Inizia

Cerca negli script per "entry"

Entry Bars -This algorithm takes in consideration Media averages, Volatility Movements and other Mathematical Properties. -After adding this signal on TradingView, you will get notified every of potential long and short points triggered by the indicator. -This signal alerts you anytime bars form a bullish or bearish pattern and price start to move in the suggested direction. -It works in any time frame or market like Forex, Crypto, Commodities even Stocks. -Recommended for bots or manual trading. Do you need an Script or an expert adviser for Forex, contact our coding service Get this indicator today! contact us
Indicatore Pine Script®
di Vertical-X
2
Amazing Crossover SystemEntry Rules BUY when the 5 EMA crosses above the 10 EMA from underneath and the RSI crosses above the 50.0 mark from the bottom. SELL when the 5 EMA crosses below the 10 EMA from the top and the RSI crosses below the 50.0 mark from the top. Make sure that the RSI did cross 50.0 from the top or bottom and not just ranging tightly around the level. How to setup Alert: 1) Add the Amazing Crossover System to your chart via Indicators 2) Find your currency pair 3) Set the timeframe on the chart to 1 hour 4) Press 'Alt + A' (create alert shortcut) 5) Set the following criteria for the alert: Condition = 'Amazing Crossover System', Plot, ' BUY Signal' The rest of the alert can be customized to your preferences 5) Repeat steps 1 - 4, but set the Condition = 'Amazing Crossover System', Plot, ' SELL Signal'
Indicatore Pine Script®
di rmunoz
4
Trend Following with Mean Reversion - IndicatorTrend Following with Mean Reversion Indicator A comprehensive technical analysis tool that combines trend detection with momentum reversal signals for enhanced market timing. Strategy Overview: This indicator identifies high-probability entry points by combining two proven technical concepts: Trend Following: Uses Exponential Moving Average (EMA) to determine market direction Mean Reversion: Utilizes RSI oversold/overbought levels for optimal entry timing Key Features: 📊 Core Indicators: Customizable EMA for trend identification (default: 50 periods) RSI momentum oscillator with adjustable overbought/oversold levels Visual trend direction indicators 🎯 Signal Generation: BUY Signals: Generated when price is above EMA (uptrend) AND RSI is oversold (<30) SELL Signals: Generated when price is below EMA (downtrend) AND RSI is overbought (>70) Clear visual labels on chart for easy identification ⏰ Advanced Time Management: Customizable trading session filter (default: 0700-1500) Multiple timezone support (GMT-8 to GMT+13) Individual day exclusion controls (weekends excluded by default) Visual background coloring for time restrictions 🎨 Visual Elements: Color-coded trend indicators RSI extreme level background highlighting Time filter status visualization Comprehensive information table showing current market conditions 🔔 Alert System: Built-in alerts for valid entry signals Notifications for signals occurring outside trading hours Customizable alert messages How It Works: Trend Filter: EMA determines if market is trending up or down Momentum Confirmation: RSI identifies when price has moved too far and is due for reversal Time Validation: Ensures signals only occur during specified trading hours Visual Confirmation: Clear BUY/SELL labels appear only when all conditions align Best Use Cases: Swing trading on higher timeframes (4H, Daily) Counter-trend entries in strong trending markets Combining with other technical analysis tools Educational purposes for understanding trend/momentum relationships Customization Options: Adjustable EMA and RSI periods Customizable overbought/oversold levels Flexible time and day restrictions Toggle visual elements on/off Multiple display themes Note: This is a technical analysis tool for educational and informational purposes. Always conduct your own analysis and consider risk management principles. Past performance does not guarantee future results.
Indicatore Pine Script®
di profitgang
SimpleBias ProSimpleBias PRO - Advanced Multi-Timeframe Bias Analysis System SimpleBias PRO is an advanced multi-timeframe bias analysis system, specifically designed for professional traders who need in-depth analysis and integrated risk management. A major upgrade from the free version, it features 6 separate table systems and sophisticated trading logic. Key Features Multi-Table Analysis System SimpleBias Table - Core bias analysis across 8 timeframes Logic Table - Advanced trading logic with confluence requirements EMA Table - Trend analysis with customizable EMA system Time Table - Session-based timing optimization Time & Price Table - Combined temporal and price analysis Risk Management Table - Automated position sizing calculations Advanced EMA Integration Multiple source options: Open, Close, High, Low Dynamic color modes with bullish/bearish visualization EMA direction analysis (RISE/FALL/NEUTRAL) Customizable periods (1-9999) with plot capability Professional line width control (1-5 pixels) Smart Time-Based Analysis Optimized trading hours for different timeframes New York timezone integration for global markets Time status indicators with visual confirmation Session-specific filtering for 15m, 5m, 1m strategies Enhanced Trading Logic Multi-timeframe confluence requirements Mid-timeframe bias analysis EMA direction confirmation system Time-based entry filtering Separate conditions for scalping (1m), day trading (5m), and swing (15m) Professional Risk Management Balance input with validation ($100 - $10,000,000) Risk percentage control (0.1% - 10.0%) Stop loss configuration in pips (5-5000) Automatic position sizing calculations Real-time risk assessment display How It Works Bias Calculation The indicator determines market bias by comparing the current timeframe's open price with the previous period's open price: BULLISH: Current open > Previous open BEARISH: Current open < Previous open NEUTRAL: Current open = Previous open Multi-Timeframe Confluence The system requires alignment across multiple timeframes before generating signals: 15-Minute Strategy: 4h, 1h, 15m bias alignment 1H mid-timeframe confirmation EMA direction confirmation Optimal time session validation 5-Minute Strategy: 1h, 15m, 5m bias alignment 15M mid-timeframe confirmation EMA trend validation Session timing optimization 1-Minute Strategy: 15m, 5m, 1m bias alignment 5M mid-timeframe confirmation EMA direction sync Precise timing windows Risk Management Integration Automatic position sizing based on: Account balance Risk percentage Stop loss distance Current market conditions Advanced Customization Theme & Display Options Light/Dark mode with automatic color adaptation Transparent background options Individual table toggle controls Position control (Top/Middle/Bottom Right) Text size optimization (Tiny/Small/Normal) Professional Color Schemes Separate bias color customization Dynamic EMA coloring Signal color differentiation Theme-adaptive interface elements Best Practices For Professional Day Trading Use 15-minute charts with 15M strategy Focus on 4H and 1H bias alignment Enable EMA confirmation Trade during optimal NY sessions Apply 0.25-0.5% risk per trade For Advanced Scalping Use 5-minute charts with 5M strategy Require 1H and 15M bias confluence Monitor EMA direction changes Focus on high-probability time windows Use tight risk management (0.1-0.25%) For Swing Trading Use 15-minute+ charts Focus on higher timeframe bias alignment Allow wider stop losses Use longer EMA periods Apply conservative risk (0.5-1%) Technical Specifications Pine Script Version: v6 Performance: Multi-table system with efficient rendering Compatibility: All TradingView timeframes and instruments Updates: Real-time bias detection and signal generation Important Disclaimers This indicator is for educational and analysis purposes only. Not financial advice - always conduct your own research and risk assessment. Past performance does not guarantee future results. Proper risk management is essential for all trading activities.
Indicatore Pine Script®
di agatarigan
Two Poles Trend Finder MTF [BigBeluga]🔵 OVERVIEW Two Poles Trend Finder MTF is a refined trend-following overlay that blends a two-pole Gaussian filter with a multi-timeframe dashboard. It provides a smooth view of price dynamics along with a clear summary of trend directions across multiple timeframes—perfect for traders seeking alignment between short and long-term momentum. 🔵 CONCEPTS Two-Pole Filter: A smoothing algorithm that responds faster than traditional moving averages but avoids the noise of short-term fluctuations. var float f = na var float f_prev1 = na var float f_prev2 = na // Apply two-pole Gaussian filter if bar_index >= 2 f := math.pow(alpha, 2) * source + 2 * (1 - alpha) * f_prev1 - math.pow(1 - alpha, 2) * f_prev2 else f := source // Warm-up for first bars // Shift state f_prev2 := f_prev1 f_prev1 := f Trend Detection Logic: Trend direction is determined by comparing the current filtered value with its value n bars ago (shifted comparison). MTF Alignment Dashboard: Trends from 5 configurable timeframes are monitored and visualized as colored boxes:   • Green = Uptrend   • Magenta = Downtrend Summary Arrow: An average trend score from all timeframes is used to plot an overall arrow next to the asset name. 🔵 FEATURES Two-Pole Gaussian Filter offers ultra-smooth trend curves while maintaining responsiveness. Multi-Timeframe Trend Detection:   • Default: 1H, 2H, 4H, 12H, 1D (fully customizable)   • Each timeframe is assessed independently using the same trend logic. Visual Trend Dashboard positioned at the bottom-right of the chart with color-coded trend blocks. Dynamic Summary Arrow shows overall market bias (🢁 / 🢃) based on majority of uptrends/downtrends. Bold + wide trail plot for the filter value with gradient coloring based on directional bias. 🔵 HOW TO USE Use the multi-timeframe dashboard to identify aligned trends across your preferred trading horizons. Confirm trend strength or weakness by observing filter slope direction . Look for dashboard consensus (e.g., 4 or more timeframes green] ) as confirmation for breakout, continuation, or trend reentry strategies. Combine with volume or price structure to enhance entry timing. 🔵 CONCLUSION Two Poles Trend Finder MTF delivers a clean and intuitive trend-following solution with built-in multi-timeframe awareness. Whether you’re trading intra-day or positioning for swing setups, this tool helps filter out market noise and keeps you focused on directional consensus.
Indicatore Pine Script®
di BigBeluga
1
FibLevel Size CalculatorThis skript calculates position sizes and new take profits for sizing into an long or short position with 3 entrys defined at custom fibonacci retracement levels. TP: -0,272 Entry1: 0.382 Entry2: 0.618 Entry3: 0.83 SL: 1.05 Expected RR per trade is 0.2 with a High Win rate definitly profitable. Search for an established trend on the higher timeframe, drop to the smaller ones and look for correction waves. Once they break to the trenddirection of the higher timeframe take the fib from lowest to highes point. Draw a fib level on the chart and use the Indicator to define these Levels above. The calculator gives you the Margin to use in each position, and will check that you will not get liquidated an that you have enough margin. It tells you the new TP for Limit2 and Limit3 if they get hit so you can get out of the trade full TP with a small bounce. Inputs: Account Balance, Risk Percentage, and Leverage: These inputs are used to calculate the position size and risk. Entry 1, Entry 2, Entry 3, Take Profit (TP), and Stop Loss (SL): These prices are used for calculating position sizes, risk, and profit for up to three entry points. Calculations: Risk Amount: Calculated based on the account balance and risk percentage. Position Sizes (Qty): For each entry point, the position size is determined. The second and third entries have a multiplier (3x for Entry 2, 5x for Entry 3) compared to the first. Stop Loss and Profit Calculation: The script calculates the potential profit and adjusts the TP levels based on the average entries for Limit 2 and Limit 3. Margin Calculation: Margin requirements for each position are calculated based on leverage. Output: Table Display: A table shows key values like entry prices, position sizes, TP levels, potential profit, and margin requirements for each limit. Warnings: It includes a liquidation warning and a check for whether the account is at risk of liquidation based on leverage. Position Type: It automatically detects if the trade is a long or short based on the relationship between TP and SL. Visualization: Lines: It draws horizontal lines on the chart to visually represent the entry, TP, and SL levels. Overall, this script is designed to help traders manage risk and calculate position sizes for multi-level entries using leverage. Pls drop feedback in the comments.
Indicatore Pine Script®
di SimpleScalp
2
Nef33 Forex & Crypto Trading Signals PRO 1. Understanding the Indicator's Context The indicator generates signals based on confluence (trend, volume, key zones, etc.), but it does not include predefined SL or TP levels. To establish them, we must: Use dynamic or static support/resistance levels already present in the script. Incorporate volatility (such as ATR) to adjust the levels based on market conditions. Define a risk/reward ratio (e.g., 1:2). 2. Options for Determining SL and TP Below, I provide several ideas based on the tools available in the script: Stop Loss (SL) The SL should protect you from adverse movements. You can base it on: ATR (Volatility): Use the smoothed ATR (atr_smooth) multiplied by a factor (e.g., 1.5 or 2) to set a dynamic SL. Buy: SL = Entry Price - (atr_smooth * atr_mult). Sell: SL = Entry Price + (atr_smooth * atr_mult). Key Zones: Place the SL below a support (for buys) or above a resistance (for sells), using Order Blocks, Fair Value Gaps, or Liquidity Zones. Buy: SL below the nearest ob_lows or fvg_lows. Sell: SL above the nearest ob_highs or fvg_highs. VWAP: Use the daily VWAP (vwap_day) as a critical level. Buy: SL below vwap_day. Sell: SL above vwap_day. Take Profit (TP) The TP should maximize profits. You can base it on: Risk/Reward Ratio: Multiply the SL distance by a factor (e.g., 2 or 3). Buy: TP = Entry Price + (SL Distance * 2). Sell: TP = Entry Price - (SL Distance * 2). Key Zones: Target the next resistance (for buys) or support (for sells). Buy: TP at the next ob_highs, fvg_highs, or liq_zone_high. Sell: TP at the next ob_lows, fvg_lows, or liq_zone_low. Ichimoku: Use the cloud levels (Senkou Span A/B) as targets. Buy: TP at senkou_span_a or senkou_span_b (whichever is higher). Sell: TP at senkou_span_a or senkou_span_b (whichever is lower). 3. Practical Implementation Since the script does not automatically draw SL/TP, you can: Calculate them manually: Observe the chart and use the levels mentioned. Modify the code: Add SL/TP as labels (label.new) at the moment of the signal. Here’s an example of how to modify the code to display SL and TP based on ATR with a 1:2 risk/reward ratio: Modified Code (Signals Section) Find the lines where the signals (trade_buy and trade_sell) are generated and add the following: pinescript // Calculate SL and TP based on ATR atr_sl_mult = 1.5 // Multiplier for SL atr_tp_mult = 3.0 // Multiplier for TP (1:2 ratio) sl_distance = atr_smooth * atr_sl_mult tp_distance = atr_smooth * atr_tp_mult if trade_buy entry_price = close sl_price = entry_price - sl_distance tp_price = entry_price + tp_distance label.new(bar_index, low, "Buy: " + str.tostring(math.round(bull_conditions, 1)), color=color.green, textcolor=color.white, style=label.style_label_up, size=size.tiny) label.new(bar_index, sl_price, "SL: " + str.tostring(math.round(sl_price, 2)), color=color.red, textcolor=color.white, style=label.style_label_down, size=size.tiny) label.new(bar_index, tp_price, "TP: " + str.tostring(math.round(tp_price, 2)), color=color.blue, textcolor=color.white, style=label.style_label_up, size=size.tiny) if trade_sell entry_price = close sl_price = entry_price + sl_distance tp_price = entry_price - tp_distance label.new(bar_index, high, "Sell: " + str.tostring(math.round(bear_conditions, 1)), color=color.red, textcolor=color.white, style=label.style_label_down, size=size.tiny) label.new(bar_index, sl_price, "SL: " + str.tostring(math.round(sl_price, 2)), color=color.red, textcolor=color.white, style=label.style_label_up, size=size.tiny) label.new(bar_index, tp_price, "TP: " + str.tostring(math.round(tp_price, 2)), color=color.blue, textcolor=color.white, style=label.style_label_down, size=size.tiny) Code Explanation SL: Calculated by subtracting/adding sl_distance to the entry price (close) depending on whether it’s a buy or sell. TP: Calculated with a double distance (tp_distance) for a 1:2 risk/reward ratio. Visualization: Labels are added to the chart to display SL (red) and TP (blue). 4. Practical Strategy Without Modifying the Code If you don’t want to modify the script, follow these steps manually: Entry: Take the trade_buy or trade_sell signal. SL: Check the smoothed ATR (atr_smooth) on the chart or calculate a fixed level (e.g., 1.5 times the ATR). Also, review nearby key zones (OB, FVG, VWAP). TP: Define a target based on the next key zone or multiply the SL distance by 2 or 3. Example: Buy at 100, ATR = 2. SL = 100 - (2 * 1.5) = 97. TP = 100 + (2 * 3) = 106. 5. Recommendations Test in Demo: Apply this logic in a demo account to adjust the multipliers (atr_sl_mult, atr_tp_mult) based on the market (forex or crypto). Combine with Zones: If the ATR-based SL is too wide, use the nearest OB or FVG as a reference. Risk/Reward Ratio: Adjust the TP based on your tolerance (1:1, 1:2, 1:3)
Indicatore Pine Script®
di neftali1327
1
AI Strat ATR Dinamico + ADX + Trend Adaptivo (No Repaint)Below is a fully self-contained, English-language description of every input, function, and logical block inside the “AI Strat ATR Dinamico + ADX + Trend Adaptivo (No Repaint)” indicator. You can copy and paste this into TradingView’s “Description” field when you publish, without exposing any Pine code. --- ## Indicator Name and Purpose **Name (Short Title):** AI Strat Adaptive v3 (NoRepaint) **Overview:** This indicator combines multiple technical tools—RSI, EMA, ATR (with a dynamic multiplier), ADX/DI, and an “AI‐style” scoring mechanism—to generate trend-filtered and reversal signals. It also optionally confirms signals on a higher timeframe, dynamically adjusts its sensitivity based on volatility, and plots intrabar stop‐loss (SL) and take‐profit (TP) levels derived from ATR. Special care has been taken to ensure that no signals “repaint” (i.e., once drawn on a closed bar, they never disappear or shift). --- ## 1. Main Inputs All of the inputs appear in the Settings dialog for the published indicator. Below is a detailed explanation of each input, grouped by logical category. ### A. RSI & EMA Base Parameters 1. **RSI Length (Base)** * **Input type:** Integer (default 14) * **Description:** Number of bars used to calculate the Relative Strength Index (RSI). A shorter RSI reacts more quickly to price changes; a longer RSI is smoother. 2. **RSI Overbought Threshold** * **Input type:** Integer (default 60) * **Description:** If the RSI value rises above this level, it contributes a “sell” signal component. You can adjust this (e.g., 70) to make your system more conservative. 3. **RSI Oversold Threshold** * **Input type:** Integer (default 40) * **Description:** If the RSI falls below this level, it contributes a “buy” signal component. Raising this threshold (e.g., 50) makes the strategy more aggressive in seeking reversals. 4. **EMA Length (Base)** * **Input type:** Integer (default 20) * **Description:** Number of bars for the Exponential Moving Average (EMA). A shorter EMA will produce more frequent crossovers, a longer EMA is smoother. ### B. ATR & Volatility Filter Parameters 5. **ATR Length (Base)** * **Input type:** Integer (default 14) * **Description:** Number of bars to calculate Average True Range (ATR). The ATR is used both for measuring volatility and for dynamic SL/TP levels. 6. **ATR SMA Length** * **Input type:** Integer (default 50) * **Description:** Number of bars to compute a Simple Moving Average of the ATR itself. This gives a baseline of “normal” volatility. If ATR rises significantly above this SMA, the indicator treats the market as “high volatility.” 7. **ATR Multiplier Base** * **Input type:** Float (default 1.2, step 0.1) * **Description:** Base multiplier for ATR when filtering for volatility. The actual threshold is computed as `ATR_SMA × (ATR_Multiplier Base) × sqrt(current_ATR / ATR_SMA)`. In other words, the multiplier becomes larger if volatility is rising, and smaller if volatility is falling. 8. **Disable Volatility Filter** * **Input type:** Boolean (default false) * **Description:** If enabled (true), the indicator will ignore any volatility‐based filtering, using signals regardless of ATR behavior. If disabled (false), signals only fire when ATR > (ATR\_SMA × dynamic multiplier). ### C. Price-Change & “AI Score” Parameters 9. **Price Change Period (bars)** * **Input type:** Integer (default 3) * **Description:** The number of bars back to measure percentage price change. Used to ensure that a “trend” signal is accompanied by a sufficiently positive (for longs) or negative (for shorts) price movement over this many bars. 10. **Base AI Score Threshold** * **Input type:** Float (default 0.1) * **Description:** The indicator computes a composite “AI-style” score by combining the RSI signal (overbought/oversold) and an EMA crossover signal. Only if the absolute value of that composite score exceeds this threshold will a trend signal be eligible. Raising it makes signals rarer but (potentially) higher-conviction. ### D. SMA “ICT” Trend Filter Parameters 11. **ICT SMA Long Length (Base)** * **Input type:** Integer (default 50) * **Description:** Number of bars for the “long” Simple Moving Average (SMA) used in the internal trend filter. Typically, price must be above this SMA (and ADX must be strong) to confirm an uptrend, or below it (and ADX strong) to confirm a downtrend. 12. **ICT SMA Short1 Length (Base)** * **Input type:** Integer (default 10) * **Description:** Secondary “fast” SMA used both for reversal logic (e.g., price crossing above it can count as a bullish reversal) and part of the internal trend confirmation. 13. **ICT SMA Short2 Length (Base)** * **Input type:** Integer (default 20) * **Description:** A second “medium” SMA used for reversal triggers (e.g., crossovers or crossunders alongside RSI conditions). ### E. ADX & DI Parameters 14. **Base ADX Length** * **Input type:** Integer (default 14) * **Description:** Number of bars for the ADX (Average Directional Index) moving averages, which measure trend strength. The same length is used for +DI and –DI smoothing. 15. **Base ADX Threshold** * **Input type:** Float (default 25.0, step 0.5) * **Description:** If ADX > this threshold and +DI > –DI, we consider an uptrend; if ADX > this threshold and –DI > +DI, we consider a downtrend. Raising this value demands stronger trends to qualify. ### F. Sensitivity & Cooldown 16. **Sensitivity (0–1)** * **Input type:** Float between 0.0 and 1.0 (default 0.5) * **Description:** A general “mixture” parameter used internally to weight how aggressively the indicator leans into trend versus reversal. In practice, the code uses it to fine-tune exact thresholds for switching between trend and reversal conditions. You can leave it at 0.5 unless you want to bias more heavily toward either regime. 17. **Base Cooldown Bars Between Signals** * **Input type:** Integer (default 5, min 0) * **Description:** Once a long or short signal fires, the indicator will wait at least this many bars before allowing a new signal in the same direction. Prevents “signal flipping” on each bar. A higher number forces fewer, more spaced-out entries. 18. **Trend Confirmation Bars** * **Input type:** Integer (default 3, min 1) * **Description:** After the directional filters (+DI/–DI cross, price vs. SMA), the indicator still requires that price remains on the same side of the long SMA for at least this many consecutive bars before confirming “trend up” or “trend down.” Larger values smooth out false breakouts but may lag signals. ### G. Higher Timeframe Confirmation 19. **Use Higher Timeframe Confirmation** * **Input type:** Boolean (default true) * **Description:** If true, the indicator will request a block of values (SMA, +DI, –DI, ADX) from a higher timeframe (default 60 minutes) and require that the higher timeframe is also in agreement (strong uptrend or strong downtrend) before confirming your current-timeframe trend. This helps filter out lower-timeframe noise. 20. **Higher Timeframe (TF) for Confirmation** * **Input type:** Timeframe (default “60”) * **Description:** The chart timeframe (e.g., 5, 15, 60 minutes) whose trend conditions must also be true. It’s sent through a `request.security(..., lookahead=barmerge.lookahead_off)` call so that it never “paints ahead.” ### H. Dynamic TP/SL Parameters 21. **TP as ATR Multiple** * **Input type:** Float (default 2.0, step 0.1) * **Description:** When a trade is open, the “take-profit” price is determined by looking at the highest high (for longs) or lowest low (for shorts) observed since entry, and then plotting a cross (“X”) at that level when the trend finally flips. This is purely for display. However, separate from that, this parameter can be adapted if you want a strictly ATR­–based TP. In the “Minimal” version, TP is ≈ (highest high) once trend inverts, but you could rewrite it to use `entry_price + ATR×TP_Multiplier`. 22. **SL as ATR Multiple** * **Input type:** Float (default 1.0, step 0.1) * **Description:** While in a trade, a trailing SL line is plotted each bar. Its value is always `entry_price ± (ATR × SL_Multiplier)`. When the trend inverts, the SL no longer updates, and you see it on the chart. ### I. Display and Mode Options 23. **Show Debug Lines** * **Input type:** Boolean (default true) * **Description:** When enabled, the indicator will plot all intermediate lines—ATR SMA, ATR Threshold, +DI, –DI, ADX (current and HTF), HTF SMA, etc.—so that you can diagnose exactly what’s happening. Turn this off to hide all debug information and only see entry/exit shapes. 24. **Enable Scalping Mode** * **Input type:** Boolean (default false) * **Description:** If true, many of the “base” parameters are halved (e.g., RSI length becomes 7 instead of 14, ATR length becomes 7 instead of 14, ADX length becomes 7, etc.), and the ADX threshold is multiplied by 0.8. This makes all oscillators and moving averages more reactive, suited for very short-term (scalping) setups. --- ## 2. Core Calculation Blocks Below is a high-level description of each logical block (in code order), translated from Pine into conceptual steps. ### A. Adjust Inputs if “Scalping Mode” Is On If **Scalping Mode** = true, then: * `RSI_Length` becomes `max(1, round(Base_RSI_Length / 2))` * `EMA_Length` becomes `max(1, round(Base_EMA_Length / 2))` * `ATR_Length` becomes `max(1, round(Base_ATR_Length / 2))` * `Price_Change_Period` becomes `max(1, round(Base_Price_Change_Period / 2))` * `SMA_Long_Length`, `SMA_Short1_Length`, and `SMA_Short2_Length` are each halved (minimum 1). * `ADX_Length` = `max(1, round(Base_ADX_Length / 2))` * `ADX_Threshold` = `Base_ADX_Threshold × 0.8` * `Cooldown_Bars` = `max(0, round(Base_Cooldown_Bars / 2))` Otherwise, all adjusted lengths = their base values. ### B. RSI, EMA & “AI Score” on Current Timeframe 1. **Compute RSI:** * Uses the (possibly adjusted) `RSI_Length`. * Denote this as `RSI_Value`. 2. **Compute ATR & Its SMA:** * `ATR_Value` = `ta.atr(ATR_Length)`. * `ATR_SMA` = `ta.sma(ATR_Value, ATR_SMA_Length)`. * Then define `Volatility_Increase` = (`ATR_Value > ATR_SMA`). * If the volatility has increased, the weighting of RSI vs. EMA changes. 3. **Compute Weights:** * If `Volatility_Increase == true`, then: * `RSI_Weight = 0.7` * `EMA_Weight = 0.3` * Otherwise: * `RSI_Weight = 0.3` * `EMA_Weight = 0.7` 4. **RSI Signal Component (`RSI_Sig`):** * If `RSI_Value > RSI_Overbought`, then `RSI_Sig = –1`. * Else if `RSI_Value < RSI_Oversold`, then `RSI_Sig = +1`. * Otherwise, `RSI_Sig = 0`. 5. **EMA Value & Signal Component (`EMA_Sig`):** * `EMA_Value` = `ta.ema(close, EMA_Length)`. * `EMA_Sig = +1` if the current close crosses **above** the EMA; `EMA_Sig = –1` if the current close crosses **below** the EMA; else `0`. 6. **Compute Raw “AI Score”:** $$ Raw\_AI = (RSI\_Sig \times RSI\_Weight)\;+\;(EMA\_Sig \times EMA\_Weight) $$ Then, $$ AI\_Score = \frac{Raw\_AI}{(RSI\_Weight + EMA\_Weight)} $$ (This normalization ensures the score always ranges between –1 and +1 if both weights sum to 1.) ### C. Dynamic ATR Multiplier & Volatility Filter 1. **Volatility Factor:** $$ Volatility\_Factor = \frac{ATR\_Value}{ATR\_SMA} $$ 2. **Dynamic ATR Multiplier:** $$ ATR\_Multiplier = ATR\_Multiplier\_Base \times \sqrt{Volatility\_Factor} $$ 3. **High Volatility Condition (`High_Volatility`):** * If `Disable_Volatility_Filter == true`, then treat `High_Volatility = true` always. * Else, `High_Volatility = (ATR_Value > ATR_SMA × ATR_Multiplier)`. ### D. Price Change Percentage * **Compute Price Change:** $$ Price\_Change = \frac{(Close - Close )}{Close } \times 100 $$ * This is the percent return from `Price_Change_Period` bars ago to now. * For a valid long‐trend signal, we require `Price_Change > 0`; for a short trend, `Price_Change < 0`. ### E. Local SMAs for Trend/Reversal Filters * `SMA_Close_Long` = `ta.sma(close, SMA_Long_Length)`. * `SMA_Close_Short1` = `ta.sma(close, SMA_Short1_Length)`. * `SMA_Close_Short2` = `ta.sma(close, SMA_Short2_Length)`. These three SMAs help define the “local trend” and reversal breakout points: * **Primary Trend Filter:** * Price must be above `SMA_Close_Long` for an uptrend filter, or below `SMA_Close_Long` for a downtrend filter. * **Reversal Filter:** * A bullish reversal is detected if **(RSI < Oversold AND close crosses above EMA)** OR **(RSI < Oversold AND close crosses above SMA\_Close\_Short1)**. * A bearish reversal is detected if **(RSI > Overbought AND close crosses below EMA)** OR **(RSI > Overbought AND close crosses below SMA\_Close\_Short1)**. ### F. Manual +DI, –DI & ADX on Current Timeframe Instead of relying on the built-in `ta.adx`, the script calculates DI and ADX manually. This makes it easier to replicate the exact logic on a higher timeframe via `request.security`. The steps are: 1. **Directional Movement (DM) Components:** * `Up_Move` = `high – high ` * `Down_Move` = `low – low` * `Plus_DM` = `Up_Move` if (`Up_Move > Down_Move` AND `Up_Move > 0`), else `0` * `Minus_DM` = `Down_Move` if (`Down_Move > Up_Move` AND `Down_Move > 0`), else `0` 2. **True Range (TR) Components:** * `TR1` = `high – low` * `TR2` = `abs(high – close )` * `TR3` = `abs(low – close )` * `True_Range` = `max(TR1, TR2, TR3)` 3. **Smoothed Averages (RMA):** * `Sm_TR` = `ta.rma(True_Range, ADX_Length)` * `Sm_Plus` = `ta.rma(Plus_DM, ADX_Length)` * `Sm_Minus`= `ta.rma(Minus_DM, ADX_Length)` 4. **Compute DI%:** $$ Plus\_DI = \frac{Sm\_Plus}{Sm\_TR} \times 100,\quad Minus\_DI = \frac{Sm\_Minus}{Sm\_TR} \times 100 $$ 5. **DX and ADX:** $$ DX = \frac{|Plus\_DI - Minus\_DI|}{Plus\_DI + Minus\_DI} \times 100,\quad ADX = ta.rma(DX, ADX_Length) $$ These values are referred to as `(plus_di, minus_di, adx_val)` for the current timeframe. --- ## 3. Higher Timeframe (HTF) Confirmation Function If **Use Higher Timeframe Confirmation** is enabled, the script calls a single helper (Pine) function `f_htf` with two parameters: the ADX length and the SMA length (both taken from the “base” or “scaled” values). Internally, `f_htf` simply reruns the manual DI/ADX logic (same as above) on the higher timeframe’s bar data, and also includes that timeframe’s closing price and its SMA for trend comparison. * **Request.Security Call:** ``` = request.security( syminfo.tickerid, higher_tf, f_htf(adx_length, sma_long_len), lookahead=barmerge.lookahead_off ) ``` * `lookahead=barmerge.lookahead_off` ensures that no HTF value “paints” early; you always see only confirmed HTF bars. * The returned tuple provides: 1. `ht_close` = HTF closing price 2. `ht_sma` = HTF SMA of length `sma_long_len` 3. `ht_pdi` = HTF +DI percentage 4. `ht_mdi` = HTF –DI percentage 5. `ht_adx` = HTF ADX value --- ## 4. Trend & Reversal Filters (Current & HTF) ### A. Current-Timeframe Trend Filter 1. **Uptrend\_Basic (Current TF)** $$ (plus\_di > minus\_di)\;\land\;(adx\_val > ADX\_Threshold)\;\land\;(close > SMA\_Close\_Long) $$ 2. **Downtrend\_Basic (Current TF)** $$ (minus\_di > plus\_di)\;\land\;(adx\_val > ADX\_Threshold)\;\land\;(close < SMA\_Close\_Long) $$ 3. **Trend Confirmation by Bars:** * `Bars_Since_Below` = number of bars since `close <= SMA_Close_Long`. * `Bars_Since_Above` = number of bars since `close >= SMA_Close_Long`. * If `Uptrend_Basic == true` AND `Bars_Since_Below ≥ Trend_Confirmation_Bars` → mark `Uptrend_Confirm = true`. * If `Downtrend_Basic == true` AND `Bars_Since_Above ≥ Trend_Confirmation_Bars` → mark `Downtrend_Confirm = true`. ### B. Reversal Filters (Current TF) 1. **Bullish Reversal (`Rev_Bullish`):** * If `(RSI < RSI_Oversold AND close crosses above EMA_Value)` OR `(RSI < RSI_Oversold AND close crosses above SMA_Close_Short1)` → then `Rev_Bullish = true`. 2. **Bearish Reversal (`Rev_Bearish`):** * If `(RSI > RSI_Overbought AND close crosses below EMA_Value)` OR `(RSI > RSI_Overbought AND close crosses below SMA_Close_Short1)` → then `Rev_Bearish = true`. ### C. Higher-Timeframe Trend Filter (HTF) 1. **HTF Uptrend (`HT_Uptrend`):** $$ (ht\_pdi > ht\_mdi)\;\land\;(ht\_adx > ADX\_Threshold)\;\land\;(ht\_close > ht\_sma) $$ 2. **HTF Downtrend (`HT_Downtrend`):** $$ (ht\_mdi > ht\_pdi)\;\land\;(ht\_adx > ADX\_Threshold)\;\land\;(ht\_close < ht\_sma) $$ 3. **Combine Current & HTF:** * If **Use\_HTF\_Confirmation == true**, then: * `Uptrend_Confirm := Uptrend_Confirm AND HT_Uptrend` * `Downtrend_Confirm := Downtrend_Confirm AND HT_Downtrend` * Otherwise, just use the current timeframe’s `Uptrend_Confirm` and `Downtrend_Confirm`. 4. **Define `CurrentTrend` (Integer):** * `CurrentTrend = +1` if `Uptrend_Confirm == true`. * `CurrentTrend = –1` if `Downtrend_Confirm == true`. * Otherwise, `CurrentTrend = 0`. 5. **Reset “One Trade Per Trend”:** * There is a persistent variable `LastTradeTrend`. * Every time `CurrentTrend` flips (i.e., `CurrentTrend != CurrentTrend `), the code sets `LastTradeTrend := 0`. * That allows one new entry once the detected trend has changed. --- ## 5. One‐Time “Cooldown” Logic * **`LastSignalBar`** * A persistent integer (initially undefined). * After each confirmed long or short entry, `LastSignalBar` is set to the bar index where that signal fired. * **`Bars_Since_Signal`** * If `LastSignalBar` is undefined, treat as a very large number (so that initial signals are always allowed). * Otherwise, `Bars_Since_Signal = bar_index – LastSignalBar`. * **Cooldown Check:** * A new long (or short) can only be generated if `(Bars_Since_Signal > Signal_Cooldown)`. * This prevents multiple signals in rapid succession. --- ## 6. Entry Conditions (No Repaint) All of the conditions below are calculated “intrabar,” but the script only actually registers a **signal** on **bar close** (`barstate.isconfirmed`) so that signals never repaint. ### A. Trend‐Based “Raw” Conditions 1. **Trend\_Long\_Raw:** $$ (AI\_Score > AI\_Score\_Threshold)\;\land\;Uptrend\_Confirm\;\land\;High\_Volatility\;\land\;(Price\_Change > 0) $$ 2. **Trend\_Short\_Raw:** $$ (AI\_Score < -AI\_Score\_Threshold)\;\land\;Downtrend\_Confirm\;\land\;High\_Volatility\;\land\;(Price\_Change < 0) $$ ### B. Reversal “Raw” Conditions 1. **Rev\_Long\_Raw:** $$ Rev\_Bullish\;\land\;(CurrentTrend \neq +1) $$ 2. **Rev\_Short\_Raw:** $$ Rev\_Bearish\;\land\;(CurrentTrend \neq -1) $$ ### C. Combine Raw Signals * `Raw_Long = Trend_Long_Raw OR Rev_Long_Raw`. * `Raw_Short = Trend_Short_Raw OR Rev_Short_Raw`. ### D. Confirmed Long/Short Signal Flags On each new bar **close** (`barstate.isconfirmed == true`): * **Long\_Signal\_Confirmed** can fire if: 1. `Raw_Long == true` 2. `LastTradeTrend != +1` (we haven’t already taken a long in this same trend) 3. `Bars_Since_Signal > Signal_Cooldown` If all three hold, then on this bar close the code sets: * `Long_Signal = true` * `LastTradeTrend := +1` * `LastSignalBar := bar_index` Otherwise, `Long_Signal := false` on this bar. * **Short\_Signal\_Confirmed** works the same way but with `Raw_Short`, `LastTradeTrend != -1`, etc. If triggered, it sets `Short_Signal = true`, `LastTradeTrend := -1`, and `LastSignalBar := bar_index`. Otherwise `Short_Signal := false`. * **Important:** If the bar is still forming (`else` branch of `barstate.isconfirmed`), then both `Long_Signal` and `Short_Signal` are forced to `false`. This guarantees that no shape or alert appears until the bar actually closes. --- ## 7. Plotting Entry/Exit Shapes 1. **Trend Long Signal (Triangle Up)** * Condition: `Long_Signal == true` **AND** `Trend_Long_Raw == true`. * Appearance: A small, semi-transparent lime green triangle drawn **below** the bar. 2. **Trend Short Signal (Triangle Down)** * Condition: `Short_Signal == true` **AND** `Trend_Short_Raw == true`. * Appearance: A small, semi-transparent maroon triangle drawn **above** the bar. 3. **Reversal Long Signal (Circle)** * Condition: `Long_Signal == true` **AND** `Rev_Long_Raw == true`. * Appearance: A tiny, more transparent green circle drawn **below** the bar. 4. **Reversal Short Signal (Circle)** * Condition: `Short_Signal == true` **AND** `Rev_Short_Raw == true`. * Appearance: A tiny, more transparent red circle drawn **above** the bar. Since `Long_Signal` and `Short_Signal` only ever become true at bar close, these shapes are never repainted or removed once drawn. --- ## 8. Unified Alert Message * As soon as a new bar closes with either `Long_Signal` or `Short_Signal == true`, an alert message is sent: * If `Long_Signal`, then `alert_msg = "action=BUY"`. * If `Short_Signal`, then `alert_msg = "action=SELL"`. * If neither, `alert_msg = ""` (no alert). * The code calls `alert(alert_msg, freq=alert.freq_once_per_bar)` only if `barstate.isconfirmed` and `alert_msg` is non‐empty. This ensures exactly one alert per confirmed bar, no intrabar pops. --- ## 9. Dynamic TP/SL Logic (Minimal Implementation) Once a long or short position is “open,” the script tracks these variables: 1. **Persistent Flags and Prices** (all persist between bars until reset): * `InLong` (Boolean) * `InShort` (Boolean) * `Long_Max` (Float) * `Short_Min` (Float) * `Entry_Price` (Float) 2. **On Bar Close:** * If `Long_Signal == true` → * Set `InLong := true`, * `Entry_Price := close` of that bar, * `Long_Max := high ` (last bar’s high, so that we’re not using “future” data). * If `Short_Signal == true` → * Set `InShort := true`, * `Entry_Price := close`, * `Short_Min := low `. 3. **While `InLong == true`:** * Continuously update `Long_Max = max(Long_Max, current high)` on each bar (intrabar, but finalized each close). * Compute a dynamic SL: $$ SL_{Long} = Entry\_Price - (ATR \times SL\_ATR\_Multiplier). $$ * If **current trend** flips to non-uptrend (`CurrentTrend != +1`), mark `ExitLong = true`. * Then the routine plots `TP_Long = Long_Max` as a cross (“X”) at that level. * Set `InLong := false` so that no further changes to `Long_Max` or `Entry_Price` happen on future bars. 4. **While `InShort == true`:** * Continuously update `Short_Min = min(Short_Min, current low)`. * Compute a dynamic SL: $$ SL_{Short} = Entry\_Price + (ATR \times SL\_ATR\_Multiplier). $$ * If trend flips to non-downtrend (`CurrentTrend != –1`), mark `ExitShort = true`. * Then the routine plots `TP_Short = Short_Min`. * Set `InShort := false` to freeze those values. 5. **Plotting TP/SL if “Show Debug” is On:** * **TP Shapes:** * When `ExitLong == true`, plot a solid lime “X” at `TP_Long` (highest high). * When `ExitShort == true`, plot a solid maroon “X” at `TP_Short` (lowest low). * **SL Lines:** * If still `InLong`, draw a thin red line at `SL_Long` on each bar. * If still `InShort`, draw a thin green line at `SL_Short`. Thus, your charts visually show the highest‐high take-profit cross for longs, the lowest-low take-profit cross for shorts, and a continuously updating trailing SL until the trend flips. Because all of this is triggered on confirmed bars, nothing “jumps around” after the fact. --- ## 10. Debug‐Only Plot Lines (When Enabled) When **Show Debug Lines** = true, the indicator will also plot: 1. **ATR SMA (Orange):** * The simple moving average of ATR over `ATR_SMA_Length`. 2. **ATR Threshold (Yellow):** * `ATR_SMA × ATR_Multiplier` (the dynamically scaled threshold). 3. **+DI & –DI (Current TF):** * +DI plotted as a green line, –DI plotted as a red line (opacity \~70%). 4. **ADX (Current TF, Blue):** * A blue line for the present timeframe’s ADX. 5. **ADX Threshold (Gray):** * A horizontal gray line showing `ADX_Threshold`. 6. **+DI & –DI (HTF, Darker Colors):** * If HTF confirmation is on, “HTF +DI” is a greener but more transparent line; “HTF –DI” is a redder but more transparent line. 7. **ADX (HTF, Blue but Transparent):** * HTF ADX plotted in blue (high transparency). 8. **HTF SMA (Orange, Transparent):** * The higher timeframe’s SMA (same length as `SMA_Long_Length`), drawn in fainter orange. 9. **Volatility Zone Fill (Yellow Tinted Area):** * Fills the area between `ATR_SMA` and `ATR_SMA × ATR_Multiplier`. * Indicates “normal” versus “high‐volatility” regimes. These debug lines are purely visual aids. Disable them if you want a cleaner chart. --- ## 11. Putting It All Together — Step-By-Step Flow 1. **Read Inputs** (RSI lengths, EMA length, ATR settings, etc.). 2. **Optionally Halve All Lengths** if “Scalping Mode” is checked. 3. **Calculate Current TF Indicators:** * RSI, ATR, ATR\_SMA, EMA, price change, various SMAs, DI/ADX. 4. **Compute “AI Score”** (weighted sum of RSI and EMA signals). 5. **Compute Dynamic ATR Multiplier** and decide if “High Volatility” is true. 6. **Compute Raw Trend/Reversal Conditions** on the current timeframe (without triggering yet). 7. **Fetch HTF Values** in one `request.security` call (SMAs, DI/ADX). 8. **Combine Current & HTF Trend Filters** to confirm `Uptrend_Confirm` or `Downtrend_Confirm`. 9. **Check Reversal Conditions** (price crossing EMA or SMA short, in overbought/oversold zones). 10. **Enforce “One Trade Per Trend”** (clear `LastTradeTrend` whenever `CurrentTrend` flips). 11. **Enforce Cooldown** (must wait at least `Signal_Cooldown` bars since the prior signal). 12. **On Bar Close:** * If `Raw_Long` AND not already in a long trend AND cooldown met, then fire `Long_Signal`. * Else if `Raw_Short` AND not already in a short trend AND cooldown met, then fire `Short_Signal`. * Otherwise, no new signal on this bar. 13. **Plot Long/Short Entry Shapes** according to whether it was a Trend signal or a Reversal signal. 14. **Send Alert** (“action=BUY” or “action=SELL”) exactly once per confirmed bar. 15. **If New Long/Short Signal, Set `InLong`/`InShort`, Record Entry Price, Initialize `Long_Max`/`Short_Min`.** 16. **While `InLong` is true:** Update `Long_Max = max(previous Long_Max, current high)`. Compute `SL_Long`. If the current trend flips (no longer uptrend), set `ExitLong = true`, plot a “TP X,” and close the position logic. 17. **While `InShort` is true:** Similarly update `Short_Min`, compute `SL_Short`, and if trend flips, set `ExitShort = true`, plot a “TP X,” and close the position logic. 18. **Optionally Display Debug Lines** (ATR SMA, ATR threshold, DI/ADX, HTF DI/ADX, etc.). --- ## 12. How to Use in TradingView Community When you publish this indicator to the TradingView community—choosing “Protected” or “Invite-only” visibility—you can paste the above description into the “Description” field. Users will see exactly what each input does, how signals are generated, and what the various plotted lines represent, **without ever seeing the script source**. In this way, the code itself remains hidden but the logic is fully documented. 1. **Go to “Create New Indicator”** on TradingView. 2. **Paste Your Pine Code** (the full indicator script) in the Pine editor and save it. 3. **Set Visibility = Protected** (or Invite-only). 4. **In the “Description” Text Box, paste the entirety of this document** (steps 1–11). 5. **Click “Publish Script.”** Users who view your indicator will see its name (“AI Strat Adaptive v3 (NoRepaint)”), a list of all inputs (with default values), and the detailed English description above. They can then load it on any chart, adjust inputs, and see the plotted signals, TP/SL lines, and optional debug overlays—without accessing the underlying Pine code. --- ### Summary of Key Points * **RSI, EMA, ATR, DI/ADX, and “AI Score”** work together to define “trend vs. reversal.” * **Dynamic volatility filter** uses ATR and ATR\_SMA to adapt the weighting of RSI vs. EMA and decide whether “volatility is high enough” to permit a trend trade. * **One trade per detected trend** and a **cooldown period** prevent over‐trading. * **Higher timeframe confirmation** (optional) further filters out noise. * **No-repaint logic**: * All signals only appear at bar close (`barstate.isconfirmed`). * HTF values are fetched with `lookahead=barmerge.lookahead_off`. * **Entry shapes** (triangles and circles) clearly mark trend vs. reversal entries. * **Dynamic TP/SL**: highest‐high (or lowest‐low) since entry is used as TP, ATR×multiplier as SL. * **Debug mode** (optional) shows every intermediate line for full transparency. Use this description verbatim (or adapt it slightly for your personal style) when publishing. That way, your community sees exactly how each component works—inputs, functions, filters—while the Pine source code remains private.
Indicatore Pine Script®
di Algo_Systems
RSI OB/OS THEDU 999//@version=6 indicator("RSI OB/OS THEDU 999", overlay=false) //#region Inputs Section // ================================ // Inputs Section // ================================ // Time Settings Inputs startTime = input.time(timestamp("1 Jan 1900"), "Start Time", group="Time Settings") endTime = input.time(timestamp("1 Jan 2099"), "End Time", group="Time Settings") isTimeWindow = time >= startTime and time <= endTime // Table Settings Inputs showTable = input.bool(true, "Show Table", group="Table Settings") fontSize = input.string("Auto", "Font Size", options= , group="Table Settings") // Strategy Settings Inputs tradeDirection = input.string("Long", "Trade Direction", options= , group="Strategy Settings") entryStrategy = input.string("Revert Cross", "Entry Strategy", options= , group="Strategy Settings") barLookback = input.int(10, "Bar Lookback", minval=1, maxval=20, group="Strategy Settings") // RSI Settings Inputs rsiPeriod = input.int(14, "RSI Period", minval=1, group="RSI Settings") overboughtLevel = input.int(70, "Overbought Level", group="RSI Settings") oversoldLevel = input.int(30, "Oversold Level", group="RSI Settings") //#endregion //#region Font Size Mapping // ================================ // Font Size Mapping // ================================ fontSizeMap = fontSize == "Auto" ? size.auto : fontSize == "Small" ? size.small : fontSize == "Normal" ? size.normal : fontSize == "Large" ? size.large : na //#endregion //#region RSI Calculation // ================================ // RSI Calculation // ================================ rsiValue = ta.rsi(close, rsiPeriod) plot(rsiValue, "RSI", color=color.yellow) hline(overboughtLevel, "OB Level", color=color.gray) hline(oversoldLevel, "OS Level", color=color.gray) //#endregion //#region Entry Conditions // ================================ // Entry Conditions // ================================ buyCondition = entryStrategy == "Revert Cross" ? ta.crossover(rsiValue, oversoldLevel) : ta.crossunder(rsiValue, oversoldLevel) sellCondition = entryStrategy == "Revert Cross" ? ta.crossunder(rsiValue, overboughtLevel) : ta.crossover(rsiValue, overboughtLevel) // Plotting buy/sell signals plotshape(buyCondition ? oversoldLevel : na, title="Buy", location=location.absolute, color=color.green, style=shape.labelup, text="BUY", textcolor=color.white, size=size.small) plotshape(sellCondition ? overboughtLevel : na, title="Sell", location=location.absolute, color=color.red, style=shape.labeldown, text="SELL", textcolor=color.white, size=size.small) // Plotting buy/sell signals on the chart plotshape(buyCondition, title="Buy", location=location.belowbar, color=color.green, style=shape.triangleup, text="BUY", textcolor=color.white, size=size.small , force_overlay = true) plotshape(sellCondition, title="Sell", location=location.abovebar, color=color.red, style=shape.triangledown, text="SELL", textcolor=color.white, size=size.small, force_overlay = true) //#endregion //#region Returns Matrix Calculation // ================================ // Returns Matrix Calculation // ================================ var returnsMatrix = matrix.new(0, barLookback, 0.0) if (tradeDirection == "Long" ? buyCondition : sellCondition ) and isTimeWindow newRow = array.new_float(barLookback) for i = 0 to barLookback - 1 entryPrice = close futurePrice = close ret = (futurePrice - entryPrice) / entryPrice * 100 array.set(newRow, i, math.round(ret, 4)) matrix.add_row(returnsMatrix, matrix.rows(returnsMatrix), newRow) //#endregion //#region Display Table // ================================ // Display Table // ================================ var table statsTable = na if barstate.islastconfirmedhistory and showTable statsTable := table.new(position.top_right, barLookback + 1, 4, border_width=1, force_overlay=true) // Table Headers table.cell(statsTable, 0, 1, "Win Rate %", bgcolor=color.rgb(45, 45, 48), text_color=color.white, text_size=fontSizeMap) table.cell(statsTable, 0, 2, "Mean Return %", bgcolor=color.rgb(45, 45, 48), text_color=color.white, text_size=fontSizeMap) table.cell(statsTable, 0, 3, "Median Return %", bgcolor=color.rgb(45, 45, 48), text_color=color.white, text_size=fontSizeMap) // Row Headers for i = 1 to barLookback table.cell(statsTable, i, 0, str.format("{0} Bar Return", i), bgcolor=color.rgb(45, 45, 48), text_color=color.white, text_size=fontSizeMap) // Calculate Statistics meanReturns = array.new_float() medianReturns = array.new_float() for col = 0 to matrix.columns(returnsMatrix) - 1 colData = matrix.col(returnsMatrix, col) array.push(meanReturns, array.avg(colData)) array.push(medianReturns, array.median(colData)) // Populate Table for col = 0 to matrix.columns(returnsMatrix) - 1 colData = matrix.col(returnsMatrix, col) positiveCount = 0 for val in colData if val > 0 positiveCount += 1 winRate = positiveCount / array.size(colData) meanRet = array.avg(colData) medianRet = array.median(colData) // Color Logic winRateColor = winRate == 0.5 ? color.rgb(58, 58, 60) : (winRate > 0.5 ? color.rgb(76, 175, 80) : color.rgb(244, 67, 54)) meanBullCol = color.from_gradient(meanRet, 0, array.max(meanReturns), color.rgb(76, 175, 80), color.rgb(0, 128, 0)) meanBearCol = color.from_gradient(meanRet, array.min(meanReturns), 0, color.rgb(255, 0, 0), color.rgb(255, 99, 71)) medianBullCol = color.from_gradient(medianRet, 0, array.max(medianReturns), color.rgb(76, 175, 80), color.rgb(0, 128, 0)) medianBearCol = color.from_gradient(medianRet, array.min(medianReturns), 0, color.rgb(255, 0, 0), color.rgb(255, 99, 71)) table.cell(statsTable, col + 1, 1, str.format("{0,number,#.##%}", winRate), text_color=color.white, bgcolor=winRateColor, text_size=fontSizeMap) table.cell(statsTable, col + 1, 2, str.format("{0,number,#.###}%", meanRet), text_color=color.white, bgcolor=meanRet > 0 ? meanBullCol : meanBearCol, text_size=fontSizeMap) table.cell(statsTable, col + 1, 3, str.format("{0,number,#.###}%", medianRet), text_color=color.white, bgcolor=medianRet > 0 ? medianBullCol : medianBearCol, text_size=fontSizeMap) //#endregion // Background color for OB/OS regions bgcolor(rsiValue >= overboughtLevel ? color.new(color.red, 90) : rsiValue <= oversoldLevel ? color.new(color.green, 90) : na)
Indicatore Pine Script®
di thedu2706