Inizia

Utility

real_time_candlesIntroduction The Real-Time Candles Library provides comprehensive tools for creating, manipulating, and visualizing custom timeframe candles in Pine Script. Unlike standard indicators that only update at bar close, this library enables real-time visualization of price action and indicators within the current bar, offering traders unprecedented insight into market dynamics as they unfold. This library addresses a fundamental limitation in traditional technical analysis: the inability to see how indicators evolve between bar closes. By implementing sophisticated real-time data processing techniques, traders can now observe indicator movements, divergences, and trend changes as they develop, potentially identifying trading opportunities much earlier than with conventional approaches. Key Features The library supports two primary candle generation approaches: Chart-Time Candles: Generate real-time OHLC data for any variable (like RSI, MACD, etc.) while maintaining synchronization with chart bars. Custom Timeframe (CTF) Candles: Create candles with custom time intervals or tick counts completely independent of the chart's native timeframe. Both approaches support traditional candlestick and Heikin-Ashi visualization styles, with options for moving average overlays to smooth the data. Configuration Requirements For optimal performance with this library: Set max_bars_back = 5000 in your script settings When using CTF drawing functions, set max_lines_count = 500, max_boxes_count = 500, and max_labels_count = 500 These settings ensure that you will be able to draw correctly and will avoid any runtime errors. Usage Examples Basic Chart-Time Candle Visualization // Create real-time candles for RSI float rsi = ta.rsi(close, 14) Candle rsi_candle = candle_series(rsi, CandleType.candlestick) // Plot the candles using Pine's built-in function plotcandle(rsi_candle.Open, rsi_candle.High, rsi_candle.Low, rsi_candle.Close, "RSI Candles", rsi_candle.candle_color, rsi_candle.candle_color) Multiple Access Patterns The library provides three ways to access candle data, accommodating different programming styles: // 1. Array-based access for collection operations Candle candles = candle_array(source) // 2. Object-oriented access for single entity manipulation Candle candle = candle_series(source) float value = candle.source(Source.HLC3) // 3. Tuple-based access for functional programming styles = candle_tuple(source) Custom Timeframe Examples // Create 20-second candles with EMA overlay plot_ctf_candles( source = close, candle_type = CandleType.candlestick, sample_type = SampleType.Time, number_of_seconds = 20, timezone = -5, tied_open = true, ema_period = 9, enable_ema = true ) // Create tick-based candles (new candle every 15 ticks) plot_ctf_tick_candles( source = close, candle_type = CandleType.heikin_ashi, number_of_ticks = 15, timezone = -5, tied_open = true ) Advanced Usage with Custom Visualization // Get custom timeframe candles without automatic plotting CandleCTF my_candles = ctf_candles_array( source = close, candle_type = CandleType.candlestick, sample_type = SampleType.Time, number_of_seconds = 30 ) // Apply custom logic to the candles float ema_values = my_candles.ctf_ema(14) // Draw candles and EMA using time-based coordinates my_candles.draw_ctf_candles_time() ema_values.draw_ctf_line_time(line_color = #FF6D00) Library Components Data Types Candle: Structure representing chart-time candles with OHLC, polarity, and visualization properties CandleCTF: Extended candle structure with additional time metadata for custom timeframes TickData: Structure for individual price updates with time deltas Enumerations CandleType: Specifies visualization style (candlestick or Heikin-Ashi) Source: Defines price components for calculations (Open, High, Low, Close, HL2, etc.) SampleType: Sets sampling method (Time-based or Tick-based) Core Functions get_tick(): Captures current price as a tick data point candle_array(): Creates an array of candles from price updates candle_series(): Provides a single candle based on latest data candle_tuple(): Returns OHLC values as a tuple ctf_candles_array(): Creates custom timeframe candles without rendering Visualization Functions source(): Extracts specific price components from candles candle_ctf_to_float(): Converts candle data to float arrays ctf_ema(): Calculates exponential moving averages for candle arrays draw_ctf_candles_time(): Renders candles using time coordinates draw_ctf_candles_index(): Renders candles using bar index coordinates draw_ctf_line_time(): Renders lines using time coordinates draw_ctf_line_index(): Renders lines using bar index coordinates Technical Implementation Notes This library leverages Pine Script's varip variables for state management, creating a sophisticated real-time data processing system. The implementation includes: Efficient tick capturing: Samples price at every execution, maintaining temporal tracking with time deltas Smart state management: Uses a hybrid approach with mutable updates at index 0 and historical preservation at index 1+ Temporal synchronization: Manages two time domains (chart time and custom timeframe) The tooltip implementation provides crucial temporal context for custom timeframe visualizations, allowing users to understand exactly when each candle formed regardless of chart timeframe. Limitations Custom timeframe candles cannot be backtested due to Pine Script's limitations with historical tick data Real-time visualization is only available during live chart updates Maximum history is constrained by Pine Script's array size limits Applications Indicator visualization: See how RSI, MACD, or other indicators evolve in real-time Volume analysis: Create custom volume profiles independent of chart timeframe Scalping strategies: Identify short-term patterns with precisely defined time windows Volatility measurement: Track price movement characteristics within bars Custom signal generation: Create entry/exit signals based on custom timeframe patterns Conclusion The Real-Time Candles Library bridges the gap between traditional technical analysis (based on discrete OHLC bars) and the continuous nature of market movement. By making indicators more responsive to real-time price action, it gives traders a significant edge in timing and decision-making, particularly in fast-moving markets where waiting for bar close could mean missing important opportunities. Whether you're building custom indicators, researching price patterns, or developing trading strategies, this library provides the foundation for sophisticated real-time analysis in Pine Script. Implementation Details & Advanced Guide Core Implementation Concepts The Real-Time Candles Library implements a sophisticated event-driven architecture within Pine Script's constraints. At its heart, the library creates what's essentially a reactive programming framework handling continuous data streams. Tick Processing System The foundation of the library is the get_tick() function, which captures price updates as they occur: export get_tick(series float source = close, series float na_replace = na)=> varip float price = na varip int series_index = -1 varip int old_time = 0 varip int new_time = na varip float time_delta = 0 // ... This function: Samples the current price Calculates time elapsed since last update Maintains a sequential index to track updates The resulting TickData structure serves as the fundamental building block for all candle generation. State Management Architecture The library employs a sophisticated state management system using varip variables, which persist across executions within the same bar. This creates a hybrid programming paradigm that's different from standard Pine Script's bar-by-bar model. For chart-time candles, the core state transition logic is: // Real-time update of current candle candle_data := Candle.new(Open, High, Low, Close, polarity, series_index, candle_color) candles.set(0, candle_data) // When a new bar starts, preserve the previous candle if clear_state candles.insert(1, candle_data) price.clear() // Reset state for new candle Open := Close price.push(Open) series_index += 1 This pattern of updating index 0 in real-time while inserting completed candles at index 1 creates an elegant solution for maintaining both current state and historical data. Custom Timeframe Implementation The custom timeframe system manages its own time boundaries independent of chart bars: bool clear_state = switch settings.sample_type SampleType.Ticks => cumulative_series_idx >= settings.number_of_ticks SampleType.Time => cumulative_time_delta >= settings.number_of_seconds This dual-clock system synchronizes two time domains: Pine's execution clock (bar-by-bar processing) The custom timeframe clock (tick or time-based) The library carefully handles temporal discontinuities, ensuring candle formation remains accurate despite irregular tick arrival or market gaps. Advanced Usage Techniques 1. Creating Custom Indicators with Real-Time Candles To develop indicators that process real-time data within the current bar: // Get real-time candles for your data Candle rsi_candles = candle_array(ta.rsi(close, 14)) // Calculate indicator values based on candle properties float signal = ta.ema(rsi_candles.first().source(Source.Close), 9) // Detect patterns that occur within the bar bool divergence = close > close and rsi_candles.first().Close < rsi_candles.get(1).Close 2. Working with Custom Timeframes and Plotting For maximum flexibility when visualizing custom timeframe data: // Create custom timeframe candles CandleCTF volume_candles = ctf_candles_array( source = volume, candle_type = CandleType.candlestick, sample_type = SampleType.Time, number_of_seconds = 60 ) // Convert specific candle properties to float arrays float volume_closes = volume_candles.candle_ctf_to_float(Source.Close) // Calculate derived values float volume_ema = volume_candles.ctf_ema(14) // Create custom visualization volume_candles.draw_ctf_candles_time() volume_ema.draw_ctf_line_time(line_color = color.orange) 3. Creating Hybrid Timeframe Analysis One powerful application is comparing indicators across multiple timeframes: // Standard chart timeframe RSI float chart_rsi = ta.rsi(close, 14) // Custom 5-second timeframe RSI CandleCTF ctf_candles = ctf_candles_array( source = close, candle_type = CandleType.candlestick, sample_type = SampleType.Time, number_of_seconds = 5 ) float fast_rsi_array = ctf_candles.candle_ctf_to_float(Source.Close) float fast_rsi = fast_rsi_array.first() // Generate signals based on divergence between timeframes bool entry_signal = chart_rsi < 30 and fast_rsi > fast_rsi_array.get(1) Final Notes This library represents an advanced implementation of real-time data processing within Pine Script's constraints. By creating a reactive programming framework for handling continuous data streams, it enables sophisticated analysis typically only available in dedicated trading platforms. The design principles employed—including state management, temporal processing, and object-oriented architecture—can serve as patterns for other advanced Pine Script development beyond this specific application. ------------------------ Library "real_time_candles" A comprehensive library for creating real-time candles with customizable timeframes and sampling methods. Supports both chart-time and custom-time candles with options for candlestick and Heikin-Ashi visualization. Allows for tick-based or time-based sampling with moving average overlay capabilities. get_tick(source, na_replace)   Captures the current price as a tick data point   Parameters:      source (float) : Optional - Price source to sample (defaults to close)      na_replace (float) : Optional - Value to use when source is na   Returns: TickData structure containing price, time since last update, and sequential index candle_array(source, candle_type, sync_start, bullish_color, bearish_color)   Creates an array of candles based on price updates   Parameters:      source (float) : Optional - Price source to sample (defaults to close)      candle_type (simple CandleType) : Optional - Type of candle chart to create (candlestick or Heikin-Ashi)      sync_start (simple bool) : Optional - Whether to synchronize with the start of a new bar      bullish_color (color) : Optional - Color for bullish candles      bearish_color (color) : Optional - Color for bearish candles   Returns: Array of Candle objects ordered with most recent at index 0 candle_series(source, candle_type, wait_for_sync, bullish_color, bearish_color)   Provides a single candle based on the latest price data   Parameters:      source (float) : Optional - Price source to sample (defaults to close)      candle_type (simple CandleType) : Optional - Type of candle chart to create (candlestick or Heikin-Ashi)      wait_for_sync (simple bool) : Optional - Whether to wait for a new bar before starting      bullish_color (color) : Optional - Color for bullish candles      bearish_color (color) : Optional - Color for bearish candles   Returns: A single Candle object representing the current state candle_tuple(source, candle_type, wait_for_sync, bullish_color, bearish_color)   Provides candle data as a tuple of OHLC values   Parameters:      source (float) : Optional - Price source to sample (defaults to close)      candle_type (simple CandleType) : Optional - Type of candle chart to create (candlestick or Heikin-Ashi)      wait_for_sync (simple bool) : Optional - Whether to wait for a new bar before starting      bullish_color (color) : Optional - Color for bullish candles      bearish_color (color) : Optional - Color for bearish candles   Returns: Tuple representing current candle values method source(self, source, na_replace)   Extracts a specific price component from a Candle   Namespace types: Candle   Parameters:      self (Candle)      source (series Source) : Type of price data to extract (Open, High, Low, Close, or composite values)      na_replace (float) : Optional - Value to use when source value is na   Returns: The requested price value from the candle method source(self, source)   Extracts a specific price component from a CandleCTF   Namespace types: CandleCTF   Parameters:      self (CandleCTF)      source (simple Source) : Type of price data to extract (Open, High, Low, Close, or composite values)   Returns: The requested price value from the candle as a varip method candle_ctf_to_float(self, source)   Converts a specific price component from each CandleCTF to a float array   Namespace types: array   Parameters:      self (array)      source (simple Source) : Optional - Type of price data to extract (defaults to Close)   Returns: Array of float values extracted from the candles, ordered with most recent at index 0 method ctf_ema(self, ema_period)   Calculates an Exponential Moving Average for a CandleCTF array   Namespace types: array   Parameters:      self (array)      ema_period (simple float) : Period for the EMA calculation   Returns: Array of float values representing the EMA of the candle data, ordered with most recent at index 0 method draw_ctf_candles_time(self, sample_type, number_of_ticks, number_of_seconds, timezone)   Renders custom timeframe candles using bar time coordinates   Namespace types: array   Parameters:      self (array)      sample_type (simple SampleType) : Optional - Method for sampling data (Time or Ticks), used for tooltips      number_of_ticks (simple int) : Optional - Number of ticks per candle (used when sample_type is Ticks), used for tooltips      number_of_seconds (simple float) : Optional - Time duration per candle in seconds (used when sample_type is Time), used for tooltips      timezone (simple int) : Optional - Timezone offset from UTC (-12 to +12), used for tooltips   Returns: void - Renders candles on the chart using time-based x-coordinates method draw_ctf_candles_index(self, sample_type, number_of_ticks, number_of_seconds, timezone)   Renders custom timeframe candles using bar index coordinates   Namespace types: array   Parameters:      self (array)      sample_type (simple SampleType) : Optional - Method for sampling data (Time or Ticks), used for tooltips      number_of_ticks (simple int) : Optional - Number of ticks per candle (used when sample_type is Ticks), used for tooltips      number_of_seconds (simple float) : Optional - Time duration per candle in seconds (used when sample_type is Time), used for tooltips      timezone (simple int) : Optional - Timezone offset from UTC (-12 to +12), used for tooltips   Returns: void - Renders candles on the chart using index-based x-coordinates method draw_ctf_line_time(self, source, line_size, line_color)   Renders a line representing a price component from the candles using time coordinates   Namespace types: array   Parameters:      self (array)      source (simple Source) : Optional - Type of price data to extract (defaults to Close)      line_size (simple int) : Optional - Width of the line      line_color (simple color) : Optional - Color of the line   Returns: void - Renders a connected line on the chart using time-based x-coordinates method draw_ctf_line_time(self, line_size, line_color)   Renders a line from a varip float array using time coordinates   Namespace types: array   Parameters:      self (array)      line_size (simple int) : Optional - Width of the line, defaults to 2      line_color (simple color) : Optional - Color of the line   Returns: void - Renders a connected line on the chart using time-based x-coordinates method draw_ctf_line_index(self, source, line_size, line_color)   Renders a line representing a price component from the candles using index coordinates   Namespace types: array   Parameters:      self (array)      source (simple Source) : Optional - Type of price data to extract (defaults to Close)      line_size (simple int) : Optional - Width of the line      line_color (simple color) : Optional - Color of the line   Returns: void - Renders a connected line on the chart using index-based x-coordinates method draw_ctf_line_index(self, line_size, line_color)   Renders a line from a varip float array using index coordinates   Namespace types: array   Parameters:      self (array)      line_size (simple int) : Optional - Width of the line, defaults to 2      line_color (simple color) : Optional - Color of the line   Returns: void - Renders a connected line on the chart using index-based x-coordinates plot_ctf_tick_candles(source, candle_type, number_of_ticks, timezone, tied_open, ema_period, bullish_color, bearish_color, line_width, ema_color, use_time_indexing)   Plots tick-based candles with moving average   Parameters:      source (float) : Input price source to sample      candle_type (simple CandleType) : Type of candle chart to display      number_of_ticks (simple int) : Number of ticks per candle      timezone (simple int) : Timezone offset from UTC (-12 to +12)      tied_open (simple bool) : Whether to tie open price to close of previous candle      ema_period (simple float) : Period for the exponential moving average      bullish_color (color) : Optional - Color for bullish candles      bearish_color (color) : Optional - Color for bearish candles      line_width (simple int) : Optional - Width of the moving average line, defaults to 2      ema_color (color) : Optional - Color of the moving average line      use_time_indexing (simple bool) : Optional - When true the function will plot with xloc.time, when false it will plot using xloc.bar_index   Returns: void - Creates visual candle chart with EMA overlay plot_ctf_tick_candles(source, candle_type, number_of_ticks, timezone, tied_open, bullish_color, bearish_color, use_time_indexing)   Plots tick-based candles without moving average   Parameters:      source (float) : Input price source to sample      candle_type (simple CandleType) : Type of candle chart to display      number_of_ticks (simple int) : Number of ticks per candle      timezone (simple int) : Timezone offset from UTC (-12 to +12)      tied_open (simple bool) : Whether to tie open price to close of previous candle      bullish_color (color) : Optional - Color for bullish candles      bearish_color (color) : Optional - Color for bearish candles      use_time_indexing (simple bool) : Optional - When true the function will plot with xloc.time, when false it will plot using xloc.bar_index   Returns: void - Creates visual candle chart without moving average plot_ctf_time_candles(source, candle_type, number_of_seconds, timezone, tied_open, ema_period, bullish_color, bearish_color, line_width, ema_color, use_time_indexing)   Plots time-based candles with moving average   Parameters:      source (float) : Input price source to sample      candle_type (simple CandleType) : Type of candle chart to display      number_of_seconds (simple float) : Time duration per candle in seconds      timezone (simple int) : Timezone offset from UTC (-12 to +12)      tied_open (simple bool) : Whether to tie open price to close of previous candle      ema_period (simple float) : Period for the exponential moving average      bullish_color (color) : Optional - Color for bullish candles      bearish_color (color) : Optional - Color for bearish candles      line_width (simple int) : Optional - Width of the moving average line, defaults to 2      ema_color (color) : Optional - Color of the moving average line      use_time_indexing (simple bool) : Optional - When true the function will plot with xloc.time, when false it will plot using xloc.bar_index   Returns: void - Creates visual candle chart with EMA overlay plot_ctf_time_candles(source, candle_type, number_of_seconds, timezone, tied_open, bullish_color, bearish_color, use_time_indexing)   Plots time-based candles without moving average   Parameters:      source (float) : Input price source to sample      candle_type (simple CandleType) : Type of candle chart to display      number_of_seconds (simple float) : Time duration per candle in seconds      timezone (simple int) : Timezone offset from UTC (-12 to +12)      tied_open (simple bool) : Whether to tie open price to close of previous candle      bullish_color (color) : Optional - Color for bullish candles      bearish_color (color) : Optional - Color for bearish candles      use_time_indexing (simple bool) : Optional - When true the function will plot with xloc.time, when false it will plot using xloc.bar_index   Returns: void - Creates visual candle chart without moving average plot_ctf_candles(source, candle_type, sample_type, number_of_ticks, number_of_seconds, timezone, tied_open, ema_period, bullish_color, bearish_color, enable_ema, line_width, ema_color, use_time_indexing)   Unified function for plotting candles with comprehensive options   Parameters:      source (float) : Input price source to sample      candle_type (simple CandleType) : Optional - Type of candle chart to display      sample_type (simple SampleType) : Optional - Method for sampling data (Time or Ticks)      number_of_ticks (simple int) : Optional - Number of ticks per candle (used when sample_type is Ticks)      number_of_seconds (simple float) : Optional - Time duration per candle in seconds (used when sample_type is Time)      timezone (simple int) : Optional - Timezone offset from UTC (-12 to +12)      tied_open (simple bool) : Optional - Whether to tie open price to close of previous candle      ema_period (simple float) : Optional - Period for the exponential moving average      bullish_color (color) : Optional - Color for bullish candles      bearish_color (color) : Optional - Color for bearish candles      enable_ema (bool) : Optional - Whether to display the EMA overlay      line_width (simple int) : Optional - Width of the moving average line, defaults to 2      ema_color (color) : Optional - Color of the moving average line      use_time_indexing (simple bool) : Optional - When true the function will plot with xloc.time, when false it will plot using xloc.bar_index   Returns: void - Creates visual candle chart with optional EMA overlay ctf_candles_array(source, candle_type, sample_type, number_of_ticks, number_of_seconds, tied_open, bullish_color, bearish_color)   Creates an array of custom timeframe candles without rendering them   Parameters:      source (float) : Input price source to sample      candle_type (simple CandleType) : Type of candle chart to create (candlestick or Heikin-Ashi)      sample_type (simple SampleType) : Method for sampling data (Time or Ticks)      number_of_ticks (simple int) : Optional - Number of ticks per candle (used when sample_type is Ticks)      number_of_seconds (simple float) : Optional - Time duration per candle in seconds (used when sample_type is Time)      tied_open (simple bool) : Optional - Whether to tie open price to close of previous candle      bullish_color (color) : Optional - Color for bullish candles      bearish_color (color) : Optional - Color for bearish candles   Returns: Array of CandleCTF objects ordered with most recent at index 0 Candle   Structure representing a complete candle with price data and display properties   Fields:      Open (series float) : Opening price of the candle      High (series float) : Highest price of the candle      Low (series float) : Lowest price of the candle      Close (series float) : Closing price of the candle      polarity (series bool) : Boolean indicating if candle is bullish (true) or bearish (false)      series_index (series int) : Sequential index identifying the candle in the series      candle_color (series color) : Color to use when rendering the candle      ready (series bool) : Boolean indicating if candle data is valid and ready for use TickData   Structure for storing individual price updates   Fields:      price (series float) : The price value at this tick      time_delta (series float) : Time elapsed since the previous tick in milliseconds      series_index (series int) : Sequential index identifying this tick CandleCTF   Structure representing a custom timeframe candle with additional time metadata   Fields:      Open (series float) : Opening price of the candle      High (series float) : Highest price of the candle      Low (series float) : Lowest price of the candle      Close (series float) : Closing price of the candle      polarity (series bool) : Boolean indicating if candle is bullish (true) or bearish (false)      series_index (series int) : Sequential index identifying the candle in the series      open_time (series int) : Timestamp marking when the candle was opened (in Unix time)      time_delta (series float) : Duration of the candle in milliseconds      candle_color (series color) : Color to use when rendering the candle
Libreria Pine Script™
di The_Peaceful_Lizard
19
iteratorThe "Iterator" library is designed to provide a flexible way to work with sequences of values. This library offers a set of functions to create and manage iterators for various data types, including integers, floats, and more. Whether you need to generate an array of values with specific increments or iterate over elements in reverse order, this library has you covered. Key Features: Array Creation: Easily generate arrays of integers or floats with customizable steps, both inclusive and exclusive of the end values. Flexible Iteration: Includes methods to iterate over arrays of different types, such as booleans, integers, floats, strings, colors, and drawing objects like lines and labels. Reverse Iteration: Support for reverse iteration, giving you control over the order in which elements are processed. Automatic Loop Control: One of the key advantages of this library is that when using the .iterate() method, it only loops over the array when there are values present. This means you don’t have to manually check if the array is populated before iterating, simplifying your code and reducing potential errors. Versatile Use Cases: Ideal for scenarios where you need to loop over an array without worrying about empty arrays or checking conditions manually. This library is particularly useful in cases where you need to perform operations on each element in an array, ensuring that your loops are efficient and free from unnecessary checks. Library "iterator" The "iterator" library provides a versatile and efficient set of functions for creating and managing iterators. It allows you to generate arrays of integers or floats with customizable steps, both inclusive and exclusive of the end values. The library also includes methods for iterating over various types, including booleans, integers, floats, strings, colors, and drawing objects like lines and labels. With support for reverse iteration and flexible customization options. iterator(stop, start, step)   Creates an array of integers from start to stop with a specified step, excluding the stop value.   Parameters:      stop (int) : The end value of the iterator, exclusive.      start (int) : The starting value of the iterator. Default is 0.      step (int) : The increment value for each step in the iterator. Default is 1. Must be greater than 0.   Returns: An array of integers incremented by the step value from start to stop. Will return and empty array if start = stop. iterator(stop, start, step)   Creates an array of floats from start to stop with a specified step, excluding the stop value.   Parameters:      stop (float) : The end value of the iterator, exclusive.      start (float) : The starting value of the iterator. Default is 0.      step (float) : The increment value for each step in the iterator. Default is 1. Must be greater than 0.   Returns: An array of floats incremented by the step value from start to stop. Will return and empty array if start = stop. iterator_inclusive(stop, start, step)   Creates an array of integers from start to stop with a specified step, including the stop value.   Parameters:      stop (int) : The end value of the iterator, inclusive.      start (int) : The starting value of the iterator. Default is 0.      step (int) : The increment value for each step in the iterator. Default is 1. Must be greater than 0.   Returns: An array of integers incremented by the step value from start to stop, including the stop value. iterator_inclusive(stop, start, step)   Creates an array of floats from start to stop with a specified step, including the stop value.   Parameters:      stop (float) : The end value of the iterator, inclusive.      start (float) : The starting value of the iterator. Default is 0.      step (float) : The increment value for each step in the iterator. Default is 1. Must be greater than 0.   Returns: An array of floats incremented by the step value from start to stop, including the stop value. itr(stop, start, step)   Creates an array of integers from start to stop with a specified step, excluding the stop value.   Parameters:      stop (int) : The end value of the iterator, exclusive.      start (int) : The starting value of the iterator. Default is 0.      step (int) : The increment value for each step in the iterator. Default is 1. Must be greater than 0.   Returns: An array of integers incremented by the step value from start to stop. itr(stop, start, step)   Creates an array of floats from start to stop with a specified step, excluding the stop value.   Parameters:      stop (float) : The end value of the iterator, exclusive.      start (float) : The starting value of the iterator. Default is 0.      step (float) : The increment value for each step in the iterator. Default is 1. Must be greater than 0.   Returns: An array of floats incremented by the step value from start to stop. itr_in(stop, start, step)   Creates an array of integers from start to stop with a specified step, including the stop value.   Parameters:      stop (int) : The end value of the iterator, inclusive.      start (int) : The starting value of the iterator. Default is 0.      step (int) : The increment value for each step in the iterator. Default is 1. Must be greater than 0.   Returns: An array of integers incremented by the step value from start to stop, including the stop value. itr_in(stop, start, step)   Creates an array of floats from start to stop with a specified step, including the stop value.   Parameters:      stop (float) : The end value of the iterator, inclusive.      start (float) : The starting value of the iterator. Default is 0.      step (float) : The increment value for each step in the iterator. Default is 1. Must be greater than 0.   Returns: An array of floats incremented by the step value from start to stop, including the stop value. method iterate(self, reverse)   Creates an iterator array for the indices of ana array, with an option to reverse the order.   Namespace types: array   Parameters:      self (array) : The array to iterate over.      reverse (bool) : A boolean flag indicating whether to reverse the iterator order. Default is false.   Returns: An array of integers representing the indices of the array. The order can be reversed if specified. method iterate(self, reverse)   Creates an iterator array for the indices of ana array, with an option to reverse the order.   Namespace types: array   Parameters:      self (array) : The array to iterate over.      reverse (bool) : A boolean flag indicating whether to reverse the iterator order. Default is false.   Returns: An array of integers representing the indices of the array. The order can be reversed if specified. method iterate(self, reverse)   Creates an iterator array for the indices of ana array, with an option to reverse the order.   Namespace types: array   Parameters:      self (array) : The array to iterate over.      reverse (bool) : A boolean flag indicating whether to reverse the iterator order. Default is false.   Returns: An array of integers representing the indices of the array. The order can be reversed if specified. method iterate(self, reverse)   Creates an iterator array for the indices of ana array, with an option to reverse the order.   Namespace types: array   Parameters:      self (array) : The array to iterate over.      reverse (bool) : A boolean flag indicating whether to reverse the iterator order. Default is false.   Returns: An array of integers representing the indices of the array. The order can be reversed if specified. method iterate(self, reverse)   Creates an iterator array for the indices of ana array, with an option to reverse the order.   Namespace types: array   Parameters:      self (array) : The array to iterate over.      reverse (bool) : A boolean flag indicating whether to reverse the iterator order. Default is false.   Returns: An array of integers representing the indices of the array. The order can be reversed if specified. method iterate(self, reverse)   Creates an iterator array for the indices of ana array, with an option to reverse the order.   Namespace types: array   Parameters:      self (array) : The array to iterate over.      reverse (bool) : A boolean flag indicating whether to reverse the iterator order. Default is false.   Returns: An array of integers representing the indices of the array. The order can be reversed if specified. method iterate(self, reverse)   Creates an iterator array for the indices of ana array, with an option to reverse the order.   Namespace types: array   Parameters:      self (array) : The array to iterate over.      reverse (bool) : A boolean flag indicating whether to reverse the iterator order. Default is false.   Returns: An array of integers representing the indices of the array. The order can be reversed if specified. method iterate(self, reverse)   Creates an iterator array for the indices of ana array, with an option to reverse the order.   Namespace types: array   Parameters:      self (array) : The array to iterate over.      reverse (bool) : A boolean flag indicating whether to reverse the iterator order. Default is false.   Returns: An array of integers representing the indices of the array. The order can be reversed if specified. method iterate(self, reverse)   Creates an iterator array for the indices of ana array, with an option to reverse the order.   Namespace types: array   Parameters:      self (array) : The array to iterate over.      reverse (bool) : A boolean flag indicating whether to reverse the iterator order. Default is false.   Returns: An array of integers representing the indices of the array. The order can be reversed if specified. method iterate(self, reverse)   Creates an iterator array for the indices of ana array, with an option to reverse the order.   Namespace types: array   Parameters:      self (array) : The array to iterate over.      reverse (bool) : A boolean flag indicating whether to reverse the iterator order. Default is false.   Returns: An array of integers representing the indices of the array. The order can be reversed if specified. method iterate(self, reverse)   Creates an iterator array for the indices of ana array, with an option to reverse the order.   Namespace types: array   Parameters:      self (array) : The array to iterate over.      reverse (bool) : A boolean flag indicating whether to reverse the iterator order. Default is false.   Returns: An array of integers representing the indices of the array. The order can be reversed if specified. method iterate(self, reverse)   Creates an iterator array for the indices of ana array, with an option to reverse the order.   Namespace types: array   Parameters:      self (array) : The array to iterate over.      reverse (bool) : A boolean flag indicating whether to reverse the iterator order. Default is false.   Returns: An array of integers representing the indices of the array. The order can be reversed if specified.
Libreria Pine Script™
di The_Peaceful_Lizard
2
Swing DistanceHello fellas, This simple indicator helps to visualize the distance between swings. It consists of two lines, the highest and the lowest line, which show the highest and lowest value of the set lookback, respectively. Additionally, it plots labels with the distance (in %) between the highest and the lowest line when there is a change in either the highest or the lowest value. Use Case: This tool helps you get a feel for which trades you might want to take and which timeframe you might want to use. Side Note: This indicator is not intended to be used as a signal emitter or filter! Best regards, simwai
Indicatore Pine Script™
di simwai
ColourUtilitiesLibrary "ColourUtilities" Utility functions for colour manipulation adjust_colour(rgb, desaturation_amount, transparency_amount)   to reduce saturation or increase transparency of an RGB colour   Parameters:      rgb (color)      desaturation_amount (float) : 0 means no desaturation (colours remains as-is), and 1 means full desaturation (colour turns grey). Can also be used inversely with negative numbers      transparency_amount (float) : How much more transparent the default transparency should become. E.g. with a value of 0.5, a transparency of 0 becomes 50 and 40 becomes 70. A value of 1 makes it fully transparent, en -1 fully opaque.   Returns: color with adjusted saturation and transparency method apply_default_palette(self, palette_name)   Some nice looking colour palettes, consisting of 6 gradient colours, are already defined here and can be quickly applied to the Palette class   Namespace types: Palette   Parameters:      self (Palette)      palette_name (string) : Currently there are 4 6-coloured palettes available: "GYTS flux signal", "GYTS purple", "GYTS flux filter" and "GYTS maroon"   Returns: None, as it populates the Palette class with pre-defined colours method get_colour(self, colour_no, transparency)   Retrieves colour from the palette and possibly changes transparency if set   Namespace types: Palette   Parameters:      self (Palette)      colour_no (int) : from the palette      transparency (int) : to possibly change the default transparency of the palette   Returns: colour method get_dynamic_colour(self, x, mid_point, colour_lb, colour_ub, trend_lookback, use_rate)   Retrieves a colour based on strength and direction of the passed series   Namespace types: Palette   Parameters:      self (Palette)      x (float) : the input data series      mid_point (float) : value as a cutoff point where the bullish/bearish colour scenario      colour_lb (float) : value (lower bound) where to apply the bearish colour at full strength      colour_ub (float) : value (upper bound) where to apply the bullish colour at full strength      trend_lookback (int) : how much bars back to check if there was a consistent move into a certain direction, otherwise a the neutral colour from the centre of the palette will be used.      use_rate (bool) : whether to use the rate (proportional difference with previous `x` value) or the input series `x` directly   Returns: colour Palette   Fields:      transparency (series__integer)      palette (array__color)
Libreria Pine Script™
di GoemonYae
Multi-Chart Widget [LuxAlgo]The Multi-Chart Widget tool is a comprehensive solution crafted for traders and investors looking to analyze multiple financial instruments simultaneously. With the capability to showcase up to three additional charts, users can customize each chart by selecting different financial instruments, and timeframes. Users can add various widely used technical indicators to the charts such as the relative strength index, Supertrend, moving averages, Bollinger Bands...etc. 🔶 USAGE The tool offers traders and investors a comprehensive view of multiple charts simultaneously. By displaying up to three additional charts alongside the primary chart, users can analyze assets across different timeframes, compare their performance, and make informed decisions. Users have the flexibility to choose from various customizable chart types, including the recently added "Volume Candles" option. This tool allows adding to the chart some of the most widely used technical indicators, such as the Supertrend, Bollinger Bands, and various moving averages. In addition to the charting capabilities, the tool also features a dynamic statistic panel that provides essential metrics and key insights into the selected assets. Users can track performance indicators such as relative strength, trend, and volatility, enabling them to identify trends, patterns, and trading opportunities efficiently. 🔶 DETAILS A brief overview of the indicators featured in the statistic panel is given in the sub-section below: 🔹Dual Supertrend The Dual Supertrend is a modified version of the Supertrend indicator, which is based on the concept of trend following. It generates buy or sell signals by analyzing the asset's price movement. The Dual Supertrend incorporates two Supertrend indicators with different parameters to provide potentially more accurate signals. It helps traders identify trend reversals and establish trend direction in a more responsive manner compared to a single Supertrend. 🔹Relative Strength Index The Relative Strength Index is a momentum oscillator that measures the speed and change of price movements. RSI oscillates between 0 and 100 and is typically used to identify overbought or oversold conditions in a market. Traditionally, RSI values above 70 are considered overbought, suggesting that the asset may be due for a reversal or correction, while RSI values below 30 are considered oversold, indicating potential buying opportunities. 🔹Volatility Volatility in trading refers to the degree of variation or fluctuation in the price of a financial instrument, such as a stock, currency pair, or commodity, over a certain period of time. It is a measure of the speed and magnitude of price changes and reflects the level of uncertainty or risk in the market. High volatility implies that prices are experiencing rapid and significant movements, while low volatility suggests that prices are relatively stable and are not changing much. Traders often use volatility as an indicator to assess the potential risk and return of an investment and to make informed decisions about when to enter or exit trades. 🔹R-Squared (R²) R-squared, also known as the coefficient of determination, is a statistical measure that indicates the proportion of the variance in the dependent variable that is predictable from the independent variable(s). In other words, it quantifies the goodness of fit of a regression model to the observed data. R-squared values range from %0 to %100, with higher values indicating a better fit of the model to the data. An R-squared of 100% means that all movements of a security are completely explained by movements in the index, while an R-squared value of %0 indicates that the model does not explain any of the variability in the dependent variable. In simpler terms, in investing, a high R-squared, from 85% to 100%, indicates that the stock’s or fund’s performance moves relatively in line with the index. Conversely, a low R-squared (around 70% or less) indicates that the fund's performance tends to deviate significantly from the movements of the index. 🔶 SETTINGS 🔹Mini Chart(s) Generic Settings Mini Charts Separator: This option toggles the visibility of the separator lines. Number Of Bars: Specifies the number of bars to be displayed for each mini chart. Horizontal Offset: Determines the distance at which the mini charts will be displayed from the primary chart. 🔹Mini Chart Settings: Top - Middle - Bottom Mini Chart Top/Middle/Bottom: Toggle the visibility of the selected mini chart. Symbol: Choose the financial instrument to be displayed in the mini chart. If left as an empty string, it will default to the current chart instrument. Timeframe: This option determines the timeframe used for calculating the mini charts. If a timeframe lower than the chart's timeframe is selected, the calculations will be based on the chart's timeframe. Chart Type: Selection from various chart types for the mini charts, including candles, volume candles, line, area, columns, high-low, and Heikin Ashi. Chart Size: Determines the size of the mini chart. Technical Indicator: Selection from various technical indicators to be displayed on top of the mini charts. Note : Chart sizing is relative to other mini charts. For example, If all the mini charts are sized to x5 relative to each other, the result will be the same as if they were all sized as x1. This is because the relative proportions between the mini charts remain consistent regardless of their absolute sizes. Therefore, their positions and sizes relative to each other remain unchanged, resulting in the same visual representation despite the differences in absolute scale. 🔹Supertrend Settings ATR Length: is the lookback length for the ATR calculation. Factor: is what the ATR is multiplied by to offset the bands from price. Color: color customization option. 🔹Moving Average Settings Type: is the type of the moving average, available types of moving averages include SMA (Simple Moving Average), EMA (Exponential Moving Average), RMA (Root Mean Square Moving Average), HMA (Hull Moving Average), WMA (Weighted Moving Average), and VWMA (Volume Weighted Moving Average). Source: Determines what data from each bar will be used in calculations. Length: The time period to be used in calculating the Moving Average. Color: Color customization option. 🔹Bollinger Bands Settings Basis Type: Determines the type of Moving Average that is applied to the basis plot line. Source: Determines what data from each bar will be used in calculations. Length: The time period to be used in calculating the Moving Average which creates the base for the Upper and Lower Bands. StdDev: The number of Standard Deviations away from the Moving Average that the Upper and Lower Bands should be. Color: Color customization options for basis, upper and lower bands. 🔹Mini Chart(s) Panel Settings Mini Chart(s) Panel: Controls the visibility of the panel containing the mini charts. Dual Supertrend: Toggles the display of the evaluated dual super trend, based on the super trend settings provided below the option. The definitions for the options are the same as stated above for the super trend. Relative Strength Index: Toggles the display of the evaluated RSI, based on the source and length settings provided below the option. Volatility: Toggles the display of the calculated Volatility, based on the length settings provided below the option. R-Squared: Toggles the display of the calculated R-Squared (R²), based on the length settings provided below the option. 🔶 LIMITATIONS The tool allows users to display mini charts featuring various types of instruments alongside the primary chart instrument. However, there's a limitation: the selected primary chart instrument must have an ACTIVE market status. Alternatively, if the primary chart instrument is not active, the mini chart instruments must belong to the same exchange and have the same type as the primary chart instrument.
Indicatore Pine Script™
di LuxAlgo
22
[TTI] Closing Range Indicator📜 ––––HISTORY & CREDITS–––– This Pine Script Utility indicator, titled " Closing Range Indicator," is designed and developed by TintinTrading but inspired by the teaching of Investor's Business Daily (IBD) and William O'Neil. It aims to help traders identify the closing range of a given timeframe, either daily or weekly. 🦄 –––UNIQUENESS––– The unique feature of this indicator lies in its ability to simulate a functionality of Closing Range calculation based on hovering of the mouse over the close. It employs a conditional display that allows the user to set the indicator as 'invisible' without removing it from the chart and hence provides a numerical closing range value when hovering over the indicator. 🛠️ ––––WHAT IT DOES–––– The Closing Range Indicator calculates the closing range of a trading bar in terms of percentages. It computes the difference between the closing price and the low price of the bar, and then divides it by the range of the bar. A stock that closes on the high would display 100% A stock that closes on the low would display 0% Generally, the higher the percentage the more bullish the close but there are exceptions to this rule. The indicator can operate on two timeframes: Daily : Computes the closing range based on the daily high, low, and closing prices. Weekly : Computes the closing range based on the weekly high, low, and closing prices. If you enable the weekly it will show the weekly close on all daily timeframes. Meaning that if the week Closing range is 54.15% on Friday, it will show the value 54.15% for all days prior to Friday from the same week. The indicator places a label at the close of each bar, with the label's tooltip showing the calculated closing range percentage. I generally hide the label and just reference the tooltip calculation with a a hoover on top of the bar. 💡 ––––HOW TO USE IT–––– Installation: Add the indicator to your TradingView chart by searching for " Closing Range Indicator" in the indicator library. Reorder: Reorder the indicator so that it sits as the first indicator (even above the price) on the Pane. This will make sure that you always trigger the tooltip functionality. Go to Settings: Timeframe: Choose between daily ('D') and weekly ('W') timeframes from the settings. Visibility: Enable the 'Make Invisible' option if you want the indicator to be hidden. Interpretation: A higher percentage indicates that the closing price is closer to the high of the range, signaling bullish sentiment. A lower percentage indicates bearish sentiment. Tooltip: Hover over the label to view the closing range in percentage terms.
Indicatore Pine Script™
di TintinTrading
1
Hide Active Candle [SteinG]Hide Active Candle An essential tool for disciplined traders seeking to avoid making hasty decisions based on active bars that have not yet closed. Have you ever found yourself eagerly anticipating an entry, only to be tempted by an active candle that starts to pull away? Or perhaps you've been caught in a trade where an active candle pushes against you, stirring unease and uncertainty. Fear not, for we have a solution! "Hide Active Candle" is a simple Pine Script indicator designed to ghost the active bar on your chart, reinforcing the importance of patiently waiting for its closure before making any trading decisions. By masking the active candle, this indicator serves as a constant reminder to exercise caution and to base your actions on solid, confirmed information. To make the most of this powerful tool, ensure that you are using a candlestick chart, as this script operates optimally within that framework. Follow these simple steps to get started: 1. Right-click on your chart and select "Settings..." 2. From the drop-down menu, choose "Symbol" under the "Chart Settings" section. 3. Disable every item in the list to fully utilize the capabilities of "Hide Active Candle." But wait, there's more! We understand that each trader has unique preferences and requirements. That's why we've included customizable settings within the script to tailor it to your specific needs. You have the option to adjust the following parameters: - Countdown seconds left : Specify the number of seconds before the bar closes when the current candle becomes visible. - Bull candle color : Select the color that represents bullish candles on your chart. - Bear candle color : Choose the color that indicates bearish candles. - Equal candle color : Define the color for Doji star candles. - Theme : Opt for a dark or light theme, as the active candle mask will be based on your chosen theme. - Custom hidden color : Personalize the mask color according to your preferences. By fine-tuning these settings, you can create a trading environment that perfectly suits your style and enhances your decision-making process.
Indicatore Pine Script™
di SteinG
3
fast_utilsLibrary "fast_utils" This library contains my favourite functions. Will be updated frequently count_int_digits()   Count int digits in number   Returns: : number of int digits in number count_float_digits()   Count float digits in number   Returns: : number of float digits in number stringify()   Convert values in array or matrix into string values   Returns: : array or matrix of string values arrcompare()   Compare values in arrays   Returns: : bool value arrdedup()   Remove duplicate values in array   Returns: : array without duplicates ResInMins()   Converts current resolution in minutes   Returns: : return float number of minuted MultOfRes(res, mult)   Convert current float TF in minutes to target string TF in "timeframe.period" format.   Parameters:      res : : current resolution in minutes      mult : : Multiple of current TF to be calculated.   Returns: : timeframe format string
Libreria Pine Script™
di f4r33x
columnsLibrary "columns" Error Tolerant Matrix Setter/Getter Operations. Easy ways to add/remove items into start and end of Columns as well as arrays to grow and shrink matrix. if mismatched sizes occur the typified NA value will be there to prevent catastrophic crashing. Rows and Columns are split into 2 libraries due to limitations on number of exports as well as ease of style (columns.shift(), rows.pop() ) pop(_matrix)   do pop last Column off of matrix   Parameters:      _matrix : Matrix To Edit   Returns: Array of Last Column, removing it from matrix shift(_matrix)   do shift the first Column off of matrix   Parameters:      _matrix : Matrix To Edit   Returns: Array of First Column, removing it from matrix get(_matrix, _clmnNum)   retrieve specific Column of matrix   Parameters:      _matrix : Matrix To Edit      _clmnNum : Column being Targeted   Returns: Array of selected Column number, leaving in place push(_matrix, _clmnNum, _item)   add single item onto end of Column   Parameters:      _matrix : Matrix To Edit      _clmnNum : Column being Targeted      _item : Item to Push on Column   Returns: shifted item from Column start push(_matrix, _array)   add single item onto end of matrix   Parameters:      _matrix : Matrix To Edit      _array : Array to Push on Matrix   Returns: Void unshift(_matrix, _clmnNum, _item)   slide single item into start of Column remove last   Parameters:      _matrix : Matrix To Edit      _clmnNum : Column being Targeted      _item : Item to Unshift on Column   Returns: popped item from Column end unshift(_matrix, _array)   add single item into first Column of matrix   Parameters:      _matrix : Matrix To Edit      _array : Array to unshift into Matrix   Returns: Void set(_matrix, _clmnNum, _array)   replace an array to an existing Column   Parameters:      _matrix : Matrix To Edit      _clmnNum : Column being Targeted      _array : Array to place in Matrix   Returns: Column that was replaced insert(_matrix, _clmnNum, _array)   insert an array to a new Column   Parameters:      _matrix : Matrix To Edit      _clmnNum : Column being Targeted      _array : Array to place in Matrix   Returns: void slideDown(_matrix, _array)   add single item onto end of Column   Parameters:      _matrix : Matrix To Edit      _array : Array to push to Matrix   Returns: shifted first Column slideUp(_matrix, _array)   add single item onto end of Column   Parameters:      _matrix : Matrix To Edit      _array : Array to unshift to Matrix   Returns: poppeed last Column pullOut(_matrix, _clmnNum)   add single item onto end of Column   Parameters:      _matrix : Matrix To Edit      _clmnNum : Column being Targeted   Returns: removed selected Column
Libreria Pine Script™
di kaigouthro
1
rowsLibrary "rows" Error Tolerant Matrix Setter/Getter Operations. Easy ways to add/remove items into start and end of rows as well as arrays to grow and shrink matrix. if mismatched sizes occur the typified NA value will be there to prevent catastrophic crashing. columns and rows are split into 2 libraries due to limitations on number of exports as well as ease of style (columns.shift(), rows.pop() ) pop(_matrix)   do pop last row off of matrix   Parameters:      _matrix : Matrix To Edit   Returns: Array of Last row, removing it from matrix shift(_matrix)   do shift the first row off of matrix   Parameters:      _matrix : Matrix To Edit   Returns: Array of First row, removing it from matrix get(_matrix, _rowNum)   retrieve specific row of matrix   Parameters:      _matrix : Matrix To Edit      _rowNum : Row being Targeted   Returns: Array of selected row number, leaving in place push(_matrix, _rowNum, _item)   add single item onto end of row   Parameters:      _matrix : Matrix To Edit      _rowNum : Row being Targeted      _item : Item to Push on Row   Returns: shifted item from row start push(_matrix, _array)   add single item onto end of matrix   Parameters:      _matrix : Matrix To Edit      _array : Array to Push on Matrix   Returns: Void unshift(_matrix, _rowNum, _item)   slide single item into start of row remove last   Parameters:      _matrix : Matrix To Edit      _rowNum : Row being Targeted      _item : Item to Unshift on Row   Returns: popped item from row end unshift(_matrix, _array)   add single item into first row of matrix   Parameters:      _matrix : Matrix To Edit      _array : Array to unshift into Matrix   Returns: Void set(_matrix, _rowNum, _array)   replace an array to an existing row   Parameters:      _matrix : Matrix To Edit      _rowNum : Row being Targeted      _array : Array to place in Matrix   Returns: row that was replaced insert(_matrix, _rowNum, _array)   insert an array to a new row   Parameters:      _matrix : Matrix To Edit      _rowNum : Row being Targeted      _array : Array to place in Matrix   Returns: void slideDown(_matrix, _array)   add single item onto end of row   Parameters:      _matrix : Matrix To Edit      _array : Array to push to Matrix   Returns: shifted first row slideUp(_matrix, _array)   add single item onto end of row   Parameters:      _matrix : Matrix To Edit      _array : Array to unshift to Matrix   Returns: popped last row pullOut(_matrix, _rowNum)   add single item onto end of row   Parameters:      _matrix : Matrix To Edit      _rowNum : Row being Targeted   Returns: removed selected row
Libreria Pine Script™
di kaigouthro
3
NNFX Exposure UtilityOVERVIEW This tool allows the user to manually keep track of how much of their account is currently exposed to each currency, and keep that information handy and organized on the chart as a table. It is specialized for NNFX traders who are trading all the pairs among the 9 major currency crosses: AUD, CAD, CHF, EUR, GBP, JPY, NZD, SGD, USD. HOW DO I USE THIS INDICATOR? Before you take a trade, you should open the indicator settings for this indicator and check off which currencies you are about to go long and short on. Here are 3 trades taken as examples: If you go long on EUR/USD with 2% risk, your exposure is 2% long on EUR and 2% short on USD. Then if you go short on GBP/SGD with 2% risk, your exposure is 2% short on GBP and 2% long on SGD. But if you go long on SGD/JPY with 2% risk, your exposure would now be 4% long on SGD and 2% short on JPY. This is against your rules if you are trading the NNFX way. So this tool allows you to see when you are about to accidentally overexpose yourself to any currency pair.
Indicatore Pine Script™
di bjr117
6
catchChecksLibrary "catchChecks" Type Check for Function Builders to allow Single item to be passed in, and determine what to do with the item, ie: need an x value? function that allows label, line, box, float, or even a string.. check item type? string ? 'str.tonumber(_item)' can be in the same switch as a 'line.get_price(_item, bar_index)' both outputting float or for pulling a value from simple, array, or matrix, one function that can switch between them. reduce overhead of many functions. there are many ways to use this tool, the simplest may be string/floats on one switch or grabbing colors from line/fill/label please Share any great recipes you come up with! typeIs(_temp, _doMeth)   Input anything..   Determine what it is.   Parameters:      _temp :   (any) Matrix, Array, or Simple Item      _doMeth : (bool) True for M/A/S , false for int/float/string.. etc..   Returns: (string) Type of item checked. ('bool' .. or 'array'.. etc..)
Libreria Pine Script™
di kaigouthro
3
calcLibrary "calc" Library for math functions. will expand over time. split(_sumTotal, _divideBy, _forceMinimum, _haltOnError)   Split a large number into integer sized chunks   Parameters:      _sumTotal : (int) Total numbert of items      _divideBy : (int) Groups to make      _forceMinimum : (bool) force minimum number 1/group      _haltOnError : (bool) force error if too few groups   Returns: int array of items per group
Libreria Pine Script™
di kaigouthro
3
UtilityFunctionsLibrary "UtilityFunctions" Utility functions written by me printLabelOnLastBar_string(string)   Prints string in a label on the last bar   Parameters:      string : value to print   Returns: void printLabelOnLastBar_float(float)   Prints float in a label on the last bar   Parameters:      float : value to print   Returns: void printSeriesInReverseOnLabels(series)   Prints a float series in labels in reverse (the first value is on the last candle, the second value is on the second to last candle, etc.)   Parameters:      series : float values to print   Returns: void isPeriodDailyBased(string)   Returns true/false if the period is Daily based (1D, 3D, ...)   Parameters:      string : timeframe period   Returns: true/false get_multiplier(string)   Gets the mutliplier of the timeframe passed compared to the current timeframe. If current TF is 5m and the passed timeframe period is 30m, the result will be 6   Parameters:      string : timeframe param   Returns: simple float of the multiplier
Libreria Pine Script™
di lyubooo
pineCalc- Calculator for PineHello and welcome to v1.00 of pineCalc - the calculator for Pine A sleek, quick, and discrete calculator in a window pane in your chart! Right now it supports basic math operation and series of two numbers but will try to update it and don't hesitate to comment any ideas SOME FEATURES: - Supports decimal numbers. - Switch statement with option to choose Addition, Subtraction, Multiplication , or Division - Choose any two numbers to use math on - Inputs, Math Type and Result Output
Indicatore Pine Script™
di Toshi-Toshi-Shiba
"Swap" - Bool/Position/Value : Array / Matrix / Var AutoswapLibrary "swap" Side / Boundary Based All Types Swapper - three automagical types for Arrays, Matrixes, and Variables -- no signal : Long/ Short position autoswap -- true / false : Boolean based side choice -- Src / Thresh : if source is above or below the threshold - two operating modes for variables, Holding mode only for arrays/matrixes -- with two items, will automatically change between the two caveat is it does not delete table/box/line(fill VAR items automatically) -- with three items, a neutral is available for NA input or neutral - one function name for all of them. One import name that's easy to type/remember -- make life easy for your conditional items. side(source, thresh, _a, _b, _c)   side Change outputs based on position or a crossing level   Parameters:      source : (float) OPTIONAL value input      thresh : (float) OPTIONAL boundary line to cross      _a : (any) if Long/True/Above      _b : (any) if Short/False/Below      _c : (any) OPTIONAL NOT FOR MTX OR ARR... Neutral Item, if var/varip on a/b it will leave behind, ie, a table or box or line will not erase , if it's a varip you're sending in.   Returns: first, second, or third items based on input conditions Please notify if bugs found. Thanks.
Libreria Pine Script™
di kaigouthro
No Active BarThis is probably the only script on TradingView that's clinically proven to lower your blood pressure!*** This script in conjunction with some chart settings changes can completely hide the active candle, only showing historic candles, thus, reducing risk of cardiac arrest and or panic attack. What to do: 0. Make sure you are using a candlestick chart or this script won't work properly 1. Right click the chart and select "Settings..." 2. Select "Symbol" under the "Chart Settings" menu 3. Disable every item EXCEPT for the "Body" 4. Click on the boxes next to "Body" to access the color picker then change both box's transparency settings down to 0 (the script only colors closed bars, so the active bar will be present just transparent) 5. Right click on the price scale on the far left or far right side of the screen and hover the mouse over "Labels". If any selections have a check mark next to them click them to disable them (especially the "Ask & Bid" price setting since it tracks current price) That's it! Instead of wicks the High & Low prices are plotted above and below the candles using a step line. It looks a bit strange at first but you'll get used to it. Check out the indicator settings to change the color and style of the High & Low lines. ***The statement could prove true for some but is mostly complete bullshit
Indicatore Pine Script™
di NeoDaNomad
1
matrixautotableLibrary "matrixautotable" Automatic Table from Matrixes with pseudo correction for na values and default color override for missing values. uses overloads in cases of cheap float only, with additional addon for strings next, then cell colors, then text colors, and tooltips last.. basic size and location are auto, include the template to speed this up... TODO : make bools version var string group_table = ' Table' var int _tblssizedemo = input.int ( 10 ) string tableYpos = input.string ( 'middle' , '↕' , inline = 'place' , group = group_table, options= ) string tableXpos = input.string ( 'center' , '↔' , inline = 'place' , group = group_table, options= , tooltip='Position on the chart.') int _textSize = input.int ( 1 , 'Table Text Size' , inline = 'place' , group = group_table) var matrix _floatmatrix = matrix.new (_tblssizedemo, _tblssizedemo, 0 ) var matrix _stringmatrix = matrix.new (_tblssizedemo, _tblssizedemo, 'test' ) var matrix _bgcolormatrix = matrix.new (_tblssizedemo, _tblssizedemo, color.white ) var matrix _textcolormatrix = matrix.new (_tblssizedemo, _tblssizedemo, color.black ) var matrix _tooltipmatrix = matrix.new (_tblssizedemo, _tblssizedemo, 'tool' ) // basic table ready to go with the aboec matrixes (replace in your code) // for demo purpose, random colors, random nums, random na vals if barstate.islast varip _xsize = matrix.rows (_floatmatrix) -1 varip _ysize = matrix.columns (_floatmatrix) -1 for _xis = 0 to _xsize -1 by 1 for _yis = 0 to _ysize -1 by 1 _randomr = int(math.random(50,250)) _randomg = int(math.random(50,250)) _randomb = int(math.random(50,250)) _randomt = int(math.random(10,90 )) bgcolor = color.rgb(250 - _randomr, 250 - _randomg, 250 - _randomb, 100 - _randomt ) txtcolor = color.rgb(_randomr, _randomg, _randomb, _randomt ) matrix.set(_bgcolormatrix ,_yis,_xis, bgcolor ) matrix.set(_textcolormatrix ,_yis,_xis, txtcolor) matrix.set(_floatmatrix ,_yis,_xis, _randomr) // random na _ymiss = math.floor(math.random(0, _yis)) _xmiss = math.floor(math.random(0, _xis)) matrix.set( _floatmatrix ,_ymiss, _xis, na) matrix.set( _stringmatrix ,_ymiss, _xis, na) matrix.set( _bgcolormatrix ,_ymiss, _xis, na) matrix.set( _textcolormatrix ,_ymiss, _xis, na) matrix.set( _tooltipmatrix ,_ymiss, _xis, na) // import here import kaigouthro/matrixautotable/1 as mtxtbl // and render table.. mtxtbl.matrixtable(_floatmatrix, _stringmatrix, _bgcolormatrix, _textcolormatrix, _tooltipmatrix, _textSize ,tableYpos ,tableXpos) matrixtable(_floatmatrix, _stringmatrix, _bgcolormatrix, _textcolormatrix, _tooltipmatrix, _textSize, tableYpos, tableXpos) matrixtable   Parameters:      _floatmatrix : float vals      _stringmatrix : string      _bgcolormatrix : color      _textcolormatrix : color      _tooltipmatrix : string      _textSize : int      tableYpos : string      tableXpos : string matrixtable(_floatmatrix, _stringmatrix, _bgcolormatrix, _textcolormatrix, _textSize, tableYpos, tableXpos) matrixtable   Parameters:      _floatmatrix : float vals      _stringmatrix : string      _bgcolormatrix : color      _textcolormatrix : color      _textSize : int      tableYpos : string      tableXpos : string matrixtable(_floatmatrix, _stringmatrix, _bgcolormatrix, _txtdefcol, _textSize, tableYpos, tableXpos) matrixtable   Parameters:      _floatmatrix : float vals      _stringmatrix : string      _bgcolormatrix : color      _txtdefcol : color      _textSize : int      tableYpos : string      tableXpos : string matrixtable(_floatmatrix, _stringmatrix, _txtdefcol, _bgdefcol, _textSize, tableYpos, tableXpos) matrixtable   Parameters:      _floatmatrix : float vals      _stringmatrix : string      _txtdefcol : color      _bgdefcol : color      _textSize : int      tableYpos : string      tableXpos : string matrixtable(_floatmatrix, _txtdefcol, _bgdefcol, _textSize, tableYpos, tableXpos) matrixtable   Parameters:      _floatmatrix : float vals      _txtdefcol : color      _bgdefcol : color      _textSize : int      tableYpos : string      tableXpos : string
Libreria Pine Script™
di kaigouthro
Syminfo [Epi]Hello! This little script tells you everything TradingView lets you access in a ticker's syminfo in Pine Script: - description - type: crypto, economic, forex, fund, futures, index, spread, stock - tickerid, such as AMEX:BLOK - prefix, such as AMEX - Ticker, such as BLOK - root: for derivatives such as futures contracts - currency, such as USD - base currency: returns 'BTC' for the ticker 'BTCUSD' - mintick - point value - session: regular, extended - timezone Some surprises I found in my development: - there are some more types than mentioned in the documentation, - the tickerid takes on additional information if you adjust for dividends or show extended session, - the prefix contains "_DL" additions depending on your data subscriptions, .e.g. "CME_MINI_DL:ES1!", - with futures, TV will show session.regular both for the 'regular' and the 'electronic' session. - Unfortunately, syminfo does not contain the 'sector', although TV has the information in the database (the sector is shown in the screener but not accessed in Pine Script). I use this little utility in my development and hope it's useful for the community. I see such a great number of contributions from the community and would like to give back, even if it's not much.
Indicatore Pine Script™
di Epi_
[TEMPLATE] Code Block Comments█  OVERVIEW Here I present to the community at large a collection of code comment blocks that I think will be useful, especially for larger script projects bordering on 2,000 lines or above of code. █  PLANNED FUTURE UPDATES Work with the community to expand this template to be even more useful with the inclusion of useful global colour sets, variables, tooltips, groups, etc. better script thumbnail. full-screen table or label outlining the script's use-cases.
Indicatore Pine Script™
di BinarySword
6
AbdulLibraryLibrary "AbdulLibrary" The library consists of three sections: Technical Analysis Functions - A collection of tools commonly used by day traders Trading Setup Filters Functions - A number of filters that help day traders to screen trading signals Candlestick Pattern Detection Functions - To detect different candlestick patterns that are used in day trading setups Note that this would have been possible without the help of @ZenAndTheArtOfTrading as I build-up this library after completing his pine script mastery course so big thanks to him The content of the library are:- fibLevels(preDayClose, preDayHigh, preDayLow) Calculates Daily Pivot Point and Fibonacci Key Levels   Parameters:      preDayClose : The previous day candle close      preDayHigh : The previous day candle high      preDayLow : The previous day candle low   Returns: Returns Daily Pivot Point and Fibonacci Key Levels as a tuple bullishFib(canHigh, canLow, fibLevel) Calculates Fibonacci Levels in Bullish move   Parameters:      canHigh : The high of the move      canLow : The low of the move      fibLevel : The Fib level as % you want to calculate   Returns: Returns The Fib level for the Bullish move bearishFib(canHigh, canLow, fibLevel) Calculates Fibonacci Levels in Bearish move   Parameters:      canHigh : The high of the move      canLow : The low of the move      fibLevel : The Fib level as % you want to calculate   Returns: Returns The Fib level for the Bearish move getCandleSize() Calculates the size of candle (high - low) in points   Returns: Returns candle size in points getCandleBodySize() Calculates the size of candle (close - open) in points   Returns: Returns candle body size in points getHighWickSize() Calculates the high wick size of candle in points   Returns: Returns The high wick size of candle in points getLowWickSize() Calculates the low wick size of candle in points   Returns: Returns The low wick size of candle in points getBodyPercentage() Calculates the candle body size as % of overall candle size   Returns: Returns The candle body size as % of overall candle size isSwingHigh(period) Checks if the price has created new swing high over a period of time   Parameters:      period : The lookback time we want to check for swing high   Returns: Returns True if the current candle or the previous candle is a swing high isSwingLow(period) Checks if the price has created new swing low over a period of time   Parameters:      period : The lookback time we want to check for swing low   Returns: Returns True if the current candle or the previous candle is a swing low isDojiSwingHigh(period) Checks if a doji is a swing high over a period of time   Parameters:      period : The lookback time we want to check for swing high   Returns: Returns True if the doji is a swing high isDojiSwingLow(period) Checks if a doji is a swing low over a period of time   Parameters:      period : The lookback time we want to check for swing low   Returns: Returns True if the doji is a swing low isBigBody(atrFilter, atr, candleBodySize, multiplier) Checks if a candle has big body compared to ATR   Parameters:      atrFilter : Check if user wants to use ATR to filter candle-setup signals      atr : The ATR value to be used to compare candle body size      candleBodySize : The candle body size      multiplier : The multiplier to be used to compare candle body size   Returns: Returns Boolean true if the candle setup is big isSmallBody(atrFilter, atr, candleBodySize, multiplier) Checks if a candle has small body compared to ATR   Parameters:      atrFilter : Check if user wants to use ATR to filter candle-setup signals      atr : The ATR value to be used to compare candle body size      candleBodySize : The candle body size      multiplier : The multiplier to be used to compare candle body size   Returns: Returns Boolean true if the candle setup is small isHammer(fibLevel, colorMatch) Checks if a candle is a hammer based on user input parameters and candle conditions   Parameters:      fibLevel : Fib level to base candle body on      colorMatch : Checks if user needs for the candel to be green   Returns: Returns Boolean - True if the candle setup is hammer isShootingStar(fibLevel, colorMatch) Checks if a candle is a shooting star based on user input parameters and candle conditions   Parameters:      fibLevel : Fib level to base candle body on      colorMatch : Checks if user needs for the candel to be red   Returns: Returns Boolean - True if the candle setup is star isBullEngCan(allowance, period) Check if a candle is a bullish engulfing candle   Parameters:      allowance : How many points the candle open is allowed to be off (To allow for gaps)      period : The lookback period for swing low check   Returns: Boolean - True only if the candle is a bullish engulfing candle isBearEngCan(allowance, period) Check if a candle is a bearish engulfing candle   Parameters:      allowance : How many points the candle open is allowed to be off (To allow for gaps)      period : The lookback period for swing high check   Returns: Boolean - True only if the candle is a bearish engulfing candle isBullDoji(maxSize, wickLimit, colorFilter) Check if a candle is a bullish doji candle   Parameters:      maxSize : Maximum candle body size as % of total candle size to be considered as doji      wickLimit : Maximum wick size of one wick compared to the other wick      colorFilter : Checks if the doji is green   Returns: Boolean - True if the candle is a bullish doji isBearDoji(maxSize, wickLimit, colorFilter) Check if a candle is a bearish doji candle   Parameters:      maxSize : Maximum candle body size as % of total candle size to be considered as doji      wickLimit : Maximum wick size of one wick compared to the other wick      colorFilter : Checks if the doji is red   Returns: Boolean - True if the candle is a bearish doji isBullOutBar() Check if a candle is a bullish outside bar   Returns: Boolean - True if the candle is a bullish outside bar isInsideBar() Check if a candle is an inside bar   Returns: Returns Boolean - True if a candle is an inside bar
Libreria Pine Script™
di Abdul_Saif
1