Inizia

Cerca negli script per "bar"

CandleAnalysisLibrary "CandleAnalysis" A collection of frequently used candle analysis functions in my scripts. isBullish(barsBack)   Checks if a specific bar is bullish.   Parameters:      barsBack (int) : (int) The number of bars to look back. The default is 0 (current bar).   Returns: True if the bar is bullish, otherwise returns false. isBearish(barsBack)   Checks if a specific bar is bearish.   Parameters:      barsBack (int) : (int) The number of bars to look back. The default is 0 (current bar).   Returns: True if the bar is bearish, otherwise returns false. isBE(barsBack)   Checks if a specific bar is break even.   Parameters:      barsBack (int) : (int) The number of bars to look back. The default is 0 (current bar).   Returns: True if the bar is break even, otherwise returns false. getBodySize(barsBack, inPriceChg)   Calculates a specific candle's body size.   Parameters:      barsBack (int) : (int) The number of bars to look back. The default is 0 (current bar).      inPriceChg (bool) : (bool) True to return the body size as a price change value. The default is false (in points).   Returns: The candle's body size in points. getTopWickSize(barsBack, inPriceChg)   Calculates a specific candle's top wick size.   Parameters:      barsBack (int) : (int) The number of bars to look back. The default is 0 (current bar).      inPriceChg (bool) : (bool) True to return the wick size as a price change value. The default is false (in points).   Returns: The candle's top wick size in points. getBottomWickSize(barsBack, inPriceChg)   Calculates a specific candle's bottom wick size.   Parameters:      barsBack (int) : (int) The number of bars to look back. The default is 0 (current bar).      inPriceChg (bool) : (bool) True to return the wick size as a price change value. The default is false (in points).   Returns: The candle's bottom wick size in points. getBodyPercent(barsBack)   Calculates a specific candle's body size as a percentage of its entire size including its wicks.   Parameters:      barsBack (int) : (int) The number of bars to look back. The default is 0 (current bar).   Returns: The candle's body size percentage. isHammer(fib, bullish, barsBack)   Checks if a specific bar is a hammer candle based on a given fibonacci level.   Parameters:      fib (float) : (float) The fibonacci level to base candle's body on. The default is 0.382.      bullish (bool) : (bool) True if the candle must to be green. The default is false.      barsBack (int) : (int) The number of bars to look back. The default is 0 (current bar).   Returns: True if the bar matches the requirements of a hammer candle, otherwise returns false. isShootingStar(fib, bearish, barsBack)   Checks if a specific bar is a shooting star candle based on a given fibonacci level.   Parameters:      fib (float) : (float) The fibonacci level to base candle's body on. The default is 0.382.      bearish (bool) : (bool) True if the candle must to be red. The default is false.      barsBack (int) : (int) The number of bars to look back. The default is 0 (current bar).   Returns: True if the bar matches the requirements of a shooting star candle, otherwise returns false. isDoji(wickSize, bodySize, barsBack)   Checks if a specific bar is a doji candle based on a given wick and body size.   Parameters:      wickSize (float) : (float) The maximum top wick size compared to the bottom and vice versa. The default is 1.5.      bodySize (float) : (bool) The maximum body size as a percentage compared to the entire candle size. The default is 5.      barsBack (int) : (int) The number of bars to look back. The default is 0 (current bar).   Returns: True if the bar matches the requirements of a doji candle. isBullishEC(gapTolerance, rejectionWickSize, engulfWick, barsBack)   Checks if a specific bar is a bullish engulfing candle.   Parameters:      gapTolerance (int)      rejectionWickSize (int) : (int) The maximum top wick size compared to the body as a percentage. The default is 10.      engulfWick (bool) : (bool) True if the engulfed candle's wick requires to be engulfed as well. The default is false.      barsBack (int) : (int) The number of bars to look back. The default is 0 (current bar).   Returns: True if the bar matches the requirements of a bullish engulfing candle. isBearishEC(gapTolerance, rejectionWickSize, engulfWick, barsBack)   Checks if a specific bar is a bearish engulfing candle.   Parameters:      gapTolerance (int)      rejectionWickSize (int) : (int) The maximum bottom wick size compared to the body as a percentage. The default is 10.      engulfWick (bool) : (bool) True if the engulfed candle's wick requires to be engulfed as well. The default is false.      barsBack (int) : (int) The number of bars to look back. The default is 0 (current bar).   Returns: True if the bar matches the requirements of a bearish engulfing candle.
Libreria Pine Script®
di ActiveQuants
MarcosLibraryLibrary "MarcosLibrary" A colection of frequently used functions in my scripts. bullFibRet(priceLow, priceHigh, fibLevel)   Calculates a bullish fibonacci retracement value.   Parameters:      priceLow (float) : (float) The lowest price point.      priceHigh (float) : (float) The highest price point.      fibLevel (float) : (float) The fibonacci level to calculate.   Returns: The fibonacci value of the given retracement level. bearFibRet(priceLow, priceHigh, fibLevel)   Calculates a bearish fibonacci retracement value.   Parameters:      priceLow (float) : (float) The lowest price point.      priceHigh (float) : (float) The highest price point.      fibLevel (float) : (float) The fibonacci level to calculate.   Returns: The fibonacci value of the given retracement level. bullFibExt(priceLow, priceHigh, thirdPivot, fibLevel)   Calculates a bullish fibonacci extension value.   Parameters:      priceLow (float) : (float) The lowest price point.      priceHigh (float) : (float) The highest price point.      thirdPivot (float) : (float) The third price point.      fibLevel (float) : (float) The fibonacci level to calculate.   Returns: The fibonacci value of the given extension level. bearFibExt(priceLow, priceHigh, thirdPivot, fibLevel)   Calculates a bearish fibonacci extension value.   Parameters:      priceLow (float) : (float) The lowest price point.      priceHigh (float) : (float) The highest price point.      thirdPivot (float) : (float) The third price point.      fibLevel (float) : (float) The fibonacci level to calculate.   Returns: The fibonacci value of the given extension level. isBullish(barsBack)   Checks if a specific bar is bullish.   Parameters:      barsBack (int) : (int) The number of bars to look back. The default is 0 (current bar).   Returns: True if the bar is bullish, otherwise returns false. isBearish(barsBack)   Checks if a specific bar is bearish.   Parameters:      barsBack (int) : (int) The number of bars to look back. The default is 0 (current bar).   Returns: True if the bar is bearish, otherwise returns false. isBE(barsBack)   Checks if a specific bar is break even.   Parameters:      barsBack (int) : (int) The number of bars to look back. The default is 0 (current bar).   Returns: True if the bar is break even, otherwise returns false. getBodySize(barsBack, inPriceChg)   Calculates a specific candle's body size.   Parameters:      barsBack (int) : (int) The number of bars to look back. The default is 0 (current bar).      inPriceChg (bool) : (bool) True to return the body size as a price change value. The default is false (in points).   Returns: The candle's body size in points. getTopWickSize(barsBack, inPriceChg)   Calculates a specific candle's top wick size.   Parameters:      barsBack (int) : (int) The number of bars to look back. The default is 0 (current bar).      inPriceChg (bool) : (bool) True to return the wick size as a price change value. The default is false (in points).   Returns: The candle's top wick size in points. getBottomWickSize(barsBack, inPriceChg)   Calculates a specific candle's bottom wick size.   Parameters:      barsBack (int) : (int) The number of bars to look back. The default is 0 (current bar).      inPriceChg (bool) : (bool) True to return the wick size as a price change value. The default is false (in points).   Returns: The candle's bottom wick size in points. getBodyPercent(barsBack)   Calculates a specific candle's body size as a percentage of its entire size including its wicks.   Parameters:      barsBack (int) : (int) The number of bars to look back. The default is 0 (current bar).   Returns: The candle's body size percentage. isHammer(fib, bullish, barsBack)   Checks if a specific bar is a hammer candle based on a given fibonacci level.   Parameters:      fib (float) : (float) The fibonacci level to base candle's body on. The default is 0.382.      bullish (bool) : (bool) True if the candle must to be green. The default is false.      barsBack (int) : (int) The number of bars to look back. The default is 0 (current bar).   Returns: True if the bar matches the requirements of a hammer candle, otherwise returns false. isShootingStar(fib, bearish, barsBack)   Checks if a specific bar is a shooting star candle based on a given fibonacci level.   Parameters:      fib (float) : (float) The fibonacci level to base candle's body on. The default is 0.382.      bearish (bool) : (bool) True if the candle must to be red. The default is false.      barsBack (int) : (int) The number of bars to look back. The default is 0 (current bar).   Returns: True if the bar matches the requirements of a shooting star candle, otherwise returns false. isDoji(wickSize, bodySize, barsBack)   Checks if a specific bar is a doji candle based on a given wick and body size.   Parameters:      wickSize (float) : (float) The maximum top wick size compared to the bottom and vice versa. The default is 1.5.      bodySize (float) : (bool) The maximum body size as a percentage compared to the entire candle size. The default is 5.      barsBack (int) : (int) The number of bars to look back. The default is 0 (current bar).   Returns: True if the bar matches the requirements of a doji candle. isBullishEC(gapTolerance, rejectionWickSize, engulfWick, barsBack)   Checks if a specific bar is a bullish engulfing candle.   Parameters:      gapTolerance (int)      rejectionWickSize (int) : (int) The maximum top wick size compared to the body as a percentage. The default is 10.      engulfWick (bool) : (bool) True if the engulfed candle's wick requires to be engulfed as well. The default is false.      barsBack (int) : (int) The number of bars to look back. The default is 0 (current bar).   Returns: True if the bar matches the requirements of a bullish engulfing candle. isBearishEC(gapTolerance, rejectionWickSize, engulfWick, barsBack)   Checks if a specific bar is a bearish engulfing candle.   Parameters:      gapTolerance (int)      rejectionWickSize (int) : (int) The maximum bottom wick size compared to the body as a percentage. The default is 10.      engulfWick (bool) : (bool) True if the engulfed candle's wick requires to be engulfed as well. The default is false.      barsBack (int) : (int) The number of bars to look back. The default is 0 (current bar).   Returns: True if the bar matches the requirements of a bearish engulfing candle.
Libreria Pine Script®
di ActiveQuants
Higher-timeframe requests█   OVERVIEW This publication focuses on enhancing awareness of the best practices for accessing higher-timeframe (HTF) data via the request.security() function. Some "traditional" approaches, such as what we explored in our previous `security()` revisited publication, have shown limitations in their ability to retrieve non-repainting HTF data. The fundamental technique outlined in this script is currently the most effective in preventing repainting when requesting data from a higher timeframe. For detailed information about why it works, see this section in the Pine Script™ User Manual . █   CONCEPTS Understanding repainting Repainting is a behavior that occurs when a script's calculations or outputs behave differently after restarting it. There are several types of repainting behavior, not all of which are inherently useless or misleading. The most prevalent form of repainting occurs when a script's calculations or outputs exhibit different behaviors on historical and realtime bars. When a script calculates across historical data, it only needs to execute once per bar, as those values are confirmed and not subject to change. After each historical execution, the script commits the states of its calculations for later access. On a realtime, unconfirmed bar, values are fluid . They are subject to change on each new tick from the data provider until the bar closes. A script's code can execute on each tick in a realtime bar, meaning its calculations and outputs are subject to realtime fluctuations, just like the underlying data it uses. Each time a script executes on an unconfirmed bar, it first reverts applicable values to their last committed states, a process referred to as rollback . It only commits the new values from a realtime bar after the bar closes. See the User Manual's Execution model page to learn more. In essence, a script can repaint when it calculates on realtime bars due to fluctuations before a bar's confirmation, which it cannot reproduce on historical data. A common strategy to avoid repainting when necessary involves forcing only confirmed values on realtime bars, which remain unchanged until each bar's conclusion. Repainting in higher-timeframe (HTF) requests When working with a script that retrieves data from higher timeframes with request.security() , it's crucial to understand the differences in how such requests behave on historical and realtime bars . The request.security() function executes all code required by its `expression` argument using data from the specified context (symbol, timeframe, or modifiers) rather than on the chart's data. As when executing code in the chart's context, request.security() only returns new historical values when a bar closes in the requested context. However, the values it returns on realtime HTF bars can also update before confirmation, akin to the rollback and recalculation process that scripts perform in the chart's context on the open bar. Similar to how scripts operate in the chart's context, request.security() only confirms new values after a realtime bar closes in its specified context. Once a script's execution cycle restarts, what were previously realtime bars become historical bars, meaning the request.security() call will only return confirmed values from the HTF on those bars. Therefore, if the requested data fluctuates across an open HTF bar, the script will repaint those values after it restarts. This behavior is not a bug; it's simply the default behavior of request.security() . In some cases, having the latest information from an unconfirmed HTF bar is precisely what a script needs. However, in many other cases, traders will require confirmed, stable values that do not fluctuate across an open HTF bar. Below, we explain the most reliable approach to achieve such a result. Achieving consistent timing on all bars One can retrieve non-fluctuating values with consistent timing across historical and realtime feeds by exclusively using request.security() to fetch the data from confirmed HTF bars. The best way to achieve this result is offsetting the `expression` argument by at least one bar (e.g., `close [1 ]`) and using barmerge.lookahead_on as the `lookahead` argument. We discourage the use of barmerge.lookahead_on alone since it prompts the function to look toward future values of HTF bars across historical data, which is heavily misleading. However, when paired with a requested `expression` that includes a one-bar historical offset, the "future" data the function retrieves is not from the future. Instead, it represents the last confirmed bar's values at the start of each HTF bar, thus preventing the results on realtime bars from fluctuating before confirmation from the timeframe. For example, this line of code uses a request.security() call with barmerge.lookahead_on to request the close price from the "1D" timeframe, offset by one bar with the history-referencing operator [ ] . This line will return the daily price with consistent timing across all bars: float htfClose = request.security(syminfo.tickerid, "1D", close , lookahead = barmerge.lookahead_on) Note that:  • This technique only works as intended for higher-timeframe requests .  • When designing a script to work specifically with HTFs, we recommend including conditions to prevent request.security() from accessing timeframes equal to or lower than the chart's timeframe, especially if you intend to publish it. In this script, we included an if structure that raises a runtime error when the requested timeframe is too small.  • A necessary trade-off with this approach is that the script must wait for an HTF bar's confirmation to retrieve new data on realtime bars, thus delaying its availability until the open of the subsequent HTF bar. The time elapsed during such a delay varies with each market, but it's typically relatively small. 👉 Failing to offset the function's `expression` argument while using barmerge.lookahead_on will produce historical results with lookahead bias , as it will look to the future states of historical HTF bars, retrieving values before the times at which they're available in the feed. See the `lookahead` and Future leak with `request.security()` sections in the Pine Script™ User Manual for more information. Evolving practices The fundamental technique outlined in this publication is currently the only reliable approach to requesting non-repainting HTF data with request.security() . It is the superior approach because it avoids the pitfalls of other methods, such as the one introduced in the `security()` revisited publication. That publication proposed using a custom `f_security()` function, which applied offsets to the `expression` and the requested result based on historical and realtime bar states. At that time, we explored techniques that didn't carry the risk of lookahead bias if misused (i.e., removing the historical offset on the `expression` while using lookahead), as requests that look ahead to the future on historical bars exhibit dangerously misleading behavior. Despite these efforts, we've unfortunately found that the bar state method employed by `f_security()` can produce inaccurate results with inconsistent timing in some scenarios, undermining its credibility as a universal non-repainting technique. As such, we've deprecated that approach, and the Pine Script™ User Manual no longer recommends it. █   METHOD VARIANTS In this script, all non-repainting requests employ the same underlying technique to avoid repainting. However, we've applied variants to cater to specific use cases, as outlined below: Variant 1 Variant 1, which the script displays using a lime plot, demonstrates a non-repainting HTF request in its simplest form, aligning with the concept explained in the "Achieving consistent timing" section above. It uses barmerge.lookahead_on and offsets the `expression` argument in request.security() by one bar to retrieve the value from the last confirmed HTF bar. For detailed information about why this works, see the Avoiding Repainting section of the User Manual's Other timeframes and data page. Variant 2 Variant 2 ( fuchsia ) introduces a custom function, `htfSecurity()`, which wraps the request.security() function to facilitate convenient repainting control. By specifying a value for its `repaint` parameter, users can determine whether to allow repainting HTF data. When the `repaint` value is `false`, the function applies lookahead and a one-bar offset to request the last confirmed value from the specified `timeframe`. When the value is `true`, the function requests the `expression` using the default behavior of request.security() , meaning the results can fluctuate across chart bars within realtime HTF bars and repaint when the script restarts. Note that:  • This function exclusively handles HTF requests. If the requested timeframe is not higher than the chart's, it will raise a runtime error .  • We prefer this approach since it provides optional repainting control. Sometimes, a script's calculations need to respond immediately to realtime HTF changes, which `repaint = true` allows. In other cases, such as when issuing alerts, triggering strategy commands, and more, one will typically need stable values that do not repaint, in which case `repaint = false` will produce the desired behavior. Variant 3 Variant 3 ( white ) builds upon the same fundamental non-repainting approach used by the first two. The difference in this variant is that it applies repainting control to tuples , which one cannot pass as the `expression` argument in our `htfSecurity()` function. Tuples are handy for consolidating `request.*()` calls when a script requires several values from the same context, as one can request a single tuple from the context rather than executing multiple separate request.security() calls. This variant applies the internal logic of our `htfSecurity()` function in the script's global scope to request a tuple containing open and `srcInput` values from a higher timeframe with repainting control. Historically, Pine Script™ did not allow the history-referencing operator [ ] when requesting tuples unless the tuple came from a function call, which limited this technique. However, updates to Pine over time have lifted this restriction, allowing us to pass tuples with historical offsets directly as the `expression` in request.security() . By offsetting all items in a tuple `expression` by one bar and using barmerge.lookahead_on , we effectively retrieve a tuple of stable, non-repainting HTF values. Since we cannot encapsulate this method within the `htfSecurity()` function and must execute the calculations in the global scope, the script's "Repainting" input directly controls the global `offset` and `lookahead` values to ensure it behaves as intended. Variant 4 (Control) Variant 4, which the script displays as a translucent orange plot, uses a default request.security() call, providing a reference point to compare the difference between a repainting request and the non-repainting variants outlined above. Whenever the script restarts its execution cycle, realtime bars become historical bars, and the request.security() call here will repaint the results on those bars. █   Inputs Repainting The "Repainting" input (`repaintInput` variable) controls whether Variant 2 and Variant 3 are allowed to use fluctuating values from an unconfirmed HTF bar. If its value is `false` (default), these requests will only retrieve stable values from the last confirmed HTF bar. Source The "Source" input (`srcInput` variable) determines the series the script will use in the `expression` for all HTF data requests. Its default value is close . HTF Selection This script features two ways to specify the higher timeframe for all its data requests, which users can control with the "HTF Selection" input (`tfTypeInput` variable):  1) If its value is "Fixed TF", the script uses the timeframe value specified by the "Fixed Higher Timeframe" input (`fixedTfInput` variable). The script will raise a runtime error if the selected timeframe is not larger than the chart's.  2) If the input's value is "Multiple of chart TF", the script multiplies the value of the "Timeframe Multiple" input (`tfMultInput` variable) by the chart's timeframe.in_seconds() value, then converts the result to a valid timeframe string via timeframe.from_seconds() . Timeframe Display This script features the option to display an "information box", i.e., a single-cell table that shows the higher timeframe the script is currently using. Users can toggle the display and determine the table's size, location, and color scheme via the inputs in the "Timeframe Display" group. █   Outputs This script produces the following outputs:  • It plots the results from all four of the above variants for visual comparison.  • It highlights the chart's background gray whenever a new bar starts on the higher timeframe, signifying when confirmations occur in the requested context.  • To demarcate which bars the script considers historical or realtime bars, it plots squares with contrasting colors corresponding to bar states at the bottom of the chart pane.  • It displays the higher timeframe string in a single-cell table with a user-specified size, location, and color scheme. Look first. Then leap.
Indicatore Pine Script®
di PineCoders
14
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
Libreria Pine Script®
di Trendoscope
2
AdxlLibrary "Adxl" Functions to calculate the Average Directional Index getDirectionUp(bar, lookback)   Bar high changed from open for bar   Parameters:      bar : series int The bar to calculate at      lookback : series int The lookback period   Returns: series float getDirectionDown(bar, lookback)   Bar low changed from open for bar   Parameters:      bar : series int The bar to calculate at      lookback : series int The lookback period   Returns: series float getPositiveDirectionalMovement(bar, lookback)   Positive directional movement for bar during lookback   Parameters:      bar : series int The bar to calculate at      lookback : series int The lookback period   Returns: series float getNegativeDirectionalMovement(bar, lookback)   Negative directional movement for bar during lookback   Parameters:      bar : series int The bar to calculate at      lookback : series int The lookback period   Returns: series float getTrueRangeMovingAverage(bar, lookback)   True range moving average for bar during lookback   Parameters:      bar : series int The bar to calculate at      lookback : simple int The lookback period   Returns: series int getDirectionUpIndex(bar, lookback)   Direction up index for bar during lookback   Parameters:      bar : series int The bar to calculate at      lookback : simple int The lookback period   Returns: series int getDirectionDownIndex(bar, lookback)   Direction down index for bar during lookback   Parameters:      bar : series int The bar to calculate at      lookback : simple int The lookback period   Returns: series int getTotalDirectionIndex(bar, lookback)   Total direction index for bar during lookback   Parameters:      bar : series int The bar to calculate at      lookback : simple int The lookback period   Returns: series int getAverageDirectionalIndex(bar, lookback)   Average Directional Index (ADX) for bar during lookback   Parameters:      bar : series int The bar to calculate at      lookback : simple int The lookback period   Returns: series int
Libreria Pine Script®
di antifragileer
Delta Volume Candles [LucF]█  OVERVIEW This indicator plots on-chart volume delta information using candles that can replace your normal candles, tops and bottoms appended to normal candles, optional MAs of those tops and bottoms levels, a divergence channel and a chart background. The indicator calculates volume delta using intrabar analysis, meaning that it uses the lower timeframe bars constituting each chart bar. █  CONCEPTS Volume Delta ​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 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 considerably limits the historical depth of charts and the number of symbols for which tick data is available. Furthermore, historical tick data is not yet available on TradingView. This indicator uses intrabar analysis to achieve a compromise between the simplest and most precise methods of calculating ​volume delta. It is currently the most precise method usable on TradingView 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 Delta Volume Channels and Volume Delta Columns Pro indicators also use intrabar analysis. Other ​volume delta indicators such as my Realtime 5D Profile use realtime chart updates to calculate volume delta without intrabar analysis, but that type of indicator only works in real time; they cannot calculate on historical bars. This is the logic I use to determine the polarity of intrabars, which determines the up or down slot where its ​volume is added:  • 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. Not all markets have volume information. Without it, this indicator is useless. Intrabar analysis Intrabars are chart bars at a lower timeframe than the chart's. The timeframe used to access intrabars determines the number of intrabars accessible for each chart bar. On a 1H chart, each chart bar of an active 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. This indicator automatically calculates an appropriate lower timeframe using the chart's timeframe and the settings you use in the script's "Intrabars" section of the inputs. As it can access lower timeframes as small as seconds when available, the indicator can be used on charts at relatively small timeframes such as 1min, provided the market is active enough to produce bars at second timeframes. The quantity of intrabars analyzed in each chart bar determines:  • The precision of calculations (more intrabars yield more precise results).  • The chart coverage of calculations (there is a 100K limit to the quantity of intrabars that can be analyzed on any chart,   so the more intrabars you analyze per chart bar, the less chart bars can be calculated by the indicator). The information box displayed at the bottom right of the chart shows the lower timeframe used for intrabars, as well as the average number of intrabars detected for chart bars and statistics on chart coverage. Balances This indicator calculates five balances from volume delta values. The balances are oscillators with a zero centerline; positive values are bullish, and negative values are bearish. It is important to understand the balances as they can be used to:  • Color candle bodies.  • Calculate body and top and bottom divergences.  • Color an EMA channel.  • Color the chart's background.  • Configure markers and alerts. The five balances are: 1 — Bar Balance : This is the only balance using instant values; it is simply the subtraction of the down volume​ from the up volume​ on the bar, so the instant volume delta for that bar. 2 — Average Balance : Calculates a distinct EMA for both the up and down volumes, and subtracts the down EMA from the up EMA.   The result is akin to MACD's histogram because it is the subtraction of two moving averages. 3 — Momentum Balance : Starts by calculating, separately for both up and down volumes, the difference between the same EMAs used in "Average Balance" and   an SMA of twice the period used for the "Average Balance" EMAs. The difference for the up side is subtracted from the difference for the down side,   and an RSI of that value is calculated and brought over the −50/+50 scale. 4 — Relative Balance : The reference values used in the calculation are the up and down EMAs used in the "Average Balance".   From those, we calculate two intermediate values using how much the instant up and down volumes on the bar exceed their respective EMA — but with a twist.   If the bar's up volume​ does not exceed the EMA of up volume​, a zero value is used. The same goes for the down volume​ with the EMA of down volume​.   Once we have our two intermediate values for the up and down volumes exceeding their respective MA, we subtract them. The final value is an ALMA of that subtraction.   The rationale behind using zero values when the bar's up/down volume​ does not exceed its EMA is to only take into account the more significant volume​.   If both instant volume​ values exceed their MA, then the difference between the two is the signal's value.   The signal is called "relative" because the intermediate values are the difference between the instant up/down volumes and their respective MA.   This balance flatlines when the bar's up/down volumes do not exceed their EMAs, which makes it useful to spot areas where trader interest dwindles, such as consolidations.   The smaller the period of the final value's ALMA, the more easily it will flatline. These flat zones should be considered no-trade zones. 5 — Percent Balance : This balance is the ALMA of the ratio of the "Bar Balance" over the total volume for that bar. From the balances and marker conditions, two more values are calculated: 1 — Marker Bias : This sums the up/down (+1/‒1) occurrences of the markers 1 to 4 over a period you define, so it ranges from −4 to +4, times the period.   Its calculation will depend on the modes used to calculate markers 3 and 4. 2 — Combined Balances : This is the sum of the bull/bear (+1/−1) states of each of the five balances, so it ranges from −5 to +5. The periods for all of these balances can be configured in the "Periods" section at the bottom of the script's inputs. As you cannot see the balances on the chart, you can use my Volume Delta Columns Pro indicator in a pane; it can plot the same balances, so you will be able to analyze them. Divergences In the context of this indicator, a divergence is any bar where the bear/bull state of a balance (above/below its zero centerline) diverges from the polarity of a chart bar. No directional bias is assigned to divergences when they occur. Candle bodies and tops/bottoms can each be colored differently on divergences detected from distinct balances. Divergence Channel The divergence channel is the space between two levels (by default, the bar's open and close ) saved when divergences occur. When price (by default the close ) 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 three different states:  • Bull (green): Price has breached the channel to the upside.  • Bear (red): Price has breached the channel to the downside.  • Neutral (gray): The channel has not yet been breached. █  HOW TO USE THE INDICATOR I do not make videos to explain how to use my indicators. I do, however, try hard to include in their description everything one needs to understand what they do. From there, it's up to you to explore and figure out if they can be useful in your trading practice. Communicating in videos what this description and the script's tooltips contain would make for very long videos that would likely exceed the attention span of most people who find this description too long. There is no quick way to understand an indicator such as this one because it uses many different concepts and has quite a bit of settings one can use to modify its visuals and behavior — thus how one uses it. I will happily answer questions on the inner workings of the indicator, but I do not answer questions like "How do I trade using this indicator?" A useful answer to that question would require an in-depth analysis of who you are, your trading methodology and objectives, which I do not have time for. I do not teach trading. Start by loading the indicator on an active chart containing volume information. See here if you need help. The default configuration displays:  • Normal candles where the bodies are only colored if the bar's volume has increased since the last bar.   If you want to use this indicator's candles, you may want to disable your chart's candles by clicking the eye icon to the right of the symbol's name in the top left of the chart.  • A top or bottom appended to the normal candles. It represents the difference between up and down volume for that bar   and is positioned at the top or bottom, depending on its polarity. If up volume is greater than down volume, a top is displayed. If down volume is greater, a bottom is plotted.   The size of tops and bottoms is determined by calculating a factor which is the proportion of volume delta over the bar's total volume.   That factor is then used to calculate the top or bottom size relative to a baseline of the average candle body size of the last 100 bars.  • An information box in the bottom right displaying intrabar and chart coverage information.  • A light red background when the intrabar volume differs from the chart's volume by more than 1%. The script's inputs contain tooltips explaining most of the fields. I will not repeat them here. Following is a brief description of each section of the indicator's inputs which will give you an idea of what the indicator can do: Normal Candles is where you configure the replacement candles plotted by the script. You can choose from different coloring schemes for their bodies and specify a unique color for bodies where a divergence calculated using the method you choose occurs. Volume Tops & Botttoms is where you configure the display of tops and bottoms, and their EMAs. The EMAs are calculated from the high point of tops and the low point of bottoms. They can act as a channel to evaluate price, and you can choose to color the channel using a gradient reflecting the advances/declines in the balance of your choice. Divergence Channel is where you set up the appearance and behavior of the divergence channel. These areas represent levels where price and volume delta information do not converge. They can be interpreted as regions with no clear direction from where one will look for breaches. You can configure the channel to take into account one or both types of divergences you have configured for candle bodies and tops/bottoms. Background allows you to configure a gradient background color that reflects the advances/declines in the balance of your choice. You can use this to provide context to the volume delta values from bars. You can also control the background color displayed on volume discrepancies between the intrabar and the chart's timeframe. Intrabars is where you choose the calculation mode determining the lower timeframe used to access intrabars. The indicator uses the chart's timeframe and the type of market you are on to calculate the lower timeframe. Your setting there should reflect which compromise you prefer between the precision of calculations and chart coverage. This is also where you control the display of the information box in the lower right corner of the chart. Markers allows you to control the plotting of chart markers on different conditions. Their configuration determines when alerts generated from the indicator will fire. Note that in order to generate alerts from this script, they must be created from your chart. See this Help Center page to learn how. Only the last 500 markers will be visible on the chart, but this will not affect the generation of alerts. Periods is where you configure the periods for the balances and the EMAs used in the indicator. The raw values calculated by this script can be inspected using the Data Window. █  INTERPRETATION Rightly or wrongly, volume delta is considered by many a useful complement to the interpretation of price action. I use it extensively in an attempt to find convergence between my read of volume delta and price movement — not so much as a predictor of future price movement. No system or person can predict the future. Accordingly, I consider people who speak or act as if they know the future with certainty to be dangerous to themselves and others; they are charlatans, imprudent or blissfully ignorant. I try to avoid elaborate volume delta interpretation schemes involving too many variables and prefer to keep things simple:  • Trends that have more chances of continuing should be accompanied by VD of the same polarity.   In trends, I am looking for "slow and steady". I work from the assumption that traders and systems often overreact, which translates into unproductive volatility.   Wild trends are more susceptible to overreactions.  • I prefer steady VD values over wildly increasing ones, as large VD increases often come with increased price volatility, which can backfire.   Large VD values caused by stopping volume will also often occur on trend reversals with abnormally high candles.  • Prices escaping divergence channels may be leading a trend in that direction, although there is no telling how long that trend will last; could be just a few bars or hundreds.   When price is in a channel, shifts in VD balances can sometimes give us an idea of the direction where price has the most chance of breaking.  • Dwindling VD will often indicate trend exhaustion and predate reversals by many bars, but the problem is that mere pauses in a trend will often produce the same behavior in VD.   I think it is too perilous to infer rigidly from VD decreases. Divergence Channel Here I have configured the divergence channels to be visible. First, I set the bodies to display divergences on the default Bar Balance. They are indicated by yellow bodies. Then I activated the divergence channels by choosing to draw levels on body divergences and checked the "Fill" checkbox to fill the channel with the same color as the levels. The divergence channel is best understood as a direction-less area from where a breach can be acted on if other variables converge with the breach's direction: Tops and Bottoms EMAs I find these EMAs rather interesting. They have no equivalent elsewhere, as they are calculated from the top and bottom values this indicator plots. The only similarity they have with volume-weighted MAs, including VWAP, is that they use price and volume. This indicator's Tops and Bottoms EMAs, however, use the price and volume delta. While the channel differs from other channels in how it is calculated, it can be used like others, as a baseline from which to evaluate price movement or, alternatively, as stop levels. Remember that you can change the period used for the EMAs in the "Periods" section of the inputs. This chart shows the EMAs in action, filled with a gradient representing the advances/decline from the Momentum balance. Notice the anomaly in the chart's latest bars where the Momentum balance gradient has been indicating a bullish bias for some time, during which price was mostly below the EMAs. Price has just broken above the channel on positive VD. My interpretation of this situation would be that it is a risky opportunity for a long trade in the larger context where the market has been in a downtrend since the 5th. Intrepid traders choosing to enter here could do so with a "make or break" tight stop that will minimize their losses should the market continue its downtrend while hopefully preserving the potential upside of price continuing on the longer-term uptrend prevalent since the 28th: █  NOTES Volume If you use indicators such as this one which depends on volume information, it is important to realize that the volume data they consume comes from data feeds, and that all data feeds are NOT created equally. Those who create the data feeds we use must make decisions concerning the nature of the transactions they tally and the way they are tallied in each feed, and these decisions affect the nature of our volume data. My Volume X-ray publication discusses some of the reasons why volume information from different timeframes, brokers/exchanges or sectors may vary considerably. I encourage you to read it. This indicator's display of a warning through a background color on volume discrepancies between the timeframe used to access intrabars and the chart's timeframe is an attempt to help you realize these variations in feeds. Don't take things for granted, and understand that the quality of a given feed's volume information affects the quality of the results this indicator calculates. Markets as ecosystems I believe it is perilous to think that behavioral patterns you discover in one market through the lens of this or any other indicator will necessarily port to other markets. While this may sometimes be the case, it will often not. Why is that? Because each market is its own ecosystem. As cities do, all markets share some common characteristics, but they also all have their idiosyncrasies. A proportion of a city's inhabitants is always composed of outsiders who come and go, but a core population of regulars and systems is usually the force that actually defines most of the city's observable characteristics. I believe markets work somewhat the same way; they may look the same, but if you live there for a while and pay attention, you will notice the idiosyncrasies. Some things that work in some markets will, accordingly, not work in others. Please keep that in mind when you draw conclusions. On Up/Down or Buy/Sell Volume Buying or selling volume are misnomers, as every unit of volume transacted is both bought and sold by two different traders. While this does not keep me from using the terms, there is no such thing as “buy only” or “sell only” volume. Trader lingo is riddled with peculiarities. Without access to order book information, traders work with the assumption that when price moves up during a bar, there was more buying pressure than selling pressure, just as when buy market orders take out limit ask orders in the order book at successively higher levels. The built-in volume indicator available on TradingView uses this logic to color the volume columns green or red. While this script’s calculations are more precise because it analyses intrabars to calculate its information, it uses pretty much the same imperfect logic. Until Pine scripts can have access to how much volume was transacted at the bid/ask prices, our volume delta calculations will remain a mere proxy. Repainting  • The values calculated on the realtime bar will update as new information comes from the feed.  • Historical values may recalculate if the historical feed is updated or when calculations start from a new point in history.  • Markers and alerts will not repaint as they only occur on a bar's close. Keep this in mind when viewing markers on historical bars,   where one could understandably and incorrectly assume they appear at the bar's open. To learn more about repainting, see the Pine Script™ User Manual's page on the subject . Superfluity In "The Bed of Procrustes", Nassim Nicholas Taleb writes: To bankrupt a fool, give him information . This indicator can display a lot of information. The inevitable adaptation period you will need to figure out how to use it should help you eliminate all the visuals you do not need. The more you eliminate, the easier it will be to focus on those that are the most useful to your trading practice. Don't be a fool. █  THANKS Thanks to alexgrover for his Dekidaka-Ashi indicator. His volume plots on candles were the inspiration for my top/bottom plots. Kudos to PineCoders for their libraries. I use two of them in this script: Time and lower_tf . The first versions of this script used functionality that I would not have known about were it not for these two guys: — A guy called Kuan who commented on a Backtest Rookies presentation of their Volume Profile indicator. — theheirophant , my partner in the exploration of the sometimes weird abysses of request.security() ’s behavior at lower timeframes.
Indicatore Pine Script®
di LucF
113
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.
Indicatore Pine Script®
di RayenGeeksdoByte
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)
Libreria Pine Script®
di goodia
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.
Libreria Pine Script®
di TanHef
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.
Indicatore Pine Script®
di starshiptrade
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.
Libreria Pine Script®
di jordanswinden
Volume Spread Analysis [TANHEF]Volume Spread Analysis: Understanding Market Intentions through the Interpretation of Volume and Price Movements. █ 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/or spread bars that consist of color coded levels. If both of these are displayed, the number of spread bars can be limited for visual appeal and understanding, with the spread bars scaled to match the volume bars. While automatic calculation of the number of visual bars for auto scaling is possible, it is avoided to prevent the indicator from reloading whenever the number of visual price bars on the chart is adjusted, ensuring uninterrupted analysis. 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: Display Volume and/or Spread: Choose between displaying volume bars, spread bars, or both with different lookback periods. 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.
Indicatore Pine Script®
di TanHef
23
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)
Indicatore Pine Script®
di LuxAlgo
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
Libreria Pine Script®
di CN_FX-999
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
Libreria Pine Script®
di liyugen
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.
Indicatore Pine Script®
di TradingView
55
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.
Indicatore Pine Script®
di LucF
50
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 ].
Libreria Pine Script®
di PineCoders
14
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()
Libreria Pine Script®
di Wheeelman
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.
Libreria Pine Script®
di SimpleCryptoLife
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.
Libreria Pine Script®
di TradingView
24
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.
Indicatore Pine Script®
di LucF
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.
Indicatore Pine Script®
di LucF
7