เริ่มกันเลย

ค้นหาในสคริปต์สำหรับ "top"

Gann Square of 144This indicator will create lines on the chart based on W.D. Gann's Square of 144. All the inputs will be detailed below Why create this indicator? I didn't find it on Tradingview (at least with open source). But the main reason is to study the strategy and be able to draw it fast. Manually drawing the square is not hard, but moving all together to the right spots and scale was time-consuming. It has a lot of inputs... Yes, each square point divisible by 6 has information with some options, so the user can create any configuration he wants. Also, it has the advantage of having the square built in seconds and adjusting itself on each new calculation. About the inputs Starting Date This input will be used when the "Set Upper/Lower Prices and Start Bar Automatically" checkbox is not selected. The indicator will calculate all the line locations on the chart using the selected start date. When selecting this input, change the Manual Max and Min Prices to the better calculation Manual Max/Min Price This input will be used when the "Set Upper/Lower Prices and Start Bar Automatically" checkbox is not selected. The indicator will calculate all the line's locations on the chart using these prices Set Upper/Lower Prices and Start Bar Automatically Selects if the starting date will be automatically selected by the system or based on the input data. When it's set, the indicator will use the most recent bar as the middle point of the square, using the higher price as the Upper Price and the lowest price as the Lower Price in the latest 72 bars (or more based on the Candles Per Division parameter) Update at a new bar When this option is market, the indicator will update all created lines to match the new bar position, together with all the possible new Upper/Lower prices. Let it unchecked to watch the progression of the price while the square remains fixed in the chart. Top X-Axis When checked, it will display the labels on the Top of the square Bottom X-Axis When checked, it will display the labels on the Bottom of the square Left X-Axis When checked, it will display the labels on the left of the square Right X-Axis When checked, it will display the labels on the right of the square Show Prices on the Right Y-Axis When checked, it will display the prices together with the labels on the right of the square Show Vertical Divisions Show the lines that will divide the square into 9 equal parts Show Extra Lines Show unique lines that will come from the Top and bottom middle of the square, connecting the center to the 36 and 108 levels Show Grid When selected, it will display a grid in the square Line Patterns A selector with some options of built-in lines configuration. When any option besides None is selected, it will override the lines inputs below Numbers Color Select the color of each number on the Axis Vertical Lines Color Select the color of the vertical lines Grid Color Select the grid line color Connections from corners to N Each corner is represented by 2 characters, so they all fit in a single line It will indicate where the line starts and where it ends ┏ ↓ = Top Left to Bottom ┏ → = Top Left to Right ┗ ↑ = Bottom Left to Top ┗ → = Bottom Left to Right ┓ ← = Top Right to Left ┓ ↓ = Top Right to Bottom ┛ ← = Bottom Right to Left ┛ ↑ = Bottom Right to Top Besides selecting what line will be created, it's possible to select the color, the style, and the extension How to use this indicator When you dig into Gann's books for more information about the square of 144, you find that it was part of his setup with multiple indicators (technical and fundamental, and astrological). It is not a "one indicator" setup, so it's hard to say that you will find entries, exits, stop loss, and take profit in this. Still, it will help see trendiness, support, and resistance levels. Mixing this with other indicators is probably a good idea, but some may find this indicator the only one needed. Some aspects of the square The end of the square is important, so where it starts is crucial. The end is important because it is where the price and time expire. The other parts of the square are defined based on their start and end, so placing them right is essential. So, where to set the start of the square? The last major low is the most indicated. The minimum price will be the lowest, and the max price will be the last major Top. Note that the indicator uses 1 candle on each point. After finding the start, the minimum, and the maximum prices for the square, it will draw all lines. Another essential part of the square is The Midpoint. The midpoint is the most crucial part of the square and is the best way to see if you positioned the square correctly. When the price is inside the square, using the starting candle as the start, a second higher low or a lower high occurs in that spot. When using the Vertical lines in the indicator, it's the middle square inside Gann's square. The other divisions will be opposing each other most of the time. So if the price is rising in the 1/3 of the square, it's common to see the price fall in the 3/3 of the square. More information about these aspects here Considerations This indicator was meant for price targets and a time calculator for possible support/resistances in the chart. It was created by William Delbert Gann and was part of his setup for trading almost a century ago. The lines will form geometric figures, which Gann used with high accuracy to predict tops/bottoms and when they would occur.
อินดิเคเตอร์ Pine Script®
โดย ThiagoSchmitz
56
Murrey Math Lines with extreme compartor and pivot pointsI did combine 3 scripts into one that really shows a lot. This is to bring together other good ideas to show improve on others work. Special thanks to pipcharlie for the murrey math lines Mage3 for the pivot points and morpheous747 for the murrey extreme compartor. // this script shows sveral things. //1. Breakouts - multiple diamonds and price staying in the outer murrey bands is a strong trend. This will lead to a double top or bottom. You could also buy/sell // the pullbacks and expext another diamond. //2. Tops - 2 pivots in the top murrey bands first top must have a diamond second must be in the top murrey zone or a higher murrey outer band without a diamond. // There also must have a dip between tops outside the top murrey zone. //3. bottoms bounces - a quick pull back if there are 2 pivots close together and the second pivot is not a diamond. //4. double bottoms - 2 pivots with the first pivot a diamond. The second is after a pullback out of the bottom murrey zone and a diamond. //5. pullbacks - red and green lines. These are a little more benificial for tops/bottoms //6. Overall trends - the triangles on top or bottoms show overall general trend. Also the murrey bands act like bollinger bands, once trend changes, expect targets // to hit the opposite band. //7. Pivots - adding pivots and extentions help determine trends, resistance levels and tops/bottoms\ //8. Volitility - the wider the murry bands the more movement is likely and ususally in trend with stronger pullbacks. The smaller the bands smaller moves and more // up and down movement
อินดิเคเตอร์ Pine Script®
โดย docelky
6
BUZARA// © Buzzara // ================================= // PLEASE SUPPORT THE TEAM // ================================= // // Telegram: t.me // ================================= //@version=5 VERSION  = ' Buzzara2.0' strategy('ALGOX V6_1_24', shorttitle = '🚀〄 Buzzara2.0 〄🚀'+ VERSION, overlay = true, explicit_plot_zorder = true, pyramiding = 0, default_qty_type = strategy.percent_of_equity, initial_capital = 1000, default_qty_value = 1, calc_on_every_tick = false, process_orders_on_close = true) G_SCRIPT01   = '■ ' + 'SAIYAN OCC' //#region ———— <↓↓↓ G_SCRIPT01 ↓↓↓> { // === INPUTS === res                       = input.timeframe('15',  'TIMEFRAME', group ="NON REPAINT") useRes                    = input(true,            'Use Alternate Signals') intRes                    = input(10,               'Multiplier for Alernate Signals') basisType                 = input.string('ALMA',   'MA Type: ', options= ) basisLen                  = input.int(50,           'MA Period', minval=1) offsetSigma               = input.int(5,           'Offset for LSMA / Sigma for ALMA', minval=0) offsetALMA                = input.float(2,      'Offset for ALMA', minval=0, step=0.01) scolor                    = input(false,           'Show coloured Bars to indicate Trend?') delayOffset               = input.int(0,           'Delay Open/Close MA', minval=0, step=1,                   tooltip = 'Forces Non-Repainting') tradeType                 = input.string('BOTH',   'What trades should be taken : ',                   options = ) //=== /INPUTS === h                         = input(false,           'Signals for Heikin Ashi Candles') //INDICATOR SETTINGS swing_length              = input.int(10,          'Swing High/Low Length', group = 'Settings', minval = 1, maxval = 50) history_of_demand_to_keep = input.int(20,          'History To Keep', minval = 5, maxval = 50) box_width                 = input.float(2.5,       'Supply/Demand Box Width', group = 'Settings', minval = 1, maxval = 10, step = 0.5) //INDICATOR VISUAL SETTINGS show_zigzag               = input.bool(false,      'Show Zig Zag', group = 'Visual Settings', inline = '1') show_price_action_labels  = input.bool(false,      'Show Price Action Labels', group = 'Visual Settings', inline = '2') supply_color              = input.color(#00000000, 'Supply', group = 'Visual Settings', inline = '3') supply_outline_color      = input.color(#00000000, 'Outline', group = 'Visual Settings', inline = '3') demand_color              = input.color(#00000000, 'Demand', group = 'Visual Settings', inline = '4') demand_outline_color      = input.color(#00000000, 'Outline', group = 'Visual Settings', inline = '4') bos_label_color           = input.color(#00000000, 'BOS Label', group = 'Visual Settings', inline = '5') poi_label_color           = input.color(#00000000, 'POI Label', group = 'Visual Settings', inline = '7') poi_border_color          = input.color(#00000000, 'POI border', group = 'Visual Settings', inline = '7') swing_type_color          = input.color(#00000000, 'Price Action Label', group = 'Visual Settings', inline = '8') zigzag_color              = input.color(#00000000, 'Zig Zag', group = 'Visual Settings', inline = '9') //END SETTINGS //      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 = swing_type_color,           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 = swing_type_color,           size = size.tiny) //      FUNCTION MAKE SURE SUPPLY ISNT OVERLAPPING f_check_overlapping(new_poi, box_array, atrValue) =>     atr_threshold = atrValue * 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, atrValue) =>     atr_buffer = atrValue * (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, atrValue)     // 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         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 = poi_border_color,              bgcolor = poi_border_color, 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         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 = poi_border_color,              bgcolor = poi_border_color, 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         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), 'BOS' )                 box.set_text_color( array.get(bos_array,0), bos_label_color)                 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         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), 'BOS' )                 box.set_text_color( array.get(bos_array,0), bos_label_color)                 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) // stratRes = timeframe.ismonthly  ? str.tostring(timeframe.multiplier * intRes, '###M') :            timeframe.isweekly   ? str.tostring(timeframe.multiplier * intRes, '###W') :            timeframe.isdaily    ? str.tostring(timeframe.multiplier * intRes, '###D') :            timeframe.isintraday ? str.tostring(timeframe.multiplier * intRes, '####') :            '60' src      = h ? request.security(ticker.heikinashi(syminfo.tickerid),            timeframe.period, close, lookahead = barmerge.lookahead_off) : close //      CALCULATE ATR atrValue = ta.atr(50) //      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 )     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, atrValue) //      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 )     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, atrValue) 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) channelBal     = input.bool(false, "Channel Balance", group = "CHART") lr_slope(_src, _len) =>     x = 0.0, y = 0.0, x2 = 0.0, xy = 0.0     for i = 0 to _len - 1         val = _src         per = i + 1         x += per         y += val         x2 += per * per         xy += val * per     _slp = (_len * xy - x * y) / (_len * x2 - x * x)     _avg = y / _len     _int = _avg - _slp * x / _len + _slp     lr_dev(_src, _len, _slp, _avg, _int) =>     upDev = 0.0, dnDev = 0.0     val = _int     for j = 0 to _len - 1         price = high - val         if price > upDev             upDev := price         price := val - low         if price > dnDev             dnDev := price         price := _src         val += _slp     // = ta.kc(close, 80, 10.5) = ta.kc(close, 80, 9.5) = ta.kc(close, 80, 8) = ta.kc(close, 80, 3) barsL          = 10 barsR          = 10 pivotHigh      = fixnan(ta.pivothigh(barsL, barsR) ) pivotLow       = fixnan(ta.pivotlow(barsL, barsR) ) source         = close, period = 150      = lr_slope(source, period) = lr_dev(source, period, s, a, i) y1 = low  - (ta.atr(30) * 2), y1B = low  - ta.atr(30) y2 = high + (ta.atr(30) * 2), y2B = high + ta.atr(30) x1 = bar_index - period + 1, _y1 = i + s * (period - 1), x2 = bar_index, _y2 = i //Functions //Line Style function get_line_style(style) =>     out = switch style         '???'  => line.style_solid         '----' => line.style_dashed         '    ' => line.style_dotted //Function to get order block coordinates get_coordinates(condition, top, btm, ob_val)=>     var ob_top  = array.new_float(0)     var ob_btm  = array.new_float(0)     var ob_avg  = array.new_float(0)     var ob_left = array.new_int(0)     float ob = na     //Append coordinates to arrays     if condition         avg = math.avg(top, btm)                 array.unshift(ob_top, top)         array.unshift(ob_btm, btm)         array.unshift(ob_avg, avg)             ob := ob_val         //Function to remove mitigated order blocks from coordinate arrays remove_mitigated(ob_top, ob_btm, ob_left, ob_avg, target, bull)=>     mitigated = false     target_array = bull ? ob_btm : ob_top     for element in target_array         idx = array.indexof(target_array, element)         if (bull ? target < element : target > element)             mitigated := true             array.remove(ob_top, idx)             array.remove(ob_btm, idx)             array.remove(ob_avg, idx)             array.remove(ob_left, idx)         mitigated //Function to set order blocks set_order_blocks(ob_top, ob_btm, ob_left, ob_avg, ext_last, bg_css, border_css, lvl_css)=>     var ob_box = array.new_box(0)     var ob_lvl = array.new_line(0) //Global elements var os = 0 var target_bull = 0. var target_bear = 0. // Create non-repainting security function rp_security(_symbol, _res, _src) =>     request.security(_symbol, _res, _src ) htfHigh = rp_security(syminfo.tickerid, res, high) htfLow  = rp_security(syminfo.tickerid, res, low) // Main Indicator // Functions smoothrng(x, t, m) =>     wper = t * 2 - 1     avrng = ta.ema(math.abs(x - x ), t)     smoothrng = ta.ema(avrng, wper) * m rngfilt(x, r) =>     rngfilt = x     rngfilt := x > nz(rngfilt ) ? x - r < nz(rngfilt ) ? nz(rngfilt ) : x - r : x + r > nz(rngfilt ) ? nz(rngfilt ) : x + r percWidth(len, perc) => (ta.highest(len) - ta.lowest(len)) * perc / 100 securityNoRep(sym, res, src) => request.security(sym, res, src, barmerge.gaps_off, barmerge.lookahead_on) swingPoints(prd) =>     pivHi = ta.pivothigh(prd, prd)     pivLo = ta.pivotlow (prd, prd)     last_pivHi = ta.valuewhen(pivHi, pivHi, 1)     last_pivLo = ta.valuewhen(pivLo, pivLo, 1)     hh = pivHi and pivHi > last_pivHi ? pivHi : na     lh = pivHi and pivHi < last_pivHi ? pivHi : na     hl = pivLo and pivLo > last_pivLo ? pivLo : na     ll = pivLo and pivLo < last_pivLo ? pivLo : na     f_chartTfInMinutes() =>     float _resInMinutes = timeframe.multiplier * (       timeframe.isseconds ? 1                   :       timeframe.isminutes ? 1.                  :       timeframe.isdaily   ? 60. * 24            :       timeframe.isweekly  ? 60. * 24 * 7        :       timeframe.ismonthly ? 60. * 24 * 30.4375  : na) f_kc(src, len, sensitivity) =>     basis = ta.sma(src, len)     span  = ta.atr(len)     wavetrend(src, chlLen, avgLen) =>     esa = ta.ema(src, chlLen)     d = ta.ema(math.abs(src - esa), chlLen)     ci = (src - esa) / (0.015 * d)     wt1 = ta.ema(ci, avgLen)     wt2 = ta.sma(wt1, 3)     f_top_fractal(_src) => _src < _src and _src < _src and _src > _src and _src > _src f_bot_fractal(_src) => _src > _src and _src > _src and _src < _src and _src < _src top_fractal    = f_top_fractal(src) bot_fractal    = f_bot_fractal(src) f_fractalize (_src) => top_fractal ? 1 : bot_fractal ? -1 : 0 f_findDivs(src, topLimit, botLimit) =>     fractalTop = f_fractalize(src) > 0 and src >= topLimit ? src : na     fractalBot = f_fractalize(src) < 0 and src <= botLimit ? src : na     highPrev   = ta.valuewhen(fractalTop, src , 0)     highPrice  = ta.valuewhen(fractalTop, high , 0)     lowPrev    = ta.valuewhen(fractalBot, src , 0)     lowPrice   = ta.valuewhen(fractalBot, low , 0)     bearSignal = fractalTop and high > highPrice and src < highPrev     bullSignal = fractalBot and low < lowPrice and src > lowPrev         // Get user input enableSR   = input(false          , "SR On/Off", group="SR") colorSup   = input(#00000000        , "Support Color", group="SR") colorRes   = input(#00000000        , "Resistance Color", group="SR") strengthSR = input.int(2          , "S/R Strength", 1, group="SR") lineStyle  = input.string("Dotted", "Line Style", , group="SR") lineWidth  = input.int(2          , "S/R Line Width", 1, group="SR") useZones   = input(true           , "Zones On/Off", group="SR") useHLZones = input(true           , "High Low Zones On/Off", group="SR") zoneWidth  = input.int(2          , "Zone Width %", 0,    tooltip = "it's calculated using % of the distance between highest/lowest in last 300 bars", group="SR") expandSR   = input(true           , "Expand SR") // Get components rb         = 10 prd        = 284 ChannelW   = 10 label_loc  = 55 style      = lineStyle == "Solid"  ? line.style_solid  :              lineStyle == "Dotted" ? line.style_dotted : line.style_dashed ph         = ta.pivothigh(rb, rb) pl         = ta.pivotlow (rb, rb) sr_levels  = array.new_float(21, na) prdhighest = ta.highest(prd) prdlowest  = ta.lowest(prd) cwidth     = percWidth(prd, ChannelW) zonePerc   = percWidth(300, zoneWidth) aas        = array.new_bool(41, true) u1         = 0.0, u1 := nz(u1 ) d1         = 0.0, d1 := nz(d1 ) highestph  = 0.0, highestph := highestph lowestpl   = 0.0, lowestpl := lowestpl var sr_levs   = array.new_float(21, na) label hlabel  = na, label.delete(hlabel ) label llabel  = na, label.delete(llabel ) var sr_lines  = array.new_line(21, na) var sr_linesH = array.new_line(21, na) var sr_linesL = array.new_line(21, na) var sr_linesF = array.new_linefill(21, na) var sr_labels = array.new_label(21, na) if (not na(ph) or not na(pl))     for x = 0 to array.size(sr_levels) - 1         array.set(sr_levels, x, na)     highestph := prdlowest     lowestpl := prdhighest     countpp = 0     for x = 0 to prd         if na(close )             break         if not na(ph ) or not na(pl )             highestph := math.max(highestph, nz(ph , prdlowest), nz(pl , prdlowest))             lowestpl := math.min(lowestpl, nz(ph , prdhighest), nz(pl , prdhighest))             countpp += 1             if countpp > 40                 break             if array.get(aas, countpp)                 upl = (not na(ph ) and (ph != 0) ? high : low ) + cwidth                 dnl = (not na(ph ) and (ph != 0) ? high : low ) - cwidth                 u1 := countpp == 1 ? upl : u1                 d1 := countpp == 1 ? dnl : d1                 tmp = array.new_bool(41, true)                 cnt = 0                 tpoint = 0                 for xx = 0 to prd                     if na(close )                         break                     if not na(ph ) or not na(pl )                         chg = false                         cnt += 1                         if cnt > 40                             break                         if array.get(aas, cnt)                             if not na(ph )                                 if high <= upl and high >= dnl                                     tpoint += 1                                     chg := true                             if not na(pl )                                 if low <= upl and low >= dnl                                     tpoint += 1                                     chg := true                         if chg and cnt < 41                             array.set(tmp, cnt, false)                 if tpoint >= strengthSR                     for g = 0 to 40 by 1                         if not array.get(tmp, g)                             array.set(aas, g, false)                     if (not na(ph ) and countpp < 21)                         array.set(sr_levels, countpp, high )                     if (not na(pl ) and countpp < 21)                         array.set(sr_levels, countpp, low ) // Plot var line highest_      = na, line.delete(highest_) var line lowest_       = na, line.delete(lowest_) var line highest_fill1 = na, line.delete(highest_fill1) var line highest_fill2 = na, line.delete(highest_fill2) var line lowest_fill1  = na, line.delete(lowest_fill1) var line lowest_fill2  = na, line.delete(lowest_fill2) hi_col = close >= highestph ? colorSup : colorRes lo_col = close >= lowestpl  ? colorSup : colorRes if enableSR     highest_ := line.new(bar_index - 311, highestph, bar_index, highestph, xloc.bar_index, expandSR ? extend.both : extend.right, hi_col, style, lineWidth)     lowest_  := line.new(bar_index - 311, lowestpl , bar_index, lowestpl , xloc.bar_index, expandSR ? extend.both : extend.right, lo_col, style, lineWidth)     if useHLZones         highest_fill1 := line.new(bar_index - 311, highestph + zonePerc, bar_index, highestph + zonePerc, xloc.bar_index, expandSR ? extend.both : extend.right, na)         highest_fill2 := line.new(bar_index - 311, highestph - zonePerc, bar_index, highestph - zonePerc, xloc.bar_index, expandSR ? extend.both : extend.right, na)         lowest_fill1  := line.new(bar_index - 311, lowestpl + zonePerc , bar_index, lowestpl + zonePerc , xloc.bar_index, expandSR ? extend.both : extend.right, na)         lowest_fill2  := line.new(bar_index - 311, lowestpl - zonePerc , bar_index, lowestpl - zonePerc , xloc.bar_index, expandSR ? extend.both : extend.right, na)         linefill.new(highest_fill1, highest_fill2, hi_col)         linefill.new(lowest_fill1 , lowest_fill2 , lo_col) if (not na(ph) or not na(pl))     for x = 0 to array.size(sr_lines) - 1         array.set(sr_levs, x, array.get(sr_levels, x)) for x = 0 to array.size(sr_lines) - 1     line.delete(array.get(sr_lines, x))     line.delete(array.get(sr_linesH, x))     line.delete(array.get(sr_linesL, x))     linefill.delete(array.get(sr_linesF, x))     if (not na(array.get(sr_levs, x)) and enableSR)         line_col = close >= array.get(sr_levs, x) ? colorSup : colorRes         array.set(sr_lines, x, line.new(bar_index - 355, array.get(sr_levs, x), bar_index, array.get(sr_levs, x), xloc.bar_index, expandSR ? extend.both : extend.right, line_col, style, lineWidth))         if useZones             array.set(sr_linesH, x, line.new(bar_index - 355, array.get(sr_levs, x) + zonePerc, bar_index, array.get(sr_levs, x) + zonePerc, xloc.bar_index, expandSR ? extend.both : extend.right, na))             array.set(sr_linesL, x, line.new(bar_index - 355, array.get(sr_levs, x) - zonePerc, bar_index, array.get(sr_levs, x) - zonePerc, xloc.bar_index, expandSR ? extend.both : extend.right, na))             array.set(sr_linesF, x, linefill.new(array.get(sr_linesH, x), array.get(sr_linesL, x), line_col)) for x = 0 to array.size(sr_labels) - 1     label.delete(array.get(sr_labels, x))     if (not na(array.get(sr_levs, x)) and enableSR)         lab_loc = close >= array.get(sr_levs, x) ? label.style_label_up : label.style_label_down         lab_col = close >= array.get(sr_levs, x) ? colorSup             : colorRes         array.set(sr_labels, x, label.new(bar_index + label_loc, array.get(sr_levs, x), str.tostring(math.round_to_mintick(array.get(sr_levs, x))), color=lab_col , textcolor=#000000, style=lab_loc)) hlabel := enableSR ? label.new(bar_index + label_loc + math.round(math.sign(label_loc)) * 20, highestph, "High Level : " + str.tostring(highestph), color=hi_col, textcolor=#000000, style=label.style_label_down) : na llabel := enableSR ? label.new(bar_index + label_loc + math.round(math.sign(label_loc)) * 20, lowestpl , "Low  Level : " + str.tostring(lowestpl) , color=lo_col, textcolor=#000000, style=label.style_label_up  ) : na // Get components rsi       = ta.rsi(close, 28) //rsiOb     = rsi > 78 and rsi > ta.ema(rsi, 10) //rsiOs     = rsi < 27 and rsi < ta.ema(rsi, 10) rsiOb     = rsi > 65 and rsi > ta.ema(rsi, 10) rsiOs     = rsi < 35 and rsi < ta.ema(rsi, 10) dHigh     = securityNoRep(syminfo.tickerid, "D", high ) dLow      = securityNoRep(syminfo.tickerid, "D", low   ) dClose    = securityNoRep(syminfo.tickerid, "D", close ) ema = ta.ema(close, 144) emaBull = close > ema equal_tf(res) => str.tonumber(res) == f_chartTfInMinutes() and not timeframe.isseconds higher_tf(res) => str.tonumber(res) > f_chartTfInMinutes() or timeframe.isseconds too_small_tf(res) => (timeframe.isweekly and res=="1") or (timeframe.ismonthly and str.tonumber(res) < 10) securityNoRep1(sym, res, src) =>     bool bull_ = na     bull_ := equal_tf(res) ? src : bull_     bull_ := higher_tf(res) ? request.security(sym, res, src, barmerge.gaps_off, barmerge.lookahead_on) : bull_     bull_array = request.security_lower_tf(syminfo.tickerid, higher_tf(res) ? str.tostring(f_chartTfInMinutes()) + (timeframe.isseconds ? "S" : "") : too_small_tf(res) ? (timeframe.isweekly ? "3" : "10") : res, src)     if array.size(bull_array) > 1 and not equal_tf(res) and not higher_tf(res)         bull_ := array.pop(bull_array)     array.clear(bull_array)     bull_ // === BASE FUNCTIONS === // Returns MA input selection variant, default to SMA if blank or typo. variant(type, src, len, offSig, offALMA) =>     v1    = ta.sma(src, len)  // Simple     v2    = ta.ema(src, len)  // Exponential     v3    = 2 * v2 - ta.ema(v2, len)  // Double Exponential     v4    = 3 * (v2 - ta.ema(v2, len)) + ta.ema(ta.ema(v2, len), len)  // Triple Exponential     v5    = ta.wma(src, len)  // Weighted     v6    = ta.vwma(src, len)  // Volume Weighted     v7    = 0.0     sma_1 = ta.sma(src, len)  // Smoothed     v7   := na(v7 ) ? sma_1 : (v7 * (len - 1) + src) / len     v8    = ta.wma(2 * ta.wma(src, len / 2) - ta.wma(src, len), math.round(math.sqrt(len)))  // Hull     v9    = ta.linreg(src, len, offSig)  // Least Squares     v10   = ta.alma(src, len, offALMA, offSig)  // Arnaud Legoux     v11   = ta.sma(v1, len)  // Triangular (extreme smooth)     // SuperSmoother filter     //   2013  John F. Ehlers     a1    = math.exp(-1.414 * 3.14159 / len)     b1    = 2 * a1 * math.cos(1.414 * 3.14159 / len)     c2    = b1     c3    = -a1 * a1     c1    = 1 - c2 - c3     v12   = 0.0     v12  := c1 * (src + nz(src )) / 2 + c2 * nz(v12 ) + c3 * nz(v12 )     type == 'EMA' ? v2 : type == 'DEMA' ? v3 : type == 'TEMA' ? v4 : type == 'WMA' ? v5 : type == 'VWMA' ? v6 : type == 'SMMA' ? v7 : type == 'HullMA' ? v8 : type == 'LSMA' ? v9 : type == 'ALMA' ? v10 : type == 'TMA' ? v11 : type == 'SSMA' ? v12 : v1 // security wrapper for repeat calls reso(exp, use, res) =>     security_1 = request.security(syminfo.tickerid, res, exp, gaps = barmerge.gaps_off, lookahead = barmerge.lookahead_on)     use ? security_1 : exp // === /BASE FUNCTIONS === // === SERIES SETUP === closeSeries = variant(basisType, close , basisLen, offsetSigma, offsetALMA) openSeries  = variant(basisType, open ,  basisLen, offsetSigma, offsetALMA) // === /SERIES === // Get Alternate resolution Series if selected. closeSeriesAlt = reso(closeSeries, useRes, stratRes) openSeriesAlt  = reso(openSeries, useRes, stratRes) // lxTrigger    = false sxTrigger    = false leTrigger    = ta.crossover (closeSeriesAlt, openSeriesAlt) seTrigger    = ta.crossunder(closeSeriesAlt, openSeriesAlt) G_RISK       = '■ ' + 'Risk Management' //#region ———— <↓↓↓ G_RISK ↓↓↓> { // ——————————— //Tooltip T_LVL        = '(%) Exit Level' T_QTY        = '(%) Adjust trade exit volume' T_MSG        = 'Paste JSON message for your bot' //Webhook Message O_LEMSG      = 'Long Entry' O_LXMSGSL    = 'Long SL' O_LXMSGTP1   = 'Long TP1' O_LXMSGTP2   = 'Long TP2' O_LXMSGTP3   = 'Long TP3' O_LXMSG      = 'Long Exit' O_SEMSG      = 'Short Entry' O_SXMSGSL    = 'Short SL' O_SXMSGA     = 'Short TP1' O_SXMSGB     = 'Short TP2' O_SXMSGC     = 'Short TP3' O_SXMSGX     = 'Short Exit' // ———————————          |           |                               |                        Line length guide | i_lxLvlTP1   = input.float      (0.2,         'Level TP1'                     , group = G_RISK,      tooltip =                   T_LVL) i_lxQtyTP1   = input.float      (80.0,        'Qty   TP1'                     , group = G_RISK,      tooltip =                   T_QTY) i_lxLvlTP2   = input.float      (0.5,       'Level TP2'                     , group = G_RISK,      tooltip =                   T_LVL) i_lxQtyTP2   = input.float      (10.0,        'Qty   TP2'                     , group = G_RISK,      tooltip =                   T_QTY) i_lxLvlTP3   = input.float      (7.0,         'Level TP3'                     , group = G_RISK,      tooltip =                   T_LVL) i_lxQtyTP3   = input.float      (2,        'Qty   TP3'                     , group = G_RISK,      tooltip =                   T_QTY) i_lxLvlSL    = input.float      (0.5,       'Stop Loss'                     , group = G_RISK,      tooltip =                   T_LVL) i_sxLvlTP1   = i_lxLvlTP1 i_sxQtyTP1   = i_lxQtyTP1 i_sxLvlTP2   = i_lxLvlTP2 i_sxQtyTP2   = i_lxQtyTP2 i_sxLvlTP3   = i_lxLvlTP3 i_sxQtyTP3   = i_lxQtyTP3 i_sxLvlSL    = i_lxLvlSL G_MSG        = '■ ' + 'Webhook Message' i_leMsg      = input.string     (O_LEMSG   ,'Long Entry'                   , group = G_MSG, tooltip = T_MSG) i_lxMsgSL    = input.string     (O_LXMSGSL ,'Long SL'                      , group = G_MSG, tooltip = T_MSG) i_lxMsgTP1   = input.string     (O_LXMSGTP1,'Long TP1'                     , group = G_MSG, tooltip = T_MSG) i_lxMsgTP2   = input.string     (O_LXMSGTP2,'Long TP2'                     , group = G_MSG, tooltip = T_MSG) i_lxMsgTP3   = input.string     (O_LXMSGTP3,'Long TP3'                     , group = G_MSG, tooltip = T_MSG) i_lxMsg      = input.string     (O_LXMSG   ,'Long Exit'                    , group = G_MSG, tooltip = T_MSG) i_seMsg      = input.string     (O_SEMSG   ,'Short Entry'                  , group = G_MSG, tooltip = T_MSG) i_sxMsgSL    = input.string     (O_SXMSGSL ,'Short SL'                     , group = G_MSG, tooltip = T_MSG) i_sxMsgTP1   = input.string     (O_SXMSGA  ,'Short TP1'                    , group = G_MSG, tooltip = T_MSG) i_sxMsgTP2   = input.string     (O_SXMSGB  ,'Short TP2'                    , group = G_MSG, tooltip = T_MSG) i_sxMsgTP3   = input.string     (O_SXMSGC  ,'Short TP3'                    , group = G_MSG, tooltip = T_MSG) i_sxMsg      = input.string     (O_SXMSGX  ,'Short Exit'                   , group = G_MSG, tooltip = T_MSG) i_src        = close G_DISPLAY    = 'Display' // i_alertOn    = input.bool       (true,      'Alert Labels On/Off'          , group = G_DISPLAY) i_barColOn   = input.bool       (true,      'Bar Color On/Off'             , group = G_DISPLAY) // ——————————— // @function        Calculate the Take Profit line, and the crossover or crossunder f_tp(_condition, _conditionValue, _leTrigger, _seTrigger, _src, _lxLvlTP, _sxLvlTP)=>     var float _tpLine = 0.0     _topLvl     = _src + (_src * (_lxLvlTP / 100))     _botLvl     = _src - (_src * (_sxLvlTP / 100))     _tpLine    := _condition !=  _conditionValue and _leTrigger ? _topLvl :                   _condition != -_conditionValue and _seTrigger ? _botLvl :                   nz(_tpLine )     // @function        Similar to "ta.crossover" or "ta.crossunder" f_cross(_scr1, _scr2, _over)=>     _cross   = _over ? _scr1 > _scr2 and _scr1 < _scr2 :                        _scr1 < _scr2 and _scr1 > _scr2 // ——————————— // var float condition = 0.0 var float slLine    = 0.0 var float entryLine = 0.0 // entryLine   := leTrigger and condition <=  0.0 ? close :                seTrigger and condition >=  0.0 ? close : nz(entryLine ) // slTopLvl    = i_src + (i_src * (i_lxLvlSL / 100)) slBotLvl    = i_src - (i_src * (i_sxLvlSL / 100)) slLine     := condition <=  0.0 and leTrigger ? slBotLvl :               condition >=  0.0 and seTrigger ? slTopLvl : nz(slLine ) slLong      = f_cross(low,  slLine, false) slShort     = f_cross(high, slLine, true ) //    = f_tp(condition, 1.2,leTrigger, seTrigger, i_src, i_lxLvlTP3, i_sxLvlTP3)    = f_tp(condition, 1.1,leTrigger, seTrigger, i_src, i_lxLvlTP2, i_sxLvlTP2)    = f_tp(condition, 1.0,leTrigger, seTrigger, i_src, i_lxLvlTP1, i_sxLvlTP1) tp3Long      = f_cross(high, tp3Line, true ) tp3Short     = f_cross(low,  tp3Line, false) tp2Long      = f_cross(high, tp2Line, true ) tp2Short     = f_cross(low,  tp2Line, false) tp1Long      = f_cross(high, tp1Line, true ) tp1Short     = f_cross(low,  tp1Line, false) switch     leTrigger and condition <=  0.0 => condition :=  1.0     seTrigger and condition >=  0.0 => condition := -1.0     tp3Long   and condition ==  1.2 => condition :=  1.3     tp3Short  and condition == -1.2 => condition := -1.3     tp2Long   and condition ==  1.1 => condition :=  1.2     tp2Short  and condition == -1.1 => condition := -1.2     tp1Long   and condition ==  1.0 => condition :=  1.1     tp1Short  and condition == -1.0 => condition := -1.1     slLong    and condition >=  1.0 => condition :=  0.0     slShort   and condition <= -1.0 => condition :=  0.0     lxTrigger and condition >=  1.0 => condition :=  0.0     sxTrigger and condition <= -1.0 => condition :=  0.0 longE        = leTrigger and condition <=  0.0 and condition ==  1.0 shortE       = seTrigger and condition >=  0.0 and condition == -1.0 longX        = lxTrigger and condition >=  1.0 and condition ==  0.0 shortX       = sxTrigger and condition <= -1.0 and condition ==  0.0 longSL       = slLong    and condition >=  1.0 and condition ==  0.0 shortSL      = slShort   and condition <= -1.0 and condition ==  0.0 longTP3      = tp3Long   and condition ==  1.2 and condition ==  1.3 shortTP3     = tp3Short  and condition == -1.2 and condition == -1.3 longTP2      = tp2Long   and condition ==  1.1 and condition ==  1.2 shortTP2     = tp2Short  and condition == -1.1 and condition == -1.2 longTP1      = tp1Long   and condition ==  1.0 and condition ==  1.1 shortTP1     = tp1Short  and condition == -1.0 and condition == -1.1 // ——————————— { // if strategy.position_size <= 0 and longE and barstate.isconfirmed     strategy.entry(       'Long',       strategy.long,       alert_message    = i_leMsg,       comment          = 'LE') if strategy.position_size > 0 and condition ==  1.0     strategy.exit(       id               = 'LXTP1',       from_entry       = 'Long',       qty_percent      = i_lxQtyTP1,       limit            = tp1Line,       stop             = slLine,       comment_profit   = 'LXTP1',       comment_loss     = 'SL',       alert_profit     = i_lxMsgTP1,       alert_loss       = i_lxMsgSL) if strategy.position_size > 0 and condition ==  1.1     strategy.exit(       id               = 'LXTP2',       from_entry       = 'Long',       qty_percent      = i_lxQtyTP2,       limit            = tp2Line,       stop             = slLine,       comment_profit   = 'LXTP2',       comment_loss     = 'SL',       alert_profit     = i_lxMsgTP2,       alert_loss       = i_lxMsgSL) if strategy.position_size > 0 and condition ==  1.2     strategy.exit(       id               = 'LXTP3',       from_entry       = 'Long',       qty_percent      = i_lxQtyTP3,       limit            = tp3Line,       stop             = slLine,       comment_profit   = 'LXTP3',       comment_loss     = 'SL',       alert_profit     = i_lxMsgTP3,       alert_loss       = i_lxMsgSL) if longX     strategy.close(       'Long',       alert_message    = i_lxMsg,       comment          = 'LX') // if strategy.position_size >= 0 and shortE and barstate.isconfirmed     strategy.entry(       'Short',       strategy.short,       alert_message    = i_leMsg,       comment          = 'SE') if strategy.position_size < 0 and condition == -1.0     strategy.exit(       id               = 'SXTP1',       from_entry       = 'Short',       qty_percent      = i_sxQtyTP1,       limit            = tp1Line,       stop             = slLine,       comment_profit   = 'SXTP1',       comment_loss     = 'SL',       alert_profit     = i_sxMsgTP1,       alert_loss       = i_sxMsgSL) if strategy.position_size < 0 and condition == -1.1     strategy.exit(       id               = 'SXTP2',       from_entry       = 'Short',       qty_percent      = i_sxQtyTP2,       limit            = tp2Line,       stop             = slLine,       comment_profit   = 'SXTP2',       comment_loss     = 'SL',       alert_profit     = i_sxMsgTP2,       alert_loss       = i_sxMsgSL) if strategy.position_size < 0 and condition == -1.2     strategy.exit(       id               = 'SXTP3',       from_entry       = 'Short',       qty_percent      = i_sxQtyTP3,       limit            = tp3Line,       stop             = slLine,       comment_profit   = 'SXTP3',       comment_loss     = 'SL',       alert_profit     = i_sxMsgTP3,       alert_loss       = i_sxMsgSL) if shortX     strategy.close(       'Short',       alert_message    = i_sxMsg,       comment          = 'SX') // ——————————— c_tp         = leTrigger or seTrigger ? na :                condition == 0.0       ? na : color.green c_entry      = leTrigger or seTrigger ? na :                condition == 0.0       ? na : color.blue c_sl         = leTrigger or seTrigger ? na :                condition == 0.0       ? na : color.red p_tp1Line    = plot (   condition ==  1.0 or   condition == -1.0 ? tp1Line : na,   title      = "TP Line 1",   color      = c_tp,   linewidth  = 1,   style      = plot.style_linebr) p_tp2Line    = plot (   condition ==  1.0 or   condition == -1.0 or   condition ==  1.1 or   condition == -1.1 ? tp2Line : na,   title      = "TP Line 2",   color      = c_tp,   linewidth  = 1,   style      = plot.style_linebr) p_tp3Line    = plot (   condition ==  1.0 or   condition == -1.0 or   condition ==  1.1 or   condition == -1.1 or   condition ==  1.2 or   condition == -1.2 ? tp3Line : na,   title      = "TP Line 3",   color      = c_tp,   linewidth  = 1,   style      = plot.style_linebr) p_entryLine  = plot (   condition >=  1.0 or   condition <= -1.0 ? entryLine : na,   title      = "Entry Line",   color      = c_entry,   linewidth  = 1,   style      = plot.style_linebr) p_slLine     = plot (   condition ==  1.0 or   condition == -1.0 or   condition ==  1.1 or   condition == -1.1 or   condition ==  1.2 or   condition == -1.2 ? slLine : na,   title      = "SL Line",   color      = c_sl,   linewidth  = 1,   style      = plot.style_linebr) fill(   p_tp3Line, p_entryLine,   color      = leTrigger or seTrigger ? na :color.new(color.green, 90)) fill(   p_entryLine, p_slLine,   color      = leTrigger or seTrigger ? na :color.new(color.red, 90)) // plotshape(   i_alertOn and longE,   title      = 'Long',   text       = 'Long',   textcolor  = color.white,   color      = color.green,   style      = shape.labelup,   size       = size.tiny,   location   = location.belowbar) plotshape(   i_alertOn and shortE,   title      = 'Short',   text       = 'Short',   textcolor  = color.white,   color      = color.red,   style      = shape.labeldown,   size       = size.tiny,   location   = location.abovebar) plotshape(   i_alertOn and (longX or shortX) ? close : na,   title      = 'Close',   text       = 'Close',   textcolor  = color.white,   color      = color.gray,   style      = shape.labelup,   size       = size.tiny,   location   = location.absolute) l_tp         = i_alertOn and (longTP1 or shortTP1) ? close : na plotshape(   l_tp,   title      = "TP1 Cross",   text       = "TP1",   textcolor  = color.white,   color      = color.olive,   style      = shape.labelup,   size       = size.tiny,   location   = location.absolute) plotshape(   i_alertOn and (longTP2 or shortTP2) ? close : na,   title      = "TP2 Cross",   text       = "TP2",   textcolor  = color.white,   color      = color.olive,   style      = shape.labelup,   size       = size.tiny,   location   = location.absolute) plotshape(   i_alertOn and (longTP3 or shortTP3) ? close : na,   title      = "TP3 Cross",   text       = "TP3",   textcolor  = color.white,   color      = color.olive,   style      = shape.labelup,   size       = size.tiny,   location   = location.absolute) plotshape(   i_alertOn and (longSL or shortSL) ? close : na,   title      = "SL Cross",   text       = "SL",   textcolor  = color.white,   color      = color.maroon,   style      = shape.labelup,   size       = size.tiny,   location   = location.absolute) // plot(   na,   title      = "─── ───",   editable   = false,   display    = display.data_window) plot(   condition,   title      = "condition",   editable   = false,   display    = display.data_window) plot(   strategy.position_size * 100,   title      = ".position_size",   editable   = false,   display    = display.data_window) //#endregion } // ——————————— <↑↑↑ G_RISK ↑↑↑> //#region ———— <↓↓↓ G_SCRIPT02 ↓↓↓> { // @function        Queues a new element in an array and de-queues its first element. f_qDq(_array, _val) =>     array.push(_array, _val)     _return = array.shift(_array)     _return var line  a_slLine     = array.new_line(1) var line  a_entryLine  = array.new_line(1) var line  a_tp3Line    = array.new_line(1) var line  a_tp2Line    = array.new_line(1) var line  a_tp1Line    = array.new_line(1) var label a_slLabel    = array.new_label(1) var label a_tp3label   = array.new_label(1) var label a_tp2label   = array.new_label(1) var label a_tp1label   = array.new_label(1) var label a_entryLabel = array.new_label(1) newEntry     = longE or shortE entryIndex   = 1 entryIndex  := newEntry ? bar_index : nz(entryIndex ) lasTrade     = bar_index >= entryIndex l_right      = 10 line.delete(   f_qDq(a_slLine,   line.new(    entryIndex,    slLine,    last_bar_index + l_right,    slLine,    style = line.style_solid,    color = c_sl))) line.delete(   f_qDq(a_entryLine,   line.new(    entryIndex,    entryLine,    last_bar_index + l_right,    entryLine,    style = line.style_solid,    color = color.blue))) line.delete(   f_qDq(a_tp3Line,   line.new(    entryIndex,    tp3Line,    last_bar_index + l_right,    tp3Line,    style = line.style_solid,    color = c_tp))) line.delete(   f_qDq(a_tp2Line,   line.new(    entryIndex,    tp2Line,    last_bar_index + l_right,    tp2Line,    style = line.style_solid,    color = c_tp))) line.delete(   f_qDq(a_tp1Line,   line.new(    entryIndex,    tp1Line,    last_bar_index + l_right,    tp1Line,    style = line.style_solid,    color = c_tp))) label.delete(   f_qDq(a_slLabel,   label.new(    last_bar_index + l_right,    slLine,    'SL: ' + str.tostring(slLine, '##.###'),    style = label.style_label_left,    textcolor  = color.white,    color = c_sl))) label.delete(   f_qDq(a_entryLabel,   label.new(    last_bar_index + l_right,    entryLine,    'Entry: ' + str.tostring(entryLine, '##.###'),    style = label.style_label_left,    textcolor  = color.white,    color = color.blue))) label.delete(   f_qDq(a_tp3label,   label.new(    last_bar_index + l_right,    tp3Line,    'TP3: ' + str.tostring(tp3Line, '##.###'),    style = label.style_label_left,    textcolor  = color.white,    color = c_tp))) label.delete(   f_qDq(a_tp2label,   label.new(    last_bar_index + l_right,    tp2Line,    'TP2: ' + str.tostring(tp2Line, '##.###'),    style = label.style_label_left,    textcolor  = color.white,    color = c_tp))) label.delete(   f_qDq(a_tp1label,   label.new(    last_bar_index + l_right,    tp1Line,    'TP1: ' + str.tostring(tp1Line, '##.###'),    style = label.style_label_left,    textcolor  = color.white,    color = c_tp))) // ——————————— // if longE or shortE or longX or shortX     alert(message = 'Any Alert',   freq = alert.freq_once_per_bar_close) if longE     alert(message = 'Long Entry',  freq = alert.freq_once_per_bar_close) if shortE     alert(message = 'Short Entry', freq = alert.freq_once_per_bar_close) if longX     alert(message = 'Long Exit',   freq = alert.freq_once_per_bar_close) if shortX     alert(message = 'Short Exit',  freq = alert.freq_once_per_bar_close) //#endregion } // ——————————— <↑↑↑ G_SCRIPT03 ↑↑↑>
อินดิเคเตอร์ Pine Script®
โดย asalya1690-90
1
USD Session 8FX - LDN & NY (TF-invariant, Live + Table)What it is A USD strength/weakness meter for the London (08:00–08:45) or New York (15:30–16:00/16:15) session. It blends the movement of 8 markets—EURUSD, GBPUSD, AUDUSD, NZDUSD, USDCHF, USDCAD, USDJPY, XAUUSD—into one Score that is timeframe-invariant (it uses a 1-minute “boundary TF” under the hood so changing chart TF doesn’t change the math). Core logic (simple) During the chosen session window, it records each symbol’s start and live end prices, computes returns, optionally normalizes by ATR (volatility), applies your weights, and averages anti-USD (EUR/GBP/AUD/NZD/XAU) vs USD-base (CHF/CAD/JPY) groups. The final Score is the normalized sum of weighted contributions: Score > 0 → “USD Strong” Score < 0 → “USD Weak” At the session close it freezes (“Locked”) the results so you can review them later. What you see Main plot: the USD Score line (with a 0 baseline). Optional lines: Anti-USD average vs USD-base average (post-normalization, pre-weights). Session background shading (London silver, New York aqua). Live table with: Each symbol’s % change, its weight, and its contribution to the Score. TOP badges for the two biggest drivers (by absolute contribution). A Side column (only for the two TOPs) showing BUY/SELL aligned with the USD verdict (e.g., if USD Strong → SELL anti-USD pairs like EURUSD, BUY USD-base like USDCHF). Verdict row with USD Strong/Weak, the Score value, the window text, and whether you’re LIVE / CLOSED / FROZEN. Trade Gate panel: Shows Verdict (USD Strong/Weak), Bias OK/weak (|Score| vs your threshold), Top-1/Top-2 VWAP checks, an overall GATE: OK/NO, and an Entry hint string (e.g., “SELL EURUSD, BUY USDCHF”) when conditions align. VWAP “Trade Gate” It confirms alignment between the USD bias and price vs VWAP for the top movers: If USD Strong: anti-USD symbols should be below VWAP (short bias), USD-base symbols above VWAP (long bias). If USD Weak: the opposite. Gate = OK only if |Score| ≥ minAbsScore and at least one of the two TOP symbols is on the correct side of VWAP. Tip: set vwapTF to an intraday value (“1”, “5”, “15”) for reliable VWAP on higher-TF charts. Alerts At session close: “USD Strong/Weak – session close”. Live threshold: alerts when |Score| crosses your intraday threshold up/down. Entry hint (Gate OK): triggers when the Gate flips from NO → OK inside the window. If you create an alert of type “Any alert() function call”, you also get a dynamic message like: ENTRY HINT • Hint: SELL EURUSD, BUY USDCHF Key inputs you can tweak Session: London vs New York; NY end time 16:00 or 16:15. Timezone: default Europe/Tirane. Boundary TF: default “1” (keeps the indicator TF-invariant). minAbsScore: sensitivity threshold for “Bias OK”. ATR normalization (len): stabilizes comparisons across different volatility regimes. VWAP settings: toggle panel and set vwapTF. How to use (playbook) Choose the session (e.g., New York 15:30–16:15), keep Boundary TF = 1. If you’re on a higher-TF chart, set vwapTF = "1" or "5". Watch Score and Verdict; when |Score| ≥ minAbsScore, bias is meaningful. Check Top-1/Top-2 and the Trade Gate: If Gate = OK, use the Entry hint (e.g., “SELL EURUSD, BUY USDCHF”) as the aligned idea. Use your own execution rules (e.g., structure, risk, stops) on the suggested symbols. After close, review the Frozen table to validate behavior and refine thresholds/weights. Notes & edge cases If some markets are illiquid/holiday, a few returns may be na; the script handles that gracefully. If ta.vwap is na on high TFs, the Gate will simply not confirm—set vwapTF intraday. You can customize weights (e.g., reduce XAUUSD to -0.3 or similar) to suit your basket philosophy. If you want, I can add toggles to show Side for all 8 symbols, or print a one-line summary (e.g., “USD Strong • Score 0.23 • Gate OK • SELL EURUSD, BUY USDCHF”) in the top-left of the pane.
อินดิเคเตอร์ Pine Script®
โดย salvatorepierro1989
Measured Pattern Move (Bulkowski) [SS]Hey everyone, This is the Measured Pattern Move using Bulkowski's process for measured move calculation. What the indicator does: The indicator has the associated measured move across 20 of the most common and frequent Bulkowski patterns, including: Double Bottom / Adam Eve Bottom Double Top / Adam Eve Top Inverse Head and Shoulders Bear Flag Bull Flag Horn Bottom Horon Top Broadening Top Descending Broadening Wedge Broadening Bottoms Broadening Tops Cup and Handle Inverted cup and handle Diamond Bottom Diamond Top Falling Wedge Rising Wedge Pipe Bottom Pipe Top Head and Shoulders It will calculate the measured move according to the Bulkowski process. What is the Bulkowski Process? Each move has an associated continuation percentage, which Bulkowski has studied, analyzed and concluded statistically. For example, Double tops have a continuation percent of 54%. Bear flags, 47%. These are "constants" that are associated with the pattern. Bulkowski applies them to the daily, but how I have formulated this, it can be used on all timeframes, and with the constant, it will correctly calculate the measured move of the pattern. What this indicator DOES NOT DO This indicator will not identify the pattern for you. I tried this using Dynamic Time Warping (DTW) using my own pre-trained Bulkowski model in R. I was successfully able to get Pinescript to calculate DTW which was amazing! But applying it to all these patterns actually went over the execution time limit, which is understandable. As such, you will need to identify the pattern yourself, then use this indicator to hilight the pattern and it will calculate the measured move based on the constant and the pattern range. Let's look at some examples: Use examples Double bottom / adam eve bottom on SPY on the 1-Minute chart Adam and Eve Double Bottom QQQ 1-Hour Chart Adam Eve Double Bottom MSFT Daily Chart Bearish Head and Shoulders Pattern MSFT Daily You get the point. How to use the indicator To use the indicator, identify the pattern of interest to you. Then, highlight the pattern using the indicator (it will ask you to select start time of the pattern and end time of the pattern). The indicator will then highlight the pattern and calculate the measured move, as seen in the examples above. Best approaches To make the most of the indicator, its best to draw out your pattern and wait for an actual break, the point of the break is usually the end of the pattern formation. From here, you will then apply this indicator to calculate the expected up or down move. Let me show you an example: Here we see CME_MINI:ES1! has made an Adam bottom pattern. We know the Eve should be forming soon and it indeed does: We mark the top of the pattern like so: Then we use our Measured move indicator to calculate the measured move: Measured move here for CME_MINI:ES1! is 6,510. Now let's see.... Voila! Selecting the Pattern After you highlight the selected pattern, in the indicator settings, simply select the type of pattern it is, for example "head and shoulders" or "Broadening wedge", etc. The indicator will then adjust its measurements to the appropriate constant and direction. Concluding remarks That is the indicator! It is helpful for determining the actual projected move of a pattern on breakout. Remember, it does not find the pattern for you , you are responsible for identifying the pattern. But this will calculate the actual TP of the pattern for you, without you having to do your own calculations. I hope you find it useful, I actually use this indicator every day, especially on the lower timeframes! And you will find, the more you use it, the better you get at recognizing significant patterns! If you are not aware of these patterns, Bulkowski lists all of this information freely accessible on his website. I cannot link it here but you can just Google him and he has graciously made his information public and free! That's it, I hope you enjoy and safe trades! Disclaimer This is not my intellectual property. The pattern calculations come from the work of Thomas Bulkowski and not myself. I simply coded this into an indicator using his publicly accessible information. You can get more information from Bulkowski's official website about his work and patterns.
อินดิเคเตอร์ Pine Script®
โดย Steversteves
1
MestreDoFOMO Future Projection BoxMestreDoFOMO Future Projection Box - Description & How to Use Description The "MestreDoFOMO Future Projection Box" is a TradingView indicator tailored for crypto traders (e.g., BTC/USDT on 1H, 4H, or 1D timeframes). It visualizes current price ranges, projects future levels, and confirms trends using semi-transparent boxes. With labeled price levels and built-in alerts, it’s a simple yet powerful tool for identifying support, resistance, and potential price targets. How It Works Blue Box (Current Channel): Shows the recent price range over the last 10 bars (adjustable). The top is the highest high plus an ATR buffer, and the bottom is the lowest low minus the buffer. Labels display exact levels (e.g., "Top: 114000", "Bottom: 102600"). Green Box (Future Projection): Projects the price range 10 bars ahead (adjustable) based on the trend slope of the moving average. Labels show "Proj Top" and "Proj Bottom" for future targets. Orange Box (Moving Average): Traces a 50-period EMA (adjustable) to confirm the trend. An upward slope signals a bullish trend; a downward slope signals a bearish trend. A label shows the current MA value (e.g., "MA: 105000"). Alerts: Triggers when the price nears the projected top or bottom, helping you catch breakouts or retracements. How to Use Add the Indicator: Apply "MestreDoFOMO Future Projection Box" to your chart in TradingView. Interpret the Trend: Check the orange box’s slope—upward for bullish, downward for bearish. Identify Key Levels: Use the blue box’s top as resistance and bottom as support. On a 4H chart, if the top is 114,000, expect resistance; if the bottom is 102,600, expect support. Plan Targets: Use the green box for future targets—top for profit-taking (e.g., 114,000), bottom for stop-loss or buying (e.g., 102,600). Set Alerts: Enable alerts for "Near Upper Projection" or "Near Lower Projection" to get notified when the price hits key levels. Trade Examples: Bullish: If the price breaks above the blue box top (e.g., 114,000), buy with a target at the green box top. Set a stop-loss below the green box bottom. Bearish: If the price rejects at the blue box top and drops below the orange MA, short with a target at the blue box bottom. Customize: Adjust the lookback period, projection bars, ATR multiplier, and MA length in the settings to fit your trading style. Tips Use on 1H for short-term trades, 4H for swing trades, or 1D for long-term trends. Combine with volume or RSI to confirm signals. Validate levels with market structure (e.g., candlestick patterns).
อินดิเคเตอร์ Pine Script®
โดย MestreDoFOMO
MVRVZ BTCMVRVZ BTC (Market Value to Realized Value Z-Score) Description: The MVRVZ BTC indicator provides insights into the relationship between the market value and realized value of Bitcoin, using the Market Value to Realized Value (MVRV) ratio, which is then adjusted using a Z-Score. This indicator highlights potential market extremes and helps in identifying overbought or oversold conditions, offering a unique perspective on Bitcoin's valuation. How It Works: MVRVZ is calculated by taking the difference between Bitcoin's Market Capitalization (MC) and Realized Capitalization (MCR), then dividing that by the Standard Deviation (Stdev) of the price over a specified period (usually 104 weeks). The resulting value is plotted as the MVRVZ line, representing how far the market price deviates from its realized value. Z-Score is then applied to the MVRVZ line, with the Z-Score bounded between +2 and -2, which allows it to be used within a consistent evaluation framework, regardless of how high or low the MVRVZ line goes. The Z-Score will reflect overbought or oversold conditions: A Z-Score above +2 indicates the market is likely overbought (possible market top). A Z-Score below -2 indicates the market is likely oversold (possible market bottom). Values between -2 and +2 indicate more neutral market conditions. How to Read the Indicator: MVRVZ Line: The MVRVZ line shows the relationship between market cap and realized cap. A higher value indicates the market is overvalued relative to the actual capital realized by holders. The MVRVZ line can move above or below the top and bottom lines you define, which are adjustable according to your preferences. These lines act as trigger levels. Top and Bottom Trigger Lines: You can customize the Top Line and Bottom Line values to your preference. When the MVRVZ line crosses the Top Line, the market might be considered overbought. When the MVRVZ line crosses the Bottom Line, the market might be considered oversold. SCDA Z-Score: The Z-Score is displayed alongside the MVRVZ line and is bounded between -2 and +2. It scales proportionally based on the MVRVZ line's position relative to the top and bottom trigger lines. The Z-Score ensures that even if the MVRVZ line moves beyond the trigger lines, the Z-Score will stay within the limits of -2 to +2, making it ideal for your custom evaluation system (SCDA). Background Highlighting: The background color changes when the MVRVZ line crosses key levels: When the MVRVZ line exceeds the Top Trigger, the background turns red, indicating overbought conditions. When the MVRVZ line falls below the Bottom Trigger, the background turns green, indicating oversold conditions. Data Sources: The data for the MVRVZ indicator is sourced from Glassnode and Coinmetrics, which provide the necessary values for: BTC Market Cap (MC) – The total market capitalization of Bitcoin. BTC Realized Market Cap (MCR) – The capitalization based on the price at which Bitcoin was last moved on the blockchain (realized value). How to Use the Indicator: Market Extremes: Use the MVRVZ and Z-Score to spot potential market tops or bottoms. A high Z-Score (above +2) suggests the market is overbought, while a low Z-Score (below -2) suggests the market is oversold. Adjusting the Triggers: Customize the Top and Bottom Trigger Lines to suit your trading strategy. These lines can act as dynamic reference points for when to take action based on the Z-Score or MVRVZ line crossing these levels. Market Evaluation (SCDA Framework): The bounded Z-Score (from -2 to +2) is tailored for your SCDA evaluation system, allowing you to assess market conditions based on consistent criteria, no matter how volatile the MVRVZ line becomes. Conclusion: The MVRVZ BTC indicator is a powerful tool for assessing the relative valuation of Bitcoin based on its market and realized capitalization. By combining it with the Z-Score, you get an easy-to-read, bounded evaluation system that highlights potential market extremes and helps you make informed decisions about Bitcoin's price behavior.
อินดิเคเตอร์ Pine Script®
โดย simonweisser_business
Drummond Geometry - Pldot and EnvelopeThis Pine Script will: 1.Calculate and display the PL Dot (Price Level Dot), a moving average that reflects short-term market trends. 2.Plot the Envelope Top and Bottom lines based on averages of previous highs and lows, which represent key areas of resistance and support. Drummond Geometry Overview Drummond Geometry is a method of market analysis focused on: PL Dot : Captures market energy and trend direction. It reacts to price deviations and serves as a magnet for price returns, often referred to as a "PL Dot Refresh." Envelope Theory : Considers price movements as cycles oscillating between the Envelope Top and Bottom. Prices breaking these boundaries often indicate trends, retracements, or exhaustion. The geometry helps traders visualize energy flows in the market and anticipate directional changes using established support and resistance zones. Understanding PL Dot and Envelope Top/Bottom PL Dot: Formula: Average(Average(H, L, C) of last three bars) Usage: Indicates short-term trends: Trend: PL Dot slopes upward or downward. Congestion: PL Dot moves horizontally. Envelope Top and Bottom: Formula: Top: (11 H1 + 11 H2 + 11 H3) / 3 Bottom: (11 L1 + 11 L2 + 11 L3) / 3 Usage: Acts as dynamic resistance and support: Price above the top: Indicates strong bullish momentum. Price below the bottom: Indicates strong bearish momentum. Advantages of Drummond Geometry Clarity of Market Flow: Highlights the relationship between price and key levels (PL Dot, Envelope Top/Bottom). Predictive Power: Suggests possible reversals or continuation based on energy distribution. Adaptability: Works across multiple time frames and market types (trending, congestion). Trading Strategy PL Dot Trades: Buy: When price returns to the PL Dot in an uptrend. Sell: When price returns to the PL Dot in a downtrend. Envelope Trades: Reversal: Trade counter to price if it breaks and retreats from the Envelope Top/Bottom. Continuation: Trade in the direction of price if it sustains movement beyond the Envelope Top/Bottom.
อินดิเคเตอร์ Pine Script®
โดย JordanMT
2
Bitcoin Cycle Master [InvestorUnknown]The "Bitcoin Cycle Master" indicator is designed for in-depth, long-term analysis of Bitcoin's price cycles, using several key metrics to track market behavior and forecast potential price tops and bottoms. The indicator integrates multiple moving averages and on-chain metrics, offering a comprehensive view of Bitcoin’s historical and projected performance. Each of its components plays a crucial role in identifying critical cycle points: Top Cap: This is a multiple of the Average Cap, which is calculated as the cumulative sum of Bitcoin’s price (price has a longer history than Market Cap) divided by its age in days. Top Cap serves as an upper boundary for speculative price peaks, multiplied by a factor of 35. Time_dif() => date = ta.valuewhen(bar_index == 0, time, 0) sec_r = math.floor(date / 1000) min_r = math.floor(sec_r / 60) h_r = math.floor(min_r / 60) d_r = math.floor(h_r / 24) // Launch of BTC start = timestamp(2009, 1, 3, 00, 00) sec_rb = math.floor(start / 1000) min_rb = math.floor(sec_rb / 60) h_rb = math.floor(min_rb / 60) d_rb = math.floor(h_rb / 24) difference = d_r - d_rb AverageCap() => ta.cum(btc_price) / (Time_dif() + btc_age) TopCap() => // To calculate Top Cap, it is first necessary to calculate Average Cap, which is the cumulative sum of Market Cap divided by the age of the market in days. // This creates a constant time-based moving average of market cap. // Once Average cap is calculated, those values are multiplied by 35. The result is Top Cap. // For AverageCap the BTC price was used instead of the MC because it has more history // (the result should have minimal if any deviation since MC would have to be divided by Supply) AverageCap() * 35 Delta Top: Defined as the difference between the Realized Cap and the Average Cap, this metric is further multiplied by a factor of 7. Delta Top provides a historically reliable signal for Bitcoin market cycle tops. DeltaTop() => // Delta Cap = Realized Cap - Average Cap // Average Cap is explained in the Top Cap section above. // Once Delta Cap is calculated, its values over time are then multiplied by 7. The result is Delta Top. (RealizedPrice() - AverageCap()) * 7 Terminal Price: Derived from Coin Days Destroyed, Terminal Price normalizes Bitcoin’s historical price behavior by its finite supply (21 million bitcoins), offering an adjusted price forecast as all bitcoins approach being mined. The original formula for Terminal Price didn’t produce expected results, hence the calculation was adjusted slightly. CVDD() => // CVDD stands for Cumulative Value Coin Days Destroyed. // Coin Days Destroyed is a term used for bitcoin to identify a value of sorts to UTXO’s (unspent transaction outputs). They can be thought of as coins moving between wallets. (MCR - TV) / 21000000 TerminalPrice() => // Theory: // Before Terminal price is calculated, it is first necessary to calculate Transferred Price. // Transferred price takes the sum of > Coin Days Destroyed and divides it by the existing supply of bitcoin and the time it has been in circulation. // The value of Transferred Price is then multiplied by 21. Remember that there can only ever be 21 million bitcoin mined. // This creates a 'terminal' value as the supply is all mined, a kind of reverse supply adjustment. // Instead of heavily weighting later behavior, it normalizes historical behavior to today. By normalizing by 21, a terminal value is created // Unfortunately the theoretical calculation didn't produce results it should, in pinescript. // Therefore the calculation was slightly adjusted/improvised TransferredPrice = CVDD() / (Supply * math.log(btc_age)) tp = TransferredPrice * 210000000 * 3 Realized Price: Calculated as the Market Cap Realized divided by the current supply of Bitcoin, this metric shows the average value of Bitcoin based on the price at which coins last moved, giving a market consensus price for long-term holders. CVDD (Cumulative Value Coin Days Destroyed): This on-chain metric analyzes Bitcoin’s UTXOs (unspent transaction outputs) and the velocity of coins moving between wallets. It highlights key market dynamics during prolonged accumulation or distribution phases. Balanced Price: The Balanced Price is the difference between the Realized Price and the Terminal Price, adjusted by Bitcoin's supply constraints. This metric provides a useful signal for identifying oversold market conditions during bear markets. BalancedPrice() => // It is calculated by subtracting Transferred Price from Realized Price RealizedPrice() - (TerminalPrice() / (21 * 3)) Each component can be toggled individually, allowing users to focus on specific aspects of Bitcoin’s price cycle and derive meaningful insights from its long-term behavior. The combination of these models provides a well-rounded view of both speculative peaks and long-term value trends. Important consideration: Top Cap did historically provide reliable signals for cycle peaks, however it may not be a relevant indication of peaks in the future.
อินดิเคเตอร์ Pine Script®
โดย InvestorUnknown
5
Goertzel Browser [Loxx]As the financial markets become increasingly complex and data-driven, traders and analysts must leverage powerful tools to gain insights and make informed decisions. One such tool is the Goertzel Browser indicator, a sophisticated technical analysis indicator that helps identify cyclical patterns in financial data. This powerful tool is capable of detecting cyclical patterns in financial data, helping traders to make better predictions and optimize their trading strategies. With its unique combination of mathematical algorithms and advanced charting capabilities, this indicator has the potential to revolutionize the way we approach financial modeling and trading. █ Brief Overview of the Goertzel Browser The Goertzel Browser is a sophisticated technical analysis tool that utilizes the Goertzel algorithm to analyze and visualize cyclical components within a financial time series. By identifying these cycles and their characteristics, the indicator aims to provide valuable insights into the market's underlying price movements, which could potentially be used for making informed trading decisions. The primary purpose of this indicator is to: 1. Detect and analyze the dominant cycles present in the price data. 2. Reconstruct and visualize the composite wave based on the detected cycles. 3. Project the composite wave into the future, providing a potential roadmap for upcoming price movements. To achieve this, the indicator performs several tasks: 1. Detrending the price data: The indicator preprocesses the price data using various detrending techniques, such as Hodrick-Prescott filters, zero-lag moving averages, and linear regression, to remove the underlying trend and focus on the cyclical components. 2. Applying the Goertzel algorithm: The indicator applies the Goertzel algorithm to the detrended price data, identifying the dominant cycles and their characteristics, such as amplitude, phase, and cycle strength. 3. Constructing the composite wave: The indicator reconstructs the composite wave by combining the detected cycles, either by using a user-defined list of cycles or by selecting the top N cycles based on their amplitude or cycle strength. 4. Visualizing the composite wave: The indicator plots the composite wave, using solid lines for the past and dotted lines for the future projections. The color of the lines indicates whether the wave is increasing or decreasing. 5. Displaying cycle information: The indicator provides a table that displays detailed information about the detected cycles, including their rank, period, Bartel's test results, amplitude, and phase. This indicator is a powerful tool that employs the Goertzel algorithm to analyze and visualize the cyclical components within a financial time series. By providing insights into the underlying price movements and their potential future trajectory, the indicator aims to assist traders in making more informed decisions. █ What is the Goertzel Algorithm? The Goertzel algorithm, named after Gerald Goertzel, is a digital signal processing technique that is used to efficiently compute individual terms of the Discrete Fourier Transform (DFT). It was first introduced in 1958, and since then, it has found various applications in the fields of engineering, mathematics, and physics. The Goertzel algorithm is primarily used to detect specific frequency components within a digital signal, making it particularly useful in applications where only a few frequency components are of interest. The algorithm is computationally efficient, as it requires fewer calculations than the Fast Fourier Transform (FFT) when detecting a small number of frequency components. This efficiency makes the Goertzel algorithm a popular choice in applications such as: 1. Telecommunications: The Goertzel algorithm is used for decoding Dual-Tone Multi-Frequency (DTMF) signals, which are the tones generated when pressing buttons on a telephone keypad. By identifying specific frequency components, the algorithm can accurately determine which button has been pressed. 2. Audio processing: The algorithm can be used to detect specific pitches or harmonics in an audio signal, making it useful in applications like pitch detection and tuning musical instruments. 3. Vibration analysis: In the field of mechanical engineering, the Goertzel algorithm can be applied to analyze vibrations in rotating machinery, helping to identify faulty components or signs of wear. 4. Power system analysis: The algorithm can be used to measure harmonic content in power systems, allowing engineers to assess power quality and detect potential issues. The Goertzel algorithm is used in these applications because it offers several advantages over other methods, such as the FFT: 1. Computational efficiency: The Goertzel algorithm requires fewer calculations when detecting a small number of frequency components, making it more computationally efficient than the FFT in these cases. 2. Real-time analysis: The algorithm can be implemented in a streaming fashion, allowing for real-time analysis of signals, which is crucial in applications like telecommunications and audio processing. 3. Memory efficiency: The Goertzel algorithm requires less memory than the FFT, as it only computes the frequency components of interest. 4. Precision: The algorithm is less susceptible to numerical errors compared to the FFT, ensuring more accurate results in applications where precision is essential. The Goertzel algorithm is an efficient digital signal processing technique that is primarily used to detect specific frequency components within a signal. Its computational efficiency, real-time capabilities, and precision make it an attractive choice for various applications, including telecommunications, audio processing, vibration analysis, and power system analysis. The algorithm has been widely adopted since its introduction in 1958 and continues to be an essential tool in the fields of engineering, mathematics, and physics. █ Goertzel Algorithm in Quantitative Finance: In-Depth Analysis and Applications The Goertzel algorithm, initially designed for signal processing in telecommunications, has gained significant traction in the financial industry due to its efficient frequency detection capabilities. In quantitative finance, the Goertzel algorithm has been utilized for uncovering hidden market cycles, developing data-driven trading strategies, and optimizing risk management. This section delves deeper into the applications of the Goertzel algorithm in finance, particularly within the context of quantitative trading and analysis. Unveiling Hidden Market Cycles: Market cycles are prevalent in financial markets and arise from various factors, such as economic conditions, investor psychology, and market participant behavior. The Goertzel algorithm's ability to detect and isolate specific frequencies in price data helps trader analysts identify hidden market cycles that may otherwise go unnoticed. By examining the amplitude, phase, and periodicity of each cycle, traders can better understand the underlying market structure and dynamics, enabling them to develop more informed and effective trading strategies. Developing Quantitative Trading Strategies: The Goertzel algorithm's versatility allows traders to incorporate its insights into a wide range of trading strategies. By identifying the dominant market cycles in a financial instrument's price data, traders can create data-driven strategies that capitalize on the cyclical nature of markets. For instance, a trader may develop a mean-reversion strategy that takes advantage of the identified cycles. By establishing positions when the price deviates from the predicted cycle, the trader can profit from the subsequent reversion to the cycle's mean. Similarly, a momentum-based strategy could be designed to exploit the persistence of a dominant cycle by entering positions that align with the cycle's direction. Enhancing Risk Management: The Goertzel algorithm plays a vital role in risk management for quantitative strategies. By analyzing the cyclical components of a financial instrument's price data, traders can gain insights into the potential risks associated with their trading strategies. By monitoring the amplitude and phase of dominant cycles, a trader can detect changes in market dynamics that may pose risks to their positions. For example, a sudden increase in amplitude may indicate heightened volatility, prompting the trader to adjust position sizing or employ hedging techniques to protect their portfolio. Additionally, changes in phase alignment could signal a potential shift in market sentiment, necessitating adjustments to the trading strategy. Expanding Quantitative Toolkits: Traders can augment the Goertzel algorithm's insights by combining it with other quantitative techniques, creating a more comprehensive and sophisticated analysis framework. For example, machine learning algorithms, such as neural networks or support vector machines, could be trained on features extracted from the Goertzel algorithm to predict future price movements more accurately. Furthermore, the Goertzel algorithm can be integrated with other technical analysis tools, such as moving averages or oscillators, to enhance their effectiveness. By applying these tools to the identified cycles, traders can generate more robust and reliable trading signals. The Goertzel algorithm offers invaluable benefits to quantitative finance practitioners by uncovering hidden market cycles, aiding in the development of data-driven trading strategies, and improving risk management. By leveraging the insights provided by the Goertzel algorithm and integrating it with other quantitative techniques, traders can gain a deeper understanding of market dynamics and devise more effective trading strategies. █ Indicator Inputs src: This is the source data for the analysis, typically the closing price of the financial instrument. detrendornot: This input determines the method used for detrending the source data. Detrending is the process of removing the underlying trend from the data to focus on the cyclical components. The available options are: hpsmthdt: Detrend using Hodrick-Prescott filter centered moving average. zlagsmthdt: Detrend using zero-lag moving average centered moving average. logZlagRegression: Detrend using logarithmic zero-lag linear regression. hpsmth: Detrend using Hodrick-Prescott filter. zlagsmth: Detrend using zero-lag moving average. DT_HPper1 and DT_HPper2: These inputs define the period range for the Hodrick-Prescott filter centered moving average when detrendornot is set to hpsmthdt. DT_ZLper1 and DT_ZLper2: These inputs define the period range for the zero-lag moving average centered moving average when detrendornot is set to zlagsmthdt. DT_RegZLsmoothPer: This input defines the period for the zero-lag moving average used in logarithmic zero-lag linear regression when detrendornot is set to logZlagRegression. HPsmoothPer: This input defines the period for the Hodrick-Prescott filter when detrendornot is set to hpsmth. ZLMAsmoothPer: This input defines the period for the zero-lag moving average when detrendornot is set to zlagsmth. MaxPer: This input sets the maximum period for the Goertzel algorithm to search for cycles. squaredAmp: This boolean input determines whether the amplitude should be squared in the Goertzel algorithm. useAddition: This boolean input determines whether the Goertzel algorithm should use addition for combining the cycles. useCosine: This boolean input determines whether the Goertzel algorithm should use cosine waves instead of sine waves. UseCycleStrength: This boolean input determines whether the Goertzel algorithm should compute the cycle strength, which is a normalized measure of the cycle's amplitude. WindowSizePast and WindowSizeFuture: These inputs define the window size for past and future projections of the composite wave. FilterBartels: This boolean input determines whether Bartel's test should be applied to filter out non-significant cycles. BartNoCycles: This input sets the number of cycles to be used in Bartel's test. BartSmoothPer: This input sets the period for the moving average used in Bartel's test. BartSigLimit: This input sets the significance limit for Bartel's test, below which cycles are considered insignificant. SortBartels: This boolean input determines whether the cycles should be sorted by their Bartel's test results. UseCycleList: This boolean input determines whether a user-defined list of cycles should be used for constructing the composite wave. If set to false, the top N cycles will be used. Cycle1, Cycle2, Cycle3, Cycle4, and Cycle5: These inputs define the user-defined list of cycles when 'UseCycleList' is set to true. If using a user-defined list, each of these inputs represents the period of a specific cycle to include in the composite wave. StartAtCycle: This input determines the starting index for selecting the top N cycles when UseCycleList is set to false. This allows you to skip a certain number of cycles from the top before selecting the desired number of cycles. UseTopCycles: This input sets the number of top cycles to use for constructing the composite wave when UseCycleList is set to false. The cycles are ranked based on their amplitudes or cycle strengths, depending on the UseCycleStrength input. SubtractNoise: This boolean input determines whether to subtract the noise (remaining cycles) from the composite wave. If set to true, the composite wave will only include the top N cycles specified by UseTopCycles. █ Exploring Auxiliary Functions The following functions demonstrate advanced techniques for analyzing financial markets, including zero-lag moving averages, Bartels probability, detrending, and Hodrick-Prescott filtering. This section examines each function in detail, explaining their purpose, methodology, and applications in finance. We will examine how each function contributes to the overall performance and effectiveness of the indicator and how they work together to create a powerful analytical tool. Zero-Lag Moving Average: The zero-lag moving average function is designed to minimize the lag typically associated with moving averages. This is achieved through a two-step weighted linear regression process that emphasizes more recent data points. The function calculates a linearly weighted moving average (LWMA) on the input data and then applies another LWMA on the result. By doing this, the function creates a moving average that closely follows the price action, reducing the lag and improving the responsiveness of the indicator. The zero-lag moving average function is used in the indicator to provide a responsive, low-lag smoothing of the input data. This function helps reduce the noise and fluctuations in the data, making it easier to identify and analyze underlying trends and patterns. By minimizing the lag associated with traditional moving averages, this function allows the indicator to react more quickly to changes in market conditions, providing timely signals and improving the overall effectiveness of the indicator. Bartels Probability: The Bartels probability function calculates the probability of a given cycle being significant in a time series. It uses a mathematical test called the Bartels test to assess the significance of cycles detected in the data. The function calculates coefficients for each detected cycle and computes an average amplitude and an expected amplitude. By comparing these values, the Bartels probability is derived, indicating the likelihood of a cycle's significance. This information can help in identifying and analyzing dominant cycles in financial markets. The Bartels probability function is incorporated into the indicator to assess the significance of detected cycles in the input data. By calculating the Bartels probability for each cycle, the indicator can prioritize the most significant cycles and focus on the market dynamics that are most relevant to the current trading environment. This function enhances the indicator's ability to identify dominant market cycles, improving its predictive power and aiding in the development of effective trading strategies. Detrend Logarithmic Zero-Lag Regression: The detrend logarithmic zero-lag regression function is used for detrending data while minimizing lag. It combines a zero-lag moving average with a linear regression detrending method. The function first calculates the zero-lag moving average of the logarithm of input data and then applies a linear regression to remove the trend. By detrending the data, the function isolates the cyclical components, making it easier to analyze and interpret the underlying market dynamics. The detrend logarithmic zero-lag regression function is used in the indicator to isolate the cyclical components of the input data. By detrending the data, the function enables the indicator to focus on the cyclical movements in the market, making it easier to analyze and interpret market dynamics. This function is essential for identifying cyclical patterns and understanding the interactions between different market cycles, which can inform trading decisions and enhance overall market understanding. Bartels Cycle Significance Test: The Bartels cycle significance test is a function that combines the Bartels probability function and the detrend logarithmic zero-lag regression function to assess the significance of detected cycles. The function calculates the Bartels probability for each cycle and stores the results in an array. By analyzing the probability values, traders and analysts can identify the most significant cycles in the data, which can be used to develop trading strategies and improve market understanding. The Bartels cycle significance test function is integrated into the indicator to provide a comprehensive analysis of the significance of detected cycles. By combining the Bartels probability function and the detrend logarithmic zero-lag regression function, this test evaluates the significance of each cycle and stores the results in an array. The indicator can then use this information to prioritize the most significant cycles and focus on the most relevant market dynamics. This function enhances the indicator's ability to identify and analyze dominant market cycles, providing valuable insights for trading and market analysis. Hodrick-Prescott Filter: The Hodrick-Prescott filter is a popular technique used to separate the trend and cyclical components of a time series. The function applies a smoothing parameter to the input data and calculates a smoothed series using a two-sided filter. This smoothed series represents the trend component, which can be subtracted from the original data to obtain the cyclical component. The Hodrick-Prescott filter is commonly used in economics and finance to analyze economic data and financial market trends. The Hodrick-Prescott filter is incorporated into the indicator to separate the trend and cyclical components of the input data. By applying the filter to the data, the indicator can isolate the trend component, which can be used to analyze long-term market trends and inform trading decisions. Additionally, the cyclical component can be used to identify shorter-term market dynamics and provide insights into potential trading opportunities. The inclusion of the Hodrick-Prescott filter adds another layer of analysis to the indicator, making it more versatile and comprehensive. Detrending Options: Detrend Centered Moving Average: The detrend centered moving average function provides different detrending methods, including the Hodrick-Prescott filter and the zero-lag moving average, based on the selected detrending method. The function calculates two sets of smoothed values using the chosen method and subtracts one set from the other to obtain a detrended series. By offering multiple detrending options, this function allows traders and analysts to select the most appropriate method for their specific needs and preferences. The detrend centered moving average function is integrated into the indicator to provide users with multiple detrending options, including the Hodrick-Prescott filter and the zero-lag moving average. By offering multiple detrending methods, the indicator allows users to customize the analysis to their specific needs and preferences, enhancing the indicator's overall utility and adaptability. This function ensures that the indicator can cater to a wide range of trading styles and objectives, making it a valuable tool for a diverse group of market participants. The auxiliary functions functions discussed in this section demonstrate the power and versatility of mathematical techniques in analyzing financial markets. By understanding and implementing these functions, traders and analysts can gain valuable insights into market dynamics, improve their trading strategies, and make more informed decisions. The combination of zero-lag moving averages, Bartels probability, detrending methods, and the Hodrick-Prescott filter provides a comprehensive toolkit for analyzing and interpreting financial data. The integration of advanced functions in a financial indicator creates a powerful and versatile analytical tool that can provide valuable insights into financial markets. By combining the zero-lag moving average, █ In-Depth Analysis of the Goertzel Browser Code The Goertzel Browser code is an implementation of the Goertzel Algorithm, an efficient technique to perform spectral analysis on a signal. The code is designed to detect and analyze dominant cycles within a given financial market data set. This section will provide an extremely detailed explanation of the code, its structure, functions, and intended purpose. Function signature and input parameters: The Goertzel Browser function accepts numerous input parameters for customization, including source data (src), the current bar (forBar), sample size (samplesize), period (per), squared amplitude flag (squaredAmp), addition flag (useAddition), cosine flag (useCosine), cycle strength flag (UseCycleStrength), past and future window sizes (WindowSizePast, WindowSizeFuture), Bartels filter flag (FilterBartels), Bartels-related parameters (BartNoCycles, BartSmoothPer, BartSigLimit), sorting flag (SortBartels), and output buffers (goeWorkPast, goeWorkFuture, cyclebuffer, amplitudebuffer, phasebuffer, cycleBartelsBuffer). Initializing variables and arrays: The code initializes several float arrays (goeWork1, goeWork2, goeWork3, goeWork4) with the same length as twice the period (2 * per). These arrays store intermediate results during the execution of the algorithm. Preprocessing input data: The input data (src) undergoes preprocessing to remove linear trends. This step enhances the algorithm's ability to focus on cyclical components in the data. The linear trend is calculated by finding the slope between the first and last values of the input data within the sample. Iterative calculation of Goertzel coefficients: The core of the Goertzel Browser algorithm lies in the iterative calculation of Goertzel coefficients for each frequency bin. These coefficients represent the spectral content of the input data at different frequencies. The code iterates through the range of frequencies, calculating the Goertzel coefficients using a nested loop structure. Cycle strength computation: The code calculates the cycle strength based on the Goertzel coefficients. This is an optional step, controlled by the UseCycleStrength flag. The cycle strength provides information on the relative influence of each cycle on the data per bar, considering both amplitude and cycle length. The algorithm computes the cycle strength either by squaring the amplitude (controlled by squaredAmp flag) or using the actual amplitude values. Phase calculation: The Goertzel Browser code computes the phase of each cycle, which represents the position of the cycle within the input data. The phase is calculated using the arctangent function (math.atan) based on the ratio of the imaginary and real components of the Goertzel coefficients. Peak detection and cycle extraction: The algorithm performs peak detection on the computed amplitudes or cycle strengths to identify dominant cycles. It stores the detected cycles in the cyclebuffer array, along with their corresponding amplitudes and phases in the amplitudebuffer and phasebuffer arrays, respectively. Sorting cycles by amplitude or cycle strength: The code sorts the detected cycles based on their amplitude or cycle strength in descending order. This allows the algorithm to prioritize cycles with the most significant impact on the input data. Bartels cycle significance test: If the FilterBartels flag is set, the code performs a Bartels cycle significance test on the detected cycles. This test determines the statistical significance of each cycle and filters out the insignificant cycles. The significant cycles are stored in the cycleBartelsBuffer array. If the SortBartels flag is set, the code sorts the significant cycles based on their Bartels significance values. Waveform calculation: The Goertzel Browser code calculates the waveform of the significant cycles for both past and future time windows. The past and future windows are defined by the WindowSizePast and WindowSizeFuture parameters, respectively. The algorithm uses either cosine or sine functions (controlled by the useCosine flag) to calculate the waveforms for each cycle. The useAddition flag determines whether the waveforms should be added or subtracted. Storing waveforms in matrices: The calculated waveforms for each cycle are stored in two matrices - goeWorkPast and goeWorkFuture. These matrices hold the waveforms for the past and future time windows, respectively. Each row in the matrices represents a time window position, and each column corresponds to a cycle. Returning the number of cycles: The Goertzel Browser function returns the total number of detected cycles (number_of_cycles) after processing the input data. This information can be used to further analyze the results or to visualize the detected cycles. The Goertzel Browser code is a comprehensive implementation of the Goertzel Algorithm, specifically designed for detecting and analyzing dominant cycles within financial market data. The code offers a high level of customization, allowing users to fine-tune the algorithm based on their specific needs. The Goertzel Browser's combination of preprocessing, iterative calculations, cycle extraction, sorting, significance testing, and waveform calculation makes it a powerful tool for understanding cyclical components in financial data. █ Generating and Visualizing Composite Waveform The indicator calculates and visualizes the composite waveform for both past and future time windows based on the detected cycles. Here's a detailed explanation of this process: Updating WindowSizePast and WindowSizeFuture: The WindowSizePast and WindowSizeFuture are updated to ensure they are at least twice the MaxPer (maximum period). Initializing matrices and arrays: Two matrices, goeWorkPast and goeWorkFuture, are initialized to store the Goertzel results for past and future time windows. Multiple arrays are also initialized to store cycle, amplitude, phase, and Bartels information. Preparing the source data (srcVal) array: The source data is copied into an array, srcVal, and detrended using one of the selected methods (hpsmthdt, zlagsmthdt, logZlagRegression, hpsmth, or zlagsmth). Goertzel function call: The Goertzel function is called to analyze the detrended source data and extract cycle information. The output, number_of_cycles, contains the number of detected cycles. Initializing arrays for past and future waveforms: Three arrays, epgoertzel, goertzel, and goertzelFuture, are initialized to store the endpoint Goertzel, non-endpoint Goertzel, and future Goertzel projections, respectively. Calculating composite waveform for past bars (goertzel array): The past composite waveform is calculated by summing the selected cycles (either from the user-defined cycle list or the top cycles) and optionally subtracting the noise component. Calculating composite waveform for future bars (goertzelFuture array): The future composite waveform is calculated in a similar way as the past composite waveform. Drawing past composite waveform (pvlines): The past composite waveform is drawn on the chart using solid lines. The color of the lines is determined by the direction of the waveform (green for upward, red for downward). Drawing future composite waveform (fvlines): The future composite waveform is drawn on the chart using dotted lines. The color of the lines is determined by the direction of the waveform (fuchsia for upward, yellow for downward). Displaying cycle information in a table (table3): A table is created to display the cycle information, including the rank, period, Bartel value, amplitude (or cycle strength), and phase of each detected cycle. Filling the table with cycle information: The indicator iterates through the detected cycles and retrieves the relevant information (period, amplitude, phase, and Bartel value) from the corresponding arrays. It then fills the table with this information, displaying the values up to six decimal places. To summarize, this indicator generates a composite waveform based on the detected cycles in the financial data. It calculates the composite waveforms for both past and future time windows and visualizes them on the chart using colored lines. Additionally, it displays detailed cycle information in a table, including the rank, period, Bartel value, amplitude (or cycle strength), and phase of each detected cycle. █ Enhancing the Goertzel Algorithm-Based Script for Financial Modeling and Trading The Goertzel algorithm-based script for detecting dominant cycles in financial data is a powerful tool for financial modeling and trading. It provides valuable insights into the past behavior of these cycles and potential future impact. However, as with any algorithm, there is always room for improvement. This section discusses potential enhancements to the existing script to make it even more robust and versatile for financial modeling, general trading, advanced trading, and high-frequency finance trading. Enhancements for Financial Modeling Data preprocessing: One way to improve the script's performance for financial modeling is to introduce more advanced data preprocessing techniques. This could include removing outliers, handling missing data, and normalizing the data to ensure consistent and accurate results. Additional detrending and smoothing methods: Incorporating more sophisticated detrending and smoothing techniques, such as wavelet transform or empirical mode decomposition, can help improve the script's ability to accurately identify cycles and trends in the data. Machine learning integration: Integrating machine learning techniques, such as artificial neural networks or support vector machines, can help enhance the script's predictive capabilities, leading to more accurate financial models. Enhancements for General and Advanced Trading Customizable indicator integration: Allowing users to integrate their own technical indicators can help improve the script's effectiveness for both general and advanced trading. By enabling the combination of the dominant cycle information with other technical analysis tools, traders can develop more comprehensive trading strategies. Risk management and position sizing: Incorporating risk management and position sizing functionality into the script can help traders better manage their trades and control potential losses. This can be achieved by calculating the optimal position size based on the user's risk tolerance and account size. Multi-timeframe analysis: Enhancing the script to perform multi-timeframe analysis can provide traders with a more holistic view of market trends and cycles. By identifying dominant cycles on different timeframes, traders can gain insights into the potential confluence of cycles and make better-informed trading decisions. Enhancements for High-Frequency Finance Trading Algorithm optimization: To ensure the script's suitability for high-frequency finance trading, optimizing the algorithm for faster execution is crucial. This can be achieved by employing efficient data structures and refining the calculation methods to minimize computational complexity. Real-time data streaming: Integrating real-time data streaming capabilities into the script can help high-frequency traders react to market changes more quickly. By continuously updating the cycle information based on real-time market data, traders can adapt their strategies accordingly and capitalize on short-term market fluctuations. Order execution and trade management: To fully leverage the script's capabilities for high-frequency trading, implementing functionality for automated order execution and trade management is essential. This can include features such as stop-loss and take-profit orders, trailing stops, and automated trade exit strategies. While the existing Goertzel algorithm-based script is a valuable tool for detecting dominant cycles in financial data, there are several potential enhancements that can make it even more powerful for financial modeling, general trading, advanced trading, and high-frequency finance trading. By incorporating these improvements, the script can become a more versatile and effective tool for traders and financial analysts alike. █ Understanding the Limitations of the Goertzel Algorithm While the Goertzel algorithm-based script for detecting dominant cycles in financial data provides valuable insights, it is important to be aware of its limitations and drawbacks. Some of the key drawbacks of this indicator are: Lagging nature: As with many other technical indicators, the Goertzel algorithm-based script can suffer from lagging effects, meaning that it may not immediately react to real-time market changes. This lag can lead to late entries and exits, potentially resulting in reduced profitability or increased losses. Parameter sensitivity: The performance of the script can be sensitive to the chosen parameters, such as the detrending methods, smoothing techniques, and cycle detection settings. Improper parameter selection may lead to inaccurate cycle detection or increased false signals, which can negatively impact trading performance. Complexity: The Goertzel algorithm itself is relatively complex, making it difficult for novice traders or those unfamiliar with the concept of cycle analysis to fully understand and effectively utilize the script. This complexity can also make it challenging to optimize the script for specific trading styles or market conditions. Overfitting risk: As with any data-driven approach, there is a risk of overfitting when using the Goertzel algorithm-based script. Overfitting occurs when a model becomes too specific to the historical data it was trained on, leading to poor performance on new, unseen data. This can result in misleading signals and reduced trading performance. No guarantee of future performance: While the script can provide insights into past cycles and potential future trends, it is important to remember that past performance does not guarantee future results. Market conditions can change, and relying solely on the script's predictions without considering other factors may lead to poor trading decisions. Limited applicability: The Goertzel algorithm-based script may not be suitable for all markets, trading styles, or timeframes. Its effectiveness in detecting cycles may be limited in certain market conditions, such as during periods of extreme volatility or low liquidity. While the Goertzel algorithm-based script offers valuable insights into dominant cycles in financial data, it is essential to consider its drawbacks and limitations when incorporating it into a trading strategy. Traders should always use the script in conjunction with other technical and fundamental analysis tools, as well as proper risk management, to make well-informed trading decisions. █ Interpreting Results The Goertzel Browser indicator can be interpreted by analyzing the plotted lines and the table presented alongside them. The indicator plots two lines: past and future composite waves. The past composite wave represents the composite wave of the past price data, and the future composite wave represents the projected composite wave for the next period. The past composite wave line displays a solid line, with green indicating a bullish trend and red indicating a bearish trend. On the other hand, the future composite wave line is a dotted line with fuchsia indicating a bullish trend and yellow indicating a bearish trend. The table presented alongside the indicator shows the top cycles with their corresponding rank, period, Bartels, amplitude or cycle strength, and phase. The amplitude is a measure of the strength of the cycle, while the phase is the position of the cycle within the data series. Interpreting the Goertzel Browser indicator involves identifying the trend of the past and future composite wave lines and matching them with the corresponding bullish or bearish color. Additionally, traders can identify the top cycles with the highest amplitude or cycle strength and utilize them in conjunction with other technical indicators and fundamental analysis for trading decisions. This indicator is considered a repainting indicator because the value of the indicator is calculated based on the past price data. As new price data becomes available, the indicator's value is recalculated, potentially causing the indicator's past values to change. This can create a false impression of the indicator's performance, as it may appear to have provided a profitable trading signal in the past when, in fact, that signal did not exist at the time. The Goertzel indicator is also non-endpointed, meaning that it is not calculated up to the current bar or candle. Instead, it uses a fixed amount of historical data to calculate its values, which can make it difficult to use for real-time trading decisions. For example, if the indicator uses 100 bars of historical data to make its calculations, it cannot provide a signal until the current bar has closed and become part of the historical data. This can result in missed trading opportunities or delayed signals. █ Conclusion The Goertzel Browser indicator is a powerful tool for identifying and analyzing cyclical patterns in financial markets. Its ability to detect multiple cycles of varying frequencies and strengths make it a valuable addition to any trader's technical analysis toolkit. However, it is important to keep in mind that the Goertzel Browser indicator should be used in conjunction with other technical analysis tools and fundamental analysis to achieve the best results. With continued refinement and development, the Goertzel Browser indicator has the potential to become a highly effective tool for financial modeling, general trading, advanced trading, and high-frequency finance trading. Its accuracy and versatility make it a promising candidate for further research and development. █ Footnotes What is the Bartels Test for Cycle Significance? The Bartels Cycle Significance Test is a statistical method that determines whether the peaks and troughs of a time series are statistically significant. The test is named after its inventor, George Bartels, who developed it in the mid-20th century. The Bartels test is designed to analyze the cyclical components of a time series, which can help traders and analysts identify trends and cycles in financial markets. The test calculates a Bartels statistic, which measures the degree of non-randomness or autocorrelation in the time series. The Bartels statistic is calculated by first splitting the time series into two halves and calculating the range of the peaks and troughs in each half. The test then compares these ranges using a t-test, which measures the significance of the difference between the two ranges. If the Bartels statistic is greater than a critical value, it indicates that the peaks and troughs in the time series are non-random and that there is a significant cyclical component to the data. Conversely, if the Bartels statistic is less than the critical value, it suggests that the peaks and troughs are random and that there is no significant cyclical component. The Bartels Cycle Significance Test is particularly useful in financial analysis because it can help traders and analysts identify significant cycles in asset prices, which can in turn inform investment decisions. However, it is important to note that the test is not perfect and can produce false signals in certain situations, particularly in noisy or volatile markets. Therefore, it is always recommended to use the test in conjunction with other technical and fundamental indicators to confirm trends and cycles. Deep-dive into the Hodrick-Prescott Fitler The Hodrick-Prescott (HP) filter is a statistical tool used in economics and finance to separate a time series into two components: a trend component and a cyclical component. It is a powerful tool for identifying long-term trends in economic and financial data and is widely used by economists, central banks, and financial institutions around the world. The HP filter was first introduced in the 1990s by economists Robert Hodrick and Edward Prescott. It is a simple, two-parameter filter that separates a time series into a trend component and a cyclical component. The trend component represents the long-term behavior of the data, while the cyclical component captures the shorter-term fluctuations around the trend. The HP filter works by minimizing the following objective function: Minimize: (Sum of Squared Deviations) + λ (Sum of Squared Second Differences) Where: The first term represents the deviation of the data from the trend. The second term represents the smoothness of the trend. λ is a smoothing parameter that determines the degree of smoothness of the trend. The smoothing parameter λ is typically set to a value between 100 and 1600, depending on the frequency of the data. Higher values of λ lead to a smoother trend, while lower values lead to a more volatile trend. The HP filter has several advantages over other smoothing techniques. It is a non-parametric method, meaning that it does not make any assumptions about the underlying distribution of the data. It also allows for easy comparison of trends across different time series and can be used with data of any frequency. However, the HP filter also has some limitations. It assumes that the trend is a smooth function, which may not be the case in some situations. It can also be sensitive to changes in the smoothing parameter λ, which may result in different trends for the same data. Additionally, the filter may produce unrealistic trends for very short time series. Despite these limitations, the HP filter remains a valuable tool for analyzing economic and financial data. It is widely used by central banks and financial institutions to monitor long-term trends in the economy, and it can be used to identify turning points in the business cycle. The filter can also be used to analyze asset prices, exchange rates, and other financial variables. The Hodrick-Prescott filter is a powerful tool for analyzing economic and financial data. It separates a time series into a trend component and a cyclical component, allowing for easy identification of long-term trends and turning points in the business cycle. While it has some limitations, it remains a valuable tool for economists, central banks, and financial institutions around the world.
อินดิเคเตอร์ Pine Script®
โดย loxx
11
Williams Vix Fix BB + RVI + LinReg & Squeeze (Keltner) BBW + %BLegend: Entery signal: When line color turns to lime (lighter green) after a blue dot appears Exit signal: When line color turns to red (darker red) after a red dot appears Note: it is more affective as an entry signal (Bottom is stronger) - When line touches or crosses red band it is Top signal (Williams Vix Fix) - When line touches or crosses blue band it is Bottom signal (Williams Vix Fix) - Red dot at the top of indicator is a Top signal (Relative Volatility Index) - Blue dot at the top of indicator is a Bottom signal (Relative Volatility Index) - Gray dot at the bottom of indicator is a Keltner Squeeze signal (filtered by either BBW or %B) - Silver dot at the bottom of indicator is a weaker Keltner Squeeze signal (Doesn't meet either BBW or %B filter) - Purple is a 'Half Squeeze' only 1 Bollinger Band crossed the Keltner Channel This is an attempt to make use of the main features of all 6 of these Volatility tools: - Williams Vix Fix + Bollinger Bands - Relative Volatility Index (RVI) - Linear Regression (detects Vix Fix starts to rise or fall to a certain degree in order to help validate bottom/top) Note : There is also added precision on Linear Regression entry by dividing WVF by square roots of basis. - The crossing of Keltner Channel by the Bollinger Bands (Squeeze) Conditions to Help Filter Keltner Squeeze: - When the Bollinger Bands Width (BBW) value is lower than the lowest value within a period plus a margin of error (percentage) - When the %B value goes up or down by the impulse value (threshold value in setting) detailed in LazyBears indicator. (www.tradingview.com) If it meets one of these 2 filters and there is a Keltner Channel Squeeze than gray color or else if the squeeze doesn’t meet one of the 2 filters than silver color (weaker Squeeze). The goal is to find the best tool to find bottoms and top relative to volatility and filter squeeze. Note: You can also change the threshold for RVI top and bottom. And this work builds on my last indicators: - Williams Vix Fix + BB & RVI (Top/Bottom) & Squeeze () - Williams Vix Fix BB + RVI & Squeeze (Keltner) filtered BBW + %B () If you have ideas on this work or have ideas on potential combinations please message me, I always want to learn or get perspective on how it can be improved. Sharing is how we get better (Parameter tuning, ideas, discussion) I don’t reinvent the wheel, just trying to make the wheel better.
อินดิเคเตอร์ Pine Script®
โดย KevInnerTrading
11
Penny Stock Short Signal Pro# Penny Stock Short Signal Pro (PSSP) v1.0 ## Complete User Guide & Documentation --- # 📋 TABLE OF CONTENTS 1. (#introduction) 2. (#why-short-penny-stocks) 3. (#the-7-core-detection-systems) 4. (#installation--setup) 5. (#understanding-the-dashboard) 6. (#input-settings-deep-dive) 7. (#visual-elements-explained) 8. (#alert-configuration) 9. (#trading-strategies) 10. (#risk-management) 11. (#best-practices) 12. (#troubleshooting) 13. (#changelog) --- # Introduction **Penny Stock Short Signal Pro (PSSP)** is a comprehensive Pine Script v6 indicator specifically engineered for identifying high-probability short-selling opportunities on low-priced, high-volatility stocks. Unlike generic indicators that apply broad technical analysis, PSSP is purpose-built for the unique characteristics of penny stock price action—where parabolic moves, retail FOMO, and violent reversals create predictable patterns for prepared traders. ## Key Features - **7 Independent Detection Systems** working in concert to identify exhaustion points - **Composite Signal Engine** that requires multiple confirmations before triggering - **Real-Time Dashboard** displaying all signal states and market metrics - **Automatic Risk Management** with dynamic stop-loss and profit target calculations - **Customizable Sensitivity** for different trading styles (scalping vs. swing) - **Built-in Alert System** for all major signal types ## Who Is This For? - **Active Day Traders** looking to capitalize on intraday reversals - **Short Sellers** who specialize in penny stocks and small caps - **Momentum Traders** who want to identify when momentum is exhausting - **Risk-Conscious Traders** who need clear entry/exit levels --- # Why Short Penny Stocks? ## The Penny Stock Lifecycle Penny stocks follow a remarkably predictable lifecycle that creates shorting opportunities: ``` PHASE 1: ACCUMULATION └── Low volume, tight range └── Smart money quietly building positions PHASE 2: MARKUP / PROMOTION └── News catalyst or promotional campaign └── Volume increases, price begins rising └── Early momentum traders enter PHASE 3: DISTRIBUTION (YOUR OPPORTUNITY) └── Parabolic move attracts retail FOMO buyers └── Smart money selling into strength └── Volume climax signals exhaustion └── ⚠️ PSSP SIGNALS FIRE HERE ⚠️ PHASE 4: DECLINE └── Support breaks, panic selling └── Price returns toward origin └── Short sellers profit ``` ## Why Shorts Work on Penny Stocks 1. **No Fundamental Support**: Most penny stocks have no earnings, revenue, or assets to justify elevated prices 2. **Promotional Nature**: Many rallies are driven by promoters who will eventually stop 3. **Retail Exhaustion**: Retail buying power is finite—when it's exhausted, gravity takes over 4. **Float Dynamics**: Low float stocks move fast in both directions 5. **Technical Levels Matter**: VWAP, round numbers, and prior highs become self-fulfilling resistance --- # The 7 Core Detection Systems PSSP employs seven independent detection algorithms. Each identifies a specific type of exhaustion or reversal signal. When multiple systems fire simultaneously, the probability of a successful short dramatically increases. --- ## 1. PARABOLIC EXHAUSTION DETECTOR ### What It Detects Identifies when price has moved too far, too fast and is likely to reverse. This system looks for the classic "blow-off top" pattern common in penny stock runners. ### Technical Logic ``` Parabolic Signal = TRUE when: ├── Consecutive green candles ≥ threshold (default: 3) ├── AND price extension from VWAP ≥ threshold ATRs (default: 1.5) └── OR shooting star / upper wick rejection pattern forms ``` ### Visual Representation ``` ╱╲ ← Shooting star / upper wick ╱ ╲ (Parabolic exhaustion) ╱ ╱ ╱ ══════════════ VWAP ╱ ╱ ``` ### Why It Works on Penny Stocks Penny stocks are notorious for parabolic moves driven by retail FOMO. When everyone who wants to buy has bought, there's no one left to push prices higher. The shooting star pattern shows that sellers are already stepping in at higher prices. ### Key Settings | Parameter | Default | Range | Description | |-----------|---------|-------|-------------| | Lookback Period | 10 | 3-30 | Bars to analyze for pattern | | Extension Threshold | 1.5 ATR | 0.5-5.0 | How far above VWAP is "parabolic" | | Consecutive Green Bars | 3 | 2-10 | Minimum green bars for exhaustion | --- ## 2. VWAP REJECTION SYSTEM ### What It Detects Volume Weighted Average Price (VWAP) is the single most important level for institutional traders. This system identifies when price tests above VWAP and gets rejected back below—a powerful short signal. ### Technical Logic ``` VWAP Rejection = TRUE when: ├── Candle high pierces above VWAP ├── AND candle closes below VWAP ├── AND candle is bearish (close < open) └── AND rejection distance is within sensitivity threshold ``` ### Visual Representation ``` High ──→ ╱╲ ╱ ╲ VWAP ════════╱════╲═══════════ Close ←── Rejection ``` ### Extended VWAP Signals The system also tracks VWAP standard deviation bands. Rejection from the upper band (2 standard deviations above VWAP) is an even stronger signal. ### Why It Works on Penny Stocks - Algorithms and institutions use VWAP as their benchmark - Failed attempts to reclaim VWAP often lead to waterfall selling - VWAP acts as a "magnet" that price tends to revert toward ### Key Settings | Parameter | Default | Range | Description | |-----------|---------|-------|-------------| | Rejection Sensitivity | 0.5 ATR | 0.1-2.0 | How close to VWAP for valid rejection | | Show VWAP Line | True | - | Display VWAP on chart | | Show VWAP Bands | True | - | Display standard deviation bands | | Band Multiplier | 2.0 | 0.5-4.0 | Standard deviations for bands | --- ## 3. VOLUME CLIMAX DETECTOR ### What It Detects Identifies "blow-off tops" where extreme volume accompanies a price spike. This often marks the exact top as it represents maximum retail participation—after which buying power is exhausted. ### Technical Logic ``` Volume Climax = TRUE when: ├── Current volume ≥ (Average volume × Climax Multiple) ├── AND one of: │ ├── Selling into the high (upper wick > lower wick on green bar) │ └── OR post-climax weakness (red bar following climax bar) ``` ### Visual Representation ``` Price: ╱╲ ╱ ╲ ╱ ╲ ╱ ╲ ╱ Volume: ▂▃▅▇██▇▅▃▂▁ ↑ Volume Climax (3x+ average) ``` ### Why It Works on Penny Stocks - Retail traders pile in at the top, creating volume spikes - Market makers and smart money use this liquidity to exit - Once the volume spike passes, there's no fuel left for higher prices - The "smart money selling into dumb money buying" creates the top ### Key Settings | Parameter | Default | Range | Description | |-----------|---------|-------|-------------| | Volume MA Length | 20 | 5-50 | Period for average volume calculation | | Climax Volume Multiple | 3.0x | 1.5-10.0 | Multiple of average for "climax" | | Show Volume Bars | True | - | Visual volume representation | --- ## 4. RSI DIVERGENCE ANALYZER ### What It Detects Bearish divergence occurs when price makes higher highs but RSI (momentum) makes lower highs. This indicates that momentum is weakening even as price pushes higher—a warning of imminent reversal. ### Technical Logic ``` Bearish Divergence = TRUE when: ├── RSI is in overbought territory (> threshold) ├── AND RSI is declining (current < previous < prior) └── Indicates momentum exhaustion before price catches up ``` ### Visual Representation ``` Price: /\ /\ / \ / \ ← Higher high / \/ / / RSI: /\ / \ /\ / \/ \ ← Lower high (DIVERGENCE) / \ ════════════════════ Overbought (70) ``` ### Why It Works on Penny Stocks - Penny stocks often push to new highs on weaker and weaker momentum - Divergence signals that fewer buyers are participating at each new high - Eventually, the lack of buying pressure leads to collapse ### Key Settings | Parameter | Default | Range | Description | |-----------|---------|-------|-------------| | RSI Length | 14 | 5-30 | Standard RSI calculation period | | Overbought Level | 70 | 60-90 | RSI level considered overbought | | Divergence Lookback | 14 | 5-30 | Bars to look back for swing highs | --- ## 5. KEY LEVEL REJECTION TRACKER ### What It Detects Identifies rejections from significant price levels where shorts are likely to be concentrated: High of Day (HOD), premarket highs, and psychological levels (whole and half dollars). ### Technical Logic ``` Level Rejection = TRUE when: ├── Price touches key level (within 0.2% tolerance) ├── AND candle is bearish (close < open) ├── AND close is in lower portion of candle range │ ├── Key Levels Tracked: │ ├── High of Day (HOD) │ ├── Premarket High │ └── Psychological levels ($1.00, $1.50, $2.00, etc.) ``` ### Visual Representation ``` HOD ───────────────────────────────── ╱╲ ← Rejection ╱ ╲ ╱ ╲ ╱ ───────────────────────────────── PM High ───────────────────────────── ``` ### Why It Works on Penny Stocks - **HOD**: The high of day is where the most traders are trapped long. Failure to break HOD often triggers stop-loss cascades - **Premarket High**: Represents overnight enthusiasm; failure to exceed often means the "news" is priced in - **Psychological Levels**: Round numbers ($1, $2, $5) attract orders and act as natural resistance ### Key Settings | Parameter | Default | Range | Description | |-----------|---------|-------|-------------| | Track HOD Rejection | True | - | Monitor high of day | | Track Premarket High | True | - | Monitor premarket resistance | | Track Psychological Levels | True | - | Monitor round numbers | --- ## 6. FAILED BREAKOUT DETECTOR ### What It Detects Identifies "bull traps" where price breaks above resistance but immediately fails and closes back below. This traps breakout buyers and often leads to accelerated selling. ### Technical Logic ``` Failed Breakout = TRUE when: ├── Price breaks above recent high (lookback period) ├── AND one of: │ ├── Same bar closes below the breakout level │ └── OR following bars show consecutive red candles ``` ### Visual Representation ``` ╱╲ ╱ ╲ ← False breakout Recent High ══╱════╲════════════════ ╱ ╲ ╱ ╲ ╱ ╲ ← Trapped longs panic sell ``` ### Why It Works on Penny Stocks - Breakout traders enter on the break, providing exit liquidity for smart money - When the breakout fails, these traders become trapped and must exit - Their forced selling accelerates the decline - Penny stocks have thin order books, making failed breakouts especially violent ### Key Settings | Parameter | Default | Range | Description | |-----------|---------|-------|-------------| | Breakout Lookback | 5 | 2-15 | Bars to define "recent high" | | Confirmation Bars | 2 | 1-5 | Bars to confirm failure | --- ## 7. MOVING AVERAGE BREAKDOWN SYSTEM ### What It Detects Monitors exponential moving averages (EMAs) for bearish crossovers and price rejections. EMA crosses often signal trend changes, while rejections from EMAs indicate resistance. ### Technical Logic ``` MA Breakdown = TRUE when: ├── Bearish EMA cross (fast crosses below slow) └── OR EMA rejection (price tests EMA from below and fails) ``` ### Visual Representation ``` ╱╲ ← Rejection from EMA ╱ ╲ EMA 9 ═══════════╱════╲═══════════ ╲ EMA 20 ═══════════════════╲════════ ╲ Bearish cross ↓ ``` ### Why It Works on Penny Stocks - EMAs smooth out the noise and show underlying trend direction - When fast EMA crosses below slow EMA, it signals momentum shift - Rejected attempts to reclaim EMAs show sellers are in control ### Key Settings | Parameter | Default | Range | Description | |-----------|---------|-------|-------------| | Fast EMA | 9 | 3-20 | Short-term trend | | Slow EMA | 20 | 10-50 | Medium-term trend | | Show EMAs | True | - | Display on chart | --- # Installation & Setup ## Step 1: Access Pine Editor 1. Open TradingView (tradingview.com) 2. Open any chart 3. Click "Pine Editor" at the bottom of the screen ## Step 2: Create New Indicator 1. Click "Open" → "New blank indicator" 2. Delete any existing code 3. Paste the entire PSSP code ## Step 3: Save and Add to Chart 1. Click "Save" (give it a name like "PSSP") 2. Click "Add to chart" 3. The indicator will appear with default settings ## Step 4: Configure Settings 1. Click the gear icon (⚙️) on the indicator 2. Adjust settings based on your trading style (see Settings section) 3. Click "OK" to apply ## Recommended Chart Setup - **Timeframe**: 1-minute or 5-minute for scalping, 15-minute for swing shorts - **Chart Type**: Candlestick - **Extended Hours**: Enable if trading premarket/afterhours - **Volume**: Can disable default volume since PSSP tracks it --- # Understanding the Dashboard The real-time dashboard provides at-a-glance status of all systems: ``` ┌─────────────────────────────────────────┐ │ 📊 SHORT SIGNAL DASHBOARD │ ├─────────────────────────────────────────┤ │ Signal Strength: 5/7 │ ├─────────────────────────────────────────┤ │ ─── ACTIVE SIGNALS ─── │ │ │ │ Parabolic Exhaustion 🔴 2.1 ATR │ │ VWAP Rejection 🔴 Above │ │ Volume Climax 🔴 4.2x Avg │ │ RSI Divergence ⚪ RSI: 68 │ │ Level Rejection 🔴 @ HOD │ │ Failed Breakout 🔴 │ │ MA Breakdown ⚪ Bullish │ ├─────────────────────────────────────────┤ │ ─── RISK LEVELS ─── │ │ Stop: $2.45 T1: $2.10 T2: $1.85 │ └─────────────────────────────────────────┘ ``` ## Dashboard Elements Explained ### Signal Strength Indicator | Rating | Signals | Color | Interpretation | |--------|---------|-------|----------------| | STRONG | 5-7 | Red | High-confidence short opportunity | | MODERATE | 3-4 | Orange | Decent setup, consider other factors | | WEAK | 1-2 | Gray | Insufficient confirmation | | NONE | 0 | Gray | No short signals active | ### Signal Status Icons - 🔴 = Signal is ACTIVE (condition met) - ⚪ = Signal is INACTIVE (condition not met) ### Contextual Metrics Each signal row includes relevant metrics: - **Parabolic**: Shows ATR extension from VWAP - **VWAP**: Shows if price is Above/Below VWAP - **Volume**: Shows current volume as multiple of average - **RSI**: Shows current RSI value - **Level**: Shows which level was touched (HOD, PM High, etc.) - **MA**: Shows EMA relationship (Bullish/Bearish) ### Risk Levels When a composite short signal fires: - **Stop**: Suggested stop-loss level (high + ATR multiple) - **T1**: First profit target (1:1 risk/reward) - **T2**: Second profit target (user-defined R:R) --- # Input Settings Deep Dive ## Group 1: Parabolic Exhaustion | Setting | Default | Conservative | Aggressive | Description | |---------|---------|--------------|------------|-------------| | Enable | True | True | True | Turn system on/off | | Lookback Period | 10 | 15 | 5 | Bars analyzed for pattern | | Extension Threshold | 1.5 | 2.0 | 1.0 | ATRs above VWAP for "parabolic" | | Consecutive Green Bars | 3 | 4 | 2 | Minimum green bars required | **Tuning Tips:** - Lower thresholds = more signals but more false positives - Higher thresholds = fewer signals but higher quality - For very volatile penny stocks, consider higher thresholds ## Group 2: VWAP Rejection | Setting | Default | Conservative | Aggressive | Description | |---------|---------|--------------|------------|-------------| | Enable | True | True | True | Turn system on/off | | Rejection Sensitivity | 0.5 | 0.3 | 0.8 | ATR distance for valid rejection | | Show VWAP Line | True | True | True | Display VWAP | | Show VWAP Bands | True | True | True | Display deviation bands | | Band Multiplier | 2.0 | 2.5 | 1.5 | Standard deviations for bands | **Tuning Tips:** - Tighter sensitivity (lower number) = must reject very close to VWAP - Wider bands = less frequent upper band rejections but more significant ## Group 3: Volume Climax | Setting | Default | Conservative | Aggressive | Description | |---------|---------|--------------|------------|-------------| | Enable | True | True | True | Turn system on/off | | Volume MA Length | 20 | 30 | 10 | Baseline volume period | | Climax Volume Multiple | 3.0 | 4.0 | 2.0 | Multiple for "climax" status | | Show Volume Profile | True | True | True | Visual volume bars | **Tuning Tips:** - Higher multiple = only extreme volume spikes trigger - Shorter MA = more responsive to recent volume changes - For highly liquid stocks, consider higher multiples ## Group 4: Momentum Divergence | Setting | Default | Conservative | Aggressive | Description | |---------|---------|--------------|------------|-------------| | Enable | True | True | True | Turn system on/off | | RSI Length | 14 | 21 | 7 | RSI calculation period | | Overbought Level | 70 | 75 | 65 | Threshold for "overbought" | | Divergence Lookback | 14 | 20 | 10 | Bars for swing high detection | **Tuning Tips:** - Lower overbought threshold = more frequent signals - Shorter RSI length = more responsive but noisier ## Group 5: Key Level Rejection | Setting | Default | Description | |---------|---------|-------------| | Enable | True | Master toggle for level system | | Track Premarket High | True | Monitor premarket resistance | | Track HOD Rejection | True | Monitor high of day | | Track Psychological Levels | True | Monitor round numbers | **Tuning Tips:** - Disable premarket tracking if stock doesn't have significant premarket activity - Psychological levels work best on stocks under $10 ## Group 6: Failed Follow-Through | Setting | Default | Conservative | Aggressive | Description | |---------|---------|--------------|------------|-------------| | Enable | True | True | True | Turn system on/off | | Breakout Lookback | 5 | 8 | 3 | Bars defining "recent high" | | Confirmation Bars | 2 | 3 | 1 | Bars to confirm failure | **Tuning Tips:** - Shorter lookback = more breakouts detected but smaller significance - More confirmation bars = higher confidence but later entry ## Group 7: Moving Average Signals | Setting | Default | Conservative | Aggressive | Description | |---------|---------|--------------|------------|-------------| | Enable | True | True | True | Turn system on/off | | Fast EMA | 9 | 12 | 5 | Short-term trend | | Slow EMA | 20 | 26 | 13 | Medium-term trend | | Show EMAs | True | True | True | Display on chart | **Tuning Tips:** - Standard 9/20 works well for most penny stocks - Faster EMAs (5/13) for scalping, slower (12/26) for swing trading ## Group 8: Composite Signal | Setting | Default | Conservative | Aggressive | Description | |---------|---------|--------------|------------|-------------| | Minimum Signals | 3 | 4-5 | 2 | Signals needed for trigger | | Show Dashboard | True | True | True | Display signal table | | Dashboard Position | top_right | - | - | Screen location | **Tuning Tips:** - **Minimum Signals is the most important setting** - Higher minimum = fewer trades but higher win rate - Lower minimum = more trades but more false signals ## Group 9: Risk Management | Setting | Default | Conservative | Aggressive | Description | |---------|---------|--------------|------------|-------------| | Show Stop Levels | True | True | True | Display stop loss | | Stop ATR Multiple | 1.5 | 2.0 | 1.0 | Stop distance in ATRs | | Show Targets | True | True | True | Display profit targets | | Target R:R | 2.0 | 1.5 | 3.0 | Risk:Reward for Target 2 | **Tuning Tips:** - Tighter stops (lower ATR multiple) = less risk but more stop-outs - Higher R:R targets = bigger winners but fewer targets hit ## Group 10: Visual Settings | Setting | Default | Description | |---------|---------|-------------| | Bullish Color | Green | Color for bullish elements | | Bearish Color | Red | Color for bearish/short signals | | Warning Color | Orange | Color for caution signals | | Neutral Color | Gray | Color for inactive elements | --- # Visual Elements Explained ## Chart Overlays ### VWAP Line (Blue) - **Solid blue line** = Volume Weighted Average Price - Price above VWAP = bullish bias - Price below VWAP = bearish bias - **Use**: Short when price rejects from above VWAP ### VWAP Bands (Purple circles) - Upper band = 2 standard deviations above VWAP - Lower band = 2 standard deviations below VWAP - **Use**: Extreme extension to upper band signals potential reversal ### EMAs (Orange and Red) - **Orange line** = Fast EMA (9-period default) - **Red line** = Slow EMA (20-period default) - **Use**: Bearish cross or price rejection from EMAs confirms short ### HOD Line (Red, dashed) - Shows the current day's high - **Use**: Rejection from HOD is a key short signal ### Premarket High (Orange, dashed) - Shows premarket session high - **Use**: Failure to break PM high often signals weakness ## Signal Markers ### Individual Signal Markers (Small) | Shape | Color | Signal | |-------|-------|--------| | ▼ Triangle | Purple | Parabolic Exhaustion | | ✕ X-Cross | Blue | VWAP Rejection | | ◆ Diamond | Yellow | Volume Climax | | ● Circle | Orange | RSI Divergence | | ■ Square | Red | Failed Breakout | ### Composite Short Signal (Large) - **Large red triangle** with "SHORT" text - Only appears when minimum signal threshold is met - This is your primary trading signal ## Risk Level Lines ### Stop Loss (Red line) - Calculated as: Entry + (ATR × Stop Multiple) - Represents maximum acceptable loss - **RESPECT THIS LEVEL** ### Target 1 (Light green line) - First profit target at 1:1 risk/reward - Consider taking partial profits here ### Target 2 (Dark green line) - Second profit target at user-defined R:R - Let winners run to this level ## Background Coloring ### Light Red Background - Appears when composite short signal is active - Indicates you should be looking for shorts, not longs ### Light Purple Background - Appears during extreme parabolic extension - Warning of potential imminent reversal --- # Alert Configuration ## Available Alerts ### 1. Composite Short Signal **Best for**: Primary trading signal ``` Condition: Composite short signal fires Message: "PSSP: Short Signal Triggered - {ticker} at {close}" ``` ### 2. Parabolic Exhaustion **Best for**: Early warning of potential top ``` Condition: Parabolic exhaustion detected Message: "PSSP: Parabolic exhaustion detected on {ticker}" ``` ### 3. Volume Climax **Best for**: Blow-off top identification ``` Condition: Volume climax occurs Message: "PSSP: Volume climax / blow-off top on {ticker}" ``` ### 4. Strong Short Setup (5+ Signals) **Best for**: High-confidence opportunities only ``` Condition: 5 or more signals active Message: "PSSP: STRONG short setup on {ticker}" ``` ### 5. Very Strong Short Setup (6+ Signals) **Best for**: Maximum confidence trades ``` Condition: 6 or more signals active Message: "PSSP: VERY STRONG short setup on {ticker}" ``` ### 6. Failed Breakout **Best for**: Bull trap identification ``` Condition: Failed breakout detected Message: "PSSP: Failed breakout detected on {ticker}" ``` ### 7. Key Level Rejection **Best for**: Resistance level plays ``` Condition: Key level rejection occurs Message: "PSSP: Key level rejection on {ticker}" ``` ## Setting Up Alerts in TradingView 1. Right-click on the chart 2. Select "Add Alert" 3. Set Condition to "Penny Stock Short Signal Pro" 4. Choose your desired alert condition 5. Configure notification method (popup, email, webhook, etc.) 6. Set expiration (or "Open-ended" for permanent) 7. Click "Create" ## Alert Strategy Recommendations ### For Active Day Traders - Enable: Composite Short Signal, Volume Climax - Set to: Popup + Sound - Check frequently during market hours ### For Swing Traders - Enable: Strong Short Setup (5+), Very Strong Short Setup (6+) - Set to: Email + Mobile Push - Review at key times (open, lunch, close) ### For Part-Time Traders - Enable: Very Strong Short Setup (6+) only - Set to: Email + SMS - Only trade highest-conviction setups --- # Trading Strategies ## Strategy 1: The Parabolic Fade **Setup Requirements:** - Parabolic Exhaustion signal ACTIVE - Extension from VWAP ≥ 2.0 ATR - Volume climax or declining volume on push **Entry:** - Short on first red candle after signal - Or short on break below prior candle's low **Stop Loss:** - Above the high of the parabolic move - Maximum: 1.5 ATR above entry **Targets:** - T1: VWAP (take 50% off) - T2: Lower VWAP band or LOD **Best Time:** 9:30-10:30 AM (morning runners) --- ## Strategy 2: VWAP Rejection Short **Setup Requirements:** - VWAP Rejection signal ACTIVE - Price came from below VWAP - Rejection candle has significant upper wick **Entry:** - Short on close below VWAP - Or short on break below rejection candle low **Stop Loss:** - Above VWAP + 0.5 ATR - Or above rejection candle high **Targets:** - T1: Lower VWAP band - T2: Prior support or LOD **Best Time:** Midday (11:00 AM - 2:00 PM) --- ## Strategy 3: HOD Failure Short **Setup Requirements:** - Level Rejection signal ACTIVE (HOD) - Multiple tests of HOD without breakthrough - Volume declining on each test **Entry:** - Short on confirmed HOD rejection - Wait for close below the rejection candle **Stop Loss:** - Above HOD + 0.25 ATR (tight) - Clear invalidation if HOD breaks **Targets:** - T1: VWAP - T2: Morning support levels **Best Time:** 10:30 AM - 12:00 PM --- ## Strategy 4: Volume Climax Fade **Setup Requirements:** - Volume Climax signal ACTIVE - Volume ≥ 3x average on green candle - Followed by bearish candle or upper wick **Entry:** - Short on first red candle after climax - Or short on break below climax candle low **Stop Loss:** - Above climax candle high - Give room for volatility spike **Targets:** - T1: 50% retracement of the run - T2: VWAP or start of the run **Best Time:** First hour of trading --- ## Strategy 5: The Full Composite (High Conviction) **Setup Requirements:** - Composite Short signal ACTIVE - Minimum 4-5 individual signals - Clear visual of signal markers clustering **Entry:** - Short immediately on composite signal - Use market order for fast-moving stocks **Stop Loss:** - Use indicator's automatic stop level - Do not deviate from system **Targets:** - T1: Indicator's T1 level (1:1) - T2: Indicator's T2 level (2:1) **Best Time:** Any time with sufficient signals --- # Risk Management ## Position Sizing Formula ``` Position Size = (Account Risk %) / (Stop Loss %) Example: - Account: $25,000 - Risk per trade: 1% = $250 - Entry: $2.00 - Stop: $2.20 (10% stop) - Position Size: $250 / 10% = $2,500 worth - Shares: $2,500 / $2.00 = 1,250 shares ``` ## Risk Rules ### The 1% Rule Never risk more than 1% of your account on any single trade. For a $25,000 account, max risk = $250. ### The 2x Stop Rule If your stop gets hit twice on the same stock, stop trading it for the day. The pattern isn't working. ### The Daily Loss Limit Set a maximum daily loss (e.g., 3% of account). Stop trading if hit. ### The Size-Down Rule After a losing trade, reduce your next position size by 50%. Rebuild after a winner. ## Short-Specific Risks ### The Short Squeeze - Penny stocks can squeeze violently - ALWAYS use stops - Never "hope" a position comes back - Size appropriately for volatility ### The Hard-to-Borrow - Check borrow availability before trading - High borrow fees eat into profits - Some stocks become HTB mid-trade ### The Halt Risk - Penny stocks can halt on volatility - Position size for worst-case halt against you - Halts can open significantly higher --- # Best Practices ## DO's ✅ **Wait for multiple signals** - Single signals have lower accuracy ✅ **Trade with the trend** - Short when daily trend is down ✅ **Use the dashboard** - Check signal count before entering ✅ **Respect stops** - The indicator calculates them for a reason ✅ **Size appropriately** - Penny stocks are volatile; position small ✅ **Trade liquid stocks** - Volume ≥ 500K daily average ✅ **Know the catalyst** - Understand why the stock is moving ✅ **Take partial profits** - Secure gains at T1 ✅ **Journal your trades** - Track what works and what doesn't ✅ **Time your entries** - Best shorts often come 10:30-11:30 AM ## DON'Ts ❌ **Don't short strong stocks** - If it won't go down, don't force it ❌ **Don't fight the tape** - A stock going up can keep going up ❌ **Don't average up on losers** - Adding to losing shorts is dangerous ❌ **Don't ignore the dashboard** - It exists to help you ❌ **Don't overtrade** - Quality over quantity ❌ **Don't short into news** - Wait for the reaction first ❌ **Don't trade the first 5 minutes** - Too chaotic for reliable signals ❌ **Don't hold overnight** - Penny stock gaps can destroy accounts ❌ **Don't trade without stops** - Ever. ❌ **Don't trade on tilt** - After losses, take a break ## Optimal Trading Windows | Time (ET) | Quality | Notes | |-----------|---------|-------| | 9:30-9:35 | ⭐ | Too volatile, avoid | | 9:35-10:30 | ⭐⭐⭐⭐⭐ | Best shorts, morning runners exhaust | | 10:30-11:30 | ⭐⭐⭐⭐ | Secondary exhaustion, HOD rejections | | 11:30-2:00 | ⭐⭐ | Midday lull, lower quality | | 2:00-3:00 | ⭐⭐⭐ | Afternoon setups develop | | 3:00-3:30 | ⭐⭐⭐⭐ | End of day momentum | | 3:30-4:00 | ⭐⭐ | Closing volatility, risky | --- # Troubleshooting ## Common Issues ### "Signals aren't appearing" - Check that the relevant system is enabled in settings - Ensure minimum signals threshold isn't too high - Verify the stock has sufficient volume for calculations ### "Too many false signals" - Increase minimum signals threshold - Use more conservative settings (see Settings section) - Focus on stocks with cleaner price action ### "Dashboard not showing" - Ensure "Show Signal Dashboard" is enabled - Check that your chart has enough space - Try a different dashboard position ### "VWAP line is missing" - VWAP requires intraday timeframes (1m, 5m, 15m, etc.) - VWAP resets daily; won't show on daily+ charts - Ensure "Show VWAP Line" is enabled ### "Stop loss seems too tight/wide" - Adjust Stop ATR Multiple in Risk Management settings - Lower multiple = tighter stop - Higher multiple = wider stop ### "Alerts not triggering" - Verify alert is set to the correct indicator - Check that alert hasn't expired - Ensure notification settings are configured in TradingView ## Performance Optimization If the indicator is slow: 1. Reduce the number of visual elements shown 2. Disable unused signal systems 3. Use on fewer simultaneous charts 4. Close unused browser tabs --- # Changelog ## Version 1.0 (Initial Release) - 7 core detection systems implemented - Real-time signal dashboard - Automatic risk management calculations - 7 alert conditions - Full visual overlay system - Comprehensive input settings ## Planned Features (Future Updates) - Scanner integration for multi-stock screening - Machine learning signal weighting - Backtesting statistics panel - Volume profile analysis - Level 2 data integration (if available) - Custom timeframe VWAP options --- # Support & Feedback ## Reporting Issues When reporting issues, please include: 1. TradingView username 2. Stock symbol and timeframe 3. Screenshot of the issue 4. Your indicator settings 5. Steps to reproduce ## Feature Requests We welcome suggestions for improving PSSP. Consider: - What specific pattern are you trying to catch? - How would this help your trading? - Any reference examples? --- # Disclaimer **IMPORTANT: This indicator is for educational and informational purposes only.** - Past performance does not guarantee future results - Short selling carries unlimited risk potential - Always use proper position sizing and stop losses - Paper trade before using real capital - The creator assumes no liability for trading losses - Consult a financial advisor before trading **Trade at your own risk.** --- *Penny Stock Short Signal Pro v1.0* *Pine Script v6* *© 2025*
อินดิเคเตอร์ Pine Script®
โดย DayTradingMD1992
1
Bloomberg Mega Board [v2.5 Fixed]Transform your TradingView chart into a professional-grade command center. Designed for traders who need high-level market awareness without switching tabs, this dashboard provides deep, multi-timeframe analysis across US Sectors, Commodities, Currencies, and Crypto. Key Features 1. Multi-Asset Paging System Pine Script has a limit of 40 security calls, which usually limits how much data you can see. This script bypasses that limitation using a smart Paging System: Sectors Page: Tracks the top 10 US Sectors (SPY, XLK, XLF, etc.) & Indices. Commodities Page: Gold, Silver, Oil, Gas, Copper, Corn, etc. Currencies Page: Major Forex pairs including DXY, EURUSD, USDJPY. Crypto Page: Top 10 Cryptocurrencies by volume. Switch pages instantly via the Settings menu. 2. Smart "News" Headlines Since Pine Script cannot access the live internet for news, this script uses an Algorithmic Headline Generator. It analyzes price action and trend alignment to generate a "Market Status" summary: Full Bull Trend: Intraday + Daily + Weekly trends are all positive. Strong Rally: Asset is up significantly (>1.25%) on the day. Heavy Sell-off: Asset is down significantly (<-1.25%) on the day. Pullback (Buy?): Daily trend is UP, but Intraday is DOWN (potential entry). Consolidating: Market is chopping sideways. 3. Timeframe Trend Matrix Monitor momentum across the curve with a single glance. The "Trend" columns are powered by the 5 EMA (Exponential Moving Average): Intraday: Adapts to your current chart timeframe (e.g., switch your chart to 15m to see the 15m trend). Daily / Weekly / Monthly: These are hard coded to always show the higher timeframe trend, regardless of what chart you are looking at. Trend is determined by price in relation to it's 5 EMA. 4. "Terminal" Aesthetic Styled with a dark, high-contrast Bloomberg Terminal look. Uses Amber tickers and Neon status blocks for rapid visual scanning. Optimized for Full Screen Mode: Hide your main chart candles to turn your monitor into a dedicated data dashboard. How to Use Add the indicator to your chart and move it to "New Lower Indicator" Then repeat 4 times for each dashboard. Open Settings (the gear icon) and find "Select Page". Choose your desired market view (e.g., Sectors, Crypto, Currencies, Commodities) Optional: To replicate the full dashboard look, go to your Chart Settings -> Symbol -> Uncheck "Body" and "Borders" to hide the candles behind the table. 2 hours ago Release Notes Transform your TradingView chart into a professional-grade command center. Designed for traders who need high-level market awareness without switching tabs, this dashboard provides deep, multi-timeframe analysis across US Sectors, Commodities, Currencies, and Crypto. Key Features 1. Multi-Asset Paging System Pine Script has a limit of 40 security calls, which usually limits how much data you can see. This script bypasses that limitation using a smart Paging System: Sectors Page: Tracks the top 10 US Sectors (SPY, XLK, XLF, etc.) & Indices. Commodities Page: Gold, Silver, Oil, Gas, Copper, Corn, etc. Currencies Page: Major Forex pairs including DXY, EURUSD, USDJPY. Crypto Page: Top 10 Cryptocurrencies by volume. Switch pages instantly via the Settings menu. 2. Smart "News" Headlines Since Pine Script cannot access the live internet for news, this script uses an Algorithmic Headline Generator. It analyzes price action and trend alignment to generate a "Market Status" summary: Full Bull Trend: Intraday + Daily + Weekly trends are all positive. Strong Rally: Asset is up significantly (>1.25%) on the day. Heavy Sell-off: Asset is down significantly (<-1.25%) on the day. Pullback (Buy?): Daily trend is UP, but Intraday is DOWN (potential entry). Consolidating: Market is chopping sideways. 3. Timeframe Trend Matrix Monitor momentum across the curve with a single glance. The "Trend" columns are powered by the 5 EMA (Exponential Moving Average): Intraday: Adapts to your current chart timeframe (e.g., switch your chart to 15m to see the 15m trend). Daily / Weekly / Monthly: These are hard coded to always show the higher timeframe trend, regardless of what chart you are looking at. Trend is determined by price in relation to it's 5 EMA. 4. "Terminal" Aesthetic Styled with a dark, high-contrast Bloomberg Terminal look. Uses Amber tickers and Neon status blocks for rapid visual scanning. Optimized for Full Screen Mode: Hide your main chart candles to turn your monitor into a dedicated data dashboard. How to Use Add the indicator to your chart and move it to "New Lower Indicator" Then repeat 4 times for each dashboard. Open Settings (the gear icon) and find "Select Page". Choose your desired market view (e.g., Sectors, Crypto, Currencies, Commodities) Optional: To replicate the full dashboard look, go to your Chart Settings -> Symbol -> Uncheck "Body" and "Borders" to hide the candles behind the table. 2 hours ago Release Notes Transform your TradingView chart into a professional-grade command center. Designed for traders who need high-level market awareness without switching tabs, this dashboard provides deep, multi-timeframe analysis across US Sectors, Commodities, Currencies, and Crypto. Key Features 1. Multi-Asset Paging System Pine Script has a limit of 40 security calls, which usually limits how much data you can see. This script bypasses that limitation using a smart Paging System: Sectors Page: Tracks the top 10 US Sectors (SPY, XLK, XLF, etc.) & Indices. Commodities Page: Gold, Silver, Oil, Gas, Copper, Corn, etc. Currencies Page: Major Forex pairs including DXY, EURUSD, USDJPY. Crypto Page: Top 10 Cryptocurrencies by volume. Switch pages instantly via the Settings menu. 2. Smart "News" Headlines Since Pine Script cannot access the live internet for news, this script uses an Algorithmic Headline Generator. It analyzes price action and trend alignment to generate a "Market Status" summary: Full Bull Trend: Intraday + Daily + Weekly trends are all positive. Strong Rally: Asset is up significantly (>1.25%) on the day. Heavy Sell-off: Asset is down significantly (<-1.25%) on the day. Pullback (Buy?): Daily trend is UP, but Intraday is DOWN (potential entry). Consolidating: Market is chopping sideways. 3. Timeframe Trend Matrix Monitor momentum across the curve with a single glance. The "Trend" columns are powered by the 5 EMA (Exponential Moving Average): Intraday: Adapts to your current chart timeframe (e.g., switch your chart to 15m to see the 15m trend). Daily / Weekly / Monthly: These are hard coded to always show the higher timeframe trend, regardless of what chart you are looking at. Trend is determined by price in relation to it's 5 EMA. 4. "Terminal" Aesthetic Styled with a dark, high-contrast Bloomberg Terminal look. Uses Amber tickers and Neon status blocks for rapid visual scanning. Optimized for Full Screen Mode: Hide your main chart candles to turn your monitor into a dedicated data dashboard. How to Use Add the indicator to your chart and move it to "New Lower Indicator" Then repeat 4 times for each dashboard. Open Settings (the gear icon) and find "Select Page". Choose your desired market view (e.g., Sectors, Crypto, Currencies, Commodities) Optional: To replicate the full dashboard look, go to your Chart Settings -> Symbol -> Uncheck "Body" and "Borders" to hide the candles behind the table. 2 hours ago Release Notes Transform your TradingView chart into a professional-grade command center. Designed for traders who need high-level market awareness without switching tabs, this dashboard provides deep, multi-timeframe analysis across US Sectors, Commodities, Currencies, and Crypto. Key Features 1. Multi-Asset Paging System Pine Script has a limit of 40 security calls, which usually limits how much data you can see. This script bypasses that limitation using a smart Paging System: Sectors Page: Tracks the top 10 US Sectors (SPY, XLK, XLF, etc.) & Indices. Commodities Page: Gold, Silver, Oil, Gas, Copper, Corn, etc. Currencies Page: Major Forex pairs including DXY, EURUSD, USDJPY. Crypto Page: Top 10 Cryptocurrencies by volume. Switch pages instantly via the Settings menu. 2. Smart "News" Headlines Since Pine Script cannot access the live internet for news, this script uses an Algorithmic Headline Generator. It analyzes price action and trend alignment to generate a "Market Status" summary: Full Bull Trend: Intraday + Daily + Weekly trends are all positive. Strong Rally: Asset is up significantly (>1.25%) on the day. Heavy Sell-off: Asset is down significantly (<-1.25%) on the day. Pullback (Buy?): Daily trend is UP, but Intraday is DOWN (potential entry). Consolidating: Market is chopping sideways. 3. Timeframe Trend Matrix Monitor momentum across the curve with a single glance. The "Trend" columns are powered by the 5 EMA (Exponential Moving Average): Intraday: Adapts to your current chart timeframe (e.g., switch your chart to 15m to see the 15m trend). Daily / Weekly / Monthly: These are hard coded to always show the higher timeframe trend, regardless of what chart you are looking at. Trend is determined by price in relation to it's 5 EMA. 4. "Terminal" Aesthetic Styled with a dark, high-contrast Bloomberg Terminal look. Uses Amber tickers and Neon status blocks for rapid visual scanning. Optimized for Full Screen Mode: Hide your main chart candles to turn your monitor into a dedicated data dashboard. How to Use Add the indicator to your chart and move it to "New Lower Indicator" Then repeat 4 times for each dashboard. Open Settings (the gear icon) and find "Select Page". Choose your desired market view (e.g., Sectors, Crypto, Currencies, Commodities) Optional: To replicate the full dashboard look, go to your Chart Settings -> Symbol -> Uncheck "Body" and "Borders" to hide the candles behind the table.
อินดิเคเตอร์ Pine Script®
โดย CustomQuantLabs
1
Adaptive Genesis Engine [AGE]ADAPTIVE GENESIS ENGINE (AGE) Pure Signal Evolution Through Genetic Algorithms Where Darwin Meets Technical Analysis 🧬 WHAT YOU'RE GETTING - THE PURE INDICATOR This is a technical analysis indicator - it generates signals, visualizes probability, and shows you the evolutionary process in real-time. This is NOT a strategy with automatic execution - it's a sophisticated signal generation system that you control . What This Indicator Does: Generates Long/Short entry signals with probability scores (35-88% range) Evolves a population of up to 12 competing strategies using genetic algorithms Validates strategies through walk-forward optimization (train/test cycles) Visualizes signal quality through premium gradient clouds and confidence halos Displays comprehensive metrics via enhanced dashboard Provides alerts for entries and exits Works on any timeframe, any instrument, any broker What This Indicator Does NOT Do: Execute trades automatically Manage positions or calculate position sizes Place orders on your behalf Make trading decisions for you This is pure signal intelligence. AGE tells you when and how confident it is. You decide whether and how much to trade. 🔬 THE SCIENCE: GENETIC ALGORITHMS MEET TECHNICAL ANALYSIS What Makes This Different - The Evolutionary Foundation Most indicators are static - they use the same parameters forever, regardless of market conditions. AGE is alive . It maintains a population of competing strategies that evolve, adapt, and improve through natural selection principles: Birth: New strategies spawn through crossover breeding (combining DNA from fit parents) plus random mutation for exploration Life: Each strategy trades virtually via shadow portfolios, accumulating wins/losses, tracking drawdown, and building performance history Selection: Strategies are ranked by comprehensive fitness scoring (win rate, expectancy, drawdown control, signal efficiency) Death: Weak strategies are culled periodically, with elite performers (top 2 by default) protected from removal Evolution: The gene pool continuously improves as successful traits propagate and unsuccessful ones die out This is not curve-fitting. Each new strategy must prove itself on out-of-sample data through walk-forward validation before being trusted for live signals. 🧪 THE DNA: WHAT EVOLVES Every strategy carries a 10-gene chromosome controlling how it interprets market data: Signal Sensitivity Genes Entropy Sensitivity (0.5-2.0): Weight given to market order/disorder calculations. Low values = conservative, require strong directional clarity. High values = aggressive, act on weaker order signals. Momentum Sensitivity (0.5-2.0): Weight given to RSI/ROC/MACD composite. Controls responsiveness to momentum shifts vs. mean-reversion setups. Structure Sensitivity (0.5-2.0): Weight given to support/resistance positioning. Determines how much price location within swing range matters. Probability Adjustment Genes Probability Boost (-0.10 to +0.10): Inherent bias toward aggressive (+) or conservative (-) entries. Acts as personality trait - some strategies naturally optimistic, others pessimistic. Trend Strength Requirement (0.3-0.8): Minimum trend conviction needed before signaling. Higher values = only trades strong trends, lower values = acts in weak/sideways markets. Volume Filter (0.5-1.5): Strictness of volume confirmation. Higher values = requires strong volume, lower values = volume less important. Risk Management Genes ATR Multiplier (1.5-4.0): Base volatility scaling for all price levels. Controls whether strategy uses tight or wide stops/targets relative to ATR. Stop Multiplier (1.0-2.5): Stop loss tightness. Lower values = aggressive profit protection, higher values = more breathing room. Target Multiplier (1.5-4.0): Profit target ambition. Lower values = quick scalping exits, higher values = swing trading holds. Adaptation Gene Regime Adaptation (0.0-1.0): How much strategy adjusts behavior based on detected market regime (trending/volatile/choppy). Higher values = more reactive to regime changes. The Magic: AGE doesn't just try random combinations. Through tournament selection and fitness-weighted crossover, successful gene combinations spread through the population while unsuccessful ones fade away. Over 50-100 bars, you'll see the population converge toward genes that work for YOUR instrument and timeframe. 📊 THE SIGNAL ENGINE: THREE-LAYER SYNTHESIS Before any strategy generates a signal, AGE calculates probability through multi-indicator confluence: Layer 1 - Market Entropy (Information Theory) Measures whether price movements exhibit directional order or random walk characteristics: The Math: Shannon Entropy = -Σ(p × log(p)) Market Order = 1 - (Entropy / 0.693) What It Means: High entropy = choppy, random market → low confidence signals Low entropy = directional market → high confidence signals Direction determined by up-move vs down-move dominance over lookback period (default: 20 bars) Signal Output: -1.0 to +1.0 (bearish order to bullish order) Layer 2 - Momentum Synthesis Combines three momentum indicators into single composite score: Components: RSI (40% weight): Normalized to -1/+1 scale using (RSI-50)/50 Rate of Change (30% weight): Percentage change over lookback (default: 14 bars), clamped to ±1 MACD Histogram (30% weight): Fast(12) - Slow(26), normalized by ATR Why This Matters: RSI catches mean-reversion opportunities, ROC catches raw momentum, MACD catches momentum divergence. Weighting favors RSI for reliability while keeping other perspectives. Signal Output: -1.0 to +1.0 (strong bearish to strong bullish) Layer 3 - Structure Analysis Evaluates price position within swing range (default: 50-bar lookback): Position Classification: Bottom 20% of range = Support Zone → bullish bounce potential Top 20% of range = Resistance Zone → bearish rejection potential Middle 60% = Neutral Zone → breakout/breakdown monitoring Signal Logic: At support + bullish candle = +0.7 (strong buy setup) At resistance + bearish candle = -0.7 (strong sell setup) Breaking above range highs = +0.5 (breakout confirmation) Breaking below range lows = -0.5 (breakdown confirmation) Consolidation within range = ±0.3 (weak directional bias) Signal Output: -1.0 to +1.0 (bearish structure to bullish structure) Confluence Voting System Each layer casts a vote (Long/Short/Neutral). The system requires minimum 2-of-3 agreement (configurable 1-3) before generating a signal: Examples: Entropy: Bullish, Momentum: Bullish, Structure: Neutral → Signal generated (2 long votes) Entropy: Bearish, Momentum: Neutral, Structure: Neutral → No signal (only 1 short vote) All three bullish → Signal generated with +5% probability bonus This is the key to quality. Single indicators give too many false signals. Triple confirmation dramatically improves accuracy. 📈 PROBABILITY CALCULATION: HOW CONFIDENCE IS MEASURED Base Probability: Raw_Prob = 50% + (Average_Signal_Strength × 25%) Then AGE applies strategic adjustments: Trend Alignment: Signal with trend: +4% Signal against strong trend: -8% Weak/no trend: no adjustment Regime Adaptation: Trending market (efficiency >50%, moderate vol): +3% Volatile market (vol ratio >1.5x): -5% Choppy market (low efficiency): -2% Volume Confirmation: Volume > 70% of 20-bar SMA: no change Volume below threshold: -3% Volatility State (DVS Ratio): High vol (>1.8x baseline): -4% (reduce confidence in chaos) Low vol (<0.7x baseline): -2% (markets can whipsaw in compression) Moderate elevated vol (1.0-1.3x): +2% (trending conditions emerging) Confluence Bonus: All 3 indicators agree: +5% 2 of 3 agree: +2% Strategy Gene Adjustment: Probability Boost gene: -10% to +10% Regime Adaptation gene: scales regime adjustments by 0-100% Final Probability: Clamped between 35% (minimum) and 88% (maximum) Why These Ranges? Below 35% = too uncertain, better not to signal Above 88% = unrealistic, creates overconfidence Sweet spot: 65-80% for quality entries 🔄 THE SHADOW PORTFOLIO SYSTEM: HOW STRATEGIES COMPETE Each active strategy maintains a virtual trading account that executes in parallel with real-time data: Shadow Trading Mechanics Entry Logic: Calculate signal direction, probability, and confluence using strategy's unique DNA Check if signal meets quality gate: Probability ≥ configured minimum threshold (default: 65%) Confluence ≥ configured minimum (default: 2 of 3) Direction is not zero (must be long or short, not neutral) Verify signal persistence: Base requirement: 2 bars (configurable 1-5) Adapts based on probability: high-prob signals (75%+) enter 1 bar faster, low-prob signals need 1 bar more Adjusts for regime: trending markets reduce persistence by 1, volatile markets add 1 Apply additional filters: Trend strength must exceed strategy's requirement gene Regime filter: if volatile market detected, probability must be 72%+ to override Volume confirmation required (volume > 70% of average) If all conditions met for required persistence bars, enter shadow position at current close price Position Management: Entry Price: Recorded at close of entry bar Stop Loss: ATR-based distance = ATR × ATR_Mult (gene) × Stop_Mult (gene) × DVS_Ratio Take Profit: ATR-based distance = ATR × ATR_Mult (gene) × Target_Mult (gene) × DVS_Ratio Position: +1 (long) or -1 (short), only one at a time per strategy Exit Logic: Check if price hit stop (on low) or target (on high) on current bar Record trade outcome in R-multiples (profit/loss normalized by ATR) Update performance metrics: Total trades counter incremented Wins counter (if profit > 0) Cumulative P&L updated Peak equity tracked (for drawdown calculation) Maximum drawdown from peak recorded Enter cooldown period (default: 8 bars, configurable 3-20) before next entry allowed Reset signal age counter to zero Walk-Forward Tracking: During position lifecycle, trades are categorized: Training Phase (first 250 bars): Trade counted toward training metrics Testing Phase (next 75 bars): Trade counted toward testing metrics (out-of-sample) Live Phase (after WFO period): Trade counted toward overall metrics Why Shadow Portfolios? No lookahead bias (uses only data available at the bar) Realistic execution simulation (entry on close, stop/target checks on high/low) Independent performance tracking for true fitness comparison Allows safe experimentation without risking capital Each strategy learns from its own experience 🏆 FITNESS SCORING: HOW STRATEGIES ARE RANKED Fitness is not just win rate. AGE uses a comprehensive multi-factor scoring system: Core Metrics (Minimum 3 trades required) Win Rate (30% of fitness): WinRate = Wins / TotalTrades Normalized directly (0.0-1.0 scale) Total P&L (30% of fitness): Normalized_PnL = (PnL + 300) / 600 Clamped 0.0-1.0. Assumes P&L range of -300R to +300R for normalization scale. Expectancy (25% of fitness): Expectancy = Total_PnL / Total_Trades Normalized_Expectancy = (Expectancy + 30) / 60 Clamped 0.0-1.0. Rewards consistency of profit per trade. Drawdown Control (15% of fitness): Normalized_DD = 1 - (Max_Drawdown / 15) Clamped 0.0-1.0. Penalizes strategies that suffer large equity retracements from peak. Sample Size Adjustment Quality Factor: <50 trades: 1.0 (full weight, small sample) 50-100 trades: 0.95 (slight penalty for medium sample) 100 trades: 0.85 (larger penalty for large sample) Why penalize more trades? Prevents strategies from gaming the system by taking hundreds of tiny trades to inflate statistics. Favors quality over quantity. Bonus Adjustments Walk-Forward Validation Bonus: if (WFO_Validated): Fitness += (WFO_Efficiency - 0.5) × 0.1 Strategies proven on out-of-sample data receive up to +10% fitness boost based on test/train efficiency ratio. Signal Efficiency Bonus (if diagnostics enabled): if (Signals_Evaluated > 10): Pass_Rate = Signals_Passed / Signals_Evaluated Fitness += (Pass_Rate - 0.1) × 0.05 Rewards strategies that generate high-quality signals passing the quality gate, not just profitable trades. Final Fitness: Clamped at 0.0 minimum (prevents negative fitness values) Result: Elite strategies typically achieve 0.50-0.75 fitness. Anything above 0.60 is excellent. Below 0.30 is prime candidate for culling. 🔬 WALK-FORWARD OPTIMIZATION: ANTI-OVERFITTING PROTECTION This is what separates AGE from curve-fitted garbage indicators. The Three-Phase Process Every new strategy undergoes a rigorous validation lifecycle: Phase 1 - Training Window (First 250 bars, configurable 100-500): Strategy trades normally via shadow portfolio All trades count toward training performance metrics System learns which gene combinations produce profitable patterns Tracks independently: Training_Trades, Training_Wins, Training_PnL Phase 2 - Testing Window (Next 75 bars, configurable 30-200): Strategy continues trading without any parameter changes Trades now count toward testing performance metrics (separate tracking) This is out-of-sample data - strategy has never seen these bars during "optimization" Tracks independently: Testing_Trades, Testing_Wins, Testing_PnL Phase 3 - Validation Check: Minimum_Trades = 5 (configurable 3-15) IF (Train_Trades >= Minimum AND Test_Trades >= Minimum): WR_Efficiency = Test_WinRate / Train_WinRate Expectancy_Efficiency = Test_Expectancy / Train_Expectancy WFO_Efficiency = (WR_Efficiency + Expectancy_Efficiency) / 2 IF (WFO_Efficiency >= 0.55): // configurable 0.3-0.9 Strategy.Validated = TRUE Strategy receives fitness bonus ELSE: Strategy receives 30% fitness penalty ELSE: Validation deferred (insufficient trades in one or both periods) What Validation Means Validated Strategy (Green "✓ VAL" in dashboard): Performed at least 55% as well on unseen data compared to training data Gets fitness bonus: +(efficiency - 0.5) × 0.1 Receives priority during tournament selection for breeding More likely to be chosen as active trading strategy Unvalidated Strategy (Orange "○ TRAIN" in dashboard): Failed to maintain performance on test data (likely curve-fitted to training period) Receives 30% fitness penalty (0.7x multiplier) Makes strategy prime candidate for culling Can still trade but with lower selection probability Insufficient Data (continues collecting): Hasn't completed both training and testing periods yet OR hasn't achieved minimum trade count in both periods Validation check deferred until requirements met Why 55% Efficiency Threshold? If a strategy earned 10R during training but only 5.5R during testing, it still proved an edge exists beyond random luck. Requiring 100% efficiency would be unrealistic - market conditions change between periods. But requiring >50% ensures the strategy didn't completely degrade on fresh data. The Protection: Strategies that work great on historical data but fail on new data are automatically identified and penalized. This prevents the population from being polluted by overfitted strategies that would fail in live trading. 🌊 DYNAMIC VOLATILITY SCALING (DVS): ADAPTIVE STOP/TARGET PLACEMENT AGE doesn't use fixed stop distances. It adapts to current volatility conditions in real-time. Four Volatility Measurement Methods 1. ATR Ratio (Simple Method): Current_Vol = ATR(14) / Close Baseline_Vol = SMA(Current_Vol, 100) Ratio = Current_Vol / Baseline_Vol Basic comparison of current ATR to 100-bar moving average baseline. 2. Parkinson (High-Low Range Based): For each bar: HL = log(High / Low) Parkinson_Vol = sqrt(Σ(HL²) / (4 × Period × log(2))) More stable than close-to-close volatility. Captures intraday range expansion without overnight gap noise. 3. Garman-Klass (OHLC Based): HL_Term = 0.5 × ² CO_Term = (2×log(2) - 1) × ² GK_Vol = sqrt(Σ(HL_Term - CO_Term) / Period) Most sophisticated estimator. Incorporates all four price points (open, high, low, close) plus gap information. 4. Ensemble Method (Default - Median of All Three): Ratio_1 = ATR_Current / ATR_Baseline Ratio_2 = Parkinson_Current / Parkinson_Baseline Ratio_3 = GK_Current / GK_Baseline DVS_Ratio = Median(Ratio_1, Ratio_2, Ratio_3) Why Ensemble? Takes median to avoid outliers and false spikes If ATR jumps but range-based methods stay calm, median prevents overreaction If one method fails, other two compensate Most robust approach across different market conditions Sensitivity Scaling Scaled_Ratio = (Raw_Ratio) ^ Sensitivity Sensitivity 0.3: Cube root - heavily dampens volatility impact Sensitivity 0.5: Square root - moderate dampening Sensitivity 0.7 (Default): Balanced response to volatility changes Sensitivity 1.0: Linear - full 1:1 volatility impact Sensitivity 1.5: Exponential - amplified response to volatility spikes Safety Clamps: Final DVS Ratio always clamped between 0.5x and 2.5x baseline to prevent extreme position sizing or stop placement errors. How DVS Affects Shadow Trading Every strategy's stop and target distances are multiplied by the current DVS ratio: Stop Loss Distance: Stop_Distance = ATR × ATR_Mult (gene) × Stop_Mult (gene) × DVS_Ratio Take Profit Distance: Target_Distance = ATR × ATR_Mult (gene) × Target_Mult (gene) × DVS_Ratio Example Scenario: ATR = 10 points Strategy's ATR_Mult gene = 2.5 Strategy's Stop_Mult gene = 1.5 Strategy's Target_Mult gene = 2.5 DVS_Ratio = 1.4 (40% above baseline volatility - market heating up) Stop = 10 × 2.5 × 1.5 × 1.4 = 52.5 points (vs. 37.5 in normal vol) Target = 10 × 2.5 × 2.5 × 1.4 = 87.5 points (vs. 62.5 in normal vol) Result: During volatility spikes: Stops automatically widen to avoid noise-based exits, targets extend for bigger moves During calm periods: Stops tighten for better risk/reward, targets compress for realistic profit-taking Strategies adapt risk management to match current market behavior 🧬 THE EVOLUTIONARY CYCLE: SPAWN, COMPETE, CULL Initialization (Bar 1) AGE begins with 4 seed strategies (if evolution enabled): Seed Strategy #0 (Balanced): All sensitivities at 1.0 (neutral) Zero probability boost Moderate trend requirement (0.4) Standard ATR/stop/target multiples (2.5/1.5/2.5) Mid-level regime adaptation (0.5) Seed Strategy #1 (Momentum-Focused): Lower entropy sensitivity (0.7), higher momentum (1.5) Slight probability boost (+0.03) Higher trend requirement (0.5) Tighter stops (1.3), wider targets (3.0) Seed Strategy #2 (Entropy-Driven): Higher entropy sensitivity (1.5), lower momentum (0.8) Slight probability penalty (-0.02) More trend tolerant (0.6) Wider stops (1.8), standard targets (2.5) Seed Strategy #3 (Structure-Based): Balanced entropy/momentum (0.8/0.9), high structure (1.4) Slight probability boost (+0.02) Lower trend requirement (0.35) Moderate risk parameters (1.6/2.8) All seeds start with WFO validation bypassed if WFO is disabled, or must validate if enabled. Spawning New Strategies Timing (Adaptive): Historical phase: Every 30 bars (configurable 10-100) Live phase: Every 200 bars (configurable 100-500) Automatically switches to live timing when barstate.isrealtime triggers Conditions: Current population < max population limit (default: 8, configurable 4-12) At least 2 active strategies exist (need parents) Available slot in population array Selection Process: Run tournament selection 3 times with different seeds Each tournament: randomly sample active strategies, pick highest fitness Best from 3 tournaments becomes Parent 1 Repeat independently for Parent 2 Ensures fit parents but maintains diversity Crossover Breeding: For each of 10 genes: Parent1_Fitness = fitness Parent2_Fitness = fitness Weight1 = Parent1_Fitness / (Parent1_Fitness + Parent2_Fitness) Gene1 = parent1's value Gene2 = parent2's value Child_Gene = Weight1 × Gene1 + (1 - Weight1) × Gene2 Fitness-weighted crossover ensures fitter parent contributes more genetic material. Mutation: For each gene in child: IF (random < mutation_rate): Gene_Range = GENE_MAX - GENE_MIN Noise = (random - 0.5) × 2 × mutation_strength × Gene_Range Mutated_Gene = Clamp(Child_Gene + Noise, GENE_MIN, GENE_MAX) Historical mutation rate: 20% (aggressive exploration) Live mutation rate: 8% (conservative stability) Mutation strength: 12% of gene range (configurable 5-25%) Initialization of New Strategy: Unique ID assigned (total_spawned counter) Parent ID recorded Generation = max(parent generations) + 1 Birth bar recorded (for age tracking) All performance metrics zeroed Shadow portfolio reset WFO validation flag set to false (must prove itself) Result: New strategy with hybrid DNA enters population, begins trading in next bar. Competition (Every Bar) All active strategies: Calculate their signal based on unique DNA Check quality gate with their thresholds Manage shadow positions (entries/exits) Update performance metrics Recalculate fitness score Track WFO validation progress Strategies compete indirectly through fitness ranking - no direct interaction. Culling Weak Strategies Timing (Adaptive): Historical phase: Every 60 bars (configurable 20-200, should be 2x spawn interval) Live phase: Every 400 bars (configurable 200-1000, should be 2x spawn interval) Minimum Adaptation Score (MAS): Initial MAS = 0.10 MAS decays: MAS × 0.995 every cull cycle Minimum MAS = 0.03 (floor) MAS represents the "survival threshold" - strategies below this fitness level are vulnerable. Culling Conditions (ALL must be true): Population > minimum population (default: 3, configurable 2-4) At least one strategy has fitness < MAS Strategy's age > culling interval (prevents premature culling of new strategies) Strategy is not in top N elite (default: 2, configurable 1-3) Culling Process: Find worst strategy: For each active strategy: IF (age > cull_interval): Fitness = base_fitness IF (not WFO_validated AND WFO_enabled): Fitness × 0.7 // 30% penalty for unvalidated IF (Fitness < MAS AND Fitness < worst_fitness_found): worst_strategy = this_strategy worst_fitness = Fitness IF (worst_strategy found): Count elite strategies with fitness > worst_fitness IF (elite_count >= elite_preservation_count): Deactivate worst_strategy (set active flag = false) Increment total_culled counter Elite Protection: Even if a strategy's fitness falls below MAS, it survives if fewer than N strategies are better. This prevents culling when population is generally weak. Result: Weak strategies removed from population, freeing slots for new spawns. Gene pool improves over time. Selection for Display (Every Bar) AGE chooses one strategy to display signals: Best fitness = -1 Selected = none For each active strategy: Fitness = base_fitness IF (WFO_validated): Fitness × 1.3 // 30% bonus for validated strategies IF (Fitness > best_fitness): best_fitness = Fitness selected_strategy = this_strategy Display selected strategy's signals on chart Result: Only the highest-fitness (optionally validated-boosted) strategy's signals appear as chart markers. Other strategies trade invisibly in shadow portfolios. 🎨 PREMIUM VISUALIZATION SYSTEM AGE includes sophisticated visual feedback that standard indicators lack: 1. Gradient Probability Cloud (Optional, Default: ON) Multi-layer gradient showing signal buildup 2-3 bars before entry: Activation Conditions: Signal persistence > 0 (same directional signal held for multiple bars) Signal probability ≥ minimum threshold (65% by default) Signal hasn't yet executed (still in "forming" state) Visual Construction: 7 gradient layers by default (configurable 3-15) Each layer is a line-fill pair (top line, bottom line, filled between) Layer spacing: 0.3 to 1.0 × ATR above/below price Outer layers = faint, inner layers = bright Color transitions from base to intense based on layer position Transparency scales with probability (high prob = more opaque) Color Selection: Long signals: Gradient from theme.gradient_bull_mid to theme.gradient_bull_strong Short signals: Gradient from theme.gradient_bear_mid to theme.gradient_bear_strong Base transparency: 92%, reduces by up to 8% for high-probability setups Dynamic Behavior: Cloud grows/shrinks as signal persistence increases/decreases Redraws every bar while signal is forming Disappears when signal executes or invalidates Performance Note: Computationally expensive due to linefill objects. Disable or reduce layers if chart performance degrades. 2. Population Fitness Ribbon (Optional, Default: ON) Histogram showing fitness distribution across active strategies: Activation: Only draws on last bar (barstate.islast) to avoid historical clutter Visual Construction: 10 histogram layers by default (configurable 5-20) Plots 50 bars back from current bar Positioned below price at: lowest_low(100) - 1.5×ATR (doesn't interfere with price action) Each layer represents a fitness threshold (evenly spaced min to max fitness) Layer Logic: For layer_num from 0 to ribbon_layers: Fitness_threshold = min_fitness + (max_fitness - min_fitness) × (layer / layers) Count strategies with fitness ≥ threshold Height = ATR × 0.15 × (count / total_active) Y_position = base_level + ATR × 0.2 × layer Color = Gradient from weak to strong based on layer position Line_width = Scaled by height (taller = thicker) Visual Feedback: Tall, bright ribbon = healthy population, many fit strategies at high fitness levels Short, dim ribbon = weak population, few strategies achieving good fitness Ribbon compression (layers close together) = population converging to similar fitness Ribbon spread = diverse fitness range, active selection pressure Use Case: Quick visual health check without opening dashboard. Ribbon growing upward over time = population improving. 3. Confidence Halo (Optional, Default: ON) Circular polyline around entry signals showing probability strength: Activation: Draws when new position opens (shadow_position changes from 0 to ±1) Visual Construction: 20-segment polyline forming approximate circle Center: Low - 0.5×ATR (long) or High + 0.5×ATR (short) Radius: 0.3×ATR (low confidence) to 1.0×ATR (elite confidence) Scales with: (probability - min_probability) / (1.0 - min_probability) Color Coding: Elite (85%+): Cyan (theme.conf_elite), large radius, minimal transparency (40%) Strong (75-85%): Strong green (theme.conf_strong), medium radius, moderate transparency (50%) Good (65-75%): Good green (theme.conf_good), smaller radius, more transparent (60%) Moderate (<65%): Moderate green (theme.conf_moderate), tiny radius, very transparent (70%) Technical Detail: Uses chart.point array with index-based positioning 5-bar horizontal spread for circular appearance (±5 bars from entry) Curved=false (Pine Script polyline limitation) Fill color matches line color but more transparent (88% vs line's transparency) Purpose: Instant visual probability assessment. No need to check dashboard - halo size/brightness tells the story. 4. Evolution Event Markers (Optional, Default: ON) Visual indicators of genetic algorithm activity: Spawn Markers (Diamond, Cyan): Plots when total_spawned increases on current bar Location: bottom of chart (location.bottom) Color: theme.spawn_marker (cyan/bright blue) Size: tiny Indicates new strategy just entered population Cull Markers (X-Cross, Red): Plots when total_culled increases on current bar Location: bottom of chart (location.bottom) Color: theme.cull_marker (red/pink) Size: tiny Indicates weak strategy just removed from population What It Tells You: Frequent spawning early = population building, active exploration Frequent culling early = high selection pressure, weak strategies dying fast Balanced spawn/cull = healthy evolutionary churn No markers for long periods = stable population (evolution plateaued or optimal genes found) 5. Entry/Exit Markers Clear visual signals for selected strategy's trades: Long Entry (Triangle Up, Green): Plots when selected strategy opens long position (position changes 0 → +1) Location: below bar (location.belowbar) Color: theme.long_primary (green/cyan depending on theme) Transparency: Scales with probability: Elite (85%+): 0% (fully opaque) Strong (75-85%): 10% Good (65-75%): 20% Acceptable (55-65%): 35% Size: small Short Entry (Triangle Down, Red): Plots when selected strategy opens short position (position changes 0 → -1) Location: above bar (location.abovebar) Color: theme.short_primary (red/pink depending on theme) Transparency: Same scaling as long entries Size: small Exit (X-Cross, Orange): Plots when selected strategy closes position (position changes ±1 → 0) Location: absolute (at actual exit price if stop/target lines enabled) Color: theme.exit_color (orange/yellow depending on theme) Transparency: 0% (fully opaque) Size: tiny Result: Clean, probability-scaled markers that don't clutter chart but convey essential information. 6. Stop Loss & Take Profit Lines (Optional, Default: ON) Visual representation of shadow portfolio risk levels: Stop Loss Line: Plots when selected strategy has active position Level: shadow_stop value from selected strategy Color: theme.short_primary with 60% transparency (red/pink, subtle) Width: 2 Style: plot.style_linebr (breaks when no position) Take Profit Line: Plots when selected strategy has active position Level: shadow_target value from selected strategy Color: theme.long_primary with 60% transparency (green, subtle) Width: 2 Style: plot.style_linebr (breaks when no position) Purpose: Shows where shadow portfolio would exit for stop/target Helps visualize strategy's risk/reward ratio Useful for manual traders to set similar levels Disable for cleaner chart (recommended for presentations) 7. Dynamic Trend EMA Gradient-colored trend line that visualizes trend strength: Calculation: EMA(close, trend_length) - default 50 period (configurable 20-100) Slope calculated over 10 bars: (current_ema - ema ) / ema × 100 Color Logic: Trend_direction: Slope > 0.1% = Bullish (1) Slope < -0.1% = Bearish (-1) Otherwise = Neutral (0) Trend_strength = abs(slope) Color = Gradient between: - Neutral color (gray/purple) - Strong bullish (bright green) if direction = 1 - Strong bearish (bright red) if direction = -1 Gradient factor = trend_strength (0 to 1+ scale) Visual Behavior: Faint gray/purple = weak/no trend (choppy conditions) Light green/red = emerging trend (low strength) Bright green/red = strong trend (high conviction) Color intensity = trend strength magnitude Transparency: 50% (subtle, doesn't overpower price action) Purpose: Subconscious awareness of trend state without checking dashboard or indicators. 8. Regime Background Tinting (Subtle) Ultra-low opacity background color indicating detected market regime: Regime Detection: Efficiency = directional_movement / total_range (over trend_length bars) Vol_ratio = current_volatility / average_volatility IF (efficiency > 0.5 AND vol_ratio < 1.3): Regime = Trending (1) ELSE IF (vol_ratio > 1.5): Regime = Volatile (2) ELSE: Regime = Choppy (0) Background Colors: Trending: theme.regime_trending (dark green, 92-93% transparency) Volatile: theme.regime_volatile (dark red, 93% transparency) Choppy: No tint (normal background) Purpose: Subliminal regime awareness Helps explain why signals are/aren't generating Trending = ideal conditions for AGE Volatile = fewer signals, higher thresholds applied Choppy = mixed signals, lower confidence Important: Extremely subtle by design. Not meant to be obvious, just subconscious context. 📊 ENHANCED DASHBOARD Comprehensive real-time metrics in single organized panel (top-right position): Dashboard Structure (5 columns × 14 rows) Header Row: Column 0: "🧬 AGE PRO" + phase indicator (🔴 LIVE or ⏪ HIST) Column 1: "POPULATION" Column 2: "PERFORMANCE" Column 3: "CURRENT SIGNAL" Column 4: "ACTIVE STRATEGY" Column 0: Market State Regime (📈 TREND / 🌊 CHAOS / ➖ CHOP) DVS Ratio (current volatility scaling factor, format: #.##) Trend Direction (▲ BULL / ▼ BEAR / ➖ FLAT with color coding) Trend Strength (0-100 scale, format: #.##) Column 1: Population Metrics Active strategies (count / max_population) Validated strategies (WFO passed / active total) Current generation number Total spawned (all-time strategy births) Total culled (all-time strategy deaths) Column 2: Aggregate Performance Total trades across all active strategies Aggregate win rate (%) - color-coded: Green (>55%) Orange (45-55%) Red (<45%) Total P&L in R-multiples - color-coded by positive/negative Best fitness score in population (format: #.###) MAS - Minimum Adaptation Score (cull threshold, format: #.###) Column 3: Current Signal Status Status indicator: "▲ LONG" (green) if selected strategy in long position "▼ SHORT" (red) if selected strategy in short position "⏳ FORMING" (orange) if signal persisting but not yet executed "○ WAITING" (gray) if no active signal Confidence percentage (0-100%, format: #.#%) Quality assessment: "🔥 ELITE" (cyan) for 85%+ probability "✓ STRONG" (bright green) for 75-85% "○ GOOD" (green) for 65-75% "- LOW" (dim) for <65% Confluence score (X/3 format) Signal age: "X bars" if signal forming "IN TRADE" if position active "---" if no signal Column 4: Selected Strategy Details Strategy ID number (#X format) Validation status: "✓ VAL" (green) if WFO validated "○ TRAIN" (orange) if still in training/testing phase Generation number (GX format) Personal fitness score (format: #.### with color coding) Trade count P&L and win rate (format: #.#R (##%) with color coding) Color Scheme: Panel background: theme.panel_bg (dark, low opacity) Panel headers: theme.panel_header (slightly lighter) Primary text: theme.text_primary (bright, high contrast) Secondary text: theme.text_secondary (dim, lower contrast) Positive metrics: theme.metric_positive (green) Warning metrics: theme.metric_warning (orange) Negative metrics: theme.metric_negative (red) Special markers: theme.validated_marker, theme.spawn_marker Update Frequency: Only on barstate.islast (current bar) to minimize CPU usage Purpose: Quick overview of entire system state No need to check multiple indicators Trading decisions informed by population health, regime state, and signal quality Transparency into what AGE is thinking 🔍 DIAGNOSTICS PANEL (Optional, Default: OFF) Detailed signal quality tracking for optimization and debugging: Panel Structure (3 columns × 8 rows) Position: Bottom-right corner (doesn't interfere with main dashboard) Header Row: Column 0: "🔍 DIAGNOSTICS" Column 1: "COUNT" Column 2: "%" Metrics Tracked (for selected strategy only): Total Evaluated: Every signal that passed initial calculation (direction ≠ 0) Represents total opportunities considered ✓ Passed: Signals that passed quality gate and executed Green color coding Percentage of evaluated signals Rejection Breakdown: ⨯ Probability: Rejected because probability < minimum threshold Most common rejection reason typically ⨯ Confluence: Rejected because confluence < minimum required (e.g., only 1 of 3 indicators agreed) ⨯ Trend: Rejected because signal opposed strong trend Indicates counter-trend protection working ⨯ Regime: Rejected because volatile regime detected and probability wasn't high enough to override Shows regime filter in action ⨯ Volume: Rejected because volume < 70% of 20-bar average Indicates volume confirmation requirement Color Coding: Passed count: Green (success metric) Rejection counts: Red (failure metrics) Percentages: Gray (neutral, informational) Performance Cost: Slight CPU overhead for tracking counters. Disable when not actively optimizing settings. How to Use Diagnostics Scenario 1: Too Few Signals Evaluated: 200 Passed: 10 (5%) ⨯ Probability: 120 (60%) ⨯ Confluence: 40 (20%) ⨯ Others: 30 (15%) Diagnosis: Probability threshold too high for this strategy's DNA. Solution: Lower min probability from 65% to 60%, or allow strategy more time to evolve better DNA. Scenario 2: Too Many False Signals Evaluated: 200 Passed: 80 (40%) Strategy win rate: 45% Diagnosis: Quality gate too loose, letting low-quality signals through. Solution: Raise min probability to 70%, or increase min confluence to 3 (all indicators must agree). Scenario 3: Regime-Specific Issues ⨯ Regime: 90 (45% of rejections) Diagnosis: Frequent volatile regime detection blocking otherwise good signals. Solution: Either accept fewer trades during chaos (recommended), or disable regime filter if you want signals regardless of market state. Optimization Workflow: Enable diagnostics Run 200+ bars Analyze rejection patterns Adjust settings based on data Re-run and compare pass rate Disable diagnostics when satisfied ⚙️ CONFIGURATION GUIDE 🧬 Evolution Engine Settings Enable AGE Evolution (Default: ON): ON: Full genetic algorithm (recommended for best results) OFF: Uses only 4 seed strategies, no spawning/culling (static population for comparison testing) Max Population (4-12, Default: 8): Higher = more diversity, more exploration, slower performance Lower = faster computation, less exploration, risk of premature convergence Sweet spot: 6-8 for most use cases 4 = minimum for meaningful evolution 12 = maximum before diminishing returns Min Population (2-4, Default: 3): Safety floor - system never culls below this count Prevents population extinction during harsh selection Should be at least half of max population Elite Preservation (1-3, Default: 2): Top N performers completely immune to culling Ensures best genes always survive 1 = minimal protection, aggressive selection 2 = balanced (recommended) 3 = conservative, slower gene pool turnover Historical: Spawn Interval (10-100, Default: 30): Bars between spawning new strategies during historical data Lower = faster evolution, more exploration Higher = slower evolution, more evaluation time per strategy 30 bars = ~1-2 hours on 15min chart Historical: Cull Interval (20-200, Default: 60): Bars between culling weak strategies during historical data Should be 2x spawn interval for balanced churn Lower = aggressive selection pressure Higher = patient evaluation Live: Spawn Interval (100-500, Default: 200): Bars between spawning during live trading Much slower than historical for stability Prevents population chaos during live trading 200 bars = ~1.5 trading days on 15min chart Live: Cull Interval (200-1000, Default: 400): Bars between culling during live trading Should be 2x live spawn interval Conservative removal during live trading Historical: Mutation Rate (0.05-0.40, Default: 0.20): Probability each gene mutates during breeding (20% = 2 out of 10 genes on average) Higher = more exploration, slower convergence Lower = more exploitation, faster convergence but risk of local optima 20% balances exploration vs exploitation Live: Mutation Rate (0.02-0.20, Default: 0.08): Mutation rate during live trading Much lower for stability (don't want population to suddenly degrade) 8% = mostly inherits parent genes with small tweaks Mutation Strength (0.05-0.25, Default: 0.12): How much genes change when mutated (% of gene's total range) 0.05 = tiny nudges (fine-tuning) 0.12 = moderate jumps (recommended) 0.25 = large leaps (aggressive exploration) Example: If gene range is 0.5-2.0, 12% strength = ±0.18 possible change 📈 Signal Quality Settings Min Signal Probability (0.55-0.80, Default: 0.65): Quality gate threshold - signals below this never generate 0.55-0.60 = More signals, accept lower confidence (higher risk) 0.65 = Institutional-grade balance (recommended) 0.70-0.75 = Fewer but higher-quality signals (conservative) 0.80+ = Very selective, very few signals (ultra-conservative) Min Confluence Score (1-3, Default: 2): Required indicator agreement before signal generates 1 = Any single indicator can trigger (not recommended - too many false signals) 2 = Requires 2 of 3 indicators agree (RECOMMENDED for balance) 3 = All 3 must agree (very selective, few signals, high quality) Base Persistence Bars (1-5, Default: 2): Base bars signal must persist before entry System adapts automatically: High probability signals (75%+) enter 1 bar faster Low probability signals (<68%) need 1 bar more Trending regime: -1 bar (faster entries) Volatile regime: +1 bar (more confirmation) 1 = Immediate entry after quality gate (responsive but prone to whipsaw) 2 = Balanced confirmation (recommended) 3-5 = Patient confirmation (slower but more reliable) Cooldown After Trade (3-20, Default: 8): Bars to wait after exit before next entry allowed Prevents overtrading and revenge trading 3 = Minimal cooldown (active trading) 8 = Balanced (recommended) 15-20 = Conservative (position trading) Entropy Length (10-50, Default: 20): Lookback period for market order/disorder calculation Lower = more responsive to regime changes (noisy) Higher = more stable regime detection (laggy) 20 = works across most timeframes Momentum Length (5-30, Default: 14): Period for RSI/ROC calculations 14 = standard (RSI default) Lower = more signals, less reliable Higher = fewer signals, more reliable Structure Length (20-100, Default: 50): Lookback for support/resistance swing range 20 = short-term swings (day trading) 50 = medium-term structure (recommended) 100 = major structure (position trading) Trend EMA Length (20-100, Default: 50): EMA period for trend detection and direction bias 20 = short-term trend (responsive) 50 = medium-term trend (recommended) 100 = long-term trend (position trading) ATR Period (5-30, Default: 14): Period for volatility measurement 14 = standard ATR Lower = more responsive to vol changes Higher = smoother vol calculation 📊 Volatility Scaling (DVS) Settings Enable DVS (Default: ON): Dynamic volatility scaling for adaptive stop/target placement Highly recommended to leave ON OFF only for testing fixed-distance stops DVS Method (Default: Ensemble): ATR Ratio: Simple, fast, single-method (good for beginners) Parkinson: High-low range based (good for intraday) Garman-Klass: OHLC based (sophisticated, considers gaps) Ensemble: Median of all three (RECOMMENDED - most robust) DVS Memory (20-200, Default: 100): Lookback for baseline volatility comparison 20 = very responsive to vol changes (can overreact) 100 = balanced adaptation (recommended) 200 = slow, stable baseline (minimizes false vol signals) DVS Sensitivity (0.3-1.5, Default: 0.7): How much volatility affects scaling (power-law exponent) 0.3 = Conservative, heavily dampens vol impact (cube root) 0.5 = Moderate dampening (square root) 0.7 = Balanced response (recommended) 1.0 = Linear, full 1:1 vol response 1.5 = Aggressive, amplified response (exponential) 🔬 Walk-Forward Optimization Settings Enable WFO (Default: ON): Out-of-sample validation to prevent overfitting Highly recommended to leave ON OFF only for testing or if you want unvalidated strategies Training Window (100-500, Default: 250): Bars for in-sample optimization 100 = fast validation, less data (risky) 250 = balanced (recommended) - about 1-2 months on daily, 1-2 weeks on 15min 500 = patient validation, more data (conservative) Testing Window (30-200, Default: 75): Bars for out-of-sample validation Should be ~30% of training window 30 = minimal test (fast validation) 75 = balanced (recommended) 200 = extensive test (very conservative) Min Trades for Validation (3-15, Default: 5): Required trades in BOTH training AND testing periods 3 = minimal sample (risky, fast validation) 5 = balanced (recommended) 10+ = conservative (slow validation, high confidence) WFO Efficiency Threshold (0.3-0.9, Default: 0.55): Minimum test/train performance ratio required 0.30 = Very loose (test must be 30% as good as training) 0.55 = Balanced (recommended) - test must be 55% as good 0.70+ = Strict (test must closely match training) Higher = fewer validated strategies, lower risk of overfitting 🎨 Premium Visuals Settings Visual Theme: Neon Genesis: Cyberpunk aesthetic (cyan/magenta/purple) Carbon Fiber: Industrial look (blue/red/gray) Quantum Blue: Quantum computing (blue/purple/pink) Aurora: Northern lights (teal/orange/purple) ⚡ Gradient Probability Cloud (Default: ON): Multi-layer gradient showing signal buildup Turn OFF if chart lags or for cleaner look Cloud Gradient Layers (3-15, Default: 7): More layers = smoother gradient, more CPU intensive Fewer layers = faster, blockier appearance 🎗️ Population Fitness Ribbon (Default: ON): Histogram showing fitness distribution Turn OFF for cleaner chart Ribbon Layers (5-20, Default: 10): More layers = finer fitness detail Fewer layers = simpler histogram ⭕ Signal Confidence Halo (Default: ON): Circular indicator around entry signals Size/brightness scales with probability Minimal performance cost 🔬 Evolution Event Markers (Default: ON): Diamond (spawn) and X (cull) markers Shows genetic algorithm activity Minimal performance cost 🎯 Stop/Target Lines (Default: ON): Shows shadow portfolio stop/target levels Turn OFF for cleaner chart (recommended for screenshots/presentations) 📊 Enhanced Dashboard (Default: ON): Comprehensive metrics panel Should stay ON unless you want zero overlays 🔍 Diagnostics Panel (Default: OFF): Detailed signal rejection tracking Turn ON when optimizing settings Turn OFF during normal use (slight performance cost) 📈 USAGE WORKFLOW - HOW TO USE THIS INDICATOR Phase 1: Initial Setup & Learning Add AGE to your chart Recommended timeframes: 15min, 30min, 1H (best signal-to-noise ratio) Works on: 5min (day trading), 4H (swing trading), Daily (position trading) Load 1000+ bars for sufficient evolution history Let the population evolve (100+ bars minimum) First 50 bars: Random exploration, poor results expected Bars 50-150: Population converging, fitness improving Bars 150+: Stable performance, validated strategies emerging Watch the dashboard metrics Population should grow toward max capacity Generation number should advance regularly Validated strategies counter should increase Best fitness should trend upward toward 0.50-0.70 range Observe evolution markers Diamond markers (cyan) = new strategies spawning X markers (red) = weak strategies being culled Frequent early activity = healthy evolution Activity slowing = population stabilizing Be patient. Evolution takes time. Don't judge performance before 150+ bars. Phase 2: Signal Observation Watch signals form Gradient cloud builds up 2-3 bars before entry Cloud brightness = probability strength Cloud thickness = signal persistence Check signal quality Look at confidence halo size when entry marker appears Large bright halo = elite setup (85%+) Medium halo = strong setup (75-85%) Small halo = good setup (65-75%) Verify market conditions Check trend EMA color (green = uptrend, red = downtrend, gray = choppy) Check background tint (green = trending, red = volatile, clear = choppy) Trending background + aligned signal = ideal conditions Review dashboard signal status Current Signal column shows: Status (Long/Short/Forming/Waiting) Confidence % (actual probability value) Quality assessment (Elite/Strong/Good) Confluence score (2/3 or 3/3 preferred) Only signals meeting ALL quality gates appear on chart. If you're not seeing signals, population is either still learning or market conditions aren't suitable. Phase 3: Manual Trading Execution When Long Signal Fires: Verify confidence level (dashboard or halo size) Confirm trend alignment (EMA sloping up, green color) Check regime (preferably trending or choppy, avoid volatile) Enter long manually on your broker platform Set stop loss at displayed stop line level (if lines enabled), or use your own risk management Set take profit at displayed target line level, or trail manually Monitor position - exit if X marker appears (signal reversal) When Short Signal Fires: Same verification process Confirm downtrend (EMA sloping down, red color) Enter short manually Use displayed stop/target levels or your own AGE tells you WHEN and HOW CONFIDENT. You decide WHETHER and HOW MUCH. Phase 4: Set Up Alerts (Never Miss a Signal) Right-click on indicator name in legend Select "Add Alert" Choose condition: "AGE Long" = Long entry signal fired "AGE Short" = Short entry signal fired "AGE Exit" = Position reversal/exit signal Set notification method: Sound alert (popup on chart) Email notification Webhook to phone/trading platform Mobile app push notification Name the alert (e.g., "AGE BTCUSD 15min Long") Save alert Recommended: Set alerts for both long and short, enable mobile push notifications. You'll get alerted in real-time even if not watching charts. Phase 5: Monitor Population Health Weekly Review: Check dashboard Population column: Active count should be near max (6-8 of 8) Validated count should be >50% of active Generation should be advancing (1-2 per week typical) Check dashboard Performance column: Aggregate win rate should be >50% (target: 55-65%) Total P&L should be positive (may fluctuate) Best fitness should be >0.50 (target: 0.55-0.70) MAS should be declining slowly (normal adaptation) Check Active Strategy column: Selected strategy should be validated (✓ VAL) Personal fitness should match best fitness Trade count should be accumulating Win rate should be >50% Warning Signs: Zero validated strategies after 300+ bars = settings too strict or market unsuitable Best fitness stuck <0.30 = population struggling, consider parameter adjustment No spawning/culling for 200+ bars = evolution stalled (may be optimal or need reset) Aggregate win rate <45% sustained = system not working on this instrument/timeframe Health Check Pass: 50%+ strategies validated Best fitness >0.50 Aggregate win rate >52% Regular spawn/cull activity Selected strategy validated Phase 6: Optimization (If Needed) Enable Diagnostics Panel (bottom-right) for data-driven tuning: Problem: Too Few Signals Evaluated: 200 Passed: 8 (4%) ⨯ Probability: 140 (70%) Solutions: Lower min probability: 65% → 60% or 55% Reduce min confluence: 2 → 1 Lower base persistence: 2 → 1 Increase mutation rate temporarily to explore new genes Check if regime filter is blocking signals (⨯ Regime high?) Problem: Too Many False Signals Evaluated: 200 Passed: 90 (45%) Win rate: 42% Solutions: Raise min probability: 65% → 70% or 75% Increase min confluence: 2 → 3 Raise base persistence: 2 → 3 Enable WFO if disabled (validates strategies before use) Check if volume filter is being ignored (⨯ Volume low?) Problem: Counter-Trend Losses ⨯ Trend: 5 (only 5% rejected) Losses often occur against trend Solutions: System should already filter trend opposition May need stronger trend requirement Consider only taking signals aligned with higher timeframe trend Use longer trend EMA (50 → 100) Problem: Volatile Market Whipsaws ⨯ Regime: 100 (50% rejected by volatile regime) Still getting stopped out frequently Solutions: System is correctly blocking volatile signals Losses happening because vol filter isn't strict enough Consider not trading during volatile periods (respect the regime) Or disable regime filter and accept higher risk Optimization Workflow: Enable diagnostics Run 200+ bars with current settings Analyze rejection patterns and win rate Make ONE change at a time (scientific method) Re-run 200+ bars and compare results Keep change if improvement, revert if worse Disable diagnostics when satisfied Never change multiple parameters at once - you won't know what worked. Phase 7: Multi-Instrument Deployment AGE learns independently on each chart: Recommended Strategy: Deploy AGE on 3-5 different instruments Different asset classes ideal (e.g., ES futures, EURUSD, BTCUSD, SPY, Gold) Each learns optimal strategies for that instrument's personality Take signals from all 5 charts Natural diversification reduces overall risk Why This Works: When one market is choppy, others may be trending Different instruments respond to different news/catalysts Portfolio-level win rate more stable than single-instrument Evolution explores different parameter spaces on each chart Setup: Same settings across all charts (or customize if preferred) Set alerts for all Take every validated signal across all instruments Position size based on total account (don't overleverage any single signal) ⚠️ REALISTIC EXPECTATIONS - CRITICAL READING What AGE Can Do ✅ Generate probability-weighted signals using genetic algorithms ✅ Evolve strategies in real-time through natural selection ✅ Validate strategies on out-of-sample data (walk-forward optimization) ✅ Adapt to changing market conditions automatically over time ✅ Provide comprehensive metrics on population health and signal quality ✅ Work on any instrument, any timeframe, any broker ✅ Improve over time as weak strategies are culled and fit strategies breed What AGE Cannot Do ❌ Win every trade (typical win rate: 55-65% at best) ❌ Predict the future with certainty (markets are probabilistic, not deterministic) ❌ Work perfectly from bar 1 (needs 100-150 bars to learn and stabilize) ❌ Guarantee profits under all market conditions ❌ Replace your trading discipline and risk management ❌ Execute trades automatically (this is an indicator, not a strategy) ❌ Prevent all losses (drawdowns are normal and expected) ❌ Adapt instantly to regime changes (re-learning takes 50-100 bars) Performance Realities Typical Performance After Evolution Stabilizes (150+ bars): Win Rate: 55-65% (excellent for trend-following systems) Profit Factor: 1.5-2.5 (realistic for validated strategies) Signal Frequency: 5-15 signals per 100 bars (quality over quantity) Drawdown Periods: 20-40% of time in equity retracement (normal trading reality) Max Consecutive Losses: 5-8 losses possible even with 60% win rate (probability says this is normal) Evolution Timeline: Bars 0-50: Random exploration, learning phase - poor results expected, don't judge yet Bars 50-150: Population converging, fitness climbing - results improving Bars 150-300: Stable performance, most strategies validated - consistent results Bars 300+: Mature population, optimal genes dominant - best results Market Condition Dependency: Trending Markets: AGE excels - clear directional moves, high-probability setups Choppy Markets: AGE struggles - fewer signals generated, lower win rate Volatile Markets: AGE cautious - higher rejection rate, wider stops, fewer trades Market Regime Changes: When market shifts from trending to choppy overnight Validated strategies can become temporarily invalidated AGE will adapt through evolution, but not instantly Expect 50-100 bar re-learning period after major regime shifts Fitness may temporarily drop then recover This is NOT a holy grail. It's a sophisticated signal generator that learns and adapts using genetic algorithms. Your success depends on: Patience during learning periods (don't abandon after 3 losses) Proper position sizing (risk 0.5-2% per trade, not 10%) Following signals consistently (cherry-picking defeats statistical edge) Not abandoning system prematurely (give it 200+ bars minimum) Understanding probability (60% win rate means 40% of trades WILL lose) Respecting market conditions (trending = trade more, choppy = trade less) Managing emotions (AGE is emotionless, you need to be too) Expected Drawdowns: Single-strategy max DD: 10-20% of equity (normal) Portfolio across multiple instruments: 5-15% (diversification helps) Losing streaks: 3-5 consecutive losses expected periodically No indicator eliminates risk. AGE manages risk through: Quality gates (rejecting low-probability signals) Confluence requirements (multi-indicator confirmation) Persistence requirements (no knee-jerk reactions) Regime awareness (reduced trading in chaos) Walk-forward validation (preventing overfitting) But it cannot prevent all losses. That's inherent to trading. 🔧 TECHNICAL SPECIFICATIONS Platform: TradingView Pine Script v5 Indicator Type: Overlay indicator (plots on price chart) Execution Type: Signals only - no automatic order placement Computational Load: Moderate to High (genetic algorithms + shadow portfolios) 8 strategies × shadow portfolio simulation = significant computation Premium visuals add additional load (gradient cloud, fitness ribbon) TradingView Resource Limits (Built-in Caps): Max Bars Back: 500 (sufficient for WFO and evolution) Max Labels: 100 (plenty for entry/exit markers) Max Lines: 150 (adequate for stop/target lines) Max Boxes: 50 (not heavily used) Max Polylines: 100 (confidence halos) Recommended Chart Settings: Timeframe: 15min to 1H (optimal signal/noise balance) 5min: Works but noisier, more signals 4H/Daily: Works but fewer signals Bars Loaded: 1000+ (ensures sufficient evolution history) Replay Mode: Excellent for testing without risk Performance Optimization Tips: Disable gradient cloud if chart lags (most CPU intensive visual) Disable fitness ribbon if still laggy Reduce cloud layers from 7 to 3 Reduce ribbon layers from 10 to 5 Turn off diagnostics panel unless actively tuning Close other heavy indicators to free resources Browser/Platform Compatibility: Works on all modern browsers (Chrome, Firefox, Safari, Edge) Mobile app supported (full functionality on phone/tablet) Desktop app supported (best performance) Web version supported (may be slower on older computers) Data Requirements: Real-time or delayed data both work No special data feeds required Works with TradingView's standard data Historical + live data seamlessly integrated 🎓 THEORETICAL FOUNDATIONS AGE synthesizes advanced concepts from multiple disciplines: Evolutionary Computation Genetic Algorithms (Holland, 1975): Population-based optimization through natural selection metaphor Tournament Selection: Fitness-based parent selection with diversity preservation Crossover Operators: Fitness-weighted gene recombination from two parents Mutation Operators: Random gene perturbation for exploration of new parameter space Elitism: Preservation of top N performers to prevent loss of best solutions Adaptive Parameters: Different mutation rates for historical vs. live phases Technical Analysis Support/Resistance: Price structure within swing ranges Trend Following: EMA-based directional bias Momentum Analysis: RSI, ROC, MACD composite indicators Volatility Analysis: ATR-based risk scaling Volume Confirmation: Trade activity validation Information Theory Shannon Entropy (1948): Quantification of market order vs. disorder Signal-to-Noise Ratio: Directional information vs. random walk Information Content: How much "information" a price move contains Statistics & Probability Walk-Forward Analysis: Rolling in-sample/out-of-sample optimization Out-of-Sample Validation: Testing on unseen data to prevent overfitting Monte Carlo Principles: Shadow portfolio simulation with realistic execution Expectancy Theory: Win rate × avg win - loss rate × avg loss Probability Distributions: Signal confidence quantification Risk Management ATR-Based Stops: Volatility-normalized risk per trade Volatility Regime Detection: Market state classification (trending/choppy/volatile) Drawdown Control: Peak-to-trough equity measurement R-Multiple Normalization: Performance measurement in risk units Machine Learning Concepts Online Learning: Continuous adaptation as new data arrives Fitness Functions: Multi-objective optimization (win rate + expectancy + drawdown) Exploration vs. Exploitation: Balance between trying new strategies and using proven ones Overfitting Prevention: Walk-forward validation as regularization Novel Contribution: AGE is the first TradingView indicator to apply genetic algorithms to real-time indicator parameter optimization while maintaining strict anti-overfitting controls through walk-forward validation. Most "adaptive" indicators simply recalibrate lookback periods or thresholds. AGE evolves entirely new strategies through competitive selection - it's not parameter tuning, it's Darwinian evolution of trading logic itself. The combination of: Genetic algorithm population management Shadow portfolio simulation for realistic fitness evaluation Walk-forward validation to prevent overfitting Multi-indicator confluence for signal quality Dynamic volatility scaling for adaptive risk ...creates a system that genuinely learns and improves over time while avoiding the curse of curve-fitting that plagues most optimization approaches. 🏗️ DEVELOPMENT NOTES This project represents months of intensive development, facing significant technical challenges: Challenge 1: Making Genetics Actually Work Early versions spawned garbage strategies that polluted the gene pool: Random gene combinations produced nonsensical parameter sets Weak strategies survived too long, dragging down population No clear convergence toward optimal solutions Solution: Comprehensive fitness scoring (4 factors: win rate, P&L, expectancy, drawdown) Elite preservation (top 2 always protected) Walk-forward validation (unproven strategies penalized 30%) Tournament selection (fitness-weighted breeding) Adaptive culling (MAS decay creates increasing selection pressure) Challenge 2: Balancing Evolution Speed vs. Stability Too fast = population chaos, no convergence. Too slow = can't adapt to regime changes. Solution: Dual-phase timing: Fast evolution during historical (30/60 bar intervals), slow during live (200/400 bar intervals) Adaptive mutation rates: 20% historical, 8% live Spawn/cull ratio: Always 2:1 to prevent population collapse Challenge 3: Shadow Portfolio Accuracy Needed realistic trade simulation without lookahead bias: Can't peek at future bars for exits Must track multiple portfolios simultaneously Stop/target checks must use bar's high/low correctly Solution: Entry on close (realistic) Exit checks on current bar's high/low (realistic) Independent position tracking per strategy Cooldown periods to prevent unrealistic rapid re-entry ATR-normalized P&L (R-multiples) for fair comparison across volatility regimes Challenge 4: Pine Script Compilation Limits Hit TradingView's execution limits multiple times: Too many array operations Too many variables Too complex conditional logic Solution: Optimized data structures (single DNA array instead of 8 separate arrays) Minimal visual overlays (only essential plots) Efficient fitness calculations (vectorized where possible) Strategic use of barstate.islast to minimize dashboard updates Challenge 5: Walk-Forward Implementation Standard WFO is difficult in Pine Script: Can't easily "roll forward" through historical data Can't re-optimize strategies mid-stream Must work in real-time streaming environment Solution: Age-based phase detection (first 250 bars = training, next 75 = testing) Separate metric tracking for train vs. test Efficiency calculation at fixed interval (after test period completes) Validation flag persists for strategy lifetime Challenge 6: Signal Quality Control Early versions generated too many signals with poor win rates: Single indicators produced excessive noise No trend alignment No regime awareness Instant entries on single-bar spikes Solution: Three-layer confluence system (entropy + momentum + structure) Minimum 2-of-3 agreement requirement Trend alignment checks (penalty for counter-trend) Regime-based probability adjustments Persistence requirements (signals must hold multiple bars) Volume confirmation Quality gate (probability + confluence thresholds) The Result A system that: Truly evolves (not just parameter sweeps) Truly validates (out-of-sample testing) Truly adapts (ongoing competition and breeding) Stays within TradingView's platform constraints Provides institutional-quality signals Maintains transparency (full metrics dashboard) Development time: 3+ months of iterative refinement Lines of code: ~1500 (highly optimized) Test instruments: ES, NQ, EURUSD, BTCUSD, SPY, AAPL Test timeframes: 5min, 15min, 1H, Daily 🎯 FINAL WORDS The Adaptive Genesis Engine is not just another indicator - it's a living system that learns, adapts, and improves through the same principles that drive biological evolution. Every bar it observes adds to its experience. Every strategy it spawns explores new parameter combinations. Every strategy it culls removes weakness from the gene pool. This is evolution in action on your charts. You're not getting a static formula locked in time. You're getting a system that thinks , that competes , that survives through natural selection. The strongest strategies rise to the top. The weakest die. The gene pool improves generation after generation. AGE doesn't claim to predict the future - it adapts to whatever the future brings. When markets shift from trending to choppy, from calm to volatile, from bullish to bearish - AGE evolves new strategies suited to the new regime. Use it on any instrument. Any timeframe. Any market condition. AGE will adapt. This indicator gives you the pure signal intelligence. How you choose to act on it - position sizing, risk management, execution discipline - that's your responsibility. AGE tells you when and how confident . You decide whether and how much . Trust the process. Respect the evolution. Let Darwin work. "In markets, as in nature, it is not the strongest strategies that survive, nor the most intelligent - but those most responsive to change." Taking you to school. — Dskyz, Trade with insight. Trade with anticipation. — Happy Holiday's
อินดิเคเตอร์ Pine Script®
โดย DskyzInvestments
3
Squeeze Hour Frequency [CHE]Squeeze Hour Frequency (ATR-PR) — Standalone — Tracks daily squeeze occurrences by hour to reveal time-based volatility patterns Summary This indicator identifies periods of unusually low volatility, defined as squeezes, and tallies their frequency across each hour of the day over historical trading sessions. By aggregating counts into a sortable table, it helps users spot hours prone to these conditions, enabling better scheduling of trading activity to avoid or target specific intraday regimes. Signals gain robustness through percentile-based detection that adapts to recent volatility history, differing from fixed-threshold methods by focusing on relative lowness rather than absolute levels, which reduces false positives in varying market environments. Motivation: Why this design? Traders often face uneven intraday volatility, with certain hours showing clustered low-activity phases that precede or follow breakouts, leading to mistimed entries or overlooked calm periods. The core idea of hourly squeeze frequency addresses this by binning low-volatility events into 24 hourly slots and counting distinct daily occurrences, providing a historical profile of when squeezes cluster. This reveals time-of-day biases without relying on real-time alerts, allowing proactive adjustments to session focus. What’s different vs. standard approaches? - Reference baseline: Classical volatility tools like simple moving average crossovers or fixed ATR thresholds, which flag squeezes uniformly across the day. - Architecture differences: - Uses persistent arrays to track one squeeze per hour per day, preventing overcounting within sessions. - Employs custom sorting on ratio arrays for dynamic table display, prioritizing top or bottom performers. - Handles timezones explicitly to ensure consistent binning across global assets. - Practical effect: Charts show a persistent table ranking hours by squeeze share, making intraday patterns immediately visible—such as a top hour capturing over 20 percent of total events—unlike static overlays that ignore temporal distribution, which matters for avoiding low-liquidity traps in crypto or forex. How it works (technical) The indicator first computes a rolling volatility measure over a specified lookback period. It then derives a relative ranking of the current value against recent history within a window of bars. A squeeze is flagged when this ranking falls below a user-defined cutoff, indicating the value is among the lowest in the recent sample. On each bar, the local hour is extracted using the selected timezone. If a squeeze occurs and the bar has price data, the count for that hour increments only if no prior mark exists for the current day, using a persistent array to store the last marked day per hour. This ensures one tally per unique trading day per slot. At the final bar, arrays compile counts and ratios for all 24 hours, where the ratio represents each hour's share of total squeezes observed. These are sorted ascending or descending based on display mode, and the top or bottom subset populates the table. Background shading highlights live squeezes in red for visual confirmation. Initialization uses zero-filled arrays for counts and negative seeds for day tracking, with state persisting across bars via variable declarations. No higher timeframe data is pulled, so there is no repaint risk from external fetches; all logic runs on confirmed bars. Parameter Guide ATR Length — Controls the lookback for the volatility measure, influencing sensitivity to short-term fluctuations; shorter values increase responsiveness but add noise, longer ones smooth for stability — Default: 14 — Trade-offs/Tips: Use 10-20 for intraday charts to balance quick detection with fewer false squeezes; test on historical data to avoid over-smoothing in trending markets. Percentile Window (bars) — Sets the history depth for ranking the current volatility value, affecting how "low" is defined relative to past; wider windows emphasize long-term norms — Default: 252 — Trade-offs/Tips: 100-300 bars suit daily cycles; narrower for fast assets like crypto to catch recent regimes, but risks instability in sparse data. Squeeze threshold (PR < x) — Defines the cutoff for flagging low relative volatility, where values below this mark a squeeze; lower thresholds tighten detection for rarer events — Default: 10.0 — Trade-offs/Tips: 5-15 percent for conservative signals reducing false positives; raise to 20 for more frequent highlights in high-vol environments, monitoring for increased noise. Timezone — Specifies the reference for hourly binning, ensuring alignment with market sessions — Default: Exchange — Trade-offs/Tips: Set to "America/New_York" for US assets; mismatches can skew counts, so verify against chart timezone. Show Table — Toggles the results display, essential for reviewing frequencies — Default: true — Trade-offs/Tips: Disable on mobile for performance; pair with position tweaks for clean overlays. Pos — Places the table on the chart pane — Default: Top Right — Trade-offs/Tips: Bottom Left avoids candle occlusion on volatile charts. Font — Adjusts text readability in the table — Default: normal — Trade-offs/Tips: Tiny for dense views, large for emphasis on key hours. Dark — Applies high-contrast colors for visibility — Default: true — Trade-offs/Tips: Toggle false in light themes to prevent washout. Display — Filters table rows to focus on extremes or full list — Default: All — Trade-offs/Tips: Top 3 for quick scans of risky hours; Bottom 3 highlights safe low-squeeze periods. Reading & Interpretation Red background shading appears on bars meeting the squeeze condition, signaling current low relative volatility. The table lists hours as "H0" to "H23", with columns for daily squeeze counts, percentage share of total squeezes (summing to 100 percent across hours), and an arrow marker on the top hour. A summary row above details the peak count, its share, and the leading hour. A label at the last bar recaps total days observed, data-valid days, and top hour stats. Rising shares indicate clustering, suggesting regime persistence in that slot. Practical Workflows & Combinations - Trend following: Scan for hours with low squeeze shares to enter during stable regimes; confirm with higher highs or lower lows on the 15-minute chart, avoiding top-share hours post-news like tariff announcements. - Exits/Stops: Tighten stops in high-share hours to guard against sudden vol spikes; use the table to shift to conservative sizing outside peak squeeze times. - Multi-asset/Multi-TF: Defaults work across crypto pairs on 5-60 minute timeframes; for stocks, widen percentile window to 500 bars. Combine with volume oscillators—enter only if squeeze count is below average for the asset. Behavior, Constraints & Performance Logic executes on closed bars, with live bars updating counts provisionally but finalizing on confirmation; table refreshes only at the last bar, avoiding intrabar flicker. No security calls or higher timeframes, so no repaint from external data. Resources include a 5000-bar history limit, loops up to 24 iterations for sorting and totals, and arrays sized to 24 elements; labels and table are capped at 500 each for efficiency. Known limits: Skips hours without bars (e.g., weekends), assumes uniform data availability, and may undercount in sparse sessions; timezone shifts can alter profiles without warning. Sensible Defaults & Quick Tuning Start with ATR Length at 14, Percentile Window at 252, and threshold at 10.0 for broad crypto use. If too many squeezes flag (noisy table), raise threshold to 15.0 and narrow window to 100 for stricter relative lowness. For sluggish detection in calm markets, drop ATR Length to 10 and threshold to 5.0 to capture subtler dips. In high-vol assets, widen window to 500 and threshold to 20.0 for stability. What this indicator is—and isn’t This is a historical frequency tracker and visualization layer for intraday volatility patterns, best as a filter in multi-tool setups. It is not a standalone signal generator, predictive model, or risk manager—pair it with price action, news filters, and position sizing rules. Disclaimer The content provided, including all code and materials, is strictly for educational and informational purposes only. It is not intended as, and should not be interpreted as, financial advice, a recommendation to buy or sell any financial instrument, or an offer of any financial product or service. All strategies, tools, and examples discussed are provided for illustrative purposes to demonstrate coding techniques and the functionality of Pine Script within a trading context. Any results from strategies or tools provided are hypothetical, and past performance is not indicative of future results. Trading and investing involve high risk, including the potential loss of principal, and may not be suitable for all individuals. Before making any trading decisions, please consult with a qualified financial professional to understand the risks involved. By using this script, you acknowledge and agree that any trading decisions are made solely at your discretion and risk. Do not use this indicator on Heikin-Ashi, Renko, Kagi, Point-and-Figure, or Range charts, as these chart types can produce unrealistic results for signal markers and alerts. Best regards and happy trading Chervolino Thanks to Duyck for the ma sorter
อินดิเคเตอร์ Pine Script®
โดย chervolino
40 Ticker Cross-Sectional Z-Scores [BackQuant]40 Ticker Cross-Sectional Z-Scores BackQuant’s 40 Ticker Cross-Sectional Z-Scores is a powerful portfolio management strategy that analyzes the relative performance of up to 40 different assets, comparing them on a cross-sectional basis to identify the top and bottom performers. This indicator computes Z-scores for each asset based on their log returns and evaluates them relative to the mean and standard deviation over a rolling window. The Z-scores represent how far an asset's return deviates from the average, and these values are used to rank the assets, allowing for dynamic asset allocation based on performance. By focusing on the strongest-performing assets and avoiding the weakest, this strategy aims to enhance returns while managing risk. Additionally, by adjusting for standard deviations, the system offers a risk-adjusted method of ranking assets, making it suitable for traders who want to dynamically allocate capital based on performance metrics rather than just price movements. Key Features 1. Cross-Sectional Z-Score Calculation: The system calculates Z-scores for 40 different assets, evaluating their log returns against the mean and standard deviation over a rolling window. This enables users to assess the relative performance of each asset dynamically, highlighting which assets are performing better or worse compared to their historical norms. The Z-score is a useful statistical tool for identifying outliers in asset performance. 2. Asset Ranking and Allocation: The system ranks assets based on their Z-scores and allocates capital to the top performers. It identifies the top and bottom assets, and traders can allocate capital to the top-performing assets, ensuring that their portfolio is aligned with the best performers. Conversely, the bottom assets are removed from the portfolio, reducing exposure to underperforming assets. 3. Rolling Window for Mean and Standard Deviation Calculations: The Z-scores are calculated based on rolling means and standard deviations, making the system adaptive to changing market conditions. This rolling calculation window allows the strategy to adjust to recent performance trends and minimize the impact of outdated data. 4. Mean and Standard Deviation Visualization: The script provides real-time visualizations of the mean (x̄) and standard deviation (σ) of asset returns, helping traders quickly identify trends and volatility in their portfolio. These visual indicators are useful for understanding the current market environment and making more informed allocation decisions. 5. Top & Bottom Performer Tables: The system generates tables that display the top and bottom performers, ranked by their Z-scores. Traders can quickly see which assets are outperforming and underperforming. These tables provide clear and actionable insights, helping traders make informed decisions about which assets to include in their portfolio. 6. Customizable Parameters: The strategy allows traders to customize several key parameters, including: Rolling Calculation Window: Set the window size for the rolling mean and standard deviation calculations. Top & Bottom Tickers: Choose how many of the top and bottom assets to display and allocate capital to. Table Orientation: Select between vertical or horizontal table formats to suit the user’s preference. 7. Forward Test & Out-of-Sample Testing: The system includes out-of-sample forward tests, ensuring that the strategy is evaluated based on real-time performance, not just historical data. This forward testing approach helps validate the robustness of the strategy in dynamic market conditions. 8. Visual Feedback and Alerts: The system provides visual feedback on the current asset rankings and allocations, with dynamic labels and plots on the chart. Additionally, users receive alerts when allocations change, keeping them informed of important adjustments. 9. Risk Management via Z-Scores and Std Dev: The system’s approach to asset selection is based on Z-scores, which normalize performance relative to the historical mean. By incorporating standard deviation, it accounts for the volatility and risk associated with each asset. This allows for more precise risk management and portfolio construction. 10. Note on Mean Reversion Strategy: If you take the inverse of the signals provided by this indicator, the strategy can be used for mean-reversion rather than trend-following. This would involve buying the underperforming assets and selling the outperforming ones. However, it's important to note that this approach does not work well with highly correlated assets, as the relationship between the assets could result in the same directional movement, undermining the effectiveness of the mean-reversion strategy. References www.uts.edu.au onlinelibrary.wiley.com www.cmegroup.com Final Thoughts The 40 Ticker Cross-Sectional Z-Scores strategy offers a data-driven approach to portfolio management, dynamically allocating capital based on the relative performance of assets. By using Z-scores and standard deviations, this strategy ensures that capital is directed to the strongest performers while avoiding weaker assets, ultimately improving the risk-adjusted returns of the portfolio. Whether you’re focused on trend-following or looking to explore mean-reversion strategies, this flexible system can be tailored to suit your investment goals.
อินดิเคเตอร์ Pine Script®
โดย BackQuant
MVRV Ratio [Alpha Extract]The MVRV Ratio Indicator provides valuable insights into Bitcoin market cycles by tracking the relationship between market value and realized value. This powerful on-chain metric helps traders identify potential market tops and bottoms, offering clear buy and sell signals based on historical patterns of Bitcoin valuation. 🔶 CALCULATION The indicator processes MVRV ratio data through several analytical methods: Raw MVRV Data: Collects MVRV data directly from INTOTHEBLOCK for Bitcoin Optional Smoothing: Applies simple moving average (SMA) to reduce noise Status Classification: Categorizes market conditions into four distinct states Signal Generation: Produces trading signals based on MVRV thresholds Price Estimation: Calculates estimated realized price (Current price / MVRV ratio) Historical Context: Compares current values to historical extremes Formula: MVRV Ratio = Market Value / Realized Value Smoothed MVRV = SMA(MVRV Ratio, Smoothing Length) Estimated Realized Price = Current Price / MVRV Ratio Distance to Top = ((3.5 / MVRV Ratio) - 1) * 100 Distance to Bottom = ((MVRV Ratio / 0.8) - 1) * 100 🔶 DETAILS Visual Features: MVRV Plot: Color-coded line showing current MVRV value (red for overvalued, orange for moderately overvalued, blue for fair value, teal for undervalued) Reference Levels: Horizontal lines indicating key MVRV thresholds (3.5, 2.5, 1.0, 0.8) Zone Highlighting: Background color changes to highlight extreme market conditions (red for potentially overvalued, blue for potentially undervalued) Information Table: Comprehensive dashboard showing current MVRV value, market status, trading signal, price information, and historical context Interpretation: MVRV ≥ 3.5: Potential market top, strong sell signal MVRV ≥ 2.5: Overvalued market, consider selling MVRV 1.5-2.5: Neutral market conditions MVRV 1.0-1.5: Fair value, consider buying MVRV < 1.0: Potential market bottom, strong buy signal 🔶 EXAMPLES Market Top Identification: When MVRV ratio exceeds 3.5, the indicator signals potential market tops, highlighting periods where Bitcoin may be significantly overvalued. Example: During bull market peaks, MVRV exceeding 3.5 has historically preceded major corrections, helping traders time their exits. Bottom Detection: MVRV values below 1.0, especially approaching 0.8, have historically marked excellent buying opportunities. Example: During bear market bottoms, MVRV falling below 1.0 has identified the most profitable entry points for long-term Bitcoin accumulation. Tracking Market Cycles: The indicator provides a clear visualization of Bitcoin's market cycles from undervalued to overvalued states. Example: Following the progression of MVRV from below 1.0 through fair value and eventually to overvalued territory helps traders position themselves appropriately throughout Bitcoin's market cycle. Realized Price Support: The estimated realized price often acts as a significant support/resistance level during market transitions. Example: During corrections, price often finds support near the realized price level calculated by the indicator, providing potential entry points. 🔶 SETTINGS Customization Options: Smoothing: Toggle smoothing option and adjust smoothing length (1-50) Table Display: Show/hide the information table Table Position: Choose between top right, top left, bottom right, or bottom left positions Visual Elements: All plots, lines, and background highlights can be customized for color and style The MVRV Ratio Indicator provides traders with a powerful on-chain metric to identify potential market tops and bottoms in Bitcoin. By tracking the relationship between market value and realized value, this indicator helps identify periods of overvaluation and undervaluation, offering clear buy and sell signals based on historical patterns. The comprehensive information table delivers valuable context about current market conditions, helping traders make more informed decisions about market positioning throughout Bitcoin's cyclical patterns.
อินดิเคเตอร์ Pine Script®
โดย AlphaExtract
1
Half Cup [LuxAlgo]The Half Cup indicator detects and displays patterns with the shape of a Half Cup , initiating a channel. From this channel, breakouts are detected and highlighted with dots. Users can control the shape of the Half Cup and the channel length through various settings. Do note that the displayed half cups are displayed retrospectively, making them subject to backpainting. 🔶 USAGE The idea behind the indicator is derived from the Cup & Handle pattern, which requires waiting for the pattern full completion. Our Half Cup publication aims to find opportunities when the potential cup is only formed halfway. In this example, a green dot shows the first breakout of the upper channel extremity. A few bars later, the price went under it, after which it returned above, triggering a second green dot. Both triggers were good opportunities in this case, and the price rose afterward. The Half Cup pattern can be the start of a potential complete Cup & Handle (As in the example above, a complete Cup pattern (without the Handle ) is shown, manually drawn with dashed lines). Every green/red dot, whether on a bullish or bearish pattern, points to a breakout respectively above/below the channel. Besides drawing patterns and the corresponding breakouts, the Half Cup indicator can also provide insights into trends and potential opportunities in the long run. 🔶 DETAILS 🔹 Validation Several criteria must be fulfilled before a visible pattern on the chart is drawn. Calculations are done beforehand to know where the Half Cup pattern would be positioned. The pattern's bottom and top edges are checked for the number of bars whose closing price is outside the half-cup area. When the number of breakouts above/below is equal to or lower than the user-defined settings ( Max % Breaks Top/Bottom ), the pattern is drawn together with a brighter-colored channel next to it. Dots highlighting the channel's breakout can be drawn from that moment until the end of both channel lines. 🔹 Positioning Users can adjust the following settings to fit their needs: % Broadness: Moves the Top/Bottom line (bullish or bearish) diagonally upwards/downwards. Vertical Shift: Shifts the entire pattern up/down. Channel Length: Sets the line length of the channel. Note that adjusting the position of the pattern will change the validation; the script will be rerun to check if patterns are still valid or if new patterns can be drawn. Some patterns may disappear, while new ones may appear. Before adjusting the position, the user can set Max % Breaks Top/Bottom at 100%. When the positioning is set, Max % Breaks Top/Bottom can be set as desired. 🔹 Updated Drawings The Half Cup pattern is always drawn retrospectively (that is it is subject to backpainting), the channel is drawn from the bar from where the pattern is detected. Every breakout of the channel will remain visible as dots. When a new swing high/low is found while the previous swing low/high remains the same, the pattern is updated to minimize clutter. The dots of earlier drawings will remain visible (to ensure no repainting occurs), but the color becomes faded, as such bright dots are associated with patterns that are visible on the chart, while faded dots are from removed/updated patterns. 🔶 SETTINGS Swing Length: Period used for the swing detection, with higher values returning longer-term Swing Levels. 🔹 Validation Max % Breaks Bottom: Allowed maximum amount of bars where the closing price is below the bottom of the Half Cup pattern against the total width of the pattern (bars). Max % Breaks Top: Allowed maximum amount of bars where the closing price is above the top of the Half Cup pattern against the total width of the pattern (bars). 🔹 Positioning % Broadness: Moves the Top/Bottom line (bullish or bearish) diagonally upwards/downwards. Vertical Shift: Shifts the entire pattern up/down. Channel Length: Sets the line length of the channel.
อินดิเคเตอร์ Pine Script®
โดย LuxAlgo
6
Weighted Moving Range with Trend Signals (WMR-TS)Weighted Moving Range with Trend Signals (WMR-TS) Technical analysis involves analyzing statistical trends from trading activity , such as price movement and volume, to make trading decisions. Technical indicators are mathematical calculations based on the price, volume, or open interest of a security or contract. They are used by traders to analyze price movements and predict future market behavior. The WMR-TS indicator combines weighted moving averages and range calculations to identify key trading levels and generate buy/sell signals. It dynamically adjusts to market conditions, offering traders insights into potential support, resistance, and trend reversal points. Key levels are color-coded for quick interpretation. It utilizes weighted moving averages (WMA) and range calculations to determine these levels, making it a robust tool for both trending and ranging markets. SUMMARY Parameters : WMA Length : Determines the length for the primary weighted moving average. Highest High Length : Sets the period for calculating the highest high. Lowest Low Length : Sets the period for calculating the lowest low. Range Corrector : Adjusts the range calculation slightly for fine-tuning. Top Level : Multiplier for determining the top level from the calculated range. Bottom Level : Multiplier for determining the bottom level from the calculated range. Levels Visibility : Sets how many recent bars will display the levels. Trading Zones : Short Area : Highlighted zone indicating potential shorting opportunities. Long Area : Highlighted zone indicating potential buying opportunities. The Levels : Wave (Yellow): Midpoint of the calculated range, adjusted by WMA. Top Level (Red): Calculated upper boundary of the trading range. Sell Level (Pink): Intermediate sell level. Resistance Level (Magenta): Immediate resistance level. Support Level (Cyan): Immediate support level. Buy Level (Light Green): Intermediate buy level. Bottom Level (Dark Green): Calculated lower boundary of the trading range. Interpreting the Signals : Hammer Signal : Red circles above bars indicate potential sell signals. Rocket Signal : Green circles below bars indicate potential buy signals. KEY CONCEPTS Highest High and Lowest Low : These values represent the highest high ( HH ) and lowest low ( LL ) over a specified number of periods. Support Level : This is the lower boundary of the trading range. It is a price level where demand is strong enough to prevent the price from falling further. As the price approaches the support level, it is likely to bounce back up. Resistance Level : This is the upper boundary of the trading range. It is a price level where supply is strong enough to prevent the price from rising further. As the price approaches the resistance level, it is likely to pull back down. THE USE OF MULTIPLIERS : The script uses several multipliers to adjust and fine-tune the calculated support and resistance levels, as well as to control the range and sensitivity of these levels. Here is a detailed explanation of these multipliers and their purpose: Range Corrector : This multiplier adjusts the calculated high ( H ) and low ( L ) levels, adding flexibility to how these levels are positioned relative to the highest high and lowest low. It ranges from -1 to 1 , with a default value of 0 . The use of positive values increase the range, making the calculated levels further apart. Thus, using negative values decrease the range, bringing the calculated levels closer together. Top Level : This multiplier adjusts the distance of the top level from the calculated high H ) level. It fluctuates from 0 to 2 , with a default value of 0.382 . Higher values will push the top level further above the high level, while lower values will bring it closer. Bottom Level : This multiplier adjusts the distance of the bottom support level from the calculated low support level. Ranging from 0 to 2, with a default value of 0.214, the higher values will push the bottom level further below the low level, while lower values will bring it closer. The script plots the support and resistance levels on the chart, allowing traders to visualize the trading range. Color-coded zones are used to indicate areas where buying or selling opportunities may arise based on the current price relative to the trading range. A trading range refers to the area between a price's support and resistance levels over a specific period of time. Within this range, the price of the security fluctuates up and down but does not break out above the resistance or below the support. Support and resistance levels to make trading decisions. Buying near the support level and selling near the resistance level is a common strategy. When the price moves above the resistance level, it is called a breakout . A breakout often indicates that the price may start a new upward trend . Conversely, when the price moves below the support level, it is called a breakdown . A breakdown often indicates that the price may start a new downward trend . By understanding and utilizing trading ranges, traders can make more informed decisions, optimize their trading strategies, and manage risk more effectively. Understanding Moving Averages A moving average (MA) is a widely used technical indicator that helps smooth out price data by creating a constantly updated average price. The main purpose of using a moving average is to identify the direction of the trend and to reduce the "noise" of random price fluctuations. The Weighted Moving Average ( WMA ) assigns different weights to each period, with more recent periods typically given more weight. A 10-day WMA might give the most recent day a weight of 10, the second most recent day a weight of 9, and so on. It is useful for traders who want to emphasize recent price data more than older data. When the price is above the moving average, it suggests an Bullish trend . A Bearish Trend is expected to take place when the price is below the moving average. Understanding the price reactions around these levels can be used to make trading decisions. APPLYING CONCEPTS Support and Resistance Calculations in the Script : The script calculates dynamic support and resistance levels using weighted moving averages ( WMA s) and the highest high and lowest low over specified periods. Buy ( Rocket ) and sell ( Hammer ) signals are generated based on the crossing of the price with calculated top and bottom levels.These signals help traders identify potential entry and exit points within the trading range . Weighted Moving Average (WMA) Application in the Script This script calculates a special trendWMA using the close price that helps in creating a more dynamic moving average that considers both high and low price actions. This modified WMA is used in conjunction with highest high and lowest low values over specified periods to calculate dynamic support and resistance levels. Explanation of the Levels in the Script By understanding these levels, traders can make more informed decisions about where to enter and exit trades, manage risk, and anticipate potential market movements. The script incorporates several key levels levels that traders can use to better anticipate price movements and make more informed trading decisions. Leveraging the principles of Fibonacci retracement ratios ( 23.6%, 38.2%, 50%, 61.8%, and 100% ) to identify key support and resistance zones can also serve for gauging the overall market sentiment. Top Level and Sell Leve l: Used to identify potential resistance zones where the price may reverse or pause. Support Level and Buy Level : Used to identify potential support zones where the price may bounce. Upper and Lower Pivot Values : Serve as intermediate levels for possible price retracements or extensions within the trading range. Wave Level : Indicates the central trend direction, which can be useful for gauging the overall market sentiment. Alerts are a crucial part of the script as they notify traders of potential buy and sell signals based on predefined conditions. There are two main alerts: one for a " Hammer " signal (sell condition) and one for a " Rocket " signal (buy condition). Adjust the input parameters to fit your trading style and the specific asset being analyzed. Shorter lengths may be more responsive to price changes but can produce more false signals , while longer lengths provide smoother signals but may lag . Always backtest the indicator on historical data to understand its behavior and performance. Also remember that different markets may require different parameter settings for optimal performance. Keep in mind that by nature like all moving averages, WMAs lag behind price action. This means that signals may be delayed. The indicator performs differently in various market conditions. Always consider the overall market context when interpreting signals. Adjusting parameters like the range corrector and visibility can help tailor the indicator to specific market conditions or trading strategies, improving its effectiveness. The script uses the calculated levels to plot lines and fill zones on the chart, helping traders visualize potential support, resistance, and trend reversal points. The use of multipliers allows for dynamic adjustment of these levels, making the indicator flexible and adaptable to different market conditions. I think traders can make more informed decisions about where to enter and exit trades, manage risk, and anticipate potential market movements following this code. Stay safe and always remember that market is always changing. Use this tool if you want, please stay informed and plan safe trades, D.
อินดิเคเตอร์ Pine Script®
โดย Dantawe
Multi Time Frame Normalized PriceEnhance Your Trading Experience with the Multi Time Frame Normalized Price Indicator Introduction As a trader, having a clear and informative chart is crucial for making informed decisions. In this post, we will introduce the Multi Time Frame Normalized Price (MTFNP) Indicator, an innovative trading tool that offers an insightful perspective on price action. The script creates a symmetric chart, with the time axis going from top to bottom, making it easier to identify potential tops and bottoms in various ranges. Let's dive deeper into this powerful tool to understand how it works and how it can improve your trading experience. The Multi Time Frame Normalized Price Indicator The MTFNP Indicator is designed to provide a comprehensive view of price action across multiple time frames. By plotting the normalized price levels for each time frame, traders can easily identify areas of support and resistance, as well as potential tops and bottoms in various ranges. One of the key features of this indicator is the symmetry of the chart. Instead of the traditional horizontal time axis, the MTFNP Indicator plots the time axis vertically from top to bottom. This innovative approach makes it easier for traders to visualize the price action across different time frames, enabling them to make more informed decisions. Benefits of a Symmetric Chart There are several advantages to using a symmetric chart with a vertical time axis, such as: Easier to read: The unique layout of the chart makes it easier to analyze price action across multiple time frames. The clear separation between each time frame helps traders avoid confusion and identify important price levels more effectively. Identifying tops and bottoms: The symmetric presentation of price action enables traders to quickly spot potential tops and bottoms in various ranges. This can be particularly useful for identifying potential reversal points or areas of support and resistance. Improved decision-making: By offering a comprehensive view of price action, the MTFNP Indicator helps traders make better-informed decisions. This can lead to improved trading strategies and ultimately, better results. The MTFNP Indicator Script The MTFNP Indicator script leverages several custom functions, including the Chebyshev Type I Moving Average, to provide a smooth and responsive signal. Additionally, the indicator uses the Spider Plot function to create a symmetric chart with the time axis going from top to bottom. To customize the MTFNP Indicator to your preferences, you can adjust the input parameters, such as the standard deviation length, multiplier, axes color, bottom color, and top color. You can also change the scale to fit your desired chart size. Exploring the Relationship between Min, Max Values and Time Frames In the Multi Time Frame Normalized Price (MTFNP) script, it is crucial to understand the relationship between the min and max values across different time frames. By analyzing how these values relate to each other, traders can make more informed decisions about market trends and potential reversals. In this section, we will dive deep into the relationship between the current time frame's min and max values and those of the further-out time frames. Interpreting Min and Max Values Across Time Frames When analyzing the min and max values of the current time frame in relation to the further-out time frames, it is essential to keep in mind the following points: All min values: If the current time frame and all further-out time frames have min values, this is a strong indication that the current price level is not just a local minimum. Instead, it is likely a more significant support level. In such cases, there is a higher probability that the price will bounce back upwards, making it a potentially favorable entry point for a long position. All max values: Conversely, if the current time frame and all further-out time frames have max values, this suggests that the current price level is not just a local maximum. Instead, it is likely a more significant resistance level. In these situations, there is a higher probability that the price will reverse downwards, making it a potentially favorable entry point for a short position. Neutral values with high current time frame: If the current time frame has a high value while the further-out time frames are more neutral, it could indicate that the trend may continue. This is because the high value in the current time frame may signify momentum in the market, whereas the neutral values in the further-out time frames suggest that the trend has not yet reached an extreme level. In this case, traders might consider following the trend and entering a position in the direction of the current movement. Neutral values with low current time frame: If the current time frame has a low value while the further-out time frames are more neutral, it could indicate that the trend may reverse. This is because the low value in the current time frame may suggest a potential reversal point, whereas the neutral values in the further-out time frames imply that the trend has not yet reached an extreme level. In this case, traders might consider entering a counter-trend position, anticipating a potential reversal. Balancing Different Time Frames for Optimal Decision Making It is essential to remember that relying solely on min and max values across different time frames can lead to potential pitfalls. The market is influenced by a wide array of factors, and no single indicator or data point can provide a complete picture. To make the most informed decisions, traders should consider incorporating additional technical analysis tools and evaluating the overall market context. Moreover, it is crucial to maintain a balance between the current time frame and the further-out time frames. While the current time frame provides information about the most recent market movements, the further-out time frames offer a broader perspective on the market's historical behavior. By combining insights from both types of time frames, traders can make more comprehensive assessments of potential opportunities and risks. Conclusion In conclusion, the Multi Time Frame Normalized Price (MTFNP) script offers traders valuable insights by analyzing the relationship between the current time frame and further-out time frames. By identifying potential trend reversals and continuations, traders can make better-informed decisions about market entry and exit points. Understanding the relationship between min and max values across different time frames is an essential component of using the MTFNP script effectively. By carefully analyzing these relationships and incorporating additional technical analysis tools, traders can improve their decision-making process and enhance their overall trading strategy. However, it is important to remember that relying solely on the MTFNP script or any single indicator can lead to potential pitfalls. The market is influenced by a wide array of factors, and no single indicator or data point can provide a complete picture. To make the most informed decisions, traders should consider using a combination of technical analysis tools, evaluating the overall market context, and maintaining a balance between the current time frame and the further-out time frames for a comprehensive understanding of the market's behavior. By doing so, they can increase their chances of success in the ever-changing and complex world of trading.
อินดิเคเตอร์ Pine Script®
โดย The_Peaceful_Lizard
Sniffer ╭━━━╮╱╱╱╱╭━╮╭━╮ ┃╭━╮┃╱╱╱╱┃╭╯┃╭╯ ┃╰━━┳━╮╭┳╯╰┳╯╰┳━━┳━╮ ╰━━╮┃╭╮╋╋╮╭┻╮╭┫┃━┫╭╯ ┃╰━╯┃┃┃┃┃┃┃╱┃┃┃┃━┫┃ ╰━━━┻╯╰┻╯╰╯╱╰╯╰━━┻╯ Overview A vast majority of modern data analysis & modelling techniques rely upon the idea of hidden patterns, wether it is some type of visualisation tool or some form of a complex machine learning algorithm, the one thing that they have in common is the belief, that patterns tell us what’s hidden behind plain numbers. The same philosophy has been adopted by many traders & investors worldwide, there’s an entire school of thought that operates purely based on chart patterns. This is where Sniffer comes in, it is a tool designed to simplify & quantify the job of pattern recognition on any given price chart, by combining various factors & techniques that generate high-quality results. This tool analyses bars selected by the user, and highlights bar clusters on the chart that exhibit similar behaviour across multiple dimensions. It can detect a single candle pattern like hammers or dojis, or it can handle multiple candles like morning/evening stars or double tops/bottoms, and many more. In fact, the tool is completely independent of such specific candle formations, instead, it works on the idea of vector similarity and generates a degree of similarity for every single combination of candles. Only the top-n matches are highlighted, users get to choose which patterns they want to analyse and to what degree, by customising the feature-space. Background In the world of trading, a common use-case is to scan a price chart for some specific candlestick formations & price structures, and then the chart is further analysed in reference to these events. Traders are often trying to answer questions like, when was the last time price showed similar behaviour, what are the instances similar to what price is doing right now, what happens when price forms a pattern like this, what were some of other indicators doing when this happened last(RSI, CCI, ADX etc), and many other abstract ideas to have a stronger confluence or to confirm a bias.Having such a context can be vital in making better informed decisions, but doing this manually on a chart that has thousands of candles can have many disadvantages. It’s tedious, human errors are rather likely, and even if it’s done with pin-point accuracy, chances are that we’ll miss out on many pieces of information. This is the thought that gave birth to Sniffer . Sniffer tries to provide a general solution for pattern-based analysis by deploying vector-similarity computation techniques, that cover the full-breadth of a price chart and generate a list of top-n matches based on the criteria selected by the user. Most of these techniques come from the data science space, where vector similarity is often implemented to solve classification & clustering problems. Sniffer uses same principles of vector comparison, and computes a degree of similarity for every single candle formation within the selected range, and as a result generates a similarity matrix that captures how similar or dissimilar a set of candles is to the input set selected by the user. How It Works A brief overview of how the tool is implemented: - Every bar is processed, and a set of features are mapped to it. - Bars selected by the user are captured, and saved for later use. - Once the all the bars have been processed, candles are back-tracked and degree of similarity is computed for every single bar(max-limit is 5000 bars). - Degree of similarity is computed by comparing attributes like price range, candle breadth & volume etc. - Similarity matrix is sorted and top-n results are highlighted on the chart through boxes of different colors. A brief overview of the features space for bars: - Range: Difference between high & low - Body: Difference between close & open - Volume: Traded volume for that candle - Head: Upper wick for green candles & lower wick for red candles - Tail: Lower wick for green candles & upper wick for red candles - BTR: Body to Range ratio - HTR: Head to Range ratio - TTR: Tail to Range ratio - HTB: Head to Body ratio - TTB: Tail to Body ratio - ROC: Rate of change for HL2 for four different periods - RSI: Relative Strength Index - CCI: Commodity Channel Index - Stochastic: Stochastic Index - ADX: DMI+, DMI- & ADX A brief overview of how degree of similarity is calculated: - Each bar set is compared to the inout bar set within the selected feature space - Features are represented as vectors, and distance between the vectors is calculated - Shorter the distance, greater the similarity - Different distance calculation methods are available to choose from, such as Cosine, Euclidean, Lorentzian, Manhattan, & Pearson - Each method is likely to generate slightly different results, users are expected to select the method & the feature space that best fits their use-case How To Use It - Usage of this tool is relatively straightforward, users can add this indicator to their chart and similar clusters will be highlighted automatically - Users need to select a time range that will be treated as input, and bars within that range become the input formation for similarity calculations - Boxes will be draw around the clusters that fit the matching criteria - Boxes are color-coded, green color boxes represent the top one-third of the top-n matches, yellow boxes represent the middle third, red boxes are for bottom third, and white box represents user-input - Boxes colors will be adjusted as you adjust input parameters, such as number of matches or look-back period User Settings Users can configure the following options: - Select the time-range to set input bars - Select the look-back period, number of candles to backtrack for similarity search - Select the number of top-n matches to show on the chart - Select the method for similarity calculation - Adjust the feature space, this enables addition of custom features, such as pattern recognition, technical indicators, rate of change etc - Toggle verbosity, shows degree of similarity as a percentage value inside the box Top Features - Pattern Agnostic: Designed to work with variable number of candles & complex patterns - Customisable Feature Space: Users get to add custom features to each bar - Comprehensive Comparison: Generates a degree of similarity for all possible combinations Final Note - Similarity matches will be shown only within last 4500 bars. - In theory, it is possible to compute similarity for any size candle formations, indicator has been tested with formations of 50+ candles, but it is recommended to select smaller range for faster & cleaner results. - As you move to smaller time frames, selected time range will provide a larger number of candles as input, which can produce undesired results, it is advised to adjust your selection when you change time frames. Seeking suggestions on how to directly receive bars as user input, instead of time range. - At times, users may see array index out of bound error when setting up this indicator, this generally happens when the input range is not properly configured. So, it should disappear after you select the input range, still trying to figure out where it is coming from, suggestions are welcome. Credits - @HeWhoMustNotBeNamed for publishing such a handy PineScript Logger, it certainly made the job a lot easier.
อินดิเคเตอร์ Pine Script®
โดย sudoMode
47
Relative Strength Index (OSC)Hello everyone, I'm sorry that the previous open-source version was hidden due to the house rules, I've re-edited the description and re-posted it (1) Indicator introduction This is RSI indicator with original divergence algorithm This indicator is plotted on the RSI and can display the divergence locations and corresponding divergence intensity The tolerance of N Klines at the top or bottom positions for price and indicator is supported, which is set by the "Tolerant Kline Number" Support the display of divergence intensity, that is, the REG/HID value displayed on the label, which is less than 0. The smaller the intensity value, the more obvious divergence Support the filtering of divergence intensity, which is set by "Cov Threshold". The divergence that REG/HID divergence intensity greater than this value will be ignored In the label, REG indicates regular top/bottom divergence while HID indicates hidden top/bottom divergence In the label, SRC(x-y) indicates a divergence occurred from the x-th kline to the y-th kline In the label, OSC(x-y) indicates a divergence occurred from the indicator corresponding to the x-th kline to the y-th kline (2) Parameter introduction - RSI Settings Source: The source to calculate RSI, close by default RSI Length: The length of RSI, 14 by default - RSI Divergence Pivot Lookback Right: Number of K-line bars recalling the pivot top/bottom point to the right Pivot Lookback Left: Number of K-line bars recalling the pivot top/bottom point to the left Max of Lookback Range: Maximum number of retracing K-line bars to find the pivot top/bottom point Min of Lookback Range: Minimum number of retracing K-line bars to find the pivot top/bottom point Tolerant Kline Number: Maximum tolerance in indexing top/bottom points of Klines and indicators Cov Threshold: Divergence intensity, which is less than 0. The smaller the intensity value, the more obvious divergence Plot Bullish: Whether to draw regular bullish divergence label Plot Hidden Bullish: Whether to draw hidden bullish divergence label Plot Bearish: Whether to draw regular bearish divergence label Plot Hidden Bearish: Whether to draw hidden bearish divergence label Happy trading and enjoy your life! ———————————————————————————————————————— 各位朋友大家好，很抱歉之前的开源版本因为规则原因被隐藏，我已经重新编辑了说明并重新发布 (1) 指标说明 该指标绘制于 RSI 上，并在对应位置显示背离点以及背离程度 支持顶底位置 N 根K线的容差，由 Tolerant Kline Number 参数设置 支持背离强度的显示，即标签上显示的 REG/HID 值，该值小于 0，且越小说明背离程度越大 支持背离强度的过滤，由 Cov Threshold 参数设置， REG/HID 值大于这个值的背离会被忽略 标签中，REG 表示常规顶/低背离，而 HID 表示隐藏顶/底背离 标签中，SRC(x-y) 表示从当前第 x 根 bar 开始到第 y 跟 bar 出现背离 标签中，OSC(x-y) 表示从当前第 x 根 bar 所对应的指标开始到第 y 跟 bar 所对应的指标出现背离 (2) 参数说明 - RSI Settings Source: 计算 RSI 指标的 source，默认为 close RSI Length: 计算 RSI 指标的长度，默认为 14 - RSI Divergence Pivot Lookback Right: 枢纽顶/底点往右回顾的 K线 bar 数量 Pivot Lookback Left: 枢纽顶/底点往左回顾的 K线 bar 数量 Max of Lookback Range: 回寻找枢纽顶/底点的最大回溯 K线 bar 数量 Min of Lookback Range: 回寻找枢纽顶/底点的最小回溯 K线 bar 数量 Tolerant Kline Number: K线和指标的顶/底点索引的最大误差 Cov Threshold: 背离程度，该值小于 0，且越小说明背离程度越大 Plot Bullish: 是否绘制常规底背离提示 Plot Hidden Bullish: 是否绘制隐藏底背离提示 Plot Bearish: 是否绘制常规顶背离提示 Plot Hidden Bearish: 是否绘制隐藏顶背离提示 祝大家交易愉快
อินดิเคเตอร์ Pine Script®
โดย dandrideng
1
Relative Strength Index (SRC)Hello everyone, I'm sorry that the previous open-source version was hidden due to the house rules, I've re-edited the description and re-posted it (1) Indicator introduction This is RSI indicator with original divergence algorithm This indicator is plotted on the klines and can display the divergence locations and corresponding divergence intensity The tolerance of N Klines at the top or bottom positions for price and indicator is supported, which is set by the "Tolerant Kline Number" Support the display of divergence intensity, that is, the REG/HID value displayed on the label, which is less than 0. The smaller the intensity value, the more obvious divergence Support the filtering of divergence intensity, which is set by "Cov Threshold". The divergence that REG/HID divergence intensity greater than this value will be ignored In the label, REG indicates regular top/bottom divergence while HID indicates hidden top/bottom divergence In the label, SRC(x-y) indicates a divergence occurred from the x-th kline to the y-th kline In the label, OSC(x-y) indicates a divergence occurred from the indicator corresponding to the x-th kline to the y-th kline (2) Parameter introduction - RSI Settings Source: The source to calculate RSI, close by default RSI Length: The length of RSI, 14 by default - RSI Divergence Pivot Lookback Right: Number of K-line bars recalling the pivot top/bottom point to the right Pivot Lookback Left: Number of K-line bars recalling the pivot top/bottom point to the left Max of Lookback Range: Maximum number of retracing K-line bars to find the pivot top/bottom point Min of Lookback Range: Minimum number of retracing K-line bars to find the pivot top/bottom point Tolerant Kline Number: Maximum tolerance in indexing top/bottom points of Klines and indicators Cov Threshold: Divergence intensity, which is less than 0. The smaller the intensity value, the more obvious divergence Plot Bullish: Whether to draw regular bullish divergence label Plot Hidden Bullish: Whether to draw hidden bullish divergence label Plot Bearish: Whether to draw regular bearish divergence label Plot Hidden Bearish: Whether to draw hidden bearish divergence label Happy trading and enjoy your life! ———————————————————————————————————————— 各位朋友大家好，很抱歉之前的开源版本因为规则原因被隐藏，我已经重新编辑了说明并重新发布 (1) 指标说明 该指标绘制于 K线 上，并在对应位置显示背离点以及背离程度 支持顶底位置 N 根K线的容差，由 Tolerant Kline Number 参数设置 支持背离强度的显示，即标签上显示的 REG/HID 值，该值小于 0，且越小说明背离程度越大 支持背离强度的过滤，由 Cov Threshold 参数设置， REG/HID 值大于这个值的背离会被忽略 标签中，REG 表示常规顶/低背离，而 HID 表示隐藏顶/底背离 标签中，SRC(x-y) 表示从当前第 x 根 bar 开始到第 y 跟 bar 出现背离 标签中，OSC(x-y) 表示从当前第 x 根 bar 所对应的指标开始到第 y 跟 bar 所对应的指标出现背离 (2) 参数说明 - RSI Settings Source: 计算 RSI 指标的 source，默认为 close RSI Length: 计算 RSI 指标的长度，默认为 14 - RSI Divergence Pivot Lookback Right: 枢纽顶/底点往右回顾的 K线 bar 数量 Pivot Lookback Left: 枢纽顶/底点往左回顾的 K线 bar 数量 Max of Lookback Range: 回寻找枢纽顶/底点的最大回溯 K线 bar 数量 Min of Lookback Range: 回寻找枢纽顶/底点的最小回溯 K线 bar 数量 Tolerant Kline Number: K线和指标的顶/底点索引的最大误差 Cov Threshold: 背离程度，该值小于 0，且越小说明背离程度越大 Plot Bullish: 是否绘制常规底背离提示 Plot Hidden Bullish: 是否绘制隐藏底背离提示 Plot Bearish: 是否绘制常规顶背离提示 Plot Hidden Bearish: 是否绘制隐藏顶背离提示 祝大家交易愉快
อินดิเคเตอร์ Pine Script®
โดย dandrideng
3