Inizia

Cerca negli script per " TABLE"

Multiple Indicator 50EMA Cross AlertsHere’s a screener including Symbol, Price, TSI, and 50 ema cross in a table output. The 50 Exponential Moving Average is a trend indicator You can find bullish momentum when the 50 ema crossed over or a bearish momentum when the 50 ema crossed under we are looking to take advantage by trading the reversion of these trends. True strength index (TSI) is a trend momentum indicator Readings are bullish when the True Strength Index shows positive values Readings are bearish when the indicator displays negative values. When a value is above 20, we look for selling overbought opportunity and when the value is under 20, we look for buying oversold opportunity. You can select the pair of your choice in the settings. Make sure to create an alert and choose any alerts then an alert will trigger when a price cross under or cross over the 50 ema for every pair separately. This allow the user to verify if there is a trade set up or not. Disclaimer This post and the script don’t provide any financial advice.
Indicatore Pine Script®
di F_rank_01
27
BTC Futures BasisShows various basis percentages in a table and plots historical basis. Also has an alert function for backwardation events. Useful for tracking bullish/bearish sentiment in BTC futures markets. *Currently displays March and June futures for the following exchanges: Bitmex, Binance, Deribit, Okex, and FTX Also displays CME Continuous Next Contract. All of the symbols are customizable. ----------- Market-wide backwardation usually occurs during a heavy sell-off (such as a liquidation cascade). **For getting alerts of backwardation events, I recommend creating an alert on the 1 minute chart with the condition "Any alert() function call". Alert level is customizable as well. ----------- *NOTE!! : Futures contracts expire (obviously), so the contract symbols will need to be updated periodically. I will try to keep them updated going into the future. **NOTE2!! : The alert() function does not track the CME contract. This is to avoid false triggers.
Indicatore Pine Script®
di daylad
4
SPY Sub-Sector Daily Money Flow TableThis calculates the dollar volume per candlestick (2nd row) and cumulative (3rd row) of the entire trading day for each subsector of the SPY. The 'Total' column is the total of all the subsectors combined. It is calculated separately from SPY volume. The money flow is calculated with (open+close)/2 which means different timeframes yield different results and won't be especially accurate day-by-day. This is useful to quickly see rotation and possible divergences. Enjoy!
Indicatore Pine Script®
di barnabygraham
6
[CLX][#01] Animation - Price Ticker (Marquee)This indicator displays a classic animated price ticker overlaid on the user’s current chart. It is possible to fully customize it or to select one of the predefined styles. A detailed description will follow in the next few days. Used Pinescript technics: - varip (view/animation) - tulip instance (config/codestructur) - table (view/position) By the way, for me, one of the coolest animated effects is by Duyck We hope you enjoy it! 🎉 CRYPTOLINX - jango_blockchained 😊👍 Disclaimer: Trading success is all about following your trading strategy and the indicators should fit within your trading strategy, and not to be traded upon solely. The script is for informational and educational purposes only. Use of the script does not constitute professional and/or financial advice. You alone have the sole responsibility of evaluating the script output and risks associated with the use of the script. In exchange for using the script, you agree not to hold dgtrd TradingView user liable for any possible claim for damages arising from any decision you make based on use of the script.
Indicatore Pine Script®
di cryptolinx
2
MTF Price/Volume % [Anan]Hello friends, This is a multi-timeframe table with these features: Display price change percentage compared with the last timeframe candle close. Display price change percentage compared with the last timeframe candle close MA. Displays change percentage compared with the last timeframe candle volume. Displays change percentage compared with the last timeframe candle volume MA. Change type/length of MA for Price/Volume. Full control of Panel position and size. Full control of displaying any row or column.
Indicatore Pine Script®
di Mohamed3nan
20
Average Daily Range TableThis is the last script to complete Vladimir Poltoratskiy's setup found in his books. Poltoratskiy argues that you should not take any fractal corridors higher than 50% of the Average Daily Range. To be honest, even 40% is a lot, because then, your target will be 160% ADR away from your entry and one "fracture" just can't be enough to predict moves this big. I chose a table to visually represent the indicator because it doesn't change its value during the day. It takes far less room on the chart. There are also two simple moving averages. You may use the as an indicator if the relative volatility as of late is extremely low and in that case, perhaps, expect an increase in the coming days. They are applied to the Average Daily Range, not one day range!
Indicatore Pine Script®
di OrcChieftain
1
PAC newThis indicator will alert you when a candle goes above or below the price action channel (PAC) but only on the first or second candle after a colour change in candle. When price is above the price action channel that is a bullish sign, when price is below the PAC that is a bearish sign. The idea is that a sudden change in price is a cause to investigate further price action moving in that direction so the indicator aims to identify reversal Scalping strategy that works on 5 min chart and aims to gain 10 pips. Do not act on every signal. Further investigation is required, for example by looking at RSI oversolf and overbought levels. For example, at an oversold area, a buy signal is more valid
Indicatore Pine Script®
di table47
Month/Month Percentage % Change, Historical; Seasonal TendencyTable of monthly % changes in Average Price over the last 10 years (or the 10 yrs prior to input year). Useful for gauging seasonal tendencies of an asset; backtesting monthly volatility and bullish/bearish tendency. ~~User Inputs~~ Choose measure of average: sma(close), sma(ohlc4), vwap(close), vwma(close). Show last 10yrs, with 10yr average % change, or to just show single year. Chose input year; with the indicator auto calculating the prior 10 years. Choose color for labels and size for labels; choose +Ve value color and -Ve value color. Set 'Daily bars in month': 21 for Forex/Commodities/Indices; 30 for Crypto. Set precision: decimal places ~~notes~~ -designed for use on Daily timeframe (tradingview is buggy on monthly timeframe calculations, and less precise on weekly timeframe calculations). -where Current month of year has not occurred yet, will print 9yr average. -calculates the average change of displayed month compared to the previous month: i.e. Jan22 value represents whole of Jan22 compared to whole of Dec21. -table displays on the chart over the input year; so for ES, with 2010 selected; shows values from 2001-2010, displaying across 2010-2011 on the chart. -plots on seperate right hand side scale, so can be shrunk and dragged vertically. -thanks to @gabx11 for the suggestion which inspired me to write this
Indicatore Pine Script®
di twingall
10
Scientific Correlation Testing FrameworkScientific Correlation Testing Framework - Comprehensive Guide Introduction to Correlation Analysis What is Correlation? Correlation is a statistical measure that describes the degree to which two assets move in relation to each other. Think of it like measuring how closely two dancers move together on a dance floor. Perfect Positive Correlation (+1.0): Both dancers move in perfect sync, same direction, same speed Perfect Negative Correlation (-1.0): Both dancers move in perfect sync but in opposite directions Zero Correlation (0): The dancers move completely independently of each other In financial markets, correlation helps us understand relationships between different assets, which is crucial for: Portfolio diversification Risk management Pairs trading strategies Hedging positions Market analysis Why This Script is Special This script goes beyond simple correlation calculations by providing: Two different correlation methods (Pearson and Spearman) Statistical significance testing to ensure results are meaningful Rolling correlation analysis to track how relationships change over time Visual representation for easy interpretation Comprehensive statistics table with detailed metrics Deep Dive into the Script's Components 1. Input Parameters Explained- Symbol Selection: This allows you to select the second asset to compare with the chart's primary asset Default is Apple (NASDAQ:AAPL), but you can change this to any symbol Example: If you're viewing a Bitcoin chart, you might set this to "NASDAQ:TSLA" to see if Bitcoin and Tesla are correlated Correlation Window (60): This is the number of periods used to calculate the main correlation Larger values (e.g., 100-500) provide more stable, long-term correlation measures Smaller values (e.g., 10-50) are more responsive to recent price movements 60 is a good balance for most daily charts (about 3 months of trading days) Rolling Correlation Window (20): A shorter window to detect recent changes in correlation This helps identify when the relationship between assets is strengthening or weakening Default of 20 is roughly one month of trading days Return Type: This determines how price changes are calculated Simple Returns: (Today's Price - Yesterday's Price) / Yesterday's Price Easy to understand: "The asset went up 2% today" Log Returns: Natural logarithm of (Today's Price / Yesterday's Price) More mathematically elegant for statistical analysis Better for time-additive properties (returns over multiple periods) Less sensitive to extreme values. Confidence Level (95%): This determines how certain we want to be about our results 95% confidence means we accept a 5% chance of being wrong (false positive) Higher confidence (e.g., 99%) makes the test more strict Lower confidence (e.g., 90%) makes the test more lenient 95% is the standard in most scientific research Show Statistical Significance: When enabled, the script will test if the correlation is statistically significant or just due to random chance. Display options control what you see on the chart: Show Pearson/Spearman/Rolling Correlation: Toggle each correlation type on/off Show Scatter Plot: Displays a scatter plot of returns (limited to recent points to avoid performance issues) Show Statistical Tests: Enables the detailed statistics table Table Text Size: Adjusts the size of text in the statistics table 2.Functions explained- calcReturns(): This function calculates price returns based on your selected method: Log Returns: Formula: ln(Price_t / Price_t-1) Example: If a stock goes from $100 to $101, the log return is ln(101/100) = ln(1.01) ≈ 0.00995 or 0.995% Benefits: More symmetric, time-additive, and better for statistical modeling Simple Returns: Formula: (Price_t - Price_t-1) / Price_t-1 Example: If a stock goes from $100 to $101, the simple return is (101-100)/100 = 0.01 or 1% Benefits: More intuitive and easier to understand rankArray(): This function calculates the rank of each value in an array, which is used for Spearman correlation: How ranking works: The smallest value gets rank 1 The second smallest gets rank 2, and so on For ties (equal values), they get the average of their ranks Example: For values Sorted: Ranks: (the two 2s tie for ranks 1 and 2, so they both get 1.5) Why this matters: Spearman correlation uses ranks instead of actual values, making it less sensitive to outliers and non-linear relationships. pearsonCorr(): This function calculates the Pearson correlation coefficient: Mathematical Formula: r = (nΣxy - ΣxΣy) / √ Where x and y are the two variables, and n is the sample size What it measures: The strength and direction of the linear relationship between two variables Values range from -1 (perfect negative linear relationship) to +1 (perfect positive linear relationship) 0 indicates no linear relationship Example: If two stocks have a Pearson correlation of 0.8, they have a strong positive linear relationship When one stock goes up, the other tends to go up in a fairly consistent proportion spearmanCorr(): This function calculates the Spearman rank correlation: How it works: Convert each value in both datasets to its rank Calculate the Pearson correlation on the ranks instead of the original values What it measures: The strength and direction of the monotonic relationship between two variables A monotonic relationship is one where as one variable increases, the other either consistently increases or decreases It doesn't require the relationship to be linear When to use it instead of Pearson: When the relationship is monotonic but not linear When there are significant outliers in the data When the data is ordinal (ranked) rather than interval/ratio Example: If two stocks have a Spearman correlation of 0.7, they have a strong positive monotonic relationship When one stock goes up, the other tends to go up, but not necessarily in a straight-line relationship tStatistic(): This function calculates the t-statistic for correlation: Mathematical Formula: t = r × √((n-2)/(1-r²)) Where r is the correlation coefficient and n is the sample size What it measures: How many standard errors the correlation is away from zero Used to test the null hypothesis that the true correlation is zero Interpretation: Larger absolute t-values indicate stronger evidence against the null hypothesis Generally, a t-value greater than 2 (in absolute terms) is considered statistically significant at the 95% confidence level criticalT() and pValue(): These functions provide approximations for statistical significance testing: criticalT(): Returns the critical t-value for a given degrees of freedom (df) and significance level The critical value is the threshold that the t-statistic must exceed to be considered statistically significant Uses approximations since Pine Script doesn't have built-in statistical distribution functions pValue(): Estimates the p-value for a given t-statistic and degrees of freedom The p-value is the probability of observing a correlation as strong as the one calculated, assuming the true correlation is zero Smaller p-values indicate stronger evidence against the null hypothesis Standard interpretation: p < 0.01: Very strong evidence (marked with **) p < 0.05: Strong evidence (marked with *) p ≥ 0.05: Weak evidence, not statistically significant stdev(): This function calculates the standard deviation of a dataset: Mathematical Formula: σ = √(Σ(x-μ)²/(n-1)) Where x is each value, μ is the mean, and n is the sample size What it measures: The amount of variation or dispersion in a set of values A low standard deviation indicates that the values tend to be close to the mean A high standard deviation indicates that the values are spread out over a wider range Why it matters for correlation: Standard deviation is used in calculating the correlation coefficient It also provides information about the volatility of each asset's returns Comparing standard deviations helps understand the relative riskiness of the two assets. 3.Getting Price Data- price1: The closing price of the primary asset (the chart you're viewing) price2: The closing price of the secondary asset (the one you selected in the input parameters) Returns are used instead of raw prices because: Returns are typically stationary (mean and variance stay constant over time) Returns normalize for price levels, allowing comparison between assets of different values Returns represent what investors actually care about: percentage changes in value 4.Information Table- Creates a table to display statistics Only shows on the last bar to avoid performance issues Positioned in the top right of the chart Has 2 columns and 15 rows Populating the Table The script then populates the table with various statistics: Header Row: "Metric" and "Value" Sample Information: Sample size and return type Pearson Correlation: Value, t-statistic, p-value, and significance Spearman Correlation: Value, t-statistic, p-value, and significance Rolling Correlation: Current value Standard Deviations: For both assets Interpretation: Text description of the correlation strength The table uses color coding to highlight important information: Green for significant positive results Red for significant negative results Yellow for borderline significance Color-coded headers for each section => Practical Applications and Interpretation How to Interpret the Results Correlation Strength 0.0 to 0.3 (or 0.0 to -0.3): Weak or no correlation The assets move mostly independently of each other Good for diversification purposes 0.3 to 0.7 (or -0.3 to -0.7): Moderate correlation The assets show some tendency to move together (or in opposite directions) May be useful for certain trading strategies but not extremely reliable 0.7 to 1.0 (or -0.7 to -1.0): Strong correlation The assets show a strong tendency to move together (or in opposite directions) Can be useful for pairs trading, hedging, or as a market indicator Statistical Significance p < 0.01: Very strong evidence that the correlation is real Marked with ** in the table Very unlikely to be due to random chance p < 0.05: Strong evidence that the correlation is real Marked with * in the table Unlikely to be due to random chance p ≥ 0.05: Weak evidence that the correlation is real Not marked in the table Could easily be due to random chance Rolling Correlation The rolling correlation shows how the relationship between assets changes over time If the rolling correlation is much different from the long-term correlation, it suggests the relationship is changing This can indicate: A shift in market regime Changing fundamentals of one or both assets Temporary market dislocations that might present trading opportunities Trading Applications 1. Portfolio Diversification Goal: Reduce overall portfolio risk by combining assets that don't move together Strategy: Look for assets with low or negative correlations Example: If you hold tech stocks, you might add some utilities or bonds that have low correlation with tech 2. Pairs Trading Goal: Profit from the relative price movements of two correlated assets Strategy: Find two assets with strong historical correlation When their prices diverge (one goes up while the other goes down) Buy the underperforming asset and short the outperforming asset Close the positions when they converge back to their normal relationship Example: If Coca-Cola and Pepsi are highly correlated but Coca-Cola drops while Pepsi rises, you might buy Coca-Cola and short Pepsi 3. Hedging Goal: Reduce risk by taking an offsetting position in a negatively correlated asset Strategy: Find assets that tend to move in opposite directions Example: If you hold a portfolio of stocks, you might buy some gold or government bonds that tend to rise when stocks fall 4. Market Analysis Goal: Understand market dynamics and interrelationships Strategy: Analyze correlations between different sectors or asset classes Example: If tech stocks and semiconductor stocks are highly correlated, movements in one might predict movements in the other If the correlation between stocks and bonds changes, it might signal a shift in market expectations 5. Risk Management Goal: Understand and manage portfolio risk Strategy: Monitor correlations to identify when diversification benefits might be breaking down Example: During market crises, many assets that normally have low correlations can become highly correlated (correlation convergence), reducing diversification benefits Advanced Interpretation and Caveats Correlation vs. Causation Important Note: Correlation does not imply causation Example: Ice cream sales and drowning incidents are correlated (both increase in summer), but one doesn't cause the other Implication: Just because two assets move together doesn't mean one causes the other to move Solution: Look for fundamental economic reasons why assets might be correlated Non-Stationary Correlations Problem: Correlations between assets can change over time Causes: Changing market conditions Shifts in monetary policy Structural changes in the economy Changes in the underlying businesses Solution: Use rolling correlations to monitor how relationships change over time Outliers and Extreme Events Problem: Extreme market events can distort correlation measurements Example: During a market crash, many assets may move in the same direction regardless of their normal relationship Solution: Use Spearman correlation, which is less sensitive to outliers Be cautious when interpreting correlations during extreme market conditions Sample Size Considerations Problem: Small sample sizes can produce unreliable correlation estimates Rule of Thumb: Use at least 30 data points for a rough estimate, 60+ for more reliable results Solution: Use the default correlation length of 60 or higher Be skeptical of correlations calculated with small samples Timeframe Considerations Problem: Correlations can vary across different timeframes Example: Two assets might be positively correlated on a daily basis but negatively correlated on a weekly basis Solution: Test correlations on multiple timeframes Use the timeframe that matches your trading horizon Look-Ahead Bias Problem: Using information that wouldn't have been available at the time of trading Example: Calculating correlation using future data Solution: This script avoids look-ahead bias by using only historical data Best Practices for Using This Script 1. Appropriate Parameter Selection Correlation Window: For short-term trading: 20-50 periods For medium-term analysis: 50-100 periods For long-term analysis: 100-500 periods Rolling Window: Should be shorter than the main correlation window Typically 1/3 to 1/2 of the main window Return Type: For most applications: Log Returns (better statistical properties) For simplicity: Simple Returns (easier to interpret) 2. Validation and Testing Out-of-Sample Testing: Calculate correlations on one time period Test if they hold in a different time period Multiple Timeframes: Check if correlations are consistent across different timeframes Economic Rationale: Ensure there's a logical reason why assets should be correlated 3. Monitoring and Maintenance Regular Review: Correlations can change, so review them regularly Alerts: Set up alerts for significant correlation changes Documentation: Keep notes on why certain assets are correlated and what might change that relationship 4. Integration with Other Analysis Fundamental Analysis: Combine correlation analysis with fundamental factors Technical Analysis: Use correlation analysis alongside technical indicators Market Context: Consider how market conditions might affect correlations Conclusion This Scientific Correlation Testing Framework provides a comprehensive tool for analyzing relationships between financial assets. By offering both Pearson and Spearman correlation methods, statistical significance testing, and rolling correlation analysis, it goes beyond simple correlation measures to provide deeper insights. For beginners, this script might seem complex, but it's built on fundamental statistical concepts that become clearer with use. Start with the default settings and focus on interpreting the main correlation lines and the statistics table. As you become more comfortable, you can adjust the parameters and explore more advanced applications. Remember that correlation analysis is just one tool in a trader's toolkit. It should be used in conjunction with other forms of analysis and with a clear understanding of its limitations. When used properly, it can provide valuable insights for portfolio construction, risk management, and pair trading strategy development.
Indicatore Pine Script®
di kingshukghosh71
COT Index v.2COT Index v.2 Indicator ( fix for extreme values) 📊 Overview The COT (Commitment of Traders) Index Indicator transforms raw COT data into normalized indices ranging from 0-100, with extensions to 120 and -20 for extreme market conditions. This powerful tool helps traders analyze institutional positioning and market sentiment by tracking the net long positions of three key market participant groups. 🎯 What It Does This indicator converts weekly CFTC Commitment of Traders data into easy-to-read oscillator format, showing: Commercial Index (Blue Line) - Smart money/hedgers positioning NonCommercial Index (Orange Line) - Large speculators/funds positioning Nonreportable Index (Red Line) - Small traders positioning 📈 Key Features Smart Scaling Algorithm 0-100 Range: Normal market conditions based on recent price action 120 Level: Extreme bullish positioning (above historical maximum) -20 Level: Extreme bearish positioning (below historical minimum) Dual Time Frame Analysis Short Period (26 weeks default): For current market scaling Historical Period (156 weeks default): For extreme condition detection Flexible Data Sources Futures Only reports Futures and Options combined reports Automatic symbol detection with manual overrides for HG and LBR 🔧 Customizable Settings Data Configuration Adjustable lookback periods for both current and historical analysis Report type selection (Futures vs Futures & Options) Display Options Toggle individual trader categories on/off Customizable reference lines (overbought/oversold levels) Optional 0/100 boundary lines Adjustable line widths and colors Reference Levels Upper Bound: 120 (extreme bullish) Overbought: 80 (default) Midline: 50 (neutral) Oversold: 20 (default) Lower Bound: -20 (extreme bearish) 💡 Trading Applications Contrarian Signals High Commercial Index + Low NonCommercial Index = Potential bullish reversal Low Commercial Index + High NonCommercial Index = Potential bearish reversal Market Sentiment Analysis Track institutional vs retail positioning divergences Identify extreme market conditions requiring attention Monitor smart money accumulation/distribution patterns Confirmation Tool Use alongside technical analysis for trade confirmation Validate breakouts with positioning data Assess market structure changes 📊 Visual Elements Status Table: Displays current settings and symbol information Color-Coded Lines: Easy identification of each trader category Reference Levels: Clear overbought/oversold boundaries Extreme Indicators: Visual cues for unusual market conditions ⚠️ Important Notes COT data is released weekly on Fridays (Tuesday data) Best suited for weekly and daily timeframes Requires symbols with available CFTC data Works automatically for most futures contracts 🎯 Best Practices Use in conjunction with price action analysis Look for divergences between price and positioning Pay special attention to extreme readings (120/-20 levels) Consider all three indices together for complete market picture Allow for data lag (3-day delay from CFTC) This indicator is ideal for swing traders, position traders, and anyone interested in understanding the positioning dynamics of professional vs retail market participants.
Indicatore Pine Script®
di dragos_cocos_dev
Dual FUT/Spot price with next monthly expiryThis Pine Script dashboard indicator is specifically designed for pair trading strategies in Indian futures markets (NSE). Let me break down how it facilitates pair trading: Core Pair Trading Concept The script monitors two correlated stocks simultaneously (Symbol A and Symbol B), comparing their: Spot prices vs Futures prices Current month futures vs Next month futures Premium/discount relationships Key Pair Trading Features 1. Dual Symbol Monitoring symbolA = "NSE:TCS" (Default) symbolB = "NSE:INFY" (Default) Allows traders to watch two stocks in the same sector (like TCS and Infosys in IT) to identify relative value opportunities. 2. Basis Analysis for Each Stock The indicator calculates the basis (difference between futures and spot): Price Difference: FUT - SPOT Premium/Discount %: ((FUT - SPOT) / SPOT) × 100 This helps identify when one stock's futures are relatively more expensive than the other's. 3. Multi-Expiry View Near Month Futures (1!): Current active contract Next Month Futures (2!): Upcoming contract This enables calendar spread analysis within each stock and helps anticipate rollover effects. 4. Comparative Table The detailed table displays side-by-side: Symbol Spot Price Near Future Near Diff (%)Next Monthly Next Diff (%)Lot SizeTCS₹3,500₹3,520+20 (+0.57%)₹3,535+35 (+1.00%)125INFY₹1,450₹1,455+5 (+0.34%)₹1,460+10 (+0.69%)600 5. Lot Size Integration Critical for position sizing in pair trades - the indicator fetches actual contract lot sizes, enabling proper hedge ratio calculations. Pair Trading Strategies Enabled Strategy 1: Basis Divergence Trading When TCS futures trade at +0.8% premium and INFY at +0.2% Trade: Short TCS futures, Long INFY futures (betting on convergence) The indicator highlights these differences with color-coded cells Strategy 2: Calendar Spread Arbitrage Compare near month vs next month premium for each stock If TCS shows wider calendar spread than INFY, potential arbitrage exists Trade the relative calendar spread difference Strategy 3: Premium/Discount Reversal Monitor which stock moves from premium to discount (or vice versa) Color indicators (green/red) make this immediately visible Enter pairs when relative premium relationships normalize Strategy 4: Lot-Adjusted Pair Trading Use lot size data to create market-neutral positions Example: If TCS lot = 125 and INFY lot = 600 Ratio = 600/125 = 4.8:1 for rupee-neutral positioning Visual Trading Cues Green cells: Futures at premium (contango) Red cells: Futures at discount (backwardation) Purple values: Next month contracts Yellow highlights: Spot prices Practical Pair Trading Example Scenario: Both stocks in same sector, historically correlated Normal state: Both show +0.5% premium Divergence: TCS jumps to +1.2%, INFY stays at +0.5% Trade Signal: Short TCS futures (expensive) Long INFY futures (relatively cheap) Exit: When premiums converge back to similar levels Hedge ratio: Use lot sizes to maintain proper exposure balance Advantages for Pair Traders ✓ Single-screen monitoring of both legs ✓ Real-time basis calculations eliminate manual math ✓ Multi-timeframe view (near + next month) ✓ Automatic lot size fetching for position sizing ✓ Visual alerts through color coding ✓ Percentage normalization for easy comparison This indicator essentially transforms raw price data into actionable pair trading intelligence by highlighting relative value discrepancies between correlated assets in the futures market. Enjoy!!
Indicatore Pine Script®
di kingshukghosh71
Advanced Seasonality Pro🎯 HOW TO USE THE ADVANCED SEASONALITY MODEL 📊 UNDERSTANDING THE COMPONENTS 1. MAIN SIGNALS STRONG BUY (▲): Strong buy signal - Signal > 0.3 WEAK BUY (●): Weak buy signal - Signal 0.1 to 0.3 STRONG SELL (▼): Strong sell signal - Signal < -0.3 WEAK SELL (●): Weak sell signal - Signal -0.1 to -0.3 NEUTRAL: No clear signal 2. INFORMATION TABLE text SIGNAL : STRONG BUY ← Most important MARKET : BULL/BEAR/SIDEWAYS VOLATILITY : HIGH/LOW/NORMAL PRICE LEVEL : NEAR RESIST/NEAR SUPPORT/MID-RANGE RSI : Current RSI value SIGNAL VALUE: 0.250 ← Signal strength MONTH : Jan/Feb/... ← Monthly effect CONFIDENCE : 75% ← Confidence level 🚀 TRADING STRATEGIES A. FOR BEGINNERS pinescript // ONLY TRADE WHEN: 1. SIGNAL = STRONG BUY/STRONG SELL 2. CONFIDENCE > 50% 3. MARKET aligns (Bull market for BUY, Bear market for SELL) 4. Not near resistance (for BUY) or near support (for SELL) B. FOR EXPERIENCED TRADERS pinescript // IDEAL CONDITIONS: STRONG BUY + BULL MARKET + LOW VOLATILITY + RSI < 60 + NOT NEAR RESISTANCE STRONG SELL + BEAR MARKET + HIGH VOLATILITY + RSI > 40 + NOT NEAR SUPPORT ⏰ BEST TRADING TIMES Monthly Patterns: Strong buys: January, October, December (January Effect, Santa Rally) Strong sells: September (September Effect) Caution: March-August (summer low volatility) Daily/Weekly Patterns: Week start (Monday): Stronger signals Week end (Friday): Reduced strength Month start (1st-5th): Positive bias Month end (after 25th): Caution advised 📈 PRACTICAL ENTRY STRATEGIES BUY ORDERS: pinescript // WHEN STRONG BUY APPEARS: 1. Wait for price pullback to SMA20 or support 2. Place BUY order with stop loss below recent low 3. Take profit at nearest resistance 4. Minimum risk reward ratio 1:2 SELL ORDERS: pinescript // WHEN STRONG SELL APPEARS: 1. Wait for price rally to near resistance 2. Place SELL order with stop loss above recent high 3. Take profit at nearest support 4. Minimum risk reward ratio 1:2 🛡️ RISK MANAGEMENT Position Sizing: pinescript // FORMULA: Risk per trade = 1-2% of account Stop loss = 1-2% from entry point Strong signal → 2% risk Weak signal → 1% risk CANCEL Conditions: pinescript 1. Signal changes from STRONG to WEAK/NEUTRAL 2. RSI enters overbought/oversold zones (>70/<30) 3. Price breaks key levels 4. Sudden volatility spike 🔍 PRACTICAL EXAMPLES Scenario 1: STRONG BUY text SIGNAL: STRONG BUY (0.35) MARKET: BULL VOLATILITY: LOW PRICE LEVEL: MID-RANGE RSI: 45 MONTH: January CONFIDENCE: 80% → GOOD SIGNAL: Execute BUY order Scenario 2: WEAK SELL text SIGNAL: WEAK SELL (-0.15) MARKET: SIDEWAYS VOLATILITY: HIGH PRICE LEVEL: NEAR SUPPORT RSI: 35 MONTH: September CONFIDENCE: 25% → WEAK SIGNAL: DO NOT trade 📱 IMPORTANT NOTES NEVER: Trade against the signal Skip stop loss orders Trade when confidence < 30% Trade multiple timeframes simultaneously Let emotions influence decisions ALWAYS: Backtest strategy first Paper trade before using real money Combine with fundamental analysis Monitor economic news Review trades weekly 🎯 CONCLUSION This model works BEST when: Combined with other indicators (volume, trend lines) Used on multiple timeframes Applied with strict risk management Patiently waiting for perfect setups Only trade when at least 3/5 conditions are favorable! 🚀 💡 PRO TIPS Use on 12H charts for optimal seasonality patterns Combine with volume confirmation for higher accuracy Adjust seasonal strength based on market conditions Monitor economic calendars for news events Keep trading journal to track performance 🔧 CUSTOMIZATION OPTIONS You can adjust these parameters in the script: seasonalStrength: Increase/decrease seasonal influence usePriceAction: Toggle price action filters useMarketRegime: Toggle market condition filters lookbackYears: Adjust historical data period Remember: No strategy is 100% accurate. Always use proper risk management and never risk more than you can afford to lose!
Indicatore Pine Script®
di Limitedterminator
Universal Ratio Trend Matrix [InvestorUnknown]The Universal Ratio Trend Matrix is designed for trend analysis on asset/asset ratios, supporting up to 40 different assets. Its primary purpose is to help identify which assets are outperforming others within a selection, providing a broad overview of market trends through a matrix of ratios. The indicator automatically expands the matrix based on the number of assets chosen, simplifying the process of comparing multiple assets in terms of performance. Key features include the ability to choose from a narrow selection of indicators to perform the ratio trend analysis, allowing users to apply well-defined metrics to their comparison. Drawback: Due to the computational intensity involved in calculating ratios across many assets, the indicator has a limitation related to loading speed. TradingView has time limits for calculations, and for users on the basic (free) plan, this could result in frequent errors due to exceeded time limits. To use the indicator effectively, users with any paid plans should run it on timeframes higher than 8h (the lowest timeframe on which it managed to load with 40 assets), as lower timeframes may not reliably load. Indicators: RSI_raw: Simple function to calculate the Relative Strength Index (RSI) of a source (asset price). RSI_sma: Calculates RSI followed by a Simple Moving Average (SMA). RSI_ema: Calculates RSI followed by an Exponential Moving Average (EMA). CCI: Calculates the Commodity Channel Index (CCI). Fisher: Implements the Fisher Transform to normalize prices. Utility Functions: f_remove_exchange_name: Strips the exchange name from asset tickers (e.g., "INDEX:BTCUSD" to "BTCUSD"). f_remove_exchange_name(simple string name) => string parts = str.split(name, ":") string result = array.size(parts) > 1 ? array.get(parts, 1) : name result f_get_price: Retrieves the closing price of a given asset ticker using request.security(). f_constant_src: Checks if the source data is constant by comparing multiple consecutive values. Inputs: General settings allow users to select the number of tickers for analysis (used_assets) and choose the trend indicator (RSI, CCI, Fisher, etc.). Table settings customize how trend scores are displayed in terms of text size, header visibility, highlighting options, and top-performing asset identification. The script includes inputs for up to 40 assets, allowing the user to select various cryptocurrencies (e.g., BTCUSD, ETHUSD, SOLUSD) or other assets for trend analysis. Price Arrays: Price values for each asset are stored in variables (price_a1 to price_a40) initialized as na. These prices are updated only for the number of assets specified by the user (used_assets). Trend scores for each asset are stored in separate arrays // declare price variables as "na" var float price_a1 = na, var float price_a2 = na, var float price_a3 = na, var float price_a4 = na, var float price_a5 = na var float price_a6 = na, var float price_a7 = na, var float price_a8 = na, var float price_a9 = na, var float price_a10 = na var float price_a11 = na, var float price_a12 = na, var float price_a13 = na, var float price_a14 = na, var float price_a15 = na var float price_a16 = na, var float price_a17 = na, var float price_a18 = na, var float price_a19 = na, var float price_a20 = na var float price_a21 = na, var float price_a22 = na, var float price_a23 = na, var float price_a24 = na, var float price_a25 = na var float price_a26 = na, var float price_a27 = na, var float price_a28 = na, var float price_a29 = na, var float price_a30 = na var float price_a31 = na, var float price_a32 = na, var float price_a33 = na, var float price_a34 = na, var float price_a35 = na var float price_a36 = na, var float price_a37 = na, var float price_a38 = na, var float price_a39 = na, var float price_a40 = na // create "empty" arrays to store trend scores var a1_array = array.new_int(40, 0), var a2_array = array.new_int(40, 0), var a3_array = array.new_int(40, 0), var a4_array = array.new_int(40, 0) var a5_array = array.new_int(40, 0), var a6_array = array.new_int(40, 0), var a7_array = array.new_int(40, 0), var a8_array = array.new_int(40, 0) var a9_array = array.new_int(40, 0), var a10_array = array.new_int(40, 0), var a11_array = array.new_int(40, 0), var a12_array = array.new_int(40, 0) var a13_array = array.new_int(40, 0), var a14_array = array.new_int(40, 0), var a15_array = array.new_int(40, 0), var a16_array = array.new_int(40, 0) var a17_array = array.new_int(40, 0), var a18_array = array.new_int(40, 0), var a19_array = array.new_int(40, 0), var a20_array = array.new_int(40, 0) var a21_array = array.new_int(40, 0), var a22_array = array.new_int(40, 0), var a23_array = array.new_int(40, 0), var a24_array = array.new_int(40, 0) var a25_array = array.new_int(40, 0), var a26_array = array.new_int(40, 0), var a27_array = array.new_int(40, 0), var a28_array = array.new_int(40, 0) var a29_array = array.new_int(40, 0), var a30_array = array.new_int(40, 0), var a31_array = array.new_int(40, 0), var a32_array = array.new_int(40, 0) var a33_array = array.new_int(40, 0), var a34_array = array.new_int(40, 0), var a35_array = array.new_int(40, 0), var a36_array = array.new_int(40, 0) var a37_array = array.new_int(40, 0), var a38_array = array.new_int(40, 0), var a39_array = array.new_int(40, 0), var a40_array = array.new_int(40, 0) f_get_price(simple string ticker) => request.security(ticker, "", close) // Prices for each USED asset f_get_asset_price(asset_number, ticker) => if (used_assets >= asset_number) f_get_price(ticker) else na // overwrite empty variables with the prices if "used_assets" is greater or equal to the asset number if barstate.isconfirmed // use barstate.isconfirmed to avoid "na prices" and calculation errors that result in empty cells in the table price_a1 := f_get_asset_price(1, asset1), price_a2 := f_get_asset_price(2, asset2), price_a3 := f_get_asset_price(3, asset3), price_a4 := f_get_asset_price(4, asset4) price_a5 := f_get_asset_price(5, asset5), price_a6 := f_get_asset_price(6, asset6), price_a7 := f_get_asset_price(7, asset7), price_a8 := f_get_asset_price(8, asset8) price_a9 := f_get_asset_price(9, asset9), price_a10 := f_get_asset_price(10, asset10), price_a11 := f_get_asset_price(11, asset11), price_a12 := f_get_asset_price(12, asset12) price_a13 := f_get_asset_price(13, asset13), price_a14 := f_get_asset_price(14, asset14), price_a15 := f_get_asset_price(15, asset15), price_a16 := f_get_asset_price(16, asset16) price_a17 := f_get_asset_price(17, asset17), price_a18 := f_get_asset_price(18, asset18), price_a19 := f_get_asset_price(19, asset19), price_a20 := f_get_asset_price(20, asset20) price_a21 := f_get_asset_price(21, asset21), price_a22 := f_get_asset_price(22, asset22), price_a23 := f_get_asset_price(23, asset23), price_a24 := f_get_asset_price(24, asset24) price_a25 := f_get_asset_price(25, asset25), price_a26 := f_get_asset_price(26, asset26), price_a27 := f_get_asset_price(27, asset27), price_a28 := f_get_asset_price(28, asset28) price_a29 := f_get_asset_price(29, asset29), price_a30 := f_get_asset_price(30, asset30), price_a31 := f_get_asset_price(31, asset31), price_a32 := f_get_asset_price(32, asset32) price_a33 := f_get_asset_price(33, asset33), price_a34 := f_get_asset_price(34, asset34), price_a35 := f_get_asset_price(35, asset35), price_a36 := f_get_asset_price(36, asset36) price_a37 := f_get_asset_price(37, asset37), price_a38 := f_get_asset_price(38, asset38), price_a39 := f_get_asset_price(39, asset39), price_a40 := f_get_asset_price(40, asset40) Universal Indicator Calculation (f_calc_score): This function allows switching between different trend indicators (RSI, CCI, Fisher) for flexibility. It uses a switch-case structure to calculate the indicator score, where a positive trend is denoted by 1 and a negative trend by 0. Each indicator has its own logic to determine whether the asset is trending up or down. // use switch to allow "universality" in indicator selection f_calc_score(source, trend_indicator, int_1, int_2) => int score = na if (not f_constant_src(source)) and source > 0.0 // Skip if you are using the same assets for ratio (for example BTC/BTC) x = switch trend_indicator "RSI (Raw)" => RSI_raw(source, int_1) "RSI (SMA)" => RSI_sma(source, int_1, int_2) "RSI (EMA)" => RSI_ema(source, int_1, int_2) "CCI" => CCI(source, int_1) "Fisher" => Fisher(source, int_1) y = switch trend_indicator "RSI (Raw)" => x > 50 ? 1 : 0 "RSI (SMA)" => x > 50 ? 1 : 0 "RSI (EMA)" => x > 50 ? 1 : 0 "CCI" => x > 0 ? 1 : 0 "Fisher" => x > x ? 1 : 0 score := y else score := 0 score Array Setting Function (f_array_set): This function populates an array with scores calculated for each asset based on a base price (p_base) divided by the prices of the individual assets. It processes multiple assets (up to 40), calling the f_calc_score function for each. // function to set values into the arrays f_array_set(a_array, p_base) => array.set(a_array, 0, f_calc_score(p_base / price_a1, trend_indicator, int_1, int_2)) array.set(a_array, 1, f_calc_score(p_base / price_a2, trend_indicator, int_1, int_2)) array.set(a_array, 2, f_calc_score(p_base / price_a3, trend_indicator, int_1, int_2)) array.set(a_array, 3, f_calc_score(p_base / price_a4, trend_indicator, int_1, int_2)) array.set(a_array, 4, f_calc_score(p_base / price_a5, trend_indicator, int_1, int_2)) array.set(a_array, 5, f_calc_score(p_base / price_a6, trend_indicator, int_1, int_2)) array.set(a_array, 6, f_calc_score(p_base / price_a7, trend_indicator, int_1, int_2)) array.set(a_array, 7, f_calc_score(p_base / price_a8, trend_indicator, int_1, int_2)) array.set(a_array, 8, f_calc_score(p_base / price_a9, trend_indicator, int_1, int_2)) array.set(a_array, 9, f_calc_score(p_base / price_a10, trend_indicator, int_1, int_2)) array.set(a_array, 10, f_calc_score(p_base / price_a11, trend_indicator, int_1, int_2)) array.set(a_array, 11, f_calc_score(p_base / price_a12, trend_indicator, int_1, int_2)) array.set(a_array, 12, f_calc_score(p_base / price_a13, trend_indicator, int_1, int_2)) array.set(a_array, 13, f_calc_score(p_base / price_a14, trend_indicator, int_1, int_2)) array.set(a_array, 14, f_calc_score(p_base / price_a15, trend_indicator, int_1, int_2)) array.set(a_array, 15, f_calc_score(p_base / price_a16, trend_indicator, int_1, int_2)) array.set(a_array, 16, f_calc_score(p_base / price_a17, trend_indicator, int_1, int_2)) array.set(a_array, 17, f_calc_score(p_base / price_a18, trend_indicator, int_1, int_2)) array.set(a_array, 18, f_calc_score(p_base / price_a19, trend_indicator, int_1, int_2)) array.set(a_array, 19, f_calc_score(p_base / price_a20, trend_indicator, int_1, int_2)) array.set(a_array, 20, f_calc_score(p_base / price_a21, trend_indicator, int_1, int_2)) array.set(a_array, 21, f_calc_score(p_base / price_a22, trend_indicator, int_1, int_2)) array.set(a_array, 22, f_calc_score(p_base / price_a23, trend_indicator, int_1, int_2)) array.set(a_array, 23, f_calc_score(p_base / price_a24, trend_indicator, int_1, int_2)) array.set(a_array, 24, f_calc_score(p_base / price_a25, trend_indicator, int_1, int_2)) array.set(a_array, 25, f_calc_score(p_base / price_a26, trend_indicator, int_1, int_2)) array.set(a_array, 26, f_calc_score(p_base / price_a27, trend_indicator, int_1, int_2)) array.set(a_array, 27, f_calc_score(p_base / price_a28, trend_indicator, int_1, int_2)) array.set(a_array, 28, f_calc_score(p_base / price_a29, trend_indicator, int_1, int_2)) array.set(a_array, 29, f_calc_score(p_base / price_a30, trend_indicator, int_1, int_2)) array.set(a_array, 30, f_calc_score(p_base / price_a31, trend_indicator, int_1, int_2)) array.set(a_array, 31, f_calc_score(p_base / price_a32, trend_indicator, int_1, int_2)) array.set(a_array, 32, f_calc_score(p_base / price_a33, trend_indicator, int_1, int_2)) array.set(a_array, 33, f_calc_score(p_base / price_a34, trend_indicator, int_1, int_2)) array.set(a_array, 34, f_calc_score(p_base / price_a35, trend_indicator, int_1, int_2)) array.set(a_array, 35, f_calc_score(p_base / price_a36, trend_indicator, int_1, int_2)) array.set(a_array, 36, f_calc_score(p_base / price_a37, trend_indicator, int_1, int_2)) array.set(a_array, 37, f_calc_score(p_base / price_a38, trend_indicator, int_1, int_2)) array.set(a_array, 38, f_calc_score(p_base / price_a39, trend_indicator, int_1, int_2)) array.set(a_array, 39, f_calc_score(p_base / price_a40, trend_indicator, int_1, int_2)) a_array Conditional Array Setting (f_arrayset): This function checks if the number of used assets is greater than or equal to a specified number before populating the arrays. // only set values into arrays for USED assets f_arrayset(asset_number, a_array, p_base) => if (used_assets >= asset_number) f_array_set(a_array, p_base) else na Main Logic The main logic initializes arrays to store scores for each asset. Each array corresponds to one asset's performance score. Setting Trend Values: The code calls f_arrayset for each asset, populating the respective arrays with calculated scores based on the asset prices. Combining Arrays: A combined_array is created to hold all the scores from individual asset arrays. This array facilitates further analysis, allowing for an overview of the performance scores of all assets at once. // create a combined array (work-around since pinescript doesn't support having array of arrays) var combined_array = array.new_int(40 * 40, 0) if barstate.islast for i = 0 to 39 array.set(combined_array, i, array.get(a1_array, i)) array.set(combined_array, i + (40 * 1), array.get(a2_array, i)) array.set(combined_array, i + (40 * 2), array.get(a3_array, i)) array.set(combined_array, i + (40 * 3), array.get(a4_array, i)) array.set(combined_array, i + (40 * 4), array.get(a5_array, i)) array.set(combined_array, i + (40 * 5), array.get(a6_array, i)) array.set(combined_array, i + (40 * 6), array.get(a7_array, i)) array.set(combined_array, i + (40 * 7), array.get(a8_array, i)) array.set(combined_array, i + (40 * 8), array.get(a9_array, i)) array.set(combined_array, i + (40 * 9), array.get(a10_array, i)) array.set(combined_array, i + (40 * 10), array.get(a11_array, i)) array.set(combined_array, i + (40 * 11), array.get(a12_array, i)) array.set(combined_array, i + (40 * 12), array.get(a13_array, i)) array.set(combined_array, i + (40 * 13), array.get(a14_array, i)) array.set(combined_array, i + (40 * 14), array.get(a15_array, i)) array.set(combined_array, i + (40 * 15), array.get(a16_array, i)) array.set(combined_array, i + (40 * 16), array.get(a17_array, i)) array.set(combined_array, i + (40 * 17), array.get(a18_array, i)) array.set(combined_array, i + (40 * 18), array.get(a19_array, i)) array.set(combined_array, i + (40 * 19), array.get(a20_array, i)) array.set(combined_array, i + (40 * 20), array.get(a21_array, i)) array.set(combined_array, i + (40 * 21), array.get(a22_array, i)) array.set(combined_array, i + (40 * 22), array.get(a23_array, i)) array.set(combined_array, i + (40 * 23), array.get(a24_array, i)) array.set(combined_array, i + (40 * 24), array.get(a25_array, i)) array.set(combined_array, i + (40 * 25), array.get(a26_array, i)) array.set(combined_array, i + (40 * 26), array.get(a27_array, i)) array.set(combined_array, i + (40 * 27), array.get(a28_array, i)) array.set(combined_array, i + (40 * 28), array.get(a29_array, i)) array.set(combined_array, i + (40 * 29), array.get(a30_array, i)) array.set(combined_array, i + (40 * 30), array.get(a31_array, i)) array.set(combined_array, i + (40 * 31), array.get(a32_array, i)) array.set(combined_array, i + (40 * 32), array.get(a33_array, i)) array.set(combined_array, i + (40 * 33), array.get(a34_array, i)) array.set(combined_array, i + (40 * 34), array.get(a35_array, i)) array.set(combined_array, i + (40 * 35), array.get(a36_array, i)) array.set(combined_array, i + (40 * 36), array.get(a37_array, i)) array.set(combined_array, i + (40 * 37), array.get(a38_array, i)) array.set(combined_array, i + (40 * 38), array.get(a39_array, i)) array.set(combined_array, i + (40 * 39), array.get(a40_array, i)) Calculating Sums: A separate array_sums is created to store the total score for each asset by summing the values of their respective score arrays. This allows for easy comparison of overall performance. Ranking Assets: The final part of the code ranks the assets based on their total scores stored in array_sums. It assigns a rank to each asset, where the asset with the highest score receives the highest rank. // create array for asset RANK based on array.sum var ranks = array.new_int(used_assets, 0) // for loop that calculates the rank of each asset if barstate.islast for i = 0 to (used_assets - 1) int rank = 1 for x = 0 to (used_assets - 1) if i != x if array.get(array_sums, i) < array.get(array_sums, x) rank := rank + 1 array.set(ranks, i, rank) Dynamic Table Creation Initialization: The table is initialized with a base structure that includes headers for asset names, scores, and ranks. The headers are set to remain constant, ensuring clarity for users as they interpret the displayed data. Data Population: As scores are calculated for each asset, the corresponding values are dynamically inserted into the table. This is achieved through a loop that iterates over the scores and ranks stored in the combined_array and array_sums, respectively. Automatic Extending Mechanism Variable Asset Count: The code checks the number of assets defined by the user. Instead of hardcoding the number of rows in the table, it uses a variable to determine the extent of the data that needs to be displayed. This allows the table to expand or contract based on the number of assets being analyzed. Dynamic Row Generation: Within the loop that populates the table, the code appends new rows for each asset based on the current asset count. The structure of each row includes the asset name, its score, and its rank, ensuring that the table remains consistent regardless of how many assets are involved. // Automatically extending table based on the number of used assets var table table = table.new(position.bottom_center, 50, 50, color.new(color.black, 100), color.white, 3, color.white, 1) if barstate.islast if not hide_head table.cell(table, 0, 0, "Universal Ratio Trend Matrix", text_color = color.white, bgcolor = #010c3b, text_size = fontSize) table.merge_cells(table, 0, 0, used_assets + 3, 0) if not hide_inps table.cell(table, 0, 1, text = "Inputs: You are using " + str.tostring(trend_indicator) + ", which takes: " + str.tostring(f_get_input(trend_indicator)), text_color = color.white, text_size = fontSize), table.merge_cells(table, 0, 1, used_assets + 3, 1) table.cell(table, 0, 2, "Assets", text_color = color.white, text_size = fontSize, bgcolor = #010c3b) for x = 0 to (used_assets - 1) table.cell(table, x + 1, 2, text = str.tostring(array.get(assets, x)), text_color = color.white, bgcolor = #010c3b, text_size = fontSize) table.cell(table, 0, x + 3, text = str.tostring(array.get(assets, x)), text_color = color.white, bgcolor = f_asset_col(array.get(ranks, x)), text_size = fontSize) for r = 0 to (used_assets - 1) for c = 0 to (used_assets - 1) table.cell(table, c + 1, r + 3, text = str.tostring(array.get(combined_array, c + (r * 40))), text_color = hl_type == "Text" ? f_get_col(array.get(combined_array, c + (r * 40))) : color.white, text_size = fontSize, bgcolor = hl_type == "Background" ? f_get_col(array.get(combined_array, c + (r * 40))) : na) for x = 0 to (used_assets - 1) table.cell(table, x + 1, x + 3, "", bgcolor = #010c3b) table.cell(table, used_assets + 1, 2, "", bgcolor = #010c3b) for x = 0 to (used_assets - 1) table.cell(table, used_assets + 1, x + 3, "==>", text_color = color.white) table.cell(table, used_assets + 2, 2, "SUM", text_color = color.white, text_size = fontSize, bgcolor = #010c3b) table.cell(table, used_assets + 3, 2, "RANK", text_color = color.white, text_size = fontSize, bgcolor = #010c3b) for x = 0 to (used_assets - 1) table.cell(table, used_assets + 2, x + 3, text = str.tostring(array.get(array_sums, x)), text_color = color.white, text_size = fontSize, bgcolor = f_highlight_sum(array.get(array_sums, x), array.get(ranks, x))) table.cell(table, used_assets + 3, x + 3, text = str.tostring(array.get(ranks, x)), text_color = color.white, text_size = fontSize, bgcolor = f_highlight_rank(array.get(ranks, x)))
Indicatore Pine Script®
di InvestorUnknown
8
Markov Chain [3D] | FractalystWhat exactly is a Markov Chain? This indicator uses a Markov Chain model to analyze, quantify, and visualize the transitions between market regimes (Bull, Bear, Neutral) on your chart. It dynamically detects these regimes in real-time, calculates transition probabilities, and displays them as animated 3D spheres and arrows, giving traders intuitive insight into current and future market conditions. How does a Markov Chain work, and how should I read this spheres-and-arrows diagram? Think of three weather modes: Sunny, Rainy, Cloudy. Each sphere is one mode. The loop on a sphere means “stay the same next step” (e.g., Sunny again tomorrow). The arrows leaving a sphere show where things usually go next if they change (e.g., Sunny moving to Cloudy). Some paths matter more than others. A more prominent loop means the current mode tends to persist. A more prominent outgoing arrow means a change to that destination is the usual next step. Direction isn’t symmetric: moving Sunny→Cloudy can behave differently than Cloudy→Sunny. Now relabel the spheres to markets: Bull, Bear, Neutral. Spheres: market regimes (uptrend, downtrend, range). Self‑loop: tendency for the current regime to continue on the next bar. Arrows: the most common next regime if a switch happens. How to read: Start at the sphere that matches current bar state. If the loop stands out, expect continuation. If one outgoing path stands out, that switch is the typical next step. Opposite directions can differ (Bear→Neutral doesn’t have to match Neutral→Bear). What states and transitions are shown? The three market states visualized are: Bullish (Bull): Upward or strong-market regime. Bearish (Bear): Downward or weak-market regime. Neutral: Sideways or range-bound regime. Bidirectional animated arrows and probability labels show how likely the market is to move from one regime to another (e.g., Bull → Bear or Neutral → Bull). How does the regime detection system work? You can use either built-in price returns (based on adaptive Z-score normalization) or supply three custom indicators (such as volume, oscillators, etc.). Values are statistically normalized (Z-scored) over a configurable lookback period. The normalized outputs are classified into Bull, Bear, or Neutral zones. If using three indicators, their regime signals are averaged and smoothed for robustness. How are transition probabilities calculated? On every confirmed bar, the algorithm tracks the sequence of detected market states, then builds a rolling window of transitions. The code maintains a transition count matrix for all regime pairs (e.g., Bull → Bear). Transition probabilities are extracted for each possible state change using Laplace smoothing for numerical stability, and frequently updated in real-time. What is unique about the visualization? 3D animated spheres represent each regime and change visually when active. Animated, bidirectional arrows reveal transition probabilities and allow you to see both dominant and less likely regime flows. Particles (moving dots) animate along the arrows, enhancing the perception of regime flow direction and speed. All elements dynamically update with each new price bar, providing a live market map in an intuitive, engaging format. Can I use custom indicators for regime classification? Yes! Enable the "Custom Indicators" switch and select any three chart series as inputs. These will be normalized and combined (each with equal weight), broadening the regime classification beyond just price-based movement. What does the “Lookback Period” control? Lookback Period (default: 100) sets how much historical data builds the probability matrix. Shorter periods adapt faster to regime changes but may be noisier. Longer periods are more stable but slower to adapt. How is this different from a Hidden Markov Model (HMM)? It sets the window for both regime detection and probability calculations. Lower values make the system more reactive, but potentially noisier. Higher values smooth estimates and make the system more robust. How is this Markov Chain different from a Hidden Markov Model (HMM)? Markov Chain (as here): All market regimes (Bull, Bear, Neutral) are directly observable on the chart. The transition matrix is built from actual detected regimes, keeping the model simple and interpretable. Hidden Markov Model: The actual regimes are unobservable ("hidden") and must be inferred from market output or indicator "emissions" using statistical learning algorithms. HMMs are more complex, can capture more subtle structure, but are harder to visualize and require additional machine learning steps for training. A standard Markov Chain models transitions between observable states using a simple transition matrix, while a Hidden Markov Model assumes the true states are hidden (latent) and must be inferred from observable “emissions” like price or volume data. In practical terms, a Markov Chain is transparent and easier to implement and interpret; an HMM is more expressive but requires statistical inference to estimate hidden states from data. Markov Chain: states are observable; you directly count or estimate transition probabilities between visible states. This makes it simpler, faster, and easier to validate and tune. HMM: states are hidden; you only observe emissions generated by those latent states. Learning involves machine learning/statistical algorithms (commonly Baum–Welch/EM for training and Viterbi for decoding) to infer both the transition dynamics and the most likely hidden state sequence from data. How does the indicator avoid “repainting” or look-ahead bias? All regime changes and matrix updates happen only on confirmed (closed) bars, so no future data is leaked, ensuring reliable real-time operation. Are there practical tuning tips? Tune the Lookback Period for your asset/timeframe: shorter for fast markets, longer for stability. Use custom indicators if your asset has unique regime drivers. Watch for rapid changes in transition probabilities as early warning of a possible regime shift. Who is this indicator for? Quants and quantitative researchers exploring probabilistic market modeling, especially those interested in regime-switching dynamics and Markov models. Programmers and system developers who need a probabilistic regime filter for systematic and algorithmic backtesting: The Markov Chain indicator is ideally suited for programmatic integration via its bias output (1 = Bull, 0 = Neutral, -1 = Bear). Although the visualization is engaging, the core output is designed for automated, rules-based workflows—not for discretionary/manual trading decisions. Developers can connect the indicator’s output directly to their Pine Script logic (using input.source()), allowing rapid and robust backtesting of regime-based strategies. It acts as a plug-and-play regime filter: simply plug the bias output into your entry/exit logic, and you have a scientifically robust, probabilistically-derived signal for filtering, timing, position sizing, or risk regimes. The MC's output is intentionally "trinary" (1/0/-1), focusing on clear regime states for unambiguous decision-making in code. If you require nuanced, multi-probability or soft-label state vectors, consider expanding the indicator or stacking it with a probability-weighted logic layer in your scripting. Because it avoids subjectivity, this approach is optimal for systematic quants, algo developers building backtested, repeatable strategies based on probabilistic regime analysis. What's the mathematical foundation behind this? The mathematical foundation behind this Markov Chain indicator—and probabilistic regime detection in finance—draws from two principal models: the (standard) Markov Chain and the Hidden Markov Model (HMM). How to use this indicator programmatically? The Markov Chain indicator automatically exports a bias value (+1 for Bullish, -1 for Bearish, 0 for Neutral) as a plot visible in the Data Window. This allows you to integrate its regime signal into your own scripts and strategies for backtesting, automation, or live trading. Step-by-Step Integration with Pine Script (input.source) Add the Markov Chain indicator to your chart. This must be done first, since your custom script will "pull" the bias signal from the indicator's plot. In your strategy, create an input using input.source() Example: //@version=5 strategy("MC Bias Strategy Example") mcBias = input.source(close, "MC Bias Source") After saving, go to your script’s settings. For the “MC Bias Source” input, select the plot/output of the Markov Chain indicator (typically its bias plot). Use the bias in your trading logic Example (long only on Bull, flat otherwise): if mcBias == 1 strategy.entry("Long", strategy.long) else strategy.close("Long") For more advanced workflows, combine mcBias with additional filters or trailing stops. How does this work behind-the-scenes? TradingView’s input.source() lets you use any plot from another indicator as a real-time, “live” data feed in your own script (source). The selected bias signal is available to your Pine code as a variable, enabling logical decisions based on regime (trend-following, mean-reversion, etc.). This enables powerful strategy modularity : decouple regime detection from entry/exit logic, allowing fast experimentation without rewriting core signal code. Integrating 45+ Indicators with Your Markov Chain — How & Why The Enhanced Custom Indicators Export script exports a massive suite of over 45 technical indicators—ranging from classic momentum (RSI, MACD, Stochastic, etc.) to trend, volume, volatility, and oscillator tools—all pre-calculated, centered/scaled, and available as plots. // Enhanced Custom Indicators Export - 45 Technical Indicators // Comprehensive technical analysis suite for advanced market regime detection //@version=6 indicator('Enhanced Custom Indicators Export | Fractalyst', shorttitle='Enhanced CI Export', overlay=false, scale=scale.right, max_labels_count=500, max_lines_count=500) // |----- Input Parameters -----| // momentum_group = "Momentum Indicators" trend_group = "Trend Indicators" volume_group = "Volume Indicators" volatility_group = "Volatility Indicators" oscillator_group = "Oscillator Indicators" display_group = "Display Settings" // Common lengths length_14 = input.int(14, "Standard Length (14)", minval=1, maxval=100, group=momentum_group) length_20 = input.int(20, "Medium Length (20)", minval=1, maxval=200, group=trend_group) length_50 = input.int(50, "Long Length (50)", minval=1, maxval=200, group=trend_group) // Display options show_table = input.bool(true, "Show Values Table", group=display_group) table_size = input.string("Small", "Table Size", options= , group=display_group) // |----- MOMENTUM INDICATORS (15 indicators) -----| // // 1. RSI (Relative Strength Index) rsi_14 = ta.rsi(close, length_14) rsi_centered = rsi_14 - 50 // 2. Stochastic Oscillator stoch_k = ta.stoch(close, high, low, length_14) stoch_d = ta.sma(stoch_k, 3) stoch_centered = stoch_k - 50 // 3. Williams %R williams_r = ta.stoch(close, high, low, length_14) - 100 // 4. MACD (Moving Average Convergence Divergence) = ta.macd(close, 12, 26, 9) // 5. Momentum (Rate of Change) momentum = ta.mom(close, length_14) momentum_pct = (momentum / close ) * 100 // 6. Rate of Change (ROC) roc = ta.roc(close, length_14) // 7. Commodity Channel Index (CCI) cci = ta.cci(close, length_20) // 8. Money Flow Index (MFI) mfi = ta.mfi(close, length_14) mfi_centered = mfi - 50 // 9. Awesome Oscillator (AO) ao = ta.sma(hl2, 5) - ta.sma(hl2, 34) // 10. Accelerator Oscillator (AC) ac = ao - ta.sma(ao, 5) // 11. Chande Momentum Oscillator (CMO) cmo = ta.cmo(close, length_14) // 12. Detrended Price Oscillator (DPO) dpo = close - ta.sma(close, length_20) // 13. Price Oscillator (PPO) ppo = ta.sma(close, 12) - ta.sma(close, 26) ppo_pct = (ppo / ta.sma(close, 26)) * 100 // 14. TRIX trix_ema1 = ta.ema(close, length_14) trix_ema2 = ta.ema(trix_ema1, length_14) trix_ema3 = ta.ema(trix_ema2, length_14) trix = ta.roc(trix_ema3, 1) * 10000 // 15. Klinger Oscillator klinger = ta.ema(volume * (high + low + close) / 3, 34) - ta.ema(volume * (high + low + close) / 3, 55) // 16. Fisher Transform fisher_hl2 = 0.5 * (hl2 - ta.lowest(hl2, 10)) / (ta.highest(hl2, 10) - ta.lowest(hl2, 10)) - 0.25 fisher = 0.5 * math.log((1 + fisher_hl2) / (1 - fisher_hl2)) // 17. Stochastic RSI stoch_rsi = ta.stoch(rsi_14, rsi_14, rsi_14, length_14) stoch_rsi_centered = stoch_rsi - 50 // 18. Relative Vigor Index (RVI) rvi_num = ta.swma(close - open) rvi_den = ta.swma(high - low) rvi = rvi_den != 0 ? rvi_num / rvi_den : 0 // 19. Balance of Power (BOP) bop = (close - open) / (high - low) // |----- TREND INDICATORS (10 indicators) -----| // // 20. Simple Moving Average Momentum sma_20 = ta.sma(close, length_20) sma_momentum = ((close - sma_20) / sma_20) * 100 // 21. Exponential Moving Average Momentum ema_20 = ta.ema(close, length_20) ema_momentum = ((close - ema_20) / ema_20) * 100 // 22. Parabolic SAR sar = ta.sar(0.02, 0.02, 0.2) sar_trend = close > sar ? 1 : -1 // 23. Linear Regression Slope lr_slope = ta.linreg(close, length_20, 0) - ta.linreg(close, length_20, 1) // 24. Moving Average Convergence (MAC) mac = ta.sma(close, 10) - ta.sma(close, 30) // 25. Trend Intensity Index (TII) tii_sum = 0.0 for i = 1 to length_20 tii_sum += close > close ? 1 : 0 tii = (tii_sum / length_20) * 100 // 26. Ichimoku Cloud Components ichimoku_tenkan = (ta.highest(high, 9) + ta.lowest(low, 9)) / 2 ichimoku_kijun = (ta.highest(high, 26) + ta.lowest(low, 26)) / 2 ichimoku_signal = ichimoku_tenkan > ichimoku_kijun ? 1 : -1 // 27. MESA Adaptive Moving Average (MAMA) mama_alpha = 2.0 / (length_20 + 1) mama = ta.ema(close, length_20) mama_momentum = ((close - mama) / mama) * 100 // 28. Zero Lag Exponential Moving Average (ZLEMA) zlema_lag = math.round((length_20 - 1) / 2) zlema_data = close + (close - close ) zlema = ta.ema(zlema_data, length_20) zlema_momentum = ((close - zlema) / zlema) * 100 // |----- VOLUME INDICATORS (6 indicators) -----| // // 29. On-Balance Volume (OBV) obv = ta.obv // 30. Volume Rate of Change (VROC) vroc = ta.roc(volume, length_14) // 31. Price Volume Trend (PVT) pvt = ta.pvt // 32. Negative Volume Index (NVI) nvi = 0.0 nvi := volume < volume ? nvi + ((close - close ) / close ) * nvi : nvi // 33. Positive Volume Index (PVI) pvi = 0.0 pvi := volume > volume ? pvi + ((close - close ) / close ) * pvi : pvi // 34. Volume Oscillator vol_osc = ta.sma(volume, 5) - ta.sma(volume, 10) // 35. Ease of Movement (EOM) eom_distance = high - low eom_box_height = volume / 1000000 eom = eom_box_height != 0 ? eom_distance / eom_box_height : 0 eom_sma = ta.sma(eom, length_14) // 36. Force Index force_index = volume * (close - close ) force_index_sma = ta.sma(force_index, length_14) // |----- VOLATILITY INDICATORS (10 indicators) -----| // // 37. Average True Range (ATR) atr = ta.atr(length_14) atr_pct = (atr / close) * 100 // 38. Bollinger Bands Position bb_basis = ta.sma(close, length_20) bb_dev = 2.0 * ta.stdev(close, length_20) bb_upper = bb_basis + bb_dev bb_lower = bb_basis - bb_dev bb_position = bb_dev != 0 ? (close - bb_basis) / bb_dev : 0 bb_width = bb_dev != 0 ? (bb_upper - bb_lower) / bb_basis * 100 : 0 // 39. Keltner Channels Position kc_basis = ta.ema(close, length_20) kc_range = ta.ema(ta.tr, length_20) kc_upper = kc_basis + (2.0 * kc_range) kc_lower = kc_basis - (2.0 * kc_range) kc_position = kc_range != 0 ? (close - kc_basis) / kc_range : 0 // 40. Donchian Channels Position dc_upper = ta.highest(high, length_20) dc_lower = ta.lowest(low, length_20) dc_basis = (dc_upper + dc_lower) / 2 dc_position = (dc_upper - dc_lower) != 0 ? (close - dc_basis) / (dc_upper - dc_lower) : 0 // 41. Standard Deviation std_dev = ta.stdev(close, length_20) std_dev_pct = (std_dev / close) * 100 // 42. Relative Volatility Index (RVI) rvi_up = ta.stdev(close > close ? close : 0, length_14) rvi_down = ta.stdev(close < close ? close : 0, length_14) rvi_total = rvi_up + rvi_down rvi_volatility = rvi_total != 0 ? (rvi_up / rvi_total) * 100 : 50 // 43. Historical Volatility hv_returns = math.log(close / close ) hv = ta.stdev(hv_returns, length_20) * math.sqrt(252) * 100 // 44. Garman-Klass Volatility gk_vol = math.log(high/low) * math.log(high/low) - (2*math.log(2)-1) * math.log(close/open) * math.log(close/open) gk_volatility = math.sqrt(ta.sma(gk_vol, length_20)) * 100 // 45. Parkinson Volatility park_vol = math.log(high/low) * math.log(high/low) parkinson = math.sqrt(ta.sma(park_vol, length_20) / (4 * math.log(2))) * 100 // 46. Rogers-Satchell Volatility rs_vol = math.log(high/close) * math.log(high/open) + math.log(low/close) * math.log(low/open) rogers_satchell = math.sqrt(ta.sma(rs_vol, length_20)) * 100 // |----- OSCILLATOR INDICATORS (5 indicators) -----| // // 47. Elder Ray Index elder_bull = high - ta.ema(close, 13) elder_bear = low - ta.ema(close, 13) elder_power = elder_bull + elder_bear // 48. Schaff Trend Cycle (STC) stc_macd = ta.ema(close, 23) - ta.ema(close, 50) stc_k = ta.stoch(stc_macd, stc_macd, stc_macd, 10) stc_d = ta.ema(stc_k, 3) stc = ta.stoch(stc_d, stc_d, stc_d, 10) // 49. Coppock Curve coppock_roc1 = ta.roc(close, 14) coppock_roc2 = ta.roc(close, 11) coppock = ta.wma(coppock_roc1 + coppock_roc2, 10) // 50. Know Sure Thing (KST) kst_roc1 = ta.roc(close, 10) kst_roc2 = ta.roc(close, 15) kst_roc3 = ta.roc(close, 20) kst_roc4 = ta.roc(close, 30) kst = ta.sma(kst_roc1, 10) + 2*ta.sma(kst_roc2, 10) + 3*ta.sma(kst_roc3, 10) + 4*ta.sma(kst_roc4, 15) // 51. Percentage Price Oscillator (PPO) ppo_line = ((ta.ema(close, 12) - ta.ema(close, 26)) / ta.ema(close, 26)) * 100 ppo_signal = ta.ema(ppo_line, 9) ppo_histogram = ppo_line - ppo_signal // |----- PLOT MAIN INDICATORS -----| // // Plot key momentum indicators plot(rsi_centered, title="01_RSI_Centered", color=color.purple, linewidth=1) plot(stoch_centered, title="02_Stoch_Centered", color=color.blue, linewidth=1) plot(williams_r, title="03_Williams_R", color=color.red, linewidth=1) plot(macd_histogram, title="04_MACD_Histogram", color=color.orange, linewidth=1) plot(cci, title="05_CCI", color=color.green, linewidth=1) // Plot trend indicators plot(sma_momentum, title="06_SMA_Momentum", color=color.navy, linewidth=1) plot(ema_momentum, title="07_EMA_Momentum", color=color.maroon, linewidth=1) plot(sar_trend, title="08_SAR_Trend", color=color.teal, linewidth=1) plot(lr_slope, title="09_LR_Slope", color=color.lime, linewidth=1) plot(mac, title="10_MAC", color=color.fuchsia, linewidth=1) // Plot volatility indicators plot(atr_pct, title="11_ATR_Pct", color=color.yellow, linewidth=1) plot(bb_position, title="12_BB_Position", color=color.aqua, linewidth=1) plot(kc_position, title="13_KC_Position", color=color.olive, linewidth=1) plot(std_dev_pct, title="14_StdDev_Pct", color=color.silver, linewidth=1) plot(bb_width, title="15_BB_Width", color=color.gray, linewidth=1) // Plot volume indicators plot(vroc, title="16_VROC", color=color.blue, linewidth=1) plot(eom_sma, title="17_EOM", color=color.red, linewidth=1) plot(vol_osc, title="18_Vol_Osc", color=color.green, linewidth=1) plot(force_index_sma, title="19_Force_Index", color=color.orange, linewidth=1) plot(obv, title="20_OBV", color=color.purple, linewidth=1) // Plot additional oscillators plot(ao, title="21_Awesome_Osc", color=color.navy, linewidth=1) plot(cmo, title="22_CMO", color=color.maroon, linewidth=1) plot(dpo, title="23_DPO", color=color.teal, linewidth=1) plot(trix, title="24_TRIX", color=color.lime, linewidth=1) plot(fisher, title="25_Fisher", color=color.fuchsia, linewidth=1) // Plot more momentum indicators plot(mfi_centered, title="26_MFI_Centered", color=color.yellow, linewidth=1) plot(ac, title="27_AC", color=color.aqua, linewidth=1) plot(ppo_pct, title="28_PPO_Pct", color=color.olive, linewidth=1) plot(stoch_rsi_centered, title="29_StochRSI_Centered", color=color.silver, linewidth=1) plot(klinger, title="30_Klinger", color=color.gray, linewidth=1) // Plot trend continuation plot(tii, title="31_TII", color=color.blue, linewidth=1) plot(ichimoku_signal, title="32_Ichimoku_Signal", color=color.red, linewidth=1) plot(mama_momentum, title="33_MAMA_Momentum", color=color.green, linewidth=1) plot(zlema_momentum, title="34_ZLEMA_Momentum", color=color.orange, linewidth=1) plot(bop, title="35_BOP", color=color.purple, linewidth=1) // Plot volume continuation plot(nvi, title="36_NVI", color=color.navy, linewidth=1) plot(pvi, title="37_PVI", color=color.maroon, linewidth=1) plot(momentum_pct, title="38_Momentum_Pct", color=color.teal, linewidth=1) plot(roc, title="39_ROC", color=color.lime, linewidth=1) plot(rvi, title="40_RVI", color=color.fuchsia, linewidth=1) // Plot volatility continuation plot(dc_position, title="41_DC_Position", color=color.yellow, linewidth=1) plot(rvi_volatility, title="42_RVI_Volatility", color=color.aqua, linewidth=1) plot(hv, title="43_Historical_Vol", color=color.olive, linewidth=1) plot(gk_volatility, title="44_GK_Volatility", color=color.silver, linewidth=1) plot(parkinson, title="45_Parkinson_Vol", color=color.gray, linewidth=1) // Plot final oscillators plot(rogers_satchell, title="46_RS_Volatility", color=color.blue, linewidth=1) plot(elder_power, title="47_Elder_Power", color=color.red, linewidth=1) plot(stc, title="48_STC", color=color.green, linewidth=1) plot(coppock, title="49_Coppock", color=color.orange, linewidth=1) plot(kst, title="50_KST", color=color.purple, linewidth=1) // Plot final indicators plot(ppo_histogram, title="51_PPO_Histogram", color=color.navy, linewidth=1) plot(pvt, title="52_PVT", color=color.maroon, linewidth=1) // |----- Reference Lines -----| // hline(0, "Zero Line", color=color.gray, linestyle=hline.style_dashed, linewidth=1) hline(50, "Midline", color=color.gray, linestyle=hline.style_dotted, linewidth=1) hline(-50, "Lower Midline", color=color.gray, linestyle=hline.style_dotted, linewidth=1) hline(25, "Upper Threshold", color=color.gray, linestyle=hline.style_dotted, linewidth=1) hline(-25, "Lower Threshold", color=color.gray, linestyle=hline.style_dotted, linewidth=1) // |----- Enhanced Information Table -----| // if show_table and barstate.islast table_position = position.top_right table_text_size = table_size == "Tiny" ? size.tiny : table_size == "Small" ? size.small : size.normal var table info_table = table.new(table_position, 3, 18, bgcolor=color.new(color.white, 85), border_width=1, border_color=color.gray) // Headers table.cell(info_table, 0, 0, 'Category', text_color=color.black, text_size=table_text_size, bgcolor=color.new(color.blue, 70)) table.cell(info_table, 1, 0, 'Indicator', text_color=color.black, text_size=table_text_size, bgcolor=color.new(color.blue, 70)) table.cell(info_table, 2, 0, 'Value', text_color=color.black, text_size=table_text_size, bgcolor=color.new(color.blue, 70)) // Key Momentum Indicators table.cell(info_table, 0, 1, 'MOMENTUM', text_color=color.purple, text_size=table_text_size, bgcolor=color.new(color.purple, 90)) table.cell(info_table, 1, 1, 'RSI Centered', text_color=color.purple, text_size=table_text_size) table.cell(info_table, 2, 1, str.tostring(rsi_centered, '0.00'), text_color=color.purple, text_size=table_text_size) table.cell(info_table, 0, 2, '', text_color=color.blue, text_size=table_text_size) table.cell(info_table, 1, 2, 'Stoch Centered', text_color=color.blue, text_size=table_text_size) table.cell(info_table, 2, 2, str.tostring(stoch_centered, '0.00'), text_color=color.blue, text_size=table_text_size) table.cell(info_table, 0, 3, '', text_color=color.red, text_size=table_text_size) table.cell(info_table, 1, 3, 'Williams %R', text_color=color.red, text_size=table_text_size) table.cell(info_table, 2, 3, str.tostring(williams_r, '0.00'), text_color=color.red, text_size=table_text_size) table.cell(info_table, 0, 4, '', text_color=color.orange, text_size=table_text_size) table.cell(info_table, 1, 4, 'MACD Histogram', text_color=color.orange, text_size=table_text_size) table.cell(info_table, 2, 4, str.tostring(macd_histogram, '0.000'), text_color=color.orange, text_size=table_text_size) table.cell(info_table, 0, 5, '', text_color=color.green, text_size=table_text_size) table.cell(info_table, 1, 5, 'CCI', text_color=color.green, text_size=table_text_size) table.cell(info_table, 2, 5, str.tostring(cci, '0.00'), text_color=color.green, text_size=table_text_size) // Key Trend Indicators table.cell(info_table, 0, 6, 'TREND', text_color=color.navy, text_size=table_text_size, bgcolor=color.new(color.navy, 90)) table.cell(info_table, 1, 6, 'SMA Momentum %', text_color=color.navy, text_size=table_text_size) table.cell(info_table, 2, 6, str.tostring(sma_momentum, '0.00'), text_color=color.navy, text_size=table_text_size) table.cell(info_table, 0, 7, '', text_color=color.maroon, text_size=table_text_size) table.cell(info_table, 1, 7, 'EMA Momentum %', text_color=color.maroon, text_size=table_text_size) table.cell(info_table, 2, 7, str.tostring(ema_momentum, '0.00'), text_color=color.maroon, text_size=table_text_size) table.cell(info_table, 0, 8, '', text_color=color.teal, text_size=table_text_size) table.cell(info_table, 1, 8, 'SAR Trend', text_color=color.teal, text_size=table_text_size) table.cell(info_table, 2, 8, str.tostring(sar_trend, '0'), text_color=color.teal, text_size=table_text_size) table.cell(info_table, 0, 9, '', text_color=color.lime, text_size=table_text_size) table.cell(info_table, 1, 9, 'Linear Regression', text_color=color.lime, text_size=table_text_size) table.cell(info_table, 2, 9, str.tostring(lr_slope, '0.000'), text_color=color.lime, text_size=table_text_size) // Key Volatility Indicators table.cell(info_table, 0, 10, 'VOLATILITY', text_color=color.yellow, text_size=table_text_size, bgcolor=color.new(color.yellow, 90)) table.cell(info_table, 1, 10, 'ATR %', text_color=color.yellow, text_size=table_text_size) table.cell(info_table, 2, 10, str.tostring(atr_pct, '0.00'), text_color=color.yellow, text_size=table_text_size) table.cell(info_table, 0, 11, '', text_color=color.aqua, text_size=table_text_size) table.cell(info_table, 1, 11, 'BB Position', text_color=color.aqua, text_size=table_text_size) table.cell(info_table, 2, 11, str.tostring(bb_position, '0.00'), text_color=color.aqua, text_size=table_text_size) table.cell(info_table, 0, 12, '', text_color=color.olive, text_size=table_text_size) table.cell(info_table, 1, 12, 'KC Position', text_color=color.olive, text_size=table_text_size) table.cell(info_table, 2, 12, str.tostring(kc_position, '0.00'), text_color=color.olive, text_size=table_text_size) // Key Volume Indicators table.cell(info_table, 0, 13, 'VOLUME', text_color=color.blue, text_size=table_text_size, bgcolor=color.new(color.blue, 90)) table.cell(info_table, 1, 13, 'Volume ROC', text_color=color.blue, text_size=table_text_size) table.cell(info_table, 2, 13, str.tostring(vroc, '0.00'), text_color=color.blue, text_size=table_text_size) table.cell(info_table, 0, 14, '', text_color=color.red, text_size=table_text_size) table.cell(info_table, 1, 14, 'EOM', text_color=color.red, text_size=table_text_size) table.cell(info_table, 2, 14, str.tostring(eom_sma, '0.000'), text_color=color.red, text_size=table_text_size) // Key Oscillators table.cell(info_table, 0, 15, 'OSCILLATORS', text_color=color.purple, text_size=table_text_size, bgcolor=color.new(color.purple, 90)) table.cell(info_table, 1, 15, 'Awesome Osc', text_color=color.blue, text_size=table_text_size) table.cell(info_table, 2, 15, str.tostring(ao, '0.000'), text_color=color.blue, text_size=table_text_size) table.cell(info_table, 0, 16, '', text_color=color.red, text_size=table_text_size) table.cell(info_table, 1, 16, 'Fisher Transform', text_color=color.red, text_size=table_text_size) table.cell(info_table, 2, 16, str.tostring(fisher, '0.000'), text_color=color.red, text_size=table_text_size) // Summary Statistics table.cell(info_table, 0, 17, 'SUMMARY', text_color=color.black, text_size=table_text_size, bgcolor=color.new(color.gray, 70)) table.cell(info_table, 1, 17, 'Total Indicators: 52', text_color=color.black, text_size=table_text_size) regime_color = rsi_centered > 10 ? color.green : rsi_centered < -10 ? color.red : color.gray regime_text = rsi_centered > 10 ? "BULLISH" : rsi_centered < -10 ? "BEARISH" : "NEUTRAL" table.cell(info_table, 2, 17, regime_text, text_color=regime_color, text_size=table_text_size) This makes it the perfect “indicator backbone” for quantitative and systematic traders who want to prototype, combine, and test new regime detection models—especially in combination with the Markov Chain indicator. How to use this script with the Markov Chain for research and backtesting: Add the Enhanced Indicator Export to your chart. Every calculated indicator is available as an individual data stream. Connect the indicator(s) you want as custom input(s) to the Markov Chain’s “Custom Indicators” option. In the Markov Chain indicator’s settings, turn ON the custom indicator mode. For each of the three custom indicator inputs, select the exported plot from the Enhanced Export script—the menu lists all 45+ signals by name. This creates a powerful, modular regime-detection engine where you can mix-and-match momentum, trend, volume, or custom combinations for advanced filtering. Backtest regime logic directly. Once you’ve connected your chosen indicators, the Markov Chain script performs regime detection (Bull/Neutral/Bear) based on your selected features—not just price returns. The regime detection is robust, automatically normalized (using Z-score), and outputs bias (1, -1, 0) for plug-and-play integration. Export the regime bias for programmatic use. As described above, use input.source() in your Pine Script strategy or system and link the bias output. You can now filter signals, control trade direction/size, or design pairs-trading that respect true, indicator-driven market regimes. With this framework, you’re not limited to static or simplistic regime filters. You can rigorously define, test, and refine what “market regime” means for your strategies—using the technical features that matter most to you. Optimize your signal generation by backtesting across a universe of meaningful indicator blends. Enhance risk management with objective, real-time regime boundaries. Accelerate your research: iterate quickly, swap indicator components, and see results with minimal code changes. Automate multi-asset or pairs-trading by integrating regime context directly into strategy logic. Add both scripts to your chart, connect your preferred features, and start investigating your best regime-based trades—entirely within the TradingView ecosystem. References & Further Reading Ang, A., & Bekaert, G. (2002). “Regime Switches in Interest Rates.” Journal of Business & Economic Statistics, 20(2), 163–182. Hamilton, J. D. (1989). “A New Approach to the Economic Analysis of Nonstationary Time Series and the Business Cycle.” Econometrica, 57(2), 357–384. Markov, A. A. (1906). "Extension of the Limit Theorems of Probability Theory to a Sum of Variables Connected in a Chain." The Notes of the Imperial Academy of Sciences of St. Petersburg. Guidolin, M., & Timmermann, A. (2007). “Asset Allocation under Multivariate Regime Switching.” Journal of Economic Dynamics and Control, 31(11), 3503–3544. Murphy, J. J. (1999). Technical Analysis of the Financial Markets. New York Institute of Finance. Brock, W., Lakonishok, J., & LeBaron, B. (1992). “Simple Technical Trading Rules and the Stochastic Properties of Stock Returns.” Journal of Finance, 47(5), 1731–1764. Zucchini, W., MacDonald, I. L., & Langrock, R. (2017). Hidden Markov Models for Time Series: An Introduction Using R (2nd ed.). Chapman and Hall/CRC. On Quantitative Finance and Markov Models: Lo, A. W., & Hasanhodzic, J. (2009). The Heretics of Finance: Conversations with Leading Practitioners of Technical Analysis. Bloomberg Press. Patterson, S. (2016). The Man Who Solved the Market: How Jim Simons Launched the Quant Revolution. Penguin Press. TradingView Pine Script Documentation: www.tradingview.com TradingView Blog: “Use an Input From Another Indicator With Your Strategy” www.tradingview.com GeeksforGeeks: “What is the Difference Between Markov Chains and Hidden Markov Models?” www.geeksforgeeks.org What makes this indicator original and unique? - On‑chart, real‑time Markov. The chain is drawn directly on your chart. You see the current regime, its tendency to stay (self‑loop), and the usual next step (arrows) as bars confirm. - Source‑agnostic by design. The engine runs on any series you select via input.source() — price, your own oscillator, a composite score, anything you compute in the script. - Automatic normalization + regime mapping. Different inputs live on different scales. The script standardizes your chosen source and maps it into clear regimes (e.g., Bull / Bear / Neutral) without you micromanaging thresholds each time. - Rolling, bar‑by‑bar learning. Transition tendencies are computed from a rolling window of confirmed bars. What you see is exactly what the market did in that window. - Fast experimentation. Switch the source, adjust the window, and the Markov view updates instantly. It’s a rapid way to test ideas and feel regime persistence/switch behavior. Integrate your own signals (using input.source()) - In settings, choose the Source . This is powered by input.source() . - Feed it price, an indicator you compute inside the script, or a custom composite series. - The script will automatically normalize that series and process it through the Markov engine, mapping it to regimes and updating the on‑chart spheres/arrows in real time. Credits: Deep gratitude to @RicardoSantos for both the foundational Markov chain processing engine and inspiring open-source contributions, which made advanced probabilistic market modeling accessible to the TradingView community. Special thanks to @Alien_Algorithms for the innovative and visually stunning 3D sphere logic that powers the indicator’s animated, regime-based visualization. Disclaimer This tool summarizes recent behavior. It is not financial advice and not a guarantee of future results.
Indicatore Pine Script®
di Fractalyst
7