Order Blocks Screener | Flux Charts💎 GENERAL OVERVIEW
Introducing our new Order Blocks Screener! This screener can provide information about the latest order blocks in up to 5 tickers. You can also customize the algorithm that finds the order blocks and the styling of the screener.
Features of the new Order Blocks Screener :
Find Latest Order Blocks Accross 5 Tickers
Latest Status, Restests, Bullish & Bearish Volume
Customizable Algoritm / Styling
📌 HOW DOES IT WORK ?
Order blocks occur when there is a high amount of market orders exist on a price range. It is possible to find order blocks using specific formations on the chart.
The high & low volume of order blocks should be taken into consideration while determining their strengths. The determination of the high & low volume of order blocks are similar to FVGs, in a bullish order block, the high volume is the last 2 bars' total volume, while the low volume is the oldest bar's volume. In a bearish order block scenerio, the low volume becomes the last 2 bars' total volume.
This screener then finds order blocks accross 5 different tickers, and shows the latest information about them.
Status ->
Far -> The current price is far away from the order block.
Approaching ⬆️/⬇️ -> The current price is approaching the order block, and the direction it's approaching from.
Inside -> The price is currently inside the order block.
Retests -> Retest means the price to invalidate the order block, but failed to do so. Here you can see how many times the price retested the order block.
For the bullish / bearish volume, check the "How Does It Work" section.
🚩UNIQUENESS
This screener can detect latest order blocks and give information about them for up to 5 tickers. This saves the user time by showing them all in a dashboard at the same time. The screener shows the number of the retests of the order block as an unique trait. Another unique ability of the screener is that it shows the latest valid order block's bullish and bearish volume in the dashboard.
⚙️SETTINGS
1. Tickers
You can set up to 5 tickers for the screener to scan order blocks here. You can also enable / disable them and set their individual timeframes.
2. General Configuration
Zone Invalidation -> Select between Wick & Close price for Order Block Invalidation.
Swing Length -> Swing length is used when finding order block formations. Smaller values will result in finding smaller order blocks.
Cerca negli script per "文华财经tick价格"
MOST + Moving Average ScreenerScreener version of Anıl Özekşi's Moving Stop Loss (MOST) Indicator:
USERS MAY SCREEN MOST WITH 11 DIFFERENT TYPES OF MOVING AVERAGES + THEY CAN ALSO SCREEN SIGNALS WITH THAT 11 MOVING AVERAGES INSTEAD OF USING MOST LINE.
Adjustable Moving Average Types:
SMA : Simple Moving Average
EMA : Exponential Moving Average
WMA : Weighted Moving Average
DEMA : Double Exponential Moving Average
TMA : Triangular Moving Average
VAR : Variable Index Dynamic Moving Average aka VIDYA
WWMA : Welles Wilder's Moving Average
ZLEMA : Zero Lag Exponential Moving Average
TSF : True Strength Force
HULL : Hull Moving Average
TILL : Tillson T3 Moving Average
About Screener Panel:
Users can explore 20 different and user-defined tickers, which can be changed from the SETTINGS (shares, crypto, commodities...) on this screener version.
The screener panel shows up right after the bars on the right side of the chart.
-In this screener version of MOST, users can define the number of demanded tickers (symbols) from 1 to 20 by checking the relevant boxes on the settings tab.
-All selected tickers can be screened in different timeframes.
-Also, different timeframes of the same Ticker can be screened.
IMPORTANT NOTICE:
Screener shows the results in 3 different logic:
1st LOGIC (Default Settings):
BUY AND SELL SIGNALS of MOST and MOVING AVERAGE LINE
Most Buy Signal: Moving Average Crosses ABOVE the MOST LINE
Most Sel Signal: Moving Average Crosses BELOW the MOST LINE
Tickers seen in green are the ones that are in an uptrend, according to MOST.
The ones that appear in red are those in the SELL signal, in a downtrend.
The numbers before each Ticker indicate how many bars passed after MOST's last BUY or SELL signal.
For example, according to the indicator, when BTCUSDT appears (3) in GREEN, Bitcoin switched to a BUY signal 3 bars ago.
2nd LOGIC (Moving Average & Price Flips Screener Mode):
This mode can only be activated by checking the 'Activate Moving Average Screening Mode' box on the settings menu.
MOST line will be disappeared after checking the box.
Buy Signal: When the Selected Price crosses ABOVE the selected Moving Average.
Sell Signal: When the Selected Price crosses BELOW the selected Moving Average.
Tickers seen in green are the ones that are in an uptrend, according to Moving Average & Price Flips.
The ones that appear in red are those in the SELL signal, in a downtrend.
The numbers before each Ticker indicate how many bars passed after the last BUY or SELL signal of Moving Average & Price Flips.
For example, according to the indicator, when BTCUSDT appears (3) in GREEN, Bitcoin switched to a BUY signal 3 bars ago.
3rd LOGIC (Moving Average Color Change Screener Mode):
Both 'Activate Moving Average Screening Mode' and 'Activate Moving Average Color Change Screening Mode' boxes must be checked in the settings tab.
Moving Average Line will turn out into two colors.
Green color means the moving average value is greater than the previous bar's value.
Red color means the moving average value is smaller than the previous bar's value.
Buy Signal: After the Selected Moving Average turns GREEN from red.
Sell Signal: After the Selected Moving Average turns RED from green.
-Screener shows the information about the color changes of the selected Moving Average with default settings.
If this option is preferred, users are advised to enlarge the length to have better signals.
Tickers seen in green are the ones that are in an uptrend, according to Moving Average Color.
The ones that appear in red are those in the SELL signal, in a downtrend.
The numbers before each Ticker indicate how many bars passed after the last BUY or SELL signal of Moving Average Color Change.
For example, according to the indicator, when BTCUSDT appears (3) in GREEN, Bitcoin switched to a BUY signal 3 bars ago.
SL and TP - ATRThis indicator is using ATR ( Average True Range ) to set the Target point and Stop loss.
Use the pink number as target, always.
If you are in Long position, use the green number as stop loss, so the red number is not useful in Buys.
If you are in Short position, use the Red number as stop loss, so the green number is not useful in Sells.
** Need to enter the numbers in ticks --> VERY IMPORTANT: Write it completely, even the numbers after the point sign but DO NOT WRITE the point sign itself. e.g. : if the target tick on indicator is 123.75, you have to write 12375 ticks for your TP. ( one more example: If the number is 0.0001203 , write 1203 ticks. )
Enter the information of the opening candle.
Most of the times, risk/reward ratio is a bit higher than 1.
Works on multi timeframes. P.S: Haven't checked the weekly timeframe.
Not trying to oversell the indicator, but this is perhaps the best TP/SL specifier.
For beauty purposes, change (Sl @ buy) and (TP @ sell) to histograms.
Histograms are only for visual purposes. Customize the indicator as you want :)) Hope you enjoy
Bitmex BTC Perpetual PremiumThis script tracks the premium of the Bitcoin Perpetual futures at Bimex exchange relative to 3 different reference prices.
The difference between this script and already published scripts is that it tracks the premium relative to 3 different reference prices. This tends to produce slightly different results.
This script is also open source, so you can verify the calculations, or use it as a basis for your own script.
The 3 plots uses the following reference prices:
Blue Area:
Bitmex Index price, ticker: BITMEX:XBT
Red line:
Bitmex Perpetual Premium, ticker XBTUSDPI
(This one is not used as reference, but simply plots the ticker*100)
Orange line:
The reference here is a price calculated by the tickers in trading view based on the Bitmex indices with weighing as follows:
Bitstamp:28,81%
Bittrex:5,5%
Coinbase: 38,07%
Gemini: 7,34%
Kraken: 20,28
Please note that Bitmex changes the bases of its indices regularly. Bitmex might also "rule out" on of these exchanges if there is a short term problem.
Linh's Anomaly Radar v2What this script does
It’s an event detector for price/volume anomalies that often precede or confirm moves.
It watches a bunch of patterns (Wyckoff tests, squeezes, failed breakouts, turnover bursts, etc.), applies robust z-scores, optional trend filters, cooldowns (to avoid spam), and then fires:
A shape/label on the bar,
A row in the mini panel (top-right),
A ready-made alertcondition you can hook into.
How to add & set up (TradingView)
Paste the script → Save → Add to chart on Daily first (works on any TF).
Open Settings → Inputs:
General
• Use Robust Z (MAD): more outlier-resistant; keep on.
• Z Lookback: 60 bars is ~3 months; bump to 120 for slower regimes.
• Cooldown: min bars to wait before the same signal can fire again (default 5).
• Use trend filter: if on, “bullish” signals only fire above SMA(tfLen), “bearish” below.
Thresholds: fine-tune sensitivity (defaults are sane).
To create alerts: Right-click chart → Add alert
Condition: Linh’s Anomaly Radar v2 → choose a specific signal or Composite (Σ).
Options: “Once per bar close” (recommended).
Customize message if you want ticker/timeframe in your phone push.
The mini panel (top-right)
Signal column: short code (see cheat sheet below).
Fired column: a dot “•” means that on the latest bar this signal fired.
Score (right column): total count of signals that fired this bar.
Σ≥N shows your composite threshold (how many must fire to trigger the “Composite” alert).
Shapes & codes (what’s what)
Code Name (category) What it’s looking for Why it matters
STL Stealth Volume z(volume)>5 & ** z(return)
EVR Effort vs Result squeeze z(vol)>3 & z(TR)<−0.5 Heavy effort, tiny spread → absorption
TGV Tight+Heavy (HL/ATR)<0.6 & z(vol)>3 Tight bar + heavy tape → pro activity
CLS Accumulation cluster ≥3 of last 5 bars: up, vol↑, close near high Classic accumulation footprint
GAP Open drive failure Big gap not filled (≥80%) & vol↑ One-sided open stalls → fade risk
BB↑ BB squeeze breakout Squeeze (z(BBWidth)<−1.3) → close > upperBB & vol↑ Regime shift with confirmation
ER↑ Effort→Result inversion Down day on vol then next bar > prior high Demand overwhelms supply
OBV OBV divergence OBV slope up & ** z(ret20)
WER Wide Effort, Opposite Result z(vol)>3, close+1 Selling into strength / distribution
NS No-Supply (Wyckoff) Down bar, HL<0.6·ATR, vol << avg Sellers absent into weakness
ND No-Demand (Wyckoff) Up bar, HL<0.6·ATR, vol << avg Buyers absent into strength
VAC Liquidity Vacuum z(vol)<−1.5 & ** z(ret)
UTD UTAD (failed breakout) Breaks swing-high, closes back below, vol↑ Stop-run, reversal risk
SPR Spring (failed breakdown) Breaks swing-low, closes back above, vol↑ Bear trap, reversal risk
PIV Pocket Pivot Up bar; vol > max down-vol in lookback Quiet base → sudden demand
NR7 Narrow Range 7 + Vol HL is 7-bar low & z(vol)>2 Coiled spring with participation
52W 52-wk breakout quality New 52-wk close high + squeeze + vol↑ High-quality breakouts
VvK Vol-of-Vol kink z(ATR20,200)>0.5 & z(ATR5,60)<0 Long-vol wakes up, short-vol compresses
TAC Turnover acceleration SMA3 vol / SMA20 vol > 1.8 & muted return Participation surging before move
RBd RSI Bullish div Price LL, RSI HL, vol z>1 Exhaustion of sellers
RS↑ RSI Bearish div Price HH, RSI LH, vol z>1 Exhaustion of buyers
Σ Composite Count of all fired signals ≥ threshold High-conviction bar
Placement:
Triangles up (below bar) → bullish-leaning events.
Triangles down (above bar) → bearish-leaning events.
Circles → neutral context (VAC, VvK, Composite).
Key inputs (quick reference)
General
Use Robust Z (MAD): keep on for noisy tickers.
Z Lookback (lenZ): 60 default; 120 if you want fewer alerts.
Trend filter: when on, bullish signals require close > SMA(tfLen), bearish require <.
Cooldown: prevents repeated firing of the same signal within N bars.
Phase-1 thresholds (core)
Stealth: vol z > 5, |ret z| < 1.
EVR: vol z > 3, TR z < −0.5.
Tight+Heavy: (HL/ATR) < 0.6, vol z > 3.
Cluster: window=5, min=3 strong bars.
GapFail: gap/ATR ≥1.5, fill <80%, vol z > 2.
BB Squeeze: z(BBWidth)<−1.3 then breakout with vol z > 2.
Eff→Res Up: prev bar heavy down → current bar > prior high.
OBV Div: OBV uptrend + |z(ret20)|<0.3.
Phase-2 thresholds (extras)
WER: vol z > 3, close1.
No-Supply/No-Demand: tight bar & very light volume vs SMA20.
Vacuum: vol z < −1.5, |ret z|>1.5.
UTAD/Spring: swing lookback N (default 20), vol z > 2.
Pocket Pivot: lookback for prior down-vol max (default 10).
NR7: 7-bar narrowest range + vol z > 2.
52W Quality: new 52-wk high + squeeze + vol z > 2.
VoV Kink: z(ATR20,200)>0.5 AND z(ATR5,60)<0.
Turnover Accel: SMA3/SMA20 > 1.8 and |ret z|<1.
RSI Divergences: compare to n bars back (default 14).
How to use it (playbooks)
A) Daily scan workflow
Run on Daily for your VN watchlist.
Turn Composite (Σ) alert on with Σ≥2 or ≥3 to reduce noise.
When a bar fires Σ (or a fav combo like STL + BB↑), drop to 60-min to time entries.
B) Breakout quality check
Look for 52W together with BB↑, TAC, and OBV.
If WER/ND appear near highs → downgrade the breakout.
C) Spring/UTAD reversals
If SPR fires near major support and RBd confirms → long bias with stop below spring low.
If UTD + WER/RS↑ near resistance → short/fade with stop above UTAD high.
D) Accumulation basing
During bases, you want CLS, OBV, TGV, STL, NR7.
A pocket pivot (PIV) can be your early add; manage risk below base lows.
Tuning tips
Too many signals? Raise stealthVolZ to 5.5–6, evrVolZ to 3.5, use Σ≥3.
Fast movers? Lower bbwZthr to −1.0 (less strict squeeze), keep trend filter on.
Illiquid tickers? Keep MAD z-scores on, increase lookbacks (e.g., lenZ=120).
Limitations & good habits
First lenZ bars on a new symbol are less reliable (incomplete z-window).
Some ideas (VWAP magnet, close auction spikes, ETF/foreign flows, options skew) need intraday/external feeds — not included here.
Pine can’t “screen” across the whole market; set alerts or cycle your watchlist.
Quick troubleshooting
Compilation errors: make sure you’re on Pine v6; don’t nest functions in if blocks; each var int must be declared on its own line.
No shapes firing: check trend filter (maybe price is below SMA and you’re waiting for bullish signals), and verify thresholds aren’t too strict.
Blue Ocean BOATS 24/5 US Market DataThis script utilizes Blue Ocean's ATS (Alternative Trading System) and U.S. exchange market data to create a continuous candlestick chart. The continuous data has the option to be used as an indicator or strategy source.
Requirements
The main chart symbol (which can be unrelated to the user-input Ticker Symbol) needs to be a 24/7 chart. An example symbol is CRYPTO:BTCUSD. CME_MINI:ES1! and FX:SPX500 work too, but are not truly 24/5 and will miss ~4 hours of the total trading week from the extended U.S. session.
The main chart's timeframe needs to be intraday. Because the script's output is currently inconsistent on daily or higher timeframes, it will disable itself.
The Ticker Symbol chosen should be a ticker that is traded on U.S. exchanges. This will provide both U.S. extended session data and a BOATS equivalent.
Usage & configuration
This script visualizes the 24-hour Monday-Friday chart of a U.S. exchange ticker. Going a step further, it can be used to compare the performance indices or cryptocurrencies to stock constituents of indices, cryptocurrency treasury stocks or holding ETFs.
The script's output, candlesticks, can be overlaid on the main chart or used as is. A "Price Source" plot is used for indicators or strategies.
Ticker Symbol: The U.S. ticker you'd like to view extended session and Blue Ocean ATS session data for.
Price Source: Price source that can be used for indicators or strategies.
Highlight Sessions: Highlight the different trading sessions.
Last Price Line: Show a horizontal line at the last traded price.
Ticker Symbol Check: Plots a label that will display only if the selected Ticker Symbol is not detected as a U.S. exchange traded ticker.
Earnings Label: Creates a label at the time of past earnings of the chosen Ticker Symbol. The time that the earnings are plotted is approximate. Because of this, the label is meant as an explanation for price action.
What this script does and how it works
It creates OHLC candlesticks by merging Blue Ocean's ATS market data and U.S. exchange data. From the OHLC data of both, a single output can be used for indicators or strategies.
References and further information
www.tradingview.com
The Blue Ocean ATS allows trading from 20:00 to 4:00 Eastern Time, Sunday through Thursday. This critical timeframe bridges the eight-hour overnight gap when major U.S. exchanges are closed.
blueocean-tech.io
Blue Ocean ATS, LLC is a US broker dealer which operates the alternative trading system BOATS. Our trading platform offers electronic access, price discovery, compliant regulatory reporting requirements, and standard clearing and settlement processes.
www.nyse.com
Hours mentioned are in Eastern Time.
Overnight trading remains far less active than extended hours trading. The hour with the highest overnight volume is 9:00PM, which averages 2.94 million shares per day and coincides with several Asian market opens. This volume is a fraction of the last hour of extended hours trading, which averages 43.22 million shares. The first hour of pre-core reported volume averages 113.30 million shares per day.
Overnight executions, in addition to the peak in the 9:00PM hour, also exhibits a smaller peak at 3:00AM, of 2.35 million shares. This coincides with several Asian bourses’ end of their regular trading day.
Example of using the script in the main chart window and the difference in how RSI may be calculated.
Note: ATS is not the name of the 20:00 to 4:00 ET session itself, and the term refers to a broader definition of trading systems that include dark pools, which can be different.
24/5 Monday-Friday really means NY time Sunday night to Friday afternoon.
Nasdaq Risk Calculator - DTFXNasdaq Risk Calculator
This Pine Script (v5) indicator provides a dashboard-style tool for calculating trading risk based on manually input tick measurements for Nasdaq futures contracts (NQ and MNQ). Designed as an overlay on the main chart, it displays key risk metrics in a fixed-position table, allowing traders to assess contract type, lot size, risk ticks, and actual risk in dollars relative to a user-defined risk amount.
Features:
Manual Tick Input: Enter the number of ticks (e.g., from a ruler measurement) to define the price range for risk calculation.
Risk Calculation: Computes the optimal contract (NQ or MNQ), number of lots, risk ticks (half the input range), and actual risk in dollars, targeting the specified risk amount (default: $100).
Customizable Dashboard: Displays results in a single-cell table with a semi-transparent white background and gray border, positioned in one of four chart corners (Top Left, Top Right, Bottom Left, Bottom Right) via user selection.
Reset Option: Includes a toggle to clear the dashboard and start anew.
How to Use:
Add the indicator to your chart (best suited for NQ or MNQ futures).
In the settings, input your "Risk Amount ($)" and "Ticks" (e.g., 400 for a 100-point range on NQ).
Select the "Dashboard Corner" to position the table.
View the calculated risk details in the chosen corner.
Adjust inputs or reset as needed.
Notes:
NQ tick value is $5.00 (NQ_MULTIPLIER = 5.0), and MNQ tick value is $0.50 (MNQ_MULTIPLIER = 0.5).
Ideal for traders planning risk based on measured price ranges, such as support/resistance zones.
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").
KNN ATR Dual Range Predictions [SS]Excited to release this indicator!
I wanted to do a machine learning, ATR based indicator for a while, but I first had to learn about machine learning algos haha.
Now that I have created a KNN based regression methodology (shared in a previous indicator), I can finally do it!
So this is a Nearest Known Neighbor or KNN regression based indicator that uses ATR (average ranges) to predict future ranges.
It operates by calculating the move from High to Open and Open to Low and performing KNN regression to look for other, similar instances of similar movements and what followed those movements.
It provides for 2 methods of KNN regression, the traditional Cluster method (where it identifies a number of clusters within a tolerance range and averages them out), or the method of last instance (where it finds the most recent identical instance and plots the result from that).
You can toggle the parameters as you wish, including the:
a) Type of Regression
b) Number of Clusters
c) Tolerance for Clusters
Others functions:
The indicator provides for the ability to view 2 different timeframe targets. The default calculation is the current timeframe you are on. So if you are on the 1 minute, 5 minute or 1 hour, it will automatically default the primary range to this timeframe. This cannot be changed.
But it permits for a second prediction to be calculated for a timeframe you can specify. The example in the chart above is the 1 hour overlaid on the 5 minute chart.
You can see how the model is performing in the statistics table. The statistics table can be removed as well if you don't want it overlaid on your chart.
You can also toggle off and on the various ranges. IF you only want to visualize 1 hour levels on a 5 minute chart, you can toggle off the bands and just view the higher tf data. Inversely, if you only want the current timeframe data and not the higher tf data, you can toggle the higher tf data off as well.
General Use Tips:
Some general use tips include:
🎯The default settings are appropriate for most common tickers. Because this is performing an autoregression on itself, the parameters tend to be more tight vs. performing dual correlation between two separate tickers which are sizably different in scale (which would require a higher tolerance).
Here is an example of YM1!, which is a sizably larger ticker, however it is performing well with the current settings.
🎯 If you get not great results from your ranges or an error in the correlation table, something like this:
It means the parameters are too tight for what you want to do and it is having trouble identifying other, similar cases (in this case, the lookback length was significantly shortened). The first step is to:
a) Expand your lookback range (up to 500 is usually sufficient). This should resolve most issues in most cases. If not:
b) If you are using the Cluster method, try broadening your cluster tolerance by 0.5 increments.
Between those two implementations, you should get a functional model. And it actually honestly hasn't happened to me in general use, I had to force that example by significantly shortening the lookback period.
Concluding Remarks
And that's pretty much the indicator.
I hope you enjoy it! I was really excited to be finally able to do it, like I said I attempted to do this for a while but needed to research the whole KNN process and how its performed.
Enjoy and leave your comments and questions below!
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.
Market Sector Scanner/Screener With MOM + RSI + MFI + DMI + MACDMARKET SECTOR SCANNER/SCREENER MOM + RSI + MFI + DMI + MACD FOR STOCKS CRYPTO & FOREX
This script scans 9 markets constantly and returns the values of 5 different popular indicators.
This indicator helps you see when one of your favorite stocks is bullish or bearish when you are not watching that chart so you can always catch the big moves as they happen.
***HOW TO USE***
A great way to use this market screener is to set up separate chart layouts for each sector you like to trade. Such as the top 9 stocks in the S & P 500, top 9 stocks in the XLF etf, etc. Make sure to set up separate chart layouts in Tradingview so you don’t have to change the symbols constantly. This will give you a good idea in real time if that entire sector is bullish, bearish or mixed. When the entire grid goes red or green, those are very strong signs of market direction across that entire sector, so trades in the corresponding direction are quite safe.
This can be done for crypto as well, using the top 9 cryptocurrencies by market cap. Watch the grid and wait for the entire lot to turn green or red and then take a position in that direction.
You can also use this with a variety of your favorite tickers so you can see when specific markets are looking strong in either direction, instead of constantly changing charts or missing good opportunities because you weren’t watching that specific chart.
This grid can also be used to determine how long to hold a position as well. If the entire grid is still green or red, according to your trade direction, you can usually expect price to continue in that direction until you see some conflicting colors start to pop up on the grid. As it starts to give mixed signals, you can expect the market to be indecisive or reverse which is a good time to get out.
If you have your scanner setup to show similar markets in one sector, be careful taking trades when the grid is very mixed in color. This shows signs of indecision and will likely have choppy price action until the market decides a direction so make sure to use caution when the grid is mixed. It is best to wait for the entire grid to turn green or red and then take position.
***COLOR MEANINGS***
When each indicator value is in bullish territory, the background of that value will turn green.
When each indicator value is in bearish territory, the background of that value will turn red.
When each indicator value is in neutral territory, the background of that value will turn blue.
When all 5 indicators for a ticker are bullish, the ticker background will turn green.
When all 5 indicators for a ticker are bearish, the ticker background will turn red.
When there is a mixture of bullish and bearish values, the ticker background will turn blue.
***CUSTOMIZATION***
You can customize which tickers are in your scanner including stocks, crypto, futures and forex, the source of the indicators, the length of the indicator settings and the smoothing parameters.
***INDICATORS USED***
The indicators used for each ticker are as follows:
Momentum(MOM) - Default length is 14. Bullish is above zero, bearish is below zero.
Relative Strength Index(RSI) - Default length is 14. Bullish is above 50, bearish is below 50.
Money Flow Index(MFI) - Default length is 14. Bullish is above 50, bearish is below 50.
Directional Movement Index(DMI) - Default length is 14 and smoothing is 14. Calculated by subtracting di minus from di plus. If the value is positive, it is bullish. If the value is negative, it is bearish.
Moving Average Convergence & Divergence(MACD) - Default settings are 12, 26, 9. If the short line is greater than the long line, then it is bullish. If the short line is less than the long line, it is bearish.
***MARKETS***
This market scanner can be used as a signal on all markets, including stocks, crypto, futures and forex.
***TIMEFRAMES***
This scanner can be used on all timeframes and pulls data from other tickers using the same timeframe as what your current chart is set to.
***TIPS***
Try using numerous indicators of ours on your chart so you can instantly see the bullish or bearish trend of multiple indicators in real time without having to analyze the data. Some of our favorites are Trend Friend Scalp & Swing Signals, Auto Fibonacci, Directional Movement Index, Volume Profile With Buy/Sell Pressure, Auto Support And Resistance and Money Flow Index in combination with this Scanner. They all have real time Bullish and Bearish labels as well so you can immediately understand each indicator's trend.
Template Trailing Strategy (Backtester)💭 Overview
💢 What is the "Template Trailing Strategy” ❓
The "Template Trailing Strategy" (TTS) is a back-tester orchestration framework. It supercharges the implementation-test-evaluation lifecycle of new trading strategies, by making it possible to plug in your own trading idea.
While TTS offers a vast number of configuration settings, it primarily allows the trader to:
Test and evaluate your own trading logic that is described in terms of entry, exit, and cancellation conditions.
Define the entry and exit order types as well as their target prices when the limit, stop, or stop-limit order types are used.
Utilize a variety of options regarding the placement of the stop-loss and take-profit target(s) prices and support for well-known techniques like moving to breakeven and trailing.
Provide well-known quantity calculation methods to properly handle risk management and easily evaluate trading strategies and compare them.
Alert on each trading event or any related change through a robust and fully customizable messaging system.
All the above, build a robust tool that, once learned, significant and repetitive work that strategy developers often implement individually on every strategy script is eliminated. Taking advantage of TradingView’s built-in backtesting engine the evaluation of the trading ideas feels natural.
By utilizing the TTS one can easily swap “trading logic” by testing, evaluating, and comparing each trading idea and/or individual component of a strategy.
Finally, TTS, through its per-event alert management (and debugging) system, provides a fully automated solution that supports automated trading with real brokers via webhooks.
NOTE: The “Template Trailing Strategy” does not dictate the way you can combine different (types of) indicators or how you should combine them. Thus, it should not be confused as a “Trading System”, because it gives its user full flexibility on that end (for better or worse).
💢 What is a “Signal Indicator” ❓
“Signal Indicator” (SI) is an indicator that can output a “signal” that follows a specific convention so that the “Template Trailing Strategy” can “understand” and execute the orders accordingly. The SI realizes the core trading logic signaling to the TTS when to enter, exit, or cancel an order. A SI instructs the TTS “when” to enter or exit, and the TTS determines “how” to enter and exit the position once the Signal Indicator generates a signal.
A very simple example of a Signal Indicator might be a 200-day Simple Moving Average Signal. When the price of the security closes above the 200-day SMA, a SI would provide TTS with a “long entry signal”. Once TTS receives the “long entry signal”, the TTS will open a long position and send an alert or automated trade message via webhook to a broker, based on the Entry settings defined in TTS. If the TTS Entry settings specify a “Market” order type, then the open long position will be executed by TTS immediately. But if the TTS Entry settings specify a “Stop” order type with a 1% Stop Distance, then when the price of the security rises by 1% after the “long entry signal” occurs, the TTS will open a long position and the Long Entry alert or webhook to the broker will be sent.
🤔 How to Guide
💢 How to connect a “signal” from a “Signal Indicator” ❓
The “Template Trailing Strategy” was designed to receive external signals from a “Signal Indicator”. In this way, a “new trading idea” can be developed, configured, and evaluated separately from the TTS. Similarly, the SI can be held constant, and the trading mechanics can change in the TTS settings and back-tested to answer questions such as, “Am I better with a different stop loss placement method, what if I used a limit order instead of a stop order to enter, what if I used 25% margin instead of trading spot market?”
To make that possible by connecting an external signal indicator to TTS, you should:
Add in the same chart, the “Signal Indicator” of your choice (e.g. “Two MA Signal Indicator” , “Click Signal Indicator” , “Signal Adapter” , “Signal Composer” ) and the “Template Trailing Strategy”.
Go to the “Settings/Inputs” tab in the “🛠️ STRATEGY” group of the TTS and change the "𝐃𝐞𝐚𝐥 𝐂𝐨𝐧𝐝𝐢𝐭𝐢𝐨𝐧𝐬 𝐌𝐨𝐝𝐞" to “🔨External”
Go to the “🔨 STRATEGY – EXTERNAL” group settings of the TTS and change the “🔌𝐒𝐢𝐠𝐧𝐚𝐥 🛈➡” to the output signal of the “Signal Indicator” you want to connect. The selected combo box option should look like “:🔌Signal to TTS” where should correspond to the short title of your “Signal Indicator”
💢 How to create a Custom Trading logic ❓
The “Template Trailing Strategy” provides two ways to plug in your custom trading logic. Both of them have their advantages and disadvantages.
✍️ Develop your own Customized “Signal Indicator” 💥
The first approach is meant to be used for relatively more complex trading logic. The advantages of this approach are the full control and customization you have over the trading logic and the relatively simple configuration setup by having two scripts only. The downsides are that you have to have some experience with pinescript or you are willing to learn and experiment. You should also know the exact formula for every indicator you will use since you have to write it by yourself. Copy-pasting from existing open-source indicators will get you started quite fast though.
The idea here is either to create a new indicator script from scratch or to copy an existing non-signal indicator and make it a “Signal Indicator”. To create a new script, press the “Pine Editor” button below the chart to open the “Pine Editor” and then press the “Open” button to open the drop-down menu with the templates. Select the “New Indicator” option. Add it to your chart to copy an existing indicator and press the source code {} button. Its source code will be shown in the “Pine Editor” with a warning on top stating that this is a read-only script. Press the “create a working copy”. Now you can give a descriptive title and a short title to your script, and you can work on (or copy-paste) the (other) indicators of your interest. Having all the information needed to make your decision the only thing you should do is define a DealConditions object and plot it like this:
import jason5480/tts_convention/4 as conv
// Calculate the start, end, cancel start, cancel end conditions
dealConditions = conv.DealConditions.new(
startLongDeal = ,
startShortDeal = ,
endLongDeal = ,
endShortDeal = ,
cnlStartLongDeal = ,
cnlStartShortDeal = ,
cnlEndLongDeal = ,
cnlEndShortDeal = )
// Use this signal in scripts like "Template Trailing Strategy" and "Signal Composer" that can use its value
// Emit the current signal value according to the "two channels mod div" convention
plot(series = conv.getSignal(dealConditions), title = '🔌Signal to TTS', color = color.olive, display = display.data_window + display.status_line, precision = 0)
You should write your deal conditions appropriately based on your trading logic and put them in the code section shown above by replacing the “…” part after “=”. You can omit the conditions that are not relevant to your logic. For example, if you use only market orders for entering and exiting your positions the cnlStartLongDeal, cnlStartShortDeal, cnlEndLongDeal, and cnlEndShortDeal are irrelevant to your case and can be safely omitted from the DealConditions object. After successfully compiling your new custom SI script add it to the same chart with the TTS by pressing the “Add to chart” button. If all goes well, you will be able to connect your “signal” to the TTS as described in the “How to connect a “signal” from a “Signal Indicator”?” guide.
🧩 Adapt and Combine existing non-signal indicators 💥
The second approach is meant to be used for relatively simple trading logic. The advantages of this approach are the lack of pine script and coding experience needed and the fact that it can be used with closed-source indicators as long as the decision-making part is displayed as a line in the chart. The drawback is that you have to have a subscription that supports the “indicator on indicator” feature so you can connect the output of one indicator as an input to another indicator. Please check if your plan supports that feature here
To plug in your own logic that way you have to add your indicator(s) of preference in the chart and then add the “Signal Adapter” script in the same chart as well. This script is a “Signal Indicator” that can be used as a proxy to define your custom logic in the CONDITIONS group of the “Settings/Inputs” tab after defining your inputs from your preferred indicators in the VARIABLES group. Then a “signal” will be produced, if your logic is simple enough it can be directly connected to the TTS that is also added to the same chart for execution. Check the “How to connect a “signal” from a “Signal Indicator”?” in the “🤔 How to Guide“ for more information.
If your logic is slightly more complicated, you can add a second “Signal Adapter” in your chart. Then you should add the “Signal Composer” in the same chart, go to the SIGNALS group of the “Settings/Inputs” tab, and connect the “signals” from the “Signal Adapters”. “Signal Composer” is also a SI so its composed “signal” can be connected to the TTS the same way it is described in the “How to connect a “signal” from a “Signal Indicator”?” guide.
At this point, due to the composability of the framework, you can add an arbitrary number (bounded by your subscription of course) of “Signal Adapters” and “Signal Composers” before connecting the final “signal” to the TTS.
💢 How to set up ⏰Alerts ❓
The “Template Trailing Strategy” provides a fully customizable per-even alert mechanism. This means that you may have an entirely different message for entering and exiting into a position, hitting a stop-loss or a take-profit target, changing trailing targets, etc. There are no restrictions, and this gives you great flexibility.
First of all, you have to enable the alerts of the events that interest you. Go to the “🔔 ALERT MESSAGES” module of the TTS settings and check the “Enable…” checkbox of the events you are interested in. For each specific event, you will find a text area where you can type the exact message you want to receive when the event occurs. What’s more, there are placeholders you can use that will be replaced by the TTS with the actual values before the message is sent. The placeholder categories are the following and the placeholder names are self-explanatory.
Chart info: {{ticker}}, {{base_currency}}, {{quote_currency}}
Quantities and percentages: {{base_quantity}}, {{quote_quantity}}, {{quote_quantity_perc}},
{{take_profit_base_quantity}}, {{remaining_quantity_perc}}, {{remaining_base_quantity}}, {{risk_perc}}
Target prices: {{stop_loss_price}}, {{entry_price}}, {{entry+_price}}, {{entry-_price}},
{{exit_price}}, {{exit+_price}}, {{exit-_price}}, {{take_profit_price_1}},
{{take_profit_price_2}}, {{take_profit_price_3}}, {{take_profit_price_4}}, {{take_profit_price_5}}
❗ To get the message on the other side you have to set a strategy alert as described here and use the {{strategy.order.alert_message}} placeholder as text in the “Message Box” that contains the message that came from the TTS.
💢 How to execute my orders in a broker ❓
To execute your orders in a broker that supports webhook integration, you should enable the appropriate alerts in the “Template Trailing Strategy” first (see the “How to set up Alerts?” guide above). Then you should go to the “Create Alert/Notifications” tab check the “Webhook URL” and paste the URL provided by your broker. You have to read the documentation of your broker for more information on what messages are expected.
Keep in mind that some brokers have deep integration with TradingView so a per-event alert approach might be overkill.
📑 Definitions
This section tries to give some definitions in terms that appear in the “Settings/Inputs" tab of the “Template Trailing Strategy”
💢 What is Trailing ❓
Trailing is a technique where a price target follows another “barrier” price (usually high or low) by trying to keep a maximum distance from the “barrier” when it moves in only one direction (up or down). When the “barrier” moves in the other direction the price target will not change. There are as many types of trailing as price targets, which means that there are entry trailing, exit trailing, stop-loss trailing, and take-profit trailing techniques.
💢 What is a Moonbag ❓
A Moonbag in a trade is the quantity of the position that is reserved and will not be exited even if all take-profit targets defined in the strategy are hit, the quantity will be exited only if the stop-loss is hit or a close signal is received. This makes the stop-loss trailing technique in a trend-following strategy a good candidate to take advantage of a Moonbag.
💢 What is Distance ❓
Distance is the difference between two prices.
💢 What is Bias ❓
Bias is a psychological phenomenon where you make decisions based on market sentiment. For example, when you want to enter a long position you have a long bias, and when you want to exit from the long position you have a short bias. It is the other way around for the short position.
💢 What is the Margin Distance of a price target ❓
The Margin Distance of a price target is the distance that the target will deviate from its initial price. The direction of this deviation depends on the bias of the market. For example, suppose you are in a long position, and you set a take-profit target to the local high (HHLL). In that case, adding a margin of five ticks will place your take-profit target 5 ticks below this local high because you have a short bias when exiting a long position. When the bias is long the margin will be added resulting in a higher target price and when you have a short bias the margin will be subtracted.
⚙️ Settings
In the “Settings/Inputs” tab of the “Template Trailing Strategy”, you can find all the customizable settings that are provided by the framework. The variety of those settings is vast; hence we will only scratch the surface here. However, for every setting, there is an information icon 🛈 where you can learn more if you mouse over it. The “Settings/Inputs” tab is divided into ten main groups. Each one of them is responsible for one module of the framework. Every setting is part of a group that is named after the module it represents. So, to spot the module of a setting find the title that appears above it comes with an emoji and uppercase letters. Some settings might have the same name but belong to different modules e.g. “Distance Method”. Some settings are indented, which means that are closely related to the non-indented setting above. Usually, intended settings provide further configuration for one or more options of the non-intended setting. The groups that correspond to each module of the framework are the following:
📆 FILTERS
In this module time filters are implemented. You can define a DateTime window for your strategy to run. You can also specify a session by selecting the days of the week and the time range you want to operate.
🛠️ STRATEGY
This module contains the "𝐃𝐞𝐚𝐥 𝐂𝐨𝐧𝐝𝐢𝐭𝐢𝐨𝐧𝐬 𝐌𝐨𝐝𝐞" that defines if the “Template Trailing Strategy” will operate using the Internal or the External (“Signal Indicator”) conditions. Some general settings can be applied regardless of the mode.
🔨 STRATEGY – EXTERNAL
This sub-module makes the connection between the external signal of the “Signal Indicator” and the “Template Trailing Strategy”. It takes effect only if the "𝐃𝐞𝐚𝐥 𝐂𝐨𝐧𝐝𝐢𝐭𝐢𝐨𝐧𝐬 𝐌𝐨𝐝𝐞" is set to “🔨External”.
🔧 STRATEGY – INTERNAL
This sub-module defines the internal strategy logic and it's used as an example to demonstrate this framework. It should produce the same results as if the “Two MA Signal Indicator” was used as a “signal” in external mode. It takes effect only if the "𝐃𝐞𝐚𝐥 𝐂𝐨𝐧𝐝𝐢𝐭𝐢𝐨𝐧𝐬 𝐌𝐨𝐝𝐞" is set to “🔧Internal”.
🎢 VOLATILITY
This module defines the volatility parameters that are used in various other settings like average true range and standard deviation. It also makes it clear whether their values are updated during a trade (DYNAMIC) or not (STATIC).
🔷 ENTRY
This module defines how the start deal conditions will be executed by defining the order type of your entry and all necessary parameters to execute them.
🎯 TAKE PROFIT
This module defines the take-profit targets placement logic. The number of the take-profit targets to use, their distance from the entry price, and the distance from each other are only some of the features that can be configured.
🛑 STOP LOSS
This module defines the stop-loss target placement logic. The distance from the entry price, move to break even, and start trailing after a take-profit target is hit are only some of the features that can be configured.
🟪 EXIT
This module defines how the end deal conditions will be executed by defining the order type of your exit and all necessary parameters to execute them.
💰 QUANTITY/RISK MANAGEMENT
This module defines the method that calculates the amount of money you will put into each trade. Also, the percentage of the Moonbag quantity can be configured.
📊 ANALYTICS
This module can visualize some extra analytics of the strategy in the chart and calculate some metrics to measure the overall performance.
🔔 ALERT MESSAGES
This module defines all the messages that can be emitted per event during the strategy execution.
😲 Caveats
💢 Does “Template Trailing Strategy” has a repainting behavior ❓
The answer is that the “Template Trailing Strategy” does not repaint as long as the “Signal Indicator” that is connected also does not repaint. If you developed your own SI make sure that you understand and know how to prevent this behavior. The publication by @PineCoders here will give you a good idea on how to avoid most of the repainting cases.
⚠️There is an exception though, when the “Enable Trail⚠️💹” checkbox is checked, the Take Profit trailing feature is enabled, and a tick-based approach is used, meaning that after a while, when the TradingView discards all the real-time data, assumptions will be made by the backtesting engine that will cause a form of repainting. To avoid making false assumptions please disable this feature in the early stages and evaluate its usefulness in your strategy later on, after first confirming the success of the logic without this feature. In this case, consider turning on the bar magnifier feature. This way you will get more accurate backtest results when the Take Profit trailing feature is enabled.
💢 Can “Template Trailing Strategy” satisfy all my trading strategies ❓
While this framework can satisfy quite a large number of trading strategies there are cases where it cannot do so. For example, if you have a custom logic for your stop-loss or take-profit placement, or if you want to dollar cost average, then it might be better to start a new strategy script from scratch.
⚠️ It is not recommended to copy the official TTS code and start developing unless you are a pine wizard! Even in that case, there is a stiff learning curve that might not be worth your time. Last, you must consider that I do not offer support for customized versions of the TTS script and if something goes wrong in the process you are all alone.
🤗 Thanks
Special thanks to @upslidedown and @metadimensional, who regularly gave feedback all those years and helped me to shape the framework as it is today! Thanks to @EltAlt, @PlusUltraTrading, and everyone else who contributed by either filing a “defect report” or asking questions that helped me to understand what improvements were necessary.
Enjoy!
Jason
Close Combination Lock Style - Visual AppealThis creates a combination style closing price change on each tick.
It has two theme options, one as silver dials for Dark Theme and the other as black dials for White Theme.
We get fixated to watching closing prices on charts and it gets visually daunting. This creates a combination style price change which updates on each tick, which is quite pleasing to the eye.
When new price is above current center line, it shift the above prices showing ▲ arrow, and if new price is lower, it will shift the bottom prices showing ▼ arrow. If there is no change in price between the ticks, it will show =.
LargestMarketCapsThis trading system uses a MA to check if the LARGEST CAP stocks are above or below the MA.
You can see from the indicator below how well it manages to capture big moves.
It aggregates the data of all the tickers to create the histogram indicator at the bottom of the chart called MarketLeaders.
If a ticker is above its moving average, then the output will increase by +1 and -1 if a ticker is below its moving average.
This is a powerful system because it uses not only data from one stock but from the stocks that really affect the market big time. If those stocks don't do well, the market won't do well either.
Basically if all the market leaders are doing well, then this system will buy those 20 tickers and keep positions open until the MarketLeaders indicator crosses below 0 -- meaning red.
It also has a red stop loss line, with a wide 15% stop loss to keep us in the trades for the long term.
I've used a 5-day chart because I wanted fewer signals, but higher quality signals.
There are no profit targets, this exits when the indicator turns red -- meaning below 0 or if a position falls 15% in price.
The MA setting is adjustable, the default is 20
These are the tickers that the strategy and indicator currently looks at
The tickers will need to be updated every 6-12 months to remove and ad those who have dropped out of the largest 20 stocks.
It would be a good idea to create a watchlist and alerts for the Large Cap tickers so you can scroll through to see how the system performed on each ticker
"SPX"
"QQQ"
"AAPL"
"MSFT"
"GOOG"
"FB"
"BRK.A"
"TSLA"
"V"
"JPM"
"WMT"
"UNH"
"MA"
"KO"
"PYPL"
"PG"
"HD"
"DIS"
"BAC"
"ADBE"
"CMCSA"
"NKE"
RELATED IDEAS / Indicators
Market Leaders Ribbon
Market Leaders Large Performance Table
Nic's VIX CorrelationIdentifies divergences in price action between the VIX (volatility index) and a ticker. Divergences can be a 'red flag' identifying lack of confidence in the price action.
Best used in with volume studies, across multiple time frames, and across multiple tickers.
Supports any volatility ticker (VIX, VXN, RVX).
Breakout Reversal Entry on WMA - NG1! Overnight ver 1This script is for learning purposes only
This strategy will plot arrows when price breaks so far above/below WMA. The strategy will enter when the price breaks away from WMA. All entries are reversals. Users can set WMA length and source; also the distance of the price away from WMA to enter. Adjustable bracket orders are placed for exit, with trailing stop or market stop choice. Last, users can set the time of day they want to enter a trade.
My Preference: I am testing this strategy on NG1! over night on 1 minute candle. with .003 on price drop/climb, I get entries almost every night. Also 10 tick stop and 5 tick profit seems backward to most, but with a high win/loss ratio, it performs quite well. Trailing stops generally help out as well.
INPUTS:
Length - The is the WMA length
Source - WMA source (High, Low, Open, Close...)
When Price Drops - This is the distance in ticks when the price drops away from WMA, an arrow is plotted, and reversal entry order is placed
When Price Climbs - Same as price drop, just in the opposite direction
Trailing Stop check box - Check if you want to place a trailing stop so many tick away from entry. Unchecked is Market (hard) stop so many ticks from entry.
Stop - Number of ticks away from entry a the stop or trailing stop is set (for NG 1 tick = $0.001)
Limit Out - Number of ticks away from entry a limit order is placed to take profits
Limit Time of day check box - check to use the time of day to limit what time of day order entry will occur.
Start/Stop Trades (Est Time) - First box is when the strategy will be allowed to start buying and stop is when the strategy will stop being allowed to buy. Sell orders continue until a stop or limit triggers an exit. These times are Eastern time zone
PROPERTIES:
Pyramiding - This feature will allow multiple entries to occur. If set to 1, the strategy should only trade 1 contract at a time. If set to 2, the strategy will enter a second order if entry requirements are met. This allows you to be holding 2 contracts. Basically on a good day, it will multiply your earnings, on a bad day, you'll just lose more. For testing, I keep this on 1.
TIPS:
- If you want to go long only, set "When Price Climbs" to an impossible number, like 10,000. It's not possible for NG to move $10 is a matter of minutes so it will not enter the market with a short order. Also keep in mind you can set different requirements for going long vs going short. If you think there is more pull on the market in a particular direction.
Acc/Dist. Cloud with Fractal Deviation Bands by @XeL_ArjonaACCUMULATION / DISTRIBUTION CLOUD with MORPHIC DEVIATION BANDS
Ver. 2.0.beta.23:08:2015
by Ricardo M. Arjona @XeL_Arjona
DISCLAIMER
The Following indicator/code IS NOT intended to be a formal investment advice or recommendation by the author, nor should be construed as such. Users will be fully responsible by their use regarding their own trading vehicles/assets.
The embedded code and ideas within this work are FREELY AND PUBLICLY available on the Web for NON LUCRATIVE ACTIVITIES and must remain as is.
Pine Script code MOD's and adaptations by @XeL_Arjona with special mention in regard of:
Buy (Bull) and Sell (Bear) "Power Balance Algorithm by Vadim Gimelfarb published at Stocks & Commodities V. 21:10 (68-72).
Custom Weighting Coefficient for Exponential Moving Average (nEMA) adaptation work by @XeL_Arjona with contribution help from @RicardoSantos at TradingView @pinescript chat room.
Morphic Numbers (PHI & Plastic) Pine Script adaptation from it's algebraic generation formulas by @XeL_Arjona
Fractal Deviation Bands idea by @XeL_Arjona
CHANGE LOG:
ACCUMULATION / DISTRIBUTION CLOUD: I decided to change it's name from the Buy to Sell Pressure. The code is essentially the same as older versions and they are the center core (VORTEX?) of all derived New stuff which are:
MORPHIC NUMBERS: The "Golden Ratio" expressed by the result of the constant "PHI" and the newer and same in characteristics "Plastic Number" expressed as "PN". For more information about this regard take a look at: HERE!
CUSTOM(K) EXPONENTIAL MOVING AVERAGE: Some code has cleaned from last version to include as custom function the nEMA , which use an additional input (K) to customise the way the "exponentially" is weighted from the custom array. For the purpose of this indicator, I implement a volatility algorithm using the Average True Range of last 9 periods multiplied by the morphic number used in the fractal study. (Golden Ratio as default) The result is very similar in response to classic EMA but tend to accelerate or decelerate much more responsive with wider bars presented in trending average.
FRACTAL DEVIATION BANDS: The main idea is based on the so useful Standard Deviation process to create Bands in favor of a multiplier (As John Bollinger used in it's own bands) from a custom array, in which for this case is the "Volume Pressure Moving Average" as the main Vortex for the "Fractallitly", so then apply as many "Child bands" using the older one as the new calculation array using the same morphic constant as multiplier (Like Fibonacci but with other approach rather than %ratios). Results are AWSOME! Market tend to accelerate or decelerate their Trend in favor of a Fractal approach. This bands try to catch them, so please experiment and feedback me your own observations.
EXTERNAL TICKER FOR VOLUME DATA: I Added a way to input volume data for this kind of study from external tickers. This is just a quicky-hack given that currently TradingView is not adding Volume to their Indexes so; maybe this is temporary by now. It seems that this part of the code is conflicting with intraday timeframes, so You are advised.
This CODE is versioned as BETA FOR TESTING PROPOSES. By now TradingView Admins are changing lot's of things internally, so maybe this could conflict with correct rendering of this study with special tickers or timeframes. I will try to code by itself just the core parts of this study in order to use them at discretion in other areas. ALL NEW IDEAS OR MODIFICATIONS to these indicator(s) are Welcome in favor to deploy a better and more accurate readings. I will be very glad to be notified at Twitter or TradingView accounts at: @XeL_Arjona
RTH Levels: VWAP + PDH/PDL + ONH/ONL + IBAlgo Index — Levels Pro (ONH/ONL • PDH/PDL • VWAP±Bands • IB • Gaps)
Purpose. A session-aware, non-repainting levels tool for intraday decision-making. Designed for futures and indices, with clean visuals, alerts, and a one-click Minimal Mode for screenshot-ready charts.
What it plots
• PDH/PDL (RTH-only) – Prior Regular Trading Hours high/low, computed intraday and frozen at the RTH close (no 24h mix-ups, no repainting).
• ONH/ONL – Prior Overnight high/low, held throughout RTH.
• RTH VWAP with ±σ bands – Volume-weighted variance, reset each RTH.
• Initial Balance (IB) – First N minutes of RTH, plus 1.5× / 2.0× extensions after IB completes.
• Today’s RTH Open & Prior RTH Close – With gap detection and “gap filled” alert.
• Killzone shading – NY Open (09:30–10:30 ET) and Lunch (11:15–13:30 ET).
• Values panel (top-right) – Each level with live distance in points & ticks.
• Right-edge level tags – With anti-overlap (stagger + vertical jitter).
• Price-scale tags – Native trackprice markers that always “stick” to the axis.
⸻
New in v6.4
• Minimal Mode: one click for a clean look (thinner lines, VWAP bands/IB extensions hidden, on-chart right-edge labels off; price-scale tags remain).
• Theme presets: Dark Hi-Contrast / Light Minimal / Futures Classic / Muted Dark.
• Anti-overlap controls: horizontal staggering, vertical jitter, and baseline offset to keep tags readable even when levels cluster.
⸻
Quick start (2 minutes)
1. Add to chart → keep defaults.
2. Sessions (ET):
• RTH Session default: 09:30–16:00 (US equities cash hours).
• Overnight Session default: 18:00–09:29.
Adjust for your market if you use different “day” hours (e.g., many use 08:20–13:30 ET for COMEX Gold).
3. Theme & Minimal Mode: pick a Theme Preset; enable Minimal Mode for screenshots.
4. Visibility: toggle PD/ON/VWAP/IB/References/Panel to taste.
5. Right-edge labels: turn Show Right-Edge Labels on. If they crowd, tune:
• Anti-overlap: min separation (ticks)
• Horizontal offset per tag (bars)
• Vertical jitter per step (ticks)
• Right-edge baseline offset (bars)
6. Alerts: open Add alert → Condition: and pick the events you want.
⸻
How levels are computed (no repainting)
• PDH/PDL: Intraday H/L are accumulated only while in RTH and saved at RTH close for “yesterday’s” values.
• ONH/ONL: Accumulated across the defined Overnight window and then held during RTH.
• RTH VWAP & ±σ: Volume-weighted mean and standard deviation, reset at the RTH open.
• IB: First N minutes of RTH (default 60). Extensions (1.5×/2.0×) appear after IB completes.
• Gaps: Today’s RTH open vs prior RTH close; “Gap Filled” triggers when price trades back to prior close.
⸻
Practical playbooks (how to trade around the levels)
1) PDH/PDL interactions
• Rejection: Price taps PDH/PDL then closes back inside → mean-reversion toward VWAP/IB.
• Acceptance: Close/hold beyond PDH/PDL with momentum → continuation to next HTF/IB target.
• Alert: PD Touch/Break.
2) ONH/ONL “taken”
• Often one ON extreme is taken during RTH. ONH Taken / ONL Taken → check if it’s a clean break or sweep & reclaim.
• Sweep + reclaim near VWAP can fuel rotations through the ON range.
3) VWAP ±σ framework
• Balanced: First tag of ±1σ often reverts toward VWAP.
• Trend: Persistent trade beyond ±1σ + IB break → target ±2σ/±3σ.
• Alerts: VWAP Cross and VWAP Reject (cross then immediate fail back).
4) IB breaks
• After IB completes, a clean IB break commonly targets 1.5× and sometimes 2.0×.
• Quick return inside IB = possible fade back to the opposite IB edge/VWAP.
• Alerts: IB Break Up / Down.
5) Gaps
• Gap-and-go: Opening drive away from prior close + VWAP support → trend until IB completion.
• Gap-fill: Weak open and VWAP overhead/underfoot → trade toward prior close; manage on Gap Filled alert.
Pro tip: Stack confluences (e.g., ONL sweep + VWAP reclaim + IB hold) and respect your execution rules (e.g., require a 5-minute close in direction, or your order-flow confirmation).
⸻
Inputs you’ll actually touch
• Sessions (ET): Session Timezone, RTH Session, Overnight Session.
• Visibility: toggles for PD/ON/VWAP/IB/Ref/Panel.
• VWAP bands: set σ multipliers (±1/±2/±3).
• IB: duration (minutes) and extension multipliers (1.5× / 2.0×).
• Style & Theme: Theme Preset, Main Line Width, Trackprice, Minimal Mode, and anti-overlap controls.
⸻
Alerts included
• PD Touch/Break — High ≥ PDH or Low ≤ PDL
• ONH Taken / ONL Taken — First in-RTH take of ONH/ONL
• VWAP Cross — Close crosses VWAP
• VWAP Reject — Cross then immediate fail back
• IB Break Up / Down — Break of IB High/Low after IB completes
• Gap Filled — Price trades back to prior RTH close
Setup: Add alert → Condition: Algo Index — Levels Pro → choose event → message → Notify on app/email.
⸻
Panel guide
The top-right panel shows each level plus live distance from last price:
LevelValue (Δpoints | Δticks)
Coloring: green if level is below current price, red if above.
⸻
Styling & screenshot tips
• Use Theme Preset that matches your chart.
• For dark charts, “Dark Hi-Contrast” with Main Line Width = 3 works well.
• Enable Trackprice for crisp axis tags that always stick to the right edge.
• Turn on Minimal Mode for cleaner screenshots (no VWAP bands or IB extensions, on-chart tags off; price-scale tags remain).
• If tags crowd, increase min separation (ticks) to 30–60 and horizontal offset to 3–5; add vertical jitter (4–12 ticks) and/or push tags farther right with baseline offset (bars).
⸻
Behavior & limitations
• Levels are computed incrementally; tables refresh on the last bar for efficiency.
• Right-edge labels are placed at bar_index + offset and do not track extra right-margin scrolling (TradingView limitation). The price-scale tags (from trackprice) do track the axis.
• “RTH” is what you define in inputs. If your market uses different day hours, change the session strings so PDH/PDL reflect your definition of “yesterday’s session.”
⸻
FAQ
Q: My PDH/PDL don’t match the daily chart.
A: By design this uses RTH-only highs/lows, not 24h daily bars. Adjust sessions if you want a different definition.
Q: Right-edge tags overlap or don’t sit at the far right.
A: Increase min separation / horizontal offset / vertical jitter and/or push tags farther with baseline offset. If you want markers that always hug the axis, rely on Trackprice.
Q: Can I change killzones?
A: Yes—edit the session strings in settings or request a version with user inputs for custom windows.
⸻
Disclaimer
Educational use only. This is not financial advice. Always apply your own risk management and confirmation rules.
⸻
Enjoy it? Please ⭐ the script and share screenshots using Minimal Mode + a Theme Preset that fits your style.
Frahm FactorIntended Usage of the Frahm Factor Indicator
The Frahm Factor is designed to give you a rapid, at-a-glance assessment of how volatile the market is right now—and how large the average candle has been—over the most recent 24-hour window. Here’s how to put it to work:
Gauge Volatility Regimes
Volatility Score (1–10)
A low score (1–3, green) signals calm seas—tight ranges, low risk of big moves.
A mid score (4–6, yellow) warns you that volatility is picking up.
A high score (7–10, red) tells you to prepare for disorderly swings or breakout opportunities.
How to trade off it
In low-volatility periods, you might favor mean-reversion or range-bound strategies.
As the score climbs into the red zone, consider widening stops, scaling back position size, or switching to breakout momentum plays.
Monitor Average Candle Size
Avg Candle (ticks) cell shows you the mean true-range of each bar over that 24h window in ticks.
When candles are small, you know the market is consolidating and liquidity may be thin.
When candles are large, momentum and volume are driving strong directional bias.
The optional dynamic color ramp (green→yellow→red) immediately flags when average bar size is unusually small or large versus its own 24h history.
Customize & Stay Flexible
Timeframes: Works on any intraday chart—from 1-minute scalping to 4-hour swing setups—because it always looks back exactly 24 hours.
Toggles:
Show or hide the Volatility and Avg-Candle cells to keep your screen uncluttered.
Turn on the dynamic color ramp only when you want that extra visual cue.
Alerts: Built-in alerts fire automatically at meaningful thresholds (Volatility ≥ 8 or ≤ 3), so you’ll never miss regime shifts, even if you step away.
Real-World Applications
Risk Management: Automatically adjust your stop-loss distances or position sizing based on the current volatility band.
Strategy Selection: Flip between range-trading and momentum strategies as the volatility regime changes.
Session Analysis: Pinpoint when during the day volatility typically ramps—perfect for doorway sessions like London opening or the US midday news spikes.
Bottom line: the Frahm Factor gives you one compact dashboard to see the pulse of the market—so you can make choices with conviction, dial your risk in real time, and never be caught off guard by sudden volatility shifts.
Logic Behind the Frahm Factor Indicator
24-Hour Rolling Window
On every intraday bar, we append that bar’s True Range (TR) and timestamp to two arrays.
We then prune any entries older than 24 hours, so the arrays always reflect exactly the last day of data.
Volatility Score (1–10)
We count how many of those 24 h TR values are less than or equal to the current bar’s TR.
Dividing by the total array size gives a percentile (0–1), which we scale and round into a 1–10 score.
Average Candle Size (ticks)
We sum all TR values in the same 24 h window, divide by array length to get the mean TR, then convert that price range into ticks.
Optionally, a green→yellow→red ramp highlights when average bar size is unusually small, medium or large versus its own 24 h history.
Color & Alerts
The Volatility cell flips green (1–3), yellow (4–6) or red (7–10) so you see regime shifts at a glance.
Built-in alertcondition calls fire when the score crosses your high (≥ 8) or low (≤ 3) thresholds.
Modularity
Everything—table location, which cells to show, dynamic coloring—is controlled by simple toggles, so you can strip it back or layer on extra visual cues as needed.
That’s the full recipe: a true 24 h look-back, a percentile-ranked volatility gauge, and a mean-bar-size meter, all wrapped into one compact dashboard.
Candle Range-BarsThe Candle Range Bars indicator visually represents the range of each candlestick in either pips or ticks, depending on your preference. It plots vertical bars to show the size of each candle, making it easy to identify periods of high or low volatility. The indicator also displays the exact range value (in pips or ticks) above each bar, with customizable text size and color for better readability.
Key Features
Pips or Ticks Mode:
Choose to display the candle range in pips (for forex traders) or ticks (for other instruments).
Customizable Text:
Adjust the text color and text size (Tiny, Small, Normal, Large) to suit your chart style.
Clear Visuals:
Bars are colored green for bullish candles and red for bearish candles, making it easy to distinguish between up and down moves.
Flexible Use:
Ideal for analyzing volatility, identifying consolidation zones, and comparing candle ranges across different timeframes.
How to Use:
Add the indicator to your chart.
Customize the settings:
Choose between pips or ticks.
Adjust the text color and text size for the range values.
Observe the bars and their corresponding range values to analyze market volatility.
Why Use This Indicator?:
Simplify Range Analysis: Quickly see the size of each candlestick without manual calculations.
Customizable: Tailor the appearance to match your trading style.
Versatile: Works on any instrument and timeframe.
Settings:
Show Pips (Otherwise Ticks): Toggle between pips and ticks mode.
Text Color: Choose the color of the range value text.
Text Size: Select the size of the range value text (Tiny, Small, Normal, Large).
Ideal For:
Forex, stocks, commodities, and crypto traders.
Traders who focus on volatility and range analysis.
Anyone looking for a clear and customizable way to visualize candle ranges.
This description highlights the key features, benefits, and usability of your indicator, making it appealing to other TradingView members. Let me know if you'd like to tweak it further! 😊
hinton_map█ HINTON MAP
This library provides functions to create and display a Hinton Map visualization. A Hinton map uses squares to represent the magnitude and direction of values in a matrix. This library allows you to display multiple ticker/timeframe/indicator combinations on a single chart, using color/boxsize/bnordersize to represent the values used. The values must be from -1.0 to 1.0 in value. 3 different values can be input per square.
Example Usage:
The example below demonstrates how to create a Hinton Map for two symbols (AAPL and MSFT) across three timeframes (1 minute, 5 minutes, and 1 day).
var hintonData = hinton_map.initHintonData(2, 3)
tickers = array.from("AAPL", "MSFT")
timeframes = array.from("1", "5", "1D")
for i = 0 to array.size(tickers) - 1
for j = 0 to array.size(timeframes) - 1
ticker = array.get(tickers, i)
timeframe = array.get(timeframes, j)
= request.security(ticker, timeframe, [close, close , ta.rsi(close, 14)], lookahead = barmerge.lookahead_on)
percent_change = (close_current - close_previous) / close_previous * 100
rsi_deviation = rsi_current - 50
hintonData.unitMatrix.set(i, j, hinton_map.createHintonUnit(
fillValue = percent_change,
borderValue = rsi_deviation,
innerValue = percent_change * rsi_deviation,
boxText = dv.from_string(str.tostring(math.round(percent_change, 2)) + "%"),
tooltipText = dv.from_string(syminfo.ticker + ", " + timeframe + ": " + str.tostring(math.round(percent_change, 2)) + "%, RSI: " + str.tostring(math.round(rsi_current, 2)))
))
hinton_map.drawHintonMap(hintonData)
█ createHintonUnit
Creates a Hinton unit.
• fillValue
Value to determine the fill color hue.
Type: float
Default Value: 0.0
• borderValue
Value to determine the border color hue and width.
Type: float
Default Value: 0.0
• innerValue
Value to determine the inner box color hue.
Type: float
Default Value: 0.0
• boxText
Text to display in the inner box.
Type: dv.DisplayValue
Default Value: na
• tooltipText
Tooltip text for the inner box.
Type: dv.DisplayValue
Default Value: na
Returns: HintonUnit
█ initHintonData
Initializes Hinton map data structure.
• rows
Number of rows.
Type: int
• columns
Number of columns.
Type: int
Returns: HintonData
█ drawHintonMap
Draws a Hinton map.
• hintonData
Hinton map data.
Type: HintonData
• unitSize
Size of each unit in bars.
Type: int
Default Value: 10
• borderWidth
Base width of the inner box border.
Type: int
Default Value: 5
• plusHue
Hue value for positive values (0-360).
Type: float
Default Value: 180
• minusHue
Hue value for negative values (0-360).
Type: float
Default Value: -30
█ HintonUnit
Data for a Hinton unit.
• fillValue
Value to determine the fill color hue.
Type: float
• borderValue
Value to determine the border color hue and width.
Type: float
• innerValue
Value to determine the inner box color hue.
Type: float
• boxText
Text to display in the inner box.
Type: dv.DisplayValue
• tooltipText
Tooltip text for the inner box.
Type: dv.DisplayValue
█ HintonData
Structure to store Hinton map data.
• unitMatrix
Matrix of Hinton units.
Type: matrix
• lineMatrix
Matrix of lines.
Type: matrix
• labelMatrix
Matrix of labels.
Type: matrix
• boxMatrix
Matrix of boxes.
Type: matrix
• fillMatrix
Matrix of line fills.
Type: matrix
Candle Range Theory | Flux Charts💎 GENERAL OVERVIEW
Introducing our new Candle Range Theory Indicator! This powerful tool offers a strategy built around the Candle Range Theory, which analyzes market movements through the relative size and structure of price candles. For more information about the process, check the "HOW DOES IT WORK" section.
Features of the new Candle Range Theory Indicator :
Implementation of the Candle Range Theory
FVG & Order Block Entry Methods
2 Different TP / SL Methods
Customizable Execution Settings
Customizable Backtesting Dashboard
Alerts for Buy, Sell, TP & SL Signals
📌 HOW DOES IT WORK ?
The Candle Range Theory (CRT) indicator operates by identifying significant price movements through the relative size and structure of candlesticks. A key part of the strategy is determining large candles based on their range compared to the Average True Range (ATR) in a higher timeframe. Once identified, a breakout of either the high wick or the low wick of the large candle is required. This breakout is considered a liquidity grab. After that, the indicator waits for confirmation through Fair Value Gaps (FVGs) or Order Blocks (OBs). The confirmation structure must be the opposite direction of the breakout, for example if the high wick is broken, a bearish FVG is required for the short entry. After a confirmation signal is received, the indicator will trigger entry points based on your chosen entry method (FVG or OB), and exit points will be calculated using either a dynamic ATR-based TP/SL method or fixed percentages. Alerts for Buy, Sell, Take-Proft, and Stop-Loss are available.
🚩 UNIQUENESS
This indicator stands out because it combines two highly effective entry methods: Fair Value Gaps (FVGs) and Order Blocks (OBs). You can choose between these strategies depending on market conditions. Additionally, the dynamic TP/SL system uses the ticker's volatility to automatically calculate stop-loss and take-profit targets. The backtesting dashboard provides metrics about the performance of the indicator. You can use it to tune the settings for best use in the current tiker. The Candle Range Theory approach offers more flexibility compared to traditional indicators, allowing for better customization and control based on your risk tolerance.
⚙️ SETTINGS
1. General Configuration
Higher Timeframe: Customize the higher timeframe for analysis. Recommended combinations include M15 -> H4, H4 -> Daily, Daily -> Weekly, and Weekly -> Monthly.
HTF Candle Size: Define the size of the higher timeframe candles as Big, Normal, or Small to filter valid setups based on their range relative to ATR.
Entry Mode: Choose between FVGs and Order Blocks for your entry triggers.
Require Retracement: Enable this option if you want a retracement to the FVG or OB for entry confirmation.
Show HTF Candle Lines: Toggle to display the higher timeframe candle lines for better visual clarity.
2. Fair Value Gaps
FVG Sensitivity: You may select between Low, Normal, High or Extreme FVG detection sensitivity. This will essentially determine the size of the spotted FVGs, with lower sensitivities resulting in spotting bigger FVGs, and higher sensitivities resulting in spotting all sizes of FVGs.
3. Order Blocks
Swing Length: Swing length is used when finding order block formations. Smaller values will result in finding smaller order blocks.
4. TP / SL
TP / SL Method:
a) Dynamic: The TP / SL zones will be auto-determined by the algorithm based on the Average True Range (ATR) of the current ticker.
b) Fixed : You can adjust the exact TP / SL ratios from the settings below.
Dynamic Risk: The risk you're willing to take if "Dynamic" TP / SL Method is selected. Higher risk usually means a better winrate at the cost of losing more if the strategy fails. This setting is has a crucial effect on the performance of the indicator, as different tickers may have different volatility so the indicator may have increased performance when this setting is correctly adjusted.
Universal Ratio Trend Matrix [InvestorUnknown]The Universal Ratio Trend Matrix is designed for trend analysis on asset/asset ratios, supporting up to 40 different assets. Its primary purpose is to help identify which assets are outperforming others within a selection, providing a broad overview of market trends through a matrix of ratios. The indicator automatically expands the matrix based on the number of assets chosen, simplifying the process of comparing multiple assets in terms of performance.
Key features include the ability to choose from a narrow selection of indicators to perform the ratio trend analysis, allowing users to apply well-defined metrics to their comparison.
Drawback: Due to the computational intensity involved in calculating ratios across many assets, the indicator has a limitation related to loading speed. TradingView has time limits for calculations, and for users on the basic (free) plan, this could result in frequent errors due to exceeded time limits. To use the indicator effectively, users with any paid plans should run it on timeframes higher than 8h (the lowest timeframe on which it managed to load with 40 assets), as lower timeframes may not reliably load.
Indicators:
RSI_raw: Simple function to calculate the Relative Strength Index (RSI) of a source (asset price).
RSI_sma: Calculates RSI followed by a Simple Moving Average (SMA).
RSI_ema: Calculates RSI followed by an Exponential Moving Average (EMA).
CCI: Calculates the Commodity Channel Index (CCI).
Fisher: Implements the Fisher Transform to normalize prices.
Utility Functions:
f_remove_exchange_name: Strips the exchange name from asset tickers (e.g., "INDEX:BTCUSD" to "BTCUSD").
f_remove_exchange_name(simple string name) =>
string parts = str.split(name, ":")
string result = array.size(parts) > 1 ? array.get(parts, 1) : name
result
f_get_price: Retrieves the closing price of a given asset ticker using request.security().
f_constant_src: Checks if the source data is constant by comparing multiple consecutive values.
Inputs:
General settings allow users to select the number of tickers for analysis (used_assets) and choose the trend indicator (RSI, CCI, Fisher, etc.).
Table settings customize how trend scores are displayed in terms of text size, header visibility, highlighting options, and top-performing asset identification.
The script includes inputs for up to 40 assets, allowing the user to select various cryptocurrencies (e.g., BTCUSD, ETHUSD, SOLUSD) or other assets for trend analysis.
Price Arrays:
Price values for each asset are stored in variables (price_a1 to price_a40) initialized as na. These prices are updated only for the number of assets specified by the user (used_assets).
Trend scores for each asset are stored in separate arrays
// declare price variables as "na"
var float price_a1 = na, var float price_a2 = na, var float price_a3 = na, var float price_a4 = na, var float price_a5 = na
var float price_a6 = na, var float price_a7 = na, var float price_a8 = na, var float price_a9 = na, var float price_a10 = na
var float price_a11 = na, var float price_a12 = na, var float price_a13 = na, var float price_a14 = na, var float price_a15 = na
var float price_a16 = na, var float price_a17 = na, var float price_a18 = na, var float price_a19 = na, var float price_a20 = na
var float price_a21 = na, var float price_a22 = na, var float price_a23 = na, var float price_a24 = na, var float price_a25 = na
var float price_a26 = na, var float price_a27 = na, var float price_a28 = na, var float price_a29 = na, var float price_a30 = na
var float price_a31 = na, var float price_a32 = na, var float price_a33 = na, var float price_a34 = na, var float price_a35 = na
var float price_a36 = na, var float price_a37 = na, var float price_a38 = na, var float price_a39 = na, var float price_a40 = na
// create "empty" arrays to store trend scores
var a1_array = array.new_int(40, 0), var a2_array = array.new_int(40, 0), var a3_array = array.new_int(40, 0), var a4_array = array.new_int(40, 0)
var a5_array = array.new_int(40, 0), var a6_array = array.new_int(40, 0), var a7_array = array.new_int(40, 0), var a8_array = array.new_int(40, 0)
var a9_array = array.new_int(40, 0), var a10_array = array.new_int(40, 0), var a11_array = array.new_int(40, 0), var a12_array = array.new_int(40, 0)
var a13_array = array.new_int(40, 0), var a14_array = array.new_int(40, 0), var a15_array = array.new_int(40, 0), var a16_array = array.new_int(40, 0)
var a17_array = array.new_int(40, 0), var a18_array = array.new_int(40, 0), var a19_array = array.new_int(40, 0), var a20_array = array.new_int(40, 0)
var a21_array = array.new_int(40, 0), var a22_array = array.new_int(40, 0), var a23_array = array.new_int(40, 0), var a24_array = array.new_int(40, 0)
var a25_array = array.new_int(40, 0), var a26_array = array.new_int(40, 0), var a27_array = array.new_int(40, 0), var a28_array = array.new_int(40, 0)
var a29_array = array.new_int(40, 0), var a30_array = array.new_int(40, 0), var a31_array = array.new_int(40, 0), var a32_array = array.new_int(40, 0)
var a33_array = array.new_int(40, 0), var a34_array = array.new_int(40, 0), var a35_array = array.new_int(40, 0), var a36_array = array.new_int(40, 0)
var a37_array = array.new_int(40, 0), var a38_array = array.new_int(40, 0), var a39_array = array.new_int(40, 0), var a40_array = array.new_int(40, 0)
f_get_price(simple string ticker) =>
request.security(ticker, "", close)
// Prices for each USED asset
f_get_asset_price(asset_number, ticker) =>
if (used_assets >= asset_number)
f_get_price(ticker)
else
na
// overwrite empty variables with the prices if "used_assets" is greater or equal to the asset number
if barstate.isconfirmed // use barstate.isconfirmed to avoid "na prices" and calculation errors that result in empty cells in the table
price_a1 := f_get_asset_price(1, asset1), price_a2 := f_get_asset_price(2, asset2), price_a3 := f_get_asset_price(3, asset3), price_a4 := f_get_asset_price(4, asset4)
price_a5 := f_get_asset_price(5, asset5), price_a6 := f_get_asset_price(6, asset6), price_a7 := f_get_asset_price(7, asset7), price_a8 := f_get_asset_price(8, asset8)
price_a9 := f_get_asset_price(9, asset9), price_a10 := f_get_asset_price(10, asset10), price_a11 := f_get_asset_price(11, asset11), price_a12 := f_get_asset_price(12, asset12)
price_a13 := f_get_asset_price(13, asset13), price_a14 := f_get_asset_price(14, asset14), price_a15 := f_get_asset_price(15, asset15), price_a16 := f_get_asset_price(16, asset16)
price_a17 := f_get_asset_price(17, asset17), price_a18 := f_get_asset_price(18, asset18), price_a19 := f_get_asset_price(19, asset19), price_a20 := f_get_asset_price(20, asset20)
price_a21 := f_get_asset_price(21, asset21), price_a22 := f_get_asset_price(22, asset22), price_a23 := f_get_asset_price(23, asset23), price_a24 := f_get_asset_price(24, asset24)
price_a25 := f_get_asset_price(25, asset25), price_a26 := f_get_asset_price(26, asset26), price_a27 := f_get_asset_price(27, asset27), price_a28 := f_get_asset_price(28, asset28)
price_a29 := f_get_asset_price(29, asset29), price_a30 := f_get_asset_price(30, asset30), price_a31 := f_get_asset_price(31, asset31), price_a32 := f_get_asset_price(32, asset32)
price_a33 := f_get_asset_price(33, asset33), price_a34 := f_get_asset_price(34, asset34), price_a35 := f_get_asset_price(35, asset35), price_a36 := f_get_asset_price(36, asset36)
price_a37 := f_get_asset_price(37, asset37), price_a38 := f_get_asset_price(38, asset38), price_a39 := f_get_asset_price(39, asset39), price_a40 := f_get_asset_price(40, asset40)
Universal Indicator Calculation (f_calc_score):
This function allows switching between different trend indicators (RSI, CCI, Fisher) for flexibility.
It uses a switch-case structure to calculate the indicator score, where a positive trend is denoted by 1 and a negative trend by 0. Each indicator has its own logic to determine whether the asset is trending up or down.
// use switch to allow "universality" in indicator selection
f_calc_score(source, trend_indicator, int_1, int_2) =>
int score = na
if (not f_constant_src(source)) and source > 0.0 // Skip if you are using the same assets for ratio (for example BTC/BTC)
x = switch trend_indicator
"RSI (Raw)" => RSI_raw(source, int_1)
"RSI (SMA)" => RSI_sma(source, int_1, int_2)
"RSI (EMA)" => RSI_ema(source, int_1, int_2)
"CCI" => CCI(source, int_1)
"Fisher" => Fisher(source, int_1)
y = switch trend_indicator
"RSI (Raw)" => x > 50 ? 1 : 0
"RSI (SMA)" => x > 50 ? 1 : 0
"RSI (EMA)" => x > 50 ? 1 : 0
"CCI" => x > 0 ? 1 : 0
"Fisher" => x > x ? 1 : 0
score := y
else
score := 0
score
Array Setting Function (f_array_set):
This function populates an array with scores calculated for each asset based on a base price (p_base) divided by the prices of the individual assets.
It processes multiple assets (up to 40), calling the f_calc_score function for each.
// function to set values into the arrays
f_array_set(a_array, p_base) =>
array.set(a_array, 0, f_calc_score(p_base / price_a1, trend_indicator, int_1, int_2))
array.set(a_array, 1, f_calc_score(p_base / price_a2, trend_indicator, int_1, int_2))
array.set(a_array, 2, f_calc_score(p_base / price_a3, trend_indicator, int_1, int_2))
array.set(a_array, 3, f_calc_score(p_base / price_a4, trend_indicator, int_1, int_2))
array.set(a_array, 4, f_calc_score(p_base / price_a5, trend_indicator, int_1, int_2))
array.set(a_array, 5, f_calc_score(p_base / price_a6, trend_indicator, int_1, int_2))
array.set(a_array, 6, f_calc_score(p_base / price_a7, trend_indicator, int_1, int_2))
array.set(a_array, 7, f_calc_score(p_base / price_a8, trend_indicator, int_1, int_2))
array.set(a_array, 8, f_calc_score(p_base / price_a9, trend_indicator, int_1, int_2))
array.set(a_array, 9, f_calc_score(p_base / price_a10, trend_indicator, int_1, int_2))
array.set(a_array, 10, f_calc_score(p_base / price_a11, trend_indicator, int_1, int_2))
array.set(a_array, 11, f_calc_score(p_base / price_a12, trend_indicator, int_1, int_2))
array.set(a_array, 12, f_calc_score(p_base / price_a13, trend_indicator, int_1, int_2))
array.set(a_array, 13, f_calc_score(p_base / price_a14, trend_indicator, int_1, int_2))
array.set(a_array, 14, f_calc_score(p_base / price_a15, trend_indicator, int_1, int_2))
array.set(a_array, 15, f_calc_score(p_base / price_a16, trend_indicator, int_1, int_2))
array.set(a_array, 16, f_calc_score(p_base / price_a17, trend_indicator, int_1, int_2))
array.set(a_array, 17, f_calc_score(p_base / price_a18, trend_indicator, int_1, int_2))
array.set(a_array, 18, f_calc_score(p_base / price_a19, trend_indicator, int_1, int_2))
array.set(a_array, 19, f_calc_score(p_base / price_a20, trend_indicator, int_1, int_2))
array.set(a_array, 20, f_calc_score(p_base / price_a21, trend_indicator, int_1, int_2))
array.set(a_array, 21, f_calc_score(p_base / price_a22, trend_indicator, int_1, int_2))
array.set(a_array, 22, f_calc_score(p_base / price_a23, trend_indicator, int_1, int_2))
array.set(a_array, 23, f_calc_score(p_base / price_a24, trend_indicator, int_1, int_2))
array.set(a_array, 24, f_calc_score(p_base / price_a25, trend_indicator, int_1, int_2))
array.set(a_array, 25, f_calc_score(p_base / price_a26, trend_indicator, int_1, int_2))
array.set(a_array, 26, f_calc_score(p_base / price_a27, trend_indicator, int_1, int_2))
array.set(a_array, 27, f_calc_score(p_base / price_a28, trend_indicator, int_1, int_2))
array.set(a_array, 28, f_calc_score(p_base / price_a29, trend_indicator, int_1, int_2))
array.set(a_array, 29, f_calc_score(p_base / price_a30, trend_indicator, int_1, int_2))
array.set(a_array, 30, f_calc_score(p_base / price_a31, trend_indicator, int_1, int_2))
array.set(a_array, 31, f_calc_score(p_base / price_a32, trend_indicator, int_1, int_2))
array.set(a_array, 32, f_calc_score(p_base / price_a33, trend_indicator, int_1, int_2))
array.set(a_array, 33, f_calc_score(p_base / price_a34, trend_indicator, int_1, int_2))
array.set(a_array, 34, f_calc_score(p_base / price_a35, trend_indicator, int_1, int_2))
array.set(a_array, 35, f_calc_score(p_base / price_a36, trend_indicator, int_1, int_2))
array.set(a_array, 36, f_calc_score(p_base / price_a37, trend_indicator, int_1, int_2))
array.set(a_array, 37, f_calc_score(p_base / price_a38, trend_indicator, int_1, int_2))
array.set(a_array, 38, f_calc_score(p_base / price_a39, trend_indicator, int_1, int_2))
array.set(a_array, 39, f_calc_score(p_base / price_a40, trend_indicator, int_1, int_2))
a_array
Conditional Array Setting (f_arrayset):
This function checks if the number of used assets is greater than or equal to a specified number before populating the arrays.
// only set values into arrays for USED assets
f_arrayset(asset_number, a_array, p_base) =>
if (used_assets >= asset_number)
f_array_set(a_array, p_base)
else
na
Main Logic
The main logic initializes arrays to store scores for each asset. Each array corresponds to one asset's performance score.
Setting Trend Values: The code calls f_arrayset for each asset, populating the respective arrays with calculated scores based on the asset prices.
Combining Arrays: A combined_array is created to hold all the scores from individual asset arrays. This array facilitates further analysis, allowing for an overview of the performance scores of all assets at once.
// create a combined array (work-around since pinescript doesn't support having array of arrays)
var combined_array = array.new_int(40 * 40, 0)
if barstate.islast
for i = 0 to 39
array.set(combined_array, i, array.get(a1_array, i))
array.set(combined_array, i + (40 * 1), array.get(a2_array, i))
array.set(combined_array, i + (40 * 2), array.get(a3_array, i))
array.set(combined_array, i + (40 * 3), array.get(a4_array, i))
array.set(combined_array, i + (40 * 4), array.get(a5_array, i))
array.set(combined_array, i + (40 * 5), array.get(a6_array, i))
array.set(combined_array, i + (40 * 6), array.get(a7_array, i))
array.set(combined_array, i + (40 * 7), array.get(a8_array, i))
array.set(combined_array, i + (40 * 8), array.get(a9_array, i))
array.set(combined_array, i + (40 * 9), array.get(a10_array, i))
array.set(combined_array, i + (40 * 10), array.get(a11_array, i))
array.set(combined_array, i + (40 * 11), array.get(a12_array, i))
array.set(combined_array, i + (40 * 12), array.get(a13_array, i))
array.set(combined_array, i + (40 * 13), array.get(a14_array, i))
array.set(combined_array, i + (40 * 14), array.get(a15_array, i))
array.set(combined_array, i + (40 * 15), array.get(a16_array, i))
array.set(combined_array, i + (40 * 16), array.get(a17_array, i))
array.set(combined_array, i + (40 * 17), array.get(a18_array, i))
array.set(combined_array, i + (40 * 18), array.get(a19_array, i))
array.set(combined_array, i + (40 * 19), array.get(a20_array, i))
array.set(combined_array, i + (40 * 20), array.get(a21_array, i))
array.set(combined_array, i + (40 * 21), array.get(a22_array, i))
array.set(combined_array, i + (40 * 22), array.get(a23_array, i))
array.set(combined_array, i + (40 * 23), array.get(a24_array, i))
array.set(combined_array, i + (40 * 24), array.get(a25_array, i))
array.set(combined_array, i + (40 * 25), array.get(a26_array, i))
array.set(combined_array, i + (40 * 26), array.get(a27_array, i))
array.set(combined_array, i + (40 * 27), array.get(a28_array, i))
array.set(combined_array, i + (40 * 28), array.get(a29_array, i))
array.set(combined_array, i + (40 * 29), array.get(a30_array, i))
array.set(combined_array, i + (40 * 30), array.get(a31_array, i))
array.set(combined_array, i + (40 * 31), array.get(a32_array, i))
array.set(combined_array, i + (40 * 32), array.get(a33_array, i))
array.set(combined_array, i + (40 * 33), array.get(a34_array, i))
array.set(combined_array, i + (40 * 34), array.get(a35_array, i))
array.set(combined_array, i + (40 * 35), array.get(a36_array, i))
array.set(combined_array, i + (40 * 36), array.get(a37_array, i))
array.set(combined_array, i + (40 * 37), array.get(a38_array, i))
array.set(combined_array, i + (40 * 38), array.get(a39_array, i))
array.set(combined_array, i + (40 * 39), array.get(a40_array, i))
Calculating Sums: A separate array_sums is created to store the total score for each asset by summing the values of their respective score arrays. This allows for easy comparison of overall performance.
Ranking Assets: The final part of the code ranks the assets based on their total scores stored in array_sums. It assigns a rank to each asset, where the asset with the highest score receives the highest rank.
// create array for asset RANK based on array.sum
var ranks = array.new_int(used_assets, 0)
// for loop that calculates the rank of each asset
if barstate.islast
for i = 0 to (used_assets - 1)
int rank = 1
for x = 0 to (used_assets - 1)
if i != x
if array.get(array_sums, i) < array.get(array_sums, x)
rank := rank + 1
array.set(ranks, i, rank)
Dynamic Table Creation
Initialization: The table is initialized with a base structure that includes headers for asset names, scores, and ranks. The headers are set to remain constant, ensuring clarity for users as they interpret the displayed data.
Data Population: As scores are calculated for each asset, the corresponding values are dynamically inserted into the table. This is achieved through a loop that iterates over the scores and ranks stored in the combined_array and array_sums, respectively.
Automatic Extending Mechanism
Variable Asset Count: The code checks the number of assets defined by the user. Instead of hardcoding the number of rows in the table, it uses a variable to determine the extent of the data that needs to be displayed. This allows the table to expand or contract based on the number of assets being analyzed.
Dynamic Row Generation: Within the loop that populates the table, the code appends new rows for each asset based on the current asset count. The structure of each row includes the asset name, its score, and its rank, ensuring that the table remains consistent regardless of how many assets are involved.
// Automatically extending table based on the number of used assets
var table table = table.new(position.bottom_center, 50, 50, color.new(color.black, 100), color.white, 3, color.white, 1)
if barstate.islast
if not hide_head
table.cell(table, 0, 0, "Universal Ratio Trend Matrix", text_color = color.white, bgcolor = #010c3b, text_size = fontSize)
table.merge_cells(table, 0, 0, used_assets + 3, 0)
if not hide_inps
table.cell(table, 0, 1,
text = "Inputs: You are using " + str.tostring(trend_indicator) + ", which takes: " + str.tostring(f_get_input(trend_indicator)),
text_color = color.white, text_size = fontSize), table.merge_cells(table, 0, 1, used_assets + 3, 1)
table.cell(table, 0, 2, "Assets", text_color = color.white, text_size = fontSize, bgcolor = #010c3b)
for x = 0 to (used_assets - 1)
table.cell(table, x + 1, 2, text = str.tostring(array.get(assets, x)), text_color = color.white, bgcolor = #010c3b, text_size = fontSize)
table.cell(table, 0, x + 3, text = str.tostring(array.get(assets, x)), text_color = color.white, bgcolor = f_asset_col(array.get(ranks, x)), text_size = fontSize)
for r = 0 to (used_assets - 1)
for c = 0 to (used_assets - 1)
table.cell(table, c + 1, r + 3, text = str.tostring(array.get(combined_array, c + (r * 40))),
text_color = hl_type == "Text" ? f_get_col(array.get(combined_array, c + (r * 40))) : color.white, text_size = fontSize,
bgcolor = hl_type == "Background" ? f_get_col(array.get(combined_array, c + (r * 40))) : na)
for x = 0 to (used_assets - 1)
table.cell(table, x + 1, x + 3, "", bgcolor = #010c3b)
table.cell(table, used_assets + 1, 2, "", bgcolor = #010c3b)
for x = 0 to (used_assets - 1)
table.cell(table, used_assets + 1, x + 3, "==>", text_color = color.white)
table.cell(table, used_assets + 2, 2, "SUM", text_color = color.white, text_size = fontSize, bgcolor = #010c3b)
table.cell(table, used_assets + 3, 2, "RANK", text_color = color.white, text_size = fontSize, bgcolor = #010c3b)
for x = 0 to (used_assets - 1)
table.cell(table, used_assets + 2, x + 3,
text = str.tostring(array.get(array_sums, x)),
text_color = color.white, text_size = fontSize,
bgcolor = f_highlight_sum(array.get(array_sums, x), array.get(ranks, x)))
table.cell(table, used_assets + 3, x + 3,
text = str.tostring(array.get(ranks, x)),
text_color = color.white, text_size = fontSize,
bgcolor = f_highlight_rank(array.get(ranks, x)))
