Começar

Statistics

Price Change IndicatorPrice Change Indicator (PCI) Version: 1.0 Author: LazyTrader 🚀 🔍 Overview The Price Change Indicator (PCI) helps traders visualize and compare price changes between the current bar and the previous bar. It provides a customizable display of price changes in two formats: Percentage (%) Change – Relative price movement. Natural Change – Absolute difference in price units. ⚙️ Key Features ✅ Customizable Calculation Method: Choose how the price change is calculated: Opening Price Closing Price High Low ✅ Flexible Display Format: Show Percentage (%) Change. Show Natural (Absolute) Change in price. ✅ Adjustable Sensitivity with Multiplier: 100 (Standard Change) 1000 (Small Change) 10000 (Tiny Change) ✅ Intuitive Labeling: Green label (above bar) for increase. Red label (below bar) for decrease. No label if no change. Large, easy-to-read labels for better visibility. ✅ Perfect for Any Market: Stocks 📈 Forex 💱 Crypto 🚀 Commodities 🛢️ 📊 How It Works The indicator calculates the difference between the current and previous bar’s price based on your chosen method. The result is displayed as either a percentage (%) or a natural price change. If the price has increased, a green label is displayed above the bar. If the price has decreased, a red label is displayed below the bar. ⚡ How to Use Add the indicator to your chart. Go to settings and customize: Select calculation method (Open, Close, High, Low). Choose display format (% or Natural Change). Adjust multiplier for more sensitivity. Analyze the labels to see price movements easily! 🔧 Settings Explained Setting Description Price Calculation Method: Choose Open, Close, High, or Low price for comparison. Display Format: Show either % Change or Natural Change. Multiplier: Apply 100, 1000, or 10000 to scale small price changes. Show Labels: Toggle labels on/off. 🎯 Best Use Cases 🔹 Identifying strong price movements 🔹 Spotting trends and momentum shifts 🔹 Comparing price movement intensity 🔹 Works for scalping, swing trading, and long-term analysis
Indicador Pine Script™
por QCodeTrader
Uptrick: Alpha TrendIntroduction Uptrick: Alpha Trend is a comprehensive technical analysis indicator designed to provide traders with detailed insights into market trends, momentum, and risk metrics. It adapts to various trading styles—from quick scalps to longer-term positions—by dynamically adjusting its calculations and visual elements. By combining multiple smoothing techniques, advanced color schemes, and customizable data tables, the indicator offers a holistic view of market behavior. Originality The Alpha Trend indicator distinguishes itself by blending established technical concepts with innovative adaptations. It employs three different smoothing techniques tailored to specific trading modes (Scalp, Swing, and Position), and it dynamically adjusts its parameters to match the chosen mode. The indicator also offers a wide range of color palettes and multiple on-screen tables that display key metrics. This unique combination of features, along with its ability to adapt in real time, sets it apart as a versatile tool for both novice and experienced traders. Features 1. Multi-Mode Trend Line The indicator automatically selects a smoothing method based on the trading mode: - Scalp Mode uses the Hull Moving Average (HMA) for rapid responsiveness. - Swing Mode employs the Exponential Moving Average (EMA) for balanced reactivity. - Position Mode applies the Weighted Moving Average (WMA) for smoother, long-term trends. Each method is chosen to best capture the price action dynamics appropriate to the trader’s timeframe. 2. Adaptive Momentum Thresholds It tracks bullish and bearish momentum with counters that increment as the trend confirms directional movement. When these counters exceed a user-defined threshold, the indicator generates optional buy or sell signals. This approach helps filter out minor fluctuations and highlights significant market moves. 3. Gradient Fills Two types of fills enhance visual clarity: - Standard Gradient Fill displays ATR-based zones above and below the trend line, indicating potential bullish and bearish areas. - Fading Gradient Fill creates a smooth transition between the trend line and the price, visually emphasizing the distance between them. 4. Bar Coloring and Signal Markers The indicator can color-code bars based on market conditions—bullish, bearish, or neutral—allowing for immediate visual assessment. Additionally, signal markers such as buy and sell arrows are plotted when momentum thresholds are breached. 5. Comprehensive Data Tables Uptrick: Alpha Trend offers several optional tables for detailed analysis: - Insider Info: Displays key metrics like the current trend value, bullish/bearish momentum counts, and ATR. - Indicator Metrics: Lists input settings such as trend length, damping, signal threshold, and net momentum. - Market Analysis: Summarizes overall trend direction, trend strength, Sortino ratio, return, and volatility. - Price & Trend Dynamics: Details price deviation from the trend, trend slope, and ATR ratio. - Momentum & Volatility Insights: Presents RSI, standard deviation (volatility), and net momentum. - Performance & Acceleration Metrics: Focuses on the Sortino ratio, trend acceleration, return, and trend strength. Each table can be positioned flexibly on the chart, allowing traders to customize the layout according to their needs. Why It Combines Specific Smoothing Techniques Smoothing techniques are essential for filtering out market noise and revealing underlying trends. The indicator combines three smoothing methods for the following reasons: - The Hull Moving Average (HMA) in Scalp Mode minimizes lag and responds quickly to price changes, which is critical for short-term trading. - The Exponential Moving Average (EMA) in Swing Mode gives more weight to recent data, striking a balance between speed and smoothness. This makes it suitable for mid-term trend analysis. - The Weighted Moving Average (WMA) in Position Mode smooths out short-term fluctuations, offering a clear view of longer-term trends and reducing the impact of transient market volatility. By using these specific methods in their respective trading modes, the indicator ensures that the trend line is appropriately responsive for the intended time frame, enhancing decision-making while maintaining clarity. Inputs 1. Trend Length (Default: 30) Defines the lookback period for the smoothing calculation. A shorter trend length results in a more responsive line, while a longer length produces a smoother, less volatile trend. 2. Trend Damping (Default: 0.75) Controls the degree of smoothing applied to the trend line. Lower values lead to a smoother curve, whereas higher values increase sensitivity to price fluctuations. 3. Signal Strength Threshold (Default: 5) Specifies the number of consecutive bullish or bearish bars required to trigger a signal. Higher thresholds reduce the frequency of signals, focusing on stronger moves. 4. Enable Bar Coloring (Default: True) Toggles whether each price bar is colored to indicate bullish, bearish, or neutral conditions. 5. Enable Signals (Default: True) When enabled, this option plots buy or sell arrows on the chart once the momentum thresholds are met. 6. Enable Standard Gradient Fill (Default: False) Activates ATR-based gradient fills around the trend line to visualize potential support and resistance zones. 7. Enable Fading Gradient Fill (Default: True) Draws a gradual color transition between the trend line and the current price, emphasizing their divergence. 8. Trading Mode (Options: Scalp, Swing, Position) Determines which smoothing method and ATR period to use, adapting the indicator’s behavior to short-term, medium-term, or long-term trading. 9. Table Position Inputs Allows users to select from nine possible chart positions (top, middle, bottom; left, center, right) for each data table. 10. Show Table Booleans Separate toggles control the display of each table (Insider Info, Indicator Metrics, Market Analysis, and the three Deep Tables), enabling a customized view of the data. Color Schemes (Default) - The colors in the preview image of the indicator. (Emerald) (Sapphire) (Golden Blaze) (Mystic) (Monochrome) (Pastel) (Vibrant) (Earth) (Neon) Calculations 1. Trend Line Methods - Scalp Mode: Utilizes the Hull Moving Average (HMA), which computes two weighted moving averages (one at half the length and one at full length), subtracts them, and then applies a final weighted average based on the square root of the length. This method minimizes lag and increases responsiveness. - Swing Mode: Uses the Exponential Moving Average (EMA), which assigns greater weight to recent prices, thus balancing quick reaction with smoothness. - Position Mode: Applies the Weighted Moving Average (WMA) to focus on longer-term trends by emphasizing the entire lookback period and reducing the impact of short-term volatility. 2. Momentum Tracking The indicator maintains separate counters for bullish and bearish momentum. These counters increase as the trend confirms directional movement and reset when the trend reverses. When a counter exceeds the defined signal strength threshold, a corresponding signal (buy or sell) is triggered. 3. Volatility and ATR Zones The Average True Range (ATR) is calculated using a period that adapts to the selected trading mode (shorter for Scalp, longer for Position). The ATR value is then used to define upper and lower zones around the trend line, highlighting the current level of market volatility. 4. Return and Trend Acceleration - Return is calculated as the difference between the current and previous closing prices, providing a simple measure of price change. - Trend Acceleration is derived from the change in the trend line’s movement (its first derivative) compared to the previous bar. This metric indicates whether the trend is gaining or losing momentum. 5. Sortino Ratio and Standard Deviation - The Sortino Ratio measures risk-adjusted performance by comparing returns to downside volatility (only considering negative price changes). - Standard Deviation is computed over the lookback period to assess the extent of price fluctuations, offering insights into market stability. Usage This indicator is suitable for various time frames and market instruments. Traders can enable or disable specific visual elements such as gradient fills, bar coloring, and signal markers based on their preference. For a minimalist approach, one might choose to display only the primary trend line. For a deeper analysis, enabling multiple tables can provide extensive data on momentum, volatility, trend dynamics, and risk metrics. Important Note on Risk Trading involves inherent risk, and no indicator can eliminate the uncertainty of the markets. Past performance is not indicative of future results. It is essential to use proper risk management, test any new tool thoroughly, and consult multiple sources or professional advice before making trading decisions. Conclusion Uptrick: Alpha Trend unifies a diverse set of calculations, adaptive smoothing techniques, and customizable visual elements into one powerful tool. By combining the Hull, Exponential, and Weighted Moving Averages, the indicator is able to provide a trend line that is both responsive and smooth, depending on the trading mode. Its advanced color schemes, gradient fills, and detailed data tables deliver a comprehensive analysis of market trends, momentum, and risk. Whether you are a short-term trader or a long-term investor, this indicator aims to clarify price action and assist you in making more informed trading decisions.
Indicador Pine Script™
por Uptrick
3
ValueAtTime█ OVERVIEW This library is a Pine Script® programming tool for accessing historical values in a time series using UNIX timestamps . Its data structure and functions index values by time, allowing scripts to retrieve past values based on absolute timestamps or relative time offsets instead of relying on bar index offsets. █ CONCEPTS UNIX timestamps In Pine Script®, a UNIX timestamp is an integer representing the number of milliseconds elapsed since January 1, 1970, at 00:00:00 UTC (the UNIX Epoch ). The timestamp is a unique, absolute representation of a specific point in time. Unlike a calendar date and time, a UNIX timestamp's meaning does not change relative to any time zone . This library's functions process series values and corresponding UNIX timestamps in pairs , offering a simplified way to identify values that occur at or near distinct points in time instead of on specific bars. Storing and retrieving time-value pairs This library's `Data` type defines the structure for collecting time and value information in pairs. Objects of the `Data` type contain the following two fields:  • `times` – An array of "int" UNIX timestamps for each recorded value.  • `values` – An array of "float" values for each saved timestamp. Each index in both arrays refers to a specific time-value pair. For instance, the `times` and `values` elements at index 0 represent the first saved timestamp and corresponding value. The library functions that maintain `Data` objects queue up to one time-value pair per bar into the object's arrays, where the saved timestamp represents the bar's opening time . Because the `times` array contains a distinct UNIX timestamp for each item in the `values` array, it serves as a custom mapping for retrieving saved values. All the library functions that return information from a `Data` object use this simple two-step process to identify a value based on time:  1. Perform a binary search on the `times` array to find the earliest saved timestamp closest to the specified time or offset and get the element's index.  2. Access the element from the `values` array at the retrieved index, returning the stored value corresponding to the found timestamp. Value search methods There are several techniques programmers can use to identify historical values from corresponding timestamps. This library's functions include three different search methods to locate and retrieve values based on absolute times or relative time offsets: Timestamp search   Find the value with the earliest saved timestamp closest to a specified timestamp. Millisecond offset search Find the value with the earliest saved timestamp closest to a specified number of milliseconds behind the current bar's opening time. This search method provides a time-based alternative to retrieving historical values at specific bar offsets. Period offset search Locate the value with the earliest saved timestamp closest to a defined period offset behind the current bar's opening time. The function calculates the span of the offset based on a period string . The "string" must contain one of the following unit tokens:  • "D" for days  • "W" for weeks  • "M" for months  • "Y" for years  • "YTD" for year-to-date, meaning the time elapsed since the beginning of the bar's opening year in the exchange time zone. The period string can include a multiplier prefix for all supported units except "YTD" (e.g., "2W" for two weeks). Note that the precise span covered by the "M", "Y", and "YTD" units varies across time. The "1M" period can cover 28, 29, 30, or 31 days, depending on the bar's opening month and year in the exchange time zone. The "1Y" period covers 365 or 366 days, depending on leap years. The "YTD" period's span changes with each new bar, because it always measures the time from the start of the current bar's opening year. █ CALCULATIONS AND USE This library's functions offer a flexible, structured approach to retrieving historical values at or near specific timestamps, millisecond offsets, or period offsets for different analytical needs. See below for explanations of the exported functions and how to use them. Retrieving single values The library includes three functions that retrieve a single stored value using timestamp, millisecond offset, or period offset search methods:  • `valueAtTime()` – Locates the saved value with the earliest timestamp closest to a specified timestamp.  • `valueAtTimeOffset()` – Finds the saved value with the earliest timestamp closest to the specified number of milliseconds behind the current bar's opening time.  • `valueAtPeriodOffset()` – Finds the saved value with the earliest timestamp closest to the period-based offset behind the current bar's opening time. Each function has two overloads for advanced and simple use cases. The first overload searches for a value in a user-specified `Data` object created by the `collectData()` function (see below). It returns a tuple containing the found value and the corresponding timestamp. The second overload maintains a `Data` object internally to store and retrieve values for a specified `source` series. This overload returns a tuple containing the historical `source` value, the corresponding timestamp, and the current bar's `source` value, making it helpful for comparing past and present values from requested contexts. Retrieving multiple values The library includes the following functions to retrieve values from multiple historical points in time, facilitating calculations and comparisons with values retrieved across several intervals:  • `getDataAtTimes()` – Locates a past `source` value for each item in a `timestamps` array. Each retrieved value's timestamp represents the earliest time closest to one of the specified timestamps.  • `getDataAtTimeOffsets()` – Finds a past `source` value for each item in a `timeOffsets` array. Each retrieved value's timestamp represents the earliest time closest to one of the specified millisecond offsets behind the current bar's opening time.  • `getDataAtPeriodOffsets()` – Finds a past value for each item in a `periods` array. Each retrieved value's timestamp represents the earliest time closest to one of the specified period offsets behind the current bar's opening time. Each function returns a tuple with arrays containing the found `source` values and their corresponding timestamps. In addition, the tuple includes the current `source` value and the symbol's description, which also makes these functions helpful for multi-interval comparisons using data from requested contexts. Processing period inputs When writing scripts that retrieve historical values based on several user-specified period offsets, the most concise approach is to create a single text input that allows users to list each period, then process the "string" list into an array for use in the `getDataAtPeriodOffsets()` function. This library includes a `getArrayFromString()` function to provide a simple way to process strings containing comma-separated lists of periods. The function splits the specified `str` by its commas and returns an array containing every non-empty item in the list with surrounding whitespaces removed. View the example code to see how we use this function to process the value of a text area input . Calculating period offset times Because the exact amount of time covered by a specified period offset can vary, it is often helpful to verify the resulting times when using the `valueAtPeriodOffset()` or `getDataAtPeriodOffsets()` functions to ensure the calculations work as intended for your use case. The library's `periodToTimestamp()` function calculates an offset timestamp from a given period and reference time. With this function, programmers can verify the time offsets in a period-based data search and use the calculated offset times in additional operations. For periods with "D" or "W" units, the function calculates the time offset based on the absolute number of milliseconds the period covers (e.g., `86400000` for "1D"). For periods with "M", "Y", or "YTD" units, the function calculates an offset time based on the reference time's calendar date in the exchange time zone. Collecting data All the `getDataAt*()` functions, and the second overloads of the `valueAt*()` functions, collect and maintain data internally, meaning scripts do not require a separate `Data` object when using them. However, the first overloads of the `valueAt*()` functions do not collect data, because they retrieve values from a user-specified `Data` object. For cases where a script requires a separate `Data` object for use with these overloads or other custom routines, this library exports the `collectData()` function. This function queues each bar's `source` value and opening timestamp into a `Data` object and returns the object's ID. This function is particularly useful when searching for values from a specific series more than once. For instance, instead of using multiple calls to the second overloads of `valueAt*()` functions with the same `source` argument, programmers can call `collectData()` to store each bar's `source` and opening timestamp, then use the returned `Data` object's ID in calls to the first `valueAt*()` overloads to reduce memory usage. The `collectData()` function and all the functions that collect data internally include two optional parameters for limiting the saved time-value pairs to a sliding window: `timeOffsetLimit` and `timeframeLimit`. When either has a non-na argument, the function restricts the collected data to the maximum number of recent bars covered by the specified millisecond- and timeframe-based intervals. NOTE : All calls to the functions that collect data for a `source` series can execute up to once per bar or realtime tick, because each stored value requires a unique corresponding timestamp. Therefore, scripts cannot call these functions iteratively within a loop . If a call to these functions executes more than once inside a loop's scope, it causes a runtime error. █ EXAMPLE CODE The example code at the end of the script demonstrates one possible use case for this library's functions. The code retrieves historical price data at user-specified period offsets, calculates price returns for each period from the retrieved data, and then populates a table with the results. The example code's process is as follows:   1. Input a list of periods – The user specifies a comma-separated list of period strings in the script's "Period list" input (e.g., "1W, 1M, 3M, 1Y, YTD"). Each item in the input list represents a period offset from the latest bar's opening time.   2. Process the period list – The example calls `getArrayFromString()` on the first bar to split the input list by its commas and construct an array of period strings.   3. Request historical data – The code uses a call to `getDataAtPeriodOffsets()` as the `expression` argument in a request.security() call to retrieve the closing prices of "1D" bars for each period included in the processed `periods` array.   4. Display information in a table – On the latest bar, the code uses the retrieved data to calculate price returns over each specified period, then populates a two-row table with the results. The cells for each return percentage are color-coded based on the magnitude and direction of the price change. The cells also include tooltips showing the compared daily bar's opening date in the exchange time zone. █ NOTES  • This library's architecture relies on a user-defined type (UDT) for its data storage format. UDTs are blueprints from which scripts create objects , i.e., composite structures with fields containing independent values or references of any supported type.  • The library functions search through a `Data` object's `times` array using the array.binary_search_leftmost() function, which is more efficient than looping through collected data to identify matching timestamps. Note that this built-in works only for arrays with elements sorted in ascending order .  • Each function that collects data from a `source` series updates the values and times stored in a local `Data` object's arrays. If a single call to these functions were to execute in a loop , it would store multiple values with an identical timestamp, which can cause erroneous search behavior. To prevent looped calls to these functions, the library uses the `checkCall()` helper function in their scopes. This function maintains a counter that increases by one each time it executes on a confirmed bar. If the count exceeds the total number of bars, indicating the call executes more than once in a loop, it raises a runtime error .  • Typically, when requesting higher-timeframe data with request.security() while using barmerge.lookahead_on as the `lookahead` argument, the `expression` argument should be offset with the history-referencing operator to prevent lookahead bias on historical bars. However, the call in this script's example code enables lookahead without offsetting the `expression` because the script displays results only on the last historical bar and all realtime bars, where there is no future data to leak into the past. This call ensures the displayed results use the latest data available from the context on realtime bars. Look first. Then leap. █ EXPORTED TYPES Data   A structure for storing successive timestamps and corresponding values from a dataset.   Fields:      times (array) : An "int" array containing a UNIX timestamp for each value in the `values` array.      values (array) : A "float" array containing values corresponding to the timestamps in the `times` array. █ EXPORTED FUNCTIONS getArrayFromString(str)   Splits a "string" into an array of substrings using the comma (`,`) as the delimiter. The function trims surrounding whitespace characters from each substring, and it excludes empty substrings from the result.   Parameters:      str (series string) : The "string" to split into an array based on its commas.   Returns: (array) An array of trimmed substrings from the specified `str`. periodToTimestamp(period, referenceTime)   Calculates a UNIX timestamp representing the point offset behind a reference time by the amount of time within the specified `period`.   Parameters:      period (series string) : The period string, which determines the time offset of the returned timestamp. The specified argument must contain a unit and an optional multiplier (e.g., "1Y", "3M", "2W", "YTD"). Supported units are: - "Y" for years. - "M" for months. - "W" for weeks. - "D" for days. - "YTD" (Year-to-date) for the span from the start of the `referenceTime` value's year in the exchange time zone. An argument with this unit cannot contain a multiplier.      referenceTime (series int) : The millisecond UNIX timestamp from which to calculate the offset time.   Returns: (int) A millisecond UNIX timestamp representing the offset time point behind the `referenceTime`. collectData(source, timeOffsetLimit, timeframeLimit)   Collects `source` and `time` data successively across bars. The function stores the information within a `Data` object for use in other exported functions/methods, such as `valueAtTimeOffset()` and `valueAtPeriodOffset()`. Any call to this function cannot execute more than once per bar or realtime tick.   Parameters:      source (series float) : The source series to collect. The function stores each value in the series with an associated timestamp representing its corresponding bar's opening time.      timeOffsetLimit (simple int) : Optional. A time offset (range) in milliseconds. If specified, the function limits the collected data to the maximum number of bars covered by the range, with a minimum of one bar. If the call includes a non-empty `timeframeLimit` value, the function limits the data using the largest number of bars covered by the two ranges. The default is `na`.      timeframeLimit (simple string) : Optional. A valid timeframe string. If specified and not empty, the function limits the collected data to the maximum number of bars covered by the timeframe, with a minimum of one bar. If the call includes a non-na `timeOffsetLimit` value, the function limits the data using the largest number of bars covered by the two ranges. The default is `na`.   Returns: (Data) A `Data` object containing collected `source` values and corresponding timestamps over the allowed time range. method valueAtTime(data, timestamp)   (Overload 1 of 2) Retrieves value and time data from a `Data` object's fields at the index of the earliest timestamp closest to the specified `timestamp`. Callable as a method or a function.   Parameters:      data (series Data) : The `Data` object containing the collected time and value data.      timestamp (series int) : The millisecond UNIX timestamp to search. The function returns data for the earliest saved timestamp that is closest to the value.   Returns: ( ) A tuple containing the following data from the `Data` object: - The stored value corresponding to the identified timestamp ("float"). - The earliest saved timestamp that is closest to the specified `timestamp` ("int"). valueAtTime(source, timestamp, timeOffsetLimit, timeframeLimit)   (Overload 2 of 2) Retrieves `source` and time information for the earliest bar whose opening timestamp is closest to the specified `timestamp`. Any call to this function cannot execute more than once per bar or realtime tick.   Parameters:      source (series float) : The source series to analyze. The function stores each value in the series with an associated timestamp representing its corresponding bar's opening time.      timestamp (series int) : The millisecond UNIX timestamp to search. The function returns data for the earliest bar whose timestamp is closest to the value.      timeOffsetLimit (simple int) : Optional. A time offset (range) in milliseconds. If specified, the function limits the collected data to the maximum number of bars covered by the range, with a minimum of one bar. If the call includes a non-empty `timeframeLimit` value, the function limits the data using the largest number of bars covered by the two ranges. The default is `na`.      timeframeLimit (simple string) : (simple string) Optional. A valid timeframe string. If specified and not empty, the function limits the collected data to the maximum number of bars covered by the timeframe, with a minimum of one bar. If the call includes a non-na `timeOffsetLimit` value, the function limits the data using the largest number of bars covered by the two ranges. The default is `na`.   Returns: ( ) A tuple containing the following data: - The `source` value corresponding to the identified timestamp ("float"). - The earliest bar's timestamp that is closest to the specified `timestamp` ("int"). - The current bar's `source` value ("float"). method valueAtTimeOffset(data, timeOffset)   (Overload 1 of 2) Retrieves value and time data from a `Data` object's fields at the index of the earliest saved timestamp closest to `timeOffset` milliseconds behind the current bar's opening time. Callable as a method or a function.   Parameters:      data (series Data) : The `Data` object containing the collected time and value data.      timeOffset (series int) : The millisecond offset behind the bar's opening time. The function returns data for the earliest saved timestamp that is closest to the calculated offset time.   Returns: ( ) A tuple containing the following data from the `Data` object: - The stored value corresponding to the identified timestamp ("float"). - The earliest saved timestamp that is closest to `timeOffset` milliseconds before the current bar's opening time ("int"). valueAtTimeOffset(source, timeOffset, timeOffsetLimit, timeframeLimit)   (Overload 2 of 2) Retrieves `source` and time information for the earliest bar whose opening timestamp is closest to `timeOffset` milliseconds behind the current bar's opening time. Any call to this function cannot execute more than once per bar or realtime tick.   Parameters:      source (series float) : The source series to analyze. The function stores each value in the series with an associated timestamp representing its corresponding bar's opening time.      timeOffset (series int) : The millisecond offset behind the bar's opening time. The function returns data for the earliest bar's timestamp that is closest to the calculated offset time.      timeOffsetLimit (simple int) : Optional. A time offset (range) in milliseconds. If specified, the function limits the collected data to the maximum number of bars covered by the range, with a minimum of one bar. If the call includes a non-empty `timeframeLimit` value, the function limits the data using the largest number of bars covered by the two ranges. The default is `na`.      timeframeLimit (simple string) : Optional. A valid timeframe string. If specified and not empty, the function limits the collected data to the maximum number of bars covered by the timeframe, with a minimum of one bar. If the call includes a non-na `timeOffsetLimit` value, the function limits the data using the largest number of bars covered by the two ranges. The default is `na`.   Returns: ( ) A tuple containing the following data: - The `source` value corresponding to the identified timestamp ("float"). - The earliest bar's timestamp that is closest to `timeOffset` milliseconds before the current bar's opening time ("int"). - The current bar's `source` value ("float"). method valueAtPeriodOffset(data, period)   (Overload 1 of 2) Retrieves value and time data from a `Data` object's fields at the index of the earliest timestamp closest to a calculated offset behind the current bar's opening time. The calculated offset represents the amount of time covered by the specified `period`. Callable as a method or a function.   Parameters:      data (series Data) : The `Data` object containing the collected time and value data.      period (series string) : The period string, which determines the calculated time offset. The specified argument must contain a unit and an optional multiplier (e.g., "1Y", "3M", "2W", "YTD"). Supported units are: - "Y" for years. - "M" for months. - "W" for weeks. - "D" for days. - "YTD" (Year-to-date) for the span from the start of the current bar's year in the exchange time zone. An argument with this unit cannot contain a multiplier.   Returns: ( ) A tuple containing the following data from the `Data` object: - The stored value corresponding to the identified timestamp ("float"). - The earliest saved timestamp that is closest to the calculated offset behind the bar's opening time ("int"). valueAtPeriodOffset(source, period, timeOffsetLimit, timeframeLimit)   (Overload 2 of 2) Retrieves `source` and time information for the earliest bar whose opening timestamp is closest to a calculated offset behind the current bar's opening time. The calculated offset represents the amount of time covered by the specified `period`. Any call to this function cannot execute more than once per bar or realtime tick.   Parameters:      source (series float) : The source series to analyze. The function stores each value in the series with an associated timestamp representing its corresponding bar's opening time.      period (series string) : The period string, which determines the calculated time offset. The specified argument must contain a unit and an optional multiplier (e.g., "1Y", "3M", "2W", "YTD"). Supported units are: - "Y" for years. - "M" for months. - "W" for weeks. - "D" for days. - "YTD" (Year-to-date) for the span from the start of the current bar's year in the exchange time zone. An argument with this unit cannot contain a multiplier.      timeOffsetLimit (simple int) : Optional. A time offset (range) in milliseconds. If specified, the function limits the collected data to the maximum number of bars covered by the range, with a minimum of one bar. If the call includes a non-empty `timeframeLimit` value, the function limits the data using the largest number of bars covered by the two ranges. The default is `na`.      timeframeLimit (simple string) : Optional. A valid timeframe string. If specified and not empty, the function limits the collected data to the maximum number of bars covered by the timeframe, with a minimum of one bar. If the call includes a non-na `timeOffsetLimit` value, the function limits the data using the largest number of bars covered by the two ranges. The default is `na`.   Returns: ( ) A tuple containing the following data: - The `source` value corresponding to the identified timestamp ("float"). - The earliest bar's timestamp that is closest to the calculated offset behind the current bar's opening time ("int"). - The current bar's `source` value ("float"). getDataAtTimes(timestamps, source, timeOffsetLimit, timeframeLimit)   Retrieves `source` and time information for each bar whose opening timestamp is the earliest one closest to one of the UNIX timestamps specified in the `timestamps` array. Any call to this function cannot execute more than once per bar or realtime tick.   Parameters:      timestamps (array) : An array of "int" values representing UNIX timestamps. The function retrieves `source` and time data for each element in this array.      source (series float) : The source series to analyze. The function stores each value in the series with an associated timestamp representing its corresponding bar's opening time.      timeOffsetLimit (simple int) : Optional. A time offset (range) in milliseconds. If specified, the function limits the collected data to the maximum number of bars covered by the range, with a minimum of one bar. If the call includes a non-empty `timeframeLimit` value, the function limits the data using the largest number of bars covered by the two ranges. The default is `na`.      timeframeLimit (simple string) : Optional. A valid timeframe string. If specified and not empty, the function limits the collected data to the maximum number of bars covered by the timeframe, with a minimum of one bar. If the call includes a non-na `timeOffsetLimit` value, the function limits the data using the largest number of bars covered by the two ranges. The default is `na`.   Returns: ( ) A tuple of the following data: - An array containing a `source` value for each identified timestamp (array). - An array containing an identified timestamp for each item in the `timestamps` array (array). - The current bar's `source` value ("float"). - The symbol's description from `syminfo.description` ("string"). getDataAtTimeOffsets(timeOffsets, source, timeOffsetLimit, timeframeLimit)   Retrieves `source` and time information for each bar whose opening timestamp is the earliest one closest to one of the time offsets specified in the `timeOffsets` array. Each offset in the array represents the absolute number of milliseconds behind the current bar's opening time. Any call to this function cannot execute more than once per bar or realtime tick.   Parameters:      timeOffsets (array) : An array of "int" values representing the millisecond time offsets used in the search. The function retrieves `source` and time data for each element in this array. For example, the array ` ` specifies that the function returns data for the timestamps closest to one day and one week behind the current bar's opening time.      source (float) : (series float) The source series to analyze. The function stores each value in the series with an associated timestamp representing its corresponding bar's opening time.      timeOffsetLimit (simple int) : Optional. A time offset (range) in milliseconds. If specified, the function limits the collected data to the maximum number of bars covered by the range, with a minimum of one bar. If the call includes a non-empty `timeframeLimit` value, the function limits the data using the largest number of bars covered by the two ranges. The default is `na`.      timeframeLimit (simple string) : Optional. A valid timeframe string. If specified and not empty, the function limits the collected data to the maximum number of bars covered by the timeframe, with a minimum of one bar. If the call includes a non-na `timeOffsetLimit` value, the function limits the data using the largest number of bars covered by the two ranges. The default is `na`.   Returns: ( ) A tuple of the following data: - An array containing a `source` value for each identified timestamp (array). - An array containing an identified timestamp for each offset specified in the `timeOffsets` array (array). - The current bar's `source` value ("float"). - The symbol's description from `syminfo.description` ("string"). getDataAtPeriodOffsets(periods, source, timeOffsetLimit, timeframeLimit)   Retrieves `source` and time information for each bar whose opening timestamp is the earliest one closest to a calculated offset behind the current bar's opening time. Each calculated offset represents the amount of time covered by a period specified in the `periods` array. Any call to this function cannot execute more than once per bar or realtime tick.   Parameters:      periods (array) : An array of period strings, which determines the time offsets used in the search. The function retrieves `source` and time data for each element in this array. For example, the array ` ` specifies that the function returns data for the timestamps closest to one day, week, and month behind the current bar's opening time. Each "string" in the array must contain a unit and an optional multiplier. Supported units are: - "Y" for years. - "M" for months. - "W" for weeks. - "D" for days. - "YTD" (Year-to-date) for the span from the start of the current bar's year in the exchange time zone. An argument with this unit cannot contain a multiplier.      source (float) : (series float) The source series to analyze. The function stores each value in the series with an associated timestamp representing its corresponding bar's opening time.      timeOffsetLimit (simple int) : Optional. A time offset (range) in milliseconds. If specified, the function limits the collected data to the maximum number of bars covered by the range, with a minimum of one bar. If the call includes a non-empty `timeframeLimit` value, the function limits the data using the largest number of bars covered by the two ranges. The default is `na`.      timeframeLimit (simple string) : Optional. A valid timeframe string. If specified and not empty, the function limits the collected data to the maximum number of bars covered by the timeframe, with a minimum of one bar. If the call includes a non-na `timeOffsetLimit` value, the function limits the data using the largest number of bars covered by the two ranges. The default is `na`.   Returns: ( ) A tuple of the following data: - An array containing a `source` value for each identified timestamp (array). - An array containing an identified timestamp for each period specified in the `periods` array (array). - The current bar's `source` value ("float"). - The symbol's description from `syminfo.description` ("string").
Biblioteca Pine Script™
por TradingView
Bitcoin DCA Strategy ( CICIL BITCOIN ) - Khilman AhmadiSTRATEGY INI, MENSIMULASIKAN UNTUK CICIL BITCOIN SECARA DAILY PADA SAAT MARKET OPEN DAILY , Kenapa tidak ada transaksi ? iyah karna disini kita hanya beli dan hold, jadi report summary nya bisa dilihat di tab- penguji strategi - kinerja,pada bagian hasil beli dan tahan - kita bisa melihat hasil berapa persen keuntungan / kerugian yg kita dapat. masukan rentang data yang bakal di backtest. usd per order masukan modal ( isi 1000000 usd ) tergantung berapa order masukan pyramid ( jumlah order bisa di isi 2000 ) - ini berarti 2000 hari ( dilebihin gpp )
Estratégia Pine Script™
por khilman22
Z Score BlackZ-score bbut with better looking black color imo Values are different because I choose source Open for original Z score and on my black one is source Closed. I don't know how to change that picture so you have to deal with it. I works exactly the same as original. All credit to original Creator: www.tradingview.com Link to original Z score: What Is Z-Score? Z-score is a statistical measurement that describes a value's relationship to the mean of a group of values. Z-score is measured in terms of standard deviations from the mean. If a Z-score is 0, it indicates that the data point's score is identical to the mean score. A Z-score of 1.0 would indicate a value that is one standard deviation from the mean. Z-scores may be positive or negative, with a positive value indicating the score is above the mean and a negative score indicating it is below the mean.
Indicador Pine Script™
por Smrkys
Global Liquidity Index (Lagged)"Global Liquidity Index (Lagged)" by aggregating data from various central banks and money supply sources. IT IS NOT A FOOLPROOF Index Central Bank Balance Sheets: FED (Federal Reserve System): request.security("USCBBS", "D", close, currency=currency.USD) Why Included: The Federal Reserve is the central bank of the United States, and its balance sheet directly reflects its monetary policy actions, such as quantitative easing (QE). Increases in the Fed's balance sheet generally indicate increased liquidity. Data Source: "USCBBS" likely refers to a TradingView symbol representing the Fed's balance sheet. TGA (Treasury General Account): request.security("WTREGEN", "D", close, currency=currency.USD) Why Included: The Treasury General Account is the U.S. Treasury's checking account at the Federal Reserve. Changes in the TGA affect the amount of reserves in the banking system. Increasing TGA, decreases liquidity. Data Source: "WTREGEN" is the tradingview ticker. RRP (Reverse Repurchase Agreements): request.security("RRPONTSYD", "D", close, currency=currency.USD) Why Included: Reverse repurchase agreements are used by the Fed to absorb excess liquidity from the financial system. Increases in RRP balances indicate a reduction in liquidity. Data Source: "RRPONTSYD" is the tradingview ticker. ECB (European Central Bank): request.security("EUCBBS * EURUSD", "D", close, currency=currency.USD) Why Included: The ECB is the central bank of the Eurozone, and its balance sheet reflects its monetary policy in the Eurozone. Data Source: "EUCBBS" likely represents the ECB's balance sheet, and EURUSD is used for currency conversion. PBC (People's Bank of China): request.security("CNCBBS * CNYUSD", "D", close, currency=currency.USD) Why Included: The PBC is the central bank of China, and its balance sheet reflects its monetary policy in the world's second-largest economy. Data Source: "CNCBBS" likely represents the PBC's balance sheet, and CNYUSD is used for currency conversion. BOJ (Bank of Japan): request.security("JPCBBS * JPYUSD", "D", close, currency=currency.USD) Why Included: The BOJ is the central bank of Japan, and its balance sheet reflects its monetary policy in a major developed economy. Data Source: "JPCBBS" likely represents the BOJ's balance sheet, and JPYUSD is used for currency conversion. Other Central Banks: The code includes data from various other central banks (e.g., Bank of England, Bank of Canada, Reserve Bank of Australia). Why Included: To capture a more comprehensive view of global liquidity. Data Source: TradingView symbols representing the respective central bank balance sheets, with currency conversions. Money Supply (M2): USA (USM2): request.security("ECONOMICS:USM2", "D", close, currency=currency.USD) Why Included: M2 is a measure of the money supply that includes cash, checking deposits, and other easily convertible assets. It provides insight into the amount of liquid funds available in the economy. Data Source: "ECONOMICS:USM2" is a TradingView symbol for the U.S. M2 money supply. Europe (EUM2), China (CNM2), Japan (JPM2), and Other Countries: The code includes M2 data from various other countries. Why Included: To capture a broader view of global money supply. Data Source: TradingView symbols representing the respective countries' M2 money supply, with currency conversions. Rationale for Inclusion: The goal of the index is to capture the overall amount of liquid funds available in the global financial system. Central bank balance sheets reflect the actions of central banks to inject or withdraw liquidity. Money supply figures reflect the amount of readily available funds in the economy. By combining these data sources, the index attempts to provide a more holistic view of global liquidity. Important Note : The accuracy of the index is limited by the availability and accuracy of the data provided by TradingView. Economic data is often released with a delay, so the index will always reflect past conditions. The weighting of the different data sources is simplistic, and a more sophisticated approach would be needed for a more accurate index.
Indicador Pine Script™
por Mgt289
Dashboard Table by KGHow It Works The script calculates the required indicators (RSI, Volatility, Volume Average, Momentum). It creates a table at the user-specified position with the specified text size. The table is populated with the indicator values, and conditional formatting is applied based on predefined conditions. The dashboard can be toggled on or off using the dashboard input. Customization Position: The user can choose where the table appears on the chart (e.g., Top-Left, Bottom-Right). Text Size: The user can adjust the text size for better readability. Indicators: The script can be extended to include additional indicators by modifying the calculations and adding more rows to the table. Example Use Case One can use this dashboard to quickly monitor key metrics like RSI, Volatility, Volume, and Momentum without cluttering the chart with multiple indicators. The conditional formatting helps identify bullish or bearish conditions at a glance.Do your own research along with other indicators.
Indicador Pine Script™
por kingshukghosh71
DataDoodles SD + ProbabilityDataDoodles SD + Probability Overview: The “DataDoodles SD + Probability” indicator is designed to provide traders with a statistical edge by leveraging standard deviation and probability metrics. This advanced tool calculates the annualized standard deviation, Z-score, and probability of price movements, offering insights into potential market direction with customizable alert thresholds. Key Features: 1. Annualized Standard Deviation (Volatility) Calculation: • Uses a user-defined period to compute the rolling standard deviation of daily returns. • Annualizes the volatility, giving a clear picture of expected price fluctuations. 2. Probability of Price Movement: • Calculates the probability of price moving up or down using a corrected Z-Score. • Displays the probability percentage for both upward and downward movements. 3. Dynamic Alerts: • Configurable alerts for upward and downward price movement probabilities. • Receive alerts when the probability exceeds user-defined thresholds. 4. Projections and Visuals: • Plots projected high and low price levels based on annualized volatility. • Displays Z-Score and probability metrics on the chart for quick reference. 5. Comprehensive Data Table: • Bottom-center table displays key metrics: • Daily Return • Standard Deviation (SD) • Annualized Standard Deviation (Yearly SD) User Inputs: • Annualization Period: Set the time frame for volatility annualization (Default: 252 days). • SD Period: Define the rolling window for calculating standard deviation (Default: 252 days). • Alert Probability Up/Down: Customize the probability thresholds for alerts (Default: 90%). How It Works: • Data Request and Calculation: • Uses daily close prices to ensure consistent timeframe calculations. • Calculates daily returns and annualizes the volatility using the square root of the time frame. • Probability Computation: • Employs a normal distribution CDF approximation to compute the probability of upward and downward price movements. • Adjusts probabilities based on Z-Score to ensure accuracy. • High and Low Projections: • Utilizes the annualized volatility to estimate high and low price projections for the year. • Visual Indicators and Alerts: • Plots projected high (green) and low (red) levels on the chart. • Displays Z-Score, probability percentages, and dynamically updates a statistics table. Use Cases: • Trend Analysis: Identify high-probability market movements using the probability metrics. • Volatility Insights: Understand annualized volatility to gauge market risk and potential price ranges. • Strategic Trading Decisions: Set alerts for high-probability scenarios to optimize entry and exit points. Why Use “DataDoodles SD + Probability”? This indicator provides a powerful combination of statistical analysis and visual representation. It empowers traders with: • Quantitative Edge: By leveraging probability metrics and standard deviation, users can make informed trading decisions. • Risk Management: Annualized volatility projections help in setting realistic stop-loss and take-profit levels. • Actionable Alerts: Customizable probability alerts ensure users are notified of potential market moves, allowing proactive trading strategies. Recommended Settings: • Annualization Period: 252 (Ideal for daily data representing a trading year) • SD Period: 252 (One trading year for consistent volatility calculations) • Alert Probability: Set to 90% for conservative signals or lower for more frequent alerts. Final Thoughts: The “DataDoodles SD + Probability” indicator is a robust tool for traders looking to integrate statistical analysis into their trading strategies. It combines volatility measurement, probability calculations, and dynamic alerts to provide a comprehensive market overview. Whether you’re a day trader or a long-term investor, this indicator can enhance your market insight and improve decision-making accuracy. Disclaimer: This indicator is a technical analysis tool designed for educational purposes. Past performance is not indicative of future results. Traders are encouraged to perform their own analysis and manage risk accordingly.
Indicador Pine Script™
por armthanathat
Kung Fu MA Hustle: The ADX & Choppiness ShowdownEver feel like your trading signals are as unpredictable as a kung fu comedy? "Kung Fu MA Hustle: The ADX & Choppiness Showdown" is here to bring some Shaolin style to your charts! This strategy unleashes a high-flying crossover when the 9-period SMA clashes with the 21-period SMA—but only if the market’s got the strength of an ADX over 20 and isn’t as choppy as a bad kung fu flick (Choppiness ≤ 50). With a humorous nod to the epic style of Stephen Chow, this strategy kicks false signals out of the ring and keeps your trades as sharp as a master’s roundhouse. Step into the dojo and let your trading do the kung fu!
Estratégia Pine Script™
por issacyinic
YZ_Altın_V4YZ Altın V4 – Güçlü RSI Analizi ile Piyasayı Yakalayın! Merhaba yatırımcılar! 🚀 YZ Altın V4 indikatörü, günlük ve haftalık RSI hesaplamalarını kullanarak piyasa yönünü analiz eden özel bir göstergedir. ✨ Öne Çıkan Özellikler: ✅ Günlük ve haftalık RSI hesaplamalarına dayalı sinyaller 📊 ✅ Özel formülle oluşturulmuş piyasa momentumu analizi Bu indikatörü kullanarak piyasa dinamiklerini daha iyi anlayabilir ve stratejinize değer katabilirsiniz! 🚀 Grafiğe ekleyin ve test edin! 📈💡 #TradingView #Forex #Altın #RSI #TeknikAnaliz #İndikatör
Indicador Pine Script™
por tezelmurat
TPO IQ [TradingIQ]Hello Traders! Introducing "TPO IQ"! TPO IQ offers a Time Price Opportunity profile with several customization options that packs several related features to help traders navigate the generated profiles! Features TPO Profiles Single Print identification Initial Balance Identification Can be anchored to timeframe change Can be anchored to fixed time interval Last profile detailed visuals Customizable value area percentage POC identification Mid-point identification TPO Profiles A TPO profile is a market profile visualization that details how much time was spent at each price level throughout the time interval. The image above further explains what a TPO Profile is! Each letter corresponds to a candlestick. With this information, traders are able to visualize how much time was spent at each price area. With customizable gradient colors, specifically in this example, blocks colored red are the earliest times in the profile, blocks colored green are in the beginning half of the time midpoint of the profile. Blue blocks represent the first half of the end of the time period, and purple blocks correspond to the end of the time period. Please note that this form of TPO profile generation will only occur when the most recent profile uses less than 500 alphabet characters! If more than 500 characters are preset, TPO IQ will revert to using labels! Initial Balance TPO IQ also identifies the initial balance range and all alphabet characters that form within it! The image above exemplifies this feature. The initial balance range is denoted by a a neon-blue line, with a blue circle showing the opening price. All characters within the initial balance range are highlighted blue, which is a feature that can be disabled with customizable colors. POC TPO IQ also identifies the point of control (POC) of the TPO Profile. The point of control for the profile is labeled yellow by default, and shows where price spent the most time throughout the time period. The image above shows the POC for the time period being identified by TPO IQ. Value Area TPO IQ also identifies the value area of the profile. A customizable percentage that is 70% by default, the value area of a TPO profile shows where price traded the majority of the time. The image above further explains this feature. For this example, with the value area percentage being set to 70%, the value area high and value area low show the price zone that prices traded at 70% of the time throughout the profile. TPO Midpoint In addition to the POC, the TPO profile midpoint is also identified by TPO IQ. The TPO midpoint simply corresponds to the middle price between the session's high and low! Fixed Interval Mode By default, TPO IQ recalculates every day, but this can also be changed to a customizable session time, such as 4 hours. If 4 hours is selected, then a new TPO profile will be generated every 4 hours. However, in Fixed Interval mode, a TPO profile will be generated through a user-defined time range, such as 1300-1700. In the image above, Fixed Interval mode is applied with a time range of 1300-1700 and, consequently, TPO IQ generates a new profile throughout every 1300-1700 time range! This feature allows traders to specify time ranges of interest to generate TPO profiles for! TPO Overview Label The TPO overview label shows key statistics for the TPO profile generated throughout the trading session! The "TPO Count" statistic shows how many alphabetical letters were generated for the profile, which is an adequate method to determine the session's volatility and price range. The "Tick Levels" statistic shows how many tick levels were used to create the profile - another method to determine the volatility and price range of the session. The "Top Letter" statistic shows which letter appears most throughout the profile. In this example, the top letter was "f", which means throughout creation of the profile, the letter "f" appeared the most! And that's all for now! If you have any feedback or new feature ideas for TPO IQ please feel free to share them with us! Thank you traders!
Indicador Pine Script™
por Trading-IQ
4
Enhanced Interval Candle with Breakout Detection and Detailed InThis indicator visualizes the last candle of a user-defined time interval (e.g., 1 hour, 4 hours, 1 day) on the current chart, providing enhanced details and breakout detection. It fetches the open, high, low, and close prices of the interval candle and draws a stylized representation of it, offset to the right of the current bar. The candle body and wicks are colored according to whether the interval candle closed bullishly (green) or bearishly (red). In addition to the candle itself, the indicator displays horizontal dotted lines representing the high, low, and midpoint of the interval candle, along with labels showing their exact values. These labels are dynamically updated as the interval candle changes. Furthermore, the script detects and visualizes breakouts of the interval candle's high or low. When the current price closes above the interval high, a green dashed line and a "Bullish Breakout" label are displayed. Conversely, when the current price closes below the interval low, a red dashed line and a "Bearish Breakout" label are shown. The breakout lines and labels are also dynamically updated. This indicator helps traders easily track the price action of a higher timeframe candle and spot potential breakouts based on that candle's range. The user can configure the time interval to suit their trading needs.
Indicador Pine Script™
por nextor_j_d