Full Currency Strength Table Dashboard (8 Currencies)
# Full Currency Strength Table Dashboard (8 Currencies) 📊
This indicator provides a **simplified, visual representation of the current relative strengths of 8 major global currencies** (EUR, USD, GBP, JPY, AUD, NZD, CAD, CHF). It's designed as a minimalist dashboard that appears discreetly on your chart, giving traders a quick and clear picture of forex pair movements.
The indicator calculates the relative strength of each currency based on its movement against the other 7 currencies in the panel, providing insight into which currencies are currently the strongest and which are the weakest.
## Key Features 🌟
* **Simplified Visualization:** Instead of showing currency strength as a line on the chart, which can often be distracting, the indicator uses a **data table (dashboard)** positioned on the chart. This ensures **maximum chart visibility** and cleanliness.
* **8 Major Currencies:** All major currencies are included ($A$ - EUR, $B$ - USD, $C$ - GBP, $D$ - JPY, $E$ - AUD, $F$ - NZD, $G$ - CAD, $H$ - CHF), allowing strength calculation based on **28 base currency pairs**.
* **Strength Calculation:** Strength is calculated based on the average percentage change $\left(\frac{\text{Close} - \text{Open}}{\text{Open}} \times 100\right)$ of the currency relative to all 7 other currencies.
* **Timeframe Setting:** Users can select a **higher timeframe (TF)** (e.g., Daily - 'D') for the strength calculation. This allows analysis of longer-term currency strength momentum, independent of the chart's current timeframe.
* **Customizable Design:** You can adjust the table's position, text size, the colour of each currency, and the resolution (length) of the strength meter.
## How to Use the Indicator (Interpretation) 💡
1. **Select a Timeframe (TF):** It's recommended to use a higher TF (e.g., Daily - 'D' or 4h - '240') to get more stable currency strength signals.
2. **The Dashboard Table:** The table displays:
* The currency name (bottom, with its corresponding colour).
* The numerical strength value (top, expressed in points or average change).
* The **Strength Meter (bar)** visually represents the currency's relative strength compared to the other currencies on the panel (calculated based on the Min/Max values across all 8 currencies).
3. **Making Decisions:**
* **Buy:** Look for a currency pair where the **Base Currency** is significantly **strong** (high positive value, long meter) and the **Quote Currency** is significantly **weak** (high negative value, short meter).
* **Sell:** Look for a currency pair where the **Base Currency** is significantly **weak** and the **Quote Currency** is significantly **strong**.
* **Avoid Trading:** Avoid pairs where both currencies have roughly the same strength or are close to zero.
## Note on Calculation and Code 🛠️
* **Base Pairs:** The script calculates 28 base currency pairs (e.g., EURUSD, EURGBP... CADCHF) using the `request.security` function to retrieve data from the selected timeframe (`freq`).
* **Data Correction:** A correction was implemented in the code by adding ` ` after `request.security` to always use the **CLOSED bar values** from the higher TF. This **eliminates NaN (Not a Number) data** that would appear when using the current bar.
* **Accumulation:** Accumulation (`sumA, sumB...`) only occurs when the selected higher TF changes (`timeframe.change(freq)`), effectively tracking the currency's relative strength during the formation of **one closed bar** on that higher TF.
### License
This work is licensed under the **Attribution-NonCommercial-ShareAlike 4.0 International (CC BY-NC-SA 4.0)** license.
The original concept and code are based on the work of the **LuxAlgo** team and finalized to fix syntax errors and handle NaN data for stable use with 8 currencies.
---
**Questions or suggestions?** I'd love to hear your feedback in the comments! Happy trading! 📈
Cerca negli script per "text"
Advanced Speedometer Gauge [PhenLabs]Advanced Speedometer Gauge
Version: PineScript™v6
📌 Description
The Advanced Speedometer Gauge is a revolutionary multi-metric visualization tool that consolidates 13 distinct trading indicators into a single, intuitive speedometer display. Instead of cluttering your workspace with multiple oscillators and panels, this gauge provides a unified interface where you can switch between different metrics while maintaining consistent visual interpretation.
Built on PineScript™ v6, the indicator transforms complex technical calculations into an easy-to-read semi-circular gauge with color-coded zones and a precision needle indicator. Each of the 13 available metrics has been carefully normalized to a 0-100 scale, ensuring that whether you’re analyzing RSI, volume trends, or volatility extremes, the visual interpretation remains consistent and intuitive.
The gauge is designed for traders who value efficiency and clarity. By consolidating multiple analytical perspectives into one compact display, you can quickly assess market conditions without the visual noise of traditional multi-indicator setups. All metrics are non-overlapping, meaning each provides unique insights into different aspects of market behavior.
🚀 Points of Innovation
13 selectable metrics covering momentum, volume, volatility, trend, and statistical analysis, all accessible through a single dropdown menu
Universal 0-100 normalization system that standardizes different indicator scales for consistent visual interpretation across all metrics
Semi-circular gauge design with 21 arc segments providing smooth precision and clear visual feedback through color-coded zones
Non-redundant metric selection ensuring each indicator provides unique market insights without analytical overlap
Advanced metrics including MFI (volume-weighted momentum), CCI (statistical deviation), Volatility Rank (extended lookback), Trend Strength (ADX-style), Choppiness Index, Volume Trend, and Price Distance from MA
Flexible positioning system with 5 chart locations, 3 size options, and fully customizable color schemes for optimal workspace integration
🔧 Core Components
Metric Selection Engine: Dropdown interface allowing instant switching between 13 different technical indicators, each with independent parameter controls
Normalization System: All metrics converted to 0-100 scale using indicator-specific algorithms that preserve the statistical significance of each measurement
Semi-Circular Gauge: Visual display using 21 arc segments arranged in curved formation with two-row thickness for enhanced visibility
Color Zone System: Three distinct zones (0-40 green, 40-70 yellow, 70-100 red) providing instant visual feedback on metric extremes
Needle Indicator: Dynamic pointer that positions across the gauge arc based on precise current metric value
Table Implementation: Professional table structure ensuring consistent positioning and rendering across different chart configurations
🔥 Key Features
RSI (Relative Strength Index): Classic momentum oscillator measuring overbought/oversold conditions with adjustable period length (default 14)
Stochastic Oscillator: Compares closing price to price range over specified period with smoothing, ideal for identifying momentum shifts
MFI (Money Flow Index): Volume-weighted RSI that combines price movement with volume to measure buying and selling pressure intensity
CCI (Commodity Channel Index): Measures statistical deviation from average price, normalized from typical -200 to +200 range to 0-100 scale
Williams %R: Alternative overbought/oversold indicator using high-low range analysis, inverted to match 0-100 scale conventions
Volume %: Current volume relative to moving average expressed as percentage, capped at 100 for extreme spikes
Volume Trend: Cumulative directional volume flow showing whether volume is flowing into up moves or down moves over specified period
ATR Percentile: Current Average True Range position within historical range using specified lookback period (default 100 bars)
Volatility Rank: Close-to-close volatility measured against extended historical range (default 252 days), differs from ATR in calculation method
Momentum: Rate of change calculation showing price movement speed, centered at 50 and normalized to 0-100 range
Trend Strength: ADX-style calculation using directional movement to quantify trend intensity regardless of direction
Choppiness Index: Measures market choppiness versus trending behavior, where high values indicate ranging markets and low values indicate strong trends
Price Distance from MA: Measures current price over-extension from moving average using standard deviation calculations
🎨 Visualization
Semi-Circular Arc Display: Curved gauge spanning from 0 (left) to 100 (right) with smooth progression and two-row thickness for visibility
Color-Coded Zones: Green zone (0-40) for low/oversold conditions, yellow zone (40-70) for neutral readings, red zone (70-100) for high/overbought conditions
Needle Indicator: Downward-pointing triangle (▼) positioned precisely at current metric value along the gauge arc
Scale Markers: Vertical line markers at 0, 25, 50, 75, and 100 positions with corresponding numerical labels below
Title Display: Merged cell showing “𓄀 PhenLabs” branding plus currently selected metric name in monospace font
Large Value Display: Current metric value shown with two decimal precision in large text directly below title
Table Structure: Professional table with customizable background color, text color, and transparency for minimal chart obstruction
📖 Usage Guidelines
Metric Selection
Select Metric: Default: RSI | Options: RSI, Stochastic, Volume %, ATR Percentile, Momentum, MFI (Money Flow), CCI (Commodity Channel), Williams %R, Volatility Rank, Trend Strength, Choppiness Index, Volume Trend, Price Distance | Choose the technical indicator you want to display on the gauge based on your current analytical needs
RSI Settings
RSI Length: Default: 14 | Range: 1+ | Controls the lookback period for RSI calculation, shorter periods increase sensitivity to recent price changes
Stochastic Settings
Stochastic Length: Default: 14 | Range: 1+ | Lookback period for stochastic calculation comparing close to high-low range
Stochastic Smooth: Default: 3 | Range: 1+ | Smoothing period applied to raw stochastic value to reduce noise and false signals
Volume Settings
Volume MA Length: Default: 20 | Range: 1+ | Moving average period used to calculate average volume for comparison with current volume
Volume Trend Length: Default: 20 | Range: 5+ | Period for calculating cumulative directional volume flow trend
ATR and Volatility Settings
ATR Length: Default: 14 | Range: 1+ | Period for Average True Range calculation used in ATR Percentile metric
ATR Percentile Lookback: Default: 100 | Range: 20+ | Historical range used to determine current ATR position as percentile
Volatility Rank Lookback (Days): Default: 252 | Range: 50+ | Extended lookback period for Volatility Rank metric using close-to-close volatility
Momentum and Trend Settings
Momentum Length: Default: 10 | Range: 1+ | Lookback period for rate of change calculation in Momentum metric
Trend Strength Length: Default: 20 | Range: 5+ | Period for directional movement calculations in ADX-style Trend Strength metric
Advanced Metric Settings
MFI Length: Default: 14 | Range: 1+ | Lookback period for Money Flow Index calculation combining price and volume
CCI Length: Default: 20 | Range: 1+ | Period for Commodity Channel Index statistical deviation calculation
Williams %R Length: Default: 14 | Range: 1+ | Lookback period for Williams %R high-low range analysis
Choppiness Index Length: Default: 14 | Range: 5+ | Period for calculating market choppiness versus trending behavior
Price Distance MA Length: Default: 50 | Range: 10+ | Moving average period used for Price Distance standard deviation calculation
Visual Customization
Position: Default: Top Right | Options: Top Left, Top Right, Bottom Left, Bottom Right, Middle Right | Controls gauge placement on chart for optimal workspace organization
Size: Default: Normal | Options: Small, Normal, Large | Adjusts overall gauge dimensions and text size for different monitor resolutions and preferences
Low Zone Color (0-40): Default: Green (#00FF00) | Customize color for low/oversold zone of gauge arc
Medium Zone Color (40-70): Default: Yellow (#FFFF00) | Customize color for neutral/medium zone of gauge arc
High Zone Color (70-100): Default: Red (#FF0000) | Customize color for high/overbought zone of gauge arc
Background Color: Default: Semi-transparent dark gray | Customize gauge background for contrast and chart integration
Text Color: Default: White (#FFFFFF) | Customize all text elements including title, value, and scale labels
✅ Best Use Cases
Quick visual assessment of market conditions when you need instant feedback on whether an asset is in extreme territory across multiple analytical dimensions
Workspace organization for traders who monitor multiple indicators but want to reduce chart clutter and visual complexity
Metric comparison by switching between different indicators while maintaining consistent visual interpretation through the 0-100 normalization
Overbought/oversold identification using RSI, Stochastic, Williams %R, or MFI depending on whether you prefer price-only or volume-weighted analysis
Volume analysis through Volume %, Volume Trend, or MFI to confirm price movements with corresponding volume characteristics
Volatility monitoring using ATR Percentile or Volatility Rank to identify expansion/contraction cycles and adjust position sizing
Trend vs range identification by comparing Trend Strength (high values = trending) against Choppiness Index (high values = ranging)
Statistical over-extension detection using CCI or Price Distance to identify when price has deviated significantly from normal behavior
Multi-timeframe analysis by duplicating the gauge on different timeframe charts to compare metric readings across time horizons
Educational purposes for new traders learning to interpret technical indicators through consistent visual representation
⚠️ Limitations
The gauge displays only one metric at a time, requiring manual switching to compare different indicators rather than simultaneous multi-metric viewing
The 0-100 normalization, while providing consistency, may obscure the raw values and specific nuances of each underlying indicator
Table-based visualization cannot be exported or saved as an image separately from the full chart screenshot
Optimal parameter settings vary by asset type, timeframe, and market conditions, requiring user experimentation for best results
💡 What Makes This Unique
Unified Multi-Metric Interface: The only gauge-style indicator offering 13 distinct metrics through a single interface, eliminating the need for multiple oscillator panels
Non-Overlapping Analytics: Each metric provides genuinely unique insights—MFI combines volume with price, CCI measures statistical deviation, Volatility Rank uses extended lookback, Trend Strength quantifies directional movement, and Choppiness Index measures ranging behavior
Universal Normalization System: All metrics standardized to 0-100 scale using indicator-appropriate algorithms that preserve statistical meaning while enabling consistent visual interpretation
Professional Visual Design: Semi-circular gauge with 21 arc segments, precision needle positioning, color-coded zones, and clean table implementation that maintains clarity across all chart configurations
Extensive Customization: Independent parameter controls for each metric, five position options, three size presets, and full color customization for seamless workspace integration
🔬 How It Works
1. Metric Calculation Phase:
All 13 metrics are calculated simultaneously on every bar using their respective algorithms with user-defined parameters
Each metric applies its own specific calculation method—RSI uses average gains vs losses, Stochastic compares close to high-low range, MFI incorporates typical price and volume, CCI measures deviation from statistical mean, ATR calculates true range, directional indicators measure up/down movement, and statistical metrics analyze price relationships
2. Normalization Process:
Each calculated metric is converted to a standardized 0-100 scale using indicator-appropriate transformations
Some metrics are naturally 0-100 (RSI, Stochastic, MFI, Williams %R), while others require scaling—CCI transforms from ±200 range, Momentum centers around 50, Volume ratio caps at 2x for 100, ATR and Volatility Rank calculate percentile positions, and Price Distance scales by standard deviations
3. Gauge Rendering:
The selected metric’s normalized value determines the needle position across 21 arc segments spanning 0-100
Each arc segment receives its color based on position—segments 0-8 are green zone, segments 9-14 are yellow zone, segments 15-20 are red zone
The needle indicator (▼) appears in row 5 at the column corresponding to the current metric value, providing precise visual feedback
4. Table Construction:
The gauge uses TradingView’s table system with merged cells for title and value display, ensuring consistent positioning regardless of chart configuration
Rows are allocated as follows: Row 0 merged for title, Row 1 merged for large value display, Row 2 for spacing, Rows 3-4 for the semi-circular arc with curved shaping, Row 5 for needle indicator, Row 6 for scale markers, Row 7 for numerical labels at 0/25/50/75/100
All visual elements update on every bar when barstate.islast is true, ensuring real-time accuracy without performance impact
💡 Note:
This indicator is designed for visual analysis and market condition assessment, not as a standalone trading system. For best results, combine gauge readings with price action analysis, support and resistance levels, and broader market context. Parameter optimization is recommended based on your specific trading timeframe and asset class. The gauge works on all timeframes but may require different parameter settings for intraday versus daily/weekly analysis. Consider using multiple instances of the gauge set to different metrics for comprehensive market analysis without switching between settings.
High Time Frame (HTF) Swing PointsIdentify and display swing highs and lows across multiple higher timeframes on a chart, overlaying horizontal lines and customizable labels at these swing points.
Timeframes
Five user-defined higher timeframes (default settings: 5-minute, 15-minute, 1-hour, 4-hour, and daily)
Manually show/hide individual timeframes
When chart’s timeframe is set higher than one of the five configured, the indicator will automatically hide it. This helps to prevent clutter when navigating between timeframes on the chart
Swing Levels
Configure the line color, opacity, width and weather it’s solid/dotted/dashed
Once swing levels are identified, the indicator will look for the chart candle where the line starts
When price crosses the swing level, the line will be terminated
Tags
Customize the tag text for each individual timeframe, using blank if a tag is not desired for that timeframe
A tag text color can be set for all tags or base it on the line color
Set tag text size based on: Auto, Tiny, Small, Normal, Large
Choose how far to the right of the line the tag text should appear, as an integer representing the size of a candle
Choose to clear the tag or leave it in place after price crosses a swing level
Use Cases
Visualize key swing points from higher timeframes to identify potential reversal or breakout zones
Identify possible low resistance liquidity run (LRLR) areas
Use swing points for stop placement or as targets or draws on liquidity
Synthetic Implied APROverview
The Synthetic Implied APR is an artificial implied APR, designed to imitate the implied APR seen when trading cryptocurrency funding rates. It combines real-time funding rates with premium data to calculate an artificial market expectation of the annualized funding rate.
The (actual) implied APR is the market's expectation of the annualized funding rate. This is dependent on bid/ask impacts of the implied APR, something which is currently unavailable to fetch with TradingView. In essence, an implied APR of X% means traders believe that asset's funding fees to average X% when annualized.
What's important to understand, is that the actual value of the synthetic implied APR is not relevant. We only simply use its relative changes when we trade (i.e if it crosses above/below its MA for a given weight). Even for the same asset, the implied APRs will change depending on days to maturity.
How it calculates
The synthetic implied APR is calculated with these steps:
Collects premium data from perpetual futures markets using optimized lower timeframe requests (check my 'Predicted Funding Rates' indicator)
Calculates the funding rate by adding the premium to an interest rate component (clamped within exchange limits)
Derives the underlying APR from the 8-hour funding rate (funding rate × 3 × 365)
Apply a weighed formula that imitates both the direction (underlying APR) with the volatility of prices (from the premium index and funding)
premium_component = (prem_avg / 50 ) * 365
weighedprem = (weight * fr) + ((1 - weight) * apr) + (premium_component * 0.3)
impliedAPR = math.avg(weighedprem, ta.sma(apr, maLength))
How to use it: Generally
Preface: Funding rates are an indication of market sentiment
If funding is positive, generally the market is bullish as longs are willing to pay shorts funding
If funding is negative, generally the market is bearish as shorts are willing to pay longs funding
So, this script can be used like a typical oscillator:
Bullish: If implied APR > MA OR if implied APR MA is green
Bearish: If implied APR < MA OR if implied APR MA is red
The components:
Synthetic Implied APR: The main metric. At current setting of 0.7, it imitates volatility
Weight: The higher the value, the smoother the synthetic implied APR is (and MA too). This value is very important to the imitation. At 0.7, it imitates the actual volatility of the implied APR. At weight = 1, it becomes very smooth. Perfect for trading
Synthetic Implied APR Moving Average: A moving average of the Synthetic implied APR. Can choose from multiple selections, (SMA, EMA, WMA, HMA, VWMA, RMA)
How to use it: Trading Funding
When trading funding there're multiple ways to use it with different settings
Trade funding rates with trend changes
Settings: Weight = 1
Method 1: When the implied APR MA turns green, long funding rates (or short if red)
Method 2: When the implied APR crosses above the MA, long funding rates (or short when crosses below)
Trade funding rates with MA pullbacks
Settings: Weight = 0.7, timeframe 15m
In an uptrend: When implied APR crosses below then above the script, long funding opportunity
In an downtrend: When implied APR crosses above then below the script, shortfunding opportunity
You can determine the trend with the method before, using a weight of 1
To trade funding rates, it's best to have these 3 scripts at these settings:
Predicted Funding Rates: This allows you to see the predicted funding rates and see if they've maxxed out for added confluence too (+/-0.01% usually for Binance BTC futures)
Synthetic implied APR: At weight 1, the MA provides a good trend (whether close above/below or colour change)
Synthetic implied APR: At weight 0.7, it provides a good imitation of volatility
How to use it: Trading Futures
When trading futures:
You can determine roughly what the trend is, if the assumption is made that funding rates can help identify trends if used as a sentiment indicator. It should be supplemented with traditional trend trading methods
To prevent whipsaws, weight should remain high
Long trend: When the implied APR MA turns green OR when it crosses above its MA
Short trend: When the implied APR MA turns red OR when it below above its MA
Why it's original
This indicator introduces a unique synthetic weighting system that combines funding rates, underlying APR, and premium components in a way not found in existing TradingView scripts. Trading funding rates is a niche area, there aren't that many scripts currently available. And to my knowledge, there's no synthetic implied APR scripts available on TradingView either. So I believe this script to be original in that sense.
Notes
Because it depends on my triangular weighting algos, optimal accuracy is found on timeframes that are 4H or less. On higher timeframes, the accuracy drops off. Best timeframes for intraday trading using this are 15m or 1 hour
The higher the timeframe, the lower the MA one should use. At 1 hour, 200 or higher is best. At say, 4h, length of 50 is best
Only works for coins that have a Binance premium index
Inputs
Funding Period - Select between "1 Hour" or "8 Hour" funding cycles. 8 hours is standard for Binance
Table - Toggle the information dashboard on/off to show or hide real-time metrics including funding rate, premium, and APR value
Weight - Controls the balance between funding rate (higher values = smoother) and APR (lower values = more responsive) in the calculation, ranging from 0.0 to 1.0. Default is 0.7, this imitates the volatility
Auto Timeframe Implied Length - Automatically calculates optimal smoothing length based on your chart timeframe for consistent behavior across different time periods
Manual Implied Length - Sets a fixed smoothing length (in bars) when auto mode is disabled, with lower values being more responsive and higher values being smoother
Show Implied APR MA - Displays an additional moving average line of the Synthetic Implied APR to help identify trend direction and crossover signals
MA Type for Implied APR - Selects the calculation method (SMA, EMA, WMA, HMA, VWMA, or RMA) for the moving average, each offering different responsiveness and lag characteristics
MA Length for Implied APR - Sets the lookback period (1-500 bars) for the moving average, with shorter lengths providing more signals and longer lengths filtering noise
Show Underlying APR - Displays the raw APR calculation (without synthetic weighting) as a reference line to compare against the main indicator
Bullish Color - Sets the color for positive values in the table and rising MA line
Bearish Color - Sets the color for negative values in the table and falling MA line
Table Background - Customizes the background color and transparency of the information dashboard
Table Text Color - Sets the color for label text in the left column of the information table
Table Text Size - Controls the font size of table text with options from Tiny to Huge
Simple Technicals Table📊 Simple Technicals Table
🎯 A comprehensive technical analysis dashboard displaying key pivot points and moving averages across multiple timeframes
📋 OVERVIEW
The Simple Technicals Table is a powerful indicator that organizes essential trading data into a clean, customizable table format. It combines Fibonacci-based pivot points with critical moving averages for both daily and weekly timeframes, giving traders instant access to key support/resistance levels and trend information.
Perfect for:
Technical analysts studying multi-timeframe data
Chart readers needing quick reference levels
Market researchers analyzing price patterns
Educational purposes and data visualization
🚀 KEY FEATURES
📊 Dual Timeframe Analysis
Daily (D1) and Weekly (W1) data side-by-side
Real-time updates as market conditions change
Seamless comparison between timeframes
🎯 Fibonacci Pivot Points
R3, R2, R1 : Resistance levels using Fibonacci ratios (38.2%, 61.8%, 100%)
PP : Central pivot point from previous period's data
S1, S2, S3 : Support levels with same methodology
📈 Complete EMA Suite
EMA 10 : Short-term trend identification
EMA 20 : Popular swing trading reference
EMA 50 : Medium-term trend confirmation
EMA 100 : Institutional support/resistance
EMA 200 : Long-term trend determination
📊 Essential Indicators
RSI 14 : Momentum for overbought/oversold conditions
ATR 14 : Volatility measurement for risk management
🎨 Full Customization
9 table positions : Place anywhere on your chart
5 text sizes : Tiny to huge for optimal visibility
Custom colors : Background, headers, and text
Optional pivot lines : Visual weekly levels on chart
⚙️ HOW IT WORKS
Fibonacci Pivot Calculation:
Pivot Point (PP) = (High + Low + Close) / 3
Range = High - Low
Resistance Levels:
R1 = PP + (Range × 0.382)
R2 = PP + (Range × 0.618)
R3 = PP + (Range × 1.000)
Support Levels:
S1 = PP - (Range × 0.382)
S2 = PP - (Range × 0.618)
S3 = PP - (Range × 1.000)
Smart Price Formatting:
< $1: 5 decimal places (crypto-friendly)
$1-$10: 4 decimal places
$10-$100: 3 decimal places
> $100: 2 decimal places
📊 TECHNICAL ANALYSIS APPLICATIONS
⚠️ EDUCATIONAL PURPOSE ONLY
This indicator is designed solely for technical analysis and educational purposes . It provides data visualization to help understand market structure and price relationships.
📈 Data Analysis Uses
Support & Resistance Identification : Visualize Fibonacci-based pivot levels
Trend Analysis : Study EMA relationships and price positioning
Multi-Timeframe Study : Compare daily and weekly technical data
Market Structure : Understand key technical levels and indicators
📚 Educational Benefits
Learn about Fibonacci pivot point calculations
Understand moving average relationships
Study RSI and ATR indicator values
Practice multi-timeframe technical analysis
🔍 Data Visualization Features
Organized table format for easy data reading
Color-coded levels for quick identification
Real-time technical indicator values
Historical data integrity maintained
🛠️ SETUP GUIDE
1. Installation
Search "Simple Technicals Table" in indicators
Add to chart (appears in middle-left by default)
Table displays automatically on any timeframe
2. Customization
Table Position : Choose from 9 locations
Text Size : Adjust for screen resolution
Colors : Match your chart theme
Pivot Lines : Toggle weekly level visualization
3. Optimization Tips
Use larger text on mobile devices
Dark backgrounds work well with light text
Enable pivot lines for visual reference
✅ BEST PRACTICES
Recommended Usage:
Use for technical analysis and educational study only
Combine with other analytical methods for comprehensive analysis
Study multi-timeframe data relationships
Practice understanding technical indicator values
Important Notes:
Levels based on previous period's data
Most effective in trending markets
No repainting - uses confirmed data only
Works on all instruments and timeframes
🔧 TECHNICAL SPECS
Performance:
Pine Script v5 optimized code
Minimal CPU/memory usage
Real-time data updates
No lookahead bias
Compatibility:
All chart types (Candlestick, Bar, Line)
Any instrument (Stocks, Forex, Crypto, etc.)
All timeframes supported
Mobile and desktop friendly
Data Accuracy:
Precise floating-point calculations
Historical data integrity maintained
No future data leakage
📱 DEVICE SUPPORT
✅ Desktop browsers (Chrome, Firefox, Safari, Edge)
✅ TradingView mobile app (iOS/Android)
✅ TradingView desktop application
✅ Light and dark themes
✅ All screen resolutions
📋 VERSION INFO
Version 1.0 - Initial Release
Fibonacci-based pivot calculations
Dual timeframe support (Daily/Weekly)
Complete EMA suite (10, 20, 50, 100, 200)
RSI and ATR indicators
Fully customizable interface
Optional pivot line visualization
Smart price formatting
Mobile-optimized display
⚠️ DISCLAIMER
This indicator is designed for technical analysis, educational and informational purposes ONLY . It provides data visualization and technical calculations to help users understand market structure and price relationships.
⚠️ NOT FOR TRADING DECISIONS
This tool does NOT provide trading signals or investment advice
All data is for analytical and educational purposes only
Users should not base trading decisions solely on this indicator
Always conduct thorough research and analysis before making any financial decisions
📚 Educational Use Only
Use for learning technical analysis concepts
Study market data and indicator relationships
Practice chart reading and data interpretation
Understand mathematical calculations behind technical indicators
The Simple Technicals Table provides technical data visualization to assist in market analysis education. It does not constitute financial advice, trading recommendations, or investment guidance. Users are solely responsible for their own research and decisions.
Author: ToTrieu
Version: 1.0
Category: Technical Analysis / Support & Resistance
License: Open source for educational use
💬 Questions? Comments? Feel free to reach out!
How to Reposition A Table CellOVERVIEW
Using table functions in Pine Script is one of the most effective methods for reporting and interpreting data in a readable manner. However, the built-in capabilities for dynamically repositioning table location are limited. To extend these limitations, a small intervention to the script may be required. This indicator exemplifies how such intervention can be modeled.
CONCEPTS
This indicator provides comprehensive control over table positioning through several user-defined parameters that work together to create flexible display options.
Text Parameters : These five string inputs allow users to define the content displayed in the table. Each parameter accepts custom text that will be displayed as separate rows within the table cell. (The relevant parameters are designed as examples. When implementing the code into your own scripts, you can use series string variables instead of the those inputs.)
Horizontal Offset : This integer parameter controls the horizontal positioning of the table content. Negative values shift the table content to the left, while positive values move it to the right. The offset is multiplied by a spacing factor (currently set to 4) to provide more noticeable movement. This parameter is particularly useful when you need to avoid overlapping with other chart elements or align multiple indicators.
Vertical Offset : This integer parameter manages the vertical positioning by adding line breaks above or below the content. Negative values push the content downward by adding line breaks at the beginning, while positive values elevate the content by adding line breaks at the end. This creates effective vertical spacing without affecting the table's base position.
Table Position : This parameter accepts values from 1 to 9, corresponding to the standard TradingView table positions arranged in a 3x3 grid format (1-3: top row, 4-6: middle row, 7-9: bottom row). This serves as the base positioning before any offset adjustments are applied, providing users with familiar reference points for initial placement.
FUNCTION
The core functionality centers on the custom f_position() function, which processes text positioning based on horizontal and vertical offset values. For vertical positioning, it adds line breaks before or after content depending on the offset direction. For horizontal positioning, it splits the text by rows and adds calculated spaces to each row, maintaining proper alignment across multi-line content. The spacing uses a fixed multiplier of 4, providing good balance between precision and visible movement.
ORIGINALITY & NOTES
Tihs indicator,
introduces a novel approach to table positioning that goes beyond TradingView's standard 9-position limitation by implementing custom offset calculations that allow pixel-level control over table placement.
serves as an educational resource, demonstrating advanced Pine Script techniques for UI manipulation that can be adapted for various custom indicator developments.
is particularly valuable for developers creating complex dashboard layouts or educational materials where precise positioning is crucial. The modular design of the positioning function makes it easily adaptable for other projects requiring similar functionality.
I hope it helps everyone, Always combine with risk management principles and market context awareness. I hope it helps everyone. Trade as safely as possible. Best of luck!
Intrabar Volume Delta — RealTime + History (Stocks/Crypto/Forex)Intrabar Volume Delta Grid — RealTime + History (Stocks/Crypto/Forex)
# Short Description
Shows intrabar Up/Down volume, Delta (absolute/relative) and UpShare% in a compact grid for both real-time and historical bars. Includes an MTF (M1…D1) dashboard, contextual coloring, density controls, and alerts on Δ and UpShare%. Smart historical splitting (“History Mode”) for Crypto/Futures/FX.
---
# What it does (Quick)
* **UpVol / DownVol / Δ / UpShare%** — visualizes order-flow inside each candle.
* **Real-time** — accumulates intrabar volume live by tick-direction.
* **History Mode** — splits Up/Down on closed bars via simple or range-aware logic.
* **MTF Dashboard** — one table view across M1, M5, M15, M30, H1, H4, D1 (Vol, Up/Down, Δ%, Share, Trend).
* **Contextual opacity** — stronger signals appear bolder.
* **Label density** — draw every N-th bar and limit to last X bars for performance.
* **Alerts** — thresholds for |Δ|, Δ%, and UpShare%.
---
# How it works (Real-Time vs History)
* **Real-time (open bar):** volume increments into **UpVolRT** or **DownVolRT** depending on last price move (↑ goes to Up, ↓ to Down). This approximates live order-flow even when full tick history isn’t available.
* **History (closed bars):**
* **None** — no split (Up/Down = 0/0). Safest for equities/indices with unreliable tick history.
* **Approx (Close vs Open)** — all volume goes to candle direction (green → Up 100%, red → Down 100%). Fast but yields many 0/100% bars.
* **Price Action Based** — splits by Close position within High-Low range; strength = |Close−mid|/(High−Low). Above mid → more Up; below mid → more Down. Falls back to direction if High==Low.
* **Auto** — **Stocks/Index → None**, **Crypto/Futures/FX → Approx**. If you see too many 0/100 bars, switch to **Price Action Based**.
---
# Rows & Meaning
* **Volume** — total bar volume (no split).
* **UpVol / DownVol** — directional intrabar volume.
* **Delta (Δ)** — UpVol − DownVol.
* **Absolute**: raw units
* **Relative (Δ%)**: Δ / (Up+Down) × 100
* **Both**: shows both formats
* **UpShare%** — UpVol / (Up+Down) × 100. >50% bullish, <50% bearish.
* Helpful icons: ▲ (>65%), ▼ (<35%).
---
# MTF Dashboard (🔧 Enable Dashboard)
A single table with **Vol, Up, Down, Δ%, Share, Trend (🔼/🔽/⏭️)** for selected timeframes (M1…D1). Great for a fast “panorama” read of flow alignment across horizons.
---
# Inputs (Grouped)
## Display
* Toggle rows: **Volume / Up / Down / Delta / UpShare**
* **Delta Display**: Absolute / Relative / Both
## Realtime & History
* **History Mode**: Auto / None / Approx / Price Action Based
* **Compact Numbers**: 1.2k, 1.25M, 3.4B…
## Theme & UI
* **Theme Mode**: Auto / Light / Dark
* **Row Spacing**: vertical spacing between rows
* **Top Row Y**: moves the whole grid vertically
* **Draw Guide Lines**: faint dotted guides
* **Text Size**: Tiny / Small / Normal / Large
## 🔧 Dashboard Settings
* **Enable Dashboard**
* **📏 Table Text Size**: Tiny…Huge
* **🦓 Zebra Rows**
* **🔲 Table Border**
## ⏰ Timeframes (for Dashboard)
* **M1…D1** toggles
## Contextual Coloring
* **Enable Contextual Coloring**: opacity by signal strength
* **Δ% cap / Share offset cap**: saturation caps
* **Min/Max transparency**: solid vs faint extremes
## Label Density & Size
* **Show every N-th bar**: draw labels only every Nth bar
* **Limit to last X bars**: keep labels only in the most recent X bars
## Colors
* Up / Down / Text / Guide
## Alerts
* **Delta Threshold (abs)** — |Δ| in volume units
* **UpShare > / <** — bullish/bearish thresholds
* **Enable Δ% Alert**, **Δ% > +**, **Δ% < −** — relative delta levels
---
# How to use (Quick Start)
1. Add the indicator to your chart (overlay=false → separate pane).
2. **History Mode**:
* Crypto/Futures/FX → keep **Auto** or switch to **Price Action Based** for richer history.
* Stocks/Index → prefer **None** or **Price Action Based** for safer splits.
3. **Label Density**: start with **Limit to last X bars = 30–150** and **Show every N-th bar = 2–4**.
4. **Contextual Coloring**: keep on to emphasize strong Δ% / Share moves.
5. **Dashboard**: enable and pick only the TFs you actually use.
6. **Alerts**: set thresholds (ideas below).
---
# Alerts (in TradingView)
Add alert → pick this indicator → choose any of:
* **Delta exceeds threshold** (|Δ| > X)
* **UpShare above threshold** (UpShare% > X)
* **UpShare below threshold** (UpShare% < X)
* **Relative Delta above +X%**
* **Relative Delta below −X%**
**Starter thresholds (tune per symbol & TF):**
* **Crypto M1/M5**: Δ% > +25…35 (bullish), Δ% < −25…−35 (bearish)
* **FX (tick volume)**: UpShare > 60–65% or < 40–35%
* **Stocks (liquid)**: set **Absolute Δ** by typical volume scale (e.g., 50k / 100k / 500k)
---
# Notes by Market Type
* **Crypto/Futures**: 24/7 and high liquidity — **Price Action Based** often gives nicer history splits than Approx.
* **Forex (FX)**: TradingView volume is typically **tick volume** (not true exchange volume). Treat Δ/Share as tick-based flow, still very useful intraday.
* **Stocks/Index**: historical tick detail can be limited. **None** or **Price Action Based** is a safer default. If you see too many 0/100% shares, switch away from Approx.
---
# “All Timeframes” accuracy
* Works on **any TF** (M1 → D1/W1).
* **Real-time accuracy** is strong for the open bar (live accumulation).
* **Historical accuracy** depends on your **History Mode** (None = safest, Approx = fastest/simplest, Price Action Based = more nuanced).
* The MTF dashboard uses `request.security` and therefore follows the same logic per TF.
---
# Trade Ideas (Use-Cases)
* **Scalping (M1–M5)**: a spike in Δ% + UpShare>65% + rising total Vol → momentum entries.
* **Intraday (M5–M30–H1)**: when multiple TFs show aligned Δ%/Share (e.g., M5 & M15 bullish), join the trend.
* **Swing (H4–D1)**: persistent Δ% > 0 and UpShare > 55–60% → structural accumulation bias.
---
# Advantages
* **True-feeling live flow** on the open bar.
* **Adaptable history** (three modes) to match data quality.
* **Clean visual layout** with guides, compact numbers, contextual opacity.
* **MTF snapshot** for quick bias read.
* **Performance controls** (last X bars, every N-th bar).
---
# Limitations & Care
* **FX uses tick volume** — interpret Δ/Share accordingly.
* **History Mode is an approximation** — confirm with trend/structure/liquidity context.
* **Illiquid symbols** can produce noisy or contradictory signals.
* **Too many labels** can slow charts → raise N, lower X, or disable guides.
---
# Best Practices (Checklist)
* Crypto/Futures: prefer **Price Action Based** for history.
* Stocks: **None** or **Price Action Based**; be cautious with **Approx**.
* FX: pair Δ% & UpShare% with session context (London/NY) and volatility.
* If labels overlap: tweak **Row Spacing** and **Text Size**.
* In the dashboard, keep only the TFs you actually act on.
* Alerts: start around **Δ% 25–35** for “punchy” moves, then refine per asset.
---
# FAQ
**1) Why do some closed bars show 0%/100% UpShare?**
You’re on **Approx** history mode. Switch to **Price Action Based** for smoother splits.
**2) Δ% looks strong but price doesn’t move — why?**
Δ% is an **order-flow** measure. Price also depends on liquidity pockets, sessions, news, higher-timeframe structure. Use confirmations.
**3) Performance slowdown — what to do?**
Lower **Limit to last X bars** (e.g., 30–100), increase **Show every N-th bar** (2–6), or disable **Draw Guide Lines**.
**4) Dashboard values don’t “match” the grid exactly?**
Dashboard is multi-TF via `request.security` and follows the history logic per TF. Differences are normal.
---
# Short “Store” Marketing Blurb
Intrabar Volume Delta Grid reveals the order-flow inside every candle (Up/Down, Δ, UpShare%) — live and on history. With smart history splitting, an MTF dashboard, contextual emphasis, and flexible alerts, it helps you spot momentum and bias across Crypto, Forex (tick volume), and Stocks. Tidy labels and compact numbers keep the panel readable and fast.
Weekly pecentage tracker by PRIVATE
Settings Picture below this link: 👇
i.ibb.co
What it is
A lightweight “Weekly % Tracker” overlay that lets you manually enter weekly performance (in percent) for XAUUSD + up to 10 FX pairs, then shows:
a small table panel with each enabled symbol and its % result
one TOTAL row (Sum / Average / Compounded across all enabled symbols)
an optional mini badge showing the % for a single selected symbol
Nothing is auto-calculated from price—you type the % yourself.
Key settings
Panel: show/hide, position, number of decimals, colors (background, text, green/red).
Total mode:
Sum – adds percentages
Average – mean of enabled rows
Compounded –
(
∏
(
1
+
𝑝
/
100
)
−
1
)
×
100
(∏(1+p/100)−1)×100
Symbols:
XAUUSD (toggle + label + % input)
10 FX pairs (each has On/Off, label text, % input). You can rename labels to any symbol text you want.
Mini badge: show/hide, position, and symbol to display.
How it works
Overlay indicator: overlay=true; just draws UI on the chart (no plots).
Arrays (syms, vals, ons) collect the row data in order: XAU first, then FX1…FX10.
Helpers:
posFrom() converts a position string (e.g., “Top Right”) into a position.* constant.
wp_col() picks green/red/neutral based on the sign of the %.
wp_round() rounds values to the selected decimals.
calc_total() computes the TOTAL with the chosen mode over enabled rows only.
Table creation logic:
Counts how many rows are enabled.
If none enabled or panel is off: the panel table is deleted, so no box/background is visible.
If enabled and on: the panel is (re)created at the chosen position.
On each last bar (barstate.islast), it clears the table to transparent (bgcolor=na) and then fills one row per enabled symbol, followed by a single TOTAL row.
Mini badge:
Always (re)created on position change.
Shows selected symbol’s % (or “-” if that symbol isn’t enabled or has no value).
Colors text green/red by sign.
Notes & limits
It’s manual input—the script doesn’t read trades or P/L from price.
You can rename each row’s label to match any symbol name you want.
When no rows are enabled, the panel disappears entirely (no empty background).
Designed to be light: only draws tables; no heavy plotting.
If you want the TOTAL row to be optional, or different color thresholds, or CSV-style export/import of the values, say the word and I’ll add it.
Custom Volume + Buyer & Price %Title: Custom Volume + Buyer & Price %
Description:
This indicator helps you see who is controlling the market — buyers or sellers — using volume and price action. It works even if your chart is on a small timeframe (like 5-min or 15-min), by showing Daily, Weekly, and Monthly information from the higher timeframe volume charts.
Key Features & How It Works:
Buyer % (B%):
Measures where the closing price is within the high-low range of a candle.
Calculation:
\text{Buyer %} = \frac{\text{Close} - \text{Low}}{\text{High} - \text{Low}} \times 100
Interpretation:
> 50% → Buyers are stronger
< 50% → Sellers are stronger
50% → Balanced
Volume Coloring:
Volume bars are colored based on Buyer %, not price movement:
Green → Buyers dominate
Red → Sellers dominate
Yellow → Balanced day
Higher Timeframe Insight:
Displays Daily, Weekly, and Monthly volume & Buyer % even if your chart is on a smaller timeframe.
Lets you understand long-term buying or selling pressure while trading intraday.
21-Day Average:
Shows average Buyer % and average volume over the past 21 days for trend context.
Why It’s Useful:
Quickly visualize whether the market is buyer-driven or seller-driven.
Identify strong accumulation or distribution days.
Works on any chart timeframe while giving higher timeframe perspective.
Ideal for traders who want easy, visual insight into market sentiment.
FluidFlow OscillatorFluidFlow Oscillator: Study Material for Traders
Overview
The FluidFlow Oscillator is a custom technical indicator designed to measure price momentum and market flow dynamics by simulating fluid motion concepts such as velocity, viscosity, and turbulence. It helps traders identify potential buy and sell signals along with trend strength, momentum direction, and volatility conditions.
This study explains the underlying calculation concepts, signal logic, visual cues, and how to interpret the professional dashboard table that summarizes key indicator readings.
________________________________________
How the FluidFlow Oscillator Works
Core Mechanisms
1. Price Flow Velocity
o Measures the rate of change of price over a specified flow length (default 40 bars).
o Calculated as a percentage change of closing price: roc=close−closelen_flowcloselen_flow×100\text{roc} = \frac{\text{close} - \text{close}_{len\_flow}}{\text{close}_{len\_flow}} \times 100roc=closelen_flowclose−closelen_flow×100
o Smoothed by an EMA (Exponential Moving Average) to reduce noise, generating a "flow velocity" value.
2. Viscosity Factor
o Analogous to fluid viscosity, it adjusts the flow velocity based on recent price volatility.
o Volatility is computed as the standard deviation of close prices over the flow length.
o The viscosity acts as a damping factor to slow down the flow velocity in highly volatile conditions.
o This results in a "flow with viscosity" value, that smooths out the velocity considering market turbulence.
3. Turbulence Burst
o Captures sudden changes or bursts in the flow by measuring changes between successive viscosity-adjusted flows.
o The turbulence value is a smoothed absolute change in flow.
o A burst boost factor is added to the oscillator to incorporate this rapid change component, amplifying signals during sudden shifts.
4. Oscillator Calculation
o The raw oscillator value is the sum of flow with viscosity plus burst boost, scaled by 10.
o Clamped between -100 and +100 to limit extremes.
o Finally, smoothed again by EMA for cleaner visualization.
________________________________________
Signal Logic
The oscillator works with complementary components to produce actionable signals:
• Signal Line: An EMA-smoothed version of the oscillator for generating crossover-based signals.
• Momentum: The rate of change of the oscillator itself, smoothed by EMA.
• Trend: Uses fast (21-period EMA) and slow (50-period EMA) moving averages of price to identify market trend direction (uptrend, downtrend, or sideways).
Signal Conditions
• Bullish Signal (Buy): Oscillator crosses above the oversold threshold with positive momentum.
• Bearish Signal (Sell): Oscillator crosses below the overbought threshold with negative momentum.
Statuses
The oscillator provides descriptive market states based on level and momentum:
• Overbought
• Oversold
• Buy Signal
• Sell Signal
• Bullish / Bearish (momentum-driven)
• Neutral (no clear trend)
________________________________________
Color System and Visualization
The oscillator uses a sophisticated HSV color model adapting hues according to:
• Oscillator value magnitude and sign (positive or negative)
• Acceleration of oscillator changes
• Smooth color gradients to facilitate intuitive understanding of trend strength and momentum shifts
Background colors highlight overbought (red tint) and oversold (green tint) zones with transparency.
________________________________________
How to Understand the Professional Dashboard Table
The FluidFlow Oscillator offers an integrated table at the bottom center of the chart. This dashboard summarizes critical indicator readings in 8 columns across 3 rows:
Column Description
SIGNAL Current signal status (e.g., Buy, Sell, Overbought) with color coding
OSCILLATOR Current oscillator value (-100 to +100) with color reflecting intensity and direction
MOMENTUM Momentum bias indicating strength/direction of oscillator changes (Strong Up, Up, Sideways, Down, Strong Down)
TREND Current trend status based on EMAs (Strong Uptrend, Uptrend, Sideways, Downtrend, Strong Downtrend)
VOLATILITY Volatility percentage relative to average, indicating market activity level
FLOW Flow velocity value describing price momentum magnitude and direction
TURBULENCE Turbulence level indicating sudden bursts or spikes in price movement
PROGRESS Oscillator's position mapped as a percentage (0% to 100%) showing proximity to extreme levels
Rows Explained
• Row 1 (Header): Labels for each metric.
• Row 2 (Values): Current numerical or descriptive values color-coded along a professional scheme:
o Green or lime tones indicate positive or bullish conditions.
o Red or orange tones indicate caution, sell signals, or bearish conditions.
o Blue tones indicate neutral or stable conditions.
• Row 3 (Status Indicators): Emoji-like icons and bars provide a quick visual gauge of each metric's intensity or signal strength:
o For example, "🟢🟢🟢" suggests very strong bullish momentum, while "🔴🔴🔴" suggests strong bearish momentum.
o Progress bar visually demonstrates oscillator movement toward oversold or overbought extremes.
________________________________________
Practical Interpretation Tips
• A Buy signal with green colors and strong momentum usually precedes upward price moves.
• An Overbought status with red background and red table colors warns of potential price corrections or reversals.
• Watch the Turbulence to gauge market instability; spikes may precede price shocks or volatility bursts.
• Confirm signals with the Trend and Momentum columns to avoid false entries.
• Use the Progress bar to anticipate oscillations approaching key threshold levels for timing trades.
________________________________________
Alerts
The oscillator supports alerts for:
• Buy and sell signals based on oscillator crossovers.
• Overbought and oversold levels reached.
These help traders automate awareness of important market conditions.
________________________________________
Disclaimer
The FluidFlow Oscillator and its signals are for educational and informational purposes only. They do not guarantee profits and should not be considered as financial advice. Always conduct your own research and use proper risk management when trading. Past performance is not indicative of future results.
________________________________________
This detailed explanation should help you understand the workings of the FluidFlow Oscillator, its components, signal logic, and how to analyze its professional dashboard for informed trading decisions.
Advanced VWAP CalendarThe Advanced VWAP Calendar is a designed to plot Volume Weighted Average Price (VWAP) lines anchored to user-defined and preset time periods, including weekly, monthly, quarterly, and custom anchors. As of August 15, 2025, this indicator provides traders with a robust tool for analyzing price trends relative to volume-weighted averages, with clear labeling and extensive customization options. Below is a summary of its key features and functionality, with technical details and code references updated to focus on user-facing behavior and presentation, while preserving all other aspects of the original summary.
Key Features
Multiple Time Period VWAPs:
Weekly VWAPs: Supports up to five VWAPs for a user-selected month and year, starting at midnight each Monday (e.g., W1 Aug 2025, W2 Aug 2025). Enabled via a single toggle, with anchors automatically set to the first Monday of the chosen month.
Monthly VWAPs: Plots VWAPs for all 12 months of a selected year (e.g., Jan 2025, Feb 2025) or a single user-specified month/year. Labels use month abbreviations (e.g., "Aug 2025").
Quarterly VWAPs: Covers four quarters of a selected year (e.g., Q1 2025, Q2 2025), with options to enable all quarters or individual ones (Q1–Q4).
Legacy VWAPs: Provides monthly and quarterly VWAPs for a user-selected legacy year (e.g., 2024), labeled with a "Legacy" prefix (e.g., "Legacy Jan 2024," "Legacy Q1 2024"), with similar enablement options.
Custom VWAPs: Includes 10 fully customizable VWAPs, each with user-defined anchor times, labels (e.g., "Q1 2025"), colors, line widths (1–5), text colors, bubble styles, text sizes (8–40), and background options.
Clear and Dynamic Labeling:
Labels appear to the right of the chart, showing the VWAP value (e.g., "Q1 2025 123.45").
Weekly labels follow a "W# Month Year" format (e.g., "W1 Aug 2025").
Monthly labels use abbreviated months (e.g., "Aug 2025"), while quarterly labels use "Q# Year" (e.g., "Q3 2025").
Legacy labels include a "Legacy" prefix (e.g., "Legacy Q1 2024").
Labels support customizable text sizes (tiny to huge) and can be displayed with or without a background, with optional bubble styles.
Flexible Customization:
Each VWAP can be enabled or disabled independently, with user inputs for anchor times, labels, and visual properties.
Colors are predefined for weekly (red, orange, blue, green, purple), monthly (varied), quarterly (red, blue, green, yellow), and legacy VWAPs, but custom VWAPs allow any color selection.
Line widths and text sizes are adjustable, ensuring visual clarity and chart readability.
This indicator was a dual effort, code was heavily contributed in effort by AzDxB, major credit and THANKS goes to him www.tradingview.com
ATAI Triangles — Volume-Based & Price Pattern Analysis (v1.01)ATAI Triangles — Volume-Based & Price Pattern Analysis (v1.01)
Overview
ATAI Triangles identifies two synchronized triangle structures — Hi-Lo-Hi (HLH) and Lo-Hi-Lo (LHL) — and analyzes them both geometrically and volumetrically. For each triangle, volume is split between its two legs (segments), providing interpretable insights into buyer vs seller activity along each path.
The idea is that certain geometric shapes, when paired with volume distribution on each leg, can reveal patterns worth exploring. Users are encouraged to share their observations and interpretations in the TradingView comments section so that more aspects of these triangle combinations can be discovered collectively.
Extra (for fun)
For a bit of entertainment, we’ve included a symbolic “hexagram” glyph that appears when both triangle types align in a particular way — it’s just a visual nod to geometry and has no predictive or trading value.
Interface & data clarity
- Inputs and parameters are organized by function (pattern geometry, volume analysis, visuals, HUD, labels).
- Each input includes tooltips explaining its purpose, units, and possible effects on calculations.
- All on-chart objects (polylines, labels, connectors) are named and colored to reflect their role, with volume values formatted in engineering notation (K, M, B).
- HUD columns and label texts use concise terms and consistent units, so that every displayed value is directly traceable to a calculation in the code.
- Daily and lower-timeframe volume series are clearly separated, with update logic documented to indicate intrabar provisional values vs finalized bar-close values.
Usage notes
Designed to be used alongside other indicators and chart tools for context; it is not a standalone signal generator.
All Buy/Sell volumes are absolute (non-negative); Δ = Buy − Sell.
Intrabar values update live and finalize at bar close (no repaint after close).
Disclaimer
For research, discussion, and educational purposes only. This is not financial advice and does not guarantee any outcome. Trade at your own risk.
VWAP CALENDARThe VWAP CALENDAR indicator plots up to 20 anchored Volume-Weighted Average Price (VWAP) lines on your chart, each starting from a user-defined date and time (e.g., April 20, 2024). Designed for simplicity, it helps traders visualize VWAPs for key events or dates, with customizable labels and colors. The indicator is optimized for crypto markets (e.g., BTC/USD) but works with any symbol providing volume data.
Features: Multiple VWAPs: Configure up to 20
independent VWAPs, each with a custom anchor date and time.
Dynamic Labels: Labels update in real-time, aligning precisely with each VWAP line’s price level, positioned to the right of the chart for clarity.
Customizable Settings: Adjust label text (e.g., “Event A”), line colors, line widths (1–5 pixels), text colors, and text sizes (8–40 points, default 22).
Bubble or No-Background Labels: Choose between bubble-style labels (with colored backgrounds) or plain text labels without backgrounds.
Timeframe Support: Accurate on daily, 4-hour, 1-hour, and 30-minute charts for anchors within ~1.5 years (e.g., April 20, 2024, from August 2025).
Limitations: VWAP accuracy for anchors like April 20, 2024 (~477 days back) is reliable on 1-hour and larger timeframes. Below 30-minute (e.g., 15-minute, 24-minute), VWAPs may start later or be unavailable due to TradingView’s 5,000-bar historical data limit. For distant anchors, use 4-hour or daily charts to ensure accuracy.
Requires sufficient chart history (e.g., premium account or deep exchange data) for older anchors on 1-hour or 30-minute charts.
Usage Notes: Set anchor dates via the indicator settings (e.g., “2024-04-20 00:00”).
Enable/disable individual VWAPs as needed.
Zoom out to load maximum chart history for best results, especially on 1-hour or 30-minute timeframes.
Ideal for crypto symbols with continuous trading data, but verify data availability for other markets.
Disclaimer:
This is a free indicator provided as-is
VWAP CALENDARThe VWAP CALENDAR indicator plots up to 20 anchored Volume-Weighted Average Price (VWAP) lines on your chart, each starting from a user-defined date and time (e.g., April 20, 2024). Designed for simplicity, it helps traders visualize VWAPs for key events or dates, with customizable labels and colors. The indicator is optimized for crypto markets (e.g., BTC/USD) but works with any symbol providing volume data.
Features: Multiple VWAPs: Configure up to 20 independent VWAPs, each with a custom anchor date and time.
Dynamic Labels: Labels update in real-time, aligning precisely with each VWAP line’s price level, positioned to the right of the chart for clarity.
Customizable Settings: Adjust label text (e.g., “Event A”), line colors, line widths (1–5 pixels), text colors, and text sizes (8–40 points, default 22).
Bubble or No-Background Labels: Choose between bubble-style labels (with colored backgrounds) or plain text labels without backgrounds.
Timeframe Support: Accurate on daily, 4-hour, 1-hour, and 30-minute charts for anchors within ~1.5 years (e.g., April 20, 2024, from August 2025).
Limitations: VWAP accuracy for anchors like April 20, 2024 (~477 days back) is reliable on 1-hour and larger timeframes. Below 30-minute (e.g., 15-minute, 24-minute), VWAPs may start later or be unavailable due to TradingView’s 5,000-bar historical data limit. For distant anchors, use 4-hour or daily charts to ensure accuracy.
Requires sufficient chart history (e.g., premium account or deep exchange data) for older anchors on 1-hour or 30-minute charts.
Usage Notes: Set anchor dates via the indicator settings (e.g., “2024-04-20 00:00”).
Enable/disable individual VWAPs as needed.
Zoom out to load maximum chart history for best results, especially on 1-hour or 30-minute timeframes.
Ideal for crypto symbols with continuous trading data, but verify data availability for other markets.
Disclaimer:
This is a free indicator provided as-is.
Multi SMA + Golden/Death + Heatmap + BB**Multi SMA (50/100/200) + Golden/Death + Candle Heatmap + BB**
A practical trend toolkit that blends classic 50/100/200 SMAs with clear crossover labels, special 🚀 Golden / 💀 Death Cross markers, and a readable candle heatmap based on a dynamic regression midline and volatility bands. Optional Bollinger Bands are included for context.
* See trend direction at a glance with SMAs.
* Get minimal, de-cluttered labels on important crosses (50↔100, 50↔200, 100↔200).
* Highlight big regime shifts with special Golden/Death tags.
* Read momentum and volatility with the candle heatmap.
* Add Bollinger Bands if you want classic mean-reversion context.
Designed to be lightweight, non-repainting on confirmed bars, and flexible across timeframes.
# What This Indicator Does (plain English)
* **Tracks trend** using **SMA 50/100/200** and lets you optionally compute each SMA on a higher or different timeframe (HTF-safe, no lookahead).
* **Prints labels** when SMAs cross each other (up or down). You can force signals only after bar close to avoid repaint.
* **Marks Golden/Death Crosses** (50 over/under 200) with special labels so major regime changes stand out.
* **Colors candles** with a **heatmap** built from a regression midline and volatility bands—greenish above, reddish below, with a smooth gradient.
* **Optionally shows Bollinger Bands** (basis SMA + stdev bands) and fills the area between them.
* **Includes alert conditions** for Golden and Death Cross so you can automate notifications.
---
# Settings — Simple Explanations
## Source
* **Source**: Price source used to calculate SMAs and Bollinger basis. Default: `close`.
## SMA 50
* **Show 50**: Turn the SMA(50) line on/off.
* **Length 50**: How many bars to average. Lower = faster but noisier.
* **Color 50** / **Width 50**: Visual style.
* **Timeframe 50**: Optional alternate timeframe for SMA(50). Leave empty to use the chart timeframe.
## SMA 100
* **Show 100**: Turn the SMA(100) line on/off.
* **Length 100**: Bars used for the mid-term trend.
* **Color 100** / **Width 100**: Visual style.
* **Timeframe 100**: Optional alternate timeframe for SMA(100).
## SMA 200
* **Show 200**: Turn the SMA(200) line on/off.
* **Length 200**: Bars used for the long-term trend.
* **Color 200** / **Width 200**: Visual style.
* **Timeframe 200**: Optional alternate timeframe for SMA(200).
## Signals (crossover labels)
* **Show crossover signals**: Prints triangle labels on SMA crosses (50↔100, 50↔200, 100↔200).
* **Wait for bar close (confirmed)**: If ON, signals only appear after the candle closes (reduces repaint).
* **Min bars between same-pair signals**: Minimum spacing to avoid duplicate labels from the same SMA pair too often.
* **Trend filter (buy: 50>100>200, sell: 50<100<200)**: Only show bullish labels when SMAs are stacked bullish (50 above 100 above 200), and only show bearish labels when stacked bearish.
### Label Offset
* **Offset mode**: Choose how to push labels away from price:
* **Percent**: Offset is a % of price.
* **ATR x**: Offset is ATR(14) × multiplier.
* **Percent of price (%)**: Used when mode = Percent.
* **ATR multiplier (for ‘ATR x’)**: Used when mode = ATR x.
### Label Colors
* **Bull color** / **Bear color**: Background of triangle labels.
* **Bull label text color** / **Bear label text color**: Text color inside the triangles.
## Golden / Death Cross
* **Show 🚀 Golden Cross (50↑200)**: Show a special “Golden” label when SMA50 crosses above SMA200.
* **Golden label color** / **Golden text color**: Styling for Golden label.
* **Show 💀 Death Cross (50↓200)**: Show a special “Death” label when SMA50 crosses below SMA200.
* **Death label color** / **Death text color**: Styling for Death label.
## Candle Heatmap
* **Enable heatmap candle colors**: Turns the heatmap on/off.
* **Length**: Lookback for the regression midline and volatility measure.
* **Deviation Multiplier**: Band width around the midline (bigger = wider).
* **Volatility basis**:
* **RMA Range** (smoothed high-low range)
* **Stdev** (standard deviation of close)
* **Upper/Middle/Lower color**: Gradient colors for the heatmap.
* **Heatmap transparency (0..100)**: 0 = solid, 100 = invisible.
* **Force override base candles**: Repaint base candles so heatmap stays visible even if your chart has custom coloring.
## Bollinger Bands (optional)
* **Show Bollinger Bands**: Toggle the overlay on/off.
* **Length**: Basis SMA length.
* **StdDev Multiplier**: Distance of bands from the basis in standard deviations.
* **Basis color** / **Band color**: Line colors for basis and bands.
* **Bands fill transparency**: Opacity of the fill between upper/lower bands.
---
# Features & How It Works
## 1) HTF-Safe SMAs
Each SMA can be calculated on the chart timeframe or a higher/different timeframe you choose. The script pulls HTF values **without lookahead** (non-repainting on confirmed bars).
## 2) Crossover Labels (Three Pairs)
* **50↔100**, **50↔200**, **100↔200**:
* **Triangle Up** label when the first SMA crosses **above** the second.
* **Triangle Down** label when it crosses **below**.
* Optional **Trend Filter** ensures only signals aligned with the overall stack (50>100>200 for bullish, 50<100<200 for bearish).
* **Debounce** spacing avoids repeated labels for the same pair too close together.
## 3) Golden / Death Cross Highlights
* **🚀 Golden Cross**: SMA50 crosses **above** SMA200 (often a longer-term bullish regime shift).
* **💀 Death Cross**: SMA50 crosses **below** SMA200 (often a longer-term bearish regime shift).
* Separate styling so they stand out from regular cross labels.
## 4) Candle Heatmap
* Builds a **regression midline** with **volatility bands**; colors candles by their position inside that channel.
* Smooth gradient: lower side → reddish, mid → yellowish, upper side → greenish.
* Helps you see momentum and “where price sits” relative to a dynamic channel.
## 5) Bollinger Bands (Optional)
* Classic **basis SMA** ± **StdDev** bands.
* Light visual context for mean-reversion and volatility expansion.
## 6) Alerts
* **Golden Cross**: `🚀 GOLDEN CROSS: SMA 50 crossed ABOVE SMA 200`
* **Death Cross**: `💀 DEATH CROSS: SMA 50 crossed BELOW SMA 200`
Add these to your alerts to get notified automatically.
---
# Tips & Notes
* For fewer false positives, keep **“Wait for bar close”** ON, especially on lower timeframes.
* Use the **Trend Filter** to align signals with the broader stack and cut noise.
* For HTF context, set **Timeframe 50/100/200** to higher frames (e.g., H1/H4/D) while you trade on a lower frame.
* Heatmap “Length” and “Deviation Multiplier” control smoothness and channel width—tune for your asset’s volatility.
Trading Report Generator from CSVMany people use the Trading Panel. Unfortunately, it doesn't have a Performance Report. However, TradingView has strategies, and they have a Performance Report :-D
What if we combine the first and second? It's easy!
This script is a special strategy that parses transactions in csv format from Paper Trading (and it will also work for other brokers) and “plays” them. As a result, we get a Performance Report for a specific instrument based on our real trades in Paper or another broker.
How to use it :
First, we need to get a CSV file with transactions. To do this, go to the Trading Panel and connect the desired broker. Select the History tab, then the Filled sub-tab, and configure the columns there, leaving only: Side, Qty, Fill Price, Closing Time. After that, open the Export data dialog, select History, and click Export. Open the downloaded CSV file in a regular text editor (Notepad or similar). It will contain a text like this:
Symbol,Side,Qty,Fill Price,Closing Time
FX:EURUSD,Buy,1000,1.0938700000000001,2023-04-05 14:29:23
COINBASE:ETHUSD,Sell,1,1332.05,2023-01-11 17:41:33
CME_MINI:ESH2023,Sell,1,3961.75,2023-01-11 17:30:40
CME_MINI:ESH2023,Buy,1,3956.75,2023-01-11 17:08:53
Next select all the text (Ctrl+A) and copy it to the clipboard.
Now apply the "Trading Report Generator from CSV" strategy to the chart with the desired symbol and TF, open the settings/input dialog, paste the contents of the clipboard into the single text input field of the strategy, and click Ok.
That's it.
In the Strategy Tester, we see a detailed Performance Report based on our real transactions.
P.S. The CSV file may contain transactions for different instruments, for example, you may have transactions for CRYPTO:BTCUSD and NASDAQ:AAPL. To view the report is based on CRYPTO:BTCUSD trades, simply change the symbol on the chart to CRYPTO:BTCUSD. To view the report is based on NASDAQ:AAPL trades, simply change the symbol on the chart to NASDAQ:AAPL. No changes to the strategy are required.
How it works :
At the beginning of the calculation, we parse the csv once, create trade objects (Trade) and sort them in chronological order. Next, on each bar, we check whether we have trades for the time period of the next bar. If there are, we place a limit order for each trade, with limit price == Fill Price of the trade. Here, we assume that if the trade is real, its execution price will be within the bar range, and the Pine strategy engine will execute this order at the specified limit price.
Vertical Time Marker Configurable (VTMC)# Vertical Time Marker Configurable (VTMC)
## Overview
The Vertical Time Marker Configurable (VTMC) is a powerful PineScript v6 indicator designed to help traders quickly identify key market times across their entire chart history. Instead of hovering over candles to check timestamps, VTMC draws clear vertical lines with customizable labels at your specified times, making it easy to spot important market sessions, news events, or personal trading windows at a glance.
## Key Features
### ⏰ Flexible Time Selection
- Set any time using an intuitive time picker (defaults to 8:30 AM Central Time)
- Automatically draws lines at your specified time across all historical data
- Perfect for marking market opens, closes, news releases, or personal trading times
### 🎨 Full Visual Customization
- **Line Color**: Choose any color (defaults to white for maximum visibility)
- **Line Style**: Solid, dashed, or dotted options
- **Line Width**: Adjustable from 1-10 pixels
- **Opacity Control**: Precise opacity slider (0-100%) for both line and text
### 🏷️ Smart Text Labels
- **Preset Options**: New York Open, New York Close, London Open, London Close, Asia Open, Asia Close
- **Custom Labels**: Enter any text for personalized marking (news events, trading windows, etc.)
- **Configurable Text**: Adjustable size (8-20px), color, and opacity
- **Smart Positioning**: Text appears just above the price action for clear visibility
### 📊 Professional Display
- Lines extend fully from top to bottom of chart
- Clean, non-intrusive design that doesn't clutter your analysis
- Works on any timeframe and market
- Historical lines persist across all chart data
## Perfect For
### Market Session Traders
- Mark key session opens and closes
- Identify overlap periods between major markets
- Track session-specific price behavior patterns
### News Traders
- Mark important economic releases (FOMC, NFP, etc.)
- Create visual reminders for scheduled events
- Track market reaction patterns around news times
### Institutional Flow Traders
- Identify key institutional activity times
- Mark order block formation periods
- Track smart money movement windows
### Personal Trading Systems
- Mark your optimal trading hours
- Create visual discipline for trading windows
- Track performance during specific time periods
## Why VTMC?
Unlike hardcoded session indicators that only work for specific markets, VTMC gives you complete flexibility to mark ANY time that matters to your trading strategy. Whether you're tracking "MY Trading Window" from 9:30-10:30 AM or marking custom news events, VTMC adapts to your specific needs.
The indicator eliminates the constant need to hover over candles to check times, instead providing instant visual reference points across your entire chart. This makes pattern recognition, backtesting, and trade timing significantly more efficient.
## Usage Tips
- Use multiple instances for different time zones or events
- Combine with other indicators for comprehensive market timing
- Customize colors to match your chart theme
- Use custom labels for personalized trading reminders
*Built with precision in PineScript v6 for reliable performance and modern TradingView compatibility.*
MACD Liquidity Tracker Strategy [Quant Trading]MACD Liquidity Tracker Strategy
Overview
The MACD Liquidity Tracker Strategy is an enhanced trading system that transforms the traditional MACD indicator into a comprehensive momentum-based strategy with advanced visual signals and risk management. This strategy builds upon the original MACD Liquidity Tracker System indicator by TheNeWSystemLqtyTrckr , converting it into a fully automated trading strategy with improved parameters and additional features.
What Makes This Strategy Original
This strategy significantly enhances the basic MACD approach by introducing:
Four distinct system types for different market conditions and trading styles
Advanced color-coded histogram visualization with four dynamic colors showing momentum strength and direction
Integrated trend filtering using 9 different moving average types
Comprehensive risk management with customizable stop-loss and take-profit levels
Multiple alert systems for entry signals, exits, and trend conditions
Flexible signal display options with customizable entry markers
How It Works
Core MACD Calculation
The strategy uses a fully customizable MACD configuration with traditional default parameters:
Fast MA : 12 periods (customizable, minimum 1, no maximum limit)
Slow MA : 26 periods (customizable, minimum 1, no maximum limit)
Signal Line : 9 periods (customizable, now properly implemented and used)
Cryptocurrency Optimization : The strategy's flexible parameter system allows for significant optimization across different crypto assets. Traditional MACD settings (12/26/9) often generate excessive noise and false signals in volatile crypto markets. By using slower, more smoothed parameters, traders can capture meaningful momentum shifts while filtering out market noise.
Example - DOGE Optimization (45/80/290 settings) :
• Performance : Optimized parameters yielding exceptional backtesting results with 29,800% PnL
• Why it works : DOGE's high volatility and social sentiment-driven price action benefits from heavily smoothed indicators
• Timeframes : Particularly effective on 30-minute and 4-hour charts for swing trading
• Logic : The very slow parameters filter out noise and capture only the most significant trend changes
Other Optimizable Cryptocurrencies : This parameter flexibility makes the strategy highly effective for major altcoins including SUI, SEI, LINK, Solana (SOL) , and many others. Each crypto asset can benefit from custom parameter tuning based on its unique volatility profile and trading characteristics.
Four Trading System Types
1. Normal System (Default)
Long signals : When MACD line is above the signal line
Short signals : When MACD line is below the signal line
Best for : Swing trading and capturing longer-term trends in stable markets
Logic : Traditional MACD crossover approach using the signal line
2. Fast System
Long signals : Bright Blue OR Dark Magenta (transparent) histogram colors
Short signals : Dark Blue (transparent) OR Bright Magenta histogram colors
Best for : Scalping and high-volatility markets (crypto, forex)
Logic : Leverages early momentum shifts based on histogram color changes
3. Safe System
Long signals : Only Bright Blue histogram color (strongest bullish momentum)
Short signals : All other colors (Dark Blue, Bright Magenta, Dark Magenta)
Best for : Risk-averse traders and choppy markets
Logic : Prioritizes only the strongest bullish signals while treating everything else as bearish
4. Crossover System
Long signals : MACD line crosses above signal line
Short signals : MACD line crosses below signal line
Best for : Precise timing entries with traditional MACD methodology
Logic : Pure crossover signals for more precise entry timing
Color-Coded Histogram Logic
The strategy uses four distinct colors to visualize momentum:
🔹 Bright Blue : MACD > 0 and rising (strong bullish momentum)
🔹 Dark Blue (Transparent) : MACD > 0 but falling (weakening bullish momentum)
🔹 Bright Magenta : MACD < 0 and falling (strong bearish momentum)
🔹 Dark Magenta (Transparent) : MACD < 0 but rising (weakening bearish momentum)
Trend Filter Integration
The strategy includes an advanced trend filter using 9 different moving average types:
SMA (Simple Moving Average)
EMA (Exponential Moving Average) - Default
WMA (Weighted Moving Average)
HMA (Hull Moving Average)
RMA (Running Moving Average)
LSMA (Least Squares Moving Average)
DEMA (Double Exponential Moving Average)
TEMA (Triple Exponential Moving Average)
VIDYA (Variable Index Dynamic Average)
Default Settings : 50-period EMA for trend identification
Visual Signal System
Entry Markers : Blue triangles (▲) below candles for long entries, Magenta triangles (▼) above candles for short entries
Candle Coloring : Price candles change color based on active signals (Blue = Long, Magenta = Short)
Signal Text : Optional "Long" or "Short" text inside entry triangles (toggleable)
Trend MA : Gray line plotted on main chart for trend reference
Parameter Optimization Examples
DOGE Trading Success (Optimized Parameters) :
Using 45/80/290 MACD settings with 50-period EMA trend filter has shown exceptional results on DOGE:
Performance : Backtesting results showing 29,800% PnL demonstrate the power of proper parameter optimization
Reasoning : DOGE's meme-driven volatility and social sentiment spikes create significant noise with traditional MACD settings
Solution : Very slow parameters (45/80/290) filter out social media-driven price spikes while capturing only major momentum shifts
Optimal Timeframes : 30-minute and 4-hour charts for swing trading opportunities
Result : Exceptionally clean signals with minimal false entries during DOGE's characteristic pump-and-dump cycles
Multi-Crypto Adaptability :
The same optimization principles apply to other major cryptocurrencies:
SUI : Benefits from smoothed parameters due to newer coin volatility patterns
SEI : Requires adjustment for its unique DeFi-related price movements
LINK : Oracle news events create price spikes that benefit from noise filtering
Solana (SOL) : Network congestion events and ecosystem developments need smoothed detection
General Rule : Higher volatility coins typically benefit from very slow MACD parameters (40-50 / 70-90 / 250-300 ranges)
Key Input Parameters
System Type : Choose between Fast, Normal, Safe, or Crossover (Default: Normal)
MACD Fast MA : 12 periods default (no maximum limit, consider 40-50 for crypto optimization)
MACD Slow MA : 26 periods default (no maximum limit, consider 70-90 for crypto optimization)
MACD Signal MA : 9 periods default (now properly utilized, consider 250-300 for crypto optimization)
Trend MA Type : EMA default (9 options available)
Trend MA Length : 50 periods default (no maximum limit)
Signal Display : Both, Long Only, Short Only, or None
Show Signal Text : True/False toggle for entry marker text
Trading Applications
Recommended Use Cases
Momentum Trading : Capitalize on strong directional moves using the color-coded system
Trend Following : Combine MACD signals with trend MA filter for higher probability trades
Scalping : Use "Fast" system type for quick entries in volatile markets
Swing Trading : Use "Normal" or "Safe" system types for longer-term positions
Cryptocurrency Trading : Optimize parameters for individual crypto assets (e.g., 45/80/290 for DOGE, custom settings for SUI, SEI, LINK, SOL)
Market Suitability
Volatile Markets : Forex, crypto, indices (recommend "Fast" system or smoothed parameters)
Stable Markets : Stocks, ETFs (recommend "Normal" or "Safe" system)
All Timeframes : Effective from 1-minute charts to daily charts
Crypto Optimization : Each major cryptocurrency (DOGE, SUI, SEI, LINK, SOL, etc.) can benefit from custom parameter tuning. Consider slower MACD parameters for noise reduction in volatile crypto markets
Alert System
The strategy provides comprehensive alerts for:
Entry Signals : Long and short entry triangle appearances
Exit Signals : Position exit notifications
Color Changes : Individual histogram color alerts
Trend Conditions : Price above/below trend MA alerts
Strategy Parameters
Default Settings
Initial Capital : $1,000
Position Size : 100% of equity
Commission : 0.1%
Slippage : 3 points
Date Range : January 1, 2018 to December 31, 2069
Risk Management (Optional)
Stop Loss : Disabled by default (customizable percentage-based)
Take Profit : Disabled by default (customizable percentage-based)
Short Trades : Disabled by default (can be enabled)
Important Notes and Limitations
Backtesting Considerations
Uses realistic commission (0.1%) and slippage (3 points)
Default position sizing uses 100% equity - adjust based on risk tolerance
Stop-loss and take-profit are disabled by default to show raw strategy performance
Strategy does not use lookahead bias or future data
Risk Warnings
Past performance does not guarantee future results
MACD-based strategies may produce false signals in ranging markets
Consider combining with additional confluences like support/resistance levels
Test thoroughly on demo accounts before live trading
Adjust position sizing based on your risk management requirements
Technical Limitations
Strategy does not work on non-standard chart types (Heikin Ashi, Renko, etc.)
Signals are based on close prices and may not reflect intraday price action
Multiple rapid signals in volatile conditions may result in overtrading
Credits and Attribution
This strategy is based on the original "MACD Liquidity Tracker System" indicator created by TheNeWSystemLqtyTrckr . This strategy version includes significant enhancements:
Complete strategy implementation with entry/exit logic
Addition of the "Crossover" system type
Proper implementation and utilization of the MACD signal line
Enhanced risk management features
Improved parameter flexibility with no artificial maximum limits
Additional alert systems for comprehensive trade management
The original indicator's core color logic and visual system have been preserved while expanding functionality for automated trading applications.
Trend Tracker ProTrend Tracker Pro - Advanced Trend Following Indicator
Overview
Trend Tracker Pro is a sophisticated trend-following indicator that combines the power of Exponential Moving Average (EMA) and Average True Range (ATR) to identify market trends and generate precise buy/sell signals. This indicator is designed to help traders capture trending moves while filtering out market noise.
🎯 Key Features
✅ Dynamic Trend Detection
Uses EMA and ATR-based bands to identify trend direction
Automatically adjusts to market volatility
Clear visual trend line that changes color based on market direction
✅ Precise Signal Generation
Buy signals when trend changes to bullish
Sell signals when trend changes to bearish
Reduces false signals by requiring actual trend changes
✅ Visual Clarity
Green trend line: Bullish trend
Red trend line: Bearish trend
Gray trend line: Sideways/neutral trend
Triangle arrows for buy/sell signals
Clear BUY/SELL text labels
✅ Customizable Settings
Trend Length: Adjustable period for EMA and ATR calculation (default: 14)
ATR Multiplier: Controls sensitivity of trend bands (default: 2.0)
Show/Hide Signals: Toggle signal arrows on/off
Show/Hide Labels: Toggle text labels on/off
✅ Built-in Information Panel
Real-time trend direction display
Current trend level value
ATR value for volatility reference
Last signal information
✅ TradingView Alerts
Buy signal alerts
Sell signal alerts
Customizable alert messages
🔧 How It Works
Algorithm Logic:
1.
Calculate EMA: Uses exponential moving average for trend baseline
2.
Calculate ATR: Measures market volatility
3.
Create Bands: Upper band = EMA + (ATR × Multiplier), Lower band = EMA - (ATR × Multiplier)
4.
Determine Trend:
Price above upper band → Bullish trend (trend line = lower band)
Price below lower band → Bearish trend (trend line = upper band)
Price between bands → Continue previous trend
5.
Generate Signals: Signal occurs when trend direction changes
📊 Best Use Cases
✅ Trending Markets
Excellent for capturing strong directional moves
Works well in both bull and bear markets
Ideal for swing trading and position trading
✅ Multiple Timeframes
Effective on all timeframes from 15 minutes to daily
Higher timeframes provide more reliable signals
Can be used for both scalping and long-term investing
✅ Various Asset Classes
Stocks, Forex, Cryptocurrencies, Commodities
Particularly effective in volatile markets
Adapts automatically to different volatility levels
⚙️ Recommended Settings
Conservative Trading (Lower Risk)
Trend Length: 20
ATR Multiplier: 2.5
Best for: Long-term positions, lower frequency signals
Balanced Trading (Default)
Trend Length: 14
ATR Multiplier: 2.0
Best for: Swing trading, moderate frequency signals
Aggressive Trading (Higher Risk)
Trend Length: 10
ATR Multiplier: 1.5
Best for: Day trading, higher frequency signals
🎨 Visual Elements
Trend Line: Main indicator line that follows the trend
Signal Arrows: Triangle shapes indicating buy/sell points
Text Labels: Clear "BUY" and "SELL" text markers
Information Table: Real-time status panel in top-right corner
Color Coding: Intuitive green/red color scheme
⚠️ Important Notes
Risk Management
Always use proper position sizing
Set stop-losses based on ATR values
Consider market conditions and volatility
Not recommended for ranging/sideways markets
Signal Confirmation
Consider using with other indicators for confirmation
Pay attention to volume and market structure
Be aware of major news events and market sessions
Backtesting Recommended
Test the indicator on historical data
Optimize parameters for your specific trading style
Consider transaction costs in your analysis
Frahm Factor Position Size CalculatorThe Frahm Factor Position Size Calculator is a powerful evolution of the original Frahm Factor script, leveraging its volatility analysis to dynamically adjust trading risk. This Pine Script for TradingView uses the Frahm Factor’s volatility score (1-10) to set risk percentages (1.75% to 5%) for both Margin-Based and Equity-Based position sizing. A compact table on the main chart displays Risk per Trade, Frahm Factor, and Average Candle Size, making it an essential tool for traders aligning risk with market conditions.
Calculates a volatility score (1-10) using true range percentile rank over a customizable look-back window (default 24 hours).
Dynamically sets risk percentage based on volatility:
Low volatility (score ≤ 3): 5% risk for bolder trades.
High volatility (score ≥ 8): 1.75% risk for caution.
Medium volatility (score 4-7): Smoothly interpolated (e.g., 4 → 4.3%, 5 → 3.6%).
Adjustable sensitivity via Frahm Scale Multiplier (default 9) for tailored volatility response.
Position Sizing:
Margin-Based: Risk as a percentage of total margin (e.g., $175 for 1.75% of $10,000 at high volatility).
Equity-Based: Risk as a percentage of (equity - minimum balance) (e.g., $175 for 1.75% of ($15,000 - $5,000)).
Compact 1-3 row table shows:
Risk per Trade with Frahm score (e.g., “$175.00 (Frahm: 8)”).
Frahm Factor (e.g., “Frahm Factor: 8”).
Average Candle Size (e.g., “Avg Candle: 50 t”).
Toggles to show/hide Frahm Factor and Average Candle Size rows, with no empty backgrounds.
Four sizes: XL (18x7, large text), L (13x6, normal), M (9x5, small, default), S (8x4, tiny).
Repositionable (9 positions, default: top-right).
Customizable cell color, text color, and transparency.
Set Frahm Factor:
Frahm Window (hrs): Pick how far back to measure volatility (e.g., 24 hours). Shorter for fast markets, longer for chill ones.
Frahm Scale Multiplier: Set sensitivity (1-10, default 9). Higher makes the score jumpier; lower smooths it out.
Set Margin-Based:
Total Margin: Enter your account balance (e.g., $10,000). Risk auto-adjusts via Frahm Factor.
Set Equity-Based:
Total Equity: Enter your total account balance (e.g., $15,000).
Minimum Balance: Set to the lowest your account can go before liquidation (e.g., $5,000). Risk is based on the difference, auto-adjusted by Frahm Factor.
Customize Display:
Calculation Method: Pick Margin-Based or Equity-Based.
Table Position: Choose where the table sits (e.g., top_right).
Table Size: Select XL, L, M, or S (default M, small text).
Table Cell Color: Set background color (default blue).
Table Text Color: Set text color (default white).
Table Cell Transparency: Adjust transparency (0 = solid, 100 = invisible, default 80).
Show Frahm Factor & Show Avg Candle Size: Check to show these rows, uncheck to hide (default on).
Historical Volatility with HV Average & High/Low Trendlines
### 📊 **Indicator Title**: Historical Volatility with HV Average & High/Low Trendlines
**Version**: Pine Script v5
**Purpose**:
This script visualizes market volatility using **Historical Volatility (HV)** and enhances analysis by:
* Showing a **moving average** of HV to identify volatility trends.
* Marking **high and low trendlines** to highlight extremes in volatility over a selected period.
---
### 🔧 **Inputs**:
1. **HV Length (`length`)**:
Controls how many bars are used to calculate Historical Volatility.
*(Default: 10)*
2. **Average Length (`avgLength`)**:
Number of bars used for calculating the moving average of HV.
*(Default: 20)*
3. **Trendline Lookback Period (`trendLookback`)**:
Number of bars to look back for calculating the highest and lowest values of HV.
*(Default: 100)*
---
### 📈 **Core Calculations**:
1. **Historical Volatility (`hv`)**:
$$
HV = 100 \times \text{stdev}\left(\ln\left(\frac{\text{close}}{\text{close} }\right), \text{length}\right) \times \sqrt{\frac{365}{\text{period}}}
$$
* Measures how much the stock price fluctuates.
* Adjusts annualization factor depending on whether it's intraday or daily.
2. **HV Moving Average (`hvAvg`)**:
A simple moving average (SMA) of HV over the selected `avgLength`.
3. **HV High & Low Trendlines**:
* `hvHigh`: Highest HV value over the last `trendLookback` bars.
* `hvLow`: Lowest HV value over the last `trendLookback` bars.
---
### 🖍️ **Visual Plots**:
* 🔵 **HV**: Blue line showing raw Historical Volatility.
* 🔴 **HV Average**: Red line (thicker) indicating smoothed HV trend.
* 🟢 **HV High**: Green horizontal line marking volatility peaks.
* 🟠 **HV Low**: Orange horizontal line marking volatility lows.
---
### ✅ **Usage**:
* **High HV**: Indicates increased risk or potential breakout conditions.
* **Low HV**: Suggests consolidation or calm markets.
* **Cross of HV above Average**: May signal rising volatility (e.g., before breakout).
* **Touching High/Low Levels**: Helps identify volatility extremes and possible reversal zones.
light_logLight Log - A Defensive Programming Library for Pine Script
Overview
The Light Log library transforms Pine Script development by introducing structured logging and defensive programming patterns typically found in enterprise languages like C#. This library addresses a fundamental challenge in Pine Script: the lack of sophisticated error handling and debugging tools that developers expect when building complex trading systems.
At its core, Light Log provides three transformative capabilities that work together to create more reliable and maintainable code. First, it wraps all native Pine Script types in error-aware containers, allowing values to carry validation state alongside their data. Second, it offers a comprehensive logging system with severity levels and conditional rendering. Third, it includes defensive programming utilities that catch errors early and make code self-documenting.
The Philosophy of Errors as Values
Traditional Pine Script error handling relies on runtime errors that halt execution, making it difficult to build resilient systems that can gracefully handle edge cases. Light Log introduces a paradigm shift by treating errors as first-class values that flow through your program alongside regular data.
When you wrap a value using Light Log's type system, you're not just storing data – you're creating a container that can carry both the value and its validation state. For example, when you call myNumber.INT() , you receive an INT object that contains both the integer value and a Log object that can describe any issues with that value. This approach, inspired by functional programming languages, allows errors to propagate through calculations without causing immediate failures.
Consider how this changes error handling in practice. Instead of a calculation failing catastrophically when it encounters invalid input, it can produce a result object that contains both the computed value (which might be na) and a detailed log explaining what went wrong. Subsequent operations can check has_error() to decide whether to proceed or handle the error condition gracefully.
The Typed Wrapper System
Light Log provides typed wrappers for every native Pine Script type: INT, FLOAT, BOOL, STRING, COLOR, LINE, LABEL, BOX, TABLE, CHART_POINT, POLYLINE, and LINEFILL. These wrappers serve multiple purposes beyond simple value storage.
Each wrapper type contains two fields: the value field v holds the actual data, while the error field e contains a Log object that tracks the value's validation state. This dual nature enables powerful programming patterns. You can perform operations on wrapped values and accumulate error information along the way, creating an audit trail of how values were processed.
The wrapper system includes convenient methods for converting between wrapped and unwrapped values. The extension methods like INT() , FLOAT() , etc., make it easy to wrap existing values, while the from_INT() , from_FLOAT() methods extract the underlying values when needed. The has_error() method provides a consistent interface for checking whether any wrapped value has encountered issues during processing.
The Log Object: Your Debugging Companion
The Log object represents the heart of Light Log's debugging capabilities. Unlike simple string concatenation for error messages, the Log object provides a structured approach to building, modifying, and rendering diagnostic information.
Each Log object carries three essential pieces of information: an error type (info, warning, error, or runtime_error), a message string that can be built incrementally, and an active flag that controls conditional rendering. This structure enables sophisticated logging patterns where you can build up detailed diagnostic information throughout your script's execution and decide later whether and how to display it.
The Log object's methods support fluent chaining, allowing you to build complex messages in a readable way. The write() and write_line() methods append text to the log, while new_line() adds formatting. The clear() method resets the log for reuse, and the rendering methods ( render_now() , render_condition() , and the general render() ) control when and how messages appear.
Defensive Programming Made Easy
Light Log's argument validation functions transform how you write defensive code. Instead of cluttering your functions with verbose validation logic, you can use concise, self-documenting calls that make your intentions clear.
The argument_error() function provides strict validation that halts execution when conditions aren't met – perfect for catching programming errors early. For less critical issues, argument_log_warning() and argument_log_error() record problems without stopping execution, while argument_log_info() provides debug visibility into your function's behavior.
These functions follow a consistent pattern: they take a condition to check, the function name, the argument name, and a descriptive message. This consistency makes error messages predictable and helpful, automatically formatting them to show exactly where problems occurred.
Building Modular, Reusable Code
Light Log encourages a modular approach to Pine Script development by providing tools that make functions more self-contained and reliable. When functions validate their inputs and return wrapped values with error information, they become true black boxes that can be safely composed into larger systems.
The void_return() function addresses Pine Script's requirement that all code paths return a value, even in error handling branches. This utility function provides a clean way to satisfy the compiler while making it clear that a particular code path should never execute.
The static log pattern, initialized with init_static_log() , enables module-wide error tracking. You can create a persistent Log object that accumulates information across multiple function calls, building a comprehensive diagnostic report that helps you understand complex behaviors in your indicators and strategies.
Real-World Applications
In practice, Light Log shines when building sophisticated trading systems. Imagine developing a complex indicator that processes multiple data streams, performs statistical calculations, and generates trading signals. With Light Log, each processing stage can validate its inputs, perform calculations, and pass along both results and diagnostic information.
For example, a moving average calculation might check that the period is positive, that sufficient data exists, and that the input series contains valid values. Instead of failing silently or throwing runtime errors, it can return a FLOAT object that contains either the calculated average or a detailed explanation of why the calculation couldn't be performed.
Strategy developers benefit even more from Light Log's capabilities. Complex entry and exit logic often involves multiple conditions that must all be satisfied. With Light Log, each condition check can contribute to a comprehensive log that explains exactly why a trade was or wasn't taken, making strategy debugging and optimization much more straightforward.
Performance Considerations
While Light Log adds a layer of abstraction over raw Pine Script values, its design minimizes performance impact. The wrapper objects are lightweight, containing only two fields. The logging operations only consume resources when actually rendered, and the conditional rendering system ensures that production code can run with logging disabled for maximum performance.
The library follows Pine Script best practices for performance, using appropriate data structures and avoiding unnecessary operations. The var keyword in init_static_log() ensures that persistent logs don't create new objects on every bar, maintaining efficiency even in real-time calculations.
Getting Started
Adopting Light Log in your Pine Script projects is straightforward. Import the library, wrap your critical values, add validation to your functions, and use Log objects to track important events. Start small by adding logging to a single function, then expand as you see the benefits of better error visibility and code organization.
Remember that Light Log is designed to grow with your needs. You can use as much or as little of its functionality as makes sense for your project. Even simple uses, like adding argument validation to key functions, can significantly improve code reliability and debugging ease.
Transform your Pine Script development experience with Light Log – because professional trading systems deserve professional development tools.
Light Log Technical Deep Dive: Advanced Patterns and Architecture
Understanding Errors as Values
The concept of "errors as values" represents a fundamental shift in how we think about error handling in Pine Script. In traditional Pine Script development, errors are events – they happen at a specific moment in time and immediately interrupt program flow. Light Log transforms errors into data – they become information that flows through your program just like any other value.
This transformation has profound implications. When errors are values, they can be stored, passed between functions, accumulated, transformed, and inspected. They become part of your program's data flow rather than exceptions to it. This approach, popularized by languages like Rust with its Result type and Haskell with its Either monad, brings functional programming's elegance to Pine Script.
Consider a practical example. Traditional Pine Script might calculate a momentum indicator like this:
momentum = close - close
If period is invalid or if there isn't enough historical data, this calculation might produce na or cause subtle bugs. With Light Log's approach:
calculate_momentum(src, period)=>
result = src.FLOAT()
if period <= 0
result.e.write("Invalid period: must be positive", true, ErrorType.error)
result.v := na
else if bar_index < period
result.e.write("Insufficient data: need " + str.tostring(period) + " bars", true, ErrorType.warning)
result.v := na
else
result.v := src - src
result.e.write("Momentum calculated successfully", false, ErrorType.info)
result
Now the function returns not just a value but a complete computational result that includes diagnostic information. Calling code can make intelligent decisions based on both the value and its associated metadata.
The Monad Pattern in Pine Script
While Pine Script lacks the type system features to implement true monads, Light Log brings monadic thinking to Pine Script development. The wrapped types (INT, FLOAT, etc.) act as computational contexts that carry both values and metadata through a series of transformations.
The key insight of monadic programming is that you can chain operations while automatically propagating context. In Light Log, this context is the error state. When you have a FLOAT that contains an error, operations on that FLOAT can check the error state and decide whether to proceed or propagate the error.
This pattern enables what functional programmers call "railway-oriented programming" – your code follows a success track when all is well but can switch to an error track when problems occur. Both tracks lead to the same destination (a result with error information), but they take different paths based on the validity of intermediate values.
Composable Error Handling
Light Log's design encourages composition – building complex functionality from simpler, well-tested components. Each component can validate its inputs, perform its calculation, and return a result with appropriate error information. Higher-level functions can then combine these results intelligently.
Consider building a complex trading signal from multiple indicators:
generate_signal(src, fast_period, slow_period, signal_period) =>
log = init_static_log(ErrorType.info)
// Calculate components with error tracking
fast_ma = calculate_ma(src, fast_period)
slow_ma = calculate_ma(src, slow_period)
// Check for errors in components
if fast_ma.has_error()
log.write_line("Fast MA error: " + fast_ma.e.message, true)
if slow_ma.has_error()
log.write_line("Slow MA error: " + slow_ma.e.message, true)
// Proceed with calculation if no errors
signal = 0.0.FLOAT()
if not (fast_ma.has_error() or slow_ma.has_error())
macd_line = fast_ma.v - slow_ma.v
signal_line = calculate_ma(macd_line, signal_period)
if signal_line.has_error()
log.write_line("Signal line error: " + signal_line.e.message, true)
signal.e := log
else
signal.v := macd_line - signal_line.v
log.write("Signal generated successfully")
else
signal.e := log
signal.v := na
signal
This composable approach makes complex calculations more reliable and easier to debug. Each component is responsible for its own validation and error reporting, and the composite function orchestrates these components while maintaining comprehensive error tracking.
The Static Log Pattern
The init_static_log() function introduces a powerful pattern for maintaining state across function calls. In Pine Script, the var keyword creates variables that persist across bars but are initialized only once. Light Log leverages this to create logging objects that can accumulate information throughout a script's execution.
This pattern is particularly valuable for debugging complex strategies where you need to understand behavior across multiple bars. You can create module-level logs that track important events:
// Module-level diagnostic log
diagnostics = init_static_log(ErrorType.info)
// Track strategy decisions across bars
check_entry_conditions() =>
diagnostics.clear() // Start fresh each bar
diagnostics.write_line("Bar " + str.tostring(bar_index) + " analysis:")
if close > sma(close, 20)
diagnostics.write_line("Price above SMA20", false)
else
diagnostics.write_line("Price below SMA20 - no entry", true, ErrorType.warning)
if volume > sma(volume, 20) * 1.5
diagnostics.write_line("Volume surge detected", false)
else
diagnostics.write_line("Normal volume", false)
// Render diagnostics based on verbosity setting
if debug_mode
diagnostics.render_now()
Advanced Validation Patterns
Light Log's argument validation functions enable sophisticated precondition checking that goes beyond simple null checks. You can implement complex validation logic while keeping your code readable:
validate_price_data(open_val, high_val, low_val, close_val) =>
argument_error(na(open_val) or na(high_val) or na(low_val) or na(close_val),
"validate_price_data", "OHLC values", "contain na values")
argument_error(high_val < low_val,
"validate_price_data", "high/low", "high is less than low")
argument_error(close_val > high_val or close_val < low_val,
"validate_price_data", "close", "is outside high/low range")
argument_log_warning(high_val == low_val,
"validate_price_data", "high/low", "are equal (no range)")
This validation function documents its requirements clearly and fails fast with helpful error messages when assumptions are violated. The mix of errors (which halt execution) and warnings (which allow continuation) provides fine-grained control over how strict your validation should be.
Performance Optimization Strategies
While Light Log adds abstraction, careful design minimizes overhead. Understanding Pine Script's execution model helps you use Light Log efficiently.
Pine Script executes once per bar, so operations that seem expensive in traditional programming might have negligible impact. However, when building real-time systems, every optimization matters. Light Log provides several patterns for efficient use:
Lazy Evaluation: Log messages are only built when they'll be rendered. Use conditional logging to avoid string concatenation in production:
if debug_mode
log.write_line("Calculated value: " + str.tostring(complex_calculation))
Selective Wrapping: Not every value needs error tracking. Wrap values at API boundaries and critical calculation points, but use raw values for simple operations:
// Wrap at boundaries
input_price = close.FLOAT()
validated_period = validate_period(input_period).INT()
// Use raw values internally
sum = 0.0
for i = 0 to validated_period.v - 1
sum += close
Error Propagation: When errors occur early, avoid expensive calculations:
process_data(input) =>
validated = validate_input(input)
if validated.has_error()
validated // Return early with error
else
// Expensive processing only if valid
perform_complex_calculation(validated)
Integration Patterns
Light Log integrates smoothly with existing Pine Script code. You can adopt it incrementally, starting with critical functions and expanding coverage as needed.
Boundary Validation: Add Light Log at the boundaries of your system – where user input enters and where final outputs are produced. This catches most errors while minimizing changes to existing code.
Progressive Enhancement: Start by adding argument validation to existing functions. Then wrap return values. Finally, add comprehensive logging. Each step improves reliability without requiring a complete rewrite.
Testing and Debugging: Use Light Log's conditional rendering to create debug modes for your scripts. Production users see clean output while developers get detailed diagnostics:
// User input for debug mode
debug = input.bool(false, "Enable debug logging")
// Conditional diagnostic output
if debug
diagnostics.render_now()
else
diagnostics.render_condition() // Only shows errors/warnings
Future-Proofing Your Code
Light Log's patterns prepare your code for Pine Script's evolution. As Pine Script adds more sophisticated features, code that uses structured error handling and defensive programming will adapt more easily than code that relies on implicit assumptions.
The type wrapper system, in particular, positions your code to take advantage of potential future features or more sophisticated type inference. By thinking in terms of wrapped values and error propagation today, you're building code that will remain maintainable and extensible tomorrow.
Light Log doesn't just make your Pine Script better today – it prepares it for the trading systems you'll need to build tomorrow.
Library "light_log"
A lightweight logging and defensive programming library for Pine Script.
Designed for modular and extensible scripts, this utility provides structured runtime validation,
conditional logging, and reusable `Log` objects for centralized error propagation.
It also introduces a typed wrapping system for all native Pine values (e.g., `INT`, `FLOAT`, `LABEL`),
allowing values to carry errors alongside data. This enables functional-style flows with built-in
validation tracking, error detection (`has_error()`), and fluent chaining.
Inspired by structured logging patterns found in systems like C#, it reduces boilerplate,
enforces argument safety, and encourages clean, maintainable code architecture.
method INT(self, error_type)
Wraps an `int` value into an `INT` struct with an optional log severity.
Namespace types: series int, simple int, input int, const int
Parameters:
self (int) : The raw `int` value to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: An `INT` object containing the value and a default Log instance.
method FLOAT(self, error_type)
Wraps a `float` value into a `FLOAT` struct with an optional log severity.
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : The raw `float` value to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `FLOAT` object containing the value and a default Log instance.
method BOOL(self, error_type)
Wraps a `bool` value into a `BOOL` struct with an optional log severity.
Namespace types: series bool, simple bool, input bool, const bool
Parameters:
self (bool) : The raw `bool` value to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `BOOL` object containing the value and a default Log instance.
method STRING(self, error_type)
Wraps a `string` value into a `STRING` struct with an optional log severity.
Namespace types: series string, simple string, input string, const string
Parameters:
self (string) : The raw `string` value to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `STRING` object containing the value and a default Log instance.
method COLOR(self, error_type)
Wraps a `color` value into a `COLOR` struct with an optional log severity.
Namespace types: series color, simple color, input color, const color
Parameters:
self (color) : The raw `color` value to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `COLOR` object containing the value and a default Log instance.
method LINE(self, error_type)
Wraps a `line` object into a `LINE` struct with an optional log severity.
Namespace types: series line
Parameters:
self (line) : The raw `line` object to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `LINE` object containing the value and a default Log instance.
method LABEL(self, error_type)
Wraps a `label` object into a `LABEL` struct with an optional log severity.
Namespace types: series label
Parameters:
self (label) : The raw `label` object to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `LABEL` object containing the value and a default Log instance.
method BOX(self, error_type)
Wraps a `box` object into a `BOX` struct with an optional log severity.
Namespace types: series box
Parameters:
self (box) : The raw `box` object to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `BOX` object containing the value and a default Log instance.
method TABLE(self, error_type)
Wraps a `table` object into a `TABLE` struct with an optional log severity.
Namespace types: series table
Parameters:
self (table) : The raw `table` object to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `TABLE` object containing the value and a default Log instance.
method CHART_POINT(self, error_type)
Wraps a `chart.point` value into a `CHART_POINT` struct with an optional log severity.
Namespace types: chart.point
Parameters:
self (chart.point) : The raw `chart.point` value to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `CHART_POINT` object containing the value and a default Log instance.
method POLYLINE(self, error_type)
Wraps a `polyline` object into a `POLYLINE` struct with an optional log severity.
Namespace types: series polyline, series polyline, series polyline, series polyline
Parameters:
self (polyline) : The raw `polyline` object to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `POLYLINE` object containing the value and a default Log instance.
method LINEFILL(self, error_type)
Wraps a `linefill` object into a `LINEFILL` struct with an optional log severity.
Namespace types: series linefill
Parameters:
self (linefill) : The raw `linefill` object to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `LINEFILL` object containing the value and a default Log instance.
method from_INT(self)
Extracts the integer value from an INT wrapper.
Namespace types: INT
Parameters:
self (INT) : The wrapped INT instance.
Returns: The underlying `int` value.
method from_FLOAT(self)
Extracts the float value from a FLOAT wrapper.
Namespace types: FLOAT
Parameters:
self (FLOAT) : The wrapped FLOAT instance.
Returns: The underlying `float` value.
method from_BOOL(self)
Extracts the boolean value from a BOOL wrapper.
Namespace types: BOOL
Parameters:
self (BOOL) : The wrapped BOOL instance.
Returns: The underlying `bool` value.
method from_STRING(self)
Extracts the string value from a STRING wrapper.
Namespace types: STRING
Parameters:
self (STRING) : The wrapped STRING instance.
Returns: The underlying `string` value.
method from_COLOR(self)
Extracts the color value from a COLOR wrapper.
Namespace types: COLOR
Parameters:
self (COLOR) : The wrapped COLOR instance.
Returns: The underlying `color` value.
method from_LINE(self)
Extracts the line object from a LINE wrapper.
Namespace types: LINE
Parameters:
self (LINE) : The wrapped LINE instance.
Returns: The underlying `line` object.
method from_LABEL(self)
Extracts the label object from a LABEL wrapper.
Namespace types: LABEL
Parameters:
self (LABEL) : The wrapped LABEL instance.
Returns: The underlying `label` object.
method from_BOX(self)
Extracts the box object from a BOX wrapper.
Namespace types: BOX
Parameters:
self (BOX) : The wrapped BOX instance.
Returns: The underlying `box` object.
method from_TABLE(self)
Extracts the table object from a TABLE wrapper.
Namespace types: TABLE
Parameters:
self (TABLE) : The wrapped TABLE instance.
Returns: The underlying `table` object.
method from_CHART_POINT(self)
Extracts the chart.point from a CHART_POINT wrapper.
Namespace types: CHART_POINT
Parameters:
self (CHART_POINT) : The wrapped CHART_POINT instance.
Returns: The underlying `chart.point` value.
method from_POLYLINE(self)
Extracts the polyline object from a POLYLINE wrapper.
Namespace types: POLYLINE
Parameters:
self (POLYLINE) : The wrapped POLYLINE instance.
Returns: The underlying `polyline` object.
method from_LINEFILL(self)
Extracts the linefill object from a LINEFILL wrapper.
Namespace types: LINEFILL
Parameters:
self (LINEFILL) : The wrapped LINEFILL instance.
Returns: The underlying `linefill` object.
method has_error(self)
Returns true if the INT wrapper has an active log entry.
Namespace types: INT
Parameters:
self (INT) : The INT instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the FLOAT wrapper has an active log entry.
Namespace types: FLOAT
Parameters:
self (FLOAT) : The FLOAT instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the BOOL wrapper has an active log entry.
Namespace types: BOOL
Parameters:
self (BOOL) : The BOOL instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the STRING wrapper has an active log entry.
Namespace types: STRING
Parameters:
self (STRING) : The STRING instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the COLOR wrapper has an active log entry.
Namespace types: COLOR
Parameters:
self (COLOR) : The COLOR instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the LINE wrapper has an active log entry.
Namespace types: LINE
Parameters:
self (LINE) : The LINE instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the LABEL wrapper has an active log entry.
Namespace types: LABEL
Parameters:
self (LABEL) : The LABEL instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the BOX wrapper has an active log entry.
Namespace types: BOX
Parameters:
self (BOX) : The BOX instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the TABLE wrapper has an active log entry.
Namespace types: TABLE
Parameters:
self (TABLE) : The TABLE instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the CHART_POINT wrapper has an active log entry.
Namespace types: CHART_POINT
Parameters:
self (CHART_POINT) : The CHART_POINT instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the POLYLINE wrapper has an active log entry.
Namespace types: POLYLINE
Parameters:
self (POLYLINE) : The POLYLINE instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the LINEFILL wrapper has an active log entry.
Namespace types: LINEFILL
Parameters:
self (LINEFILL) : The LINEFILL instance to check.
Returns: True if an error or message is active in the log.
void_return()
Utility function used when a return is syntactically required but functionally unnecessary.
Returns: Nothing. Function never executes its body.
argument_error(condition, function, argument, message)
Throws a runtime error when a condition is met. Used for strict argument validation.
Parameters:
condition (bool) : Boolean expression that triggers the runtime error.
function (string) : Name of the calling function (for formatting).
argument (string) : Name of the problematic argument.
message (string) : Description of the error cause.
Returns: Never returns. Halts execution if the condition is true.
argument_log_info(condition, function, argument, message)
Logs an informational message when a condition is met. Used for optional debug visibility.
Parameters:
condition (bool) : Boolean expression that triggers the log.
function (string) : Name of the calling function.
argument (string) : Argument name being referenced.
message (string) : Informational message to log.
Returns: Nothing. Logs if the condition is true.
argument_log_warning(condition, function, argument, message)
Logs a warning when a condition is met. Non-fatal but highlights potential issues.
Parameters:
condition (bool) : Boolean expression that triggers the warning.
function (string) : Name of the calling function.
argument (string) : Argument name being referenced.
message (string) : Warning message to log.
Returns: Nothing. Logs if the condition is true.
argument_log_error(condition, function, argument, message)
Logs an error message when a condition is met. Does not halt execution.
Parameters:
condition (bool) : Boolean expression that triggers the error log.
function (string) : Name of the calling function.
argument (string) : Argument name being referenced.
message (string) : Error message to log.
Returns: Nothing. Logs if the condition is true.
init_static_log(error_type, message, active)
Initializes a persistent (var) Log object. Ideal for global logging in scripts or modules.
Parameters:
error_type (series ErrorType) : Initial severity level (required).
message (string) : Optional starting message string. Default value of ("").
active (bool) : Whether the log should be flagged active on initialization. Default value of (false).
Returns: A static Log object with the given parameters.
method new_line(self)
Appends a newline character to the Log message. Useful for separating entries during chained writes.
Namespace types: Log
Parameters:
self (Log) : The Log instance to modify.
Returns: The updated Log object with a newline appended.
method write(self, message, flag_active, error_type)
Appends a message to a Log object without a newline. Updates severity and active state if specified.
Namespace types: Log
Parameters:
self (Log) : The Log instance being modified.
message (string) : The text to append to the log.
flag_active (bool) : Whether to activate the log for conditional rendering. Default value of (false).
error_type (series ErrorType) : Optional override for the severity level. Default value of (na).
Returns: The updated Log object.
method write_line(self, message, flag_active, error_type)
Appends a message to a Log object, prefixed with a newline for clarity.
Namespace types: Log
Parameters:
self (Log) : The Log instance being modified.
message (string) : The text to append to the log.
flag_active (bool) : Whether to activate the log for conditional rendering. Default value of (false).
error_type (series ErrorType) : Optional override for the severity level. Default value of (na).
Returns: The updated Log object.
method clear(self, flag_active, error_type)
Clears a Log object’s message and optionally reactivates it. Can also update the error type.
Namespace types: Log
Parameters:
self (Log) : The Log instance being cleared.
flag_active (bool) : Whether to activate the log after clearing. Default value of (false).
error_type (series ErrorType) : Optional new error type to assign. If not provided, the previous type is retained. Default value of (na).
Returns: The cleared Log object.
method render_condition(self, flag_active, error_type)
Conditionally renders the log if it is active. Allows overriding error type and controlling active state afterward.
Namespace types: Log
Parameters:
self (Log) : The Log instance to evaluate and render.
flag_active (bool) : Whether to activate the log after rendering. Default value of (false).
error_type (series ErrorType) : Optional error type override. Useful for contextual formatting just before rendering. Default value of (na).
Returns: The updated Log object.
method render_now(self, flag_active, error_type)
Immediately renders the log regardless of `active` state. Allows overriding error type and active flag.
Namespace types: Log
Parameters:
self (Log) : The Log instance to render.
flag_active (bool) : Whether to activate the log after rendering. Default value of (false).
error_type (series ErrorType) : Optional error type override. Allows dynamic severity adjustment at render time. Default value of (na).
Returns: The updated Log object.
render(self, condition, flag_active, error_type)
Renders the log conditionally or unconditionally. Allows full control over render behavior.
Parameters:
self (Log) : The Log instance to render.
condition (bool) : If true, renders only if the log is active. If false, always renders. Default value of (false).
flag_active (bool) : Whether to activate the log after rendering. Default value of (false).
error_type (series ErrorType) : Optional error type override passed to the render methods. Default value of (na).
Returns: The updated Log object.
Log
A structured object used to store and render logging messages.
Fields:
error_type (series ErrorType) : The severity level of the message (from the ErrorType enum).
message (series string) : The text of the log message.
active (series bool) : Whether the log should trigger rendering when conditionally evaluated.
INT
A wrapped integer type with attached logging for validation or tracing.
Fields:
v (series int) : The underlying `int` value.
e (Log) : Optional log object describing validation status or error context.
FLOAT
A wrapped float type with attached logging for validation or tracing.
Fields:
v (series float) : The underlying `float` value.
e (Log) : Optional log object describing validation status or error context.
BOOL
A wrapped boolean type with attached logging for validation or tracing.
Fields:
v (series bool) : The underlying `bool` value.
e (Log) : Optional log object describing validation status or error context.
STRING
A wrapped string type with attached logging for validation or tracing.
Fields:
v (series string) : The underlying `string` value.
e (Log) : Optional log object describing validation status or error context.
COLOR
A wrapped color type with attached logging for validation or tracing.
Fields:
v (series color) : The underlying `color` value.
e (Log) : Optional log object describing validation status or error context.
LINE
A wrapped line object with attached logging for validation or tracing.
Fields:
v (series line) : The underlying `line` value.
e (Log) : Optional log object describing validation status or error context.
LABEL
A wrapped label object with attached logging for validation or tracing.
Fields:
v (series label) : The underlying `label` value.
e (Log) : Optional log object describing validation status or error context.
BOX
A wrapped box object with attached logging for validation or tracing.
Fields:
v (series box) : The underlying `box` value.
e (Log) : Optional log object describing validation status or error context.
TABLE
A wrapped table object with attached logging for validation or tracing.
Fields:
v (series table) : The underlying `table` value.
e (Log) : Optional log object describing validation status or error context.
CHART_POINT
A wrapped chart point with attached logging for validation or tracing.
Fields:
v (chart.point) : The underlying `chart.point` value.
e (Log) : Optional log object describing validation status or error context.
POLYLINE
A wrapped polyline object with attached logging for validation or tracing.
Fields:
v (series polyline) : The underlying `polyline` value.
e (Log) : Optional log object describing validation status or error context.
LINEFILL
A wrapped linefill object with attached logging for validation or tracing.
Fields:
v (series linefill) : The underlying `linefill` value.
e (Log) : Optional log object describing validation status or error context.
Approximate Entropy Zones [PhenLabs]Version: PineScript™ v6
Description
This indicator identifies periods of market complexity and randomness by calculating the Approximate Entropy (ApEn) of price action. As the movement of the market becomes complex, it means the current trend is losing steam and a reversal or consolidation is likely near. The indicator plots high-entropy periods as zones on your chart, providing a graphical suggestion to anticipate a potential market direction change. This indicator is designed to help traders identify favorable times to get in or out of a trade by highlighting when the market is in a state of disarray.
Points of Innovation
Advanced Complexity Analysis: Instead of relying on traditional momentum or trend indicators, this tool uses Approximate Entropy to quantify the unpredictability of price movements.
Dynamic Zone Creation: It automatically plots zones on the chart during periods of high entropy, providing a clear and intuitive visual guide.
Customizable Sensitivity: Users can fine-tune the ‘Entropy Threshold’ to adjust how frequently zones appear, allowing for calibration to different assets and timeframes.
Time-Based Zone Expiration: Zones can be set to expire after a specific time, keeping the chart clean and relevant.
Built-in Zone Size Filter: Excludes zones that form on excessively large candles, filtering out noise from extreme volatility events.
On-Chart Calibration Guide: A persistent note on the chart provides simple instructions for adjusting the entropy threshold, making it easy for users to optimize the indicator’s performance.
Core Components
Approximate Entropy (ApEn) Calculation: The core of the indicator, which measures the complexity or randomness of the price data.
Zone Plotting: Creates visual boxes on the chart when the calculated ApEn value exceeds a user-defined threshold.
Dynamic Zone Management: Manages the lifecycle of the zones, from creation to expiration, ensuring the chart remains uncluttered.
Customizable Settings: A comprehensive set of inputs that allow users to control the indicator’s sensitivity, appearance, and time-based behavior.
Key Features
Identifies Potential Reversals: The high-entropy zones can signal that a trend is nearing its end, giving traders an early warning.
Works on Any Timeframe: The indicator can be applied to any chart timeframe, from minutes to days.
Customizable Appearance: Users can change the color and transparency of the zones to match their chart’s theme.
Informative Labels: Each zone can display the calculated entropy value and the direction of the candle on which it formed.
Visualization
Entropy Zones: Shaded boxes that appear on the chart, highlighting candles with high complexity.
Zone Labels: Text within each zone that displays the ApEn value and a directional arrow (e.g., “0.525 ↑”).
Calibration Note: A small table in the top-right corner of the chart with instructions for adjusting the indicator’s sensitivity.
Usage Guidelines
Entropy Analysis
Source: The price data used for the ApEn calculation. (Default: close)
Lookback Length: The number of bars used in the ApEn calculation. (Default: 20, Range: 10-50)
Embedding Dimension (m): The length of patterns to be compared; a standard value for financial data. (Default: 2)
Tolerance Multiplier (r): Adjusts the tolerance for pattern matching; a larger value makes matching more lenient. (Default: 0.2)
Entropy Threshold: The ApEn value that must be exceeded to plot a zone. Increase this if too many zones appear; decrease it if too few appear. (Default: 0.525)
Time Settings
Analysis Timeframe: How long a zone remains on the chart after it forms. (Default: 1D)
Custom Period (Bars): The zone’s lifespan in bars if “Analysis Timeframe” is set to “Custom”. (Default: 1000)
Zone Settings
Zone Fill Color: The color of the entropy zones. (Default: #21f38a with 80% transparency)
Maximum Zone Size %: Filters out zones on candles that are larger than this percentage of their low price. (Default: 0.5)
Display Options
Show Entropy Label: Toggles the visibility of the text label inside each zone. (Default: true)
Label Text Position: The horizontal alignment of the text label. (Default: Right)
Show Calibration Note: Toggles the visibility of the calibration note in the corner of the chart. (Default: true)
Best Use Cases
Trend Reversal Trading: Identifying when a strong trend is likely to reverse or pause.
Breakout Confirmation: Using the absence of high entropy to confirm the strength of a breakout.
Ranging Market Identification: Periods of high entropy can indicate that a market is transitioning into a sideways or choppy phase.
Limitations
Not a Standalone Signal: This indicator should be used in conjunction with other forms of analysis to confirm trading signals.
Lagging Nature: Like all indicators based on historical data, ApEn is a lagging measure and does not predict future price movements with certainty.
Calibration Required: The effectiveness of the indicator is highly dependent on the “Entropy Threshold” setting, which needs to be adjusted for different assets and timeframes.
What Makes This Unique
Quantifies Complexity: It provides a numerical measure of market complexity, offering a different perspective than traditional indicators.
Clear Visual Cues: The zones make it easy to see when the market is in a state of high unpredictability.
User-Friendly Design: With features like the on-chart calibration note, the indicator is designed to be easy to use and optimize.
How It Works
Calculate Standard Deviation: The indicator first calculates the standard deviation of the source price data over a specified lookback period.
Calculate Phi: It then calculates a value called “phi” for two different pattern lengths (embedding dimensions ‘m’ and ‘m+1’). This involves comparing sequences of data points to see how many are “similar” within a certain tolerance (determined by the standard deviation and the ‘r’ multiplier).
Calculate ApEn: The Approximate Entropy is the difference between the two phi values. A higher ApEn value indicates greater irregularity and unpredictability in the data.
Plot Zones: If the calculated ApEn exceeds the user-defined ‘Entropy Threshold’, a zone is plotted on the chart.
Note: The “Entropy Threshold” is the most important setting to adjust. If you see too many zones, increase the threshold. If you see too few, decrease it.
