Começar

Indicadores e estratégias

ZigzagLiteLibrary "ZigzagLite" Lighter version of the Zigzag Library. Without indicators and sub-component divisions method getPrices(pivots)   Namespace types: array   Parameters:      pivots (array) method getBars(pivots)   Namespace types: array   Parameters:      pivots (array) method getPoints(pivots)   Namespace types: array   Parameters:      pivots (array) method getPoints(this)   Namespace types: Zigzag   Parameters:      this (Zigzag) method calculate(this, ohlc, ltfHighTime, ltfLowTime)   Namespace types: Zigzag   Parameters:      this (Zigzag)      ohlc (array)      ltfHighTime (int)      ltfLowTime (int) method calculate(this)   Namespace types: Zigzag   Parameters:      this (Zigzag) PivotCandle   PivotCandle represents data of the candle which forms either pivot High or pivot low or both   Fields:      _high (series float) : High price of candle forming the pivot      _low (series float) : Low price of candle forming the pivot      length (series int) : Pivot length      pHighBar (series int) : represents number of bar back the pivot High occurred.      pLowBar (series int) : represents number of bar back the pivot Low occurred.      pHigh (series float) : Pivot High Price      pLow (series float) : Pivot Low Price Pivot   Pivot refers to zigzag pivot.   Fields:      point (chart.point)      dir (series int)      level (series int)      ratio (series float)      sizeRatio (series float)      barRatio (series float) ZigzagFlags   Flags required for drawing zigzag.   Fields:      newPivot (series bool)      doublePivot (series bool)      updateLastPivot (series bool) Zigzag   Zigzag object which contains whole zigzag calculation parameters and pivots   Fields:      length (series int)      numberOfPivots (series int)      offset (series int)      level (series int)      zigzagPivots (array)      flags (ZigzagFlags) ZigzagObject   Zigzag Drawing Object   Fields:      zigzagLine (series line)      zigzagLabel (series label) ZigzagProperties   Object which holds properties of zigzag drawing.   Fields:      lineColor (series color)      lineWidth (series int)      lineStyle (series string)      showLabel (series bool)      textColor (series color)      maxObjects (series int)      xloc (series string)      curved (series bool)      force_overlay (series bool) ZigzagDrawing   Object which holds complete zigzag drawing objects and properties.   Fields:      zigzag (Zigzag)      properties (ZigzagProperties)      drawings (array) ZigzagDrawingPL   Object which holds complete zigzag drawing objects and properties - polyline version   Fields:      zigzag (Zigzag)      properties (ZigzagProperties)      zigzagLabels (array)      zigzagLine (series polyline)
Biblioteca Pine Script®
por ajitgorde121
arraysLibrary "arrays" Supplementary array methods. method delete(arr, index)   remove int object from array of integers at specific index   Namespace types: array   Parameters:      arr (array) : int array      index (int) : index at which int object need to be removed   Returns: void method delete(arr, index)   remove float object from array of float at specific index   Namespace types: array   Parameters:      arr (array) : float array      index (int) : index at which float object need to be removed   Returns: float method delete(arr, index)   remove bool object from array of bool at specific index   Namespace types: array   Parameters:      arr (array) : bool array      index (int) : index at which bool object need to be removed   Returns: bool method delete(arr, index)   remove string object from array of string at specific index   Namespace types: array   Parameters:      arr (array) : string array      index (int) : index at which string object need to be removed   Returns: string method delete(arr, index)   remove color object from array of color at specific index   Namespace types: array   Parameters:      arr (array) : color array      index (int) : index at which color object need to be removed   Returns: color method delete(arr, index)   remove chart.point object from array of chart.point at specific index   Namespace types: array   Parameters:      arr (array) : chart.point array      index (int) : index at which chart.point object need to be removed   Returns: void method delete(arr, index)   remove line object from array of lines at specific index and deletes the line   Namespace types: array   Parameters:      arr (array) : line array      index (int) : index at which line object need to be removed and deleted   Returns: void method delete(arr, index)   remove label object from array of labels at specific index and deletes the label   Namespace types: array   Parameters:      arr (array) : label array      index (int) : index at which label object need to be removed and deleted   Returns: void method delete(arr, index)   remove box object from array of boxes at specific index and deletes the box   Namespace types: array   Parameters:      arr (array) : box array      index (int) : index at which box object need to be removed and deleted   Returns: void method delete(arr, index)   remove table object from array of tables at specific index and deletes the table   Namespace types: array   Parameters:      arr (array) : table array      index (int) : index at which table object need to be removed and deleted   Returns: void method delete(arr, index)   remove linefill object from array of linefills at specific index and deletes the linefill   Namespace types: array   Parameters:      arr (array) : linefill array      index (int) : index at which linefill object need to be removed and deleted   Returns: void method delete(arr, index)   remove polyline object from array of polylines at specific index and deletes the polyline   Namespace types: array   Parameters:      arr (array) : polyline array      index (int) : index at which polyline object need to be removed and deleted   Returns: void method popr(arr)   remove last int object from array   Namespace types: array   Parameters:      arr (array) : int array   Returns: int method popr(arr)   remove last float object from array   Namespace types: array   Parameters:      arr (array) : float array   Returns: float method popr(arr)   remove last bool object from array   Namespace types: array   Parameters:      arr (array) : bool array   Returns: bool method popr(arr)   remove last string object from array   Namespace types: array   Parameters:      arr (array) : string array   Returns: string method popr(arr)   remove last color object from array   Namespace types: array   Parameters:      arr (array) : color array   Returns: color method popr(arr)   remove last chart.point object from array   Namespace types: array   Parameters:      arr (array) : chart.point array   Returns: void method popr(arr)   remove and delete last line object from array   Namespace types: array   Parameters:      arr (array) : line array   Returns: void method popr(arr)   remove and delete last label object from array   Namespace types: array   Parameters:      arr (array) : label array   Returns: void method popr(arr)   remove and delete last box object from array   Namespace types: array   Parameters:      arr (array) : box array   Returns: void method popr(arr)   remove and delete last table object from array   Namespace types: array   Parameters:      arr (array) : table array   Returns: void method popr(arr)   remove and delete last linefill object from array   Namespace types: array   Parameters:      arr (array) : linefill array   Returns: void method popr(arr)   remove and delete last polyline object from array   Namespace types: array   Parameters:      arr (array) : polyline array   Returns: void method shiftr(arr)   remove first int object from array   Namespace types: array   Parameters:      arr (array) : int array   Returns: int method shiftr(arr)   remove first float object from array   Namespace types: array   Parameters:      arr (array) : float array   Returns: float method shiftr(arr)   remove first bool object from array   Namespace types: array   Parameters:      arr (array) : bool array   Returns: bool method shiftr(arr)   remove first string object from array   Namespace types: array   Parameters:      arr (array) : string array   Returns: string method shiftr(arr)   remove first color object from array   Namespace types: array   Parameters:      arr (array) : color array   Returns: color method shiftr(arr)   remove first chart.point object from array   Namespace types: array   Parameters:      arr (array) : chart.point array   Returns: void method shiftr(arr)   remove and delete first line object from array   Namespace types: array   Parameters:      arr (array) : line array   Returns: void method shiftr(arr)   remove and delete first label object from array   Namespace types: array   Parameters:      arr (array) : label array   Returns: void method shiftr(arr)   remove and delete first box object from array   Namespace types: array   Parameters:      arr (array) : box array   Returns: void method shiftr(arr)   remove and delete first table object from array   Namespace types: array   Parameters:      arr (array) : table array   Returns: void method shiftr(arr)   remove and delete first linefill object from array   Namespace types: array   Parameters:      arr (array) : linefill array   Returns: void method shiftr(arr)   remove and delete first polyline object from array   Namespace types: array   Parameters:      arr (array) : polyline array   Returns: void method push(arr, val, maxItems)   add int to the end of an array with max items cap. Objects are removed from start to maintain max items cap   Namespace types: array   Parameters:      arr (array) : int array      val (int) : int object to be pushed      maxItems (int) : max number of items array can hold   Returns: int method push(arr, val, maxItems)   add float to the end of an array with max items cap. Objects are removed from start to maintain max items cap   Namespace types: array   Parameters:      arr (array) : float array      val (float) : float object to be pushed      maxItems (int) : max number of items array can hold   Returns: float method push(arr, val, maxItems)   add bool to the end of an array with max items cap. Objects are removed from start to maintain max items cap   Namespace types: array   Parameters:      arr (array) : bool array      val (bool) : bool object to be pushed      maxItems (int) : max number of items array can hold   Returns: bool method push(arr, val, maxItems)   add string to the end of an array with max items cap. Objects are removed from start to maintain max items cap   Namespace types: array   Parameters:      arr (array) : string array      val (string) : string object to be pushed      maxItems (int) : max number of items array can hold   Returns: string method push(arr, val, maxItems)   add color to the end of an array with max items cap. Objects are removed from start to maintain max items cap   Namespace types: array   Parameters:      arr (array) : color array      val (color) : color object to be pushed      maxItems (int) : max number of items array can hold   Returns: color method push(arr, val, maxItems)   add chart.point to the end of an array with max items cap. Objects are removed and deleted from start to maintain max items cap   Namespace types: array   Parameters:      arr (array) : chart.point array      val (chart.point) : chart.point object to be pushed      maxItems (int) : max number of items array can hold   Returns: chart.point method push(arr, val, maxItems)   add line to the end of an array with max items cap. Objects are removed and deleted from start to maintain max items cap   Namespace types: array   Parameters:      arr (array) : line array      val (line) : line object to be pushed      maxItems (int) : max number of items array can hold   Returns: line method push(arr, val, maxItems)   add label to the end of an array with max items cap. Objects are removed and deleted from start to maintain max items cap   Namespace types: array   Parameters:      arr (array) : label array      val (label) : label object to be pushed      maxItems (int) : max number of items array can hold   Returns: label method push(arr, val, maxItems)   add box to the end of an array with max items cap. Objects are removed and deleted from start to maintain max items cap   Namespace types: array   Parameters:      arr (array) : box array      val (box) : box object to be pushed      maxItems (int) : max number of items array can hold   Returns: box method push(arr, val, maxItems)   add table to the end of an array with max items cap. Objects are removed and deleted from start to maintain max items cap   Namespace types: array   Parameters:      arr (array) : table array      val (table) : table object to be pushed      maxItems (int) : max number of items array can hold   Returns: table method push(arr, val, maxItems)   add linefill to the end of an array with max items cap. Objects are removed and deleted from start to maintain max items cap   Namespace types: array   Parameters:      arr (array) : linefill array      val (linefill) : linefill object to be pushed      maxItems (int) : max number of items array can hold   Returns: linefill method push(arr, val, maxItems)   add polyline to the end of an array with max items cap. Objects are removed and deleted from start to maintain max items cap   Namespace types: array   Parameters:      arr (array) : polyline array      val (polyline) : polyline object to be pushed      maxItems (int) : max number of items array can hold   Returns: polyline method unshift(arr, val, maxItems)   add int to the beginning of an array with max items cap. Objects are removed from end to maintain max items cap   Namespace types: array   Parameters:      arr (array) : int array      val (int) : int object to be unshift      maxItems (int) : max number of items array can hold   Returns: int method unshift(arr, val, maxItems)   add float to the beginning of an array with max items cap. Objects are removed from end to maintain max items cap   Namespace types: array   Parameters:      arr (array) : float array      val (float) : float object to be unshift      maxItems (int) : max number of items array can hold   Returns: float method unshift(arr, val, maxItems)   add bool to the beginning of an array with max items cap. Objects are removed from end to maintain max items cap   Namespace types: array   Parameters:      arr (array) : bool array      val (bool) : bool object to be unshift      maxItems (int) : max number of items array can hold   Returns: bool method unshift(arr, val, maxItems)   add string to the beginning of an array with max items cap. Objects are removed from end to maintain max items cap   Namespace types: array   Parameters:      arr (array) : string array      val (string) : string object to be unshift      maxItems (int) : max number of items array can hold   Returns: string method unshift(arr, val, maxItems)   add color to the beginning of an array with max items cap. Objects are removed from end to maintain max items cap   Namespace types: array   Parameters:      arr (array) : color array      val (color) : color object to be unshift      maxItems (int) : max number of items array can hold   Returns: color method unshift(arr, val, maxItems)   add chart.point to the beginning of an array with max items cap. Objects are removed and deleted from end to maintain max items cap   Namespace types: array   Parameters:      arr (array) : chart.point array      val (chart.point) : chart.point object to be unshift      maxItems (int) : max number of items array can hold   Returns: chart.point method unshift(arr, val, maxItems)   add line to the beginning of an array with max items cap. Objects are removed and deleted from end to maintain max items cap   Namespace types: array   Parameters:      arr (array) : line array      val (line) : line object to be unshift      maxItems (int) : max number of items array can hold   Returns: line method unshift(arr, val, maxItems)   add label to the beginning of an array with max items cap. Objects are removed and deleted from end to maintain max items cap   Namespace types: array   Parameters:      arr (array) : label array      val (label) : label object to be unshift      maxItems (int) : max number of items array can hold   Returns: label method unshift(arr, val, maxItems)   add box to the beginning of an array with max items cap. Objects are removed and deleted from end to maintain max items cap   Namespace types: array   Parameters:      arr (array) : box array      val (box) : box object to be unshift      maxItems (int) : max number of items array can hold   Returns: box method unshift(arr, val, maxItems)   add table to the beginning of an array with max items cap. Objects are removed and deleted from end to maintain max items cap   Namespace types: array   Parameters:      arr (array) : table array      val (table) : table object to be unshift      maxItems (int) : max number of items array can hold   Returns: table method unshift(arr, val, maxItems)   add linefill to the beginning of an array with max items cap. Objects are removed and deleted from end to maintain max items cap   Namespace types: array   Parameters:      arr (array) : linefill array      val (linefill) : linefill object to be unshift      maxItems (int) : max number of items array can hold   Returns: linefill method unshift(arr, val, maxItems)   add polyline to the beginning of an array with max items cap. Objects are removed and deleted from end to maintain max items cap   Namespace types: array   Parameters:      arr (array) : polyline array      val (polyline) : polyline object to be unshift      maxItems (int) : max number of items array can hold   Returns: polyline method isEmpty(arr)   checks if an int array is either null or empty   Namespace types: array   Parameters:      arr (array) : int array   Returns: bool method isEmpty(arr)   checks if a float array is either null or empty   Namespace types: array   Parameters:      arr (array) : float array   Returns: bool method isEmpty(arr)   checks if a string array is either null or empty   Namespace types: array   Parameters:      arr (array) : string array   Returns: bool method isEmpty(arr)   checks if a bool array is either null or empty   Namespace types: array   Parameters:      arr (array) : bool array   Returns: bool method isEmpty(arr)   checks if a color array is either null or empty   Namespace types: array   Parameters:      arr (array) : color array   Returns: bool method isEmpty(arr)   checks if a chart.point array is either null or empty   Namespace types: array   Parameters:      arr (array) : chart.point array   Returns: bool method isEmpty(arr)   checks if a line array is either null or empty   Namespace types: array   Parameters:      arr (array) : line array   Returns: bool method isEmpty(arr)   checks if a label array is either null or empty   Namespace types: array   Parameters:      arr (array) : label array   Returns: bool method isEmpty(arr)   checks if a box array is either null or empty   Namespace types: array   Parameters:      arr (array) : box array   Returns: bool method isEmpty(arr)   checks if a linefill array is either null or empty   Namespace types: array   Parameters:      arr (array) : linefill array   Returns: bool method isEmpty(arr)   checks if a polyline array is either null or empty   Namespace types: array   Parameters:      arr (array) : polyline array   Returns: bool method isEmpty(arr)   checks if a table array is either null or empty   Namespace types: array   Parameters:      arr (array) : table array   Returns: bool method isNotEmpty(arr)   checks if an int array is not null and has at least one item   Namespace types: array   Parameters:      arr (array) : int array   Returns: bool method isNotEmpty(arr)   checks if a float array is not null and has at least one item   Namespace types: array   Parameters:      arr (array) : float array   Returns: bool method isNotEmpty(arr)   checks if a string array is not null and has at least one item   Namespace types: array   Parameters:      arr (array) : string array   Returns: bool method isNotEmpty(arr)   checks if a bool array is not null and has at least one item   Namespace types: array   Parameters:      arr (array) : bool array   Returns: bool method isNotEmpty(arr)   checks if a color array is not null and has at least one item   Namespace types: array   Parameters:      arr (array) : color array   Returns: bool method isNotEmpty(arr)   checks if a chart.point array is not null and has at least one item   Namespace types: array   Parameters:      arr (array) : chart.point array   Returns: bool method isNotEmpty(arr)   checks if a line array is not null and has at least one item   Namespace types: array   Parameters:      arr (array) : line array   Returns: bool method isNotEmpty(arr)   checks if a label array is not null and has at least one item   Namespace types: array   Parameters:      arr (array) : label array   Returns: bool method isNotEmpty(arr)   checks if a box array is not null and has at least one item   Namespace types: array   Parameters:      arr (array) : box array   Returns: bool method isNotEmpty(arr)   checks if a linefill array is not null and has at least one item   Namespace types: array   Parameters:      arr (array) : linefill array   Returns: bool method isNotEmpty(arr)   checks if a polyline array is not null and has at least one item   Namespace types: array   Parameters:      arr (array) : polyline array   Returns: bool method isNotEmpty(arr)   checks if a table array is not null and has at least one item   Namespace types: array   Parameters:      arr (array) : table array   Returns: bool method flush(arr)   remove all int objects in an array   Namespace types: array   Parameters:      arr (array) : int array   Returns: int method flush(arr)   remove all float objects in an array   Namespace types: array   Parameters:      arr (array) : float array   Returns: float method flush(arr)   remove all bool objects in an array   Namespace types: array   Parameters:      arr (array) : bool array   Returns: bool method flush(arr)   remove all string objects in an array   Namespace types: array   Parameters:      arr (array) : string array   Returns: string method flush(arr)   remove all color objects in an array   Namespace types: array   Parameters:      arr (array) : color array   Returns: color method flush(arr)   remove all chart.point objects in an array   Namespace types: array   Parameters:      arr (array) : chart.point array   Returns: chart.point method flush(arr)   remove and delete all line objects in an array   Namespace types: array   Parameters:      arr (array) : line array   Returns: line method flush(arr)   remove and delete all label objects in an array   Namespace types: array   Parameters:      arr (array) : label array   Returns: label method flush(arr)   remove and delete all box objects in an array   Namespace types: array   Parameters:      arr (array) : box array   Returns: box method flush(arr)   remove and delete all table objects in an array   Namespace types: array   Parameters:      arr (array) : table array   Returns: table method flush(arr)   remove and delete all linefill objects in an array   Namespace types: array   Parameters:      arr (array) : linefill array   Returns: linefill method flush(arr)   remove and delete all polyline objects in an array   Namespace types: array   Parameters:      arr (array) : polyline array   Returns: polyline
Biblioteca Pine Script®
por ajitgorde121
LineWrapperLibrary "LineWrapper" Wrapper Type for Line. Useful when you want to store the line details without drawing them. Can also be used in scenarios where you collect lines to be drawn and draw together towards the end. method draw(this)   draws line as per the wrapper object contents   Namespace types: Line   Parameters:      this (Line) : (series Line) Line object.   Returns: current Line object method draw(this)   draws lines as per the wrapper object array   Namespace types: array   Parameters:      this (array) : (series array) Array of Line object.   Returns: current Array of Line objects method update(this)   updates or redraws line as per the wrapper object contents   Namespace types: Line   Parameters:      this (Line) : (series Line) Line object.   Returns: current Line object method update(this)   updates or redraws lines as per the wrapper object array   Namespace types: array   Parameters:      this (array) : (series array) Array of Line object.   Returns: current Array of Line objects method delete(this)   Deletes the underlying line drawing object   Namespace types: Line   Parameters:      this (Line) : (series Line) Line object.   Returns: Current Line object method get_price(this, bar)   get line price based on bar   Namespace types: Line   Parameters:      this (Line) : (series Line) Line object.      bar (int) : (series/int) bar at which line price need to be calculated   Returns: line price at given bar. Line   Line Wrapper object   Fields:      p1 (chart.point)      p2 (chart.point)      xloc (series string) : (series string) See description of x1 argument. Possible values: xloc.bar_index and xloc.bar_time. Default is xloc.bar_index.      extend (series string) : (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) : (series color) Line color.      style (series string) : (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) : (series int) Line width in pixels.      obj (series line) : line object
Biblioteca Pine Script®
por ajitgorde121
ohlcLibrary "ohlc" Library having OHLC and Indicator type and method implementations. getOhlcArray(o, h, l, c, highBeforeLow, highAfterLow, lowBeforeHigh, lowAfterHigh, barindex, bartime, indicators)   get array of OHLC values when called on every bar   Parameters:      o (float) : Open price      h (float) : High Price      l (float) : Low Price      c (float) : Close Price      highBeforeLow (float) : to be calculated based on lower timeframe. high price attained within the candle before reaching the lowest point.      highAfterLow (float) : to be calculated based on lower timeframe. high price attained within the candle after reaching the lowest point.      lowBeforeHigh (float) : to be calculated based on lower timeframe. low price attained within the candle before reaching the highest point.      lowAfterHigh (float) : to be calculated based on lower timeframe. low price attained within the candle after reaching the highest point.      barindex (int) : bar_index of OHLC data      bartime (int) : time of OHLC cata      indicators (array) : array containing indicator   Returns: Array of OHLC objects push(this, item, maxItems)   Push items to OHLC array with maxItems limit   Parameters:      this (array)      item (OHLC) : OHLC Item to be pushed to the array      maxItems (int) : max Items the array can hold at a time   Returns: current object push(this, item, maxItems)   Push items to Indicator array with maxItems limit   Parameters:      this (array)      item (Indicator) : Indicator Item to be pushed to the array      maxItems (int) : max Items the array can hold at a time   Returns: current object unshift(this, item, maxItems)   Unshift items to OHLC array with maxItems limit   Parameters:      this (array)      item (OHLC) : OHLC Item to be unshifted to the array      maxItems (int) : max Items the array can hold at a time   Returns: current object unshift(this, item, maxItems)   Unshift items to Indicator array with maxItems limit   Parameters:      this (array)      item (Indicator) : Indicator Item to be unshifted to the array      maxItems (int) : max Items the array can hold at a time   Returns: current object method getPoints(indicators)   get array of points based on array of indicator values   Namespace types: array   Parameters:      indicators (array) : Array containing indicator objects   Returns: array of indicator points method plot(indicator, xloc, line_color, line_style, line_width)   plots an array of Indicator using polyline   Namespace types: array   Parameters:      indicator (array) : Array containing indicator objects      xloc (string) : can have values xloc.bar_index or xloc.bar_time. Used for drawing the line based on either bars or time.      line_color (color) : color in which the plots need to be printed on chart.      line_style (string) : line style line.style_solid, line.style_dotted, line.style_dashed, line.style_arrow_right, line.style_arrow_left, line.style_arrow_both      line_width (int) : width of the plot line   Returns: array of plot polyline Indicator   Object containing Indicator name and value   Fields:      name (series string) : Indicator Name      value (chart.point) : Indicator Value as a chart point OHLC   Object containing OHLC and indicator values   Fields:      o (series float) : Open price      h (series float) : High Price      l (series float) : Low Price      c (series float) : Close Price      highBeforeLow (series float) : to be calculated based on lower timeframe. high price attained within the candle before reaching the lowest point.      highAfterLow (series float) : to be calculated based on lower timeframe. high price attained within the candle after reaching the lowest point.      lowBeforeHigh (series float) : to be calculated based on lower timeframe. low price attained within the candle before reaching the highest point.      lowAfterHigh (series float) : to be calculated based on lower timeframe. low price attained within the candle after reaching the highest point.      barindex (series int) : bar_index of OHLC data      bartime (series int) : time of OHLC cata      indicators (array) : array containing indicator
Biblioteca Pine Script®
por ajitgorde121
utilsLibrary "utils" Few essentials captured together by ajitgorde121 timer(timeStart, timeEnd)   finds difference between two timestamps   Parameters:      timeStart (int) : start timestamp      timeEnd (int)   Returns: check_overflow(pivots, barArray, dir)   finds difference between two timestamps   Parameters:      pivots (array) : pivots array      barArray (array) : pivot bar array      dir (int) : direction for which overflow need to be checked   Returns: bool overflow get_trend_series(pivots, length, highLow, trend)   finds series of pivots in particular trend   Parameters:      pivots (array) : pivots array      length (int) : length for which trend series need to be checked      highLow (int) : filter pivot high or low      trend (int) : Uptrend or Downtrend   Returns: int trendIndexes get_trend_series(pivots, firstIndex, lastIndex)   finds series of pivots in particular trend   Parameters:      pivots (array) : pivots array      firstIndex (int) : First index of the series      lastIndex (int) : Last index of the series   Returns: int trendIndexes getConsolidatedLabel(include, labels, separator)   Consolidates labels into single string by concatenating it with given separator   Parameters:      include (array) : array of conditions to include label or not      labels (array) : string array of labels      separator (simple string) : Separator for concatenating labels   Returns: string labelText getColors(theme)   gets array of colors based on theme   Parameters:      theme (simple string) : dark or light theme   Returns: color themeColors
Biblioteca Pine Script®
por ajitgorde121
Input Library [1CG]Input Library (v1) – User Guide Overview The Input Library is a Pine Script® v6 utility library that standardizes and simplifies common user input patterns across indicators, strategies, and libraries. It provides: Predefined timezone enums mapped to IANA/Olson strings 24-hour and 60-minute enumerations Standardized line styles, sizes, label styles, and box alignment options Helper methods for converting enums into TradingView constants Utility functions for time formatting and span calculations This library is designed to: Reduce repetitive input boilerplate Improve UI consistency across scripts Prevent string-based input errors Encourage clean, readable configuration logic Library Declaration To use the library in your script: //@version=6 import OneCleverGuy/InputLibrary/1 as IL Timezone Enums Timezones Provides a comprehensive list of IANA timezone identifiers using short, intuitive enum names. Examples include: utc → "UTC" exch → Exchange timezone (syminfo.timezone) ny → "America/New_York" lon → "Europe/London" tokyo → "Asia/Tokyo" syd → "Australia/Sydney" Method: timezoneToString() Resolves the enum to a valid timezone string. tzString = tzInput.timezoneToString() Behavior: If Timezones.exch is selected, returns syminfo.timezone Otherwise returns the mapped IANA timezone string Time Formatting Enums hours Represents 24-hour values from "00" through "23". minutes Represents minute values from "00" through "59". Function: combineTime() Combines hour and minute enums into a "HHMM" formatted string. sessionTime = IL.combineTime(hourInput, minuteInput) Example output: "0930" "1600" Drawing Style Enums The library standardizes visual input options and converts them into TradingView constants. LineStyle solid dotted dashed lArrow rArrow bArrow Method: lineStyle() lineStyleValue = styleInput.lineStyle() LineSize thin → 1px normal → 2px heavy → 3px thick → 4px wide → 5px Method: lineSize() width = sizeInput.lineSize() TextSize auto tiny small normal large huge Method: textSize() textSizeValue = textSizeInput.textSize() Box Alignment Enums BoxHAlign left center right BoxVAlign top center bottom Methods: hAlign = hAlignInput.boxHAlign() vAlign = vAlignInput.boxVAlign() Line Extension LineExtend none right left both Method: lineExtend() extendValue = extendInput.lineExtend() Label Styles LabelStyle center down left right up lowLeft lowRight upperLeft upperRight Method: labelStyle() labelStyleValue = labelInput.labelStyle() String-Based Conversion Helpers For compatibility with legacy scripts or string inputs: lineStyleFromString() lineSizeFromString() These functions convert common string descriptions into valid TradingView constants. Timezone Offset Utility Function: getTZOffset() Calculates the difference between a specified timezone and UTC. offset = IL.getTZOffset("America/New_York") Returns: Millisecond difference between UTC and the specified timezone Accounts for daylight saving time Time Span Utility Function: timeSpan() Converts common span names into milliseconds. Supported values: "Minute" "Half Hour" "Hour" "4 Hours" "8 Hours" "12 Hours" "Day" "Week" Example: ms = IL.timeSpan("Hour") Best Practices Prefer enums over raw strings for safer configuration Use conversion methods directly on enum inputs Standardize visual settings across scripts using shared enums Avoid hardcoding timezone strings where possible Limitations timeSpan() supports predefined span names only getTZOffset() returns raw millisecond difference, not formatted hours Library does not enforce input validation beyond enum constraints Summary The Input Library centralizes common input patterns into a reusable, structured framework. It improves script consistency, reduces UI friction, and ensures proper conversion between user selections and TradingView internal constants. Designed for Pine Script® v6.
Biblioteca Pine Script®
por OneCleverGuy
backtestLibrary "backtest" curve(disp_ind)   Call function to get a certain curve of your strategy.   Parameters:      disp_ind (string)   Returns: Returns type of curve plot. cleaner(disp_ind, plot)   Call function to filter out your Strategy plots   Parameters:      disp_ind (string)      plot (float) backtestTable(option, position)   Assign this function to a random variable to get the "Performance Table"   Parameters:      option (simple string)      position (simple string)
Biblioteca Pine Script®
por TheTradingSpiderMan
LECAPS_BONCAP_DUALES_LibraryLECAPS BONCAP DUALES Library - Argentine Fixed Income Data =========================================================== Library containing instrument data for Argentine Treasury fixed-rate securities (LECAPs, BONCAPs, and DUALES) and Dólar Futures contracts. 📊 CONTENTS ----------- • LECAP (9 instruments): Zero-coupon treasury notes with "S" prefix • BONCAP (6 instruments): Fixed-rate treasury bonds with "T" prefix • DUALES (2 instruments): Dual-rate TAMAR-linked bonds with "M" prefix • Dólar Futures (11 contracts): ROFEX USD/ARS futures (Feb-Dec 2026) 📈 DATA PROVIDED ---------------- For each instrument: • Ticker symbol (full and short versions) • Maturity price (precio de vencimiento) • Maturity date/timestamp 🔧 EXPORTED FUNCTIONS --------------------- // Counts getLecapCount() → int getBoncapCount() → int getDualesCount() → int getDolarFuturesCount() → int // LECAP data getLecapTicker(index) → string // e.g., "BCBA:S27F6" getLecapTickerShort(index) → string // e.g., "S27F6" getLecapMaturityPrice(index) → float // e.g., 125.84 getLecapMaturityTimestamp(index) → int // BONCAP data getBoncapTicker(index) → string getBoncapTickerShort(index) → string getBoncapMaturityPrice(index) → float getBoncapMaturityTimestamp(index) → int // DUALES data getDualesTicker(index) → string getDualesTickerShort(index) → string getDualesMaturityPrice(index) → float getDualesMaturityTimestamp(index) → int // Dólar Futures data getDolarFuturesTicker(index) → string // e.g., "ROFEX:DLRG2026" getDolarFuturesShort(index) → string // e.g., "DLR Feb26" getDolarFuturesExpiry(index) → int // Helpers isExpired(maturityTs) → bool getDaysToMaturity(maturityTs) → int 💡 USAGE EXAMPLE ---------------- import YourUsername/LECAPS_BONCAP_DUALES_Library/1 as lib // Get LECAP count and iterate for i = 0 to lib.getLecapCount() - 1 ticker = lib.getLecapTickerShort(i) maturityPrice = lib.getLecapMaturityPrice(i) maturityTs = lib.getLecapMaturityTimestamp(i) if not lib.isExpired(maturityTs) // Process active instrument daysLeft = lib.getDaysToMaturity(maturityTs) 📅 INSTRUMENTS (as of 2026-02-11) --------------------------------- LECAP: S27F6 (27-Feb-26), S16M6 (16-Mar-26), S17A6 (17-Apr-26), S30A6 (30-Apr-26), S29Y6 (29-May-26), S31L6 (31-Jul-26), S31G6 (31-Aug-26), S30O6 (30-Oct-26), S30N6 (30-Nov-26) BONCAP: T13F6 (13-Feb-26), T30J6 (30-Jun-26), T15E7 (15-Jan-27), T30A7 (30-Apr-27), T31Y7 (31-May-27), T30J7 (30-Jun-27) DUALES: M27F6 (27-Feb-26), M30A6 (30-Apr-26) DÓLAR FUTURES: DLRG2026 (Feb), DLRH2026 (Mar), DLRJ2026 (Apr), DLRK2026 (May), DLRM2026 (Jun), DLRN2026 (Jul), DLRQ2026 (Aug), DLRU2026 (Sep), DLRV2026 (Oct), DLRX2026 (Nov), DLRZ2026 (Dec) ⚠️ NOTES -------- • Data is updated periodically as new instruments are issued • Expired instruments are automatically filtered via isExpired() • Maturity prices are set at public auction (licitación) • Use with the companion indicator "Breakeven LECAPs BONCAPs DUALES" 🏷️ TAGS ------- argentina, lecap, boncap, duales, treasury, fixed-income, bonds, letras, bonos, dolar, futures, rofex, bcba, breakeven
Biblioteca Pine Script®
por Eco Valores
Kerbal_BreadthLibrary "kerbal_breadth" Kerbal Indicators Shared Library - Breadth Analysis This library provides functions for analyzing market breadth indicators including Advance/Decline lines, Bullish Percent Index, and breadth divergence detection. getAdvDecLine()   Get NYSE Advance/Decline line   Returns: NYSE A/D line value getAdvDecRatio()   Get NYSE Advance/Decline ratio   Returns: NYSE Advance/Decline ratio advDecSlope(length)   Calculate A/D line slope (rate of change)   Parameters:      length (int) : Period for slope calculation   Returns: A/D line slope (positive = breadth improving, negative = deteriorating) advDecDivergence(priceHigh, priceHighBar, lookback)   Detect A/D line divergence with price   Parameters:      priceHigh (float) : Recent price high      priceHighBar (int) : Bar index of price high      lookback (int) : Bars to look back for divergence   Returns: Tuple - true if divergence detected getBullishPercentNYSE()   Get Bullish Percent Index for NYSE   Returns: NYSE BPI value (0-100 scale) getBullishPercentSPX()   Get Bullish Percent Index for S&P 500   Returns: SPX BPI value (0-100 scale) getBullishPercentNDX()   Get Bullish Percent Index for Nasdaq   Returns: NDX BPI value (0-100 scale) bpiRegime(bpi, oversoldThresh, overboughtThresh)   Classify BPI regime   Parameters:      bpi (float) : BPI value (0-100)      oversoldThresh (float) : Oversold threshold (contrarian bullish)      overboughtThresh (float) : Overbought threshold (contrarian bearish)   Returns: Regime: "OVERSOLD", "BULLISH", "NEUTRAL", "BEARISH", "OVERBOUGHT" pctAbove200MA_SPX()   Get percentage of S&P 500 stocks above their 200-day MA   Returns: Percentage (0-100) pctAbove50MA_SPX()   Get percentage of S&P 500 stocks above their 50-day MA   Returns: Percentage (0-100) breadthHealth(pct200, pct50)   Analyze breadth health based on MA participation   Parameters:      pct200 (float) : Percentage above 200-day MA      pct50 (float) : Percentage above 50-day MA   Returns: Health assessment: "STRONG", "HEALTHY", "WEAK", "POOR" breadthThrust(period, threshold)   Detect breadth thrust (rapid improvement in breadth)   Parameters:      period (int) : Measurement period      threshold (float) : Minimum improvement threshold   Returns: True if breadth thrust detected breadthScore(advDecSlope, bpi, pct200)   Calculate composite breadth score   Parameters:      advDecSlope (float) : A/D line slope      bpi (float) : Bullish Percent Index value      pct200 (float) : Percentage above 200-day MA   Returns: Breadth score 0-100 (higher = better breadth) currentBreadthScore()   Get current composite breadth with all data retrieval   Returns: Composite breadth score 0-100 breadthBearishDivergence(priceHigh, prevPriceHigh, currentBreadth, prevBreadth)   Detect bearish breadth divergence   Parameters:      priceHigh (float) : Current price high      prevPriceHigh (float) : Previous price high      currentBreadth (float) : Current breadth score      prevBreadth (float) : Previous breadth score   Returns: True if bearish divergence (price up, breadth down) breadthBullishDivergence(priceLow, prevPriceLow, currentBreadth, prevBreadth)   Detect bullish breadth divergence   Parameters:      priceLow (float) : Current price low      prevPriceLow (float) : Previous price low      currentBreadth (float) : Current breadth score      prevBreadth (float) : Previous breadth score   Returns: True if bullish divergence (price down, breadth up) breadthConfirmsBullish(breadthScore, minScore)   Check if breadth confirms bullish price action   Parameters:      breadthScore (float) : Current breadth score (0-100)      minScore (float) : Minimum acceptable breadth score   Returns: True if breadth is confirming breadthConfirmsBearish(breadthScore, maxScore)   Check if breadth confirms bearish price action   Parameters:      breadthScore (float) : Current breadth score (0-100)      maxScore (float) : Maximum acceptable breadth score   Returns: True if breadth is confirming breadthWarning(breadthScore, priceAction)   Detect breadth warning signals   Parameters:      breadthScore (float) : Current breadth score      priceAction (int) : Recent price direction (1 = up, -1 = down, 0 = neutral)   Returns: Tuple marketHealthFromBreadth(breadthScore, hasThrust, divergenceType)   Comprehensive market health from breadth indicators   Parameters:      breadthScore (float) : Composite breadth score      hasThrust (bool) : Whether breadth thrust detected      divergenceType (int) : Divergence type: 1 = bearish, -1 = bullish, 0 = none   Returns: Health string: "EXCELLENT", "GOOD", "FAIR", "POOR", "WARNING" marketHealth(sentimentScore, breadthScore)   Combined sentiment and breadth confirmation   Parameters:      sentimentScore (float) : Sentiment score from kerbal_sentiment library (0-100)      breadthScore (float) : Breadth score (0-100)   Returns: Tuple
Biblioteca Pine Script®
por Kerbal
Kerbal_SentimentLibrary "kerbal_sentiment" Kerbal Indicators Shared Library - Sentiment Analysis This library provides functions for accessing and analyzing market sentiment indicators including VIX and Put/Call ratios for contrarian signal generation. getVIX()   Get VIX (CBOE Volatility Index) close value   Returns: VIX close price vixPercentile(length)   Calculate VIX percentile rank over lookback period   Parameters:      length (int) : Lookback period for percentile calculation   Returns: VIX percentile (0-100) vixRegime(vix, lowThresh, highThresh, extremeThresh)   Classify VIX regime based on thresholds   Parameters:      vix (float) : VIX value to classify (use na for current)      lowThresh (float) : Low VIX threshold (complacent market)      highThresh (float) : High VIX threshold (fearful market)      extremeThresh (float) : Extreme fear threshold   Returns: Regime: "COMPLACENT", "NORMAL", "FEARFUL", or "EXTREME_FEAR" vixZScore(length)   Calculate VIX z-score for relative positioning   Parameters:      length (int) : Lookback period for mean and standard deviation   Returns: VIX z-score getPutCallRatio()   Get equity put/call ratio   Returns: Put/Call ratio (typically from CBOE data feed) putCallSmoothed(length)   Get smoothed put/call ratio using SMA   Parameters:      length (int) : Smoothing period   Returns: Smoothed put/call ratio putCallZScore(length)   Calculate put/call z-score for extremes detection   Parameters:      length (int) : Lookback period for mean and standard deviation   Returns: Put/Call z-score (positive = elevated put buying) putCallRegime(pc, lowThresh, highThresh)   Classify put/call ratio regime   Parameters:      pc (float) : Put/call ratio (use na for current)      lowThresh (float) : Low P/C threshold (complacent/bullish)      highThresh (float) : High P/C threshold (fearful/bearish sentiment)   Returns: Regime: "COMPLACENT", "NORMAL", "DEFENSIVE", "FEARFUL" sentimentScore(vixPercentile, putCallZScore)   Calculate composite sentiment score   Parameters:      vixPercentile (float) : VIX percentile rank (0-100)      putCallZScore (float) : Put/Call ratio z-score   Returns: Sentiment score 0-100 (0 = extreme fear/bullish contrarian, 100 = extreme complacency/bearish contrarian) contrarianSignal(sentimentScore, bullishThreshold, bearishThreshold)   Check if sentiment is at contrarian extreme   Parameters:      sentimentScore (float) : Composite sentiment score (0-100)      bullishThreshold (float) : Threshold for contrarian bullish signal (extreme fear)      bearishThreshold (float) : Threshold for contrarian bearish signal (extreme complacency)   Returns: Tuple sentimentTrend(sentimentScore, prevSentimentScore, threshold)   Get sentiment direction and strength   Parameters:      sentimentScore (float) : Current sentiment score      prevSentimentScore (float) : Previous sentiment score      threshold (float)   Returns: Tuple where direction is "INCREASING_FEAR", "DECREASING_FEAR", "STABLE" vixSpike(spikeThreshold)   Detect VIX spike (sudden fear increase)   Parameters:      spikeThreshold (float) : Z-score threshold for spike detection   Returns: True if VIX is spiking putCallSpike(spikeThreshold)   Detect put/call spike (sudden defensive positioning)   Parameters:      spikeThreshold (float) : Z-score threshold for spike detection   Returns: True if P/C ratio is spiking marketStress()   Composite market stress indicator   Returns: Stress level 0-100 (higher = more stress) contrarianBuyOpportunity(minStress)   Identify contrarian buy opportunity   Parameters:      minStress (float) : Minimum stress level required   Returns: True if contrarian buy opportunity detected contrarianSellOpportunity(maxStress)   Identify contrarian sell opportunity   Parameters:      maxStress (float) : Maximum stress level (complacency)   Returns: True if contrarian sell opportunity detected
Biblioteca Pine Script®
por Kerbal
Kerbal_HelpersLibrary "kerbal_helpers" Kerbal Indicators Shared Library - Drawing object helpers This library provides utilities for managing labels, boxes, and areas within Pine Script limits (500 each). Includes deduplication, cleanup, filtering, and zone management functions. ageFilter(barIndex, creationBar, maxAge)   Check if an object is too old based on bar index   Parameters:      barIndex (int) : Current bar index      creationBar (int) : Bar index when object was created      maxAge (int) : Maximum age in bars   Returns: True if object should be filtered out (too old) distanceFilter(price, referencePrice, atrMultiplier, atr)   Check if price is within acceptable distance from reference   Parameters:      price (float) : The price to check      referencePrice (float) : The reference price      atrMultiplier (float) : ATR multiplier for distance      atr (float) : The ATR value   Returns: True if within acceptable distance weightFilter(weight, minWeight)   Check if weight meets minimum threshold   Parameters:      weight (float) : The weight value      minWeight (float) : Minimum acceptable weight   Returns: True if weight is acceptable perfectionFilter(isPerfected, requirePerfection)   Check perfection requirement (for Price Exhaustion clusters)   Parameters:      isPerfected (bool) : Whether the signal is perfected      requirePerfection (bool) : Whether perfection is required   Returns: True if passes perfection filter boxOverlaps(box1Top, box1Bot, box2Top, box2Bot)   Check if two boxes overlap in price space   Parameters:      box1Top (float) : Top price of first box      box1Bot (float) : Bottom price of first box      box2Top (float) : Top price of second box      box2Bot (float) : Bottom price of second box   Returns: True if boxes overlap boxMerge(box1Top, box1Bot, box2Top, box2Bot)   Calculate the merged boundaries of two overlapping boxes   Parameters:      box1Top (float) : Top price of first box      box1Bot (float) : Bottom price of first box      box2Top (float) : Top price of second box      box2Bot (float) : Bottom price of second box   Returns: Tuple priceInZone(price, boxTop, boxBot)   Check if a price is within a box/zone   Parameters:      price (float) : The price to check      boxTop (float) : Top of the box      boxBot (float) : Bottom of the box   Returns: True if price is within box boundaries zoneCenter(boxTop, boxBot)   Calculate the center price of a zone   Parameters:      boxTop (float) : Top of the zone      boxBot (float) : Bottom of the zone   Returns: Center price zoneWidth(boxTop, boxBot)   Calculate zone width/thickness   Parameters:      boxTop (float) : Top of the zone      boxBot (float) : Bottom of the zone   Returns: Zone width labelsNearby(x1, y1, x2, y2, barTolerance, priceTolerance)   Check if two labels would be too close (for deduplication)   Parameters:      x1 (int) : Bar index of first label      y1 (float) : Price of first label      x2 (int) : Bar index of second label      y2 (float) : Price of second label      barTolerance (int) : Maximum bar distance for considering labels duplicate      priceTolerance (float) : Maximum price distance for considering labels duplicate   Returns: True if labels are close enough to be considered duplicates labelDistance(x1, y1, x2, y2, atr)   Calculate distance score between two label positions (lower is closer)   Parameters:      x1 (int) : Bar index of first label      y1 (float) : Price of first label      x2 (int) : Bar index of second label      y2 (float) : Price of second label      atr (float) : ATR value for price normalization   Returns: Distance score (0+ range, lower means closer) clusterType(hasSession, hasPivot, hasVolume, weight, goldThreshold, limeThreshold)   Classify cluster composition based on anchor types present   Parameters:      hasSession (bool) : Whether cluster contains session anchors (daily/weekly)      hasPivot (bool) : Whether cluster contains pivot anchors      hasVolume (bool) : Whether cluster contains volume anchors      weight (float) : Total cluster weight      goldThreshold (float) : Weight threshold for "gold" classification      limeThreshold (float) : Weight threshold for "lime" classification   Returns: Cluster type: "GOLD", "LIME", "MIXED", "SESSION", "PIVOT", "VOLUME" clusterColor(clusterType)   Get color for cluster based on type   Parameters:      clusterType (string) : The cluster type string   Returns: Appropriate color for the cluster type zoneSignificant(weight, width, minWeight, maxWidth)   Check if a zone is significant enough to display   Parameters:      weight (float) : Zone weight      width (float) : Zone width in price      minWeight (float) : Minimum weight threshold      maxWidth (float) : Maximum width threshold (ATR-based)   Returns: True if zone should be displayed mergeZones(prices, widths, tolerance)   Merge multiple nearby zones into a single wider zone   Parameters:      prices (array) : Array of zone center prices      widths (array) : Array of zone widths      tolerance (float) : Merging tolerance (typically ATR-based)   Returns: Tuple of arrays findSupportResistance(prices, currentPrice)   Calculate support and resistance levels from an array of prices   Parameters:      prices (array) : Array of price levels      currentPrice (float) : Current market price   Returns: Tuple of zoneStrength(weight, age, touches, width, maxAge, maxTouches, optimalWidth)   Calculate zone strength score based on multiple factors   Parameters:      weight (float) : Zone weight (volume participation)      age (int) : Bars since zone creation      touches (int) : Number of price touches/tests      width (float) : Zone width      maxAge (int) : Maximum age for full score      maxTouches (int) : Maximum touches for full score      optimalWidth (float) : Optimal zone width (narrower is better)   Returns: Strength score 0-100
Biblioteca Pine Script®
por Kerbal
Kerbal_LibLibrary "kerbal_lib" Kerbal Indicators Shared Library - Core utilities for TradingView indicators This library provides reusable functions for ATR calculations, multi-timeframe analysis, confluence detection, clustering, regime classification, and more. atrTolerance(length, multiplier)   Calculate ATR-based tolerance value   Parameters:      length (simple int) : The ATR calculation length      multiplier (float) : The ATR multiplier for tolerance   Returns: The tolerance value (ATR * multiplier) pricesWithinATR(price1, price2, atrMultiplier, atrLength)   Check if two prices are within ATR tolerance   Parameters:      price1 (float) : First price level      price2 (float) : Second price level      atrMultiplier (float) : ATR multiplier for tolerance      atrLength (simple int) : ATR calculation length   Returns: True if prices are within tolerance atrPercentile(atrLength, lookback, percentile)   Get ATR percentile for compression detection   Parameters:      atrLength (simple int) : The ATR calculation length      lookback (int) : Lookback period for percentile      percentile (simple float) : The percentile to calculate (0-100)   Returns: ATR percentile value isHigherTimeframe(htfPeriod)   Check if a given timeframe is higher than current chart timeframe   Parameters:      htfPeriod (string) : Higher timeframe period string   Returns: True if HTF is genuinely higher than chart TF confluenceCount(signal1, signal2, signal3, signal4, signal5)   Count how many boolean signals are true   Parameters:      signal1 (bool) : First signal      signal2 (bool) : Second signal      signal3 (bool) : Third signal      signal4 (bool) : Fourth signal      signal5 (bool) : Fifth signal   Returns: Count of true signals confluenceScore(signal1, signal2, signal3, signal4, signal5, weight1, weight2, weight3, weight4, weight5)   Calculate weighted confluence score from multiple signals   Parameters:      signal1 (bool) : First signal      signal2 (bool) : Second signal      signal3 (bool) : Third signal      signal4 (bool) : Fourth signal      signal5 (bool) : Fifth signal      weight1 (float) : Weight for first signal      weight2 (float) : Weight for second signal      weight3 (float) : Weight for third signal      weight4 (float) : Weight for fourth signal      weight5 (float) : Weight for fifth signal   Returns: Weighted score (0-100) clusterPrices(prices, weights, tolerance)   Cluster prices within tolerance using weighted averaging   Parameters:      prices (array) : Array of price levels to cluster      weights (array) : Array of weights for each price      tolerance (float) : Distance tolerance for grouping (typically ATR-based)   Returns: Tuple of arrays clusterSort(centers, weights, maxClusters)   Sort clusters by weight and return top N   Parameters:      centers (array) : Array of cluster center prices      weights (array) : Array of cluster weights      maxClusters (int) : Maximum number of clusters to return   Returns: Tuple of arrays (descending by weight) regimeClassify(hurst, thresholdHi, thresholdLo)   Classify market regime based on Hurst exponent   Parameters:      hurst (float) : The Hurst exponent value (0-1)      thresholdHi (float) : Upper threshold for trending regime      thresholdLo (float) : Lower threshold for mean-reverting regime   Returns: Regime string: "TREND", "REVERT", or "MIXED" volatilityRegime(atrLength, lookback, percentile)   Classify volatility regime based on ATR percentile   Parameters:      atrLength (simple int) : ATR calculation length      lookback (int) : Lookback period for percentile      percentile (simple float) : Compression threshold percentile   Returns: Volatility regime: "COMPRESSED", "NORMAL", or "EXPANDED" normalizedSlope(current, previous, atrLength)   Calculate normalized slope using ATR   Parameters:      current (float) : Current value      previous (float) : Previous value      atrLength (simple int) : ATR length for normalization   Returns: Normalized slope value slopeColor(slope, threshold, upColor, downColor, flatColor)   Get color based on slope direction   Parameters:      slope (float) : The slope value to evaluate      threshold (float) : Threshold for flat detection      upColor (color) : Color for rising slope      downColor (color) : Color for falling slope      flatColor (color) : Color for flat slope   Returns: Color based on slope direction slopeDirection(current, previous, threshold)   Determine slope direction as string   Parameters:      current (float) : Current value      previous (float) : Previous value      threshold (float) : Threshold for flat detection   Returns: Direction string: "RISING", "FALLING", or "FLAT" dojiMid(openPrice, closePrice)   Calculate doji midpoint (fair value for doji candles)   Parameters:      openPrice (float) : Open price      closePrice (float) : Close price   Returns: Midpoint between open and close vwap(sumPriceVolume, sumVolume)   Calculate VWAP from cumulative values   Parameters:      sumPriceVolume (float) : Cumulative sum of price * volume      sumVolume (float) : Cumulative sum of volume   Returns: VWAP value isNewSession(tf)   Check if a new session has started for given timeframe   Parameters:      tf (string) : Timeframe string (e.g., "1D", "1W")   Returns: True if new session started isIntraday()   Check if current timeframe is intraday   Returns: True if intraday timeframe relativeVolume(length)   Calculate relative volume using median baseline   Parameters:      length (int) : Lookback length for median calculation   Returns: Relative volume (current volume / median volume) volumeCategory(relVol, lowThreshold, highThreshold, extremeThreshold)   Categorize volume level   Parameters:      relVol (float) : Relative volume value      lowThreshold (float) : Threshold for low volume      highThreshold (float) : Threshold for high volume      extremeThreshold (float) : Threshold for extreme volume   Returns: Volume category: "EXTREME", "HIGH", "NORMAL", or "LOW" volumeTrend(shortLength, longLength)   Calculate volume trend (fast median vs slow median)   Parameters:      shortLength (int) : Short median length      longLength (int) : Long median length   Returns: Volume trend ratio volumeMultiplier(relVol, lowThreshold, highThreshold, extremeThreshold)   Get volume multiplier for calculations based on relative volume   Parameters:      relVol (float) : Relative volume value      lowThreshold (float) : Threshold for low volume multiplier      highThreshold (float) : Threshold for high volume multiplier      extremeThreshold (float) : Threshold for extreme volume multiplier   Returns: Multiplier value (0.5 for low, 1.0 for normal, 1.5 for high, 2.0 for extreme)
Biblioteca Pine Script®
por Kerbal
Kerbal_CloudsLibrary "kerbal_clouds" Kerbal Indicators Shared Library - EMA/SMA Cloud Helpers This library provides convenient functions for creating and managing moving average clouds (high/close/low based). emaCloud(period)   Calculate EMA cloud values (high, close, low)   Parameters:      period (simple int) : The EMA period   Returns: Tuple of cloudWidth(emaHigh, emaLow)   Calculate EMA cloud width   Parameters:      emaHigh (float) : EMA of high      emaLow (float) : EMA of low   Returns: Cloud width (emaHigh - emaLow) cloudPosition(emaHigh, emaClose, emaLow)   Calculate price position within cloud (0-1 scale)   Parameters:      emaHigh (float) : EMA of high      emaClose (float) : EMA of close      emaLow (float) : EMA of low   Returns: Position from 0 (at low) to 1 (at high) distanceToCloud(price, emaHigh, emaLow)   Calculate distance from price to cloud   Parameters:      price (float) : Current price to check      emaHigh (float) : EMA of high      emaLow (float) : EMA of low   Returns: Distance (positive if above cloud, negative if below, 0 if inside) priceCloudRelation(price, emaHigh, emaLow)   Check if price is above, below, or within cloud   Parameters:      price (float) : Current price      emaHigh (float) : EMA of high      emaLow (float) : EMA of low   Returns: Position string: "ABOVE", "BELOW", or "INSIDE" smaCloud(period)   Calculate SMA cloud values (high, close, low)   Parameters:      period (int) : The SMA period   Returns: Tuple of cloudStacking(shortHigh, shortLow, mediumHigh, mediumLow, longHigh, longLow)   Check if clouds are properly stacked (bullish or bearish)   Parameters:      shortHigh (float) : Short period EMA high      shortLow (float) : Short period EMA low      mediumHigh (float) : Medium period EMA high      mediumLow (float) : Medium period EMA low      longHigh (float) : Long period EMA high      longLow (float) : Long period EMA low   Returns: Stacking string: "BULLISH" (short > medium > long), "BEARISH" (short < medium < long), "MIXED" cloudAlignment(shortClose, mediumClose, longClose)   Calculate cloud alignment score (0-100)   Parameters:      shortClose (float) : Short period EMA close      mediumClose (float) : Medium period EMA close      longClose (float) : Long period EMA close   Returns: Alignment score (100 = perfect bullish, 0 = perfect bearish, 50 = mixed) cloudTrendStrength(shortClose, mediumClose, longClose, atr)   Calculate trend strength based on cloud separation   Parameters:      shortClose (float) : Short period EMA close      mediumClose (float) : Medium period EMA close      longClose (float) : Long period EMA close      atr (float) : Current ATR for normalization   Returns: Trend strength (-1 to 1, negative for bearish, positive for bullish) cloudSqueeze(shortWidth, mediumWidth, longWidth, atr, threshold)   Detect cloud squeeze (compression)   Parameters:      shortWidth (float) : Short cloud width      mediumWidth (float) : Medium cloud width      longWidth (float) : Long cloud width      atr (float) : Current ATR      threshold (float) : Squeeze threshold (width/ATR ratio)   Returns: True if all clouds are squeezed below threshold bullishCloudCross(price, cloudHigh)   Detect bullish cloud crossover   Parameters:      price (float) : Current price      cloudHigh (float) : Cloud high boundary   Returns: True if price crossed above cloud bearishCloudCross(price, cloudLow)   Detect bearish cloud crossover   Parameters:      price (float) : Current price      cloudLow (float) : Cloud low boundary   Returns: True if price crossed below cloud tripleCloud(shortPeriod, mediumPeriod, longPeriod)   Calculate triple cloud system (short, medium, long periods)   Parameters:      shortPeriod (simple int) : Short EMA period      mediumPeriod (simple int) : Medium EMA period      longPeriod (simple int) : Long EMA period   Returns: Tuple of 9 values: cloudTrendColor(emaClose, emaPrevClose, bullishColor, bearishColor)   Get cloud color based on position and trend   Parameters:      emaClose (float) : EMA close value      emaPrevClose (float) : Previous EMA close value      bullishColor (color) : Color for bullish/rising cloud      bearishColor (color) : Color for bearish/falling cloud   Returns: Appropriate cloud color
Biblioteca Pine Script®
por Kerbal
TrinityCore30Library "TrinityCore30" TRINITY CORE LIBRARY v30.1 (Diamond Final / Safety Sync Fixed) Architecture: Fixed 7 Calls / Raw Kernels / State Machine / Array Math Constitution: 1. Max 7 security calls. 2. Bible Compliance: CD (Corr), DDG (Ratio), Dynamic Lengths. 3. Ironclad Math: Volatility %, NaN-Guarded. 4. Semantics: Safety Valve correctly syncs is_ready/risk_gate flags. calc_weights(sym, cp, cs, s1, s2, s3, s4, s5, cfg)   Parameters:      sym (string)      cp (string)      cs (string)      s1 (string)      s2 (string)      s3 (string)      s4 (string)      s5 (string)      cfg (TrinityConfig) calc_diagnostics(sym, cp, cs, s1, s2, s3, s4, s5, cfg)   Parameters:      sym (string)      cp (string)      cs (string)      s1 (string)      s2 (string)      s3 (string)      s4 (string)      s5 (string)      cfg (TrinityConfig) calc_weights_flat(sym, cp, cs, s1, s2, s3, s4, s5, en, l20, w20, l63, w63, l126, w126, l252, w252, rf, fac, tvs, tvsf, gmm, kl, kd, ks, tk, bl, wcp, wcd, wvs, wdd, sp, sv, ft, rf2, ra, r_cp, r_dd, pen_v, rb)   Parameters:      sym (string)      cp (string)      cs (string)      s1 (string)      s2 (string)      s3 (string)      s4 (string)      s5 (string)      en (bool)      l20 (int)      w20 (float)      l63 (int)      w63 (float)      l126 (int)      w126 (float)      l252 (int)      w252 (float)      rf (float)      fac (float)      tvs (float)      tvsf (float)      gmm (float)      kl (int)      kd (float)      ks (float)      tk (int)      bl (float)      wcp (float)      wcd (float)      wvs (float)      wdd (float)      sp (float)      sv (float)      ft (float)      rf2 (float)      ra (float)      r_cp (float)      r_dd (float)      pen_v (float)      rb (int) core_build() TrinityWeights   Fields:      stock (series float)      safe1 (series float)      safe2 (series float)      safe3 (series float)      safe4 (series float)      safe5 (series float)      cash (series float) TrinityDiagLite   Fields:      is_ready (series bool)      ready_code (series int)      core_build (series int)      risk_gate (series bool)      wroc_stock (series float)      valid_safe_count (series int)      passed_safe_count (series int)      sum_ok (series bool) TrinityDiagFull   Fields:      raw_stock (series float)      mvol_stock (series float)      mdecel_stock (series float)      gov_stock (series float)      safe_budget (series float)      top1_id (series int)      top2_id (series int)      sum_weights (series float) SafeDiag   Fields:      enabled (series bool)      valid (series bool)      sqs (series float)      final_w (series float)      drop_code (series int) TrinityConfig   Fields:      enabled (series bool)      len_20 (series int)      w_20 (series float)      len_63 (series int)      w_63 (series float)      len_126 (series int)      w_126 (series float)      len_252 (series int)      w_252 (series float)      risk_floor (series float)      risk_factor (series float)      target_vol_stock (series float)      target_vol_safe (series float)      gov_min_mult (series float)      k_len (series int)      k_decay (series float)      k_scale (series float)      top_k (series int)      baseline (series float)      w_cp (series float)      w_cd (series float)      w_vs (series float)      w_ddg (series float)      shock_price (series float)      shock_vol (series float)      fall_thr (series float)      rate_fall (series float)      rate_accel (series float)      penalty_val (series float)      range_cp (series float)      range_dd (series float)      ready_bars (series int)
Biblioteca Pine Script®
por excelar
DafeLiquidityEngineDafeLiquidityEngine: The Institutional Liquidity & Microstructure Engine This is not a volume indicator. This is a complete, institutional-grade quantitative laboratory for the analysis of market liquidity. It is a toolkit for seeing the invisible architecture of the order book and trading the cause, not the effect. █ CHAPTER 1: THE PHILOSOPHY - BEYOND VOLUME, INTO LIQUIDITY The standard volume bar is a lie. It tells you that the market was active, but it tells you nothing about the quality of that activity. Was it a deep, liquid market that could easily absorb large orders, or a thin, fragile market on the verge of a violent cascade? Was the volume driven by informed, institutional flow, or by reactive, retail panic? The DafeLiquidityEngine was created to answer these critical questions. This library is not a simple "mashup" of existing indicators; it is a foundational, original work that brings a suite of concepts from academic and institutional quantitative finance directly into the Pine Script environment. Its purpose is to move beyond the one-dimensional view of volume and provide a multi-faceted, high-resolution picture of the market's true, underlying liquidity structure. b]This is not an indicator that gives buy or sell signals. It is a far more powerful tool: a measurement device. It provides you with the crucial intelligence to assess the quality of the market environment. It tells you when liquidity is deep and signals can be trusted, and when liquidity has vanished and risk is extreme. It is the definitive engine for understanding the hidden structure of the market auction. █ CHAPTER 2: THE CORE INNOVATIONS - A UNIVERSITY-LEVEL TOOLKIT This library's value is rooted in its implementation of sophisticated, academically recognized models for liquidity and price impact, many for the first time on this platform. Multi-Scale Delta Divergence Engine: The engine doesn't just calculate one Cumulative Volume Delta (CVD). It calculates two simultaneously: a fast delta (representing scalpers and retail flow) and a slow delta (representing institutional accumulation/distribution). Its true genius lies in its ability to analyze the divergence between these two flows, classifying the market into one of five distinct states like "Absorption" (institutions absorbing retail selling) or "Stealth" (institutions quietly building a position). Advanced Bid-Ask Spread Estimation: Without access to Level 2 data, how can you know the spread? This library uses two renowned academic models—the Corwin-Schultz estimator (using high-low data) and the Roll spread estimator (using serial covariance)—to create a high-fidelity proxy for the live bid-ask spread. This is a direct measure of market tightness. Amihud Illiquidity Ratio: A classic, powerful measure of illiquidity. It calculates the absolute price return per dollar of volume traded. A high Amihud score means that even small amounts of volume are causing large, violent price swings—a clear sign of a dangerously illiquid market. Kyle's Lambda (Price Impact): This is the professional's measure of market impact. Lambda calculates how much the price moves for every unit of signed order flow. A high Lambda value indicates a "thin" order book where a single large market order can cause a significant price cascade. It is a direct measure of market fragility. The Volume Clock Engine: This module analyzes the market in "volume time" instead of chronological time. It detects volume "droughts" and "floods," measures the "participation rate" against historical norms, and analyzes the acceleration of volume to determine if a move is gaining or losing institutional support. The Composite Liquidity Regime: The capstone of the engine. It synthesizes the intelligence from all other modules into a single, unified classification of the market's liquidity state, from "Deep" and "Normal" to "Thin," "Desert," and the dreaded "Frozen." For developers, this provides a simple, powerful output: a risk_multiplier and a signal_penalty to automatically adjust position sizing and signal confidence based on the current liquidity environment. █ CHAPTER 3: A DEEP DIVE INTO THE ENGINE'S MODULES This is your guide to the engine room. Each module is a specialized analytical tool. The DeltaState Module: This is the heart of the divergence engine. It provides you with the raw and Z-scored values for both fast and slow delta, their velocity, and the final divergence classification ("absorption," "exhaustion," etc.) along with a confidence score. This is your primary tool for detecting conflicts between retail and institutional flow. The SpreadState Module: This gives you a direct, quantitative measure of market tightness. Use the spread_z score to see if the current bid-ask spread is statistically wide or tight, and the spread_regime to know if the market is "Blown" (extremely wide and risky) or "Tight" (liquid and efficient). The AmihudState & KyleState Modules: These are your professional-grade risk assessment tools. A rising illiquidity_z score from Amihud is a clear warning that the market is becoming fragile. A rising lambda_z from Kyle's Lambda tells you that price impact is increasing, and the risk of a slippage cascade is high. The VolumeClockState Module: This is your lens into market participation. The vol_clock_regime ("drought," "low," "normal," "elevated," "flood") tells you the character of the current volume, while the vol_trend_strength provides a measure of the momentum of participation. The LiquidityRegime Module: This is the final, synthesized verdict. It provides a single, easy-to-use regime name ("Flush," "Deep," "Normal," "Thin," "Desert," "Frozen") that encapsulates the combined intelligence of the entire system. Crucially, it also outputs the risk_multiplier and signal_penalty—direct, actionable factors you can use to modulate your own strategy's behavior. █ CHAPTER 4: THE DEVELOPER'S MASTERCLASS - IMPLEMENTATION GUIDE The DafeLiquidityEngine is a professional framework designed for seamless integration. This guide provides the complete instructions for leveraging its power. PART I: THE INPUTS TEMPLATE (THE CONTROL PANEL) While this is a library, a high-quality indicator built upon it would expose these parameters to the user for fine-tuning. This is the recommended input structure. // ╔═════════════════════════════════════════════════════════╗ // ║ INPUTS TEMPLATE ║ // ╚═════════════════════════════════════════════════════════╝ // INPUT GROUPS string G_LIQ_ENGINE = "═══════════ 💧 LIQUIDITY ENGINE ════════════" string G_LIQ_DELTA = "═══════════ 📊 DELTA & DIVERGENCE ══════════" string G_LIQ_RISK = "═══════════ ⚖️ RISK & SPREAD ════════════" // ENGINE CONFIG int i_liq_fast = input.int(8, "Fast Delta Length", minval=3, maxval=20, group=G_LIQ_ENGINE, tooltip="Lookback for the 'fast' retail/scalper delta.") int i_liq_slow = input.int(34, "Slow Delta Length", minval=21, maxval=100, group=G_LIQ_ENGINE, tooltip="Lookback for the 'slow' institutional delta.") int i_liq_zlookback = input.int(50, "Normalization Lookback", minval=20, maxval=200, group=G_LIQ_ENGINE, tooltip="The lookback period for all Z-Score calculations, which makes the metrics adaptive to the asset.") PART II: THE IMPLEMENTATION LOGIC (THE HEART OF YOUR SCRIPT) This is the boilerplate code you will adapt to your indicator. It shows the complete lifecycle of creating, updating, and using the engine. // ╔═════════════════════════════════════════════════════════╗ // ║ USAGE EXAMPLE (ADAPT TO YOUR SCRIPT) ║ // ╚═════════════════════════════════════════════════════════╝ // 1. IMPORT THE LIBRARY import YourUsername/DafeLiquidityEngine/1 as liq // 2. INITIALIZE THE ENGINE (happens only on the first bar) // The 'engine' must be a 'var' to retain its state across bars. var liq.LiquidityEngine engine = liq.create_engine(i_liq_fast, i_liq_slow, i_liq_zlookback) // 3. UPDATE THE ENGINE (runs on every bar) // Feed the current bar's OHLCV data into the engine. It handles all internal calculations. engine := liq.update(engine, open, high, low, close, volume) // 4. EXTRACT INTELLIGENCE (runs on every bar) // Get the final, synthesized output state from the engine. liq.LiquidityState state = liq.get_state(engine) // 5. USE THE INTELLIGENCE TO BUILD YOUR LOGIC // --- Example 1: Creating a Sophisticated Signal Filter --- bool my_raw_buy_signal = ta.crossover(ta.ema(close, 10), ta.ema(close, 20)) // The liquidity engine provides a simple penalty score. 1.0 = good liquidity, 0.2 = bad liquidity. float liquidity_penalty = state.signal_penalty // Only trust the signal if liquidity is good enough. bool final_buy_signal = my_raw_buy_signal and liquidity_penalty > 0.6 plotshape(final_buy_signal, "Filtered Buy", ...) // --- Example 2: Dynamic Position Sizing --- float base_position_size = 10000 // Your base size in dollars // The engine provides a risk multiplier. 1.0 = normal risk, 0.3 = high risk (reduce size). float liquidity_risk_multiplier = state.risk_multiplier float final_position_size = base_position_size * liquidity_risk_multiplier // Now use 'final_position_size' in your strategy logic. // --- Example 3: Building a Divergence-Based Strategy --- if state.divergence_type == "accumulation" and state.divergence_confidence > 0.7 // This is a high-confidence signal that institutions are quietly buying while price is falling. // A powerful setup for a long entry. strategy.entry("Accumulation Long", strategy.long) // --- Example 4: Displaying the State on a Dashboard --- if barstate.islast label.new(bar_index, high, "Liquidity Regime: " + state.liq_regime_name + " Risk Multiplier: " + str.tostring(state.risk_multiplier, "#.##") + " Divergence: " + state.divergence_type) █ DEVELOPMENT PHILOSOPHY The DafeLiquidityEngine was born from a single, guiding principle: liquidity is the fuel of the market. Price cannot move without it, and its absence or presence dictates the character of every trading session. This library provides, for the first time, a comprehensive, institutional-grade toolkit for quantifying this elusive but critical variable. It is a tool for the serious developer and the quantitative trader who is not satisfied with surface-level analysis, but who seeks to understand the deep, structural mechanics of the market auction. █ DISCLAIMER & IMPORTANT NOTES THIS IS A LIBRARY FOR ADVANCED DEVELOPERS: This script does nothing on its own. It is a powerful engine that must be imported and used by other indicator developers to build their own tools. THIS IS AN ESTIMATION ENGINE: The algorithms used (Corwin-Schultz, Kyle's Lambda, Delta Estimation) are highly respected academic and institutional proxies for true order book data. They are high-fidelity estimates, not a direct feed of Level 2 data. CONTEXT IS KEY: The output of this engine is contextual intelligence, not direct trading signals. A "Thin" liquidity regime is not a signal to sell; it is a signal to reduce position size, widen stops, and be wary of false breakouts. Create with DAFE.
Biblioteca Pine Script®
por DskyzInvestments
DafeVIXEngineDAFE VIX Intelligence Engine: The Definitive Guide to Market Volatility This is a professional-grade intelligence engine that decodes the multi-dimensional language of market fear. It analyzes the VIX Term Structure, Volatility Surprise, and Regime Physics to provide a probabilistic forecast of market stability and transitions. █ CHAPTER 1: THE PHILOSOPHY - BEYOND THE VIX NUMBER For most traders, the VIX is a single number—a simple "fear gauge." This is a dangerously incomplete view. The VIX is not a single data point; it is the observable surface of a deep, complex, multi-dimensional field of information. Its true power lies not in its absolute level, but in its relationship to itself across time (its slope), its relationship to its future expectations (its term structure), and its relationship to the market's actual, realized volatility (the volatility risk premium). The DAFE VIX Intelligence Engine was created to provide a complete, institutional-grade view of this hidden information field. This script is not a simple "mashup" of existing indicators; it is a foundational, original work that introduces a suite of proprietary algorithms and concepts to the TradingView platform. It deconstructs the entire VIX complex and analyzes it through the lens of quantitative finance and statistical modeling. Its purpose is not to give you simple buy or sell signals. Its purpose is to provide you with a master "weather report" for the market. It answers the most critical questions a professional trader must ask before putting on any position: What is the current volatility regime? Is the market stable or fragile? And what is the probability that the entire environment is about to change? This is a tool for quantifying the unseen risks and opportunities in the market. █ CHAPTER 2: THE CORE INNOVATIONS - ORIGINALITY & USEFULNESS This engine's value is rooted in its synthesis of concepts from professional derivatives analysis, applied to the VIX in a novel and accessible way. Every component is designed to extract a unique and powerful layer of intelligence. Multi-Source Data Ingestion & Validation: The engine doesn't just rely on the standard VIX. It intelligently pulls data from the entire VIX family, including the VIX9D (9-day VIX) and VX1! (the front-month VIX future). Crucially, it includes a sophisticated Stale Data Detection system. If it detects that the CBOE data is not updating (a common issue), it seamlessly falls back to a high-fidelity Realized Volatility model (blending Parkinson and Yang-Zhang estimators), ensuring you always have a reliable reading. Term Structure Analysis: This is the heart of the engine and a concept rarely seen outside of institutional platforms. It analyzes the slope of the VIX futures curve (VX1! - VIX) to determine if the market is in Contango (normal, calm) or Backwardation (stressed, fearful). An inverted term structure is one of the most reliable leading indicators of market stress. Volatility Surprise (VRP) Engine: The engine quantifies the Volatility Risk Premium by comparing implied volatility (the VIX) to the actual, historical realized volatility of the underlying asset. This allows it to detect when "fear is overpriced" (VIX is much higher than reality, a potential bullish signal for equities) or "fear is underpriced" (VIX is lower than reality, signaling dangerous complacency). Probabilistic Regime Transition Model: This is the engine's predictive powerhouse. It doesn't just tell you the current regime; it calculates the probability of a transition. It does this by analyzing the "acceleration" of key volatility metrics—the rate of change of the term structure slope, the rate of change of realized volatility, and the "mean-reversion pressure" building up in the system. A high transition probability is a powerful early warning that the entire market character is about to shift. Intelligent Instrument Profiling: The engine includes a smart detection system that identifies the asset you are trading (e.g., NQ, ES, BTC, Gold) and automatically applies a pre-calibrated "Sensitivity Profile." It understands that a VIX of 25 has a different implication for Nasdaq than it does for Bitcoin, and it adjusts its risk calculations accordingly. █ CHAPTER 3: THE ANALYTICAL PIPELINE - HOW THE ENGINE THINKS The VIX Intelligence Engine operates on a clear, five-stage pipeline to transform raw data into high-level intelligence. STAGE 1: DATA INGESTION & VALIDATION: The engine pulls data from VIX, VIX9D, and VX1!. It simultaneously calculates the realized volatility of the primary asset. It runs a continuous check for stale data. If the VIX data is found to be stale, it transparently switches to a fallback model, blending the last known VIX value with the live realized volatility reading. STAGE 2: MULTI-DIMENSIONAL ANALYSIS: The validated volatility data is analyzed across four key dimensions: Level: The raw VIX value is converted to a Z-Score to measure its statistical rarity. Slope: The rate of change of the VIX is calculated to measure its momentum. Term Structure: The VX1! - VIX spread and the VIX9D - VIX spread are calculated to determine the shape of the futures curve. Surprise: The VIX - Realized Volatility spread is calculated to quantify the Volatility Risk Premium. STAGE 3: REGIME CLASSIFICATION: A weighted scoring model synthesizes all the metrics from Stage 2 to classify the market into one of seven distinct volatility regimes: Compression, Low Vol, Normal, Elevated, Expansion, Panic, or Euphoria. Each regime is assigned a color and a confidence score. STAGE 4: TRANSITION PROBABILITY: This is the predictive layer. The engine analyzes the second derivative (acceleration) of its core metrics. A sharp acceleration in the term structure slope, combined with a build-up of mean-reversion pressure, will result in a high "Transition Probability" score, warning you that the current regime is becoming unstable. STAGE 5: FINAL OUTPUT & VISUALIZATION: All of this intelligence is rendered into the intuitive lower pane display, the on-chart detection dots, and the comprehensive dashboard. █ CHAPTER 4: A GUIDE FOR DEVELOPERS - INTEGRATING THE ENGINE This script is published as a standalone indicator, but its core logic is designed to be extracted and used as a library. This guide provides the complete input template and a conceptual workflow for integrating this VIX intelligence into your own systems. PART I: THE INPUTS TEMPLATE (THE CONTROL PANEL) To give your users full control over the VIX engine, you can replicate these inputs in your own script. // ╔═════════════════════════════════════════════════════╗ // ║ INPUTS TEMPLATE (COPY INTO YOUR SCRIPT) ║ // ╚═════════════════════════════════════════════════════╝ // INPUT GROUPS string GRP_ENGINE = "══════════ 🌡️ VIX ENGINE ══════════" string GRP_DISPLAY = "══════════ 📊 DISPLAY LAYERS ══════════" string GRP_DETECT = "══════════ 🔍 DETECTION OVERLAYS ══════════" string GRP_VIZ = "══════════ 🎨 VISUALIZATION ══════════" string GRP_DASH = "══════════ 📋 DASHBOARD ══════════" // VIX ENGINE int i_zLookback = input.int(50, "Z-Score Lookback", minval=20, maxval=200, group=GRP_ENGINE, tooltip="Normalization period for all Z-score calculations. • 30-40: Adaptive • 50: Standard • 100+: Very stable") int i_rvLookback = input.int(20, "Realized Vol Lookback", minval=10, maxval=50, group=GRP_ENGINE, tooltip="Lookback for Parkinson + Yang-Zhang realized volatility estimators.") // DISPLAY LAYERS bool i_showVixLevel = input.bool(true, "Show VIX Level Z-Score", group=GRP_DISPLAY) bool i_showVixSlope = input.bool(true, "Show VIX Slope", group=GRP_DISPLAY) bool i_showTermStructure = input.bool(true, "Show Term Structure", group=GRP_DISPLAY) bool i_showVolSurprise = input.bool(true, "Show Vol Surprise", group=GRP_DISPLAY) bool i_showTransition = input.bool(true, "Show Transition Probability", group=GRP_DISPLAY) bool i_showDangerBar = input.bool(true, "Show Danger Bar", group=GRP_DISPLAY) // DETECTION OVERLAYS bool i_showRegimeDots = input.bool(true, "Show Regime Detection Dots", group=GRP_DETECT) bool i_showTransitionWarning = input.bool(true, "Show Transition Warnings", group=GRP_DETECT) bool i_showStaleDots = input.bool(true, "Show Stale Data Warnings", group=GRP_DETECT) bool i_showSurpriseDetection = input.bool(true, "Show Vol Surprise Detections", group=GRP_DETECT) float i_transitionThreshold = input.float(0.4, "Transition Warning Threshold", minval=0.1, maxval=0.9, step=0.05, group=GRP_DETECT) // VISUALIZATION & DASHBOARD string i_vizMode = input.string("Layered Analysis", "Visualization Mode", options= , group=GRP_VIZ) string i_colorTheme = input.string("Quantum Dark", "Color Theme", options= , group=GRP_VIZ) bool i_showDash = input.bool(true, "Show Dashboard", group=GRP_DASH) // ... other dash inputs PART II: THE IMPLEMENTATION WORKFLOW (CONCEPTUAL) If this were a library, here is how you would use its exported functions to build a sophisticated signal filter. // import DskyzInvestments/DafeVIXEngineLib/1 as vix // // // 1. INITIALIZE & RUN THE ENGINE (happens on every bar) // // The engine would contain all the logic from this indicator. // = vix.run_analysis(zLookback, rvLookback) // // // 2. USE THE INTELLIGENCE TO CREATE FILTERS FOR YOUR STRATEGY // // // A simple trend-following strategy // bool my_buy_signal = ta.crossover(ta.ema(close, 20), ta.ema(close, 50)) // bool my_sell_signal = ta.crossunder(ta.ema(close, 20), ta.ema(close, 50)) // // // --- Build the VIX Filter --- // // We only want to take trend-following trades if the VIX engine confirms a stable, low-volatility environment. // bool vix_filter_pass = state.regime_id <= 2 and // Must be in "Normal" regime or better // state.transition_prob < 0.5 and // Regime must be stable // state.danger_score < 50 and // Overall danger must be low // state.data_confidence > 0.7 // VIX data must be reliable // // // --- Apply the filter to your signals --- // bool final_buy_signal = my_buy_signal and vix_filter_pass // bool final_sell_signal = my_sell_signal and vix_filter_pass // // // 3. PLOT YOUR FILTERED SIGNALS // plotshape(final_buy_signal, "Filtered Buy", ...) /pine] █ CHAPTER 5: A VISUAL GUIDE - DECODING THE DISPLAYS THE ON-CHART OVERLAYS (THE DOTS) These dots are your real-time alerts, plotted directly on the price chart. Colored Dots (Above Price): These are the Regime Detection Dots . Their color corresponds to the currently detected volatility regime (e.g., Green for Low Vol, Yellow for Elevated, Red for Panic). Their transparency indicates the confidence of the classification—a solid dot is a high-confidence reading. Purple Dots (Below Price): These are the Transition Warning Dots . They appear when the engine's predictive model calculates a high probability that the market regime is about to shift. This is a critical early warning to tighten stops or defer new entries. Gold/Red Dots (Below Price): These are the Volatility Surprise Detections . A gold dot signals that fear is significantly "overpriced" (VIX > RV), a condition that often precedes a bounce in equities. A red dot signals that fear is "underpriced" (VIX < RV), indicating dangerous complacency. Gray Dots (Below Price): These are Stale Data Warnings , providing transparent feedback that the engine is currently operating in its fallback mode using realized volatility. THE LOWER INDICATOR PANE (THE ENGINE ROOM) This is where the raw data from all analytical layers is visualized. Choose from four distinct modes: Layered Analysis: The default professional view. Each major component (VIX Level, Slope, Term Structure, Surprise, Transition Prob) gets its own layer, allowing you to see which factor is driving the current analysis. Regime Heatmap: A color-block visualization where the color of each block is determined by a specific metric's state, creating a "heatmap" of market risk. Oscillator Stack: Renders the core metrics as a set of zero-centric oscillators, ideal for spotting momentum and divergences within the volatility data itself. Risk Waterfall: A unique cascading visualization that cumulatively stacks the risk from each component, with the final line representing the total, blended risk assessment. THE DASHBOARD (MISSION CONTROL) The dashboard is a comprehensive, institutional-grade summary of the entire VIX ecosystem. VIX Family Data: Displays the live values for VIX, VIX9D, and VX1!, along with a data confidence score. Instrument Profile: Shows the detected asset and its automatically applied sensitivity profile. State Variables: The core Z-Score and Slope readings that power the engine. Volatility Regime: The final, classified regime name, its duration, and the confidence of the reading. Term Structure: A complete breakdown of the VIX curve analysis, showing the state (Contango/Backwardation), the slope, and the level of inversion. Vol Surprise: Quantifies the Volatility Risk Premium, showing the spread between Implied and Realized vol and classifying it as "Overpriced" or "Underpriced." Transition Engine: The predictive output, showing the raw Transition Probability and the predicted next regime. Danger Assessment: The final, synthesized "Danger Score" from 0-100, providing a single, unambiguous measure of market fragility. █ DEVELOPMENT PHILOSOPHY The DAFE VIX Intelligence Engine was born from the conviction that volatility is the master variable in all financial markets. By deconstructing the VIX complex and analyzing its components through the lens of quantitative finance, we have created a tool that provides a level of contextual awareness previously unavailable to retail traders. This is not just about measuring fear; it's about understanding its structure, its momentum, and its probable future state. It is a tool for quantifying the unseen. █ DISCLAIMER & IMPORTANT NOTES THIS IS AN ADVANCED ANALYTICAL TOOL: This indicator provides intelligence on market volatility, not direct buy or sell signals. It is designed to be used as a master filter and contextual guide for your existing trading strategies. DATA DEPENDENCY: The accuracy of the engine is dependent on a live, reliable data feed for the CBOE VIX family. While the engine has a robust fallback system, its full power is realized with live data. ALL TRADING INVOLVES RISK: The probabilities and classifications are based on historical statistical models. They are a powerful edge, not a guarantee of future outcomes. Create with DAFE.
Biblioteca Pine Script®
por DskyzInvestments
MovingAveragesLibrary "MovingAverages" A collection of O(1) numerically stable moving averages that support anchors and fractional lengths up to 100k bars. Pine Script has a robust set of moving averages suitable for a majority of cases, making these alternatives useful only if you need anchoring, fractional lengths, or more than 5k bars. Included are the classic SMA , EMA , RMA , WMA , VWMA , VWAP , HMA , SWMA , Linear Regression , and ATR . The common parameters are: source (float) : Series of values to process. length (simple float) : Number of bars. Optional. anchor (bool) : The condition that triggers a calculation reset. Optional. parity (simple bool) : Sets if built-in function should be used. Optional. Other DSP filter adaptations include One Euro , Laguerre , Super Smoother , and Holt , as well as rate limiting functions such as Smooth Damp and Slew Rate Limiter . ANCHORING This is the libraries first and primary benefit. Akin to the built-in VWAP, anchoring is managed by passing a series bool into the function. For sessional anchoring, the included new_session() returns true on the first bar of intraday sessions, and stabilize_anchor() helps reduce near-anchor volatility. When no length is provided, the series continues indefinitely until a new anchor is set. Values during the warmup period are returned. source = close length = 9.5 anchor = ma.new_session() // Assumes library is imported as "ma" swma = ma.swma(source, length, anchor).stabilize_anchor(source, length, anchor) STREAMING UPDATES Rather than naively using loops to recalculate the whole series on each bar, linear interpolation (aka. "lerping") is used to incrementally update and translate between values. The canonical formula being: a + (b - a) * t. This formula is effectively an EMA, but it's applicable to nearly all averaging equations. Coupling this technique with a circular buffer captures 3 of the 5 benefits this library offers: O(1) computation, fractional lengths, and 100k bars. NUMERIC STABILITY The last benefit is how the library minimizes floating point errors. When possible, Pine Script functions are used for mathematical parity. Otherwise Kahan summation error compensation is used when calculating an average. Not only does this keep custom implementations stable throughout the series, it also helps keep them within 1.0e-10 of the built-in functions. Automatically defaulting to the built-in functions can be disabled by setting parity to false .
Biblioteca Pine Script®
por liquid-trader
blueprint_ephemeris_lib🔭 Library blueprint_ephemeris_lib Consolidated planetary ephemeris library with improved accuracy. Supersedes previous individual planet libraries (lib_vsop_core, lib_vsop_mercury, lib_vsop_venus, etc.). One import gives you geocentric/heliocentric positions for all 10 solar system bodies. █ ACCURACY — VALIDATED AGAINST JPL DE440 Every planetary body was validated against NASA's DE440 ephemeris (via Skyfield). Using only 1.6% of the full VSOP87D theory (511 of 31,577 terms), this library achieves sub-arcminute accuracy for all planets: Sun 0.004° (14 arcseconds) Mercury 0.005° (18") Venus 0.006° (22") Mars 0.010° (36") Jupiter 0.007° (25") Saturn 0.009° (32") Uranus 0.013° (47") Neptune 0.017° (61") Moon 0.062° (3.7') Pluto 0.059° (3.5') All bodies under 0.1° RMS — more than sufficient for aspect calculations, ingress timing, and planetary line work. The Sun is accurate to 14 arcseconds using a truncated series that fits entirely inside Pine Script's token limits. █ WHAT'S NEW (V2) The original ephemeris required 11 chained library imports. A full validation audit uncovered critical coefficient errors and motivated this rewrite: • L1 Precession Fix — All 8 VSOP87 planets had incorrect longitude rate coefficients (VSOP87B values instead of VSOP87D). Each was missing +0.24382 rad/millennium of general precession. This single correction reduced error from ~0.75° to < 0.1° across the board. • 28% Smaller — 4,300 lines across 11 files → ~3,100 lines in 1 file. • Single Import — No dependency chain. Faster execution. • Moon Improvements — Functions accept raw `time` directly. Node functions renamed with explicit north/south designation. █ THEORIES VSOP87D (Bretagnon & Francou, 1988) — Mercury through Neptune 511 truncated terms out of 31,577 total (1.6%). Heliocentric spherical coordinates in the ecliptic of date. ELP2000-82 (Chapront-Touzé & Chapront, 1983) — Moon 91 terms (48 longitude + 43 latitude) from Meeus Chapter 47. Meeus Series (Meeus, 1998) — Pluto Analytical series from "Astronomical Algorithms" Ch. 37. Valid ±1 century from J2000. █ HOW TO USE Import the library: import BlueprintResearch/blueprint_ephemeris_lib/1 as eph Basic — plot a planet's geocentric longitude and declination: float jupiter_lon = eph.get_longitude(eph.Planet.Jupiter, time, true) float jupiter_decl = eph.get_declination(eph.Planet.Jupiter, time) plot(jupiter_lon, "Jupiter Geo Lon", color.yellow) plot(jupiter_decl, "Jupiter Decl", color.red) Retrograde detection: bool mercury_retro = eph.is_retrograde(eph.Planet.Mercury, time) bgcolor(mercury_retro ? color.new(color.red, 90) : na) Moon nodes and declination: float north_node = eph.get_mean_north_node_lon(time) float south_node = eph.get_mean_south_node_lon(time) float moon_decl = eph.get_declination(time) plot(north_node, "North Node", color.green) plot(south_node, "South Node", color.purple) plot(moon_decl, "Moon Declination", color.orange) Dynamic planet selection from input: string planet_str = input.string("Sun", "Planet", options= ) eph.Planet p = eph.string_to_planet(planet_str) float geo = eph.get_longitude(p, time, true) float helio = eph.get_longitude(p, time, false) float speed = eph.get_speed(p, time) plot(geo, "Geocentric", color.yellow) plot(helio, "Heliocentric", color.blue) plot(speed * 100, "Speed x100", color.white) All functions accept TradingView's `time` variable directly. █ FUNCTIONS Unified API (all planets): `get_longitude(Planet, time, preferGeo)` — geo or heliocentric longitude `get_declination(Planet, time)` — equatorial declination `get_speed(Planet, time)` — longitude speed (°/day) `is_retrograde(Planet, time)` — true when retrograde `string_to_planet(string)` — name to enum Averages : `get_avg6_geo_lon` / `get_avg6_helio_lon` — Mercury–Saturn `get_avg8_geo_lon` / `get_avg8_helio_lon` — Mercury–Neptune Moon (direct access): `get_geo_ecl_lon(time)` · `get_geo_ecl_lat(time)` · `get_declination(time)` `get_mean_north_node_lon(time)` · `get_mean_south_node_lon(time)` `get_true_north_node_lon(time)` · `get_true_south_node_lon(time)` `get_north_node_declination(time)` · `get_south_node_declination(time)` █ LIMITATIONS • Truncated series — sub-degree accuracy, not sub-arcsecond. More than sufficient for ingress timing and aspect work. • Validated against DE440 across 250 years (1850–2100). Over this full span, the worst-case VSOP87 planet (Uranus) is 0.017° RMS / 0.043° max error. Ingress dates manually verified back to the late 1800s with consistent accuracy. • Pluto uses Meeus series, limited to ±1 century from J2000. • Moon has no speed function. █ ACKNOWLEDGMENTS Coefficient validation was made possible by Greg Miller's VSOP87 multi-language project, which provides the complete VSOP87D coefficient tables in accessible formats. His work converting the original Fortran data files into CSV/JSON for multiple languages was essential for identifying the L1 precession errors in the original libraries. Miller released this work into the public domain. github.com/gmiller123456/vsop87-multilang References : • Meeus, Jean. Astronomical Algorithms (2nd Ed., 1998) • Bretagnon & Francou. VSOP87 Solutions (Astronomy & Astrophysics, 1988) • Chapront-Touzé & Chapront. ELP2000-82 (1983) █ OPEN SOURCE MIT License — part of the Blueprint Research open-source toolkit. Source code on GitHub get_geo_ecl_lon(time_)   Returns geocentric ecliptic longitude of the Moon.   Parameters:      time_ (float)   Returns: (float) Longitude in degrees, range [0, 360). get_geo_ecl_lat(time_)   Returns geocentric ecliptic latitude of the Moon.   Parameters:      time_ (float)   Returns: (float) Latitude in degrees. get_obliquity_j(time_)   Returns mean obliquity of the ecliptic.   Parameters:      time_ (float)   Returns: (float) Obliquity in degrees. get_declination(time_)   Returns geocentric equatorial declination of the Moon.   Parameters:      time_ (float)   Returns: (float) Declination in degrees, range where positive is north. get_declination(p, t)   Returns planetary geocentric equatorial declination.   Parameters:      p (series Planet) : (Planet) Planet to query.      t (float) : (float) Unix timestamp in milliseconds (use built-in 'time' variable).   Returns: (float) Geocentric declination in degrees, range where positive is north. @note Declination is always geocentric (no heliocentric equivalent in library). get_mean_north_node_lon(time_)   Returns mean longitude of the Moon's North Node (ascending node).   Parameters:      time_ (float)   Returns: (float) Longitude in degrees, range [0, 360). @note Mean node is a simple averaged calculation, reducing computational error. Used for declination calculations. get_mean_south_node_lon(time_)   Returns mean longitude of the Moon's South Node (descending node).   Parameters:      time_ (float)   Returns: (float) Longitude in degrees, range [0, 360). Equals North Node + 180°. get_true_north_node_lon(time_)   Returns true longitude of the Moon's North Node with perturbation corrections.   Parameters:      time_ (float)   Returns: (float) Longitude in degrees, range [0, 360). @note True node includes periodic perturbations but formula is low precision. Consider using mean node for consistency. get_true_south_node_lon(time_)   Returns true longitude of the Moon's South Node with perturbation corrections.   Parameters:      time_ (float)   Returns: (float) Longitude in degrees, range [0, 360). Equals True North Node + 180°. get_north_node_declination(time_)   Returns declination of the Moon's North Node.   Parameters:      time_ (float)   Returns: (float) Declination in degrees, range (bounded by obliquity). @note Uses mean node for calculation (more consistent than true node). get_south_node_declination(time_)   Returns declination of the Moon's South Node.   Parameters:      time_ (float)   Returns: (float) Declination in degrees. Inverse of North Node declination. normalizeLongitude(lon)   Normalizes any longitude value to the range [0, 360) degrees.   Parameters:      lon (float) : (float) Longitude in degrees (can be any value, including negative or >360).   Returns: (float) Normalized longitude in range [0, 360). string_to_planet(planetStr)   Converts a planet string identifier to Planet enum value.   Parameters:      planetStr (string) : (string) Planet name (case-insensitive). Supports formats: "Sun", "☉︎ Sun", "sun", "SUN"   Returns: (Planet) Corresponding Planet enum. Returns Planet.Sun if string not recognized. @note Supported planet strings: Sun, Moon, Mercury, Venus, Earth, Mars, Jupiter, Saturn, Uranus, Neptune, Pluto get_longitude(p, t, preferGeo)   Returns planetary longitude with automatic coordinate system selection.   Parameters:      p (series Planet) : (Planet) Planet to query.      t (float) : (float) Unix timestamp in milliseconds (use built-in 'time' variable).      preferGeo (bool) : (bool) If true, return geocentric; if false, return heliocentric.   Returns: (float) Longitude in degrees, normalized to range [0, 360). @note Sun and Moon always return geocentric regardless of preference (heliocentric not applicable). get_speed(p, t)   Returns planetary geocentric longitude speed (rate of change).   Parameters:      p (series Planet) : (Planet) Planet to query.      t (float) : (float) Unix timestamp in milliseconds (use built-in 'time' variable).   Returns: (float) Geocentric longitude speed in degrees per day. Negative values indicate retrograde motion. Returns na for Moon. @note Speed is always geocentric (no heliocentric equivalent in library). Moon speed calculation not implemented. get_avg6_geo_lon(t)   get_avg6_geo_lon @description Returns the arithmetic average of the geocentric longitudes for the six outer planets: Mars, Jupiter, Saturn, Uranus, Neptune, and Pluto.   Parameters:      t (float) : (float) Time in Unix timestamp (milliseconds).   Returns: (float) Average geocentric longitude of the six outer planets in degrees, range [0, 360). get_avg6_helio_lon(t)   get_avg6_helio_lon @description Returns the arithmetic average of the heliocentric longitudes for the six outer planets: Mars, Jupiter, Saturn, Uranus, Neptune, and Pluto.   Parameters:      t (float) : (float) Time in Unix timestamp (milliseconds).   Returns: (float) Average heliocentric longitude of the six outer planets in degrees, range [0, 360). get_avg8_geo_lon(t)   get_avg8_geo_lon @description Returns the arithmetic average of the geocentric longitudes for all eight classical planets: Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, and Pluto.   Parameters:      t (float) : (float) Time in Unix timestamp (milliseconds).   Returns: (float) Average geocentric longitude of all eight classical planets in degrees, range [0, 360). get_avg8_helio_lon(t)   get_avg8_helio_lon @description Returns the arithmetic average of the heliocentric longitudes for all eight classical planets: Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, and Pluto.   Parameters:      t (float) : (float) Time in Unix timestamp (milliseconds).   Returns: (float) Average heliocentric longitude of all eight classical planets in degrees, range [0, 360). is_retrograde(p, t)   Returns true if the planet is currently in retrograde motion (geocentric speed < 0) == 0 = stationary.   Parameters:      p (series Planet) : The planet to check.      t (float) : Time in Unix timestamp (milliseconds).   Returns: true if the planet is in retrograde, false otherwise.
Biblioteca Pine Script®
por BlueprintResearch
3
DafePatternsLibDafePatternLib: The Adaptive Pattern Recognition Engine DafePatternLib is not a static pattern library. It is an adaptive recognition engine. It doesn't just find patterns; it tracks, weights, and filters them based on their performance in the live market. █ CHAPTER 1: THE PHILOSOPHY — BEYOND STATIC RULES, INTO DYNAMIC LEARNING For decades, chart pattern analysis has been trapped in a rigid paradigm. An indicator coded to find a "Bullish Engulfing" will signal that pattern with the same confidence every time, regardless of whether it has been failing consistently for weeks. It has no memory and no ability to adapt. DafePatternLib was created to change this. It is built on a performance-based reinforcement framework. This library is not just a collection of detection functions; it is a self-weighting logic system. It tracks outcomes. It remembers what works. Over time, it amplifies the signals of high-probability patterns and filters out those that are failing in the current market regime. This is not a black box. It is an open-source, observable learning system. It strengthens and weakens its own internal weights based on positive and negative feedback, evolving into a tool adapted to the specific asset you are trading. █ CHAPTER 2: CORE INNOVATIONS This library introduces several advanced concepts for algorithmic analysis: Reinforcement Learning Engine: The core of the system. Every high-confidence pattern is logged into "Active Memory." The library tracks the outcome against projected stops and targets. If successful, the weight for that pattern category is strengthened. If it fails, the weight is reduced. This creates a continuous feedback loop. Adaptation Rate (Plasticity): You have direct control over the engine's "plasticity"—its ability to learn. High plasticity allows fast adaptation to new conditions; lower plasticity creates a stable, long-term model. Dynamic Volatility Scaling (DVS): Markets breathe. DVS is a proprietary function that calculates a real-time volatility scalar by comparing current ATR to historical averages. This scalar automatically adjusts lookback periods and sensitivities. In high volatility, engines look for larger structures; in low volatility, they tighten focus. Smart Confidence Score: The output is not a simple "true/false." Every pattern includes two scores: • Raw Confidence: Static confidence based on the pattern's textbook definition. • Net Confidence: The adaptive score (Raw Confidence × Learned Bias). A performing pattern sees its confidence boosted; a failing pattern gets penalized. Intelligent Filtering: If the learned bias for a category (e.g., "Candle") drops below a threshold (e.g., 0.8), the library automatically filters those signals, treating them as low-probability noise until performance improves. █ CHAPTER 3: ANATOMY OF THE LOGIC — HOW IT THINKS The LogicWeights (The Core) The central data structure holding the system's "memory." It stores a floating-point weight or "bias" for each of the five major categories (Candle, Harmonic, Structure, Geometry, VSA). Initialized at 1.0 (neutral). update_core() (The Learning Process) The heart of the reinforcement loop. When a pattern resolves (win/loss), this function applies a positive or negative adjustment to the corresponding category weight. Weights are constrained between 0.5 (distrust) and 2.0 (trust). manage_memory() (Short-Term Memory) Maintains an array of active signals. On every bar, it checks if targets or stops have been hit. Resolved patterns trigger update_core(). Unresolved patterns eventually expire, applying a minor penalty to discourage stagnation. scan_pattern_universe() (Master Controller) The main exported function. On every bar, it: Calculates the Dynamic Volatility Scalar (DVS). Runs all pattern detection engines (VSA, Geometry, Candles, etc.) adapted to DVS. Identifies the single best pattern based on raw confidence. Passes it to memory for tracking. Applies the learned bias to calculate Net Confidence. Returns the final, adaptively weighted PatternResult. █ CHAPTER 4: DEVELOPER INTEGRATION GUIDE Designed for simplicity and power. 1. Import the Library: import DskyzInvestments/DafePatternLib/1 as pattern 2. Call the Scanner: The library handles DVS, scanning, memory, and learning internally. pattern.PatternResult signal = pattern.scan_pattern_universe() 3. Use the Result: if signal.is_active label.new(bar_index, signal.entry, "Conf: " + str.tostring(signal.net_confidence, "#") + "%") With just these lines, you integrate a self-weighting, multi-pattern recognition engine. █ INPUTS TEMPLATE (COPY INTO YOUR SCRIPT) // ═══════════════════════════════════════════════════════════ // INPUT GROUPS // ═══════════════════════════════════════════════════════════ string G_AI_ENGINE = "══════════ 🧠 LOGIC ENGINE ══════════" string G_AI_PATTERNS = "══════════ 🔬 PATTERN SELECTION ══════════" string G_AI_VISUALS = "══════════ 🎨 VISUALS & SIGNALS ══════════" string G_AI_DASH = "══════════ 📋 LOGIC STATE DASHBOARD ══════════" string G_AI_ALERTS = "══════════ 🔔 ALERTS ══════════" // ═══════════════════════════════════════════════════════════ // LOGIC ENGINE CONTROLS // ═══════════════════════════════════════════════════════════ bool i_enable_ai = input.bool(true, "✨ Enable Adaptive Engine", group = G_AI_ENGINE, tooltip="Master switch to enable the pattern recognition and learning system.") float i_plasticity = input.float(0.03, "Adaptation Rate", minval=0.01, maxval=0.1, step=0.01, group = G_AI_ENGINE, tooltip="Controls adaptation speed. • Low (0.01-0.02): Stable learning. • Medium (0.03-0.05): Balanced. • High (0.06+): Fast adaptation.") float i_filter_threshold = input.float(0.8, "Adaptive Filter Threshold", minval=0.5, maxval=1.0, step=0.05, group = G_AI_ENGINE, tooltip="Hide signals from categories with a learned bias below this value.") // ═══════════════════════════════════════════════════════════ // PATTERN SELECTION // ═══════════════════════════════════════════════════════════ bool i_scan_candles = input.bool(true, "🕯️ Candlestick Patterns", group = G_AI_PATTERNS, inline="row1") bool i_scan_vsa = input.bool(true, "📦 Volume Spread Analysis", group = G_AI_PATTERNS, inline="row1") bool i_scan_geometry = input.bool(true, "📐 Geometric Patterns", group = G_AI_PATTERNS, inline="row2") bool i_scan_structure = input.bool(true, "📈 Market Structure (SMC)", group = G_AI_PATTERNS, inline="row2") bool i_scan_harmonic = input.bool(false, "🦋 Harmonic Setups", group = G_AI_PATTERNS, inline="row3") // ═══════════════════════════════════════════════════════════ // VISUALS & DASHBOARD // ═══════════════════════════════════════════════════════════ bool i_show_signals = input.bool(true, "Show Signals", group = G_AI_VISUALS) bool i_show_dashboard = input.bool(true, "Show Logic Dashboard", group = G_AI_DASH) █ DEVELOPMENT PHILOSOPHY DafePatternLib was born from a vision to bring dynamic logic to technical analysis. We believe an indicator should not be a static tool, but an intelligent partner that adapts. This library is an open-source framework empowering developers to build the next generation of smart indicators. █ DISCLAIMER • LIBRARY FOR DEVELOPERS: This script produces no visual output on its own. It is an engine for developers. • ADAPTIVE, NOT PREDICTIVE: Reinforcement learning optimizes based on recent history. It is a statistical edge, not a crystal ball. • RISK WARNING: Patterns and confidence scores are for informational purposes. "The key to trading success is emotional discipline. If intelligence were the key, there would be a lot more people making money trading." — Victor Sperandeo Create with DAFE.
Biblioteca Pine Script®
por DskyzInvestments
WickPressureLibWickPressureLib: The Regime Dynamics Engine DESCRIPTION: WickPressureLib/b] is not a standard candlestick pattern library. It is an advanced analytical engine designed to deconstruct the internal dynamics of price action. It provides a definitive toolkit for analyzing candle microstructure and quantifying order flow pressure through statistical modeling. █ CHAPTER 1: THE PHILOSOPHY — BEYOND PATTERNS, INTO DYNAMICS A candlestick wick represents a specific market event: a rejection of price. Traditional analysis often labels these simply as "bullish" or "bearish." This library aims to go deeper by treating each candle as a dataset of opposing forces. The WickPressureLib translates static price action into dynamic metrics. It deconstructs the candle into core components and subjects them to multi-layered analysis. It calculates Kinetic Force , estimates institutional Delta , tracks the Siege Decay of key levels, and uses Thompson Sampling (a Bayesian probability algorithm) to assess the statistical weight of each formation. This library does not just identify patterns; it quantifies the forces that create them. It is designed for developers who need quantitative, data-driven metrics rather than subjective interpretation. █ CHAPTER 2: THE ANALYTICAL PIPELINE — SIX LAYERS OF LOGIC The engine's capabilities come from a six-stage processing pipeline. Each layer builds upon the last to create a comprehensive data object. LAYER 1 — DELTA ESTIMATION: Uses a proprietary model to approximate order flow (Delta) within a single candle based on the relationship between wicks, body, and total range. LAYER 2 — SIEGE ANALYSIS: A concept for measuring structural integrity. Every time a price level is tested by a wick, its "Siege Decay" score is updated. Repeated tests without a breakout result in a decayed score, indicating weakening support/resistance. LAYER 3 — MAGNETISM ENGINE: Calculates the probability of a wick being "filled" (mean reversion) based on trend strength and volume profile. Distinguishes between rejection wicks and exhaustion wicks. LAYER 4 — REGIME DETECTION: Context-aware analysis using statistical tools— Shannon Entropy (disorder), DFA (trend vs. mean-reversion), and Hurst Exponent (persistence)—to classify the market state (e.g., "Bull Trend," "Bear Range," "Choppy"). LAYER 5 — ADAPTIVE LEARNING (THOMPSON SAMPLING): Uses a Bayesian Multi-Armed Bandit algorithm to track performance. It maintains a set of "Agents," each tracking a different wick pattern type. Based on historical outcomes, the system updates the probability score for each pattern in real-time. LAYER 6 — CONTEXTUAL ROUTING: The final layer of logic. The engine analyzes the wick, determines its pattern type, and routes it to the appropriate Agent for probability assessment, weighted by the current market regime. █ CHAPTER 3: CORE FUNCTIONS analyze_wick() — The Master Analyzer The primary function. Accepts a bar index and returns a WickAnalysis object containing over 15 distinct metrics: • Anomaly Score: Z-Score indicating how statistically rare the wick's size is. • Kinetic Force: Metric combining range and relative volume to quantify impact. • Estimated Delta: Approximation of net buying/selling pressure. • Siege Decay: Structural integrity of the tested level. • Magnet Score: Probability of the wick being filled. • Win Probability: Adaptive success rate based on the Thompson Sampling engine. scan_clusters() — Liquidity Zone Detection Scans recent price history to identify "Pressure Clusters"—zones where multiple high-pressure wicks have overlapped. Useful for finding high-probability supply and demand zones. detect_regime() — Context Engine Uses statistical methods to determine the market's current personality (Trending, Ranging, or Volatile). This output allows the analysis to adapt dynamically to changing conditions. █ CHAPTER 4: DEVELOPER INTEGRATION GUIDE This library is a low-level engine for building sophisticated indicators. 1. Import the Library: import DskyzInvestments/DafeWickLib/1 as wpk 2. Initialize the Agents: var agents = wpk.create_learning_agents() 3. Analyze the Market: regime = wpk.detect_regime(100) wick_data = wpk.analyze_wick(0, regime, agents) prob = wpk.get_probability(wick_data, regime) 4. Update Learning (Feedback Loop): agent_id = wpk.get_agent_by_pattern(wick_data) agents := wpk.update_learning_agent(agents, agent_id, 1.0) // +1 win, -1 loss █ CHAPTER 5: THE DEVELOPER'S FRAMEWORK — INTEGRATION GUIDE This library serves as a professional integration framework. This guide provides instructions and templates required to connect the DAFE components into a unified custom Pine Script indicator. PART I: THE INPUTS TEMPLATE (CONTROL PANEL) To provide users full control over the system, include the input templates from all connected libraries. This section details the bridge-specific controls. // ╔═════════════════════════════════════════════════════════╗ // ║ BRIDGE INPUTS TEMPLATE (COPY INTO YOUR SCRIPT) ║ // ╚═════════════════════════════════════════════════════════╝ // INPUT GROUPS string G_BRIDGE_MAIN = "════════════ 🌉 BRIDGE CONFIG ════════════" string G_BRIDGE_EXT = "════════════ 🌐 EXTERNAL DATA ════════════" // BRIDGE MAIN CONFIG float i_bridge_min_conf = input.float(0.55, "Min Confidence to Trade", minval=0.4, maxval=0.8, step=0.01, group=G_BRIDGE_MAIN, tooltip="Minimum blended confidence required for a trade signal.") int i_bridge_warmup = input.int(100, "System Warmup Bars", minval=50, maxval=500, group=G_BRIDGE_MAIN, tooltip="Bars required for data gathering before signals begin.") // EXTERNAL DATA SOCKETS bool i_ext_enable = input.bool(true, "🌐 Enable External Data Sockets", group=G_BRIDGE_EXT, tooltip="Enables analysis of external market data (e.g., VIX, DXY).") // Example for one external socket string i_ext1_name = input.string("VIX", "Socket 1: Name", group=G_BRIDGE_EXT, inline="ext1") string i_ext1_sym = input.symbol("TVC:VIX", "Symbol", group=G_BRIDGE_EXT, inline="ext1") string i_ext1_type = input.string("volatility", "Data Type", options= , group=G_BRIDGE_EXT, inline="ext1") float i_ext1_weight = input.float(1.0, "Weight", minval=0.1, maxval=2.0, step=0.1, group=G_BRIDGE_EXT, inline="ext1") PART II: IMPLEMENTATION LOGIC (THE CORE LOOP) This boilerplate code demonstrates the complete, unified pipeline structure. // ╔════════════════════════════════════════════════════════╗ // ║ USAGE EXAMPLE (ADAPT TO YOUR SCRIPT) ║ // ╚════════════════════════════════════════════════════════╝ // 1. INITIALIZE ENGINES (First bar only) var rl.RLAgent agent = rl.init(...) var spa.SPAEngine spa_engine = spa.init(...) var bridge.BridgeState bridge_state = bridge.init_bridge(i_spa_num_arms, i_rl_num_actions, i_bridge_min_conf, i_bridge_warmup) // 2. CONNECT SOCKETS (First bar only) if barstate.isfirst // Connect internal sockets agent := rl.connect_socket(agent, "rsi", ...) // Register external sockets if i_ext_enable ext_socket_1 = bridge.create_ext_socket(i_ext1_name, i_ext1_sym, i_ext1_type, i_ext1_weight) bridge_state := bridge.register_ext_socket(bridge_state, ext_socket_1) // 3. MAIN LOOP (Every bar) // --- A. UPDATE EXTERNAL DATA --- if i_ext_enable = request.security(i_ext1_sym, timeframe.period, ) bridge_state := bridge.update_ext_by_name(bridge_state, i_ext1_name, ext1_c, ext1_h, ext1_l) bridge_state := bridge.aggregate_ext_sockets(bridge_state) // --- B. RL/ML PROPOSES --- rl.RLState ml_state = rl.build_state(agent) = rl.select_action(agent, ml_state) agent := updated_agent // --- C. BRIDGE TRANSLATES --- array arm_signals = bridge.generate_arm_signals(ml_action.action, ml_action.confidence, i_spa_num_arms, i_rl_num_actions, 0) // --- D. SPA DISPOSES --- spa_engine := spa.feed_signals(spa_engine, arm_signals, close) = spa.select(spa_engine) spa_engine := updated_spa string arm_name = spa.get_name(spa_engine, selected_arm) // --- E. RECONCILE REGIME & COMPUTE RISK --- bridge_state := bridge.reconcile_regime(bridge_state, ml_regime_id, ml_regime_name, ml_conf, spa_regime_id, spa_conf, ...) float risk = bridge.compute_risk(bridge_state, ml_action.confidence, spa_conf, ...) // --- F. MAKE FINAL DECISION --- bridge_state := bridge.make_decision(bridge_state, ml_action.action, ml_action.confidence, selected_arm, arm_name, final_spa_signal, spa_conf, risk, 0.25) bridge.UnifiedDecision final_decision = bridge_state.decision // --- G. EXECUTE --- if final_decision.should_trade // Plot signals, manage positions based on final_decision.direction // --- H. LEARN (FEEDBACK LOOP) --- if (trade_is_closed) bridge_state := bridge.compute_reward(bridge_state, selected_arm, ...) agent := rl.learn(agent, ..., bridge_state.reward.shaped_reward, ...) // --- I. PERFORMANCE & DIAGNOSTICS --- bridge_state := bridge.update_performance(bridge_state, actual_market_direction) if barstate.islast label.new(bar_index, high, bridge.bridge_diagnostics(bridge_state), textalign=text.align_left) █ DEVELOPMENT PHILOSOPHY DafeMLSPABridge represents a hierarchical design philosophy. We believe robust systems rely not on a single algorithm, but on the intelligent integration of specialized subsystems. A complete trading logic requires tactical precision (ML), strategic selection (SPA), and environmental awareness (External Sockets). This library provides the infrastructure for these components to communicate and coordinate. █ DISCLAIMER & IMPORTANT NOTES • LIBRARY FOR DEVELOPERS: This script is an integration tool and produces no output on its own. It requires implementation of DafeRLMLLib and DafeSPALib. • COMPUTATION: Full bridged systems are computationally intensive. • RISK: All automated decisions are based on statistical probabilities from historical data. They do not predict future market movements with certainty. "The whole is greater than the sum of its parts." — Aristotle Create with DAFE.
Biblioteca Pine Script®
por DskyzInvestments