Mulai

Custom

Session Breaks [crlmx]Session break lines with 3 separate customisable time frames - visibility control for LTF / MTF / HTF conditions, replacing standard option that clutters charts. Key Features - Three independent time-tiers (default: Daily / Weekly / Monthly) - Options per tier: 30min, 1H, 4H, 12H, D, W, M, Q - Visibility toggles - Per-tier colour with opacity, line style, width - Lookback setting limits how many break lines display - Overlap handling, only the highest timeframe draws - Streamlined input / UI brought to you by crlmx Trading Applications - Keep daily breaks visible on intraday TF while hiding them on daily+ - Use weekly and monthly breaks as structural reference - Layer multiple break types with distinct styles for quick session boundary identification - Disable visibility at or above the break timeframe to avoid redundant lines Scalping: (1): 30min / (2): 4H / (3): D Default / Day Trading: (1): D / (2): W / (3): M Version History v1.0 (Latest - 04 Mar 2026) - Three configurable break tiers with visibility toggles - Per-tier styling, lookback, and overlap priority - Responsive colour, width, and style controls
Indikator Pine Script®
oleh crlmx
TickCharts [crlmx]Volume-based candlestick chart - each candle represents a fixed dollar volume, rather than a time interval. A configurable bar statistics table shows delta, CVD, and volume breakdowns per candle. Reveals market participation pace, institutional activity, and regime shifts through candle formation speed. Key Features Dollar volume threshold candles (default $1M) Tick-accurate volume via TradingView footprint API (Premium or above) Bar statistics table with 6 configurable rows below candles 9 data types per row: Time, Volume, Delta, Buy, Sell, Delta %, Buy %, Sell %, Session CVD Volume progress label showing dollar amount, threshold and percentage on the live candle Streamlined input / UI brought to you by crlmx Trading Applications Volume candles compress during consolidation and expand during breakouts Fast candle succession signals high participation; slow formation signals stalling CVD tracks cumulative order flow direction across the visible range Delta and CVD rows show buyer/seller dominance per candle Recommended settings: Crypto (BTC/ETH): Candle Volume: $5M-$10M Index Futures (ES/NQ): Candle Volume: $1M-$2M Commodities (Gold): Candle Volume: $500K-$1M Version History v0.42 (Latest - 07 Mar 2026) Updated LTF Volume calculation to Footprint API Added Bar statistics table with 6 configurable rows and 9 data types Added row customisation
Indikator Pine Script®
oleh crlmx
Value Area Levels [crlmx]Calculated from native volume-at-price data vaLevels shows Value Area levels (VAH, POC, VAL) across three independently configurable timeframes. Requires TradingView Premium or above plan for Footprint data access, Short of that refere to Lite version (coming soon). Key Features - Three independent VA slots with on/off toggles - Timeframe selection: D, W, M, 30min, 1H, 4H, 8H, 12H - Session-based VA on slot 3: NYC, London, Asia, Custom - Custom session with user-defined time window and label prefix - Auto-calculated row resolution per instrument type - Manual ticks-per-row override for fine-tuning - Configurable Value Area percentage (default 68%) - Individual VAH, POC, VAL toggles per slot - Optional price display in labels - Requires TradingView Premium or Ultimate plan - Streamlined input / UI brought to you by crlmx Trading Applications - Map previous day area against weekly and session VAs to identify confluence zones - Track VAH/VAL as breakout triggers when price moves outside the prior value area - Compare session VA (NYC/LDN) against daily VA to for reactions - When daily and weekly VAs overlap, expect stronger reactions at the shared boundary - Combine with prLevels for a complete prior-level picture (price levels + volume levels) - Recommended Settings Intraday S/R: D + W + NYC | Chart: 1-15 min Session Trading: D + 4H + LDN | Chart: 1-5 min Swing Reference: D + W + M | Chart: 30 min - 4H Version History - v0.10: Initial release
Indikator Pine Script®
oleh crlmx
VWAP [crlmx] Flexible Volume Weighted Average Price (VWAP) for clean volume-weighted fair value benchmark and trend direction. Key Features - Adjustable VWAP Anchor - 30min, 1H, 2H, 4H, 8H, 12H, D, W, M, Q, Y - Sessions New York, London, Asia, with adjustable time - Clean session breaks, no skews in VWAP line - Period limit fearure (default 3) hides older periods - Streamlined inputs/UI brought to you by crlmx Trading Applications - Intraday anchors (30min-12H): scalping and day trading - Daily anchor: traditional intraday analysis - Weekly/Monthly/Quarterly: swing trading context - Yearly: long-term fair value - Configuration examples: Scalping: 30min-1H anchor | Limit: 5-10 | Bands: On | Multiplier: 1.0-1.5 Intraday: Day anchor | Limit: 3-5 | Bands: On | Multiplier: 1.0-2.0 Swing: Week-Month | Limit: 3-5 | Bands: Off | VWAP line only Position: Quarter-Year | Limit: 3 | Bands: Off | Fair value reference Version History v1.56 (Latest - 22 Feb 2026) - VWAP display limit feature: shows set amount of periods - Added Market Sessions - Streamlined input panel organisation
Indikator Pine Script®
oleh crlmx
VWAP x3 [crlmx] Flexible tripple VWAP for multi-timeframe analysis with session-based anchors for volume-weighted fair value benchmark and trend direction. Key Features - 3x fully adjustable VWAP anchor periods - Off, 30min, 1H, 2H, 4H, 8H, 12H, D, W, M, Q, Y, - New York, London, Asia Sessions with adjustable (UTC) - Clean session breaks in VWAP line - No skewed line continuation between anchor periods - Lookback control for cleaner charts - Session VWAPS exclude weekend days - Optional VWAP labels with controls - Streamlined inputs / UI brought to you by crlmx Trading Applications - VWAP 1 (Daily): intraday fair value - VWAP 2 (Weekly): swing trade context - VWAP 3 (Monthly): position trade reference - Turn off unused VWAPs for cleaner charts - Customizable to any anchor combination - Examples; Day Trading: VWAP1: 30min | VWAP2: 1H | VWAP3: Day Swing Trading: VWAP1: Day | VWAP2: Week | VWAP3: Month Session Trading: VWAP1: NY Session | VWAP2: London | VWAP3: Asia Position Trading: VWAP1: Week | VWAP2: Month | VWAP3: Quarter Version History v1.43 (Latest - 19 Jan 2026) - Three independent VWAP lines - Session-based anchors (NY/London/Asia) - Configurable session times (UTC) - Lookback parameter - Labels with size and offset options - Clean session breaks at boundaries
Indikator Pine Script®
oleh crlmx
Average Volume Corner BoxAn indicator that anchors a single info box to the chart’s top right corner. It compares the current volume to a selectable moving average (SMA, EMA, WMA) and displays a status (VOL > AVG or VOL < AVG), the current volume, the average volume, and percent difference. The color switches between red and green backgrounds so you can read volume at a glance without cluttering the chart with those stinky volume rectangles. Features • Fixed corner box anchored to the chart top right • Choose MA type: SMA, EMA, WMA • Selectable MA length • Optional percent difference display • Threshold multiplier to only flag meaningful spikes (e.g., vol > avg * 1.5) • Configurable colors and font size
Indikator Pine Script®
oleh lainkura
Volume Based Sampling [BackQuant]Volume Based Sampling What this does This indicator converts the usual time-based stream of candles into an event-based stream of “synthetic” bars that are created only when enough trading activity has occurred . You choose the activity definition: Volume bars : create a new synthetic bar whenever the cumulative number of shares/contracts traded reaches a threshold. Dollar bars : create a new synthetic bar whenever the cumulative traded dollar value (price × volume) reaches a threshold. The script then keeps an internal ledger of these synthetic opens, highs, lows, closes, and volumes, and can display them as candles, plot a moving average calculated over the synthetic closes, mark each time a new sample is formed, and optionally overlay the native time-bars for comparison. Why event-based sampling matters Markets do not release information on a clock: activity clusters during news, opens/closes, and liquidity shocks. Event-based bars normalize for that heteroskedastic arrival of information: during active periods you get more bars (finer resolution); during quiet periods you get fewer bars (coarser resolution). Research shows this can reduce microstructure pathologies and produce series that are closer to i.i.d. and more suitable for statistical modeling and ML. In particular: Volume and dollar bars are a common event-time alternative to time bars in quantitative research and are discussed extensively in Advances in Financial Machine Learning (AFML). These bars aim to homogenize information flow by sampling on traded size or value rather than elapsed seconds. The Volume Clock perspective models market activity in “volume time,” showing that many intraday phenomena (volatility, liquidity shocks) are better explained when time is measured by traded volume instead of seconds. Related market microstructure work on flow toxicity and liquidity highlights that the risk dealers face is tied to information intensity of order flow, again arguing for activity-based clocks. How the indicator works (plain English) Choose your bucket type Volume : accumulate volume until it meets a threshold. Dollar Bars : accumulate close × volume until it meets a dollar threshold. Pick the threshold rule Dynamic threshold : by default, the script computes a rolling statistic (mean or median) of recent activity to set the next bucket size. This adapts bar size to changing conditions (e.g., busier sessions produce more frequent synthetic bars). Fixed threshold : optionally override with a constant target (e.g., exactly 100,000 contracts per synthetic bar, or $5,000,000 per dollar bar). Build the synthetic bar While a bucket fills, the script tracks: o_s: first price of the bucket (synthetic open) h_s: running maximum price (synthetic high) l_s: running minimum price (synthetic low) c_s: last price seen (synthetic close) v_s: cumulative native volume inside the bucket d_samples: number of native bars consumed to complete the bucket (a proxy for “how fast” the threshold filled) Emit a new sample Once the bucket meets/exceeds the threshold, a new synthetic bar is finalized and stored. If overflow occurs (e.g., a single native bar pushes you past the threshold by a lot), the code will emit multiple synthetic samples to account for the extra activity. Maintain a rolling history efficiently A ring buffer can overwrite the oldest samples when you hit your Max Stored Samples cap, keeping memory usage stable. Compute synthetic-space statistics The script computes an SMA over the last N synthetic closes and basic descriptors like average bars per synthetic sample, mean and standard deviation of synthetic returns, and more. These are all in event time , not clock time. Inputs and options you will actually use Data Settings Sampling Method : Volume or Dollar Bars. Rolling Lookback : window used to estimate the dynamic threshold from recent activity. Filter : Mean or Median for the dynamic threshold. Median is more robust to spikes. Use Fixed? / Fixed Threshold : override dynamic sizing with a constant target. Max Stored Samples : cap on synthetic history to keep performance snappy. Use Ring Buffer : turn on to recycle storage when at capacity. Indicator Settings SMA over last N samples : moving average in synthetic space . Because its index is sample count, not minutes, it adapts naturally: more updates in busy regimes, fewer in quiet regimes. Visuals Show Synthetic Bars : plot the synthetic OHLC candles. Candle Color Mode : Green/Red: directional close vs open Volume Intensity: opacity scales with synthetic size Neutral: single color Adaptive: graded by how large the bucket was relative to threshold Mark new samples : drop a small marker whenever a new synthetic bar prints. Comparison & Research Show Time Bars : overlay the native time-based candles to visually compare how the two sampling schemes differ. How to read it, step by step Turn on “Synthetic Bars” and optionally overlay “Time Bars.” You will see that during high-activity bursts, synthetic bars print much faster than time bars. Watch the synthetic SMA . Crosses in synthetic space can be more meaningful because each update represents a roughly comparable amount of traded information. Use the “Avg Bars per Sample” in the info table as a regime signal. Falling average bars per sample means activity is clustering, often coincident with higher realized volatility. Try Dollar Bars when price varies a lot but share count does not; they normalize by dollar risk taken in each sample. Volume Bars are ideal when share count is a better proxy for information flow in your instrument. Quant finance background and citations Event time vs. clock time : Easley, López de Prado, and O’Hara advocate measuring intraday phenomena on a volume clock to better align sampling with information arrival. This framing helps explain volatility bursts and liquidity droughts and motivates volume-based bars. Flow toxicity and dealer risk : The same authors show how adverse selection risk changes with the intensity and informativeness of order flow, further supporting activity-based clocks for modeling and risk management. AFML framework : In Advances in Financial Machine Learning , event-driven bars such as volume, dollar, and imbalance bars are presented as superior sampling units for many ML tasks, yielding more stationary features and fewer microstructure distortions than fixed time bars. ( Alpaca ) Practical use cases 1) Regime-aware moving averages The synthetic SMA in event time is not fooled by quiet periods: if nothing of consequence trades, it barely updates. This can make trend filters less sensitive to calendar drift and more sensitive to true participation. 2) Breakout logic on “equal-information” samples The script exposes simple alerts such as breakout above/below the synthetic SMA . Because each bar approximates a constant amount of activity, breakouts are conditioned on comparable informational mass, not arbitrary time buckets. 3) Volatility-adaptive backtests If you use synthetic bars as your base data stream, most signal rules become self-paced : entry and exit opportunities accelerate in fast markets and slow down in quiet regimes, which often improves the realism of slippage and fill modeling in research pipelines (pair this indicator with strategy code downstream). 4) Regime diagnostics Avg Bars per Sample trending down: activity is dense; expect larger realized ranges. Return StdDev (synthetic) rising: noise or trend acceleration in event time; re-tune risk. Interpreting the info panel Method : your sampling choice and current threshold. Total Samples : how many synthetic bars have been formed. Current Vol/Dollar : how much of the next bucket is already filled. Bars in Bucket : native bars consumed so far in the current bucket. Avg Bars/Sample : lower means higher trading intensity. Avg Return / Return StdDev : return stats computed over synthetic closes . Research directions you can build from here Imbalance and run bars Extend beyond pure volume or dollar thresholds to imbalance bars that trigger on directional order flow imbalance (e.g., buy volume minus sell volume), as discussed in the AFML ecosystem. These often further homogenize distributional properties used in ML. alpaca.markets Volume-time indicators Re-compute classical indicators (RSI, MACD, Bollinger) on the synthetic stream. The premise is that signals are updated by traded information , not seconds, which may stabilize indicator behavior in heteroskedastic regimes. Liquidity and toxicity overlays Combine synthetic bars with proxies of flow toxicity to anticipate spread widening or volatility clustering. For instance, tag synthetic bars that surpass multiples of the threshold and test whether subsequent realized volatility is elevated. Dollar-risk parity sampling for portfolios Use dollar bars to align samples across assets by notional risk, enabling cleaner cross-asset features and comparability in multi-asset models (e.g., correlation studies, regime clustering). AFML discusses the benefits of event-driven sampling for cross-sectional ML feature engineering. Microstructure feature set Compute duration in native bars per synthetic sample , range per sample , and volume multiple of threshold as inputs to state classifiers or regime HMMs . These features are inherently activity-aware and often predictive of short-horizon volatility and trend persistence per the event-time literature. ( Alpaca ) Tips for clean usage Start with dynamic thresholds using Median over a sensible lookback to avoid outlier distortion, then move to Fixed thresholds when you know your instrument’s typical activity scale. Compare time bars vs synthetic bars side by side to develop intuition for how your market “breathes” in activity time. Keep Max Stored Samples reasonable for performance; the ring buffer avoids memory creep while preserving a rolling window of research-grade data.
Indikator Pine Script®
oleh BackQuant
Custom Period High LowSummary I'm moving over from TradeStation and default Pre-Market Session there is 0800-0930. Default PMS on TradingView is 0400-0930. I find that the 0800-0930 High and Low are more accurate levels. This script addresses exactly that - it allows you to grab High and Low of any custom time slot. This script started as Custom Pre-Market H/L, that's why the shading. Then I realized it can be used for any custom time period, so I renamed it to PERIOD H/L. Limitations Different tickers are provided by different exchanges, in different time zones. The end result is that the SAME session time (0800-0930) may shift for different tickers. Examples: - SPY : 0800-0930 // no shift: NYSE, in NYC - ES1!: 0900-1030 // shifted 1 hr ahead: CME, in Chicago - NQ1!: 0900-1030 // shifted 1 hr ahead: CME, in Chicago To see for yourself, set Time Zone config parameter to empty string for non-NYC tickers like ES1! or NQ1 and watch times for shaded and non-shaded areas. Why TV chooses to go by the ticker's TZ, and not the TZ that's configured in the lower right corner of my TV screen - I have no idea. But asking for user's TZ is how you fix it. If you know how I can get that value so I don't have to ask the user - let me know. I'm new to TV. Hacks You can use it more than once for, say, Opening Range Breakout. Configure your custom PMS for 0930-0945, change lines, remove area fill - and ta-da - you have High and Low for first 15 min! See release chart for the example.
Indikator Pine Script®
oleh hash1024
Fibo RSIThis is a customized Relative Strength Index (RSI) indicator designed to replicate TradingView’s default RSI while adding additional reference levels for deeper market analysis. 🔹 Features: RSI length set to 8 by default (user adjustable). Calculates RSI using the standard ta.rsi() function. Plots the RSI line in a clean, separate panel. Adds 7 key levels for analysis: 0, 20, 30, 50, 70, 80, 100. Levels are drawn as thin, solid straight lines for a cleaner look (instead of default dashed). 🔹 Use cases: Identify momentum shifts with enhanced precision. Use intermediate levels (20, 30, 50, 70, 80) as potential support/resistance zones. Ideal for traders who want a Fibonacci-like structure in RSI analysis.
Indikator Pine Script®
oleh MALIK897
Dual Custom Index with SpreadDual Custom Index with Spread Create powerful custom indices from any instruments and analyze their relative strength dynamics Overview This advanced indicator allows you to build two completely customizable indices from your choice of instruments and analyze their spread relationship. Perfect for inter-market analysis, sector rotation strategies, currency strength comparisons, and sophisticated relative performance studies. Key Features 🔧 Fully Customizable Index Construction Build each index from up to 6 instruments with individual weightings Enable/disable instruments on the fly without losing settings Automatic weight validation ensures mathematically accurate calculations Invert functionality for instruments that move opposite to index strength 📊 Advanced ADX-Based Methodology Uses sophisticated ADX +DI/-DI directional bias calculations Normalized bias calculation for consistent scaling across different instruments Optimized default settings for intraday trading with full customization options Professional-grade smoothing and filtering options 📈 Dual Analysis Modes Difference Mode: Shows absolute strength difference (Index1 - Index2) Ratio Mode: Shows relative performance ratio (Index1 / Index2) Additional spread smoothing for cleaner signals 🎨 Professional Display Options Custom labels with full color, size, and positioning control Dynamic "Follow Line" labels that move with your data Static corner positioning for reference displays Clean error messaging and validation feedback Use Cases Gold Trading: Create gold strength vs USD strength indices for precise market timing Sector Analysis: Compare technology vs financial sector strength for rotation strategies Currency Strength: Build custom currency baskets for advanced forex analysis Commodity Spreads: Analyze relative strength between different commodity groups Regional Markets: Compare strength between different geographical market indices Crypto Analysis: Track relative performance between different cryptocurrency sectors Technical Specifications Instruments per Index: Up to 6 with individual enable/disable Weight Validation: Automatic 100% total weight enforcement Calculation Method: ADX-based directional bias with trend strength weighting Smoothing Options: Multiple levels of customizable smoothing Error Handling: Professional validation with clear user feedback Optimization Tips Intraday Trading: Use DI Length 3-7 for faster response Daily Analysis: Use DI Length 10-14 for smoother signals Noisy Markets: Increase Final Smoothing for cleaner signals Trending Markets: Lower smoothing values for faster reaction Perfect for traders who need sophisticated inter-market analysis tools beyond standard indicators. Whether you're analyzing gold vs dollar dynamics, sector rotation opportunities, or custom currency strength relationships, this indicator provides institutional-grade analysis capabilities with complete customization flexibility.
Indikator Pine Script®
oleh d_day_80
VIX Filter/RSI/EMA Bias/Cum-TICK w/ Exhaustion Zone DashboardThis all-in-one dashboard gives intraday traders a real-time visual read of market conditions, combining volatility regime, trend bias, momentum exhaustion, and internal strength — all in a fully customizable overlay that won’t clutter your chart. 📉 VIX Market Regime Detector Identifies "Weak", "Normal", "Volatile", or "Danger" market states based on customizable VIX ranges and symbol (e.g., VXN or VIX). 📊 RSI Momentum Readout Displays real-time RSI from any selected timeframe or symbol, with adjustable length, OB/OS thresholds, and color-coded exhaustion alerts. 📈 EMA Trend Bias Scanner Compares fast and slow EMAs to define bullish or bearish bias, using your preferred timeframe, symbol, and EMA lengths — ideal for multi-timeframe setups. 🧠 Cumulative TICK Pressure & Exhaustion Engine Analyzes internal market strength using cumulative TICK data to classify conditions as: -Strong / Mild Bullish or Bearish Pressure -Choppy / No Edge -⚠️ Exhaustion Zones — when raw TICK values hit extreme highs/lows, a separate highlight box appears in the dashboard, warning of potential turning points All logic is customizable, including TICK symbol, timeframes, thresholds, and lookback periods. Scalpers and day traders who want fast, visual insight into market internals, exhaustion, and trend bias.
Indikator Pine Script®
oleh BKNY954RR
Gold DynamicThis is a custom-made TradingView indicator designed to visualize "sequential price levels" based on a user-defined step value, dynamically centered around the current gold price. It draws horizontal lines at multiples of a chosen step value (e.g., 7) both above and below the current price. Key Features: Dynamic Price Levels: Lines are calculated relative to the live price, providing relevant support/resistance or structural levels for the current market context. Customizable Step Value: Easily adjust the Sequence Step Value (e.g., 7, 10, 14) from the indicator settings to align with your trading theory. Adjustable Line Count: Control the Number of Lines ABOVE Current Price and Number of Lines BELOW Current Price to show as many or as few levels as desired. Extended Lines: Horizontal lines extend indefinitely to both the left (historical data) and right (future projection) for comprehensive visualization. Clear Price Labels: Each line displays its exact price value, positioned at the far right of the chart for quick reference. Customizable Appearance: Modify line color, width, and style (solid, dotted, dashed) to suit your charting preferences. Exact Values: All displayed price labels are rounded to whole numbers for clear, precise visualization without decimal values. This indicator is ideal for traders looking to apply a fixed-step price theory to their gold analysis.
Indikator Pine Script®
oleh pipsmix0
Top Right Watermark# TopRight Watermark **Finally, a watermark that stays out of your way!** Tired of TradingView's default watermark blocking your price action and technical analysis? This customizable watermark indicator gives you complete control over positioning and content display. ## 🎯 Key Features **✅ Flexible Positioning** - Place anywhere: corners, sides, or edges **✅ Multi-Slot Display** - Up to 3 customizable information slots **✅ Individual Font Control** - Different sizes for each slot **✅ Platform Compatibility** - TradingView OR MetaTrader timeframe formats **✅ Clean & Professional** - Customizable colors and transparency ## 🔧 What You Can Display - **Timeframe** - Current chart period - **Ticker** - Symbol name (smart formatting for crypto/forex) - **Exchange** - Broker/platform name - **Custom Text** - Your own message - **Empty** - Hide unused slots ## 🎨 Customization Options - **Position**: 9 placement options (top/middle/bottom + left/center/right) - **Colors**: Full color picker with transparency control - **Font Sizes**: 5 sizes available per slot (tiny to huge) - **Timeframe Style**: Choose TradingView (1m, 4H) or MetaTrader (M1, H4) format ## 🚀 Perfect For - Traders who need clean chart visibility - Multi-timeframe analysis - Professional chart screenshots - Platform migrants (MT4/MT5 to TradingView) - Anyone wanting organized chart information ## 💡 Pro Tips - Place in corners to avoid price action interference - Combine Exchange + Ticker + Timeframe for complete context - Use transparency to make it subtle but visible **Stop letting watermarks interfere with your trading analysis. Take control of your chart display today!** --- *Compatible with all TradingView chart types and timeframes. Easy setup with intuitive controls.*
Indikator Pine Script®
oleh dabhi358
Zweig Market Breadth Thrust Indicator+Trigger [LazyBear x rwak]The Breadth Thrust (BT) indicator is a market momentum indicator developed by Dr. Martin Zweig. According to Dr. Zweig, a Breadth Thrust occurs when, during a 10-day period, the Breadth Thrust indicator rises from below 40 percent to above 61.5 percent. A "Thrust" indicates that the stock market has rapidly changed from an oversold condition to one of strength, but has not yet become overbought. This is very rare and has happened only a few times. Dr. Zweig also points out that most bull markets begin with a Breadth Thrust. This version of the Breadth Thrust indicator includes a trigger visualized with red circles, making it easier to spot when the indicator crosses the critical 61.5% level, signaling potential bullish momentum. All parameters are configurable. You can draw BT for NYSE, NASDAQ, AMEX, or based on combined data (i.e., AMEX+NYSE+NASD). There is also a "CUSTOM" mode supported, so you can enter your own ADV/DEC symbols. Credit: The original Breadth Thrust logic was created by LazyBear, whose public indicators can be found here , and app-store indicators here . More info: Definition of Breadth Thrust A Breadth Thrust Signal A Rare "Zweig" Buy Signal Zweig Breadth Thrust: Redux
Indikator Pine Script®
oleh rwak
real_time_candlesIntroduction The Real-Time Candles Library provides comprehensive tools for creating, manipulating, and visualizing custom timeframe candles in Pine Script. Unlike standard indicators that only update at bar close, this library enables real-time visualization of price action and indicators within the current bar, offering traders unprecedented insight into market dynamics as they unfold. This library addresses a fundamental limitation in traditional technical analysis: the inability to see how indicators evolve between bar closes. By implementing sophisticated real-time data processing techniques, traders can now observe indicator movements, divergences, and trend changes as they develop, potentially identifying trading opportunities much earlier than with conventional approaches. Key Features The library supports two primary candle generation approaches: Chart-Time Candles: Generate real-time OHLC data for any variable (like RSI, MACD, etc.) while maintaining synchronization with chart bars. Custom Timeframe (CTF) Candles: Create candles with custom time intervals or tick counts completely independent of the chart's native timeframe. Both approaches support traditional candlestick and Heikin-Ashi visualization styles, with options for moving average overlays to smooth the data. Configuration Requirements For optimal performance with this library: Set max_bars_back = 5000 in your script settings When using CTF drawing functions, set max_lines_count = 500, max_boxes_count = 500, and max_labels_count = 500 These settings ensure that you will be able to draw correctly and will avoid any runtime errors. Usage Examples Basic Chart-Time Candle Visualization // Create real-time candles for RSI float rsi = ta.rsi(close, 14) Candle rsi_candle = candle_series(rsi, CandleType.candlestick) // Plot the candles using Pine's built-in function plotcandle(rsi_candle.Open, rsi_candle.High, rsi_candle.Low, rsi_candle.Close, "RSI Candles", rsi_candle.candle_color, rsi_candle.candle_color) Multiple Access Patterns The library provides three ways to access candle data, accommodating different programming styles: // 1. Array-based access for collection operations Candle candles = candle_array(source) // 2. Object-oriented access for single entity manipulation Candle candle = candle_series(source) float value = candle.source(Source.HLC3) // 3. Tuple-based access for functional programming styles = candle_tuple(source) Custom Timeframe Examples // Create 20-second candles with EMA overlay plot_ctf_candles( source = close, candle_type = CandleType.candlestick, sample_type = SampleType.Time, number_of_seconds = 20, timezone = -5, tied_open = true, ema_period = 9, enable_ema = true ) // Create tick-based candles (new candle every 15 ticks) plot_ctf_tick_candles( source = close, candle_type = CandleType.heikin_ashi, number_of_ticks = 15, timezone = -5, tied_open = true ) Advanced Usage with Custom Visualization // Get custom timeframe candles without automatic plotting CandleCTF my_candles = ctf_candles_array( source = close, candle_type = CandleType.candlestick, sample_type = SampleType.Time, number_of_seconds = 30 ) // Apply custom logic to the candles float ema_values = my_candles.ctf_ema(14) // Draw candles and EMA using time-based coordinates my_candles.draw_ctf_candles_time() ema_values.draw_ctf_line_time(line_color = #FF6D00) Library Components Data Types Candle: Structure representing chart-time candles with OHLC, polarity, and visualization properties CandleCTF: Extended candle structure with additional time metadata for custom timeframes TickData: Structure for individual price updates with time deltas Enumerations CandleType: Specifies visualization style (candlestick or Heikin-Ashi) Source: Defines price components for calculations (Open, High, Low, Close, HL2, etc.) SampleType: Sets sampling method (Time-based or Tick-based) Core Functions get_tick(): Captures current price as a tick data point candle_array(): Creates an array of candles from price updates candle_series(): Provides a single candle based on latest data candle_tuple(): Returns OHLC values as a tuple ctf_candles_array(): Creates custom timeframe candles without rendering Visualization Functions source(): Extracts specific price components from candles candle_ctf_to_float(): Converts candle data to float arrays ctf_ema(): Calculates exponential moving averages for candle arrays draw_ctf_candles_time(): Renders candles using time coordinates draw_ctf_candles_index(): Renders candles using bar index coordinates draw_ctf_line_time(): Renders lines using time coordinates draw_ctf_line_index(): Renders lines using bar index coordinates Technical Implementation Notes This library leverages Pine Script's varip variables for state management, creating a sophisticated real-time data processing system. The implementation includes: Efficient tick capturing: Samples price at every execution, maintaining temporal tracking with time deltas Smart state management: Uses a hybrid approach with mutable updates at index 0 and historical preservation at index 1+ Temporal synchronization: Manages two time domains (chart time and custom timeframe) The tooltip implementation provides crucial temporal context for custom timeframe visualizations, allowing users to understand exactly when each candle formed regardless of chart timeframe. Limitations Custom timeframe candles cannot be backtested due to Pine Script's limitations with historical tick data Real-time visualization is only available during live chart updates Maximum history is constrained by Pine Script's array size limits Applications Indicator visualization: See how RSI, MACD, or other indicators evolve in real-time Volume analysis: Create custom volume profiles independent of chart timeframe Scalping strategies: Identify short-term patterns with precisely defined time windows Volatility measurement: Track price movement characteristics within bars Custom signal generation: Create entry/exit signals based on custom timeframe patterns Conclusion The Real-Time Candles Library bridges the gap between traditional technical analysis (based on discrete OHLC bars) and the continuous nature of market movement. By making indicators more responsive to real-time price action, it gives traders a significant edge in timing and decision-making, particularly in fast-moving markets where waiting for bar close could mean missing important opportunities. Whether you're building custom indicators, researching price patterns, or developing trading strategies, this library provides the foundation for sophisticated real-time analysis in Pine Script. Implementation Details & Advanced Guide Core Implementation Concepts The Real-Time Candles Library implements a sophisticated event-driven architecture within Pine Script's constraints. At its heart, the library creates what's essentially a reactive programming framework handling continuous data streams. Tick Processing System The foundation of the library is the get_tick() function, which captures price updates as they occur: export get_tick(series float source = close, series float na_replace = na)=> varip float price = na varip int series_index = -1 varip int old_time = 0 varip int new_time = na varip float time_delta = 0 // ... This function: Samples the current price Calculates time elapsed since last update Maintains a sequential index to track updates The resulting TickData structure serves as the fundamental building block for all candle generation. State Management Architecture The library employs a sophisticated state management system using varip variables, which persist across executions within the same bar. This creates a hybrid programming paradigm that's different from standard Pine Script's bar-by-bar model. For chart-time candles, the core state transition logic is: // Real-time update of current candle candle_data := Candle.new(Open, High, Low, Close, polarity, series_index, candle_color) candles.set(0, candle_data) // When a new bar starts, preserve the previous candle if clear_state candles.insert(1, candle_data) price.clear() // Reset state for new candle Open := Close price.push(Open) series_index += 1 This pattern of updating index 0 in real-time while inserting completed candles at index 1 creates an elegant solution for maintaining both current state and historical data. Custom Timeframe Implementation The custom timeframe system manages its own time boundaries independent of chart bars: bool clear_state = switch settings.sample_type SampleType.Ticks => cumulative_series_idx >= settings.number_of_ticks SampleType.Time => cumulative_time_delta >= settings.number_of_seconds This dual-clock system synchronizes two time domains: Pine's execution clock (bar-by-bar processing) The custom timeframe clock (tick or time-based) The library carefully handles temporal discontinuities, ensuring candle formation remains accurate despite irregular tick arrival or market gaps. Advanced Usage Techniques 1. Creating Custom Indicators with Real-Time Candles To develop indicators that process real-time data within the current bar: // Get real-time candles for your data Candle rsi_candles = candle_array(ta.rsi(close, 14)) // Calculate indicator values based on candle properties float signal = ta.ema(rsi_candles.first().source(Source.Close), 9) // Detect patterns that occur within the bar bool divergence = close > close and rsi_candles.first().Close < rsi_candles.get(1).Close 2. Working with Custom Timeframes and Plotting For maximum flexibility when visualizing custom timeframe data: // Create custom timeframe candles CandleCTF volume_candles = ctf_candles_array( source = volume, candle_type = CandleType.candlestick, sample_type = SampleType.Time, number_of_seconds = 60 ) // Convert specific candle properties to float arrays float volume_closes = volume_candles.candle_ctf_to_float(Source.Close) // Calculate derived values float volume_ema = volume_candles.ctf_ema(14) // Create custom visualization volume_candles.draw_ctf_candles_time() volume_ema.draw_ctf_line_time(line_color = color.orange) 3. Creating Hybrid Timeframe Analysis One powerful application is comparing indicators across multiple timeframes: // Standard chart timeframe RSI float chart_rsi = ta.rsi(close, 14) // Custom 5-second timeframe RSI CandleCTF ctf_candles = ctf_candles_array( source = close, candle_type = CandleType.candlestick, sample_type = SampleType.Time, number_of_seconds = 5 ) float fast_rsi_array = ctf_candles.candle_ctf_to_float(Source.Close) float fast_rsi = fast_rsi_array.first() // Generate signals based on divergence between timeframes bool entry_signal = chart_rsi < 30 and fast_rsi > fast_rsi_array.get(1) Final Notes This library represents an advanced implementation of real-time data processing within Pine Script's constraints. By creating a reactive programming framework for handling continuous data streams, it enables sophisticated analysis typically only available in dedicated trading platforms. The design principles employed—including state management, temporal processing, and object-oriented architecture—can serve as patterns for other advanced Pine Script development beyond this specific application. ------------------------ Library "real_time_candles" A comprehensive library for creating real-time candles with customizable timeframes and sampling methods. Supports both chart-time and custom-time candles with options for candlestick and Heikin-Ashi visualization. Allows for tick-based or time-based sampling with moving average overlay capabilities. get_tick(source, na_replace)   Captures the current price as a tick data point   Parameters:      source (float) : Optional - Price source to sample (defaults to close)      na_replace (float) : Optional - Value to use when source is na   Returns: TickData structure containing price, time since last update, and sequential index candle_array(source, candle_type, sync_start, bullish_color, bearish_color)   Creates an array of candles based on price updates   Parameters:      source (float) : Optional - Price source to sample (defaults to close)      candle_type (simple CandleType) : Optional - Type of candle chart to create (candlestick or Heikin-Ashi)      sync_start (simple bool) : Optional - Whether to synchronize with the start of a new bar      bullish_color (color) : Optional - Color for bullish candles      bearish_color (color) : Optional - Color for bearish candles   Returns: Array of Candle objects ordered with most recent at index 0 candle_series(source, candle_type, wait_for_sync, bullish_color, bearish_color)   Provides a single candle based on the latest price data   Parameters:      source (float) : Optional - Price source to sample (defaults to close)      candle_type (simple CandleType) : Optional - Type of candle chart to create (candlestick or Heikin-Ashi)      wait_for_sync (simple bool) : Optional - Whether to wait for a new bar before starting      bullish_color (color) : Optional - Color for bullish candles      bearish_color (color) : Optional - Color for bearish candles   Returns: A single Candle object representing the current state candle_tuple(source, candle_type, wait_for_sync, bullish_color, bearish_color)   Provides candle data as a tuple of OHLC values   Parameters:      source (float) : Optional - Price source to sample (defaults to close)      candle_type (simple CandleType) : Optional - Type of candle chart to create (candlestick or Heikin-Ashi)      wait_for_sync (simple bool) : Optional - Whether to wait for a new bar before starting      bullish_color (color) : Optional - Color for bullish candles      bearish_color (color) : Optional - Color for bearish candles   Returns: Tuple representing current candle values method source(self, source, na_replace)   Extracts a specific price component from a Candle   Namespace types: Candle   Parameters:      self (Candle)      source (series Source) : Type of price data to extract (Open, High, Low, Close, or composite values)      na_replace (float) : Optional - Value to use when source value is na   Returns: The requested price value from the candle method source(self, source)   Extracts a specific price component from a CandleCTF   Namespace types: CandleCTF   Parameters:      self (CandleCTF)      source (simple Source) : Type of price data to extract (Open, High, Low, Close, or composite values)   Returns: The requested price value from the candle as a varip method candle_ctf_to_float(self, source)   Converts a specific price component from each CandleCTF to a float array   Namespace types: array   Parameters:      self (array)      source (simple Source) : Optional - Type of price data to extract (defaults to Close)   Returns: Array of float values extracted from the candles, ordered with most recent at index 0 method ctf_ema(self, ema_period)   Calculates an Exponential Moving Average for a CandleCTF array   Namespace types: array   Parameters:      self (array)      ema_period (simple float) : Period for the EMA calculation   Returns: Array of float values representing the EMA of the candle data, ordered with most recent at index 0 method draw_ctf_candles_time(self, sample_type, number_of_ticks, number_of_seconds, timezone)   Renders custom timeframe candles using bar time coordinates   Namespace types: array   Parameters:      self (array)      sample_type (simple SampleType) : Optional - Method for sampling data (Time or Ticks), used for tooltips      number_of_ticks (simple int) : Optional - Number of ticks per candle (used when sample_type is Ticks), used for tooltips      number_of_seconds (simple float) : Optional - Time duration per candle in seconds (used when sample_type is Time), used for tooltips      timezone (simple int) : Optional - Timezone offset from UTC (-12 to +12), used for tooltips   Returns: void - Renders candles on the chart using time-based x-coordinates method draw_ctf_candles_index(self, sample_type, number_of_ticks, number_of_seconds, timezone)   Renders custom timeframe candles using bar index coordinates   Namespace types: array   Parameters:      self (array)      sample_type (simple SampleType) : Optional - Method for sampling data (Time or Ticks), used for tooltips      number_of_ticks (simple int) : Optional - Number of ticks per candle (used when sample_type is Ticks), used for tooltips      number_of_seconds (simple float) : Optional - Time duration per candle in seconds (used when sample_type is Time), used for tooltips      timezone (simple int) : Optional - Timezone offset from UTC (-12 to +12), used for tooltips   Returns: void - Renders candles on the chart using index-based x-coordinates method draw_ctf_line_time(self, source, line_size, line_color)   Renders a line representing a price component from the candles using time coordinates   Namespace types: array   Parameters:      self (array)      source (simple Source) : Optional - Type of price data to extract (defaults to Close)      line_size (simple int) : Optional - Width of the line      line_color (simple color) : Optional - Color of the line   Returns: void - Renders a connected line on the chart using time-based x-coordinates method draw_ctf_line_time(self, line_size, line_color)   Renders a line from a varip float array using time coordinates   Namespace types: array   Parameters:      self (array)      line_size (simple int) : Optional - Width of the line, defaults to 2      line_color (simple color) : Optional - Color of the line   Returns: void - Renders a connected line on the chart using time-based x-coordinates method draw_ctf_line_index(self, source, line_size, line_color)   Renders a line representing a price component from the candles using index coordinates   Namespace types: array   Parameters:      self (array)      source (simple Source) : Optional - Type of price data to extract (defaults to Close)      line_size (simple int) : Optional - Width of the line      line_color (simple color) : Optional - Color of the line   Returns: void - Renders a connected line on the chart using index-based x-coordinates method draw_ctf_line_index(self, line_size, line_color)   Renders a line from a varip float array using index coordinates   Namespace types: array   Parameters:      self (array)      line_size (simple int) : Optional - Width of the line, defaults to 2      line_color (simple color) : Optional - Color of the line   Returns: void - Renders a connected line on the chart using index-based x-coordinates plot_ctf_tick_candles(source, candle_type, number_of_ticks, timezone, tied_open, ema_period, bullish_color, bearish_color, line_width, ema_color, use_time_indexing)   Plots tick-based candles with moving average   Parameters:      source (float) : Input price source to sample      candle_type (simple CandleType) : Type of candle chart to display      number_of_ticks (simple int) : Number of ticks per candle      timezone (simple int) : Timezone offset from UTC (-12 to +12)      tied_open (simple bool) : Whether to tie open price to close of previous candle      ema_period (simple float) : Period for the exponential moving average      bullish_color (color) : Optional - Color for bullish candles      bearish_color (color) : Optional - Color for bearish candles      line_width (simple int) : Optional - Width of the moving average line, defaults to 2      ema_color (color) : Optional - Color of the moving average line      use_time_indexing (simple bool) : Optional - When true the function will plot with xloc.time, when false it will plot using xloc.bar_index   Returns: void - Creates visual candle chart with EMA overlay plot_ctf_tick_candles(source, candle_type, number_of_ticks, timezone, tied_open, bullish_color, bearish_color, use_time_indexing)   Plots tick-based candles without moving average   Parameters:      source (float) : Input price source to sample      candle_type (simple CandleType) : Type of candle chart to display      number_of_ticks (simple int) : Number of ticks per candle      timezone (simple int) : Timezone offset from UTC (-12 to +12)      tied_open (simple bool) : Whether to tie open price to close of previous candle      bullish_color (color) : Optional - Color for bullish candles      bearish_color (color) : Optional - Color for bearish candles      use_time_indexing (simple bool) : Optional - When true the function will plot with xloc.time, when false it will plot using xloc.bar_index   Returns: void - Creates visual candle chart without moving average plot_ctf_time_candles(source, candle_type, number_of_seconds, timezone, tied_open, ema_period, bullish_color, bearish_color, line_width, ema_color, use_time_indexing)   Plots time-based candles with moving average   Parameters:      source (float) : Input price source to sample      candle_type (simple CandleType) : Type of candle chart to display      number_of_seconds (simple float) : Time duration per candle in seconds      timezone (simple int) : Timezone offset from UTC (-12 to +12)      tied_open (simple bool) : Whether to tie open price to close of previous candle      ema_period (simple float) : Period for the exponential moving average      bullish_color (color) : Optional - Color for bullish candles      bearish_color (color) : Optional - Color for bearish candles      line_width (simple int) : Optional - Width of the moving average line, defaults to 2      ema_color (color) : Optional - Color of the moving average line      use_time_indexing (simple bool) : Optional - When true the function will plot with xloc.time, when false it will plot using xloc.bar_index   Returns: void - Creates visual candle chart with EMA overlay plot_ctf_time_candles(source, candle_type, number_of_seconds, timezone, tied_open, bullish_color, bearish_color, use_time_indexing)   Plots time-based candles without moving average   Parameters:      source (float) : Input price source to sample      candle_type (simple CandleType) : Type of candle chart to display      number_of_seconds (simple float) : Time duration per candle in seconds      timezone (simple int) : Timezone offset from UTC (-12 to +12)      tied_open (simple bool) : Whether to tie open price to close of previous candle      bullish_color (color) : Optional - Color for bullish candles      bearish_color (color) : Optional - Color for bearish candles      use_time_indexing (simple bool) : Optional - When true the function will plot with xloc.time, when false it will plot using xloc.bar_index   Returns: void - Creates visual candle chart without moving average plot_ctf_candles(source, candle_type, sample_type, number_of_ticks, number_of_seconds, timezone, tied_open, ema_period, bullish_color, bearish_color, enable_ema, line_width, ema_color, use_time_indexing)   Unified function for plotting candles with comprehensive options   Parameters:      source (float) : Input price source to sample      candle_type (simple CandleType) : Optional - Type of candle chart to display      sample_type (simple SampleType) : Optional - Method for sampling data (Time or Ticks)      number_of_ticks (simple int) : Optional - Number of ticks per candle (used when sample_type is Ticks)      number_of_seconds (simple float) : Optional - Time duration per candle in seconds (used when sample_type is Time)      timezone (simple int) : Optional - Timezone offset from UTC (-12 to +12)      tied_open (simple bool) : Optional - Whether to tie open price to close of previous candle      ema_period (simple float) : Optional - Period for the exponential moving average      bullish_color (color) : Optional - Color for bullish candles      bearish_color (color) : Optional - Color for bearish candles      enable_ema (bool) : Optional - Whether to display the EMA overlay      line_width (simple int) : Optional - Width of the moving average line, defaults to 2      ema_color (color) : Optional - Color of the moving average line      use_time_indexing (simple bool) : Optional - When true the function will plot with xloc.time, when false it will plot using xloc.bar_index   Returns: void - Creates visual candle chart with optional EMA overlay ctf_candles_array(source, candle_type, sample_type, number_of_ticks, number_of_seconds, tied_open, bullish_color, bearish_color)   Creates an array of custom timeframe candles without rendering them   Parameters:      source (float) : Input price source to sample      candle_type (simple CandleType) : Type of candle chart to create (candlestick or Heikin-Ashi)      sample_type (simple SampleType) : Method for sampling data (Time or Ticks)      number_of_ticks (simple int) : Optional - Number of ticks per candle (used when sample_type is Ticks)      number_of_seconds (simple float) : Optional - Time duration per candle in seconds (used when sample_type is Time)      tied_open (simple bool) : Optional - Whether to tie open price to close of previous candle      bullish_color (color) : Optional - Color for bullish candles      bearish_color (color) : Optional - Color for bearish candles   Returns: Array of CandleCTF objects ordered with most recent at index 0 Candle   Structure representing a complete candle with price data and display properties   Fields:      Open (series float) : Opening price of the candle      High (series float) : Highest price of the candle      Low (series float) : Lowest price of the candle      Close (series float) : Closing price of the candle      polarity (series bool) : Boolean indicating if candle is bullish (true) or bearish (false)      series_index (series int) : Sequential index identifying the candle in the series      candle_color (series color) : Color to use when rendering the candle      ready (series bool) : Boolean indicating if candle data is valid and ready for use TickData   Structure for storing individual price updates   Fields:      price (series float) : The price value at this tick      time_delta (series float) : Time elapsed since the previous tick in milliseconds      series_index (series int) : Sequential index identifying this tick CandleCTF   Structure representing a custom timeframe candle with additional time metadata   Fields:      Open (series float) : Opening price of the candle      High (series float) : Highest price of the candle      Low (series float) : Lowest price of the candle      Close (series float) : Closing price of the candle      polarity (series bool) : Boolean indicating if candle is bullish (true) or bearish (false)      series_index (series int) : Sequential index identifying the candle in the series      open_time (series int) : Timestamp marking when the candle was opened (in Unix time)      time_delta (series float) : Duration of the candle in milliseconds      candle_color (series color) : Color to use when rendering the candle
Perpustakaan Pine Script®
oleh The_Peaceful_Lizard
30
Triple Doji SequenceThe Triple Doji Sequence indicator helps traders identify consecutive Doji candlestick patterns, allowing them to choose between spotting single, double, or triple Dojis. A Doji is detected when the candle's body is small relative to its wicks, with either the upper or lower wick being significantly larger. Users can customize their own Doji criteria by adjusting the body size and wick dominance settings. The indicator ensures that consecutive Dojis align in the same direction before confirming a valid pattern, making it easier to identify market indecision or potential trend reversals. When the chosen Doji sequence is detected, the indicator plots a star (*) above bearish Dojis (upper wick dominant) and below bullish Dojis (lower wick dominant). It also sends alerts when a valid sequence is confirmed at the close of the bar. This tool helps traders refine their strategy by spotting repeated Doji formations, which may indicate key turning points or continuation patterns in price action. How to Use the Triple Doji Sequence Indicator? Apply the Indicator: Add the Triple Doji Sequence indicator to your TradingView chart. It will automatically scan for Doji patterns based on your settings. Customize Your Doji Criteria: Adjust the body size and wick dominance settings to define what qualifies as a Doji. Choose whether to detect single, double, or triple Doji sequences. Interpret the Signals: A star (*) above a candle signals a bearish Doji (upper wick dominant). A star (*) below a candle signals a bullish Doji (lower wick dominant). Set Up Alerts: Enable alerts to receive notifications when a Doji sequence is confirmed at bar close. Choose alert frequency based on your trading strategy (e.g., once per bar, once per bar close). Use in Trading Strategy: Doji sequences can indicate trend reversals or market indecision. Combine this indicator with support/resistance levels, volume, or other indicators to confirm signals. PS: Good luck in finding a Triple Doji :)
Indikator Pine Script®
oleh Marc_Thiart
Custom Index CompositeCustom Index Composite calculates an unweighted composite index by averaging the daily returns of multiple stock tickers. Instead of using price-level weighting, it focuses solely on percentage change, allowing you to compare diverse market themes side by side on a common basis. Why Use a Custom Index Composite? Unlike traditional indices that often lean on market capitalization or price-level data, a custom composite based solely on returns strips out the bias inherent to high-priced stocks. This provides several benefits: Objective Cross-Comparison: When stocks or market themes trade at very different price levels, it can be difficult to assess performance objectively. Using percentage returns, the composite creates an even playing field, enabling a clear comparison between different assets or themes. Tailored Benchmarking: By selecting and combining specific tickers, you can create benchmarks that better represent the segments or strategies you’re interested in. This is particularly useful when standard indices do not capture the nuances of your investment approach. Performance Normalization: Converting raw price data into daily percentage returns minimizes distortions that arise from price differences. This normalization helps in understanding true performance trends across the chosen tickers, making the composite index a more reliable gauge of relative market movement. Custom Analysis Framework: The indicator offers flexibility to adjust the lookback period (defaulting to about 3 months) so you can fine-tune the sensitivity of the index to recent market behavior. This enables you to either smooth out volatility or capture a more immediate trend, depending on your analytical needs. Key Features: Configurable Appearance: You can easily configure the line color, line width, index name, and index name color via the options panel. Ticker Configuration: By default, you can enter up to 15 different tickers into the composite index. Technically, the indicator supports up to 40 tickers (these additional inputs are commented out by default to maintain performance), and you may enable them individually if required. Calculated Bars Length: The indicator uses a “Calculated bars length” setting, which is set by default to 63 days (approximately 3 months). This value can be adjusted, and it is recommended to use the greatest common denominator for consistent analysis. How To Configure Your Chart: Add the Indicator: Place the Custom Index Composite on your chart. Disable Main Symbol Visibility: Hide the primary symbol’s plot and set its scale to “None” to prevent interference with the composite display. Pin to Right Scale: Set the scale of the first composite indicator to “Pinned to right scale.” This helps maintain consistency across different composite indicators. Add Multiple Composites: You can add additional composite indicators and set their scales to “Pinned to right scale” (or alternatively to “A”) for convenient comparison. Limitations: If a ticker symbol is set once in the options, it cannot be cleared to an empty value later. As a result, the symbol will continue to appear in the indicator’s title on the chart. The only way to remove an unwanted symbol is to completely reset the settings and re-enter your desired tickers.
Indikator Pine Script®
oleh fyntrade