DIY CUSTOM STRATEGY

Stenozar · Tue, 19 Aug 2025 19:37:41 +0000

Ciao, chiedo la traduzione del seguente codice, grazie. //@ZPayab //@version=5 indicator(title=’DIY Custom Strategy Builder [ZP] – v1′, shorttitle=”DIY Custom Strategy Builder [ZP] – v1″, overlay=true, max_bars_back=500) ma(_source, _length, _type) => switch _type “SMA” => ta.sma (_source, _length) “EMA” => ta.ema (_source, _length) “RMA” => ta.rma (_source, _length) “WMA” => ta.wma (_source, _length) “VWMA” => ta.vwma(_source, _length) alarm(_osc, _message) => alert(syminfo.ticker + ‘ ‘ + _osc + ‘ : ‘ + _message + ‘, price (‘ + str.tostring(close, format.mintick) + ‘)’) //Conditional Sampling EMA Function Cond_EMA(x, cond, n) => var val = array.new_float(0) var ema_val = array.new_float(1) if cond array.push(val, x) if array.size(val) > 1 array.remove(val, 0) if na(array.get(ema_val, 0)) array.fill(ema_val, array.get(val, 0)) array.set(ema_val, 0, (array.get(val, 0) – array.get(ema_val, 0)) * (2 / (n + 1)) + array.get(ema_val, 0)) EMA = array.get(ema_val, 0) EMA //Conditional Sampling SMA Function Cond_SMA(x, cond, n) => var vals = array.new_float(0) if cond array.push(vals, x) if array.size(vals) > n array.remove(vals, 0) SMA = array.avg(vals) SMA //Standard Deviation Function Stdev(x, n) => math.sqrt(Cond_SMA(math.pow(x, 2), 1, n) – math.pow(Cond_SMA(x, 1, n), 2)) //Range Size Function rng_size(x, scale, qty, n) => ATR = Cond_EMA(ta.tr(true), 1, n) AC = Cond_EMA(math.abs(x – x[1]), 1, n) SD = Stdev(x, n) rng_size = scale == ‘Pips’ ? qty * 0.0001 : scale == ‘Points’ ? qty * syminfo.pointvalue : scale == ‘% of Price’ ? close * qty / 100 : scale == ‘ATR’ ? qty * ATR : scale == ‘Average Change’ ? qty * AC : scale == ‘Standard Deviation’ ? qty * SD : scale == ‘Ticks’ ? qty * syminfo.mintick : qty rng_size //Two Type Range Filter Function rng_filt(h, l, rng_, n, type, smooth, sn, av_rf, av_n) => rng_smooth = Cond_EMA(rng_, 1, sn) r = smooth ? rng_smooth : rng_ var rfilt = array.new_float(2, (h + l) / 2) array.set(rfilt, 1, array.get(rfilt, 0)) if type == ‘Type 1’ if h – r > array.get(rfilt, 1) array.set(rfilt, 0, h – r) if l + r < array.get(rfilt, 1) array.set(rfilt, 0, l + r) if type == ‘Type 2’ if h >= array.get(rfilt, 1) + r array.set(rfilt, 0, array.get(rfilt, 1) + math.floor(math.abs(h – array.get(rfilt, 1)) / r) * r) if l <= array.get(rfilt, 1) – r array.set(rfilt, 0, array.get(rfilt, 1) – math.floor(math.abs(l – array.get(rfilt, 1)) / r) * r) rng_filt1 = array.get(rfilt, 0) hi_band1 = rng_filt1 + r lo_band1 = rng_filt1 – r rng_filt2 = Cond_EMA(rng_filt1, rng_filt1 != rng_filt1[1], av_n) hi_band2 = Cond_EMA(hi_band1, rng_filt1 != rng_filt1[1], av_n) lo_band2 = Cond_EMA(lo_band1, rng_filt1 != rng_filt1[1], av_n) rng_filt = av_rf ? rng_filt2 : rng_filt1 hi_band = av_rf ? hi_band2 : hi_band1 lo_band = av_rf ? lo_band2 : lo_band1 [hi_band, lo_band, rng_filt] ma_function(source, length, type) => if type == ‘RMA’ ta.rma(source, length) else if type == ‘SMA’ ta.sma(source, length) else if type == ‘EMA’ ta.ema(source, length) else if type == ‘WMA’ ta.wma(source, length) else if type == ‘HMA’ if(length<2) ta.hma(source,2) else ta.hma(source, length) else ta.vwma(source, length) // Get Table Size table_size(s) => switch s “Auto” => size.auto “Huge” => size.huge “Large” => size.large “Normal” => size.normal “Small” => size.small => size.tiny setup_group= “████████ Indicator Setup ████████” signalexpiry = input.int(defval=3, title=’Signal Expiry Candle Count’,group=setup_group, inline=’expiry’,tooltip=”Number of candles to wait for all indicators to confirm a signal. Default is 3 which means if leading indicator print the signal, it will wait for max 3 more candles for rest of the indicators to print signal, if not then this setup is invalided and will have to wait for another signal form the leading indicator.”) alternatesignal = input.bool (true, “Alternate Signal”, group=setup_group, inline=’alternate’) showsignal = input.bool (true, “Show Long/Short Signal”, group=setup_group,inline=’showsignal’,tooltip=”Option to turn on/off the Long/Short signal shown on the chart. by default it will print Long/ Short signal on the chart.”) showdashboard = input.bool (true, “Show Dashboard”, group=setup_group,inline=’dashboard’) string i_tab1Ypos = input.string(‘bottom’, ‘Dashboard Position’,group=setup_group, inline=’dashboard2′, options=[‘top’, ‘middle’, ‘bottom’]) string i_tab1Xpos = input.string(‘right’, ”, inline=’dashboard2′, group=setup_group,options=[‘left’, ‘center’, ‘right’]) in_dashboardtab_size = input.string(title=”Dashboard Size ”, defval=”Normal”, options=[“Auto”, “Huge”, “Large”, “Normal”, “Small”, “Tiny”], group= setup_group , inline= “dashboard3″) /////////////////////////////////////////////// ///// Signal filters ///////////////////////////////////////////// leadingindicator = input.string(title=”Leading Indicator”, defval=”Range Filter”, options=[“Range Filter”, “Rational Quadratic Kernel (RQK)”,”Supertrend”,”Half Trend”,”Ichimoku Cloud”,”SuperIchi”,”True Strength Indicator (TSI)”,”Trend Direction Force Index (TDFI)”,”Trendline Breakout”,”Range Detector”,”Heiken-Ashi Candlestick Oscillator”,”Donchian Trend Ribbon”,”Stochastic”,”RSI”,”Rate of Change (ROC)”,”VWAP”,”CCI”,”2 EMA Cross”,”3 EMA Cross”,”B-Xtrender”,”Bull Bear Power Trend”,”Detrended Price Oscillator (DPO)”,”BB Oscillator”,”Chandelier Exit”,”DMI (Adx)”,”Parabolic SAR (PSAR)”,”MACD”,”SSL Channel”,”Waddah Attar Explosion”,”Chaikin Money Flow”,”Vortex Index”,”Schaff Trend Cycle (STC)”,”Awesome Oscillator”,”Volatility Oscillator”,”Wolfpack Id”,”QQE Mod”,”Hull Suite”], group=’████████ Main Indicator (signal) ████████’, inline=’li’) confirmation_group = “████████ Confirmation Indicators (filter) ████████ ” ema_tooltip = “EMA filter for confirmation.\n\n Validates Long signal if price is above the EMA FILTER level, and validates Short signal if price is below the EMA FILTER level. \n\nDefault is 200, you can change that to meet your requiremnt.” respectema = input.bool (false, “EMA Filter”, group=confirmation_group, inline=’respectema’) respectemaperiod = input.int(defval=200, minval=1, title=”, group=confirmation_group, inline=’respectema’, tooltip=ema_tooltip) ema2_tooltip = “Generates Long signal if Fast EMA cross above Slow EMA.\n\n Generates Short signal when Fast EMA cross below the Slow EMA.\n\n Default values are 50 and 200. you can change that to meet your requirement.” respect2ma = input.bool (false, “2 EMA Cross : “, group=confirmation_group, inline=’2ma’) respect2maperiod_1 = input.int(defval=50, title=”,group=confirmation_group, inline=’2ma’) respect2maperiod_2 = input.int(defval=200, title=”,group=confirmation_group, inline=’2ma’,tooltip=ema2_tooltip) signal_type = input.string(“Default”, “Signal Type”,group=confirmation_group, options=[“Default”, “Lookback”], inline=’2ma’) lookback_period = input.int(defval=3, title=”Lookback Period”,group=confirmation_group, minval=1, tooltip=”Number of candles to look back for confirming the cross”, inline=’2ma’) ema3_tooltip = “Generates Long signal if first EMA (Fastest) cross above 2nd and 3rd EMA and 2nd EMA cross above 3rd EMA.\n\n Generates Short signal if first EMA (Fastest) cross below 2nd and 3rd EMA and 2nd EMA cross below 3rd EMA .\n\n Default values are 9,21 and 55. you can change that to meet your requirement.” respect3ma = input.bool (false, “3 EMA Cross : “, group=confirmation_group, inline=’3ma’,tooltip=ema3_tooltip) respect3maperiod_1 = input.int(defval=9, title=”,group=confirmation_group, inline=’3ma’,tooltip=ema3_tooltip) respect3maperiod_2 = input.int(defval=21, title=”,group=confirmation_group, inline=’3ma’,tooltip=ema3_tooltip) respect3maperiod_3 = input.int(defval=55, title=”,group=confirmation_group, inline=’3ma’,tooltip=ema3_tooltip) respectrf = input.bool (false, “Range Filter”, group=confirmation_group, inline=’rf’) rftype = input.string(title=””, defval=”Default”, options=[“Default”,”DW”], group=confirmation_group, inline=’rf’) respectrqk = input.bool (true, “Rational Quadratic Kernel (RQK)”, group=confirmation_group, inline=’rqk’,tooltip=”Nadaraya Watson: Rational Quadratic Kernel (RQK)”) respectst = input.bool (false, “SuperTrend”, group=confirmation_group, inline=’st’) respectht = input.bool (false, “Half Trend”, group=confirmation_group, inline=’ht’) respectdonchian = input.bool (false, “Donchian Trend Ribbon”, group=confirmation_group, inline=’donchian’) respectroc = input.bool (false, “Rate of Change (ROC)”, group=confirmation_group, inline=’roc’) respecttsi = input.bool (false, “True Strength Indicator (TSI)”, group=confirmation_group, inline=’tsi’) tsitooltip = “Signal Crossover:\n\n TSI crossover or greater than signal line for long, and TSI crossunder signal line for short.\n\n Zero Line Cross:\n\n TSI cross above zero line and signal line for long signal. Tsi Cross below zero and signal line for short signal.” tsitype = input.string(title=””, defval=”Signal Cross”, options=[“Signal Cross”, “Zero line cross”],tooltip=tsitooltip, group=confirmation_group, inline=’tsi’) respecttdfi = input.bool (false, “Trend Direction Force Index (TDFI)”, group=confirmation_group, inline=’tdfi’) respectmd = input.bool (false, “McGinley Dynamic”, group=confirmation_group, inline=’md’) respectdpo = input.bool (false, “Detrended Price Oscillator (DPO)”, group=confirmation_group, inline=’dpo’) respectichi = input.bool (false, “Ichimoku Cloud”, group=confirmation_group, inline=’ichi’) respectsuperichi = input.bool (false, “SuperIchi”, group=confirmation_group, inline=’ichi’,tooltip=”Ichimoku Cloud Conditions: \n \n 1. Candle above cloud \n \n 2. Converstion Line above base line \n \n 3. Leading 26 bar cloud is green \n \n 4. lagging span is above the cloud”) respecttrendline_breakout = input.bool (false, “Trendline Breakout”, group=confirmation_group, inline=’tb’) respectrd = input.bool (false, “Range Detector”, group=confirmation_group, inline=’rd’,tooltip=”Range Detector:\n\n if used as leading indicator, it will be based on range breakout. \n\n If used as confirmation indicator, it will be used to filter entries within the active range area.”) respecthacolt = input.bool (false, “Heiken-Ashi Candlestick Oscillator”, group=confirmation_group, inline=’hacolt’,tooltip=”Vervoort LongTerm Heiken-Ashi Candlestick Oscillator:\n\n If oscilliation is above 0 line, then long signal is issued and if below zero line, short signal is issued.”) respectbx = input.bool (false, “B-Xtrender”, group=confirmation_group, inline=’bx’) bxtype = input.string(title=””, defval=”Short and Long term trend”, options=[“Short and Long term trend”,”Short Term trend”], group=confirmation_group, inline=’bx’, tooltip = “Short term trend:\n\n===================== \n\n For buy signal the short term trend line must turn green, and for the sell signal, the short term trend line must turn red. \n\n Short and Long term trend: \n\n===================== \n\n For buy signal, the short term trend must change from red to green and long term trend cross above zero line, for Sell signal the short term trend must turn red and long term trend line cross down the zero line..”) respectbbpt = input.bool (false, “Bull bear Power Trend”, group=confirmation_group, inline=’bbpt’) bbpttype = input.string(title=””, defval=”Follow Trend”, options=[“Follow Trend”,”Without Trend”], group=confirmation_group, inline=’bbpt’, tooltip = “Follow Trend:\n\n===================== \n\n Buy signal will be validated if the BBPT trend line is above 2, and Sell signal will be validated if BBPT trend line is below -2. \n\n Without Trend: \n\n===================== \n\n Ignore the BBPT trend line.”) respectvwap = input.bool (false, “VWAP”, group=confirmation_group, inline=’vwap’) respectbbosc = input.bool (false, “BB Oscillator”, group=confirmation_group, inline=’bbosc’) bbtype = input.string(title=””, defval=”Entering Lower/Upper Band”, options=[“Entering Lower/Upper Band”,”Exiting Lower/Upper Band”], group=confirmation_group, inline=’bbosc’) // respecttm = input.bool (false, “Trend Meter”, group=confirmation_group, inline=’tm’) // tmtype = input.string(title=””, defval=”3 TM and 2 TB change to same color”, options=[“3 TM change to same color”, “3 TM and 2 TB change to same color”, “3 TM, 2 TB and Wavetrend change to same color”], group=confirmation_group, inline=’tm’) respectce = input.bool (false, “Chandelier Exit”, group=confirmation_group, inline=’ce’) respectcci = input.bool (false, “CCI”, group=confirmation_group, inline=’cci’) respectao = input.bool (false, “Awesome Oscillator”, group=confirmation_group, inline=’ao’) aotype = input.string(title=””, defval=”Zero Line Cross”, options=[“Zero Line Cross”,”AC Zero Line Cross”,”AC Momentum Bar”], group=confirmation_group, inline=’ao’, tooltip = “Zero Line Cross:\n\n If AO value cross the zero line up, Buy signal will be generated, and if AO value cross down the zero line, sell signal will be generated.”) respectadx = input.bool (false, “DMI (ADx)”, group=confirmation_group, inline=’adx’) adxtype = input.string(title=””, defval=”Adx & +Di -Di”, options=[“Adx Only”,”Adx & +Di -Di”, “Advance”], group=confirmation_group, inline=’adx’, tooltip = “Adx Only:\n\n If Adx value is above the defined level. \n\n Adx & +Di -DI :\n\n When Adx value is above the defined level and croseeover between +di and -di. Di will determine the direction of the movement. \n\n Advance: “) respectsar = input.bool (false, “Parabolic SAR (PSAR)”, group=confirmation_group, inline=’sar’) respectwae = input.bool (false, “Waddah Attar Explosion”, group=confirmation_group, inline=’wae’) vo_tooltip = “Volatility Oscillator: \n\n ======================= \n\n If the spike line is above the upper line, buy signal is generated (or validated). \n\n If the spike line is below the lower line, sell signal is generated (or validated).” respectvo = input.bool (false, “Volatility Oscillator”, group=confirmation_group, inline=’vo’, tooltip = vo_tooltip) ci_tooltip = “Choppiness index: \n\n ======================= \n\n If the index is below the defined threshold (default 61.8) then asset is considered trending and signal will be validated, if index is above 61.8 then asset is considered having sideway movement.” respectci = input.bool (false, “Choppiness Index “, group=confirmation_group, inline=’ci’) ci_limit = input.float(61.8,title=” “, inline=’ci’,group=confirmation_group, tooltip = ci_tooltip) respectdv = input.bool (false, “Damiani Volatility (DV)”, group=confirmation_group, inline=’dv’) dvtype = input.string(title=””, defval=”Simple”, options=[“Simple”, “Threshold”,”10p Difference”], group=confirmation_group, inline=’dv’, tooltip = “Simple\n Volatility is green. \nThreshold\n Volatility green and >1.1″) stochtooltip=”CrossOver:\n——————\n\n CrossOver of K and D line at any level. \n\n CrossOver in OB & OS levels:\n\n Generate buy signal if crossover happens in oversold area and crossing up oversold level.\n\n Generate sell signal on crossover in overbought area and cross down upper level. \n——————\n\n %K above/below %D\n——————\n: Generate Buy signal or validate other signal if %K is above %D and opposite for Sell Signal.” respectstochastic = input.bool (false, “Stochastic”, group=confirmation_group, inline=’stoch’) stochtype = input.string(title=””, defval=”CrossOver”, options=[“CrossOver”, “CrossOver in OB & OS levels”,”%K above/below %D”],tooltip=stochtooltip, group=confirmation_group, inline=’stoch’) rsi_tooltip = “RSI MA Cross:\n=============\n Generate buy signal when RSI cross up RSI MA line and sell signal when RSI cross down RSI MA line.\n\nRSI Exits OB/OS zones:\n==================\n Generate Buy signal when RSI crosses down the overbough zone and sell signal when RSI crosses up the oversold zone.\n\nRSI Level:\n==========\nGenerate buy signal if RSI cross above the specific level and sell signal when RSI crossdown the level.\n\n\n +++++\nYou can change the setting to define the OB/OS and MidLine Levels” respectrsi = input.bool (false, “RSI”, group=confirmation_group, inline=’rsi’) rsitype = input.string(title=””, defval=”RSI MA Cross”, options=[“RSI MA Cross”, “RSI Exits OB/OS zones”,”RSI Level”], tooltip=rsi_tooltip, group=confirmation_group, inline=’rsi’) rsima_tooltip = “RSI MA Direction:\n=============\n The buy and sell signal will respect the RSI MA direction. For buy signal, the RSI MA should be increasing or same compared to previous RSI MA. \n\n for SHORT, the RSI MA should be same or decreasing compared to last RSI MA” respectrsima = input.bool (false, “RSI MA Direction”, group=confirmation_group, inline=’rsi2′,tooltip=rsima_tooltip) rsilimit_tooltip = “RSI Limit:\n=============\n This is to allow you to set limit for the RSI value for long and short. default value for long is 40, which means if the RSI is 40 or above, only then BUY signal will be validated. \n\nfor short if RSI is 60 or less, only then sell signal willbe validated.” respectrsilimit = input.bool (false, “RSI Limit : “, group=confirmation_group, inline=’rsi3′,tooltip=rsilimit_tooltip) rsilimitup = input.int(40, title=”Long”,inline=’rsi3′, group=confirmation_group) rsilimitdown = input.int(60, title=”short”,inline=’rsi3′, group=confirmation_group) rsimalimit_tooltip = “RSI MA Limit:\n=============\n This is to allow you to set limit for the RSI MA value for long and short. default value for long is 40, which means if the RSI MA is 40 or above, only then BUY signal will be validated. \n\nfor short if RSI MA is 60 or less, only then sell signal willbe validated.” respectrsimalimit = input.bool (false, “RSI MA Limit : “, group=confirmation_group, inline=’rsi4′,tooltip=rsimalimit_tooltip) rsimalimitup = input.int(40, title=”Long”,inline=’rsi4′, group=confirmation_group) rsimalimitdown = input.int(60, title=”short”,inline=’rsi4′, group=confirmation_group) macdtooltip=”MACD Crossover:\n——————\n\n CrossOver of MACD and the Signal line. Generates Long signal when MACD cross up Signal line and Short signal when MACD cross down Signal Line. . \n\n Zero line crossover:\n——————\n\n Generate buy signal when MACD cross up the zero line and Sell signal when MACD cross down the zero line.” respectmacd = input.bool (false, “MACD”, group=confirmation_group, inline=’macd’) macdtype = input.string(title=””, defval=”MACD Crossover”, options=[“MACD Crossover”, “Zero line crossover”],tooltip=macdtooltip, group=confirmation_group, inline=’macd’) respectssl = input.bool (false, “SSL Channel”, group=confirmation_group, inline=’ssl’) respectstc = input.bool (false, “Schaff Trend Cycle (STC)”, group=confirmation_group, inline=’stc’) respectchaikin = input.bool (false, “Chaikin Money Flow”, group=confirmation_group, inline=’chaikin’) respectvol = input.bool (false, “Volume”, group=confirmation_group, inline=’volume’) volumetype = input.string(title=””, defval=”volume above MA”, options=[“volume above MA”,”Simple”, “Delta”], group=confirmation_group, inline=’volume’, tooltip = “Simple volume is comparing the up/down volme with previous candle. \nVolume delta will compare the delta or difference between up and down volume with previous candle.\nExample:\n up volume = 100 \n Down volume=-1100\n Delta = -1000\n Satisfy the bear flag condition if previous -ve delta is lower”) respectwolf = input.bool (false, “Wolfpack Id”, group=confirmation_group, inline=’wolf’) respectqqe = input.bool (false, “QQE Mod”, group=confirmation_group, inline=’qqe’) qqetype = input.string(title=””, defval=”Line”, options=[“Line”, “Bar”,”Line & Bar”], group=confirmation_group, inline=’qqe’, tooltip = “Line: signal generated when QQE line is above or below 0. \nBar: when Blue bar is above 0 or Red bar below 0 \nLine & Bar: Both Bar and Line to be above(bullist) or below (bearish) 0” ) respecthull = input.bool (false, “Hull Suite”,group=confirmation_group, inline=’hull’) respectvi = input.bool (false, “Vortex Indicator”,group=confirmation_group, inline=’vi’) vitype = input.string(title=””, defval=”Simple”, options=[“Simple”, “Advance”],group=confirmation_group, inline=’vi’, tooltip = “Simple\n Green Cross Red. \Advance\n vipcondition := vip > vim and vip > viupper and vip > vip[1] and vim < vim[1] and vim[1] <= vilower and vip[1] >= viupper vimcondition := vip < vim and vim > viupper and vim > vim[1] and vip < vip [1] and vip[1] <= vilower and vim [1] >= viupper “) ///////////////////////////////////////////////////////////////////////// // Switch Board //////////////////////////////////////////////////////////////////////// switchboard_group = “████ Switch Board (Turn On/Off Overlay Indicators) ████” switch_ema = input.bool (false, “EMA”, group=switchboard_group, inline=’Switch1′) switch_poi = input.bool (true, “Supply/Demand Zone”, group=switchboard_group, inline=’Switch1′) switch_sar = input.bool (false, “PSAR”, group=switchboard_group, inline=’Switch1′) switch_ichi = input.bool (false, “Ichimoku Cloud”, group=switchboard_group, inline=’Switch2′) switch_ha = input.bool (false, “Heiken-Ashi Candles”, group=switchboard_group, inline=’Switch2′) switch_fibonacci = input.bool(false, “Fibonacci”, group=switchboard_group, inline=’Switch2′) switch_rd = input.bool (false, “Range Detector”, group=switchboard_group, inline=’Switch2′) switch_vwap = input.bool (false, “VWAP”, group=switchboard_group, inline=’Switch3′) switch_bb = input.bool (false, “Bollinger Band”, group=switchboard_group, inline=’Switch3′) switch_supertrend = input.bool (false, “Supertrend”, group=switchboard_group, inline=’Switch2′) switch_halftrend= input.bool (false, “Half Trend”, group=switchboard_group, inline=’Switch2′) switch_rangefilter = input.bool (false, “Range Filter”, group=switchboard_group, inline=’Switch2′) switch_stc = input.bool (false, “STC”, group=switchboard_group, inline=’Switch3′) switch_pvsra = input.bool (true, “PVSRA”, group=switchboard_group, inline=’Switch3′) switch_vectorzone = input.bool (false, “Liquidity Zone”, group=switchboard_group, inline=’Switch3′) switch_fvg = input.bool (false, “Fair Value Gap (FVG)”, group=switchboard_group, inline=’Switch4′) switch_pivot = input.bool (false, “Pivot Levels”, group=switchboard_group, inline=’Switch4′) switch_fractal = input.bool (false, “Fractal”, group=switchboard_group, inline=’Switch4′) bool show_markets = input.bool(true, group=switchboard_group, title=’Market Sessions’, tooltip=’Turn on or off all market sessions’) /////////////////////////////////////////////////////////////////////// // Fibonacci settings fibgroup = “█████████ Fibonacci Display Settting █████████” devTooltip = “Deviation is a multiplier that affects how much the price should deviate from the previous pivot in order for the bar to become a new pivot.” depthTooltip = “The minimum number of bars that will be taken into account when calculating the indicator.” threshold_multiplier2 = input.float(title=”Deviation”, defval=3, minval=0, tooltip=devTooltip,group=fibgroup) depth2 = input.int(title=”Depth”, defval=10, minval=2, tooltip=depthTooltip,group=fibgroup) reverse2 = input(false, “Reverse”, display = display.data_window,group=fibgroup) var extendLeft = input(false, “Extend Left | Extend Right”, inline = “Extend Lines”,group=fibgroup) var extendRight = input(true, “”, inline = “Extend Lines”,group=fibgroup) var extending = extend.none if extendLeft and extendRight extending := extend.both if extendLeft and not extendRight extending := extend.left if not extendLeft and extendRight extending := extend.right prices = input(false, “Show Prices”, display = display.data_window,group=fibgroup) levels = input(true, “Show Levels”, inline = “Levels”, display = display.data_window,group=fibgroup) levelsFormat = input.string(“Values”, “”, options = [“Values”, “Percent”], inline = “Levels”, display = display.data_window,group=fibgroup) labelsPosition = input.string(“Left”, “Labels Position”, options = [“Left”, “Right”], display = display.data_window,group=fibgroup) var int backgroundTransparency = input.int(85, “Background Transparency”, minval = 0, maxval = 100, display = display.data_window,group=fibgroup) import TradingView/ZigZag/7 as zigzag update() => var settings = zigzag.Settings.new(threshold_multiplier2, depth2, color(na), false, false, false, false, “Absolute”, true) var zigzag.ZigZag zigZag = zigzag.newInstance(settings) var zigzag.Pivot lastP = na var float startPrice2 = na var float height = na settings.devThreshold := ta.atr(10) / close * 100 * threshold_multiplier2 if zigZag.update() lastP := zigZag.lastPivot() if not na(lastP) var line lineLast = na if switch_fibonacci if na(lineLast) lineLast := line.new(lastP.start, lastP.end, xloc=xloc.bar_time, color=color.gray, width=1, style=line.style_dashed) else line.set_first_point(lineLast, lastP.start) line.set_second_point(lineLast, lastP.end) startPrice2 := reverse2 ? lastP.start.price : lastP.end.price endPrice = reverse2 ? lastP.end.price : lastP.start.price height := (startPrice2 > endPrice ? -1 : 1) * math.abs(startPrice2 – endPrice) [lastP, startPrice2, height] [lastP, startPrice2, height] = update() _draw_line(price, col) => var id = line.new(lastP.start.time, lastP.start.price, time, price, xloc=xloc.bar_time, color=col, width=1, extend=extending) line.set_xy1(id, lastP.start.time, price) line.set_xy2(id, lastP.end.time, price) id _draw_label(price, txt, txtColor) => x = labelsPosition == “Left” ? lastP.start.time : not extendRight ? lastP.end.time : time labelStyle = labelsPosition == “Left” ? label.style_label_right : label.style_label_left align = labelsPosition == “Left” ? text.align_right : text.align_left labelsAlignStrLeft = txt + ‘\n ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ \n’ labelsAlignStrRight = ‘ ‘ + txt + ‘\n ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ \n’ labelsAlignStr = labelsPosition == “Left” ? labelsAlignStrLeft : labelsAlignStrRight var id = label.new(x=x, y=price, xloc=xloc.bar_time, text=labelsAlignStr, textcolor=txtColor, style=labelStyle, textalign=align, color=#00000000) label.set_xy(id, x, price) label.set_text(id, labelsAlignStr) label.set_textcolor(id, txtColor) _wrap(txt) => “(” + str.tostring(txt, format.mintick) + “)” _label_txt(level, price) => l = levelsFormat == “Values” ? str.tostring(level) : str.tostring(level * 100) + “%” (levels ? l : “”) + (prices ? _wrap(price) : “”) _crossing_level(series float sr, series float r) => (r > sr and r < sr[1]) or (r < sr and r > sr[1]) processLevel(bool show, float value, color colorL, line lineIdOther) => float m = value r = startPrice2 + height * m crossed = _crossing_level(close, r) if show and not na(lastP) lineId = _draw_line(r, colorL) _draw_label(r, _label_txt(m, r), colorL) if crossed alert(“Autofib: ” + syminfo.ticker + ” crossing level ” + str.tostring(value)) if not na(lineIdOther) linefill.new(lineId, lineIdOther, color = color.new(colorL, backgroundTransparency)) lineId else lineIdOther show_0 = input(true, “”, inline = “Level0”, display = display.data_window) value_0 = input(0, “”, inline = “Level0”, display = display.data_window) color_0 = input(#787b86, “”, inline = “Level0”, display = display.data_window) show_0_236 = input(false, “”, inline = “Level0”, display = display.data_window) value_0_236 = input(0.236, “”, inline = “Level0”, display = display.data_window) color_0_236 = input(#f44336, “”, inline = “Level0”, display = display.data_window) show_0_382 = input(false, “”, inline = “Level1”, display = display.data_window) value_0_382 = input(0.382, “”, inline = “Level1”, display = display.data_window) color_0_382 = input(#81c784, “”, inline = “Level1”, display = display.data_window) show_0_5 = input(true, “”, inline = “Level1”, display = display.data_window) value_0_5 = input(0.5, “”, inline = “Level1”, display = display.data_window) color_0_5 = input(#4caf50, “”, inline = “Level1”, display = display.data_window) show_0_618 = input(false, “”, inline = “Level2”, display = display.data_window) value_0_618 = input(0.618, “”, inline = “Level2”, display = display.data_window) color_0_618 = input(#009688, “”, inline = “Level2”, display = display.data_window) show_0_65 = input(false, “”, inline = “Level2”, display = display.data_window) value_0_65 = input(0.65, “”, inline = “Level2”, display = display.data_window) color_0_65 = input(#009688, “”, inline = “Level2”, display = display.data_window) show_0_786 = input(false, “”, inline = “Level3”, display = display.data_window) value_0_786 = input(0.786, “”, inline = “Level3”, display = display.data_window) color_0_786 = input(#64b5f6, “”, inline = “Level3”, display = display.data_window) show_1 = input(true, “”, inline = “Level3”, display = display.data_window) value_1 = input(1, “”, inline = “Level3”, display = display.data_window) color_1 = input(#787b86, “”, inline = “Level3”, display = display.data_window) show_1_272 = input(false, “”, inline = “Level4”, display = display.data_window) value_1_272 = input(1.272, “”, inline = “Level4”, display = display.data_window) color_1_272 = input(#81c784, “”, inline = “Level4”, display = display.data_window) show_1_414 = input(false, “”, inline = “Level4”, display = display.data_window) value_1_414 = input(1.414, “”, inline = “Level4”, display = display.data_window) color_1_414 = input(#f44336, “”, inline = “Level4”, display = display.data_window) show_1_618 = input(false, “”, inline = “Level5”, display = display.data_window) value_1_618 = input(1.618, “”, inline = “Level5”, display = display.data_window) color_1_618 = input(#2962ff, “”, inline = “Level5”, display = display.data_window) show_1_65 = input(false, “”, inline = “Level5”, display = display.data_window) value_1_65 = input(1.65, “”, inline = “Level5”, display = display.data_window) color_1_65 = input(#2962ff, “”, inline = “Level5”, display = display.data_window) show_2_618 = input(false, “”, inline = “Level6”, display = display.data_window) value_2_618 = input(2.618, “”, inline = “Level6”, display = display.data_window) color_2_618 = input(#f44336, “”, inline = “Level6”, display = display.data_window) show_2_65 = input(false, “”, inline = “Level6”, display = display.data_window) value_2_65 = input(2.65, “”, inline = “Level6”, display = display.data_window) color_2_65 = input(#f44336, “”, inline = “Level6”, display = display.data_window) show_3_618 = input(false, “”, inline = “Level7”, display = display.data_window) value_3_618 = input(3.618, “”, inline = “Level7”, display = display.data_window) color_3_618 = input(#9c27b0, “”, inline = “Level7”, display = display.data_window) show_3_65 = input(false, “”, inline = “Level7”, display = display.data_window) value_3_65 = input(3.65, “”, inline = “Level7”, display = display.data_window) color_3_65 = input(#9c27b0, “”, inline = “Level7”, display = display.data_window) show_4_236 = input(false, “”, inline = “Level8”, display = display.data_window) value_4_236 = input(4.236, “”, inline = “Level8”, display = display.data_window) color_4_236 = input(#e91e63, “”, inline = “Level8”, display = display.data_window) show_4_618 = input(false, “”, inline = “Level8”, display = display.data_window) value_4_618 = input(4.618, “”, inline = “Level8”, display = display.data_window) color_4_618 = input(#81c784, “”, inline = “Level8”, display = display.data_window) show_neg_0_236 = input(false, “”, inline = “Level9”, display = display.data_window) value_neg_0_236 = input(-0.236, “”, inline = “Level9”, display = display.data_window) color_neg_0_236 = input(#f44336, “”, inline = “Level9”, display = display.data_window) show_neg_0_382 = input(false, “”, inline = “Level9”, display = display.data_window) value_neg_0_382 = input(-0.382, “”, inline = “Level9”, display = display.data_window) color_neg_0_382 = input(#81c784, “”, inline = “Level9”, display = display.data_window) show_neg_0_618 = input(false, “”, inline = “Level10”, display = display.data_window) value_neg_0_618 = input(-0.618, “”, inline = “Level10”, display = display.data_window) color_neg_0_618 = input(#009688, “”, inline = “Level10”, display = display.data_window) show_neg_0_65 = input(false, “”, inline = “Level10”, display = display.data_window) value_neg_0_65 = input(-0.65, “”, inline = “Level10”, display = display.data_window) color_neg_0_65 = input(#009688, “”, inline = “Level10”, display = display.data_window) var line lineId0 = na var line lineId1 = na var line lineId2 = na var line lineId3 = na var line lineId4 = na var line lineId5 = na var line lineId6 = na var line lineId7 = na var line lineId8 = na var line lineId9 = na var line lineId10 = na var line lineId11 = na var line lineId12 = na var line lineId13 = na var line lineId14 = na var line lineId15 = na var line lineId16 = na var line lineId17 = na var line lineId18 = na var line lineId19 = na var line lineId20 = na var line lineId21 = na if (switch_fibonacci) // Check the boolean here lineId0 := processLevel(show_neg_0_65, value_neg_0_65, color_neg_0_65, line(na)) lineId1 := processLevel(show_neg_0_618, value_neg_0_618, color_neg_0_618, lineId0) lineId2 := processLevel(show_neg_0_382, value_neg_0_382, color_neg_0_382, lineId1) lineId3 := processLevel(show_neg_0_236, value_neg_0_236, color_neg_0_236, lineId2) lineId4 := processLevel(show_0, value_0, color_0, lineId3) lineId5 := processLevel(show_0_236, value_0_236, color_0_236, lineId4) lineId6 := processLevel(show_0_382, value_0_382, color_0_382, lineId5) lineId7 := processLevel(show_0_5, value_0_5, color_0_5, lineId6) lineId8 := processLevel(show_0_618, value_0_618, color_0_618, lineId7) lineId9 := processLevel(show_0_65, value_0_65, color_0_65, lineId8) lineId10 := processLevel(show_0_786, value_0_786, color_0_786, lineId9) lineId11 := processLevel(show_1, value_1, color_1, lineId10) lineId12 := processLevel(show_1_272, value_1_272, color_1_272, lineId11) lineId13 := processLevel(show_1_414, value_1_414, color_1_414, lineId12) lineId14 := processLevel(show_1_618, value_1_618, color_1_618, lineId13) lineId15 := processLevel(show_1_65, value_1_65, color_1_65, lineId14) lineId16 := processLevel(show_2_618, value_2_618, color_2_618, lineId15) lineId17 := processLevel(show_2_65, value_2_65, color_2_65, lineId16) lineId18 := processLevel(show_3_618, value_3_618, color_3_618, lineId17) lineId19 := processLevel(show_3_65, value_3_65, color_3_65, lineId18) lineId20 := processLevel(show_4_236, value_4_236, color_4_236, lineId19) lineId21 := processLevel(show_4_618, value_4_618, color_4_618, lineId20) ///////////////////////////////////////////////////////////////////////// // EMA Selection //////////////////////////////////////////////////////////////////////// ma_group= “██████████ MAs Line ██████████” len1bool = input.bool(true,”,group=ma_group,inline=’len1′) len1 = input.int(5, title=’MA 1′,group=ma_group,inline=’len1′) string ma_1_type = input.string(defval=’EMA’, title=’Type’, options=[‘RMA’, ‘SMA’, ‘EMA’, ‘WMA’,’HMA’,’VWMA’], inline=’len1′,group=ma_group) color ma_1_colour = input.color(color.rgb(254, 234, 74, 0), ”, inline=’len1′,group=ma_group) len2bool = input.bool(true,”,group=ma_group,inline=’len2′) len2 = input.int(13, minval=1, title=’MA 2′,group=ma_group,inline=’len2′) string ma_2_type = input.string(defval=’EMA’, title=’Type’, options=[‘RMA’, ‘SMA’, ‘EMA’, ‘WMA’,’HMA’,’VWMA’], inline=’len2′,group=ma_group) color ma_2_colour = input.color(color.rgb(253, 84, 87, 0), ”, inline=’len2′,group=ma_group) len3bool = input.bool(false,”,group=ma_group,inline=’len3′) len3 = input.int(20, minval=1, title=’MA 3′,group=ma_group,inline=’len3′) string ma_3_type = input.string(defval=’EMA’, title=’Type’, options=[‘RMA’, ‘SMA’, ‘EMA’, ‘WMA’,’HMA’,’VWMA’], inline=’len3′,group=ma_group) color ma_3_colour = input.color(color.new(color.aqua, 0), ”, inline=’len3′,group=ma_group) len4bool = input.bool(true,”,group=ma_group,inline=’len4′) len4 = input.int(50, minval=1, title=’MA 4′,group=ma_group,inline=’len4′) string ma_4_type = input.string(defval=’EMA’, title=’Type’, options=[‘RMA’, ‘SMA’, ‘EMA’, ‘WMA’,’HMA’,’VWMA’], inline=’len4′,group=ma_group) color ma_4_colour = input.color(color.new(color.blue, 0), ”, inline=’len4′,group=ma_group) len5bool = input.bool(true,”,group=ma_group,inline=’len5′) len5 = input.int(200, minval=1, title=’MA 5′,group=ma_group,inline=’len5′) string ma_5_type = input.string(defval=’EMA’, title=’Type’, options=[‘RMA’, ‘SMA’, ‘EMA’, ‘WMA’,’HMA’,’VWMA’], inline=’len5′,group=ma_group) color ma_5_colour = input.color(color.new(color.white, 0), ”, inline=’len5′,group=ma_group) ema1 = request.security(syminfo.tickerid, timeframe.period, ma_function(close, len1, ma_1_type)) ema2 = request.security(syminfo.tickerid, timeframe.period, ma_function(close, len2, ma_2_type)) ema3 = request.security(syminfo.tickerid, timeframe.period, ma_function(close, len3, ma_3_type)) ema4 = request.security(syminfo.tickerid, timeframe.period, ma_function(close, len4, ma_4_type)) ema5 = request.security(syminfo.tickerid, timeframe.period, ma_function(close, len5, ma_5_type)) plot(len1bool and switch_ema ? ema1:na, color=ma_1_colour, linewidth=2, title=’MA 1′) plot(len2bool and switch_ema? ema2:na, color=ma_2_colour, linewidth=2, title=’MA 2′) plot(len3bool and switch_ema? ema3:na, color=ma_3_colour, linewidth=2, title=’MA 3′) plot(len4bool and switch_ema? ema4:na, color=ma_4_colour, linewidth=2, title=’MA 4′) plot(len5bool and switch_ema? ema5:na, color=ma_5_colour, linewidth=2, title=’MA 5′) //////////////////////////////////////////////////////////////////////////// //////////// 2EMA cross //////////////////////////////////////////////////////////////////////////// var float first_2ema = 0 var float second_2ema = 0 // if respect2ma or leadingindicator==’2 EMA Cross’ // first_2ema := ta.ema(close, respect2maperiod_1) // second_2ema := ta.ema(close, respect2maperiod_2) // Calculate EMAs first_2ema := ta.ema(close, respect2maperiod_1) second_2ema := ta.ema(close, respect2maperiod_2) // Function to detect cross with lookback detectCrossWithLookback(fast_series, slow_series, lookback) => crossUp = fast_series[lookback] > slow_series[lookback] and fast_series[lookback + 1] <= slow_series[lookback + 1] crossDown = fast_series[lookback] < slow_series[lookback] and fast_series[lookback + 1] >= slow_series[lookback + 1] if crossUp or crossDown noCrosses = true for i = 0 to lookback – 1 if (fast_series[i] > slow_series[i] and fast_series[i+1] <= slow_series[i+1]) or (fast_series[i] < slow_series[i] and fast_series[i+1] >= slow_series[i+1]) noCrosses := false break if noCrosses if crossUp 1 else -1 else 0 else 0 // Detect signals based on selected method var float ema2_long = 0 var float ema2_short = 0 if signal_type == “Default” ema2_long := ta.crossover(first_2ema, second_2ema) ? 1 : 0 ema2_short := ta.crossunder(first_2ema, second_2ema) ? 1 : 0 else // Lookback method crossDetected = detectCrossWithLookback(first_2ema, second_2ema, lookback_period) ema2_long := crossDetected == 1 and first_2ema > second_2ema ? 1 : 0 ema2_short := crossDetected == -1 and first_2ema < second_2ema ? 1 : 0 //////////////////////////////////////////////////////////////////////////// //////////// 3EMA cross //////////////////////////////////////////////////////////////////////////// var float first_3ema = 0 var float second_3ema = 0 var float third_3ema = 0 if respect3ma or leadingindicator==’3 EMA Cross’ first_3ema := ta.ema(close, respect3maperiod_1) second_3ema := ta.ema(close, respect3maperiod_2) third_3ema := ta.ema(close, respect3maperiod_3) ////////////////////////////////////////////////////////////////////////// // Pivots ////////////////////////////////////////////////////////////////////////// pivot_group = ‘██████████ Pivot Levels ██████████’ pivotTypeInput = input.string(title=”Type”, defval=”Traditional”, options=[“Traditional”, “Fibonacci”, “Woodie”, “Classic”, “DM”, “Camarilla”],group=pivot_group) pivotAnchorInput = input.string(title=”Pivots Timeframe”, defval=”Auto”, options=[“Auto”, “Daily”, “Weekly”, “Monthly”, “Quarterly”, “Yearly”, “Biyearly”, “Triyearly”, “Quinquennially”, “Decennially”],group=pivot_group) maxHistoricalPivotsInput = input.int(title=”Number of Pivots Back”, defval=1, minval=1, maxval=200, display = display.data_window,group=pivot_group) isDailyBasedInput = input.bool(title=”Use Daily-based Values”, defval=true,group=pivot_group, display = display.data_window, tooltip=”When this option is unchecked, Pivot Points will use intraday data while calculating on intraday charts. If Extended Hours are displayed on the chart, they will be taken into account during the pivot level calculation. If intraday OHLC values are different from daily-based values (normal for stocks), the pivot levels will also differ.”) showLabelsInput = input.bool(title=”Show Labels”, defval=true,group=pivot_group, display = display.data_window) showPricesInput = input.bool(title=”Show Prices”, defval=true,group=pivot_group, display = display.data_window) positionLabelsInput = input.string(“Left”, “Labels Position”, options=[“Left”, “Right”],group=pivot_group, display = display.data_window) linewidthInput = input.int(title=”Line Width”, defval=1, minval=1, maxval=100,group=pivot_group, display = display.data_window) DEFAULT_COLOR = #FB8C00 pColorInput = input.color(DEFAULT_COLOR, “P‏ ‏ ‏”, inline=”P”,group=pivot_group, display = display.data_window) pShowInput = input.bool(true, “”, inline=”P”,group=pivot_group, display = display.data_window) s1ColorInput = input.color(DEFAULT_COLOR, “S1″, inline=”S1/R1” ,group=pivot_group, display = display.data_window) s1ShowInput = input.bool(true, “”, inline=”S1/R1″,group=pivot_group, display = display.data_window) r1ColorInput = input.color(DEFAULT_COLOR, “‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏R1″, inline=”S1/R1”,group=pivot_group, display = display.data_window) r1ShowInput = input.bool(true, “”, inline=”S1/R1″,group=pivot_group, display = display.data_window) s2ColorInput = input.color(DEFAULT_COLOR, “S2″, inline=”S2/R2”,group=pivot_group, display = display.data_window) s2ShowInput = input.bool(true, “”, inline=”S2/R2″,group=pivot_group, display = display.data_window) r2ColorInput = input.color(DEFAULT_COLOR, “‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏R2″, inline=”S2/R2”,group=pivot_group, display = display.data_window) r2ShowInput = input.bool(true, “”, inline=”S2/R2″,group=pivot_group, tooltip = “Not applicable to DM”, display = display.data_window) s3ColorInput = input.color(DEFAULT_COLOR, “S3″, inline=”S3/R3”,group=pivot_group, display = display.data_window) s3ShowInput = input.bool(true, “”, inline=”S3/R3″,group=pivot_group, display = display.data_window) r3ColorInput = input.color(DEFAULT_COLOR, “‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏R3″, inline=”S3/R3”,group=pivot_group, display = display.data_window) r3ShowInput = input.bool(true, “”, inline=”S3/R3″,group=pivot_group, tooltip = “Not applicable to DM”, display = display.data_window) s4ColorInput = input.color(DEFAULT_COLOR, “S4″, inline=”S4/R4”,group=pivot_group, display = display.data_window) s4ShowInput = input.bool(true, “”, inline=”S4/R4″,group=pivot_group, display = display.data_window) r4ColorInput = input.color(DEFAULT_COLOR, “‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏R4″, inline=”S4/R4”,group=pivot_group, display = display.data_window) r4ShowInput = input.bool(true, “”, inline=”S4/R4″,group=pivot_group, tooltip = “Not applicable to: Fibonacci, DM”, display = display.data_window) s5ColorInput = input.color(DEFAULT_COLOR, “S5″, inline=”S5/R5”,group=pivot_group, display = display.data_window) s5ShowInput = input.bool(true, “”, inline=”S5/R5″,group=pivot_group, display = display.data_window) r5ColorInput = input.color(DEFAULT_COLOR, “‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏R5″, inline=”S5/R5”,group=pivot_group, display = display.data_window) r5ShowInput = input.bool(true, “”, inline=”S5/R5″,group=pivot_group, tooltip = “Not applicable to: Fibonacci, Woodie, Classic, DM”, display = display.data_window) type graphicSettings string levelName color levelColor bool showLevel var graphicSettingsArray = array.from( graphicSettings.new(” P”, pColorInput, pShowInput), graphicSettings.new(“R1”, r1ColorInput, r1ShowInput), graphicSettings.new(“S1”, s1ColorInput, s1ShowInput), graphicSettings.new(“R2”, r2ColorInput, r2ShowInput), graphicSettings.new(“S2”, s2ColorInput, s2ShowInput), graphicSettings.new(“R3”, r3ColorInput, r3ShowInput), graphicSettings.new(“S3”, s3ColorInput, s3ShowInput), graphicSettings.new(“R4”, r4ColorInput, r4ShowInput), graphicSettings.new(“S4”, s4ColorInput, s4ShowInput), graphicSettings.new(“R5”, r5ColorInput, r5ShowInput), graphicSettings.new(“S5”, s5ColorInput, s5ShowInput)) autoAnchor = switch timeframe.isintraday => timeframe.multiplier <= 15 ? “1D” : “1W” timeframe.isdaily => “1M” => “12M” pivotTimeframe = switch pivotAnchorInput “Auto” => autoAnchor “Daily” => “1D” “Weekly” => “1W” “Monthly” => “1M” “Quarterly” => “3M” => “12M” //@variable The number of years in the selected Pivot period pivotYearMultiplier = switch pivotAnchorInput “Biyearly” => 2 “Triyearly” => 3 “Quinquennially” => 5 “Decennially” => 10 => 1 //@variable The number of values in the pivots of the selected type numOfPivotLevels = switch pivotTypeInput “Traditional” => 11 “Camarilla” => 11 “Woodie” => 9 “Classic” => 9 “Fibonacci” => 7 “DM” => 3 type pivotGraphic line pivotLine label pivotLabel method delete(pivotGraphic graphic) => graphic.pivotLine.delete() graphic.pivotLabel.delete() var drawnGraphics = matrix.new<pivotGraphic>() localPivotTimeframeChange = timeframe.change(pivotTimeframe) and year % pivotYearMultiplier == 0 securityPivotTimeframeChange = timeframe.change(timeframe.period) and year % pivotYearMultiplier == 0 pivotTimeframeChangeCounter(condition) => var count = 0 if condition and bar_index > 0 count += 1 count localPivots = ta.pivot_point_levels(pivotTypeInput, localPivotTimeframeChange) securityPivotPointsArray = ta.pivot_point_levels(pivotTypeInput, securityPivotTimeframeChange) securityTimeframe = timeframe.isintraday ? “1D” : timeframe.period [securityPivots, securityPivotCounter] = request.security(syminfo.tickerid, pivotTimeframe, [securityPivotPointsArray, pivotTimeframeChangeCounter(securityPivotTimeframeChange)], lookahead = barmerge.lookahead_on) pivotPointsArray = isDailyBasedInput ? securityPivots : localPivots //@function Sets the ending points of the currently active pivots to endTime. affixOldPivots(endTime) => if drawnGraphics.rows() > 0 lastGraphics = drawnGraphics.row(drawnGraphics.rows() – 1) for graphic in lastGraphics graphic.pivotLine.set_x2(endTime) if positionLabelsInput == “Right” graphic.pivotLabel.set_x(endTime) //@function Draws pivot lines and labels from startTime to the approximate end of the period. drawNewPivots(startTime) => newGraphics = array.new<pivotGraphic>() for [index, coord] in pivotPointsArray levelSettings = graphicSettingsArray.get(index) if not na(coord) and levelSettings.showLevel and switch_pivot lineEndTime = startTime + timeframe.in_seconds(pivotTimeframe) * 1000 * pivotYearMultiplier pivotLine = line.new(startTime, coord, lineEndTime, coord, xloc = xloc.bar_time, color=levelSettings.levelColor, width=linewidthInput) pivotLabel = label.new(x = positionLabelsInput == “Left” ? startTime : lineEndTime, y = coord, text = (showLabelsInput ? levelSettings.levelName + ” ” : “”) + (showPricesInput ? “(” + str.tostring(coord, format.mintick) + “)” : “”), style = positionLabelsInput == “Left” ? label.style_label_right : label.style_label_left, textcolor = levelSettings.levelColor, color = #00000000, xloc=xloc.bar_time) newGraphics.push(pivotGraphic.new(pivotLine, pivotLabel)) drawnGraphics.add_row(array_id = newGraphics) if drawnGraphics.rows() > maxHistoricalPivotsInput oldGraphics = drawnGraphics.remove_row(0) for graphic in oldGraphics graphic.delete() localPivotDrawConditionStatic = not isDailyBasedInput and localPivotTimeframeChange securityPivotDrawConditionStatic = isDailyBasedInput and securityPivotCounter != securityPivotCounter[1] var isMultiYearly = array.from(“Biyearly”, “Triyearly”, “Quinquennially”, “Decennially”).includes(pivotAnchorInput) localPivotDrawConditionDeveloping = not isDailyBasedInput and time_close == time_close(pivotTimeframe) and not isMultiYearly securityPivotDrawConditionDeveloping = false if (switch_pivot and (securityPivotDrawConditionStatic or localPivotDrawConditionStatic)) affixOldPivots(time) drawNewPivots(time) // If possible, draw pivots from the beginning of the chart if none were found var FIRST_BAR_TIME = time if (barstate.islastconfirmedhistory and drawnGraphics.columns() == 0 and switch_pivot) if not na(securityPivots) and securityPivotCounter > 0 if isDailyBasedInput drawNewPivots(FIRST_BAR_TIME) else runtime.error(“Not enough intraday data to calculate Pivot Points. Lower the Pivots Timeframe or turn on the ‘Use Daily-based Values’ option in the indicator settings.”) else runtime.error(“Not enough data to calculate Pivot Points. Lower the Pivots Timeframe in the indicator settings.”) ////////////////////////////////////////////////////////////////////////// // William Fractals ////////////////////////////////////////////////////////////////////////// // Define “n” as the number of periods and keep a minimum value of 2 for error handling. n = input.int(title=”Periods”, defval=2, minval=2,group=”██████████ Fractal ██████████”) // UpFractal bool upflagDownFrontier = true bool upflagUpFrontier0 = true bool upflagUpFrontier1 = true bool upflagUpFrontier2 = true bool upflagUpFrontier3 = true bool upflagUpFrontier4 = true if switch_fractal for i = 1 to n upflagDownFrontier := upflagDownFrontier and (high[n-i] < high[n]) upflagUpFrontier0 := upflagUpFrontier0 and (high[n+i] < high[n]) upflagUpFrontier1 := upflagUpFrontier1 and (high[n+1] <= high[n] and high[n+i + 1] < high[n]) upflagUpFrontier2 := upflagUpFrontier2 and (high[n+1] <= high[n] and high[n+2] <= high[n] and high[n+i + 2] < high[n]) upflagUpFrontier3 := upflagUpFrontier3 and (high[n+1] <= high[n] and high[n+2] <= high[n] and high[n+3] <= high[n] and high[n+i + 3] < high[n]) upflagUpFrontier4 := upflagUpFrontier4 and (high[n+1] <= high[n] and high[n+2] <= high[n] and high[n+3] <= high[n] and high[n+4] <= high[n] and high[n+i + 4] < high[n]) flagUpFrontier = upflagUpFrontier0 or upflagUpFrontier1 or upflagUpFrontier2 or upflagUpFrontier3 or upflagUpFrontier4 upFractal = (upflagDownFrontier and flagUpFrontier) // downFractal bool downflagDownFrontier = true bool downflagUpFrontier0 = true bool downflagUpFrontier1 = true bool downflagUpFrontier2 = true bool downflagUpFrontier3 = true bool downflagUpFrontier4 = true if switch_fractal for i = 1 to n downflagDownFrontier := downflagDownFrontier and (low[n-i] > low[n]) downflagUpFrontier0 := downflagUpFrontier0 and (low[n+i] > low[n]) downflagUpFrontier1 := downflagUpFrontier1 and (low[n+1] >= low[n] and low[n+i + 1] > low[n]) downflagUpFrontier2 := downflagUpFrontier2 and (low[n+1] >= low[n] and low[n+2] >= low[n] and low[n+i + 2] > low[n]) downflagUpFrontier3 := downflagUpFrontier3 and (low[n+1] >= low[n] and low[n+2] >= low[n] and low[n+3] >= low[n] and low[n+i + 3] > low[n]) downflagUpFrontier4 := downflagUpFrontier4 and (low[n+1] >= low[n] and low[n+2] >= low[n] and low[n+3] >= low[n] and low[n+4] >= low[n] and low[n+i + 4] > low[n]) flagDownFrontier = downflagUpFrontier0 or downflagUpFrontier1 or downflagUpFrontier2 or downflagUpFrontier3 or downflagUpFrontier4 downFractal = (downflagDownFrontier and flagDownFrontier) plotshape(downFractal and switch_fractal ? true : na, style=shape.triangledown, location=location.belowbar, offset=-n, color=#F44336, size = size.small) plotshape(upFractal and switch_fractal ? true : na, style=shape.triangleup, location=location.abovebar, offset=-n, color=#009688, size = size.small) ////////////////////////////////////////////////////////////////////////// // Range Filter ////////////////////////////////////////////////////////////////////////// rf_group= “██████████ Range Filter ██████████” //switch_rangefilter = input.bool (true, “Show Range Filter Signals”, group=’=============== Range Filter ================’) showrfline = input.bool (true, “Show RF line”, group=rf_group) src = input.source(defval=close, title=’Source’, group=rf_group,inline = ‘rf’) // Sampling Period // Settings for 5min chart, BTCUSDC. For Other coin, change the paremeters per = input.int(defval=100, minval=1, title=’Period’, group=rf_group,inline = ‘rf’) // Range Multiplier mult = input.float(defval=3.0, minval=0.1, title=’Multiplier’, group=rf_group,inline = ‘rf’) // Smooth Average Range smoothrng(x, t, m) => wper = t * 2 – 1 avrng = ta.ema(math.abs(x – x[1]), t) smoothrng = ta.ema(avrng, wper) * m smoothrng smrng = smoothrng(src, per, mult) // Range Filter rngfilt(x, r) => rngfilt = x rngfilt := x > nz(rngfilt[1]) ? x – r < nz(rngfilt[1]) ? nz(rngfilt[1]) : x – r : x + r > nz(rngfilt[1]) ? nz(rngfilt[1]) : x + r rngfilt filt = rngfilt(src, smrng) // Filter Direction upward = 0.0 upward := filt > filt[1] ? nz(upward[1]) + 1 : filt < filt[1] ? 0 : nz(upward[1]) downward = 0.0 downward := filt < filt[1] ? nz(downward[1]) + 1 : filt > filt[1] ? 0 : nz(downward[1]) // Target Bands hband = filt + smrng lband = filt – smrng /////////////////////////////// ////// RF2 /////////////////////////////// //Filter Type f_type = input.string(defval=’Type 1′, options=[‘Type 1’, ‘Type 2′], title=’Filter Type’) //Movement Source mov_src = input.string(defval=’Close’, options=[‘Wicks’, ‘Close’], title=’Movement Source’) //Range Size Inputs rng_qty = input.float(defval=2.618, minval=0.0000001, title=’Range Size’) rng_scale = input.string(defval=’Average Change’, options=[‘Points’, ‘Pips’, ‘Ticks’, ‘% of Price’, ‘ATR’, ‘Average Change’, ‘Standard Deviation’, ‘Absolute’], title=’Range Scale’) //Range Period rng_per = input.int(defval=14, minval=1, title=’Range Period (for ATR, Average Change, and Standard Deviation)’) //Range Smoothing Inputs smooth_range = input(defval=true, title=’Smooth Range’) smooth_per = input.int(defval=27, minval=1, title=’Smoothing Period’) //Filter Value Averaging Inputs av_vals = input(defval=false, title=’Average Filter Changes’) av_samples = input.int(defval=2, minval=1, title=’Number Of Changes To Average’) //—————————————————————————————————————————————————————– //Definitions //—————————————————————————————————————————————————————– //High And Low Values h_val = mov_src == ‘Wicks’ ? high : close l_val = mov_src == ‘Wicks’ ? low : close //Range Filter Values [h_band, l_band, filt2] = rng_filt(h_val, l_val, rng_size((h_val + l_val) / 2, rng_scale, rng_qty, rng_per), rng_per, f_type, smooth_range, smooth_per, av_vals, av_samples) //Direction Conditions var fdir2 = 0.0 fdir2 := filt2 > filt2[1] ? 1 : filt2 < filt2[1] ? -1 : fdir2 rfupward = fdir2 == 1 ? 1 : 0 rfdownward= fdir2 == -1 ? 1 : 0 //—————————————————————————————————————————————————————– //color and switchboard rf //—————————————————————————————————————————————————————– filtcolor = upward > 0 ? color.lime : downward > 0 ? color.red : color.orange // filt2_color = rfupward ? #05ff9b : rfdownward ? #ff0583 : #cccccc filttype = string(na) if rftype == “Default” filttype := “filt” else if rftype == “DW” filttype := “filt2” filtplot = plot(switch_rangefilter and showrfline?filt:na, color=filtcolor, linewidth=2, title=’Range Filter’) // filtplot2 = plot(switch_rangefilter2 ?filt2:na, color=filt2_color, linewidth=2, title=’Range Filter’) //////////////////////////////// /// RQK //////////////////////////////// rqkgroupname = ‘████████ Rational Quadratic Kernel (RQK) ████████’ rqksrc = input.source(close, ‘Source’, group=rqkgroupname) h2 = input.float(8., ‘Lookback Window’, minval=3., tooltip=’The number of bars used for the estimation. This is a sliding value that represents the most recent historical bars. Recommended range: 3-50′, group=rqkgroupname) r = input.float(8., ‘Relative Weighting’, step=0.25, group=rqkgroupname, tooltip=’Relative weighting of time frames. As this value approaches zero, the longer time frames will exert more influence on the estimation. As this value approaches infinity, the behavior of the Rational Quadratic Kernel will become identical to the Gaussian kernel. Recommended range: 0.25-25′) x_0 = input.int(25, “Start Regression at Bar”, group=rqkgroupname, tooltip=’Bar index on which to start regression. The first bars of a chart are often highly volatile, and omission of these initial bars often leads to a better overall fit. Recommended range: 5-25′) smoothColors = input.bool(false, “Smooth Colors”, group=rqkgroupname, tooltip=”Uses a crossover based mechanism to determine colors. This often results in less color transitions overall.”, inline=’1′) lag = input.int(2, “Lag”, group=rqkgroupname, tooltip=”Lag for crossover detection. Lower values result in earlier crossovers. Recommended range: 1-2″, inline=’1′) size = array.size(array.from(rqksrc)) // size of the data series kernel_regression(_rqksrc, _size, _h2) => float _currentWeight = 0. float _cumulativeWeight = 0. for i = 0 to _size + x_0 y = _rqksrc[i] w = math.pow(1 + (math.pow(i, 2) / ((math.pow(_h2, 2) * 2 * r))), -r) _currentWeight += y*w _cumulativeWeight += w _currentWeight / _cumulativeWeight var bool rqkuptrend = na var bool rqkdowntrend = na if respectrqk or leadingindicator==”Rational Quadratic Kernel (RQK)” // Estimations yhat1 = kernel_regression(rqksrc, size, h2) yhat2 = kernel_regression(rqksrc, size, h2-lag) // Rates of Change bool wasBearish = yhat1[2] > yhat1[1] bool wasBullish = yhat1[2] < yhat1[1] bool isBearish = yhat1[1] > yhat1 bool isBullish = yhat1[1] < yhat1 bool isBearishChange = isBearish and wasBullish bool isBullishChange = isBullish and wasBearish // Crossovers bool isBullishCross = ta.crossover(yhat2, yhat1) bool isBearishCross = ta.crossunder(yhat2, yhat1) bool isBullishSmooth = yhat2 > yhat1 bool isBearishSmooth = yhat2 < yhat1 rqkuptrend := yhat1[1] < yhat1 rqkdowntrend := yhat1[1] > yhat1 ///////////////////////////// ////////// TSI ///////////////////////////// tsi_group = “██████████ True Strength Indicator (TSI) ██████████” tsi_long_length = input(title=”Long Length”, defval=25,group=tsi_group) tsi_short_length = input(title=”Short Length”, defval=13,group=tsi_group) tsi_signal_length = input(title=”Signal Length”, defval=13,group=tsi_group) tsi_price = close tsi_double_smooth(src, long, short) => fist_smooth = ta.ema(src, long) ta.ema(fist_smooth, short) tsi_pc = ta.change(tsi_price) tsi_double_smoothed_pc = tsi_double_smooth(tsi_pc, tsi_long_length, tsi_short_length) tsi_double_smoothed_abs_pc = tsi_double_smooth(math.abs(tsi_pc), tsi_long_length, tsi_short_length) tsi_value = 100 * (tsi_double_smoothed_pc / tsi_double_smoothed_abs_pc) var tsi_long = bool(na) var tsi_short = bool(na) tsi_signal = ta.ema(tsi_value, tsi_signal_length) if tsitype == “Signal Cross” tsi_long := tsi_value > tsi_signal tsi_short := tsi_value < tsi_signal else if tsitype == “Zero line cross” tsi_long := tsi_value > tsi_signal and tsi_value>0 tsi_short := tsi_value < tsi_signal and tsi_value<0 //////////////////////////////// ///// Super Trend ////////////////////////////// sp_group = “██████████ SuperTrend ██████████” Periods = input(title=’ATR Period’, defval=10, group=sp_group) stsrc = input(hl2, title=’Source’, group=sp_group) Multiplier = input.float(title=’ATR Multiplier’, step=0.1, defval=3.0, group=sp_group) changeATR = input(title=’Change ATR Calculation Method ?’, defval=true, group=sp_group) showsignals = input(title=’Show Buy/Sell Signals ?’, defval=true, group=sp_group) highlighting = input(title=’Highlighter On/Off ?’, defval=true, group=sp_group) statr2 = ta.sma(ta.tr, Periods) statr = changeATR ? ta.atr(Periods) : statr2 stup = stsrc – Multiplier * statr up1 = nz(stup[1], stup) stup := close[1] > up1 ? math.max(stup, up1) : stup dn = stsrc + Multiplier * statr dn1 = nz(dn[1], dn) dn := close[1] < dn1 ? math.min(dn, dn1) : dn sttrend = 1 sttrend := nz(sttrend[1], sttrend) sttrend := sttrend == -1 and close > dn1 ? 1 : sttrend == 1 and close < up1 ? -1 : sttrend upPlot = plot(sttrend == 1 and switch_supertrend ? stup : na, title=’Up Trend’, style=plot.style_linebr, linewidth=2, color=color.new(color.green, 0)) stbuySignal = sttrend == 1 and sttrend[1] == -1 plotshape(stbuySignal and switch_supertrend ? stup : na, title=’UpTrend Begins’, location=location.absolute, style=shape.circle, size=size.tiny, color=color.new(color.green, 0)) dnPlot = plot(sttrend != 1 and switch_supertrend ? dn : na , title=’Down Trend’, style=plot.style_linebr, linewidth=2, color=color.new(color.red, 0)) stsellSignal = sttrend == -1 and sttrend[1] == 1 plotshape(stsellSignal and switch_supertrend ? dn : na, title=’DownTrend Begins’, location=location.absolute, style=shape.circle, size=size.tiny, color=color.new(color.red, 0)) ///////////////////////////////////////////// /////////// Half Trend //////////////////////////////////////////// ht_group = “██████████ HalfTrend ██████████” amplitude = input(title=’Amplitude’, defval=2,group=ht_group) channelDeviation = input(title=’Channel Deviation’, defval=2,group=ht_group) showArrows = input(title=’Show Arrows’, defval=true,group=ht_group) showChannels = input(title=’Show Channels’, defval=true,group=ht_group) var bool halftrend_long = na var bool halftrend_short = na var float ht = na var color htColor = na if respectht or leadingindicator==”Half Trend” or switch_halftrend var int ht_trend = 0 var int nextTrend = 0 var float maxLowPrice = nz(low[1], low) var float minHighPrice = nz(high[1], high) var float ht_up = 0.0 var float ht_down = 0.0 float atrHigh = 0.0 float atrLow = 0.0 float arrowUp = na float arrowDown = na ht_atr2 = ta.atr(100) / 2 ht_dev = channelDeviation * ht_atr2 highPrice = high[math.abs(ta.highestbars(amplitude))] lowPrice = low[math.abs(ta.lowestbars(amplitude))] highma = ta.sma(high, amplitude) lowma = ta.sma(low, amplitude) if nextTrend == 1 maxLowPrice := math.max(lowPrice, maxLowPrice) if highma < maxLowPrice and close < nz(low[1], low) ht_trend := 1 nextTrend := 0 minHighPrice := highPrice minHighPrice else minHighPrice := math.min(highPrice, minHighPrice) if lowma > minHighPrice and close > nz(high[1], high) ht_trend := 0 nextTrend := 1 maxLowPrice := lowPrice maxLowPrice if ht_trend == 0 if not na(ht_trend[1]) and ht_trend[1] != 0 ht_up := na(ht_down[1]) ? ht_down : ht_down[1] arrowUp := ht_up – ht_atr2 arrowUp else ht_up := na(ht_up[1]) ? maxLowPrice : math.max(maxLowPrice, ht_up[1]) ht_up atrHigh := ht_up + ht_dev atrLow := ht_up – ht_dev atrLow else if not na(ht_trend[1]) and ht_trend[1] != 1 ht_down := na(ht_up[1]) ? ht_up : ht_up[1] arrowDown := ht_down + ht_atr2 arrowDown else ht_down := na(ht_down[1]) ? minHighPrice : math.min(minHighPrice, ht_down[1]) ht_down atrHigh := ht_down + ht_dev atrLow := ht_down – ht_dev atrLow ht := ht_trend == 0 ? ht_up : ht_down var color buyColor = color.blue var color sellColor = color.red htColor := ht_trend == 0 ? buyColor : sellColor halftrend_long := ht_trend == 0 halftrend_short := ht_trend != 0 htPlot = plot(switch_halftrend ? ht:na, title=’HalfTrend’, linewidth=2, color=htColor) ////////////////////////////////////// ///////////////////////////////////////////// ///////// Trend Line Breakout ///////////////////////////////////////////// //—————————————————————————— //Settings //—————————————————————————–{ tbgroup= “██████████ Trendline Breakout ██████████” length_tb = input.int(14, ‘Swing Detection Lookback’,group=tbgroup) mult_tb = input.float(1., ‘Slope’, minval = 0, step = .1,group=tbgroup) calcMethod = input.string(‘Atr’, ‘Slope Calculation Method’, options = [‘Atr’,’Stdev’,’Linreg’],group=tbgroup) backpaint = input(true, tooltip = ‘Backpainting offset displayed elements in the past. Disable backpainting to see real time information returned by the indicator.’,group=tbgroup) var upos = 0 var dnos = 0 tb_buysignal = bool (na) tb_sellsignal = bool (na) if respecttrendline_breakout or leadingindicator==”Trendline Breakout” //—————————————————————————–} //Calculations //—————————————————————————–{ var upper_tb = 0. var lower_tb = 0. var slope_ph = 0. var slope_pl = 0. var offset_tb = backpaint ? length_tb : 0 n_tb = bar_index src_tb = close ph = ta.pivothigh(length_tb, length_tb) pl = ta.pivotlow(length_tb, length_tb) //Slope Calculation Method slope_tb = switch calcMethod ‘Atr’ => ta.atr(length_tb) / length_tb * mult_tb ‘Stdev’ => ta.stdev(src_tb,length_tb) / length_tb * mult_tb ‘Linreg’ => math.abs(ta.sma(src_tb * n_tb, length_tb) – ta.sma(src_tb, length_tb) * ta.sma(n_tb, length_tb)) / ta.variance(n_tb, length_tb) / 2 * mult_tb //Get slopes and calculate trendlines slope_ph := ph ? slope_tb : slope_ph slope_pl := pl ? slope_tb : slope_pl upper_tb := ph ? ph : upper_tb – slope_ph lower_tb := pl ? pl : lower_tb + slope_pl upos := ph ? 0 : close > upper_tb – slope_ph * length_tb ? 1 : upos dnos := pl ? 0 : close < lower_tb + slope_pl * length_tb ? 1 : dnos for i = 0 to signalexpiry – 1 tb_buysignal := upos[0] > upos[i+1] tb_sellsignal := dnos[0] > dnos[i+1] ////////////////////////////////////////////// ////// Ichimoku ///////////////////////////////////////////// ichigroup = “██████████ Ichimoku ██████████” conversionPeriods = input.int(9, minval=1, title=”Conversion Line Length”,group=ichigroup) basePeriods = input.int(26, minval=1, title=”Base Line Length”,group=ichigroup) laggingSpan2Periods = input.int(52, minval=1, title=”Leading Span B Length”,group=ichigroup) displacement = input.int(26, minval=1, title=”Lagging Span”,group=ichigroup) donchian(len) => math.avg(ta.lowest(len), ta.highest(len)) conversionLine = donchian(conversionPeriods) baseLine = donchian(basePeriods) leadLine1 = math.avg(conversionLine, baseLine) leadLine2 = donchian(laggingSpan2Periods) ChikouSpan = close[25] + (close – close[25]) lead1 = leadLine1[displacement – 1] lead2 = leadLine2[displacement – 1] plot(switch_ichi?conversionLine:na, color=#2962FF, title=”Conversion Line”,linewidth = 1) plot(switch_ichi ? baseLine:na, color=#B71C1C, title=”Base Line”,linewidth = 1) plot(switch_ichi?close:na, offset = -displacement + 1, color=#43A047, title=”Lagging Span”) p1 = plot(switch_ichi?leadLine1:na, offset = displacement – 1, color=#A5D6A7, title=”Leading Span A”) p2 = plot(switch_ichi?leadLine2:na, offset = displacement – 1, color=#EF9A9A, title=”Leading Span B”) fill(p1, p2, color = leadLine1 > leadLine2 and switch_ichi ? color.rgb(67, 160, 71, 70) : color.rgb(244, 67, 54, 70)) ichi_long = conversionLine > baseLine and leadLine1> leadLine2 and close >leadLine1[displacement -1] and close >leadLine2[displacement -1] and (ChikouSpan > leadLine1[50] and ChikouSpan > leadLine2[50]) ichi_short = conversionLine < baseLine and leadLine1 < leadLine2 and close < leadLine1[displacement -1] and close < leadLine2[displacement -1] and (ChikouSpan < leadLine2[50] and ChikouSpan < leadLine1[50]) ////////////////////////////// ///////// SuperIchi ///////////////////////////// superichigroup = “██████████ SuperIchi ██████████” tenkan_len = input(9,’Tenkan ’,inline=’tenkan’,group=superichigroup) tenkan_mult = input(2.,”,inline=’tenkan’,group=superichigroup) kijun_len = input(26,’Kijun ’,inline=’kijun’,group=superichigroup) kijun_mult = input(4.,”,inline=’kijun’,group=superichigroup) spanB_len = input(52,’Senkou Span B ’,inline=’span’,group=superichigroup) spanB_mult = input(6.,”,inline=’span’,group=superichigroup) offset = input(26,’Displacement’,group=superichigroup) //—————————————————————————— avg(src,length,mult)=> atr = ta.atr(length)*mult up = hl2 + atr dn = hl2 – atr upper = 0.,lower = 0. upper := src[1] < upper[1] ? math.min(up,upper[1]) : up lower := src[1] > lower[1] ? math.max(dn,lower[1]) : dn os = 0,max = 0.,min = 0. os := src > upper ? 1 : src < lower ? 0 : os[1] spt = os == 1 ? lower : upper max := ta.cross(src,spt) ? math.max(src,max[1]) : os == 1 ? math.max(src,max[1]) : spt min := ta.cross(src,spt) ? math.min(src,min[1]) : os == 0 ? math.min(src,min[1]) : spt math.avg(max,min) //—————————————————————————— tenkan = avg(close,tenkan_len,tenkan_mult) kijun = avg(close,kijun_len,kijun_mult) senkouA = math.avg(kijun,tenkan) senkouB = avg(close,spanB_len,spanB_mult) //—————————————————————————— superichi_long = tenkan > kijun and senkouA> senkouB and close >senkouA[displacement -1] and close >senkouB[displacement -1] and (ChikouSpan > senkouA[50] and ChikouSpan > senkouB[50]) superichi_short = tenkan < kijun and senkouA < senkouB and close < senkouA[displacement -1] and close < senkouB[displacement -1] and (ChikouSpan < senkouB[50] and ChikouSpan < senkouA[50]) ////////////////////////////////// ///////////Donchian Channel Ribbon /////////////////////////////////// donchiangroup = “██████████ Donchian Channel Ribbon ██████████” dlen = input.int(defval=15, title=’Donchian Channel Period’, group=donchiangroup) dchannel(len) => float hh = ta.highest(len) float ll = ta.lowest(len) int trend = 0 trend := close > hh[1] ? 1 : close < ll[1] ? -1 : nz(trend[1]) trend dchannelalt(len, maintrend) => float hh = ta.highest(len) float ll = ta.lowest(len) int trend = 0 trend := close > hh[1] ? 1 : close < ll[1] ? -1 : nz(trend[1]) maintrend == 1 ? trend == 1 ? #00FF00ff : #00FF009f : maintrend == -1 ? trend == -1 ? #FF0000ff : #FF00009f : na maintrend = dchannel(dlen) donchian_long = maintrend == 1 ? true:na donchian_short = maintrend == -1 ? true:na //////////////////////////////// // DMI code //////////////////////////////// dmi_group = “████████ Directional Movement Index (DMI) ████████” adxlen = input(5, title=”ADX”, group=dmi_group, inline=’dmi’) keyLevel = input(20, title=’ADX limit’,group=dmi_group, inline=’dmi’) dilen = input.int(10, title=”DI Length”,group=dmi_group, inline=’dmi’) lensig = adxlen upp = ta.change(high) downn = ta.change(low) plusDM = na(upp) ? na : upp > downn and upp > 0 ? upp : 0 minusDM = na(downn) ? na : downn > upp and downn > 0 ? downn : 0 trur = ta.rma(ta.tr, dilen) plus = fixnan(100 * ta.rma(plusDM, dilen) / trur) minus = fixnan(100 * ta.rma(minusDM, dilen) / trur) sum = plus + minus adxx = 100 * ta.rma(math.abs(plus – minus) / (sum == 0 ? 1 : sum), lensig) dirmov(dilen) => up = ta.change(high) down = -ta.change(low) truerange = ta.rma(ta.tr, dilen) plus = fixnan(100 * ta.rma(up > down and up > 0 ? up : 0, dilen) / truerange) minus = fixnan(100 * ta.rma(down > up and down > 0 ? down : 0, dilen) / truerange) [plus, minus] adx(dilen, adxlen) => [plus, minus] = dirmov(dilen) sum = plus + minus adx = 100 * ta.rma(math.abs(plus – minus) / (sum == 0 ? 1 : sum), adxlen) [adx, plus, minus] [adx, diplus, diminus] = adx(dilen, adxlen) //////////////////////////////////////////////// //Parabolic SAR /////////////////////////////////////////////// //showsar = input.bool (false, “Show SAR”, group=’————————-Parabolic SAR————————-‘) psar_group = “██████████ Parabolic SAR (PSAR) ██████████” start = input.float(0.02, group=psar_group, inline =’sar’) increment = input.float(0.02, group=psar_group, inline =’sar’) maximum = input.float(0.2, ‘Max Value’, group=psar_group, inline =’sar’) out = ta.sar(start, increment, maximum) sarcolor = if (out>close) color.red else color.green if (switch_sar ) color.red else color.green plot(switch_sar ? out : na, ‘ParabolicSAR’, style=plot.style_cross, color=sarcolor) ////////////////////////////////////////////////// ///////// TDFI ///////////////////////////////////////////////// rdfi_group = “█████ Trend Direction Force Index (TDFI) █████ ” lookback = input(13, title=’Lookback’,group=rdfi_group) mmaLength = input(13, title=’MMA Length’,group=rdfi_group) mmaMode = input.string(title=’MMA Mode’, defval=’ema’, options=[’ema’, ‘wma’, ‘swma’, ‘vwma’, ‘hull’, ‘tema’],group=rdfi_group) smmaLength = input(13,group=rdfi_group) smmaMode = input.string(title=’SMMA Mode’, defval=’ema’, options=[’ema’, ‘wma’, ‘swma’, ‘vwma’, ‘hull’, ‘tema’],group=rdfi_group) nLength = input(3, title=’N Length’,group=rdfi_group) filterHigh = input(0.05, title=’Filter High’,group=rdfi_group) filterLow = input(-0.05, title=’Filter Low’,group=rdfi_group) price = input(close, ‘Period’,group=rdfi_group) tema(src, len) => ema1_tdfi = ta.ema(src, len) ema2_tdfi = ta.ema(ema1_tdfi, len) ema3_tdfi = ta.ema(ema2_tdfi, len) 3 * ema1_tdfi – 3 * ema2_tdfi + ema3_tdfi tdfi_ma(mode, src, len) => mode == ’ema’ ? ta.ema(src, len) : mode == ‘wma’ ? ta.wma(src, len) : mode == ‘swma’ ? ta.swma(src) : mode == ‘vwma’ ? ta.vwma(src, len) : mode == ‘hull’ ? ta.wma(2 * ta.wma(src, len / 2) – ta.wma(src, len), math.round(math.sqrt(len))) : mode == ‘tema’ ? tema(src, len) : ta.sma(src, len) tdfi() => mma = tdfi_ma(mmaMode, price * 1000, mmaLength) smma = tdfi_ma(smmaMode, mma, smmaLength) impetmma = mma – mma[1] impetsmma = smma – smma[1] divma = math.abs(mma – smma) averimpet = (impetmma + impetsmma) / 2 tdf = math.pow(divma, 1) * math.pow(averimpet, nLength) tdf / ta.highest(math.abs(tdf), lookback * nLength) signal_tdfi = tdfi() tdfi_long = signal_tdfi > filterHigh tdfi_short = signal_tdfi < filterLow ////////////////////////////////////////////////// ///////// McGinley Dynamic ///////////////////////////////////////////////// md_group = “████████████████████ McGinley Dynamic ████████████████████” md_length = input.int(14, minval=1,group=md_group) md_source = close mg = 0.0 mg := na(mg[1]) ? ta.ema(md_source, md_length) : mg[1] + (md_source – mg[1]) / (md_length * math.pow(md_source/mg[1], 4)) md_long = close > mg md_short = close<mg ////////////////////////////////////////////////// ///////// CCI ///////////////////////////////////////////////// cci_group = “████████████████████ CCI ████████████████████” ccilength = input.int(20,title=”CCI Length”, minval=1,inline=”cci”, group=cci_group) ccisrc = input(hlc3, title=”Source”,inline=”cci”, group=cci_group) cciupperband = input.int(100,title=”Upper Band”,inline=”cci2″, group=cci_group) ccilowerband = input.int(-100,title=”Lower Band”,inline=”cci2″, group=cci_group) ma = ta.sma(ccisrc, ccilength) cci = (ccisrc – ma) / (0.015 * ta.dev(ccisrc, ccilength)) typeMA = input.string(title = “Method”, defval = “SMA”, options=[“SMA”, “EMA”, “SMMA (RMA)”, “WMA”, “VWMA”], group=”Smoothing”,inline=”cci4″) smoothingLength = input.int(title = “Length”, defval = 5, minval = 1, maxval = 100, group=”Smoothing”,inline=”cci3″) smoothingLine = ma(cci, smoothingLength, typeMA) ccilong = cci > cciupperband ccishort = cci < ccilowerband /////////////////////////////////////////////// /////// B-Xtrender ///////////////////////////////////////////// bxgroup= “██████████ B-Xtrender ██████████” short_l1 = input(5, title=’Short – L1′,group=bxgroup) short_l2 = input(20, title=’Short – L2′,group=bxgroup) short_l3 = input(15, title=’Short – L3′,group=bxgroup) long_l1 = input(5, title=’Long – L1′,group=bxgroup) long_l2 = input(10, title=’Long – L2′,group=bxgroup) shortTermXtrender = ta.rsi(ta.ema(close, short_l1) – ta.ema(close, short_l2), short_l3) – 50 longTermXtrender = ta.rsi(ta.ema(close, long_l1), long_l2) – 50 t3(src, len) => xe1_1 = ta.ema(src, len) xe2_1 = ta.ema(xe1_1, len) xe3_1 = ta.ema(xe2_1, len) xe4_1 = ta.ema(xe3_1, len) xe5_1 = ta.ema(xe4_1, len) xe6_1 = ta.ema(xe5_1, len) b_1 = 0.7 c1_1 = -b_1 * b_1 * b_1 c2_1 = 3 * b_1 * b_1 + 3 * b_1 * b_1 * b_1 c3_1 = -6 * b_1 * b_1 – 3 * b_1 – 3 * b_1 * b_1 * b_1 c4_1 = 1 + 3 * b_1 + b_1 * b_1 * b_1 + 3 * b_1 * b_1 nT3Average_1 = c1_1 * xe6_1 + c2_1 * xe5_1 + c3_1 * xe4_1 + c4_1 * xe3_1 nT3Average_1 maShortTermXtrender = t3(shortTermXtrender, 5) bx_long = bool(na) bx_short = bool(na) if bxtype == “Short Term trend” bx_long := maShortTermXtrender > maShortTermXtrender[1] bx_short := maShortTermXtrender < maShortTermXtrender[1] else if bxtype == “Short and Long term trend” bx_long := maShortTermXtrender > maShortTermXtrender[1] and (longTermXtrender > 0 and longTermXtrender > longTermXtrender[1]) and (shortTermXtrender > shortTermXtrender[1] and shortTermXtrender > 0) bx_short := maShortTermXtrender < maShortTermXtrender[1] and (longTermXtrender < 0 and longTermXtrender < longTermXtrender[1]) and (shortTermXtrender < shortTermXtrender[1] and shortTermXtrender < 0) //////////////////////////////////////////////// ////// Bull Bear Power Trend (BBPT) /////////////////////////////////////////////// BullTrend_hist = 0.0 BearTrend_hist = 0.0 BullTrend = (close – ta.lowest(low, 50)) / ta.atr(5) BearTrend = (ta.highest(high, 50) – close) / ta.atr(5) BearTrend2 = -1 * BearTrend Trend = BullTrend – BearTrend if BullTrend < 2 BullTrend_hist := BullTrend – 2 BullTrend_hist if BearTrend2 > -2 BearTrend_hist := BearTrend2 + 2 BearTrend_hist bbpt_long = bool(na) bbpt_short = bool(na) if bbpttype ==”Follow Trend” bbpt_long := BearTrend_hist > 0 and Trend>=2 bbpt_short := BullTrend_hist < 0 and Trend<=-2 else if bbpttype == “Without Trend” bbpt_long := BearTrend_hist > 0 bbpt_short := BullTrend_hist < 0 /////////////////////////////////////////////// //////////// VWAP ///////////////////////////////////////////// vwap_group = “██████████ VWAP Settings ██████████” hideonDWM = input(false, title=”Hide VWAP on 1D or Above”, group=vwap_group) var anchor = input.string(defval = “Session”, title=”Anchor Period”, options=[“Session”, “Week”, “Month”, “Quarter”, “Year”, “Decade”, “Century”, “Earnings”, “Dividends”, “Splits”], group=vwap_group) srcvwap = input(title = “Source”, defval = hlc3, group=vwap_group) offsetvwap = input(0, title=”Offset”, group=vwap_group) showBand_1 = input(true, title=””, group=”Standard Deviation Bands Settings”, inline=”band_1″) stdevMult_1 = input(1.0, title=”Bands Multiplier #1″, group=”Standard Deviation Bands Settings”, inline=”band_1″) showBand_2 = input(false, title=””, group=”Standard Deviation Bands Settings”, inline=”band_2″) stdevMult_2 = input(2.0, title=”Bands Multiplier #2″, group=”Standard Deviation Bands Settings”, inline=”band_2″) showBand_3 = input(false, title=””, group=”Standard Deviation Bands Settings”, inline=”band_3″) stdevMult_3 = input(3.0, title=”Bands Multiplier #3″, group=”Standard Deviation Bands Settings”, inline=”band_3″) if barstate.islast and ta.cum(volume) == 0 runtime.error(“No volume is provided by the data vendor.”) new_earnings = request.earnings(syminfo.tickerid, earnings.actual, barmerge.gaps_on, barmerge.lookahead_on, ignore_invalid_symbol=true) new_dividends = request.dividends(syminfo.tickerid, dividends.gross, barmerge.gaps_on, barmerge.lookahead_on, ignore_invalid_symbol=true) new_split = request.splits(syminfo.tickerid, splits.denominator, barmerge.gaps_on, barmerge.lookahead_on, ignore_invalid_symbol=true) isNewPeriod = switch anchor “Earnings” => not na(new_earnings) “Dividends” => not na(new_dividends) “Splits” => not na(new_split) “Session” => timeframe.change(“D”) “Week” => timeframe.change(“W”) “Month” => timeframe.change(“M”) “Quarter” => timeframe.change(“3M”) “Year” => timeframe.change(“12M”) “Decade” => timeframe.change(“12M”) and year % 10 == 0 “Century” => timeframe.change(“12M”) and year % 100 == 0 => false isEsdAnchor = anchor == “Earnings” or anchor == “Dividends” or anchor == “Splits” if na(srcvwap[1]) and not isEsdAnchor isNewPeriod := true float vwapValue = na float upperBandValue1 = na float lowerBandValue1 = na float upperBandValue2 = na float lowerBandValue2 = na float upperBandValue3 = na float lowerBandValue3 = na if not (hideonDWM and timeframe.isdwm) [_vwap, _stdevUpper, _] = ta.vwap(srcvwap, isNewPeriod, 1) vwapValue := _vwap stdevAbs = _stdevUpper – _vwap upperBandValue1 := _vwap + stdevAbs * stdevMult_1 lowerBandValue1 := _vwap – stdevAbs * stdevMult_1 upperBandValue2 := _vwap + stdevAbs * stdevMult_2 lowerBandValue2 := _vwap – stdevAbs * stdevMult_2 upperBandValue3 := _vwap + stdevAbs * stdevMult_3 lowerBandValue3 := _vwap – stdevAbs * stdevMult_3 plot(switch_vwap? vwapValue:na, title=”VWAP”, color=#2962FF, offset=offsetvwap) long_vwap = close>vwapValue short_vwap = close < vwapValue //////////////////////////////////////////////// ////// Chandelier Exit /////////////////////////////////////////////// ChandelierE = “██████████ Chandelier Exit ██████████” ce_length = input(title=’ATR Period’, defval=22,group=ChandelierE) ce_mult = input.float(title=’ATR Multiplier’, step=0.1, defval=3.0,group=ChandelierE) showLabels = input(title=’Show Buy/Sell Labels ?’, defval=true,group=ChandelierE) useClose = input(title=’Use Close Price for Extremums ?’, defval=true,group=ChandelierE) highlightState = input(title=’Highlight State ?’, defval=true,group=ChandelierE) ce_atr = ce_mult * ta.atr(ce_length) longStop = (useClose ? ta.highest(close, ce_length) : ta.highest(ce_length)) – ce_atr longStopPrev = nz(longStop[1], longStop) longStop := close[1] > longStopPrev ? math.max(longStop, longStopPrev) : longStop shortStop = (useClose ? ta.lowest(close, ce_length) : ta.lowest(ce_length)) + ce_atr shortStopPrev = nz(shortStop[1], shortStop) shortStop := close[1] < shortStopPrev ? math.min(shortStop, shortStopPrev) : shortStop var int dir = 1 dir := close > shortStopPrev ? 1 : close < longStopPrev ? -1 : dir ce_long = dir == 1 ce_short = dir == -1 //////////////////////////////////////////////// ////// ROC /////////////////////////////////////////////// roc_group = “██████████ Rate of Change (ROC) ██████████” roc_length = input.int(9, minval=1,group=roc_group) roc_source = input(close, “Source”,group=roc_group) roc = 100 * (roc_source – roc_source[roc_length])/roc_source[roc_length] roc_long= roc>0 roc_short = roc<0 //////////////////////////////////////////////// ////// SSL Channel /////////////////////////////////////////////// group_ssl = “██████████ SSL Channel ██████████” SSLperiod = input(title=’Period’, defval=10, group=group_ssl) SSLlen = input(title=’Period’, defval=10, group=group_ssl) smaHigh = ta.sma(high, SSLlen) smaLow = ta.sma(low, SSLlen) Hlv = int(na) Hlv := close > smaHigh ? 1 : close < smaLow ? -1 : Hlv[1] sslDown = Hlv < 0 ? smaHigh : smaLow sslUp = Hlv < 0 ? smaLow : smaHigh ssl_long = sslUp>sslDown ssl_short = sslUp<sslDown //////////////////////////////////////////////// ////// Chaikin Money Flow /////////////////////////////////////////////// group_chaikin = “██████████ Chaiken Money Flow ██████████” chaiking_length = input.int(20, minval=1, group = group_chaikin ) ad = close == high and close == low or high == low ? 0 : (2 * close – low – high) / (high – low) * volume mf = math.sum(ad, chaiking_length) / math.sum(volume, chaiking_length) chaikin_long = mf>0 chaikin_short = mf<0 //////////////////////////////////////////////// ////// Vortex INdex /////////////////////////////////////////////// vortex_group = “██████████ Vortex Index ██████████” period_ = input.int(14, title=”Length”, minval=2, group=vortex_group, inline = ‘vi’) viupper = input.float(1.1, title=”Upper band”,group=vortex_group, inline = ‘vi’) vilower = input.float(0.9, title=”Lower Band”, group=vortex_group, inline = ‘vi’) VMP = math.sum( math.abs( high – low[1]), period_ ) VMM = math.sum( math.abs( low – high[1]), period_ ) STR = math.sum( ta.atr(1), period_ ) vip = VMP / STR vim = VMM / STR ///////////////////////////////////////////////// ////////Waddar Atar explosion (WAR) ////////////////////////////////////////////////// group_wae = “██████████ Waddah Attar Explosion ██████████” wae_sensitivity = input(150, title=”Sensitivity”,group=group_wae) wae_fastLength=input(20, title=”FastEMA Length”,group=group_wae) wae_slowLength=input(40, title=”SlowEMA Length”,group=group_wae) channelLength=input(20, title=”BB Channel Length”,group=group_wae) wae_mult=input(2.0, title=”BB Stdev Multiplier”,group=group_wae) deadzone = nz(ta.rma(ta.tr(true),100)) * 3.7 calc_macd(source, wae_fastLength, wae_slowLength) => fastMA = ta.ema(source, wae_fastLength) slowMA = ta.ema(source, wae_slowLength) fastMA – slowMA calc_BBUpper(source, length, wae_mult) => basis = ta.sma(source, length) dev = wae_mult * ta.stdev(source, length) basis + dev calc_BBLower(source, length, wae_mult) => basis = ta.sma(source, length) dev = wae_mult * ta.stdev(source, length) basis – dev t1 = (calc_macd(close, wae_fastLength, wae_slowLength) – calc_macd(close[1], wae_fastLength, wae_slowLength))*wae_sensitivity e1 = (calc_BBUpper(close, channelLength, wae_mult) – calc_BBLower(close, channelLength, wae_mult)) trendUp = (t1 >= 0) ? t1 : 0 trendDown = (t1 < 0) ? (-1*t1) : 0 wae_long = trendUp and trendUp >e1 and e1 > deadzone and trendUp>deadzone wae_short = trendDown and trendDown >e1 and e1 > deadzone and trendDown>deadzone ////////////////////////////////////////////// ////////// Range Detector ////////////////////////////////////////////// rdgroup= “██████████ Range Detector ██████████” //—————————————————————————— //Settings //—————————————————————————–{ rd_length = input.int(20, ‘Minimum Range Length’, minval = 2,group=rdgroup) rd_mult = input.float(1., ‘Range Width’, minval = 0, step = 0.1,group=rdgroup) rd_atrLen = input.int(500, ‘ATR Length’, minval = 1,group=rdgroup) //Style rd_upCss = input(#089981, ‘Broken Upward’, group = ‘Style’,group=rdgroup) rd_dnCss = input(#f23645, ‘Broken Downward’, group = ‘Style’,group=rdgroup) unbrokenCss = input(#2157f3, ‘Unbroken’, group = ‘Style’,group=rdgroup) //—————————————————————————–} //Detect and highlight ranges //—————————————————————————–{ //Ranges drawings var box bx = na var line lvl = na //Extensions var float rd_max = na var float rd_min = na var rd_os = 0 color detect_css = na rd_n = bar_index rd_atr = ta.atr(rd_atrLen) * rd_mult rd_ma = ta.sma(close, rd_length) count = 0 for i = 0 to rd_length-1 count += math.abs(close[i] – rd_ma) > rd_atr ? 1 : 0 // if switch_rd if count == 0 and count[1] != count //Test for overlap and change coordinates if rd_n[rd_length] <= bx.get_right() rd_max := math.max(rd_ma + rd_atr, bx.get_top()) rd_min := math.min(rd_ma – rd_atr, bx.get_bottom()) if switch_rd //Box new coordinates bx.set_top(rd_max) bx.set_rightbottom(rd_n, rd_min) bx.set_bgcolor(color.new(unbrokenCss, 80)) //Line new coordinates avg = math.avg(rd_max, rd_min) lvl.set_y1(avg) lvl.set_xy2(rd_n, avg) lvl.set_color(unbrokenCss) else rd_max := rd_ma + rd_atr rd_min := rd_ma – rd_atr //Set new box and level if switch_rd bx := box.new(rd_n[rd_length], rd_ma + rd_atr, rd_n, rd_ma – rd_atr, na, bgcolor = color.new(unbrokenCss, 80)) lvl := line.new(rd_n[rd_length], rd_ma, rd_n, rd_ma, color = unbrokenCss, style = line.style_dotted) detect_css := color.new(color.gray, 80) rd_os := 0 else if count == 0 bx.set_right(rd_n) lvl.set_x2(rd_n) //Set color if close > bx.get_top() bx.set_bgcolor(color.new(rd_upCss, 80)) lvl.set_color(rd_upCss) rd_os := 1 else if close < bx.get_bottom() bx.set_bgcolor(color.new(rd_dnCss, 80)) lvl.set_color(rd_dnCss) rd_os := -1 //—————————————————————————–} //Plots //—————————————————————————–{ //Range detection bgcolor bgcolor(detect_css) plot(switch_rd? rd_max:na, ‘Range Top’ , rd_max != rd_max[1] ? na : rd_os == 0 ? unbrokenCss : rd_os == 1 ? rd_upCss : rd_dnCss) plot(switch_rd ? rd_min:na, ‘Range Bottom’ , rd_min != rd_min[1] ? na : rd_os == 0 ? unbrokenCss : rd_os == 1 ? rd_upCss : rd_dnCss) //—————————————————————————–} // for leading indicator rd_long = close > rd_max rd_short = close < rd_min //for confirmation indicator rd_signal = close > rd_max or close <rd_min ///////////////////////////////////////////////// ////////Volatility Oscillator ////////////////////////////////////////////////// group_vo = “██████████ Volatility Oscillator ██████████” volength = input(100, group = group_vo) spike = close – open vox = ta.stdev(spike,volength) voy = ta.stdev(spike,volength) * -1 vo_long = spike > vox vo_short = spike < voy ///////////////////////////////////////////////// ////////Detrended Price Oscillator (DPO) ////////////////////////////////////////////////// group_dpo = “██████████ Detrended Price Oscillator (DPO) ██████████” dpo_period_ = input.int(10, title=”Length”, minval=1,group=group_dpo) isCentered = input(false, title=”Centered”,group=group_dpo) barsback = dpo_period_/2 + 1 dpo_ma = ta.sma(close, dpo_period_) dpo = isCentered ? close[barsback] – dpo_ma : close – dpo_ma[barsback] dpo_long = dpo > 0 dpo_short = dpo<0 ///////////////////////////////////////////////// ////////HACOLT ////////////////////////////////////////////////// hacolt_group = “███████ Heiken-Ashi Candlestick Oscillator ███████” hacolt_length = input(defval=55, title=”TEMA Period”,group=hacolt_group) hacolt_emaLength = input(defval=60, title=”EMA Period”,group=hacolt_group) hacolt_candleSizeFactor = input(defval=1.1, title=”Candle size factor”,group=hacolt_group) calc_tema(src, length) => hacolt_ema1 = ta.ema(src, length) hacolt_ema2 = ta.ema(hacolt_ema1, length) hacolt_ema3 = ta.ema(hacolt_ema2, length) 3 * (hacolt_ema1 – hacolt_ema2) + hacolt_ema3 var bool hacolt_long = na var bool hacolt_short = na if respecthacolt or leadingindicator == “Heiken-Ashi Candlestick Oscillator” var float hacolt_haOpen = na hacolt_haOpen := nz(hacolt_haOpen[1] + hl2) / 2 hacolt_haClose = (hacolt_haOpen + math.max(high, hacolt_haOpen) + math.min(low, hacolt_haOpen) + hl2) / 4 hacolt_thaClose = calc_tema(hacolt_haClose, hacolt_length) hacolt_thl2 = calc_tema(hl2, hacolt_length) hacolt_haCloseSmooth = 2 * hacolt_thaClose – calc_tema(hacolt_thaClose, hacolt_length) hacolt_hl2Smooth = 2 * hacolt_thl2 – calc_tema(hacolt_thl2, hacolt_length) hacolt_shortCandle = math.abs(close – open) < ((high – low) * hacolt_candleSizeFactor) hacolt_keepn1 = ((hacolt_haClose >= hacolt_haOpen) and (hacolt_haClose[1] >= hacolt_haOpen[1])) or (close >= hacolt_haClose) or (high > high[1]) or (low > low[1]) or (hacolt_hl2Smooth >= hacolt_haCloseSmooth) hacolt_keepall1 = hacolt_keepn1 or (hacolt_keepn1[1] and (close >= open) or (close >= close[1])) hacolt_keep13 = hacolt_shortCandle and (high >= low[1]) hacolt_utr = hacolt_keepall1 or (hacolt_keepall1[1] and hacolt_keep13) hacolt_keepn2 = (hacolt_haClose < hacolt_haOpen) and (hacolt_haClose[1] < hacolt_haOpen[1]) or (hacolt_hl2Smooth < hacolt_haCloseSmooth) hacolt_keep23 = hacolt_shortCandle and (low <= high[1]) hacolt_keepall2 = hacolt_keepn2 or (hacolt_keepn2[1] and (close < open) or (close < close[1])) hacolt_dtr = hacolt_keepall2 or (hacolt_keepall2[1] and hacolt_keep23) hacolt_upw = hacolt_dtr == 0 and hacolt_dtr[1] and hacolt_utr hacolt_dnw = hacolt_utr == 0 and hacolt_utr[1] and hacolt_dtr var bool hacolt_upwWithOffset = na hacolt_upwWithOffset := hacolt_upw != hacolt_dnw ? hacolt_upw : nz(hacolt_upwWithOffset[1]) hacolt_buySig = hacolt_upw or (not hacolt_dnw and (na(hacolt_upwWithOffset) ? false : hacolt_upwWithOffset)) hacolt_ltSellSig = close < ta.ema(close, hacolt_emaLength) var bool hacolt_neutralSig = na hacolt_neutralSig := hacolt_buySig or (hacolt_ltSellSig ? false : nz(hacolt_neutralSig[1])) hacolt = hacolt_buySig ? 1 : hacolt_neutralSig ? 0 : -1 hacolt_long := hacolt > 0 hacolt_short := hacolt < 0 ///////////////////////////////////////////////// ////////Choppiness Index ////////////////////////////////////////////////// group_ci = “██████████ Choppiness Index ██████████” ci_length = input.int(14, minval=1,group=group_ci) ci_index = 100 * math.log10(math.sum(ta.atr(1), ci_length) / (ta.highest(ci_length) – ta.lowest(ci_length))) / math.log10(ci_length) ci_filter = ci_index<ci_limit ////////////////////////////////////////////////// ////////Damiani Volatmeter ////////////////////////////////////////////////// dv_group = “██████████ Damiani Volatmeter ██████████” int vis_atr = input.int(13,title=”Vis ATR”, group=dv_group, inline = ‘1’) int vis_std = input.int(20,title=”Vis STD”, group=dv_group, inline = ‘1’) int sed_atr = input.int(40,title=”Sed ATR”, group=dv_group, inline = ‘1’) int sed_std = input.int(100,title=”SEd STD”, group=dv_group, inline = ‘1’) float threshold_level = input.float(1.4,title=”Threshold”, group=dv_group, inline = ‘1’) bool lag_supressor = input.bool(true,title=”Lag Supressor”, group=dv_group, inline = ‘1’) lag_s_K = 0.5 vol = 0.0 s1_pivot=nz(vol[1], 0) s3_pivot=nz(vol[3], 0) vol := lag_supressor ? ta.atr(vis_atr) / ta.atr(sed_atr) + lag_s_K*(s1_pivot-s3_pivot) : ta.atr(vis_atr) / ta.atr(sed_atr) anti_thres = ta.stdev(close, vis_std) / ta.stdev(close, sed_std) t = threshold_level – anti_thres vol_m = vol > t ? -1 : 0.03 ////////////////////////////////////////////// /////// MACD ///////////////////////////////////////////// macd_group = “██████████ MACD ██████████” fast_length = input(title=”Fast Length”, defval=12,group=macd_group) slow_length = input(title=”Slow Length”, defval=26,group=macd_group) macdsrc = input(title=”Source”, defval=close,group=macd_group) signal_length = input.int(title=”Signal Smoothing”, minval = 1, maxval = 50, defval = 9,group=macd_group) sma_source = input.string(title=”Oscillator MA Type”, defval=”EMA”, options=[“SMA”, “EMA”],group=macd_group) sma_signal = input.string(title=”Signal Line MA Type”, defval=”EMA”, options=[“SMA”, “EMA”],group=macd_group) fast_ma = sma_source == “SMA” ? ta.sma(macdsrc, fast_length) : ta.ema(macdsrc, fast_length) slow_ma = sma_source == “SMA” ? ta.sma(macdsrc, slow_length) : ta.ema(macdsrc, slow_length) macdd = fast_ma – slow_ma signal = sma_signal == “SMA” ? ta.sma(macdd, signal_length) : ta.ema(macdd, signal_length) hist = macdd – signal ///////////////////////////////////////////// ///// Awesome Oscillator //////////////////////////////////////////// ao_group = “██████████ Awesome Oscillator ██████████” nLengthSlow = input(34, title=”Length Slow”,group=ao_group) nLengthFast = input(5, title=”Length Fast”,group=ao_group) reverse = input(false, title=”Trade reverse”,group=ao_group) xSMA1_hl2 = ta.sma(hl2, nLengthFast) xSMA2_hl2 = ta.sma(hl2, nLengthSlow) xSMA1_SMA2 = xSMA1_hl2 – xSMA2_hl2 xSMA_hl2 = ta.sma(xSMA1_SMA2, nLengthFast) nRes = xSMA1_SMA2 – xSMA_hl2 //// zero line cross (standard code) ao = ta.sma(hl2,5) – ta.sma(hl2,34) diff = ao – ao[1] ao_long = bool(na) ao_short = bool(na) if aotype == “AC Zero Line Cross” ao_long := nRes > nRes[1] and nRes > 0 ao_short := nRes < nRes[1] and nRes < 0 else if aotype == “AC Momentum Bar” ao_long := nRes > nRes[1] ao_short := nRes < nRes[1] else if aotype == “Zero Line Cross” ao_long := ao > 0 ao_short := ao < 0 ///////////////////////////////////////////// ///// WolfPack ID //////////////////////////////////////////// wolfgroup = “██████████ Wolf Pack ID ██████████” input1 = input(title=’Fast Length’, group=wolfgroup,defval=3) input2 = input(title=’Slow Length’,group=wolfgroup, defval=8) pivR = input(title=’Wolfpack Wave Pivot Lookback Right’, group=wolfgroup,defval=1) pivL = input(title=’Wolfpack Wave Pivot Lookback Left’,group=wolfgroup, defval=15) fastmaa = ta.ema(close, input1) fastmab = ta.ema(close, input2) wolfsrc = close bspread = (fastmaa – fastmab) * 1.001 adline = 0 m = bspread > 0 ? color.new(color.lime, 0) : color.new(color.red, 0) wolfup = ta.rma(math.max(ta.change(wolfsrc), 0), 3) wolfdown = ta.rma(-math.min(ta.change(wolfsrc), 0), 3) lbR = input(title=’Divergence Pivot Lookback Right’,group=wolfgroup, defval=1) lbL = input(title=’Divergence Pivot Lookback Left’, group=wolfgroup,defval=10) rangeUpper = input(title=’Max of Lookback Range’,group=wolfgroup, defval=100) rangeLower = input(title=’Min of Lookback Range’, group=wolfgroup,defval=2) osc = bspread _inRange(cond) => bars = ta.barssince(cond == true) rangeLower <= bars and bars <= rangeUpper wolf_long = bspread > 0 wolf_short = bspread < 0 ///////////////////////////////////////////// ///// Bollinger Band (BB) //////////////////////////////////////////// bb_group= “██████████ Bollinger Band ██████████” bb_length = input.int(20, minval=1) bb_maType = input.string(“SMA”, “Basis MA Type”, options = [“SMA”, “EMA”, “SMMA (RMA)”, “WMA”, “VWMA”]) bbsrc = input(close, title=”Source”) bbmult = input.float(2.0, minval=0.001, maxval=50, title=”StdDev”) bb_basis = ma(bbsrc, bb_length, bb_maType) bbdev = bbmult * ta.stdev(bbsrc, bb_length) bbupper = bb_basis + bbdev bblower = bb_basis – bbdev bboffset = input.int(0, “Offset”, minval = -500, maxval = 500) plot(switch_bb ? bb_basis:na, “Basis”, color=#FF6D00, offset = bboffset) bbp1 = plot(switch_bb ? bbupper:na, “Upper”, color=#2962FF, offset = bboffset) bbp2 = plot(switch_bb ? bblower:na, “Lower”, color=#2962FF, offset = bboffset) fillColor = switch_bb ? color.rgb(33, 150, 243, 95) : na fill(bbp1, bbp2, title = “Background”, color=fillColor) ///////////////////////////////////////////// ///// BB Oscillator //////////////////////////////////////////// bbgroup = “██████████ Bollinger Band (BB) Oscillator ██████████” bbosc_length = input.int(20, minval=1,group=bbgroup) bbosc_src = input(close, title=’Source’,group=bbgroup) bbosc_mult = input.float(2.0, minval=0.001, maxval=50, title=’StdDev’,group=bbgroup) bbosc_basis = ta.sma(bbosc_src, bbosc_length) dlength = input.int(4, minval=1, title=’Trigger Length’,group=bbgroup) bbosc_offset = input.int(0, ‘Offset’, minval=-500, maxval=500,group=bbgroup, tooltip = “Use Offset and Show Last to turn indicator into a widget.\nExample:\nOffset = 120\nShow Last = 100 “) bbosc_last = input(0, ‘Show Last’,group=bbgroup) bbosc_dev = bbosc_mult * ta.stdev(bbosc_src, bbosc_length) bbosc_upper = bbosc_basis + bbosc_dev bbosc_lower = bbosc_basis – bbosc_dev upercent = (bbosc_upper – close) / (bbosc_upper + close / 2) lpercent = (bbosc_lower – close) / (bbosc_lower + close / 2) bpercent = (bbosc_basis – close) / (bbosc_basis + close / 2) usmooth = ta.wma(upercent, 6) lsmooth = ta.wma(lpercent, 6) bsmooth = ta.wma(bpercent, 6) d1 = ta.sma(bsmooth, 2) j = (bsmooth + d1) * -1 d2 = ta.sma(j, dlength) bbosc_long = bool(na) bbosc_short = bool(na) bbcycle = 0 bbup = ta.crossover(j, usmooth) bbdown = ta.crossunder(j, lsmooth) bbcycle := bbup ? 1 : bbdown ? -1 : bbcycle[1] if bbtype == “Entering Lower/Upper Band” bbosc_long := j > d2 and (j==lsmooth or j>lsmooth) and bbcycle==-1 bbosc_short:= j < d2 and (j==usmooth or j<usmooth) and bbcycle==1 else if bbtype == “Exiting Lower/Upper Band” bbosc_long := j > d2 and (j>usmooth) bbosc_short:= j < d2 and (j<lsmooth) // //////////////////////////////////////////// // ///// Trend Meter // //////////////////////////////////////////// // tm_group = “██████████ Trend Meter ██████████” // ShowTrendBar = true // WTSetups = input.bool(true, ‘Wave Trend Filtered by Trend’, group=tm_group, inline = ‘tm’) // TMSetups = input.bool(true, ‘All 3 Trend Meters Now Align’, group=tm_group, inline = ‘tm2’) // MSBar1 = ‘Trend Filter’ // input(title= “1 – Wave Trend Signals”, defval = “Trend Filter”, options = [“N/A”, “Trend Filter”, “Filter X”, “Filter X + Trend Filter”]) // MSBar2 = ‘Trend Filter’ // input(title= “2 – Wave Trend Signals”, defval = “Filter X”, options = [“N/A”, “Trend Filter”, “Filter X”, “Filter X + Trend Filter”]) // TrendBar1 = input.string(title=’Trend Meter 1′, defval=’MACD Crossover – Fast – 8, 21, 5′, options=[‘MACD Crossover – 12, 26, 9’, ‘MACD Crossover – Fast – 8, 21, 5’, ‘Mom Dad Cross (Top Dog Trading)’, ‘RSI Signal Line Cross – RSI 13, Sig 21’, ‘RSI 13: > or < 50’, ‘RSI 5: > or < 50’, ‘Trend Candles’, ‘N/A’], group=’Trend Meters’) // “MA Crossover”, “DAD Direction (Top Dog Trading)”, // TrendBar2 = input.string(title=’Trend Meter 2′, defval=’RSI 13: > or < 50′, options=[‘MACD Crossover – 12, 26, 9’, ‘MACD Crossover – Fast – 8, 21, 5’, ‘Mom Dad Cross (Top Dog Trading)’, ‘RSI Signal Line Cross – RSI 13, Sig 21’, ‘RSI 13: > or < 50’, ‘RSI 5: > or < 50’, ‘Trend Candles’, ‘N/A’], group=’Trend Meters’) // “MA Crossover”, “DAD Direction (Top Dog Trading)”, // TrendBar3 = input.string(title=’Trend Meter 3′, defval=’RSI 5: > or < 50′, options=[‘MACD Crossover – 12, 26, 9’, ‘MACD Crossover – Fast – 8, 21, 5’, ‘Mom Dad Cross (Top Dog Trading)’, ‘RSI Signal Line Cross – RSI 13, Sig 21’, ‘RSI 13: > or < 50’, ‘RSI 5: > or < 50’, ‘Trend Candles’, ‘N/A’], group=’Trend Meters’) // “MA Crossover”, “DAD Direction (Top Dog Trading)”, // TrendBar4 = input.string(title=’Trend Bar 1′, defval=’MA Crossover’, options=[‘MA Crossover’, ‘MA Direction – Fast MA – TB1’, ‘MA Direction – Slow MA – TB1’, ‘N/A’], group=’Trend Bars’) // “MACD Crossover – 12, 26 9”, “MACD Crossover – Fast – 8, 21, 5”, “DAD Direction (Top Dog Trading)”, // TrendBar5 = input.string(title=’Trend Bar 2′, defval=’MA Crossover’, options=[‘MA Crossover’, ‘MA Direction – Fast MA – TB2’, ‘MA Direction – Slow MA – TB2’, ‘N/A’], group=’Trend Bars’) // “MACD Crossover – 12, 26 9”, “MACD Crossover – Fast – 8, 21, 5”, “DAD Direction (Top Dog Trading)”, // ////////////////Signals – Wave Trend///////////////////////////////////////////////////////////////////////////////////////////////// // // Wave Trend – RSI // RSIMC = ta.rsi(close, 14) // // Wave Trend // ap = hlc3 // input(hlc3, “Wave Trend – Source”) // n1 = 9 //input(9, “Wave Trend – WT Channel Length”) // n2 = 12 // input(12, “Wave Trend – WT Average Length”) // esa = ta.ema(ap, n1) // de = ta.ema(math.abs(ap – esa), n1) // ci = (ap – esa) / (0.015 * de) // tci = ta.ema(ci, n2) // wt11 = tci // wt22 = ta.sma(wt11, 3) // // Wave Trend – Overbought & Oversold lines // obLevel2 = 60 // input( 60, “Wave Trend – WT Very Overbought”) // obLevel = 50 // input( 50, “Wave Trend – WT Overbought”) // osLevel = -50 // input(-50, “Wave Trend – WT Oversold”) // osLevel2 = -60 // input(-60, “Wave Trend – WT Very Oversold”) // // Wave Trend – Conditions // WTCross = ta.cross(wt11, wt22) // WTCrossUp = wt22 – wt11 <= 0 // WTCrossDown = wt22 – wt11 >= 0 // WTOverSold = wt22 <= osLevel2 // WTOverBought = wt22 >= obLevel2 // // MA Inputs // MA1_Length = input.int(5, title=’Fast MA’, minval=1, group=’Trend Bar 1 – Settings’, inline=’TB1 Fast’) // MA1_Type = input.string(title=”, defval=’EMA’, options=[‘EMA’, ‘SMA’], group=’Trend Bar 1 – Settings’, inline=’TB1 Fast’) // MA2_Length = input.int(11, title=’Slow MA’, minval=1, group=’Trend Bar 1 – Settings’, inline=’TB1 Slow’) // MA2_Type = input.string(title=”, defval=’EMA’, options=[‘EMA’, ‘SMA’], group=’Trend Bar 1 – Settings’, inline=’TB1 Slow’) // MA3_Length = input.int(9, title=’Fast MA’, minval=1, group=’Trend Bar 2 – Settings’, inline=’TB2 Fast’) // MA3_Type = input.string(title=”, defval=’EMA’, options=[‘EMA’, ‘SMA’], group=’Trend Bar 2 – Settings’, inline=’TB2 Fast’) // MA4_Length = input.int(21, title=’Slow MA’, minval=1, group=’Trend Bar 2 – Settings’, inline=’TB2 Slow’) // MA4_Type = input.string(title=”, defval=’SMA’, options=[‘EMA’, ‘SMA’], group=’Trend Bar 2 – Settings’, inline=’TB2 Slow’) // // MA Calculations // Close = request.security(syminfo.tickerid, timeframe.period, close, lookahead=barmerge.lookahead_on) // MA1 = if MA1_Type == ‘SMA’ // ta.sma(Close, MA1_Length) // else // ta.ema(Close, MA1_Length) // MA2 = if MA2_Type == ‘SMA’ // ta.sma(Close, MA2_Length) // else // ta.ema(Close, MA2_Length) // MA3 = if MA3_Type == ‘SMA’ // ta.sma(Close, MA3_Length) // else // ta.ema(Close, MA3_Length) // MA4 = if MA4_Type == ‘SMA’ // ta.sma(Close, MA4_Length) // else // ta.ema(Close, MA4_Length) // // MA Crossover Condition // MACrossover1 = MA1 > MA2 ? 1 : 0 // MACrossover2 = MA3 > MA4 ? 1 : 0 // // MA Direction Condition // MA1Direction = MA1 > MA1[1] ? 1 : 0 // MA2Direction = MA2 > MA2[1] ? 1 : 0 // MA3Direction = MA3 > MA3[1] ? 1 : 0 // MA4Direction = MA4 > MA4[1] ? 1 : 0 // // MA Direction Change Condition // MA1PositiveDirectionChange = MA1Direction and not MA1Direction[1] ? 1 : 0 // MA2PositiveDirectionChange = MA2Direction and not MA2Direction[1] ? 1 : 0 // MA3PositiveDirectionChange = MA3Direction and not MA3Direction[1] ? 1 : 0 // MA4PositiveDirectionChange = MA4Direction and not MA4Direction[1] ? 1 : 0 // MA1NegativeDirectionChange = not MA1Direction and MA1Direction[1] ? 1 : 0 // MA2NegativeDirectionChange = not MA2Direction and MA2Direction[1] ? 1 : 0 // MA3NegativeDirectionChange = not MA3Direction and MA3Direction[1] ? 1 : 0 // MA4NegativeDirectionChange = not MA4Direction and MA4Direction[1] ? 1 : 0 // // MACD and MOM & DAD – Top Dog Trading // // Standard MACD Calculations // MACDfastMA = 12 // MACDslowMA = 26 // MACDsignalSmooth = 9 // MACDLine = ta.ema(close, MACDfastMA) – ta.ema(close, MACDslowMA) // SignalLine = ta.ema(MACDLine, MACDsignalSmooth) // MACDHistogram = MACDLine – SignalLine // // MACD- Background Color Change Condition // MACDHistogramCross = MACDHistogram > 0 ? 1 : 0 // MACDLineOverZero = MACDLine > 0 ? 1 : 0 // MACDLineOverZeroandHistogramCross = MACDHistogramCross and MACDLineOverZero ? 1 : 0 // MACDLineUnderZeroandHistogramCross = not MACDHistogramCross and not MACDLineOverZero ? 1 : 0 // // Fast MACD Calculations // FastMACDfastMA = 8 // FastMACDslowMA = 21 // FastMACDsignalSmooth = 5 // FastMACDLine = ta.ema(close, FastMACDfastMA) – ta.ema(close, FastMACDslowMA) // FastSignalLine = ta.ema(FastMACDLine, FastMACDsignalSmooth) // FastMACDHistogram = FastMACDLine – FastSignalLine // // Fast MACD- Background Color Change Condition // FastMACDHistogramCross = FastMACDHistogram > 0 ? 1 : 0 // FastMACDLineOverZero = FastMACDLine > 0 ? 1 : 0 // FastMACDLineOverZeroandHistogramCross = FastMACDHistogramCross and FastMACDLineOverZero ? 1 : 0 // FastMACDLineUnderZeroandHistogramCross = not FastMACDHistogramCross and not FastMACDLineOverZero ? 1 : 0 // // Top Dog Trading – Mom Dad Calculations // TopDog_Fast_MA = 5 // TopDog_Slow_MA = 20 // TopDog_Sig = 30 // TopDogMom = ta.ema(close, TopDog_Fast_MA) – ta.ema(close, TopDog_Slow_MA) // TopDogDad = ta.ema(TopDogMom, TopDog_Sig) // // Top Dog Dad – Background Color Change Condition // TopDogDadDirection = TopDogDad > TopDogDad[1] ? 1 : 0 // TopDogMomOverDad = TopDogMom > TopDogDad ? 1 : 0 // TopDogMomOverZero = TopDogMom > 0 ? 1 : 0 // ////// Trend Barmeter Calculations ////// // haclose_tm = ohlc4 // haopen_tm = 0.0 // haopen_tm := na(haopen_tm[1]) ? (open + close) / 2 : (haopen_tm[1] + haclose_tm[1]) / 2 // // RSI 5 Trend Barmeter Calculations // RSI5 = ta.rsi(close, 5) // RSI5Above50 = RSI5 > 50 ? 1 : 0 // // RSI 5 Trend Barmeter Calculations // RSI13 = ta.rsi(close, 13) // // Linear Regression Calculation For RSI Signal Line // SignalLineLength1 = 21 // x = bar_index // y = RSI13 // x_ = ta.sma(x, SignalLineLength1) // y_ = ta.sma(y, SignalLineLength1) // mx = ta.stdev(x, SignalLineLength1) // my = ta.stdev(y, SignalLineLength1) // c = ta.correlation(x, y, SignalLineLength1) // slope = c * (my / mx) // inter = y_ – slope * x_ // LinReg1 = x * slope + inter // RSISigDirection = LinReg1 > LinReg1[1] ? 1 : 0 // RSISigCross = RSI13 > LinReg1 ? 1 : 0 // RSI13Above50 = RSI13 > 50 ? 1 : 0 // TrendBar1Result = TrendBar1 == ‘MA Crossover’ ? MACrossover1 : TrendBar1 == ‘MACD Crossover – 12, 26, 9’ ? MACDHistogramCross : TrendBar1 == ‘MACD Crossover – Fast – 8, 21, 5’ ? FastMACDHistogramCross : TrendBar1 == ‘Mom Dad Cross (Top Dog Trading)’ ? TopDogMomOverDad : TrendBar1 == ‘DAD Direction (Top Dog Trading)’ ? TopDogDadDirection : TrendBar1 == ‘RSI Signal Line Cross – RSI 13, Sig 21’ ? RSISigCross : TrendBar1 == ‘RSI 5: > or < 50’ ? RSI5Above50 : TrendBar1 == ‘RSI 13: > or < 50’ ? RSI13Above50 : na // TrendBar2Result = TrendBar2 == ‘MA Crossover’ ? MACrossover1 : TrendBar2 == ‘MACD Crossover – 12, 26, 9’ ? MACDHistogramCross : TrendBar2 == ‘MACD Crossover – Fast – 8, 21, 5’ ? FastMACDHistogramCross : TrendBar2 == ‘Mom Dad Cross (Top Dog Trading)’ ? TopDogMomOverDad : TrendBar2 == ‘DAD Direction (Top Dog Trading)’ ? TopDogDadDirection : TrendBar2 == ‘RSI Signal Line Cross – RSI 13, Sig 21’ ? RSISigCross : TrendBar2 == ‘RSI 5: > or < 50’ ? RSI5Above50 : TrendBar2 == ‘RSI 13: > or < 50’ ? RSI13Above50 : na // TrendBar3Result = TrendBar3 == ‘MA Crossover’ ? MACrossover1 : TrendBar3 == ‘MACD Crossover – 12, 26, 9’ ? MACDHistogramCross : TrendBar3 == ‘MACD Crossover – Fast – 8, 21, 5’ ? FastMACDHistogramCross : TrendBar3 == ‘Mom Dad Cross (Top Dog Trading)’ ? TopDogMomOverDad : TrendBar3 == ‘DAD Direction (Top Dog Trading)’ ? TopDogDadDirection : TrendBar3 == ‘RSI Signal Line Cross – RSI 13, Sig 21’ ? RSISigCross : TrendBar3 == ‘RSI 5: > or < 50’ ? RSI5Above50 : TrendBar3 == ‘RSI 13: > or < 50’ ? RSI13Above50 : na // FilterXUp = FastMACDHistogramCross and ta.ema(close, 15) > ta.ema(close, 15)[1] // FilterXDown = not FastMACDHistogramCross and ta.ema(close, 15) < ta.ema(close, 15)[1] // TrendFilterPlus = ta.ema(close, 15) > ta.ema(close, 20) and ta.ema(close, 20) > ta.ema(close, 30) and ta.ema(close, 30) > ta.ema(close, 40) and ta.ema(close, 40) > ta.ema(close, 50) ? 1 : 0 // TrendFilterMinus = ta.ema(close, 15) < ta.ema(close, 20) and ta.ema(close, 20) < ta.ema(close, 30) and ta.ema(close, 30) < ta.ema(close, 40) and ta.ema(close, 40) < ta.ema(close, 50) ? 1 : 0 // MSBar1PositiveWaveTrendSignal = MSBar1 == ‘Filter X’ ? FilterXUp and WTCross and WTCrossUp : MSBar1 == ‘Trend Filter’ ? TrendFilterPlus and WTCross and WTCrossUp : MSBar1 == ‘Filter X + Trend Filter’ ? FilterXUp and TrendFilterPlus and WTCross and WTCrossUp : WTCross and WTCrossUp // MSBar1NegativeWaveTrendSignal = MSBar1 == ‘Filter X’ ? FilterXDown and WTCross and WTCrossDown : MSBar1 == ‘Trend Filter’ ? TrendFilterMinus and WTCross and WTCrossDown : MSBar1 == ‘Filter X + Trend Filter’ ? FilterXDown and TrendFilterMinus and WTCross and WTCrossDown : WTCross and WTCrossDown // MSBar2PositiveWaveTrendSignal = MSBar2 == ‘Filter X’ ? FilterXUp and WTCross and WTCrossUp : MSBar2 == ‘Trend Filter’ ? TrendFilterPlus and WTCross and WTCrossUp : MSBar2 == ‘Filter X + Trend Filter’ ? FilterXUp and TrendFilterPlus and WTCross and WTCrossUp : WTCross and WTCrossUp // MSBar2NegativeWaveTrendSignal = MSBar2 == ‘Filter X’ ? FilterXDown and WTCross and WTCrossDown : MSBar2 == ‘Trend Filter’ ? TrendFilterMinus and WTCross and WTCrossDown : MSBar2 == ‘Filter X + Trend Filter’ ? FilterXDown and TrendFilterMinus and WTCross and WTCrossDown : WTCross and WTCrossDown // /////////////////////////////////////////////////////////////////////////////////////////////////////////////// // CrossoverType2 = TrendBar4 == ‘DAD Direction (Top Dog Trading)’ ? TopDogDadDirection : TrendBar4 == ‘MACD Crossover’ ? MACDHistogramCross : TrendBar4 == ‘MA Direction – Fast MA – TB1’ ? MA1Direction : TrendBar4 == ‘MA Direction – Slow MA – TB1’ ? MA2Direction : MACrossover1 // CrossoverType3 = TrendBar5 == ‘DAD Direction (Top Dog Trading)’ ? TopDogDadDirection : TrendBar5 == ‘MACD Crossover’ ? MACDHistogramCross : TrendBar5 == ‘MA Direction – Fast MA – TB2’ ? MA3Direction : TrendBar5 == ‘MA Direction – Slow MA – TB2′ ? MA4Direction : MACrossover2 // MaxValueMACrossUp = ta.crossover(ta.ema(Close, 5), ta.ema(Close, 11)) // MaxValueMACrossDown = ta.crossunder(ta.ema(Close, 5), ta.ema(Close, 11)) // TB1MACrossUp = ta.crossover(MA1, MA2) // TB1MACrossDown = ta.crossunder(MA1, MA2) // TB2MACrossUp = ta.crossover(MA3, MA4) // TB2MACrossDown = ta.crossunder(MA3, MA4) // TB1Green = MA1 > MA2 // TB1Red = MA1 < MA2 // TB2Green = MA3 > MA4 // TB2Red = MA3 < MA4 // TB12Green = TB1Green and TB2Green and (TB1MACrossUp or TB2MACrossUp) // TB12Red = TB1Red and TB2Red and (TB1MACrossDown or TB2MACrossDown) ///////////////////////////////// /////// Stochastic ///////////////////////////////// groupname = “██████████ Stochastic ██████████” len = input.int(14, minval=1, title=”Length”,group=groupname) smoothK = input.int(3, minval=1, title=”K Smoothing”,group=groupname) smoothD = input.int(3, minval=1, title=”D Smoothing”,group=groupname) upLine = input.int(80, minval=50, maxval=90, title=”Overbought level”,group=groupname) lowLine = input.int(20, minval=10, maxval=50, title=”Oversold level”,group=groupname) //Resolutioon for MTF resstoch = timeframe.period //Stoch formula kk = ta.sma(ta.stoch(close, high, low, len), smoothK) dd = ta.sma(kk, smoothD) outK = request.security(syminfo.tickerid, resstoch, kk) outD = request.security(syminfo.tickerid, resstoch, dd) //definitions for Cross aboveLine = outK > upLine ? 1 : 0 belowLine = outK < lowLine ? 1 : 0 stoch_long = bool (na) stoch_short = bool (na) if stochtype == “CrossOver” stoch_long := (outK[1] < outD[1] and outK > outD) ? 1 : 0 stoch_short := (outK[1] > outD[1] and outK < outD) ? 1 : 0 else if stochtype == “CrossOver in OB & OS levels” stoch_long := (outK[1] < outD[1] and outK[1] < lowLine[1]) and (outK > outD) and outK > lowLine? 1 : 0 stoch_short := (outK[1] > outD[1] and outK[1] > upLine[1]) and (outK < outD) and outK < upLine? 1 : 0 else if stochtype == “%K above/below %D” stoch_long := outK > outD stoch_short := outK < outD /////////////////////////////////////////////// ///////RSI /////////////////////////////////////////////// rsi_group = “█████████████████ RSI █████████████████” rsiLengthInput = input.int(14, minval=1, title=”RSI Length”, group=rsi_group) rsiSourceInput = input.source(close, “Source”, group=rsi_group) maTypeInput = input.string(“SMA”, title=”MA Type”, options=[“SMA”, “Bollinger Bands”, “EMA”, “SMMA (RMA)”, “WMA”, “VWMA”], group=rsi_group) rsi_upper = input.int(defval=80, title=’Overbought Zone’, group=rsi_group, inline=’zone’) rsi_lower = input.int(defval=20, title=’Oversold Zone’, group=rsi_group, inline=’zone’) respectrsilevel = input.int(defval=50, minval=1, title=’RSI MidLine’, group=rsi_group) maLengthInput = input.int(14, title=”MA Length”, group=rsi_group) up = ta.rma(math.max(ta.change(rsiSourceInput), 0), rsiLengthInput) down = ta.rma(-math.min(ta.change(rsiSourceInput), 0), rsiLengthInput) rsi = down == 0 ? 100 : up == 0 ? 0 : 100 – (100 / (1 + up / down)) rsiMA = ma(rsi, maLengthInput, maTypeInput) isBB = maTypeInput == “Bollinger Bands” /////////////////////////////////////////////// /// HULL SUITE ////////////////////////////////////////////// hull_group = “██████████ HullSuite ██████████” //INPUT hullsrc = input(close, title=’Source’,group=hull_group) modeSwitch = input.string(‘Hma’, title=’Hull Variation’, options=[‘Hma’, ‘Thma’, ‘Ehma’],group=hull_group) hull_length = input(55, title=’hull_length(180-200 for floating S/R , 55 for swing entry)’,group=hull_group) hull_lengthMult = input(1.0, title=’hull_length multiplier (Used to view higher timeframes with straight band)’,group=hull_group) useHtf = input(false, title=’Show Hull MA from X timeframe? (good for scalping)’,group=hull_group) htf = input.timeframe(‘240′, title=’Higher timeframe’,group=hull_group) //FUNCTIONS //HMA HMA(_hullsrc, _hull_length) => ta.wma(2 * ta.wma(_hullsrc, _hull_length / 2) – ta.wma(_hullsrc, _hull_length), math.round(math.sqrt(_hull_length))) //EHMA EHMA(_hullsrc, _hull_length) => ta.ema(2 * ta.ema(_hullsrc, _hull_length / 2) – ta.ema(_hullsrc, _hull_length), math.round(math.sqrt(_hull_length))) //THMA THMA(_hullsrc, _hull_length) => ta.wma(ta.wma(_hullsrc, _hull_length / 3) * 3 – ta.wma(_hullsrc, _hull_length / 2) – ta.wma(_hullsrc, _hull_length), _hull_length) //SWITCH Mode(modeSwitch, hullsrc, len) => modeSwitch == ‘Hma’ ? HMA(hullsrc, len) : modeSwitch == ‘Ehma’ ? EHMA(hullsrc, len) : modeSwitch == ‘Thma’ ? THMA(hullsrc, len / 2) : na //OUT _hull = Mode(modeSwitch, hullsrc, int(hull_length * hull_lengthMult)) HULL = useHtf ? request.security(syminfo.ticker, htf, _hull) : _hull MHULL = HULL[0] SHULL = HULL[2] //COLOR // hullColor = switchColor ? HULL > HULL[2] ? #00ff00 : #ff0000 : #ff9800 ///////////////////////// /// STC overlay signal ///////////////////////// stc_group = “██████████ Schaff Trend Cycle (STC) ██████████” fastLength = input(title=’MACD Fast Length’, defval=23, group=stc_group) slowLength = input(title=’MACD Slow Length’, defval=50, group=stc_group) cycleLength = input(title=’Cycle Length’, defval=10, group=stc_group) d1Length = input(title=’1st %D Length’, defval=3, group=stc_group) d2Length = input(title=’2nd %D Length’, defval=3, group=stc_group) srcstc = input(title=’Source’, defval=close, group=stc_group) upper = input(title=’Upper Band’, defval=75, group=stc_group) lower = input(title=’Lower Band’, defval=25, group=stc_group) v_show_last = input(2000, “Plotting Length”, group=stc_group) macd = ta.ema(srcstc, fastLength) – ta.ema(srcstc, slowLength) k = nz(fixnan(ta.stoch(macd, macd, macd, cycleLength))) d = ta.ema(k, d1Length) kd = nz(fixnan(ta.stoch(d, d, d, cycleLength))) stc = ta.ema(kd, d2Length) stc := math.max(math.min(stc, 100), 0) stcColor1 = stc > stc[1] ? color.green : color.red stcColor2 = stc > upper ? color.green : stc <= lower ? color.red : color.orange upperCrossover = ta.crossover(stc, upper) upperCrossunder = ta.crossunder(stc, upper) lowerCrossover = ta.crossover(stc, lower) lowerCrossunder = ta.crossunder(stc, lower) stcup = stc >= upper stcdown = stc <= lower plotshape(stcdown and switch_stc? true :na, style=shape.circle, location=location.top , show_last = v_show_last, color=color.new(color.red, 0), title=’STC Sell’) plotshape(stcup and switch_stc? true:na, style=shape.circle, location=location.top, show_last = v_show_last, color=color.new(color.green, 0), title=’STC Buy’) ////////////////////////////////////////////////////// //vector candles ///////////////////////////////////////////////////// // Indicator Settings pvsra_group=”██████████ PVSRA ██████████” var overideCandleColours = input.bool(title=’Override Candles with PVSRA Colour’, defval=true, tooltip=”Indicator must be dragged to the top of the Object Tree to display correctly”, group=pvsra_group) var bool override_imnt = input.bool(defval=false, title=”Overide Symbol”, group=pvsra_group, inline=”0″) var string pvsra_sym = input.symbol(title=””, defval=”BINANCE:BTCUSDTPERP”, group=pvsra_group, inline=”0″) var Bull200CandleColor = input.color(color.new(color.lime, 0), title=”200% Volume”, group=pvsra_group, inline=”1″) var Bear200CandleColor = input.color(color.new(color.red, 0), title=””, group=pvsra_group, inline = “1”) var Bull150CandleColor = input.color(color.new(color.blue, 0), title=”150% Volume”, group=pvsra_group, inline=”2″) var Bear150CandleColor = input.color(color.new(color.fuchsia, 0), title=””, group=pvsra_group, inline=”2″) var BullNormCandleColor = input.color(color.new(#999999, 0), title=”Norm Volume”, group=pvsra_group, inline=”3″) var BearNormCandleColor = input.color(color.new(#4d4d4d, 0), title=””, group=pvsra_group, inline=”3″) var color candleColor = na var color imbalanceColor = na var color imbalancedLineColor = na var color NO_COLOR = na var bool chartIs120MinOrMore = false // Logic to reference another Instruments Volume Profile pvsra_imnt(sresolution,sseries) => request.security(override_imnt ? pvsra_sym : syminfo.tickerid ,sresolution,sseries, barmerge.gaps_off,barmerge.lookahead_off) volume_imnt = override_imnt == true? pvsra_imnt(“”,volume): volume high_imnt = override_imnt == true? pvsra_imnt(“”,high): high low_imnt = override_imnt == true? pvsra_imnt(“”,low): low close_imnt = override_imnt == true? pvsra_imnt(“”,close): close open_imnt = override_imnt == true? pvsra_imnt(“”,open): open av = ta.sma(volume_imnt, 10)//sum_2 = math.sum(volume, 10) value2 = volume_imnt * (high_imnt – low_imnt) hivalue2 = ta.highest(value2, 10) imnt_override_pvsra_calc_part2 = volume_imnt >= av * 1.5 ? 2 : 0 va = volume_imnt >= av * 2 or value2 >= hivalue2 ? 1 : imnt_override_pvsra_calc_part2 // Bull or bear Candle Colors isBull = close_imnt > open_imnt var bool is200Bull = na var bool is150Bull = na var bool is100Bull = na var bool is200Bear = na var bool is150Bear = na var bool is100Bear = na if isBull if va == 1 candleColor := Bull200CandleColor is200Bull := true else if va == 2 candleColor := Bull150CandleColor is150Bull := true else is200Bull := false is150Bull := false candleColor := BullNormCandleColor imbalanceColor := na imbalancedLineColor := na else if va == 1 candleColor := Bear200CandleColor is200Bear := true else if va == 2 candleColor := Bear150CandleColor is150Bear := true else is200Bear := false is150Bear := false candleColor := BearNormCandleColor imbalanceColor := na imbalancedLineColor := na barcolor(overideCandleColours and switch_pvsra ? candleColor : NO_COLOR) plotcandle(open, high, low, close, color=(overideCandleColours and switch_pvsra ? candleColor : NO_COLOR), wickcolor=(overideCandleColours and switch_pvsra? candleColor : NO_COLOR), bordercolor=(overideCandleColours and switch_pvsra? candleColor : NO_COLOR), display = display.all) /////////////////////////////////////////////////// //////// SUpply/Demand POI ////////////////////////////////////////////////// // INDICATOR SETTINGS poi_group = ‘██████████ Supply/Demand Zone ██████████’ swing_length = input.int(10, title = ‘Swing High/Low Length’, group = poi_group, minval = 1, maxval = 50) history_of_demand_to_keep = input.int(20, title = ‘History To Keep’, minval = 5, maxval = 50, group = poi_group) box_width = input.float(2.5, title = ‘Supply/Demand Box Width’, group = poi_group, minval = 1, maxval = 10, step = 0.5) // INDICATOR VISUAL SETTINGS show_zigzag = input.bool(false, title = ‘Show Zig Zag’, group = ‘Visual Settings’, inline = ‘1’) show_price_action_labels = input.bool(false, title = ‘Show Price Action Labels’, group = ‘Visual Settings’, inline = ‘2’) supply_color = input.color(color.new(#EDEDED,70), title = ‘Supply’, group = ‘Visual Settings’, inline = ‘3’) supply_outline_color = input.color(color.new(color.white,100), title = ‘Outline’, group = ‘Visual Settings’, inline = ‘3’) demand_color = input.color(color.new(#00FFFF,70), title = ‘Demand’, group = ‘Visual Settings’, inline = ‘4’) demand_outline_color = input.color(color.new(color.white,100), title = ‘Outline’, group = ‘Visual Settings’, inline = ‘4’) poi_label_color = input.color(color.white, title = ‘POI Label’, group = ‘Visual Settings’, inline = ‘7’) swing_type_color = input.color(color.black, title = ‘Price Action Label’, group = ‘Visual Settings’, inline = ‘8’) zigzag_color = input.color(color.new(#000000,0), title = ‘Zig Zag’, group = ‘Visual Settings’, inline = ‘9’) // //END SETTINGS // atrpoi = ta.atr(50) // //FUNCTIONS // // FUNCTION TO ADD NEW AND REMOVE LAST IN ARRAY f_array_add_pop(array, new_value_to_add) => array.unshift(array, new_value_to_add) array.pop(array) // FUNCTION SWING H & L LABELS f_sh_sl_labels(array, swing_type) => var string label_text = na if swing_type == 1 if array.get(array, 0) >= array.get(array, 1) label_text := ‘HH’ else label_text := ‘LH’ label.new(bar_index – swing_length, array.get(array,0), text = label_text, style=label.style_label_down, textcolor = swing_type_color, color = color.new(swing_type_color, 100), size = size.tiny) else if swing_type == -1 if array.get(array, 0) >= array.get(array, 1) label_text := ‘HL’ else label_text := ‘LL’ label.new(bar_index – swing_length, array.get(array,0), text = label_text, style=label.style_label_up, textcolor = swing_type_color, color = color.new(swing_type_color, 100), size = size.tiny) // FUNCTION MAKE SURE SUPPLY ISNT OVERLAPPING f_check_overlapping(new_poi, box_array, atrpoi) => atr_threshold = atrpoi * 2 okay_to_draw = true for i = 0 to array.size(box_array) – 1 top = box.get_top(array.get(box_array, i)) bottom = box.get_bottom(array.get(box_array, i)) poi = (top + bottom) / 2 upper_boundary = poi + atr_threshold lower_boundary = poi – atr_threshold if new_poi >= lower_boundary and new_poi <= upper_boundary okay_to_draw := false break else okay_to_draw := true okay_to_draw // FUNCTION TO DRAW SUPPLY OR DEMAND ZONE f_supply_demand(value_array, bn_array, box_array, label_array, box_type, atrpoi) => atr_buffer = atrpoi * (box_width / 10) box_left = array.get(bn_array, 0) box_right = bar_index var float box_top = 0.00 var float box_bottom = 0.00 var float poi = 0.00 if box_type == 1 box_top := array.get(value_array, 0) box_bottom := box_top – atr_buffer poi := (box_top + box_bottom) / 2 else if box_type == -1 box_bottom := array.get(value_array, 0) box_top := box_bottom + atr_buffer poi := (box_top + box_bottom) / 2 okay_to_draw = f_check_overlapping(poi, box_array, atrpoi) // okay_to_draw = true //delete oldest box, and then create a new box and add it to the array if box_type == 1 and okay_to_draw and switch_poi box.delete( array.get(box_array, array.size(box_array) – 1) ) f_array_add_pop(box_array, box.new( left = box_left, top = box_top, right = box_right, bottom = box_bottom, border_color = supply_outline_color, bgcolor = supply_color, extend = extend.right, text = ‘SUPPLY’, text_halign = text.align_center, text_valign = text.align_center, text_color = poi_label_color, text_size = size.small, xloc = xloc.bar_index)) box.delete( array.get(label_array, array.size(label_array) – 1) ) f_array_add_pop(label_array, box.new( left = box_left, top = poi, right = box_right, bottom = poi, border_color = color.new(poi_label_color,90), bgcolor = color.new(poi_label_color,90), extend = extend.right, text = ‘POI’, text_halign = text.align_left, text_valign = text.align_center, text_color = poi_label_color, text_size = size.small, xloc = xloc.bar_index)) else if box_type == -1 and okay_to_draw and switch_poi box.delete( array.get(box_array, array.size(box_array) – 1) ) f_array_add_pop(box_array, box.new( left = box_left, top = box_top, right = box_right, bottom = box_bottom, border_color = demand_outline_color, bgcolor = demand_color, extend = extend.right, text = ‘DEMAND’, text_halign = text.align_center, text_valign = text.align_center, text_color = poi_label_color, text_size = size.small, xloc = xloc.bar_index)) box.delete( array.get(label_array, array.size(label_array) – 1) ) f_array_add_pop(label_array, box.new( left = box_left, top = poi, right = box_right, bottom = poi, border_color = color.new(poi_label_color,90), bgcolor = color.new(poi_label_color,90), extend = extend.right, text = ‘POI’, text_halign = text.align_left, text_valign = text.align_center, text_color = poi_label_color, text_size = size.small, xloc = xloc.bar_index)) // FUNCTION TO CHANGE SUPPLY/DEMAND TO A BOS IF BROKEN f_sd_to_bos(box_array, bos_array, label_array, zone_type) => if zone_type == 1 and switch_poi for i = 0 to array.size(box_array) – 1 level_to_break = box.get_top(array.get(box_array,i)) // if ta.crossover(close, level_to_break) if close >= level_to_break copied_box = box.copy(array.get(box_array,i)) f_array_add_pop(bos_array, copied_box) mid = (box.get_top(array.get(box_array,i)) + box.get_bottom(array.get(box_array,i))) / 2 box.set_top(array.get(bos_array,0), mid) box.set_bottom(array.get(bos_array,0), mid) box.set_extend( array.get(bos_array,0), extend.none) box.set_right( array.get(bos_array,0), bar_index) box.set_text( array.get(bos_array,0), ” ) box.set_text_color( array.get(bos_array,0), color.new(color.white, 0)) box.set_text_size( array.get(bos_array,0), size.small) box.set_text_halign( array.get(bos_array,0), text.align_center) box.set_text_valign( array.get(bos_array,0), text.align_center) box.delete(array.get(box_array, i)) box.delete(array.get(label_array, i)) if zone_type == -1 and switch_poi for i = 0 to array.size(box_array) – 1 level_to_break = box.get_bottom(array.get(box_array,i)) // if ta.crossunder(close, level_to_break) if close <= level_to_break copied_box = box.copy(array.get(box_array,i)) f_array_add_pop(bos_array, copied_box) mid = (box.get_top(array.get(box_array,i)) + box.get_bottom(array.get(box_array,i))) / 2 box.set_top(array.get(bos_array,0), mid) box.set_bottom(array.get(bos_array,0), mid) box.set_extend( array.get(bos_array,0), extend.none) box.set_right( array.get(bos_array,0), bar_index) box.set_text( array.get(bos_array,0), ” ) box.set_text_color( array.get(bos_array,0), color.new(color.white, 0)) box.set_text_size( array.get(bos_array,0), size.small) box.set_text_halign( array.get(bos_array,0), text.align_center) box.set_text_valign( array.get(bos_array,0), text.align_center) box.delete(array.get(box_array, i)) box.delete(array.get(label_array, i)) // FUNCTION MANAGE CURRENT BOXES BY CHANGING ENDPOINT f_extend_box_endpoint(box_array) => for i = 0 to array.size(box_array) – 1 box.set_right(array.get(box_array, i), bar_index + 100) // CALCULATE SWING HIGHS & SWING LOWS swing_high = ta.pivothigh(high, swing_length, swing_length) swing_low = ta.pivotlow(low, swing_length, swing_length) // ARRAYS FOR SWING H/L & BN var swing_high_values = array.new_float(5,0.00) var swing_low_values = array.new_float(5,0.00) var swing_high_bns = array.new_int(5,0) var swing_low_bns = array.new_int(5,0) // ARRAYS FOR SUPPLY / DEMAND var current_supply_box = array.new_box(history_of_demand_to_keep, na) var current_demand_box = array.new_box(history_of_demand_to_keep, na) // ARRAYS FOR SUPPLY / DEMAND POI LABELS var current_supply_poi = array.new_box(history_of_demand_to_keep, na) var current_demand_poi = array.new_box(history_of_demand_to_keep, na) // ARRAYS FOR BOS var supply_bos = array.new_box(5, na) var demand_bos = array.new_box(5, na) // //END CALCULATIONS // // NEW SWING HIGH if not na(swing_high) //MANAGE SWING HIGH VALUES f_array_add_pop(swing_high_values, swing_high) f_array_add_pop(swing_high_bns, bar_index[swing_length]) if show_price_action_labels f_sh_sl_labels(swing_high_values, 1) f_supply_demand(swing_high_values, swing_high_bns, current_supply_box, current_supply_poi, 1, atrpoi) // NEW SWING LOW else if not na(swing_low) //MANAGE SWING LOW VALUES f_array_add_pop(swing_low_values, swing_low) f_array_add_pop(swing_low_bns, bar_index[swing_length]) if show_price_action_labels f_sh_sl_labels(swing_low_values, -1) f_supply_demand(swing_low_values, swing_low_bns, current_demand_box, current_demand_poi, -1, atrpoi) f_sd_to_bos(current_supply_box, supply_bos, current_supply_poi, 1) f_sd_to_bos(current_demand_box, demand_bos, current_demand_poi, -1) f_extend_box_endpoint(current_supply_box) f_extend_box_endpoint(current_demand_box) //ZIG ZAG h = ta.highest(high, swing_length * 2 + 1) l = ta.lowest(low, swing_length * 2 + 1) f_isMin(len) => l == low[len] f_isMax(len) => h == high[len] var dirUp = false var lastLow = high * 100 var lastHigh = 0.0 var timeLow = bar_index var timeHigh = bar_index var line li = na f_drawLine() => _li_color = show_zigzag and switch_poi ? zigzag_color : color.new(#ffffff,100) line.new(timeHigh – swing_length, lastHigh, timeLow – swing_length, lastLow, xloc.bar_index, color=_li_color, width=2) if dirUp if f_isMin(swing_length) and low[swing_length] < lastLow lastLow := low[swing_length] timeLow := bar_index line.delete(li) li := f_drawLine() li if f_isMax(swing_length) and high[swing_length] > lastLow lastHigh := high[swing_length] timeHigh := bar_index dirUp := false li := f_drawLine() li if not dirUp if f_isMax(swing_length) and high[swing_length] > lastHigh lastHigh := high[swing_length] timeHigh := bar_index line.delete(li) li := f_drawLine() li if f_isMin(swing_length) and low[swing_length] < lastHigh lastLow := low[swing_length] timeLow := bar_index dirUp := true li := f_drawLine() if f_isMax(swing_length) and high[swing_length] > lastLow lastHigh := high[swing_length] timeHigh := bar_index dirUp := false li := f_drawLine() li /////////////////////////////////////////////////// ///////// Heiken Ashi Candle //////////////////////////////////////////////////// hagroup = “███████ Heiken-ashi candles ███████” hkClose = (open + high + low + close) / 4 hkOpen = float(na) hkOpen := na(hkOpen[1]) ? (open + close) / 2 : (nz(hkOpen[1]) + nz(hkClose[1])) / 2 hkHigh = math.max(high, math.max(hkOpen, hkClose)) hkLow = math.min(low, math.min(hkOpen, hkClose)) //[hkOpen, hkHigh, hkLow, hkClose] = security(heikinashi(syminfo.tickerid), timeframe.period, [open, high, low, close]) candletype = input.string (“Hollow”, “Candle Type”, options=[“Hollow”, “Bars”, “Candles”], group=hagroup, tooltip=”Candle Type to be dispalyed. User will have to ‘Mute’ the main series bar using the 👁 symbol next to ticker id.”) BodyBull = input.color (#26a69a, “”, inline=”a”, group=”Candle Body”, group=hagroup) BodyBear = input.color (#ef5350, “”, inline=”a”, group=”Candle Body”, group=hagroup) BorderBull = input.color (#26a69a, “”, inline=”b”, group=”Candle Borders”, group=hagroup) BorderBear = input.color (#ef5350, “”, inline=”b”, group=”Candle Borders”, group=hagroup) WickBull = input.color (#26a69a, “”, inline=”c”, group=”Candle Wick”, group=hagroup) WickBear = input.color (#ef5350, “”, inline=”c”, group=”Candle Wick”, group=hagroup) hollow = candletype == “Hollow” bars = candletype == “Bars” candle = candletype == “Candles” plotcandle( hkOpen, hkHigh, hkLow, hkClose, “Hollow Candles”, switch_ha ? (hollow ? hkClose < hkOpen ? BodyBear : na : candle ? hkClose < hkOpen ? BodyBear : BodyBull : na) : na, switch_ha ? (hollow or candle ? hkClose < hkOpen ? WickBear : WickBull : na) : na, bordercolor = switch_ha ? (hollow or candle ? hkClose < hkOpen ? BorderBear : BorderBull : na) : na) /////////////////////////////////////////////////// ///////// Fair Value gap //////////////////////////////////////////////////// fvggroup = “██████████ Fair Value Gap (FVG) ██████████” numDays = input.int(7, “number of days lookback”,group=fvggroup) showUP = input.bool(true, “‘UP’ FVGs:”, inline =’1′,group=fvggroup) colUp = input.color(color.new(color.blue, 86), “”, inline =’1′,group=fvggroup) showDN = input.bool(true, “‘DOWN’ FVGs:”, inline =’2′,group=fvggroup) colDn = input.color(color.new(color.orange, 86), “”, inline =’2′,group=fvggroup) showCE = input.bool(true, “show CE”, inline =’3′,group=fvggroup) ceCol = input.color(color.new(color.black, 1), “| color:”, inline =’3′,group=fvggroup) ceStyle = input.string(line.style_dotted, “| style:”, options=[line.style_dotted,line.style_solid, line.style_dashed], inline =’3′,group=fvggroup) deleteFilledBoxes = input.bool(true, “delete filled boxes & lines”,group=fvggroup) CEcond = input.bool (false, “Use CE (as opposed to Full Fill)”,group=fvggroup, tooltip = “If toggled OFF, FVGs and CEs will paint until FVG has been completely filled.\n\nThis threshold is used for Above/Below threshold Alert conditions too (but does not effect the IOFED alerts):\ni.e. this will determine if your ‘ABOVE threshold’ alert fires when price hits most recent FVG CE ABOVE or most recent FVG Full Fill ABOVE\n\nAlerts are set by clicking the three dots on the indicator display line.”) colorNone = color.new(color.white, 100) _day = 24*3600*1000 var box bxUp = na, var box bxDn = na, var line lnUp = na, var line lnDn = na var array<box> bxUpArr = array.new<box>(0), var array<line> lnUpArr = array.new<line>(0) var array<box> bxDnArr = array.new<box>(0), var array<line> lnDnArr = array.new<line>(0) dnCE = high[1] + (low[3]-high[1])/2 upCE = low[1] – (low[1]-high[3])/2 if low[3] > high[1] and time> timenow- numDays*_day and showDN and switch_fvg bxDnArr.push(box.new(bar_index-3, low[3], bar_index, high[1], bgcolor = colDn, border_color = colorNone)) lnDnArr.push(line.new(bar_index-3, dnCE, bar_index, dnCE, color = showCE?ceCol:colorNone, style =ceStyle)) if high[3] < low[1] and time> timenow- numDays*_day and showUP and switch_fvg bxUpArr.push(box.new(bar_index-3, low[1], bar_index, high[3], bgcolor = colUp, border_color = colorNone)) lnUpArr.push(line.new(bar_index-3, upCE, bar_index, upCE, color = showCE?ceCol:colorNone, style =ceStyle)) var array<int> _countArr =array.new<int>(0) var array<int> _countArrIOFED =array.new<int>(0) //modified form of @Bjorgum’s looping function. This stops boxes/lines painting when price passes to or through them extendAndRemoveBx(array<box> boxArray, array<line> lineArray, array<int> countArr1, array<int> countArr2, simple bool isBull, int maxSize) => if boxArray.size() > 0 for i = boxArray.size() -1 to 0 line ln = lineArray.get(i) box bx = boxArray.get(i) bx.set_right(bar_index) ln.set_x2(bar_index) float price = CEcond?ln.get_price(bar_index):(isBull?bx.get_top():bx.get_bottom()) float price_IOFED = isBull?bx.get_bottom():bx.get_top() int m = isBull ? 1 : -1 float hiLo = isBull ? high : low if hiLo * m > price * m boxArray.remove(i) lineArray.remove(i) countArr1.push(isBull?1:-1) //for ‘above/below threshold alerts; counter sum will decrement 1 on lower threshold hit, increment 1 on upper threshold hit if deleteFilledBoxes bx.set_bgcolor(colorNone) ln.set_color(colorNone) if hiLo*m>price_IOFED*m countArr2.push(isBull?1:-1) if boxArray.size() > maxSize box.delete(boxArray.shift()) line.delete(lineArray.shift()) extendAndRemoveBx(bxDnArr,lnDnArr,_countArr,_countArrIOFED, true, 12) //12 should be good for around 2200 bars of history extendAndRemoveBx(bxUpArr, lnUpArr,_countArr,_countArrIOFED, false, 12) upThresholdLst = array.sum(_countArr)>array.sum(_countArr)[1] dnThresholdLst = array.sum(_countArr)<array.sum(_countArr)[1] upIOFEDlast= array.sum(_countArrIOFED)>array.sum(_countArrIOFED)[1] dnIOFEDlast= array.sum(_countArrIOFED)<array.sum(_countArrIOFED)[1] /////////////////////////////////////////////////// /////////// Vector Zone ////////////////////////////////////////////////// import TradersReality/Traders_Reality_Lib/1 as trLib vz_group = “██████████ Liquidity Zone ██████████” color redVectorColor = input.color(title=’Vector: Red’, group=vz_group, defval=color.red, inline=’vectors’) color greenVectorColor = input.color(title=’Green’, group=vz_group, defval=color.lime, inline=’vectors’) color violetVectorColor = input.color(title=’Violet’, group=vz_group, defval=color.fuchsia, inline=’vectors’) color blueVectorColor = input.color(title=’Blue’, group=vz_group, defval=color.blue, inline=’vectors’, tooltip=’Bull bars are green and bear bars are red when the bar is with volume >= 200% of the average volume of the 10 previous bars, or bars where the product of candle spread x candle volume is >= the highest for the 10 previous bars.\n Bull bars are blue and bear are violet when the bar is with with volume >= 150% of the average volume of the 10 previous bars.’) color regularCandleUpColor = input.color(title=’Regular: Up Candle’, group=vz_group, defval=#999999, inline=’nonVectors’) color regularCandleDownColor = input.color(title=’Down Candle’, group=vz_group, defval=#4d4d4d, inline=’nonVectors’, tooltip=’Bull bars are light gray and bear are dark gray when none of the red/green/blue/violet vector conditions are met.’) bool setcandlecolors = input.bool(false, title=’Set PVSRA candle colors?’, group=vz_group, inline=’setCandle’) int zonesMax = input.int(500, ‘Maximum zones to draw’, group=vz_group) string zoneType = input.string(group=vz_group, defval=’Body only’, title=’Zone top/bottom is defined with: ‘, options=[‘Body only’, ‘Body with wicks’]) string zoneUpdateType = input.string(group=vz_group, defval=’Body with wicks’, title=’Zones are cleared using candle: ‘, options=[‘Body only’, ‘Body with wicks’]) int borderWidth = input.int(0, ‘Zone border width’, group=vz_group) bool colorOverride = input.bool(true, ‘Override color?’ , group=vz_group, inline=”vcz1″) color zoneColor = input.color(title=’Color’, group=vz_group, defval=color.rgb(255, 230, 75, 90), inline=”vcz1″, tooltip=’the vector candle zones color to use if you dont not want to use the PVSRA Candle Colors.’) int transperancy = input.int(90, ‘Zone Transperancy’, minval = 0, maxval = 100, group=vz_group, tooltip=’If the vector candle zones color is not overriden, then we want to set the transparancy of the vector candle colors as defined by the PBSRA candle colors. This setting only affects the candle zone colors not the candle colors themselves.’) bool overrideSym = input.bool(group=’PVSRA Override’, title=’Override chart symbol?’, defval=false, inline=’pvsra’) string pvsraSym = input.string(group=’PVSRA Override’, title=”, defval=’INDEX:BTCUSD’, tooltip=’You can use INDEX:BTCUSD or you can combine multiple feeds, for example BINANCE:BTCUSDT+COINBASE:BTCUSD. Note that adding too many will slow things down.’, inline=’pvsra’) pvsraVolume(overrideSymbolX, pvsraSymbolX, tickerIdX) => request.security(overrideSymbolX ? pvsraSymbolX : tickerIdX, ”, volume, barmerge.gaps_off, barmerge.lookahead_off) pvsraHigh(overrideSymbolX, pvsraSymbolX, tickerIdX) => request.security(overrideSymbolX ? pvsraSymbolX : tickerIdX, ”, high, barmerge.gaps_off, barmerge.lookahead_off) pvsraLow(overrideSymbolX, pvsraSymbolX, tickerIdX) => request.security(overrideSymbolX ? pvsraSymbolX : tickerIdX, ”, low, barmerge.gaps_off, barmerge.lookahead_off) pvsraClose(overrideSymbolX, pvsraSymbolX, tickerIdX) => request.security(overrideSymbolX ? pvsraSymbolX : tickerIdX, ”, close, barmerge.gaps_off, barmerge.lookahead_off) pvsraOpen(overrideSymbolX, pvsraSymbolX, tickerIdX) => request.security(overrideSymbolX ? pvsraSymbolX : tickerIdX, ”, open, barmerge.gaps_off, barmerge.lookahead_off) pvsraVolume = pvsraVolume(overrideSym, pvsraSym, syminfo.tickerid) pvsraHigh = pvsraHigh(overrideSym, pvsraSym, syminfo.tickerid) pvsraLow = pvsraLow(overrideSym, pvsraSym, syminfo.tickerid) pvsraClose = pvsraClose(overrideSym, pvsraSym, syminfo.tickerid) pvsraOpen = pvsraOpen(overrideSym, pvsraSym, syminfo.tickerid) [pvsraColor, alertFlag, averageVolume, volumeSpread, highestVolumeSpread] = trLib.calcPvsra(pvsraVolume, pvsraHigh, pvsraLow, pvsraClose, pvsraOpen, redVectorColor, greenVectorColor, violetVectorColor, blueVectorColor, regularCandleDownColor, regularCandleUpColor) var zoneBoxesAbove = array.new_box() var zoneBoxesBelow = array.new_box() barcolor(setcandlecolors ? pvsraColor : na) pvsra = trLib.getPvsraFlagByColor(switch_vectorzone ? pvsraColor:na, redVectorColor, greenVectorColor, violetVectorColor, blueVectorColor, regularCandleUpColor) trLib.updateZones(pvsra, 0, zoneBoxesBelow, zonesMax, pvsraHigh, pvsraLow, pvsraOpen, pvsraClose, transperancy, zoneUpdateType, zoneColor, zoneType, borderWidth, colorOverride, redVectorColor, greenVectorColor, violetVectorColor, blueVectorColor) trLib.updateZones(pvsra, 1, zoneBoxesAbove, zonesMax, pvsraHigh, pvsraLow, pvsraOpen, pvsraClose, transperancy, zoneUpdateType, zoneColor, zoneType, borderWidth, colorOverride, redVectorColor, greenVectorColor, violetVectorColor, blueVectorColor) trLib.cleanarr(zoneBoxesAbove) trLib.cleanarr(zoneBoxesBelow) //***************** // Market sessions //***************** string weekend_sessions = ‘:1234567’ string no_weekend_sessions = ‘:23456′ bool show_rectangle1 = input.bool(group=’Market session: London (0800-1630 UTC+0) – DST Aware’, defval=true, title=’Show: session?’, inline=’session1conf’, tooltip=’If this checkbox is off, Label and Open Range have no effect’) and show_markets bool show_label1 = input.bool(group=’Market session: London (0800-1630 UTC+0) – DST Aware’, defval=true, title=’Label?’, inline=’session1conf’) and show_rectangle1 and show_markets bool show_or1 = input.bool(group=’Market session: London (0800-1630 UTC+0) – DST Aware’, defval=true, title=’Opening Range?’, inline=’session1conf’, tooltip=’This controls the shaded area for the session’) and show_rectangle1 and show_markets string sess1Label = input.string(group=’Market session: London (0800-1630 UTC+0) – DST Aware’, defval=’London’, title=’Name:’, inline=’session1style’) color sess1col = input.color(group=’Market session: London (0800-1630 UTC+0) – DST Aware’, title=’Color: Box’, defval=color.rgb(120, 123, 134, 75), inline=’session1style’) color sess1colLabel = input.color(group=’Market session: London (0800-1630 UTC+0) – DST Aware’, title=’Label’, defval=color.rgb(120, 123, 134, 0), inline=’session1style’) string sess1TimeX = ‘0800-1630’//input.session(group=’Market session: London (0800-1630 UTC+0)’, defval=’0800-1630′, title=’Time (UTC+0):’, inline=’session1style’, tooltip=’Normally you will not want to adjust these times. Defaults are taken as if the session is NOT in DST and times must be in UTC+0. Note due to limitations of pinescript some values sellected here other than the default might not work correctly on all exchanges.’) string rectStyle = input.string(group=’Market session: London (0800-1630 UTC+0) – DST Aware’, defval=’Dashed’, title=’Line style of Market Session hi/lo line’, options=[‘Dashed’, ‘Solid’]) sessLineStyle = line.style_dashed bool show_markets_weekends = input.bool(false, group=’Market session: London (0800-1630 UTC+0) – DST Aware’, title=’Show Market Session on Weekends?’, tooltip=’Turn on or off market sessions in the weekends. Note do not turn this on for exchanges that dont have weekend data like OANDA’) sess1Time = show_markets_weekends ? sess1TimeX + weekend_sessions : sess1TimeX + no_weekend_sessions bool show_rectangle2 = input.bool(group=’Market session: New York (1430-2100 UTC+0) – DST Aware’, defval=true, title=’Show: session?’, inline=’session2conf’, tooltip=’If this checkbox is off, Label and Open Range have no effect’) and show_markets bool show_label2 = input.bool(group=’Market session: New York (1430-2100 UTC+0) – DST Aware’, defval=true, title=’Label?’, inline=’session2conf’) and show_rectangle2 and show_markets bool show_or2 = input.bool(group=’Market session: New York (1430-2100 UTC+0) – DST Aware’, defval=true, title=’Opening Range?’, inline=’session2conf’, tooltip=’This controls the shaded area for the session’) and show_rectangle2 and show_markets string sess2Label = input.string(group=’Market session: New York (1430-2100 UTC+0) – DST Aware’, defval=’NewYork’, title=’Name:’, inline=’session2style’) color sess2col = input.color(group=’Market session: New York (1430-2100 UTC+0) – DST Aware’, title=’Color: Box’, defval=color.rgb(251, 86, 91, 75), inline=’session2style’) color sess2colLabel = input.color(group=’Market session: New York (1430-2100 UTC+0) – DST Aware’, title=’Label’, defval=color.rgb(253, 84, 87, 25), inline=’session2style’) string sess2TimeX = ‘1430-2100’//input.session(group=’Market session: New York (1430-2100 UTC+0)’, defval=’1430-2100′, title=’Time (UTC+0):’, inline=’session2style’, tooltip=’Normally you will not want to adjust these times. Defaults are taken as if the session is NOT in DST times must be in UTC+0. Note due to limitations of pinescript some values sellected here other than the default might not work correctly on all exchanges.’) sess2Time = show_markets_weekends ? sess2TimeX + weekend_sessions : sess2TimeX + no_weekend_sessions bool show_rectangle3 = input.bool(group=’Market session: Tokyo (0000-0600 UTC+0) – DST Aware’, defval=true, title=’Show: session?’, inline=’session3conf’, tooltip=’If this checkbox is off, Label and Open Range have no effect’) and show_markets bool show_label3 = input.bool(group=’Market session: Tokyo (0000-0600 UTC+0) – DST Aware’, defval=true, title=’Label?’, inline=’session3conf’) and show_rectangle3 and show_markets bool show_or3 = input.bool(group=’Market session: Tokyo (0000-0600 UTC+0) – DST Aware’, defval=true, title=’Opening Range?’, inline=’session3conf’, tooltip=’This controls the shaded area for the session’) and show_rectangle3 and show_markets string sess3Label = input.string(group=’Market session: Tokyo (0000-0600 UTC+0) – DST Aware’, defval=’Tokyo’, title=’Name:’, inline=’session3style’) color sess3col = input.color(group=’Market session: Tokyo (0000-0600 UTC+0) – DST Aware’, title=’Color: Box’, defval=color.rgb(80, 174, 85, 75), inline=’session3style’) color sess3colLabel = input.color(group=’Market session: Tokyo (0000-0600 UTC+0) – DST Aware’, title=’Label’, defval=color.rgb(80, 174, 85, 25), inline=’session3style’) string sess3TimeX = ‘0000-0600’//input.session(group=’Market session: Tokyo (0000-0600 UTC+0)’, defval=’0000-0600′, title=’Time (UTC+0):’, inline=’session3style’, tooltip=’Normally you will not want to adjust these times. Defaults are taken as if the session is NOT in DST times must be in UTC+0. Note due to limitations of pinescript some values sellected here other than the default might not work correctly on all exchanges.’) sess3Time = show_markets_weekends ? sess3TimeX + weekend_sessions : sess3TimeX + no_weekend_sessions bool show_rectangle4 = input.bool(group=’Market session: Hong Kong (0130-0800 UTC+0) – DST Aware’, defval=true, title=’Show: session?’, inline=’session4conf’, tooltip=’If this checkbox is off, Label and Open Range have no effect’) and show_markets bool show_label4 = input.bool(group=’Market session: Hong Kong (0130-0800 UTC+0) – DST Aware’, defval=true, title=’Label?’, inline=’session4conf’) and show_rectangle4 and show_markets bool show_or4 = input.bool(group=’Market session: Hong Kong (0130-0800 UTC+0) – DST Aware’, defval=true, title=’Opening Range?’, inline=’session4conf’, tooltip=’This controls the shaded area for the session’) and show_rectangle4 and show_markets string sess4Label = input.string(group=’Market session: Hong Kong (0130-0800 UTC+0) – DST Aware’, defval=’HongKong’, title=’Name:’, inline=’session4style’) color sess4col = input.color(group=’Market session: Hong Kong (0130-0800 UTC+0) – DST Aware’, title=’Color: Box’, defval=color.rgb(128, 127, 23, 75), inline=’session4style’) color sess4colLabel = input.color(group=’Market session: Hong Kong (0130-0800 UTC+0) – DST Aware’, title=’Label’, defval=color.rgb(128, 127, 23, 25), inline=’session4style’) string sess4TimeX = ‘0130-0800’//input.session(group=’Market session: Hong Kong (0130-0800 UTC+0)’, defval=’0130-0800′, title=’Time (UTC+0):’, inline=’session4style’, tooltip=’Normally you will not want to adjust these times. Defaults are taken as if the session is NOT in DST times must be in UTC+0. Note due to limitations of pinescript some values sellected here other than the default might not work correctly on all exchanges.’) sess4Time = show_markets_weekends ? sess4TimeX + weekend_sessions : sess4TimeX + no_weekend_sessions bool show_rectangle5 = input.bool(group=’Market session: Sydney (NZX+ASX 2200-0600 UTC+0) – DST Aware’, defval=true, title=’Show: session?’, inline=’session5conf’, tooltip=’If this checkbox is off, Label and Open Range have no effect’) and show_markets bool show_label5 = input.bool(group=’Market session: Sydney (NZX+ASX 2200-0600 UTC+0) – DST Aware’, defval=true, title=’Label?’, inline=’session5conf’) and show_rectangle5 and show_markets bool show_or5 = input.bool(group=’Market session: Sydney (NZX+ASX 2200-0600 UTC+0) – DST Aware’, defval=true, title=’Opening Range?’, inline=’session5conf’, tooltip=’This controls the shaded area for the session’) and show_rectangle5 and show_markets string sess5Label = input.string(group=’Market session: Sydney (NZX+ASX 2200-0600 UTC+0) – DST Aware’, defval=’Sydney’, title=’Name:’, inline=’session5style’) color sess5col = input.color(group=’Market session: Sydney (NZX+ASX 2200-0600 UTC+0) – DST Aware’, title=’Color: Box’, defval=color.rgb(37, 228, 123, 75), inline=’session5style’) color sess5colLabel = input.color(group=’Market session: Sydney (NZX+ASX 2200-0600 UTC+0) – DST Aware’, title=’Label’, defval=color.rgb(37, 228, 123, 25), inline=’session5style’) string sess5TimeX = ‘2200-0600’//input.session(group=’Market session: Sydney (NZX+ASX 2200-0600 UTC+0)’, defval=’2200-0600′, title=’Time (UTC+0):’, inline=’session5style’, tooltip=’Normally you will not want to adjust these times. Defaults are taken as if the session is NOT in DST times must be in UTC+0. Note due to limitations of pinescript some values sellected here other than the default might not work correctly on all exchanges.’) sess5Time = show_markets_weekends ? sess5TimeX + weekend_sessions : sess5TimeX + no_weekend_sessions bool show_rectangle6 = input.bool(group=’Market session: EU Brinks (0800-0900 UTC+0) – DST Aware’, defval=true, title=’Show: session?’, inline=’session6conf’, tooltip=’If this checkbox is off, Label and Open Range have no effect’) and show_markets bool show_label6 = input.bool(group=’Market session: EU Brinks (0800-0900 UTC+0) – DST Aware’, defval=true, title=’Label?’, inline=’session6conf’) and show_rectangle6 and show_markets bool show_or6 = input.bool(group=’Market session: EU Brinks (0800-0900 UTC+0) – DST Aware’, defval=true, title=’Opening Range?’, inline=’session6conf’, tooltip=’This controls the shaded area for the session’) and show_rectangle6 and show_markets string sess6Label = input.string(group=’Market session: EU Brinks (0800-0900 UTC+0) – DST Aware’, defval=’EU Brinks’, title=’Name:’, inline=’session6style’) color sess6col = input.color(group=’Market session: EU Brinks (0800-0900 UTC+0) – DST Aware’, title=’Color: Box’, defval=color.rgb(255, 255, 255, 65), inline=’session6style’) color sess6colLabel = input.color(group=’Market session: EU Brinks (0800-0900 UTC+0) – DST Aware’, title=’Label’, defval=color.rgb(255, 255, 255, 25), inline=’session6style’) string sess6TimeX = ‘0800-0900’//input.session(group=’Market session: EU Brinks (0800-0900 UTC+0)’, defval=’0800-0900′, title=’Time (UTC+0):’, inline=’session6style’, tooltip=’Normally you will not want to adjust these times. Defaults are taken as if the session is NOT in DST times must be in UTC+0. Note due to limitations of pinescript some values sellected here other than the default might not work correctly on all exchanges.’) sess6Time = show_markets_weekends ? sess6TimeX + weekend_sessions : sess6TimeX + no_weekend_sessions bool show_rectangle7 = input.bool(group=’Market session: US Brinks (1400-1500 UTC+0) – DST Aware’, defval=true, title=’Show: session?’, inline=’session7conf’, tooltip=’If this checkbox is off, Label and Open Range have no effect’) and show_markets bool show_label7 = input.bool(group=’Market session: US Brinks (1400-1500 UTC+0) – DST Aware’, defval=true, title=’Label?’, inline=’session7conf’) and show_rectangle7 and show_markets bool show_or7 = input.bool(group=’Market session: US Brinks (1400-1500 UTC+0) – DST Aware’, defval=true, title=’Opening Range?’, inline=’session7conf’, tooltip=’This controls the shaded area for the session’) and show_rectangle7 and show_markets string sess7Label = input.string(group=’Market session: US Brinks (1400-1500 UTC+0) – DST Aware’, defval=’US Brinks’, title=’Name:’, inline=’session7style’) color sess7col = input.color(group=’Market session: US Brinks (1400-1500 UTC+0) – DST Aware’, title=’Color: Box’, defval=color.rgb(255, 255, 255, 65), inline=’session7style’) color sess7colLabel = input.color(group=’Market session: US Brinks (1400-1500 UTC+0) – DST Aware’, title=’Label’, defval=color.rgb(255, 255, 255, 25), inline=’session7style’) string sess7TimeX = ‘1400-1500’//input.session(group=’Market session: US Brinks (1400-1500 UTC+0)’, defval=’1400-1500′, title=’Time (UTC+0):’, inline=’session7style’, tooltip=’Normally you will not want to adjust these times. Defaults are taken as if the session is NOT in DST times must be in UTC+0. Note due to limitations of pinescript some values sellected here other than the default might not work correctly on all exchanges.’) sess7Time = show_markets_weekends ? sess7TimeX + weekend_sessions : sess7TimeX + no_weekend_sessions splitSessionString(sessXTime) => //session stirng looks like this: 0000-0000:1234567 ie start time, end time, day of the week //we need to parse the sessXTime string into hours and min for start and end times so we can use those in the timestampfunction below //string times contains “0000-2300” as an example string times = array.get(str.split(sessXTime, ‘:’), 0) //string startTime contains “0000” string startTime = array.get(str.split(times, ‘-‘), 0) //string endTime contains “2300” string endTime = array.get(str.split(times, ‘-‘), 1) //now we need to get the start hour and start min, sing 0 index – hour is the characters in index 0 and index 1 while min is the chars at index 2 and 3 string[] startTimeChars = str.split(startTime, ”) string[] endTimeChars = str.split(endTime, ”) //so now startHour contains 00 and start min contains 00 string startHour = array.get(startTimeChars, 0) + array.get(startTimeChars, 1) string startMin = array.get(startTimeChars, 2) + array.get(startTimeChars, 3) //so now endHour contains 23 and end min contains 00 string endHour = array.get(endTimeChars, 0) + array.get(endTimeChars, 1) string endMin = array.get(endTimeChars, 2) + array.get(endTimeChars, 3) [startHour, startMin, endHour, endMin] calc_session_startend(sessXTime, gmt) => [startHour, startMin, endHour, endMin] = splitSessionString(sessXTime) targetstartTimeX = timestamp(gmt, year, month, dayofmonth, math.round(str.tonumber(startHour)), math.round(str.tonumber(startMin)), 00) targetendTimeX = timestamp(gmt, year, month, dayofmonth, math.round(str.tonumber(endHour)), math.round(str.tonumber(endMin)), 00) time_now = timestamp(year, month, dayofmonth, hour, minute, 00) midnight_exchange = timestamp(year, month, dayofmonth, 00, 00, 00) //if start hour is greater than end hour we are dealing with a session that starts towards the end of one day //and ends the next day. ie advance the end time by 24 hours – its the next day bool adjusted = false if gmt == ‘GMT+0’ if math.round(str.tonumber(startHour)) > math.round(str.tonumber(endHour)) if time_now – targetstartTimeX >= 0 targetendTimeX := targetendTimeX + 24 * 60 * 60 * 1000 adjusted := true targetendTimeX if gmt == ‘GMT+1′ if math.round(str.tonumber(startHour)) == 0 startHour := ’24’ if math.round(str.tonumber(endHour)) == 0 endHour := ’24’ if math.round(str.tonumber(startHour))-1 > math.round(str.tonumber(endHour))-1 if time_now – targetstartTimeX >= 0 targetendTimeX := targetendTimeX + 24 * 60 * 60 * 1000 adjusted := true targetendTimeX if targetstartTimeX < midnight_exchange and midnight_exchange < targetendTimeX and not adjusted targetendTimeX := targetendTimeX + 24 * 60 * 60 * 1000 targetendTimeX [targetstartTimeX,targetendTimeX] draw_open_range(sessXTime, sessXcol, show_orX, gmt)=> if show_orX // Initialize variables on bar zero only, so they preserve their values across bars. var hi = float(na) var lo = float(na) var box hiLoBox = na // Detect changes in timeframe. session = time(timeframe.period, sessXTime, gmt) bool newTF = session and not session[1] if newTF // New bar in higher timeframe; reset values and create new lines and box. [targetstartTimeX,targetendTimeX] = calc_session_startend(sessXTime, gmt) sessionDuration = math.round(math.abs(time – targetendTimeX)/(timeframe.multiplier*60*1000)) hi := high lo := low hiLoBox := box.new(bar_index, hi, timeframe.multiplier == 1? bar_index : bar_index+sessionDuration, lo, border_color = na, bgcolor = sessXcol) int(na) else if timeframe.multiplier == 1 and (na(session[1]) and not na(session) or session[1] < session) box.set_right(hiLoBox, bar_index+1) int(na) draw_session_hilo(sessXTime, show_rectangleX, show_labelX, sessXcolLabel, sessXLabel, gmt)=> if show_rectangleX // Initialize variables on bar zero only, so they preserve their values across bars. var hi = float(0) var lo = float(10000000000.0) var line line_t = na var line line_b = na var label line_label = na // var box hiLoBox = na // Detect changes in timeframe. session = time(timeframe.period, sessXTime, gmt) sessLineStyleX = rectStyle == ‘Solid’ ? line.style_solid : line.style_dashed bool newTF = session and not session[1] hi := newTF ? high : session ? math.max(high, hi[1]) : hi[1] lo := newTF ? low : session ? math.min(low, lo[1]) : lo[1] if newTF beginIndex = bar_index [targetstartTimeX,targetendTimeX] = calc_session_startend(sessXTime, gmt) sessionDuration = math.round(math.abs(time – targetendTimeX)/(timeframe.multiplier*60*1000)) line_t := line.new(beginIndex, hi, timeframe.multiplier == 1? bar_index : bar_index+sessionDuration, hi, xloc=xloc.bar_index, style=sessLineStyleX, color=sessXcolLabel) line_b := line.new(beginIndex, lo, timeframe.multiplier == 1? bar_index : bar_index+sessionDuration, lo, xloc=xloc.bar_index, style=sessLineStyleX, color=sessXcolLabel) line.delete(line_t[1]) line.delete(line_b[1]) if show_labelX line_label := label.new(beginIndex, hi, sessXLabel, xloc=xloc.bar_index, textcolor=sessXcolLabel, style=label.style_none, size=size.normal, textalign=text.align_right) label.delete(line_label[1]) int(na) else if na(session[1]) and not na(session) or session[1] < session if timeframe.multiplier == 1 line.set_x2(line_t,bar_index+1) line.set_x2(line_b,bar_index+1) line.set_y1(line_t,hi) line.set_y2(line_t,hi) line.set_y1(line_b,lo) line.set_y2(line_b,lo) if show_labelX and not na(line_label) label.set_y(line_label, hi) int(na) //*****************************// // Daylight Savings Time Flags // //*****************************// int previousSunday = dayofmonth – dayofweek + 1 bool nyDST = na bool ukDST = na bool sydDST = na if month < 3 or month > 11 nyDST := false ukDST := false sydDST := true else if month > 4 and month < 10 nyDST := true ukDST := true sydDST := false else if month == 3 nyDST := previousSunday >= 8 ukDST := previousSunday >= 24 sydDST := true else if month == 4 nyDST := true ukDST := true sydDST := previousSunday <= 0 else if month == 10 nyDST := true ukDST := previousSunday <= 24 sydDST := previousSunday >= 0 else // month == 11 nyDST := previousSunday <= 0 ukDST := false sydDST := true if ukDST draw_open_range(sess1Time,sess1col,show_or1,’GMT+1′) draw_session_hilo(sess1Time, show_rectangle1, show_label1, sess1colLabel, sess1Label, ‘GMT+1′) else draw_open_range(sess1Time,sess1col,show_or1,’GMT+0’) draw_session_hilo(sess1Time, show_rectangle1, show_label1, sess1colLabel, sess1Label, ‘GMT+0′) if nyDST draw_open_range(sess2Time,sess2col,show_or2,’GMT+1’) draw_session_hilo(sess2Time, show_rectangle2, show_label2, sess2colLabel, sess2Label, ‘GMT+1′) else draw_open_range(sess2Time,sess2col,show_or2,’GMT+0’) draw_session_hilo(sess2Time, show_rectangle2, show_label2, sess2colLabel, sess2Label, ‘GMT+0′) // Tokyo draw_open_range(sess3Time,sess3col,show_or3,’GMT+0’) draw_session_hilo(sess3Time, show_rectangle3, show_label3, sess3colLabel, sess3Label, ‘GMT+0′) // Hong Kong draw_open_range(sess4Time,sess4col,show_or4,’GMT+0’) draw_session_hilo(sess4Time, show_rectangle4, show_label4, sess4colLabel, sess4Label, ‘GMT+0′) if sydDST draw_open_range(sess5Time,sess5col,show_or5,’GMT+1’) draw_session_hilo(sess5Time, show_rectangle5, show_label5, sess5colLabel, sess5Label, ‘GMT+1′) else draw_open_range(sess5Time,sess5col,show_or5,’GMT+0’) draw_session_hilo(sess5Time, show_rectangle5, show_label5, sess5colLabel, sess5Label, ‘GMT+0′) if nyDST draw_open_range(sess7Time,sess7col,show_or7,’GMT+1’) draw_session_hilo(sess7Time, show_rectangle7, show_label7, sess7colLabel, sess7Label, ‘GMT+1′) else draw_open_range(sess7Time,sess7col,show_or7,’GMT+0’) draw_session_hilo(sess7Time, show_rectangle7, show_label7, sess7colLabel, sess7Label, ‘GMT+0′) ////////////////////////////////////////////////// ////QQE MOD ///////////////////////////////////////////////// qqe_gorup = “██████████ QQE ██████████” RSI_Period = input(6, title=’RSI Length’, group=qqe_gorup) SF = input(5, title=’RSI Smoothing’, group=qqe_gorup) QQE = input(3, title=’Fast QQE Factor’, group=qqe_gorup) ThreshHold = input(3, title=’Thresh-hold’, group=qqe_gorup) // srcqqe = input(close, title=’RSI Source’, group=qqe_gorup) // // Wilders_Period = RSI_Period * 2 – 1 Rsi = ta.rsi(srcqqe, RSI_Period) RsiMa = ta.ema(Rsi, SF) AtrRsi = math.abs(RsiMa[1] – RsiMa) MaAtrRsi = ta.ema(AtrRsi, Wilders_Period) dar = ta.ema(MaAtrRsi, Wilders_Period) * QQE longband = 0.0 shortband = 0.0 trend = 0 DeltaFastAtrRsi = dar RSIndex = RsiMa newshortband = RSIndex + DeltaFastAtrRsi newlongband = RSIndex – DeltaFastAtrRsi longband := RSIndex[1] > longband[1] and RSIndex > longband[1] ? math.max(longband[1], newlongband) : newlongband shortband := RSIndex[1] < shortband[1] and RSIndex < shortband[1] ? math.min(shortband[1], newshortband) : newshortband cross_1 = ta.cross(longband[1], RSIndex) trend := ta.cross(RSIndex, shortband[1]) ? 1 : cross_1 ? -1 : nz(trend[1], 1) FastAtrRsiTL = trend == 1 ? longband : shortband length = input.int(50, minval=1, title=’Bollinger Length’, group=qqe_gorup) multqqe = input.float(0.35, minval=0.001, maxval=5, step=0.1, title=’BB Multiplier’, group=qqe_gorup) basis = ta.sma(FastAtrRsiTL – 50, length) dev = multqqe * ta.stdev(FastAtrRsiTL – 50, length) upperqqe = basis + dev lowerqqe = basis – dev color_bar = RsiMa – 50 > upperqqe ? #00c3ff : RsiMa – 50 < lowerqqe ? #ff0062 : color.gray // // Zero cross QQEzlong = 0 QQEzlong := nz(QQEzlong[1]) QQEzshort = 0 QQEzshort := nz(QQEzshort[1]) QQEzlong := RSIndex >= 50 ? QQEzlong + 1 : 0 QQEzshort := RSIndex < 50 ? QQEzshort + 1 : 0 // //////////////////////////////////////////////////////////////// RSI_Period2 = input(6, title=’RSI Length’, group=qqe_gorup) SF2 = input(5, title=’RSI Smoothing’, group=qqe_gorup) QQE2 = input(1.61, title=’Fast QQE2 Factor’, group=qqe_gorup) ThreshHold2 = input(3, title=’Thresh-hold’, group=qqe_gorup) src2 = input(close, title=’RSI Source’, group=qqe_gorup) // // Wilders_Period2 = RSI_Period2 * 2 – 1 Rsi2 = ta.rsi(src2, RSI_Period2) RsiMa2 = ta.ema(Rsi2, SF2) AtrRsi2 = math.abs(RsiMa2[1] – RsiMa2) MaAtrRsi2 = ta.ema(AtrRsi2, Wilders_Period2) dar2 = ta.ema(MaAtrRsi2, Wilders_Period2) * QQE2 longband2 = 0.0 shortband2 = 0.0 trend2 = 0 DeltaFastAtrRsi2 = dar2 RSIndex2 = RsiMa2 newshortband2 = RSIndex2 + DeltaFastAtrRsi2 newlongband2 = RSIndex2 – DeltaFastAtrRsi2 longband2 := RSIndex2[1] > longband2[1] and RSIndex2 > longband2[1] ? math.max(longband2[1], newlongband2) : newlongband2 shortband2 := RSIndex2[1] < shortband2[1] and RSIndex2 < shortband2[1] ? math.min(shortband2[1], newshortband2) : newshortband2 cross_2 = ta.cross(longband2[1], RSIndex2) trend2 := ta.cross(RSIndex2, shortband2[1]) ? 1 : cross_2 ? -1 : nz(trend2[1], 1) FastAtrRsi2TL = trend2 == 1 ? longband2 : shortband2 // // Zero cross QQE2zlong = 0 QQE2zlong := nz(QQE2zlong[1]) QQE2zshort = 0 QQE2zshort := nz(QQE2zshort[1]) QQE2zlong := RSIndex2 >= 50 ? QQE2zlong + 1 : 0 QQE2zshort := RSIndex2 < 50 ? QQE2zshort + 1 : 0 // qqeline = FastAtrRsi2TL – 50 // hcolor2 = RsiMa2 – 50 > ThreshHold2 ? color.silver : RsiMa2 – 50 < 0 – ThreshHold2 ? color.silver : na Greenbar1 = RsiMa2 – 50 > ThreshHold2 Greenbar2 = RsiMa – 50 > upperqqe Redbar1 = RsiMa2 – 50 < 0 – ThreshHold2 Redbar2 = RsiMa – 50 < lowerqqe ///////////////////////////////////////////////// /////////////// Volume Up/Down //////////////////////////////////////////////// vgroup = “██████████ Up/Down Volume ██████████” lowerTimeframeTooltip = “The indicator scans lower timeframe data to approximate Up/Down volume. By default, the timeframe is chosen automatically. These inputs override this with a custom timeframe.\n\nHigher timeframes provide more historical data, but the data will be less precise.” useCustomTimeframeInput = input.bool(false, “Use custom timeframe”, tooltip = lowerTimeframeTooltip,group=vgroup) lowerTimeframeInput = input.timeframe(“1”, “Timeframe”,group=vgroup) upAndDownVolume() => posVol = 0.0 negVol = 0.0 switch close > open => posVol += volume close < open => negVol -= volume close >= close[1] => posVol += volume close < close[1] => negVol -= volume [posVol, negVol] lowerTimeframe = switch useCustomTimeframeInput => lowerTimeframeInput timeframe.isintraday => “1” timeframe.isdaily => “5” => “60” // Modify the timeframe argument in the security call timeframeForSecurity = useCustomTimeframeInput ? lowerTimeframeInput : timeframe.period [upVolumeArray, downVolumeArray] = request.security_lower_tf(syminfo.tickerid, timeframeForSecurity, upAndDownVolume()) SMALength = input(20, title=”SMA Length”,group=vgroup) volume_ma = ta.sma(volume, SMALength) volume_abovema_signal = volume > volume_ma upVolume = array.sum(upVolumeArray) downVolume = array.sum(downVolumeArray) delta = upVolume + downVolume prevdelta = delta[1] var cumVol = 0. cumVol += nz(volume) if barstate.islast and cumVol == 0 runtime.error(“The data vendor doesn’t provide volume data for this symbol.”) respectemavalue = ta.ema(src, respectemaperiod) isaboverespectema = close > respectemavalue isbelowrespectema = close < respectemavalue isqqebarabove = Greenbar1 and Greenbar2 isqqebarbelow = Redbar1 and Redbar2 dv2up = bool (na) dvup = bool (na) if dvtype == ‘Threshold’ dvup := vol > t and vol>=1.1 else if dvtype == ’10p Difference’ dvup := vol > t and (vol – t >= 0.1) else dvup := vol > t sarup = out < close sardown = out > close longvol = bool(na) shortvol = bool (na) if volumetype == ‘Delta’ longvol := delta > 0 and delta > delta[1] shortvol := delta < 0 and delta < delta[1] else if volumetype == ‘volume above MA’ longvol := volume_abovema_signal shortvol := volume_abovema_signal else longvol := upVolume > upVolume[1] shortvol := downVolume < downVolume[1] longCond = bool(na) shortCond = bool(na) longCond2 = bool(na) shortCond2 = bool(na) vipcondition = bool(na) vimcondition = bool(na) if vitype == ‘Simple’ vipcondition := vip > vim vimcondition := vip < vim else vipcondition := vip > vim and vip > viupper and vip > vip[1] and vim < vim[1] and vim[1] <= vilower and vip[1] >= viupper vimcondition := vip < vim and vim > viupper and vim > vim[1] and vip < vip [1] and vip[1] <= vilower and vim [1] >= viupper vipcondition2 = vip > vim vimcondition2 = vip < vim ///////////////////////////////////ADX Condition //////////////////////////////////////// adxcycle = 0 adxup = ta.crossover(adx, keyLevel) adxdown = ta.crossunder(adx, keyLevel) adxcycle := adxup ? 1 : adxdown ? -1 : adxcycle[1] adxcondition = string(na) adxupcondition = bool(na) adxdowncondition = bool (na) if adxtype == ‘Adx & +Di -Di’ adxupcondition := diplus > diminus and adx>=keyLevel adxdowncondition := diplus < diminus and adx>=keyLevel if adxtype == ‘Adx Only’ adxupcondition := adx>keyLevel adxdowncondition := adx>keyLevel else if adxcycle == -1 adxupcondition := diplus > diminus and adx>=keyLevel and diplus – diminus > 1 adxdowncondition := diplus < diminus and adx>=keyLevel and diminus – diplus > 1 else if adxcycle==1 adxupcondition := diplus > diminus and adx>=keyLevel and adx<55 and (adx>adx[1] or (diplus > diplus[1] and diminus < diminus[1])) and diplus – diminus > 1 adxdowncondition := diplus < diminus and adx>=keyLevel and adx<55 and (adx>adx[1] or (diplus < diplus[1] and diminus > diminus[1])) and diminus – diplus > 1 ///////////////adx condition end///////////////////////////////////////////////////// justcontinue = bool(true) isstup = bool(na) isstdown = bool(na) isstup := sttrend == 1 isstdown := sttrend != 1 ismacdup = bool(na) ismacddown = bool(na) isqqeabove = bool(na) isqqebelow = bool(na) if qqetype == ‘Line’ isqqeabove := qqeline>0 isqqebelow := qqeline<0 else if qqetype == ‘Bar’ isqqeabove := RsiMa2 – 50 > 0 and (Greenbar1 and Greenbar2) isqqebelow := RsiMa2 – 50 < 0 and (Redbar1 and Redbar2) else if qqetype == ‘Line & Bar’ isqqeabove := RsiMa2 – 50 > 0 and (Greenbar1 and Greenbar2) and qqeline>0 isqqebelow := RsiMa2 – 50 < 0 and (Redbar1 and Redbar2) and qqeline<0 rsimalong2 = bool(na) rsimashort2 = bool(na) rsimalong2:= rsiMA >= rsiMA[1] rsimashort2:= rsiMA <= rsiMA[1] rsilimitlong = rsi >= rsilimitup rsilimitshort = rsi <= rsilimitdown rsimalimitlong = rsiMA >= rsimalimitup rsimalimitshort = rsiMA <= rsimalimitdown leadinglongcond = bool(na) leadingshortcond = bool(na) if leadingindicator == ‘Range Filter’ if rftype == ‘Default’ leadinglongcond := src > filt and src > src[1] and upward > 0 or src > filt and src < src[1] and upward > 0 leadingshortcond := src < filt and src < src[1] and downward > 0 or src < filt and src > src[1] and downward > 0 else if rftype == ‘DW’ leadinglongcond := rfupward leadingshortcond := rfdownward else if leadingindicator == ‘DMI (Adx)’ if adxtype == ‘Basic’ leadinglongcond := diplus > diminus and adx>=keyLevel leadingshortcond := diplus < diminus and adx>=keyLevel else if adxcycle == -1 leadinglongcond := diplus > diminus and adx>=keyLevel and diplus – diminus > 1 leadingshortcond := diplus < diminus and adx>=keyLevel and diminus – diplus > 1 else if adxcycle==1 leadinglongcond := diplus > diminus and adx>=keyLevel and adx<55 and (adx>adx[1] or (diplus > diplus[1] and diminus < diminus[1])) and diplus – diminus > 1 leadingshortcond := diplus < diminus and adx>=keyLevel and adx<55 and (adx>adx[1] or (diplus < diplus[1] and diminus > diminus[1])) and diminus – diplus > 1 else if leadingindicator == ‘Parabolic SAR (PSAR)’ leadinglongcond := out < close leadingshortcond := out > close else if leadingindicator == ‘Rational Quadratic Kernel (RQK)’ leadinglongcond := rqkuptrend leadingshortcond := rqkdowntrend else if leadingindicator == ‘Trendline Breakout’ leadinglongcond := tb_buysignal leadingshortcond := tb_sellsignal else if leadingindicator == ‘Range Detector’ leadinglongcond := rd_long leadingshortcond := rd_short else if leadingindicator == ‘Heiken-Ashi Candlestick Oscillator’ leadinglongcond := hacolt_long leadingshortcond := hacolt_short else if leadingindicator == ‘Donchian Trend Ribbon’ leadinglongcond := donchian_long leadingshortcond := donchian_short else if leadingindicator == ‘Rate of Change (ROC)’ leadinglongcond := roc_long leadingshortcond := roc_short else if leadingindicator == ‘Trend Direction Force Index (TDFI)’ leadinglongcond := tdfi_long leadingshortcond := tdfi_short else if leadingindicator == ‘Detrended Price Oscillator (DPO)’ leadinglongcond := dpo_long leadingshortcond := dpo_short else if leadingindicator == ‘2 EMA Cross’ leadinglongcond := ema2_long leadingshortcond := ema2_short else if leadingindicator == ‘3 EMA Cross’ leadinglongcond := first_3ema > second_3ema and first_3ema > third_3ema and second_3ema>third_3ema leadingshortcond := first_3ema < second_3ema and first_3ema < third_3ema and second_3ema<third_3ema else if leadingindicator == ‘Chandelier Exit’ leadinglongcond := ce_long leadingshortcond := ce_short else if leadingindicator == ‘Stochastic’ leadinglongcond := stoch_long leadingshortcond := stoch_short else if leadingindicator == ‘Vortex Index’ if vitype == ‘Simple’ leadinglongcond := vip > vim leadingshortcond := vip < vim else leadinglongcond := vip > vim and vip > viupper and vip > vip[1] and vim < vim[1] and vim[1] <= vilower and vip[1] >= viupper leadingshortcond := vip < vim and vim > viupper and vim > vim[1] and vip < vip [1] and vip[1] <= vilower and vim [1] >= viupper else if leadingindicator == ‘Schaff Trend Cycle (STC)’ leadinglongcond := stc >= upper leadingshortcond := stc <= upper else if leadingindicator == ‘Wolfpack Id’ leadinglongcond := wolf_long leadingshortcond := wolf_short else if leadingindicator == ‘B-Xtrender’ leadinglongcond := bx_long leadingshortcond := bx_short else if leadingindicator == ‘Bull Bear Power Trend’ leadinglongcond := bbpt_long leadingshortcond := bbpt_short else if leadingindicator == ‘QQE Mod’ if qqetype == ‘Line’ leadinglongcond := qqeline>0 leadingshortcond := qqeline<0 else if qqetype == ‘Bar’ leadinglongcond := RsiMa2 – 50 > 0 and (Greenbar1 and Greenbar2) leadingshortcond := RsiMa2 – 50 < 0 and (Redbar1 and Redbar2) else if qqetype == ‘Line & Bar’ leadinglongcond := RsiMa2 – 50 > 0 and (Greenbar1 and Greenbar2) and qqeline>0 leadingshortcond := RsiMa2 – 50 < 0 and (Redbar1 and Redbar2) and qqeline<0 else if leadingindicator == ‘MACD’ if macdtype == ‘MACD Crossover’ leadinglongcond := macdd > signal leadingshortcond := macdd < signal else if macdtype == ‘Zero line crossover’ leadinglongcond := macdd > signal and macdd > 0.00000 leadingshortcond := macdd < signal and macdd < 0.00000 else if leadingindicator == ‘True Strength Indicator (TSI)’ if tsitype == ‘Signal Cross’ leadinglongcond := tsi_long leadingshortcond := tsi_short else if tsitype == ‘Zero line cross’ leadinglongcond := tsi_long leadingshortcond := tsi_short else if leadingindicator == ‘RSI’ if rsitype == ‘RSI MA Cross’ leadinglongcond := rsi > rsiMA leadingshortcond := rsi < rsiMA else if rsitype == ‘RSI Exits OB/OS zones’ leadinglongcond := rsi > rsi_lower and rsi[1] < rsi_lower leadingshortcond := rsi < rsi_upper and rsi[1] > rsi_upper else if rsitype == ‘RSI Level’ leadinglongcond := rsi > respectrsilevel leadingshortcond := rsi < respectrsilevel else if leadingindicator == ‘Chaikin Money Flow’ leadinglongcond := chaikin_long leadingshortcond := chaikin_short else if leadingindicator == ‘Volatility Oscillator’ leadinglongcond := vo_long leadingshortcond := vo_short else if leadingindicator == ‘SSL Channel’ leadinglongcond := ssl_long leadingshortcond := ssl_short else if leadingindicator == ‘Awesome Oscillator’ leadinglongcond := ao_long leadingshortcond := ao_short else if leadingindicator == ‘Supertrend’ leadinglongcond := sttrend == 1 leadingshortcond := sttrend != 1 else if leadingindicator == ‘Half Trend’ leadinglongcond := halftrend_long leadingshortcond := halftrend_short else if leadingindicator == ‘Waddah Attar Explosion’ leadinglongcond := wae_long leadingshortcond := wae_short else if leadingindicator == ‘Hull Suite’ leadinglongcond := HULL > HULL[2] leadingshortcond := HULL < HULL[2] else if leadingindicator == ‘BB Oscillator’ leadinglongcond := bbosc_long leadingshortcond := bbosc_short else if leadingindicator == ‘Ichimoku Cloud’ leadinglongcond := ichi_long leadingshortcond := ichi_short else if leadingindicator == ‘VWAP’ leadinglongcond := long_vwap leadingshortcond := short_vwap else if leadingindicator == ‘SuperIchi’ leadinglongcond := superichi_long leadingshortcond := superichi_short // else if leadingindicator == ‘Trend Meter’ // if tmtype == ‘3 TM and 2 TB change to same color’ // leadinglongcond := TB1Green and TB2Green and (TrendBar1Result and TrendBar2Result and TrendBar3Result ? 1 : 0) // leadingshortcond := TB1Red and TB2Red and (not TrendBar1Result and not TrendBar2Result and not TrendBar3Result ? 1 : 0) // else if tmtype == ‘3 TM change to same color’ // leadinglongcond := TrendBar1Result and TrendBar2Result and TrendBar3Result ? 1 : 0 // leadingshortcond := not TrendBar1Result and not TrendBar2Result and not TrendBar3Result ? 1 : 0 // else if tmtype == ‘3 TM, 2 TB and Wavetrend change to same color’ // leadinglongcond := TB1Green and TB2Green and (TrendBar1Result and TrendBar2Result and TrendBar3Result ? 1 : 0) and MSBar1PositiveWaveTrendSignal // leadingshortcond := TB1Red and TB2Red and (not TrendBar1Result and not TrendBar2Result and not TrendBar3Result ? 1 : 0) and MSBar1NegativeWaveTrendSignal else if leadingindicator == ‘CCI’ leadinglongcond := ccilong leadingshortcond := ccishort tmup = bool(na) tmdown = bool(na) // if tmtype == ‘3 TM and 2 TB change to same color’ // tmup := TB1Green and TB2Green and (TrendBar1Result and TrendBar2Result and TrendBar3Result ? 1 : 0) // tmdown := TB1Red and TB2Red and (not TrendBar1Result and not TrendBar2Result and not TrendBar3Result ? 1 : 0) // else if tmtype == ‘3 TM change to same color’ // tmup := TrendBar1Result and TrendBar2Result and TrendBar3Result ? 1 : 0 // tmdown := not TrendBar1Result and not TrendBar2Result and not TrendBar3Result ? 1 : 0 // else if tmtype == ‘3 TM, 2 TB and Wavetrend change to same color’ // tmup := TB1Green and TB2Green and (TrendBar1Result and TrendBar2Result and TrendBar3Result ? 1 : 0) and MSBar1PositiveWaveTrendSignal // tmdown := TB1Red and TB2Red and (not TrendBar1Result and not TrendBar2Result and not TrendBar3Result ? 1 : 0) and MSBar1NegativeWaveTrendSignal hullup = bool(na) hulldown = bool(na) if respecthull hullup := HULL > HULL[2] hulldown := HULL < HULL[2] rsiup = bool (na) rsidown = bool (na) if rsitype == ‘RSI MA Cross’ rsiup := rsi > rsiMA rsidown := rsi < rsiMA else if rsitype == ‘RSI Exits OB/OS zones’ rsiup := rsi > rsi_lower and rsi[1] < rsi_lower rsidown := rsi < rsi_upper and rsi[1] > rsi_upper else if rsitype == ‘RSI Level’ rsiup := rsi > respectrsilevel rsidown := rsi < respectrsilevel if macdtype == ‘MACD Crossover’ ismacdup := macdd > signal ismacddown := macdd < signal else if macdtype == ‘Zero line crossover’ ismacdup := macdd > signal and macdd > 0.00000 ismacddown := macdd < signal and macdd < 0.00000 uprf = bool (na) downrf = bool(na) if rftype == ‘Default’ uprf := src > filt and src > src[1] and upward > 0 or src > filt and src < src[1] and upward > 0 downrf := src < filt and src < src[1] and downward > 0 or src < filt and src > src[1] and downward > 0 else if rftype == ‘DW’ uprf := rfupward downrf := rfdownward ema3_long = first_3ema > second_3ema and first_3ema > third_3ema and second_3ema>third_3ema ema3_short = first_3ema < second_3ema and first_3ema < third_3ema and second_3ema<third_3ema longCond := leadinglongcond and (respectrf?uprf:justcontinue) and (respectadx?adxupcondition:justcontinue) and (respecttsi?tsi_long:justcontinue) and (respecthacolt?hacolt_long:justcontinue) and (respectmd?md_long:justcontinue) and (respecttdfi?tdfi_long:justcontinue) and (respectdpo?dpo_long:justcontinue) and (respectrd? rd_signal:justcontinue) and (respectci?ci_filter:justcontinue) and (respectroc?roc_long:justcontinue) and (respectht?halftrend_long:justcontinue) and (respectdonchian?donchian_long:justcontinue) and (respecttrendline_breakout?tb_buysignal:justcontinue) and (respectbbpt?bbpt_long:justcontinue) and (respectrqk?rqkuptrend:justcontinue) and (respectbx?bx_long:justcontinue) and (respectbbosc?bbosc_long:justcontinue) and (respectwae?wae_long:justcontinue) and (respectce?ce_long:justcontinue) and (respectssl?ssl_long:justcontinue) and (respect2ma?ema2_long:justcontinue) and (respect3ma?ema3_long:justcontinue) and (respectstochastic?stoch_long:justcontinue) and (respectcci?ccilong:justcontinue) and (respectst?isstup:justcontinue) and (respectrsi?rsiup:justcontinue) and (respectrsimalimit?rsimalimitlong:justcontinue) and (respectrsilimit?rsilimitlong:justcontinue) and (respectrsima?rsimalong2:justcontinue) and (respectema?isaboverespectema:justcontinue) and (respectqqe?isqqeabove:justcontinue) and (respectsar?sarup:justcontinue) and (respectvol?longvol:justcontinue) and (respectchaikin?chaikin_long:justcontinue) and (respectvwap?long_vwap:justcontinue) and (respectvo?vo_long:justcontinue) and (respectao?ao_long:justcontinue) and (respectsuperichi?superichi_long:justcontinue) and (respectwolf?wolf_long:justcontinue) and (respectichi?ichi_long:justcontinue) and (respectmacd?ismacdup:justcontinue) and (respecthull?hullup:justcontinue) and (respectvi?vipcondition:justcontinue) and (respectstc?stcup:justcontinue) and (respectdv?dvup:justcontinue) //and (respecttm?tmup:justcontinue) shortCond := leadingshortcond and (respectrf?downrf:justcontinue) and (respectadx?adxdowncondition:justcontinue) and (respecttsi?tsi_short:justcontinue) and (respecthacolt?hacolt_short:justcontinue) and (respectmd?md_short:justcontinue) and (respecttdfi?tdfi_short:justcontinue) and (respectdpo?dpo_short:justcontinue) and (respectrd? rd_signal:justcontinue) and (respectci?ci_filter:justcontinue) and (respectroc?roc_short:justcontinue) and (respectht?halftrend_short:justcontinue) and (respecttrendline_breakout?tb_sellsignal:justcontinue) and (respectdonchian?donchian_short:justcontinue) and (respectbbpt?bbpt_short:justcontinue) and (respectrqk?rqkdowntrend:justcontinue) and (respectbx?bx_short:justcontinue) and (respectbbosc?bbosc_short:justcontinue) and (respectwae?wae_short:justcontinue) and (respectce?ce_short:justcontinue) and (respectssl?ssl_short:justcontinue) and (respectchaikin?chaikin_short:justcontinue) and (respect2ma?ema2_short:justcontinue) and (respect3ma?ema3_short:justcontinue) and (respectstochastic?stoch_short:justcontinue) and (respectcci?ccishort:justcontinue) and (respectrsimalimit?rsimalimitshort:justcontinue) and (respectrsilimit?rsilimitshort:justcontinue) and (respectrsima?rsimashort2:justcontinue) and (respectst?isstdown:justcontinue) and (respectrsi?rsidown:justcontinue) and (respectema?isbelowrespectema:justcontinue) and (respectqqe?isqqebelow:justcontinue) and (respectsar?sardown:justcontinue) and (respectvol?shortvol:justcontinue) and (respectvwap?short_vwap:justcontinue) and (respectvo?vo_short:justcontinue) and (respectao?ao_short:justcontinue) and (respectsuperichi?superichi_short:justcontinue) and (respectwolf?wolf_short:justcontinue) and (respectichi?ichi_short:justcontinue) and (respectmacd?ismacddown:justcontinue) and (respecthull?hulldown:justcontinue) and (respectvi?vimcondition:justcontinue) and (respectstc?stcdown:justcontinue) and (respectdv?dvup:justcontinue) //and (respecttm?tmdown:justcontinue) var int leadinglong_count = 0 var int leadinglong_count2 = 0 var int leadingshort_count = 0 var int leadingshort_count2 = 0 if leadinglongcond leadinglong_count := leadinglong_count + 1 leadinglong_count2 := leadinglong_count for i = 1 to 100 if leadinglongcond[i] leadinglong_count := leadinglong_count + 1 leadinglong_count2 := leadinglong_count else leadinglong_count := 0 break if leadingshortcond leadingshort_count := leadingshort_count + 1 leadingshort_count2 := leadingshort_count for i = 1 to 100 if leadingshortcond[i] leadingshort_count := leadingshort_count + 1 leadingshort_count2 := leadingshort_count else leadingshort_count := 0 break CondIni = 0 longCondition = bool (na) shortCondition = bool(na) // if expiry option is used longcond_withexpiry = longCond and leadinglong_count2 <= signalexpiry shortcond_withexpiry = shortCond and leadingshort_count2 <= signalexpiry log.info(“leadinglong_count2 : {0}”,leadinglong_count2) log.info(“leadingshort_count2: {0}”,leadingshort_count2) //without expiry longCondition := longcond_withexpiry and CondIni[1] == -1 shortCondition := shortcond_withexpiry and CondIni[1] == 1 if alternatesignal longCondition := longcond_withexpiry and CondIni[1] == -1 shortCondition := shortcond_withexpiry and CondIni[1] == 1 else longCondition := longcond_withexpiry shortCondition := shortcond_withexpiry CondIni := longcond_withexpiry ? 1 : shortcond_withexpiry ? -1 : CondIni[1] is_expiry_count_crossed_long = leadinglong_count2 >= signalexpiry is_expiry_count_crossed_short = leadingshort_count2 >= signalexpiry plotshape(showsignal ? (longCondition[1] ? false : longCondition) : na, title=’Buy Signal’, text=’long’, textcolor=color.new(color.white, 0), style=shape.labelup, size=size.tiny, location=location.belowbar, color=color.new(color.green, 0)) plotshape(showsignal and shortCondition and showsignal, title=’Sell Signal’, text=’short’, textcolor=color.new(color.white, 0), style=shape.labeldown, size=size.tiny, location=location.abovebar, color=color.new(color.red, 0)) alertcondition(longCondition, title=’Buy Alert’, message=’BUY’) alertcondition(shortCondition, title=’Sell Alert’, message=’SELL’) alertcondition(longCondition or shortCondition, title=’Buy or Sell Alert’, message=”Buy or Sell Alert”) rsitype2 = rsitype if rsitype2 == “RSI Level” rsitype2 := “RSI Level (” + str.tostring(respectrsilevel) +”)” confirmation_counter = array.new_string(0) confirmation_val = array.new_string(0) confirmation_val_short = array.new_string(0) pushConfirmation(respect, label, longCondition, shortCondition) => if respect array.push(confirmation_counter, label) array.push(confirmation_val, longCondition ? “✔️” : “❌”) array.push(confirmation_val_short, shortCondition ? “✔️” : “❌”) pushConfirmation(respectema, “EMA”, isaboverespectema, isbelowrespectema) pushConfirmation(respect2ma, “2 EMA Cross (” + str.tostring(respect2maperiod_1) + “,” + str.tostring(respect2maperiod_2) + “)”, ema2_long, ema2_short) pushConfirmation(respect3ma, “3 EMA Cross (” + str.tostring(respect3maperiod_1) + “,” + str.tostring(respect3maperiod_2) + “,” + str.tostring(respect3maperiod_3) + “)”, ema3_long, ema3_short) pushConfirmation(respectrf, “Range Filter”, uprf, downrf) pushConfirmation(respectrqk, “Rational Quadratic Kernel (RQK)”, rqkuptrend, rqkdowntrend) pushConfirmation(respectst, “SuperTrend”, isstup, isstdown) pushConfirmation(respectht, “Half Trend”, halftrend_long, halftrend_short) pushConfirmation(respecttrendline_breakout, “Trendline breakout”, tb_buysignal, tb_sellsignal) pushConfirmation(respectrd, “Range Detector”, rd_long, rd_short) pushConfirmation(respecthacolt, “Heiken-Ashi Candlestick Oscillator”, hacolt_long, hacolt_short) pushConfirmation(respectdonchian, “Donchian Trend Ribbon”, donchian_long, donchian_short) pushConfirmation(respectroc, “Rate of Change (ROC)”, roc_long, roc_short) pushConfirmation(respecttsi, “True Strength Indicator (TSI)”, tsi_long, tsi_short) pushConfirmation(respecttdfi, “Trend Direction Force Index (TDFI)”, tdfi_long, tdfi_short) pushConfirmation(respectbx, “B-Xtrender (” + str.tostring(bxtype) + “)”, bx_long, bx_short) pushConfirmation(respectbbpt, “Bull Bear Power Trend (” + str.tostring(bbpttype) + “)”, bbpt_long, bbpt_short) pushConfirmation(respectvwap, “VWAP”, long_vwap, short_vwap) pushConfirmation(respectichi, “Ichimoku Cloud”, ichi_long, ichi_short) pushConfirmation(respectsuperichi, “Superichi”, superichi_long, superichi_short) pushConfirmation(respectbbosc, “BB Oscillator”, bbosc_long, bbosc_short) // pushConfirmation(respecttm, “Trend Meter”, tmup, tmdown) pushConfirmation(respectce, “Chandelier Exit”, ce_long, ce_short) pushConfirmation(respectcci, “CCI”, ccilong, ccishort) pushConfirmation(respectadx, “DMI (Adx) (” + str.tostring(adxtype) + “)”, adxupcondition, adxdowncondition) pushConfirmation(respectsar, “Parabolic SAR”, sarup, sardown) pushConfirmation(respectssl, “SSL Channel”, ssl_long, ssl_short) pushConfirmation(respectvo, “Volatility Oscillator”, vo_long, vo_short) pushConfirmation(respectdpo, “Detrended Price Oscillator(DPO)”, dpo_long, dpo_short) pushConfirmation(respectmd, “McGinley Dynamic”, md_long, md_short) pushConfirmation(respectdv, “DV”, dvup, dvup) // Note: Both are ‘dvup’. Double-check if it’s intended. pushConfirmation(respectci, “Choppiness Index”, ci_filter, ci_filter) // Note: Both are ‘dvup’. Double-check if it’s intended. pushConfirmation(respectstochastic, “Stochastic (” + str.tostring(stochtype) + “)”, stoch_long, stoch_short) pushConfirmation(respectrsi, “RSI (” + str.tostring(rsitype2) + “)”, rsiup, rsidown) pushConfirmation(respectmacd, “MACD (” + str.tostring(macdtype) + “)”, ismacdup, ismacddown) pushConfirmation(respectstc, “Schaff Trend Cycle”, stcup, stcdown) pushConfirmation(respectwae, “Waddah Attar Explosion”, wae_long, wae_short) pushConfirmation(respectchaikin, “Chaikin Money Flow”, chaikin_long, chaikin_short) pushConfirmation(respectvol, “Volume”, longvol, shortvol) pushConfirmation(respectao, “Awesome Oscillator(” + str.tostring(aotype) + “)”, ao_long, ao_short) pushConfirmation(respectwolf, “Wolfpack Id”, wolf_long, wolf_short) pushConfirmation(respectqqe, “QQE Mod (” + str.tostring(qqetype) + “)”, isqqeabove, isqqebelow) pushConfirmation(respecthull, “HullSuite”, hullup, hulldown) pushConfirmation(respectvi, “Vortex Index (” + str.tostring(vitype) + “)”, vipcondition, vimcondition) getFalseShortConditionItems(arrShort) => sShort = “” if array.size(arrShort) > 0 for i = 0 to array.size(arrShort) – 1 if array.get(arrShort, i) == “❌” sShort := sShort + array.get(confirmation_counter, i) + “\n” sShort falseShortConditionString = getFalseShortConditionItems(confirmation_val_short) tooltipS = “🔴 Failed Short Confirmations: ” + “\n” + “————————–” + “\n” + falseShortConditionString labelShortCondition = showsignal and is_expiry_count_crossed_short and not is_expiry_count_crossed_short[1] and CondIni == 1 if labelShortCondition label.new(bar_index, low, “🔴”, color=color.new(#dd1111, 0), textcolor=color.white, style=label.style_none, yloc=yloc.belowbar, size=size.small, tooltip=tooltipS) getFalseLongConditionItems(arr) => s = “” if array.size(arr) > 0 for i = 0 to array.size(arr) – 1 if array.get(arr, i) == “❌” s := s + array.get(confirmation_counter, i) + “\n” s falseLongConditionString = getFalseLongConditionItems(confirmation_val) tooltipL = “🔴 Failed Long Confirmations: ” + “\n” + “————————–” + “\n” + falseLongConditionString labelCondition = showsignal and is_expiry_count_crossed_long and not is_expiry_count_crossed_long[1] and CondIni == -1 if labelCondition label.new(bar_index, high, “🔴”, color=color.new(color.green, 0), textcolor=color.white, style=label.style_none, yloc=yloc.abovebar, size=size.small, tooltip=tooltipL) leadingstatus = leadinglongcond ? “✔️” : “❌” leadingstatus_short = leadingshortcond ? “✔️” : “❌” rowcount = int(na) if array.size(confirmation_counter) ==0 rowcount := 5 else rowcount := array.size(confirmation_counter)+4 if showdashboard var table tab1 = table.new(i_tab1Ypos + ‘_’ + i_tab1Xpos, 3, rowcount, color.rgb(42, 46, 57), color.rgb(204, 204, 204), 0, color.rgb(77, 71, 71), 1) table.cell(tab1, 1, 0,”Long”, text_halign=text.align_left, text_size=table_size(in_dashboardtab_size), bgcolor=color.rgb(61, 189, 72),text_color=color.white) table.cell(tab1, 2, 0,”Short”, text_halign=text.align_left, text_size=table_size(in_dashboardtab_size), bgcolor=color.rgb(243, 77, 77),text_color=color.white) table.cell(tab1, 0, 1, “Leading Indicator”, text_halign=text.align_left, text_size=table_size(in_dashboardtab_size), bgcolor=color.rgb(68, 68, 67),text_color=color.white) table.cell(tab1, 1, 1,””, text_halign=text.align_left, text_size=table_size(in_dashboardtab_size), bgcolor=color.rgb(68, 68, 67),text_color=color.white) table.cell(tab1, 2, 1,””, text_halign=text.align_left, text_size=table_size(in_dashboardtab_size), bgcolor=color.rgb(68, 68, 67),text_color=color.white) table.cell(tab1, 0, 2, leadingindicator, text_halign=text.align_left, text_size=table_size(in_dashboardtab_size), text_color=color.white) table.cell(tab1, 1, 2, leadingstatus, text_halign=text.align_left, text_size=table_size(in_dashboardtab_size), text_color=color.white) table.cell(tab1, 2, 2, leadingstatus_short, text_halign=text.align_left, text_size=table_size(in_dashboardtab_size), text_color=color.white) table.cell(tab1, 0, 3, “Confirmation Indicators”, text_halign=text.align_left, text_size=table_size(in_dashboardtab_size), bgcolor=color.rgb(68, 68, 67),text_color=color.white) table.cell(tab1, 1, 3, “”, text_halign=text.align_left, text_size=table_size(in_dashboardtab_size), bgcolor=color.rgb(68, 68, 67),text_color=color.white) table.cell(tab1, 2, 3, “”, text_halign=text.align_left, text_size=table_size(in_dashboardtab_size), bgcolor=color.rgb(68, 68, 67),text_color=color.white) if array.size(confirmation_counter) > 0 for i=0 to array.size(confirmation_counter)-1 table.cell(tab1, 0, 4+i, array.get(confirmation_counter,i), text_halign=text.align_left, text_size=table_size(in_dashboardtab_size), text_color=color.white) else table.cell(tab1, 0, 4, “None Selected”, text_halign=text.align_left, text_size=table_size(in_dashboardtab_size), text_color=color.white) if array.size(confirmation_val) > 0 for j=0 to array.size(confirmation_val)-1 table.cell(tab1, 1, 4+j, array.get(confirmation_val,j), text_halign=text.align_left, text_size=table_size(in_dashboardtab_size), text_color=color.white) table.cell(tab1, 2, 4+j, array.get(confirmation_val_short,j), text_halign=text.align_left, text_size=table_size(in_dashboardtab_size), text_color=color.white) plot(longCondition?100:na, “long Signal”,display = display.data_window ) plot(shortCondition?-100:na, “Short Signal”,display = display.data_window )

This topic has 0 replies, 1 voice, and was last updated 14 hours ago by Stenozar.

Viewing 1 post (of 1 total)

08/19/2025 at 8:37 PM #249890

Stenozar

Ciao, chiedo la traduzione del seguente codice, grazie.

//@ZPayab

//@version=5

indicator(title=’DIY Custom Strategy Builder [ZP] – v1′, shorttitle=”DIY Custom Strategy Builder [ZP] – v1″, overlay=true, max_bars_back=500)

ma(_source, _length, _type) =>
switch _type
“SMA” => ta.sma (_source, _length)
“EMA” => ta.ema (_source, _length)
“RMA” => ta.rma (_source, _length)
“WMA” => ta.wma (_source, _length)
“VWMA” => ta.vwma(_source, _length)

alarm(_osc, _message) =>
alert(syminfo.ticker + ‘ ‘ + _osc + ‘ : ‘ + _message + ‘, price (‘ + str.tostring(close, format.mintick) + ‘)’)

//Conditional Sampling EMA Function
Cond_EMA(x, cond, n) =>
var val = array.new_float(0)
var ema_val = array.new_float(1)
if cond
array.push(val, x)
if array.size(val) > 1
array.remove(val, 0)
if na(array.get(ema_val, 0))
array.fill(ema_val, array.get(val, 0))
array.set(ema_val, 0, (array.get(val, 0) – array.get(ema_val, 0)) * (2 / (n + 1)) + array.get(ema_val, 0))
EMA = array.get(ema_val, 0)
EMA

//Conditional Sampling SMA Function
Cond_SMA(x, cond, n) =>
var vals = array.new_float(0)
if cond
array.push(vals, x)
if array.size(vals) > n
array.remove(vals, 0)
SMA = array.avg(vals)
SMA

//Standard Deviation Function
Stdev(x, n) =>
math.sqrt(Cond_SMA(math.pow(x, 2), 1, n) – math.pow(Cond_SMA(x, 1, n), 2))

//Range Size Function
rng_size(x, scale, qty, n) =>
ATR = Cond_EMA(ta.tr(true), 1, n)
AC = Cond_EMA(math.abs(x – x[1]), 1, n)
SD = Stdev(x, n)
rng_size = scale == ‘Pips’ ? qty * 0.0001 : scale == ‘Points’ ? qty * syminfo.pointvalue : scale == ‘% of Price’ ? close * qty / 100 : scale == ‘ATR’ ? qty * ATR : scale == ‘Average Change’ ? qty * AC : scale == ‘Standard Deviation’ ? qty * SD : scale == ‘Ticks’ ? qty * syminfo.mintick : qty
rng_size

//Two Type Range Filter Function
rng_filt(h, l, rng_, n, type, smooth, sn, av_rf, av_n) =>
rng_smooth = Cond_EMA(rng_, 1, sn)
r = smooth ? rng_smooth : rng_
var rfilt = array.new_float(2, (h + l) / 2)
array.set(rfilt, 1, array.get(rfilt, 0))
if type == ‘Type 1’
if h – r > array.get(rfilt, 1)
array.set(rfilt, 0, h – r)
if l + r < array.get(rfilt, 1)
array.set(rfilt, 0, l + r)
if type == ‘Type 2’
if h >= array.get(rfilt, 1) + r
array.set(rfilt, 0, array.get(rfilt, 1) + math.floor(math.abs(h – array.get(rfilt, 1)) / r) * r)
if l <= array.get(rfilt, 1) – r
array.set(rfilt, 0, array.get(rfilt, 1) – math.floor(math.abs(l – array.get(rfilt, 1)) / r) * r)
rng_filt1 = array.get(rfilt, 0)
hi_band1 = rng_filt1 + r
lo_band1 = rng_filt1 – r
rng_filt2 = Cond_EMA(rng_filt1, rng_filt1 != rng_filt1[1], av_n)
hi_band2 = Cond_EMA(hi_band1, rng_filt1 != rng_filt1[1], av_n)
lo_band2 = Cond_EMA(lo_band1, rng_filt1 != rng_filt1[1], av_n)
rng_filt = av_rf ? rng_filt2 : rng_filt1
hi_band = av_rf ? hi_band2 : hi_band1
lo_band = av_rf ? lo_band2 : lo_band1
[hi_band, lo_band, rng_filt]

ma_function(source, length, type) =>

if type == ‘RMA’
ta.rma(source, length)
else if type == ‘SMA’
ta.sma(source, length)
else if type == ‘EMA’
ta.ema(source, length)
else if type == ‘WMA’
ta.wma(source, length)
else if type == ‘HMA’
if(length<2)
ta.hma(source,2)
else
ta.hma(source, length)
else
ta.vwma(source, length)

// Get Table Size
table_size(s) =>
switch s
“Auto” => size.auto
“Huge” => size.huge
“Large” => size.large
“Normal” => size.normal
“Small” => size.small
=> size.tiny

setup_group= “████████ Indicator Setup ████████”
signalexpiry = input.int(defval=3, title=’Signal Expiry Candle Count’,group=setup_group, inline=’expiry’,tooltip=”Number of candles to wait for all indicators to confirm a signal. Default is 3 which means if leading indicator print the signal, it will wait for max 3 more candles for rest of the indicators to print signal, if not then this setup is invalided and will have to wait for another signal form the leading indicator.”)
alternatesignal = input.bool (true, “Alternate Signal”, group=setup_group, inline=’alternate’)

showsignal = input.bool (true, “Show Long/Short Signal”, group=setup_group,inline=’showsignal’,tooltip=”Option to turn on/off the Long/Short signal shown on the chart. by default it will print Long/ Short signal on the chart.”)

showdashboard = input.bool (true, “Show Dashboard”, group=setup_group,inline=’dashboard’)
string i_tab1Ypos = input.string(‘bottom’, ‘Dashboard Position’,group=setup_group, inline=’dashboard2′, options=[‘top’, ‘middle’, ‘bottom’])
string i_tab1Xpos = input.string(‘right’, ”, inline=’dashboard2′, group=setup_group,options=[‘left’, ‘center’, ‘right’])
in_dashboardtab_size = input.string(title=”Dashboard Size ”, defval=”Normal”,
options=[“Auto”, “Huge”, “Large”, “Normal”, “Small”, “Tiny”],
group= setup_group , inline= “dashboard3″)

///////////////////////////////////////////////
///// Signal filters
/////////////////////////////////////////////
leadingindicator = input.string(title=”Leading Indicator”, defval=”Range Filter”,
options=[“Range Filter”, “Rational Quadratic Kernel (RQK)”,”Supertrend”,”Half Trend”,”Ichimoku Cloud”,”SuperIchi”,”True Strength Indicator (TSI)”,”Trend Direction Force Index (TDFI)”,”Trendline Breakout”,”Range Detector”,”Heiken-Ashi Candlestick Oscillator”,”Donchian Trend Ribbon”,”Stochastic”,”RSI”,”Rate of Change (ROC)”,”VWAP”,”CCI”,”2 EMA Cross”,”3 EMA Cross”,”B-Xtrender”,”Bull Bear Power Trend”,”Detrended Price Oscillator (DPO)”,”BB Oscillator”,”Chandelier Exit”,”DMI (Adx)”,”Parabolic SAR (PSAR)”,”MACD”,”SSL Channel”,”Waddah Attar Explosion”,”Chaikin Money Flow”,”Vortex Index”,”Schaff Trend Cycle (STC)”,”Awesome Oscillator”,”Volatility Oscillator”,”Wolfpack Id”,”QQE Mod”,”Hull Suite”], group=’████████ Main Indicator (signal) ████████’, inline=’li’)

confirmation_group = “████████ Confirmation Indicators (filter) ████████ ”

ema_tooltip = “EMA filter for confirmation.\n\n Validates Long signal if price is above the EMA FILTER level, and validates Short signal if price is below the EMA FILTER level. \n\nDefault is 200, you can change that to meet your requiremnt.”
respectema = input.bool (false, “EMA Filter”, group=confirmation_group, inline=’respectema’)
respectemaperiod = input.int(defval=200, minval=1, title=”, group=confirmation_group, inline=’respectema’, tooltip=ema_tooltip)

ema2_tooltip = “Generates Long signal if Fast EMA cross above Slow EMA.\n\n Generates Short signal when Fast EMA cross below the Slow EMA.\n\n Default values are 50 and 200. you can change that to meet your requirement.”
respect2ma = input.bool (false, “2 EMA Cross : “, group=confirmation_group, inline=’2ma’)
respect2maperiod_1 = input.int(defval=50, title=”,group=confirmation_group, inline=’2ma’)
respect2maperiod_2 = input.int(defval=200, title=”,group=confirmation_group, inline=’2ma’,tooltip=ema2_tooltip)
signal_type = input.string(“Default”, “Signal Type”,group=confirmation_group, options=[“Default”, “Lookback”], inline=’2ma’)
lookback_period = input.int(defval=3, title=”Lookback Period”,group=confirmation_group, minval=1, tooltip=”Number of candles to look back for confirming the cross”, inline=’2ma’)

ema3_tooltip = “Generates Long signal if first EMA (Fastest) cross above 2nd and 3rd EMA and 2nd EMA cross above 3rd EMA.\n\n Generates Short signal if first EMA (Fastest) cross below 2nd and 3rd EMA and 2nd EMA cross below 3rd EMA .\n\n Default values are 9,21 and 55. you can change that to meet your requirement.”
respect3ma = input.bool (false, “3 EMA Cross : “, group=confirmation_group, inline=’3ma’,tooltip=ema3_tooltip)
respect3maperiod_1 = input.int(defval=9, title=”,group=confirmation_group, inline=’3ma’,tooltip=ema3_tooltip)
respect3maperiod_2 = input.int(defval=21, title=”,group=confirmation_group, inline=’3ma’,tooltip=ema3_tooltip)
respect3maperiod_3 = input.int(defval=55, title=”,group=confirmation_group, inline=’3ma’,tooltip=ema3_tooltip)

respectrf = input.bool (false, “Range Filter”, group=confirmation_group, inline=’rf’)
rftype = input.string(title=””, defval=”Default”, options=[“Default”,”DW”], group=confirmation_group, inline=’rf’)

respectrqk = input.bool (true, “Rational Quadratic Kernel (RQK)”, group=confirmation_group, inline=’rqk’,tooltip=”Nadaraya Watson: Rational Quadratic Kernel (RQK)”)

respectst = input.bool (false, “SuperTrend”, group=confirmation_group, inline=’st’)

respectht = input.bool (false, “Half Trend”, group=confirmation_group, inline=’ht’)

respectdonchian = input.bool (false, “Donchian Trend Ribbon”, group=confirmation_group, inline=’donchian’)

respectroc = input.bool (false, “Rate of Change (ROC)”, group=confirmation_group, inline=’roc’)

respecttsi = input.bool (false, “True Strength Indicator (TSI)”, group=confirmation_group, inline=’tsi’)

tsitooltip = “Signal Crossover:\n\n TSI crossover or greater than signal line for long, and TSI crossunder signal line for short.\n\n Zero Line Cross:\n\n TSI cross above zero line and signal line for long signal. Tsi Cross below zero and signal line for short signal.”
tsitype = input.string(title=””, defval=”Signal Cross”, options=[“Signal Cross”, “Zero line cross”],tooltip=tsitooltip, group=confirmation_group, inline=’tsi’)

respecttdfi = input.bool (false, “Trend Direction Force Index (TDFI)”, group=confirmation_group, inline=’tdfi’)

respectmd = input.bool (false, “McGinley Dynamic”, group=confirmation_group, inline=’md’)

respectdpo = input.bool (false, “Detrended Price Oscillator (DPO)”, group=confirmation_group, inline=’dpo’)

respectichi = input.bool (false, “Ichimoku Cloud”, group=confirmation_group, inline=’ichi’)

respectsuperichi = input.bool (false, “SuperIchi”, group=confirmation_group, inline=’ichi’,tooltip=”Ichimoku Cloud Conditions: \n \n 1. Candle above cloud \n \n 2. Converstion Line above base line \n \n 3. Leading 26 bar cloud is green \n \n 4. lagging span is above the cloud”)

respecttrendline_breakout = input.bool (false, “Trendline Breakout”, group=confirmation_group, inline=’tb’)

respectrd = input.bool (false, “Range Detector”, group=confirmation_group, inline=’rd’,tooltip=”Range Detector:\n\n if used as leading indicator, it will be based on range breakout. \n\n If used as confirmation indicator, it will be used to filter entries within the active range area.”)

respecthacolt = input.bool (false, “Heiken-Ashi Candlestick Oscillator”, group=confirmation_group, inline=’hacolt’,tooltip=”Vervoort LongTerm Heiken-Ashi Candlestick Oscillator:\n\n If oscilliation is above 0 line, then long signal is issued and if below zero line, short signal is issued.”)

respectbx = input.bool (false, “B-Xtrender”, group=confirmation_group, inline=’bx’)
bxtype = input.string(title=””, defval=”Short and Long term trend”, options=[“Short and Long term trend”,”Short Term trend”], group=confirmation_group, inline=’bx’, tooltip = “Short term trend:\n\n===================== \n\n For buy signal the short term trend line must turn green, and for the sell signal, the short term trend line must turn red. \n\n Short and Long term trend: \n\n===================== \n\n For buy signal, the short term trend must change from red to green and long term trend cross above zero line, for Sell signal the short term trend must turn red and long term trend line cross down the zero line..”)

respectbbpt = input.bool (false, “Bull bear Power Trend”, group=confirmation_group, inline=’bbpt’)
bbpttype = input.string(title=””, defval=”Follow Trend”, options=[“Follow Trend”,”Without Trend”], group=confirmation_group, inline=’bbpt’, tooltip = “Follow Trend:\n\n===================== \n\n Buy signal will be validated if the BBPT trend line is above 2, and Sell signal will be validated if BBPT trend line is below -2. \n\n Without Trend: \n\n===================== \n\n Ignore the BBPT trend line.”)

respectvwap = input.bool (false, “VWAP”, group=confirmation_group, inline=’vwap’)

respectbbosc = input.bool (false, “BB Oscillator”, group=confirmation_group, inline=’bbosc’)
bbtype = input.string(title=””, defval=”Entering Lower/Upper Band”, options=[“Entering Lower/Upper Band”,”Exiting Lower/Upper Band”], group=confirmation_group, inline=’bbosc’)

// respecttm = input.bool (false, “Trend Meter”, group=confirmation_group, inline=’tm’)
// tmtype = input.string(title=””, defval=”3 TM and 2 TB change to same color”, options=[“3 TM change to same color”, “3 TM and 2 TB change to same color”, “3 TM, 2 TB and Wavetrend change to same color”], group=confirmation_group, inline=’tm’)

respectce = input.bool (false, “Chandelier Exit”, group=confirmation_group, inline=’ce’)

respectcci = input.bool (false, “CCI”, group=confirmation_group, inline=’cci’)

respectao = input.bool (false, “Awesome Oscillator”, group=confirmation_group, inline=’ao’)
aotype = input.string(title=””, defval=”Zero Line Cross”, options=[“Zero Line Cross”,”AC Zero Line Cross”,”AC Momentum Bar”], group=confirmation_group, inline=’ao’, tooltip = “Zero Line Cross:\n\n If AO value cross the zero line up, Buy signal will be generated, and if AO value cross down the zero line, sell signal will be generated.”)

respectadx = input.bool (false, “DMI (ADx)”, group=confirmation_group, inline=’adx’)
adxtype = input.string(title=””, defval=”Adx & +Di -Di”, options=[“Adx Only”,”Adx & +Di -Di”, “Advance”], group=confirmation_group, inline=’adx’, tooltip = “Adx Only:\n\n If Adx value is above the defined level. \n\n Adx & +Di -DI :\n\n When Adx value is above the defined level and croseeover between +di and -di. Di will determine the direction of the movement. \n\n Advance: “)

respectsar = input.bool (false, “Parabolic SAR (PSAR)”, group=confirmation_group, inline=’sar’)

respectwae = input.bool (false, “Waddah Attar Explosion”, group=confirmation_group, inline=’wae’)

vo_tooltip = “Volatility Oscillator: \n\n ======================= \n\n If the spike line is above the upper line, buy signal is generated (or validated). \n\n If the spike line is below the lower line, sell signal is generated (or validated).”
respectvo = input.bool (false, “Volatility Oscillator”, group=confirmation_group, inline=’vo’, tooltip = vo_tooltip)

ci_tooltip = “Choppiness index: \n\n ======================= \n\n If the index is below the defined threshold (default 61.8) then asset is considered trending and signal will be validated, if index is above 61.8 then asset is considered having sideway movement.”
respectci = input.bool (false, “Choppiness Index “, group=confirmation_group, inline=’ci’)
ci_limit = input.float(61.8,title=” “, inline=’ci’,group=confirmation_group, tooltip = ci_tooltip)

respectdv = input.bool (false, “Damiani Volatility (DV)”, group=confirmation_group, inline=’dv’)

dvtype = input.string(title=””, defval=”Simple”, options=[“Simple”, “Threshold”,”10p Difference”], group=confirmation_group, inline=’dv’, tooltip = “Simple\n Volatility is green. \nThreshold\n Volatility green and >1.1″)

stochtooltip=”CrossOver:\n——————\n\n CrossOver of K and D line at any level. \n\n CrossOver in OB & OS levels:\n\n Generate buy signal if crossover happens in oversold area and crossing up oversold level.\n\n Generate sell signal on crossover in overbought area and cross down upper level. \n——————\n\n %K above/below %D\n——————\n: Generate Buy signal or validate other signal if %K is above %D and opposite for Sell Signal.”

respectstochastic = input.bool (false, “Stochastic”, group=confirmation_group, inline=’stoch’)
stochtype = input.string(title=””, defval=”CrossOver”, options=[“CrossOver”, “CrossOver in OB & OS levels”,”%K above/below %D”],tooltip=stochtooltip, group=confirmation_group, inline=’stoch’)
rsi_tooltip = “RSI MA Cross:\n=============\n Generate buy signal when RSI cross up RSI MA line and sell signal when RSI cross down RSI MA line.\n\nRSI Exits OB/OS zones:\n==================\n Generate Buy signal when RSI crosses down the overbough zone and sell signal when RSI crosses up the oversold zone.\n\nRSI Level:\n==========\nGenerate buy signal if RSI cross above the specific level and sell signal when RSI crossdown the level.\n\n\n +++++\nYou can change the setting to define the OB/OS and MidLine Levels”

respectrsi = input.bool (false, “RSI”, group=confirmation_group, inline=’rsi’)
rsitype = input.string(title=””, defval=”RSI MA Cross”, options=[“RSI MA Cross”, “RSI Exits OB/OS zones”,”RSI Level”], tooltip=rsi_tooltip, group=confirmation_group, inline=’rsi’)

rsima_tooltip = “RSI MA Direction:\n=============\n The buy and sell signal will respect the RSI MA direction. For buy signal, the RSI MA should be increasing or same compared to previous RSI MA. \n\n for SHORT, the RSI MA should be same or decreasing compared to last RSI MA”
respectrsima = input.bool (false, “RSI MA Direction”, group=confirmation_group, inline=’rsi2′,tooltip=rsima_tooltip)

rsilimit_tooltip = “RSI Limit:\n=============\n This is to allow you to set limit for the RSI value for long and short. default value for long is 40, which means if the RSI is 40 or above, only then BUY signal will be validated. \n\nfor short if RSI is 60 or less, only then sell signal willbe validated.”
respectrsilimit = input.bool (false, “RSI Limit : “, group=confirmation_group, inline=’rsi3′,tooltip=rsilimit_tooltip)

rsilimitup = input.int(40, title=”Long”,inline=’rsi3′, group=confirmation_group)
rsilimitdown = input.int(60, title=”short”,inline=’rsi3′, group=confirmation_group)

rsimalimit_tooltip = “RSI MA Limit:\n=============\n This is to allow you to set limit for the RSI MA value for long and short. default value for long is 40, which means if the RSI MA is 40 or above, only then BUY signal will be validated. \n\nfor short if RSI MA is 60 or less, only then sell signal willbe validated.”
respectrsimalimit = input.bool (false, “RSI MA Limit : “, group=confirmation_group, inline=’rsi4′,tooltip=rsimalimit_tooltip)

rsimalimitup = input.int(40, title=”Long”,inline=’rsi4′, group=confirmation_group)
rsimalimitdown = input.int(60, title=”short”,inline=’rsi4′, group=confirmation_group)

macdtooltip=”MACD Crossover:\n——————\n\n CrossOver of MACD and the Signal line. Generates Long signal when MACD cross up Signal line and Short signal when MACD cross down Signal Line. . \n\n Zero line crossover:\n——————\n\n Generate buy signal when MACD cross up the zero line and Sell signal when MACD cross down the zero line.”
respectmacd = input.bool (false, “MACD”, group=confirmation_group, inline=’macd’)
macdtype = input.string(title=””, defval=”MACD Crossover”, options=[“MACD Crossover”, “Zero line crossover”],tooltip=macdtooltip, group=confirmation_group, inline=’macd’)

respectssl = input.bool (false, “SSL Channel”, group=confirmation_group, inline=’ssl’)

respectstc = input.bool (false, “Schaff Trend Cycle (STC)”, group=confirmation_group, inline=’stc’)
respectchaikin = input.bool (false, “Chaikin Money Flow”, group=confirmation_group, inline=’chaikin’)

respectvol = input.bool (false, “Volume”, group=confirmation_group, inline=’volume’)
volumetype = input.string(title=””, defval=”volume above MA”, options=[“volume above MA”,”Simple”, “Delta”], group=confirmation_group, inline=’volume’, tooltip = “Simple volume is comparing the up/down volme with previous candle. \nVolume delta will compare the delta or difference between up and down volume with previous candle.\nExample:\n up volume = 100 \n Down volume=-1100\n Delta = -1000\n Satisfy the bear flag condition if previous -ve delta is lower”)

respectwolf = input.bool (false, “Wolfpack Id”, group=confirmation_group, inline=’wolf’)

respectqqe = input.bool (false, “QQE Mod”, group=confirmation_group, inline=’qqe’)
qqetype = input.string(title=””, defval=”Line”, options=[“Line”, “Bar”,”Line & Bar”], group=confirmation_group, inline=’qqe’, tooltip = “Line: signal generated when QQE line is above or below 0. \nBar: when Blue bar is above 0 or Red bar below 0 \nLine & Bar: Both Bar and Line to be above(bullist) or below (bearish) 0” )

respecthull = input.bool (false, “Hull Suite”,group=confirmation_group, inline=’hull’)

respectvi = input.bool (false, “Vortex Indicator”,group=confirmation_group, inline=’vi’)
vitype = input.string(title=””, defval=”Simple”, options=[“Simple”, “Advance”],group=confirmation_group, inline=’vi’,
tooltip = “Simple\n Green Cross Red. \Advance\n vipcondition := vip > vim and vip > viupper and vip > vip[1] and vim < vim[1] and vim[1] <= vilower and vip[1] >= viupper
vimcondition := vip < vim and vim > viupper and vim > vim[1] and vip < vip [1] and vip[1] <= vilower and vim [1] >= viupper “)

/////////////////////////////////////////////////////////////////////////
// Switch Board
////////////////////////////////////////////////////////////////////////

switchboard_group = “████ Switch Board (Turn On/Off Overlay Indicators) ████”
switch_ema = input.bool (false, “EMA”, group=switchboard_group, inline=’Switch1′)
switch_poi = input.bool (true, “Supply/Demand Zone”, group=switchboard_group, inline=’Switch1′)
switch_sar = input.bool (false, “PSAR”, group=switchboard_group, inline=’Switch1′)
switch_ichi = input.bool (false, “Ichimoku Cloud”, group=switchboard_group, inline=’Switch2′)

switch_ha = input.bool (false, “Heiken-Ashi Candles”, group=switchboard_group, inline=’Switch2′)
switch_fibonacci = input.bool(false, “Fibonacci”, group=switchboard_group, inline=’Switch2′)

switch_rd = input.bool (false, “Range Detector”, group=switchboard_group, inline=’Switch2′)
switch_vwap = input.bool (false, “VWAP”, group=switchboard_group, inline=’Switch3′)
switch_bb = input.bool (false, “Bollinger Band”, group=switchboard_group, inline=’Switch3′)

switch_supertrend = input.bool (false, “Supertrend”, group=switchboard_group, inline=’Switch2′)
switch_halftrend= input.bool (false, “Half Trend”, group=switchboard_group, inline=’Switch2′)

switch_rangefilter = input.bool (false, “Range Filter”, group=switchboard_group, inline=’Switch2′)

switch_stc = input.bool (false, “STC”, group=switchboard_group, inline=’Switch3′)
switch_pvsra = input.bool (true, “PVSRA”, group=switchboard_group, inline=’Switch3′)
switch_vectorzone = input.bool (false, “Liquidity Zone”, group=switchboard_group, inline=’Switch3′)
switch_fvg = input.bool (false, “Fair Value Gap (FVG)”, group=switchboard_group, inline=’Switch4′)
switch_pivot = input.bool (false, “Pivot Levels”, group=switchboard_group, inline=’Switch4′)
switch_fractal = input.bool (false, “Fractal”, group=switchboard_group, inline=’Switch4′)

bool show_markets = input.bool(true, group=switchboard_group, title=’Market Sessions’, tooltip=’Turn on or off all market sessions’)

///////////////////////////////////////////////////////////////////////

// Fibonacci settings
fibgroup = “█████████ Fibonacci Display Settting █████████”
devTooltip = “Deviation is a multiplier that affects how much the price should deviate from the previous pivot in order for the bar to become a new pivot.”
depthTooltip = “The minimum number of bars that will be taken into account when calculating the indicator.”
threshold_multiplier2 = input.float(title=”Deviation”, defval=3, minval=0, tooltip=devTooltip,group=fibgroup)
depth2 = input.int(title=”Depth”, defval=10, minval=2, tooltip=depthTooltip,group=fibgroup)
reverse2 = input(false, “Reverse”, display = display.data_window,group=fibgroup)
var extendLeft = input(false, “Extend Left | Extend Right”, inline = “Extend Lines”,group=fibgroup)
var extendRight = input(true, “”, inline = “Extend Lines”,group=fibgroup)
var extending = extend.none
if extendLeft and extendRight
extending := extend.both
if extendLeft and not extendRight
extending := extend.left
if not extendLeft and extendRight
extending := extend.right
prices = input(false, “Show Prices”, display = display.data_window,group=fibgroup)
levels = input(true, “Show Levels”, inline = “Levels”, display = display.data_window,group=fibgroup)
levelsFormat = input.string(“Values”, “”, options = [“Values”, “Percent”], inline = “Levels”, display = display.data_window,group=fibgroup)
labelsPosition = input.string(“Left”, “Labels Position”, options = [“Left”, “Right”], display = display.data_window,group=fibgroup)
var int backgroundTransparency = input.int(85, “Background Transparency”, minval = 0, maxval = 100, display = display.data_window,group=fibgroup)

import TradingView/ZigZag/7 as zigzag

update() =>
var settings = zigzag.Settings.new(threshold_multiplier2, depth2, color(na), false, false, false, false, “Absolute”, true)
var zigzag.ZigZag zigZag = zigzag.newInstance(settings)
var zigzag.Pivot lastP = na
var float startPrice2 = na
var float height = na
settings.devThreshold := ta.atr(10) / close * 100 * threshold_multiplier2
if zigZag.update()
lastP := zigZag.lastPivot()
if not na(lastP)
var line lineLast = na
if switch_fibonacci
if na(lineLast)
lineLast := line.new(lastP.start, lastP.end, xloc=xloc.bar_time, color=color.gray, width=1, style=line.style_dashed)
else
line.set_first_point(lineLast, lastP.start)
line.set_second_point(lineLast, lastP.end)

startPrice2 := reverse2 ? lastP.start.price : lastP.end.price
endPrice = reverse2 ? lastP.end.price : lastP.start.price
height := (startPrice2 > endPrice ? -1 : 1) * math.abs(startPrice2 – endPrice)
[lastP, startPrice2, height]

[lastP, startPrice2, height] = update()

_draw_line(price, col) =>
var id = line.new(lastP.start.time, lastP.start.price, time, price, xloc=xloc.bar_time, color=col, width=1, extend=extending)
line.set_xy1(id, lastP.start.time, price)
line.set_xy2(id, lastP.end.time, price)
id

_draw_label(price, txt, txtColor) =>
x = labelsPosition == “Left” ? lastP.start.time : not extendRight ? lastP.end.time : time
labelStyle = labelsPosition == “Left” ? label.style_label_right : label.style_label_left
align = labelsPosition == “Left” ? text.align_right : text.align_left
labelsAlignStrLeft = txt + ‘\n ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ \n’
labelsAlignStrRight = ‘ ‘ + txt + ‘\n ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏ \n’
labelsAlignStr = labelsPosition == “Left” ? labelsAlignStrLeft : labelsAlignStrRight
var id = label.new(x=x, y=price, xloc=xloc.bar_time, text=labelsAlignStr, textcolor=txtColor, style=labelStyle, textalign=align, color=#00000000)
label.set_xy(id, x, price)
label.set_text(id, labelsAlignStr)
label.set_textcolor(id, txtColor)

_wrap(txt) =>
“(” + str.tostring(txt, format.mintick) + “)”

_label_txt(level, price) =>
l = levelsFormat == “Values” ? str.tostring(level) : str.tostring(level * 100) + “%”
(levels ? l : “”) + (prices ? _wrap(price) : “”)

_crossing_level(series float sr, series float r) =>
(r > sr and r < sr[1]) or (r < sr and r > sr[1])

processLevel(bool show, float value, color colorL, line lineIdOther) =>
float m = value
r = startPrice2 + height * m
crossed = _crossing_level(close, r)
if show and not na(lastP)
lineId = _draw_line(r, colorL)
_draw_label(r, _label_txt(m, r), colorL)
if crossed
alert(“Autofib: ” + syminfo.ticker + ” crossing level ” + str.tostring(value))
if not na(lineIdOther)
linefill.new(lineId, lineIdOther, color = color.new(colorL, backgroundTransparency))
lineId
else
lineIdOther

show_0 = input(true, “”, inline = “Level0”, display = display.data_window)
value_0 = input(0, “”, inline = “Level0”, display = display.data_window)
color_0 = input(#787b86, “”, inline = “Level0”, display = display.data_window)

show_0_236 = input(false, “”, inline = “Level0”, display = display.data_window)
value_0_236 = input(0.236, “”, inline = “Level0”, display = display.data_window)
color_0_236 = input(#f44336, “”, inline = “Level0”, display = display.data_window)

show_0_382 = input(false, “”, inline = “Level1”, display = display.data_window)
value_0_382 = input(0.382, “”, inline = “Level1”, display = display.data_window)
color_0_382 = input(#81c784, “”, inline = “Level1”, display = display.data_window)

show_0_5 = input(true, “”, inline = “Level1”, display = display.data_window)
value_0_5 = input(0.5, “”, inline = “Level1”, display = display.data_window)
color_0_5 = input(#4caf50, “”, inline = “Level1”, display = display.data_window)

show_0_618 = input(false, “”, inline = “Level2”, display = display.data_window)
value_0_618 = input(0.618, “”, inline = “Level2”, display = display.data_window)
color_0_618 = input(#009688, “”, inline = “Level2”, display = display.data_window)

show_0_65 = input(false, “”, inline = “Level2”, display = display.data_window)
value_0_65 = input(0.65, “”, inline = “Level2”, display = display.data_window)
color_0_65 = input(#009688, “”, inline = “Level2”, display = display.data_window)

show_0_786 = input(false, “”, inline = “Level3”, display = display.data_window)
value_0_786 = input(0.786, “”, inline = “Level3”, display = display.data_window)
color_0_786 = input(#64b5f6, “”, inline = “Level3”, display = display.data_window)

show_1 = input(true, “”, inline = “Level3”, display = display.data_window)
value_1 = input(1, “”, inline = “Level3”, display = display.data_window)
color_1 = input(#787b86, “”, inline = “Level3”, display = display.data_window)

show_1_272 = input(false, “”, inline = “Level4”, display = display.data_window)
value_1_272 = input(1.272, “”, inline = “Level4”, display = display.data_window)
color_1_272 = input(#81c784, “”, inline = “Level4”, display = display.data_window)

show_1_414 = input(false, “”, inline = “Level4”, display = display.data_window)
value_1_414 = input(1.414, “”, inline = “Level4”, display = display.data_window)
color_1_414 = input(#f44336, “”, inline = “Level4”, display = display.data_window)

show_1_618 = input(false, “”, inline = “Level5”, display = display.data_window)
value_1_618 = input(1.618, “”, inline = “Level5”, display = display.data_window)
color_1_618 = input(#2962ff, “”, inline = “Level5”, display = display.data_window)

show_1_65 = input(false, “”, inline = “Level5”, display = display.data_window)
value_1_65 = input(1.65, “”, inline = “Level5”, display = display.data_window)
color_1_65 = input(#2962ff, “”, inline = “Level5”, display = display.data_window)

show_2_618 = input(false, “”, inline = “Level6”, display = display.data_window)
value_2_618 = input(2.618, “”, inline = “Level6”, display = display.data_window)
color_2_618 = input(#f44336, “”, inline = “Level6”, display = display.data_window)

show_2_65 = input(false, “”, inline = “Level6”, display = display.data_window)
value_2_65 = input(2.65, “”, inline = “Level6”, display = display.data_window)
color_2_65 = input(#f44336, “”, inline = “Level6”, display = display.data_window)

show_3_618 = input(false, “”, inline = “Level7”, display = display.data_window)
value_3_618 = input(3.618, “”, inline = “Level7”, display = display.data_window)
color_3_618 = input(#9c27b0, “”, inline = “Level7”, display = display.data_window)

show_3_65 = input(false, “”, inline = “Level7”, display = display.data_window)
value_3_65 = input(3.65, “”, inline = “Level7”, display = display.data_window)
color_3_65 = input(#9c27b0, “”, inline = “Level7”, display = display.data_window)

show_4_236 = input(false, “”, inline = “Level8”, display = display.data_window)
value_4_236 = input(4.236, “”, inline = “Level8”, display = display.data_window)
color_4_236 = input(#e91e63, “”, inline = “Level8”, display = display.data_window)

show_4_618 = input(false, “”, inline = “Level8”, display = display.data_window)
value_4_618 = input(4.618, “”, inline = “Level8”, display = display.data_window)
color_4_618 = input(#81c784, “”, inline = “Level8”, display = display.data_window)

show_neg_0_236 = input(false, “”, inline = “Level9”, display = display.data_window)
value_neg_0_236 = input(-0.236, “”, inline = “Level9”, display = display.data_window)
color_neg_0_236 = input(#f44336, “”, inline = “Level9”, display = display.data_window)

show_neg_0_382 = input(false, “”, inline = “Level9”, display = display.data_window)
value_neg_0_382 = input(-0.382, “”, inline = “Level9”, display = display.data_window)
color_neg_0_382 = input(#81c784, “”, inline = “Level9”, display = display.data_window)

show_neg_0_618 = input(false, “”, inline = “Level10”, display = display.data_window)
value_neg_0_618 = input(-0.618, “”, inline = “Level10”, display = display.data_window)
color_neg_0_618 = input(#009688, “”, inline = “Level10”, display = display.data_window)

show_neg_0_65 = input(false, “”, inline = “Level10”, display = display.data_window)
value_neg_0_65 = input(-0.65, “”, inline = “Level10”, display = display.data_window)
color_neg_0_65 = input(#009688, “”, inline = “Level10”, display = display.data_window)

var line lineId0 = na
var line lineId1 = na
var line lineId2 = na
var line lineId3 = na
var line lineId4 = na
var line lineId5 = na
var line lineId6 = na
var line lineId7 = na
var line lineId8 = na
var line lineId9 = na
var line lineId10 = na
var line lineId11 = na
var line lineId12 = na
var line lineId13 = na
var line lineId14 = na
var line lineId15 = na
var line lineId16 = na
var line lineId17 = na
var line lineId18 = na
var line lineId19 = na
var line lineId20 = na
var line lineId21 = na

if (switch_fibonacci) // Check the boolean here
lineId0 := processLevel(show_neg_0_65, value_neg_0_65, color_neg_0_65, line(na))
lineId1 := processLevel(show_neg_0_618, value_neg_0_618, color_neg_0_618, lineId0)
lineId2 := processLevel(show_neg_0_382, value_neg_0_382, color_neg_0_382, lineId1)
lineId3 := processLevel(show_neg_0_236, value_neg_0_236, color_neg_0_236, lineId2)
lineId4 := processLevel(show_0, value_0, color_0, lineId3)
lineId5 := processLevel(show_0_236, value_0_236, color_0_236, lineId4)
lineId6 := processLevel(show_0_382, value_0_382, color_0_382, lineId5)
lineId7 := processLevel(show_0_5, value_0_5, color_0_5, lineId6)
lineId8 := processLevel(show_0_618, value_0_618, color_0_618, lineId7)
lineId9 := processLevel(show_0_65, value_0_65, color_0_65, lineId8)
lineId10 := processLevel(show_0_786, value_0_786, color_0_786, lineId9)
lineId11 := processLevel(show_1, value_1, color_1, lineId10)
lineId12 := processLevel(show_1_272, value_1_272, color_1_272, lineId11)
lineId13 := processLevel(show_1_414, value_1_414, color_1_414, lineId12)
lineId14 := processLevel(show_1_618, value_1_618, color_1_618, lineId13)
lineId15 := processLevel(show_1_65, value_1_65, color_1_65, lineId14)
lineId16 := processLevel(show_2_618, value_2_618, color_2_618, lineId15)
lineId17 := processLevel(show_2_65, value_2_65, color_2_65, lineId16)
lineId18 := processLevel(show_3_618, value_3_618, color_3_618, lineId17)
lineId19 := processLevel(show_3_65, value_3_65, color_3_65, lineId18)
lineId20 := processLevel(show_4_236, value_4_236, color_4_236, lineId19)
lineId21 := processLevel(show_4_618, value_4_618, color_4_618, lineId20)

/////////////////////////////////////////////////////////////////////////
// EMA Selection
////////////////////////////////////////////////////////////////////////

ma_group= “██████████ MAs Line ██████████”
len1bool = input.bool(true,”,group=ma_group,inline=’len1′)
len1 = input.int(5, title=’MA 1′,group=ma_group,inline=’len1′)
string ma_1_type = input.string(defval=’EMA’, title=’Type’, options=[‘RMA’, ‘SMA’, ‘EMA’, ‘WMA’,’HMA’,’VWMA’], inline=’len1′,group=ma_group)
color ma_1_colour = input.color(color.rgb(254, 234, 74, 0), ”, inline=’len1′,group=ma_group)

len2bool = input.bool(true,”,group=ma_group,inline=’len2′)
len2 = input.int(13, minval=1, title=’MA 2′,group=ma_group,inline=’len2′)
string ma_2_type = input.string(defval=’EMA’, title=’Type’, options=[‘RMA’, ‘SMA’, ‘EMA’, ‘WMA’,’HMA’,’VWMA’], inline=’len2′,group=ma_group)
color ma_2_colour = input.color(color.rgb(253, 84, 87, 0), ”, inline=’len2′,group=ma_group)

len3bool = input.bool(false,”,group=ma_group,inline=’len3′)
len3 = input.int(20, minval=1, title=’MA 3′,group=ma_group,inline=’len3′)
string ma_3_type = input.string(defval=’EMA’, title=’Type’, options=[‘RMA’, ‘SMA’, ‘EMA’, ‘WMA’,’HMA’,’VWMA’], inline=’len3′,group=ma_group)
color ma_3_colour = input.color(color.new(color.aqua, 0), ”, inline=’len3′,group=ma_group)

len4bool = input.bool(true,”,group=ma_group,inline=’len4′)
len4 = input.int(50, minval=1, title=’MA 4′,group=ma_group,inline=’len4′)
string ma_4_type = input.string(defval=’EMA’, title=’Type’, options=[‘RMA’, ‘SMA’, ‘EMA’, ‘WMA’,’HMA’,’VWMA’], inline=’len4′,group=ma_group)
color ma_4_colour = input.color(color.new(color.blue, 0), ”, inline=’len4′,group=ma_group)

len5bool = input.bool(true,”,group=ma_group,inline=’len5′)
len5 = input.int(200, minval=1, title=’MA 5′,group=ma_group,inline=’len5′)
string ma_5_type = input.string(defval=’EMA’, title=’Type’, options=[‘RMA’, ‘SMA’, ‘EMA’, ‘WMA’,’HMA’,’VWMA’], inline=’len5′,group=ma_group)
color ma_5_colour = input.color(color.new(color.white, 0), ”, inline=’len5′,group=ma_group)

ema1 = request.security(syminfo.tickerid, timeframe.period, ma_function(close, len1, ma_1_type))
ema2 = request.security(syminfo.tickerid, timeframe.period, ma_function(close, len2, ma_2_type))
ema3 = request.security(syminfo.tickerid, timeframe.period, ma_function(close, len3, ma_3_type))
ema4 = request.security(syminfo.tickerid, timeframe.period, ma_function(close, len4, ma_4_type))
ema5 = request.security(syminfo.tickerid, timeframe.period, ma_function(close, len5, ma_5_type))

plot(len1bool and switch_ema ? ema1:na, color=ma_1_colour, linewidth=2, title=’MA 1′)
plot(len2bool and switch_ema? ema2:na, color=ma_2_colour, linewidth=2, title=’MA 2′)
plot(len3bool and switch_ema? ema3:na, color=ma_3_colour, linewidth=2, title=’MA 3′)
plot(len4bool and switch_ema? ema4:na, color=ma_4_colour, linewidth=2, title=’MA 4′)
plot(len5bool and switch_ema? ema5:na, color=ma_5_colour, linewidth=2, title=’MA 5′)

////////////////////////////////////////////////////////////////////////////
//////////// 2EMA cross
////////////////////////////////////////////////////////////////////////////

var float first_2ema = 0
var float second_2ema = 0

// if respect2ma or leadingindicator==’2 EMA Cross’
// first_2ema := ta.ema(close, respect2maperiod_1)
// second_2ema := ta.ema(close, respect2maperiod_2)

// Calculate EMAs
first_2ema := ta.ema(close, respect2maperiod_1)
second_2ema := ta.ema(close, respect2maperiod_2)

// Function to detect cross with lookback
detectCrossWithLookback(fast_series, slow_series, lookback) =>
crossUp = fast_series[lookback] > slow_series[lookback] and fast_series[lookback + 1] <= slow_series[lookback + 1]
crossDown = fast_series[lookback] < slow_series[lookback] and fast_series[lookback + 1] >= slow_series[lookback + 1]

if crossUp or crossDown
noCrosses = true
for i = 0 to lookback – 1
if (fast_series[i] > slow_series[i] and fast_series[i+1] <= slow_series[i+1]) or
(fast_series[i] < slow_series[i] and fast_series[i+1] >= slow_series[i+1])
noCrosses := false
break
if noCrosses
if crossUp
1
else
-1
else
0
else
0

// Detect signals based on selected method
var float ema2_long = 0
var float ema2_short = 0

if signal_type == “Default”
ema2_long := ta.crossover(first_2ema, second_2ema) ? 1 : 0
ema2_short := ta.crossunder(first_2ema, second_2ema) ? 1 : 0
else // Lookback method
crossDetected = detectCrossWithLookback(first_2ema, second_2ema, lookback_period)
ema2_long := crossDetected == 1 and first_2ema > second_2ema ? 1 : 0
ema2_short := crossDetected == -1 and first_2ema < second_2ema ? 1 : 0
////////////////////////////////////////////////////////////////////////////
//////////// 3EMA cross
////////////////////////////////////////////////////////////////////////////
var float first_3ema = 0
var float second_3ema = 0
var float third_3ema = 0

if respect3ma or leadingindicator==’3 EMA Cross’
first_3ema := ta.ema(close, respect3maperiod_1)
second_3ema := ta.ema(close, respect3maperiod_2)
third_3ema := ta.ema(close, respect3maperiod_3)

//////////////////////////////////////////////////////////////////////////
// Pivots
//////////////////////////////////////////////////////////////////////////

pivot_group = ‘██████████ Pivot Levels ██████████’
pivotTypeInput = input.string(title=”Type”, defval=”Traditional”, options=[“Traditional”, “Fibonacci”, “Woodie”, “Classic”, “DM”, “Camarilla”],group=pivot_group)
pivotAnchorInput = input.string(title=”Pivots Timeframe”, defval=”Auto”, options=[“Auto”, “Daily”, “Weekly”, “Monthly”, “Quarterly”, “Yearly”, “Biyearly”, “Triyearly”, “Quinquennially”, “Decennially”],group=pivot_group)
maxHistoricalPivotsInput = input.int(title=”Number of Pivots Back”, defval=1, minval=1, maxval=200, display = display.data_window,group=pivot_group)
isDailyBasedInput = input.bool(title=”Use Daily-based Values”, defval=true,group=pivot_group, display = display.data_window, tooltip=”When this option is unchecked, Pivot Points will use intraday data while calculating on intraday charts. If Extended Hours are displayed on the chart, they will be taken into account during the pivot level calculation. If intraday OHLC values are different from daily-based values (normal for stocks), the pivot levels will also differ.”)
showLabelsInput = input.bool(title=”Show Labels”, defval=true,group=pivot_group, display = display.data_window)
showPricesInput = input.bool(title=”Show Prices”, defval=true,group=pivot_group, display = display.data_window)
positionLabelsInput = input.string(“Left”, “Labels Position”, options=[“Left”, “Right”],group=pivot_group, display = display.data_window)
linewidthInput = input.int(title=”Line Width”, defval=1, minval=1, maxval=100,group=pivot_group, display = display.data_window)

DEFAULT_COLOR = #FB8C00
pColorInput = input.color(DEFAULT_COLOR, “P‏ ‏ ‏”, inline=”P”,group=pivot_group, display = display.data_window)
pShowInput = input.bool(true, “”, inline=”P”,group=pivot_group, display = display.data_window)
s1ColorInput = input.color(DEFAULT_COLOR, “S1″, inline=”S1/R1” ,group=pivot_group, display = display.data_window)
s1ShowInput = input.bool(true, “”, inline=”S1/R1″,group=pivot_group, display = display.data_window)
r1ColorInput = input.color(DEFAULT_COLOR, “‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏R1″, inline=”S1/R1”,group=pivot_group, display = display.data_window)
r1ShowInput = input.bool(true, “”, inline=”S1/R1″,group=pivot_group, display = display.data_window)
s2ColorInput = input.color(DEFAULT_COLOR, “S2″, inline=”S2/R2”,group=pivot_group, display = display.data_window)
s2ShowInput = input.bool(true, “”, inline=”S2/R2″,group=pivot_group, display = display.data_window)
r2ColorInput = input.color(DEFAULT_COLOR, “‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏R2″, inline=”S2/R2”,group=pivot_group, display = display.data_window)
r2ShowInput = input.bool(true, “”, inline=”S2/R2″,group=pivot_group, tooltip = “Not applicable to DM”, display = display.data_window)
s3ColorInput = input.color(DEFAULT_COLOR, “S3″, inline=”S3/R3”,group=pivot_group, display = display.data_window)
s3ShowInput = input.bool(true, “”, inline=”S3/R3″,group=pivot_group, display = display.data_window)
r3ColorInput = input.color(DEFAULT_COLOR, “‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏R3″, inline=”S3/R3”,group=pivot_group, display = display.data_window)
r3ShowInput = input.bool(true, “”, inline=”S3/R3″,group=pivot_group, tooltip = “Not applicable to DM”, display = display.data_window)
s4ColorInput = input.color(DEFAULT_COLOR, “S4″, inline=”S4/R4”,group=pivot_group, display = display.data_window)
s4ShowInput = input.bool(true, “”, inline=”S4/R4″,group=pivot_group, display = display.data_window)
r4ColorInput = input.color(DEFAULT_COLOR, “‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏R4″, inline=”S4/R4”,group=pivot_group, display = display.data_window)
r4ShowInput = input.bool(true, “”, inline=”S4/R4″,group=pivot_group, tooltip = “Not applicable to: Fibonacci, DM”, display = display.data_window)
s5ColorInput = input.color(DEFAULT_COLOR, “S5″, inline=”S5/R5”,group=pivot_group, display = display.data_window)
s5ShowInput = input.bool(true, “”, inline=”S5/R5″,group=pivot_group, display = display.data_window)
r5ColorInput = input.color(DEFAULT_COLOR, “‏ ‏ ‏ ‏ ‏ ‏ ‏ ‏R5″, inline=”S5/R5”,group=pivot_group, display = display.data_window)
r5ShowInput = input.bool(true, “”, inline=”S5/R5″,group=pivot_group, tooltip = “Not applicable to: Fibonacci, Woodie, Classic, DM”, display = display.data_window)

type graphicSettings
string levelName
color levelColor
bool showLevel

var graphicSettingsArray = array.from(
graphicSettings.new(” P”, pColorInput, pShowInput),
graphicSettings.new(“R1”, r1ColorInput, r1ShowInput), graphicSettings.new(“S1”, s1ColorInput, s1ShowInput),
graphicSettings.new(“R2”, r2ColorInput, r2ShowInput), graphicSettings.new(“S2”, s2ColorInput, s2ShowInput),
graphicSettings.new(“R3”, r3ColorInput, r3ShowInput), graphicSettings.new(“S3”, s3ColorInput, s3ShowInput),
graphicSettings.new(“R4”, r4ColorInput, r4ShowInput), graphicSettings.new(“S4”, s4ColorInput, s4ShowInput),
graphicSettings.new(“R5”, r5ColorInput, r5ShowInput), graphicSettings.new(“S5”, s5ColorInput, s5ShowInput))

autoAnchor = switch
timeframe.isintraday => timeframe.multiplier <= 15 ? “1D” : “1W”
timeframe.isdaily => “1M”
=> “12M”

pivotTimeframe = switch pivotAnchorInput
“Auto” => autoAnchor
“Daily” => “1D”
“Weekly” => “1W”
“Monthly” => “1M”
“Quarterly” => “3M”
=> “12M”

//@variable The number of years in the selected Pivot period
pivotYearMultiplier = switch pivotAnchorInput
“Biyearly” => 2
“Triyearly” => 3
“Quinquennially” => 5
“Decennially” => 10
=> 1

//@variable The number of values in the pivots of the selected type
numOfPivotLevels = switch pivotTypeInput
“Traditional” => 11
“Camarilla” => 11
“Woodie” => 9
“Classic” => 9
“Fibonacci” => 7
“DM” => 3

type pivotGraphic
line pivotLine
label pivotLabel

method delete(pivotGraphic graphic) =>
graphic.pivotLine.delete()
graphic.pivotLabel.delete()

var drawnGraphics = matrix.new<pivotGraphic>()

localPivotTimeframeChange = timeframe.change(pivotTimeframe) and year % pivotYearMultiplier == 0
securityPivotTimeframeChange = timeframe.change(timeframe.period) and year % pivotYearMultiplier == 0

pivotTimeframeChangeCounter(condition) =>
var count = 0
if condition and bar_index > 0
count += 1
count

localPivots = ta.pivot_point_levels(pivotTypeInput, localPivotTimeframeChange)
securityPivotPointsArray = ta.pivot_point_levels(pivotTypeInput, securityPivotTimeframeChange)

securityTimeframe = timeframe.isintraday ? “1D” : timeframe.period
[securityPivots, securityPivotCounter] = request.security(syminfo.tickerid, pivotTimeframe, [securityPivotPointsArray, pivotTimeframeChangeCounter(securityPivotTimeframeChange)], lookahead = barmerge.lookahead_on)
pivotPointsArray = isDailyBasedInput ? securityPivots : localPivots

//@function Sets the ending points of the currently active pivots to endTime.
affixOldPivots(endTime) =>
if drawnGraphics.rows() > 0
lastGraphics = drawnGraphics.row(drawnGraphics.rows() – 1)

for graphic in lastGraphics
graphic.pivotLine.set_x2(endTime)
if positionLabelsInput == “Right”
graphic.pivotLabel.set_x(endTime)

//@function Draws pivot lines and labels from startTime to the approximate end of the period.
drawNewPivots(startTime) =>

newGraphics = array.new<pivotGraphic>()

for [index, coord] in pivotPointsArray
levelSettings = graphicSettingsArray.get(index)
if not na(coord) and levelSettings.showLevel and switch_pivot
lineEndTime = startTime + timeframe.in_seconds(pivotTimeframe) * 1000 * pivotYearMultiplier
pivotLine = line.new(startTime, coord, lineEndTime, coord, xloc = xloc.bar_time, color=levelSettings.levelColor, width=linewidthInput)
pivotLabel = label.new(x = positionLabelsInput == “Left” ? startTime : lineEndTime,
y = coord,
text = (showLabelsInput ? levelSettings.levelName + ” ” : “”) + (showPricesInput ? “(” + str.tostring(coord, format.mintick) + “)” : “”),
style = positionLabelsInput == “Left” ? label.style_label_right : label.style_label_left,
textcolor = levelSettings.levelColor,
color = #00000000,
xloc=xloc.bar_time)

newGraphics.push(pivotGraphic.new(pivotLine, pivotLabel))

drawnGraphics.add_row(array_id = newGraphics)

if drawnGraphics.rows() > maxHistoricalPivotsInput
oldGraphics = drawnGraphics.remove_row(0)

for graphic in oldGraphics
graphic.delete()

localPivotDrawConditionStatic = not isDailyBasedInput and localPivotTimeframeChange
securityPivotDrawConditionStatic = isDailyBasedInput and securityPivotCounter != securityPivotCounter[1]

var isMultiYearly = array.from(“Biyearly”, “Triyearly”, “Quinquennially”, “Decennially”).includes(pivotAnchorInput)
localPivotDrawConditionDeveloping = not isDailyBasedInput and time_close == time_close(pivotTimeframe) and not isMultiYearly
securityPivotDrawConditionDeveloping = false

if (switch_pivot and (securityPivotDrawConditionStatic or localPivotDrawConditionStatic))
affixOldPivots(time)
drawNewPivots(time)

// If possible, draw pivots from the beginning of the chart if none were found
var FIRST_BAR_TIME = time
if (barstate.islastconfirmedhistory and drawnGraphics.columns() == 0 and switch_pivot)

if not na(securityPivots) and securityPivotCounter > 0
if isDailyBasedInput
drawNewPivots(FIRST_BAR_TIME)
else
runtime.error(“Not enough intraday data to calculate Pivot Points. Lower the Pivots Timeframe or turn on the ‘Use Daily-based Values’ option in the indicator settings.”)
else
runtime.error(“Not enough data to calculate Pivot Points. Lower the Pivots Timeframe in the indicator settings.”)

//////////////////////////////////////////////////////////////////////////
// William Fractals
//////////////////////////////////////////////////////////////////////////

// Define “n” as the number of periods and keep a minimum value of 2 for error handling.
n = input.int(title=”Periods”, defval=2, minval=2,group=”██████████ Fractal ██████████”)

// UpFractal
bool upflagDownFrontier = true
bool upflagUpFrontier0 = true
bool upflagUpFrontier1 = true
bool upflagUpFrontier2 = true
bool upflagUpFrontier3 = true
bool upflagUpFrontier4 = true

if switch_fractal
for i = 1 to n
upflagDownFrontier := upflagDownFrontier and (high[n-i] < high[n])
upflagUpFrontier0 := upflagUpFrontier0 and (high[n+i] < high[n])
upflagUpFrontier1 := upflagUpFrontier1 and (high[n+1] <= high[n] and high[n+i + 1] < high[n])
upflagUpFrontier2 := upflagUpFrontier2 and (high[n+1] <= high[n] and high[n+2] <= high[n] and high[n+i + 2] < high[n])
upflagUpFrontier3 := upflagUpFrontier3 and (high[n+1] <= high[n] and high[n+2] <= high[n] and high[n+3] <= high[n] and high[n+i + 3] < high[n])
upflagUpFrontier4 := upflagUpFrontier4 and (high[n+1] <= high[n] and high[n+2] <= high[n] and high[n+3] <= high[n] and high[n+4] <= high[n] and high[n+i + 4] < high[n])
flagUpFrontier = upflagUpFrontier0 or upflagUpFrontier1 or upflagUpFrontier2 or upflagUpFrontier3 or upflagUpFrontier4

upFractal = (upflagDownFrontier and flagUpFrontier)

// downFractal
bool downflagDownFrontier = true
bool downflagUpFrontier0 = true
bool downflagUpFrontier1 = true
bool downflagUpFrontier2 = true
bool downflagUpFrontier3 = true
bool downflagUpFrontier4 = true

if switch_fractal
for i = 1 to n
downflagDownFrontier := downflagDownFrontier and (low[n-i] > low[n])
downflagUpFrontier0 := downflagUpFrontier0 and (low[n+i] > low[n])
downflagUpFrontier1 := downflagUpFrontier1 and (low[n+1] >= low[n] and low[n+i + 1] > low[n])
downflagUpFrontier2 := downflagUpFrontier2 and (low[n+1] >= low[n] and low[n+2] >= low[n] and low[n+i + 2] > low[n])
downflagUpFrontier3 := downflagUpFrontier3 and (low[n+1] >= low[n] and low[n+2] >= low[n] and low[n+3] >= low[n] and low[n+i + 3] > low[n])
downflagUpFrontier4 := downflagUpFrontier4 and (low[n+1] >= low[n] and low[n+2] >= low[n] and low[n+3] >= low[n] and low[n+4] >= low[n] and low[n+i + 4] > low[n])
flagDownFrontier = downflagUpFrontier0 or downflagUpFrontier1 or downflagUpFrontier2 or downflagUpFrontier3 or downflagUpFrontier4

downFractal = (downflagDownFrontier and flagDownFrontier)

plotshape(downFractal and switch_fractal ? true : na, style=shape.triangledown, location=location.belowbar, offset=-n, color=#F44336, size = size.small)
plotshape(upFractal and switch_fractal ? true : na, style=shape.triangleup, location=location.abovebar, offset=-n, color=#009688, size = size.small)

//////////////////////////////////////////////////////////////////////////
// Range Filter
//////////////////////////////////////////////////////////////////////////

rf_group= “██████████ Range Filter ██████████”

//switch_rangefilter = input.bool (true, “Show Range Filter Signals”, group=’=============== Range Filter ================’)
showrfline = input.bool (true, “Show RF line”, group=rf_group)

src = input.source(defval=close, title=’Source’, group=rf_group,inline = ‘rf’)

// Sampling Period
// Settings for 5min chart, BTCUSDC. For Other coin, change the paremeters

per = input.int(defval=100, minval=1, title=’Period’, group=rf_group,inline = ‘rf’)

// Range Multiplier

mult = input.float(defval=3.0, minval=0.1, title=’Multiplier’, group=rf_group,inline = ‘rf’)

// Smooth Average Range

smoothrng(x, t, m) =>
wper = t * 2 – 1
avrng = ta.ema(math.abs(x – x[1]), t)
smoothrng = ta.ema(avrng, wper) * m
smoothrng
smrng = smoothrng(src, per, mult)

// Range Filter

rngfilt(x, r) =>
rngfilt = x
rngfilt := x > nz(rngfilt[1]) ? x – r < nz(rngfilt[1]) ? nz(rngfilt[1]) : x – r : x + r > nz(rngfilt[1]) ? nz(rngfilt[1]) : x + r
rngfilt
filt = rngfilt(src, smrng)

// Filter Direction

upward = 0.0
upward := filt > filt[1] ? nz(upward[1]) + 1 : filt < filt[1] ? 0 : nz(upward[1])
downward = 0.0
downward := filt < filt[1] ? nz(downward[1]) + 1 : filt > filt[1] ? 0 : nz(downward[1])

// Target Bands

hband = filt + smrng
lband = filt – smrng

///////////////////////////////
////// RF2
///////////////////////////////

//Filter Type
f_type = input.string(defval=’Type 1′, options=[‘Type 1’, ‘Type 2′], title=’Filter Type’)

//Movement Source
mov_src = input.string(defval=’Close’, options=[‘Wicks’, ‘Close’], title=’Movement Source’)

//Range Size Inputs
rng_qty = input.float(defval=2.618, minval=0.0000001, title=’Range Size’)
rng_scale = input.string(defval=’Average Change’, options=[‘Points’, ‘Pips’, ‘Ticks’, ‘% of Price’, ‘ATR’, ‘Average Change’, ‘Standard Deviation’, ‘Absolute’], title=’Range Scale’)

//Range Period
rng_per = input.int(defval=14, minval=1, title=’Range Period (for ATR, Average Change, and Standard Deviation)’)

//Range Smoothing Inputs
smooth_range = input(defval=true, title=’Smooth Range’)
smooth_per = input.int(defval=27, minval=1, title=’Smoothing Period’)

//Filter Value Averaging Inputs
av_vals = input(defval=false, title=’Average Filter Changes’)
av_samples = input.int(defval=2, minval=1, title=’Number Of Changes To Average’)

//—————————————————————————————————————————————————————–
//Definitions
//—————————————————————————————————————————————————————–

//High And Low Values
h_val = mov_src == ‘Wicks’ ? high : close
l_val = mov_src == ‘Wicks’ ? low : close

//Range Filter Values
[h_band, l_band, filt2] = rng_filt(h_val, l_val, rng_size((h_val + l_val) / 2, rng_scale, rng_qty, rng_per), rng_per, f_type, smooth_range, smooth_per, av_vals, av_samples)

//Direction Conditions
var fdir2 = 0.0
fdir2 := filt2 > filt2[1] ? 1 : filt2 < filt2[1] ? -1 : fdir2
rfupward = fdir2 == 1 ? 1 : 0
rfdownward= fdir2 == -1 ? 1 : 0

//—————————————————————————————————————————————————————–
//color and switchboard rf
//—————————————————————————————————————————————————————–

filtcolor = upward > 0 ? color.lime : downward > 0 ? color.red : color.orange
// filt2_color = rfupward ? #05ff9b : rfdownward ? #ff0583 : #cccccc

filttype = string(na)
if rftype == “Default”
filttype := “filt”
else if rftype == “DW”
filttype := “filt2”

filtplot = plot(switch_rangefilter and showrfline?filt:na, color=filtcolor, linewidth=2, title=’Range Filter’)
// filtplot2 = plot(switch_rangefilter2 ?filt2:na, color=filt2_color, linewidth=2, title=’Range Filter’)

////////////////////////////////
/// RQK
////////////////////////////////

rqkgroupname = ‘████████ Rational Quadratic Kernel (RQK) ████████’
rqksrc = input.source(close, ‘Source’, group=rqkgroupname)
h2 = input.float(8., ‘Lookback Window’, minval=3., tooltip=’The number of bars used for the estimation. This is a sliding value that represents the most recent historical bars. Recommended range: 3-50′, group=rqkgroupname)
r = input.float(8., ‘Relative Weighting’, step=0.25, group=rqkgroupname, tooltip=’Relative weighting of time frames. As this value approaches zero, the longer time frames will exert more influence on the estimation. As this value approaches infinity, the behavior of the Rational Quadratic Kernel will become identical to the Gaussian kernel. Recommended range: 0.25-25′)
x_0 = input.int(25, “Start Regression at Bar”, group=rqkgroupname, tooltip=’Bar index on which to start regression. The first bars of a chart are often highly volatile, and omission of these initial bars often leads to a better overall fit. Recommended range: 5-25′)
smoothColors = input.bool(false, “Smooth Colors”, group=rqkgroupname, tooltip=”Uses a crossover based mechanism to determine colors. This often results in less color transitions overall.”, inline=’1′)
lag = input.int(2, “Lag”, group=rqkgroupname, tooltip=”Lag for crossover detection. Lower values result in earlier crossovers. Recommended range: 1-2″, inline=’1′)
size = array.size(array.from(rqksrc)) // size of the data series

kernel_regression(_rqksrc, _size, _h2) =>
float _currentWeight = 0.
float _cumulativeWeight = 0.
for i = 0 to _size + x_0
y = _rqksrc[i]
w = math.pow(1 + (math.pow(i, 2) / ((math.pow(_h2, 2) * 2 * r))), -r)
_currentWeight += y*w
_cumulativeWeight += w
_currentWeight / _cumulativeWeight

var bool rqkuptrend = na
var bool rqkdowntrend = na

if respectrqk or leadingindicator==”Rational Quadratic Kernel (RQK)”
// Estimations
yhat1 = kernel_regression(rqksrc, size, h2)
yhat2 = kernel_regression(rqksrc, size, h2-lag)

// Rates of Change
bool wasBearish = yhat1[2] > yhat1[1]
bool wasBullish = yhat1[2] < yhat1[1]
bool isBearish = yhat1[1] > yhat1
bool isBullish = yhat1[1] < yhat1
bool isBearishChange = isBearish and wasBullish
bool isBullishChange = isBullish and wasBearish

// Crossovers
bool isBullishCross = ta.crossover(yhat2, yhat1)
bool isBearishCross = ta.crossunder(yhat2, yhat1)
bool isBullishSmooth = yhat2 > yhat1
bool isBearishSmooth = yhat2 < yhat1

rqkuptrend := yhat1[1] < yhat1
rqkdowntrend := yhat1[1] > yhat1

/////////////////////////////
////////// TSI
/////////////////////////////
tsi_group = “██████████ True Strength Indicator (TSI) ██████████”

tsi_long_length = input(title=”Long Length”, defval=25,group=tsi_group)
tsi_short_length = input(title=”Short Length”, defval=13,group=tsi_group)
tsi_signal_length = input(title=”Signal Length”, defval=13,group=tsi_group)
tsi_price = close
tsi_double_smooth(src, long, short) =>
fist_smooth = ta.ema(src, long)
ta.ema(fist_smooth, short)
tsi_pc = ta.change(tsi_price)
tsi_double_smoothed_pc = tsi_double_smooth(tsi_pc, tsi_long_length, tsi_short_length)
tsi_double_smoothed_abs_pc = tsi_double_smooth(math.abs(tsi_pc), tsi_long_length, tsi_short_length)
tsi_value = 100 * (tsi_double_smoothed_pc / tsi_double_smoothed_abs_pc)

var tsi_long = bool(na)
var tsi_short = bool(na)
tsi_signal = ta.ema(tsi_value, tsi_signal_length)

if tsitype == “Signal Cross”
tsi_long := tsi_value > tsi_signal
tsi_short := tsi_value < tsi_signal
else if tsitype == “Zero line cross”
tsi_long := tsi_value > tsi_signal and tsi_value>0
tsi_short := tsi_value < tsi_signal and tsi_value<0

////////////////////////////////
///// Super Trend
//////////////////////////////

sp_group = “██████████ SuperTrend ██████████”

Periods = input(title=’ATR Period’, defval=10, group=sp_group)
stsrc = input(hl2, title=’Source’, group=sp_group)
Multiplier = input.float(title=’ATR Multiplier’, step=0.1, defval=3.0, group=sp_group)
changeATR = input(title=’Change ATR Calculation Method ?’, defval=true, group=sp_group)
showsignals = input(title=’Show Buy/Sell Signals ?’, defval=true, group=sp_group)
highlighting = input(title=’Highlighter On/Off ?’, defval=true, group=sp_group)

statr2 = ta.sma(ta.tr, Periods)
statr = changeATR ? ta.atr(Periods) : statr2
stup = stsrc – Multiplier * statr
up1 = nz(stup[1], stup)
stup := close[1] > up1 ? math.max(stup, up1) : stup
dn = stsrc + Multiplier * statr
dn1 = nz(dn[1], dn)
dn := close[1] < dn1 ? math.min(dn, dn1) : dn
sttrend = 1
sttrend := nz(sttrend[1], sttrend)
sttrend := sttrend == -1 and close > dn1 ? 1 : sttrend == 1 and close < up1 ? -1 : sttrend
upPlot = plot(sttrend == 1 and switch_supertrend ? stup : na, title=’Up Trend’, style=plot.style_linebr, linewidth=2, color=color.new(color.green, 0))
stbuySignal = sttrend == 1 and sttrend[1] == -1
plotshape(stbuySignal and switch_supertrend ? stup : na, title=’UpTrend Begins’, location=location.absolute, style=shape.circle, size=size.tiny, color=color.new(color.green, 0))
dnPlot = plot(sttrend != 1 and switch_supertrend ? dn : na , title=’Down Trend’, style=plot.style_linebr, linewidth=2, color=color.new(color.red, 0))
stsellSignal = sttrend == -1 and sttrend[1] == 1
plotshape(stsellSignal and switch_supertrend ? dn : na, title=’DownTrend Begins’, location=location.absolute, style=shape.circle, size=size.tiny, color=color.new(color.red, 0))

/////////////////////////////////////////////
/////////// Half Trend
////////////////////////////////////////////

ht_group = “██████████ HalfTrend ██████████”
amplitude = input(title=’Amplitude’, defval=2,group=ht_group)
channelDeviation = input(title=’Channel Deviation’, defval=2,group=ht_group)
showArrows = input(title=’Show Arrows’, defval=true,group=ht_group)
showChannels = input(title=’Show Channels’, defval=true,group=ht_group)

var bool halftrend_long = na
var bool halftrend_short = na
var float ht = na
var color htColor = na

if respectht or leadingindicator==”Half Trend” or switch_halftrend
var int ht_trend = 0
var int nextTrend = 0
var float maxLowPrice = nz(low[1], low)
var float minHighPrice = nz(high[1], high)

var float ht_up = 0.0
var float ht_down = 0.0
float atrHigh = 0.0
float atrLow = 0.0
float arrowUp = na
float arrowDown = na

ht_atr2 = ta.atr(100) / 2
ht_dev = channelDeviation * ht_atr2

highPrice = high[math.abs(ta.highestbars(amplitude))]
lowPrice = low[math.abs(ta.lowestbars(amplitude))]
highma = ta.sma(high, amplitude)
lowma = ta.sma(low, amplitude)

if nextTrend == 1
maxLowPrice := math.max(lowPrice, maxLowPrice)

if highma < maxLowPrice and close < nz(low[1], low)
ht_trend := 1
nextTrend := 0
minHighPrice := highPrice
minHighPrice
else
minHighPrice := math.min(highPrice, minHighPrice)

if lowma > minHighPrice and close > nz(high[1], high)
ht_trend := 0
nextTrend := 1
maxLowPrice := lowPrice
maxLowPrice

if ht_trend == 0
if not na(ht_trend[1]) and ht_trend[1] != 0
ht_up := na(ht_down[1]) ? ht_down : ht_down[1]
arrowUp := ht_up – ht_atr2
arrowUp
else
ht_up := na(ht_up[1]) ? maxLowPrice : math.max(maxLowPrice, ht_up[1])
ht_up
atrHigh := ht_up + ht_dev
atrLow := ht_up – ht_dev
atrLow
else
if not na(ht_trend[1]) and ht_trend[1] != 1
ht_down := na(ht_up[1]) ? ht_up : ht_up[1]
arrowDown := ht_down + ht_atr2
arrowDown
else
ht_down := na(ht_down[1]) ? minHighPrice : math.min(minHighPrice, ht_down[1])
ht_down
atrHigh := ht_down + ht_dev
atrLow := ht_down – ht_dev
atrLow

ht := ht_trend == 0 ? ht_up : ht_down

var color buyColor = color.blue
var color sellColor = color.red

htColor := ht_trend == 0 ? buyColor : sellColor

halftrend_long := ht_trend == 0
halftrend_short := ht_trend != 0

htPlot = plot(switch_halftrend ? ht:na, title=’HalfTrend’, linewidth=2, color=htColor)

//////////////////////////////////////

/////////////////////////////////////////////
///////// Trend Line Breakout
/////////////////////////////////////////////
//——————————————————————————
//Settings
//—————————————————————————–{

tbgroup= “██████████ Trendline Breakout ██████████”
length_tb = input.int(14, ‘Swing Detection Lookback’,group=tbgroup)
mult_tb = input.float(1., ‘Slope’, minval = 0, step = .1,group=tbgroup)
calcMethod = input.string(‘Atr’, ‘Slope Calculation Method’, options = [‘Atr’,’Stdev’,’Linreg’],group=tbgroup)
backpaint = input(true, tooltip = ‘Backpainting offset displayed elements in the past. Disable backpainting to see real time information returned by the indicator.’,group=tbgroup)

var upos = 0
var dnos = 0
tb_buysignal = bool (na)
tb_sellsignal = bool (na)

if respecttrendline_breakout or leadingindicator==”Trendline Breakout”

//—————————————————————————–}
//Calculations
//—————————————————————————–{
var upper_tb = 0.
var lower_tb = 0.
var slope_ph = 0.
var slope_pl = 0.

var offset_tb = backpaint ? length_tb : 0

n_tb = bar_index
src_tb = close

ph = ta.pivothigh(length_tb, length_tb)
pl = ta.pivotlow(length_tb, length_tb)

//Slope Calculation Method
slope_tb = switch calcMethod
‘Atr’ => ta.atr(length_tb) / length_tb * mult_tb
‘Stdev’ => ta.stdev(src_tb,length_tb) / length_tb * mult_tb
‘Linreg’ => math.abs(ta.sma(src_tb * n_tb, length_tb) – ta.sma(src_tb, length_tb) * ta.sma(n_tb, length_tb)) / ta.variance(n_tb, length_tb) / 2 * mult_tb

//Get slopes and calculate trendlines
slope_ph := ph ? slope_tb : slope_ph
slope_pl := pl ? slope_tb : slope_pl

upper_tb := ph ? ph : upper_tb – slope_ph
lower_tb := pl ? pl : lower_tb + slope_pl

upos := ph ? 0 : close > upper_tb – slope_ph * length_tb ? 1 : upos
dnos := pl ? 0 : close < lower_tb + slope_pl * length_tb ? 1 : dnos

for i = 0 to signalexpiry – 1
tb_buysignal := upos[0] > upos[i+1]
tb_sellsignal := dnos[0] > dnos[i+1]

//////////////////////////////////////////////
////// Ichimoku
/////////////////////////////////////////////

ichigroup = “██████████ Ichimoku ██████████”
conversionPeriods = input.int(9, minval=1, title=”Conversion Line Length”,group=ichigroup)
basePeriods = input.int(26, minval=1, title=”Base Line Length”,group=ichigroup)
laggingSpan2Periods = input.int(52, minval=1, title=”Leading Span B Length”,group=ichigroup)
displacement = input.int(26, minval=1, title=”Lagging Span”,group=ichigroup)
donchian(len) => math.avg(ta.lowest(len), ta.highest(len))
conversionLine = donchian(conversionPeriods)
baseLine = donchian(basePeriods)
leadLine1 = math.avg(conversionLine, baseLine)
leadLine2 = donchian(laggingSpan2Periods)
ChikouSpan = close[25] + (close – close[25])
lead1 = leadLine1[displacement – 1]
lead2 = leadLine2[displacement – 1]
plot(switch_ichi?conversionLine:na, color=#2962FF, title=”Conversion Line”,linewidth = 1)
plot(switch_ichi ? baseLine:na, color=#B71C1C, title=”Base Line”,linewidth = 1)
plot(switch_ichi?close:na, offset = -displacement + 1, color=#43A047, title=”Lagging Span”)
p1 = plot(switch_ichi?leadLine1:na, offset = displacement – 1, color=#A5D6A7,
title=”Leading Span A”)
p2 = plot(switch_ichi?leadLine2:na, offset = displacement – 1, color=#EF9A9A,
title=”Leading Span B”)

fill(p1, p2, color = leadLine1 > leadLine2 and switch_ichi ? color.rgb(67, 160, 71, 70) : color.rgb(244, 67, 54, 70))

ichi_long = conversionLine > baseLine and leadLine1> leadLine2 and close >leadLine1[displacement -1] and close >leadLine2[displacement -1] and (ChikouSpan > leadLine1[50] and ChikouSpan > leadLine2[50])
ichi_short = conversionLine < baseLine and leadLine1 < leadLine2 and close < leadLine1[displacement -1] and close < leadLine2[displacement -1] and (ChikouSpan < leadLine2[50] and ChikouSpan < leadLine1[50])

//////////////////////////////
///////// SuperIchi
/////////////////////////////
superichigroup = “██████████ SuperIchi ██████████”

tenkan_len = input(9,’Tenkan ’,inline=’tenkan’,group=superichigroup)
tenkan_mult = input(2.,”,inline=’tenkan’,group=superichigroup)

kijun_len = input(26,’Kijun ’,inline=’kijun’,group=superichigroup)
kijun_mult = input(4.,”,inline=’kijun’,group=superichigroup)

spanB_len = input(52,’Senkou Span B ’,inline=’span’,group=superichigroup)
spanB_mult = input(6.,”,inline=’span’,group=superichigroup)

offset = input(26,’Displacement’,group=superichigroup)
//——————————————————————————
avg(src,length,mult)=>
atr = ta.atr(length)*mult
up = hl2 + atr
dn = hl2 – atr
upper = 0.,lower = 0.
upper := src[1] < upper[1] ? math.min(up,upper[1]) : up
lower := src[1] > lower[1] ? math.max(dn,lower[1]) : dn

os = 0,max = 0.,min = 0.
os := src > upper ? 1 : src < lower ? 0 : os[1]
spt = os == 1 ? lower : upper
max := ta.cross(src,spt) ? math.max(src,max[1]) : os == 1 ? math.max(src,max[1]) : spt
min := ta.cross(src,spt) ? math.min(src,min[1]) : os == 0 ? math.min(src,min[1]) : spt
math.avg(max,min)
//——————————————————————————
tenkan = avg(close,tenkan_len,tenkan_mult)
kijun = avg(close,kijun_len,kijun_mult)

senkouA = math.avg(kijun,tenkan)
senkouB = avg(close,spanB_len,spanB_mult)
//——————————————————————————

superichi_long = tenkan > kijun and senkouA> senkouB and close >senkouA[displacement -1] and close >senkouB[displacement -1] and (ChikouSpan > senkouA[50] and ChikouSpan > senkouB[50])
superichi_short = tenkan < kijun and senkouA < senkouB and close < senkouA[displacement -1] and close < senkouB[displacement -1] and (ChikouSpan < senkouB[50] and ChikouSpan < senkouA[50])

//////////////////////////////////
///////////Donchian Channel Ribbon
///////////////////////////////////
donchiangroup = “██████████ Donchian Channel Ribbon ██████████”
dlen = input.int(defval=15, title=’Donchian Channel Period’, group=donchiangroup)

dchannel(len) =>
float hh = ta.highest(len)
float ll = ta.lowest(len)

int trend = 0
trend := close > hh[1] ? 1 : close < ll[1] ? -1 : nz(trend[1])
trend

dchannelalt(len, maintrend) =>
float hh = ta.highest(len)
float ll = ta.lowest(len)

int trend = 0
trend := close > hh[1] ? 1 : close < ll[1] ? -1 : nz(trend[1])
maintrend == 1 ? trend == 1 ? #00FF00ff : #00FF009f : maintrend == -1 ? trend == -1 ? #FF0000ff : #FF00009f : na

maintrend = dchannel(dlen)

donchian_long = maintrend == 1 ? true:na
donchian_short = maintrend == -1 ? true:na

////////////////////////////////
// DMI code
////////////////////////////////

dmi_group = “████████ Directional Movement Index (DMI) ████████”
adxlen = input(5, title=”ADX”, group=dmi_group, inline=’dmi’)
keyLevel = input(20, title=’ADX limit’,group=dmi_group, inline=’dmi’)
dilen = input.int(10, title=”DI Length”,group=dmi_group, inline=’dmi’)

lensig = adxlen
upp = ta.change(high)
downn = ta.change(low)
plusDM = na(upp) ? na : upp > downn and upp > 0 ? upp : 0
minusDM = na(downn) ? na : downn > upp and downn > 0 ? downn : 0
trur = ta.rma(ta.tr, dilen)
plus = fixnan(100 * ta.rma(plusDM, dilen) / trur)
minus = fixnan(100 * ta.rma(minusDM, dilen) / trur)
sum = plus + minus
adxx = 100 * ta.rma(math.abs(plus – minus) / (sum == 0 ? 1 : sum), lensig)
dirmov(dilen) =>
up = ta.change(high)
down = -ta.change(low)
truerange = ta.rma(ta.tr, dilen)
plus = fixnan(100 * ta.rma(up > down and up > 0 ? up : 0, dilen) / truerange)
minus = fixnan(100 * ta.rma(down > up and down > 0 ? down : 0, dilen) / truerange)
[plus, minus]

adx(dilen, adxlen) =>
[plus, minus] = dirmov(dilen)
sum = plus + minus
adx = 100 * ta.rma(math.abs(plus – minus) / (sum == 0 ? 1 : sum), adxlen)
[adx, plus, minus]

[adx, diplus, diminus] = adx(dilen, adxlen)

////////////////////////////////////////////////
//Parabolic SAR
///////////////////////////////////////////////
//showsar = input.bool (false, “Show SAR”, group=’————————-Parabolic SAR————————-‘)
psar_group = “██████████ Parabolic SAR (PSAR) ██████████”
start = input.float(0.02, group=psar_group, inline =’sar’)
increment = input.float(0.02, group=psar_group, inline =’sar’)
maximum = input.float(0.2, ‘Max Value’, group=psar_group, inline =’sar’)
out = ta.sar(start, increment, maximum)
sarcolor = if (out>close)
color.red
else
color.green

if (switch_sar )
color.red
else
color.green
plot(switch_sar ? out : na, ‘ParabolicSAR’, style=plot.style_cross, color=sarcolor)

//////////////////////////////////////////////////
///////// TDFI
/////////////////////////////////////////////////
rdfi_group = “█████ Trend Direction Force Index (TDFI) █████ ”

lookback = input(13, title=’Lookback’,group=rdfi_group)
mmaLength = input(13, title=’MMA Length’,group=rdfi_group)
mmaMode = input.string(title=’MMA Mode’, defval=’ema’, options=[’ema’, ‘wma’, ‘swma’, ‘vwma’, ‘hull’, ‘tema’],group=rdfi_group)
smmaLength = input(13,group=rdfi_group)
smmaMode = input.string(title=’SMMA Mode’, defval=’ema’, options=[’ema’, ‘wma’, ‘swma’, ‘vwma’, ‘hull’, ‘tema’],group=rdfi_group)
nLength = input(3, title=’N Length’,group=rdfi_group)
filterHigh = input(0.05, title=’Filter High’,group=rdfi_group)
filterLow = input(-0.05, title=’Filter Low’,group=rdfi_group)
price = input(close, ‘Period’,group=rdfi_group)

tema(src, len) =>
ema1_tdfi = ta.ema(src, len)
ema2_tdfi = ta.ema(ema1_tdfi, len)
ema3_tdfi = ta.ema(ema2_tdfi, len)
3 * ema1_tdfi – 3 * ema2_tdfi + ema3_tdfi

tdfi_ma(mode, src, len) =>
mode == ’ema’ ? ta.ema(src, len) : mode == ‘wma’ ? ta.wma(src, len) : mode == ‘swma’ ? ta.swma(src) : mode == ‘vwma’ ? ta.vwma(src, len) : mode == ‘hull’ ? ta.wma(2 * ta.wma(src, len / 2) – ta.wma(src, len), math.round(math.sqrt(len))) : mode == ‘tema’ ? tema(src, len) : ta.sma(src, len)

tdfi() =>
mma = tdfi_ma(mmaMode, price * 1000, mmaLength)
smma = tdfi_ma(smmaMode, mma, smmaLength)
impetmma = mma – mma[1]
impetsmma = smma – smma[1]
divma = math.abs(mma – smma)
averimpet = (impetmma + impetsmma) / 2
tdf = math.pow(divma, 1) * math.pow(averimpet, nLength)
tdf / ta.highest(math.abs(tdf), lookback * nLength)

signal_tdfi = tdfi()

tdfi_long = signal_tdfi > filterHigh
tdfi_short = signal_tdfi < filterLow

//////////////////////////////////////////////////
///////// McGinley Dynamic
/////////////////////////////////////////////////
md_group = “████████████████████ McGinley Dynamic ████████████████████”

md_length = input.int(14, minval=1,group=md_group)
md_source = close
mg = 0.0
mg := na(mg[1]) ? ta.ema(md_source, md_length) : mg[1] + (md_source – mg[1]) / (md_length * math.pow(md_source/mg[1], 4))

md_long = close > mg
md_short = close<mg

//////////////////////////////////////////////////
///////// CCI
/////////////////////////////////////////////////
cci_group = “████████████████████ CCI ████████████████████”
ccilength = input.int(20,title=”CCI Length”, minval=1,inline=”cci”, group=cci_group)
ccisrc = input(hlc3, title=”Source”,inline=”cci”, group=cci_group)
cciupperband = input.int(100,title=”Upper Band”,inline=”cci2″, group=cci_group)
ccilowerband = input.int(-100,title=”Lower Band”,inline=”cci2″, group=cci_group)

ma = ta.sma(ccisrc, ccilength)
cci = (ccisrc – ma) / (0.015 * ta.dev(ccisrc, ccilength))

typeMA = input.string(title = “Method”, defval = “SMA”, options=[“SMA”, “EMA”, “SMMA (RMA)”, “WMA”, “VWMA”], group=”Smoothing”,inline=”cci4″)
smoothingLength = input.int(title = “Length”, defval = 5, minval = 1, maxval = 100, group=”Smoothing”,inline=”cci3″)

smoothingLine = ma(cci, smoothingLength, typeMA)

ccilong = cci > cciupperband
ccishort = cci < ccilowerband

///////////////////////////////////////////////
/////// B-Xtrender
/////////////////////////////////////////////

bxgroup= “██████████ B-Xtrender ██████████”
short_l1 = input(5, title=’Short – L1′,group=bxgroup)
short_l2 = input(20, title=’Short – L2′,group=bxgroup)
short_l3 = input(15, title=’Short – L3′,group=bxgroup)

long_l1 = input(5, title=’Long – L1′,group=bxgroup)
long_l2 = input(10, title=’Long – L2′,group=bxgroup)

shortTermXtrender = ta.rsi(ta.ema(close, short_l1) – ta.ema(close, short_l2), short_l3) – 50
longTermXtrender = ta.rsi(ta.ema(close, long_l1), long_l2) – 50

t3(src, len) =>
xe1_1 = ta.ema(src, len)
xe2_1 = ta.ema(xe1_1, len)
xe3_1 = ta.ema(xe2_1, len)
xe4_1 = ta.ema(xe3_1, len)
xe5_1 = ta.ema(xe4_1, len)
xe6_1 = ta.ema(xe5_1, len)
b_1 = 0.7
c1_1 = -b_1 * b_1 * b_1
c2_1 = 3 * b_1 * b_1 + 3 * b_1 * b_1 * b_1
c3_1 = -6 * b_1 * b_1 – 3 * b_1 – 3 * b_1 * b_1 * b_1
c4_1 = 1 + 3 * b_1 + b_1 * b_1 * b_1 + 3 * b_1 * b_1
nT3Average_1 = c1_1 * xe6_1 + c2_1 * xe5_1 + c3_1 * xe4_1 + c4_1 * xe3_1
nT3Average_1

maShortTermXtrender = t3(shortTermXtrender, 5)

bx_long = bool(na)
bx_short = bool(na)

if bxtype == “Short Term trend”
bx_long := maShortTermXtrender > maShortTermXtrender[1]
bx_short := maShortTermXtrender < maShortTermXtrender[1]
else if bxtype == “Short and Long term trend”
bx_long := maShortTermXtrender > maShortTermXtrender[1] and (longTermXtrender > 0 and longTermXtrender > longTermXtrender[1]) and (shortTermXtrender > shortTermXtrender[1] and shortTermXtrender > 0)
bx_short := maShortTermXtrender < maShortTermXtrender[1] and (longTermXtrender < 0 and longTermXtrender < longTermXtrender[1]) and (shortTermXtrender < shortTermXtrender[1] and shortTermXtrender < 0)

////////////////////////////////////////////////
////// Bull Bear Power Trend (BBPT)
///////////////////////////////////////////////

BullTrend_hist = 0.0
BearTrend_hist = 0.0

BullTrend = (close – ta.lowest(low, 50)) / ta.atr(5)
BearTrend = (ta.highest(high, 50) – close) / ta.atr(5)
BearTrend2 = -1 * BearTrend

Trend = BullTrend – BearTrend

if BullTrend < 2
BullTrend_hist := BullTrend – 2
BullTrend_hist

if BearTrend2 > -2
BearTrend_hist := BearTrend2 + 2
BearTrend_hist

bbpt_long = bool(na)
bbpt_short = bool(na)
if bbpttype ==”Follow Trend”
bbpt_long := BearTrend_hist > 0 and Trend>=2
bbpt_short := BullTrend_hist < 0 and Trend<=-2
else if bbpttype == “Without Trend”
bbpt_long := BearTrend_hist > 0
bbpt_short := BullTrend_hist < 0

///////////////////////////////////////////////
//////////// VWAP
/////////////////////////////////////////////

vwap_group = “██████████ VWAP Settings ██████████”
hideonDWM = input(false, title=”Hide VWAP on 1D or Above”, group=vwap_group)
var anchor = input.string(defval = “Session”, title=”Anchor Period”,
options=[“Session”, “Week”, “Month”, “Quarter”, “Year”, “Decade”, “Century”, “Earnings”, “Dividends”, “Splits”], group=vwap_group)
srcvwap = input(title = “Source”, defval = hlc3, group=vwap_group)
offsetvwap = input(0, title=”Offset”, group=vwap_group)

showBand_1 = input(true, title=””, group=”Standard Deviation Bands Settings”, inline=”band_1″)
stdevMult_1 = input(1.0, title=”Bands Multiplier #1″, group=”Standard Deviation Bands Settings”, inline=”band_1″)
showBand_2 = input(false, title=””, group=”Standard Deviation Bands Settings”, inline=”band_2″)
stdevMult_2 = input(2.0, title=”Bands Multiplier #2″, group=”Standard Deviation Bands Settings”, inline=”band_2″)
showBand_3 = input(false, title=””, group=”Standard Deviation Bands Settings”, inline=”band_3″)
stdevMult_3 = input(3.0, title=”Bands Multiplier #3″, group=”Standard Deviation Bands Settings”, inline=”band_3″)

if barstate.islast and ta.cum(volume) == 0
runtime.error(“No volume is provided by the data vendor.”)

new_earnings = request.earnings(syminfo.tickerid, earnings.actual, barmerge.gaps_on, barmerge.lookahead_on, ignore_invalid_symbol=true)
new_dividends = request.dividends(syminfo.tickerid, dividends.gross, barmerge.gaps_on, barmerge.lookahead_on, ignore_invalid_symbol=true)
new_split = request.splits(syminfo.tickerid, splits.denominator, barmerge.gaps_on, barmerge.lookahead_on, ignore_invalid_symbol=true)

isNewPeriod = switch anchor
“Earnings” => not na(new_earnings)
“Dividends” => not na(new_dividends)
“Splits” => not na(new_split)
“Session” => timeframe.change(“D”)
“Week” => timeframe.change(“W”)
“Month” => timeframe.change(“M”)
“Quarter” => timeframe.change(“3M”)
“Year” => timeframe.change(“12M”)
“Decade” => timeframe.change(“12M”) and year % 10 == 0
“Century” => timeframe.change(“12M”) and year % 100 == 0
=> false

isEsdAnchor = anchor == “Earnings” or anchor == “Dividends” or anchor == “Splits”
if na(srcvwap[1]) and not isEsdAnchor
isNewPeriod := true

float vwapValue = na
float upperBandValue1 = na
float lowerBandValue1 = na
float upperBandValue2 = na
float lowerBandValue2 = na
float upperBandValue3 = na
float lowerBandValue3 = na

if not (hideonDWM and timeframe.isdwm)
[_vwap, _stdevUpper, _] = ta.vwap(srcvwap, isNewPeriod, 1)
vwapValue := _vwap
stdevAbs = _stdevUpper – _vwap
upperBandValue1 := _vwap + stdevAbs * stdevMult_1
lowerBandValue1 := _vwap – stdevAbs * stdevMult_1
upperBandValue2 := _vwap + stdevAbs * stdevMult_2
lowerBandValue2 := _vwap – stdevAbs * stdevMult_2
upperBandValue3 := _vwap + stdevAbs * stdevMult_3
lowerBandValue3 := _vwap – stdevAbs * stdevMult_3

plot(switch_vwap? vwapValue:na, title=”VWAP”, color=#2962FF, offset=offsetvwap)

long_vwap = close>vwapValue
short_vwap = close < vwapValue

////////////////////////////////////////////////
////// Chandelier Exit
///////////////////////////////////////////////

ChandelierE = “██████████ Chandelier Exit ██████████”

ce_length = input(title=’ATR Period’, defval=22,group=ChandelierE)
ce_mult = input.float(title=’ATR Multiplier’, step=0.1, defval=3.0,group=ChandelierE)
showLabels = input(title=’Show Buy/Sell Labels ?’, defval=true,group=ChandelierE)
useClose = input(title=’Use Close Price for Extremums ?’, defval=true,group=ChandelierE)
highlightState = input(title=’Highlight State ?’, defval=true,group=ChandelierE)

ce_atr = ce_mult * ta.atr(ce_length)

longStop = (useClose ? ta.highest(close, ce_length) : ta.highest(ce_length)) – ce_atr
longStopPrev = nz(longStop[1], longStop)
longStop := close[1] > longStopPrev ? math.max(longStop, longStopPrev) : longStop

shortStop = (useClose ? ta.lowest(close, ce_length) : ta.lowest(ce_length)) + ce_atr
shortStopPrev = nz(shortStop[1], shortStop)
shortStop := close[1] < shortStopPrev ? math.min(shortStop, shortStopPrev) : shortStop

var int dir = 1
dir := close > shortStopPrev ? 1 : close < longStopPrev ? -1 : dir

ce_long = dir == 1
ce_short = dir == -1

////////////////////////////////////////////////
////// ROC
///////////////////////////////////////////////

roc_group = “██████████ Rate of Change (ROC) ██████████”

roc_length = input.int(9, minval=1,group=roc_group)
roc_source = input(close, “Source”,group=roc_group)
roc = 100 * (roc_source – roc_source[roc_length])/roc_source[roc_length]
roc_long= roc>0
roc_short = roc<0

////////////////////////////////////////////////
////// SSL Channel
///////////////////////////////////////////////

group_ssl = “██████████ SSL Channel ██████████”
SSLperiod = input(title=’Period’, defval=10, group=group_ssl)
SSLlen = input(title=’Period’, defval=10, group=group_ssl)
smaHigh = ta.sma(high, SSLlen)
smaLow = ta.sma(low, SSLlen)
Hlv = int(na)
Hlv := close > smaHigh ? 1 : close < smaLow ? -1 : Hlv[1]
sslDown = Hlv < 0 ? smaHigh : smaLow
sslUp = Hlv < 0 ? smaLow : smaHigh

ssl_long = sslUp>sslDown
ssl_short = sslUp<sslDown
////////////////////////////////////////////////
////// Chaikin Money Flow
///////////////////////////////////////////////

group_chaikin = “██████████ Chaiken Money Flow ██████████”
chaiking_length = input.int(20, minval=1, group = group_chaikin )
ad = close == high and close == low or high == low ? 0 : (2 * close – low – high) / (high – low) * volume
mf = math.sum(ad, chaiking_length) / math.sum(volume, chaiking_length)

chaikin_long = mf>0
chaikin_short = mf<0

////////////////////////////////////////////////
////// Vortex INdex
///////////////////////////////////////////////
vortex_group = “██████████ Vortex Index ██████████”

period_ = input.int(14, title=”Length”, minval=2, group=vortex_group, inline = ‘vi’)
viupper = input.float(1.1, title=”Upper band”,group=vortex_group, inline = ‘vi’)
vilower = input.float(0.9, title=”Lower Band”, group=vortex_group, inline = ‘vi’)

VMP = math.sum( math.abs( high – low[1]), period_ )
VMM = math.sum( math.abs( low – high[1]), period_ )
STR = math.sum( ta.atr(1), period_ )
vip = VMP / STR
vim = VMM / STR

/////////////////////////////////////////////////
////////Waddar Atar explosion (WAR)
//////////////////////////////////////////////////
group_wae = “██████████ Waddah Attar Explosion ██████████”

wae_sensitivity = input(150, title=”Sensitivity”,group=group_wae)
wae_fastLength=input(20, title=”FastEMA Length”,group=group_wae)
wae_slowLength=input(40, title=”SlowEMA Length”,group=group_wae)
channelLength=input(20, title=”BB Channel Length”,group=group_wae)
wae_mult=input(2.0, title=”BB Stdev Multiplier”,group=group_wae)

deadzone = nz(ta.rma(ta.tr(true),100)) * 3.7

calc_macd(source, wae_fastLength, wae_slowLength) =>
fastMA = ta.ema(source, wae_fastLength)
slowMA = ta.ema(source, wae_slowLength)
fastMA – slowMA

calc_BBUpper(source, length, wae_mult) =>
basis = ta.sma(source, length)
dev = wae_mult * ta.stdev(source, length)
basis + dev

calc_BBLower(source, length, wae_mult) =>
basis = ta.sma(source, length)
dev = wae_mult * ta.stdev(source, length)
basis – dev

t1 = (calc_macd(close, wae_fastLength, wae_slowLength) – calc_macd(close[1], wae_fastLength, wae_slowLength))*wae_sensitivity

e1 = (calc_BBUpper(close, channelLength, wae_mult) – calc_BBLower(close, channelLength, wae_mult))

trendUp = (t1 >= 0) ? t1 : 0
trendDown = (t1 < 0) ? (-1*t1) : 0

wae_long = trendUp and trendUp >e1 and e1 > deadzone and trendUp>deadzone
wae_short = trendDown and trendDown >e1 and e1 > deadzone and trendDown>deadzone

//////////////////////////////////////////////
////////// Range Detector
//////////////////////////////////////////////

rdgroup= “██████████ Range Detector ██████████”

//——————————————————————————
//Settings
//—————————————————————————–{
rd_length = input.int(20, ‘Minimum Range Length’, minval = 2,group=rdgroup)
rd_mult = input.float(1., ‘Range Width’, minval = 0, step = 0.1,group=rdgroup)
rd_atrLen = input.int(500, ‘ATR Length’, minval = 1,group=rdgroup)
//Style
rd_upCss = input(#089981, ‘Broken Upward’, group = ‘Style’,group=rdgroup)
rd_dnCss = input(#f23645, ‘Broken Downward’, group = ‘Style’,group=rdgroup)
unbrokenCss = input(#2157f3, ‘Unbroken’, group = ‘Style’,group=rdgroup)

//—————————————————————————–}
//Detect and highlight ranges
//—————————————————————————–{
//Ranges drawings
var box bx = na
var line lvl = na

//Extensions
var float rd_max = na
var float rd_min = na

var rd_os = 0
color detect_css = na

rd_n = bar_index
rd_atr = ta.atr(rd_atrLen) * rd_mult
rd_ma = ta.sma(close, rd_length)

count = 0
for i = 0 to rd_length-1
count += math.abs(close[i] – rd_ma) > rd_atr ? 1 : 0

// if switch_rd
if count == 0 and count[1] != count
//Test for overlap and change coordinates
if rd_n[rd_length] <= bx.get_right()
rd_max := math.max(rd_ma + rd_atr, bx.get_top())
rd_min := math.min(rd_ma – rd_atr, bx.get_bottom())

if switch_rd
//Box new coordinates
bx.set_top(rd_max)
bx.set_rightbottom(rd_n, rd_min)
bx.set_bgcolor(color.new(unbrokenCss, 80))

//Line new coordinates
avg = math.avg(rd_max, rd_min)
lvl.set_y1(avg)
lvl.set_xy2(rd_n, avg)
lvl.set_color(unbrokenCss)
else
rd_max := rd_ma + rd_atr
rd_min := rd_ma – rd_atr

//Set new box and level
if switch_rd
bx := box.new(rd_n[rd_length], rd_ma + rd_atr, rd_n, rd_ma – rd_atr, na, bgcolor = color.new(unbrokenCss, 80))

lvl := line.new(rd_n[rd_length], rd_ma, rd_n, rd_ma, color = unbrokenCss, style = line.style_dotted)

detect_css := color.new(color.gray, 80)
rd_os := 0

else if count == 0
bx.set_right(rd_n)
lvl.set_x2(rd_n)

//Set color
if close > bx.get_top()
bx.set_bgcolor(color.new(rd_upCss, 80))
lvl.set_color(rd_upCss)
rd_os := 1
else if close < bx.get_bottom()
bx.set_bgcolor(color.new(rd_dnCss, 80))
lvl.set_color(rd_dnCss)
rd_os := -1

//—————————————————————————–}
//Plots
//—————————————————————————–{
//Range detection bgcolor
bgcolor(detect_css)

plot(switch_rd? rd_max:na, ‘Range Top’
, rd_max != rd_max[1] ? na : rd_os == 0 ? unbrokenCss : rd_os == 1 ? rd_upCss : rd_dnCss)

plot(switch_rd ? rd_min:na, ‘Range Bottom’
, rd_min != rd_min[1] ? na : rd_os == 0 ? unbrokenCss : rd_os == 1 ? rd_upCss : rd_dnCss)

//—————————————————————————–}

// for leading indicator
rd_long = close > rd_max
rd_short = close < rd_min

//for confirmation indicator
rd_signal = close > rd_max or close <rd_min

/////////////////////////////////////////////////
////////Volatility Oscillator
//////////////////////////////////////////////////
group_vo = “██████████ Volatility Oscillator ██████████”
volength = input(100, group = group_vo)
spike = close – open
vox = ta.stdev(spike,volength)
voy = ta.stdev(spike,volength) * -1

vo_long = spike > vox
vo_short = spike < voy

/////////////////////////////////////////////////
////////Detrended Price Oscillator (DPO)
//////////////////////////////////////////////////
group_dpo = “██████████ Detrended Price Oscillator (DPO) ██████████”

dpo_period_ = input.int(10, title=”Length”, minval=1,group=group_dpo)
isCentered = input(false, title=”Centered”,group=group_dpo)
barsback = dpo_period_/2 + 1
dpo_ma = ta.sma(close, dpo_period_)
dpo = isCentered ? close[barsback] – dpo_ma : close – dpo_ma[barsback]

dpo_long = dpo > 0
dpo_short = dpo<0

/////////////////////////////////////////////////
////////HACOLT
//////////////////////////////////////////////////
hacolt_group = “███████ Heiken-Ashi Candlestick Oscillator ███████”

hacolt_length = input(defval=55, title=”TEMA Period”,group=hacolt_group)
hacolt_emaLength = input(defval=60, title=”EMA Period”,group=hacolt_group)
hacolt_candleSizeFactor = input(defval=1.1, title=”Candle size factor”,group=hacolt_group)

calc_tema(src, length) =>
hacolt_ema1 = ta.ema(src, length)
hacolt_ema2 = ta.ema(hacolt_ema1, length)
hacolt_ema3 = ta.ema(hacolt_ema2, length)
3 * (hacolt_ema1 – hacolt_ema2) + hacolt_ema3

var bool hacolt_long = na
var bool hacolt_short = na

if respecthacolt or leadingindicator == “Heiken-Ashi Candlestick Oscillator”
var float hacolt_haOpen = na
hacolt_haOpen := nz(hacolt_haOpen[1] + hl2) / 2
hacolt_haClose = (hacolt_haOpen + math.max(high, hacolt_haOpen) + math.min(low, hacolt_haOpen) + hl2) / 4
hacolt_thaClose = calc_tema(hacolt_haClose, hacolt_length)
hacolt_thl2 = calc_tema(hl2, hacolt_length)
hacolt_haCloseSmooth = 2 * hacolt_thaClose – calc_tema(hacolt_thaClose, hacolt_length)
hacolt_hl2Smooth = 2 * hacolt_thl2 – calc_tema(hacolt_thl2, hacolt_length)
hacolt_shortCandle = math.abs(close – open) < ((high – low) * hacolt_candleSizeFactor)
hacolt_keepn1 = ((hacolt_haClose >= hacolt_haOpen) and (hacolt_haClose[1] >= hacolt_haOpen[1])) or (close >= hacolt_haClose) or (high > high[1]) or (low > low[1]) or (hacolt_hl2Smooth >= hacolt_haCloseSmooth)
hacolt_keepall1 = hacolt_keepn1 or (hacolt_keepn1[1] and (close >= open) or (close >= close[1]))
hacolt_keep13 = hacolt_shortCandle and (high >= low[1])
hacolt_utr = hacolt_keepall1 or (hacolt_keepall1[1] and hacolt_keep13)
hacolt_keepn2 = (hacolt_haClose < hacolt_haOpen) and (hacolt_haClose[1] < hacolt_haOpen[1]) or (hacolt_hl2Smooth < hacolt_haCloseSmooth)
hacolt_keep23 = hacolt_shortCandle and (low <= high[1])
hacolt_keepall2 = hacolt_keepn2 or (hacolt_keepn2[1] and (close < open) or (close < close[1]))
hacolt_dtr = hacolt_keepall2 or (hacolt_keepall2[1] and hacolt_keep23)
hacolt_upw = hacolt_dtr == 0 and hacolt_dtr[1] and hacolt_utr
hacolt_dnw = hacolt_utr == 0 and hacolt_utr[1] and hacolt_dtr
var bool hacolt_upwWithOffset = na
hacolt_upwWithOffset := hacolt_upw != hacolt_dnw ? hacolt_upw : nz(hacolt_upwWithOffset[1])

hacolt_buySig = hacolt_upw or (not hacolt_dnw and (na(hacolt_upwWithOffset) ? false : hacolt_upwWithOffset))
hacolt_ltSellSig = close < ta.ema(close, hacolt_emaLength)
var bool hacolt_neutralSig = na
hacolt_neutralSig := hacolt_buySig or (hacolt_ltSellSig ? false : nz(hacolt_neutralSig[1]))
hacolt = hacolt_buySig ? 1 : hacolt_neutralSig ? 0 : -1

hacolt_long := hacolt > 0
hacolt_short := hacolt < 0

/////////////////////////////////////////////////
////////Choppiness Index
//////////////////////////////////////////////////
group_ci = “██████████ Choppiness Index ██████████”

ci_length = input.int(14, minval=1,group=group_ci)

ci_index = 100 * math.log10(math.sum(ta.atr(1), ci_length) / (ta.highest(ci_length) – ta.lowest(ci_length))) / math.log10(ci_length)

ci_filter = ci_index<ci_limit

//////////////////////////////////////////////////
////////Damiani Volatmeter
//////////////////////////////////////////////////

dv_group = “██████████ Damiani Volatmeter ██████████”
int vis_atr = input.int(13,title=”Vis ATR”, group=dv_group, inline = ‘1’)
int vis_std = input.int(20,title=”Vis STD”, group=dv_group, inline = ‘1’)
int sed_atr = input.int(40,title=”Sed ATR”, group=dv_group, inline = ‘1’)
int sed_std = input.int(100,title=”SEd STD”, group=dv_group, inline = ‘1’)
float threshold_level = input.float(1.4,title=”Threshold”, group=dv_group, inline = ‘1’)
bool lag_supressor = input.bool(true,title=”Lag Supressor”, group=dv_group, inline = ‘1’)
lag_s_K = 0.5

vol = 0.0
s1_pivot=nz(vol[1], 0)
s3_pivot=nz(vol[3], 0)

vol := lag_supressor ? ta.atr(vis_atr) / ta.atr(sed_atr) + lag_s_K*(s1_pivot-s3_pivot) : ta.atr(vis_atr) / ta.atr(sed_atr)
anti_thres = ta.stdev(close, vis_std) / ta.stdev(close, sed_std)
t = threshold_level – anti_thres
vol_m = vol > t ? -1 : 0.03

//////////////////////////////////////////////
/////// MACD
/////////////////////////////////////////////
macd_group = “██████████ MACD ██████████”
fast_length = input(title=”Fast Length”, defval=12,group=macd_group)
slow_length = input(title=”Slow Length”, defval=26,group=macd_group)
macdsrc = input(title=”Source”, defval=close,group=macd_group)
signal_length = input.int(title=”Signal Smoothing”, minval = 1, maxval = 50, defval = 9,group=macd_group)
sma_source = input.string(title=”Oscillator MA Type”, defval=”EMA”, options=[“SMA”, “EMA”],group=macd_group)
sma_signal = input.string(title=”Signal Line MA Type”, defval=”EMA”, options=[“SMA”, “EMA”],group=macd_group)

fast_ma = sma_source == “SMA” ? ta.sma(macdsrc, fast_length) : ta.ema(macdsrc, fast_length)
slow_ma = sma_source == “SMA” ? ta.sma(macdsrc, slow_length) : ta.ema(macdsrc, slow_length)
macdd = fast_ma – slow_ma
signal = sma_signal == “SMA” ? ta.sma(macdd, signal_length) : ta.ema(macdd, signal_length)
hist = macdd – signal

/////////////////////////////////////////////
///// Awesome Oscillator
////////////////////////////////////////////

ao_group = “██████████ Awesome Oscillator ██████████”
nLengthSlow = input(34, title=”Length Slow”,group=ao_group)
nLengthFast = input(5, title=”Length Fast”,group=ao_group)
reverse = input(false, title=”Trade reverse”,group=ao_group)
xSMA1_hl2 = ta.sma(hl2, nLengthFast)
xSMA2_hl2 = ta.sma(hl2, nLengthSlow)
xSMA1_SMA2 = xSMA1_hl2 – xSMA2_hl2
xSMA_hl2 = ta.sma(xSMA1_SMA2, nLengthFast)
nRes = xSMA1_SMA2 – xSMA_hl2

//// zero line cross (standard code)
ao = ta.sma(hl2,5) – ta.sma(hl2,34)
diff = ao – ao[1]

ao_long = bool(na)
ao_short = bool(na)

if aotype == “AC Zero Line Cross”
ao_long := nRes > nRes[1] and nRes > 0
ao_short := nRes < nRes[1] and nRes < 0
else if aotype == “AC Momentum Bar”
ao_long := nRes > nRes[1]
ao_short := nRes < nRes[1]
else if aotype == “Zero Line Cross”
ao_long := ao > 0
ao_short := ao < 0

/////////////////////////////////////////////
///// WolfPack ID
////////////////////////////////////////////

wolfgroup = “██████████ Wolf Pack ID ██████████”
input1 = input(title=’Fast Length’, group=wolfgroup,defval=3)
input2 = input(title=’Slow Length’,group=wolfgroup, defval=8)
pivR = input(title=’Wolfpack Wave Pivot Lookback Right’, group=wolfgroup,defval=1)
pivL = input(title=’Wolfpack Wave Pivot Lookback Left’,group=wolfgroup, defval=15)
fastmaa = ta.ema(close, input1)
fastmab = ta.ema(close, input2)
wolfsrc = close
bspread = (fastmaa – fastmab) * 1.001
adline = 0
m = bspread > 0 ? color.new(color.lime, 0) : color.new(color.red, 0)
wolfup = ta.rma(math.max(ta.change(wolfsrc), 0), 3)
wolfdown = ta.rma(-math.min(ta.change(wolfsrc), 0), 3)
lbR = input(title=’Divergence Pivot Lookback Right’,group=wolfgroup, defval=1)
lbL = input(title=’Divergence Pivot Lookback Left’, group=wolfgroup,defval=10)
rangeUpper = input(title=’Max of Lookback Range’,group=wolfgroup, defval=100)
rangeLower = input(title=’Min of Lookback Range’, group=wolfgroup,defval=2)

osc = bspread

_inRange(cond) =>
bars = ta.barssince(cond == true)
rangeLower <= bars and bars <= rangeUpper

wolf_long = bspread > 0
wolf_short = bspread < 0

/////////////////////////////////////////////
///// Bollinger Band (BB)
////////////////////////////////////////////

bb_group= “██████████ Bollinger Band ██████████”
bb_length = input.int(20, minval=1)
bb_maType = input.string(“SMA”, “Basis MA Type”, options = [“SMA”, “EMA”, “SMMA (RMA)”, “WMA”, “VWMA”])
bbsrc = input(close, title=”Source”)
bbmult = input.float(2.0, minval=0.001, maxval=50, title=”StdDev”)

bb_basis = ma(bbsrc, bb_length, bb_maType)
bbdev = bbmult * ta.stdev(bbsrc, bb_length)
bbupper = bb_basis + bbdev
bblower = bb_basis – bbdev
bboffset = input.int(0, “Offset”, minval = -500, maxval = 500)
plot(switch_bb ? bb_basis:na, “Basis”, color=#FF6D00, offset = bboffset)
bbp1 = plot(switch_bb ? bbupper:na, “Upper”, color=#2962FF, offset = bboffset)
bbp2 = plot(switch_bb ? bblower:na, “Lower”, color=#2962FF, offset = bboffset)
fillColor = switch_bb ? color.rgb(33, 150, 243, 95) : na
fill(bbp1, bbp2, title = “Background”, color=fillColor)

/////////////////////////////////////////////
///// BB Oscillator
////////////////////////////////////////////
bbgroup = “██████████ Bollinger Band (BB) Oscillator ██████████”

bbosc_length = input.int(20, minval=1,group=bbgroup)
bbosc_src = input(close, title=’Source’,group=bbgroup)
bbosc_mult = input.float(2.0, minval=0.001, maxval=50, title=’StdDev’,group=bbgroup)
bbosc_basis = ta.sma(bbosc_src, bbosc_length)
dlength = input.int(4, minval=1, title=’Trigger Length’,group=bbgroup)
bbosc_offset = input.int(0, ‘Offset’, minval=-500, maxval=500,group=bbgroup, tooltip = “Use Offset and Show Last to turn indicator into a widget.\nExample:\nOffset = 120\nShow Last = 100 “)
bbosc_last = input(0, ‘Show Last’,group=bbgroup)
bbosc_dev = bbosc_mult * ta.stdev(bbosc_src, bbosc_length)
bbosc_upper = bbosc_basis + bbosc_dev
bbosc_lower = bbosc_basis – bbosc_dev
upercent = (bbosc_upper – close) / (bbosc_upper + close / 2)
lpercent = (bbosc_lower – close) / (bbosc_lower + close / 2)
bpercent = (bbosc_basis – close) / (bbosc_basis + close / 2)
usmooth = ta.wma(upercent, 6)
lsmooth = ta.wma(lpercent, 6)
bsmooth = ta.wma(bpercent, 6)
d1 = ta.sma(bsmooth, 2)
j = (bsmooth + d1) * -1
d2 = ta.sma(j, dlength)

bbosc_long = bool(na)
bbosc_short = bool(na)

bbcycle = 0
bbup = ta.crossover(j, usmooth)
bbdown = ta.crossunder(j, lsmooth)
bbcycle := bbup ? 1 : bbdown ? -1 : bbcycle[1]

if bbtype == “Entering Lower/Upper Band”
bbosc_long := j > d2 and (j==lsmooth or j>lsmooth) and bbcycle==-1
bbosc_short:= j < d2 and (j==usmooth or j<usmooth) and bbcycle==1
else if bbtype == “Exiting Lower/Upper Band”
bbosc_long := j > d2 and (j>usmooth)
bbosc_short:= j < d2 and (j<lsmooth)

// ////////////////////////////////////////////
// ///// Trend Meter
// ////////////////////////////////////////////
// tm_group = “██████████ Trend Meter ██████████”

// ShowTrendBar = true

// WTSetups = input.bool(true, ‘Wave Trend Filtered by Trend’, group=tm_group, inline = ‘tm’)

// TMSetups = input.bool(true, ‘All 3 Trend Meters Now Align’, group=tm_group, inline = ‘tm2’)

// MSBar1 = ‘Trend Filter’ // input(title= “1 – Wave Trend Signals”, defval = “Trend Filter”, options = [“N/A”, “Trend Filter”, “Filter X”, “Filter X + Trend Filter”])

// MSBar2 = ‘Trend Filter’ // input(title= “2 – Wave Trend Signals”, defval = “Filter X”, options = [“N/A”, “Trend Filter”, “Filter X”, “Filter X + Trend Filter”])

// TrendBar1 = input.string(title=’Trend Meter 1′, defval=’MACD Crossover – Fast – 8, 21, 5′, options=[‘MACD Crossover – 12, 26, 9’, ‘MACD Crossover – Fast – 8, 21, 5’, ‘Mom Dad Cross (Top Dog Trading)’, ‘RSI Signal Line Cross – RSI 13, Sig 21’, ‘RSI 13: > or < 50’, ‘RSI 5: > or < 50’, ‘Trend Candles’, ‘N/A’], group=’Trend Meters’) // “MA Crossover”, “DAD Direction (Top Dog Trading)”,

// TrendBar2 = input.string(title=’Trend Meter 2′, defval=’RSI 13: > or < 50′, options=[‘MACD Crossover – 12, 26, 9’, ‘MACD Crossover – Fast – 8, 21, 5’, ‘Mom Dad Cross (Top Dog Trading)’, ‘RSI Signal Line Cross – RSI 13, Sig 21’, ‘RSI 13: > or < 50’, ‘RSI 5: > or < 50’, ‘Trend Candles’, ‘N/A’], group=’Trend Meters’) // “MA Crossover”, “DAD Direction (Top Dog Trading)”,

// TrendBar3 = input.string(title=’Trend Meter 3′, defval=’RSI 5: > or < 50′, options=[‘MACD Crossover – 12, 26, 9’, ‘MACD Crossover – Fast – 8, 21, 5’, ‘Mom Dad Cross (Top Dog Trading)’, ‘RSI Signal Line Cross – RSI 13, Sig 21’, ‘RSI 13: > or < 50’, ‘RSI 5: > or < 50’, ‘Trend Candles’, ‘N/A’], group=’Trend Meters’) // “MA Crossover”, “DAD Direction (Top Dog Trading)”,

// TrendBar4 = input.string(title=’Trend Bar 1′, defval=’MA Crossover’, options=[‘MA Crossover’, ‘MA Direction – Fast MA – TB1’, ‘MA Direction – Slow MA – TB1’, ‘N/A’], group=’Trend Bars’) // “MACD Crossover – 12, 26 9”, “MACD Crossover – Fast – 8, 21, 5”, “DAD Direction (Top Dog Trading)”,

// TrendBar5 = input.string(title=’Trend Bar 2′, defval=’MA Crossover’, options=[‘MA Crossover’, ‘MA Direction – Fast MA – TB2’, ‘MA Direction – Slow MA – TB2’, ‘N/A’], group=’Trend Bars’) // “MACD Crossover – 12, 26 9”, “MACD Crossover – Fast – 8, 21, 5”, “DAD Direction (Top Dog Trading)”,

// ////////////////Signals – Wave Trend/////////////////////////////////////////////////////////////////////////////////////////////////

// // Wave Trend – RSI

// RSIMC = ta.rsi(close, 14)

// // Wave Trend

// ap = hlc3 // input(hlc3, “Wave Trend – Source”)
// n1 = 9 //input(9, “Wave Trend – WT Channel Length”)
// n2 = 12 // input(12, “Wave Trend – WT Average Length”)
// esa = ta.ema(ap, n1)
// de = ta.ema(math.abs(ap – esa), n1)
// ci = (ap – esa) / (0.015 * de)
// tci = ta.ema(ci, n2)
// wt11 = tci
// wt22 = ta.sma(wt11, 3)

// // Wave Trend – Overbought & Oversold lines

// obLevel2 = 60 // input( 60, “Wave Trend – WT Very Overbought”)
// obLevel = 50 // input( 50, “Wave Trend – WT Overbought”)
// osLevel = -50 // input(-50, “Wave Trend – WT Oversold”)
// osLevel2 = -60 // input(-60, “Wave Trend – WT Very Oversold”)

// // Wave Trend – Conditions

// WTCross = ta.cross(wt11, wt22)
// WTCrossUp = wt22 – wt11 <= 0
// WTCrossDown = wt22 – wt11 >= 0
// WTOverSold = wt22 <= osLevel2
// WTOverBought = wt22 >= obLevel2

// // MA Inputs

// MA1_Length = input.int(5, title=’Fast MA’, minval=1, group=’Trend Bar 1 – Settings’, inline=’TB1 Fast’)
// MA1_Type = input.string(title=”, defval=’EMA’, options=[‘EMA’, ‘SMA’], group=’Trend Bar 1 – Settings’, inline=’TB1 Fast’)

// MA2_Length = input.int(11, title=’Slow MA’, minval=1, group=’Trend Bar 1 – Settings’, inline=’TB1 Slow’)
// MA2_Type = input.string(title=”, defval=’EMA’, options=[‘EMA’, ‘SMA’], group=’Trend Bar 1 – Settings’, inline=’TB1 Slow’)

// MA3_Length = input.int(9, title=’Fast MA’, minval=1, group=’Trend Bar 2 – Settings’, inline=’TB2 Fast’)
// MA3_Type = input.string(title=”, defval=’EMA’, options=[‘EMA’, ‘SMA’], group=’Trend Bar 2 – Settings’, inline=’TB2 Fast’)

// MA4_Length = input.int(21, title=’Slow MA’, minval=1, group=’Trend Bar 2 – Settings’, inline=’TB2 Slow’)
// MA4_Type = input.string(title=”, defval=’SMA’, options=[‘EMA’, ‘SMA’], group=’Trend Bar 2 – Settings’, inline=’TB2 Slow’)

// // MA Calculations

// Close = request.security(syminfo.tickerid, timeframe.period, close, lookahead=barmerge.lookahead_on)

// MA1 = if MA1_Type == ‘SMA’
// ta.sma(Close, MA1_Length)
// else
// ta.ema(Close, MA1_Length)

// MA2 = if MA2_Type == ‘SMA’
// ta.sma(Close, MA2_Length)
// else
// ta.ema(Close, MA2_Length)

// MA3 = if MA3_Type == ‘SMA’
// ta.sma(Close, MA3_Length)
// else
// ta.ema(Close, MA3_Length)

// MA4 = if MA4_Type == ‘SMA’
// ta.sma(Close, MA4_Length)
// else
// ta.ema(Close, MA4_Length)

// // MA Crossover Condition

// MACrossover1 = MA1 > MA2 ? 1 : 0

// MACrossover2 = MA3 > MA4 ? 1 : 0

// // MA Direction Condition

// MA1Direction = MA1 > MA1[1] ? 1 : 0

// MA2Direction = MA2 > MA2[1] ? 1 : 0

// MA3Direction = MA3 > MA3[1] ? 1 : 0

// MA4Direction = MA4 > MA4[1] ? 1 : 0

// // MA Direction Change Condition

// MA1PositiveDirectionChange = MA1Direction and not MA1Direction[1] ? 1 : 0

// MA2PositiveDirectionChange = MA2Direction and not MA2Direction[1] ? 1 : 0

// MA3PositiveDirectionChange = MA3Direction and not MA3Direction[1] ? 1 : 0

// MA4PositiveDirectionChange = MA4Direction and not MA4Direction[1] ? 1 : 0

// MA1NegativeDirectionChange = not MA1Direction and MA1Direction[1] ? 1 : 0

// MA2NegativeDirectionChange = not MA2Direction and MA2Direction[1] ? 1 : 0

// MA3NegativeDirectionChange = not MA3Direction and MA3Direction[1] ? 1 : 0

// MA4NegativeDirectionChange = not MA4Direction and MA4Direction[1] ? 1 : 0

// // MACD and MOM & DAD – Top Dog Trading

// // Standard MACD Calculations

// MACDfastMA = 12
// MACDslowMA = 26
// MACDsignalSmooth = 9

// MACDLine = ta.ema(close, MACDfastMA) – ta.ema(close, MACDslowMA)

// SignalLine = ta.ema(MACDLine, MACDsignalSmooth)

// MACDHistogram = MACDLine – SignalLine

// // MACD- Background Color Change Condition

// MACDHistogramCross = MACDHistogram > 0 ? 1 : 0

// MACDLineOverZero = MACDLine > 0 ? 1 : 0

// MACDLineOverZeroandHistogramCross = MACDHistogramCross and MACDLineOverZero ? 1 : 0

// MACDLineUnderZeroandHistogramCross = not MACDHistogramCross and not MACDLineOverZero ? 1 : 0

// // Fast MACD Calculations

// FastMACDfastMA = 8
// FastMACDslowMA = 21
// FastMACDsignalSmooth = 5

// FastMACDLine = ta.ema(close, FastMACDfastMA) – ta.ema(close, FastMACDslowMA)

// FastSignalLine = ta.ema(FastMACDLine, FastMACDsignalSmooth)

// FastMACDHistogram = FastMACDLine – FastSignalLine

// // Fast MACD- Background Color Change Condition

// FastMACDHistogramCross = FastMACDHistogram > 0 ? 1 : 0

// FastMACDLineOverZero = FastMACDLine > 0 ? 1 : 0

// FastMACDLineOverZeroandHistogramCross = FastMACDHistogramCross and FastMACDLineOverZero ? 1 : 0

// FastMACDLineUnderZeroandHistogramCross = not FastMACDHistogramCross and not FastMACDLineOverZero ? 1 : 0

// // Top Dog Trading – Mom Dad Calculations

// TopDog_Fast_MA = 5
// TopDog_Slow_MA = 20
// TopDog_Sig = 30

// TopDogMom = ta.ema(close, TopDog_Fast_MA) – ta.ema(close, TopDog_Slow_MA)

// TopDogDad = ta.ema(TopDogMom, TopDog_Sig)

// // Top Dog Dad – Background Color Change Condition

// TopDogDadDirection = TopDogDad > TopDogDad[1] ? 1 : 0

// TopDogMomOverDad = TopDogMom > TopDogDad ? 1 : 0

// TopDogMomOverZero = TopDogMom > 0 ? 1 : 0

// ////// Trend Barmeter Calculations //////

// haclose_tm = ohlc4
// haopen_tm = 0.0
// haopen_tm := na(haopen_tm[1]) ? (open + close) / 2 : (haopen_tm[1] + haclose_tm[1]) / 2

// // RSI 5 Trend Barmeter Calculations

// RSI5 = ta.rsi(close, 5)

// RSI5Above50 = RSI5 > 50 ? 1 : 0

// // RSI 5 Trend Barmeter Calculations

// RSI13 = ta.rsi(close, 13)

// // Linear Regression Calculation For RSI Signal Line

// SignalLineLength1 = 21

// x = bar_index
// y = RSI13
// x_ = ta.sma(x, SignalLineLength1)
// y_ = ta.sma(y, SignalLineLength1)
// mx = ta.stdev(x, SignalLineLength1)
// my = ta.stdev(y, SignalLineLength1)
// c = ta.correlation(x, y, SignalLineLength1)
// slope = c * (my / mx)
// inter = y_ – slope * x_
// LinReg1 = x * slope + inter

// RSISigDirection = LinReg1 > LinReg1[1] ? 1 : 0

// RSISigCross = RSI13 > LinReg1 ? 1 : 0

// RSI13Above50 = RSI13 > 50 ? 1 : 0

// TrendBar1Result = TrendBar1 == ‘MA Crossover’ ? MACrossover1 : TrendBar1 == ‘MACD Crossover – 12, 26, 9’ ? MACDHistogramCross : TrendBar1 == ‘MACD Crossover – Fast – 8, 21, 5’ ? FastMACDHistogramCross : TrendBar1 == ‘Mom Dad Cross (Top Dog Trading)’ ? TopDogMomOverDad : TrendBar1 == ‘DAD Direction (Top Dog Trading)’ ? TopDogDadDirection : TrendBar1 == ‘RSI Signal Line Cross – RSI 13, Sig 21’ ? RSISigCross : TrendBar1 == ‘RSI 5: > or < 50’ ? RSI5Above50 : TrendBar1 == ‘RSI 13: > or < 50’ ? RSI13Above50 : na

// TrendBar2Result = TrendBar2 == ‘MA Crossover’ ? MACrossover1 : TrendBar2 == ‘MACD Crossover – 12, 26, 9’ ? MACDHistogramCross : TrendBar2 == ‘MACD Crossover – Fast – 8, 21, 5’ ? FastMACDHistogramCross : TrendBar2 == ‘Mom Dad Cross (Top Dog Trading)’ ? TopDogMomOverDad : TrendBar2 == ‘DAD Direction (Top Dog Trading)’ ? TopDogDadDirection : TrendBar2 == ‘RSI Signal Line Cross – RSI 13, Sig 21’ ? RSISigCross : TrendBar2 == ‘RSI 5: > or < 50’ ? RSI5Above50 : TrendBar2 == ‘RSI 13: > or < 50’ ? RSI13Above50 : na

// TrendBar3Result = TrendBar3 == ‘MA Crossover’ ? MACrossover1 : TrendBar3 == ‘MACD Crossover – 12, 26, 9’ ? MACDHistogramCross : TrendBar3 == ‘MACD Crossover – Fast – 8, 21, 5’ ? FastMACDHistogramCross : TrendBar3 == ‘Mom Dad Cross (Top Dog Trading)’ ? TopDogMomOverDad : TrendBar3 == ‘DAD Direction (Top Dog Trading)’ ? TopDogDadDirection : TrendBar3 == ‘RSI Signal Line Cross – RSI 13, Sig 21’ ? RSISigCross : TrendBar3 == ‘RSI 5: > or < 50’ ? RSI5Above50 : TrendBar3 == ‘RSI 13: > or < 50’ ? RSI13Above50 : na

// FilterXUp = FastMACDHistogramCross and ta.ema(close, 15) > ta.ema(close, 15)[1]

// FilterXDown = not FastMACDHistogramCross and ta.ema(close, 15) < ta.ema(close, 15)[1]

// TrendFilterPlus = ta.ema(close, 15) > ta.ema(close, 20) and ta.ema(close, 20) > ta.ema(close, 30) and ta.ema(close, 30) > ta.ema(close, 40) and ta.ema(close, 40) > ta.ema(close, 50) ? 1 : 0

// TrendFilterMinus = ta.ema(close, 15) < ta.ema(close, 20) and ta.ema(close, 20) < ta.ema(close, 30) and ta.ema(close, 30) < ta.ema(close, 40) and ta.ema(close, 40) < ta.ema(close, 50) ? 1 : 0

// MSBar1PositiveWaveTrendSignal = MSBar1 == ‘Filter X’ ? FilterXUp and WTCross and WTCrossUp : MSBar1 == ‘Trend Filter’ ? TrendFilterPlus and WTCross and WTCrossUp : MSBar1 == ‘Filter X + Trend Filter’ ? FilterXUp and TrendFilterPlus and WTCross and WTCrossUp : WTCross and WTCrossUp
// MSBar1NegativeWaveTrendSignal = MSBar1 == ‘Filter X’ ? FilterXDown and WTCross and WTCrossDown : MSBar1 == ‘Trend Filter’ ? TrendFilterMinus and WTCross and WTCrossDown : MSBar1 == ‘Filter X + Trend Filter’ ? FilterXDown and TrendFilterMinus and WTCross and WTCrossDown : WTCross and WTCrossDown

// MSBar2PositiveWaveTrendSignal = MSBar2 == ‘Filter X’ ? FilterXUp and WTCross and WTCrossUp : MSBar2 == ‘Trend Filter’ ? TrendFilterPlus and WTCross and WTCrossUp : MSBar2 == ‘Filter X + Trend Filter’ ? FilterXUp and TrendFilterPlus and WTCross and WTCrossUp : WTCross and WTCrossUp
// MSBar2NegativeWaveTrendSignal = MSBar2 == ‘Filter X’ ? FilterXDown and WTCross and WTCrossDown : MSBar2 == ‘Trend Filter’ ? TrendFilterMinus and WTCross and WTCrossDown : MSBar2 == ‘Filter X + Trend Filter’ ? FilterXDown and TrendFilterMinus and WTCross and WTCrossDown : WTCross and WTCrossDown

// ///////////////////////////////////////////////////////////////////////////////////////////////////////////////

// CrossoverType2 = TrendBar4 == ‘DAD Direction (Top Dog Trading)’ ? TopDogDadDirection : TrendBar4 == ‘MACD Crossover’ ? MACDHistogramCross : TrendBar4 == ‘MA Direction – Fast MA – TB1’ ? MA1Direction : TrendBar4 == ‘MA Direction – Slow MA – TB1’ ? MA2Direction : MACrossover1

// CrossoverType3 = TrendBar5 == ‘DAD Direction (Top Dog Trading)’ ? TopDogDadDirection : TrendBar5 == ‘MACD Crossover’ ? MACDHistogramCross : TrendBar5 == ‘MA Direction – Fast MA – TB2’ ? MA3Direction : TrendBar5 == ‘MA Direction – Slow MA – TB2′ ? MA4Direction : MACrossover2

// MaxValueMACrossUp = ta.crossover(ta.ema(Close, 5), ta.ema(Close, 11))
// MaxValueMACrossDown = ta.crossunder(ta.ema(Close, 5), ta.ema(Close, 11))

// TB1MACrossUp = ta.crossover(MA1, MA2)
// TB1MACrossDown = ta.crossunder(MA1, MA2)

// TB2MACrossUp = ta.crossover(MA3, MA4)
// TB2MACrossDown = ta.crossunder(MA3, MA4)

// TB1Green = MA1 > MA2
// TB1Red = MA1 < MA2

// TB2Green = MA3 > MA4
// TB2Red = MA3 < MA4

// TB12Green = TB1Green and TB2Green and (TB1MACrossUp or TB2MACrossUp)
// TB12Red = TB1Red and TB2Red and (TB1MACrossDown or TB2MACrossDown)

/////////////////////////////////
/////// Stochastic
/////////////////////////////////
groupname = “██████████ Stochastic ██████████”
len = input.int(14, minval=1, title=”Length”,group=groupname)
smoothK = input.int(3, minval=1, title=”K Smoothing”,group=groupname)
smoothD = input.int(3, minval=1, title=”D Smoothing”,group=groupname)
upLine = input.int(80, minval=50, maxval=90, title=”Overbought level”,group=groupname)
lowLine = input.int(20, minval=10, maxval=50, title=”Oversold level”,group=groupname)

//Resolutioon for MTF
resstoch = timeframe.period
//Stoch formula
kk = ta.sma(ta.stoch(close, high, low, len), smoothK)
dd = ta.sma(kk, smoothD)
outK = request.security(syminfo.tickerid, resstoch, kk)
outD = request.security(syminfo.tickerid, resstoch, dd)

//definitions for Cross
aboveLine = outK > upLine ? 1 : 0
belowLine = outK < lowLine ? 1 : 0
stoch_long = bool (na)
stoch_short = bool (na)
if stochtype == “CrossOver”
stoch_long := (outK[1] < outD[1] and outK > outD) ? 1 : 0
stoch_short := (outK[1] > outD[1] and outK < outD) ? 1 : 0
else if stochtype == “CrossOver in OB & OS levels”
stoch_long := (outK[1] < outD[1] and outK[1] < lowLine[1]) and (outK > outD) and outK > lowLine? 1 : 0
stoch_short := (outK[1] > outD[1] and outK[1] > upLine[1]) and (outK < outD) and outK < upLine? 1 : 0
else if stochtype == “%K above/below %D”
stoch_long := outK > outD
stoch_short := outK < outD

///////////////////////////////////////////////
///////RSI
///////////////////////////////////////////////

rsi_group = “█████████████████ RSI █████████████████”

rsiLengthInput = input.int(14, minval=1, title=”RSI Length”, group=rsi_group)
rsiSourceInput = input.source(close, “Source”, group=rsi_group)
maTypeInput = input.string(“SMA”, title=”MA Type”, options=[“SMA”, “Bollinger Bands”, “EMA”, “SMMA (RMA)”, “WMA”, “VWMA”], group=rsi_group)
rsi_upper = input.int(defval=80, title=’Overbought Zone’, group=rsi_group, inline=’zone’)
rsi_lower = input.int(defval=20, title=’Oversold Zone’, group=rsi_group, inline=’zone’)

respectrsilevel = input.int(defval=50, minval=1, title=’RSI MidLine’, group=rsi_group)
maLengthInput = input.int(14, title=”MA Length”, group=rsi_group)

up = ta.rma(math.max(ta.change(rsiSourceInput), 0), rsiLengthInput)
down = ta.rma(-math.min(ta.change(rsiSourceInput), 0), rsiLengthInput)
rsi = down == 0 ? 100 : up == 0 ? 0 : 100 – (100 / (1 + up / down))
rsiMA = ma(rsi, maLengthInput, maTypeInput)
isBB = maTypeInput == “Bollinger Bands”

///////////////////////////////////////////////
/// HULL SUITE
//////////////////////////////////////////////
hull_group = “██████████ HullSuite ██████████”
//INPUT
hullsrc = input(close, title=’Source’,group=hull_group)
modeSwitch = input.string(‘Hma’, title=’Hull Variation’, options=[‘Hma’, ‘Thma’, ‘Ehma’],group=hull_group)
hull_length = input(55, title=’hull_length(180-200 for floating S/R , 55 for swing entry)’,group=hull_group)
hull_lengthMult = input(1.0, title=’hull_length multiplier (Used to view higher timeframes with straight band)’,group=hull_group)

useHtf = input(false, title=’Show Hull MA from X timeframe? (good for scalping)’,group=hull_group)
htf = input.timeframe(‘240′, title=’Higher timeframe’,group=hull_group)

//FUNCTIONS
//HMA
HMA(_hullsrc, _hull_length) =>
ta.wma(2 * ta.wma(_hullsrc, _hull_length / 2) – ta.wma(_hullsrc, _hull_length), math.round(math.sqrt(_hull_length)))
//EHMA
EHMA(_hullsrc, _hull_length) =>
ta.ema(2 * ta.ema(_hullsrc, _hull_length / 2) – ta.ema(_hullsrc, _hull_length), math.round(math.sqrt(_hull_length)))
//THMA
THMA(_hullsrc, _hull_length) =>
ta.wma(ta.wma(_hullsrc, _hull_length / 3) * 3 – ta.wma(_hullsrc, _hull_length / 2) – ta.wma(_hullsrc, _hull_length), _hull_length)

//SWITCH
Mode(modeSwitch, hullsrc, len) =>
modeSwitch == ‘Hma’ ? HMA(hullsrc, len) : modeSwitch == ‘Ehma’ ? EHMA(hullsrc, len) : modeSwitch == ‘Thma’ ? THMA(hullsrc, len / 2) : na

//OUT
_hull = Mode(modeSwitch, hullsrc, int(hull_length * hull_lengthMult))
HULL = useHtf ? request.security(syminfo.ticker, htf, _hull) : _hull
MHULL = HULL[0]
SHULL = HULL[2]

//COLOR
// hullColor = switchColor ? HULL > HULL[2] ? #00ff00 : #ff0000 : #ff9800

/////////////////////////
/// STC overlay signal
/////////////////////////
stc_group = “██████████ Schaff Trend Cycle (STC) ██████████”
fastLength = input(title=’MACD Fast Length’, defval=23, group=stc_group)
slowLength = input(title=’MACD Slow Length’, defval=50, group=stc_group)
cycleLength = input(title=’Cycle Length’, defval=10, group=stc_group)
d1Length = input(title=’1st %D Length’, defval=3, group=stc_group)
d2Length = input(title=’2nd %D Length’, defval=3, group=stc_group)
srcstc = input(title=’Source’, defval=close, group=stc_group)
upper = input(title=’Upper Band’, defval=75, group=stc_group)
lower = input(title=’Lower Band’, defval=25, group=stc_group)
v_show_last = input(2000, “Plotting Length”, group=stc_group)

macd = ta.ema(srcstc, fastLength) – ta.ema(srcstc, slowLength)
k = nz(fixnan(ta.stoch(macd, macd, macd, cycleLength)))
d = ta.ema(k, d1Length)
kd = nz(fixnan(ta.stoch(d, d, d, cycleLength)))
stc = ta.ema(kd, d2Length)
stc := math.max(math.min(stc, 100), 0)

stcColor1 = stc > stc[1] ? color.green : color.red
stcColor2 = stc > upper ? color.green : stc <= lower ? color.red : color.orange

upperCrossover = ta.crossover(stc, upper)
upperCrossunder = ta.crossunder(stc, upper)
lowerCrossover = ta.crossover(stc, lower)
lowerCrossunder = ta.crossunder(stc, lower)
stcup = stc >= upper
stcdown = stc <= lower

plotshape(stcdown and switch_stc? true :na, style=shape.circle, location=location.top , show_last = v_show_last, color=color.new(color.red, 0), title=’STC Sell’)
plotshape(stcup and switch_stc? true:na, style=shape.circle, location=location.top, show_last = v_show_last, color=color.new(color.green, 0), title=’STC Buy’)

//////////////////////////////////////////////////////
//vector candles
/////////////////////////////////////////////////////

// Indicator Settings

pvsra_group=”██████████ PVSRA ██████████”

var overideCandleColours = input.bool(title=’Override Candles with PVSRA Colour’, defval=true, tooltip=”Indicator must be dragged to the top of the Object Tree to display correctly”, group=pvsra_group)

var bool override_imnt = input.bool(defval=false, title=”Overide Symbol”, group=pvsra_group, inline=”0″)
var string pvsra_sym = input.symbol(title=””, defval=”BINANCE:BTCUSDTPERP”, group=pvsra_group, inline=”0″)

var Bull200CandleColor = input.color(color.new(color.lime, 0), title=”200% Volume”, group=pvsra_group, inline=”1″)
var Bear200CandleColor = input.color(color.new(color.red, 0), title=””, group=pvsra_group, inline = “1”)

var Bull150CandleColor = input.color(color.new(color.blue, 0), title=”150% Volume”, group=pvsra_group, inline=”2″)
var Bear150CandleColor = input.color(color.new(color.fuchsia, 0), title=””, group=pvsra_group, inline=”2″)

var BullNormCandleColor = input.color(color.new(#999999, 0), title=”Norm Volume”, group=pvsra_group, inline=”3″)
var BearNormCandleColor = input.color(color.new(#4d4d4d, 0), title=””, group=pvsra_group, inline=”3″)

var color candleColor = na
var color imbalanceColor = na
var color imbalancedLineColor = na

var color NO_COLOR = na

var bool chartIs120MinOrMore = false

// Logic to reference another Instruments Volume Profile

pvsra_imnt(sresolution,sseries) => request.security(override_imnt ? pvsra_sym : syminfo.tickerid ,sresolution,sseries, barmerge.gaps_off,barmerge.lookahead_off)
volume_imnt = override_imnt == true? pvsra_imnt(“”,volume): volume
high_imnt = override_imnt == true? pvsra_imnt(“”,high): high
low_imnt = override_imnt == true? pvsra_imnt(“”,low): low
close_imnt = override_imnt == true? pvsra_imnt(“”,close): close
open_imnt = override_imnt == true? pvsra_imnt(“”,open): open

av = ta.sma(volume_imnt, 10)//sum_2 = math.sum(volume, 10)
value2 = volume_imnt * (high_imnt – low_imnt)
hivalue2 = ta.highest(value2, 10)
imnt_override_pvsra_calc_part2 = volume_imnt >= av * 1.5 ? 2 : 0
va = volume_imnt >= av * 2 or value2 >= hivalue2 ? 1 : imnt_override_pvsra_calc_part2

// Bull or bear Candle Colors
isBull = close_imnt > open_imnt

var bool is200Bull = na
var bool is150Bull = na
var bool is100Bull = na
var bool is200Bear = na
var bool is150Bear = na
var bool is100Bear = na

if isBull
if va == 1
candleColor := Bull200CandleColor
is200Bull := true
else
if va == 2
candleColor := Bull150CandleColor
is150Bull := true
else
is200Bull := false
is150Bull := false
candleColor := BullNormCandleColor
imbalanceColor := na
imbalancedLineColor := na
else
if va == 1
candleColor := Bear200CandleColor
is200Bear := true
else
if va == 2
candleColor := Bear150CandleColor
is150Bear := true
else
is200Bear := false
is150Bear := false
candleColor := BearNormCandleColor
imbalanceColor := na
imbalancedLineColor := na

barcolor(overideCandleColours and switch_pvsra ? candleColor : NO_COLOR)
plotcandle(open, high, low, close, color=(overideCandleColours and switch_pvsra ? candleColor : NO_COLOR), wickcolor=(overideCandleColours and switch_pvsra? candleColor : NO_COLOR), bordercolor=(overideCandleColours and switch_pvsra? candleColor : NO_COLOR), display = display.all)

///////////////////////////////////////////////////
//////// SUpply/Demand POI
//////////////////////////////////////////////////
// INDICATOR SETTINGS
poi_group = ‘██████████ Supply/Demand Zone ██████████’
swing_length = input.int(10, title = ‘Swing High/Low Length’, group = poi_group, minval = 1, maxval = 50)
history_of_demand_to_keep = input.int(20, title = ‘History To Keep’, minval = 5, maxval = 50, group = poi_group)
box_width = input.float(2.5, title = ‘Supply/Demand Box Width’, group = poi_group, minval = 1, maxval = 10, step = 0.5)

// INDICATOR VISUAL SETTINGS
show_zigzag = input.bool(false, title = ‘Show Zig Zag’, group = ‘Visual Settings’, inline = ‘1’)
show_price_action_labels = input.bool(false, title = ‘Show Price Action Labels’, group = ‘Visual Settings’, inline = ‘2’)

supply_color = input.color(color.new(#EDEDED,70), title = ‘Supply’, group = ‘Visual Settings’, inline = ‘3’)
supply_outline_color = input.color(color.new(color.white,100), title = ‘Outline’, group = ‘Visual Settings’, inline = ‘3’)

demand_color = input.color(color.new(#00FFFF,70), title = ‘Demand’, group = ‘Visual Settings’, inline = ‘4’)
demand_outline_color = input.color(color.new(color.white,100), title = ‘Outline’, group = ‘Visual Settings’, inline = ‘4’)

poi_label_color = input.color(color.white, title = ‘POI Label’, group = ‘Visual Settings’, inline = ‘7’)

swing_type_color = input.color(color.black, title = ‘Price Action Label’, group = ‘Visual Settings’, inline = ‘8’)
zigzag_color = input.color(color.new(#000000,0), title = ‘Zig Zag’, group = ‘Visual Settings’, inline = ‘9’)

//
//END SETTINGS
//

atrpoi = ta.atr(50)
//
//FUNCTIONS
//

// FUNCTION TO ADD NEW AND REMOVE LAST IN ARRAY
f_array_add_pop(array, new_value_to_add) =>
array.unshift(array, new_value_to_add)
array.pop(array)

// FUNCTION SWING H & L LABELS
f_sh_sl_labels(array, swing_type) =>

var string label_text = na
if swing_type == 1
if array.get(array, 0) >= array.get(array, 1)
label_text := ‘HH’
else
label_text := ‘LH’
label.new(bar_index – swing_length, array.get(array,0), text = label_text, style=label.style_label_down, textcolor = swing_type_color, color = color.new(swing_type_color, 100), size = size.tiny)

else if swing_type == -1
if array.get(array, 0) >= array.get(array, 1)
label_text := ‘HL’
else
label_text := ‘LL’
label.new(bar_index – swing_length, array.get(array,0), text = label_text, style=label.style_label_up, textcolor = swing_type_color, color = color.new(swing_type_color, 100), size = size.tiny)

// FUNCTION MAKE SURE SUPPLY ISNT OVERLAPPING
f_check_overlapping(new_poi, box_array, atrpoi) =>

atr_threshold = atrpoi * 2
okay_to_draw = true

for i = 0 to array.size(box_array) – 1
top = box.get_top(array.get(box_array, i))
bottom = box.get_bottom(array.get(box_array, i))
poi = (top + bottom) / 2

upper_boundary = poi + atr_threshold
lower_boundary = poi – atr_threshold

if new_poi >= lower_boundary and new_poi <= upper_boundary
okay_to_draw := false
break
else
okay_to_draw := true
okay_to_draw

// FUNCTION TO DRAW SUPPLY OR DEMAND ZONE
f_supply_demand(value_array, bn_array, box_array, label_array, box_type, atrpoi) =>

atr_buffer = atrpoi * (box_width / 10)
box_left = array.get(bn_array, 0)
box_right = bar_index

var float box_top = 0.00
var float box_bottom = 0.00
var float poi = 0.00

if box_type == 1
box_top := array.get(value_array, 0)
box_bottom := box_top – atr_buffer
poi := (box_top + box_bottom) / 2
else if box_type == -1
box_bottom := array.get(value_array, 0)
box_top := box_bottom + atr_buffer
poi := (box_top + box_bottom) / 2

okay_to_draw = f_check_overlapping(poi, box_array, atrpoi)
// okay_to_draw = true

//delete oldest box, and then create a new box and add it to the array
if box_type == 1 and okay_to_draw and switch_poi
box.delete( array.get(box_array, array.size(box_array) – 1) )
f_array_add_pop(box_array, box.new( left = box_left, top = box_top, right = box_right, bottom = box_bottom, border_color = supply_outline_color,
bgcolor = supply_color, extend = extend.right, text = ‘SUPPLY’, text_halign = text.align_center, text_valign = text.align_center, text_color = poi_label_color, text_size = size.small, xloc = xloc.bar_index))

box.delete( array.get(label_array, array.size(label_array) – 1) )
f_array_add_pop(label_array, box.new( left = box_left, top = poi, right = box_right, bottom = poi, border_color = color.new(poi_label_color,90),
bgcolor = color.new(poi_label_color,90), extend = extend.right, text = ‘POI’, text_halign = text.align_left, text_valign = text.align_center, text_color = poi_label_color, text_size = size.small, xloc = xloc.bar_index))

else if box_type == -1 and okay_to_draw and switch_poi
box.delete( array.get(box_array, array.size(box_array) – 1) )
f_array_add_pop(box_array, box.new( left = box_left, top = box_top, right = box_right, bottom = box_bottom, border_color = demand_outline_color,
bgcolor = demand_color, extend = extend.right, text = ‘DEMAND’, text_halign = text.align_center, text_valign = text.align_center, text_color = poi_label_color, text_size = size.small, xloc = xloc.bar_index))

box.delete( array.get(label_array, array.size(label_array) – 1) )
f_array_add_pop(label_array, box.new( left = box_left, top = poi, right = box_right, bottom = poi, border_color = color.new(poi_label_color,90),
bgcolor = color.new(poi_label_color,90), extend = extend.right, text = ‘POI’, text_halign = text.align_left, text_valign = text.align_center, text_color = poi_label_color, text_size = size.small, xloc = xloc.bar_index))

// FUNCTION TO CHANGE SUPPLY/DEMAND TO A BOS IF BROKEN
f_sd_to_bos(box_array, bos_array, label_array, zone_type) =>

if zone_type == 1 and switch_poi
for i = 0 to array.size(box_array) – 1
level_to_break = box.get_top(array.get(box_array,i))
// if ta.crossover(close, level_to_break)
if close >= level_to_break
copied_box = box.copy(array.get(box_array,i))
f_array_add_pop(bos_array, copied_box)
mid = (box.get_top(array.get(box_array,i)) + box.get_bottom(array.get(box_array,i))) / 2
box.set_top(array.get(bos_array,0), mid)
box.set_bottom(array.get(bos_array,0), mid)
box.set_extend( array.get(bos_array,0), extend.none)
box.set_right( array.get(bos_array,0), bar_index)
box.set_text( array.get(bos_array,0), ” )
box.set_text_color( array.get(bos_array,0), color.new(color.white, 0))
box.set_text_size( array.get(bos_array,0), size.small)
box.set_text_halign( array.get(bos_array,0), text.align_center)
box.set_text_valign( array.get(bos_array,0), text.align_center)
box.delete(array.get(box_array, i))
box.delete(array.get(label_array, i))

if zone_type == -1 and switch_poi
for i = 0 to array.size(box_array) – 1
level_to_break = box.get_bottom(array.get(box_array,i))
// if ta.crossunder(close, level_to_break)
if close <= level_to_break
copied_box = box.copy(array.get(box_array,i))
f_array_add_pop(bos_array, copied_box)
mid = (box.get_top(array.get(box_array,i)) + box.get_bottom(array.get(box_array,i))) / 2
box.set_top(array.get(bos_array,0), mid)
box.set_bottom(array.get(bos_array,0), mid)
box.set_extend( array.get(bos_array,0), extend.none)
box.set_right( array.get(bos_array,0), bar_index)
box.set_text( array.get(bos_array,0), ” )
box.set_text_color( array.get(bos_array,0), color.new(color.white, 0))
box.set_text_size( array.get(bos_array,0), size.small)
box.set_text_halign( array.get(bos_array,0), text.align_center)
box.set_text_valign( array.get(bos_array,0), text.align_center)
box.delete(array.get(box_array, i))
box.delete(array.get(label_array, i))

// FUNCTION MANAGE CURRENT BOXES BY CHANGING ENDPOINT
f_extend_box_endpoint(box_array) =>

for i = 0 to array.size(box_array) – 1
box.set_right(array.get(box_array, i), bar_index + 100)

// CALCULATE SWING HIGHS & SWING LOWS
swing_high = ta.pivothigh(high, swing_length, swing_length)
swing_low = ta.pivotlow(low, swing_length, swing_length)

// ARRAYS FOR SWING H/L & BN
var swing_high_values = array.new_float(5,0.00)
var swing_low_values = array.new_float(5,0.00)

var swing_high_bns = array.new_int(5,0)
var swing_low_bns = array.new_int(5,0)

// ARRAYS FOR SUPPLY / DEMAND
var current_supply_box = array.new_box(history_of_demand_to_keep, na)
var current_demand_box = array.new_box(history_of_demand_to_keep, na)

// ARRAYS FOR SUPPLY / DEMAND POI LABELS
var current_supply_poi = array.new_box(history_of_demand_to_keep, na)
var current_demand_poi = array.new_box(history_of_demand_to_keep, na)

// ARRAYS FOR BOS
var supply_bos = array.new_box(5, na)
var demand_bos = array.new_box(5, na)
//
//END CALCULATIONS
//

// NEW SWING HIGH
if not na(swing_high)

//MANAGE SWING HIGH VALUES
f_array_add_pop(swing_high_values, swing_high)
f_array_add_pop(swing_high_bns, bar_index[swing_length])
if show_price_action_labels
f_sh_sl_labels(swing_high_values, 1)

f_supply_demand(swing_high_values, swing_high_bns, current_supply_box, current_supply_poi, 1, atrpoi)

// NEW SWING LOW
else if not na(swing_low)

//MANAGE SWING LOW VALUES
f_array_add_pop(swing_low_values, swing_low)
f_array_add_pop(swing_low_bns, bar_index[swing_length])
if show_price_action_labels
f_sh_sl_labels(swing_low_values, -1)

f_supply_demand(swing_low_values, swing_low_bns, current_demand_box, current_demand_poi, -1, atrpoi)

f_sd_to_bos(current_supply_box, supply_bos, current_supply_poi, 1)
f_sd_to_bos(current_demand_box, demand_bos, current_demand_poi, -1)

f_extend_box_endpoint(current_supply_box)
f_extend_box_endpoint(current_demand_box)

//ZIG ZAG
h = ta.highest(high, swing_length * 2 + 1)
l = ta.lowest(low, swing_length * 2 + 1)
f_isMin(len) =>
l == low[len]
f_isMax(len) =>
h == high[len]

var dirUp = false
var lastLow = high * 100
var lastHigh = 0.0
var timeLow = bar_index
var timeHigh = bar_index
var line li = na

f_drawLine() =>
_li_color = show_zigzag and switch_poi ? zigzag_color : color.new(#ffffff,100)
line.new(timeHigh – swing_length, lastHigh, timeLow – swing_length, lastLow, xloc.bar_index, color=_li_color, width=2)

if dirUp
if f_isMin(swing_length) and low[swing_length] < lastLow
lastLow := low[swing_length]
timeLow := bar_index
line.delete(li)
li := f_drawLine()
li

if f_isMax(swing_length) and high[swing_length] > lastLow
lastHigh := high[swing_length]
timeHigh := bar_index
dirUp := false
li := f_drawLine()
li

if not dirUp
if f_isMax(swing_length) and high[swing_length] > lastHigh
lastHigh := high[swing_length]
timeHigh := bar_index
line.delete(li)
li := f_drawLine()
li
if f_isMin(swing_length) and low[swing_length] < lastHigh
lastLow := low[swing_length]
timeLow := bar_index
dirUp := true
li := f_drawLine()
if f_isMax(swing_length) and high[swing_length] > lastLow
lastHigh := high[swing_length]
timeHigh := bar_index
dirUp := false
li := f_drawLine()
li

///////////////////////////////////////////////////
///////// Heiken Ashi Candle
////////////////////////////////////////////////////

hagroup = “███████ Heiken-ashi candles ███████”

hkClose = (open + high + low + close) / 4
hkOpen = float(na)
hkOpen := na(hkOpen[1]) ? (open + close) / 2 : (nz(hkOpen[1]) + nz(hkClose[1])) / 2
hkHigh = math.max(high, math.max(hkOpen, hkClose))
hkLow = math.min(low, math.min(hkOpen, hkClose))

//[hkOpen, hkHigh, hkLow, hkClose] = security(heikinashi(syminfo.tickerid), timeframe.period, [open, high, low, close])

candletype = input.string (“Hollow”, “Candle Type”, options=[“Hollow”, “Bars”, “Candles”], group=hagroup, tooltip=”Candle Type to be dispalyed. User will have to ‘Mute’ the main series bar using the 👁 symbol next to ticker id.”)

BodyBull = input.color (#26a69a, “”, inline=”a”, group=”Candle Body”, group=hagroup)
BodyBear = input.color (#ef5350, “”, inline=”a”, group=”Candle Body”, group=hagroup)
BorderBull = input.color (#26a69a, “”, inline=”b”, group=”Candle Borders”, group=hagroup)
BorderBear = input.color (#ef5350, “”, inline=”b”, group=”Candle Borders”, group=hagroup)
WickBull = input.color (#26a69a, “”, inline=”c”, group=”Candle Wick”, group=hagroup)
WickBear = input.color (#ef5350, “”, inline=”c”, group=”Candle Wick”, group=hagroup)

hollow = candletype == “Hollow”
bars = candletype == “Bars”
candle = candletype == “Candles”

plotcandle(
hkOpen, hkHigh, hkLow, hkClose,
“Hollow Candles”,
switch_ha ? (hollow ? hkClose < hkOpen ? BodyBear : na : candle ? hkClose < hkOpen ? BodyBear : BodyBull : na) : na,
switch_ha ? (hollow or candle ? hkClose < hkOpen ? WickBear : WickBull : na) : na,
bordercolor = switch_ha ? (hollow or candle ? hkClose < hkOpen ? BorderBear : BorderBull : na) : na)

///////////////////////////////////////////////////
///////// Fair Value gap
////////////////////////////////////////////////////

fvggroup = “██████████ Fair Value Gap (FVG) ██████████”
numDays = input.int(7, “number of days lookback”,group=fvggroup)
showUP = input.bool(true, “‘UP’ FVGs:”, inline =’1′,group=fvggroup)
colUp = input.color(color.new(color.blue, 86), “”, inline =’1′,group=fvggroup)
showDN = input.bool(true, “‘DOWN’ FVGs:”, inline =’2′,group=fvggroup)
colDn = input.color(color.new(color.orange, 86), “”, inline =’2′,group=fvggroup)
showCE = input.bool(true, “show CE”, inline =’3′,group=fvggroup)
ceCol = input.color(color.new(color.black, 1), “| color:”, inline =’3′,group=fvggroup)
ceStyle = input.string(line.style_dotted, “| style:”, options=[line.style_dotted,line.style_solid, line.style_dashed], inline =’3′,group=fvggroup)
deleteFilledBoxes = input.bool(true, “delete filled boxes & lines”,group=fvggroup)
CEcond = input.bool (false, “Use CE (as opposed to Full Fill)”,group=fvggroup, tooltip = “If toggled OFF, FVGs and CEs will paint until FVG has been completely filled.\n\nThis threshold is used for Above/Below threshold Alert conditions too (but does not effect the IOFED alerts):\ni.e. this will determine if your ‘ABOVE threshold’ alert fires when price hits most recent FVG CE ABOVE or most recent FVG Full Fill ABOVE\n\nAlerts are set by clicking the three dots on the indicator display line.”)
colorNone = color.new(color.white, 100)
_day = 24*3600*1000
var box bxUp = na, var box bxDn = na, var line lnUp = na, var line lnDn = na
var array<box> bxUpArr = array.new<box>(0), var array<line> lnUpArr = array.new<line>(0)
var array<box> bxDnArr = array.new<box>(0), var array<line> lnDnArr = array.new<line>(0)
dnCE = high[1] + (low[3]-high[1])/2
upCE = low[1] – (low[1]-high[3])/2
if low[3] > high[1] and time> timenow- numDays*_day and showDN and switch_fvg
bxDnArr.push(box.new(bar_index-3, low[3], bar_index, high[1], bgcolor = colDn, border_color = colorNone))
lnDnArr.push(line.new(bar_index-3, dnCE, bar_index, dnCE, color = showCE?ceCol:colorNone, style =ceStyle))
if high[3] < low[1] and time> timenow- numDays*_day and showUP and switch_fvg
bxUpArr.push(box.new(bar_index-3, low[1], bar_index, high[3], bgcolor = colUp, border_color = colorNone))
lnUpArr.push(line.new(bar_index-3, upCE, bar_index, upCE, color = showCE?ceCol:colorNone, style =ceStyle))

var array<int> _countArr =array.new<int>(0)
var array<int> _countArrIOFED =array.new<int>(0)

//modified form of @Bjorgum’s looping function. This stops boxes/lines painting when price passes to or through them
extendAndRemoveBx(array<box> boxArray, array<line> lineArray, array<int> countArr1, array<int> countArr2, simple bool isBull, int maxSize) =>
if boxArray.size() > 0
for i = boxArray.size() -1 to 0
line ln = lineArray.get(i)
box bx = boxArray.get(i)
bx.set_right(bar_index)
ln.set_x2(bar_index)
float price = CEcond?ln.get_price(bar_index):(isBull?bx.get_top():bx.get_bottom())
float price_IOFED = isBull?bx.get_bottom():bx.get_top()
int m = isBull ? 1 : -1
float hiLo = isBull ? high : low
if hiLo * m > price * m
boxArray.remove(i)
lineArray.remove(i)
countArr1.push(isBull?1:-1) //for ‘above/below threshold alerts; counter sum will decrement 1 on lower threshold hit, increment 1 on upper threshold hit
if deleteFilledBoxes
bx.set_bgcolor(colorNone)
ln.set_color(colorNone)
if hiLo*m>price_IOFED*m
countArr2.push(isBull?1:-1)

if boxArray.size() > maxSize
box.delete(boxArray.shift())
line.delete(lineArray.shift())

extendAndRemoveBx(bxDnArr,lnDnArr,_countArr,_countArrIOFED, true, 12) //12 should be good for around 2200 bars of history
extendAndRemoveBx(bxUpArr, lnUpArr,_countArr,_countArrIOFED, false, 12)

upThresholdLst = array.sum(_countArr)>array.sum(_countArr)[1]
dnThresholdLst = array.sum(_countArr)<array.sum(_countArr)[1]

upIOFEDlast= array.sum(_countArrIOFED)>array.sum(_countArrIOFED)[1]
dnIOFEDlast= array.sum(_countArrIOFED)<array.sum(_countArrIOFED)[1]

///////////////////////////////////////////////////
/////////// Vector Zone
//////////////////////////////////////////////////

import TradersReality/Traders_Reality_Lib/1 as trLib

vz_group = “██████████ Liquidity Zone ██████████”
color redVectorColor = input.color(title=’Vector: Red’, group=vz_group, defval=color.red, inline=’vectors’)
color greenVectorColor = input.color(title=’Green’, group=vz_group, defval=color.lime, inline=’vectors’)
color violetVectorColor = input.color(title=’Violet’, group=vz_group, defval=color.fuchsia, inline=’vectors’)
color blueVectorColor = input.color(title=’Blue’, group=vz_group, defval=color.blue, inline=’vectors’, tooltip=’Bull bars are green and bear bars are red when the bar is with volume >= 200% of the average volume of the 10 previous bars, or bars where the product of candle spread x candle volume is >= the highest for the 10 previous bars.\n Bull bars are blue and bear are violet when the bar is with with volume >= 150% of the average volume of the 10 previous bars.’)
color regularCandleUpColor = input.color(title=’Regular: Up Candle’, group=vz_group, defval=#999999, inline=’nonVectors’)
color regularCandleDownColor = input.color(title=’Down Candle’, group=vz_group, defval=#4d4d4d, inline=’nonVectors’, tooltip=’Bull bars are light gray and bear are dark gray when none of the red/green/blue/violet vector conditions are met.’)
bool setcandlecolors = input.bool(false, title=’Set PVSRA candle colors?’, group=vz_group, inline=’setCandle’)

int zonesMax = input.int(500, ‘Maximum zones to draw’, group=vz_group)
string zoneType = input.string(group=vz_group, defval=’Body only’, title=’Zone top/bottom is defined with: ‘, options=[‘Body only’, ‘Body with wicks’])
string zoneUpdateType = input.string(group=vz_group, defval=’Body with wicks’, title=’Zones are cleared using candle: ‘, options=[‘Body only’, ‘Body with wicks’])
int borderWidth = input.int(0, ‘Zone border width’, group=vz_group)
bool colorOverride = input.bool(true, ‘Override color?’ , group=vz_group, inline=”vcz1″)
color zoneColor = input.color(title=’Color’, group=vz_group, defval=color.rgb(255, 230, 75, 90), inline=”vcz1″, tooltip=’the vector candle zones color to use if you dont not want to use the PVSRA Candle Colors.’)
int transperancy = input.int(90, ‘Zone Transperancy’, minval = 0, maxval = 100, group=vz_group, tooltip=’If the vector candle zones color is not overriden, then we want to set the transparancy of the vector candle colors as defined by the PBSRA candle colors. This setting only affects the candle zone colors not the candle colors themselves.’)

bool overrideSym = input.bool(group=’PVSRA Override’, title=’Override chart symbol?’, defval=false, inline=’pvsra’)
string pvsraSym = input.string(group=’PVSRA Override’, title=”, defval=’INDEX:BTCUSD’, tooltip=’You can use INDEX:BTCUSD or you can combine multiple feeds, for example BINANCE:BTCUSDT+COINBASE:BTCUSD. Note that adding too many will slow things down.’, inline=’pvsra’)

pvsraVolume(overrideSymbolX, pvsraSymbolX, tickerIdX) =>
request.security(overrideSymbolX ? pvsraSymbolX : tickerIdX, ”, volume, barmerge.gaps_off, barmerge.lookahead_off)
pvsraHigh(overrideSymbolX, pvsraSymbolX, tickerIdX) =>
request.security(overrideSymbolX ? pvsraSymbolX : tickerIdX, ”, high, barmerge.gaps_off, barmerge.lookahead_off)
pvsraLow(overrideSymbolX, pvsraSymbolX, tickerIdX) =>
request.security(overrideSymbolX ? pvsraSymbolX : tickerIdX, ”, low, barmerge.gaps_off, barmerge.lookahead_off)
pvsraClose(overrideSymbolX, pvsraSymbolX, tickerIdX) =>
request.security(overrideSymbolX ? pvsraSymbolX : tickerIdX, ”, close, barmerge.gaps_off, barmerge.lookahead_off)
pvsraOpen(overrideSymbolX, pvsraSymbolX, tickerIdX) =>
request.security(overrideSymbolX ? pvsraSymbolX : tickerIdX, ”, open, barmerge.gaps_off, barmerge.lookahead_off)

pvsraVolume = pvsraVolume(overrideSym, pvsraSym, syminfo.tickerid)
pvsraHigh = pvsraHigh(overrideSym, pvsraSym, syminfo.tickerid)
pvsraLow = pvsraLow(overrideSym, pvsraSym, syminfo.tickerid)
pvsraClose = pvsraClose(overrideSym, pvsraSym, syminfo.tickerid)
pvsraOpen = pvsraOpen(overrideSym, pvsraSym, syminfo.tickerid)
[pvsraColor, alertFlag, averageVolume, volumeSpread, highestVolumeSpread] = trLib.calcPvsra(pvsraVolume, pvsraHigh, pvsraLow, pvsraClose, pvsraOpen, redVectorColor, greenVectorColor, violetVectorColor, blueVectorColor, regularCandleDownColor, regularCandleUpColor)

var zoneBoxesAbove = array.new_box()
var zoneBoxesBelow = array.new_box()

barcolor(setcandlecolors ? pvsraColor : na)
pvsra = trLib.getPvsraFlagByColor(switch_vectorzone ? pvsraColor:na, redVectorColor, greenVectorColor, violetVectorColor, blueVectorColor, regularCandleUpColor)
trLib.updateZones(pvsra, 0, zoneBoxesBelow, zonesMax, pvsraHigh, pvsraLow, pvsraOpen, pvsraClose, transperancy, zoneUpdateType, zoneColor, zoneType, borderWidth, colorOverride, redVectorColor, greenVectorColor, violetVectorColor, blueVectorColor)
trLib.updateZones(pvsra, 1, zoneBoxesAbove, zonesMax, pvsraHigh, pvsraLow, pvsraOpen, pvsraClose, transperancy, zoneUpdateType, zoneColor, zoneType, borderWidth, colorOverride, redVectorColor, greenVectorColor, violetVectorColor, blueVectorColor)
trLib.cleanarr(zoneBoxesAbove)
trLib.cleanarr(zoneBoxesBelow)

//*****************
// Market sessions
//*****************

string weekend_sessions = ‘:1234567’
string no_weekend_sessions = ‘:23456′

bool show_rectangle1 = input.bool(group=’Market session: London (0800-1630 UTC+0) – DST Aware’, defval=true, title=’Show: session?’, inline=’session1conf’, tooltip=’If this checkbox is off, Label and Open Range have no effect’) and show_markets
bool show_label1 = input.bool(group=’Market session: London (0800-1630 UTC+0) – DST Aware’, defval=true, title=’Label?’, inline=’session1conf’) and show_rectangle1 and show_markets
bool show_or1 = input.bool(group=’Market session: London (0800-1630 UTC+0) – DST Aware’, defval=true, title=’Opening Range?’, inline=’session1conf’, tooltip=’This controls the shaded area for the session’) and show_rectangle1 and show_markets
string sess1Label = input.string(group=’Market session: London (0800-1630 UTC+0) – DST Aware’, defval=’London’, title=’Name:’, inline=’session1style’)
color sess1col = input.color(group=’Market session: London (0800-1630 UTC+0) – DST Aware’, title=’Color: Box’, defval=color.rgb(120, 123, 134, 75), inline=’session1style’)
color sess1colLabel = input.color(group=’Market session: London (0800-1630 UTC+0) – DST Aware’, title=’Label’, defval=color.rgb(120, 123, 134, 0), inline=’session1style’)
string sess1TimeX = ‘0800-1630’//input.session(group=’Market session: London (0800-1630 UTC+0)’, defval=’0800-1630′, title=’Time (UTC+0):’, inline=’session1style’, tooltip=’Normally you will not want to adjust these times. Defaults are taken as if the session is NOT in DST and times must be in UTC+0. Note due to limitations of pinescript some values sellected here other than the default might not work correctly on all exchanges.’)
string rectStyle = input.string(group=’Market session: London (0800-1630 UTC+0) – DST Aware’, defval=’Dashed’, title=’Line style of Market Session hi/lo line’, options=[‘Dashed’, ‘Solid’])
sessLineStyle = line.style_dashed
bool show_markets_weekends = input.bool(false, group=’Market session: London (0800-1630 UTC+0) – DST Aware’, title=’Show Market Session on Weekends?’, tooltip=’Turn on or off market sessions in the weekends. Note do not turn this on for exchanges that dont have weekend data like OANDA’)

sess1Time = show_markets_weekends ? sess1TimeX + weekend_sessions : sess1TimeX + no_weekend_sessions

bool show_rectangle2 = input.bool(group=’Market session: New York (1430-2100 UTC+0) – DST Aware’, defval=true, title=’Show: session?’, inline=’session2conf’, tooltip=’If this checkbox is off, Label and Open Range have no effect’) and show_markets
bool show_label2 = input.bool(group=’Market session: New York (1430-2100 UTC+0) – DST Aware’, defval=true, title=’Label?’, inline=’session2conf’) and show_rectangle2 and show_markets
bool show_or2 = input.bool(group=’Market session: New York (1430-2100 UTC+0) – DST Aware’, defval=true, title=’Opening Range?’, inline=’session2conf’, tooltip=’This controls the shaded area for the session’) and show_rectangle2 and show_markets
string sess2Label = input.string(group=’Market session: New York (1430-2100 UTC+0) – DST Aware’, defval=’NewYork’, title=’Name:’, inline=’session2style’)
color sess2col = input.color(group=’Market session: New York (1430-2100 UTC+0) – DST Aware’, title=’Color: Box’, defval=color.rgb(251, 86, 91, 75), inline=’session2style’)
color sess2colLabel = input.color(group=’Market session: New York (1430-2100 UTC+0) – DST Aware’, title=’Label’, defval=color.rgb(253, 84, 87, 25), inline=’session2style’)
string sess2TimeX = ‘1430-2100’//input.session(group=’Market session: New York (1430-2100 UTC+0)’, defval=’1430-2100′, title=’Time (UTC+0):’, inline=’session2style’, tooltip=’Normally you will not want to adjust these times. Defaults are taken as if the session is NOT in DST times must be in UTC+0. Note due to limitations of pinescript some values sellected here other than the default might not work correctly on all exchanges.’)
sess2Time = show_markets_weekends ? sess2TimeX + weekend_sessions : sess2TimeX + no_weekend_sessions

bool show_rectangle3 = input.bool(group=’Market session: Tokyo (0000-0600 UTC+0) – DST Aware’, defval=true, title=’Show: session?’, inline=’session3conf’, tooltip=’If this checkbox is off, Label and Open Range have no effect’) and show_markets
bool show_label3 = input.bool(group=’Market session: Tokyo (0000-0600 UTC+0) – DST Aware’, defval=true, title=’Label?’, inline=’session3conf’) and show_rectangle3 and show_markets
bool show_or3 = input.bool(group=’Market session: Tokyo (0000-0600 UTC+0) – DST Aware’, defval=true, title=’Opening Range?’, inline=’session3conf’, tooltip=’This controls the shaded area for the session’) and show_rectangle3 and show_markets
string sess3Label = input.string(group=’Market session: Tokyo (0000-0600 UTC+0) – DST Aware’, defval=’Tokyo’, title=’Name:’, inline=’session3style’)
color sess3col = input.color(group=’Market session: Tokyo (0000-0600 UTC+0) – DST Aware’, title=’Color: Box’, defval=color.rgb(80, 174, 85, 75), inline=’session3style’)
color sess3colLabel = input.color(group=’Market session: Tokyo (0000-0600 UTC+0) – DST Aware’, title=’Label’, defval=color.rgb(80, 174, 85, 25), inline=’session3style’)
string sess3TimeX = ‘0000-0600’//input.session(group=’Market session: Tokyo (0000-0600 UTC+0)’, defval=’0000-0600′, title=’Time (UTC+0):’, inline=’session3style’, tooltip=’Normally you will not want to adjust these times. Defaults are taken as if the session is NOT in DST times must be in UTC+0. Note due to limitations of pinescript some values sellected here other than the default might not work correctly on all exchanges.’)
sess3Time = show_markets_weekends ? sess3TimeX + weekend_sessions : sess3TimeX + no_weekend_sessions

bool show_rectangle4 = input.bool(group=’Market session: Hong Kong (0130-0800 UTC+0) – DST Aware’, defval=true, title=’Show: session?’, inline=’session4conf’, tooltip=’If this checkbox is off, Label and Open Range have no effect’) and show_markets
bool show_label4 = input.bool(group=’Market session: Hong Kong (0130-0800 UTC+0) – DST Aware’, defval=true, title=’Label?’, inline=’session4conf’) and show_rectangle4 and show_markets
bool show_or4 = input.bool(group=’Market session: Hong Kong (0130-0800 UTC+0) – DST Aware’, defval=true, title=’Opening Range?’, inline=’session4conf’, tooltip=’This controls the shaded area for the session’) and show_rectangle4 and show_markets
string sess4Label = input.string(group=’Market session: Hong Kong (0130-0800 UTC+0) – DST Aware’, defval=’HongKong’, title=’Name:’, inline=’session4style’)
color sess4col = input.color(group=’Market session: Hong Kong (0130-0800 UTC+0) – DST Aware’, title=’Color: Box’, defval=color.rgb(128, 127, 23, 75), inline=’session4style’)
color sess4colLabel = input.color(group=’Market session: Hong Kong (0130-0800 UTC+0) – DST Aware’, title=’Label’, defval=color.rgb(128, 127, 23, 25), inline=’session4style’)
string sess4TimeX = ‘0130-0800’//input.session(group=’Market session: Hong Kong (0130-0800 UTC+0)’, defval=’0130-0800′, title=’Time (UTC+0):’, inline=’session4style’, tooltip=’Normally you will not want to adjust these times. Defaults are taken as if the session is NOT in DST times must be in UTC+0. Note due to limitations of pinescript some values sellected here other than the default might not work correctly on all exchanges.’)
sess4Time = show_markets_weekends ? sess4TimeX + weekend_sessions : sess4TimeX + no_weekend_sessions

bool show_rectangle5 = input.bool(group=’Market session: Sydney (NZX+ASX 2200-0600 UTC+0) – DST Aware’, defval=true, title=’Show: session?’, inline=’session5conf’, tooltip=’If this checkbox is off, Label and Open Range have no effect’) and show_markets
bool show_label5 = input.bool(group=’Market session: Sydney (NZX+ASX 2200-0600 UTC+0) – DST Aware’, defval=true, title=’Label?’, inline=’session5conf’) and show_rectangle5 and show_markets
bool show_or5 = input.bool(group=’Market session: Sydney (NZX+ASX 2200-0600 UTC+0) – DST Aware’, defval=true, title=’Opening Range?’, inline=’session5conf’, tooltip=’This controls the shaded area for the session’) and show_rectangle5 and show_markets
string sess5Label = input.string(group=’Market session: Sydney (NZX+ASX 2200-0600 UTC+0) – DST Aware’, defval=’Sydney’, title=’Name:’, inline=’session5style’)
color sess5col = input.color(group=’Market session: Sydney (NZX+ASX 2200-0600 UTC+0) – DST Aware’, title=’Color: Box’, defval=color.rgb(37, 228, 123, 75), inline=’session5style’)
color sess5colLabel = input.color(group=’Market session: Sydney (NZX+ASX 2200-0600 UTC+0) – DST Aware’, title=’Label’, defval=color.rgb(37, 228, 123, 25), inline=’session5style’)
string sess5TimeX = ‘2200-0600’//input.session(group=’Market session: Sydney (NZX+ASX 2200-0600 UTC+0)’, defval=’2200-0600′, title=’Time (UTC+0):’, inline=’session5style’, tooltip=’Normally you will not want to adjust these times. Defaults are taken as if the session is NOT in DST times must be in UTC+0. Note due to limitations of pinescript some values sellected here other than the default might not work correctly on all exchanges.’)
sess5Time = show_markets_weekends ? sess5TimeX + weekend_sessions : sess5TimeX + no_weekend_sessions

bool show_rectangle6 = input.bool(group=’Market session: EU Brinks (0800-0900 UTC+0) – DST Aware’, defval=true, title=’Show: session?’, inline=’session6conf’, tooltip=’If this checkbox is off, Label and Open Range have no effect’) and show_markets
bool show_label6 = input.bool(group=’Market session: EU Brinks (0800-0900 UTC+0) – DST Aware’, defval=true, title=’Label?’, inline=’session6conf’) and show_rectangle6 and show_markets
bool show_or6 = input.bool(group=’Market session: EU Brinks (0800-0900 UTC+0) – DST Aware’, defval=true, title=’Opening Range?’, inline=’session6conf’, tooltip=’This controls the shaded area for the session’) and show_rectangle6 and show_markets
string sess6Label = input.string(group=’Market session: EU Brinks (0800-0900 UTC+0) – DST Aware’, defval=’EU Brinks’, title=’Name:’, inline=’session6style’)
color sess6col = input.color(group=’Market session: EU Brinks (0800-0900 UTC+0) – DST Aware’, title=’Color: Box’, defval=color.rgb(255, 255, 255, 65), inline=’session6style’)
color sess6colLabel = input.color(group=’Market session: EU Brinks (0800-0900 UTC+0) – DST Aware’, title=’Label’, defval=color.rgb(255, 255, 255, 25), inline=’session6style’)
string sess6TimeX = ‘0800-0900’//input.session(group=’Market session: EU Brinks (0800-0900 UTC+0)’, defval=’0800-0900′, title=’Time (UTC+0):’, inline=’session6style’, tooltip=’Normally you will not want to adjust these times. Defaults are taken as if the session is NOT in DST times must be in UTC+0. Note due to limitations of pinescript some values sellected here other than the default might not work correctly on all exchanges.’)
sess6Time = show_markets_weekends ? sess6TimeX + weekend_sessions : sess6TimeX + no_weekend_sessions

bool show_rectangle7 = input.bool(group=’Market session: US Brinks (1400-1500 UTC+0) – DST Aware’, defval=true, title=’Show: session?’, inline=’session7conf’, tooltip=’If this checkbox is off, Label and Open Range have no effect’) and show_markets
bool show_label7 = input.bool(group=’Market session: US Brinks (1400-1500 UTC+0) – DST Aware’, defval=true, title=’Label?’, inline=’session7conf’) and show_rectangle7 and show_markets
bool show_or7 = input.bool(group=’Market session: US Brinks (1400-1500 UTC+0) – DST Aware’, defval=true, title=’Opening Range?’, inline=’session7conf’, tooltip=’This controls the shaded area for the session’) and show_rectangle7 and show_markets
string sess7Label = input.string(group=’Market session: US Brinks (1400-1500 UTC+0) – DST Aware’, defval=’US Brinks’, title=’Name:’, inline=’session7style’)
color sess7col = input.color(group=’Market session: US Brinks (1400-1500 UTC+0) – DST Aware’, title=’Color: Box’, defval=color.rgb(255, 255, 255, 65), inline=’session7style’)
color sess7colLabel = input.color(group=’Market session: US Brinks (1400-1500 UTC+0) – DST Aware’, title=’Label’, defval=color.rgb(255, 255, 255, 25), inline=’session7style’)
string sess7TimeX = ‘1400-1500’//input.session(group=’Market session: US Brinks (1400-1500 UTC+0)’, defval=’1400-1500′, title=’Time (UTC+0):’, inline=’session7style’, tooltip=’Normally you will not want to adjust these times. Defaults are taken as if the session is NOT in DST times must be in UTC+0. Note due to limitations of pinescript some values sellected here other than the default might not work correctly on all exchanges.’)
sess7Time = show_markets_weekends ? sess7TimeX + weekend_sessions : sess7TimeX + no_weekend_sessions

splitSessionString(sessXTime) =>
//session stirng looks like this: 0000-0000:1234567 ie start time, end time, day of the week
//we need to parse the sessXTime string into hours and min for start and end times so we can use those in the timestampfunction below

//string times contains “0000-2300” as an example
string times = array.get(str.split(sessXTime, ‘:’), 0)

//string startTime contains “0000”
string startTime = array.get(str.split(times, ‘-‘), 0)
//string endTime contains “2300”
string endTime = array.get(str.split(times, ‘-‘), 1)

//now we need to get the start hour and start min, sing 0 index – hour is the characters in index 0 and index 1 while min is the chars at index 2 and 3
string[] startTimeChars = str.split(startTime, ”)
string[] endTimeChars = str.split(endTime, ”)

//so now startHour contains 00 and start min contains 00
string startHour = array.get(startTimeChars, 0) + array.get(startTimeChars, 1)
string startMin = array.get(startTimeChars, 2) + array.get(startTimeChars, 3)

//so now endHour contains 23 and end min contains 00
string endHour = array.get(endTimeChars, 0) + array.get(endTimeChars, 1)
string endMin = array.get(endTimeChars, 2) + array.get(endTimeChars, 3)
[startHour, startMin, endHour, endMin]

calc_session_startend(sessXTime, gmt) =>
[startHour, startMin, endHour, endMin] = splitSessionString(sessXTime)
targetstartTimeX = timestamp(gmt, year, month, dayofmonth, math.round(str.tonumber(startHour)), math.round(str.tonumber(startMin)), 00)
targetendTimeX = timestamp(gmt, year, month, dayofmonth, math.round(str.tonumber(endHour)), math.round(str.tonumber(endMin)), 00)
time_now = timestamp(year, month, dayofmonth, hour, minute, 00)
midnight_exchange = timestamp(year, month, dayofmonth, 00, 00, 00)

//if start hour is greater than end hour we are dealing with a session that starts towards the end of one day
//and ends the next day. ie advance the end time by 24 hours – its the next day
bool adjusted = false
if gmt == ‘GMT+0’
if math.round(str.tonumber(startHour)) > math.round(str.tonumber(endHour))
if time_now – targetstartTimeX >= 0
targetendTimeX := targetendTimeX + 24 * 60 * 60 * 1000
adjusted := true
targetendTimeX
if gmt == ‘GMT+1′
if math.round(str.tonumber(startHour)) == 0
startHour := ’24’
if math.round(str.tonumber(endHour)) == 0
endHour := ’24’
if math.round(str.tonumber(startHour))-1 > math.round(str.tonumber(endHour))-1
if time_now – targetstartTimeX >= 0
targetendTimeX := targetendTimeX + 24 * 60 * 60 * 1000
adjusted := true
targetendTimeX

if targetstartTimeX < midnight_exchange and midnight_exchange < targetendTimeX and not adjusted
targetendTimeX := targetendTimeX + 24 * 60 * 60 * 1000
targetendTimeX

[targetstartTimeX,targetendTimeX]

draw_open_range(sessXTime, sessXcol, show_orX, gmt)=>
if show_orX
// Initialize variables on bar zero only, so they preserve their values across bars.
var hi = float(na)
var lo = float(na)
var box hiLoBox = na
// Detect changes in timeframe.
session = time(timeframe.period, sessXTime, gmt)
bool newTF = session and not session[1]
if newTF
// New bar in higher timeframe; reset values and create new lines and box.
[targetstartTimeX,targetendTimeX] = calc_session_startend(sessXTime, gmt)
sessionDuration = math.round(math.abs(time – targetendTimeX)/(timeframe.multiplier*60*1000))

hi := high
lo := low
hiLoBox := box.new(bar_index, hi, timeframe.multiplier == 1? bar_index : bar_index+sessionDuration, lo, border_color = na, bgcolor = sessXcol)
int(na)
else
if timeframe.multiplier == 1 and (na(session[1]) and not na(session) or session[1] < session)
box.set_right(hiLoBox, bar_index+1)
int(na)
draw_session_hilo(sessXTime, show_rectangleX, show_labelX, sessXcolLabel, sessXLabel, gmt)=>
if show_rectangleX
// Initialize variables on bar zero only, so they preserve their values across bars.
var hi = float(0)
var lo = float(10000000000.0)

var line line_t = na
var line line_b = na
var label line_label = na
// var box hiLoBox = na
// Detect changes in timeframe.
session = time(timeframe.period, sessXTime, gmt)
sessLineStyleX = rectStyle == ‘Solid’ ? line.style_solid : line.style_dashed
bool newTF = session and not session[1]
hi := newTF ? high : session ? math.max(high, hi[1]) : hi[1]
lo := newTF ? low : session ? math.min(low, lo[1]) : lo[1]

if newTF
beginIndex = bar_index
[targetstartTimeX,targetendTimeX] = calc_session_startend(sessXTime, gmt)
sessionDuration = math.round(math.abs(time – targetendTimeX)/(timeframe.multiplier*60*1000))

line_t := line.new(beginIndex, hi, timeframe.multiplier == 1? bar_index : bar_index+sessionDuration, hi, xloc=xloc.bar_index, style=sessLineStyleX, color=sessXcolLabel)
line_b := line.new(beginIndex, lo, timeframe.multiplier == 1? bar_index : bar_index+sessionDuration, lo, xloc=xloc.bar_index, style=sessLineStyleX, color=sessXcolLabel)
line.delete(line_t[1])
line.delete(line_b[1])
if show_labelX
line_label := label.new(beginIndex, hi, sessXLabel, xloc=xloc.bar_index, textcolor=sessXcolLabel, style=label.style_none, size=size.normal, textalign=text.align_right)
label.delete(line_label[1])

int(na)
else
if na(session[1]) and not na(session) or session[1] < session
if timeframe.multiplier == 1
line.set_x2(line_t,bar_index+1)
line.set_x2(line_b,bar_index+1)
line.set_y1(line_t,hi)
line.set_y2(line_t,hi)
line.set_y1(line_b,lo)
line.set_y2(line_b,lo)
if show_labelX and not na(line_label)
label.set_y(line_label, hi)
int(na)

//*****************************//
// Daylight Savings Time Flags //
//*****************************//

int previousSunday = dayofmonth – dayofweek + 1
bool nyDST = na
bool ukDST = na
bool sydDST = na

if month < 3 or month > 11
nyDST := false
ukDST := false
sydDST := true
else if month > 4 and month < 10
nyDST := true
ukDST := true
sydDST := false
else if month == 3
nyDST := previousSunday >= 8
ukDST := previousSunday >= 24
sydDST := true
else if month == 4
nyDST := true
ukDST := true
sydDST := previousSunday <= 0
else if month == 10
nyDST := true
ukDST := previousSunday <= 24
sydDST := previousSunday >= 0
else // month == 11
nyDST := previousSunday <= 0
ukDST := false
sydDST := true

if ukDST
draw_open_range(sess1Time,sess1col,show_or1,’GMT+1′)
draw_session_hilo(sess1Time, show_rectangle1, show_label1, sess1colLabel, sess1Label, ‘GMT+1′)
else
draw_open_range(sess1Time,sess1col,show_or1,’GMT+0’)
draw_session_hilo(sess1Time, show_rectangle1, show_label1, sess1colLabel, sess1Label, ‘GMT+0′)

if nyDST
draw_open_range(sess2Time,sess2col,show_or2,’GMT+1’)
draw_session_hilo(sess2Time, show_rectangle2, show_label2, sess2colLabel, sess2Label, ‘GMT+1′)
else
draw_open_range(sess2Time,sess2col,show_or2,’GMT+0’)
draw_session_hilo(sess2Time, show_rectangle2, show_label2, sess2colLabel, sess2Label, ‘GMT+0′)

// Tokyo
draw_open_range(sess3Time,sess3col,show_or3,’GMT+0’)
draw_session_hilo(sess3Time, show_rectangle3, show_label3, sess3colLabel, sess3Label, ‘GMT+0′)

// Hong Kong
draw_open_range(sess4Time,sess4col,show_or4,’GMT+0’)
draw_session_hilo(sess4Time, show_rectangle4, show_label4, sess4colLabel, sess4Label, ‘GMT+0′)

if sydDST
draw_open_range(sess5Time,sess5col,show_or5,’GMT+1’)
draw_session_hilo(sess5Time, show_rectangle5, show_label5, sess5colLabel, sess5Label, ‘GMT+1′)
else
draw_open_range(sess5Time,sess5col,show_or5,’GMT+0’)
draw_session_hilo(sess5Time, show_rectangle5, show_label5, sess5colLabel, sess5Label, ‘GMT+0′)

if nyDST
draw_open_range(sess7Time,sess7col,show_or7,’GMT+1’)
draw_session_hilo(sess7Time, show_rectangle7, show_label7, sess7colLabel, sess7Label, ‘GMT+1′)
else
draw_open_range(sess7Time,sess7col,show_or7,’GMT+0’)
draw_session_hilo(sess7Time, show_rectangle7, show_label7, sess7colLabel, sess7Label, ‘GMT+0′)

//////////////////////////////////////////////////
////QQE MOD
/////////////////////////////////////////////////

qqe_gorup = “██████████ QQE ██████████”
RSI_Period = input(6, title=’RSI Length’, group=qqe_gorup)
SF = input(5, title=’RSI Smoothing’, group=qqe_gorup)
QQE = input(3, title=’Fast QQE Factor’, group=qqe_gorup)
ThreshHold = input(3, title=’Thresh-hold’, group=qqe_gorup)
//

srcqqe = input(close, title=’RSI Source’, group=qqe_gorup)
//

//
Wilders_Period = RSI_Period * 2 – 1

Rsi = ta.rsi(srcqqe, RSI_Period)
RsiMa = ta.ema(Rsi, SF)
AtrRsi = math.abs(RsiMa[1] – RsiMa)
MaAtrRsi = ta.ema(AtrRsi, Wilders_Period)
dar = ta.ema(MaAtrRsi, Wilders_Period) * QQE

longband = 0.0
shortband = 0.0
trend = 0

DeltaFastAtrRsi = dar
RSIndex = RsiMa
newshortband = RSIndex + DeltaFastAtrRsi
newlongband = RSIndex – DeltaFastAtrRsi
longband := RSIndex[1] > longband[1] and RSIndex > longband[1] ? math.max(longband[1], newlongband) : newlongband
shortband := RSIndex[1] < shortband[1] and RSIndex < shortband[1] ? math.min(shortband[1], newshortband) : newshortband
cross_1 = ta.cross(longband[1], RSIndex)
trend := ta.cross(RSIndex, shortband[1]) ? 1 : cross_1 ? -1 : nz(trend[1], 1)
FastAtrRsiTL = trend == 1 ? longband : shortband

length = input.int(50, minval=1, title=’Bollinger Length’, group=qqe_gorup)
multqqe = input.float(0.35, minval=0.001, maxval=5, step=0.1, title=’BB Multiplier’, group=qqe_gorup)
basis = ta.sma(FastAtrRsiTL – 50, length)
dev = multqqe * ta.stdev(FastAtrRsiTL – 50, length)
upperqqe = basis + dev
lowerqqe = basis – dev
color_bar = RsiMa – 50 > upperqqe ? #00c3ff : RsiMa – 50 < lowerqqe ? #ff0062 : color.gray

//
// Zero cross
QQEzlong = 0
QQEzlong := nz(QQEzlong[1])
QQEzshort = 0
QQEzshort := nz(QQEzshort[1])
QQEzlong := RSIndex >= 50 ? QQEzlong + 1 : 0
QQEzshort := RSIndex < 50 ? QQEzshort + 1 : 0
//

////////////////////////////////////////////////////////////////

RSI_Period2 = input(6, title=’RSI Length’, group=qqe_gorup)
SF2 = input(5, title=’RSI Smoothing’, group=qqe_gorup)
QQE2 = input(1.61, title=’Fast QQE2 Factor’, group=qqe_gorup)
ThreshHold2 = input(3, title=’Thresh-hold’, group=qqe_gorup)

src2 = input(close, title=’RSI Source’, group=qqe_gorup)
//

//
Wilders_Period2 = RSI_Period2 * 2 – 1

Rsi2 = ta.rsi(src2, RSI_Period2)
RsiMa2 = ta.ema(Rsi2, SF2)
AtrRsi2 = math.abs(RsiMa2[1] – RsiMa2)
MaAtrRsi2 = ta.ema(AtrRsi2, Wilders_Period2)
dar2 = ta.ema(MaAtrRsi2, Wilders_Period2) * QQE2
longband2 = 0.0
shortband2 = 0.0
trend2 = 0

DeltaFastAtrRsi2 = dar2
RSIndex2 = RsiMa2
newshortband2 = RSIndex2 + DeltaFastAtrRsi2
newlongband2 = RSIndex2 – DeltaFastAtrRsi2
longband2 := RSIndex2[1] > longband2[1] and RSIndex2 > longband2[1] ? math.max(longband2[1], newlongband2) : newlongband2
shortband2 := RSIndex2[1] < shortband2[1] and RSIndex2 < shortband2[1] ? math.min(shortband2[1], newshortband2) : newshortband2
cross_2 = ta.cross(longband2[1], RSIndex2)
trend2 := ta.cross(RSIndex2, shortband2[1]) ? 1 : cross_2 ? -1 : nz(trend2[1], 1)
FastAtrRsi2TL = trend2 == 1 ? longband2 : shortband2

//
// Zero cross
QQE2zlong = 0
QQE2zlong := nz(QQE2zlong[1])
QQE2zshort = 0
QQE2zshort := nz(QQE2zshort[1])
QQE2zlong := RSIndex2 >= 50 ? QQE2zlong + 1 : 0
QQE2zshort := RSIndex2 < 50 ? QQE2zshort + 1 : 0
//
qqeline = FastAtrRsi2TL – 50
// hcolor2 = RsiMa2 – 50 > ThreshHold2 ? color.silver : RsiMa2 – 50 < 0 – ThreshHold2 ? color.silver : na

Greenbar1 = RsiMa2 – 50 > ThreshHold2
Greenbar2 = RsiMa – 50 > upperqqe

Redbar1 = RsiMa2 – 50 < 0 – ThreshHold2
Redbar2 = RsiMa – 50 < lowerqqe

/////////////////////////////////////////////////
/////////////// Volume Up/Down
////////////////////////////////////////////////
vgroup = “██████████ Up/Down Volume ██████████”
lowerTimeframeTooltip = “The indicator scans lower timeframe data to approximate Up/Down volume. By default, the timeframe is chosen automatically. These inputs override this with a custom timeframe.\n\nHigher timeframes provide more historical data, but the data will be less precise.”
useCustomTimeframeInput = input.bool(false, “Use custom timeframe”, tooltip = lowerTimeframeTooltip,group=vgroup)
lowerTimeframeInput = input.timeframe(“1”, “Timeframe”,group=vgroup)

upAndDownVolume() =>
posVol = 0.0
negVol = 0.0

switch
close > open => posVol += volume
close < open => negVol -= volume
close >= close[1] => posVol += volume
close < close[1] => negVol -= volume

[posVol, negVol]

lowerTimeframe = switch
useCustomTimeframeInput => lowerTimeframeInput
timeframe.isintraday => “1”
timeframe.isdaily => “5”
=> “60”

// Modify the timeframe argument in the security call
timeframeForSecurity = useCustomTimeframeInput ? lowerTimeframeInput : timeframe.period

[upVolumeArray, downVolumeArray] = request.security_lower_tf(syminfo.tickerid, timeframeForSecurity, upAndDownVolume())

SMALength = input(20, title=”SMA Length”,group=vgroup)
volume_ma = ta.sma(volume, SMALength)

volume_abovema_signal = volume > volume_ma

upVolume = array.sum(upVolumeArray)
downVolume = array.sum(downVolumeArray)
delta = upVolume + downVolume
prevdelta = delta[1]

var cumVol = 0.
cumVol += nz(volume)
if barstate.islast and cumVol == 0
runtime.error(“The data vendor doesn’t provide volume data for this symbol.”)

respectemavalue = ta.ema(src, respectemaperiod)
isaboverespectema = close > respectemavalue
isbelowrespectema = close < respectemavalue

isqqebarabove = Greenbar1 and Greenbar2
isqqebarbelow = Redbar1 and Redbar2

dv2up = bool (na)

dvup = bool (na)

if dvtype == ‘Threshold’
dvup := vol > t and vol>=1.1
else if dvtype == ’10p Difference’
dvup := vol > t and (vol – t >= 0.1)
else
dvup := vol > t

sarup = out < close
sardown = out > close

longvol = bool(na)
shortvol = bool (na)

if volumetype == ‘Delta’
longvol := delta > 0 and delta > delta[1]
shortvol := delta < 0 and delta < delta[1]
else if volumetype == ‘volume above MA’
longvol := volume_abovema_signal
shortvol := volume_abovema_signal
else
longvol := upVolume > upVolume[1]
shortvol := downVolume < downVolume[1]

longCond = bool(na)
shortCond = bool(na)

longCond2 = bool(na)
shortCond2 = bool(na)

vipcondition = bool(na)
vimcondition = bool(na)

if vitype == ‘Simple’
vipcondition := vip > vim
vimcondition := vip < vim
else
vipcondition := vip > vim and vip > viupper and vip > vip[1] and vim < vim[1] and vim[1] <= vilower and vip[1] >= viupper
vimcondition := vip < vim and vim > viupper and vim > vim[1] and vip < vip [1] and vip[1] <= vilower and vim [1] >= viupper

vipcondition2 = vip > vim
vimcondition2 = vip < vim

///////////////////////////////////ADX Condition ////////////////////////////////////////
adxcycle = 0
adxup = ta.crossover(adx, keyLevel)
adxdown = ta.crossunder(adx, keyLevel)
adxcycle := adxup ? 1 : adxdown ? -1 : adxcycle[1]
adxcondition = string(na)

adxupcondition = bool(na)
adxdowncondition = bool (na)
if adxtype == ‘Adx & +Di -Di’
adxupcondition := diplus > diminus and adx>=keyLevel
adxdowncondition := diplus < diminus and adx>=keyLevel
if adxtype == ‘Adx Only’
adxupcondition := adx>keyLevel
adxdowncondition := adx>keyLevel
else
if adxcycle == -1
adxupcondition := diplus > diminus and adx>=keyLevel and diplus – diminus > 1
adxdowncondition := diplus < diminus and adx>=keyLevel and diminus – diplus > 1
else if adxcycle==1
adxupcondition := diplus > diminus and adx>=keyLevel and adx<55 and (adx>adx[1] or (diplus > diplus[1] and diminus < diminus[1])) and diplus – diminus > 1
adxdowncondition := diplus < diminus and adx>=keyLevel and adx<55 and (adx>adx[1] or (diplus < diplus[1] and diminus > diminus[1])) and diminus – diplus > 1

///////////////adx condition end/////////////////////////////////////////////////////

justcontinue = bool(true)

isstup = bool(na)
isstdown = bool(na)
isstup := sttrend == 1
isstdown := sttrend != 1

ismacdup = bool(na)
ismacddown = bool(na)

isqqeabove = bool(na)
isqqebelow = bool(na)

if qqetype == ‘Line’
isqqeabove := qqeline>0
isqqebelow := qqeline<0
else if qqetype == ‘Bar’
isqqeabove := RsiMa2 – 50 > 0 and (Greenbar1 and Greenbar2)
isqqebelow := RsiMa2 – 50 < 0 and (Redbar1 and Redbar2)
else if qqetype == ‘Line & Bar’
isqqeabove := RsiMa2 – 50 > 0 and (Greenbar1 and Greenbar2) and qqeline>0
isqqebelow := RsiMa2 – 50 < 0 and (Redbar1 and Redbar2) and qqeline<0

rsimalong2 = bool(na)
rsimashort2 = bool(na)

rsimalong2:= rsiMA >= rsiMA[1]
rsimashort2:= rsiMA <= rsiMA[1]

rsilimitlong = rsi >= rsilimitup
rsilimitshort = rsi <= rsilimitdown

rsimalimitlong = rsiMA >= rsimalimitup
rsimalimitshort = rsiMA <= rsimalimitdown

leadinglongcond = bool(na)
leadingshortcond = bool(na)

if leadingindicator == ‘Range Filter’

if rftype == ‘Default’
leadinglongcond := src > filt and src > src[1] and upward > 0 or src > filt and src < src[1] and upward > 0
leadingshortcond := src < filt and src < src[1] and downward > 0 or src < filt and src > src[1] and downward > 0
else if rftype == ‘DW’
leadinglongcond := rfupward
leadingshortcond := rfdownward

else if leadingindicator == ‘DMI (Adx)’
if adxtype == ‘Basic’
leadinglongcond := diplus > diminus and adx>=keyLevel
leadingshortcond := diplus < diminus and adx>=keyLevel
else
if adxcycle == -1
leadinglongcond := diplus > diminus and adx>=keyLevel and diplus – diminus > 1
leadingshortcond := diplus < diminus and adx>=keyLevel and diminus – diplus > 1
else if adxcycle==1
leadinglongcond := diplus > diminus and adx>=keyLevel and adx<55 and (adx>adx[1] or (diplus > diplus[1] and diminus < diminus[1])) and diplus – diminus > 1
leadingshortcond := diplus < diminus and adx>=keyLevel and adx<55 and (adx>adx[1] or (diplus < diplus[1] and diminus > diminus[1])) and diminus – diplus > 1
else if leadingindicator == ‘Parabolic SAR (PSAR)’
leadinglongcond := out < close
leadingshortcond := out > close
else if leadingindicator == ‘Rational Quadratic Kernel (RQK)’
leadinglongcond := rqkuptrend
leadingshortcond := rqkdowntrend

else if leadingindicator == ‘Trendline Breakout’
leadinglongcond := tb_buysignal
leadingshortcond := tb_sellsignal

else if leadingindicator == ‘Range Detector’
leadinglongcond := rd_long
leadingshortcond := rd_short

else if leadingindicator == ‘Heiken-Ashi Candlestick Oscillator’
leadinglongcond := hacolt_long
leadingshortcond := hacolt_short

else if leadingindicator == ‘Donchian Trend Ribbon’
leadinglongcond := donchian_long
leadingshortcond := donchian_short

else if leadingindicator == ‘Rate of Change (ROC)’
leadinglongcond := roc_long
leadingshortcond := roc_short

else if leadingindicator == ‘Trend Direction Force Index (TDFI)’
leadinglongcond := tdfi_long
leadingshortcond := tdfi_short

else if leadingindicator == ‘Detrended Price Oscillator (DPO)’
leadinglongcond := dpo_long
leadingshortcond := dpo_short

else if leadingindicator == ‘2 EMA Cross’
leadinglongcond := ema2_long
leadingshortcond := ema2_short

else if leadingindicator == ‘3 EMA Cross’
leadinglongcond := first_3ema > second_3ema and first_3ema > third_3ema and second_3ema>third_3ema
leadingshortcond := first_3ema < second_3ema and first_3ema < third_3ema and second_3ema<third_3ema

else if leadingindicator == ‘Chandelier Exit’
leadinglongcond := ce_long
leadingshortcond := ce_short

else if leadingindicator == ‘Stochastic’
leadinglongcond := stoch_long
leadingshortcond := stoch_short

else if leadingindicator == ‘Vortex Index’

if vitype == ‘Simple’
leadinglongcond := vip > vim
leadingshortcond := vip < vim
else
leadinglongcond := vip > vim and vip > viupper and vip > vip[1] and vim < vim[1] and vim[1] <= vilower and vip[1] >= viupper
leadingshortcond := vip < vim and vim > viupper and vim > vim[1] and vip < vip [1] and vip[1] <= vilower and vim [1] >= viupper

else if leadingindicator == ‘Schaff Trend Cycle (STC)’
leadinglongcond := stc >= upper
leadingshortcond := stc <= upper
else if leadingindicator == ‘Wolfpack Id’
leadinglongcond := wolf_long
leadingshortcond := wolf_short

else if leadingindicator == ‘B-Xtrender’
leadinglongcond := bx_long
leadingshortcond := bx_short

else if leadingindicator == ‘Bull Bear Power Trend’
leadinglongcond := bbpt_long
leadingshortcond := bbpt_short

else if leadingindicator == ‘QQE Mod’
if qqetype == ‘Line’
leadinglongcond := qqeline>0
leadingshortcond := qqeline<0
else if qqetype == ‘Bar’
leadinglongcond := RsiMa2 – 50 > 0 and (Greenbar1 and Greenbar2)
leadingshortcond := RsiMa2 – 50 < 0 and (Redbar1 and Redbar2)
else if qqetype == ‘Line & Bar’
leadinglongcond := RsiMa2 – 50 > 0 and (Greenbar1 and Greenbar2) and qqeline>0
leadingshortcond := RsiMa2 – 50 < 0 and (Redbar1 and Redbar2) and qqeline<0

else if leadingindicator == ‘MACD’
if macdtype == ‘MACD Crossover’
leadinglongcond := macdd > signal
leadingshortcond := macdd < signal
else if macdtype == ‘Zero line crossover’
leadinglongcond := macdd > signal and macdd > 0.00000
leadingshortcond := macdd < signal and macdd < 0.00000

else if leadingindicator == ‘True Strength Indicator (TSI)’
if tsitype == ‘Signal Cross’
leadinglongcond := tsi_long
leadingshortcond := tsi_short
else if tsitype == ‘Zero line cross’
leadinglongcond := tsi_long
leadingshortcond := tsi_short

else if leadingindicator == ‘RSI’
if rsitype == ‘RSI MA Cross’
leadinglongcond := rsi > rsiMA
leadingshortcond := rsi < rsiMA
else if rsitype == ‘RSI Exits OB/OS zones’
leadinglongcond := rsi > rsi_lower and rsi[1] < rsi_lower
leadingshortcond := rsi < rsi_upper and rsi[1] > rsi_upper
else if rsitype == ‘RSI Level’
leadinglongcond := rsi > respectrsilevel
leadingshortcond := rsi < respectrsilevel

else if leadingindicator == ‘Chaikin Money Flow’
leadinglongcond := chaikin_long
leadingshortcond := chaikin_short

else if leadingindicator == ‘Volatility Oscillator’
leadinglongcond := vo_long
leadingshortcond := vo_short

else if leadingindicator == ‘SSL Channel’
leadinglongcond := ssl_long
leadingshortcond := ssl_short

else if leadingindicator == ‘Awesome Oscillator’
leadinglongcond := ao_long
leadingshortcond := ao_short

else if leadingindicator == ‘Supertrend’

leadinglongcond := sttrend == 1
leadingshortcond := sttrend != 1

else if leadingindicator == ‘Half Trend’

leadinglongcond := halftrend_long
leadingshortcond := halftrend_short

else if leadingindicator == ‘Waddah Attar Explosion’

leadinglongcond := wae_long
leadingshortcond := wae_short

else if leadingindicator == ‘Hull Suite’
leadinglongcond := HULL > HULL[2]
leadingshortcond := HULL < HULL[2]

else if leadingindicator == ‘BB Oscillator’
leadinglongcond := bbosc_long
leadingshortcond := bbosc_short

else if leadingindicator == ‘Ichimoku Cloud’
leadinglongcond := ichi_long
leadingshortcond := ichi_short

else if leadingindicator == ‘VWAP’
leadinglongcond := long_vwap
leadingshortcond := short_vwap

else if leadingindicator == ‘SuperIchi’
leadinglongcond := superichi_long
leadingshortcond := superichi_short

// else if leadingindicator == ‘Trend Meter’
// if tmtype == ‘3 TM and 2 TB change to same color’
// leadinglongcond := TB1Green and TB2Green and (TrendBar1Result and TrendBar2Result and TrendBar3Result ? 1 : 0)
// leadingshortcond := TB1Red and TB2Red and (not TrendBar1Result and not TrendBar2Result and not TrendBar3Result ? 1 : 0)
// else if tmtype == ‘3 TM change to same color’
// leadinglongcond := TrendBar1Result and TrendBar2Result and TrendBar3Result ? 1 : 0
// leadingshortcond := not TrendBar1Result and not TrendBar2Result and not TrendBar3Result ? 1 : 0
// else if tmtype == ‘3 TM, 2 TB and Wavetrend change to same color’
// leadinglongcond := TB1Green and TB2Green and (TrendBar1Result and TrendBar2Result and TrendBar3Result ? 1 : 0) and MSBar1PositiveWaveTrendSignal
// leadingshortcond := TB1Red and TB2Red and (not TrendBar1Result and not TrendBar2Result and not TrendBar3Result ? 1 : 0) and MSBar1NegativeWaveTrendSignal
else if leadingindicator == ‘CCI’
leadinglongcond := ccilong
leadingshortcond := ccishort

tmup = bool(na)
tmdown = bool(na)

// if tmtype == ‘3 TM and 2 TB change to same color’
// tmup := TB1Green and TB2Green and (TrendBar1Result and TrendBar2Result and TrendBar3Result ? 1 : 0)
// tmdown := TB1Red and TB2Red and (not TrendBar1Result and not TrendBar2Result and not TrendBar3Result ? 1 : 0)
// else if tmtype == ‘3 TM change to same color’
// tmup := TrendBar1Result and TrendBar2Result and TrendBar3Result ? 1 : 0
// tmdown := not TrendBar1Result and not TrendBar2Result and not TrendBar3Result ? 1 : 0
// else if tmtype == ‘3 TM, 2 TB and Wavetrend change to same color’
// tmup := TB1Green and TB2Green and (TrendBar1Result and TrendBar2Result and TrendBar3Result ? 1 : 0) and MSBar1PositiveWaveTrendSignal
// tmdown := TB1Red and TB2Red and (not TrendBar1Result and not TrendBar2Result and not TrendBar3Result ? 1 : 0) and MSBar1NegativeWaveTrendSignal

hullup = bool(na)
hulldown = bool(na)
if respecthull
hullup := HULL > HULL[2]
hulldown := HULL < HULL[2]

rsiup = bool (na)
rsidown = bool (na)

if rsitype == ‘RSI MA Cross’
rsiup := rsi > rsiMA
rsidown := rsi < rsiMA
else if rsitype == ‘RSI Exits OB/OS zones’
rsiup := rsi > rsi_lower and rsi[1] < rsi_lower
rsidown := rsi < rsi_upper and rsi[1] > rsi_upper
else if rsitype == ‘RSI Level’
rsiup := rsi > respectrsilevel
rsidown := rsi < respectrsilevel

if macdtype == ‘MACD Crossover’
ismacdup := macdd > signal
ismacddown := macdd < signal
else if macdtype == ‘Zero line crossover’
ismacdup := macdd > signal and macdd > 0.00000
ismacddown := macdd < signal and macdd < 0.00000

uprf = bool (na)
downrf = bool(na)

if rftype == ‘Default’
uprf := src > filt and src > src[1] and upward > 0 or src > filt and src < src[1] and upward > 0
downrf := src < filt and src < src[1] and downward > 0 or src < filt and src > src[1] and downward > 0
else if rftype == ‘DW’
uprf := rfupward
downrf := rfdownward

ema3_long = first_3ema > second_3ema and first_3ema > third_3ema and second_3ema>third_3ema
ema3_short = first_3ema < second_3ema and first_3ema < third_3ema and second_3ema<third_3ema

longCond := leadinglongcond and (respectrf?uprf:justcontinue) and
(respectadx?adxupcondition:justcontinue) and (respecttsi?tsi_long:justcontinue) and (respecthacolt?hacolt_long:justcontinue) and (respectmd?md_long:justcontinue) and (respecttdfi?tdfi_long:justcontinue) and (respectdpo?dpo_long:justcontinue) and (respectrd? rd_signal:justcontinue) and (respectci?ci_filter:justcontinue) and (respectroc?roc_long:justcontinue) and (respectht?halftrend_long:justcontinue) and (respectdonchian?donchian_long:justcontinue) and (respecttrendline_breakout?tb_buysignal:justcontinue) and (respectbbpt?bbpt_long:justcontinue) and (respectrqk?rqkuptrend:justcontinue) and (respectbx?bx_long:justcontinue) and (respectbbosc?bbosc_long:justcontinue) and (respectwae?wae_long:justcontinue) and (respectce?ce_long:justcontinue) and (respectssl?ssl_long:justcontinue) and (respect2ma?ema2_long:justcontinue) and (respect3ma?ema3_long:justcontinue) and (respectstochastic?stoch_long:justcontinue) and (respectcci?ccilong:justcontinue) and (respectst?isstup:justcontinue) and (respectrsi?rsiup:justcontinue) and (respectrsimalimit?rsimalimitlong:justcontinue) and (respectrsilimit?rsilimitlong:justcontinue) and (respectrsima?rsimalong2:justcontinue) and (respectema?isaboverespectema:justcontinue) and (respectqqe?isqqeabove:justcontinue) and (respectsar?sarup:justcontinue) and
(respectvol?longvol:justcontinue) and (respectchaikin?chaikin_long:justcontinue) and (respectvwap?long_vwap:justcontinue) and (respectvo?vo_long:justcontinue) and (respectao?ao_long:justcontinue) and (respectsuperichi?superichi_long:justcontinue) and (respectwolf?wolf_long:justcontinue) and (respectichi?ichi_long:justcontinue) and (respectmacd?ismacdup:justcontinue) and (respecthull?hullup:justcontinue) and (respectvi?vipcondition:justcontinue) and (respectstc?stcup:justcontinue) and (respectdv?dvup:justcontinue)

//and (respecttm?tmup:justcontinue)

shortCond := leadingshortcond and (respectrf?downrf:justcontinue) and
(respectadx?adxdowncondition:justcontinue) and (respecttsi?tsi_short:justcontinue) and (respecthacolt?hacolt_short:justcontinue) and (respectmd?md_short:justcontinue) and (respecttdfi?tdfi_short:justcontinue) and (respectdpo?dpo_short:justcontinue) and (respectrd? rd_signal:justcontinue) and (respectci?ci_filter:justcontinue) and (respectroc?roc_short:justcontinue) and (respectht?halftrend_short:justcontinue) and (respecttrendline_breakout?tb_sellsignal:justcontinue) and (respectdonchian?donchian_short:justcontinue) and (respectbbpt?bbpt_short:justcontinue) and (respectrqk?rqkdowntrend:justcontinue) and (respectbx?bx_short:justcontinue) and (respectbbosc?bbosc_short:justcontinue) and (respectwae?wae_short:justcontinue) and (respectce?ce_short:justcontinue) and (respectssl?ssl_short:justcontinue) and (respectchaikin?chaikin_short:justcontinue) and (respect2ma?ema2_short:justcontinue) and (respect3ma?ema3_short:justcontinue) and (respectstochastic?stoch_short:justcontinue) and (respectcci?ccishort:justcontinue) and (respectrsimalimit?rsimalimitshort:justcontinue) and (respectrsilimit?rsilimitshort:justcontinue) and (respectrsima?rsimashort2:justcontinue) and (respectst?isstdown:justcontinue) and (respectrsi?rsidown:justcontinue) and (respectema?isbelowrespectema:justcontinue) and (respectqqe?isqqebelow:justcontinue) and (respectsar?sardown:justcontinue) and
(respectvol?shortvol:justcontinue) and (respectvwap?short_vwap:justcontinue) and (respectvo?vo_short:justcontinue) and (respectao?ao_short:justcontinue) and (respectsuperichi?superichi_short:justcontinue) and (respectwolf?wolf_short:justcontinue) and (respectichi?ichi_short:justcontinue) and (respectmacd?ismacddown:justcontinue) and (respecthull?hulldown:justcontinue) and (respectvi?vimcondition:justcontinue) and (respectstc?stcdown:justcontinue) and (respectdv?dvup:justcontinue)

//and (respecttm?tmdown:justcontinue)

var int leadinglong_count = 0
var int leadinglong_count2 = 0

var int leadingshort_count = 0
var int leadingshort_count2 = 0

if leadinglongcond
leadinglong_count := leadinglong_count + 1
leadinglong_count2 := leadinglong_count

for i = 1 to 100
if leadinglongcond[i]
leadinglong_count := leadinglong_count + 1
leadinglong_count2 := leadinglong_count

else
leadinglong_count := 0
break

if leadingshortcond
leadingshort_count := leadingshort_count + 1
leadingshort_count2 := leadingshort_count

for i = 1 to 100
if leadingshortcond[i]
leadingshort_count := leadingshort_count + 1
leadingshort_count2 := leadingshort_count

else
leadingshort_count := 0
break

CondIni = 0

longCondition = bool (na)
shortCondition = bool(na)

// if expiry option is used
longcond_withexpiry = longCond and leadinglong_count2 <= signalexpiry
shortcond_withexpiry = shortCond and leadingshort_count2 <= signalexpiry

log.info(“leadinglong_count2 : {0}”,leadinglong_count2)
log.info(“leadingshort_count2: {0}”,leadingshort_count2)
//without expiry
longCondition := longcond_withexpiry and CondIni[1] == -1
shortCondition := shortcond_withexpiry and CondIni[1] == 1

if alternatesignal
longCondition := longcond_withexpiry and CondIni[1] == -1
shortCondition := shortcond_withexpiry and CondIni[1] == 1

else
longCondition := longcond_withexpiry
shortCondition := shortcond_withexpiry

CondIni := longcond_withexpiry ? 1 : shortcond_withexpiry ? -1 : CondIni[1]

is_expiry_count_crossed_long = leadinglong_count2 >= signalexpiry
is_expiry_count_crossed_short = leadingshort_count2 >= signalexpiry

plotshape(showsignal ? (longCondition[1] ? false : longCondition) : na, title=’Buy Signal’, text=’long’, textcolor=color.new(color.white, 0), style=shape.labelup, size=size.tiny, location=location.belowbar, color=color.new(color.green, 0))
plotshape(showsignal and shortCondition and showsignal, title=’Sell Signal’, text=’short’, textcolor=color.new(color.white, 0), style=shape.labeldown, size=size.tiny, location=location.abovebar, color=color.new(color.red, 0))

alertcondition(longCondition, title=’Buy Alert’, message=’BUY’)
alertcondition(shortCondition, title=’Sell Alert’, message=’SELL’)
alertcondition(longCondition or shortCondition, title=’Buy or Sell Alert’, message=”Buy or Sell Alert”)

rsitype2 = rsitype
if rsitype2 == “RSI Level”
rsitype2 := “RSI Level (” + str.tostring(respectrsilevel) +”)”

confirmation_counter = array.new_string(0)
confirmation_val = array.new_string(0)
confirmation_val_short = array.new_string(0)

pushConfirmation(respect, label, longCondition, shortCondition) =>
if respect
array.push(confirmation_counter, label)
array.push(confirmation_val, longCondition ? “✔️” : “❌”)
array.push(confirmation_val_short, shortCondition ? “✔️” : “❌”)

pushConfirmation(respectema, “EMA”, isaboverespectema, isbelowrespectema)
pushConfirmation(respect2ma, “2 EMA Cross (” + str.tostring(respect2maperiod_1) + “,” + str.tostring(respect2maperiod_2) + “)”, ema2_long, ema2_short)
pushConfirmation(respect3ma, “3 EMA Cross (” + str.tostring(respect3maperiod_1) + “,” + str.tostring(respect3maperiod_2) + “,” + str.tostring(respect3maperiod_3) + “)”, ema3_long, ema3_short)
pushConfirmation(respectrf, “Range Filter”, uprf, downrf)
pushConfirmation(respectrqk, “Rational Quadratic Kernel (RQK)”, rqkuptrend, rqkdowntrend)
pushConfirmation(respectst, “SuperTrend”, isstup, isstdown)
pushConfirmation(respectht, “Half Trend”, halftrend_long, halftrend_short)

pushConfirmation(respecttrendline_breakout, “Trendline breakout”, tb_buysignal, tb_sellsignal)
pushConfirmation(respectrd, “Range Detector”, rd_long, rd_short)
pushConfirmation(respecthacolt, “Heiken-Ashi Candlestick Oscillator”, hacolt_long, hacolt_short)

pushConfirmation(respectdonchian, “Donchian Trend Ribbon”, donchian_long, donchian_short)
pushConfirmation(respectroc, “Rate of Change (ROC)”, roc_long, roc_short)
pushConfirmation(respecttsi, “True Strength Indicator (TSI)”, tsi_long, tsi_short)

pushConfirmation(respecttdfi, “Trend Direction Force Index (TDFI)”, tdfi_long, tdfi_short)

pushConfirmation(respectbx, “B-Xtrender (” + str.tostring(bxtype) + “)”, bx_long, bx_short)
pushConfirmation(respectbbpt, “Bull Bear Power Trend (” + str.tostring(bbpttype) + “)”, bbpt_long, bbpt_short)
pushConfirmation(respectvwap, “VWAP”, long_vwap, short_vwap)
pushConfirmation(respectichi, “Ichimoku Cloud”, ichi_long, ichi_short)
pushConfirmation(respectsuperichi, “Superichi”, superichi_long, superichi_short)
pushConfirmation(respectbbosc, “BB Oscillator”, bbosc_long, bbosc_short)
// pushConfirmation(respecttm, “Trend Meter”, tmup, tmdown)
pushConfirmation(respectce, “Chandelier Exit”, ce_long, ce_short)
pushConfirmation(respectcci, “CCI”, ccilong, ccishort)
pushConfirmation(respectadx, “DMI (Adx) (” + str.tostring(adxtype) + “)”, adxupcondition, adxdowncondition)
pushConfirmation(respectsar, “Parabolic SAR”, sarup, sardown)
pushConfirmation(respectssl, “SSL Channel”, ssl_long, ssl_short)
pushConfirmation(respectvo, “Volatility Oscillator”, vo_long, vo_short)
pushConfirmation(respectdpo, “Detrended Price Oscillator(DPO)”, dpo_long, dpo_short)
pushConfirmation(respectmd, “McGinley Dynamic”, md_long, md_short)

pushConfirmation(respectdv, “DV”, dvup, dvup) // Note: Both are ‘dvup’. Double-check if it’s intended.
pushConfirmation(respectci, “Choppiness Index”, ci_filter, ci_filter) // Note: Both are ‘dvup’. Double-check if it’s intended.

pushConfirmation(respectstochastic, “Stochastic (” + str.tostring(stochtype) + “)”, stoch_long, stoch_short)
pushConfirmation(respectrsi, “RSI (” + str.tostring(rsitype2) + “)”, rsiup, rsidown)
pushConfirmation(respectmacd, “MACD (” + str.tostring(macdtype) + “)”, ismacdup, ismacddown)
pushConfirmation(respectstc, “Schaff Trend Cycle”, stcup, stcdown)
pushConfirmation(respectwae, “Waddah Attar Explosion”, wae_long, wae_short)

pushConfirmation(respectchaikin, “Chaikin Money Flow”, chaikin_long, chaikin_short)
pushConfirmation(respectvol, “Volume”, longvol, shortvol)
pushConfirmation(respectao, “Awesome Oscillator(” + str.tostring(aotype) + “)”, ao_long, ao_short)
pushConfirmation(respectwolf, “Wolfpack Id”, wolf_long, wolf_short)
pushConfirmation(respectqqe, “QQE Mod (” + str.tostring(qqetype) + “)”, isqqeabove, isqqebelow)
pushConfirmation(respecthull, “HullSuite”, hullup, hulldown)
pushConfirmation(respectvi, “Vortex Index (” + str.tostring(vitype) + “)”, vipcondition, vimcondition)

getFalseShortConditionItems(arrShort) =>
sShort = “”
if array.size(arrShort) > 0
for i = 0 to array.size(arrShort) – 1
if array.get(arrShort, i) == “❌”
sShort := sShort + array.get(confirmation_counter, i) + “\n”
sShort

falseShortConditionString = getFalseShortConditionItems(confirmation_val_short)

tooltipS = “🔴 Failed Short Confirmations: ” + “\n” + “————————–” + “\n” + falseShortConditionString

labelShortCondition = showsignal and is_expiry_count_crossed_short and not is_expiry_count_crossed_short[1] and CondIni == 1

if labelShortCondition
label.new(bar_index, low, “🔴”, color=color.new(#dd1111, 0), textcolor=color.white, style=label.style_none, yloc=yloc.belowbar, size=size.small, tooltip=tooltipS)

getFalseLongConditionItems(arr) =>
s = “”
if array.size(arr) > 0
for i = 0 to array.size(arr) – 1
if array.get(arr, i) == “❌”
s := s + array.get(confirmation_counter, i) + “\n”
s

falseLongConditionString = getFalseLongConditionItems(confirmation_val)

tooltipL = “🔴 Failed Long Confirmations: ” + “\n” + “————————–” + “\n” + falseLongConditionString

labelCondition = showsignal and is_expiry_count_crossed_long and not is_expiry_count_crossed_long[1] and CondIni == -1

if labelCondition
label.new(bar_index, high, “🔴”, color=color.new(color.green, 0), textcolor=color.white, style=label.style_none, yloc=yloc.abovebar, size=size.small, tooltip=tooltipL)

leadingstatus = leadinglongcond ? “✔️” : “❌”
leadingstatus_short = leadingshortcond ? “✔️” : “❌”

rowcount = int(na)
if array.size(confirmation_counter) ==0
rowcount := 5
else
rowcount := array.size(confirmation_counter)+4

if showdashboard
var table tab1 = table.new(i_tab1Ypos + ‘_’ + i_tab1Xpos, 3, rowcount, color.rgb(42, 46, 57), color.rgb(204, 204, 204), 0, color.rgb(77, 71, 71), 1)

table.cell(tab1, 1, 0,”Long”, text_halign=text.align_left, text_size=table_size(in_dashboardtab_size), bgcolor=color.rgb(61, 189, 72),text_color=color.white)
table.cell(tab1, 2, 0,”Short”, text_halign=text.align_left, text_size=table_size(in_dashboardtab_size), bgcolor=color.rgb(243, 77, 77),text_color=color.white)

table.cell(tab1, 0, 1, “Leading Indicator”, text_halign=text.align_left, text_size=table_size(in_dashboardtab_size), bgcolor=color.rgb(68, 68, 67),text_color=color.white)
table.cell(tab1, 1, 1,””, text_halign=text.align_left, text_size=table_size(in_dashboardtab_size), bgcolor=color.rgb(68, 68, 67),text_color=color.white)
table.cell(tab1, 2, 1,””, text_halign=text.align_left, text_size=table_size(in_dashboardtab_size), bgcolor=color.rgb(68, 68, 67),text_color=color.white)

table.cell(tab1, 0, 2, leadingindicator, text_halign=text.align_left, text_size=table_size(in_dashboardtab_size), text_color=color.white)
table.cell(tab1, 1, 2, leadingstatus, text_halign=text.align_left, text_size=table_size(in_dashboardtab_size), text_color=color.white)
table.cell(tab1, 2, 2, leadingstatus_short, text_halign=text.align_left, text_size=table_size(in_dashboardtab_size), text_color=color.white)

table.cell(tab1, 0, 3, “Confirmation Indicators”, text_halign=text.align_left, text_size=table_size(in_dashboardtab_size), bgcolor=color.rgb(68, 68, 67),text_color=color.white)
table.cell(tab1, 1, 3, “”, text_halign=text.align_left, text_size=table_size(in_dashboardtab_size), bgcolor=color.rgb(68, 68, 67),text_color=color.white)
table.cell(tab1, 2, 3, “”, text_halign=text.align_left, text_size=table_size(in_dashboardtab_size), bgcolor=color.rgb(68, 68, 67),text_color=color.white)

if array.size(confirmation_counter) > 0
for i=0 to array.size(confirmation_counter)-1
table.cell(tab1, 0, 4+i, array.get(confirmation_counter,i), text_halign=text.align_left, text_size=table_size(in_dashboardtab_size), text_color=color.white)
else
table.cell(tab1, 0, 4, “None Selected”, text_halign=text.align_left, text_size=table_size(in_dashboardtab_size), text_color=color.white)

if array.size(confirmation_val) > 0
for j=0 to array.size(confirmation_val)-1
table.cell(tab1, 1, 4+j, array.get(confirmation_val,j), text_halign=text.align_left, text_size=table_size(in_dashboardtab_size), text_color=color.white)
table.cell(tab1, 2, 4+j, array.get(confirmation_val_short,j), text_halign=text.align_left, text_size=table_size(in_dashboardtab_size), text_color=color.white)

plot(longCondition?100:na, “long Signal”,display = display.data_window )
plot(shortCondition?-100:na, “Short Signal”,display = display.data_window )

Stenozar
Participant

Topics: 41
Replies: 48
Been thanked: 1 time
Author

Posts

Viewing 1 post (of 1 total)

Find exclusive trading pro-tools on