1000X Dual T3 Set to Any Time Frame1000X Dual T3 Set to Any Time Frame
The "1000X Dual T3 Set to Any Time Frame" is an enhancement of the well-known T3 indicator, building upon the T3 Average script by HPotter , which was itself based on Tim Wilson's work on smoothing techniques. This version provides two T3 lines, which is useful when adapting one each to the long and short trends on the same chart, with the added flexibility of setting the indicator to a higher time frame than the one you are currently trading. We also make the "b" value adjustable, creating a more sensitivity, adaptable indicator. This indicator is recommended as a trend filter or confirmation indicator in trading strategies.
Key Features
Dual Trend Analysis: The dual T3 offers a view of long and short trends to aid in better optimized market analysis. This avoids the problem with using a single T3 line to filter tradable price action for both long and short sides, which forces one to compromise performance in order to achieve profitability in both directions.
Timeframe Customization: This indicator can be set to a desired timeframe while trading another. For example, the T3 can be set as a trend filter on the daily or weekly time frame to separate bull and bear markets, even as you work with other indicators on a chart set to a lower time frame. Set the time frame in the inputs, using minutes (15, 60, 240, etc.) or using D, W, and M.
Preserved T3 Script: Like the powerful HPotter script on which it builds, this indicator leverages EMA-based T3 smoothing calculations for smooth and responsive trend lines.
B Value adjustability: Given the role of the b value in smoothing and sensitivity, I have found it beneficial to make the b value an adjustable input as well. A higher b value will make the T3 line more responsive to recent price changes, making it closer to the actual price movements but potentially more susceptible to market noise.
Visual Trend Indicators: In addition to filtering markets using the "above or below" approach, this script provides colour coding to delineate trend directions.
Acknowledgments
As stated, this work is a tribute to the foundational contributions of Tim Wilson and the subsequent development by HPotter whose script was the basis of this one. The enhancements in this version aim to provide added value to the trading community.
Pesquisar nos scripts por "涨幅大于1000的股票"
Six T3 Bands – Set to Any Time Frame [1000X]Script Description: Six T3 Bands – Set to Any Time Frame
This script leverages T3 lines, an advanced form of moving averages, to provide more adaptive and responsive indicators compared to traditional Moving Averages (MA) or Exponential Moving Averages (EMA). The T3 indicator, originally conceptualized by Tim Tillson in 1998, is known for its smoothness and reduced lag, making it a powerful tool for traders seeking precise market signals.
Features:
1 Adjustable Parameters:
◦ The script allows for the customization of six different T3 lines, each with adjustable lengths and "b values" (smoothing coefficients). This flexibility lets users fine-tune the indicators to fit various trading styles and market conditions.
◦ Users can set the reference timeframe for the T3 lines using the request.security function, enabling analysis across different timeframes. By default, the timeframe is set to the daily chart.
2 Calculation Method:
◦ The T3 lines are calculated using a multi-stage Exponential Moving Average (EMA) process. Specifically, the price data is smoothed through six stages of EMA calculations, with coefficients applied to produce the final T3 value. This method ensures the T3 lines are smoother and less laggy than traditional moving averages.
3 Usage:
◦ The T3 lines can be utilized to identify natural support and resistance levels within the market. By observing how the price interacts with these lines, traders can gain insights into potential reversal points or continuation patterns.
◦ The script's default settings are optimized for identifying these levels, but users are encouraged to adjust the parameters to match their specific trading strategies.
How to Use:
1 Customization:
◦ Access the script's settings to adjust the T3 lengths and "b values" for each of the six lines. This customization allows you to tailor the indicator to your preferred sensitivity and responsiveness.
◦ Set the reference timeframe according to your analysis needs. Whether you prefer intraday, daily, or longer-term charts, the T3 lines will remain set to the reference timeframe that you choose, while you focus your attention on the time frame of your choice.
2 Trading Strategies:
◦ Support and Resistance Trading: Use the T3 lines to identify key support and resistance zones. Look for price reactions around these lines to make informed trading decisions.
◦ Trend Confirmation: Combine the T3 lines with other technical indicators to confirm trends and filter out noise. The smoothness of the T3 lines helps in recognizing genuine trend changes.
Conclusion: This script builds on the foundational work of Tim Tillson and the classic T3 Average script by @HPotter (2014). Significant enhancements include making the "b value" an adjustable input and utilizing the request.security function to apply T3 lines to a specified timeframe. These improvements provide traders with greater control and adaptability, enhancing the practical utility of the T3 indicator.
The "Six T3 Bands – Set to Any Time Frame " script offers a useful tool for traders looking to enhance their technical analysis, both to visualize trend direction and to identify likely support and resistance levels. Its adaptive nature and customizable features make it a valuable addition to many trading strategies..
OBVious MA Indicator [1000X] On Balance Volume (OBV) is a gift to traders. OBV often provides a leading signal at the outset of a trend, when compression in the markets produces a surge in OBV prior to increased volatility.
This indicator demonstrates one method of utilizing OBV to your advantage. I call it the "OBVious MA Indicator ” only because it is simple in its mechanics. The primary utility of the OBVious MA indicator is as a volume confirmation filter that complements other components of a strategy.
Indicator Features:
• The Indicator revolves around the On Balance Volume indicator. OBV is a straightforward indicator: it registers a value by adding total volume traded on up candles, and subtracts total volume on down candles, generating a line by connecting those values. OBV was described in 1963 by Joe Granville in his book "Granville's New Key to Stock Market Profits” in which the author argues that OBV is the most vital key to success as a trader, with volume changes are a major predictor of price changes.
• Dual Moving Averages: here we use separate moving averages for entries and exits. This allows for more granular trade management; for example, one can either extend the length of the exit MA to hold positions longer, or shorten the MA for swifter exits, independently of the entry signals.
Execution: long trades are signalled when the OBV line crosses above the Long Entry Moving Average of the OBV. Long exits signals occur when the OBV line crosses under the Long Exit MA of the OBV. Shorts signal occur on a cross below the Short Entry MA, and exit signals come on a cross above the Short Exit MA.
Application:
While this indicator outlines entry and exit conditions based on OBV crossovers with designated moving averages, is is, as stated, best used in conjunction with a supporting cast of confirmatory indicators (feel free to drop me a note and tell me how you've used it). It can be used to confirm entries, or you might try using it as a sole exit indicator in a strategy.
Visualization:
The indicator includes conditional plotting of the OBV MAs, which plot based on the selected trading direction. This visualization aids in understanding how OBV interacts with the set moving averages.
Further Discussion:
We all know the importance of volume; this indicator demonstrates one simple yet effective method of incorporating the OBV for volume analysis. The OBV indicator can be used in many ways - for example, we can monitor OBV trend line breaks, look for divergences, or as we do here, watch for breaks of the moving average.
Despite its simplicity, I'm unaware of any previously published cases of this method. But the concept of applying MAs or EMAs to volume-based indicators like OBV is not uncommon in technical analysisIf, so I expect work like this has been done before. If you know of other similar indicators or strategies, please mention in the comments.
One comparable method uses EMAs of the OBV is QuantNomad’s "On Balance Volume Oscillator Strategy ”. That strategy uses a pair of EMAs on a normalized-range OBV-based oscillator. In that strategy, however, entry and exit signals occur on one EMA crossing the other, which places trades at distinctly different times than crossings of the OBV itself. Both are valid approaches with strength in simplicity.
Note: This is the indicator version of the Strategy found here .
OBVious MA Strategy [1000X Trader]Exploring OBV: The OBVious MA Strategy
Are you using On Balance Volume (OBV) effectively? OBV is a gift to traders. OBV often provides a leading signal at the outset of a trend, when compression in the markets produces a surge in OBV prior to increased volatility.
This strategy demonstrates one method of utilizing OBV to your advantage. I call it the "OBVious MA Strategy ” only because it is so simple in its mechanics. This is meant to be a demonstration, not a strategy to utilize in live trading, as the primary utility of the OBVious MA indicator is as a volume confirmation filter that complements other components of a strategy. That said, I felt useful to present this indicator in isolation in this strategy to demonstrate the power it holds.
Strategy Features:
• OBV is the core signal: this strategy revolves around the On Balance Volume indicator. OBV is a straightforward indicator: it registers a value by adding total volume traded on up candles, and subtracts total volume on down candles, generating a line by connecting those values. OBV was described in 1963 by Joe Granville in his book "Granville's New Key to Stock Market Profits” in which the author argues that OBV is the most vital key to success as a trader, as volume changes are a major predictor of price changes.
• Dual Moving Averages: here we use separate moving averages for entries and exits. This allows for more granular trade management; for example, one can either extend the length of the exit MA to hold positions longer, or shorten the MA for swifter exits, independently of the entry signals.
Execution: long trades are taken when the OBV line crosses above the Long Entry Moving Average of the OBV. Long exits occur when the OBV line crosses under the Long Exit MA of the OBV. Shorts enter on a cross below the Short Entry MA, and exit on a cross above the Short Exit MA.
• Directional Trading: a direction filter can be set to "long" or "short," but not “both”, given that there is no trend filter in this strategy. When used in a bi-directional strategy with a trend filter, we add “both” to the script as a third option.
Application:
While this strategy outlines entry and exit conditions based on OBV crossovers with designated moving averages, is is, as stated, best used in conjunction with a supporting cast of confirmatory indicators (feel free to drop me a note and tell me how you've used it). It can be used to confirm entries, or you might try using it as a sole exit indicator in a strategy.
Visualization:
The strategy includes conditional plotting of the OBV MAs, which plot based on the selected trading direction. This visualization aids in understanding how OBV interacts with the set moving averages.
Further Discussion:
We all know the importance of volume; this strategy demonstrates one simple yet effective method of incorporating the OBV for volume analysis. The OBV indicator can be used in many ways - for example, we can monitor OBV trend line breaks, look for divergences, or as we do here, watch for breaks of the moving average.
Despite its simplicity, I'm unaware of any previously published cases of this method. The concept of applying MAs or EMAs to volume-based indicators like OBV is not uncommon in technical analysis, so I expect that work like this has been done before. If you know of other similar indicators or strategies, please mention in the comments.
One comparable strategy that uses EMAs of the OBV is QuantNomad’s "On Balance Volume Oscillator Strategy ", which uses a pair of EMAs on a normalized-range OBV-based oscillator. In that strategy, however, entries and exits occur on one EMA crossing the other, which places trades at distinctly different times than crossings of the OBV itself. Both are valid approaches with strength in simplicity.
[STRATEGY][RS]MicuRobert EMA cross V2Great thanks Ricardo , watch this man . Start at 2014 December with 1000 euro.
5-Min Candle Ranges (Last 1000)Average candle size for 1000 candles. This indicators looks at the volatility of candles and averages the size of the candles.
4 EMAs With Colors(100,300,600,1000)+ichimoku Cloud4 EMAs With Colors(100,300,600,1000) To detect trend
+ichimoku Cloud to have successful trading
4 Exponential Moving Averages With Colors(100,300,600,1000)4 Exponential Moving Averages With Colors(100,300,600,1000) With Colors
To play with Scalper,Swing, intraday
Exchanges Combined Volume📊 Exchanges Combined Volume
(Aggregated Multi-Exchange Volume: Binance, OKX, Bybit, etc.) by BIGTAKER*
🔍 Purpose
The Exchanges Combined Volume indicator aggregates real-time trading volumes from multiple global exchanges for a specific asset (e.g., a cryptocurrency).
Instead of relying on a single market, it provides a broader view of market activity, helping users detect abnormal volume behavior and increased participation across the entire market.
⚙️ Supported Exchanges
* USDT Markets
`Binance`, `OKX`, `Bybit`, `Bitget`, `Gate.io`
* USD Markets
`Coinbase`, `Bitfinex`, `Bitstamp`
* Default
Includes the current chart symbol’s native volume by default.
🧮 Core Calculation Logic
1. 📛 Symbol Normalization (cleanSymbol)
Prefixes such as `1000`, `10000`, `100000`, or `1M` (common in leveraged tickers) are automatically removed to extract the base token.
> Example:
> `1000PEPEUSDT` → `PEPEUSDT`
2. 📈 Volume Requests from External Exchanges
Volume is retrieved using the `` format (e.g., `'BINANCE:PEPEUSDT'`, `'COINBASE:BTCUSD'`).
Invalid or delisted pairs are safely ignored using `ignore_invalid_symbol=true`.
3. 📊 Total Volume Calculation
totalVolume = usdtVolume + usdVolume + currentSymbolVolume
The indicator sums the volume from all target exchanges plus the volume from the current chart symbol.
4. 📏 Comparison to Average Volume
* Period: `length = 60` (Simple Moving Average over 60 candles)
* A candle is considered **high-intensity** if:
5. 🎨 Visual Styling
| Condition | Color | Meaning |
| -------------------------- | --------------------- | ----------------------- |
| High-volume Bullish Candle | Light Green (#30db78) | Strong Buying Activity |
| High-volume Bearish Candle | Bright Red (#ff0000) | Strong Selling Activity |
| Normal Bullish Candle | Dark Green (#3c7058) | Regular Buying Volume |
| Normal Bearish Candle | Dark Red (#682e2c) | Regular Selling Volume |
📌 Use Cases
* Detect synchronized volume surges across major global exchanges.
* Identify pre-pump accumulation phases on altcoins.
* Combine with premium gap indicators (e.g., Kimchi Premium) to identify leading market sentiment.
* Confirm breakout momentum with multi-exchange volume validation.
📘 Notes & Warnings
* Listing differences across exchanges may result in **zero volume** on some platforms.
* Prefixes like `1000`, `1M`, etc., are automatically removed to **improve symbol matching accuracy**.
* As volume units are not standardized, this indicator is best suited for **absolute value analysis**, not ratio-based comparisons.
Industry Group Strength - IndiaPresenting the Industry Group Strength Indicator for India market, designed to help traders identify top-performing stocks within specific industry groups that are predefined.
⦿ Identifies Leading Stocks in Industry Groups
⦿ Analyses the following metrics
YTD Return : Measures stock performance from the start of the year.
RS Rating : Relative Strength rating for user-selected periods.
% Return : Percentage return over a user-selected lookback period.
Features
This indicator dynamically recognises the industry group of the current stock on the chart and ranks stocks within that group based on predefined data points. Traders can add this indicator to focus on top-performing stocks relative to their industry.
⦿ Color-coded for Easy Visualisation
You can choose from the following key metrics to rank stocks:
YTD Return
RS Rating
% Return
⦿ Table Format with Performance Metrics Compact mode
Vertical View
Horizontal View
All of the three metrics are shown in the compact mode and the current stock that is viewed is highlighted!
Vertical view
Horizontal view
Stock Ranking
Stocks are ranked based on their performance within industry groups, enabling traders to easily spot leaders and laggards in each sector. Color-coded gradients visually represent the stocks’ performance rankings, with higher percentile rankings indicating better performance.
Relative Strength (RS)
Relative Strength (RS) compares a stock’s performance against the benchmark index. The RS value is normalized from 1 to 99, making it easier to compare across different stocks. A rising RS value indicates that the stock is outperforming the market, helping traders quickly gauge relative performance within industry groups.
Limitations
At the time of developing this indicator, Pine requests are limited to 40 per script so the predefined symbols had to be filtered to 40 per Industry group
Stocks Filters
Filters that are used to filter the stocks in an Industry group to have maximum of 40 stocks
⦿ Auto, Chemical, Engineering, Finance, Pharma
Market Cap >= 1000 Crores and Market Cap <= 60000 Crores
Price >= 30 and Price <= 6000
50 Days Average ( Price * Volume ) >= 6 Crores
⦿ For rest of the Industry groups
Market Cap >= 1000 Crores and Market Cap <= 100000 Crores
Price >= 20 and Price <= 10000
50 Days Average ( Price * Volume ) >= 3 Crores
Credits
This indicator is forked from the Script for US market by @Amphibiantrading Thanks Brandon for the beginning of this indicator.
This indicator is built on TradingView’s new dynamic requests feature, thanks to @PineCoders for making this possible!
Binance Spot vs Perpetual Price index by BIGTAKER📌 Overview
This indicator calculates the premium (%) between Binance Perpetual Futures and Spot prices in real time and visualizes it as a column-style chart.
It automatically detects numeric prefixes in futures symbols—such as `1000PEPE`, `1MFLUX`, etc.—and applies the appropriate scaling factor to ensure accurate 1:1 price comparisons with corresponding spot pairs, without requiring manual configuration.
Rather than simply showing raw price differences, this tool highlights potential imbalances in supply and demand, helping to identify phases of market overheating or panic selling.
🔧 Component Breakdown
1. ✅ Auto Symbol Mapping & Prefix Scaling
Automatically identifies and processes common numeric prefixes (`1000`, `1M`, etc.) used in Binance perpetual futures symbols.
Example:
`1000PEPEUSDT.P` → Spot symbol: `PEPEUSDT`, Scaling factor: `1000`
This ensures precise alignment between futures and spot prices by adjusting the scale appropriately.
2. 📈 Premium Calculation Logic
Formula:
(Scaled Futures Price − Spot Price) / Spot Price × 100
Interpretation:
* Positive (+) → Futures are priced higher than spot: indicates possible long-side euphoria
* Negative (−) → Futures are priced lower than spot: indicates possible panic selling or oversold conditions
* Zero → Equilibrium between futures and spot pricing
3. 🎨 Visualization Style
* Rendered as column plots (bar chart) on each candle
* Color-coded based on premium polarity:
* 🟩 Positive premium: Light green (`#52ff7d`)
* 🟥 Negative premium: Light red (`#f56464`)
* ⬜ Neutral / NA: Gray
* A dashed horizontal line at 0% is included to indicate the neutral zone for quick visual reference
💡 Strategic Use Cases
| Market Behavior | Strategy / Interpretation |
| ----------------------------------------- | ------------------------------------------------------------------------ |
| 📈 Premium surging | Strong futures demand → Overheated longs (short setup) |
| 📉 Premium dropping | Aggressive selling in futures → Oversold signal (long setup) |
| 🔄 Near-zero premium | Balanced market → Wait and observe or reassess |
| 🧩 Combined with funding rate or OI delta | Enables multi-factor confirmation for short-term or mid-term signals |
🧠 Technical Advantages
* Fully automated scaling for prefixes like `1000`, `1M`, etc.
* Built-in error handling for inactive or missing symbols (`ignore_invalid_symbol=true`)
* Broad compatibility with Binance USDT Spot & Perpetual Futures markets
🔍 Target Use Cases & Examples
Compatible symbols:
`1000PEPEUSDT.P`, `DOGEUSDT.P`, `1MFLUXUSDT.P`, `ETHUSDT.P`, and most other Binance USDT-margined perpetual futures
Works seamlessly with:
* Binance Spot Market
* Binance Perpetual Futures Market
TICK Charting & DivergencesOverview
The TICK index measures the number of NYSE stocks making an uptick versus a downtick. This indicator identifies divergences between price action and TICK readings, potentially signaling trend reversals.
Key Features
Real-time TICK monitoring during market hours (9:30 AM - 4:00 PM ET)
Customizable smoothing factor for TICK values
Regular and hidden divergences detection
Reference lines at ±500 and ±1000 levels
Current TICK value display
TICK Internals Interpretation
Above +1000: Strong buying pressure, potential exhaustion
Above +500: Moderate buying pressure
Below -500: Moderate selling pressure
Below -1000: Strong selling pressure, potential exhaustion
Best Practices
Use in conjunction with support/resistance levels, market trend direction, and time of day.
Higher probability setups with multiple timeframe confirmation, divergence at key price levels, and extreme TICK readings (±1000).
Settings Optimization
Smoothing Factor: 1-3 (lower for faster signals)
Pivot Lookback: 5-10 bars (adjust based on timeframe)
Range: 5-60 bars (wider for longer-term signals)
Warning Signs
Multiple failed divergences
Choppy price action
Low volume periods
Major news events pending
Remember: TICK divergences are not guaranteed signals. Always use proper risk management and combine with other technical analysis tools.
BB21_MA200_StrategyThis strategy follows the trend and keeps you in the trend until it breaks SMA 200
SMA setting is 200
BB setting is 21
BUY
====
when BB is (lower band and upper band) above SMA 200 and price crossing above BB middle line
Partial Exit
==========
When Lower BB crossing down SMA200 , exit 30%
Total Exit
=========
When BB middle band crosses down SMA200 , exit ALL
Stop Loss
======
default is set to 5%
Risk Management
================
This is new parameter I have introduced in my strategies. Default value is 10% . That means , if your capital is 10000 , you are willing to risk 10% of it ... i.e 1000.
It doesnot mean that you are buying shares/units for 1000 only. It is different ...see below
Your trade size is calculated based on Risk% .... capital x risk 5 / stop Loss units
for further explanation you can check Alexander Elder's risk management rule. He mentioned 2% rule for 100K account. But most of us dont have 100K accounts .. . so I have defaulted 10% on 10K account. You can change this values and see the results. It wont change the number of trades or profit factor. It will increase the net profit.
Warning
=======
For educational purposes only
TICK Extreme Zones Indicator OverlayOverview :
The TICK Extreme Zones Indicator Overlay is designed to gauge the overall market trend using the TICK index. By determining the number of bullish (values above 0) and bearish (values below 0) TICK closes within a user-specified lookback period, it provides an insight into the prevailing market sentiment. This insight can be beneficial for traders looking to identify potential entry or exit points based on the market's strength or weakness.
Key Features :
Lookback Period : This is a user-defined time frame in minutes. The indicator counts the number of bullish and bearish TICK closes within this period.
Market Trend Label : Based on the TICK values, the indicator determines if the market is:
Uptrending: Majority of TICK values are positive.
Downtrending: Majority are negative.
Neutral/Rangebound: Equal positive and negative closes.
Zones : These represent certain threshold levels in the TICK values.
Positive Zones:
Dark Blue: 1000
Light Blue: 800 & 600
Negative Zones:
Red: -1000
Yellow: -800 & -600
Touch Detection Method : Detects intraday touches and can be toggled on/off based on the user's preference.
Usage Guidelines :
Trending Market :
In a trending market, the TICK index can remain consistently above or below zero.
For a market moving upwards, it's advisable to consider entering a trade when the indicator returns to zero instead of waiting for it to return to -1000.
Using Exponential Moving Averages (EMAs) can provide additional confirmation of the trend.
Rangebound Market :
For sideways markets, consider initiating a long position when the TICK index goes below -1000 and exit the position when the index reaches +1000.
It's beneficial to pair these readings with significant support and resistance levels to make more informed trading decisions.
Divergence :
Divergence between the TICK index and price can be a good measure of the underlying market strength.
If a stock's price is making lower lows, but the TICK index is making higher lows, it might indicate weakening selling momentum.
Notes:
- Always use this indicator in conjunction with other technical analysis tools.
- Proper risk management practices are crucial when using any trading tool or strategy.
whookLibrary "whook"
This library provides functions for generating trading alerts for `whook`
check this -> github.com
Currently supported exchanges:
Kucoin futures
Bitget futures
Coinex futures
Bingx
OKX futures ( also its demo mode )
Bybit futures ( also Bybit testnet )
Binance futures ( also Binance futures testnet )
Phemex futures ( also Phemex testnet )
Kraken futures ( also Kraken futures testnet )
# --- Test Cases ---
Note: These test cases are for demonstration purposes only and may not cover all scenarios.
// buy(string account, float amount, string unit = "units", float leverage = 1)
buy("MyAccount", 100, "units", 1)
buy("MyAccount", 1000, "USDT", 5)
buy("MyAccount", 50, "percent", 2)
// sell(string account, float amount, string unit = "units", float leverage = 1)
sell("MyAccount", 50, "units", 1)
sell("MyAccount", 500, "USDT", 3)
sell("MyAccount", 25, "percent", 2)
// set_position(string account, float amount, string unit = "units", float leverage = 1)
set_position("MyAccount", 100, "units", 1)
set_position("MyAccount", 1000, "USDT", 5)
set_position("MyAccount", 50, "percent", 2)
// limit_buy(string account, float amount, float price, string unit = "units", float leverage = 1, string id = "")
limit_buy("MyAccount", 100, 10000, "units", 1, "MyBuyOrder")
limit_buy("MyAccount", 1000, 10500, "USDT", 5)
limit_buy("MyAccount", 50, 11000, "percent", 2)
// limit_sell(string account, float amount, float price, string unit = "units", float leverage = 1, string id = "")
limit_sell("MyAccount", 50, 10000, "units", 1, "MySellOrder")
limit_sell("MyAccount", 500, 9500, "USDT", 3)
limit_sell("MyAccount", 25, 9000, "percent", 2)
// close_percent(string account, float pct = 100)
close_percent("MyAccount", 100)
close_percent("MyAccount", 50)
buy(account, amount, unit, leverage)
Sends a trading alert to execute a market buy order.
Parameters:
account (string) : The account ID.
amount (float) : The amount to buy (can be in USD, units, or percentage).
unit (string) : The unit of the amount (optional, defaults to "units").
leverage (float) : The leverage to use (optional, defaults to 1x).
sell(account, amount, unit, leverage)
Sends a trading alert to execute a market sell order.
Parameters:
account (string) : The account ID.
amount (float) : The amount to sell (can be in USD, units, or percentage).
unit (string) : The unit of the amount (optional, defaults to "units").
leverage (float) : The leverage to use (optional, defaults to 1x).
set_position(account, amount, unit, leverage)
Sends a trading alert to set a position.
Parameters:
account (string) : The account ID.
amount (float) : The amount to set the position to (can be in USD, units, or percentage).
unit (string) : The unit of the amount (optional, defaults to "units").
leverage (float) : The leverage to use (optional, defaults to 1x).
limit_buy(account, amount, price, unit, leverage, id)
Sends a trading alert to place a limit buy order.
Parameters:
account (string) : The account ID.
amount (float) : The amount to buy (can be in USD, units, or percentage).
price (float) : The limit price.
unit (string) : The unit of the amount (optional, defaults to "units").
leverage (float) : The leverage to use (optional, defaults to 1x).
id (string) : An optional custom ID for the limit order.
limit_sell(account, amount, price, unit, leverage, id)
Sends a trading alert to place a limit sell order.
Parameters:
account (string) : The account ID.
amount (float) : The amount to sell (can be in USD, units, or percentage).
price (float) : The limit price.
unit (string) : The unit of the amount (optional, defaults to "units").
leverage (float) : The leverage to use (optional, defaults to 1x).
id (string) : An optional custom ID for the limit order.
close_percent(account, pct)
Sends an alert to close a position on Phemex.
Parameters:
account (string) : The account ID.
pct (float) : The percentage of the position to close (optional, defaults to 100%).
Price Change IndicatorPrice Change Indicator (PCI)
Version: 1.0
Author: LazyTrader 🚀
🔍 Overview
The Price Change Indicator (PCI) helps traders visualize and compare price changes between the current bar and the previous bar. It provides a customizable display of price changes in two formats:
Percentage (%) Change – Relative price movement.
Natural Change – Absolute difference in price units.
⚙️ Key Features
✅ Customizable Calculation Method: Choose how the price change is calculated:
Opening Price
Closing Price
High
Low
✅ Flexible Display Format:
Show Percentage (%) Change.
Show Natural (Absolute) Change in price.
✅ Adjustable Sensitivity with Multiplier:
100 (Standard Change)
1000 (Small Change)
10000 (Tiny Change)
✅ Intuitive Labeling:
Green label (above bar) for increase.
Red label (below bar) for decrease.
No label if no change.
Large, easy-to-read labels for better visibility.
✅ Perfect for Any Market:
Stocks 📈
Forex 💱
Crypto 🚀
Commodities 🛢️
📊 How It Works
The indicator calculates the difference between the current and previous bar’s price based on your chosen method.
The result is displayed as either a percentage (%) or a natural price change.
If the price has increased, a green label is displayed above the bar.
If the price has decreased, a red label is displayed below the bar.
⚡ How to Use
Add the indicator to your chart.
Go to settings and customize:
Select calculation method (Open, Close, High, Low).
Choose display format (% or Natural Change).
Adjust multiplier for more sensitivity.
Analyze the labels to see price movements easily!
🔧 Settings Explained
Setting Description
Price Calculation Method: Choose Open, Close, High, or Low price for comparison.
Display Format: Show either % Change or Natural Change.
Multiplier: Apply 100, 1000, or 10000 to scale small price changes.
Show Labels: Toggle labels on/off.
🎯 Best Use Cases
🔹 Identifying strong price movements
🔹 Spotting trends and momentum shifts
🔹 Comparing price movement intensity
🔹 Works for scalping, swing trading, and long-term analysis
OHLC MeansNote: This indicator works only on daily timeframes.
The indicator calculates the OHLC averages for days corresponding to the day of the last displayed candlestick. For instance, if the last candlestick displayed is Monday, it calculates the OHLC average for all Mondays; if Tuesday, it does the same for all Tuesdays.
Customizable period: The indicator allows you to select the number of candlesticks to analyze, with a default value of 1000. This means it will consider the last 1000 candlesticks before the final displayed one. Assuming there are only five trading days per week, this corresponds to about 200 days. (not true for cryptos, you need to devide by 7)
Example scenario:
Today is Tuesday and we analyse NQ
By default, the indicator analyzes the last 1000 candlesticks (modifiable parameter).
Since there are five trading days in a week,
1000 ÷ 5 = 200
The indicator calculates the OHLC averages for the last 200 Tuesdays, corresponding to the past seven years. Of course it is not exactly 200 becauses the may be one tuesday where the market is closed (if christmas is on tuesday for instance)
Output:
Displays four daily averages as four lines with their levels as labels :
High and Low averages are displayed at the extremes.
Open and Close averages are displayed at the center.
Color coding:
Red indicates bearish movement.
Green indicates bullish movement.
Usage recommendations:
Best suited for assets with a significant historical dataset.
Only functional on daily timeframes.
benchLibrary "bench"
A simple banchmark library to analyse script performance and bottlenecks.
Very useful if you are developing an overly complex application in Pine Script, or trying to optimise a library / function / algorithm...
Supports artificial looping benchmarks (of fast functions)
Supports integrated linear benchmarks (of expensive scripts)
One important thing to note is that the Pine Script compiler will completely ignore any calculations that do not eventually produce chart output. Therefore, if you are performing an artificial benchmark you will need to use the bench.reference(value) function to ensure the calculations are executed.
Please check the examples towards the bottom of the script.
Quick Reference
(Be warned this uses non-standard space characters to get the line indentation to work in the description!)
```
// Looping benchmark style
benchmark = bench.new(samples = 500, loops = 5000)
data = array.new_int()
if bench.start(benchmark)
while bench.loop(benchmark)
array.unshift(data, timenow)
bench.mark(benchmark)
while bench.loop(benchmark)
array.unshift(data, timenow)
bench.mark(benchmark)
while bench.loop(benchmark)
array.unshift(data, timenow)
bench.stop(benchmark)
bench.reference(array.get(data, 0))
bench.report(benchmark, '1x array.unshift()')
// Linear benchmark style
benchmark = bench.new()
data = array.new_int()
bench.start(benchmark)
for i = 0 to 1000
array.unshift(data, timenow)
bench.mark(benchmark)
for i = 0 to 1000
array.unshift(data, timenow)
bench.stop(benchmark)
bench.reference(array.get(data, 0))
bench.report(benchmark,'1000x array.unshift()')
```
Detailed Interface
new(samples, loops) Initialises a new benchmark array
Parameters:
samples : int, the number of bars in which to collect samples
loops : int, the number of loops to execute within each sample
Returns: int , the benchmark array
active(benchmark) Determing if the benchmarks state is active
Parameters:
benchmark : int , the benchmark array
Returns: bool, true only if the state is active
start(benchmark) Start recording a benchmark from this point
Parameters:
benchmark : int , the benchmark array
Returns: bool, true only if the benchmark is unfinished
loop(benchmark) Returns true until call count exceeds bench.new(loop) variable
Parameters:
benchmark : int , the benchmark array
Returns: bool, true while looping
reference(number, string) Add a compiler reference to the chart so the calculations don't get optimised away
Parameters:
number : float, a numeric value to reference
string : string, a string value to reference
mark(benchmark, number, string) Marks the end of one recorded interval and the start of the next
Parameters:
benchmark : int , the benchmark array
number : float, a numeric value to reference
string : string, a string value to reference
stop(benchmark, number, string) Stop the benchmark, ending the final interval
Parameters:
benchmark : int , the benchmark array
number : float, a numeric value to reference
string : string, a string value to reference
report(Prints, benchmark, title, text_size, position)
Parameters:
Prints : the benchmarks results to the screen
benchmark : int , the benchmark array
title : string, add a custom title to the report
text_size : string, the text size of the log console (global size vars)
position : string, the position of the log console (global position vars)
unittest_bench(case) Cache module unit tests, for inclusion in parent script test suite. Usage: bench.unittest_bench(__ASSERTS)
Parameters:
case : string , the current test case and array of previous unit tests (__ASSERTS)
unittest(verbose) Run the bench module unit tests as a stand alone. Usage: bench.unittest()
Parameters:
verbose : bool, optionally disable the full report to only display failures
Ultimate Machine Learning MACD (Deep Learning Edition)This script is a "Deep Learning MACD" indicator that combines traditional MACD calculations with advanced machine learning techniques, including recursive feedback, adaptive learning rates, Monte Carlo simulations, and volatility-based adjustments. Here’s a breakdown of its key components:
Inputs
Lookback: The length of historical data (1000 by default) used for learning and volatility measurement.
Momentum and Volatility Weighting: Adjusts how much momentum and volatility contribute to the learning process (momentum weight: 1.2, volatility weight: 1.5).
MACD Lengths: Defines the range for MACD fast and slow lengths, starting at minimum of 1 and max of 1000.
Learning Rate: Defines how much the model learns from its predictions (very small learning rate by default).
Adaptive Learning: Enables dynamic learning rates based on market volatility.
Memory Factor: A feedback factor that determines how much weight past performance has in the current model.
Simulations: The number of Monte Carlo simulations used for probabilistic modeling.
Price Change: Calculated as the difference between the current and previous close.
Momentum: Measured using a lookback period (1000 bars by default).
Volatility: Standard deviation of closing prices.
ATR: Average true range over 14 periods for measuring market volatility.
Custom EMA Calculation
Implements an exponential moving average (EMA) formula from scratch using a recursive calculation with a smoothing factor.
Dynamic Learning Rate
Adjusts the learning rate based on market volatility. When volatility is high, the learning rate increases, and when volatility is low, it decreases. This makes the model more responsive during volatile markets and more stable during calm periods.
Error Calculation and Adjustment
Error Calculation: Measures the difference between the predicted value (via Monte Carlo simulations) and the true MACD value.
Adjust MACD Length: Uses the error to adjust the fast and slow MACD lengths dynamically, so the system can learn from market conditions.
Probabilistic Monte Carlo Simulation
Runs multiple simulations (200 by default) to generate probabilistic predictions. It uses random values weighted by momentum and volatility to simulate various market scenarios, enhancing
prediction accuracy.
MACD Calculation (Learning-Enhanced)
A custom MACD function that calculates:
Fast EMA and Slow EMA for MACD line.
Signal Line: An EMA of the MACD line.
Histogram: The difference between the MACD and signal lines.
Adaptive MACD Calculation
Adjusts the fast and slow MACD lengths based on the error from the Monte Carlo prediction.
Calculates the adaptive MACD, signal, and histogram using dynamically adjusted lengths.
Recursive Memory Feedback
Stores previous MACD values in an array (macdMemory) and averages them to create a feedback loop. This adds a "memory" to the system, allowing it to learn from past behaviors and refine future predictions.
Volatility-Based Reinforcement
Introduces a volatility reinforcement factor that influences the signal based on market conditions. It adds volatility awareness to the feedback system, making the system more reactive during high volatility periods.
Smoothed MACD
After all the adjustments, the MACD line is further smoothed based on the current market volatility, resulting in a final smoothed MACD.
Key Features
Monte Carlo Simulation: Runs multiple simulations to enhance predictions based on randomness and market behavior.
Adaptive Learning: Dynamic adjustments of learning rates and MACD lengths based on market conditions.
Recursive Feedback: Uses past data as feedback to refine the system’s predictions over time.
Volatility Awareness: Integrates market volatility into the system, making the MACD more responsive to market fluctuations.
This combination of traditional MACD with machine learning creates an adaptive indicator capable of learning from past behaviors and adjusting its sensitivity based on changing market conditions.
Volume Profile (Maps) [LuxAlgo]The Pine Script® developers have unleashed "maps"!
Volume Profile (Maps) displays volume, associated with price, above and below the latest price, by using maps
The largest and second-largest volume is highlighted.
🔶 USAGE
The proposed script can highlight more frequent closing prices/prices with the highest volume, potentially highlighting more liquid areas. The prices with the highest associated volume (in red and orange in the indicator) can eventually be used as support/resistance levels.
Voids within the volume profile can highlight large price displacements (volatile variations).
🔶 CONCEPTS
🔹 Maps
A map object is a collection that consists of key - value pairs
Each key is unique and can only appear once. When adding a new value with a key that the map already contains, that value replaces the old value associated with the key .
You can change the value of a particular key though, for example adding volume (value) at the same price (key), the latter technique is used in this script.
Volume is added to the map, associated with a particular price (default close, can be set at high, low, open,...)
When the map already contains the same price (key), the value (volume) is added to the existing volume at the associated price.
A map can contain maximum 50K values, which is more than enough to hold 20K bars (Basic 5K - Premium plan 20K), so the whole history can be put into a map.
🔹 Visible line/box limit
We can only display maximum 500 line.new() though.
The code locates the current (last) close, and displays volume values around this price, using lines, for example 250 lines above and 250 lines below current price.
If one side contains fewer values, the other side can show more lines, taking the maximum out of the 500 visible line limitation.
Example (max. 500 lines visible)
• 100 values below close
• 2000 values above close
-> 100 values will be displayed below close
-> 400 remaining -> 400 values will be displayed above close
Pushing the limits even further, when ' Amount of bars ' is set higher than 500, boxes - box.new() - will be used as well.
These have a limit of 500 as well, bringing the total limit to 1000.
Note that there are visual differences when boxes overlap against lines.
If this is confusing, please keep ' Amount of bars ' at max. 500 (then only lines will be used).
🔹 Rounding function
This publication contains 2 round functions, which can be used to widen the Volume Profile
Round
• "Round" set at zero -> nothing changes to the source number
• "Round" set below zero -> x digit(s) after the decimal point, starting from the right side, and rounded.
• "Round" set above zero -> x digit(s) before the decimal point, starting from the right side, and rounded.
Example: 123456.789
0->123456.789
1->123456.79
2->123456.8
3->123457
-1->123460
-2->123500
Step
Another option is custom steps.
After setting "Round" to "Step", choose the desired steps in price,
Examples
• 2 -> 1234.00, 1236.00, 1238.00, 1240.00
• 5 -> 1230.00, 1235.00, 1240.00, 1245.00
• 100 -> 1200.00, 1300.00, 1400.00, 1500.00
• 0.05 -> 1234.00, 1234.05, 1234.10, 1234.15
•••
🔶 FEATURES
🔹 Adjust position & width
🔹 Table
The table shows the details:
• Size originalMap : amount of elements in original map
• # higher: amount of elements, higher than last "close" (source)
• index "close" : index of last "close" (source), or # element, lower than source
• Size newMap : amount of elements in new map (used for display lines)
• # higher : amount of elements in newMap, higher than last "close" (source)
• # lower : amount of elements in newMap, lower than last "close" (source)
🔹 Volume * currency
Let's take as example BTCUSD, relative to USD, 10 volume at a price of 100 BTCUSD will be very different than 10 volume at a price of 30000 (1K vs. 300K)
If you want volume to be associated with USD, enable Volume * currency . Volume will then be multiplied by the price:
• 10 volume, 1 BTC = 100 -> 1000
• 10 volume, 1 BTC = 30K -> 300K
Disabled
Enabled
🔶 DETAILS
🔹 Put
When the map doesn't contain a price, it will be added, using map.put(id, key, value)
In our code:
map.put(originalMap, price, volume)
or
originalMap.put(price, volume)
A key (price) is now associated with a value (volume) -> key : value
Since all keys are unique, we don't have to know its position to extract the value, we just need to know the key -> map.get(id, key)
We use map.get() when a certain key already exists in the map, and we want to add volume with that value.
if originalMap.contains(price)
originalMap.put(price, originalMap.get(price) + volume)
-> At the last bar, all prices (source) are now associated with volume.
🔹 Copy & sort
Next, every key of the map is copied and sorted (array of keys), after which the index (idx) is retrieved of last (current) price.
copyK = originalMap.keys().copy()
copyK.sort()
idx = copyK.binary_search_leftmost(src)
Then left and right side of idx is investigated to show a maximum amount of lines at both sides of last price.
🔹 New map & display
The keys (from sorted array of copied keys) that will be displayed are put in a new map, with the associated volume values from the original map.
newMap = map.new()
🔹 Re-cap
• put in original amp (price key, volume value)
• copy & sort
• find index of last price
• fetch relevant keys left/right from that index
• put keys in new map and fetch volume associated with these keys (from original map)
Simple example (only show 5 lines)
bar 0, price = 2, volume = 23
bar 1, price = 4, volume = 3
bar 2, price = 8, volume = 21
bar 3, price = 6, volume = 7
bar 4, price = 9, volume = 13
bar 5, price = 5, volume = 85
bar 6, price = 3, volume = 13
bar 7, price = 1, volume = 4
bar 8, price = 7, volume = 9
Original map:
Copied keys array:
Sorted:
-> 5 keys around last price (7) are fetched (5, 6, 7, 8, 9)
-> keys are placed into new map + volume values from original map
Lastly, these values are displayed.
🔶 SETTINGS
Source : Set source of choice; default close , can be set as high , low , open , ...
Volume & currency : Enable to multiply volume with price (see Features )
Amount of bars : Set amount of bars which you want to include in the Volume Profile
Max lines : maximum 1000 (if you want to use only lines, and no boxes -> max. 500, see Concepts )
🔹 Round -> ' Round/Step '
Round -> see Concepts
Step -> see Concepts
🔹 Display Volume Profile
Offset: shifts the Volume Profile (max. 500 bars to the right of last bar, see Features )
Max width Volume Profile: largest volume will be x bars wide, the rest is displayed as a ratio against largest volume (see Features )
Show table : Show details (see Features )
🔶 LIMITATIONS
• Lines won't go further than first bar (coded).
• The Volume Profile can be placed maximum 500 bar to the right of last price.
• Maximum 500 lines/boxes can be displayed
LNL Smart TICKLNL Smart TICK
This study is mostly beneficial for intraday traders. It is basically a user-friendly "colorful" representation of the $TICK chart with highlighted $TICK extremes. This indicator also includes: a simple trend gauge that can visualize the bias for the day, cumulative tick cloud which is showing the cumulative strength of either longs & shorts on the day.
$TICK Trend Gauge
Although it is just a exponential moving average. This average (default set on 20) works quite well as an overall gauge for the day. Whenever the gauge is green (above zero), any negative $TICK values below -500 can offer great pullback opportunities. Same applies for the red gauge. 20 EMA is below zero ? Great time to fade any +500 or +1000 tick readings. Obviously the gauge can be ajdusted to any number based on personal style.
$TICK Extremes (little triangles)
These little triangles are triggered anytime $TICK jumps above or below the pre-set values of +1000 or -1000. By just simply observing the $TICK triangles during the day can tell you how much volaility or pressure there is. Sometimes there will be 20 green triangles and only 2 red ones. That obviously mean there is a strong bearish pressure. But there will be days when you are not going to see any triangles at all which can mean there is either a low volatility or the price is stuck in the indecisive market.
Cumulative $TICK Cloud
Cumulative $TICK by itself is a great study for day traders. It is basically running "counting" $TICK that is adding the previous $TICK values from previous bars. Cumulative $TICK can create a direct picture of the current market sentiment. It is not just a simple green / red line but a cloud that can really show you the depth on the $TICK. Some days, the cloud will be quite wide which is a good sign for the strength to one side, but sometimes the cloud will be so narrow it will practically disappear. This would be telling you the exact opposite - not much conviction to any side. Of course the depth as well as the color of the cloud can change during the day.
$TICK & Cumulative $TICK Tables
By just looking at these tables. You can immidiately tell the state of the current $TICK. They both can be red or green. It all depends whether the values are positive or negative. The tables are just a little visual addition to the whole $TICK study.
Hope it helps.
Volatility Percentile🎲 Volatility is an important measure to be included in trading plan and strategy. Strategies have varied outcome based on volatility of the instruments in hand.
For example,
🚩 Trend following strategies work better on low volatility instruments and reversal patterns work better in high volatility instruments. It is also important for us to understand the median volatility of an instrument before applying particular strategy strategy on them.
🚩 Different instrument will have different volatility range. For instance crypto currencies have higher volatility whereas major currency pairs have lower volatility with respect to their price. It is also important for us to understand if the current volatility of the instrument is relatively higher or lower based on the historical values.
This indicator is created to study and understand more about volatility of the instruments.
⬜ Process
▶ Volatility metric used here is ATR as percentage of price. Other things such as bollinger bandwidth etc can also be used with few changes.
▶ We use array based counters to count ATR values in different range. For example, if we are measuring ATR range based on precision 2, we will use array containing 10000 values all initially set to 0 which act as 10000 buckets to hold counters of different range. But, based on the ATR percentage range, they will be incremented. Let's say, if atr percent is 2, then 200th element of the array is increased by 1.
▶ When we do this for every bar, we have array of counters which has the division on how many bars had what range of atr percent.
▶ Using this array, we can calculate how many bars had atr percent more than current value, how many had less than current value, and how many bars in history has same atr percent as current value.
▶ With these information, we can calculate the percentile of atr percentage value. We can also plot a detailed table mentioning what percentile each range map to.
⬜ Settings
▶ ATR Parameters - this include Moving average type and Length for atr calculation.
▶ Rounding type refers to rounding ATR percentage value before we put into certain bucket. For example, if ATR percentage 2.7, round or ceil will make it 3, whereas floor will make it 2 which may fall into different buckets based on the precision selected.
▶ Precision refers to how much detailed the range should be. If precision set to 0, then we get array of 100 to collect the range where each value will represent a range of 1%. Similarly precision of 1 will lead to array of 1000 with each item representing range of 0.1. Default value used is 2 which is also the max precision possible in this script. This means, we use array of 10000 to track the range and percentile of the ATR.
▶ Display Settings - Inverse when applied track percentile with respect to lowest value of ATR instead of high. By default this is set to false. Other two options allow users to enable stats table. When detailed stats are enabled, ATR Percentile as plot is hidden.
▶ Table Settings - Allows users to select set size and coloring options.
▶ Indicator Time Window - Allow users to select particular timeframe instead of all available bars to run the study. By default windows are disabled. Users can chose start and end time individually.
Indicator display components can be described as below:
Polyline PlusThis library introduces the `PolylinePlus` type, which is an enhanced version of the built-in PineScript `polyline`. It enables two features that are absent from the built-in type:
1. Developers can now efficiently add or remove points from the polyline. In contrast, the built-in `polyline` type is immutable, requiring developers to create a new instance of the polyline to make changes, which is cumbersome and incurs a significant performance penalty.
2. Each `PolylinePlus` instance can theoretically hold up to ~1M points, surpassing the built-in `polyline` type's limit of 10K points, as long as it does not exceed the memory limit of the PineScript runtime.
Internally, each `PolylinePlus` instance utilizes an array of `line`s and an array of `polyline`s. The `line`s array serves as a buffer to store lines formed by recently added points. When the buffer reaches its capacity, it flushes the contents and converts the lines into polylines. These polylines are expected to undergo fewer updates. This approach is similiar to the concept of "Buffered I/O" in file and network systems. By connecting the underlying lines and polylines, this library achieves an enhanced polyline that is dynamic, efficient, and capable of surpassing the maximum number of points imposed by the built-in polyline.
🔵 API
Step 1: Import this library
import algotraderdev/polylineplus/1 as pp
// remember to check the latest version of this library and replace the 1 above.
Step 2: Initialize the `PolylinePlus` type.
var p = pp.PolylinePlus.new()
There are a few optional params that developers can specify in the constructor to modify the behavior and appearance of the polyline instance.
var p = pp.PolylinePlus.new(
// If true, the drawing will also connect the first point to the last point, resulting in a closed polyline.
closed = false,
// Determines the field of the chart.point objects that the polyline will use for its x coordinates. Either xloc.bar_index (default), or xloc.bar_time.
xloc = xloc.bar_index,
// Color of the polyline. Default is blue.
line_color = color.blue,
// Style of the polyline. Default is line.style_solid.
line_style = line.style_solid,
// Width of the polyline. Default is 1.
line_width = 1,
// The maximum number of points that each built-in `polyline` instance can contain.
// NOTE: this is not to be confused with the maximum of points that each `PolylinePlus` instance can contain.
max_points_per_builtin_polyline = 10000,
// The number of lines to keep in the buffer. If more points are to be added while the buffer is full, then all the lines in the buffer will be flushed into the poylines.
// The higher the number, the less frequent we'll need to // flush the buffer, and thus lead to better performance.
// NOTE: the maximum total number of lines per chart allowed by PineScript is 500. But given there might be other places where the indicator or strategy are drawing lines outside this polyline context, the default value is 50 to be safe.
lines_bffer_size = 50)
Step 3: Push / Pop Points
// Push a single point
p.push_point(chart.point.now())
// Push multiple points
chart.point points = array.from(p1, p2, p3) // Where p1, p2, p3 are all chart.point type.
p.push_points(points)
// Pop point
p.pop_point()
// Resets all the points in the polyline.
p.set_points(points)
// Deletes the polyline.
p.delete()
🔵 Benchmark
Below is a simple benchmark comparing the performance between `PolylinePlus` and the native `polyline` type for incrementally adding 10K points to a polyline.
import algotraderdev/polylineplus/2 as pp
var t1 = 0
var t2 = 0
if bar_index < 10000
int start = timenow
var p = pp.PolylinePlus.new(xloc = xloc.bar_time, closed = true)
p.push_point(chart.point.now())
t1 += timenow - start
start := timenow
var polyline pl = na
var points = array.new()
points.push(chart.point.now())
if not na(pl)
pl.delete()
pl := polyline.new(points)
t2 += timenow - start
if barstate.islast
log.info('{0} {1}', t1, t2)
For this benchmark, `PolylinePlus` took ~300ms, whereas the native `polyline` type took ~6000ms.
We can also fine-tune the parameters for `PolylinePlus` to have a larger buffer size for `line`s and a smaller buffer for `polyline`s.
var p = pp.PolylinePlus.new(xloc = xloc.bar_time, closed = true, lines_buffer_size = 500, max_points_per_builtin_polyline = 1000)
With the above optimization, it only took `PolylinePlus` ~80ms to process the same 10K points, which is ~75x the performance compared to the native `polyline`.
