Começar

Indicadores e estratégias

HTFCandlesLibLibrary "HTFCandlesLib" Library to get detailed higher timeframe candle information method tostring(this, delimeter)   Returns OHLC values, BarIndex of higher and lower timeframe candles in string format   Namespace types: Candle   Parameters:      this (Candle) : Current Candle object      delimeter (string) : delimeter to join the string components of the candle   Returns: String representation of the Candle method draw(this, bullishColor, bearishColor, printDescription)   Draws the current candle using boxes and lines for body and wicks   Namespace types: Candle   Parameters:      this (Candle) : Current Candle object      bullishColor (color) : color for bullish representation      bearishColor (color) : color for bearish representation      printDescription (bool) : if set to true prints the description   Returns: Current candle object getCurrentCandle(ltfCandles)   Gets the current candle along with reassigned ltf components. To be used with request.security to capture higher timeframe candle data   Parameters:      ltfCandles (array) : Lower timeframe Candles array   Returns: Candle object with embedded lower timeframe key candles in them Candle   Candle represents the data related to a candle   Fields:      o (series float) : Open price of the candle      h (series float) : High price of the candle      l (series float) : Low price of the candle      c (series float) : Close price of the candle      lo (Candle) : Lower timeframe candle that records the open price of the current candle.      lh (Candle) : Lower timeframe candle that records the high price of the current candle.      ll (Candle) : Lower timeframe candle that records the low price of the current candle.      lc (Candle) : Lower timeframe candle that records the close price of the current candle.      barindex (series int) : Bar Index of the candle      bartime (series int) : Bar time of the candle      last (Candle) : Link to last candle of the series if any
Biblioteca Pine Script™
por Trendoscope
13
chartpatternsLibrary "chartpatterns" Library having complete chart pattern implementation method draw(this)   draws pattern on the chart   Namespace types: Pattern   Parameters:      this (Pattern) : Pattern object that needs to be drawn   Returns: Current Pattern object method erase(this)   erase the given pattern on the chart   Namespace types: Pattern   Parameters:      this (Pattern) : Pattern object that needs to be erased   Returns: Current Pattern object method findPattern(this, properties, patterns)   Find patterns based on the currect zigzag object and store them in the patterns array   Namespace types: zg.Zigzag   Parameters:      this (Zigzag type from Trendoscope/ZigzagLite/2) : Zigzag object containing pivots      properties (PatternProperties) : PatternProperties object      patterns (Pattern ) : Array of Pattern objects   Returns: Current Pattern object PatternProperties   Object containing properties for pattern scanning   Fields:      offset (series int) : Zigzag pivot offset. Set it to 1 for non repainting scan.      numberOfPivots (series int) : Number of pivots to be used in pattern search. Can be either 5 or 6      errorRatio (series float) : Error Threshold to be considered for comparing the slope of lines      flatRatio (series float) : Retracement ratio threshold used to determine if the lines are flat      checkBarRatio (series bool) : Also check bar ratio are within the limits while scanning the patterns      barRatioLimit (series float) : Bar ratio limit used for checking the bars. Used only when checkBarRatio is set to true      avoidOverlap (series bool)      patternLineWidth (series int) : Line width of the pattern trend lines      showZigzag (series bool) : show zigzag associated with pattern      zigzagLineWidth (series int) : line width of the zigzag lines. Used only when showZigzag is set to true      zigzagLineColor (series color) : color of the zigzag lines. Used only when showZigzag is set to true      showPatternLabel (series bool) : display pattern label containing the name      patternLabelSize (series string) : size of the pattern label. Used only when showPatternLabel is set to true      showPivotLabels (series bool) : Display pivot labels of the patterns marking 1-6      pivotLabelSize (series string) : size of the pivot label. Used only when showPivotLabels is set to true      pivotLabelColor (series color) : color of the pivot label outline. chart.bg_color or chart.fg_color are the appropriate values.      allowedPatterns (bool ) : array of bool encoding the allowed pattern types.      themeColors (color ) : color array of themes to be used. Pattern   Object containing Individual Pattern data   Fields:      pivots (Pivot type from Trendoscope/ZigzagLite/2) : array of Zigzag Pivot points      trendLine1 (Line type from Trendoscope/LineWrapper/1) : First trend line joining pivots 1, 3, 5      trendLine2 (Line type from Trendoscope/LineWrapper/1) : Second trend line joining pivots 2, 4 (, 6)      properties (PatternProperties) : PatternProperties Object carrying common properties      patternColor (series color) : Individual pattern color. Lines and labels will be using this color.      ratioDiff (series float) : Difference between trendLine1 and trendLine2 ratios      zigzagLine (series polyline) : Internal zigzag line drawing Object      pivotLabels (label ) : array containning Pivot labels      patternLabel (series label) : pattern label Object      patternType (series int) : integer representing the pattern type      patternName (series string) : Type of pattern in string
Biblioteca Pine Script™
por Trendoscope
15
GuageLibrary "Gauge" The gauge library utilizes a gaugeParams object, encapsulating crucial parameters for gauge creation. Essential attributes include num (the measured value) , min (the minimum value equating to 100% on the gauge's minimum scale) , and max (the maximum value equating to 100% on the gauge's maximum scale) . The size attribute (defaulting to 10) splits the scale into increments, each representing 100% divided by the specified size. The num value dynamically shifts within the gauge based on its percentage move from the mathematical average between min and max . When num is below the average, the minimum portion of the scale activates, displaying the appropriate percentage based on the distance from the average to the minimum. The same principle applies when num exceeds the average. The 100% scale is reached at either end when num equals min or max . The library offers full customization, allowing users to configure color schemes, labels, and titles. The gauge can be displayed either vertically (default) or horizontally. The colors employ a gradient, adapting based on the number's movement. Overall, the gauge library provides a flexible and comprehensive tool for visualizing and interpreting numerical values within a specified range.
Biblioteca Pine Script™
por faiyaz7283
10
MarketHolidaysLibrary "MarketHolidays" The MarketHolidays library compiles market holidays (including historical special market closures) into arrays, which can then be utilized in TradingView indicators and strategies to account for non-trading days. The datasets were split into different libraries to overcome compiling limitations, streamline the process of removing specific time frames if not needed, and to enhance code execution speed. The timestamps are generated using a custom Python script that employs the 'pandas_market_calendars' library. To build your own set of arrays, you can find the script and instructions at github.com getHolidays(_country)   The getHolidays function aggregates holiday data from different time periods to create a single array with market holidays for a specified country.   Parameters:      _country (string) : The country code for which to retrieve market holidays. Accepts syminfo.country or pre-set country code in ISO 3166-1 alpha-2 format.   Returns: An array of timestamps of market holidays \ non-trading days for the given country.
Biblioteca Pine Script™
por Protervus
3
SimilarityMeasuresLibrary "SimilarityMeasures" Similarity measures are statistical methods used to quantify the distance between different data sets or strings. There are various types of similarity measures, including those that compare: - data points (SSD, Euclidean, Manhattan, Minkowski, Chebyshev, Correlation, Cosine, Camberra, MAE, MSE, Lorentzian, Intersection, Penrose Shape, Meehl), - strings (Edit(Levenshtein), Lee, Hamming, Jaro), - probability distributions (Mahalanobis, Fidelity, Bhattacharyya, Hellinger), - sets (Kumar Hassebrook, Jaccard, Sorensen, Chi Square). --- These measures are used in various fields such as data analysis, machine learning, and pattern recognition. They help to compare and analyze similarities and differences between different data sets or strings, which can be useful for making predictions, classifications, and decisions. --- References: en.wikipedia.org cran.r-project.org numerics.mathdotnet.com github.com github.com github.com Encyclopedia of Distances, doi.org ssd(p, q)   Sum of squared difference for N dimensions.   Parameters:      p (float ) : `array` Vector with first numeric distribution.      q (float ) : `array` Vector with second numeric distribution.   Returns: Measure of distance that calculates the squared euclidean distance. euclidean(p, q)   Euclidean distance for N dimensions.   Parameters:      p (float ) : `array` Vector with first numeric distribution.      q (float ) : `array` Vector with second numeric distribution.   Returns: Measure of distance that calculates the straight-line (or Euclidean). manhattan(p, q)   Manhattan distance for N dimensions.   Parameters:      p (float ) : `array` Vector with first numeric distribution.      q (float ) : `array` Vector with second numeric distribution.   Returns: Measure of absolute differences between both points. minkowski(p, q, p_value)   Minkowsky Distance for N dimensions.   Parameters:      p (float ) : `array` Vector with first numeric distribution.      q (float ) : `array` Vector with second numeric distribution.      p_value (float) : `float` P value, default=1.0(1: manhatan, 2: euclidean), does not support chebychev.   Returns: Measure of similarity in the normed vector space. chebyshev(p, q)   Chebyshev distance for N dimensions.   Parameters:      p (float ) : `array` Vector with first numeric distribution.      q (float ) : `array` Vector with second numeric distribution.   Returns: Measure of maximum absolute difference. correlation(p, q)   Correlation distance for N dimensions.   Parameters:      p (float ) : `array` Vector with first numeric distribution.      q (float ) : `array` Vector with second numeric distribution.   Returns: Measure of maximum absolute difference. cosine(p, q)   Cosine distance between provided vectors.   Parameters:      p (float ) : `array` 1D Vector.      q (float ) : `array` 1D Vector.   Returns: The Cosine distance between vectors `p` and `q`. --- angiogenesis.dkfz.de camberra(p, q)   Camberra distance for N dimensions.   Parameters:      p (float ) : `array` Vector with first numeric distribution.      q (float ) : `array` Vector with second numeric distribution.   Returns: Weighted measure of absolute differences between both points. mae(p, q)   Mean absolute error is a normalized version of the sum of absolute difference (manhattan).   Parameters:      p (float ) : `array` Vector with first numeric distribution.      q (float ) : `array` Vector with second numeric distribution.   Returns: Mean absolute error of vectors `p` and `q`. mse(p, q)   Mean squared error is a normalized version of the sum of squared difference.   Parameters:      p (float ) : `array` Vector with first numeric distribution.      q (float ) : `array` Vector with second numeric distribution.   Returns: Mean squared error of vectors `p` and `q`. lorentzian(p, q)   Lorentzian distance between provided vectors.   Parameters:      p (float ) : `array` Vector with first numeric distribution.      q (float ) : `array` Vector with second numeric distribution.   Returns: Lorentzian distance of vectors `p` and `q`. --- angiogenesis.dkfz.de intersection(p, q)   Intersection distance between provided vectors.   Parameters:      p (float ) : `array` Vector with first numeric distribution.      q (float ) : `array` Vector with second numeric distribution.   Returns: Intersection distance of vectors `p` and `q`. --- angiogenesis.dkfz.de penrose(p, q)   Penrose Shape distance between provided vectors.   Parameters:      p (float ) : `array` Vector with first numeric distribution.      q (float ) : `array` Vector with second numeric distribution.   Returns: Penrose shape distance of vectors `p` and `q`. --- angiogenesis.dkfz.de meehl(p, q)   Meehl distance between provided vectors.   Parameters:      p (float ) : `array` Vector with first numeric distribution.      q (float ) : `array` Vector with second numeric distribution.   Returns: Meehl distance of vectors `p` and `q`. --- angiogenesis.dkfz.de edit(x, y)   Edit (aka Levenshtein) distance for indexed strings.   Parameters:      x (int ) : `array` Indexed array.      y (int ) : `array` Indexed array.   Returns: Number of deletions, insertions, or substitutions required to transform source string into target string. --- generated description: The Edit distance is a measure of similarity used to compare two strings. It is defined as the minimum number of operations (insertions, deletions, or substitutions) required to transform one string into another. The operations are performed on the characters of the strings, and the cost of each operation depends on the specific algorithm used. The Edit distance is widely used in various applications such as spell checking, text similarity, and machine translation. It can also be used for other purposes like finding the closest match between two strings or identifying the common prefixes or suffixes between them. --- github.com www.red-gate.com planetcalc.com lee(x, y, dsize)   Distance between two indexed strings of equal length.   Parameters:      x (int ) : `array` Indexed array.      y (int ) : `array` Indexed array.      dsize (int) : `int` Dictionary size.   Returns: Distance between two strings by accounting for dictionary size. --- www.johndcook.com hamming(x, y)   Distance between two indexed strings of equal length.   Parameters:      x (int ) : `array` Indexed array.      y (int ) : `array` Indexed array.   Returns: Length of different components on both sequences. --- en.wikipedia.org jaro(x, y)   Distance between two indexed strings.   Parameters:      x (int ) : `array` Indexed array.      y (int ) : `array` Indexed array.   Returns: Measure of two strings' similarity: the higher the value, the more similar the strings are. The score is normalized such that `0` equates to no similarities and `1` is an exact match. --- rosettacode.org mahalanobis(p, q, VI)   Mahalanobis distance between two vectors with population inverse covariance matrix.   Parameters:      p (float ) : `array` 1D Vector.      q (float ) : `array` 1D Vector.      VI (matrix) : `matrix` Inverse of the covariance matrix.   Returns: The mahalanobis distance between vectors `p` and `q`. --- people.revoledu.com stat.ethz.ch docs.scipy.org fidelity(p, q)   Fidelity distance between provided vectors.   Parameters:      p (float ) : `array` 1D Vector.      q (float ) : `array` 1D Vector.   Returns: The Bhattacharyya Coefficient between vectors `p` and `q`. --- en.wikipedia.org bhattacharyya(p, q)   Bhattacharyya distance between provided vectors.   Parameters:      p (float ) : `array` 1D Vector.      q (float ) : `array` 1D Vector.   Returns: The Bhattacharyya distance between vectors `p` and `q`. --- en.wikipedia.org hellinger(p, q)   Hellinger distance between provided vectors.   Parameters:      p (float ) : `array` 1D Vector.      q (float ) : `array` 1D Vector.   Returns: The hellinger distance between vectors `p` and `q`. --- en.wikipedia.org jamesmccaffrey.wordpress.com kumar_hassebrook(p, q)   Kumar Hassebrook distance between provided vectors.   Parameters:      p (float ) : `array` 1D Vector.      q (float ) : `array` 1D Vector.   Returns: The Kumar Hassebrook distance between vectors `p` and `q`. --- github.com jaccard(p, q)   Jaccard distance between provided vectors.   Parameters:      p (float ) : `array` 1D Vector.      q (float ) : `array` 1D Vector.   Returns: The Jaccard distance between vectors `p` and `q`. --- github.com sorensen(p, q)   Sorensen distance between provided vectors.   Parameters:      p (float ) : `array` 1D Vector.      q (float ) : `array` 1D Vector.   Returns: The Sorensen distance between vectors `p` and `q`. --- people.revoledu.com chi_square(p, q, eps)   Chi Square distance between provided vectors.   Parameters:      p (float ) : `array` 1D Vector.      q (float ) : `array` 1D Vector.      eps (float)   Returns: The Chi Square distance between vectors `p` and `q`. --- uw.pressbooks.pub stats.stackexchange.com www.itl.nist.gov kulczynsky(p, q, eps)   Kulczynsky distance between provided vectors.   Parameters:      p (float ) : `array` 1D Vector.      q (float ) : `array` 1D Vector.      eps (float)   Returns: The Kulczynsky distance between vectors `p` and `q`. --- github.com
Biblioteca Pine Script™
por RicardoSantos
11
imlibLibrary "imlib" Description The library allows you to display images in your scripts utilising the objects. You can change the image size and screen aspect ratio (the ratio of width to height which you can change if the image is too wide / tall). The library has "example()" function which you can use to see how it works. It also has a handy "logo()" function which you can use to quickly display an image by passing the "Image data string", table position, image size and aspect ratio. And of course you can use it in your own custom way by taking the "logo()" function as an example and modifying the code to your needs. Since tables in Pinescript are limited to 100 by 100 cells, the limit for image's size is also 100x100 px. All the necessary data to display an image is passed as a string variable, and since Pinescript has a limit of 4096 characters for variables of type, that string can have a maximum length of 4096 characters, which is enough to display a 64x64px image (but can be enough to display a 100x100 image, depending on the image itself). Below you can find the definitions of functions for this library. _decompress(data)   : Decompresses string with data image   Parameters:      data (string)   Returns: : Array of with decompressed data load(data)   : Splits the string with image data into components and builds an object   Parameters:      data (string)   Returns: : An object show(imgdata, table_id, image_size, screen_ratio)   : Displays an image in a table   Parameters:      imgdata (ImgData)      table_id (table)      image_size (float)      screen_ratio (string)   Returns: : nothing example()   : Use it as an example of how this library works and how to use it in your own scripts   Returns: : nothing logo(imgdata, position, image_size, screen_ratio)   : Displays logo using image data string   Parameters:      imgdata (string)      position (string)      image_size (float)      screen_ratio (string)   Returns: : nothing ImgData   Fields:      w (series__integer)      h (series__integer)      s (series__string)      pal (series__string)      data (array__string)
Biblioteca Pine Script™
por sabricat
11
TradingToolsLibraryLibrary "TradingToolsLibrary" Easily create advanced entries, exits, filters and qualifiers to simulate strategies. Supports DCA (Dollar Cost Averaging) Lines, Stop Losses, Take Profits (with trailing or without) & ATR. method deepCopy(this)   This creates a deep copy instead of a shallow copy of an entry_position. This does NOT deep copy the self_pyramiding_positions array reference, since only the master entry_position needs this to track the rest of its copies for efficiency reasons. This is to prevent a feedback loop.   Namespace types: entry_position   Parameters:      this (entry_position)   Returns: entry_position method precision_fix(this, precision)   Convert a floating point number to a precise floating point number with digit precision to avoid floating point errors in quantity calculations.   Namespace types: series float, simple float, input float, const float   Parameters:      this (float)      precision (int)   Returns: float xSellBuyMidInterpolation(_x, _high, _low, _sellRange, _buyRange)   Creates an interpolation for a sell range and buy range but with an emphasis on reaching the _low the closer to the middle of the _sell and _buy range you go.   Parameters:      _x (float) : is the value you want to use to control interpolation bewteen the _high and _low value. This will return the lowest percentage at the mid between high and low and highest percentage at the _high and _low.      _high (float)      _low (float)      _sellRange (float)      _buyRange (float)   Returns: an interpolated float between the _high and _low supplied. xSellBuyInterpolation(_x, _high, _low, _sellRange, _buyRange)   Creates an interpolation a sell range and buy range   Parameters:      _x (float) : is the value you want to use to control interpolation bewteen the _high and _low value.      _high (float)      _low (float)      _sellRange (float)      _buyRange (float)   Returns: an interpolated float between the _high and _low supplied. activate_entries_and_exits(_entries, _exits, _filters, _qualifiers, _equity)   Determines activation for entries or exits. Does not place the actual orders.   Parameters:      _entries (entry_position )      _exits (exit_position )      _filters (filter )      _qualifiers (qualifier )      _equity (equity_management)   Returns: void create_entries_and_exits(_entries, _exits, _equity)   Creates actual entry and exit orders if activated   Parameters:      _entries (entry_position )      _exits (exit_position )      _equity (equity_management)   Returns: void filter   Fields:      disabled (series__bool)      filter_for_entries_or_exits (series__string)      filter_for_groups (series__string)      condition (series__bool)      dynamic_condition (series__bool)      use_dynamic_condition (series__bool)      use_override_default_condition (series__bool)      dynamic_condition_operator (series__string)      dynamic_condition_source (series__float)      dynamic_compare_source (series__float)      dynamic_condition_source_prior (series__float)      dynamic_compare_source_prior (series__float)      use_dynamic_compare_source (series__bool)      dynamic_condition_activate_value (series__string)      expire_condition_activate_value (series__string)      expire_condition_source (series__float)      expire_condition_source_prior (series__float)      expire_compare_source (series__float)      expire_compare_source_prior (series__float)      use_expire_compare_source (series__bool)      expire_condition_operator (series__string) qualifier   Fields:      disabled (series__bool)      qualify_for_entries_or_exits (series__string)      qualify_for_groups (series__string)      disqualify (series__bool)      condition (series__bool)      dynamic_condition (series__bool)      use_dynamic_condition (series__bool)      use_override_default_condition (series__bool)      dynamic_condition_operator (series__string)      dynamic_condition_source (series__float)      dynamic_compare_source (series__float)      dynamic_condition_source_prior (series__float)      dynamic_compare_source_prior (series__float)      use_dynamic_compare_source (series__bool)      dynamic_condition_activate_value (series__string)      expire_after_x_bars (series__integer)      use_expire_after_x_bars (series__bool)      use_expire_condition (series__bool)      use_override_expire_condition (series__bool)      expire_condition_operator (series__string)      expire_condition_source (series__float)      expire_compare_source (series__float)      expire_condition_source_prior (series__float)      expire_compare_source_prior (series__float)      use_expire_compare_source (series__bool)      expire_condition_activate_value (series__string)      active (series__bool)      expire_after_bars_bar_index (series__integer)      expire_after_bars_bar_index_prior (series__integer)      expire_bar_count (series__integer)      expire_bar_changed (series__bool) entry_position   Fields:      disabled (series__bool)      activate (series__bool)      active (series__bool)      override_occured (series__bool)      passDebug (array__bool)      initial_activation_price (series__float)      dca_done (series__bool)      condition (series__bool)      dynamic_condition (series__bool)      use_dynamic_condition (series__bool)      use_override_default_condition (series__bool)      dynamic_condition_operator (series__string)      dynamic_condition_source (series__float)      dynamic_compare_source (series__float)      dynamic_condition_source_prior (series__float)      dynamic_compare_source_prior (series__float)      use_dynamic_compare_source (series__bool)      dynamic_condition_activate_value (series__string)      use_cash (series__bool)      use_percent_equity (series__bool)      percent_equity_amount (series__float)      cash_amount (series__float)      position_size (series__float)      total_position_size (series__float)      prior_total_position_size (series__float)      equity_remaining (series__float)      prior_equity_remaining (series__float)      initial_equity (series__float)      use_martingale (series__bool)      martingale_win_ratio (series__float)      martingale_lose_ratio (series__float)      martingale_win_limit (series__integer)      martingale_lose_limit (series__integer)      martingale_limit_reset_mode (series__string)      use_dynamic_percent_equity (series__bool)      dynamic_percent_equity_amount (series__float)      initial_dynamic_percent_equity_amount (series__float)      dynamic_percent_equity_source (series__float)      dynamic_percent_equity_min (series__float)      dynamic_percent_equity_max (series__float)      dynamic_percent_equity_source_sell_range (series__float)      dynamic_percent_equity_source_buy_range (series__float)      dynamic_equity_interpolation_method (series__string)      total_bars (series__integer)      bar_index_at_activate (series__integer)      bars_since_active (series__integer)      time_at_activate (series__integer)      time_since_active (series__integer)      bar_index_at_activated (series__integer)      bar_index_at_pyramid_change (series__integer)      name (series__string)      id (series__string)      group (series__string)      pyramiding_limit (series__integer)      self_pyramiding_limit (series__integer)      self_pyramiding_positions (array__|entry_position|#OBJ)      new_pyramid_cancels_dca (series__bool)      num_active_long_positions (series__integer)      num_active_short_positions (series__integer)      num_active_positions (series__integer)      position_remaining (series__float)      prior_position_remaining (series__float)      direction (series__string)      allow_flip_position (series__bool)      flip_occurred (series__bool)      ignore_flip (series__bool)      use_dca (series__bool)      dca_use_limit (series__bool)      dca_num_positions (series__integer)      dca_positions (array__float)      dca_deviation_percentage (series__float)      dca_scale (series__float)      dca_percentages (series__string)      dca_close_cancels (series__bool)      dca_active_positions (series__integer)      use_atr_deviation (series__bool)      dca_atr_length (series__integer)      dca_atr_mult (series__float)      dca_atr_updates_dca_positions (series__bool)      close_price_at_order (series__float)      dca_use_deviation_atr_min (series__bool)      dca_position_quantities (array__float)      use_dca_dynamic_percent_equity (series__bool)      dca_in_use (array__bool)      dca_activated (array__bool)      dca_money_used (array__float)      dca_lines (array__line)      dca_color (series__color)      show_dca_lines (series__bool)      atr_value (series__float)      atr_value_at_activation (series__float)      use_cooldown_bars (series__bool)      cooldown_bars (series__integer)      cooldown_bar_changed (series__bool)      cooldown_bar_index (series__integer)      cooldown_bar_index_prior (series__integer)      cooldown_bar_change_count (series__integer)      expire_condition_activate_value (series__string)      expire_condition_source (series__float)      expire_condition_source_prior (series__float)      expire_compare_source (series__float)      expire_compare_source_prior (series__float)      use_expire_compare_source (series__bool)      expire_condition_operator (series__string) exit_position   Fields:      disabled (series__bool)      id (series__string)      group (series__string)      exit_for_entries (series__string)      exit_for_groups (series__string)      total_bars (series__integer)      name (series__string)      condition (series__bool)      dynamic_condition (series__bool)      use_dynamic_condition (series__bool)      use_override_default_condition (series__bool)      dynamic_condition_operator (series__string)      dynamic_condition_source (series__float)      dynamic_compare_source (series__float)      dynamic_condition_source_prior (series__float)      dynamic_compare_source_prior (series__float)      use_dynamic_compare_source (series__bool)      dynamic_condition_activate_value (series__string)      activate (series__bool)      active (series__bool)      reset_equity (series__bool)      use_limit (series__bool)      use_alerts (series__bool)      reset_entry_cooldowns (series__bool)      prevent_new_entries_on_partial_close (series__bool)      show_activation_zone (series__bool)      use_average_position (series__bool)      source_value (series__float)      trigger_x_times (series__integer)      amount_of_times_triggered (series__integer)      quantity_percent (series__float)      trade_qty (series__float)      exit_amount (series__float)      entries_exiting_for (array__|entry_position|#OBJ)      atr_value (series__float)      update_atr (series__bool)      use_activate_after_bars (series__bool)      show_activate_after_bars (series__bool)      activate_after_bars (series__integer)      activate_after_bars_bar_changed (series__bool)      activate_after_bars_bar_index (series__integer)      activate_after_bars_bar_index_prior (series__integer)      activate_after_bars_bar_change_count (series__integer)      all_conditions_pass (series__bool)      use_close_if_profit_only (series__bool)      profit_value (series__float)      exit_type (series__string)      exit_modifier (series__string)      update_atr_with_new_pyramid (series__bool)      percentage (series__float)      activation_percentage (series__float)      atr_multiplier (series__float)      use_cancel_if_percent (series__bool)      cancel_if_percent (series__float)      activation_value (series__float)      activation_value_crossed (series__bool)      exit_value (series__float)      hypo_long_exit_value (series__float)      hypo_short_exit_value (series__float)      close_exit_value (series__float)      debug (series__float)      expire_condition_activate_value (series__string)      expire_condition_source (series__float)      expire_condition_source_prior (series__float)      expire_compare_source (series__float)      expire_compare_source_prior (series__float)      use_expire_compare_source (series__bool)      expire_condition_operator (series__string) equity_management   Fields:      equity (series__float)      prior_equity (series__float)      position_used (series__float)      prior_position_used (series__float)      prevent_future_entries (series__bool)      minimum_order_size (series__float)      decimal_rounding_precision (series__integer)      direction (series__string)      show_order_info_in_comments (series__bool)      show_order_info_in_labels (series__bool)      allow_longs (series__bool)      allow_shorts (series__bool)      override_occured (series__bool)      flip_occured (series__bool)      num_concurrent_wins (series__integer)      num_concurrent_losses (series__integer)      first_entry (|entry_position|#OBJ)      num_win_trades (series__integer)      num_losing_trades (series__integer)
Biblioteca Pine Script™
por Gentleman-Goat
8
Vector3Library "Vector3" Representation of 3D vectors and points. This structure is used to pass 3D positions and directions around. It also contains functions for doing common vector operations. Besides the functions listed below, other classes can be used to manipulate vectors and points as well. For example the Quaternion and the Matrix4x4 classes are useful for rotating or transforming vectors and points. ___ **Reference:** - github.com - github.com - github.com - www.movable-type.co.uk - docs.unity3d.com - referencesource.microsoft.com - github.com \ new(x, y, z)   Create a new `Vector3`.   Parameters:      x (float) : `float` Property `x` value, (optional, default=na).      y (float) : `float` Property `y` value, (optional, default=na).      z (float) : `float` Property `z` value, (optional, default=na).   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` .new(1.1, 1, 1) ``` from(value)   Create a new `Vector3` from a single value.   Parameters:      value (float) : `float` Properties positional value, (optional, default=na).   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` .from(1.1) ``` from_Array(values, fill_na)   Create a new `Vector3` from a list of values, only reads up to the third item.   Parameters:      values (float ) : `array` Vector property values.      fill_na (float) : `float` Parameter value to replace missing indexes, (optional, defualt=na).   Returns: `Vector3` Generated new vector. ___ **Notes:** - Supports any size of array, fills non available fields with `na`. ___ **Usage:** ``` .from_Array(array.from(1.1, fill_na=33)) .from_Array(array.from(1.1, 2, 3)) ``` from_Vector2(values)   Create a new `Vector3` from a `Vector2`.   Parameters:      values (Vector2 type from RicardoSantos/CommonTypesMath/1) : `Vector2` Vector property values.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` .from:Vector2(.Vector2.new(1, 2.0)) ``` ___ **Notes:** - Type `Vector2` from CommonTypesMath library. from_Quaternion(values)   Create a new `Vector3` from a `Quaternion`'s `x, y, z` properties.   Parameters:      values (Quaternion type from RicardoSantos/CommonTypesMath/1) : `Quaternion` Vector property values.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` .from_Quaternion(.Quaternion.new(1, 2, 3, 4)) ``` ___ **Notes:** - Type `Quaternion` from CommonTypesMath library. from_String(expression, separator, fill_na)   Create a new `Vector3` from a list of values in a formated string.   Parameters:      expression (string) : `array` String with the list of vector properties.      separator (string) : `string` Separator between entries, (optional, default=`","`).      fill_na (float) : `float` Parameter value to replace missing indexes, (optional, defualt=na).   Returns: `Vector3` Generated new vector. ___ **Notes:** - Supports any size of array, fills non available fields with `na`. - `",,"` Empty fields will be ignored. ___ **Usage:** ``` .from_String("1.1", fill_na=33)) .from_String("(1.1,, 3)") // 1.1 , 3.0, NaN // empty field will be ignored!! ``` back()   Create a new `Vector3` object in the form `(0, 0, -1)`.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` .back() ``` front()   Create a new `Vector3` object in the form `(0, 0, 1)`.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` .front() ``` up()   Create a new `Vector3` object in the form `(0, 1, 0)`.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` .up() ``` down()   Create a new `Vector3` object in the form `(0, -1, 0)`.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` .down() ``` left()   Create a new `Vector3` object in the form `(-1, 0, 0)`.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` .left() ``` right()   Create a new `Vector3` object in the form `(1, 0, 0)`.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` .right() ``` zero()   Create a new `Vector3` object in the form `(0, 0, 0)`.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` .zero() ``` one()   Create a new `Vector3` object in the form `(1, 1, 1)`.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` .one() ``` minus_one()   Create a new `Vector3` object in the form `(-1, -1, -1)`.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` .minus_one() ``` unit_x()   Create a new `Vector3` object in the form `(1, 0, 0)`.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` .unit_x() ``` unit_y()   Create a new `Vector3` object in the form `(0, 1, 0)`.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` .unit_y() ``` unit_z()   Create a new `Vector3` object in the form `(0, 0, 1)`.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` .unit_z() ``` nan()   Create a new `Vector3` object in the form `(na, na, na)`.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` .nan() ``` random(max, min)   Generate a vector with random properties.   Parameters:      max (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Maximum defined range of the vector properties.      min (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Minimum defined range of the vector properties.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` .random(.from(math.pi), .from(-math.pi)) ``` random(max)   Generate a vector with random properties (min set to 0.0).   Parameters:      max (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Maximum defined range of the vector properties.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` .random(.from(math.pi)) ``` method copy(this)   Copy a existing `Vector3`   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .one().copy() ``` method i_add(this, other)   Modify a instance of a vector by adding a vector to it.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      other (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Other Vector.   Returns: `Vector3` Updated source vector. ___ **Usage:** ``` a = .from(1) , a.i_add(.up()) ``` method i_add(this, value)   Modify a instance of a vector by adding a vector to it.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      value (float) : `float` Value.   Returns: `Vector3` Updated source vector. ___ **Usage:** ``` a = .from(1) , a.i_add(3.2) ``` method i_subtract(this, other)   Modify a instance of a vector by subtracting a vector to it.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      other (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Other Vector.   Returns: `Vector3` Updated source vector. ___ **Usage:** ``` a = .from(1) , a.i_subtract(.down()) ``` method i_subtract(this, value)   Modify a instance of a vector by subtracting a vector to it.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      value (float) : `float` Value.   Returns: `Vector3` Updated source vector. ___ **Usage:** ``` a = .from(1) , a.i_subtract(3) ``` method i_multiply(this, other)   Modify a instance of a vector by multiplying a vector with it.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      other (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Other Vector.   Returns: `Vector3` Updated source vector. ___ **Usage:** ``` a = .from(1) , a.i_multiply(.left()) ``` method i_multiply(this, value)   Modify a instance of a vector by multiplying a vector with it.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      value (float) : `float` value.   Returns: `Vector3` Updated source vector. ___ **Usage:** ``` a = .from(1) , a.i_multiply(3) ``` method i_divide(this, other)   Modify a instance of a vector by dividing it by another vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      other (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Other Vector.   Returns: `Vector3` Updated source vector. ___ **Usage:** ``` a = .from(1) , a.i_divide(.forward()) ``` method i_divide(this, value)   Modify a instance of a vector by dividing it by another vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      value (float) : `float` Value.   Returns: `Vector3` Updated source vector. ___ **Usage:** ``` a = .from(1) , a.i_divide(3) ``` method i_mod(this, other)   Modify a instance of a vector by modulo assignment with another vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      other (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Other Vector.   Returns: `Vector3` Updated source vector. ___ **Usage:** ``` a = .from(1) , a.i_mod(.back()) ``` method i_mod(this, value)   Modify a instance of a vector by modulo assignment with another vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      value (float) : `float` Value.   Returns: `Vector3` Updated source vector. ___ **Usage:** ``` a = .from(1) , a.i_mod(3) ``` method i_pow(this, exponent)   Modify a instance of a vector by modulo assignment with another vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      exponent (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Exponent Vector.   Returns: `Vector3` Updated source vector. ___ **Usage:** ``` a = .from(1) , a.i_pow(.up()) ``` method i_pow(this, exponent)   Modify a instance of a vector by modulo assignment with another vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      exponent (float) : `float` Exponent Value.   Returns: `Vector3` Updated source vector. ___ **Usage:** ``` a = .from(1) , a.i_pow(2) ``` method length_squared(this)   Squared length of the vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1)   Returns: `float` The squared length of this vector. ___ **Usage:** ``` a = .one().length_squared() ``` method magnitude_squared(this)   Squared magnitude of the vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.   Returns: `float` The length squared of this vector. ___ **Usage:** ``` a = .one().magnitude_squared() ``` method length(this)   Length of the vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.   Returns: `float` The length of this vector. ___ **Usage:** ``` a = .one().length() ``` method magnitude(this)   Magnitude of the vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.   Returns: `float` The Length of this vector. ___ **Usage:** ``` a = .one().magnitude() ``` method normalize(this, magnitude, eps)   Normalize a vector with a magnitude of 1(optional).   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      magnitude (float) : `float` Value to manipulate the magnitude of normalization, (optional, default=1.0).      eps (float)   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .new(33, 50, 100).normalize() // (x=0.283, y=0.429, z=0.858) a = .new(33, 50, 100).normalize(2) // (x=0.142, y=0.214, z=0.429) ``` method to_String(this, precision)   Converts source vector to a string format, in the form `"(x, y, z)"`.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      precision (string) : `string` Precision format to apply to values (optional, default='').   Returns: `string` Formated string in a `"(x, y, z)"` format. ___ **Usage:** ``` a = .one().to_String("#.###") ``` method to_Array(this)   Converts source vector to a array format.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.   Returns: `array` List of the vector properties. ___ **Usage:** ``` a = .new(1, 2, 3).to_Array() ``` method to_Vector2(this)   Converts source vector to a Vector2 in the form `x, y`.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.   Returns: `Vector2` Generated new vector. ___ **Usage:** ``` a = .from(1).to_Vector2() ``` method to_Quaternion(this, w)   Converts source vector to a Quaternion in the form `x, y, z, w`.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Sorce vector.      w (float) : `float` Property of `w` new value.   Returns: `Quaternion` Generated new vector. ___ **Usage:** ``` a = .from(1).to_Quaternion(w=1) ``` method add(this, other)   Add a vector to source vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      other (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Other vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1).add(.unit_z()) ``` method add(this, value)   Add a value to each property of the vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      value (float) : `float` Value.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1).add(2.0) ``` add(value, other)   Add each property of a vector to a base value as a new vector.   Parameters:      value (float) : `float` Value.      other (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(2) , b = .add(1.0, a) ``` method subtract(this, other)   Subtract vector from source vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      other (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Other vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1).subtract(.left()) ``` method subtract(this, value)   Subtract a value from each property in source vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      value (float) : `float` Value.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1).subtract(2.0) ``` subtract(value, other)   Subtract each property in a vector from a base value and create a new vector.   Parameters:      value (float) : `float` Value.      other (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .subtract(1.0, .right()) ``` method multiply(this, other)   Multiply a vector by another.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      other (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Other vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1).multiply(.up()) ``` method multiply(this, value)   Multiply each element in source vector with a value.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      value (float) : `float` Value.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1).multiply(2.0) ``` multiply(value, other)   Multiply a value with each property in a vector and create a new vector.   Parameters:      value (float) : `float` Value.      other (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .multiply(1.0, .new(1, 2, 1)) ``` method divide(this, other)   Divide a vector by another.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      other (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Other vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1).divide(.from(2)) ``` method divide(this, value)   Divide each property in a vector by a value.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      value (float) : `float` Value.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1).divide(2.0) ``` divide(value, other)   Divide a base value by each property in a vector and create a new vector.   Parameters:      value (float) : `float` Value.      other (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .divide(1.0, .from(2)) ``` method mod(this, other)   Modulo a vector by another.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      other (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Other vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1).mod(.from(2)) ``` method mod(this, value)   Modulo each property in a vector by a value.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      value (float) : `float` Value.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1).mod(2.0) ``` mod(value, other)   Modulo a base value by each property in a vector and create a new vector.   Parameters:      value (float) : `float` Value.      other (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .mod(1.0, .from(2)) ``` method negate(this)   Negate a vector in the form `(zero - this)`.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .one().negate() ``` method pow(this, other)   Modulo a vector by another.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      other (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Other vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(2).pow(.from(3)) ``` method pow(this, exponent)   Raise the vector elements by a exponent.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      exponent (float) : `float` The exponent to raise the vector by.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1).pow(2.0) ``` pow(value, exponent)   Raise value into a vector raised by the elements in exponent vector.   Parameters:      value (float) : `float` Base value.      exponent (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` The exponent to raise the vector of base value by.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .pow(1.0, .from(2)) ``` method sqrt(this)   Square root of the elements in a vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1).sqrt() ``` method abs(this)   Absolute properties of the vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1).abs() ``` method max(this)   Highest property of the vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.   Returns: `float` Highest value amongst the vector properties. ___ **Usage:** ``` a = .new(1, 2, 3).max() ``` method min(this)   Lowest element of the vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.   Returns: `float` Lowest values amongst the vector properties. ___ **Usage:** ``` a = .new(1, 2, 3).min() ``` method floor(this)   Floor of vector a.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .new(1.33, 1.66, 1.99).floor() ``` method ceil(this)   Ceil of vector a.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .new(1.33, 1.66, 1.99).ceil() ``` method round(this)   Round of vector elements.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .new(1.33, 1.66, 1.99).round() ``` method round(this, precision)   Round of vector elements to n digits.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      precision (int) : `int` Number of digits to round the vector elements.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .new(1.33, 1.66, 1.99).round(1) // 1.3, 1.7, 2 ``` method fractional(this)   Fractional parts of vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1.337).fractional() // 0.337 ``` method dot_product(this, other)   Dot product of two vectors.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      other (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Other vector.   Returns: `float` Dot product. ___ **Usage:** ``` a = .from(2).dot_product(.left()) ``` method cross_product(this, other)   Cross product of two vectors.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      other (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Other vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1).cross_produc(.right()) ``` method scale(this, scalar)   Scale vector by a scalar value.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      scalar (float) : `float` Value to scale the the vector by.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1).scale(2) ``` method rescale(this, magnitude)   Rescale a vector to a new magnitude.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      magnitude (float) : `float` Value to manipulate the magnitude of normalization.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(20).rescale(1) ``` method equals(this, other)   Compares two vectors.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      other (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Other vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1).equals(.one()) ``` method sin(this)   Sine of vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1).sin() ``` method cos(this)   Cosine of vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1).cos() ``` method tan(this)   Tangent of vector.   Namespace types: TMath.Vector3   Parameters:      this (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .from(1).tan() ``` vmax(a, b)   Highest elements of the properties from two vectors.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Vector.      b (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .vmax(.one(), .from(2)) ``` vmax(a, b, c)   Highest elements of the properties from three vectors.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Vector.      b (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Vector.      c (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .vmax(.new(0.1, 2.5, 3.4), .from(2), .from(3)) ``` vmin(a, b)   Lowest elements of the properties from two vectors.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Vector.      b (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .vmin(.one(), .from(2)) ``` vmin(a, b, c)   Lowest elements of the properties from three vectors.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Vector.      b (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Vector.      c (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .vmin(.one(), .from(2), .new(3.3, 2.2, 0.5)) ``` distance(a, b)   Distance between vector `a` and `b`.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      b (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Target vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = distance(.from(3), .unit_z()) ``` clamp(a, min, max)   Restrict a vector between a min and max vector.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      min (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Minimum boundary vector.      max (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Maximum boundary vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .clamp(a=.new(2.9, 1.5, 3.9), min=.from(2), max=.new(2.5, 3.0, 3.5)) ``` clamp_magnitude(a, radius)   Vector with its magnitude clamped to a radius.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.object, vector with properties that should be restricted to a radius.      radius (float) : `float` Maximum radius to restrict magnitude of vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .clamp_magnitude(.from(21), 7) ``` lerp_unclamped(a, b, rate)   `Unclamped` linearly interpolates between provided vectors by a rate.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      b (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Target vector.      rate (float) : `float` Rate of interpolation, range(0 > 1) where 0 == source vector and 1 == target vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .lerp_unclamped(.from(1), .from(2), 1.2) ``` lerp(a, b, rate)   Linearly interpolates between provided vectors by a rate.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      b (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Target vector.      rate (float) : `float` Rate of interpolation, range(0 > 1) where 0 == source vector and 1 == target vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = lerp(.one(), .from(2), 0.2) ``` herp(start, start_tangent, end, end_tangent, rate)   Hermite curve interpolation between provided vectors.   Parameters:      start (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Start vector.      start_tangent (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Start vector tangent.      end (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` End vector.      end_tangent (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` End vector tangent.      rate (int) : `float` Rate of the movement from `start` to `end` to get position, should be range(0 > 1).   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` s = .new(0, 0, 0) , st = .new(0, 1, 1) e = .new(1, 2, 2) , et = .new(-1, -1, 3) h = .herp(s, st, e, et, 0.3) ``` ___ **Reference:** en.m.wikibooks.org herp_2(a, b, rate)   Hermite curve interpolation between provided vectors.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      b (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Target vector.      rate (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Rate of the movement per component from `start` to `end` to get position, should be range(0 > 1).   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` h = .herp_2(.one(), .new(0.1, 3, 2), 0.6) ``` noise(a)   3D Noise based on Morgan McGuire @morgan3d   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = noise(.one()) ``` ___ **Reference:** - thebookofshaders.com - www.shadertoy.com rotate(a, axis, angle)   Rotate a vector around a axis.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      axis (string) : `string` The plane to rotate around, `option="x", "y", "z"`.      angle (float) : `float` Angle in radians.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .rotate(.from(3), 'y', math.toradians(45.0)) ``` rotate_x(a, angle)   Rotate a vector on a fixed `x`.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      angle (float) : `float` Angle in radians.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .rotate_x(.from(3), math.toradians(90.0)) ``` rotate_y(a, angle)   Rotate a vector on a fixed `y`.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      angle (float) : `float` Angle in radians.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .rotate_y(.from(3), math.toradians(90.0)) ``` rotate_yaw_pitch(a, yaw, pitch)   Rotate a vector by yaw and pitch values.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      yaw (float) : `float` Angle in radians.      pitch (float) : `float` Angle in radians.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .rotate_yaw_pitch(.from(3), math.toradians(90.0), math.toradians(45.0)) ``` project(a, normal, eps)   Project a vector off a plane defined by a normal.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      normal (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` The normal of the surface being reflected off.      eps (float) : `float` Minimum resolution to void division by zero (default=0.000001).   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .project(.one(), .down()) ``` project_on_plane(a, normal, eps)   Projects a vector onto a plane defined by a normal orthogonal to the plane.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      normal (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` The normal of the surface being reflected off.      eps (float) : `float` Minimum resolution to void division by zero (default=0.000001).   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .project_on_plane(.one(), .left()) ``` project_to_2d(a, camera_position, camera_target)   Project a vector onto a two dimensions plane.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      camera_position (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Camera position.      camera_target (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Camera target plane position.   Returns: `Vector2` Generated new vector. ___ **Usage:** ``` a = .project_to_2d(.one(), .new(2, 2, 3), .zero()) ``` reflect(a, normal)   Reflects a vector off a plane defined by a normal.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      normal (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` The normal of the surface being reflected off.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .reflect(.one(), .right()) ``` angle(a, b, eps)   Angle in degrees between two vectors.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      b (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Target vector.      eps (float) : `float` Minimum resolution to void division by zero (default=1.0e-15).   Returns: `float` Angle value in degrees. ___ **Usage:** ``` a = .angle(.one(), .up()) ``` angle_signed(a, b, axis)   Signed angle in degrees between two vectors.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      b (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Target vector.      axis (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Axis vector.   Returns: `float` Angle value in degrees. ___ **Usage:** ``` a = .angle_signed(.one(), .left(), .down()) ``` ___ **Notes:** - The smaller of the two possible angles between the two vectors is returned, therefore the result will never be greater than 180 degrees or smaller than -180 degrees. - If you imagine the from and to vectors as lines on a piece of paper, both originating from the same point, then the /axis/ vector would point up out of the paper. - The measured angle between the two vectors would be positive in a clockwise direction and negative in an anti-clockwise direction. ___ **Reference:** - github.com angle2d(a, b)   2D angle between two vectors.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      b (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Target vector.   Returns: `float` Angle value in degrees. ___ **Usage:** ``` a = .angle2d(.one(), .left()) ``` transform_Matrix(a, M)   Transforms a vector by the given matrix.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      M (matrix) : `matrix` A 4x4 matrix. The transformation matrix.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` mat = matrix.new(4, 0) mat.add_row(0, array.from(0.0, 0.0, 0.0, 1.0)) mat.add_row(1, array.from(0.0, 0.0, 1.0, 0.0)) mat.add_row(2, array.from(0.0, 1.0, 0.0, 0.0)) mat.add_row(3, array.from(1.0, 0.0, 0.0, 0.0)) b = .transform_Matrix(.one(), mat) ``` transform_M44(a, M)   Transforms a vector by the given matrix.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      M (M44 type from RicardoSantos/CommonTypesMath/1) : `M44` A 4x4 matrix. The transformation matrix.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .transform_M44(.one(), .M44.new(0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0)) ``` ___ **Notes:** - Type `M44` from `CommonTypesMath` library. transform_normal_Matrix(a, M)   Transforms a vector by the given matrix.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      M (matrix) : `matrix` A 4x4 matrix. The transformation matrix.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` mat = matrix.new(4, 0) mat.add_row(0, array.from(0.0, 0.0, 0.0, 1.0)) mat.add_row(1, array.from(0.0, 0.0, 1.0, 0.0)) mat.add_row(2, array.from(0.0, 1.0, 0.0, 0.0)) mat.add_row(3, array.from(1.0, 0.0, 0.0, 0.0)) b = .transform_normal_Matrix(.one(), mat) ``` transform_normal_M44(a, M)   Transforms a vector by the given matrix.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector.      M (M44 type from RicardoSantos/CommonTypesMath/1) : `M44` A 4x4 matrix. The transformation matrix.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .transform_normal_M44(.one(), .M44.new(0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0)) ``` ___ **Notes:** - Type `M44` from `CommonTypesMath` library. transform_Array(a, rotation)   Transforms a vector by the given Quaternion rotation value.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector. The source vector to be rotated.      rotation (float ) : `array` A 4 element array. Quaternion. The rotation to apply.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .transform_Array(.one(), array.from(0.2, 0.2, 0.2, 1.0)) ``` ___ **Reference:** - referencesource.microsoft.com transform_Quaternion(a, rotation)   Transforms a vector by the given Quaternion rotation value.   Parameters:      a (Vector3 type from RicardoSantos/CommonTypesMath/1) : `Vector3` Source vector. The source vector to be rotated.      rotation (Quaternion type from RicardoSantos/CommonTypesMath/1) : `array` A 4 element array. Quaternion. The rotation to apply.   Returns: `Vector3` Generated new vector. ___ **Usage:** ``` a = .transform_Quaternion(.one(), .Quaternion.new(0.2, 0.2, 0.2, 1.0)) ``` ___ **Notes:** - Type `Quaternion` from `CommonTypesMath` library. ___ **Reference:** - referencesource.microsoft.com
Biblioteca Pine Script™
por RicardoSantos
7
Cleaner Screeners LibraryLibrary "cleanscreens" Screener Panel. This indicator displays a panel with a list of symbols and their indications. It can be used as a screener for multiple timess and symbols in any timeframe and with any indication in any combination. #### Features Multiple timeframes Multiple symbols Multiple indications per group Vertical or horizontal layouts Acceepts External Inputs Customizable colors with 170 presets included (dark and light) Customizable icons Customizable text size and font Customizable cell size width and height Customizable frame width and border width Customizable position Customizable strong and weak values Accepts any indicator as input Only 4 functions to call, easy to use #### Usage Initialize the panel with _paneel = cleanscreens.init() Add groupd with _screener = cleanscreens.Screener(_paneel, "Group Name") Add indicators to screeener groups with cleanscreens.Indicator(_screener, "Indicator Name", _source) Update the panel with cleanscreens.display(_paneel) Thanks @ PineCoders , and the Group members for setting the bar high. # local setup for methods on our script import kaigouthro/cleanscreen/1 method Screener ( panel p, string _name) => cleanscreens.Screener ( p, _name) method Indicator ( screener s , string _tf, string name, float val) => cleanscreens.Indicator ( s , _tf, name, val) method display ( panel p ) => cleanscreens.display ( p ) init(_themein, loc)   # Panel init > init a panel for all the screens   Parameters:      _themein (string) : string: Theme Preset Name      loc (int) : int : 1 = left top, 2 = middle top, 3 = right top, 4 = left middle, 5 = middle middle, 6 = right middle, 7 = left bottom, 8 = middle bottom, 9 = right bottom   Returns: panel method Screener(p, _name)   # Screener - Create a new screener ### Example: cleanscreens.new(panel, 'Crpyto Screeners')   Namespace types: panel   Parameters:      p (panel)      _name (string) method Indicator(s, _tf, name, val)   # Indicator - Create a new Indicator ### Example: cleanscreens.Inidcator('1h', 'RSI', ta.rsi(close, 14))   Namespace types: screener   Parameters:      s (screener)      _tf (string)      name (string)      val (float) method display(p)   # Display - Display the Panel ### Example: cleanscreens.display(panel)   Namespace types: panel   Parameters:      p (panel) indication   single indication for a symbol screener   Fields:      name (series string)      icon (series string)      rating (series string)      value (series float)      col (series color)      tf (series string)      tooltip (series string)      normalized (series float)      init (series bool) screener   single symbol screener   Fields:      ticker (series string)      icon (series string)      rating (series string)      value (series float)      bg (series color)      fg (series color)      items (indication )      init (series bool) config   screener configuration   Fields:      strong (series float)      weak (series float)      theme (series string)      vert (series bool)      cellwidth (series float)      cellheight (series float)      textsize (series string)      font (series int)      framewidth (series int)      borders (series int)      position (series string) icons   screener Icons   Fields:      buy (series string)      sell (series string)      strong (series string) panel   screener panel object   Fields:      items (screener )      table (series table)      config (config)      theme (theme type from kaigouthro/theme_engine/1)      icons (icons)
Biblioteca Pine Script™
por kaigouthro
13
Simple Trendlines📈 Trendlines, made easy. Simple Trendlines is a carefully made library that provides an easy and accessible way to draw trendlines on the chart. Containing only 10 properties and 2 methods, the implementation is designed to be understandable through an object-oriented structure and provides developers the opportunity to expand without having to deal with slope calculation while also ensuring that there's no leakage between the trendlines before they're drawn. Developers only need to provide 5 expressions to get everything up in running. This includes the following but is not limited to The x-axis Point A (Y1 Value) Point B (Y2 Value) A condition to draw the line A condition to keep the trendline under continuation Automatic x-axis calculation is not a built-in feature due to the inconsistency it could bring. 📕 Quick Example import HoanGhetti/SimpleTrendlines/1 as tl input_len = input.int(defval = 10) pivotLow = fixnan(ta.pivotlow(input_len, input_len)) xAxis = ta.valuewhen(ta.change(pivotLow), bar_index, 0) - ta.valuewhen(ta.change(pivotLow), bar_index, 1) prevPivot = ta.valuewhen(ta.change(pivotLow), pivotLow, 1) pivotCondition = ta.change(pivotLow) and pivotLow > prevPivot plData = tl.new(x_axis = xAxis, offset = input_len) plData.drawLine(pivotCondition, prevPivot, pivotLow) plData.drawTrendline(close > 0) plData.lines.trendline.set_style(line.style_dashed) plData.lines.trendline.set_width(2) plData.lines.startline.set_width(2) Excluding the styling at the bottom, that was only 8 lines of code which yields the following result. ⏳ Before continuing The library does not support block-scoped execution. Conditions must be declared before and integrated as a parameter. This doesn't limit any capabilities and only involves thinking logically about precedence. It was made this way for code readability and to keep things organized. The offset value inside the TrendlineSettings object can potentially affect performance (although very minimal) if you're using strict mode. When using strict mode, it loops through historical values to then do backend calculations. 🔽 Getting Started 🔽 Creating trendlines without a library isn't a hard task. However, the library features a built-in system called strict mode. We'll dive further into this below. Creating an Instance You can create an instance of the library by calling the new() function. Passing an identifier is conventionally mandatory in this case so you can reference properties and methods. import HoanGhetti/SimpleTrendlines/2 as tl lineData = tl.new(int x_axis, int offset, bool strictMode, int strictType) ___ int x_axis (Required) The distance between point A and point B provided by the user. int offset (Optional) The offset from x2 and the current bar_index. Used in situations where conditions execute ahead of where the x2 location is such as pivót events. bool strictMode (Optional) Strict mode works in the backend of things to ensure that the price hasn't closed below the trendline before the trendline is drawn. int strictType (Optional) Only accepts 0 and 1, 0 ensures that the price during slope calculation is above the line, and 1 ensures that the price during slope calculation is below the line. The Initial Line After instantiating the library, we can go ahead use the identifer we made above and create an instance of our initial line by calling the drawLine() method. lineData.drawLine(bool condition, float y1, float y2, float src) ___ bool condition (Required) The condition in order to draw a new line. float y1 (Required) The y-value of point A. float y2 (Required) The y-value of point B. float src (Optional) Determines which value strict mode will actively check for leakage before a trendline is drawn. Typically used if you're not referencing OHLC values for your y-values, or you want to check for another value to exceed the line besides using the close value. The Trendline The trendline that gets drawn solely uses the values of the initial line and can be called using the drawTrendline() method. The library enforces a condition as a parameter in order to maintain simplicity. lineData.drawTrendline(bool condition) ___ bool condition (Required) The condition in order to maintain and continue drawing the trendline. ⚙️ Features 🔹 Automatic Slope Calculation In the background, the library calculates the next Y2 and X2 values on every tick for the trendline. Preventing the developer from having to do such a process themself. 🔹 Object-Oriented Each object contains manipulative properties that allow the developer to debug and have the freedom they want. 🔹 Enforced Error Checking Runtime errors have been put in place to ensure you're doing things correctly. 🔹 Strict Mode & Offset Strict mode can only be used when the offset value is over 0. It's a feature that's only meant to function under scenarios where a condition executes further than where the X2 is relative to the current bar_index value. Let's think about pivot systems. As you're aware, pivot events are detected based on historical factors. If a swing low occurred nth bars ago, then the pivot condition will execute at the current bar_index instead of executing nth bars back. Now because of this, what if you wanted to draw a trendline when the pivot event is executed? The offset value takes care of this just as you would when developing your other scripts, basically how we always do bar_index - n. However, what does this mean for strict mode? The photo below represents the logic behind the execution. When looking at this image, imagine this just happened, the event just executed and the trendline is now drawn. Pay attention to all the values inside the surrounding box. As you can see there are some candles that closed below the trendline before the trendline was drawn. From what I can see 5-6 candles closed below the trendline during slope calculation. The goal of strict mode is to be a provisional system that prevents such occurrences from happening. Here's a photo with strict mode on. 🔹 Strict Type A parameter used in the new() function that acts as a representation of what strict mode should calculate for. It accepts only two values, 0 and 1. 0 - Ensures that all candles have closed above the trendline before the trendline is drawn. 1 - Ensures that all candles have closed below the trendline before the trendline is drawn. In the most recent photo above, I used 0 for strict type, since I was wanting to have a clean trendline and ensure that not a single candlestick closed below. If you want to reference something else besides the close value during strict mode calculation, you can change it in the drawLine() method. If it's still difficult to understand, think 0 for pivot lows, and 1 for pivot highs. 📕 Methods and Property Inheritance The library isn't crazy, but hopefully, it helps. That is all.👍
Biblioteca Pine Script™
por HoanGhetti
23
DataChartLibrary "DataChart" Library to plot scatterplot or heatmaps for your own set of data samples draw(this)   draw contents of the chart object   Parameters:      this : Chart object   Returns: current chart object init(this)   Initialize Chart object.   Parameters:      this : Chart object to be initialized   Returns: current chart object addSample(this, sample, trigger)   Add sample data to chart using Sample object   Parameters:      this : Chart object      sample : Sample object containing sample x and y values to be plotted      trigger : Samples are added to chart only if trigger is set to true. Default value is true   Returns: current chart object addSample(this, x, y, trigger)   Add sample data to chart using x and y values   Parameters:      this : Chart object      x : x value of sample data      y : y value of sample data      trigger : Samples are added to chart only if trigger is set to true. Default value is true   Returns: current chart object addPriceSample(this, priceSampleData, config)   Add price sample data - special type of sample designed to measure price displacements of events   Parameters:      this : Chart object      priceSampleData : PriceSampleData object containing event driven displacement data of x and y      config : PriceSampleConfig object containing configurations for deriving x and y from priceSampleData   Returns: current chart object Sample   Sample data for chart   Fields:      xValue : x value of the sample data      yValue : y value of the sample data ChartProperties   Properties of plotting chart   Fields:      title : Title of the chart      suffix : Suffix for values. It can be used to reference 10X or 4% etc. Used only if format is not format.percent      matrixSize : size of the matrix used for plotting      chartType : Can be either scatterplot or heatmap. Default is scatterplot      outliersStart : Indicates the percentile of data to filter out from the starting point to get rid of outliers      outliersEnd : Indicates the percentile of data to filter out from the ending point to get rid of outliers.      backgroundColor      plotColor : color of plots on the chart. Default is color.yellow. Only used for scatterplot type      heatmapColor : color of heatmaps on the chart. Default is color.red. Only used for heatmap type      borderColor : border color of the chart table. Default is color.yellow.      plotSize : size of scatter plots. Default is size.large      format : data representation format in tooltips. Use mintick.percent if measuring any data in terms of percent. Else, use format.mintick      showCounters : display counters which shows totals on each quadrants. These are single cell tables at the corners displaying number of occurences on each quadrant.      showTitle : display title at the top center. Uses the title string set in the properties      counterBackground : background color of counter table cells. Default is color.teal      counterTextColor : text color of counter table cells. Default is color.white      counterTextSize : size of counter table cells. Default is size.large      titleBackground : background color of chart title. Default is color.maroon      titleTextColor : text color of the chart title. Default is color.white      titleTextSize : text size of the title cell. Default is size.large      addOutliersToBorder : If set, instead of removing the outliers, it will be added to the border cells.      useCommonScale : Use common scale for both x and y. If not selected, different scales are calculated based on range of x and y values from samples. Default is set to false.      plotchar : scatter plot character. Default is set to ascii bullet. ChartDrawing   Chart drawing objects collection   Fields:      properties : ChartProperties object which determines the type and characteristics of chart being plotted      titleTable : table containing title of the chart.      mainTable : table containing plots or heatmaps.      quadrantTables : Array of tables containing counters of all 4 quandrants Chart   Chart type which contains all the information of chart being plotted   Fields:      properties : ChartProperties object which determines the type and characteristics of chart being plotted      samples : Array of Sample objects collected over period of time for plotting on chart.      displacements : Array containing displacement values. Both x and y values      displacementX : Array containing only X displacement values.      displacementY : Array containing only Y displacement values.      drawing : ChartDrawing object which contains all the drawing elements PriceSampleConfig   Configs used for adding specific type of samples called PriceSamples   Fields:      duration : impact duration for which price displacement samples are calculated.      useAtrReference : Default is true. If set to true, price is measured in terms of Atr. Else is measured in terms of percentage of price.      atrLength : atrLength to be used for measuring the price based on ATR. Used only if useAtrReference is set to true. PriceSampleData   Special type of sample called price sample. Can be used instead of basic Sample type   Fields:      trigger : consider sample only if trigger is set to true. Default is true.      source : Price source. Default is close      highSource : High price source. Default is high      lowSource : Low price source. Default is low      tr : True range value. Default is ta.tr
Biblioteca Pine Script™
por Trendoscope
20
Markdown: The Pine Editor's Hidden Gem💬 Markdown, a markup language Markdown is a portable, lightweight markup language that can be used for everything whether you're building a website, documentation, or even presentations. Platforms like Discord, Reddit, and GitHub support Markdown and is the widely go-to option for text formatting due to its simplicity. Pine Script is a language that also utilizes Markdown, specifically in the Pine Editor where it can really be used to some extent. Since the release of libraries, user-defined types, and methods, Pine Script is entering an age where developers will be highly dependent on libraries due to the capabilities Pine has inherited recently. It would be no surprise if a few people got together and took their time to thoroughly develop an entire project/library centered around improving Pine Script's built-in functions and providing developers with easier ways of achieving things than they thought they could. As you're all aware, hovering over functions (and more) in the editor pops up a prompt that specifies the parameters, types, and what the function returns. Pine Script uses Markdown for that, so I figured we could go ahead and push that feature to its limits and see what we can do. Today we'll go over how we can utilize Markdown in Pine Script, and how you can make your library's built-in functions stand out more than they did previously. For more information, visit www.markdownguide.org 📕 General Notes Markdown syntax only works on functions and methods. Using arrays as parameters as of 2/21/2023 breaks the Markdown system. The prompt window holds a max of 166 characters on one line before overflowing. There is no limit on how long the prompt window can be. 🔽 Getting Started 🔽 ▶️ Headings If you have experience in HTML, Markdown, or even Microsoft Word then you already have a grasp of how headings work and look. To simplify it, headings make the given text either massive or tiny depending on how many number symbols are provided. When defining headings, you must have a space between the number (#) symbol, and the text. This is typical syntax throughout the language. Pine Script uses bold text by applying (**) for their titles on their built-ins (e.g. @returns) but you could also use heading level 4 (####) and have it look the same. ▶️ Paragraphs & Line Breaks You may want to provide extensive details and examples relating to one function, in this case, you could create line breaks. Creating line breaks skips to the next line so you can keep things organized as a result. To achieve a valid line break and create a new paragraph, you must end the line with two or more spaces. If you want to have an empty line in between, apply a backslash (\). Backslashes (\) are generally not recommended for every line break. In this case, I only recommend using them for empty lines. ▶️ Text Formatting Markdown provides text formatting such as bold, italics, and strikethrough. For bolding text, you can apply open and close (**) or (__). For italicizing text, you can apply open and close (*) or (_). For bolding and italicizing text, you can apply open and close (***) or (___). For s̶t̶r̶i̶k̶e̶t̶h̶r̶o̶u̶g̶h̶, you need to apply open and close (~~). This was mentioned in the Headers section, but Pine Script's main titles (e.g. @returns or @syntax) use bold (**) by default. ▶️ Blockquotes Blockquotes in Pine Script can be visualized as a built-in indentation system. They are declared using greater than (>) and everything will be auto-aligned and indented until closed. By convention you generally want to include the greater than (>) on every line that's included in the block quote. Even when not needed. If you would like to indent even more (nested blockquotes), you can apply multiple greater than symbols (>). For example, (>>) Blockquotes can be closed by ending the next line with only one greater than (>) symbol, or by using a horizontal rule. ▶️ Horizontal Rules Horizontal rules in Pine Script are what you see at the very top of the prompt in built-ins. When hovering, you can see the top of the prompt provides a line, and we can actually reproduce these lines. These are extremely useful for separating information into their own parts and are accessed by applying 3 underscores (___), or 3 asterisks (***). Horizontal rules were mentioned above, when we were discussing block quotes. These can also be used to close blockquotes as well. Horizontal rules require a minimum of 3 underscores (___) or 3 asterisks (***). ▶️ Lists Lists give us a way to structure data in a somewhat neat way. There are multiple ways to start a list, such as 1. First Item (number followed by a period) - First Item (dash) + First Item (plus sign) * First Item (asterisk) Using number-based lists provide an ordered list, whereas using (-), (+), or (*) will provide an unordered list (bullet points). If you want to begin an unordered list with a number that ends with a period, you must use an escape sequence (\) after the number. Standard indentation (tab-width) list detection isn't supported, so to nest lists you have to use blockquotes (>) which may not look as appealing. ▶️ Code Blocks Using code blocks allows you to write actual Pine Script code inside the prompt. It's a game changer that can potentially help people understand how to execute functions quickly. To use code blocks, apply three 3 open and close backquotes (```). Built-in's use (```pine) but there's no difference when we apply it. Considering that tab-width indentation isn't detected properly, we can make use of the blockquotes mentioned above. ▶️ Denotation Denoting can also be seen as highlighting a background layer behind text. They're basically code blocks, but without the "block". Similar to how code blocks work, we apply one backquote open and close (`). Make sure to only use this on important keywords. There really isn't a conventional way of applying this. It's up to you to decide what people should have their eyes tracked onto when they hover over your functions. If needed, look at how Pine Script's built-in variables and functions utilize this. ▶️ Tables Tables are possible in Markdown, although they may look a bit different in the Pine Editor. They are made by separating text with vertical bars (|). The headers are detected when there is a minimum of one hyphen (-) below them. You can align text by using a colon as I do in the photo. Hyphens must be connected to the colon in order to display correctly. Tables aren't ideal to use in the editor but are there if anyone wants to give it a go. ▶️ Links & Images Markdown supports images and hyperlinks, which means we can also do that here in the Pine Editor. Cool right? If you want to create a hyperlink, surround the displayed text in open and close brackets . If you want to load a photo into your prompt, it's the same syntax as the hyperlink, except it uses a (!) See syntax list below. Here are realistic usage examples. (Snippets from code below) These follow the same syntax as the built-ins. I'm not using horizontal rules here, but it's entirely up to you. ▶️ Syntax List Headings Level 1: # Level 2: ## Level 3: ### Level 4: #### Level 5: ##### Level 6: ###### Line Breaks Text (two spaces) Text\ (backslash) Text Formatting Bold (**) Italic (**) Strikethrough (~~) Blockquotes Indent (>) Double Indent (>>) Triple Indent (>>>) and so on. Horizontal Rules (___) or (***) Lists Ordered List (1.) Unordered List (-) or (+) or (*) Code Blocks (```) or (```pine) Denotation (`) Tables (|) and (-) and (:) Hyperlinks (URL) Images ! (URL) Hope this helps. 👍
Biblioteca Pine Script™
por HoanGhetti
15
Motion▮ FEATURES Now as library version :) String-based transition-effects Performance optimization. Reduced memory consumption up to >90% by kicking the output to the "stdout". Use marquee- or loader-effect on any possible string location. Example: UI Price-Ticker ---------------------------------------------------------------------------- Library "Motion" _getStringMono(_len, _str, _sep)   Parameters:      _len      _str      _sep marquee(this, _extern, _ws, _subLen, _subStart)   Parameters:      this      _extern      _ws      _subLen      _subStart transition(this, _subLen, _subStart)   Parameters:      this      _subLen      _subStart hold(this)   Parameters:      this keyframe   keyframe A keyframe object.   Fields:      seq      intv      step      length      update_no      frame_no      ltr      hold
Biblioteca Pine Script™
por cryptolinx
5
HSV and HSL gradient Tools ( Built-in Drop-in replacement )Library "hsvColor" HSV and HSL Gradient Tool Alternatives and helpers. Demo'd is built-in in the middle with HSL/HSV gradients on top/bottom TODO: Solve for #000000 issue rgbhsv(_col)   RGB Color to HSV Values   Parameters:      _col : Color input (#abc012 or color.name or color.rgb(0,0,0,0))   Returns: values rgbhsv(_r, _g, _b, _t)   RGB Color to HSV Values   Parameters:      _r : Red 0 - 255      _g : Green 0 - 255      _b : Blue 0 - 255      _t : Transp 0 - 100   Returns: values hsv(_h, _s, _v, _a)   HSV colors, Auto fix if past boundaries   Parameters:      _h : Hue Input (-360 - 360) or further      _s : Saturation 0.- 1.      _v : Value 0.- 1.      _a : Alpha 0.- 1.   Returns: Color output hue(_col)   returns 0-359 hue on color wheel   Parameters:      _col :   Returns: 360 degree hue value hsv_gradient(signal, _startVal, _endVal, _startCol, _endCol)   Color Gradient Replacement Function for HSV calculated Gradents   Parameters:      signal : Control signal      _startVal : start color limit      _endVal : end color limit      _startCol : start color      _endCol : end color   Returns: HSV calculated gradient hsl_gradient(signal, _startVal, _endVal, _startCol, _endCol)   Color Gradient Replacement Function for HSV calculated Gradents   Parameters:      signal : Control signal      _startVal : start color limit      _endVal : end color limit      _startCol : start color      _endCol : end color   Returns: HSV calculated gradient
Biblioteca Pine Script™
por kaigouthro
31
VisibleChart█   OVERVIEW This library is a Pine programmer’s tool containing functions that return values calculated from the range of visible bars on the chart. This is now possible in Pine Script™ thanks to the recently-released chart.left_visible_bar_time and chart.right_visible_bar_time built-ins, which return the opening time of the leftmost and rightmost bars on the chart. These values update as traders scroll or zoom their charts, which gives way to a class of indicators that can dynamically recalculate and draw visuals on visible bars only, as users scroll or zoom their charts. We hope this library's functions help you make the most of the world of possibilities these new built-ins provide for Pine scripts. For an example of a script using this library, have a look at the Chart ​VWAP indicator. █   CONCEPTS Chart properties The new chart.left_visible_bar_time and chart.right_visible_bar_time variables return the opening time of the leftmost and rightmost bars on the chart. They are only two of many new built-ins in the `chart.*` namespace. See this blog post for more information, or look them up by typing "chart." in the Pine Script™ Reference Manual . Dynamic recalculation of scripts on visible bars Any script using chart.left_visible_bar_time or chart.right_visible_bar_time acquires a unique property, which triggers its recalculation when traders scroll or zoom their charts in such a way that the range of visible bars on the chart changes. This library's functions use the two recent built-ins to derive various values from the range of visible bars. Designing your scripts for dynamic recalculation For the library's functions to work correctly, they must be called on every bar. For reliable results, assign their results to global variables and then use the variables locally where needed — not the raw function calls. Some functions like `barIsVisible()` or `open()` will return a value starting on the leftmost visible bar. Others such as `high()` or `low()` will also return a value starting on the leftmost visible bar, but their correct value can only be known on the rightmost visible bar, after all visible bars have been analyzed by the script. You can plot values as the script executes on visible bars, but efficient code will, when possible, create resource-intensive labels, lines or tables only once in the global ​scope using var , and then use the setter functions to modify their properties on the last bar only. The example code included in this library uses this method. Keep in mind that when your script uses chart.left_visible_bar_time or chart.right_visible_bar_time , your script will recalculate on all bars each time the user scrolls or zooms their chart. To provide script users with the best experience you should strive to keep calculations to a minimum and use efficient code so that traders are not always waiting for your script to recalculate every time they scroll or zoom their chart. Another aspect to consider is the fact that the rightmost visible bar will not always be the last bar in the dataset. When script users scroll back in time, a large portion of the time series the script calculates on may be situated after the rightmost visible bar. We can never assume the rightmost visible bar is also the last bar of the time series. Use `barIsVisible()` to restrict calculations to visible bars, but also consider that your script can continue to execute past them. Look first. Then leap. █   FUNCTIONS The library contains the following functions: barIsVisible()   Condition to determine if a given bar is within the users visible time range.   Returns: (bool) True if the the calling bar is between the `chart.left_visible_bar_time` and the `chart.right_visible_bar_time`. high()   Determines the value of the highest `high` in visible bars.   Returns: (float) The maximum high value of visible chart bars. highBarIndex()   Determines the `bar_index` of the highest `high` in visible bars.   Returns: (int) The `bar_index` of the `high()`. highBarTime()   Determines the bar time of the highest `high` in visible bars.   Returns: (int) The `time` of the `high()`. low()   Determines the value of the lowest `low` in visible bars.   Returns: (float) The minimum low value of visible chart bars. lowBarIndex()   Determines the `bar_index` of the lowest `low` in visible bars.   Returns: (int) The `bar_index` of the `low()`. lowBarTime()   Determines the bar time of the lowest `low` in visible bars.   Returns: (int) The `time` of the `low()`. open()   Determines the value of the opening price in the visible chart time range.   Returns: (float) The `open` of the leftmost visible chart bar. close()   Determines the value of the closing price in the visible chart time range.   Returns: (float) The `close` of the rightmost visible chart bar. leftBarIndex()   Determines the `bar_index` of the leftmost visible chart bar.   Returns: (int) A `bar_index`. rightBarIndex()   Determines the `bar_index` of the rightmost visible chart bar.   Returns: (int) A `bar_index` bars()   Determines the number of visible chart bars.   Returns: (int) The number of bars. volume()   Determines the sum of volume of all visible chart bars.   Returns: (float) The cumulative sum of volume. ohlcv()   Determines the open, high, low, close, and volume sum of the visible bar time range.   Returns: ( ) A tuple of the OHLCV values for the visible chart bars. Example: open is chart left, high is the highest visible high, etc. chartYPct(​pct)   Determines a price level as a percentage of the visible bar price range, which depends on the chart's top/bottom margins in "Settings/Appearance".   Parameters:      pct : (series float) Percentage of the visible price range (50 is 50%). Negative values are allowed.   Returns: (float) A price level equal to the `pct` of the price range between the high and low of visible chart bars. Example: 50 is halfway between the visible high and low. chartXTimePct(​pct)   Determines a time as a percentage of the visible bar time range.   Parameters:      pct : (series float) Percentage of the visible time range (50 is 50%). Negative values are allowed.   Returns: (float) A time in UNIX format equal to the `pct` of the time range from the `chart.left_visible_bar_time` to the `chart.right_visible_bar_time`. Example: 50 is halfway from the leftmost visible bar to the rightmost. chartXIndexPct(​pct)   Determines a `bar_index` as a percentage of the visible bar time range.   Parameters:      pct : (series float) Percentage of the visible time range (50 is 50%). Negative values are allowed.   Returns: (float) A time in UNIX format equal to the `pct` of the time range from the `chart.left_visible_bar_time` to the `chart.right_visible_bar_time`. Example: 50 is halfway from the leftmost visible bar to the rightmost. whenVisible(​src, whenCond, length)   Creates an array containing the `length` last `src` values where `whenCond` is true for visible chart bars.   Parameters:      src : (series int/float) The source of the values to be included.      whenCond : (series bool) The condition determining which values are included. Optional. The default is `true`.      length : (simple int) The number of last values to return. Optional. The default is all values.   Returns: (float ) The array ID of the accumulated `src` values. avg(​src)   Gathers values of the source over visible chart bars and averages them.   Parameters:      src : (series int/float) The source of the values to be averaged. Optional. Default is `close`.   Returns: (float) A cumulative average of values for the visible time range. median(​src)   Calculates the median of a source over visible chart bars.   Parameters:      src : (series int/float) The source of the values. Optional. Default is `close`.   Returns: (float) The median of the `src` for the visible time range. vVwap(​src)   Calculates a volume-weighted average for visible chart bars.   Parameters:      src : (series int/float) Source used for the ​VWAP calculation. Optional. Default is `hlc3`.   Returns: (float) The ​VWAP for the visible time range.
Biblioteca Pine Script™
por PineCoders
62
Time█   OVERVIEW This library is a Pine Script™ programmer’s tool containing a variety of time related functions to calculate or measure time, or format time into string variables. █   CONCEPTS `formattedTime()`, `formattedDate()` and `formattedDay()` Pine Script™, like many other programming languages, uses timestamps in UNIX format, expressed as the number of milliseconds elapsed since 00:00:00 UTC, 1 January 1970. These three functions convert a UNIX timestamp to a formatted string for human consumption. These are examples of ways you can call the functions, and the ensuing results: CODE RESULT formattedTime(timenow) >>> "00:40:35" formattedTime(timenow, "short") >>> "12:40 AM" formattedTime(timenow, "full") >>> "12:40:35 AM ​UTC​" formattedTime(1000 * 60 * 60 * 3.5, "HH:mm") >>> "03:30" formattedDate(timenow, "short") >>> "4/30/22" formattedDate(timenow, "medium") >>> ​"Apr​ 30, 2022" formattedDate(timenow, "full") >>> "Saturday, April 30, 2022" formattedDay(timenow, "E") >>> "Sat" formattedDay(timenow, "dd.MM.yy") >>> "30.04.22" formattedDay(timenow, "yyyy.MM.dd G 'at' hh:mm:ss z") >>> "2022.04.30 AD at 12:40:35 UTC" These functions use str.format() and some of the special formatting codes it allows for. Pine Script™ documentation does not yet contain complete specifications on these codes, but in the meantime you can find some information in the The Java™ Tutorials and in Java documentation of its MessageFormat class . Note that str.format() implements only a subset of the MessageFormat features in Java. `secondsSince()` The introduction of varip variables in Pine Script™ has made it possible to track the time for which a condition is true when a script is executing on a realtime bar. One obvious use case that comes to mind is to enable trades to exit only when the exit condition has been true for a period of time, whether that period is shorter that the chart's timeframe, or spans across multiple realtime bars. For more information on this function and varip please see our Using `varip` variables publication. `timeFrom( )` When plotting lines , boxes , and labels one often needs to calculate an offset for past or future end points relative to the time a condition or point occurs in history. Using xloc.bar_index is often the easiest solution, but some situations require the use of xloc.bar_time . We introduce `timeFrom()` to assist in calculating time-based offsets. The function calculates a timestamp using a negative (into the past) or positive (into the future) offset from the current bar's starting or closing time, or from the current time of day. The offset can be expressed in units of chart timeframe, or in seconds, minutes, hours, days, months or years. This function was ported from our Time Offset Calculation Framework . `formattedNoOfPeriods()` and `secondsToTfString()` Our final two offerings aim to confront two remaining issues: How much time is represented in a given timestamp? How can I produce a "simple string" timeframe usable with request.security() from a timeframe expressed in seconds? `formattedNoOfPeriods()` converts a time value in ​ms to a quantity of time units. This is useful for calculating a difference in time between 2 points and converting to a desired number of units of time. If no unit is supplied, the function automatically chooses a unit based on a predetermined time step. `secondsToTfString()` converts an input time in seconds to a target timeframe string in timeframe.period string format. This is useful for implementing stepped timeframes relative to the chart time, or calculating multiples of a given chart timeframe. Results from this function are in simple form, which means they are useable as `timeframe` arguments in functions like request.security() . █   NOTES Although the example code is commented in detail, the size of the library justifies some further explanation as many concepts are demonstrated. Key points are as follows:  • ​Pivot points are used to draw lines from. `timeFrom( )` calculates the length of the lines in the specified unit of time.   By default the script uses 20 units of the charts timeframe. Example: a 1hr chart has arrows 20 hours in length.  • At the point of the arrows `formattedNoOfPeriods()` calculates the line length in the specified unit of time from the input menu.   If “Use Input Time” is disabled, a unit of time is automatically assigned.  • At each ​pivot point a label with a formatted date or time is placed with one of the three formatting helper functions to display the time or date the ​pivot occurred.  • A label on the last bar showcases `secondsSince()` . The label goes through three stages of detection for a timed alert.   If the difference between the high and the open in ticks exceeds the input value, a timer starts and will turn the label red once the input time is exceeded to simulate a time-delayed alert.  • In the bottom right of the screen `secondsToTfString()` posts the chart timeframe in a table. This can be multiplied from the input menu. Look first. Then leap. █   FUNCTIONS formattedTime(timeInMs, format)   Converts a UNIX timestamp (in milliseconds) to a formatted time string.   Parameters:      timeInMs : (series float) Timestamp to be formatted.      format : (series string) Format for the time. Optional. The default value is "HH:mm:ss".   Returns: (string) A string containing the formatted time. formattedDate(timeInMs, format)   Converts a UNIX timestamp (in milliseconds) to a formatted date string.   Parameters:      timeInMs : (series float) Timestamp to be formatted.      format : (series string) Format for the date. Optional. The default value is "yyyy-MM-dd".   Returns: (string) A string containing the formatted date. formattedDay(timeInMs, format)   Converts a UNIX timestamp (in milliseconds) to the name of the day of the week.   Parameters:      timeInMs : (series float) Timestamp to be formatted.      format : (series string) Format for the day of the week. Optional. The default value is "EEEE" (complete day name).   Returns: (string) A string containing the day of the week. secondsSince(cond, resetCond)   The duration in milliseconds that a condition has been true.   Parameters:      cond : (series bool) Condition to time.      resetCond : (series bool) When `true`, the duration resets.   Returns: The duration in seconds for which `cond` is continuously true. timeFrom(from, qty, units)   Calculates a +/- time offset in variable units from the current bar's time or from the current time.   Parameters:      from : (series string) Starting time from where the offset is calculated: "bar" to start from the bar's starting time, "close" to start from the bar's closing time, "now" to start from the current time.      qty : (series int) The +/- qty of units of offset required. A "series float" can be used but it will be cast to a "series int".      units : (series string) String containing one of the seven allowed time units: "chart" (chart's timeframe), "seconds", "minutes", "hours", "days", "months", "years".   Returns: (int) The resultant time offset `from` the `qty` of time in the specified `units`. formattedNoOfPeriods(​ms, unit)   Converts a time value in ​ms to a quantity of time units.   Parameters:      ms : (series int) Value of time to be formatted.      unit : (series string) The target unit of time measurement. Options are "seconds", "minutes", "hours", "days", "weeks", "months". If not used one will be automatically assigned.   Returns: (string) A formatted string from the number of `ms` in the specified `unit` of time measurement secondsToTfString(tfInSeconds, mult)   Convert an input time in seconds to target string TF in `timeframe.period` string format.   Parameters:      tfInSeconds : (simple int) a timeframe in seconds to convert to a string.      mult : (simple float) Multiple of `tfInSeconds` to be calculated. Optional. 1 (no multiplier) is default.   Returns: (string) The `tfInSeconds` in `timeframe.period` format usable with `request.security()`.
Biblioteca Pine Script™
por PineCoders
34
[e2] Drawing Library :: Horizontal Ray█ OVERVIEW Library "e2hray" A drawing library that contains the hray() function, which draws a horizontal ray/s with an initial point determined by a specified condition. It plots a ray until it reached the price. The function let you control the visibility of historical levels and setup the alerts. █ HORIZONTAL RAY FUNCTION hray(condition, level, color, extend, hist_lines, alert_message, alert_delay, style, hist_style, width, hist_width)   Parameters:      condition : Boolean condition that defines the initial point of a ray      level : Ray price level.      color : Ray color.      extend : (optional) Default value true, current ray levels extend to the right, if false - up to the current bar.      hist_lines : (optional) Default value true, shows historical ray levels that were revisited, default is dashed lines. To avoid alert problems set to 'false' before creating alerts.      alert_message : (optional) Default value string(na), if declared, enables alerts that fire when price revisits a line, using the text specified      alert_delay : (optional) Default value int(0), number of bars to validate the level. Alerts won't trigger if the ray is broken during the 'delay'.      style : (optional) Default value 'line.style_solid'. Ray line style.      hist_style : (optional) Default value 'line.style_dashed'. Historical ray line style.      width : (optional) Default value int(1), ray width in pixels.      hist_width : (optional) Default value int(1), historical ray width in pixels.   Returns: void █ EXAMPLES  • Example 1. Single horizontal ray from the dynamic input. //@version=5 indicator("hray() example :: Dynamic input ray", overlay = true) import e2e4mfck/e2hray/1 as e2draw inputTime = input.time(timestamp("20 Jul 2021 00:00 +0300"), "Date", confirm = true) inputPrice = input.price(54, 'Price Level', confirm = true) e2draw.hray(time == inputTime, inputPrice, color.blue, alert_message = 'Ray level re-test!') var label mark = label.new(inputTime, inputPrice, 'Selected point to start the ray', xloc.bar_time)  • Example 2. Multiple horizontal rays on the moving averages cross. //@version=5 indicator("hray() example :: MA Cross", overlay = true) import e2e4mfck/e2hray/1 as e2draw float sma1 = ta.​sma​(close, 20) float sma2 = ta.​sma​(close, 50) bullishCross = ta.crossover( sma1, sma2) bearishCross = ta.crossunder(sma1, sma2) plot(sma1, 'sma1', color.purple) plot(sma2, 'sma2', color.blue) // 1a. We can use 2 function calls to distinguish long and short sides. e2draw.hray(bullishCross, sma1, color.green, alert_message = 'Bullish Cross Level Broken!', alert_delay = 10) e2draw.hray(bearishCross, sma2, color.red, alert_message = 'Bearish Cross Level Broken!', alert_delay = 10) // 1b. Or a single call for both. // e2draw.hray(bullishCross or bearishCross, sma1, bullishCross ? color.green : color.red)  • Example 3. Horizontal ray at the all time highs with an alert. //@version=5 indicator("hray() example :: ATH", overlay = true) import e2e4mfck/e2hray/1 as e2draw var float ​ath​ = 0, ​ath​ := math.max(high, ​ath​) bool newAth = ta.change(​ath​) e2draw.hray(​nz​(newAth ), high , color.orange, alert_message = 'All Time Highs Tested!', alert_delay = 10)
Biblioteca Pine Script™
por e2e4
16
DebugConsoleLibrary "DebugConsole" Methods for debuging/output into a table, console like style. init(size) initiate property variables. Parameters: size : int, console line size. Returns: tuple, table and string array. queue(console_id, new_line) Regular Queue, will be called once every bar its called. Parameters: console_id : string array, console configuration array. new_line : string, with contents for new line. Returns: void. queue_one(console_id, new_line) Queue only one time, will not repeat itself. Parameters: console_id : string array, console configuration array. new_line : string, with contents for new line. Returns: void. update(table_id, console_id) Update method for the console screen. Parameters: table_id : table, table to update console text. console_id : string array, console configuration array. Returns: void.
Biblioteca Pine Script™
por RicardoSantos
37
BjCandlePatternsLibrary "BjCandlePatterns" Patterns is a Japanese candlestick pattern recognition Library for developers. Functions here within detect viable setups in a variety of popular patterns. Please note some patterns are without filters such as comparisons to average candle sizing, or trend detection to allow the author more freedom. doji(dojiSize, dojiWickSize) Detects "Doji" candle patterns   Parameters:      dojiSize : (float) The relationship of body to candle size (ie. body is 5% of total candle size). Default is 5.0 (5%)      dojiWickSize : (float) Maximum wick size comparative to the opposite wick. (eg. 2 = bottom wick must be less than or equal to 2x the top wick). Default is 2   Returns: (series bool) True when pattern detected dLab(showLabel, labelColor, textColor) Produces "Doji" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow      textColor : (series color) Text color   Returns: (series label) A label visible at the chart level intended for the title pattern bullEngulf(maxRejectWick, mustEngulfWick) Detects "Bullish Engulfing" candle patterns   Parameters:      maxRejectWick : (float) Maximum rejection wick size. The maximum wick size as a percentge of body size allowable for a top wick on the resolution candle of the pattern. 0.0 disables the filter. eg. 50 allows a top wick half the size of the body. Default is 0% (Disables wick detection).      mustEngulfWick : (bool) input to only detect setups that close above the high prior effectively engulfing the candle in its entirety. Default is false   Returns: (series bool) True when pattern detected bewLab(showLabel, labelColor, textColor) Produces "Bullish Engulfing" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow      textColor : (series color) Text color   Returns: (series label) A label visible at the chart level intended for the title pattern bearEngulf(maxRejectWick, mustEngulfWick) Detects "Bearish Engulfing" candle patterns   Parameters:      maxRejectWick : (float) Maximum rejection wick size. The maximum wick size as a percentge of body size allowable for a bottom wick on the resolution candle of the pattern. 0.0 disables the filter. eg. 50 allows a botom wick half the size of the body. Default is 0% (Disables wick detection).      mustEngulfWick : (bool) Input to only detect setups that close below the low prior effectively engulfing the candle in its entirety. Default is false   Returns: (series bool) True when pattern detected bebLab(showLabel, labelColor, textColor) Produces "Bearish Engulfing" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow      textColor : (series color) Text color   Returns: (series label) A label visible at the chart level intended for the title pattern hammer(ratio, shadowPercent) Detects "Hammer" candle patterns   Parameters:      ratio : (float) The relationship of body to candle size (ie. body is 33% of total candle size). Default is 33%.      shadowPercent : (float) The maximum allowable top wick size as a percentage of body size. Default is 5%.   Returns: (series bool) True when pattern detected hLab(showLabel, labelColor, textColor) Produces "Hammer" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow      textColor : (series color) Text color   Returns: (series label) A label visible at the chart level intended for the title pattern star(ratio, shadowPercent) Detects "Star" candle patterns   Parameters:      ratio : (float) The relationship of body to candle size (ie. body is 33% of total candle size). Default is 33%.      shadowPercent : (float) The maximum allowable bottom wick size as a percentage of body size. Default is 5%.   Returns: (series bool) True when pattern detected ssLab(showLabel, labelColor, textColor) Produces "Star" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow      textColor : (series color) Text color   Returns: (series label) A label visible at the chart level intended for the title pattern dragonflyDoji() Detects "Dragonfly Doji" candle patterns   Returns: (series bool) True when pattern detected ddLab(showLabel, labelColor) Produces "Dragonfly Doji" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow   Returns: (series label) A label visible at the chart level intended for the title pattern gravestoneDoji() Detects "Gravestone Doji" candle patterns   Returns: (series bool) True when pattern detected gdLab(showLabel, labelColor, textColor) Produces "Gravestone Doji" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow      textColor : (series color) Text color   Returns: (series label) A label visible at the chart level intended for the title pattern tweezerBottom(closeUpperHalf) Detects "Tweezer Bottom" candle patterns   Parameters:      closeUpperHalf : (bool) input to only detect setups that close above the mid-point of the candle prior increasing its bullish tendancy. Default is false   Returns: (series bool) True when pattern detected tbLab(showLabel, labelColor, textColor) Produces "Tweezer Bottom" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow      textColor : (series color) Text color   Returns: (series label) A label visible at the chart level intended for the title pattern tweezerTop(closeLowerHalf) Detects "TweezerTop" candle patterns   Parameters:      closeLowerHalf : (bool) input to only detect setups that close below the mid-point of the candle prior increasing its bearish tendancy. Default is false   Returns: (series bool) True when pattern detected ttLab(showLabel, labelColor, textColor) Produces "TweezerTop" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow      textColor : (series color) Text color   Returns: (series label) A label visible at the chart level intended for the title pattern spinningTopBull(wickSize) Detects "Bullish Spinning Top" candle patterns   Parameters:      wickSize : (float) input to adjust detection of the size of the top wick/ bottom wick as a percent of total candle size. Default is 34%, which ensures the wicks are both larger than the body.   Returns: (series bool) True when pattern detected stwLab(showLabel, labelColor, textColor) Produces "Bullish Spinning Top" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow      textColor : (series color) Text color   Returns: (series label) A label visible at the chart level intended for the title pattern spinningTopBear(wickSize) Detects "Bearish Spinning Top" candle patterns   Parameters:      wickSize : (float) input to adjust detection of the size of the top wick/ bottom wick as a percent of total candle size. Default is 34%, which ensures the wicks are both larger than the body.   Returns: (series bool) True when pattern detected stbLab(showLabel, labelColor, textColor) Produces "Bearish Spinning Top" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow      textColor : (series color) Text color   Returns: (series label) A label visible at the chart level intended for the title pattern spinningTop(wickSize) Detects "Spinning Top" candle patterns   Parameters:      wickSize : (float) input to adjust detection of the size of the top wick/ bottom wick as a percent of total candle size. Default is 34%, which ensures the wicks are both larger than the body.   Returns: (series bool) True when pattern detected stLab(showLabel, labelColor, textColor) Produces "Spinning Top" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow      textColor : (series color) Text color   Returns: (series label) A label visible at the chart level intended for the title pattern morningStar() Detects "Bullish Morning Star" candle patterns   Returns: (series bool) True when pattern detected msLab(showLabel, labelColor, textColor) Produces "Bullish Morning Star" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow      textColor : (series color) Text color   Returns: (series label) A label visible at the chart level intended for the title pattern eveningStar() Detects "Bearish Evening Star" candle patterns   Returns: (series bool) True when pattern detected esLab(showLabel, labelColor, textColor) Produces "Bearish Evening Star" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow      textColor : (series color) Text color   Returns: (series label) A label visible at the chart level intended for the title pattern haramiBull() Detects "Bullish Harami" candle patterns   Returns: (series bool) True when pattern detected hwLab(showLabel, labelColor, textColor) Produces "Bullish Harami" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow      textColor : (series color) Text color   Returns: (series label) A label visible at the chart level intended for the title pattern haramiBear() Detects "Bearish Harami" candle patterns   Returns: (series bool) True when pattern detected hbLab(showLabel, labelColor, textColor) Produces "Bearish Harami" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow      textColor : (series color) Text color   Returns: (series label) A label visible at the chart level intended for the title pattern haramiBullCross() Detects "Bullish Harami Cross" candle patterns   Returns: (series bool) True when pattern detected hcwLab(showLabel, labelColor, textColor) Produces "Bullish Harami Cross" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow      textColor : (series color) Text color   Returns: (series label) A label visible at the chart level intended for the title pattern haramiBearCross() Detects "Bearish Harami Cross" candle patterns   Returns: (series bool) True when pattern detected hcbLab(showLabel, labelColor) Produces "Bearish Harami Cross" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow   Returns: (series label) A label visible at the chart level intended for the title pattern marubullzu() Detects "Bullish Marubozu" candle patterns   Returns: (series bool) True when pattern detected mwLab(showLabel, labelColor, textColor) Produces "Bullish Marubozu" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow      textColor : (series color) Text color   Returns: (series label) A label visible at the chart level intended for the title pattern marubearzu() Detects "Bearish Marubozu" candle patterns   Returns: (series bool) True when pattern detected mbLab(showLabel, labelColor, textColor) Produces "Bearish Marubozu" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow      textColor : (series color) Text color   Returns: (series label) A label visible at the chart level intended for the title pattern abandonedBull() Detects "Bullish Abandoned Baby" candle patterns   Returns: (series bool) True when pattern detected abwLab(showLabel, labelColor, textColor) Produces "Bullish Abandoned Baby" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow      textColor : (series color) Text color   Returns: (series label) A label visible at the chart level intended for the title pattern abandonedBear() Detects "Bearish Abandoned Baby" candle patterns   Returns: (series bool) True when pattern detected abbLab(showLabel, labelColor, textColor) Produces "Bearish Abandoned Baby" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow      textColor : (series color) Text color   Returns: (series label) A label visible at the chart level intended for the title pattern piercing() Detects "Piercing" candle patterns   Returns: (series bool) True when pattern detected pLab(showLabel, labelColor, textColor) Produces "Piercing" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow      textColor : (series color) Text color   Returns: (series label) A label visible at the chart level intended for the title pattern darkCloudCover() Detects "Dark Cloud Cover" candle patterns   Returns: (series bool) True when pattern detected dccLab(showLabel, labelColor, textColor) Produces "Dark Cloud Cover" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow      textColor : (series color) Text color   Returns: (series label) A label visible at the chart level intended for the title pattern tasukiBull() Detects "Upside Tasuki Gap" candle patterns   Returns: (series bool) True when pattern detected utgLab(showLabel, labelColor, textColor) Produces "Upside Tasuki Gap" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow      textColor : (series color) Text color   Returns: (series label) A label visible at the chart level intended for the title pattern tasukiBear() Detects "Downside Tasuki Gap" candle patterns   Returns: (series bool) True when pattern detected dtgLab(showLabel, labelColor, textColor) Produces "Downside Tasuki Gap" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow      textColor : (series color) Text color   Returns: (series label) A label visible at the chart level intended for the title pattern risingThree() Detects "Rising Three Methods" candle patterns   Returns: (series bool) True when pattern detected rtmLab(showLabel, labelColor, textColor) Produces "Rising Three Methods" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow      textColor : (series color) Text color   Returns: (series label) A label visible at the chart level intended for the title pattern fallingThree() Detects "Falling Three Methods" candle patterns   Returns: (series bool) True when pattern detected ftmLab(showLabel, labelColor, textColor) Produces "Falling Three Methods" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow      textColor : (series color) Text color   Returns: (series label) A label visible at the chart level intended for the title pattern risingWindow() Detects "Rising Window" candle patterns   Returns: (series bool) True when pattern detected rwLab(showLabel, labelColor, textColor) Produces "Rising Window" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow      textColor : (series color) Text color   Returns: (series label) A label visible at the chart level intended for the title pattern fallingWindow() Detects "Falling Window" candle patterns   Returns: (series bool) True when pattern detected fwLab(showLabel, labelColor, textColor) Produces "Falling Window" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow      textColor : (series color) Text color   Returns: (series label) A label visible at the chart level intended for the title pattern kickingBull() Detects "Bullish Kicking" candle patterns   Returns: (series bool) True when pattern detected kwLab(showLabel, labelColor, textColor) Produces "Bullish Kicking" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow      textColor : (series color) Text color   Returns: (series label) A label visible at the chart level intended for the title pattern kickingBear() Detects "Bearish Kicking" candle patterns   Returns: (series bool) True when pattern detected kbLab(showLabel, labelColor, textColor) Produces "Bearish Kicking" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow      textColor : (series color) Text color   Returns: (series label) A label visible at the chart level intended for the title pattern lls(ratio) Detects "Long Lower Shadow" candle patterns   Parameters:      ratio : (float) A relationship of the lower wick to the overall candle size expressed as a percent. Default is 75%   Returns: (series bool) True when pattern detected llsLab(showLabel, labelColor, textColor) Produces "Long Lower Shadow" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow      textColor : (series color) Text color   Returns: (series label) A label visible at the chart level intended for the title pattern lus(ratio) Detects "Long Upper Shadow" candle patterns   Parameters:      ratio : (float) A relationship of the upper wick to the overall candle size expressed as a percent. Default is 75%   Returns: (series bool) True when pattern detected lusLab(showLabel, labelColor, textColor) Produces "Long Upper Shadow" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow      textColor : (series color) Text color   Returns: (series label) A label visible at the chart level intended for the title pattern bullNeck() Detects "Bullish On Neck" candle patterns   Returns: (series bool) True when pattern detected nwLab(showLabel, labelColor, textColor) Produces "Bullish On Neck" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow      textColor : (series color) Text color   Returns: (series label) A label visible at the chart level intended for the title pattern bearNeck() Detects "Bearish On Neck" candle patterns   Returns: (series bool) True when pattern detected nbLab(showLabel, labelColor, textColor) Produces "Bearish On Neck" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow      textColor : (series color) Text color   Returns: (series label) A label visible at the chart level intended for the title pattern soldiers(wickSize) Detects "Three White Soldiers" candle patterns   Parameters:      wickSize : (float) Maximum allowable top wick size throughout pattern expressed as a percent of total candle height. Default is 5%   Returns: (series bool) True when pattern detected wsLab(showLabel, labelColor, textColor) Produces "Three White Soldiers" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow      textColor : (series color) Text color   Returns: (series label) A label visible at the chart level intended for the title pattern crows(wickSize) Detects "Three Black Crows" candle patterns   Parameters:      wickSize : (float) Maximum allowable bottom wick size throughout pattern expressed as a percent of total candle height. Default is 5%   Returns: (series bool) True when pattern detected bcLab(showLabel, labelColor, textColor) Produces "Three Black Crows" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow      textColor : (series color) Text color   Returns: (series label) A label visible at the chart level intended for the title pattern triStarBull() Detects "Bullish Tri-Star" candle patterns   Returns: (series bool) True when pattern detected tswLab(showLabel, labelColor, textColor) Produces "Bullish Tri-Star" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow      textColor : (series color) Text color   Returns: (series label) A label visible at the chart level intended for the title pattern triStarBear() Detects "Bearish Tri-Star" candle patterns   Returns: (series bool) True when pattern detected tsbLab(showLabel, labelColor, textColor) Produces "Bearish Tri-Star" identifier label   Parameters:      showLabel : (bool) Shows label when input is true. Default is false      labelColor : (series color) Color of the label border and arrow      textColor : (series color) Text color   Returns: (series label) A label visible at the chart level intended for the title pattern wrap(cond, barsBack, borderColor, bgcolor) Produces a box wrapping the highs and lows over the look back.   Parameters:      cond : (series bool) Condition under which to draw the box.      barsBack : (series int) the number of bars back to begin drawing the box.      borderColor : (series color) Color of the four borders. Optional. The default is color.gray.      bgcolor : (series color) Background color of the box. Optional. The default is color.gray.   Returns: (series box) A box who's top and bottom are above and below the highest and lowest points over the lookback topWick() returns the top wick size of the current candle   Returns: (series float) A value equivelent to the distance from the top of the candle body to its high bottomWick() returns the bottom wick size of the current candle   Returns: (series float) A value equivelent to the distance from the bottom of the candle body to its low body() returns the body size of the current candle   Returns: (series float) A value equivelent to the distance between the top and the bottom of the candle body highestBody() returns the highest body of the current candle   Returns: (series float) A value equivelent to the highest body, whether it is the open or the close lowestBody() returns the lowest body of the current candle   Returns: (series float) A value equivelent to the highest body, whether it is the open or the close barRange() returns the height of the current candle   Returns: (series float) A value equivelent to the distance between the high and the low of the candle bodyPct() returns the body size as a percent   Returns: (series float) A value equivelent to the percentage of body size to the overall candle size midBody() returns the price of the mid-point of the candle body   Returns: (series float) A value equivelent to the center point of the distance bewteen the body low and the body high bodyupGap() returns true if there is a gap up between the real body of the current candle in relation to the candle prior   Returns: (series bool) true if there is a gap up and no overlap in the real bodies of the current candle and the preceding candle bodydwnGap() returns true if there is a gap down between the real body of the current candle in relation to the candle prior   Returns: (series bool) true if there is a gap down and no overlap in the real bodies of the current candle and the preceding candle gapUp() returns true if there is a gap down between the real body of the current candle in relation to the candle prior   Returns: (series bool) true if there is a gap down and no overlap in the real bodies of the current candle and the preceding candle gapDwn() returns true if there is a gap down between the real body of the current candle in relation to the candle prior   Returns: (series bool) true if there is a gap down and no overlap in the real bodies of the current candle and the preceding candle dojiBody() returns true if the candle body is a doji   Returns: (series bool) true if the candle body is a doji. Defined by a body that is 5% of total candle size
Biblioteca Pine Script™
por Bjorgum
63
FunctionLinearRegressionLibrary "FunctionLinearRegression" Method for Linear Regression using array sample points. linreg(sample_x, sample_y) Performs Linear Regression over the provided sample points.   Parameters:      sample_x : float array, sample points X value.      sample_y : float array, sample points Y value.   Returns: tuple with: _predictions: Array with adjusted Y values. _max_dev: Max deviation from the mean. _min_dev: Min deviation from the mean. _stdev/_sizeX: Average deviation from the mean. draw(sample_x, sample_y, extend, mid_color, mid_style, mid_width, std_color, std_style, std_width, max_color, max_style, max_width) Method for drawing the Linear Regression into chart.   Parameters:      sample_x : float array, sample point X value.      sample_y : float array, sample point Y value.      extend : string, default=extend.none, extend lines.      mid_color : color, default=color.blue, middle line color.      mid_style : string, default=line.style_solid, middle line style.      mid_width : int, default=2, middle line width.      std_color : color, default=color.aqua, standard deviation line color.      std_style : string, default=line.style_dashed, standard deviation line style.      std_width : int, default=1, standard deviation line width.      max_color : color, default=color.purple, max range line color.      max_style : string, default=line.style_dotted, max line style.      max_width : int, default=1, max line width.   Returns: line array.
Biblioteca Pine Script™
por RicardoSantos
10
pandas_taLibrary "pandas_ta" Level: 3 Background Today is the first day of 2022 and happy new year every tradingviewers! May health and wealth go along with you all the time. I use this chance to publish my 1st PINE v5 lib : pandas_ta This is not a piece of cake like thing, which cost me a lot of time and efforts to build this lib. Beyond 300 versions of this script was iterated in draft. Function Library "pandas_ta" PINE v5 Counterpart of Pandas TA - A Technical Analysis Library in Python 3 at github.com The Original Pandas Technical Analysis (Pandas TA) is an easy to use library that leverages the Pandas package with more than 130 Indicators and Utility functions and more than 60 TA Lib Candlestick Patterns. I realized most of indicators except Candlestick Patterns because tradingview built-in Candlestick Patterns are even more powerful! I use this to verify pandas_ta python version indicators for myself, but I realize that maybe many may need similar lib for pine v5 as well. Function Brief Descriptions (Pls find details in script comments) bton --> Binary to number wcp --> Weighted Closing Price (WCP) counter --> Condition counter xbt --> Between ebsw --> Even Better SineWave (EBSW) ao --> Awesome Oscillator (AO) apo --> Absolute Price Oscillator (APO) xrf --> Dynamic shifted values bias --> Bias (BIAS) bop --> Balance of Power (BOP) brar --> BRAR (BRAR) cci --> Commodity Channel Index (CCI) cfo --> Chande Forcast Oscillator (CFO) cg --> Center of Gravity (CG) cmo --> Chande Momentum Oscillator (CMO) coppock --> Coppock Curve (COPC) cti --> Correlation Trend Indicator (CTI) dmi --> Directional Movement Index(DMI) er --> Efficiency Ratio (ER) eri --> Elder Ray Index (ERI) fisher --> Fisher Transform (FISHT) inertia --> Inertia (INERTIA) kdj --> KDJ (KDJ) kst --> 'Know Sure Thing' (KST) macd --> Moving Average Convergence Divergence (MACD) mom --> Momentum (MOM) pgo --> Pretty Good Oscillator (PGO) ppo --> Percentage Price Oscillator (PPO) psl --> Psychological Line (PSL) pvo --> Percentage Volume Oscillator (PVO) qqe --> Quantitative Qualitative Estimation (QQE) roc --> Rate of Change (ROC) rsi --> Relative Strength Index (RSI) rsx --> Relative Strength Xtra (rsx) rvgi --> Relative Vigor Index (RVGI) slope --> Slope smi --> SMI Ergodic Indicator (SMI) sqz* --> Squeeze (SQZ) * NOTE: code sufferred from very strange error, code was commented. sqz_pro --> Squeeze PRO(SQZPRO) xfl --> Condition filter stc --> Schaff Trend Cycle (STC) stoch --> Stochastic (STOCH) stochrsi --> Stochastic RSI (STOCH RSI) trix --> Trix (TRIX) tsi --> True Strength Index (TSI) uo --> Ultimate Oscillator (UO) willr --> William's Percent R (WILLR) alma --> Arnaud Legoux Moving Average (ALMA) xll --> Dynamic rolling lowest values dema --> Double Exponential Moving Average (DEMA) ema --> Exponential Moving Average (EMA) fwma --> Fibonacci's Weighted Moving Average (FWMA) hilo --> Gann HiLo Activator(HiLo) hma --> Hull Moving Average (HMA) hwma --> HWMA (Holt-Winter Moving Average) ichimoku --> Ichimoku Kinkō Hyō (ichimoku) jma --> Jurik Moving Average Average (JMA) kama --> Kaufman's Adaptive Moving Average (KAMA) linreg --> Linear Regression Moving Average (linreg) mgcd --> McGinley Dynamic Indicator rma --> wildeR's Moving Average (RMA) sinwma --> Sine Weighted Moving Average (SWMA) ssf --> Ehler's Super Smoother Filter (SSF) © 2013 supertrend --> Supertrend (supertrend) xsa --> X simple moving average swma --> Symmetric Weighted Moving Average (SWMA) t3 --> Tim Tillson's T3 Moving Average (T3) tema --> Triple Exponential Moving Average (TEMA) trima --> Triangular Moving Average (TRIMA) vidya --> Variable Index Dynamic Average (VIDYA) vwap --> Volume Weighted Average Price (VWAP) vwma --> Volume Weighted Moving Average (VWMA) wma --> Weighted Moving Average (WMA) zlma --> Zero Lag Moving Average (ZLMA) entropy --> Entropy (ENTP) kurtosis --> Rolling Kurtosis skew --> Rolling Skew xev --> Condition all zscore --> Rolling Z Score adx --> Average Directional Movement (ADX) aroon --> Aroon & Aroon Oscillator (AROON) chop --> Choppiness Index (CHOP) xex --> Condition any cksp --> Chande Kroll Stop (CKSP) dpo --> Detrend Price Oscillator (DPO) long_run --> Long Run psar --> Parabolic Stop and Reverse (psar) short_run --> Short Run vhf --> Vertical Horizontal Filter (VHF) vortex --> Vortex accbands --> Acceleration Bands (ACCBANDS) atr --> Average True Range (ATR) bbands --> Bollinger Bands (BBANDS) donchian --> Donchian Channels (DC) kc --> Keltner Channels (KC) massi --> Mass Index (MASSI) natr --> Normalized Average True Range (NATR) pdist --> Price Distance (PDIST) rvi --> Relative Volatility Index (RVI) thermo --> Elders Thermometer (THERMO) ui --> Ulcer Index (UI) ad --> Accumulation/Distribution (AD) cmf --> Chaikin Money Flow (CMF) efi --> Elder's Force Index (EFI) ecm --> Ease of Movement (EOM) kvo --> Klinger Volume Oscillator (KVO) mfi --> Money Flow Index (MFI) nvi --> Negative Volume Index (NVI) obv --> On Balance Volume (OBV) pvi --> Positive Volume Index (PVI) dvdi --> Dual Volume Divergence Index (DVDI) xhh --> Dynamic rolling highest values pvt --> Price-Volume Trend (PVT) Remarks I also incorporated func descriptions and func test script in commented mode, you can test the functino with the embedded test script and modify them as you wish. This is a Level 3 free and open source indicator library. Feedbacks are appreciated. This is not the end of pandas_ta lib publication, but it is start point with pine v5 lib function and I will add more and more funcs into this lib for my own indicators. Function Name List: bton() wcp() count() xbt() ebsw() ao() apo() xrf() bias() bop() brar() cci() cfo() cg() cmo() coppock() cti() dmi() er() eri() fisher() inertia() kdj() kst() macd() mom() pgo() ppo() psl() pvo() qqe() roc() rsi() rsx() rvgi() slope() smi() sqz_pro() xfl() stc() stoch() stochrsi() trix() tsi() uo() willr() alma() wcx() xll() dema() ema() fwma() hilo() hma() hwma() ichimoku() jma() kama() linreg() mgcd() rma() sinwma() ssf() supertrend() xsa() swma() t3() tema() trima() vidya() vwap() vwma() wma() zlma() entropy() kurtosis() skew() xev() zscore() adx() aroon() chop() xex() cksp() dpo() long_run() psar() short_run() vhf() vortex() accbands() atr() bbands() donchian() kc() massi() natr() pdist() rvi() thermo() ui() ad() cmf() efi() ecm() kvo() mfi() nvi() obv() pvi() dvdi() xhh() pvt()
Biblioteca Pine Script™
por blackcat1402
20
HarmonicPatternLibrary "HarmonicPattern" Functions to detect/check harmonic patterns from provided values. line_price_rate(point_c, point_b, point_a) Compute the price rate of the line AB divided by the the line BC Parameters: point_c : float, the price at point C. point_b : float, the price at point B. point_a : float, the price at point A. Returns: float line_time_rate(_c, _b, _a) Compute the time rate of the line AB divided by the the line BC Parameters: _c : float, the time or bar_index at point C. _b : float, the time or bar_index at point B. _a : float, the time or bar_index at point A. Returns: float is_inrange(value, min, max) Check if value is within min/max range of tolerance. Parameters: value : float, value to check tolerance. min : float, minimum value in range of tolerance. max : float, maximum value in range of tolerance. Returns: bool isHarmonicTriangle(rate_cba, margin_of_error) Check if the rate(s) correspond to pattern ("Harmonic Triangle"). Parameters: rate_cba : float, percent rate of the triangle CBA. expects a negative rate. margin_of_error : float, percent rate of expected error margin, default 0.05(5%). Returns: bool is2Tap(rate_cba, margin_of_error) Check if the rate(s) correspond to pattern ("2Tap", 'Double Top / Bottom'). Parameters: rate_cba : float, percent rate of the triangle CBA. expects a negative rate. margin_of_error : float, percent rate of expected error margin, default 0.05(5%). Returns: bool is3Tap(rate_edc, rate_cba, margin_of_error) Check if the rate(s) correspond to pattern ("3Tap", "Triple Top / Bottom"). Parameters: rate_edc : float, percent rate of the triangle EDC. expects a negative rate. rate_cba : float, percent rate of the triangle CBA. expects a negative rate. margin_of_error : float, percent rate of expected error margin, default 0.05(5%). Returns: bool is4Tap(rate_gfe, rate_edc, rate_cba, margin_of_error) Check if the rate(s) correspond to pattern ("4Tap", "Quadruple Top / Bottom"). Parameters: rate_gfe : float, percent rate of the triangle GFE. expects a negative rate. rate_edc : float, percent rate of the triangle EDC. expects a negative rate. rate_cba : float, percent rate of the triangle CBA. expects a negative rate. margin_of_error : float, percent rate of expected error margin, default 0.05(5%). Returns: bool isABCD(rate_cba, rate_dcb, margin_of_error) Check if the rate(s) correspond to pattern ("AB=CD"). Parameters: rate_cba : float, percent rate of the triangle CBA. expects a negative rate. rate_dcb : float, percent rate of the triangle DCB. expects a negative rate. margin_of_error : float, percent rate of expected error margin, default 0.05(5%). Returns: bool isBat(rate_edc, rate_dcb, rate_cba, rate_eda, margin_of_error) Check if the rate(s) correspond to pattern ("Bat"). Parameters: rate_edc : float, percent rate of the triangle EDC. expects a negative rate. rate_dcb : float, percent rate of the triangle DCB. expects a negative rate. rate_cba : float, percent rate of the triangle CBA. expects a negative rate. rate_eda : float, percent rate of the triangle EDA. expects a negative rate. margin_of_error : float, percent rate of expected error margin, default 0.05(5%). Returns: bool isButterfly(rate_edc, rate_dcb, rate_cba, rate_eda, margin_of_error) Check if the rate(s) correspond to pattern ("Butterfly"). Parameters: rate_edc : float, percent rate of the triangle EDC. expects a negative rate. rate_dcb : float, percent rate of the triangle DCB. expects a negative rate. rate_cba : float, percent rate of the triangle CBA. expects a negative rate. rate_eda : float, percent rate of the triangle EDA. expects a negative rate. margin_of_error : float, percent rate of expected error margin, default 0.05(5%). Returns: bool isGartley(rate_edc, rate_dcb, rate_cba, rate_eda, margin_of_error) Check if the rate(s) correspond to pattern ("Gartley"). Parameters: rate_edc : float, percent rate of the triangle EDC. expects a negative rate. rate_dcb : float, percent rate of the triangle DCB. expects a negative rate. rate_cba : float, percent rate of the triangle CBA. expects a negative rate. rate_eda : float, percent rate of the triangle EDA. expects a negative rate. margin_of_error : float, percent rate of expected error margin, default 0.05(5%). Returns: bool isCrab(rate_edc, rate_dcb, rate_cba, rate_eda, margin_of_error) Check if the rate(s) correspond to pattern ("Crab"). Parameters: rate_edc : float, percent rate of the triangle EDC. expects a negative rate. rate_dcb : float, percent rate of the triangle DCB. expects a negative rate. rate_cba : float, percent rate of the triangle CBA. expects a negative rate. rate_eda : float, percent rate of the triangle EDA. expects a negative rate. margin_of_error : float, percent rate of expected error margin, default 0.05(5%). Returns: bool isShark(rate_edc, rate_dcb, rate_cba, rate_eda, margin_of_error) Check if the rate(s) correspond to pattern ("Shark"). Parameters: rate_edc : float, percent rate of the triangle EDC. expects a negative rate. rate_dcb : float, percent rate of the triangle DCB. expects a negative rate. rate_cba : float, percent rate of the triangle CBA. expects a negative rate. rate_eda : float, percent rate of the triangle EDA. expects a negative rate. margin_of_error : float, percent rate of expected error margin, default 0.05(5%). Returns: bool is5o(rate_edc, rate_dcb, rate_cba, rate_eda, margin_of_error) Check if the rate(s) correspond to pattern ("5o"). Parameters: rate_edc : float, percent rate of the triangle EDC. expects a negative rate. rate_dcb : float, percent rate of the triangle DCB. expects a negative rate. rate_cba : float, percent rate of the triangle CBA. expects a negative rate. rate_eda : float, percent rate of the triangle EDA. expects a negative rate. margin_of_error : float, percent rate of expected error margin, default 0.05(5%). Returns: bool isWolfe(rate_edc, rate_dcb, rate_cba, rate_eda, margin_of_error) Check if the rate(s) correspond to pattern ("Wolfe"). Parameters: rate_edc : float, percent rate of the triangle EDC. expects a negative rate. rate_dcb : float, percent rate of the triangle DCB. expects a negative rate. rate_cba : float, percent rate of the triangle CBA. expects a negative rate. rate_eda : float, percent rate of the triangle EDA. expects a negative rate. margin_of_error : float, percent rate of expected error margin, default 0.05(5%). Returns: bool is3Driver(rate_edc, rate_dcb, rate_cba, rate_eda, margin_of_error) Check if the rate(s) correspond to pattern ("3 Driver"). Parameters: rate_edc : float, percent rate of the triangle EDC. expects a negative rate. rate_dcb : float, percent rate of the triangle DCB. expects a negative rate. rate_cba : float, percent rate of the triangle CBA. expects a negative rate. rate_eda : float, percent rate of the triangle EDA. expects a negative rate. margin_of_error : float, percent rate of expected error margin, default 0.05(5%). Returns: bool isConTria(rate_edc, rate_dcb, rate_cba, rate_eda, margin_of_error) Check if the rate(s) correspond to pattern ("Contracting Triangle"). Parameters: rate_edc : float, percent rate of the triangle EDC. expects a negative rate. rate_dcb : float, percent rate of the triangle DCB. expects a negative rate. rate_cba : float, percent rate of the triangle CBA. expects a negative rate. rate_eda : float, percent rate of the triangle EDA. expects a negative rate. margin_of_error : float, percent rate of expected error margin, default 0.05(5%). Returns: bool isExpTria(rate_edc, rate_dcb, rate_cba, rate_eda, margin_of_error) Check if the rate(s) correspond to pattern ("Expanding Triangle"). Parameters: rate_edc : float, percent rate of the triangle EDC. expects a negative rate. rate_dcb : float, percent rate of the triangle DCB. expects a negative rate. rate_cba : float, percent rate of the triangle CBA. expects a negative rate. rate_eda : float, percent rate of the triangle EDA. expects a negative rate. margin_of_error : float, percent rate of expected error margin, default 0.05(5%). Returns: bool isHnS(rate_fed, rate_feb, rate_edc, rate_dcb, rate_cba, rate_eda, margin_of_error) Check if the rate(s) correspond to pattern ("Head and Shoulders"). Parameters: rate_fed : float, percent rate of the triangle FED. expects a negative rate. rate_feb : float, percent rate of the triangle FEB. expects a negative rate. rate_edc : float, percent rate of the triangle EDC. expects a negative rate. rate_dcb : float, percent rate of the triangle DCB. expects a negative rate. rate_cba : float, percent rate of the triangle CBA. expects a negative rate. rate_eda : float, percent rate of the triangle EDA. expects a negative rate. margin_of_error : float, percent rate of expected error margin, default 0.05(5%). Returns: bool
Biblioteca Pine Script™
por RicardoSantos
7
benchLibrary "bench" A simple banchmark library to analyse script performance and bottlenecks. Very useful if you are developing an overly complex application in Pine Script, or trying to optimise a library / function / algorithm... Supports artificial looping benchmarks (of fast functions) Supports integrated linear benchmarks (of expensive scripts) One important thing to note is that the Pine Script compiler will completely ignore any calculations that do not eventually produce chart output. Therefore, if you are performing an artificial benchmark you will need to use the bench.reference(value) function to ensure the calculations are executed. Please check the examples towards the bottom of the script. Quick Reference (Be warned this uses non-standard space characters to get the line indentation to work in the description!) ``` // Looping benchmark style benchmark = bench.new(samples = 500, loops = 5000) data = array.new_int() if bench.start(benchmark)   while bench.loop(benchmark)     array.unshift(data, timenow)   bench.mark(benchmark)   while bench.loop(benchmark)     array.unshift(data, timenow)   bench.mark(benchmark)   while bench.loop(benchmark)     array.unshift(data, timenow)   bench.stop(benchmark)   bench.reference(array.get(data, 0)) bench.report(benchmark, '1x array.unshift()') // Linear benchmark style benchmark = bench.new() data = array.new_int() bench.start(benchmark) for i = 0 to 1000   array.unshift(data, timenow) bench.mark(benchmark) for i = 0 to 1000   array.unshift(data, timenow) bench.stop(benchmark) bench.reference(array.get(data, 0)) bench.report(benchmark,'1000x array.unshift()') ``` Detailed Interface new(samples, loops) Initialises a new benchmark array   Parameters:      samples : int, the number of bars in which to collect samples      loops : int, the number of loops to execute within each sample   Returns: int , the benchmark array active(benchmark) Determing if the benchmarks state is active   Parameters:      benchmark : int , the benchmark array   Returns: bool, true only if the state is active start(benchmark) Start recording a benchmark from this point   Parameters:      benchmark : int , the benchmark array   Returns: bool, true only if the benchmark is unfinished loop(benchmark) Returns true until call count exceeds bench.new(loop) variable   Parameters:      benchmark : int , the benchmark array   Returns: bool, true while looping reference(number, string) Add a compiler reference to the chart so the calculations don't get optimised away   Parameters:      number : float, a numeric value to reference      string : string, a string value to reference mark(benchmark, number, string) Marks the end of one recorded interval and the start of the next   Parameters:      benchmark : int , the benchmark array      number : float, a numeric value to reference      string : string, a string value to reference stop(benchmark, number, string) Stop the benchmark, ending the final interval   Parameters:      benchmark : int , the benchmark array      number : float, a numeric value to reference      string : string, a string value to reference report(Prints, benchmark, title, text_size, position)   Parameters:      Prints : the benchmarks results to the screen      benchmark : int , the benchmark array      title : string, add a custom title to the report      text_size : string, the text size of the log console (global size vars)      position : string, the position of the log console (global position vars) unittest_bench(case) Cache module unit tests, for inclusion in parent script test suite. Usage: bench.unittest_bench(__ASSERTS)   Parameters:      case : string , the current test case and array of previous unit tests (__ASSERTS) unittest(verbose) Run the bench module unit tests as a stand alone. Usage: bench.unittest()   Parameters:      verbose : bool, optionally disable the full report to only display failures
Biblioteca Pine Script™
por GeoffHammond
13