Şimdi başlat

"bar" için komut dosyalarını ara

MSFA_LibraryLibrary "MSFA_library" TODO: add library description here getDecimals()   Calculates how many decimals are on the quote price of the current market   Returns: The current decimal places on the market quote price getPipSize(multiplier)   Calculates the pip size of the current market   Parameters:      multiplier (int) : The mintick point multiplier (1 by default, 10 for FX/Crypto/CFD but can be used to override when certain markets require)   Returns: The pip size for the current market truncate(number, decimalPlaces)   Truncates (cuts) excess decimal places   Parameters:      number (float) : The number to truncate      decimalPlaces (simple float) : (default=2) The number of decimal places to truncate to   Returns: The given number truncated to the given decimalPlaces toWhole(number)   Converts pips into whole numbers   Parameters:      number (float) : The pip number to convert into a whole number   Returns: The converted number toPips(number)   Converts whole numbers back into pips   Parameters:      number (float) : The whole number to convert into pips   Returns: The converted number getPctChange(value1, value2, lookback)   Gets the percentage change between 2 float values over a given lookback period   Parameters:      value1 (float) : The first value to reference      value2 (float) : The second value to reference      lookback (int) : The lookback period to analyze   Returns: The percent change over the two values and lookback period random(minRange, maxRange)   Wichmann–Hill Pseudo-Random Number Generator   Parameters:      minRange (float) : The smallest possible number (default: 0)      maxRange (float) : The largest possible number (default: 1)   Returns: A random number between minRange and maxRange bullFib(priceLow, priceHigh, fibRatio)   Calculates a bullish fibonacci value   Parameters:      priceLow (float) : The lowest price point      priceHigh (float) : The highest price point      fibRatio (float) : The fibonacci % ratio to calculate   Returns: The fibonacci value of the given ratio between the two price points bearFib(priceLow, priceHigh, fibRatio)   Calculates a bearish fibonacci value   Parameters:      priceLow (float) : The lowest price point      priceHigh (float) : The highest price point      fibRatio (float) : The fibonacci % ratio to calculate   Returns: The fibonacci value of the given ratio between the two price points getMA(length, maType)   Gets a Moving Average based on type (! MUST BE CALLED ON EVERY TICK TO BE ACCURATE, don't place in scopes)   Parameters:      length (simple int) : The MA period      maType (string) : The type of MA   Returns: A moving average with the given parameters barsAboveMA(lookback, ma)   Counts how many candles are above the MA   Parameters:      lookback (int) : The lookback period to look back over      ma (float) : The moving average to check   Returns: The bar count of how many recent bars are above the MA barsBelowMA(lookback, ma)   Counts how many candles are below the MA   Parameters:      lookback (int) : The lookback period to look back over      ma (float) : The moving average to reference   Returns: The bar count of how many recent bars are below the EMA barsCrossedMA(lookback, ma)   Counts how many times the EMA was crossed recently (based on closing prices)   Parameters:      lookback (int) : The lookback period to look back over      ma (float) : The moving average to reference   Returns: The bar count of how many times price recently crossed the EMA (based on closing prices) getPullbackBarCount(lookback, direction)   Counts how many green & red bars have printed recently (ie. pullback count)   Parameters:      lookback (int) : The lookback period to look back over      direction (int) : The color of the bar to count (1 = Green, -1 = Red)   Returns: The bar count of how many candles have retraced over the given lookback & direction getBodySize()   Gets the current candle's body size (in POINTS, divide by 10 to get pips)   Returns: The current candle's body size in POINTS getTopWickSize()   Gets the current candle's top wick size (in POINTS, divide by 10 to get pips)   Returns: The current candle's top wick size in POINTS getBottomWickSize()   Gets the current candle's bottom wick size (in POINTS, divide by 10 to get pips)   Returns: The current candle's bottom wick size in POINTS getBodyPercent()   Gets the current candle's body size as a percentage of its entire size including its wicks   Returns: The current candle's body size percentage isHammer(fib, colorMatch)   Checks if the current bar is a hammer candle based on the given parameters   Parameters:      fib (float) : (default=0.382) The fib to base candle body on      colorMatch (bool) : (default=false) Does the candle need to be green? (true/false)   Returns: A boolean - true if the current bar matches the requirements of a hammer candle isStar(fib, colorMatch)   Checks if the current bar is a shooting star candle based on the given parameters   Parameters:      fib (float) : (default=0.382) The fib to base candle body on      colorMatch (bool) : (default=false) Does the candle need to be red? (true/false)   Returns: A boolean - true if the current bar matches the requirements of a shooting star candle isDoji(wickSize, bodySize)   Checks if the current bar is a doji candle based on the given parameters   Parameters:      wickSize (float) : (default=2) The maximum top wick size compared to the bottom (and vice versa)      bodySize (float) : (default=0.05) The maximum body size as a percentage compared to the entire candle size   Returns: A boolean - true if the current bar matches the requirements of a doji candle isBullishEC(allowance, rejectionWickSize, engulfWick)   Checks if the current bar is a bullish engulfing candle   Parameters:      allowance (float) : (default=0) How many POINTS to allow the open to be off by (useful for markets with micro gaps)      rejectionWickSize (float) : (default=disabled) The maximum rejection wick size compared to the body as a percentage      engulfWick (bool) : (default=false) Does the engulfing candle require the wick to be engulfed as well?   Returns: A boolean - true if the current bar matches the requirements of a bullish engulfing candle isBearishEC(allowance, rejectionWickSize, engulfWick)   Checks if the current bar is a bearish engulfing candle   Parameters:      allowance (float) : (default=0) How many POINTS to allow the open to be off by (useful for markets with micro gaps)      rejectionWickSize (float) : (default=disabled) The maximum rejection wick size compared to the body as a percentage      engulfWick (bool) : (default=false) Does the engulfing candle require the wick to be engulfed as well?   Returns: A boolean - true if the current bar matches the requirements of a bearish engulfing candle isInsideBar()   Detects inside bars   Returns: Returns true if the current bar is an inside bar isOutsideBar()   Detects outside bars   Returns: Returns true if the current bar is an outside bar barInSession(sess, useFilter)   Determines if the current price bar falls inside the specified session   Parameters:      sess (simple string) : The session to check      useFilter (bool) : (default=true) Whether or not to actually use this filter   Returns: A boolean - true if the current bar falls within the given time session barOutSession(sess, useFilter)   Determines if the current price bar falls outside the specified session   Parameters:      sess (simple string) : The session to check      useFilter (bool) : (default=true) Whether or not to actually use this filter   Returns: A boolean - true if the current bar falls outside the given time session dateFilter(startTime, endTime)   Determines if this bar's time falls within date filter range   Parameters:      startTime (int) : The UNIX date timestamp to begin searching from      endTime (int) : the UNIX date timestamp to stop searching from   Returns: A boolean - true if the current bar falls within the given dates dayFilter(monday, tuesday, wednesday, thursday, friday, saturday, sunday)   Checks if the current bar's day is in the list of given days to analyze   Parameters:      monday (bool) : Should the script analyze this day? (true/false)      tuesday (bool) : Should the script analyze this day? (true/false)      wednesday (bool) : Should the script analyze this day? (true/false)      thursday (bool) : Should the script analyze this day? (true/false)      friday (bool) : Should the script analyze this day? (true/false)      saturday (bool) : Should the script analyze this day? (true/false)      sunday (bool) : Should the script analyze this day? (true/false)   Returns: A boolean - true if the current bar's day is one of the given days atrFilter(atrValue, maxSize)   Parameters:      atrValue (float)      maxSize (float) tradeCount()   Calculate total trade count   Returns: Total closed trade count isLong()   Check if we're currently in a long trade   Returns: True if our position size is positive isShort()   Check if we're currently in a short trade   Returns: True if our position size is negative isFlat()   Check if we're currentlyflat   Returns: True if our position size is zero wonTrade()   Check if this bar falls after a winning trade   Returns: True if we just won a trade lostTrade()   Check if this bar falls after a losing trade   Returns: True if we just lost a trade maxDrawdownRealized()   Gets the max drawdown based on closed trades (ie. realized P&L). The strategy tester displays max drawdown as open P&L (unrealized).   Returns: The max drawdown based on closed trades (ie. realized P&L). The strategy tester displays max drawdown as open P&L (unrealized). totalPipReturn()   Gets the total amount of pips won/lost (as a whole number)   Returns: Total amount of pips won/lost (as a whole number) longWinCount()   Count how many winning long trades we've had   Returns: Long win count shortWinCount()   Count how many winning short trades we've had   Returns: Short win count longLossCount()   Count how many losing long trades we've had   Returns: Long loss count shortLossCount()   Count how many losing short trades we've had   Returns: Short loss count breakEvenCount(allowanceTicks)   Count how many break-even trades we've had   Parameters:      allowanceTicks (float) : Optional - how many ticks to allow between entry & exit price (default 0)   Returns: Break-even count longCount()   Count how many long trades we've taken   Returns: Long trade count shortCount()   Count how many short trades we've taken   Returns: Short trade count longWinPercent()   Calculate win rate of long trades   Returns: Long win rate (0-100) shortWinPercent()   Calculate win rate of short trades   Returns: Short win rate (0-100) breakEvenPercent(allowanceTicks)   Calculate break even rate of all trades   Parameters:      allowanceTicks (float) : Optional - how many ticks to allow between entry & exit price (default 0)   Returns: Break-even win rate (0-100) averageRR()   Calculate average risk:reward   Returns: Average winning trade divided by average losing trade unitsToLots(units)   (Forex) Convert the given unit count to lots (multiples of 100,000)   Parameters:      units (float) : The units to convert into lots   Returns: Units converted to nearest lot size (as float) skipTradeMonteCarlo(chance, debug)   Checks to see if trade should be skipped to emulate rudimentary Monte Carlo simulation   Parameters:      chance (float) : The chance to skip a trade (0-1 or 0-100, function will normalize to 0-1)      debug (bool) : Whether or not to display a label informing of the trade skip   Returns: True if the trade is skipped, false if it's not skipped (idea being to include this function in entry condition validation checks) fillCell(tableID, column, row, title, value, bgcolor, txtcolor, tooltip)   This updates the given table's cell with the given values   Parameters:      tableID (table) : The table ID to update      column (int) : The column to update      row (int) : The row to update      title (string) : The title of this cell      value (string) : The value of this cell      bgcolor (color) : The background color of this cell      txtcolor (color) : The text color of this cell      tooltip (string)   Returns: Nothing.
Pine Script® kütüphanesi
hphuc0212 tarafından
GEEKSDOBYTE IFVG w/ Buy/Sell Signals1. Inputs & Configuration Swing Lookback (swingLen) Controls how many bars on each side are checked to mark a swing high or swing low (default = 5). Booleans to Toggle Plotting showSwings – Show small triangle markers at swing highs/lows showFVG – Show Fair Value Gap zones showSignals – Show “BUY”/“SELL” labels when price inverts an FVG showDDLine – Show a yellow “DD” line at the close of the inversion bar showCE – Show an orange dashed “CE” line at the midpoint of the gap area 2. Swing High / Low Detection isSwingHigh = ta.pivothigh(high, swingLen, swingLen) Marks a bar as a swing high if its high is higher than the highs of the previous swingLen bars and the next swingLen bars. isSwingLow = ta.pivotlow(low, swingLen, swingLen) Marks a bar as a swing low if its low is lower than the lows of the previous and next swingLen bars. Plotting If showSwings is true, small red downward triangles appear above swing highs, and green upward triangles below swing lows. 3. Fair Value Gap (3‐Bar) Identification A Fair Value Gap (FVG) is defined here using a simple three‐bar logic (sometimes called an “inefficiency” in price): Bullish FVG (bullFVG) Checks if, two bars ago, the low of that bar (low ) is strictly greater than the current bar’s high (high). In other words: bullFVG = low > high Bearish FVG (bearFVG) Checks if, two bars ago, the high of that bar (high ) is strictly less than the current bar’s low (low). In other words: bearFVG = high < low When either condition is true, it identifies a three‐bar “gap” or unfilled imbalance in the market. 4. Drawing FVG Zones If showFVG is enabled, each time a bullish or bearish FVG is detected: Bullish FVG Zone Draws a semi‐transparent green box from the bar two bars ago (where the gap began) at low up to the current bar’s high. Bearish FVG Zone Draws a semi‐transparent red box from the bar two bars ago at high down to the current bar’s low. These colored boxes visually highlight the “fair value imbalance” area on the chart. 5. Inversion (Fill) Detection & Entry Signals An inversion is defined as the price “closing through” that previously drawn FVG: Bullish Inversion (bullInversion) Occurs when a bullish FVG was identified on bar-2 (bullFVG), and on the current bar the close is greater than that old bar-2 low: bullInversion = bullFVG and close > low Bearish Inversion (bearInversion) Occurs when a bearish FVG was identified on bar-2 (bearFVG), and on the current bar the close is lower than that old bar-2 high: bearInversion = bearFVG and close < high When an inversion is true, the indicator optionally draws two lines and a label (depending on input toggles): Draw “DD” Line (yellow, solid) Plots a horizontal yellow line from the current bar’s close price extending five bars forward (bar_index + 5). This is often referred to as a “Demand/Daily Demand” line, marking where price inverted the gap. Draw “CE” Line (orange, dashed) Calculates the midpoint (ce) of the original FVG zone. For a bullish inversion: ce = (low + high) / 2 For a bearish inversion: ce = (high + low) / 2 Plots a horizontal dashed orange line at that midpoint for five bars forward. Plot Label (“BUY” / “SELL”) If showSignals is true, a green “BUY” label is placed at the low of the current bar when a bullish inversion occurs. Likewise, a red “SELL” label at the high of the current bar when a bearish inversion happens. 6. Putting It All Together Swing Markers (Optional): Visually confirm recent swing highs and swing lows with small triangles. FVG Zones (Optional): Highlight areas where price left a 3-bar gap (bullish in green, bearish in red). Inversion Confirmation: Wait for price to close beyond the old FVG boundary. Once that happens, draw the yellow “DD” line at the close, the orange dashed “CE” line at the zone’s midpoint, and place a “BUY” or “SELL” label exactly on that bar. User Controls: All of the above elements can be individually toggled on/off (showSwings, showFVG, showSignals, showDDLine, showCE). In Practice A bullish FVG forms whenever a strong drop leaves a gap in liquidity (three bars ago low > current high). When price later “fills” that gap by closing above the old low, the script signals a potential long entry (BUY), draws a demand line at the closing price, and marks the midpoint of that gap. Conversely, a bearish FVG marks a potential short zone (three bars ago high < current low). When price closes below that gap’s high, it signals a SELL, with similar lines drawn. By combining these elements, the indicator helps users visually identify inefficiencies (FVGs), confirm when price inverts/fills them, and place straightforward buy/sell labels alongside reference lines for trade management.
Pine Script® göstergesi
RayenGeeksdoByte tarafından
1
MirPapa_Library_ICTLibrary "MirPapa_Library_ICT" GetHTFoffsetToLTFoffset(_offset, _chartTf, _htfTf)   GetHTFoffsetToLTFoffset @description Adjust an HTF offset to an LTF offset by calculating the ratio of timeframes.   Parameters:      _offset (int) : int The HTF bar offset (0 means current HTF bar).      _chartTf (string) : string The current chart’s timeframe (e.g., "5", "15", "1D").      _htfTf (string) : string The High Time Frame string (e.g., "60", "1D"). @return int The corresponding LTF bar index. Returns 0 if the result is negative. IsConditionState(_type, _isBull, _level, _open, _close, _open1, _close1, _low1, _low2, _low3, _low4, _high1, _high2, _high3, _high4)   IsConditionState @description Evaluate a condition state based on type for COB, FVG, or FOB. Overloaded: first signature handles COB, second handles FVG/FOB.   Parameters:      _type (string) : string Condition type ("cob", "fvg", "fob").      _isBull (bool) : bool Direction flag: true for bullish, false for bearish.      _level (int) : int Swing level (only used for COB).      _open (float) : float Current bar open price (only for COB).      _close (float) : float Current bar close price (only for COB).      _open1 (float) : float Previous bar open price (only for COB).      _close1 (float) : float Previous bar close price (only for COB).      _low1 (float) : float Low 1 bar ago (only for COB).      _low2 (float) : float Low 2 bars ago (only for COB).      _low3 (float) : float Low 3 bars ago (only for COB).      _low4 (float) : float Low 4 bars ago (only for COB).      _high1 (float) : float High 1 bar ago (only for COB).      _high2 (float) : float High 2 bars ago (only for COB).      _high3 (float) : float High 3 bars ago (only for COB).      _high4 (float) : float High 4 bars ago (only for COB). @return bool True if the specified condition is met, false otherwise. IsConditionState(_type, _isBull, _pricePrev, _priceNow)   IsConditionState @description Evaluate FVG or FOB condition based on price movement.   Parameters:      _type (string) : string Condition type ("fvg", "fob").      _isBull (bool) : bool Direction flag: true for bullish, false for bearish.      _pricePrev (float) : float Previous price (for FVG/FOB).      _priceNow (float) : float Current price (for FVG/FOB). @return bool True if the specified condition is met, false otherwise. IsSwingHighLow(_isBull, _level, _open, _close, _open1, _close1, _low1, _low2, _low3, _low4, _high1, _high2, _high3, _high4)   IsSwingHighLow @description Public wrapper for isSwingHighLow.   Parameters:      _isBull (bool) : bool Direction flag: true for bullish, false for bearish.      _level (int) : int Swing level (1 or 2).      _open (float) : float Current bar open price.      _close (float) : float Current bar close price.      _open1 (float) : float Previous bar open price.      _close1 (float) : float Previous bar close price.      _low1 (float) : float Low 1 bar ago.      _low2 (float) : float Low 2 bars ago.      _low3 (float) : float Low 3 bars ago.      _low4 (float) : float Low 4 bars ago.      _high1 (float) : float High 1 bar ago.      _high2 (float) : float High 2 bars ago.      _high3 (float) : float High 3 bars ago.      _high4 (float) : float High 4 bars ago. @return bool True if swing condition is met, false otherwise. AddBox(_left, _right, _top, _bot, _xloc, _colorBG, _colorBD)   AddBox @description Draw a rectangular box on the chart with specified coordinates and colors.   Parameters:      _left (int) : int Left bar index for the box.      _right (int) : int Right bar index for the box.      _top (float) : float Top price coordinate for the box.      _bot (float) : float Bottom price coordinate for the box.      _xloc (string) : string X-axis location type (e.g., xloc.bar_index).      _colorBG (color) : color Background color for the box.      _colorBD (color) : color Border color for the box. @return box Returns the created box object. Addline(_x, _y, _xloc, _color, _width)   Addline @description Draw a vertical or horizontal line at specified coordinates.   Parameters:      _x (int) : int X-coordinate for start (bar index).      _y (int) : float Y-coordinate for start (price).      _xloc (string) : string X-axis location type (e.g., xloc.bar_index).      _color (color) : color Line color.      _width (int) : int Line width. @return line Returns the created line object. Addline(_x, _y, _xloc, _color, _width)   Parameters:      _x (int)      _y (float)      _xloc (string)      _color (color)      _width (int) Addline(_x1, _y1, _x2, _y2, _xloc, _color, _width)   Parameters:      _x1 (int)      _y1 (int)      _x2 (int)      _y2 (int)      _xloc (string)      _color (color)      _width (int) Addline(_x1, _y1, _x2, _y2, _xloc, _color, _width)   Parameters:      _x1 (int)      _y1 (int)      _x2 (int)      _y2 (float)      _xloc (string)      _color (color)      _width (int) Addline(_x1, _y1, _x2, _y2, _xloc, _color, _width)   Parameters:      _x1 (int)      _y1 (float)      _x2 (int)      _y2 (int)      _xloc (string)      _color (color)      _width (int) Addline(_x1, _y1, _x2, _y2, _xloc, _color, _width)   Parameters:      _x1 (int)      _y1 (float)      _x2 (int)      _y2 (float)      _xloc (string)      _color (color)      _width (int) AddlineMid(_type, _left, _right, _top, _bot, _xloc, _color, _width)   AddlineMid @description Draw a midline between top and bottom for FVG or FOB types.   Parameters:      _type (string) : string Type identifier: "fvg" or "fob".      _left (int) : int Left bar index for midline start.      _right (int) : int Right bar index for midline end.      _top (float) : float Top price of the region.      _bot (float) : float Bottom price of the region.      _xloc (string) : string X-axis location type (e.g., xloc.bar_index).      _color (color) : color Line color.      _width (int) : int Line width. @return line or na Returns the created line or na if type is not recognized. GetHtfFromLabel(_label)   GetHtfFromLabel @description Convert a Korean HTF label into a Pine Script timeframe string via handler library.   Parameters:      _label (string) : string The Korean label (e.g., "5분", "1시간"). @return string Returns the corresponding Pine Script timeframe (e.g., "5", "60"). IsChartTFcomparisonHTF(_chartTf, _htfTf)   IsChartTFcomparisonHTF @description Determine whether a given HTF is greater than or equal to the current chart timeframe.   Parameters:      _chartTf (string) : string Current chart timeframe (e.g., "5", "15", "1D").      _htfTf (string) : string HTF timeframe (e.g., "60", "1D"). @return bool True if HTF ≥ chartTF, false otherwise. CreateBoxData(_type, _isBull, _useLine, _top, _bot, _xloc, _colorBG, _colorBD, _offset, _htfTf, htfBarIdx, _basePoint)   CreateBoxData @description Create and draw a box and optional midline for given type and parameters. Returns success flag and BoxData.   Parameters:      _type (string) : string Type identifier: "fvg", "fob", "cob", or "sweep".      _isBull (bool) : bool Direction flag: true for bullish, false for bearish.      _useLine (bool) : bool Whether to draw a midline inside the box.      _top (float) : float Top price of the box region.      _bot (float) : float Bottom price of the box region.      _xloc (string) : string X-axis location type (e.g., xloc.bar_index).      _colorBG (color) : color Background color for the box.      _colorBD (color) : color Border color for the box.      _offset (int) : int HTF bar offset (0 means current HTF bar).      _htfTf (string) : string HTF timeframe string (e.g., "60", "1D").      htfBarIdx (int) : int HTF bar_index (passed from HTF request).      _basePoint (float) : float Base point for breakout checks. @return tuple(bool, BoxData) Returns a boolean indicating success and the created BoxData struct. ProcessBoxDatas(_datas, _useMidLine, _closeCount, _colorClose)   ProcessBoxDatas @description Process an array of BoxData structs: extend, record volume, update stage, and finalize boxes.   Parameters:      _datas (array) : array Array of BoxData objects to process.      _useMidLine (bool) : bool Whether to update the midline endpoint.      _closeCount (int) : int Number of touches required to close the box.      _colorClose (color) : color Color to apply when a box closes. @return void No return value; updates are in-place. BoxData   Fields:      _isActive (series bool)      _isBull (series bool)      _box (series box)      _line (series line)      _basePoint (series float)      _boxTop (series float)      _boxBot (series float)      _stage (series int)      _isStay (series bool)      _volBuy (series float)      _volSell (series float)      _result (series string) LineData   Fields:      _isActive (series bool)      _isBull (series bool)      _line (series line)      _basePoint (series float)      _stage (series int)      _isStay (series bool)      _result (series string)
Pine Script® kütüphanesi
goodia tarafından
LinearRegressionLibrary "LinearRegression" Calculates a variety of linear regression and deviation types, with optional emphasis weighting. Additionally, multiple of slope and Pearson’s R calculations. calcSlope(_src, _len, _condition)   Calculates the slope of a linear regression over the specified length.   Parameters:      _src (float) : (float) The source data.      _len (int) : (int) The length of the lookback period for the linear regression.      _condition (bool) : (bool) Flag to enable calculation. Set to true to calculate on every bar; otherwise, set to barstate.islast for efficiency.   Returns: (float) The slope of the linear regression. calcReg(_src, _len, _condition)   Calculates a basic linear regression, returning y1, y2, slope, and average.   Parameters:      _src (float) : (float) The source data series.      _len (int) : (int) The length of the lookback period.      _condition (bool) : (bool) Flag to enable calculation (true = calculate).   Returns: (float ) An array of 4 values: . calcRegStandard(_src, _len, _emphasis, _condition)   Calculates an Standard linear regression with optional emphasis.   Parameters:      _src (float) : (series float) The source data series.      _len (int) : (int) The length of the lookback period.      _emphasis (float) : (float) The emphasis factor: 0 for equal weight; >0 emphasizes recent bars; <0 emphasizes older bars.      _condition (bool) : (bool) Flag to enable calculation (true = calculate).   Returns: (float ) . calcRegRidge(_src, _len, lambda, _emphasis, _condition)   Calculates a ridge regression with optional emphasis.   Parameters:      _src (float) : (float) The source data series.      _len (int) : (int) The length of the lookback period.      lambda (float) : (float) The ridge regularization parameter.      _emphasis (float) : (float) The emphasis factor: 0 for equal weight; >0 emphasizes recent bars; <0 emphasizes older bars.      _condition (bool) : (bool) Flag to enable calculation (true = calculate).   Returns: (float ) . calcRegLasso(_src, _len, lambda, _emphasis, _condition)   Calculates a Lasso regression with optional emphasis.   Parameters:      _src (float) : (float) The source data series.      _len (int) : (int) The length of the lookback period.      lambda (float) : (float) The Lasso regularization parameter.      _emphasis (float) : (float) The emphasis factor: 0 for equal weight; >0 emphasizes recent bars; <0 emphasizes older bars.      _condition (bool) : (bool) Flag to enable calculation (true = calculate).   Returns: (float ) . calcElasticNetLinReg(_src, _len, lambda1, lambda2, _emphasis, _condition)   Calculates an Elastic Net regression with optional emphasis.   Parameters:      _src (float) : (float) The source data series.      _len (int) : (int) The length of the lookback period.      lambda1 (float) : (float) L1 regularization parameter (Lasso).      lambda2 (float) : (float) L2 regularization parameter (Ridge).      _emphasis (float) : (float) Emphasis factor: 0 for equal weight; >0 emphasizes recent bars; <0 emphasizes older bars.      _condition (bool) : (bool) Flag to enable calculation (true = calculate).   Returns: (float ) . calcRegHuber(_src, _len, delta, iterations, _emphasis, _condition)   Calculates a Huber regression using Iteratively Reweighted Least Squares (IRLS).   Parameters:      _src (float) : (float) The source data series.      _len (int) : (int) The length of the lookback period.      delta (float) : (float) Huber threshold parameter.      iterations (int) : (int) Number of IRLS iterations.      _emphasis (float) : (float) Emphasis factor: 0 for equal weight; >0 emphasizes recent bars; <0 emphasizes older bars.      _condition (bool) : (bool) Flag to enable calculation (true = calculate).   Returns: (float ) . calcRegLAD(_src, _len, iterations, _emphasis, _condition)   Calculates a Least Absolute Deviations (LAD) regression via IRLS.   Parameters:      _src (float) : (float) The source data series.      _len (int) : (int) The length of the lookback period.      iterations (int) : (int) Number of IRLS iterations for LAD.      _emphasis (float) : (float) Emphasis factor: 0 for equal weight; >0 emphasizes recent bars; <0 emphasizes older bars.      _condition (bool) : (bool) Flag to enable calculation (true = calculate).   Returns: (float ) . calcRegBayesian(_src, _len, priorMean, priorSpan, sigma, _emphasis, _condition)   Calculates a Bayesian linear regression with optional emphasis.   Parameters:      _src (float) : (float) The source data series.      _len (int) : (int) The length of the lookback period.      priorMean (float) : (float) The prior mean for the slope.      priorSpan (float) : (float) The prior variance (or span) for the slope.      sigma (float) : (float) The assumed standard deviation of residuals.      _emphasis (float) : (float) Emphasis factor: 0 for equal weight; >0 emphasizes recent bars; <0 emphasizes older bars.      _condition (bool) : (bool) Flag to enable calculation (true = calculate).   Returns: (float ) . calcRFromLinReg(_src, _len, _slope, _average, _y1, _condition)   Calculates the Pearson correlation coefficient (R) based on linear regression parameters.   Parameters:      _src (float) : (float) The source data.      _len (int) : (int) The length of the lookback period.      _slope (float) : (float) The slope of the linear regression.      _average (float) : (float) The average value of the source data series.      _y1 (float) : (float) The starting point (y-intercept of the oldest bar) for the linear regression.      _condition (bool) : (bool) Flag to enable calculation. Set to true to calculate on every bar; otherwise, set to barstate.islast for efficiency.   Returns: (float) The Pearson correlation coefficient (R) adjusted for the direction of the slope. calcRFromSource(_src, _len, _condition)   Calculates the correlation coefficient (R) using a specified length and source data.   Parameters:      _src (float) : (float) The source data.      _len (int) : (int) The length of the lookback period.      _condition (bool) : (bool) Flag to enable calculation. Set to true to calculate on every bar; otherwise, set to barstate.islast for efficiency.   Returns: (float) The correlation coefficient (R). calcSlopeLengthZero(_src, _len, _minLen, _step, _condition)   Identifies the length at which the slope is flattest (closest to zero).   Parameters:      _src (float) : (float) The source data.      _len (int) : (int) The maximum lookback length to consider (minimum of 2).      _minLen (int) : (int) The minimum length to start from (cannot exceed the max length).      _step (int) : (int) The increment step for lengths.      _condition (bool) : (bool) Flag to enable calculation. Set to true to calculate on every bar; otherwise, set to barstate.islast.   Returns: (int) The length at which the slope is flattest. calcSlopeLengthHighest(_src, _len, _minLen, _step, _condition)   Identifies the length at which the slope is highest.   Parameters:      _src (float) : (float) The source data.      _len (int) : (int) The maximum lookback length (minimum of 2).      _minLen (int) : (int) The minimum length to start from.      _step (int) : (int) The step for incrementing lengths.      _condition (bool) : (bool) Flag to enable calculation. Set to true to calculate on every bar; otherwise, set to barstate.islast.   Returns: (int) The length at which the slope is highest. calcSlopeLengthLowest(_src, _len, _minLen, _step, _condition)   Identifies the length at which the slope is lowest.   Parameters:      _src (float) : (float) The source data.      _len (int) : (int) The maximum lookback length (minimum of 2).      _minLen (int) : (int) The minimum length to start from.      _step (int) : (int) The step for incrementing lengths.      _condition (bool) : (bool) Flag to enable calculation. Set to true to calculate on every bar; otherwise, set to barstate.islast.   Returns: (int) The length at which the slope is lowest. calcSlopeLengthAbsolute(_src, _len, _minLen, _step, _condition)   Identifies the length at which the absolute slope value is highest.   Parameters:      _src (float) : (float) The source data.      _len (int) : (int) The maximum lookback length (minimum of 2).      _minLen (int) : (int) The minimum length to start from.      _step (int) : (int) The step for incrementing lengths.      _condition (bool) : (bool) Flag to enable calculation. Set to true to calculate on every bar; otherwise, set to barstate.islast.   Returns: (int) The length at which the absolute slope value is highest. calcRLengthZero(_src, _len, _minLen, _step, _condition)   Identifies the length with the lowest absolute R value.   Parameters:      _src (float) : (float) The source data.      _len (int) : (int) The maximum lookback length (minimum of 2).      _minLen (int) : (int) The minimum length to start from.      _step (int) : (int) The step for incrementing lengths.      _condition (bool) : (bool) Flag to enable calculation. Set to true to calculate on every bar; otherwise, set to barstate.islast.   Returns: (int) The length with the lowest absolute R value. calcRLengthHighest(_src, _len, _minLen, _step, _condition)   Identifies the length with the highest R value.   Parameters:      _src (float) : (float) The source data.      _len (int) : (int) The maximum lookback length (minimum of 2).      _minLen (int) : (int) The minimum length to start from.      _step (int) : (int) The step for incrementing lengths.      _condition (bool) : (bool) Flag to enable calculation. Set to true to calculate on every bar; otherwise, set to barstate.islast.   Returns: (int) The length with the highest R value. calcRLengthLowest(_src, _len, _minLen, _step, _condition)   Identifies the length with the lowest R value.   Parameters:      _src (float) : (float) The source data.      _len (int) : (int) The maximum lookback length (minimum of 2).      _minLen (int) : (int) The minimum length to start from.      _step (int) : (int) The step for incrementing lengths.      _condition (bool) : (bool) Flag to enable calculation. Set to true to calculate on every bar; otherwise, set to barstate.islast.   Returns: (int) The length with the lowest R value. calcRLengthAbsolute(_src, _len, _minLen, _step, _condition)   Identifies the length with the highest absolute R value.   Parameters:      _src (float) : (float) The source data.      _len (int) : (int) The maximum lookback length (minimum of 2).      _minLen (int) : (int) The minimum length to start from.      _step (int) : (int) The step for incrementing lengths.      _condition (bool) : (bool) Flag to enable calculation. Set to true to calculate on every bar; otherwise, set to barstate.islast.   Returns: (int) The length with the highest absolute R value. calcDevReverse(_src, _len, _slope, _y1, _inputDev, _emphasis, _condition)   Calculates the regressive linear deviation in reverse order, with optional emphasis on recent data.   Parameters:      _src (float) : (float) The source data.      _len (int) : (int) The length of the lookback period.      _slope (float) : (float) The slope of the linear regression.      _y1 (float) : (float) The y-intercept (oldest bar) of the linear regression.      _inputDev (float) : (float) The input deviation multiplier.      _emphasis (float) : (float) Emphasis factor: 0 for equal weight; >0 emphasizes recent bars; <0 emphasizes older bars.      _condition (bool) : (bool) Flag to enable calculation (true = calculate).   Returns: A 2-element tuple: . calcDevForward(_src, _len, _slope, _y1, _inputDev, _emphasis, _condition)   Calculates the progressive linear deviation in forward order (oldest to most recent bar), with optional emphasis.   Parameters:      _src (float) : (float) The source data array, where _src is oldest and _src is most recent.      _len (int) : (int) The length of the lookback period.      _slope (float) : (float) The slope of the linear regression.      _y1 (float) : (float) The y-intercept of the linear regression (value at the most recent bar, adjusted by slope).      _inputDev (float) : (float) The input deviation multiplier.      _emphasis (float) : (float) Emphasis factor: 0 for equal weight; >0 emphasizes recent bars; <0 emphasizes older bars.      _condition (bool) : (bool) Flag to enable calculation (true = calculate).   Returns: A 2-element tuple: . calcDevBalanced(_src, _len, _slope, _y1, _inputDev, _emphasis, _condition)   Calculates the balanced linear deviation with optional emphasis on recent or older data.   Parameters:      _src (float) : (float) Source data array, where _src is the most recent and _src is the oldest.      _len (int) : (int) The length of the lookback period.      _slope (float) : (float) The slope of the linear regression.      _y1 (float) : (float) The y-intercept of the linear regression (value at the oldest bar).      _inputDev (float) : (float) The input deviation multiplier.      _emphasis (float) : (float) Emphasis factor: 0 for equal weight; >0 emphasizes recent bars; <0 emphasizes older bars.      _condition (bool) : (bool) Flag to enable calculation (true = calculate).   Returns: A 2-element tuple: . calcDevMean(_src, _len, _slope, _y1, _inputDev, _emphasis, _condition)   Calculates the mean absolute deviation from a forward-applied linear trend (oldest to most recent), with optional emphasis.   Parameters:      _src (float) : (float) The source data array, where _src is the most recent and _src is the oldest.      _len (int) : (int) The length of the lookback period.      _slope (float) : (float) The slope of the linear regression.      _y1 (float) : (float) The y-intercept (oldest bar) of the linear regression.      _inputDev (float) : (float) The input deviation multiplier.      _emphasis (float) : (float) Emphasis factor: 0 for equal weight; >0 emphasizes recent bars; <0 emphasizes older bars.      _condition (bool) : (bool) Flag to enable calculation (true = calculate).   Returns: A 2-element tuple: . calcDevMedian(_src, _len, _slope, _y1, _inputDev, _emphasis, _condition)   Calculates the median absolute deviation with optional emphasis on recent data.   Parameters:      _src (float) : (float) The source data array (index 0 = oldest, index _len - 1 = most recent).      _len (int) : (int) The length of the lookback period.      _slope (float) : (float) The slope of the linear regression.      _y1 (float) : (float) The y-intercept (oldest bar) of the linear regression.      _inputDev (float) : (float) The deviation multiplier.      _emphasis (float) : (float) Emphasis factor: 0 for equal weight; >0 emphasizes recent bars; <0 emphasizes older bars.      _condition (bool) : (bool) Flag to enable calculation (true = calculate).   Returns: calcDevPercent(_y1, _inputDev, _condition)   Calculates the percent deviation from a given value and a specified percentage.   Parameters:      _y1 (float) : (float) The base value from which to calculate deviation.      _inputDev (float) : (float) The deviation percentage.      _condition (bool) : (bool) Flag to enable calculation (true = calculate).   Returns: A 2-element tuple: . calcDevFitted(_len, _slope, _y1, _emphasis, _condition)   Calculates the weighted fitted deviation based on high and low series data, showing max deviation, with optional emphasis.   Parameters:      _len (int) : (int) The length of the lookback period.      _slope (float) : (float) The slope of the linear regression.      _y1 (float) : (float) The Y-intercept (oldest bar) of the linear regression.      _emphasis (float) : (float) Emphasis factor: 0 for equal weight; >0 emphasizes recent bars; <0 emphasizes older bars.      _condition (bool) : (bool) Flag to enable calculation (true = calculate).   Returns: A 2-element tuple: . calcDevATR(_src, _len, _slope, _y1, _inputDev, _emphasis, _condition)   Calculates an ATR-style deviation with optional emphasis on recent data.   Parameters:      _src (float) : (float) The source data (typically close).      _len (int) : (int) The length of the lookback period.      _slope (float) : (float) The slope of the linear regression.      _y1 (float) : (float) The Y-intercept (oldest bar) of the linear regression.      _inputDev (float) : (float) The input deviation multiplier.      _emphasis (float) : (float) Emphasis factor: 0 for equal weight; >0 emphasizes recent bars; <0 emphasizes older bars.      _condition (bool) : (bool) Flag to enable calculation (true = calculate).   Returns: A 2-element tuple: . calcPricePositionPercent(_top, _bot, _src)   Calculates the percent position of a price within a linear regression channel. Top=100%, Bottom=0%.   Parameters:      _top (float) : (float) The top (positive) deviation, corresponding to 100%.      _bot (float) : (float) The bottom (negative) deviation, corresponding to 0%.      _src (float) : (float) The source price.   Returns: (float) The percent position within the channel. plotLinReg(_len, _y1, _y2, _slope, _devTop, _devBot, _scaleTypeLog, _lineWidth, _extendLines, _channelStyle, _colorFill, _colUpLine, _colDnLine, _colUpFill, _colDnFill)   Plots the linear regression line and its deviations, with configurable styles and fill.   Parameters:      _len (int) : (int) The lookback period for the linear regression.      _y1 (float) : (float) The starting y-value of the regression line.      _y2 (float) : (float) The ending y-value of the regression line.      _slope (float) : (float) The slope of the regression line (used to determine line color).      _devTop (float) : (float) The top deviation to add to the line.      _devBot (float) : (float) The bottom deviation to subtract from the line.      _scaleTypeLog (bool) : (bool) Use a log scale if true; otherwise, linear scale.      _lineWidth (int) : (int) The width of the plotted lines.      _extendLines (string) : (string) How lines should extend (none, left, right, both).      _channelStyle (string) : (string) The style of the channel lines (solid, dashed, dotted).      _colorFill (bool) : (bool) Whether to fill the space between the top and bottom deviation lines.      _colUpLine (color) : (color) Line color when slope is positive.      _colDnLine (color) : (color) Line color when slope is negative.      _colUpFill (color) : (color) Fill color when slope is positive.      _colDnFill (color) : (color) Fill color when slope is negative.
Pine Script® kütüphanesi
TanHef tarafından
2
Exposure Oscillator (Cumulative 0 to ±100%) Exposure Oscillator (Cumulative 0 to ±100%) This Pine Script indicator plots an "Exposure Oscillator" on the chart, which tracks the cumulative market exposure from a range of technical buy and sell signals. The exposure is measured on a scale from -100% (maximum short exposure) to +100% (maximum long exposure), helping traders assess the strength of their position in the market. It provides an intuitive visual cue to aid decision-making for trend-following strategies. Buy Signals (Increase Exposure Score by +10%) Buy Signal 1 (Cross Above 21 EMA): This signal is triggered when the price crosses above the 21-period Exponential Moving Average (EMA), where the current bar closes above the EMA21, and the previous bar closed below the EMA21. This indicates a potential upward price movement as the market shifts into a bullish trend. buySignal1 = ta.crossover(close, ema21) Buy Signal 2 (Trending Above 21 EMA): This signal is triggered when the price closes above the 21-period EMA for each of the last 5 bars, indicating a sustained bullish trend. It confirms that the price is consistently above the EMA21 for a significant period. buySignal2 = ta.barssince(close <= ema21) > 5 Buy Signal 3 (Living Above 21 EMA): This signal is triggered when the price has closed above the 21-period EMA for each of the last 15 bars, demonstrating a strong, prolonged uptrend. buySignal3 = ta.barssince(close <= ema21) > 15 Buy Signal 4 (Cross Above 50 SMA): This signal is triggered when the price crosses above the 50-period Simple Moving Average (SMA), where the current bar closes above the 50 SMA, and the previous bar closed below it. It indicates a shift toward bullish momentum. buySignal4 = ta.crossover(close, sma50) Buy Signal 5 (Cross Above 200 SMA): This signal is triggered when the price crosses above the 200-period Simple Moving Average (SMA), where the current bar closes above the 200 SMA, and the previous bar closed below it. This suggests a long-term bullish trend. buySignal5 = ta.crossover(close, sma200) Buy Signal 6 (Low Above 50 SMA): This signal is true when the lowest price of the current bar is above the 50-period SMA, indicating strong bullish pressure as the price maintains itself above the moving average. buySignal6 = low > sma50 Buy Signal 7 (Accumulation Day): An accumulation day occurs when the closing price is in the upper half of the daily range (greater than 50%) and the volume is larger than the previous bar's volume, suggesting buying pressure and accumulation. buySignal7 = (close - low) / (high - low) > 0.5 and volume > volume Buy Signal 8 (Higher High): This signal occurs when the current bar’s high exceeds the highest high of the previous 14 bars, indicating a breakout or strong upward momentum. buySignal8 = high > ta.highest(high, 14) Buy Signal 9 (Key Reversal Bar): This signal is generated when the stock opens below the low of the previous bar but rallies to close above the previous bar’s high, signaling a potential reversal from bearish to bullish. buySignal9 = open < low and close > high Buy Signal 10 (Distribution Day Fall Off): This signal is triggered when a distribution day (a day with high volume and a close near the low of the range) "falls off" the rolling 25-bar period, indicating the end of a bearish trend or selling pressure. buySignal10 = ta.barssince(close < sma50 and close < sma50) > 25 Sell Signals (Decrease Exposure Score by -10%) Sell Signal 1 (Cross Below 21 EMA): This signal is triggered when the price crosses below the 21-period Exponential Moving Average (EMA), where the current bar closes below the EMA21, and the previous bar closed above it. It suggests that the market may be shifting from a bullish trend to a bearish trend. sellSignal1 = ta.crossunder(close, ema21) Sell Signal 2 (Trending Below 21 EMA): This signal is triggered when the price closes below the 21-period EMA for each of the last 5 bars, indicating a sustained bearish trend. sellSignal2 = ta.barssince(close >= ema21) > 5 Sell Signal 3 (Living Below 21 EMA): This signal is triggered when the price has closed below the 21-period EMA for each of the last 15 bars, suggesting a strong downtrend. sellSignal3 = ta.barssince(close >= ema21) > 15 Sell Signal 4 (Cross Below 50 SMA): This signal is triggered when the price crosses below the 50-period Simple Moving Average (SMA), where the current bar closes below the 50 SMA, and the previous bar closed above it. It indicates the start of a bearish trend. sellSignal4 = ta.crossunder(close, sma50) Sell Signal 5 (Cross Below 200 SMA): This signal is triggered when the price crosses below the 200-period Simple Moving Average (SMA), where the current bar closes below the 200 SMA, and the previous bar closed above it. It indicates a long-term bearish trend. sellSignal5 = ta.crossunder(close, sma200) Sell Signal 6 (High Below 50 SMA): This signal is true when the highest price of the current bar is below the 50-period SMA, indicating weak bullishness or a potential bearish reversal. sellSignal6 = high < sma50 Sell Signal 7 (Distribution Day): A distribution day is identified when the closing range of a bar is less than 50% and the volume is larger than the previous bar's volume, suggesting that selling pressure is increasing. sellSignal7 = (close - low) / (high - low) < 0.5 and volume > volume Sell Signal 8 (Lower Low): This signal occurs when the current bar's low is less than the lowest low of the previous 14 bars, indicating a breakdown or strong downward momentum. sellSignal8 = low < ta.lowest(low, 14) Sell Signal 9 (Downside Reversal Bar): A downside reversal bar occurs when the stock opens above the previous bar's high but falls to close below the previous bar’s low, signaling a reversal from bullish to bearish. sellSignal9 = open > high and close < low Sell Signal 10 (Distribution Cluster): This signal is triggered when a distribution day occurs three times in the rolling 7-bar period, indicating significant selling pressure. sellSignal10 = ta.valuewhen((close < low) and volume > volume , 1, 7) >= 3 Theme Mode: Users can select the theme mode (Auto, Dark, or Light) to match the chart's background or to manually choose a light or dark theme for the oscillator's appearance. Exposure Score Calculation: The script calculates a cumulative exposure score based on a series of buy and sell signals. Buy signals increase the exposure score, while sell signals decrease it. Each signal impacts the score by ±10%. Signal Conditions: The buy and sell signals are derived from multiple conditions, including crossovers with moving averages (EMA21, SMA50, SMA200), trend behavior, and price/volume analysis. Oscillator Visualization: The exposure score is visualized as a line on the chart, changing color based on whether the exposure is positive (long position) or negative (short position). It is limited to the range of -100% to +100%. Position Type: The indicator also indicates the position type based on the exposure score, labeling it as "Long," "Short," or "Neutral." Horizontal Lines: Reference lines at 0%, 100%, and -100% visually mark neutral, increasing long, and increasing short exposure levels. Exposure Table: A table displays the current exposure level (in percentage) and position type ("Long," "Short," or "Neutral"), updated dynamically based on the oscillator’s value. Inputs: Theme Mode: Choose "Auto" to use the default chart theme, or manually select "Dark" or "Light." Usage: This oscillator is designed to help traders track market sentiment, gauge exposure levels, and manage risk. It can be used for long-term trend-following strategies or short-term trades based on moving average crossovers and volume analysis. The oscillator operates in conjunction with the chart’s price action and provides a visual representation of the market’s current trend strength and exposure. Important Considerations: Risk Management: While the exposure score provides valuable insight, it should be combined with other risk management tools and analysis for optimal trading decisions. Signal Sensitivity: The accuracy and effectiveness of the signals depend on market conditions and may require adjustments based on the user’s trading strategy or timeframe. Disclaimer: This script is for educational purposes only. Trading involves significant risk, and users should carefully evaluate all market conditions and apply appropriate risk management strategies before using this tool in live trading environments.
Pine Script® göstergesi
starshiptrade tarafından
JordanSwindenLibraryLibrary "JordanSwindenLibrary" TODO: add library description here getDecimals()   Calculates how many decimals are on the quote price of the current market   Returns: The current decimal places on the market quote price getPipSize(multiplier)   Calculates the pip size of the current market   Parameters:      multiplier (int) : The mintick point multiplier (1 by default, 10 for FX/Crypto/CFD but can be used to override when certain markets require)   Returns: The pip size for the current market truncate(number, decimalPlaces)   Truncates (cuts) excess decimal places   Parameters:      number (float) : The number to truncate      decimalPlaces (simple float) : (default=2) The number of decimal places to truncate to   Returns: The given number truncated to the given decimalPlaces toWhole(number)   Converts pips into whole numbers   Parameters:      number (float) : The pip number to convert into a whole number   Returns: The converted number toPips(number)   Converts whole numbers back into pips   Parameters:      number (float) : The whole number to convert into pips   Returns: The converted number getPctChange(value1, value2, lookback)   Gets the percentage change between 2 float values over a given lookback period   Parameters:      value1 (float) : The first value to reference      value2 (float) : The second value to reference      lookback (int) : The lookback period to analyze   Returns: The percent change over the two values and lookback period random(minRange, maxRange)   Wichmann–Hill Pseudo-Random Number Generator   Parameters:      minRange (float) : The smallest possible number (default: 0)      maxRange (float) : The largest possible number (default: 1)   Returns: A random number between minRange and maxRange bullFib(priceLow, priceHigh, fibRatio)   Calculates a bullish fibonacci value   Parameters:      priceLow (float) : The lowest price point      priceHigh (float) : The highest price point      fibRatio (float) : The fibonacci % ratio to calculate   Returns: The fibonacci value of the given ratio between the two price points bearFib(priceLow, priceHigh, fibRatio)   Calculates a bearish fibonacci value   Parameters:      priceLow (float) : The lowest price point      priceHigh (float) : The highest price point      fibRatio (float) : The fibonacci % ratio to calculate   Returns: The fibonacci value of the given ratio between the two price points getMA(length, maType)   Gets a Moving Average based on type (! MUST BE CALLED ON EVERY TICK TO BE ACCURATE, don't place in scopes)   Parameters:      length (simple int) : The MA period      maType (string) : The type of MA   Returns: A moving average with the given parameters barsAboveMA(lookback, ma)   Counts how many candles are above the MA   Parameters:      lookback (int) : The lookback period to look back over      ma (float) : The moving average to check   Returns: The bar count of how many recent bars are above the MA barsBelowMA(lookback, ma)   Counts how many candles are below the MA   Parameters:      lookback (int) : The lookback period to look back over      ma (float) : The moving average to reference   Returns: The bar count of how many recent bars are below the EMA barsCrossedMA(lookback, ma)   Counts how many times the EMA was crossed recently (based on closing prices)   Parameters:      lookback (int) : The lookback period to look back over      ma (float) : The moving average to reference   Returns: The bar count of how many times price recently crossed the EMA (based on closing prices) getPullbackBarCount(lookback, direction)   Counts how many green & red bars have printed recently (ie. pullback count)   Parameters:      lookback (int) : The lookback period to look back over      direction (int) : The color of the bar to count (1 = Green, -1 = Red)   Returns: The bar count of how many candles have retraced over the given lookback & direction getBodySize()   Gets the current candle's body size (in POINTS, divide by 10 to get pips)   Returns: The current candle's body size in POINTS getTopWickSize()   Gets the current candle's top wick size (in POINTS, divide by 10 to get pips)   Returns: The current candle's top wick size in POINTS getBottomWickSize()   Gets the current candle's bottom wick size (in POINTS, divide by 10 to get pips)   Returns: The current candle's bottom wick size in POINTS getBodyPercent()   Gets the current candle's body size as a percentage of its entire size including its wicks   Returns: The current candle's body size percentage isHammer(fib, colorMatch)   Checks if the current bar is a hammer candle based on the given parameters   Parameters:      fib (float) : (default=0.382) The fib to base candle body on      colorMatch (bool) : (default=false) Does the candle need to be green? (true/false)   Returns: A boolean - true if the current bar matches the requirements of a hammer candle isStar(fib, colorMatch)   Checks if the current bar is a shooting star candle based on the given parameters   Parameters:      fib (float) : (default=0.382) The fib to base candle body on      colorMatch (bool) : (default=false) Does the candle need to be red? (true/false)   Returns: A boolean - true if the current bar matches the requirements of a shooting star candle isDoji(wickSize, bodySize)   Checks if the current bar is a doji candle based on the given parameters   Parameters:      wickSize (float) : (default=2) The maximum top wick size compared to the bottom (and vice versa)      bodySize (float) : (default=0.05) The maximum body size as a percentage compared to the entire candle size   Returns: A boolean - true if the current bar matches the requirements of a doji candle isBullishEC(allowance, rejectionWickSize, engulfWick)   Checks if the current bar is a bullish engulfing candle   Parameters:      allowance (float) : (default=0) How many POINTS to allow the open to be off by (useful for markets with micro gaps)      rejectionWickSize (float) : (default=disabled) The maximum rejection wick size compared to the body as a percentage      engulfWick (bool) : (default=false) Does the engulfing candle require the wick to be engulfed as well?   Returns: A boolean - true if the current bar matches the requirements of a bullish engulfing candle isBearishEC(allowance, rejectionWickSize, engulfWick)   Checks if the current bar is a bearish engulfing candle   Parameters:      allowance (float) : (default=0) How many POINTS to allow the open to be off by (useful for markets with micro gaps)      rejectionWickSize (float) : (default=disabled) The maximum rejection wick size compared to the body as a percentage      engulfWick (bool) : (default=false) Does the engulfing candle require the wick to be engulfed as well?   Returns: A boolean - true if the current bar matches the requirements of a bearish engulfing candle isInsideBar()   Detects inside bars   Returns: Returns true if the current bar is an inside bar isOutsideBar()   Detects outside bars   Returns: Returns true if the current bar is an outside bar barInSession(sess, useFilter)   Determines if the current price bar falls inside the specified session   Parameters:      sess (simple string) : The session to check      useFilter (bool) : (default=true) Whether or not to actually use this filter   Returns: A boolean - true if the current bar falls within the given time session barOutSession(sess, useFilter)   Determines if the current price bar falls outside the specified session   Parameters:      sess (simple string) : The session to check      useFilter (bool) : (default=true) Whether or not to actually use this filter   Returns: A boolean - true if the current bar falls outside the given time session dateFilter(startTime, endTime)   Determines if this bar's time falls within date filter range   Parameters:      startTime (int) : The UNIX date timestamp to begin searching from      endTime (int) : the UNIX date timestamp to stop searching from   Returns: A boolean - true if the current bar falls within the given dates dayFilter(monday, tuesday, wednesday, thursday, friday, saturday, sunday)   Checks if the current bar's day is in the list of given days to analyze   Parameters:      monday (bool) : Should the script analyze this day? (true/false)      tuesday (bool) : Should the script analyze this day? (true/false)      wednesday (bool) : Should the script analyze this day? (true/false)      thursday (bool) : Should the script analyze this day? (true/false)      friday (bool) : Should the script analyze this day? (true/false)      saturday (bool) : Should the script analyze this day? (true/false)      sunday (bool) : Should the script analyze this day? (true/false)   Returns: A boolean - true if the current bar's day is one of the given days atrFilter(atrValue, maxSize)   Parameters:      atrValue (float)      maxSize (float) tradeCount()   Calculate total trade count   Returns: Total closed trade count isLong()   Check if we're currently in a long trade   Returns: True if our position size is positive isShort()   Check if we're currently in a short trade   Returns: True if our position size is negative isFlat()   Check if we're currentlyflat   Returns: True if our position size is zero wonTrade()   Check if this bar falls after a winning trade   Returns: True if we just won a trade lostTrade()   Check if this bar falls after a losing trade   Returns: True if we just lost a trade maxDrawdownRealized()   Gets the max drawdown based on closed trades (ie. realized P&L). The strategy tester displays max drawdown as open P&L (unrealized).   Returns: The max drawdown based on closed trades (ie. realized P&L). The strategy tester displays max drawdown as open P&L (unrealized). totalPipReturn()   Gets the total amount of pips won/lost (as a whole number)   Returns: Total amount of pips won/lost (as a whole number) longWinCount()   Count how many winning long trades we've had   Returns: Long win count shortWinCount()   Count how many winning short trades we've had   Returns: Short win count longLossCount()   Count how many losing long trades we've had   Returns: Long loss count shortLossCount()   Count how many losing short trades we've had   Returns: Short loss count breakEvenCount(allowanceTicks)   Count how many break-even trades we've had   Parameters:      allowanceTicks (float) : Optional - how many ticks to allow between entry & exit price (default 0)   Returns: Break-even count longCount()   Count how many long trades we've taken   Returns: Long trade count shortCount()   Count how many short trades we've taken   Returns: Short trade count longWinPercent()   Calculate win rate of long trades   Returns: Long win rate (0-100) shortWinPercent()   Calculate win rate of short trades   Returns: Short win rate (0-100) breakEvenPercent(allowanceTicks)   Calculate break even rate of all trades   Parameters:      allowanceTicks (float) : Optional - how many ticks to allow between entry & exit price (default 0)   Returns: Break-even win rate (0-100) averageRR()   Calculate average risk:reward   Returns: Average winning trade divided by average losing trade unitsToLots(units)   (Forex) Convert the given unit count to lots (multiples of 100,000)   Parameters:      units (float) : The units to convert into lots   Returns: Units converted to nearest lot size (as float) getFxPositionSize(balance, risk, stopLossPips, fxRate, lots)   (Forex) Calculate fixed-fractional position size based on given parameters   Parameters:      balance (float) : The account balance      risk (float) : The % risk (whole number)      stopLossPips (float) : Pip distance to base risk on      fxRate (float) : The conversion currency rate (more info below in library documentation)      lots (bool) : Whether or not to return the position size in lots rather than units (true by default)   Returns: Units/lots to enter into "qty=" parameter of strategy entry function EXAMPLE USAGE: string conversionCurrencyPair = (strategy.account_currency == syminfo.currency ? syminfo.tickerid : strategy.account_currency + syminfo.currency) float fx_rate = request.security(conversionCurrencyPair, timeframe.period, close ) if (longCondition) strategy.entry("Long", strategy.long, qty=zen.getFxPositionSize(strategy.equity, 1, stopLossPipsWholeNumber, fx_rate, true)) skipTradeMonteCarlo(chance, debug)   Checks to see if trade should be skipped to emulate rudimentary Monte Carlo simulation   Parameters:      chance (float) : The chance to skip a trade (0-1 or 0-100, function will normalize to 0-1)      debug (bool) : Whether or not to display a label informing of the trade skip   Returns: True if the trade is skipped, false if it's not skipped (idea being to include this function in entry condition validation checks) fillCell(tableID, column, row, title, value, bgcolor, txtcolor, tooltip)   This updates the given table's cell with the given values   Parameters:      tableID (table) : The table ID to update      column (int) : The column to update      row (int) : The row to update      title (string) : The title of this cell      value (string) : The value of this cell      bgcolor (color) : The background color of this cell      txtcolor (color) : The text color of this cell      tooltip (string)   Returns: Nothing.
Pine Script® kütüphanesi
jordanswinden tarafından
Auto Volume Spread Analysis (VSA) [TANHEF]Auto Volume Spread Analysis (visible volume and spread bars auto-scaled): Understanding Market Intentions through the Interpretation of Volume and Price Movements. All the sections below contain the same descriptions as my other indicator "Volume Spread Analysis" with the exception of 'Auto Scaling'. █ Auto-Scaling This indicator auto-scales spread bars to match the visible volume bars, unlike the previous "Volume Spread Analysis " version which limited the number of visible spread bars to a fixed count. The auto-scaling feature allows for easier navigation through historical data, enabling both more historical spread bars to be viewed and more historical VSA pattern labels being displayed without requiring using the bar replay tool. Please note that this indicator’s auto-scaling feature recalculates the visible bars on the chart, causing the indicator to reload whenever the chart is moved. Auto-scaled spread bars have two display options (set via 'Spread Bars Method' setting): Lines: a bar lookback limit of 500 bars. Polylines: no bar lookback limit as only plotted on visible bars on chart, which uses multiple polylines are used. █ Simple Explanation: The Volume Spread Analysis (VSA) indicator is a comprehensive tool that helps traders identify key market patterns and trends based on volume and spread data. This indicator highlights significant VSA patterns and provides insights into market behavior through color-coded volume/spread bars and identification of bars indicating strength, weakness, and neutrality between buyers and sellers. It also includes powerful volume and spread forecasting capabilities. █ Laws of Volume Spread Analysis (VSA): The origin of VSA begins with Richard Wyckoff, a pivotal figure in its development. Wyckoff made significant contributions to trading theory, including the formulation of three basic laws: The Law of Supply and Demand: This fundamental law states that supply and demand balance each other over time. High demand and low supply lead to rising prices until demand falls to a level where supply can meet it. Conversely, low demand and high supply cause prices to fall until demand increases enough to absorb the excess supply. The Law of Cause and Effect: This law assumes that a 'cause' will result in an 'effect' proportional to the 'cause'. A strong 'cause' will lead to a strong trend (effect), while a weak 'cause' will lead to a weak trend. The Law of Effort vs. Result: This law asserts that the result should reflect the effort exerted. In trading terms, a large volume should result in a significant price move (spread). If the spread is small, the volume should also be small. Any deviation from this pattern is considered an anomaly. █ Volume and Spread Analysis Bars: Display: Volume and spread bars that consist of color coded levels, with the spread bars scaled to match the volume bars. A displayable table (Legend) of bar colors and levels can give context and clarify to each volume/spread bar. Calculation: Levels are calculated using multipliers applied to moving averages to represent key levels based on historical data: low, normal, high, ultra. This method smooths out short-term fluctuations and focuses on longer-term trends. Low Level: Indicates reduced volatility and market interest. Normal Level: Reflects typical market activity and volatility. High Level: Indicates increased activity and volatility. Ultra Level: Identifies extreme levels of activity and volatility. This illustrates the appearance of Volume and Spread bars when scaled and plotted together: █ Forecasting Capabilities: Display: Forecasted volume and spread levels using predictive models. Calculation: Volume and Spread prediction calculations differ as volume is linear and spread is non-linear. Volume Forecast (Linear Forecasting): Predicts future volume based on current volume rate and bar time till close. Spread Forecast (Non-Linear Dynamic Forecasting): Predicts future spread using a dynamic multiplier, less near midpoint (consolidation) and more near low or high (trending), reflecting non-linear expansion. Moving Averages: In forecasting, moving averages utilize forecasted levels instead of actual levels to ensure the correct level is forecasted (low, normal, high, or ultra). The following compares forecasted volume with actual resulting volume, highlighting the power of early identifying increased volume through forecasted levels: █ VSA Patterns: Criteria and descriptions for each VSA pattern are available as tooltips beside them within the indicator’s settings. These tooltips provide explanations of potential developments based on the volume and spread data. Signs of Strength (🟢): Patterns indicating strong buying pressure and potential market upturns. Down Thrust Selling Climax No Effort ➤ Bearish Result Bearish Effort ➤ No Result Inverse Down Thrust Failed Selling Climax Bull Outside Reversal End of Falling Market (Bag Holder) Pseudo Down Thrust No Supply Signs of Weakness (🔴): Patterns indicating strong selling pressure and potential market downturns. Up Thrust Buying Climax No Effort ➤ Bullish Result Bullish Effort ➤ No Result Inverse Up Thrust Failed Buying Climax Bear Outside Reversal End of Rising Market (Bag Seller) Pseudo Up Thrust No Demand Neutral Patterns (🔵): Patterns indicating market indecision and potential for continuation or reversal. Quiet Doji Balanced Doji Strong Doji Quiet Spinning Top Balanced Spinning Top Strong Spinning Top Quiet High Wave Balanced High Wave Strong High Wave Consolidation Bar Patterns (🟡): Common candlestick patterns that offer insights into market sentiment. These are required in some VSA patterns and can also be displayed independently. Bull Pin Bar Bear Pin Bar Doji Spinning Top High Wave Consolidation This demonstrates the acronym and descriptive options for displaying bar patterns, with the ability to hover over text to reveal the descriptive text along with what type of pattern: █ Alerts: VSA Pattern Alerts: Notifications for identified VSA patterns at bar close. Volume and Spread Alerts: Alerts for confirmed and forecasted volume/spread levels (Low, High, Ultra). Forecasted Volume and Spread Alerts: Alerts for forecasted volume/spread levels (High, Ultra) include a minimum percent time elapsed input to reduce false early signals by ensuring sufficient bar time has passed. █ Inputs and Settings: Indicator Bar Color: Select color schemes for bars (Normal, Detail, Levels). Indicator Moving Average Color: Select schemes for bars (Fill, Lines, None). Price Bar Colors: Options to color price bars based on VSA patterns and volume levels. Legend: Display a table of bar colors and levels for context and clarity of volume/spread bars. Forecast: Configure forecast display and prediction details for volume and spread. Average Multipliers: Define multipliers for different levels (Low, High, Ultra) to refine the analysis. Moving Average: Set volume and spread moving average settings. VSA: Select the VSA patterns to be calculated and displayed (Strength, Weakness, Neutral). Bar Patterns: Criteria for bar patterns used in VSA (Doji, Bull Pin Bar, Bear Pin Bar, Spinning Top, Consolidation, High Wave). Colors: Set exact colors used for indicator bars, indicator moving averages, and price bars. More Display Options: Specify how VSA pattern text is displayed (Acronym, Descriptive), positioning, and sizes. Alerts: Configure alerts for VSA patterns, volume, and spread levels, including forecasted levels. █ Usage: The Volume Spread Analysis indicator is a helpful tool for leveraging volume spread analysis to make informed trading decisions. It offers comprehensive visual and textual cues on the chart, making it easier to identify market conditions, potential reversals, and continuations. Whether analyzing historical data or forecasting future trends, this indicator provides insights into the underlying factors driving market movements.
Pine Script® göstergesi
TanHef tarafından
7
Delta ZigZag [LuxAlgo]The Delta ZigZag indicator is focused on volume analysis during the development of ZigZag lines. Volume data can be retrieved from a Lower timeframe (LTF) or real-time Tick data. Our Delta ZigZag publication can be helpful in detecting indications of a trend reversal or potential weakening/strengthening of the trend. This indicator by its very nature backpaints, meaning that the displayed components are offset in the past. 🔶 USAGE The ZigZag line is formed by connecting Swings , which can be set by adjusting the Left and Right settings. Left is the number of bars for evaluation at the left of the evaluated point. Right is the number of bars for evaluation at the right of the evaluated point. A valid Swing is a value higher or lower than the bars at the left/right . A higher Left or Right set number will generally create broader ZigZag ( ZZ ) lines, while the drawing of the ZZ line will be delayed (especially when Right is set higher). On the other hand, when Right is set at 0, ZZ line are drawn quickly. However, this results in a hyperactive switching of the ZZ direction. To ensure maximum visibility of values, we recommend using " Bars " from the " Bar's style " menu. 🔹 Volume examination The script provides two options for Volume examination : Examination per ZigZag line Examination per bar Bullish Volume is volume associated with a green bar ( close > open ) Bearish Volume is volume associated with a red bar ( close < open ) Neutral Volume (volume on a " close == open" bar) is not included in this publication. 🔹 Examination per ZigZag line As long as the price moves in the same direction, the present ZZ line will continue. When the direction of the price changes, the bull/bear volume of the previous ZZ line is evaluated and drawn on the chart. The ZZ line is divided into two parts: a bullish green line and a bearish red line. The intercept of these two lines will depend on the ratio of bullish/bearish volume This ratio is displayed at the intercept as % bullish volume (Settings -> Show % Bullish Volume) * Note that we cannot draw between 2 bars. Therefore, if a ZZ line is only 1 bar long, the intercept will be at one of those 2 bars and not in between. The percentage can be helpful in interpreting bull/bear volume. In the example above (2 most right labels), you can see that an overlap of 2 labels is prevented, ensuring the ability to evaluate the bullish % volume of the ZZ line . The percentage will be colored green when more than 50%, red otherwise. The color will fade when the direction is contradictory; for example, 40% when the ZZ line goes up or 70% when the ZZ line falls. More details can be visualized by enabling " Show " and choosing 1 of 3 options: Average Volume Delta/bar Average Volume/bar Normalised Volume Delta For both 'averages', the sum of " Volume "/" Volume Delta " of every bar on the ZZ line is divided by the number of bars (per ZZ line ). The " Normalised Volume Delta " is calculated by dividing the sum of " Delta Volume " by the sum of " Volume " (neutral volume not included), which is displayed as a percentage. All three options will display a label at the last point of the ZZ line and be coloured similarly: green when the ratio bullish/bearish volume of the ZZ line is bullish and red otherwise. Here, the colour also fades when it is bullish, but the ZZ line falls or when it is bearish with a rising ZZ line . A tooltip at each label hints at the chosen option. You can pick one of the options or combine them together. 🔹 Examination per bar Besides information about what's happening during the ZZ line , information per bar can be visualized by enabling " Show Details " in Settings . Split Volume per bar : show the sum of bullish (upV) and bearish (dnV) volume per bar Volume (bar) : Total Volume per bar (bullish + bearish volume, neutral volume not included) Δ Volume (bar) : Show Delta Volume (bullish - bearish volume) 🔹 Using Lower Timeframe Data The ZigZag lines using LTF data are colored brighter. Also note the vertical line where the LTF data starts and the gap between ZZ lines with LTF data and without. When " LTF " is chosen for the " Data from: " option in Settings , data is retrieved from Lower Timeframe bars (default 1 minute). When the LTF setting is higher than the current chart timeframe, the LTF period will automatically be adjusted to the current timeframe to prevent errors. As there is a 100K limit to the number of LTF intrabars that can be analyzed by a script, this implies the higher the difference between LTF and current TF; the fewer ZZ lines will be seen. 🔹 Using real-time tick data The principles are mostly the same as those of LTF data. However, in contrast with LTF data, where you already have LTF ZZ lines when loading the script, real-time tick data-based ZZ lines will only start after loading the chart. Changing the settings of a ticker will reset everything. However, returning to the same settings/ticker would show the cached data again. Here, you can see that changing settings reset everything, but returning after 2 minutes to the initial settings shows the cached data. Don't expect it to be cached for hours or days, though. 🔶 DETAILS The timeframe used for LTF data should always be the same or lower than the current TF; otherwise, an error occurs. This snippet prevents the error and adjusts the LTF to the current TF when LTF is too high: res = input.timeframe('1') res := timeframe.from_seconds( math.min( timeframe.in_seconds(timeframe.period), timeframe.in_seconds(res) ) ) 🔶 SETTINGS Data from: LTF (Lower TimeFrame) or Ticks (Real-time ticks) Res: Lower TimeFrame (only applicable when choosing LTF ) Option: choose " high/low " or " close " for Swing detection 🔹 ZigZag Left: Lookback period for Swings Right: Confirmation period after potential Swing 🔹 ZigZag Delta Show % Bullish Volume : % bullish volume against total volume during the ZZ line Show: Average Volume Delta/bar Average Volume/bar Normalised Volume Delta See USAGE for more information 🔹 Bar Data Split Volume per bar: shows the sum of bullish ( upV ) and bearish ( dnV ) volume per bar Volume (bar): Total Volume per bar (bullish + bearish volume, neutral volume not included) Δ Volume (bar): Show Volume Delta (bullish - bearish volume)
Pine Script® göstergesi
LuxAlgo tarafından
15
CNTLibraryLibrary "CNTLibrary" Custom Functions To Help Code In Pinescript V5 Coded By Christian Nataliano First Coded In 10/06/2023 Last Edited In 22/06/2023 Huge Shout Out To © ZenAndTheArtOfTrading and his ZenLibrary V5, Some Of The Custom Functions Were Heavily Inspired By Matt's Work & His Pine Script Mastery Course Another Shout Out To The TradingView's Team Library ta V5 //==================================================================================================================================================== // Custom Indicator Functions //==================================================================================================================================================== GetKAMA(KAMA_lenght, Fast_KAMA, Slow_KAMA)   Calculates An Adaptive Moving Average Based On Perry J Kaufman's Calculations   Parameters:      KAMA_lenght (int) : Is The KAMA Lenght      Fast_KAMA (int) : Is The KAMA's Fastes Moving Average      Slow_KAMA (int) : Is The KAMA's Slowest Moving Average   Returns: Float Of The KAMA's Current Calculations GetMovingAverage(Source, Lenght, Type)   Get Custom Moving Averages Values   Parameters:      Source (float) : Of The Moving Average, Defval = close      Lenght (simple int) : Of The Moving Average, Defval = 50      Type (string) : Of The Moving Average, Defval = Exponential Moving Average   Returns: The Moving Average Calculation Based On Its Given Source, Lenght & Calculation Type (Please Call Function On Global Scope) GetDecimals()   Calculates how many decimals are on the quote price of the current market © ZenAndTheArtOfTrading   Returns: The current decimal places on the market quote price Truncate(number, decimalPlaces)   Truncates (cuts) excess decimal places © ZenAndTheArtOfTrading   Parameters:      number (float)      decimalPlaces (simple float)   Returns: The given number truncated to the given decimalPlaces ToWhole(number)   Converts pips into whole numbers © ZenAndTheArtOfTrading   Parameters:      number (float)   Returns: The converted number ToPips(number)   Converts whole numbers back into pips © ZenAndTheArtOfTrading   Parameters:      number (float)   Returns: The converted number GetPctChange(value1, value2, lookback)   Gets the percentage change between 2 float values over a given lookback period © ZenAndTheArtOfTrading   Parameters:      value1 (float)      value2 (float)      lookback (int) BarsAboveMA(lookback, ma)   Counts how many candles are above the MA © ZenAndTheArtOfTrading   Parameters:      lookback (int)      ma (float)   Returns: The bar count of how many recent bars are above the MA BarsBelowMA(lookback, ma)   Counts how many candles are below the MA © ZenAndTheArtOfTrading   Parameters:      lookback (int)      ma (float)   Returns: The bar count of how many recent bars are below the EMA BarsCrossedMA(lookback, ma)   Counts how many times the EMA was crossed recently © ZenAndTheArtOfTrading   Parameters:      lookback (int)      ma (float)   Returns: The bar count of how many times price recently crossed the EMA GetPullbackBarCount(lookback, direction)   Counts how many green & red bars have printed recently (ie. pullback count) © ZenAndTheArtOfTrading   Parameters:      lookback (int)      direction (int)   Returns: The bar count of how many candles have retraced over the given lookback & direction GetSwingHigh(Lookback, SwingType)   Check If Price Has Made A Recent Swing High   Parameters:      Lookback (int) : Is For The Swing High Lookback Period, Defval = 7      SwingType (int) : Is For The Swing High Type Of Identification, Defval = 1   Returns: A Bool - True If Price Has Made A Recent Swing High GetSwingLow(Lookback, SwingType)   Check If Price Has Made A Recent Swing Low   Parameters:      Lookback (int) : Is For The Swing Low Lookback Period, Defval = 7      SwingType (int) : Is For The Swing Low Type Of Identification, Defval = 1   Returns: A Bool - True If Price Has Made A Recent Swing Low //==================================================================================================================================================== // Custom Risk Management Functions //==================================================================================================================================================== CalculateStopLossLevel(OrderType, Entry, StopLoss)   Calculate StopLoss Level   Parameters:      OrderType (int) : Is To Determine A Long / Short Position, Defval = 1      Entry (float) : Is The Entry Level Of The Order, Defval = na      StopLoss (float) : Is The Custom StopLoss Distance, Defval = 2x ATR Below Close   Returns: Float - The StopLoss Level In Actual Price As A CalculateStopLossDistance(OrderType, Entry, StopLoss)   Calculate StopLoss Distance In Pips   Parameters:      OrderType (int) : Is To Determine A Long / Short Position, Defval = 1      Entry (float) : Is The Entry Level Of The Order, NEED TO INPUT PARAM      StopLoss (float) : Level Based On Previous Calculation, NEED TO INPUT PARAM   Returns: Float - The StopLoss Value In Pips CalculateTakeProfitLevel(OrderType, Entry, StopLossDistance, RiskReward)   Calculate TakeProfit Level   Parameters:      OrderType (int) : Is To Determine A Long / Short Position, Defval = 1      Entry (float) : Is The Entry Level Of The Order, Defval = na      StopLossDistance (float)      RiskReward (float)   Returns: Float - The TakeProfit Level In Actual Price CalculateTakeProfitDistance(OrderType, Entry, TakeProfit)   Get TakeProfit Distance In Pips   Parameters:      OrderType (int) : Is To Determine A Long / Short Position, Defval = 1      Entry (float) : Is The Entry Level Of The Order, NEED TO INPUT PARAM      TakeProfit (float) : Level Based On Previous Calculation, NEED TO INPUT PARAM   Returns: Float - The TakeProfit Value In Pips CalculateConversionCurrency(AccountCurrency, SymbolCurrency, BaseCurrency)   Get The Conversion Currecny Between Current Account Currency & Current Pair's Quoted Currency (FOR FOREX ONLY)   Parameters:      AccountCurrency (simple string) : Is For The Account Currency Used      SymbolCurrency (simple string) : Is For The Current Symbol Currency (Front Symbol)      BaseCurrency (simple string) : Is For The Current Symbol Base Currency (Back Symbol)   Returns: Tuple Of A Bollean (Convert The Currency ?) And A String (Converted Currency) CalculateConversionRate(ConvertCurrency, ConversionRate)   Get The Conversion Rate Between Current Account Currency & Current Pair's Quoted Currency (FOR FOREX ONLY)   Parameters:      ConvertCurrency (bool) : Is To Check If The Current Symbol Needs To Be Converted Or Not      ConversionRate (float) : Is The Quoted Price Of The Conversion Currency (Input The request.security Function Here)   Returns: Float Price Of Conversion Rate (If In The Same Currency Than Return Value Will Be 1.0) LotSize(LotSizeSimple, Balance, Risk, SLDistance, ConversionRate)   Get Current Lot Size   Parameters:      LotSizeSimple (bool) : Is To Toggle Lot Sizing Calculation (Simple Is Good Enough For Stocks & Crypto, Whilst Complex Is For Forex)      Balance (float) : Is For The Current Account Balance To Calculate The Lot Sizing Based Off      Risk (float) : Is For The Current Risk Per Trade To Calculate The Lot Sizing Based Off      SLDistance (float) : Is The Current Position StopLoss Distance From Its Entry Price      ConversionRate (float) : Is The Currency Conversion Rate (Used For Complex Lot Sizing Only)   Returns: Float - Position Size In Units ToLots(Units)   Converts Units To Lots   Parameters:      Units (float) : Is For How Many Units Need To Be Converted Into Lots (Minimun 1000 Units)   Returns: Float - Position Size In Lots ToUnits(Lots)   Converts Lots To Units   Parameters:      Lots (float) : Is For How Many Lots Need To Be Converted Into Units (Minimun 0.01 Units)   Returns: Int - Position Size In Units ToLotsInUnits(Units)   Converts Units To Lots Than Back To Units   Parameters:      Units (float) : Is For How Many Units Need To Be Converted Into Lots (Minimun 1000 Units)   Returns: Float - Position Size In Lots That Were Rounded To Units ATRTrail(OrderType, SourceType, ATRPeriod, ATRMultiplyer, SwingLookback)   Calculate ATR Trailing Stop   Parameters:      OrderType (int) : Is To Determine A Long / Short Position, Defval = 1      SourceType (int) : Is To Determine Where To Calculate The ATR Trailing From, Defval = close      ATRPeriod (simple int) : Is To Change Its ATR Period, Defval = 20      ATRMultiplyer (float) : Is To Change Its ATR Trailing Distance, Defval = 1      SwingLookback (int) : Is To Change Its Swing HiLo Lookback (Only From Source Type 5), Defval = 7   Returns: Float - Number Of The Current ATR Trailing DangerZone(WinRate, AvgRRR, Filter)   Calculate Danger Zone Of A Given Strategy   Parameters:      WinRate (float) : Is The Strategy WinRate      AvgRRR (float) : Is The Strategy Avg RRR      Filter (float) : Is The Minimum Profit It Needs To Be Out Of BE Zone, Defval = 3   Returns: Int - Value, 1 If Out Of Danger Zone, 0 If BE, -1 If In Danger Zone IsQuestionableTrades(TradeTP, TradeSL)   Checks For Questionable Trades (Which Are Trades That Its TP & SL Level Got Hit At The Same Candle)   Parameters:      TradeTP (float) : Is The Trade In Question Take Profit Level      TradeSL (float) : Is The Trade In Question Stop Loss Level   Returns: Bool - True If The Last Trade Was A "Questionable Trade" //==================================================================================================================================================== // Custom Strategy Functions //==================================================================================================================================================== OpenLong(EntryID, LotSize, LimitPrice, StopPrice, Comment, CommentValue)   Open A Long Order Based On The Given Params   Parameters:      EntryID (string) : Is The Trade Entry ID, Defval = "Long"      LotSize (float) : Is The Lot Size Of The Trade, Defval = 1      LimitPrice (float) : Is The Limit Order Price To Set The Order At, Defval = Na / Market Order Execution      StopPrice (float) : Is The Stop Order Price To Set The Order At, Defval = Na / Market Order Execution      Comment (string) : Is The Order Comment, Defval = Long Entry Order      CommentValue (string) : Is For Custom Values In The Order Comment, Defval = Na   Returns: Void OpenShort(EntryID, LotSize, LimitPrice, StopPrice, Comment, CommentValue)   Open A Short Order Based On The Given Params   Parameters:      EntryID (string) : Is The Trade Entry ID, Defval = "Short"      LotSize (float) : Is The Lot Size Of The Trade, Defval = 1      LimitPrice (float) : Is The Limit Order Price To Set The Order At, Defval = Na / Market Order Execution      StopPrice (float) : Is The Stop Order Price To Set The Order At, Defval = Na / Market Order Execution      Comment (string) : Is The Order Comment, Defval = Short Entry Order      CommentValue (string) : Is For Custom Values In The Order Comment, Defval = Na   Returns: Void TP_SLExit(FromID, TPLevel, SLLevel, PercentageClose, Comment, CommentValue)   Exits Based On Predetermined TP & SL Levels   Parameters:      FromID (string) : Is The Trade ID That The TP & SL Levels Be Palced      TPLevel (float) : Is The Take Profit Level      SLLevel (float) : Is The StopLoss Level      PercentageClose (float) : Is The Amount To Close The Order At (In Percentage) Defval = 100      Comment (string) : Is The Order Comment, Defval = Exit Order      CommentValue (string) : Is For Custom Values In The Order Comment, Defval = Na   Returns: Void CloseLong(ExitID, PercentageClose, Comment, CommentValue, Instant)   Exits A Long Order Based On A Specified Condition   Parameters:      ExitID (string) : Is The Trade ID That Will Be Closed, Defval = "Long"      PercentageClose (float) : Is The Amount To Close The Order At (In Percentage) Defval = 100      Comment (string) : Is The Order Comment, Defval = Exit Order      CommentValue (string) : Is For Custom Values In The Order Comment, Defval = Na      Instant (bool) : Is For Exit Execution Type, Defval = false   Returns: Void CloseShort(ExitID, PercentageClose, Comment, CommentValue, Instant)   Exits A Short Order Based On A Specified Condition   Parameters:      ExitID (string) : Is The Trade ID That Will Be Closed, Defval = "Short"      PercentageClose (float) : Is The Amount To Close The Order At (In Percentage) Defval = 100      Comment (string) : Is The Order Comment, Defval = Exit Order      CommentValue (string) : Is For Custom Values In The Order Comment, Defval = Na      Instant (bool) : Is For Exit Execution Type, Defval = false   Returns: Void BrokerCheck(Broker)   Checks Traded Broker With Current Loaded Chart Broker   Parameters:      Broker (string) : Is The Current Broker That Is Traded   Returns: Bool - True If Current Traded Broker Is Same As Loaded Chart Broker OpenPC(LicenseID, OrderType, UseLimit, LimitPrice, SymbolPrefix, Symbol, SymbolSuffix, Risk, SL, TP, OrderComment, Spread)   Compiles Given Parameters Into An Alert String Format To Open Trades Using Pine Connector   Parameters:      LicenseID (string) : Is The Users PineConnector LicenseID      OrderType (int) : Is The Desired OrderType To Open      UseLimit (bool) : Is If We Want To Enter The Position At Exactly The Previous Closing Price      LimitPrice (float) : Is The Limit Price Of The Trade (Only For Pending Orders)      SymbolPrefix (string) : Is The Current Symbol Prefix (If Any)      Symbol (string) : Is The Traded Symbol      SymbolSuffix (string) : Is The Current Symbol Suffix (If Any)      Risk (float) : Is The Trade Risk Per Trade / Fixed Lot Sizing      SL (float) : Is The Trade SL In Price / In Pips      TP (float) : Is The Trade TP In Price / In Pips      OrderComment (string) : Is The Executed Trade Comment      Spread (float) : is The Maximum Spread For Execution   Returns: String - Pine Connector Order Syntax Alert Message ClosePC(LicenseID, OrderType, SymbolPrefix, Symbol, SymbolSuffix)   Compiles Given Parameters Into An Alert String Format To Close Trades Using Pine Connector   Parameters:      LicenseID (string) : Is The Users PineConnector LicenseID      OrderType (int) : Is The Desired OrderType To Close      SymbolPrefix (string) : Is The Current Symbol Prefix (If Any)      Symbol (string) : Is The Traded Symbol      SymbolSuffix (string) : Is The Current Symbol Suffix (If Any)   Returns: String - Pine Connector Order Syntax Alert Message //==================================================================================================================================================== // Custom Backtesting Calculation Functions //==================================================================================================================================================== CalculatePNL(EntryPrice, ExitPrice, LotSize, ConversionRate)   Calculates Trade PNL Based On Entry, Eixt & Lot Size   Parameters:      EntryPrice (float) : Is The Trade Entry      ExitPrice (float) : Is The Trade Exit      LotSize (float) : Is The Trade Sizing      ConversionRate (float) : Is The Currency Conversion Rate (Used For Complex Lot Sizing Only)   Returns: Float - The Current Trade PNL UpdateBalance(PrevBalance, PNL)   Updates The Previous Ginve Balance To The Next PNL   Parameters:      PrevBalance (float) : Is The Previous Balance To Be Updated      PNL (float) : Is The Current Trade PNL To Be Added   Returns: Float - The Current Updated PNL CalculateSlpComm(PNL, MaxRate)   Calculates Random Slippage & Commisions Fees Based On The Parameters   Parameters:      PNL (float) : Is The Current Trade PNL      MaxRate (float) : Is The Upper Limit (In Percentage) Of The Randomized Fee   Returns: Float - A Percentage Fee Of The Current Trade PNL UpdateDD(MaxBalance, Balance)   Calculates & Updates The DD Based On Its Given Parameters   Parameters:      MaxBalance (float) : Is The Maximum Balance Ever Recorded      Balance (float) : Is The Current Account Balance   Returns: Float - The Current Strategy DD CalculateWR(TotalTrades, LongID, ShortID)   Calculate The Total, Long & Short Trades Win Rate   Parameters:      TotalTrades (int) : Are The Current Total Trades That The Strategy Has Taken      LongID (string) : Is The Order ID Of The Long Trades Of The Strategy      ShortID (string) : Is The Order ID Of The Short Trades Of The Strategy   Returns: Tuple Of Long WR%, Short WR%, Total WR%, Total Winning Trades, Total Losing Trades, Total Long Trades & Total Short Trades CalculateAvgRRR(WinTrades, LossTrades)   Calculates The Overall Strategy Avg Risk Reward Ratio   Parameters:      WinTrades (int) : Are The Strategy Winning Trades      LossTrades (int) : Are The Strategy Losing Trades   Returns: Float - The Average RRR Values CAGR(StartTime, StartPrice, EndTime, EndPrice)   Calculates The CAGR Over The Given Time Period © TradingView   Parameters:      StartTime (int) : Is The Starting Time Of The Calculation      StartPrice (float) : Is The Starting Price Of The Calculation      EndTime (int) : Is The Ending Time Of The Calculation      EndPrice (float) : Is The Ending Price Of The Calculation   Returns: Float - The CAGR Values //==================================================================================================================================================== // Custom Plot Functions //==================================================================================================================================================== EditLabels(LabelID, X1, Y1, Text, Color, TextColor, EditCondition, DeleteCondition)   Edit / Delete Labels   Parameters:      LabelID (label) : Is The ID Of The Selected Label      X1 (int) : Is The X1 Coordinate IN BARINDEX Xloc      Y1 (float) : Is The Y1 Coordinate IN PRICE Yloc      Text (string) : Is The Text Than Wants To Be Written In The Label      Color (color) : Is The Color Value Change Of The Label Text      TextColor (color)      EditCondition (int) : Is The Edit Condition of The Line (Setting Location / Color)      DeleteCondition (bool) : Is The Delete Condition Of The Line If Ture Deletes The Prev Itteration Of The Line   Returns: Void EditLine(LineID, X1, Y1, X2, Y2, Color, EditCondition, DeleteCondition)   Edit / Delete Lines   Parameters:      LineID (line) : Is The ID Of The Selected Line      X1 (int) : Is The X1 Coordinate IN BARINDEX Xloc      Y1 (float) : Is The Y1 Coordinate IN PRICE Yloc      X2 (int) : Is The X2 Coordinate IN BARINDEX Xloc      Y2 (float) : Is The Y2 Coordinate IN PRICE Yloc      Color (color) : Is The Color Value Change Of The Line      EditCondition (int) : Is The Edit Condition of The Line (Setting Location / Color)      DeleteCondition (bool) : Is The Delete Condition Of The Line If Ture Deletes The Prev Itteration Of The Line   Returns: Void //==================================================================================================================================================== // Custom Display Functions (Using Tables) //==================================================================================================================================================== FillTable(TableID, Column, Row, Title, Value, BgColor, TextColor, ToolTip)   Filling The Selected Table With The Inputed Information   Parameters:      TableID (table) : Is The Table ID That Wants To Be Edited      Column (int) : Is The Current Column Of The Table That Wants To Be Edited      Row (int) : Is The Current Row Of The Table That Wants To Be Edited      Title (string) : Is The String Title Of The Current Cell Table      Value (string) : Is The String Value Of The Current Cell Table      BgColor (color) : Is The Selected Color For The Current Table      TextColor (color) : Is The Selected Color For The Current Table      ToolTip (string) : Is The ToolTip Of The Current Cell In The Table   Returns: Void DisplayBTResults(TableID, BgColor, TextColor, StartingBalance, Balance, DollarReturn, TotalPips, MaxDD)   Filling The Selected Table With The Inputed Information   Parameters:      TableID (table) : Is The Table ID That Wants To Be Edited      BgColor (color) : Is The Selected Color For The Current Table      TextColor (color) : Is The Selected Color For The Current Table      StartingBalance (float) : Is The Account Starting Balance      Balance (float)      DollarReturn (float) : Is The Account Dollar Reture      TotalPips (float) : Is The Total Pips Gained / loss      MaxDD (float) : Is The Maximum Drawdown Over The Backtesting Period   Returns: Void DisplayBTResultsV2(TableID, BgColor, TextColor, TotalWR, QTCount, LongWR, ShortWR, InitialCapital, CumProfit, CumFee, AvgRRR, MaxDD, CAGR, MeanDD)   Filling The Selected Table With The Inputed Information   Parameters:      TableID (table) : Is The Table ID That Wants To Be Edited      BgColor (color) : Is The Selected Color For The Current Table      TextColor (color) : Is The Selected Color For The Current Table      TotalWR (float) : Is The Strategy Total WR In %      QTCount (int) : Is The Strategy Questionable Trades Count      LongWR (float) : Is The Strategy Total WR In %      ShortWR (float) : Is The Strategy Total WR In %      InitialCapital (float) : Is The Strategy Initial Starting Capital      CumProfit (float) : Is The Strategy Ending Cumulative Profit      CumFee (float) : Is The Strategy Ending Cumulative Fee (Based On Randomized Fee Assumptions)      AvgRRR (float) : Is The Strategy Average Risk Reward Ratio      MaxDD (float) : Is The Strategy Maximum DrawDown In Its Backtesting Period      CAGR (float) : Is The Strategy Compounded Average GRowth In %      MeanDD (float) : Is The Strategy Mean / Average Drawdown In The Backtesting Period   Returns: Void //==================================================================================================================================================== // Custom Pattern Detection Functions //==================================================================================================================================================== BullFib(priceLow, priceHigh, fibRatio)   Calculates A Bullish Fibonacci Value (From Swing Low To High) © ZenAndTheArtOfTrading   Parameters:      priceLow (float)      priceHigh (float)      fibRatio (float)   Returns: The Fibonacci Value Of The Given Ratio Between The Two Price Points BearFib(priceLow, priceHigh, fibRatio)   Calculates A Bearish Fibonacci Value (From Swing High To Low) © ZenAndTheArtOfTrading   Parameters:      priceLow (float)      priceHigh (float)      fibRatio (float)   Returns: The Fibonacci Value Of The Given Ratio Between The Two Price Points GetBodySize()   Gets The Current Candle Body Size IN POINTS © ZenAndTheArtOfTrading   Returns: The Current Candle Body Size IN POINTS GetTopWickSize()   Gets The Current Candle Top Wick Size IN POINTS © ZenAndTheArtOfTrading   Returns: The Current Candle Top Wick Size IN POINTS GetBottomWickSize()   Gets The Current Candle Bottom Wick Size IN POINTS © ZenAndTheArtOfTrading   Returns: The Current Candle Bottom Wick Size IN POINTS GetBodyPercent()   Gets The Current Candle Body Size As A Percentage Of Its Entire Size Including Its Wicks © ZenAndTheArtOfTrading   Returns: The Current Candle Body Size IN PERCENTAGE GetTopWickPercent()   Gets The Current Top Wick Size As A Percentage Of Its Entire Body Size   Returns: Float - The Current Candle Top Wick Size IN PERCENTAGE GetBottomWickPercent()   Gets The Current Bottom Wick Size As A Percentage Of Its Entire Bodu Size   Returns: Float - The Current Candle Bottom Size IN PERCENTAGE BullishEC(Allowance, RejectionWickSize, EngulfWick, NearSwings, SwingLookBack)   Checks If The Current Bar Is A Bullish Engulfing Candle   Parameters:      Allowance (int) : To Give Flexibility Of Engulfing Pattern Detection In Markets That Have Micro Gaps, Defval = 0      RejectionWickSize (float) : To Filter Out long (Upper And Lower) Wick From The Bullsih Engulfing Pattern, Defval = na      EngulfWick (bool) : To Specify If We Want The Pattern To Also Engulf Its Upper & Lower Previous Wicks, Defval = false      NearSwings (bool) : To Specify If We Want The Pattern To Be Near A Recent Swing Low, Defval = true      SwingLookBack (int) : To Specify How Many Bars Back To Detect A Recent Swing Low, Defval = 10   Returns: Bool - True If The Current Bar Matches The Requirements of a Bullish Engulfing Candle BearishEC(Allowance, RejectionWickSize, EngulfWick, NearSwings, SwingLookBack)   Checks If The Current Bar Is A Bearish Engulfing Candle   Parameters:      Allowance (int) : To Give Flexibility Of Engulfing Pattern Detection In Markets That Have Micro Gaps, Defval = 0      RejectionWickSize (float) : To Filter Out long (Upper And Lower) Wick From The Bearish Engulfing Pattern, Defval = na      EngulfWick (bool) : To Specify If We Want The Pattern To Also Engulf Its Upper & Lower Previous Wicks, Defval = false      NearSwings (bool) : To Specify If We Want The Pattern To Be Near A Recent Swing High, Defval = true      SwingLookBack (int) : To Specify How Many Bars Back To Detect A Recent Swing High, Defval = 10   Returns: Bool - True If The Current Bar Matches The Requirements of a Bearish Engulfing Candle Hammer(Fib, ColorMatch, NearSwings, SwingLookBack, ATRFilterCheck, ATRPeriod)   Checks If The Current Bar Is A Hammer Candle   Parameters:      Fib (float) : To Specify Which Fibonacci Ratio To Use When Determining The Hammer Candle, Defval = 0.382 Ratio      ColorMatch (bool) : To Filter Only Bullish Closed Hammer Candle Pattern, Defval = false      NearSwings (bool) : To Specify If We Want The Doji To Be Near A Recent Swing Low, Defval = true      SwingLookBack (int) : To Specify How Many Bars Back To Detect A Recent Swing Low, Defval = 10      ATRFilterCheck (float) : To Filter Smaller Hammer Candles That Might Be Better Classified As A Doji Candle, Defval = 1      ATRPeriod (simple int) : To Change ATR Period Of The ATR Filter, Defval = 20   Returns: Bool - True If The Current Bar Matches The Requirements of a Hammer Candle Star(Fib, ColorMatch, NearSwings, SwingLookBack, ATRFilterCheck, ATRPeriod)   Checks If The Current Bar Is A Hammer Candle   Parameters:      Fib (float) : To Specify Which Fibonacci Ratio To Use When Determining The Hammer Candle, Defval = 0.382 Ratio      ColorMatch (bool) : To Filter Only Bullish Closed Hammer Candle Pattern, Defval = false      NearSwings (bool) : To Specify If We Want The Doji To Be Near A Recent Swing Low, Defval = true      SwingLookBack (int) : To Specify How Many Bars Back To Detect A Recent Swing Low, Defval = 10      ATRFilterCheck (float) : To Filter Smaller Hammer Candles That Might Be Better Classified As A Doji Candle, Defval = 1      ATRPeriod (simple int) : To Change ATR Period Of The ATR Filter, Defval = 20   Returns: Bool - True If The Current Bar Matches The Requirements of a Hammer Candle Doji(MaxWickSize, MaxBodySize, DojiType, NearSwings, SwingLookBack)   Checks If The Current Bar Is A Doji Candle   Parameters:      MaxWickSize (float) : To Specify The Maximum Lenght Of Its Upper & Lower Wick, Defval = 2      MaxBodySize (float) : To Specify The Maximum Lenght Of Its Candle Body IN PERCENT, Defval = 0.05      DojiType (int)      NearSwings (bool) : To Specify If We Want The Doji To Be Near A Recent Swing High / Low (Only In Dragonlyf / Gravestone Mode), Defval = true      SwingLookBack (int) : To Specify How Many Bars Back To Detect A Recent Swing High / Low (Only In Dragonlyf / Gravestone Mode), Defval = 10   Returns: Bool - True If The Current Bar Matches The Requirements of a Doji Candle BullishIB(Allowance, RejectionWickSize, EngulfWick, NearSwings, SwingLookBack)   Checks If The Current Bar Is A Bullish Harami Candle   Parameters:      Allowance (int) : To Give Flexibility Of Harami Pattern Detection In Markets That Have Micro Gaps, Defval = 0      RejectionWickSize (float) : To Filter Out long (Upper And Lower) Wick From The Bullsih Harami Pattern, Defval = na      EngulfWick (bool) : To Specify If We Want The Pattern To Also Engulf Its Upper & Lower Previous Wicks, Defval = false      NearSwings (bool) : To Specify If We Want The Pattern To Be Near A Recent Swing Low, Defval = true      SwingLookBack (int) : To Specify How Many Bars Back To Detect A Recent Swing Low, Defval = 10   Returns: Bool - True If The Current Bar Matches The Requirements of a Bullish Harami Candle BearishIB(Allowance, RejectionWickSize, EngulfWick, NearSwings, SwingLookBack)   Checks If The Current Bar Is A Bullish Harami Candle   Parameters:      Allowance (int) : To Give Flexibility Of Harami Pattern Detection In Markets That Have Micro Gaps, Defval = 0      RejectionWickSize (float) : To Filter Out long (Upper And Lower) Wick From The Bearish Harami Pattern, Defval = na      EngulfWick (bool) : To Specify If We Want The Pattern To Also Engulf Its Upper & Lower Previous Wicks, Defval = false      NearSwings (bool) : To Specify If We Want The Pattern To Be Near A Recent Swing High, Defval = true      SwingLookBack (int) : To Specify How Many Bars Back To Detect A Recent Swing High, Defval = 10   Returns: Bool - True If The Current Bar Matches The Requirements of a Bearish Harami Candle //==================================================================================================================================================== // Custom Time Functions //==================================================================================================================================================== BarInSession(sess, useFilter)   Determines if the current price bar falls inside the specified session © ZenAndTheArtOfTrading   Parameters:      sess (simple string)      useFilter (bool)   Returns: A boolean - true if the current bar falls within the given time session BarOutSession(sess, useFilter)   Determines if the current price bar falls outside the specified session © ZenAndTheArtOfTrading   Parameters:      sess (simple string)      useFilter (bool)   Returns: A boolean - true if the current bar falls outside the given time session DateFilter(startTime, endTime)   Determines if this bar's time falls within date filter range © ZenAndTheArtOfTrading   Parameters:      startTime (int)      endTime (int)   Returns: A boolean - true if the current bar falls within the given dates DayFilter(monday, tuesday, wednesday, thursday, friday, saturday, sunday)   Checks if the current bar's day is in the list of given days to analyze © ZenAndTheArtOfTrading   Parameters:      monday (bool)      tuesday (bool)      wednesday (bool)      thursday (bool)      friday (bool)      saturday (bool)      sunday (bool)   Returns: A boolean - true if the current bar's day is one of the given days AUSSess()   Checks If The Current Australian Forex Session In Running   Returns: Bool - True If Currently The Australian Session Is Running ASIASess()   Checks If The Current Asian Forex Session In Running   Returns: Bool - True If Currently The Asian Session Is Running EURSess()   Checks If The Current European Forex Session In Running   Returns: Bool - True If Currently The European Session Is Running USSess()   Checks If The Current US Forex Session In Running   Returns: Bool - True If Currently The US Session Is Running UNIXToDate(Time, ConversionType, TimeZone)   Converts UNIX Time To Datetime   Parameters:      Time (int) : Is The UNIX Time Input      ConversionType (int) : Is The Datetime Output Format, Defval = DD-MM-YYYY      TimeZone (string) : Is To Convert The Outputed Datetime Into The Specified Time Zone, Defval = Exchange Time Zone   Returns: String - String Of Datetime
Pine Script® kütüphanesi
CN_FX-999 tarafından
LYGLibraryLibrary "LYGLibrary" A collection of custom tools & utility functions commonly used with my scripts getDecimals()   Calculates how many decimals are on the quote price of the current market   Returns: The current decimal places on the market quote price truncate(number, decimalPlaces)   Truncates (cuts) excess decimal places   Parameters:      number (float)      decimalPlaces (simple float)   Returns: The given number truncated to the given decimalPlaces toWhole(number)   Converts pips into whole numbers   Parameters:      number (float)   Returns: The converted number toPips(number)   Converts whole numbers back into pips   Parameters:      number (float)   Returns: The converted number getPctChange(value1, value2, lookback)   Gets the percentage change between 2 float values over a given lookback period   Parameters:      value1 (float)      value2 (float)      lookback (int) av_getPositionSize(balance, risk, stopPoints, conversionRate)   Calculates OANDA forex position size for AutoView based on the given parameters   Parameters:      balance (float)      risk (float)      stopPoints (float)      conversionRate (float)   Returns: The calculated position size (in units - only compatible with OANDA) bullFib(priceLow, priceHigh, fibRatio)   Calculates a bullish fibonacci value   Parameters:      priceLow (float) : The lowest price point      priceHigh (float) : The highest price point      fibRatio (float) : The fibonacci % ratio to calculate   Returns: The fibonacci value of the given ratio between the two price points bearFib(priceLow, priceHigh, fibRatio)   Calculates a bearish fibonacci value   Parameters:      priceLow (float) : The lowest price point      priceHigh (float) : The highest price point      fibRatio (float) : The fibonacci % ratio to calculate   Returns: The fibonacci value of the given ratio between the two price points getMA(length, maType)   Gets a Moving Average based on type (MUST BE CALLED ON EVERY CALCULATION)   Parameters:      length (simple int)      maType (string)   Returns: A moving average with the given parameters getEAP(atr)   Performs EAP stop loss size calculation (eg. ATR >= 20.0 and ATR < 30, returns 20)   Parameters:      atr (float)   Returns: The EAP SL converted ATR size getEAP2(atr)   Performs secondary EAP stop loss size calculation (eg. ATR < 40, add 5 pips, ATR between 40-50, add 10 pips etc)   Parameters:      atr (float)   Returns: The EAP SL converted ATR size barsAboveMA(lookback, ma)   Counts how many candles are above the MA   Parameters:      lookback (int)      ma (float)   Returns: The bar count of how many recent bars are above the MA barsBelowMA(lookback, ma)   Counts how many candles are below the MA   Parameters:      lookback (int)      ma (float)   Returns: The bar count of how many recent bars are below the EMA barsCrossedMA(lookback, ma)   Counts how many times the EMA was crossed recently   Parameters:      lookback (int)      ma (float)   Returns: The bar count of how many times price recently crossed the EMA getPullbackBarCount(lookback, direction)   Counts how many green & red bars have printed recently (ie. pullback count)   Parameters:      lookback (int)      direction (int)   Returns: The bar count of how many candles have retraced over the given lookback & direction getBodySize()   Gets the current candle's body size (in POINTS, divide by 10 to get pips)   Returns: The current candle's body size in POINTS getTopWickSize()   Gets the current candle's top wick size (in POINTS, divide by 10 to get pips)   Returns: The current candle's top wick size in POINTS getBottomWickSize()   Gets the current candle's bottom wick size (in POINTS, divide by 10 to get pips)   Returns: The current candle's bottom wick size in POINTS getBodyPercent()   Gets the current candle's body size as a percentage of its entire size including its wicks   Returns: The current candle's body size percentage isHammer(fib, colorMatch)   Checks if the current bar is a hammer candle based on the given parameters   Parameters:      fib (float)      colorMatch (bool)   Returns: A boolean - true if the current bar matches the requirements of a hammer candle isStar(fib, colorMatch)   Checks if the current bar is a shooting star candle based on the given parameters   Parameters:      fib (float)      colorMatch (bool)   Returns: A boolean - true if the current bar matches the requirements of a shooting star candle isDoji(wickSize, bodySize)   Checks if the current bar is a doji candle based on the given parameters   Parameters:      wickSize (float)      bodySize (float)   Returns: A boolean - true if the current bar matches the requirements of a doji candle isBullishEC(allowance, rejectionWickSize, engulfWick)   Checks if the current bar is a bullish engulfing candle   Parameters:      allowance (float)      rejectionWickSize (float)      engulfWick (bool)   Returns: A boolean - true if the current bar matches the requirements of a bullish engulfing candle isBearishEC(allowance, rejectionWickSize, engulfWick)   Checks if the current bar is a bearish engulfing candle   Parameters:      allowance (float)      rejectionWickSize (float)      engulfWick (bool)   Returns: A boolean - true if the current bar matches the requirements of a bearish engulfing candle isInsideBar()   Detects inside bars   Returns: Returns true if the current bar is an inside bar isOutsideBar()   Detects outside bars   Returns: Returns true if the current bar is an outside bar barInSession(sess, useFilter)   Determines if the current price bar falls inside the specified session   Parameters:      sess (simple string)      useFilter (bool)   Returns: A boolean - true if the current bar falls within the given time session barOutSession(sess, useFilter)   Determines if the current price bar falls outside the specified session   Parameters:      sess (simple string)      useFilter (bool)   Returns: A boolean - true if the current bar falls outside the given time session dateFilter(startTime, endTime)   Determines if this bar's time falls within date filter range   Parameters:      startTime (int)      endTime (int)   Returns: A boolean - true if the current bar falls within the given dates dayFilter(monday, tuesday, wednesday, thursday, friday, saturday, sunday)   Checks if the current bar's day is in the list of given days to analyze   Parameters:      monday (bool)      tuesday (bool)      wednesday (bool)      thursday (bool)      friday (bool)      saturday (bool)      sunday (bool)   Returns: A boolean - true if the current bar's day is one of the given days atrFilter(atrValue, maxSize)   Parameters:      atrValue (float)      maxSize (float) fillCell(tableID, column, row, title, value, bgcolor, txtcolor)   This updates the given table's cell with the given values   Parameters:      tableID (table)      column (int)      row (int)      title (string)      value (string)      bgcolor (color)      txtcolor (color)   Returns: A boolean - true if the current bar falls within the given dates
Pine Script® kütüphanesi
liyugen tarafından
LineWrapperLibrary "LineWrapper" Wrapper Type for Line. Useful when you want to store the line details without drawing them. Can also be used in scnearios where you collect lines to be drawn and draw together towards the end. draw(this)   draws line as per the wrapper object contents   Parameters:      this : (series Line) Line object.   Returns: current Line object draw(this)   draws lines as per the wrapper object array   Parameters:      this : (series array) Array of Line object.   Returns: current Array of Line objects update(this)   updates or redraws line as per the wrapper object contents   Parameters:      this : (series Line) Line object.   Returns: current Line object update(this)   updates or redraws lines as per the wrapper object array   Parameters:      this : (series array) Array of Line object.   Returns: current Array of Line objects get_price(this, bar)   get line price based on bar   Parameters:      this : (series Line) Line object.      bar : (series/int) bar at which line price need to be calculated   Returns: line price at given bar. get_x1(this)   Returns UNIX time or bar index (depending on the last xloc value set) of the first point of the line.   Parameters:      this : (series Line) Line object.   Returns: UNIX timestamp (in milliseconds) or bar index. get_x2(this)   Returns UNIX time or bar index (depending on the last xloc value set) of the second point of the line.   Parameters:      this : (series Line) Line object.   Returns: UNIX timestamp (in milliseconds) or bar index. get_y1(this)   Returns price of the first point of the line.   Parameters:      this : (series Line) Line object.   Returns: Price value. get_y2(this)   Returns price of the second point of the line.   Parameters:      this : (series Line) Line object.   Returns: Price value. set_x1(this, x, draw, update)   Sets bar index or bar time (depending on the xloc) of the first point.   Parameters:      this : (series Line) Line object.      x : (series int) Bar index or bar time. Note that objects positioned using xloc.bar_index cannot be drawn further than 500 bars into the future.      draw : (series bool) draw line after setting attribute      update : (series bool) update line instead of redraw. Only valid if draw is set.   Returns: Current Line object set_x2(this, x, draw, update)   Sets bar index or bar time (depending on the xloc) of the second point.   Parameters:      this : (series Line) Line object.      x : (series int) Bar index or bar time. Note that objects positioned using xloc.bar_index cannot be drawn further than 500 bars into the future.      draw : (series bool) draw line after setting attribute      update : (series bool) update line instead of redraw. Only valid if draw is set.   Returns: Current Line object set_y1(this, y, draw, update)   Sets price of the first point   Parameters:      this : (series Line) Line object.      y : (series int/float) Price.      draw : (series bool) draw line after setting attribute      update : (series bool) update line instead of redraw. Only valid if draw is set.   Returns: Current Line object set_y2(this, y, draw, update)   Sets price of the second point   Parameters:      this : (series Line) Line object.      y : (series int/float) Price.      draw : (series bool) draw line after setting attribute      update : (series bool) update line instead of redraw. Only valid if draw is set.   Returns: Current Line object set_color(this, color, draw, update)   Sets the line color   Parameters:      this : (series Line) Line object.      color : (series color) New line color      draw : (series bool) draw line after setting attribute      update : (series bool) update line instead of redraw. Only valid if draw is set.   Returns: Current Line object set_extend(this, extend, draw, update)   Sets extending type of this line object. If extend=extend.none, draws segment starting at point (x1, y1) and ending at point (x2, y2). If extend is equal to extend.right or extend.left, draws a ray starting at point (x1, y1) or (x2, y2), respectively. If extend=extend.both, draws a straight line that goes through these points.   Parameters:      this : (series Line) Line object.      extend : (series string) New extending type.      draw : (series bool) draw line after setting attribute      update : (series bool) update line instead of redraw. Only valid if draw is set.   Returns: Current Line object set_style(this, style, draw, update)   Sets the line style   Parameters:      this : (series Line) Line object.      style : (series string) New line style.      draw : (series bool) draw line after setting attribute      update : (series bool) update line instead of redraw. Only valid if draw is set.   Returns: Current Line object set_width(this, width, draw, update)   Sets the line width.   Parameters:      this : (series Line) Line object.      width : (series int) New line width in pixels.      draw : (series bool) draw line after setting attribute      update : (series bool) update line instead of redraw. Only valid if draw is set.   Returns: Current Line object set_xloc(this, x1, x2, xloc, draw, update)   Sets x-location and new bar index/time values.   Parameters:      this : (series Line) Line object.      x1 : (series int) Bar index or bar time of the first point.      x2 : (series int) Bar index or bar time of the second point.      xloc : (series string) New x-location value.      draw : (series bool) draw line after setting attribute      update : (series bool) update line instead of redraw. Only valid if draw is set.   Returns: Current Line object set_xy1(this, x, y, draw, update)   Sets bar index/time and price of the first point.   Parameters:      this : (series Line) Line object.      x : (series int) Bar index or bar time. Note that objects positioned using xloc.bar_index cannot be drawn further than 500 bars into the future.      y : (series int/float) Price.      draw : (series bool) draw line after setting attribute      update : (series bool) update line instead of redraw. Only valid if draw is set.   Returns: Current Line object set_xy2(this, x, y, draw, update)   Sets bar index/time and price of the second point   Parameters:      this : (series Line) Line object.      x : (series int) Bar index or bar time. Note that objects positioned using xloc.bar_index cannot be drawn further than 500 bars into the future.      y : (series int/float) Price.      draw : (series bool) draw line after setting attribute      update : (series bool) update line instead of redraw. Only valid if draw is set.   Returns: Current Line object delete(this)   Deletes the underlying line drawing object   Parameters:      this : (series Line) Line object.   Returns: Current Line object Line   Line Wrapper object   Fields:      x1 : (series int) Bar index (if xloc = xloc.bar_index) or bar UNIX time (if xloc = xloc.bar_time) of the first point of the line. Note that objects positioned using xloc.bar_index cannot be drawn further than 500 bars into the future.      y1 : (series int/float) Price of the first point of the line.      x2 : (series int) Bar index (if xloc = xloc.bar_index) or bar UNIX time (if xloc = xloc.bar_time) of the second point of the line. Note that objects positioned using xloc.bar_index cannot be drawn further than 500 bars into the future.      y2 : (series int/float) Price of the second point of the line.      xloc : (series string) See description of x1 argument. Possible values: xloc.bar_index and xloc.bar_time. Default is xloc.bar_index.      extend : (series string) If extend=extend.none, draws segment starting at point (x1, y1) and ending at point (x2, y2). If extend is equal to extend.right or extend.left, draws a ray starting at point (x1, y1) or (x2, y2), respectively. If extend=extend.both, draws a straight line that goes through these points. Default value is extend.none.      color : (series color) Line color.      style : (series string) Line style. Possible values: line.style_solid, line.style_dotted, line.style_dashed, line.style_arrow_left, line.style_arrow_right, line.style_arrow_both.      width : (series int) Line width in pixels.      obj : line object
Pine Script® kütüphanesi
Trendoscope tarafından
2
CVD - Cumulative Volume Delta (Chart)█   OVERVIEW This indicator displays cumulative ​volume delta (​CVD) as an on-chart oscillator. It uses intrabar analysis to obtain more precise ​volume delta information compared to methods that only use the chart's timeframe. The core concepts in this script come from our first ​ CVD indicator , which displays CVD​ values as plot candles in a separate indicator pane. In this script, CV​D values are scaled according to price ranges and represented on the main chart pane. █   CONCEPTS Bar polarity Bar polarity refers to the position of the close price relative to the open price. In other words, bar polarity is the direction of price change. Intrabars Intrabars are chart bars at a lower timeframe than the chart's. Each 1H chart bar of a 24x7 market will, for example, usually contain 60 bars at the lower timeframe of 1min, provided there was market activity during each minute of the hour. Mining information from intrabars can be useful in that it offers traders visibility on the activity inside a chart bar. Lower timeframes (LTFs) A lower timeframe is a timeframe that is smaller than the chart's timeframe. This script utilizes a LTF to analyze intrabars, or price changes within a chart bar. The lower the ​LTF, the more intrabars are analyzed, but the less chart bars can display information due to the limited number of intrabars that can be analyzed. Volume delta Volume delta is a measure that separates ​volume​ into "up" and "down" parts, then takes the difference to estimate the net demand for the asset. This approach gives traders a more detailed insight when analyzing volume​ and market sentiment. There are several methods for determining whether an asset's volume​ belongs in the "up" or "down" category. Some indicators, such as On Balance Volume​ and the Klinger Oscillator , use the change in price between bars to assign ​volume​ values to the appropriate category. Others, such as Chaikin Money Flow , make assumptions based on open, high, low, and close prices. The most accurate method involves using tick data to determine whether each transaction occurred at the bid or ask price and assigning the ​volume​ value to the appropriate category accordingly. However, this method requires a large amount of data on historical bars, which can limit the historical depth of charts and the number of symbols for which tick data is available. In the context where historical tick data is not yet available on TradingView, intrabar analysis is the most precise technique to calculate ​volume delta on historical bars on our charts. This indicator uses intrabar analysis to achieve a compromise between simplicity and accuracy in calculating ​volume delta on historical bars. Our Volume Profile indicators use it as well. Other ​volume delta indicators in our Community Scripts , such as the Realtime 5D Profile , use real-time chart updates to achieve more precise ​volume delta calculations. However, these indicators aren't suitable for analyzing historical bars since they only work for real-time analysis. This is the logic we use to assign intrabar ​volume to the "up" or "down" category:  • If the intrabar's open and close values are different, their relative position is used.  • If the intrabar's open and close values are the same, the difference between the intrabar's close and the previous intrabar's close is used.  • As a last resort, when there is no movement during an intrabar and it closes at the same price as the previous intrabar, the last known polarity is used. Once all intrabars comprising a chart bar are analyzed, we calculate the net difference between "up" and "down" intrabar volume​ to produce the volume​ delta for the chart bar. █   FEATURES CVD resets The "cumulative" part of the indicator's name stems from the fact that calculations accumulate during a period of time. By periodically resetting the volume​ delta accumulation, we can analyze the progression of ​volume delta across manageable chunks, which is often more useful than looking at ​volume delta accumulated from the beginning of a chart's history. You can configure the reset period using the "CVD Resets" input, which offers the following selections:  • None : Calculations do not reset.  • On a fixed higher timeframe : Calculations reset on the higher timeframe you select in the "Fixed higher timeframe" field.  • At a fixed time that you specify.  • At the beginning of the regular session .  • On trend changes : Calculations reset on the direction change of either the Aroon indicator, Parabolic SAR , or Supertrend .  • On a stepped higher timeframe : Calculations reset on a higher timeframe automatically stepped using the chart's timeframe and following these rules: Chart TF ​HTF < 1min 1H < 3H 1D <= 12H 1W < 1W 1M >= 1W 1Y Specifying intrabar precision Ten options are included in the script to control the number of intrabars used per chart bar for calculations. The greater the number of intrabars per chart bar, the fewer chart bars can be analyzed. The first five options allow users to specify the approximate amount of chart bars to be covered:  • Least Precise (Most chart bars) : Covers all chart bars by dividing the current timeframe by four.   This ensures the highest level of intrabar precision while achieving complete coverage for the dataset.  • Less Precise (Some chart bars) & More Precise (Less chart bars) : These options calculate a stepped ​LTF in relation to the current chart's timeframe.  • Very precise (2min intrabars) : Uses the second highest quantity of intrabars possible with the 2min ​LTF.  • Most precise (1min intrabars) : Uses the maximum quantity of intrabars possible with the 1min ​LTF. The stepped lower timeframe for "Less Precise" and "More Precise" options is calculated from the current chart's timeframe as follows: Chart Timeframe Lower Timeframe Less Precise More Precise < 1hr 1min 1min < 1D 15min 1min < 1W ​2hr​ 30min > 1W 1D 60min The last five options allow users to specify an approximate fixed number of intrabars to analyze per chart bar. The available choices are 12, 24, 50, 100, and 250. The script will calculate the LTF​ which most closely approximates the specified number of intrabars per chart bar. Keep in mind that due to factors such as the length of a ticker's sessions and rounding of the LTF​, it is not always possible to produce the exact number specified. However, the script will do its best to get as close to the value as possible. As there is a limit to the number of intrabars that can be analyzed by a script, a tradeoff occurs between the number of intrabars analyzed per chart bar and the chart bars for which calculations are possible. Display This script displays raw or cumulative volume​ delta values on the chart as either line or histogram oscillator zones scaled according to the price chart, allowing traders to visualize volume​ activity on each bar or cumulatively over time. The indicator's background shows where CVD​ resets occur, demarcating the beginning of new zones. The vertical axis of each oscillator zone is scaled relative to the one with the highest price range, and the oscillator values are scaled relative to the highest volume​ delta. A vertical offset is applied to each oscillator zone so that the highest oscillator value aligns with the lowest price. This method ensures an accurate, intuitive visual comparison of volume​ activity within zones, as the scale is consistent across the chart, and oscillator values sit below prices. The vertical scale of oscillator zones can be adjusted using the "Zone Height" input in the script settings. This script displays labels at the highest and lowest oscillator values in each zone, which can be enabled using the "Hi/Lo Labels" input in the "Visuals" section of the script settings. Additionally, the oscillator's value on a chart bar is displayed as a tooltip when a user hovers over the bar, which can be enabled using the "Value Tooltips" input. Divergences occur when the polarity of ​volume delta does not match that of the chart bar. The script displays divergences as bar colors and background colors that can be enabled using the "Color bars on divergences" and "Color background on divergences" inputs. An information box in the lower-left corner of the indicator displays the HTF used for resets, the ​LTF used for intrabars, the average quantity of intrabars per chart bar, and the number of chart bars for which there is LTF data. This is enabled using the "Show information box" input in the "Visuals" section of the script settings. FOR Pine Script™ CODERS  • This script utilizes `ltf()` and `ltfStats()` from the lower_tf library.   The `ltf()` function determines the appropriate lower timeframe from the selected calculation mode and chart timeframe, and returns it in a format that can be used with request.security_lower_tf() .   The `ltfStats()` function, on the other hand, is used to compute and display statistical information about the lower timeframe in an information box.  • The script utilizes display.data_window and display.status_line to restrict the display of certain plots.   These new built-ins allow coders to fine-tune where a script’s plot values are displayed.  • The newly added session.isfirstbar_regular built-in allows for resetting the ​CVD segments at the start of the regular session.  • The VisibleChart library developed by our resident PineCoders team leverages the chart.left_visible_bar_time and chart.right_visible_bar_time variables to optimize the performance of this script.   These variables identify the opening time of the leftmost and rightmost visible bars on the chart, allowing the script to recalculate and draw objects only within the range of visible bars as the user scrolls.   This functionality also enables the scaling of the oscillator zones.   These variables are just a couple of the many new built-ins available in the chart.* namespace.   For more information, check out this blog post or look them up by typing "chart." in the Pine Script™ Reference Manual .  • Our ta library has undergone significant updates recently, including the incorporation of the `aroon()` indicator used as a method for resetting ​CVD segments within this script.   Revisit the library to see more of the newly added content! Look first. Then leap.
Pine Script® göstergesi
TradingView tarafından
58
Delta Volume Channels [LucF]█  OVERVIEW This indicator displays on-chart visuals aimed at making the most of delta ​volume information. It can color bars and display two channels: one for delta ​volume, another calculated from the price levels of bars where delta ​volume divergences occur. Markers and alerts can also be configured using key conditions, and filtered in many different ways. The indicator caters to traders who prefer chart visuals over raw values. It will work on historical bars and in real time, using intrabar analysis to calculate delta ​volume in both conditions. █  CONCEPTS Delta Volume ​The ​volume delta concept divides a bar's ​volume in "up" and "down" ​volumes. The delta is calculated by subtracting down ​volume from up ​volume. Many calculation techniques exist to isolate up and down ​volume within a bar. The simplest techniques use the polarity of interbar price changes to assign their ​volume to up or down slots, e.g., On Balance Volume or the Klinger Oscillator . Others such as Chaikin Money Flow use assumptions based on a bar's OHLC values. The most precise calculation method uses tick data and assigns the ​volume of each tick to the up or down slot depending on whether the transaction occurs at the bid or ask price. While this technique is ideal, it requires huge amounts of data on historical bars, which usually limits the historical depth of charts and the number of symbols for which tick data is available. This indicator uses intrabar analysis to achieve a compromise between the simplest and most precise methods of calculating ​volume delta. In the context where historical tick data is not yet available on TradingView, intrabar analysis is the most precise technique to calculate ​volume delta on historical bars on our charts. TradingView's Volume Profile built-in indicators use it, as do the CVD - Cumulative ​Volume Delta Candles and CVD - Cumulative Volume Delta (Chart) indicators published from the TradingView account . My Volume Delta Columns Pro indicator also uses intrabar analysis. Other ​volume delta indicators such as my Realtime 5D Profile use realtime chart updates to achieve more precise ​volume delta calculations. Indicators of that type cannot be used on historical bars however; they only work in real time. This is the logic I use to assign intrabar ​volume to up or down slots:  • If the intrabar's open and close values are different, their relative position is used.  • If the intrabar's open and close values are the same, the difference between the intrabar's close and the previous intrabar's close is used.  • As a last resort, when there is no movement during an intrabar and it closes at the same price as the previous intrabar, the last known polarity is used. Once all intrabars making up a chart bar have been analyzed and the up or down property of each intrabar's ​volume determined, the up volumes are added and the down volumes subtracted. The resulting value is ​volume delta for that chart bar, which can be used as an estimate of the buying/selling pressure on an instrument. Delta ​Volume Percent (DV%) This value is the proportion that delta ​volume represents of the total intrabar ​volume in the chart bar. Note that on some symbols/timeframes, the total intrabar ​volume may differ from the chart's ​volume for a bar, but that will not affect our calculations since we use the total intrabar ​volume. Delta ​Volume Channel The ​​DV channel is the space between two moving averages: the reference line and a DV%-weighted version of that reference. The reference line is a moving average of a type, source and length which you select. The DV%-weighted line uses the same settings, but it averages the DV%-weighted price source. The weight applied to the source of the reference line is calculated from two values, which are multiplied: DV% and the relative size of the bar's ​volume in relation to previous bars. The effect of this is that DV% values on bars with higher total ​volume will carry greater weight than those with lesser ​volume. The ​DV channel can be in one of four states, each having its corresponding color:  • Bull (teal): The DV%-weighted line is above the reference line.  • Strong bull (lime): The bull condition is fulfilled and the bar's close is above the reference line and both the reference and the DV%-weighted lines are rising.  • Bear (maroon): The DV%-weighted line is below the reference line.  • Strong bear (pink): The bear condition is fulfilled and the bar's close is below the reference line and both the reference and the DV%-weighted lines are falling. Divergences In the context of this indicator, a divergence is any bar where the slope of the reference line does not match that of the DV%-weighted line. No directional bias is assigned to divergences when they occur. Divergence Channel The divergence channel is the space between two levels (by default, the bar's low and high ) saved when divergences occur. When price has breached a channel and a new divergence occurs, a new channel is created. Until that new channel is breached, bars where additional divergences occur will expand the channel's levels if the bar's price points are outside the channel. Prices breaches of the divergence channel will change its state. Divergence channels can be in one of five different states:  • Bull (teal): Price has breached the channel to the upside.  • Strong bull (lime): The bull condition is fulfilled and the ​DV channel is in the strong bull state.  • Bear (maroon): Price has breached the channel to the downside.  • Strong bear (pink): The bear condition is fulfilled and the ​DV channel is in the strong bear state.  • Neutral (gray): The channel has not been breached. █  HOW TO USE THE INDICATOR Load the indicator on an active chart (see here if you don't know how). The default configuration displays:  • The ​DV channel, without the reference or DV%-weighted lines.  • The Divergence channel, without its level lines.  • Bar colors using the state of the ​DV channel. The default settings use an Arnaud-Legoux moving average on the close and a length of 20 bars. The DV%-weighted version of it uses a combination of DV% and relative ​volume to calculate the ultimate weight applied to the reference. The DV%-weighted line is capped to 5 standard deviations of the reference. The lower timeframe used to access intrabars automatically adjusts to the chart's timeframe and achieves optimal balance between the number of intrabars inspected in each chart bar, and the number of chart bars covered by the script's calculations. The Divergence channel's levels are determined using the high and low of the bars where divergences occur. Breaches of the channel require a bar's low to move above the top of the channel, and the bar's high to move below the channel's bottom. No markers appear on the chart; if you want to create alerts from this script, you will need first to define the conditions that will trigger the markers, then create the alert, which will trigger on those same conditions. To learn more about how to use this indicator, you must understand the concepts it uses and the information it displays, which requires reading this description. There are no videos to explain it. █  FEATURES The script's inputs are divided in four sections: "DV channel", "Divergence channel", "Other Visuals" and "Marker/Alert Conditions". The first setting is the selection method used to determine the intrabar precision, i.e., how many lower timeframe bars (intrabars) are examined in each chart bar. The more intrabars you analyze, the more precise the calculation of DV% results will be, but the less chart coverage can be covered by the script's calculations. DV Channel Here, you control the visibility and colors of the reference line, its weighted version, and the DV channel between them. You also specify what type of moving average you want to use as a reference line, its source and length. This acts as the ​DV channel's baseline. The DV%-weighted line is also a moving average of the same type and length as the reference line, except that it will be calculated from the DV%-weighted source used in the reference line. By default, the DV%-weighted line is capped to five standard deviations of the reference line. You can change that value here. This section is also where you can disable the relative ​volume component of the weight. Divergence Channel This is where you control the appearance of the divergence channel and the key price values used in determining the channel's levels and breaching conditions. These choices have an impact on the behavior of the channel. More generous level prices like the default low and high selection will produce more conservative channels, as will the default choice for breach prices. In this section, you can also enable a mode where an attempt is made to estimate the channel's bias before price breaches the channel. When it is enabled, successive increases/decreases of the channel's top and bottom levels are counted as new divergences occur. When one count is greater than the other, a bull/bear bias is inferred from it. Other Visuals You specify here:  • The method used to color chart bars, if you choose to do so.  • The display of a mark appearing above or below bars when a divergence occurs.  • If you want raw values to appear in tooltips when you hover above chart bars. The default setting does not display them, which makes the script faster.  • If you want to display an information box which by default appears in the lower left of the chart.   It shows which lower timeframe is used for intrabars, and the average number of intrabars per chart bar. Marker/Alert Conditions Here, you specify the conditions that will trigger up or down markers. The trigger conditions can include a combination of state transitions of the ​DV and the divergence channels. The triggering conditions can be filtered using a variety of conditions. Configuring the marker conditions is necessary before creating an alert from this script, as the alert will use the marker conditions to trigger. Markers only appear on bar closes, so they will not repaint. Keep in mind, when looking at markers on historical bars, that they are positioned on the bar when it closes — NOT when it opens. Raw values The raw values calculated by this script can be inspected using a tooltip and the Data Window. The tooltip is visible when you hover over the top of chart bars. It will display on the last 500 bars of the chart, and shows the values of ​DV, DV%, the combined weight, and the intermediary values used to calculate them. █  INTERPRETATION The aim of the ​DV channel is to provide a visual representation of the buying/selling pressure calculated using delta ​volume. The simplest characteristic of the channel is its bull/bear state. One can then distinguish between its bull and strong bull states, as transitions from strong bull to bull states will generally happen when buyers are losing steam. While one should not infer a reversal from such transitions, they can be a good place to tighten stops. Only time will tell if a reversal will occur. One or more divergences will often occur before reversals. The nature of the divergence channel's design makes it particularly adept at identifying consolidation areas if its settings are kept on the conservative side. A gray divergence channel should usually be considered a no-trade zone. More adventurous traders can use the ​DV channel to orient their trade entries if they accept the risk of trading in a neutral divergence channel, which by definition will not have been breached by price. If your charts are already busy with other stuff you want to hold on to, you could consider using only the chart bar coloring component of this indicator: At its simplest, one way to use this indicator would be to look for overlaps of the strong bull/bear colors in both the ​DV channel and a divergence channel, as these identify points where price is breaching the divergence channel when buy/sell pressure is consistent with the direction of the breach. I have highlighted all those points in the chart below. Not all of them would have produced profitable trades, but nothing is perfect in the markets. Also, keep in mind that the circles identify the visual you would be looking for — not the trade's entry level. █  LIMITATIONS  • The script will not work on symbols where no ​volume is available. An error will appear when that is the case.  • Because a maximum of 100K intrabars can be analyzed by a script, a compromise is necessary between the number of intrabars analyzed per chart bar   and chart coverage. The more intrabars you analyze per chart bar, the less coverage you will obtain.   The setting of the "Intrabar precision" field in the "DV channel" section of the script's inputs   is where you control how the lower timeframe is calculated from the chart's timeframe. █  NOTES Volume Quality If you use ​volume, it's important to understand its nature and quality, as it varies with sectors and instruments. My Volume X-ray indicator is one way you can appraise the quality of an instrument's intraday ​volume. For Pine Script™ Coders  • This script uses the new overload of the fill() function which now makes it possible to do vertical gradients in Pine. I use it for both channels displayed by this script.  • I use the new arguments for plot() 's `display` parameter to control where the script plots some of its values,   namely those I only want to appear in the script's status line and in the Data Window.  • I wrote my script using the revised recommendations in the Style Guide from the Pine v5 User Manual. █  THANKS To PineCoders . I have used their lower_tf library in this script, to manage the calculation of the LTF and intrabar stats, and their Time library to convert a timeframe in seconds to a printable form for its display in the Information box. To TradingView's Pine Script™ team. Their innovations and improvements, big and small, constantly expand the boundaries of the language. What this script does would not have been possible just a few months back. And finally, thanks to all the users of my scripts who take the time to comment on my publications and suggest improvements. I do not reply to all but I do read your comments and do my best to implement your suggestions with the limited time that I have.
Pine Script® göstergesi
LucF tarafından
51
lower_tf█   OVERVIEW This library is a Pine programmer’s tool containing functions to help those who use the request.security_lower_tf() function. Its `ltf()` function helps translate user inputs into a lower timeframe string usable with request.security_lower_tf() . Another function, `ltfStats()`, accumulates statistics on processed chart bars and intrabars. █   CONCEPTS Chart bars Chart bars , as referred to in our publications, are bars that occur at the current chart timeframe, as opposed to those that occur at a timeframe that is higher or lower than that of the chart view. Intrabars Intrabars are chart bars at a lower timeframe than the chart's. Each 1H chart bar of a 24x7 market will, for example, usually contain 60 intrabars at the ​LTF of 1min, provided there was market activity during each minute of the hour. Mining information from intrabars can be useful in that it offers traders visibility on the activity inside a chart bar. Lower timeframes (LTFs) A lower timeframe is a timeframe that is smaller than the chart's timeframe. This framework exemplifies how authors can determine which ​LTF to use by examining the chart's timeframe. The ​LTF determines how many intrabars are examined for each chart bar; the lower the timeframe, the more intrabars are analyzed. Intrabar precision The precision of calculations increases with the number of intrabars analyzed for each chart bar. As there is a 100K limit to the number of intrabars that can be analyzed by a script, a trade-off occurs between the number of intrabars analyzed per chart bar and the chart bars for which calculations are possible. █   `ltf()` This function returns a timeframe string usable with request.security_lower_tf() . It calculates the returned timeframe by taking into account a user selection between eight different calculation modes and the chart's timeframe. You send it the user's selection, along with the text corresponding to the eight choices from which the user has chosen, and the function returns a corresponding ​LTF string. Because the function processes strings and doesn't require recalculation on each bar, using var to declare the variable to which its result is assigned will execute the function only once on bar zero and speed up your script: var string ltfString = ​ltf(ltfModeInput, LTF1, LTF2, LTF3, LTF4, LTF5, LTF6, LTF7, LTF8) The eight choices users can select from are of two types: the first four allow a selection from the desired amount of chart bars to be covered, the last four are choices of a fixed number of intrabars to be analyzed per chart bar. Our example code shows how to structure your input call and then make the call to `ltf()`. By changing the text associated with the `LTF1` to `LTF8` constants, you can tailor it to your preferences while preserving the functionality of `ltf()` because you will be sending those string constants as the function's arguments so it can determine the user's selection. The association between each `LTFx` constant and its calculation mode is fixed, so the order of the arguments is important when you call `ltf()`. These are the first four modes and the `LTFx` constants corresponding to each: Covering most chart bars (least precise) — LTF1 Covers all chart bars. This is accomplished by dividing the current timeframe in seconds by 4 and converting that number back to a string in timeframe.period format using secondsToTfString() . Due to the fact that, on premium subscriptions, the typical historical bar count is between 20-25k bars, dividing the timeframe by 4 ensures the highest level of intrabar precision possible while achieving complete coverage for the entire dataset with the maximum allowed 100K intrabars. Covering some chart bars (less precise) — LTF2 Covering less chart bars (more precise) — LTF3 These levels offer a stepped ​LTF in relation to the chart timeframe with slightly more, or slightly less precision. The stepped lower timeframe tiers are calculated from the chart timeframe as follows: Chart Timeframe Lower Timeframe Less Precise More Precise < 1hr 1min 1min < 1D 15min 1min < 1W ​2hr​ 30min > 1W 1D 60min Covering the least chart bars (most precise) — LTF4 Analyzes the maximum quantity of intrabars possible by using the 1min ​LTF, which also allows the least amount of chart bars to be covered. The last four modes allow the user to specify a fixed number of intrabars to analyze per chart bar. Users can choose from 12, 24, 50 or 100 intrabars, respectively corresponding to the `LTF5`, `LTF6`, `LTF7` and `LTF8` constants. The value is a target; the function will do its best to come up with a ​LTF producing the required number of intrabars. Because of considerations such as the length of a ticker's session, rounding of the ​LTF to the closest allowable timeframe, or the lowest allowable timeframe of 1min intrabars, it is often impossible for the function to find a ​​LTF producing the exact number of intrabars. Requesting 100 intrabars on a 60min chart, for example, can only produce 60 1min intrabars. Higher chart timeframes, tickers with high liquidity or 24x7 markets will produce optimal results. █   `ltfStats()` `ltfStats()` returns statistics that will be useful to programmers using intrabar inspection. By analyzing the arrays returned by request.security_lower_tf() in can determine:  • intrabarsInChartBar : The number of intrabars analyzed for each chart bar.  • chartBarsCovered : The number of chart bars where intrabar information is available.  • avgIntrabars : The average number of intrabars analyzed per chart bar. Events like holidays, market activity, or reduced hours sessions can cause the number of intrabars to vary, bar to bar. The function must be called on each bar to produce reliable results. █   DEMONSTRATION CODE Our example code shows how to provide users with an input from which they can select a ​LTF calculation mode. If you use this library's functions, feel free to reuse our input setup code, including the tooltip providing users with explanations on how it works for them. We make a simple call to request.security_lower_tf() to fetch the close values of intrabars, but we do not use those values. We simply send the returned array to `ltfStats()` and then plot in the indicator's pane the number of intrabars examined on each bar and its average. We also display an information box showing the user's selection of the ​LTF calculation mode, the resulting ​LTF calculated by `ltf()` and some statistics. █   NOTES  • As in several of our recent publications, this script uses secondsToTfString() to produce a timeframe string in timeframe.period format from a timeframe expressed in seconds.  • The script utilizes display.data_window and display.status_line to restrict the display of certain plots.   These new built-ins allow coders to fine-tune where a script’s plot values are displayed.  • We implement a new recommended best practice for tables which works faster and reduces memory consumption.   Using this new method, tables are declared only once with var , as usual. Then, on bar zero only, we use table.cell() calls to populate the table.   Finally, table.set_*() functions are used to update attributes of table cells on the last bar of the dataset.   This greatly reduces the resources required to render tables. We encourage all Pine Script™ programmers to do the same. Look first. Then leap. █   FUNCTIONS The library contains the following functions: ltf(userSelection, choice1, choice2, choice3, choice4, choice5, choice6, choice7, choice8)   Selects a ​LTF from the chart's TF, depending on the `userSelection` input string.   Parameters:      userSelection : (simple string) User-selected input string which must be one of the `choicex` arguments.      choice1 : (simple string) Input selection corresponding to "Least precise, covering most chart bars".      choice2 : (simple string) Input selection corresponding to "Less precise, covering some chart bars".      choice3 : (simple string) Input selection corresponding to "More precise, covering less chart bars".      choice4 : (simple string) Input selection corresponding to "Most precise, 1min intrabars".      choice5 : (simple string) Input selection corresponding to "~12 intrabars per chart bar".      choice6 : (simple string) Input selection corresponding to "~24 intrabars per chart bar".      choice7 : (simple string) Input selection corresponding to "~50 intrabars per chart bar".      choice8 : (simple string) Input selection corresponding to "~100 intrabars per chart bar".   Returns: (simple string) A timeframe string to be used with `request.security_lower_tf()`. ltfStats()   Returns statistics about analyzed intrabars and chart bars covered by calls to `request.security_lower_tf()`.   Parameters:      intrabarValues : (float [ ]) The ID of a float array containing values fetched by a call to `request.security_lower_tf()`.   Returns: A 3-element tuple: [ (series int) intrabarsInChartBar, (series int) chartBarsCovered, (series float) avgIntrabars ].
Pine Script® kütüphanesi
PineCoders tarafından
16
Library CommonLibrary "LibraryCommon" A collection of custom tools & utility functions commonly used with my scripts @description TODO: add library description here getDecimals() Calculates how many decimals are on the quote price of the current market   Returns: The current decimal places on the market quote price truncate(float, float) Truncates (cuts) excess decimal places   Parameters:      float : number The number to truncate      float : decimalPlaces (default=2) The number of decimal places to truncate to   Returns: The given number truncated to the given decimalPlaces toWhole(float) Converts pips into whole numbers   Parameters:      float : number The pip number to convert into a whole number   Returns: The converted number toPips(float) Converts whole numbers back into pips   Parameters:      float : number The whole number to convert into pips   Returns: The converted number getPctChange(float, float, int) Gets the percentage change between 2 float values over a given lookback period   Parameters:      float : value1 The first value to reference      float : value2 The second value to reference      int : lookback The lookback period to analyze av_getPositionSize(float, float, float, float) Calculates OANDA forex position size for AutoView based on the given parameters   Parameters:      float : balance The account balance to use      float : risk The risk percentage amount (as a whole number - eg. 1 = 1% risk)      float : stopPoints The stop loss distance in POINTS (not pips)      float : conversionRate The conversion rate of our account balance currency   Returns: The calculated position size (in units - only compatible with OANDA) bullFib(priceLow, priceHigh, fibRatio) Calculates a bullish fibonacci value   Parameters:      priceLow : The lowest price point      priceHigh : The highest price point      fibRatio : The fibonacci % ratio to calculate   Returns: The fibonacci value of the given ratio between the two price points bearFib(priceLow, priceHigh, fibRatio) Calculates a bearish fibonacci value   Parameters:      priceLow : The lowest price point      priceHigh : The highest price point      fibRatio : The fibonacci % ratio to calculate   Returns: The fibonacci value of the given ratio between the two price points getMA(int, string) Gets a Moving Average based on type (MUST BE CALLED ON EVERY CALCULATION)   Parameters:      int : length The MA period      string : maType The type of MA   Returns: A moving average with the given parameters getEAP(float) Performs EAP stop loss size calculation (eg. ATR >= 20.0 and ATR < 30, returns 20)   Parameters:      float : atr The given ATR to base the EAP SL calculation on   Returns: The EAP SL converted ATR size getEAP2(float) Performs secondary EAP stop loss size calculation (eg. ATR < 40, add 5 pips, ATR between 40-50, add 10 pips etc)   Parameters:      float : atr The given ATR to base the EAP SL calculation on   Returns: The EAP SL converted ATR size barsAboveMA(int, float) Counts how many candles are above the MA   Parameters:      int : lookback The lookback period to look back over      float : ma The moving average to check   Returns: The bar count of how many recent bars are above the MA barsBelowMA(int, float) Counts how many candles are below the MA   Parameters:      int : lookback The lookback period to look back over      float : ma The moving average to reference   Returns: The bar count of how many recent bars are below the EMA barsCrossedMA(int, float) Counts how many times the EMA was crossed recently   Parameters:      int : lookback The lookback period to look back over      float : ma The moving average to reference   Returns: The bar count of how many times price recently crossed the EMA getPullbackBarCount(int, int) Counts how many green & red bars have printed recently (ie. pullback count)   Parameters:      int : lookback The lookback period to look back over      int : direction The color of the bar to count (1 = Green, -1 = Red)   Returns: The bar count of how many candles have retraced over the given lookback & direction getBodySize() Gets the current candle's body size (in POINTS, divide by 10 to get pips)   Returns: The current candle's body size in POINTS getTopWickSize() Gets the current candle's top wick size (in POINTS, divide by 10 to get pips)   Returns: The current candle's top wick size in POINTS getBottomWickSize() Gets the current candle's bottom wick size (in POINTS, divide by 10 to get pips)   Returns: The current candle's bottom wick size in POINTS getBodyPercent() Gets the current candle's body size as a percentage of its entire size including its wicks   Returns: The current candle's body size percentage isHammer(float, bool) Checks if the current bar is a hammer candle based on the given parameters   Parameters:      float : fib (default=0.382) The fib to base candle body on      bool : colorMatch (default=false) Does the candle need to be green? (true/false)   Returns: A boolean - true if the current bar matches the requirements of a hammer candle isStar(float, bool) Checks if the current bar is a shooting star candle based on the given parameters   Parameters:      float : fib (default=0.382) The fib to base candle body on      bool : colorMatch (default=false) Does the candle need to be red? (true/false)   Returns: A boolean - true if the current bar matches the requirements of a shooting star candle isDoji(float, bool) Checks if the current bar is a doji candle based on the given parameters   Parameters:      float : wickSize (default=2) The maximum top wick size compared to the bottom (and vice versa)      bool : bodySize (default=0.05) The maximum body size as a percentage compared to the entire candle size   Returns: A boolean - true if the current bar matches the requirements of a doji candle isBullishEC(float, float, bool) Checks if the current bar is a bullish engulfing candle   Parameters:      float : allowance (default=0) How many POINTS to allow the open to be off by (useful for markets with micro gaps)      float : rejectionWickSize (default=disabled) The maximum rejection wick size compared to the body as a percentage      bool : engulfWick (default=false) Does the engulfing candle require the wick to be engulfed as well?   Returns: A boolean - true if the current bar matches the requirements of a bullish engulfing candle isBearishEC(float, float, bool) Checks if the current bar is a bearish engulfing candle   Parameters:      float : allowance (default=0) How many POINTS to allow the open to be off by (useful for markets with micro gaps)      float : rejectionWickSize (default=disabled) The maximum rejection wick size compared to the body as a percentage      bool : engulfWick (default=false) Does the engulfing candle require the wick to be engulfed as well?   Returns: A boolean - true if the current bar matches the requirements of a bearish engulfing candle isInsideBar() Detects inside bars   Returns: Returns true if the current bar is an inside bar isOutsideBar() Detects outside bars   Returns: Returns true if the current bar is an outside bar barInSession(string, bool) Determines if the current price bar falls inside the specified session   Parameters:      string : sess The session to check      bool : useFilter (default=true) Whether or not to actually use this filter   Returns: A boolean - true if the current bar falls within the given time session barOutSession(string, bool) Determines if the current price bar falls outside the specified session   Parameters:      string : sess The session to check      bool : useFilter (default=true) Whether or not to actually use this filter   Returns: A boolean - true if the current bar falls outside the given time session dateFilter(int, int) Determines if this bar's time falls within date filter range   Parameters:      int : startTime The UNIX date timestamp to begin searching from      int : endTime the UNIX date timestamp to stop searching from   Returns: A boolean - true if the current bar falls within the given dates dayFilter(bool, bool, bool, bool, bool, bool, bool) Checks if the current bar's day is in the list of given days to analyze   Parameters:      bool : monday Should the script analyze this day? (true/false)      bool : tuesday Should the script analyze this day? (true/false)      bool : wednesday Should the script analyze this day? (true/false)      bool : thursday Should the script analyze this day? (true/false)      bool : friday Should the script analyze this day? (true/false)      bool : saturday Should the script analyze this day? (true/false)      bool : sunday Should the script analyze this day? (true/false)   Returns: A boolean - true if the current bar's day is one of the given days atrFilter() fillCell()
Pine Script® kütüphanesi
Wheeelman tarafından
2
HighTimeframeTimingLibrary "HighTimeframeTiming" @description Library for sampling high timeframe (HTF) historical data at an arbitrary number of HTF bars back, using a single security() call. The data is fixed and does not alter over the course of the HTF bar. It also behaves consistently on historical and elapsed realtime bars. ‼ LIMITATIONS: This library function depends on there being a consistent number of chart timeframe bars within the HTF bar. This is almost always true in 24/7 markets like crypto. This might not be true if the chart doesn't produce an update when expected, for example because the asset is thinly traded and there is no volume or price update from the feed at that time. To mitigate this risk, use this function on liquid assets and at chart timeframes high enough to reliably produce updates at least once per bar period. The consistent ratio of bars might also break down in markets with irregular sessions and hours. I'm not sure if or how one could mitigate this. Another limitation is that because we're accessing a multiplied number of chart bars, you will run out of chart bars faster than you would HTF bars. This is only a problem if you use a large historical operator. If you call a function from this library, you should probably reproduce these limitations in your script description. However, all of this doesn't mean that this function might not still be the best available solution, depending what your needs are. If a single chart bar is skipped, for example, the calculation will be off by 1 until the next HTF bar opens. This is certainly inconsistent, but potentially still usable. @function f_offset_synch(float _HTF_X, int _HTF_H, int _openChartBarsIn, bool _updateEarly) Returns the number of chart bars that you need to go back in order to get a stable HTF value from a given number of HTF bars ago. @param float _HTF_X is the timeframe multiplier, i.e. how much bigger the selected timeframe is than the chart timeframe. The script shows a way to calculate this using another of my libraries without using up a security() call. @param int _HTF_H is the historical operator on the HTF, i.e. how many bars back you want to go on the higher timeframe. If omitted, defaults to zero. @param int _openChartBarsIn is how many chart bars have been opened within the current HTF bar. An example of calculating this is given below. @param bool _updateEarly defines whether you want to update the value at the closing calculation of the last chart bar in the HTF bar or at the open of the first one. @returns an integer that you can use as a historical operator to retrieve the value for the appropriate HTF bar. 🙏 Credits: This library is an attempt at a solution of the problems in using HTF data that were laid out by Pinecoders in "security() revisited" - Thanks are due to the authors of that work for an understanding of HTF issues. In addition, the current script also includes some of its code. Specifically, this script reuses the main function recommended in "security() revisited", for the purposes of comparison. And it extends that function to access historical data, again just for comparison. All the rest of the code, and in particular all of the code in the exported function, is my own. Special thanks to LucF for pointing out the limitations of my approach. ~~~~~~~~~~~~~~~~| EXPLANATION ~~~~~~~~~~~~~~~~| Problems with live HTF data: Many problems with using live HTF data from security() have been clearly explained by Pinecoders in "security() revisited" In short, its behaviour is inconsistent between historical and elapsed realtime bars, and it changes in realtime, which can cause calculations and alerts to misbehave. Various unsatisfactory solutions are discussed in "security() revisited", and understanding that script is a prerequisite to understanding this library. PineCoders give their own solution, which is to fix the data by essentially using the previous HTF bar's data. Importantly, that solution is consistent between historical and realtime bars. This library is an attempt to provide an alternative to that solution. Problems with historical HTF data: In addition to the problems with live HTF data, there are different issues when trying to access historical HTF data. Why use historical HTF data? Maybe you want to do custom calculations that involve previous HTF bars. Or to use HTF data in a function that has mutable variables and so can't be done in a security() call. Most obviously, using the historical operator (in this description, represented using { } because the square brackets don't render) on variables already retrieved from a security() call, e.g. HTF_Close{1}, is not very useful: it retrieves the value from the previous *chart* bar, not the previous HTF bar. Using {1} directly in the security() call instead does get data from the previous HTF bar, but it behaves inconsistently, as we shall see. This library addresses these concerns as well. Housekeeping: To follow what's going on with the example and comparisons, turn line labels on: Settings > Scales > Indicator Name Label. The following explanation assumes "close" as the source, but you can change it if you want. To quickly see the difference between historical and realtime bars, set the HTF to something like 3 minutes on a 15s chart. The bars at the top of the screen show the status. Historical bars are grey, elapsed realtime bars are red, and the realtime bar is green. A white vertical line shows the open of a HTF bar. A: This library function f_offset_synch(): When supplied with an input offset of 0, it plots a stable value of the close of the *previous* HTF bar. This value is thus safe to use for calculations and alerts. For a historical operator of {1}, it gives the close of the *last-but-one* bar. Sounds simple enough. Let's look at the other options to see its advantages. B: Live HTF data: Represented on the line label as "security(){0}". Note: this is the source that f_offset_synch() samples. The raw HTF data is very different on historical and realtime bars: + On historical bars, it uses a flat value from the end of the previous HTF bar. It updates at the close of the HTF bar. + On realtime bars, it varies between and within each chart bar. There might be occasions where you want to use live data, in full knowledge of its drawbacks described above. For example, to show simple live conditions that are reversible after a chart bar close. This library transforms live data to get the fixed data, thus giving you access to both live and fixed data with only one security() call. C: Historical data using security(){H}: To see how this behaves, set the {H} value in the settings to 1 and show options A, B, and C. + On historical bars, this option matches option A, this library function, exactly. It behaves just like security(){0} but one HTF bar behind, as you would expect. + On realtime bars, this option takes the value of security(){0} at the end of a HTF bar, but it takes it from the previous *chart* bar, and then persists that. The easiest way to see this inconsistency is on the first realtime bar (marked red at the top of the screen). This option suddenly jumps, even if it's in the middle of a HTF bar. Contrast this with option A, which is always constant, until it updates, once per HTF bar. D: PineCoders' original function: To see how this behaves, show options A, B, and D. Set the {H} value in the settings to 0, then 1. The PineCoders' original function (D) and extended function (E) do not have the same limitations as this library, described in the Limitations section. This option has all of the same advantages that this library function, option A, does, with the following differences: + It cannot access historical data. The {H} setting makes no difference. + It always updates at the open of the first chart bar in a new HTF bar. By contrast, this library function, option A, is configured by default to update at the close of the last chart bar in a HTF bar. This little frontrunning is only a few seconds but could be significant in trading. E.g. on a 1D HTF with a 4H chart, an alert that involves a HTF change set to trigger ON CLOSE would trigger 4 hours later using this method - but use exactly the same value. It depends on the market and timeframe as to whether you could actually trade this. E.g. at the very end of a tradfi day your order won't get executed. This behaviour mimics how security() itself updates, as is easy to see on the chart. If you don't want it, just set in_updateEarly to false. Then it matches option D exactly. E: PineCoders' function, extended to get history: To see how this behaves, show options A and E. Set the {H} value in the settings to 0, then 1. I modified the original function to be able to get historical values. In all other respects it is the same. Apart from not having the option to update earlier, the only disadvantage of this method vs this library function is that it requires one security() call for each historical operator. For example, if you wanted live data, and fixed data, and fixed data one bar back, you would need 3 security() calls. My library function requires just one. This is the essential tradeoff: extra complexity and less robustness in certain circumstances (the PineCoders function is simple and universal by comparison) for more flexibility with fewer security() calls.
Pine Script® kütüphanesi
SimpleCryptoLife tarafından
7
taLibrary "ta" █  OVERVIEW This library holds technical ​analysis functions calculating values for which no Pine built-in exists. Look first. Then leap. █  FUNCTIONS cagr(entryTime, entryPrice, exitTime, exitPrice) It calculates the "Compound Annual Growth Rate" between two points in time. The ​CAGR is a notional, annualized growth rate that assumes all profits are reinvested. It only takes into account the prices of the two end points — not drawdowns, so it does not calculate risk. It can be used as a yardstick to compare the performance of two instruments. Because it annualizes values, the function requires a minimum of one day between the two end points (annualizing returns over smaller periods of times doesn't produce very meaningful figures).   Parameters:      entryTime : The starting timestamp.      entryPrice : The starting point's price.      exitTime : The ending timestamp.      exitPrice : The ending point's price.   Returns: ​CAGR in % (50 is 50%). Returns `na` if there is not >=1D between `entryTime` and `exitTime`, or until the two time points have not been reached by the script. █  v2, Mar. 8, 2022 Added functions `allTimeHigh()` and `allTimeLow()` to find the highest or lowest value of a source from the first historical bar to the current bar. These functions will not look ahead; they will only return new highs/lows on the bar where they occur. allTimeHigh(​src) Tracks the highest value of `src` from the first historical bar to the current bar.   Parameters:      src : (series int/float) Series to track. Optional. The default is `high`.   Returns: (float) The highest value tracked. allTimeLow(​src) Tracks the lowest value of `src` from the first historical bar to the current bar.   Parameters:      src : (series int/float) Series to track. Optional. The default is `low`.   Returns: (float) The lowest value tracked. █  v3, Sept. 27, 2022 This version includes the following new functions: aroon(length)   Calculates the values of the Aroon indicator.   Parameters:      length (simple int) : (simple int) Number of bars (length).   Returns: ( [float, float ]) A tuple of the Aroon-Up and Aroon-Down values. coppock(source, longLength, shortLength, smoothLength)   Calculates the value of the Coppock Curve indicator.   Parameters:      source (float) : (series int/float) Series of values to process.      longLength (simple int) : (simple int) Number of bars for the fast ROC value (length).      shortLength (simple int) : (simple int) Number of bars for the slow ROC value (length).      smoothLength (simple int) : (simple int) Number of bars for the weigted moving average value (length).   Returns: (float) The oscillator value. dema(source, length)   Calculates the value of the Double Exponential Moving Average (DEMA).   Parameters:      source (float) : (series int/float) Series of values to process.      length (simple int) : (simple int) Length for the smoothing parameter calculation.   Returns: (float) The double exponentially weighted moving average of the `source`. d​ema2(​src, length)   An alternate ​Double Exponential ​Moving Average (D​ema) function to `d​ema()`, which allows a "series float" length argument.   Parameters:      ​src : (series int/float) Series of values to process.      length : (series int/float) Length for the smoothing parameter calculation.   Returns: (float) The double exponentially ​weighted moving average of the `​src`. dm(length)   Calculates the value of the "Demarker" indicator.   Parameters:      length (simple int) : (simple int) Number of bars (length).   Returns: (float) The oscillator value. donchian(length)   Calculates the values of a Donchian Channel using `high` and `low` over a given `length`.   Parameters:      length (int) : (series int) Number of bars (length).   Returns: ( [float, float, float ]) A tuple containing the channel high, low, and median, respectively. ​ema2(​src, length)   An alternate ​ema function to the `ta.​ema()` built-in, which allows a "series float" length argument.   Parameters:      ​src : (series int/float) Series of values to process.      length : (series int/float) Number of bars (length).   Returns: (float) The exponentially ​weighted moving average of the `​src`. eom(length, div)   Calculates the value of the Ease of Movement indicator.   Parameters:      length (simple int) : (simple int) Number of bars (length).      div (simple int) : (simple int) Divisor used for normalzing values. Optional. The default is 10000.   Returns: (float) The oscillator value. frama(source, length)   The Fractal Adaptive Moving Average (FRAMA), developed by John Ehlers, is an adaptive moving average that dynamically adjusts its lookback period based on fractal geometry.   Parameters:      source (float) : (series int/float) Series of values to process.      length (int) : (series int) Number of bars (length).   Returns: (float) The fractal adaptive moving average of the `source`. ft(source, length)   Calculates the value of the Fisher Transform indicator.   Parameters:      source (float) : (series int/float) Series of values to process.      length (simple int) : (simple int) Number of bars (length).   Returns: (float) The oscillator value. ht(source)   Calculates the value of the Hilbert Transform indicator.   Parameters:      source (float) : (series int/float) Series of values to process.   Returns: (float) The oscillator value. ichimoku(conLength, baseLength, senkouLength)   Calculates values of the Ichimoku Cloud indicator, including tenkan, kijun, senkouSpan1, senkouSpan2, and chikou. NOTE: offsets forward or backward can be done using the `offset` argument in `plot()`.   Parameters:      conLength (int) : (series int) Length for the Conversion Line (Tenkan). The default is 9 periods, which returns the mid-point of the 9 period Donchian Channel.      baseLength (int) : (series int) Length for the Base Line (Kijun-sen). The default is 26 periods, which returns the mid-point of the 26 period Donchian Channel.      senkouLength (int) : (series int) Length for the Senkou Span 2 (Leading Span B). The default is 52 periods, which returns the mid-point of the 52 period Donchian Channel.   Returns: ( [float, float, float, float, float ]) A tuple of the Tenkan, Kijun, Senkou Span 1, Senkou Span 2, and Chikou Span values. NOTE: by default, the senkouSpan1 and senkouSpan2 should be plotted 26 periods in the future, and the Chikou Span plotted 26 days in the past. ift(source)   Calculates the value of the Inverse Fisher Transform indicator.   Parameters:      source (float) : (series int/float) Series of values to process.   Returns: (float) The oscillator value. kvo(fastLen, slowLen, trigLen)   Calculates the values of the Klinger Volume Oscillator.   Parameters:      fastLen (simple int) : (simple int) Length for the fast moving average smoothing parameter calculation.      slowLen (simple int) : (simple int) Length for the slow moving average smoothing parameter calculation.      trigLen (simple int) : (simple int) Length for the trigger moving average smoothing parameter calculation.   Returns: ( [float, float ]) A tuple of the KVO value, and the trigger value. pzo(length)   Calculates the value of the Price Zone Oscillator.   Parameters:      length (simple int) : (simple int) Length for the smoothing parameter calculation.   Returns: (float) The oscillator value. rms(source, length)   Calculates the Root Mean Square of the `source` over the `length`.   Parameters:      source (float) : (series int/float) Series of values to process.      length (int) : (series int) Number of bars (length).   Returns: (float) The RMS value. rwi(length)   Calculates the values of the Random Walk Index.   Parameters:      length (simple int) : (simple int) Lookback and ATR smoothing parameter length.   Returns: ( [float, float ]) A tuple of the `rwiHigh` and `rwiLow` values. stc(source, fast, slow, cycle, d1, d2)   Calculates the value of the Schaff Trend Cycle indicator.   Parameters:      source (float) : (series int/float) Series of values to process.      fast (simple int) : (simple int) Length for the MACD fast smoothing parameter calculation.      slow (simple int) : (simple int) Length for the MACD slow smoothing parameter calculation.      cycle (simple int) : (simple int) Number of bars for the Stochastic values (length).      d1 (simple int) : (simple int) Length for the initial %D smoothing parameter calculation.      d2 (simple int) : (simple int) Length for the final %D smoothing parameter calculation.   Returns: (float) The oscillator value. stochFull(periodK, smoothK, periodD)   Calculates the %K and %D values of the Full Stochastic indicator.   Parameters:      periodK (simple int) : (simple int) Number of bars for Stochastic calculation. (length).      smoothK (simple int) : (simple int) Number of bars for smoothing of the %K value (length).      periodD (simple int) : (simple int) Number of bars for smoothing of the %D value (length).   Returns: ( [float, float ]) A tuple of the slow %K and the %D moving average values. stochRsi(lengthRsi, periodK, smoothK, periodD, source)   Calculates the %K and %D values of the Stochastic RSI indicator.   Parameters:      lengthRsi (simple int) : (simple int) Length for the RSI smoothing parameter calculation.      periodK (simple int) : (simple int) Number of bars for Stochastic calculation. (length).      smoothK (simple int) : (simple int) Number of bars for smoothing of the %K value (length).      periodD (simple int) : (simple int) Number of bars for smoothing of the %D value (length).      source (float) : (series int/float) Series of values to process. Optional. The default is `close`.   Returns: ( [float, float ]) A tuple of the slow %K and the %D moving average values. supertrend(factor, atrLength, wicks)   Calculates the values of the SuperTrend indicator with the ability to take candle wicks into account, rather than only the closing price.   Parameters:      factor (float) : (series int/float) Multiplier for the ATR value.      atrLength (simple int) : (simple int) Length for the ATR smoothing parameter calculation.      wicks (simple bool) : (simple bool) Condition to determine whether to take candle wicks into account when reversing trend, or to use the close price. Optional. Default is false.   Returns: ( [float, int ]) A tuple of the superTrend value and trend direction. szo(source, length)   Calculates the value of the Sentiment Zone Oscillator.   Parameters:      source (float) : (series int/float) Series of values to process.      length (simple int) : (simple int) Length for the smoothing parameter calculation.   Returns: (float) The oscillator value. t3(source, length, vf)   Calculates the value of the Tilson Moving Average (T3).   Parameters:      source (float) : (series int/float) Series of values to process.      length (simple int) : (simple int) Length for the smoothing parameter calculation.      vf (simple float) : (simple float) Volume factor. Affects the responsiveness.   Returns: (float) The Tilson moving average of the `source`. t3Alt(source, length, vf)   An alternate Tilson Moving Average (T3) function to `t3()`, which allows a "series float" `length` argument.   Parameters:      source (float) : (series int/float) Series of values to process.      length (float) : (series int/float) Length for the smoothing parameter calculation.      vf (simple float) : (simple float) Volume factor. Affects the responsiveness.   Returns: (float) The Tilson moving average of the `source`. tema(source, length)   Calculates the value of the Triple Exponential Moving Average (TEMA).   Parameters:      source (float) : (series int/float) Series of values to process.      length (simple int) : (simple int) Length for the smoothing parameter calculation.   Returns: (float) The triple exponentially weighted moving average of the `source`. tema2(source, length)   An alternate Triple Exponential Moving Average (TEMA) function to `tema()`, which allows a "series float" `length` argument.   Parameters:      source (float) : (series int/float) Series of values to process.      length (float) : (series int/float) Length for the smoothing parameter calculation.   Returns: (float) The triple exponentially weighted moving average of the `source`. trima(source, length)   Calculates the value of the Triangular Moving Average (TRIMA).   Parameters:      source (float) : (series int/float) Series of values to process.      length (int) : (series int) Number of bars (length).   Returns: (float) The triangular moving average of the `source`. trima2(​src, length)   An alternate Triangular ​Moving Average (TRIMA) function to `trima()`, which allows a "series int" length argument.   Parameters:      ​src : (series int/float) Series of values to process.      length : (series int) Number of bars (length).   Returns: (float) The triangular moving average of the `​src`. trix(source, length, signalLength, exponential)   Calculates the values of the TRIX indicator.   Parameters:      source (float) : (series int/float) Series of values to process.      length (simple int) : (simple int) Length for the smoothing parameter calculation.      signalLength (simple int) : (simple int) Length for smoothing the signal line.      exponential (simple bool) : (simple bool) Condition to determine whether exponential or simple smoothing is used. Optional. The default is `true` (exponential smoothing).   Returns: ( [float, float, float ]) A tuple of the TRIX value, the signal value, and the histogram. uo(fastLen, midLen, slowLen)   Calculates the value of the Ultimate Oscillator.   Parameters:      fastLen (simple int) : (series int) Number of bars for the fast smoothing average (length).      midLen (simple int) : (series int) Number of bars for the middle smoothing average (length).      slowLen (simple int) : (series int) Number of bars for the slow smoothing average (length).   Returns: (float) The oscillator value. vhf(source, length)   Calculates the value of the Vertical Horizontal Filter.   Parameters:      source (float) : (series int/float) Series of values to process.      length (simple int) : (simple int) Number of bars (length).   Returns: (float) The oscillator value. vi(length)   Calculates the values of the Vortex Indicator.   Parameters:      length (simple int) : (simple int) Number of bars (length).   Returns: ( [float, float ]) A tuple of the viPlus and viMinus values. vzo(length)   Calculates the value of the Volume Zone Oscillator.   Parameters:      length (simple int) : (simple int) Length for the smoothing parameter calculation.   Returns: (float) The oscillator value. williamsFractal(period)   Detects Williams Fractals.   Parameters:      period (int) : (series int) Number of bars (length).   Returns: ( [bool, bool ]) A tuple of an up fractal and down fractal. Variables are true when detected. wpo(length)   Calculates the value of the Wave Period Oscillator.   Parameters:      length (simple int) : (simple int) Length for the smoothing parameter calculation.   Returns: (float) The oscillator value. █  v7, Nov. 2, 2023 This version includes the following new and updated functions: atr2(length)   An alternate ATR function to the `ta.atr()` built-in, which allows a "series float" `length` argument.   Parameters:      length (float) : (series int/float) Length for the smoothing parameter calculation.   Returns: (float) The ATR value. changePercent(newValue, oldValue)   Calculates the percentage difference between two distinct values.   Parameters:      newValue (float) : (series int/float) The current value.      oldValue (float) : (series int/float) The previous value.   Returns: (float) The percentage change from the `oldValue` to the `newValue`. donchian(length)   Calculates the values of a Donchian Channel using `high` and `low` over a given `length`.   Parameters:      length (int) : (series int) Number of bars (length).   Returns: ( [float, float, float ]) A tuple containing the channel high, low, and median, respectively. highestSince(cond, source)   Tracks the highest value of a series since the last occurrence of a condition.   Parameters:      cond (bool) : (series bool) A condition which, when `true`, resets the tracking of the highest `source`.      source (float) : (series int/float) Series of values to process. Optional. The default is `high`.   Returns: (float) The highest `source` value since the last time the `cond` was `true`. lowestSince(cond, source)   Tracks the lowest value of a series since the last occurrence of a condition.   Parameters:      cond (bool) : (series bool) A condition which, when `true`, resets the tracking of the lowest `source`.      source (float) : (series int/float) Series of values to process. Optional. The default is `low`.   Returns: (float) The lowest `source` value since the last time the `cond` was `true`. relativeVolume(length, anchorTimeframe, isCumulative, adjustRealtime)   Calculates the volume since the last change in the time value from the `anchorTimeframe`, the historical average volume using bars from past periods that have the same relative time offset as the current bar from the start of its period, and the ratio of these volumes. The volume values are cumulative by default, but can be adjusted to non-accumulated with the `isCumulative` parameter.   Parameters:      length (simple int) : (simple int) The number of periods to use for the historical average calculation.      anchorTimeframe (simple string) : (simple string) The anchor timeframe used in the calculation. Optional. Default is "D".      isCumulative (simple bool) : (simple bool) If `true`, the volume values will be accumulated since the start of the last `anchorTimeframe`. If `false`, values will be used without accumulation. Optional. The default is `true`.      adjustRealtime (simple bool) : (simple bool) If `true`, estimates the cumulative value on unclosed bars based on the data since the last `anchor` condition. Optional. The default is `false`.   Returns: ( [float, float, float ]) A tuple of three float values. The first element is the current volume. The second is the average of volumes at equivalent time offsets from past anchors over the specified number of periods. The third is the ratio of the current volume to the historical average volume. rma2(source, length)   An alternate RMA function to the `ta.rma()` built-in, which allows a "series float" `length` argument.   Parameters:      source (float) : (series int/float) Series of values to process.      length (float) : (series int/float) Length for the smoothing parameter calculation.   Returns: (float) The rolling moving average of the `source`. supertrend2(factor, atrLength, wicks)   An alternate SuperTrend function to `supertrend()`, which allows a "series float" `atrLength` argument.   Parameters:      factor (float) : (series int/float) Multiplier for the ATR value.      atrLength (float) : (series int/float) Length for the ATR smoothing parameter calculation.      wicks (simple bool) : (simple bool) Condition to determine whether to take candle wicks into account when reversing trend, or to use the close price. Optional. Default is `false`.   Returns: ( [float, int ]) A tuple of the superTrend value and trend direction. vStop(source, atrLength, atrFactor)   Calculates an ATR-based stop value that trails behind the `source`. Can serve as a possible stop-loss guide and trend identifier.   Parameters:      source (float) : (series int/float) Series of values that the stop trails behind.      atrLength (simple int) : (simple int) Length for the ATR smoothing parameter calculation.      atrFactor (float) : (series int/float) The multiplier of the ATR value. Affects the maximum distance between the stop and the `source` value. A value of 1 means the maximum distance is 100% of the ATR value. Optional. The default is 1.   Returns: ( [float, bool ]) A tuple of the volatility stop value and the trend direction as a "bool". vStop2(source, atrLength, atrFactor)   An alternate Volatility Stop function to `vStop()`, which allows a "series float" `atrLength` argument.   Parameters:      source (float) : (series int/float) Series of values that the stop trails behind.      atrLength (float) : (series int/float) Length for the ATR smoothing parameter calculation.      atrFactor (float) : (series int/float) The multiplier of the ATR value. Affects the maximum distance between the stop and the `source` value. A value of 1 means the maximum distance is 100% of the ATR value. Optional. The default is 1.   Returns: ( [float, bool ]) A tuple of the volatility stop value and the trend direction as a "bool". Removed Functions: allTimeHigh(src)   Tracks the highest value of `src` from the first historical bar to the current bar. allTimeLow(src)   Tracks the lowest value of `src` from the first historical bar to the current bar. trima2(src, length)   An alternate Triangular Moving Average (TRIMA) function to `trima()`, which allows a "series int" length argument.
Pine Script® kütüphanesi
TradingView tarafından
25
Realtime Delta Volume Action [LucF]█  OVERVIEW This indicator displays on-chart, realtime, delta volume​ and delta ticks information for each bar. It aims to provide traders who trade price action on small timeframes with volume​ and tick information gathered as updates come in the chart's feed. It builds its own candles, which are optimized to display volume​ delta information. It only works in realtime. █  WARNING This script is intended for traders who can already profitably trade discretionary on small timeframes. The high cost in fees and the excitement of trading at small timeframes have ruined many newcomers to trading. While trading at small timeframes can work magic for adrenaline junkies in search of thrills rather than profits, I DO NOT recommend it to most traders. Only seasoned discretionary traders able to factor in the relatively high cost of such a trading practice can ever hope to take money out of markets in that type of environment, and I would venture​ they account for an infinitesimal percentage of traders. If you are a newcomer to trading, AVOID THIS TOOL AT ALL COSTS — unless you are interested in experimenting with the interpretation of volume​ delta combined with price action. No tool currently available on TradingView provides this type of close monitoring of volume​ delta information, but if you are not already trading small timeframes profitably, please do not let yourself become convinced that it is the missing piece you needed. Avoid becoming a sucker who only contributes by providing liquidity to markets. The information calculated by the indicator cannot be saved on charts, nor can it be recalculated from historical bars. If you refresh the chart or restart the script, the accumulated information will be lost. █  FEATURES Key values The script displays the following key values:  • Above the bar: ticks delta​ (DT​), the total ticks​ for the bar, the percentage of total ticks that DT​ represents (DT%)  • Below the bar: volume delta​ (DV​), the total volume​ for the bar, the percentage of total volume​ that DV​ represents (DV%). Candles Candles are composed of four components:  1. A top shaped like this: ┴, and a bottom shaped like this: ┬ (picture a normal Japanese candle without a body outline; the values used are the same).  2. The candle bodies are filled with the bull/bear color representing the polarity of DV​. The intensity of the body's color is determined by the DV% value.    When DV% is 100, the intensity of the fill is brightest. This plays well in interpreting the body colors, as the smaller, less significant DV% values will produce less vivid colors.  3. The bright-colored borders of the candle bodies occur on "strong bars", i.e., bars meeting the criteria selected in the script's inputs, which you can configure.  4. The POC line is a small horizontal line that appears to the left of the candle. It is the volume-weighted average of all price updates during the bar. Calculations This script monitors each realtime update of the chart's feed. It first determines if price has moved up or down since the last update. The polarity of the price change, in turn, determines the polarity of the volume​​ and tick for that specific update. If price does not move between consecutive updates, then the last known polarity is used. Using this method, we can calculate a running volume​ delta and ticks delta for the bar, which becomes the bar's final​ delta values when the bar closes (you can inspect values of elapsed realtime bars in the Data Window or the indicator's values). Note that these values will all reset if the script re-executes because of a change in inputs or a chart refresh. While this method of calculating is not perfect, it is by far the most precise way of calculating volume​ delta available on TradingView at the moment. Calculating more precise results would require scripts to have access to tick data from any chart timeframe. Charts at seconds timeframes do use exchange/broker ticks when the feeds you are using allow for it, and this indicator will run on them, but tick data is not yet available from higher timeframes. Also, note that the method used in this script is far superior to the intrabar inspection technique used on historical bars in my other "Delta Volume​" indicators. This is because volume​ and ticks delta here are calculated from many more realtime updates than the available intrabars in history. Unfortunately, the calculation method used here cannot be used on historical bars, where intrabar inspection remains, in my opinion, the optimal method. Inputs The script's inputs provide many ways to personalize all the components: what is displayed, the colors used to display the information, and the marker conditions. Tooltips provide details for many of the inputs; I leave their exploration to you. Markers Markers provide a way for you to identify the points of interest of your choice on the chart. You control the set of conditions that trigger each of the five available markers. You select conditions by entering, in the field for each marker, the number of each condition you want to include, separated by a comma. The conditions are:   1 —  The bar's polarity is up/dn​.   2 —  `close` rises/falls ("rises" means it is higher than its value on the previous bar).   3 —  DV's polarity is +/–.   4 —  DV% rises (↕).   5 —  POC rises/falls.   6 —  The quantity of realtime updates rises (↕).   7 —  DV​ > limit (You specify the limit in the inputs. Since DV​ can be +/–, DV– must be less than `–limit` for a short marker).   8 —  DV% > limit (↕).   9 —  DV+ rises for a long marker, DV– falls for a short.  10 —  Consecutive DV+/DV– on two bars.  11 —  Total volume rises (↕).  12 —  DT's polarity is +/–.  13 —  DT% rises (↕).  14 —  DT+ rises for a long marker, DT– falls for a short. Conditions showing the (↕) symbol do not have symmetrical states; they act more like filters. If you only include condition 4 in a marker's setup, for example, both long and short markers will trigger on bars where DV% rises. To trigger only long or short markers, you must add a condition providing directional differentiation, such as conditions 1 or 2. Accordingly, you would enter "1,4" or "2,4". For a marker to trigger, ALL the conditions you specified for it must be met. Long markers appear on the chart as "Mx▲" signs under the values displayed below candles. Short markers display "Mx▼" over the number of updates displayed above candles. The marker's number will replace the "x" in "Mx▲". The script loads with five markers that will not trigger because no conditions are associated with them. To activate markers, you will need to select and enter the set of conditions you require for each one. Alerts You can configure alerts on this script. They will trigger whenever one of the configured markers triggers. Alerts do not repaint, so they trigger at the bar's close—which is also when the markers will appear. █  HOW TO USE IT As a rule, I do not prescribe expected use of my indicators, as traders have proved to be much more creative than me in using them. Additionally, I tend to think that if you expect detailed recommendations from me to be able to use my indicators, it's a sign you are in a precarious situation and should go back to the drawing board and master the necessary basics that will allow you to explore and decide for yourself if my indicators can be useful to you, and how you will use them. I will make an exception for this thing, as it presents fairly novel information. I will use simple logic to surmise potential uses, as contrary to most of my other indicators, I have NOT used this one to actually trade. Markets have a way of throwing wrenches in our seemingly bullet-proof rationalizing, so drive cautiously and please forgive me if the pointers I share here don't pan out. The first thing to do is to disable your normal bars. You can do this by clicking on the eye icon that appears when you hover over the symbol's name in the upper-left corner of your chart. The absolute value and polarity of DV​ mean little without perspective; that's why I include both total volume​ for the bar and the percentage that DV​ represents of that total volume​. I interpret a low DV% value as indecision. If you share that opinion, you could, let's say, configure one of the markers on "DV% > 80%", for example (to do so you would enter "8" in the condition field of any marker, and "80" in the limit field for condition 8, below the marker conditions). I also like to analyze price action on the bar with DV%. Small DV% values should often produce small candle bodies. If a small DV% value occurs on a bar with much movement and high volume​, I'm thinking "tough battle with potential explosive power when one side wins". Conversely, large bodies with high DV% mean that large volume​ is breaching through multiple levels, or that nobody is suddenly willing to take the other side of a normal volume of trades. I find the POC lines really interesting. First, they tell us the price point where the most significant action (taking into account both price occurrences AND volume​) during the bar occurred. Second, they can be useful when compared against past values. Third, their color helps us in figuring out which ones are the most significant. Unsurprisingly, bunches of orange POCs tend to appear in consolidation zones, in pauses, and before reversals. It may be useful to often focus more on POC progression than on `close` values. This is not to say that OHLC values are not useful; looking, as is customary, for higher highs or lower lows, or for repeated tests of precise levels can of course still be useful. I do like how POCs add another dimension to chart readings. What should you do with the ticks delta above bars? Old-time ticker tape readers paid attention to the sounds coming from it (the "ticker" moniker actually comes from the sound they made). They knew activity was picking up when the frequency of the "ticks" increased. My thinking is that the total number of ticks will help you in the same way, since increasing updates usually mean growing interest—and thus perhaps price movement, as increasing volatility​ or volume​ would lead us to surmise. Ticks delta can help you figure out when proportionally large, random orders come in from traders with other perspectives than the short-term price action you are typically working with when you use this tool. Just as volume delta, ticks delta are one more informational component that can help you confirm convergence when building your opinions on price action. What are strong bars? They are an attempt to identify significance. They are like a default marker, except that instead of displaying "Mx▲/▼" below/above the bar, the candle's body is outlined in bright​ bull/bear color when one is detected. Strong bars require a respectable amount of conditions to be met (you can see and re-configure them in the inputs). Think of them as pushes rather than indications of an upcoming, strong and multi-bar move. Pushes do, for sure, often occur at the beginning of strong trends. You will often see a few strong bars occur at 2-3 bar intervals at the beginning or middle of trends. But they also tend to occur at tops/bottoms, which makes their interpretation problematic. Another pattern that you will see quite frequently is a final strong bar in the direction of the trend, followed a few bars later by another strong bar in the reverse direction. My summary analyses seemed to indicate these were perhaps good points where one could make a bet on an early, risky reversal entry. The last piece of information displayed by the indicator is the color of the candle bodies. Three possible colors are used. Bull/bear is determined by the polarity of DV​, but only when the bar's polarity matches that of DV​. When it doesn't, the color is the divergence color (orange, by default). Whichever color is used for the body, its intensity is determined by the DV% value. Maximum intensity occurs when DV%=100, so the more significant DV% values generate more noticeable colors. Body colors can be useful when looking to confirm the convergence of other components. The visual effect this creates hopefully makes it easier to detect patterns on the chart. One obvious methodology that comes to mind to trade with this tool would be to use another indicator like Technical Ratings at a higher timeframe to identify the larger context's trend, and then use this tool to identify entries for short-term trades in that direction. █  NOTES AND RAMBLINGS Instant Calculations This indicator uses instant values calculated on the bar only. No moving averages or calculations involving historical periods are used. The only exception to this rule is in some of the marker conditions like "Two consecutive DV+ values", where information from the previous bar is used. Trading Small vs Long Timeframes I never trade discretionary at the 5sec–5min timeframes this indicator was designed to be used with; I trade discretionary at 1D, 1W and 1M timeframes, and let systems trade at smaller timeframes. The higher the timeframe you trade at, the fewer fees you will pay because you trade less and are not churning trading volume​, as is inevitable at smaller timeframes. Trading at higher timeframes is also a good way to gain an instant edge on most of the trading crowd that has its nose to the ground and often tends to forget the big picture. It also makes for a much less demanding trading practice, where you have lots of time to research and build your long-term opinions on potential future outcomes. While the future is always uncertain, I believe trades riding on long-term trends have stronger underlying support from the reality outside markets. To traders who will ask why I publish an indicator designed for small timeframes, let me say that my main purpose here is to showcase what can be done with Pine. I often see comments by coders who are obviously not aware of what Pine is capable of in 2021. Since its humble beginnings seven years ago, Pine has grown and become a serious programming language. TradingView's growing popularity and its ongoing commitment to keep Pine accessible to newcomers to programming is gradually making Pine more and more of a standard in indicator and strategy programming. The technical barriers to entry for traders interested in owning their trading practice by developing their personal tools to trade have never been so low. I am also publishing this script because I value volume​ delta information, and I present here what I think is an original way of analyzing it. Performance The script puts a heavy load on the Pine runtime and the charting engine. After running the script for a while, you will often notice your chart becoming less responsive, and your chart tab can take longer to activate when you go back to it after using other tabs. That is the reason I encourage you to set the number of historical values displayed on bars to the minimum that meets your needs. When your chart becomes less responsive because the script has been running on it for many hours, refreshing the browser tab will restart everything and bring the chart's speed back up. You will then lose the information displayed on elapsed bars. Neutral Volume This script represents a departure from the way I have previously calculated volume​ delta in my scripts. I used the notion of "neutral volume" when inspecting intrabar timeframes, for bars where price did not move. No longer. While this had little impact​ when using intrabar inspection because the minimum usable timeframe was 1min (where bars with zero movement are relatively infrequent), a more precise way was required to handle realtime updates, where multiple consecutive prices often have the same value. This will usually happen whenever orders are unable to move across the bid/ask levels, either because of slow action or because a large-volume​ bid/ask level is taking time to breach. In either case, the proper way to calculate the polarity of volume​ delta for those updates is to use the last known polarity, which is how I calculate now. The Order Book Without access to the order book's levels (the depth of market), we are limited to analyzing transactions that come in the TradingView feed for the chart. That does not mean the volume​ delta information calculated this way is irrelevant; on the contrary, much of the information calculated here is not available in trading consoles supplied by exchanges/brokers. Yet it's important to realize that without access to the order book, you are forfeiting the valuable information that can be gleaned from it. The order book's levels are always in movement, of course, and some of the information they contain is mere posturing, i.e., attempts to influence the behavior of other players in the market by traders/systems who will often remove their orders when price comes near their order levels. Nonetheless, the order book is an essential tool for serious traders operating at intraday timeframes. It can be used to time entries/exits, to explain the causes of particular price movements, to determine optimal stop levels, to get to know the traders/systems you are betting against (they tend to exhibit behavioral patterns only recognizable through the order book), etc. This tool in no way makes the order book less useful; I encourage all intraday traders to become familiar with it and avoid trading without one.
Pine Script® göstergesi
LucF tarafından
101
Great Expectations [LucF]Great Expectations helps traders answer the question: What is possible? It is a powerful question, yet exploration of the unknown always entails risk. A more complete set of questions better suited to traders could be: What opportunity exists from any given point on a chart? What portion of this opportunity can be realistically captured? What risk will be incurred in trying to do so, and how long will it take? Great Expectations is the result of an exploration of these questions. It is a trade simulator that generates visual and quantitative information to help strategy modelers visually identify and analyse areas of optimal expectation on charts, whether they are designing automated or discretionary strategies. WARNING: Great Expectations is NOT an indicator that helps determine the current state of a market. It works by looking at points in the past from which the future is already known. It uses one definition of repainting extensively (i.e. it goes back in the past to print information that could not have been know at the time). Repainting understood that way is in fact almost all the indicator does! —albeit for what I hope is a noble cause. The indicator is of no use whatsoever in analyzing markets in real-time. If you do not understand what it does, please stay away! This is an indicator—not a strategy that uses TradingView’s backtesting engine. It works by simulating trades, not unlike a backtest, but with the crucial difference that it assumes a trade (either long or short) is entered on all bars in the historic sample. It walks forward from each bar and determines possible outcomes, gathering individual trade statistics that in turn generate precious global statistics from all outcomes tested on the chart. Great Expectations provides numbers summarizing trade results on all simulations run from the chart. Those numbers cannot be compared to backtest-produced numbers since all non-filtered bars are examined, even if an entry was taken on the bar immediately preceding the current one, which never happens in a backtest. This peculiarity does NOT invalidate Great Expectations calculations; it just entails that results be considered under a different light. Provided they are evaluated within the indicator’s context, they can be useful—sometimes even more than backtesting results, e.g. in evaluating the impact of parameter-fitting or variations in entry, exit or filtering strats. Traders and strategy modelers are creatures of hope often suffering from blurred vision; my hope is that Great Expectations will help them appraise the validity of their setup and strat intuitions in a realistic fashion, preventing confirmation bias from obstructing perspective—and great expectations from turning into financial great deceptions. USE CASES You’ve identified what looks like a promising setup on other indicators. You load Great Expectations on the chart and evaluate if its high-expectation areas match locations where your setup’s conditions occur. Unless today is your lucky day, chances are the indicator will help you realize your setup is not as promising as you had hoped. You want to get a rough estimate of the optimal trade duration for a chart and you don’t mind using the entry and exit strategies provided with the indicator. You use the trade length readouts of the indicator. You’re experimenting with a new stop strategy and want to know how long it will keep you in trades, on average. You integrate your stop strategy in the indicator’s code and look at the average trade length it produces and the TST ratio to evaluate its performance. You have put together your own entry and exit criteria and are looking for a filter that will help you improve backtesting results. You visually ascertain the suitability of your filter by looking at its results on the charts with great Expectations, to see if your filter is choosing its areas correctly. You have a strategy that shows backtested trades on your chart. Great Expectations can help you evaluate how well your strategy is benefitting from high-opportunity areas while avoiding poor expectation spots. You want more complete statistics on your set of strategies than what backtesting will provide. You use Great Expectations, knowing that it tests all bars in the sample that correspond to your criteria, as opposed to backtesting results which are limited to a subset of all possible entries. You want to fool your friends into thinking you’ve designed the holy grail of indicators, something that identifies optimal opportunities on any chart; you show them the P&L cloud. FEATURES For one trade At any given point on the chart, assuming a trade is entered there, Great Expectations shows you information specific to that trade simulation both on the chart and in the Data Window. The chart can display: the P & L Cloud which shows whether the trade ended profitably or not, and by how much, the Opportunity & Risk Cloud which the maximum opportunity and risk the simulation encountered. When superimposed over the P & L cloud, you will see what I call the managed opportunity and risk, i.e the portion of maximum opportunity that was captured and the portion of the maximum risk that was incurred, the target and if it was reached, a background that uses a gradient to show different levels of trade length, P&L or how frequently the target was reached during simulation. The Data Window displays more than 40 values on individual trades and global results. For any given trade you will know: Entry/Exit levels, including slippage impact, It’s outcome and duration, P/L achieved, The fraction of the maximum opportunity/risk managed by the trade. For all trades After going through all the possible trades on the chart, the indicator will provide you with a rare view of all outcomes expressed with the P&L cloud, which allows us to instantly see the most/least profitable areas of a chart using trade data as support, while also showing its relationship with the opportunity/risk encountered during the simulation. The difference between the two clouds is the managed opportunity and risk. The Data Window will present you with numbers which we will go through later. Some of them are: average stop size, P/L, win rate, % opportunity managed, trade lengths for different types of trade outcomes and the TST (Target:Stop Travel) ratio. Let’s see Great Expectations in action… and remember to open your Data Window! INPUTS Trade direction : You must first choose if you wish to look at long or short trades. Because of the way the indicator works and the amount of visual information on the chart, it is only practical to look at one type of trades at a time. The default is Longs. Maximum trade Length (MaxL) : This is the maximum walk forward distance the simulator will go in analyzing outcomes from any given point in the past. It also determines the size of the dead zone among the chart’s last bars. A red background line identifies the beginning of the dead zone for which not enough bars have elapsed to analyze outcomes for the maximum trade length defined. If an ATR-based entry stop is used, that length is added to the wait time before beginning simulations, so that the first entry starts with a clean ATR value. On a sample of around 16000 bars, my tests show that the indicator runs into server errors at lengths of around 290, i.e. having completed ~4,6M simulation loop iterations. That is way too high a length anyways; 100 will usually be amply enough to ring out all the possibilities out of a simulation, and on shorter time frames, 30 can be enough. While making it unduly small will prevent simulations of expressing the market’s potential, the less you use, the faster the indicator will run. The default is 40. Unrealized P&L base at End of Trade (EOT) : When a simulation ends and the trade is still open, we calculate unrealized P&L from an exit order executed from either the last in-trade stop on the previous bar, or the close of the last bar. You can readily see the impact of this selection on the chart, with the P&L cloud. The default is on the close. Display : The check box besides the title does nothing. Show target : Shows a green line displaying the trade’s target expressed as a multiple of X, i.e. the amplitude of the entry stop. I call this value “X” and use it as a unit to express profit and loss on a trade (some call it “R”). The line is highlighted for trades where the close reached the target during the trade, whether the trade ended in profit or loss. This is also where you specify the multiple of X you wish to use in calculating targets. The multiple is used even if targets are not displayed. Show P&L Cloud : The cloud allows traders to see right away the profitable areas of the chart. The only line printed with the cloud is the “end of trade line” (EOT). The EOT line is the only way one can see the level where a trade ended on the chart (in the Data Window you can see it as the “Exit Fill” value). The EOT level for the trade determines if the trade ended in a profit or a loss. Its value represents one of the following: - fill from order executed at close of bar where stop is breached during trade (which produces “Realized P/L”), - simulation of a fill pseudo-fill at the user-defined EOT level (last close or stop level) if the trade runs its course through MaxL bars without getting stopped (producing Unrealized P/L). The EOT line and the cloud fill print in green when the trade’s outcome is profitable and in red when it is not. If the trade was closed after breaching the stop, the line appears brighter. Show Opportunity&Risk Cloud : Displays the maximum opportunity/risk that was present during the trade, i.e. the maximum and minimum prices reached. Background Color Scheme : Allows you to choose between 3 different color schemes for the background gradients, to accommodate different types of chart background/candles. Select “None” if you don’t want a background. Background source : Determines what value will be used to generate the different intensities of the gradient. You can choose trade length (brighter is shorter), Trade P&L (brighter is higher) or the number of times the target was reached during simulation (brighter is higher). The default is Trade Length. Entry strat : The check box besides the title does nothing. The default strat is All bars, meaning a trade will be simulated from all bars not excluded by the filters where a MaxL bars future exists. For fun, I’ve included a pseudo-random entry strat (an indirect way of changing the seed is to vary the starting date of the simulation). Show Filter State : Displays areas where the combination of filters you have selected are allowing entries. Filtering occurs as per your selection(s), whether the state is displayed or not. The effect of multiple selections is additive. The filters are: 1. Bar direction: Longs will only be entered if close>open and vice versa. 2. Rising Volume: Applies to both long and shorts. 3. Rising/falling MA of the length you choose over the number of bars you choose. 4. Custom indicator: You can feed your own filtering signal through this from another indicator. It must produce a signal of 1 to allow long entries and 0 to allow shorts. Show Entry Stops : 1. Multiple of user-defined length ATR. 2. Fixed percentage. 3. Fixed value. All entry stops are calculated using the entry fill price as a reference. The fill price is calculated from the current bar’s open, to which slippage is added if configured. This simulates the case where the strategy issued the entry signal on the previous bar for it to be executed at the next bar’s open. The entry stop remains active until the in-trade stop becomes the more aggressive of the two stops. From then on, the entry stop will be ignored, unless a bar close breaches the in-trade stop, in which case the stop will be reset with a new entry stop and the process repeats. Show In-trade stops : Displays in bright red the selected in-trade stop (be sure to read the note in this section about them). 1. ATR multiple: added/subtracted from the average of the two previous bars minimum/maximum of open/close. 2. A trailing stop with a deviation expressed as a multiple of entry stop (X). 3. A fixed percentage trailing stop. Trailing stops deviations are measured from the highest/lowest high/low reached during the trade. Note: There is a twist with the in-trade stops. It’s that for any given bar, its in-trade stop can hold multiple values, as each successive pass of the advancing simulation loops goes over it from a different entry points. What is printed is the stop from the loop that ended on that bar, which may have nothing to do with other instances of the trade’s in-trade stop for the same bar when visited from other starting points in previous simulations. There is just no practical way to print all stop values that were used for any given bar. While the printed entry stops are the actual ones used on each bar, the in-trade stops shown are merely the last instance used among many. Include Slippage : if checked, slippage will be added/subtracted from order price to yield the fill price. Slippage is in percentage. If you choose to include slippage in the simulations, remember to adjust it by considering the liquidity of the markets and the time frame you’ll be analyzing. Include Fees : if checked, fees will be subtracted/added to both realized an unrealized trade profits/losses. Fees are in percentage. The default fees work well for crypto markets but will need adjusting for others—especially in Forex. Remember to modify them accordingly as they can have a major impact on results. Both fees and slippage are included to remind us of their importance, even if the global numbers produced by the indicator are not representative of a real trading scenario composed of sequential trades. Date Range filtering : the usual. Just note that the checkbox has to be selected for date filtering to activate. DATA WINDOW Most of the information produced by this indicator is made available in the Data Window, which you bring up by using the icon below the Watchlist and Alerts buttons at the right of the TV UI. Here’s what’s there. Some of the information presented in the Data Window is standard trade data; other values are not so standard; e. g. the notions of managed opportunity and risk and Target:Stop Travel ratio. The interplay between all the values provided by Great Expectations is inherently complex, even for a static set of entry/filter/exit strats. During the constant updating which the habitual process of progressive refinement in building strategies that is the lot of strategy modelers entails, another level of complexity is no doubt added to the analysis of this indicator’s values. While I don’t want to sound like Wolfram presenting A New Kind of Science , I do believe that if you are a serious strategy modeler and spend the time required to get used to using all the information this indicator makes available, you may find it useful. Trade Information Entry Order : This is the open of the bar where simulation starts. We suppose that an entry signal was generated at the previous bar. Entry Fill (including slip.) : The actual entry price, including slippage. This is the base price from which other values will be calculated. Exit Order : When a stop is breached, an exit order is executed from the close of the bar that breached the stop. While there is no “In-trade stop” value included in the Data Window (other than the End of trade Stop previously discussed), this “Exit Order” value is how we can know the level where the trade was stopped during the simulation. The “Trade Length” value will then show the bar where the stop was breached. Exit Fill (including slip.) : When the exit order is simulated, slippage is added to the order level to create the fill. Chart: Target : This is the target calculated at the beginning of the simulation. This value also appear on the chart in teal. It is controlled by the multiple of X defined under the “Show Target” checkbox in the Inputs. Chart: Entry Stop : This value also appears on the chart (the red dots under points where a trade was simulated). Its value is controlled by the Entry Strat chosen in the Inputs. X (% Fill, including Fees) and X (currency) : This is the stop’s amplitude (Entry Fill – Entry Stop) + Fees. It represents the risk incurred upon entry and will be used to express P&L. We will show R expressed in both a percentage of the Entry Fill level (this value), and currency (the next value). This value represents the risk in the risk:reward ratio and is considered to be a unit of 1 so that RR can be expressed as a single value (i.e. “2” actually meaning “1:2”). Trade Length : If trade was stopped, it’s the number of bars elapsed until then. The trade is then considered “Closed”. If the trade ends without being stopped (there is no profit-taking strat implemented, so the stop is the only exit strat), then the trade is “Open”, the length is MaxL and it will show in orange. Otherwise the value will print in green/red to reflect if the trade is winning/losing. P&L (X) : The P&L of the trade, expressed as a multiple of X, which takes into account fees paid at entry and exit. Given our default target setting at 2 units of “X”, a trade that closes at its target will have produced a P&L of +2.0, i.e. twice the value of X (not counting fees paid at exit ). A trade that gets stopped late 50% further that the entry stop’s level will produce a P&L of -1.5X. P&L (currency, including Fees) : same value as above, but expressed in currency. Target first reached at bar : If price closed above the target during the trade (even if it occurs after the trade was stopped), this will show when. This value will be used in calculating our TST ratio. Times Stop/Target reached in sim. : Includes all occurrences during the complete simulation loop. Opportunity (X) : The highest/lowest price reached during a simulation, i.e. the maximum opportunity encountered, whether the trade was previously stopped or not, expressed as a multiple of X. Risk (X) : The lowest/highest price reached during a simulation, i.e. the maximum risk encountered, whether the trade was previously stopped or not, expressed as a multiple of X. Risk:Opportunity : The greater this ratio, the greater Opportunity is, compared to Risk. Managed Opportunity (%) : The portion of Opportunity that was captured by the highest/low stop position, even if it occurred after a previous stop closed the trade. Managed Risk (%) : The portion of risk that was protected by the lowest/highest stop position, even if it occurred after a previous stop closed the trade. When this value is greater than 100%, it means the trade’s stop is protecting more than the maximum risk, which is frequent. You will, however, never see close to those values for the Managed Opportunity value, since the stop would have to be higher than the Maximum opportunity. It is much easier to alleviate the risk than it is to lock in profits. Managed Risk:Opportunity : The ratio of the two preceding values. Managed Opp. vs. Risk : The Managed Opportunity minus the Managed Risk. When it is negative, which is most often is, it means your strat is protecting a greater portion of the risk than it captures opportunity. Global Numbers Win Rate(%) : Percentage of winning trades over all entries. Open trades are considered winning if their last stop/close (as per user selection) locks in profits. Avg X%, Avg X (currency) : Averages of previously described values:. Avg Profitability/Trade (APPT) : This measures expectation using: Average Profitability Per Trade = (Probability of Win × Average Win) − (Probability of Loss × Average Loss) . It quantifies the average expectation/trade, which RR alone can’t do, as the probabilities of each outcome (win/lose) must also be used to calculate expectancy. The APPT combine the RR with the win rate to yield the true expectancy of a strategy. In my usual way of expressing risk with X, APPT is the equivalent of the average P&L per trade expressed in X. An APPT of -1.5 means that we lose on average 1.5X/trade. Equity (X), Equity (currency) : The cumulative result of all trade outcomes, expressed as a multiple of X. Multiplied by the Average X in currency, this yields the Equity in currency. Risk:Opportunity, Managed Risk:Opportunity, Managed Opp. vs. Risk : The global values of the ones previously described. Avg Trade Length (TL) : One of the most important values derived by going through all the simulations. Again, it is composed of either the length of stopped trades, or MaxL when the trade isn’t stopped (open). This value can help systems modelers shape the characteristics of the components they use to build their strategies. Avg Closed Win TL and Avg Closed Lose TL : The average lengths of winning/losing trades that were stopped. Target reached? Avg bars to Stop and Target reached? Avg bars to Target : For the trades where the target was reached at some point in the simulation, the number of bars to the first point where the stop was breached and where the target was reached, respectively. These two values are used to calculate the next value. TST (Target:Stop Travel Ratio) : This tracks the ratio between the two preceding values (Bars to first stop/Bars to first target), but only for trades where the target was reached somewhere in the loop. A ratio of 2 means targets are reached twice as fast as stops. The next values of this section are counts or percentages and are self-explanatory. Chart Plots Contains chart plots of values already describes. NOTES Optimization/Overfitting: There is a fine line between optimizing and overfitting. Tools like this indicator can lead unsuspecting modelers down a path of overfitting that often turns strategies into over-specialized beasts that do not perform elegantly when confronted to the real-world. Proven testing strategies like walk forward analysis will go a long way in helping modelers alleviate this risk. Input tuning: Because the results generated by the indicator will vary with the parameters used in the active entry, filtering and exit strats, it’s important to realize that although it may be fun at first, just slapping the default settings on a chart and time frame will not yield optimal nor reliable results. While using ATR as often as possible (as I do in this indicator) is a good way to make strat parametrization adaptable, it is not a foolproof solution. There is no data for the last MaxL bars of the chart, since not enough trade future has elapsed to run a simulation from MaxL bars back. Modifying the code: I have tried to structure the code modularly, even if that entails a larger code base, so that you can adapt it to your needs. I’ve included a few token components in each of the placeholders designed for entry strategies, filters, entry stops and in-trade stops. This will hopefully make it easier to add your own. In the same spirit, I have also commented liberally. You will find in the code many instances of standard trade management tasks that can be lifted to code TV strategies where, as I do in mine, you manage everything yourself and don’t rely on built-in Pine strategy functions to act on your trades. Enjoy! THANKS To @scarf who showed me how plotchar() could be used to plot values without ruining scale. To @glaz for the suggestion to include a Chandelier stop strat; I will. To @simpelyfe for the idea of using an indicator input for the filters (if some day TV lets us use more than one, it will be useful in other modules of the indicator). To @RicardoSantos for the random generator used in the random entry strat. To all scripters publishing open source on TradingView; their code is the best way to learn. To my trading buddies Irving and Bruno; who showed me way back how pro traders get it done.
Pine Script® göstergesi
LucF tarafından
7
Scalp Precision Matrix [BullByte]SCALP PRECISION MATRIX (SPM) OVERVIEW Scalp Precision Matrix (SPM) is a comprehensive decision-support framework designed specifically for scalpers and short-term traders. This indicator synthesizes five distinct analytical layers into a unified system that helps identify high-quality setups while avoiding common pitfalls that trap traders. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ THE CORE PROBLEM THIS INDICATOR ADDRESSES Scalping demands rapid decision-making while simultaneously processing multiple data points. Traders constantly ask themselves: Is momentum still alive? Am I entering near a potential reversal zone? Is this the right session to trade? What is my actual risk-to-reward? Most traders either overwhelm themselves with too many separate indicators (creating analysis paralysis) or use too few (missing crucial context). SPM was developed to consolidate these essential checks into one cohesive framework. Rather than overlaying disconnected indicators, each component in SPM directly informs and adjusts the others, creating an integrated analytical system. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ WHY THESE SPECIFIC COMPONENTS AND HOW THEY WORK TOGETHER The five analytical layers in SPM are not arbitrarily combined. Each addresses a specific question in the scalping decision process, and together they form a logical workflow: LAYER 1: MOMENTUM FUEL GAUGE This answers the question: "Does the current move still have energy?" After any impulse move (a significant directional price movement), momentum naturally decays over time. The Fuel Gauge estimates remaining momentum by analyzing four factors: Body Strength (30% weight): Compares recent candle body sizes against the historical average. Strong momentum produces candles with large bodies relative to their wicks. The calculation takes the 3-bar average body size divided by the 20-bar average body size, then scales it to a 0-100 range. Wick Rejection (25% weight): Measures the wick-to-body ratio. When wicks are large relative to bodies, it suggests rejection and weakening momentum. A ratio of 2.0 or higher (wicks twice the body size) scores low; smaller ratios score higher. Volume Consistency (20% weight): Compares recent 3-bar average volume against the lookback period average. Sustained moves require consistent volume support. Volume dropping off suggests the move may be losing participation. Time Decay (25% weight): Tracks how many bars have passed since the last detected impulse. Momentum naturally fades over time. The typical impulse duration is adjusted based on the current volatility regime. These components are weighted and combined, then smoothed with a 3-period EMA to reduce noise. The result is a 0-100% gauge where: - Above 70% = Strong momentum (green) - 40-70% = Moderate momentum (amber) - Below 40% = Weak momentum (red) - Below 20% = Exhausted (triggers EXIT warning) The Fuel Gauge also estimates how many bars of momentum remain based on the current burn rate. IMPORTANT DISCLAIMER : The Fuel Gauge is NOT order flow, volume profile, or depth of market data. It is a technical proxy calculated entirely from standard OHLCV (Open, High, Low, Close, Volume) data. The term "Fuel" is used metaphorically to represent estimated remaining momentum energy. LAYER 2: TRAP ZONE DETECTION This answers the question: "Am I walking into a potential reversal area?" Price tends to reverse at levels where it has reversed before. SPM identifies these zones by detecting clusters of historical swing points: How it works: 1. The indicator detects swing highs and swing lows using the Swing Detection Length setting (default 5 bars on each side required to confirm a pivot). 2. Recent swing points are stored (up to 10 of each type). 3. For each potential zone, the algorithm counts how many swing points cluster within a tolerance of 0.5 ATR. 4. Zones with 2 or more clustered swing points, positioned between 0.3 and 4.0 ATR from current price, are marked as Trap Zones. 5. A Confluence Score is calculated based on cluster density and proximity to current price. The percentage displayed (e.g., "TRAP 85%") is a CONFLUENCE SCORE, not a probability. Higher percentages mean more swing points cluster at that level and price is closer to it. This indicates stronger historical significance, not a prediction of future reversal. CRITICAL DISCLAIMER : Trap Zones are NOT institutional order flow, liquidity pools, smart money footprints, or any proprietary data feed. They are calculated purely from historical swing point clustering using standard technical analysis. The term "trap" describes how price action has historically reversed at these levels, potentially trapping traders who enter prematurely. This is pattern recognition, not market structure data. LAYER 3: VELOCITY ANALYSIS This answers the question: "Is price moving favorably right now?" Velocity measures how fast price is currently moving compared to its recent average: Calculation: - Current velocity = Absolute price change from previous bar divided by ATR - Average velocity = Simple moving average of velocity over the lookback period - Velocity ratio = Current velocity divided by average velocity Classification: - FAST (ratio above 1.5 ): Price is moving significantly faster than normal. Good for momentum continuation plays. - NORMAL (ratio 0.5 to 1.5) : Typical price movement speed. - SLOW (ratio below 0.5 ): Price is moving sluggishly. Often indicates ranging or choppy conditions where scalping becomes difficult. The velocity score contributes 18% to the overall quality score calculation. LAYER 4: SESSION AWARENESS This answers the question: "Is this a good time to trade?" Different trading sessions have different characteristics. SPM automatically detects which major session is active and adjusts its quality assessment: Session Times (all in UTC): - A sia Session : 00:00 - 08:00 UTC - London Session : 08:00 - 16:00 UTC - New York Session : 13:00 - 21:00 UTC - London/NY Overlap : 13:00 - 16:00 UTC - Off-Peak : Outside major sessions Session Quality Weighting: - Overlap : 100 points (highest liquidity, best movement) - London : 85 points - New York : 80 points - Asia : 50 points (tends to range more) - Off-Peak : 30 points (lower liquidity, more false signals) The session score contributes 17% to the overall quality calculation. Signals are also filtered to prevent firing during off-peak hours. Note : These are fixed UTC times and may not perfectly match your broker's session boundaries. Use them as general guidance rather than precise timing. LAYER 5: VOLATILITY REGIME ADAPTATION This answers the question: "How should I adjust for current market conditions?" SPM compares current volatility (14-period ATR) against historical volatility (50-period ATR) to categorize the market: HIGH Volatility (ratio above 1.3): Current ATR is 30%+ above normal. SPM widens thresholds to filter noise and extends target projections. NORMAL Volatility (ratio 0.7 to 1.3): Typical conditions. Standard parameters apply. LOW Volatility (ratio below 0.7): Current ATR is 30%+ below normal. SPM tightens thresholds for sensitivity and reduces target expectations. The market state may show AVOID during prolonged low volatility. This adaptation prevents false signals during erratic markets and missed signals during quiet markets. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ THE SYNERGY: WHY THIS COMBINATION MATTERS These five layers are not independent indicators placed on one chart. They form an interconnected system: - A signal only fires when momentum exists (Fuel above 40%), price is away from danger zones (Trap Zones factored into quality score), movement is favorable (Velocity contributes to score), timing is appropriate (Session is not off-peak), and volatility is accounted for (thresholds adapt to regime). - The Trap Zones directly influence Entry Zone placement. Entry zones are positioned beyond trap zones to avoid getting caught in reversals. - Target projections automatically adjust to avoid placing take-profit levels inside detected trap zones. - The Fuel Gauge affects which signal tier fires. Insufficient fuel prevents all signals. - Session quality is weighted into the overall score, reducing signal quality during less favorable trading hours. This integration is the core originality of SPM. Each component makes the others more useful than they would be in isolation. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ HOW THE QUALITY SCORE IS CALCULATED The Quality Score (0-100) synthesizes all layers into a single number for each direction (long and short): For Long Quality Score: - Fuel Component (28% weight) : Full fuel value if impulse direction is bullish; 60% of fuel value otherwise - Trap Avoidance (22% weight) : 75 points if no trap zone below; otherwise 100 minus the trap confluence score (minimum 20) - Velocity Component (18% weight) : Direct velocity score - Session Component (17% weight) : Current session quality score - Trend Alignment (15% bonus) : Adds 12 points if price is above the 20-period SMA For Short Quality Score: - Same structure but reversed (bearish impulse direction, trap zone above, price below SMA) The direction with the higher score becomes the current Bias. A 12-point difference is required to switch bias, preventing flip-flopping in neutral conditions. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ SIGNAL TYPES AND WHAT THEY MEAN SPM generates four types of signals, each with specific visual representation: PRIME SIGNALS (Cyan Diamond) These represent the highest quality confluence. Requirements: - Quality score crosses above the Prime threshold (default 80) - Bias aligns with signal direction - Fuel is sufficient (above 40%) - Session is active (not off-peak) - Cooldown period has passed Prime signals appear as cyan-colored diamond shapes. Long signals appear below the bar; short signals appear above. STANDARD SIGNALS (Green Triangle Up / Red Triangle Down) These represent good quality setups. Requirements: - Quality score crosses above the Standard threshold (default 75) but below Prime - Same bias, fuel, and cooldown requirements as Prime Standard signals appear as small triangles in green (long) or red (short). CAUTION SIGNALS (Small Faded Circle) These represent minimum threshold setups. Requirements: - Quality score crosses above the Caution threshold (default 65) but below Standard - Same additional requirements Caution signals appear as small, faded circles. These suggest the setup exists but with weaker confluence. Consider these only when broader market context supports them, or skip them entirely during uncertain conditions. EXHAUSTION SIGNAL (Purple X with "EXIT" text) This warning appears when the Fuel Gauge drops below 20% from above, indicating momentum has depleted. This is not a trade signal but a warning to: - Consider exiting existing positions - Avoid entering new trades in the current direction - Wait for new momentum to develop All signals use CONFIRMED bar data only (referencing the previous closed bar) to prevent repainting. Once a signal appears, it will never disappear or change position on historical bars. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ READING THE CHART ELEMENTS TRAP ZONES (Red Dashed Box with "TRAP XX%" Label) These mark price levels where multiple historical swing points cluster. The red dashed box shows the zone boundaries. The percentage is the confluence score indicating cluster strength and proximity. How to use: When price approaches a trap zone, be cautious about entering in that direction. If your bias is LONG and there's a strong trap zone above, consider taking partial profits before price reaches it or adjusting your target below it. ENTRY ZONES (Green Solid Box with "ENTRY" Label) These show suggested entry areas based on the current bias direction. For LONG bias, the entry zone appears below the trap zone (buying the dip beyond support). For SHORT bias, it appears above the trap zone (selling the rally beyond resistance). How to use: Rather than entering at current price, consider placing limit orders within the entry zone. This positions you beyond where typical trap reversals occur. TARGET ZONES (Blue Dotted Box with "TARGET" Label) These project potential take-profit areas based on ATR multiples, adjusted for: - Current volatility regime (wider in high volatility, tighter in low) - Impulse direction (larger targets when aligned with impulse) - Nearby trap zones (targets adjust to avoid placing TP inside trap zones) How to use: These are suggestions, not guarantees. Consider taking partial profits before the target or using trailing stops once price moves favorably. STOP LEVEL (Orange Dashed Line with "STOP" Label) This shows suggested stop-loss placement, calculated as 0.8 ATR beyond the trap zone (or 2.0 ATR from current price if no trap zone exists). How to use: This provides a reference for risk calculation. The dashboard R:R ratio is calculated using this stop level. Chart Example: Scalp Precision Matrix displays real-time market analysis through dynamic zones and quality scores. ENTRY/TARGET/STOP zones show potential price levels based on current market structure - they appear continuously as reference points, NOT as trade instructions. Actual trade signals (diamonds, triangles, circles) fire only when multiple conditions align: quality score thresholds are crossed, fuel gauge is sufficient, session is active, and cooldown period has passed. The zones help you understand market context; the signals tell you when to act. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ UNDERSTANDING THE DASHBOARD (Top Right Panel) The main dashboard provides comprehensive market context: Row 1 - Header: - "SPM " : Indicator name - Market State : Current overall condition Market States Explained: - PRIME : Excellent conditions. Quality score meets prime threshold, session is active. Best opportunities. - READY : Good conditions. Quality score meets standard threshold. Solid setups available. - WAIT : Mixed conditions. Some factors favorable, others not. Patience recommended. - AVOID : Poor conditions. Off-peak session or very low volatility. High risk of false signals. - EXIT : Fuel exhausted. Momentum depleted. Consider closing positions or waiting. Row 2-3 - Quality Bars: - " UP ########## " : Visual meter for long quality (each # = 10 points, . = empty) - " DN ########## " : Visual meter for short quality - The number on the right shows the exact quality score Row 4 - Bias: - Shows current directional lean: LONG, SHORT, or NEUTRAL - Color-coded: Green for long, red for short, gray for neutral Rows 5-7 (Full Mode Only) - Trade Levels: - Entry : Suggested entry price for current bias direction - Stop : Suggested stop-loss price - Target : Projected take-profit price Row 8 - Risk:Reward Ratio: - Format : "1:X.X" where X.X is the reward multiple - Color-coded : Green if 2:1 or better, amber if 1.5:1 to 2:1, red if below 1.5:1 Row 9 - Fuel: - Shows percentage and estimated bars remaining in parentheses - Example : "72% (8)" means 72% fuel with approximately 8 bars remaining - Color-coded : Green above 70%, amber 40-70%, red below 40% Row 10-11 (Full Mode Only) - Market Conditions: - Vol : Current volatility regime (HIGH/NORMAL/LOW) - Speed : Current velocity zone (FAST/NORMAL/SLOW) Row 12 - Session: - Shows active trading session - Color-coded by session type Row 13 (Full Mode Only) - Remaining: - Time remaining in current session (hours and minutes) Row 14 (Conditional) - Trap Warning: - Appears when a significant trap zone exists in your bias direction - Shows direction (ABOVE/BELOW) and confluence percentage ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ UNDERSTANDING THE QUICK PANEL (Bottom Left) The Quick Panel provides essential information at a glance without looking away from price action: Row 1: Current Bias and Quality Score (large text for quick reading) Row 2: Market State Row 3: Fuel Percentage Row 4: Estimated Bars Remaining Row 5: Risk:Reward Ratio Row 6: Current Session Both panels can be repositioned using the settings, and each can be toggled on/off independently. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ SETTINGS EXPLAINED CORE SETTINGS: Analysis Lookback (Default: 20) Number of bars used for statistical calculations including average volume and average body size. Higher values create smoother but slower-reacting analysis. Lower values are more responsive but may include more noise. Swing Detection Length (Default: 5) Bars required on each side to confirm a swing high or low. A setting of 5 means a swing high must have 5 lower highs on each side. Lower values detect more swings (more trap zones, more sensitivity). Higher values find only major pivots (fewer but more significant zones). Impulse Sensitivity (Default: 1.5) Multiplier for ATR when detecting impulse moves. Lower values (like 1.0) detect smaller price movements as impulses, refreshing the fuel gauge more frequently. Higher values (like 2.5) require larger moves, making impulse detection less frequent but more significant. SIGNAL SETTINGS: Prime/Standard/Caution Thresholds (Defaults: 80/75/65) These control the quality score required for each signal tier. You can adjust these based on your preference: - More conservative : Raise thresholds (e.g., 85/80/70) for fewer but higher-quality signals - More aggressive : Lower thresholds (e.g., 75/70/60) for more signals with slightly lower quality Signal Cooldown (Default: 8 bars) Minimum bars between signals to prevent signal spam. After any signal fires, no new signals can appear until this many bars pass. Increase for fewer signals in choppy markets; decrease if you want faster signal refresh. Show Prime/Standard/Caution/Exhaustion Signals Toggle each signal type on or off based on your preference. ZONE DISPLAY: Show Trap Zones / Entry Zones / Target Zones / Stop Levels Toggle each zone type on or off. Turning off zones you don't use reduces chart clutter. Zone Transparency (Default: 88) Controls how transparent zone boxes appear. Higher values (closer to 95) make zones barely visible; lower values (closer to 75) make them more prominent. Zone History (Default: 25 bars) How far back zone boxes extend on the chart. Purely visual preference. BACKGROUND: Background Mode (Options: Off, Subtle, Normal) Controls whether and how intensely the chart background is colored. Subtle is barely noticeable; Normal is more visible; Off disables background coloring entirely. Background Type (Options: Bias, Fuel) - Bias : Colors background based on current directional lean (green for long, red for short) - Fuel : Colors background based on momentum level (green for high fuel, amber for moderate, red for low) DASHBOARD / QUICK PANEL: Show Dashboard / Show Quick Panel Toggle each panel on or off. Compact Mode When enabled, the main dashboard shows only essential rows (quality bars, bias, R:R, fuel, session) without entry/stop/target levels, volatility, velocity, or time remaining. Position Settings Choose where each panel appears on your chart from six options: Top Right, Top Left, Bottom Right, Bottom Left, Middle Right, Middle Left. ALERTS: Alert Prime Signals / Standard Signals / Fuel Exhaustion Enable or disable TradingView alerts for each condition. When enabled, you can set up alerts in TradingView that will notify you when these conditions occur. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ RECOMMENDED TIMEFRAMES AND USAGE OPTIMAL TIMEFRAMES: - 1-minute to 5-minute : Best for active scalping with quick entries and exits - 5-minute to 15-minute : Balanced scalping with slightly more confirmation - 15-minute to 1-hour : Short-term swing entries, fewer but more significant signals Zone visualizations only appear on intraday timeframes to prevent chart clutter on higher timeframes. BEST PRACTICES: 1. Trade primarily during LONDON, NEW YORK, or OVERLAP sessions. The indicator weights these sessions higher for good reason - liquidity and movement are typically better. 2. Prioritize PRIME signals. These represent the highest confluence and have proven most reliable. Use STANDARD signals as secondary opportunities. Treat CAUTION signals with extra scrutiny. 3. Respect the Fuel Gauge. Avoid entering new positions when fuel is below 40%. When the EXIT signal appears, seriously consider closing or reducing positions. 4. Pay attention to TRAP warnings. When the dashboard shows a trap zone in your bias direction, be cautious about holding through that level. 5. Verify R:R before entry. The dashboard shows the risk-to-reward ratio. Ensure it meets your minimum requirements (many traders require at least 1.5:1 or 2:1). 6. When state shows AVOID or EXIT, step back. These conditions typically produce poor results. 7. Combine with your own analysis. SPM is a decision-support tool, not a standalone system. Use it alongside your understanding of market structure, news events, and overall context. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ PRACTICAL EXAMPLE Scenario : You're watching a 5-minute chart during London session. A cyan diamond (Prime Long signal) appears below the bar. Before entering, you check the dashboard: - State shows "PRIME" - conditions are favorable - Fuel shows "72% (8)" - plenty of momentum remaining (approximately 8 bars) - R:R shows "1:2.3" - acceptable risk-to-reward ratio - Session shows "LONDON" - active session with good liquidity - No TRAP warning in dashboard - no immediate resistance cluster in your way - Entry zone visible on chart at a lower price level - Stop and Target zones clearly marked With this confluence of factors, you have context for a more informed decision. The signal indicates quality, the fuel suggests momentum remains, the R:R is favorable, and no immediate trap threatens your trade. However, you also notice the target zone sits just below where a trap zone would be if there were one. This is by design - SPM adjusts targets to avoid placing them inside reversal zones. This multi-factor confirmation delivered in a single glance is what SPM provides. Chart Example :This chart demonstrates how the Scalp Precision Matrix identifies key market transitions. After a strong bullish impulse (cyan PRIME signal at ~08:30), price reached a historical reversal cluster (TRAP ZONE at 92,300). The indicator detected momentum exhaustion (purple EXIT signal) as fuel dropped below 20%, warning traders to exit longs. Now showing a SHORT bias with entry/stop/target zones clearly marked. The 92% trap zone confluence indicates a strong cluster of previous swing highs where price historically reversed. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ DATA WINDOW VALUES For detailed analysis and strategy development, SPM exports the following values to TradingView's Data Window (visible when you hover over the chart with the indicator selected): - Long Quality Score (0-100) - Short Quality Score (0-100) - Fuel Gauge (0-100%) - Risk:Reward Ratio These values can be useful for understanding how the indicator behaves over time and for developing your own insights about when it works best for your trading style. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ NON-REPAINTING CONFIRMATION All signals in SPM are generated using CONFIRMED bar data only. The signal logic references the previous closed bar's values ( and in Pine Script terms). This means: - Signals appear at the OPEN of the new bar (after the previous bar closes) - Signals will NEVER disappear once they appear - Signals will NEVER change position on historical bars - What you see in backtesting is what you would have seen in real-time The dashboard and zones update in real-time to provide current market context, but the trading signals themselves are non-repainting. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ IMPORTANT DISCLAIMERS TERMINOLOGY CLARIFICATION: This indicator uses terms that might imply access to data it does not have. To be completely transparent: - "Trap Zones" are calculated from historical swing point clustering. They are NOT institutional liquidity pools, order blocks, smart money footprints, or any form of order flow data. The term "trap" is metaphorical, describing how price has historically reversed at these levels. - "Fuel Gauge" is a technical momentum proxy. It is NOT order flow, volume profile, depth of market, or bid/ask data. It estimates momentum remaining based entirely on standard OHLCV price and volume data. - "Quality Scores" are weighted combinations of the technical factors described above. A high score indicates multiple conditions align favorably according to the indicator's logic. It does NOT predict or guarantee trade success. - The percentages shown on trap zones are CONFLUENCE SCORES measuring cluster density and proximity. They are NOT probability predictions of reversal. TRADING RISK WARNING: Trading involves substantial risk of loss and is not suitable for all investors. This indicator is a technical analysis tool designed to assist with decision-making. It does not constitute financial advice, trading advice, or any other sort of advice. Past performance of any signal or pattern does not guarantee future results. Markets are inherently unpredictable. Always use proper risk management. Define your risk before entering any trade. Never risk more than you can afford to lose. Consider consulting with a licensed financial advisor before making trading decisions. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ORIGINALITY STATEMENT - NOT A MASHUP Scalp Precision Matrix is an original work that combines several analytical concepts into a purpose-built scalping framework. While individual components like ATR calculations, pivot detection, session timing, and trend alignment exist in various forms elsewhere, the specific implementation here represents original synthesis: - The Fuel Gauge decay model with its four-component weighted calculation - The Trap Zone cluster detection with confluence scoring - The multi-factor quality scoring system that integrates all layers - The trap-aware entry and target zone placement logic - The volatility regime adaptation across all components - The session weighting is integrated into the quality assessment The indicator does not simply overlay separate indicators on one chart. It creates interconnected layers where each component informs and adjusts the others. This integration is the core originality of SPM. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ For best results, combine SPM with your own market understanding and always practice proper risk management. -BullByte
Pine Script® göstergesi
BullByte tarafından
10
Intrabar Volume Flow IntelligenceIntrabar Volume Flow Intelligence: A Comprehensive Analysis: The Intrabar Volume Flow Intelligence indicator represents a sophisticated approach to understanding market dynamics through the lens of volume analysis at a granular, intrabar level. This Pine Script version 5 indicator transcends traditional volume analysis by dissecting price action within individual bars to reveal the true nature of buying and selling pressure that often remains hidden when examining only the external characteristics of completed candlesticks. At its core, this indicator operates on the principle that volume is the fuel that drives price movement, and by understanding where volume is being applied within each bar—whether at higher prices indicating buying pressure or at lower prices indicating selling pressure—traders can gain a significant edge in anticipating future price movements before they become obvious to the broader market. The foundational innovation of this indicator lies in its use of lower timeframe data to analyze what happens inside each bar on your chart timeframe. While most traders see only the open, high, low, and close of a five-minute candle, for example, this indicator requests data from a one-minute timeframe by default to see all the individual one-minute candles that comprise that five-minute bar. This intrabar analysis allows the indicator to calculate a weighted intensity score based on where the price closed within each sub-bar's range. If the close is near the high, that volume is attributed more heavily to buying pressure; if near the low, to selling pressure. This methodology is far more nuanced than simple tick volume analysis or even traditional volume delta calculations because it accounts for the actual price behavior and distribution of volume throughout the formation of each bar, providing a three-dimensional view of market participation. The intensity calculation itself demonstrates the coding sophistication embedded in this indicator. For each intrabar segment, the indicator calculates a base intensity using the formula of close minus low divided by the range between high and low. This gives a value between zero and one, where values approaching one indicate closes near the high and values approaching zero indicate closes near the low. However, the indicator doesn't stop there—it applies an open adjustment factor that considers the relationship between the close and open positions within the overall range, adding up to twenty percent additional weighting based on directional movement. This adjustment ensures that strongly directional intrabar movement receives appropriate emphasis in the final volume allocation. The adjusted intensity is then bounded between zero and one to prevent extreme outliers from distorting the analysis, demonstrating careful consideration of edge cases and data integrity. The volume flow calculation multiplies this intensity by the actual volume transacted in each intrabar segment, creating buy volume and sell volume figures that represent not just quantity but quality of market participation. These figures are accumulated across all intrabar segments within the parent bar, and simultaneously, a volume-weighted average price is calculated for the entire bar using the typical price of each segment multiplied by its volume. This intrabar VWAP becomes a critical reference point for understanding whether the overall bar is trading above or below its fair value as determined by actual transaction levels. The deviation from this intrabar VWAP is then used as a weighting mechanism—when the close is significantly above the intrabar VWAP, buying volume receives additional weight; when below, selling volume is emphasized. This creates a feedback loop where volume that moves price away from equilibrium is recognized as more significant than volume that keeps price near balance. The imbalance filter represents another layer of analytical sophistication that separates meaningful volume flows from normal market noise. The indicator calculates the absolute difference between buy and sell volume as a percentage of total volume, and this imbalance must exceed a user-defined threshold—defaulted to twenty-five percent but adjustable from five to eighty percent—before the volume flow is considered significant enough to register on the indicator. This filtering mechanism ensures that only bars with clear directional conviction contribute to the cumulative flow measurements, while bars with balanced buying and selling are essentially ignored. This is crucial because markets spend considerable time in equilibrium states where volume is simply facilitating position exchanges without directional intent. By filtering out these neutral periods, the indicator focuses trader attention exclusively on moments when one side of the market is demonstrating clear dominance. The decay factor implementation showcases advanced state management in Pine Script coding. Rather than allowing imbalanced volume to simply disappear after one bar, the indicator maintains decayed values using variable state that persists across bars. When a new significant imbalance occurs, it replaces the decayed value; when no significant imbalance is present, the previous value is multiplied by the decay factor, which defaults to zero point eight-five. This means that a large volume imbalance continues to influence the indicator for several bars afterward, gradually diminishing in impact unless reinforced by new imbalances. This decay mechanism creates persistence in the flow measurements, acknowledging that large institutional volume accumulation or distribution campaigns don't execute in single bars but rather unfold across multiple bars. The cumulative flow calculation then sums these decayed values over a lookback period, creating a running total that represents sustained directional pressure rather than momentary spikes. The dual moving average crossover system applied to these volume flows creates actionable trading signals from the underlying data. The indicator calculates both a fast exponential moving average and a slower simple moving average of the buy flow, sell flow, and net flow values. The use of EMA for the fast line provides responsiveness to recent changes while the SMA for the slow line provides a more stable baseline, and the divergence or convergence between these averages signals shifts in volume flow momentum. When the buy flow EMA crosses above its SMA while volume is elevated, this indicates that buying pressure is not only present but accelerating, which is the foundation for the strong buy signal generation. The same logic applies inversely for selling pressure, creating a symmetrical approach to detecting both upside and downside momentum shifts based on volume characteristics rather than price characteristics. The volume threshold filtering ensures that signals only generate during periods of statistically significant market participation. The indicator calculates a simple moving average of total volume over a user-defined period, defaulted to twenty bars, and then requires that current volume exceed this average by a multiplier, defaulted to one point two times. This ensures that signals occur during periods when the market is actively engaged rather than during quiet periods when a few large orders can create misleading volume patterns. The indicator even distinguishes between high volume—exceeding the threshold—and very high volume—exceeding one point five times the threshold—with the latter triggering background color changes to alert traders to exceptional participation levels. This tiered volume classification allows traders to calibrate their position sizing and conviction levels based on the strength of market participation supporting the signal. The flow momentum calculation adds a velocity dimension to the volume analysis. By calculating the rate of change of the net flow EMA over a user-defined momentum length—defaulted to five bars—the indicator measures not just the direction of volume flow but the acceleration or deceleration of that flow. A positive and increasing flow momentum indicates that buying pressure is not only dominant but intensifying, which typically precedes significant upward price movements. Conversely, negative and decreasing flow momentum suggests selling pressure is building upon itself, often preceding breakdowns. The indicator even calculates a second derivative—the momentum of momentum, termed flow acceleration—which can identify very early turning points when the rate of change itself begins to shift, providing the most forward-looking signal available from this methodology. The divergence detection system represents one of the most powerful features for identifying potential trend reversals and continuations. The indicator maintains separate tracking of price extremes and flow extremes over a lookback period defaulted to fourteen bars. A bearish divergence is identified when price makes a new high or equals the recent high, but the net flow EMA is significantly below its recent high—specifically less than eighty percent of that high—and is declining compared to its value at the divergence lookback distance. This pattern indicates that while price is pushing higher, the volume support for that movement is deteriorating, which frequently precedes reversals. Bullish divergences work inversely, identifying situations where price makes new lows without corresponding weakness in volume flow, suggesting that selling pressure is exhausted and a reversal higher is probable. These divergence signals are plotted as distinct diamond shapes on the indicator, making them visually prominent for trader attention. The accumulation and distribution zone detection provides a longer-term context for understanding institutional positioning. The indicator uses the bars-since function to track consecutive periods where the net flow EMA has remained positive or negative. When buying pressure has persisted for at least five consecutive bars, average intensity exceeds zero point six indicating strong closes within bar ranges, and volume is elevated above the threshold, the indicator identifies an accumulation zone. These zones suggest that smart money is systematically building long positions across multiple bars despite potentially choppy or sideways price action. Distribution zones are identified through the inverse criteria, revealing periods when institutions are systematically exiting or building short positions. These zones are visualized through colored fills on the indicator pane, creating a backdrop that helps traders understand the broader volume flow context beyond individual bar signals. The signal strength scoring system provides a quantitative measure of conviction for each buy or sell signal. Rather than treating all signals as equal, the indicator assigns point values to different signal components: twenty-five points for the buy flow EMA-SMA crossover, twenty-five points for the net flow EMA-SMA crossover, twenty points for high volume presence, fifteen points for positive flow momentum, and fifteen points for bullish divergence presence. These points are summed to create a buy score that can range from zero to one hundred percent, with higher scores indicating that multiple independent confirmation factors are aligned. The same methodology creates a sell score, and these scores are displayed in the information table, allowing traders to quickly assess whether a signal represents a tentative suggestion or a high-conviction setup. This scoring approach transforms the indicator from a binary signal generator into a nuanced probability assessment tool. The visual presentation of the indicator demonstrates exceptional attention to user experience and information density. The primary display shows the net flow EMA as a thick colored line that transitions between green when above zero and above its SMA, indicating strong buying, to a lighter green when above zero but below the SMA, indicating weakening buying, to red when below zero and below the SMA, indicating strong selling, to a lighter red when below zero but above the SMA, indicating weakening selling. This color gradient provides immediate visual feedback about both direction and momentum of volume flows. The net flow SMA is overlaid in orange as a reference line, and a zero line is drawn to clearly delineate positive from negative territory. Behind these lines, a histogram representation of the raw net flow—scaled down by thirty percent for visibility—shows bar-by-bar flow with color intensity reflecting whether flow is strengthening or weakening compared to the previous bar. This layered visualization allows traders to simultaneously see the raw data, the smoothed trend, and the trend of the trend, accommodating both short-term and longer-term trading perspectives. The cumulative delta line adds a macro perspective by maintaining a running sum of all volume deltas divided by one million for scale, plotted in purple as a separate series. This cumulative measure acts similar to an on-balance volume calculation but with the sophisticated volume attribution methodology of this indicator, creating a long-term sentiment gauge that can reveal whether an asset is under sustained accumulation or distribution across days, weeks, or months. Divergences between this cumulative delta and price can identify major trend exhaustion or reversal points that might not be visible in the shorter-term flow measurements. The signal plotting uses shape-based markers rather than background colors or arrows to maximize clarity while preserving chart space. Strong buy signals—meeting multiple criteria including EMA-SMA crossover, high volume, and positive momentum—appear as full-size green triangle-up shapes at the bottom of the indicator pane. Strong sell signals appear as full-size red triangle-down shapes at the top. Regular buy and sell signals that meet fewer criteria appear as smaller, semi-transparent circles, indicating they warrant attention but lack the full confirmation of strong signals. Divergence-based signals appear as distinct diamond shapes in cyan for bullish divergences and orange for bearish divergences, ensuring these critical reversal indicators are immediately recognizable and don't get confused with momentum-based signals. This multi-tiered signal hierarchy helps traders prioritize their analysis and avoid signal overload. The information table in the top-right corner of the indicator pane provides real-time quantitative feedback on all major calculation components. It displays the current bar's buy volume and sell volume in millions with appropriate color coding, the imbalance percentage with color indicating whether it exceeds the threshold, the average intensity score showing whether closes are generally near highs or lows, the flow momentum value, and the current buy and sell scores. This table transforms the indicator from a purely graphical tool into a quantitative dashboard, allowing discretionary traders to incorporate specific numerical thresholds into their decision frameworks. For example, a trader might require that buy score exceed seventy percent and intensity exceed zero point six-five before taking a long position, creating objective entry criteria from subjective chart reading. The background shading that occurs during very high volume periods provides an ambient alert system that doesn't require focused attention on the indicator pane. When volume spikes to one point five times the threshold and net flow EMA is positive, a very light green background appears across the entire indicator pane; when volume spikes with negative net flow, a light red background appears. These backgrounds create a subliminal awareness of exceptional market participation moments, ensuring traders notice when the market is making important decisions even if they're focused on price action or other indicators at that moment. The alert system built into the indicator allows traders to receive notifications for strong buy signals, strong sell signals, bullish divergences, bearish divergences, and very high volume events. These alerts can be configured in TradingView to send push notifications to mobile devices, emails, or webhook calls to automated trading systems. This functionality transforms the indicator from a passive analysis tool into an active monitoring system that can watch markets continuously and notify the trader only when significant volume flow developments occur. For traders monitoring multiple instruments, this alert capability is invaluable for efficient time allocation, allowing them to analyze other opportunities while being instantly notified when this indicator identifies high-probability setups on their watch list. The coding implementation demonstrates advanced Pine Script techniques including the use of request.security_lower_tf to access intrabar data, array manipulation to process variable-length intrabar arrays, proper variable scoping with var keyword for persistent state management across bars, and efficient conditional logic that prevents unnecessary calculations. The code structure with clearly delineated sections for inputs, calculations, signal generation, plotting, and alerts makes it maintainable and educational for those studying Pine Script development. The use of input groups with custom headers creates an organized settings panel that doesn't overwhelm users with dozens of ungrouped parameters, while still providing substantial customization capability for advanced users who want to optimize the indicator for specific instruments or timeframes. For practical trading application, this indicator excels in several specific use cases. Scalpers and day traders can use the intrabar analysis to identify accumulation or distribution happening within the bars of their entry timeframe, providing early entry signals before momentum indicators or price patterns complete. Swing traders can use the cumulative delta and accumulation-distribution zones to understand whether short-term pullbacks in an uptrend are being bought or sold, helping distinguish between healthy retracements and trend reversals. Position traders can use the divergence detection to identify major turning points where price extremes are not supported by volume, providing low-risk entry points for counter-trend positions or warnings to exit with-trend positions before significant reversals. The indicator is particularly valuable in ranging markets where price-based indicators produce numerous false breakout signals. By requiring that breakouts be accompanied by volume flow imbalances, the indicator filters out failed breakouts driven by low participation. When price breaks a range boundary accompanied by a strong buy or sell signal with high buy or sell score and very high volume, the probability of successful breakout follow-through increases dramatically. Conversely, when price breaks a range but the indicator shows low imbalance, opposing flow direction, or low volume, traders can fade the breakout or at minimum avoid chasing it. During trending markets, the indicator helps traders identify the healthiest entry points by revealing where pullbacks are being accumulated by smart money. A trending market will show the cumulative delta continuing in the trend direction even as price pulls back, and accumulation zones will form during these pullbacks. When price resumes the trend, the indicator will generate strong buy or sell signals with high scores, providing objective entry points with clear invalidation levels. The flow momentum component helps traders stay with trends longer by distinguishing between healthy momentum pauses—where momentum goes to zero but doesn't reverse—and actual momentum reversals where opposing pressure is building. The VWAP deviation weighting adds particular value for traders of liquid instruments like major forex pairs, stock indices, and high-volume stocks where VWAP is widely watched by institutional participants. When price deviates significantly from the intrabar VWAP and volume flows in the direction of that deviation with elevated weighting, it indicates that the move away from fair value is being driven by conviction rather than mechanical order flow. This suggests the deviation will likely extend further, creating continuation trading opportunities. Conversely, when price deviates from intrabar VWAP but volume flow shows reduced intensity or opposing direction despite the weighting, it suggests the deviation will revert to VWAP, creating mean reversion opportunities. The ATR normalization option makes the indicator values comparable across different volatility regimes and different instruments. Without normalization, a one-million share buy-sell imbalance might be significant for a low-volatility stock but trivial for a high-volatility cryptocurrency. By normalizing the delta by ATR, the indicator accounts for the typical price movement capacity of the instrument, making signal thresholds and comparison values meaningful across different trading contexts. This is particularly valuable for traders running the indicator on multiple instruments who want consistent signal quality regardless of the underlying instrument characteristics. The configurable decay factor allows traders to adjust how persistent they want volume flows to remain influential. For very short-term scalping, a lower decay factor like zero point five will cause volume imbalances to dissipate quickly, keeping the indicator focused only on very recent flows. For longer-term position trading, a higher decay factor like zero point nine-five will allow significant volume events to influence the indicator for many bars, revealing longer-term accumulation and distribution patterns. This flexibility makes the single indicator adaptable to trading styles ranging from one-minute scalping to daily chart position trading simply by adjusting the decay parameter and the lookback bars. The minimum imbalance percentage setting provides crucial noise filtering that can be optimized per instrument. Highly liquid instruments with tight spreads might show numerous small imbalances that are meaningless, requiring a higher threshold like thirty-five or forty percent to filter noise effectively. Thinly traded instruments might rarely show extreme imbalances, requiring a lower threshold like fifteen or twenty percent to generate adequate signals. By making this threshold user-configurable with a wide range, the indicator accommodates the full spectrum of market microstructure characteristics across different instruments and timeframes. In conclusion, the Intrabar Volume Flow Intelligence indicator represents a comprehensive volume analysis system that combines intrabar data access, sophisticated volume attribution algorithms, multi-timeframe smoothing, statistical filtering, divergence detection, zone identification, and intelligent signal scoring into a cohesive analytical framework. It provides traders with visibility into market dynamics that are invisible to price-only analysis and even to conventional volume analysis, revealing the true intentions of market participants through their actual transaction behavior within each bar. The indicator's strength lies not in any single feature but in the integration of multiple analytical layers that confirm and validate each other, creating high-probability signal generation that can form the foundation of complete trading systems or provide powerful confirmation for discretionary analysis. For traders willing to invest time in understanding its components and optimizing its parameters for their specific instruments and timeframes, this indicator offers a significant informational advantage in increasingly competitive markets where edge is derived from seeing what others miss and acting on that information before it becomes consensus.
Pine Script® göstergesi
jaydesaigu tarafından
Iridescent Liquidity Prism [JOAT]Iridescent Liquidity Prism | Peer Momentum HUD A multi-layered order-flow indicator that combines microstructure analysis, smart-money footprint detection, and intermarket momentum signals. The script uses dynamic color-shifting themes to visualize liquidity patterns, structure, and peer momentum data directly on the chart. There is so much to choose from inside the settings, if you think it's a mess on the chart it's because you have to personally customize it based on your needs... Core Functionality The indicator calculates and displays several analytical layers simultaneously: Order-Flow Imbalance (OFI): Calculates buy vs. sell volume pressure using volume-weighted price distribution within each bar. Uses an EMA filter (default: 55 periods) to smooth the signal. Values are normalized using standard deviation to identify significant imbalances. Smart Money Footprints: Detects accumulation and distribution zones by comparing volume rate of change (ROC) against price ROC. When volume ROC exceeds a threshold (default: 65%) and price ROC is positive, accumulation is detected. When volume ROC is high but price ROC is negative, distribution is detected. Fractal Structure Mapping: Identifies pivot highs and lows using a fractal detection algorithm (default: 5-bar period). Maintains a rolling window of recent structure points (default: 4 levels) and draws connecting lines to show trend structure. Fair Value Gap (FVG) Detection: Automatically detects price gaps where three consecutive candles create an imbalance. Bullish FVGs occur when the current low exceeds the high two bars ago. Bearish FVGs occur when the current high is below the low two bars ago. Gaps persist for a configurable duration (default: 320 bars) and fade when price fills the gap. Liquidity Void Detection: Identifies candles where the high-low range exceeds an ATR threshold (default: 1.7x ATR) while volume is below average (default: 65% of 20-bar average). These conditions suggest areas where liquidity may be thin. Price/Volume Divergence: Uses linear regression to detect when price trend direction disagrees with volume trend direction. A divergence alert appears when price is trending up while volume is trending down, or vice versa. Peer Momentum Heatmap (PMH): Calculates composite momentum scores for up to 6 symbols across 4 timeframes. Each score combines RSI (default: 14 periods) and StochRSI (default: 14 periods, 3-bar smooth) to create a momentum composite between -1 and +1. The highest absolute momentum score across all combinations is displayed in the HUD. Custom settings using Fractal Pivots, Skeleton Structure, Pulse Liquidity Voids, Bottom Colorful HeatMaps, and Iridescent Field. --- Visual Components Spectrum Aura Glow: ATR-weighted bands (default: 0.25x ATR) that expand and contract around price action, indicating volatility conditions. The thickness adapts to market volatility. Chromatic Flow Trail: A blended line combining EMA and WMA of price (default: 8-period EMA blended with WMA at 65% ratio). The trail uses gradient colors that shift based on a phase oscillator, creating an iridescent effect. Volume Heat Projection: Creates horizontal volume profile bands at price levels (default: 14 levels). Scans recent bars (default: 150 bars) to calculate volume concentration. Each level is colored based on its volume density relative to the maximum volume level. Structure Skeleton: Dashed lines connecting fractal pivot points. Uses two layers: a primary line (2-3px width) and an optional glow overlay (4-5px width) for enhanced visibility. Fractal Markers: Diamond shapes placed at pivot high and low points. Color-coded: primary color for highs, secondary color for lows. Iridescent Color Themes: Five color themes available: Iridescent (default), Pearlescent, Prismatic, ColorShift, and Metallic. Colors shift dynamically using a phase oscillator that cycles through the color spectrum based on bar index and a speed multiplier (default: 0.35). --- HUD Console Metrics The right-side HUD displays seven key metrics: Flow: Shows OFI status: ▲ FLOW BUY when normalized OFI exceeds imbalance threshold (default: 2.2), ▼ FLOW SELL when below -2.2, or ◆ FLOW BAL when balanced. Struct: Structure trend bias: ▲ STRUCT BULL when microtrend > 2, ▼ STRUCT BEAR when < -2, or ◆ STRUCT RANGE when neutral. Smart$: Institutional activity: ◈ ACCUM when smart money index = 1, ◈ DISTRIB when = -1, or ○ IDLE when inactive. Liquid: Liquidity state: ⚡ VOID when a liquidity void is detected, or ● NORMAL otherwise. Diverg: Divergence status: ⚠ ALERT when price/volume divergence detected, or ✓ CLEAR when aligned. PMH: Peer Momentum Heatmap status: Shows dominant timeframe and momentum score. Displays 🪩 for bull surge (above 0.55 threshold) or 🧨 for bear surge (below -0.55). FVG: Fair Value Gap status: Shows active gap count or CLEAR when no gaps exist. Displays GAP LONG when bullish gap detected, GAP SHORT when bearish gap detected. Pearlscent Color with Volume Heatmap. Parameters and Settings Microstructure Engine: Analysis Depth: 20-250 bars (default: 55) - Controls OFI smoothing period Liquidity Threshold ATR: 1.0-4.0 (default: 1.7) - Multiplier for void detection Imbalance Ratio: 1.5-6.0 (default: 2.2) - Standard deviations for OFI significance Smart Money Layer: Smart Money Window: 10-150 bars (default: 24) - Period for ROC calculations Accumulation Threshold: 40-95% (default: 65%) - Volume ROC threshold Structural Mapping: Fractal Pivot Period: 3-15 bars (default: 5) - Period for pivot detection Structure Memory: 2-8 levels (default: 4) - Number of structure points to track Volume Heat Projection: Heat Map Lookback: 60-400 bars (default: 150) - Bars to analyze for volume profile Heat Map Levels: 5-30 levels (default: 14) - Number of price level bands Heat Map Opacity: 40-100% (default: 92%) - Transparency of heat map boxes Heat Map Width Limit: 6-80 bars (default: 26) - Maximum width of heat map boxes Heat Map Visibility Threshold: 0.0-0.5 (default: 0.08) - Minimum density to display Iridescent Enhancements: Visual Theme: Iridescent, Pearlescent, Prismatic, ColorShift, or Metallic Color Shift Speed: 0.05-1.00 (default: 0.35) - Speed of color phase oscillation Aura Thickness (ATR): 0.05-1.0 (default: 0.25) - Multiplier for aura band width Chromatic Trail Length: 2-50 bars (default: 8) - Period for trail calculation Trail Blend Ratio: 0.1-0.95 (default: 0.65) - EMA/WMA blend percentage FVG Persistence: 50-600 bars (default: 320) - Bars to keep FVG boxes active Max Active FVG Boxes: 10-200 (default: 40) - Maximum boxes on chart FVG Base Opacity: 20-95% (default: 80%) - Transparency of FVG boxes Peer Momentum Heatmap: Peer Symbols: Comma-separated list of up to 6 symbols (e.g., "BTCUSD,ETHUSD") Peer Timeframes: Comma-separated list of up to 4 timeframes (default: "60,240,D") PMH RSI Length: 5-50 periods (default: 14) PMH StochRSI Length: 5-50 periods (default: 14) PMH StochRSI Smooth: 1-10 periods (default: 3) Super Momentum Threshold: 0.2-0.95 (default: 0.55) - Threshold for surge detection Clarity & Readability: Liquidity Void Opacity: 5-90% (default: 30%) Smart Money Footprint Opacity: 5-90% (default: 35%) HUD Background Opacity: 40-95% (default: 70%) Iridescent Field: Field Opacity: 20-100% (default: 86%) - Background color intensity Field Smooth Length: 10-200 bars (default: 34) - Smoothing for background gradient --- Alerts The indicator provides seven alert conditions: Liquidity Void Detected - Triggers when void conditions are met Strong Order Flow - Triggers when normalized OFI exceeds imbalance ratio Smart Money Activity - Triggers when accumulation or distribution detected Price/Volume Divergence - Triggers when divergence conditions occur Structure Shift - Triggers when structure polarity changes significantly PMH Bull Surge - Triggers when PMH exceeds positive threshold (if enabled) PMH Bear Surge - Triggers when PMH exceeds negative threshold (if enabled) Bull/Bear Prismatic FVG - Triggers when new FVG is detected (if FVG display enabled) --- Usage Considerations Performance may vary on lower timeframes due to the volume heat map calculations scanning multiple bars. Consider reducing heat map lookback or levels if experiencing slowdowns. The PMH feature requires data requests to other symbols/timeframes, which may impact performance. Limit the number of peer symbols and timeframes for optimal performance. FVG boxes automatically expire after the persistence period to prevent chart clutter. The maximum box limit (default: 40) prevents excessive memory usage. Color themes affect all visual elements. Choose a theme that provides good contrast with your chart background. The indicator is designed for overlay display. All visual elements are positioned relative to price action. Structure lines are drawn dynamically as new pivots form. On fast-moving markets, structure may update frequently. Volume calculations assume typical volume data availability. Symbols without volume may show incomplete data for volume-dependent features. --- Technical Notes Built on Pine Script v6 with dynamic request capability for PMH functionality. Uses exponential moving averages (EMA) and weighted moving averages (WMA) for trail calculations to balance responsiveness and smoothness. Volume profile calculation uses price level buckets. Higher levels provide finer granularity but require more computation. Iridescent color engine uses a phase oscillator with sine wave calculations for smooth color transitions. Box management includes automatic cleanup of expired boxes to maintain performance. All visual elements use color gradients and transparency for smooth blending with price action. --- Customization Examples Intraday Scalping Setup: Analysis Depth: 30 bars Heat Map Lookback: 100 bars FVG Persistence: 150 bars PMH Window: 15 bars Fast color shift speed: 0.5+ Macro Structure Tracking: Analysis Depth: 100+ bars Heat Map Lookback: 300+ bars FVG Persistence: 500+ bars Structure Memory: 6-8 levels Slower color shift speed: 0.2 --- Limitations Volume heat map calculations may be computationally intensive on lower timeframes with high lookback values. PMH requires valid symbol names and accessible timeframes. Invalid symbols or timeframes will return no data. FVG detection requires at least 3 bars of history. Early bars may not show FVG boxes. Structure lines connect points but do not predict future structure. They reflect historical pivot relationships. Color themes are aesthetic choices and do not affect calculation logic. The indicator does not provide trading signals. All visual elements are analytical tools that require interpretation in context of market conditions. Open Source This indicator is open source and available for modification and distribution. The code is published with Pine Script v6 compliance. Users are free to customize parameters, modify calculations, and adapt the visual elements to their trading needs. For questions, suggestions, or anything please talk to me in private messages or comments below! Would love to help! - officialjackofalltrades
Pine Script® göstergesi
officialjackofalltrades tarafından
1
On Balance Volume [BrightSideTrading] # On Balance Volume - Complete User Guide ## Overview This enhanced OBV indicator provides clean, actionable volume analysis with intelligent signal filtering. It combines On-Balance Volume (OBV) with a smoothed signal line to identify shifts in buying and selling pressure without chart clutter. **Key Features:** - Real-time OBV and signal line visualization - Smart crossover detection with confirmation filtering - Z-Score momentum analysis - Customizable signal alerts with V-shaped markers - Window-normalized option for detrended analysis --- ## What is On-Balance Volume (OBV)? OBV is a volume-based momentum indicator that accumulates volume on up days and subtracts volume on down days. It answers a fundamental question: **Is volume flowing in (buying) or out (selling)?** **Formula:** - If Close > Previous Close: OBV = Previous OBV + Volume - If Close < Previous Close: OBV = Previous OBV - Volume - If Close = Previous Close: OBV = Previous OBV (unchanged) **What it tells you:** - **Rising OBV** = Accumulation (smart money buying) - **Falling OBV** = Distribution (smart money selling) - **OBV above zero line** = Net positive buying pressure - **OBV below zero line** = Net negative selling pressure --- ## Interface & Settings ### **MAIN VISUALIZATION** **OBV Line (Green/Red Ribbon)** - Green when OBV is above the signal line (bullish trend) - Red when OBV is below the signal line (bearish trend) - Toggles between window-normalized (detrended) and raw values **Signal Line (Orange)** - Smoothed average of OBV - Crossovers with OBV generate buy/sell signals - Default: 21-period SMA **V-Shaped Markers** - Green upward V = Bullish crossover (buy signal) - Red downward V = Bearish crossover (sell signal) - Appears at the OBV value when signal is triggered **Zero Line (Yellow)** - Center equilibrium point for volume balance - Acts as support/resistance for OBV - Separates buying pressure (above) from selling pressure (below) --- ### **SOURCE GROUP** **Source** - **Default:** Close - **Options:** Open, High, Low, or any custom value - Controls which price value triggers OBV direction changes - Most traders use Close for standard OBV calculation --- ### **SIGNAL SMOOTHING GROUP** **Show Signal?** - **Default:** ON - Toggle visibility of the signal line - Disable if you prefer to see raw OBV only **Smoothing Type** - **SMA (Simple Moving Average)** - Default, standard smoothing - **EMA (Exponential Moving Average)** - Faster response, weights recent bars more heavily - **Choose SMA** for consistent, traditional OBV signals - **Choose EMA** for faster trend identification (more whipsaws possible) **Smoothing Length** - **Default:** 21 bars - **Range:** 1-200 bars - **Lower values** (5-14): Faster signals, more noise - **Higher values** (30-50): Slower signals, fewer false alarms - **Recommendation:** Use 21-25 for most timeframes --- ### **SIGNAL FILTERING GROUP** This is your primary control for signal quality and frequency. **Show Signal Markers?** - **Default:** ON - Toggle the V-shaped buy/sell markers on/off - Disable if markers distract from your analysis **Signal Filter Type** - **None** - Shows every single crossover (noisy, best for skilled traders) - **Confirmation Bars** - Waits N bars before confirming signal (recommended) - **Strength-Based** - Only signals during strong momentum (filters weakest moves) #### **CONFIRMATION BARS MODE** (Recommended) Best for reducing false signals while staying responsive to real moves. **Confirmation Bars** - **Default:** 2 bars - **Range:** 1-10 bars - Waits for the signal to hold for N consecutive bars after crossover - **Setting 1:** Every crossover (same as "None") - **Setting 2:** Wait 1 bar confirmation (good balance) - **Setting 3:** Wait 2 bars confirmation (filters 50% of noise) - **Setting 4+:** Very selective, misses quick reversals **How it works:** 1. OBV crosses signal line → Confirmation counter starts 2. If OBV stays on correct side for 2 bars → V-marker appears 3. If OBV crosses back → Counter resets, no signal #### **STRENGTH-BASED MODE** Only signals when momentum is statistically significant. **Min Z-Score Strength** - **Default:** 0.3 - **Range:** 0.0-3.0 - Requires OBV deviation from its mean to reach this threshold - **Setting 0.1-0.3:** More signals, lower quality - **Setting 0.5-0.8:** Moderate signals, good quality - **Setting 1.0+:** Only the strongest momentum shifts **How it works:** - Calculates how far OBV is from its 50-bar average (Z-score) - Only shows signals when this distance is meaningful - Automatically avoids weak, choppy market conditions --- ### **VISUALS & COLORS GROUP** **Highlight Crossovers?** - **Default:** ON - Master toggle for all signal markers - Turn OFF to see only the OBV/signal lines **Apply Ribbon Filling?** - **Default:** ON - Colors the space between OBV and signal line - Green fill = OBV above signal (bullish) - Red fill = OBV below signal (bearish) - Provides clear visual trend confirmation - Turn OFF for minimal chart clutter --- ### **STATS & ZONES GROUP** **Use Window-Normalized OBV (visual only)?** - **Default:** ON - Removes long-term trend from OBV for clearer short-term signals - Detrends the indicator to highlight recent momentum changes - **ON:** Better for swing trading and identifying reversals - **OFF:** Better for trend-following strategies - Note: Z-Score always uses raw OBV for statistical accuracy **OBV Normalize Window** - **Default:** 200 bars - Lookback period for detrending calculation - Larger values = more aggressive detrending - Adjust if you want OBV to oscillate more/less around zero **Show Z-Score (OBV)?** - **Default:** ON - Displays statistical momentum indicator below main chart - Ranges from -3 to +3 (most data within -2 to +2) - High Z-Score = Strong buying momentum - Low Z-Score = Strong selling momentum **Z-Score Lookback** - **Default:** 50 bars - Period for calculating Z-Score mean and standard deviation - Larger = smoother Z-Score, slower response - Smaller = noisier Z-Score, faster response **Show ROC (OBV Momentum)?** - **Default:** OFF - Rate of Change indicator for OBV velocity - Useful for identifying momentum turning points - Enable if you want to see speed of volume changes **ROC Lookback** - **Default:** 14 bars - Period for ROC calculation **Show Z-Score StdDev Zones?** - **Default:** ON - Shaded regions around zero line showing statistical boundaries - Inner Zone (±1 Z) = Normal variation - Outer Zone (±2 Z) = Extreme moves, potential reversals - Helps identify overbought/oversold volume conditions **Inner Zone (±Z)** - **Default:** 1.0 - First boundary for standard deviation zones - Most normal trading occurs within ±1 **Outer Zone (±Z)** - **Default:** 2.0 - Second boundary for extreme conditions - Crossing these zones indicates significant momentum shift --- ## Trading Strategy Examples ### **Strategy 1: Signal Line Crossovers (Beginner)** **Setup:** - Signal Filter Type: **Confirmation Bars** - Confirmation Bars: **2-3** - Show Signal Markers: **ON** **Rules:** 1. **BUY signal** (green V): When OBV crosses above signal line and holds for 2-3 bars - Confirms buying pressure is building - Look for price to follow within 1-3 bars 2. **SELL signal** (red V): When OBV crosses below signal line and holds for 2-3 bars - Confirms selling pressure is increasing - Expect price decline 3. **Exit:** Take profits at next signal or use price support/resistance **Best For:** Swing trading, intraday reversals, timeframes 5m-1h --- ### **Strategy 2: Zero Line Bounce (Intermediate)** **Setup:** - Signal Filter Type: **Strength-Based** - Min Z-Score Strength: **0.5** - Show Z-Score StdDev Zones: **ON** **Rules:** 1. **Watch OBV approach zero line** during established trends - OBV bouncing repeatedly off zero = trend is healthy - OBV breaking through zero = trend reversal imminent 2. **Enter on bounce:** Buy when OBV bounces from zero line in uptrend 3. **Exit on break:** Close position when OBV breaks below zero line 4. **Confirm with Z-Score:** Only take trades when Z-Score shows momentum (|Z| > 0.5) **Best For:** Trend traders, identifying trend strength, medium timeframes 15m-4h --- ### **Strategy 3: Momentum Extremes (Advanced)** **Setup:** - Signal Filter Type: **None** - Show Z-Score StdDev Zones: **ON** - Outer Zone: **2.0** **Rules:** 1. **Identify extremes:** When Z-Score breaks outer zone (±2.0) - Indicator is in extreme territory - Likely overextended 2. **Fade extremes:** Take opposite position when Z-Score hits extreme - High Z (>2.0) = OBV overbought, expect pullback - Low Z (<-2.0) = OBV oversold, expect bounce 3. **Confirm:** Wait for crossover signal to enter 4. **Target:** Outer zone of opposite side or zero line **Best For:** Range trading, mean reversion, experienced traders only --- ## Reading the Indicator in Different Markets ### **Strong Uptrend** - OBV consistently above signal line (green) - OBV well above zero line, rising higher lows - Z-Score positive, trending upward - **Action:** Buy dips to signal line, sell at resistance ### **Strong Downtrend** - OBV consistently below signal line (red) - OBV well below zero line, making lower highs - Z-Score negative, trending downward - **Action:** Sell rallies to signal line, cover at support ### **Consolidation/Choppy Market** - OBV whipsaws around signal line frequently - Crossovers occur every few bars - Z-Score oscillating between -1 and +1 - **Action:** Increase confirmation bars to 3-4, or switch to strength-based filter ### **Accumulation (Bottom Formation)** - OBV rising while price is flat or falling - Volume flowing in despite downtrend (bullish divergence) - Z-Score climbing while price lows hold - **Action:** Expect breakout up; prepare buy near support ### **Distribution (Top Formation)** - OBV falling while price is flat or rising - Volume flowing out despite uptrend (bearish divergence) - Z-Score falling while price continues higher - **Action:** Expect breakdown down; prepare short near resistance --- ## Parameter Tuning Guide ### **Aggressive Settings (More Signals)** - Smoothing Length: 14 - Signal Filter: None or Confirmation Bars: 1 - Min Z-Score: 0.1 - Best for: Day trading, high volatility stocks - Risk: More false signals ### **Balanced Settings (Recommended)** - Smoothing Length: 21 - Signal Filter: Confirmation Bars: 2 - Min Z-Score: 0.3 - Best for: Swing trading, most market conditions - Risk/Reward: Moderate ### **Conservative Settings (Fewer Signals)** - Smoothing Length: 30-40 - Signal Filter: Confirmation Bars: 3-4 or Strength-Based: 0.7+ - Min Z-Score: 0.8 - Best for: Position trading, high-conviction trades only - Risk: May miss some moves --- ## Common Questions & Troubleshooting **Q: Why are there more sell signals than buy signals?** A: This reflects the actual market action. Markets often decline faster than they rise (fear > greed). Confirm signals with price action and support/resistance. **Q: The indicator keeps whipsawing, should I hide it?** A: Increase Confirmation Bars to 3-4 or switch to Strength-Based filter. Market conditions matter—choppy markets require stricter filters. **Q: What's the difference between normalized and raw OBV?** A: Normalized (detrended) shows shorter-term momentum by removing long-term trends. Raw OBV shows absolute accumulation/distribution over the full period. Use normalized for swing signals, raw for trend confirmation. **Q: My signals come too late. How do I get faster entry?** A: Reduce Smoothing Length (try 14 instead of 21), use EMA instead of SMA, or set Confirmation Bars to 1. Trade-off: More false signals. **Q: Can I use this for day trading?** A: Yes, on 1m-5m charts with aggressive settings. Use Confirmation Bars: 1 and focus on Z-Score > 0.5 entries only. **Q: Should I trade every signal?** A: No. Filter signals using: price near support/resistance, multiple indicators confirming, and Z-Score showing momentum. Best signals occur at key levels. --- ## Best Practices 1. **Always confirm with price action:** OBV signals work best when price is near support, resistance, or moving average. Don't trade signals in a vacuum. 2. **Use volume context:** Check if volume is increasing or decreasing on the signal. Strong signals have volume confirmation (increasing volume on OBV spikes). 3. **Adjust settings per timeframe:** - 1m-5m: Smoothing 12, Confirmation 1, Z-Score 0.2 - 15m-1h: Smoothing 20, Confirmation 2, Z-Score 0.3 - 4h-1d: Smoothing 25, Confirmation 3, Z-Score 0.5 4. **Watch the zero line:** It's your friend. OBV behavior at the zero line reveals trend strength. Bounces = healthy trend. Breaks = reversal. 5. **Risk management:** No indicator is perfect. Use proper position sizing and stop losses. OBV should confirm your thesis, not be the only reason to trade. 6. **Combine with other indicators:** - Price moving averages for trend confirmation - RSI or Stochastic for overbought/oversold levels - Support/resistance for entry/exit zones - MACD for momentum divergences --- ## Disclaimer This indicator is for educational and informational purposes only. It is not financial advice. Past performance does not guarantee future results. Always conduct your own research and consult with a financial advisor before making trading decisions. Trading carries risk, including potential loss of principal. --- ## Version History **Version 1.0** - Initial release with enhanced signal filtering, Z-Score analysis, and customizable parameters.
Pine Script® göstergesi
bbosman129 tarafından