Empiece

Buscar en scripts para "黄金近20年走势"

Dashboard — Vol & PriceDashboard for traders Indicator Description 1. Prev Day High What it shows: the previous trading day's high. Why it shows: a resistance level. Many traders watch to see if the price will hold above or below this level. A breakout can signal buying strength. 2. Prev Day Low What it shows: the previous day's low. Why it shows: a support level. If the price breaks downwards, it signals weakness and a possible continuation of the decline. 3. Today What it shows: The difference between the current price and yesterday's close (in absolute values ​​and as a percentage). Color: green for an increase, red for a decrease. Why it shows: immediately shows how strong a gap or movement is today relative to yesterday. This is an indicator of current momentum. 4. ADR, % (Average Daily Range) What it shows: Average daily range (High – Low), expressed as a percentage of the closing price, for the selected period (default 7 days). Why it's useful: To understand the "normal" volatility of an instrument. For example, if the ADR is 3%, then a 1% move is small, while a 6% move is very large. 5. ATR (Average True Range) What it shows: Average fluctuation range (including gaps), in absolute points, for the specified period (default 7 days). Why it's useful: A classic volatility indicator. Useful for setting stops, calculating position sizes, and identifying "noise" movements. 6. ATR (Today), % What it shows: How much the current movement today (from yesterday's close to the current price) represents in % of the average ATR. Why it shows: Shows whether the instrument has "played out" its average range. If the value is already >100%, there is a high probability that the movement will begin to slow. 7. Vol (Today) What it shows: Current trading volume for the day (in millions/billions). Comparison with yesterday as a percentage (for example: 77.32M (-52.78%)). Color: green if the volume is higher than yesterday; red if lower. Why it shows:Quickly shows whether the market is active today. Volume = fuel for price movement. 8. Avg Vol (20d) What it shows: Average daily volume over the last 20 trading days. Why it's useful:"normal" activity level. It's a convenient backdrop for assessing today's turnover. 9. Rel. Vol (Today), % (Relative Volume) What it shows: Deviation of the current volume from the average (20 days). Formula: `(today / average - 1)` * 100`. +30% = volume 30% above average, -40% = 40% below average. Color: green for +, red for –. Why it's useful:A key indicator for a trader. If RelVol > 100% (green), the market is "charged," and the movement is more significant. If low, activity is weak and movements are less reliable. 10. Normalized RS (Relative Strength) What it shows: the relative strength of a stock to a selected benchmark (e.g., SPY), normalized by the period (default 7 days). 100 = same result as the market. > 100 = the stock is stronger than the index. <100 = weaker than the index. Why it's needed: filtering ideas. Strong stocks rise faster when the market rises, weak stocks fall more sharply. This helps trade in the direction of the trend and select the best candidates. In summary: Prev High / Low — key support and resistance levels. Today — an instant understanding of the current momentum. ADR and ATR — volatility and potential movement. ATR (Today) — how much the instrument has already "run." Vol + Rel.Vol — activity and confirmation of the movement's strength. RS — selecting strong/weak leaders against the market.
Indicador Pine Script®
por finrangecom
MPO4 Lines – Modal Engine█ OVERVIEW MPO4 Lines – Modal Engine is an advanced multi-line modal oscillator for TradingView, designed to detect momentum shifts, trend strength, and reversal points through candle-based pressure analysis with multiple fast lines and a reference slow line. It features divergence detection on Fast Line A, overbought/oversold return signals, dynamic coloring modes, and layered gradient visualizations for enhanced clarity and decision-making. █ CONCEPT The indicator is built upon the Market Pressure Oscillator (MPO) and serves as its expanded evolution, aimed at enabling broader market analysis through multiple lines with varying parameters. It calculates modal pressure using candle body size and direction, weighted against average body size over a lookback period, then normalized and smoothed via EMA. It generates four distinct oscillator lines: a heavily smoothed Slow Line (trend reference), two Fast Lines (A & B) for momentum and support/resistance, and an optional Line 4 for additional confirmation. Divergence is calculated solely on Fast Line A, with visual gradients between lines and bands for intuitive interpretation. █ WHY USE IT? - Multi-Layer Momentum: Combines slow trend reference with dual fast lines for precise entry/exit timing. - Divergence Precision: Bullish/bearish divergences on Fast Line A with labeled confirmation. - OB/OS Return Signals: Clear buy/sell markers when Fast Line A exits oversold/overbought zones. - Dynamic Visuals: Gradient fills, line-to-line shading, and band gradients for instant market state recognition. - Flexible Coloring: Slow Line color by direction or zero-position; fast lines by sign. - Full Customization: Independent lengths, smoothing, visibility, and transparency — by adjusting the lengths of different lines, you can tailor results for various strategies; for example, enabling Line 4 and tuning its length allows trading based on crossovers between different lines. █ HOW IT WORKS? - Candle Pressure Calculation: Body = math.abs(close - open); avgBody = ta.sma(body, len). Direction = +1 (bull), –1 (bear), 0 (neutral). Weight = body / avgBody. Contribution = direction × weight. - Rolling Sum & Normalization: Sums contributions over lookback, normalizes to ±100 scale (÷ (len × 2) × 100). Smoothing: Applies primary EMA (smoothLen), with extra EMA on Slow Line for stability. Line Structure: - Slow Line = calcCPO(len1=20, smoothLen1=5) → extra EMA (5) - Fast Line A = calcCPO(len2=6, smoothLen2=7) - Fast Line B = calcCPO(len3=6, smoothLen3=10) - Line 4 = calcCPO(len4=14, smoothLen4=1) Divergence Detection: Uses ta.pivothigh/low on price and Fast Line A (pivotLength left/right). Bullish: lower price low + higher osc low. Bearish: higher price high + lower osc high. Valid within 5–60 bar window. Signals: - Buy: Fast Line A crosses above oversold (–30) - Sell: Fast Line A crosses below overbought (+30) - Slow Line color flip (direction or zero-cross) - Divergence labels ("Bull" / "Bear") - Band Coloring as Momentum Signal: When Fast Line A ≤ Fast Line B → Overbought band turns red (bearish pressure building) When Fast Line A > Fast Line B → Oversold band turns green (bullish pressure building) This dynamic coloring serves as visual confirmation of momentum shift following fast line crossovers Visualization: - Gradients: Fast B → Zero (multi-layer fade), Fast A ↔ B fill, OB/OS bands - Dynamic colors: Green/red based on sign or trend - Zero line + dashed OB/OS thresholds Alerts: Trigger on OB/OS returns, Slow Line changes, and divergences. █ SETTINGS AND CUSTOMIZATION - Line Visibility: Toggle Slow, Fast A, Fast B, Line 4 independently. Line Lengths: - Slow Line: Base (20), Primary EMA (5), Extra EMA (5) - Fast A: Lookback (6), EMA (7) - Fast B: Lookback (6), EMA (10) - Line 4: Lookback (14), EMA (1) - Slow Line Coloring Mode: “Direction” (trend-based) or “Position vs Zero”. - Bands & Thresholds: Overbought (+30), Oversold (–30), step 0.1. - Signals: Enable Fast A OB/OS return markers (default: on). - Divergence: Enable/disable, Pivot Length (default: 2, min 1). - Colors & Appearance: Full control over bullish/bearish hues for all lines, zero, bands, divergence, and text. Gradients & Transparency: - Fast B → Zero: 75 (default) - Fast A ↔ B fill: 50 - Band gradients: 40 - Toggle each gradient independently █ USAGE EXAMPLES The indicator allows users to configure various strategies manually, though no built-in alerts exist for them. Entry signals can include color of fast lines, crossovers between different lines, alignment of colors across lines, or consistency in direction. - Trend Confirmation: Slow Line above zero + green = bullish bias; below + red = bearish. - Entry Timing: Buy on Fast A crossing above –30 (circle marker), especially if Slow Line is rising or near zero. - Reversal Setup: Bullish divergence (“Bull” label) + Fast A in oversold + green gradient band = high-probability long. - Scalping: Fast A vs Fast B crossover in direction of Slow Line trend. - Noise Reduction: Increase extraSmoothLen on Slow Line █ USER NOTES - Best combined with volume, support/resistance, or trend channels. - Adjust lookback and smoothing to asset volatility. - Divergence delay = pivotLength; plan entries accordingly.
Indicador Pine Script®
por Uncle_the_shooter
PineConnectorLibrary "PineConnector" This library is a comprehensive alert webhook text generator for PineConnector. It contains every possible alert syntax variation from the documentation, along with some debugging functions. To use it, just import the library (eg. "import ZenAndTheArtOfTrading/PineConnector/1 as pc") and use pc.buy(licenseID) to send an alert off to PineConnector - assuming all your webhooks etc are set up correctly. View the PineConnector documentation for more information on how to send the commands you're looking to send (all of this library's function names match the documentation). all()   Usage: pc.buy(pc_id, freq=pc.all())   Returns: "all" once_per_bar()   Usage: pc.buy(pc_id, freq=pc.once_per_bar())   Returns: "once_per_bar" once_per_bar_close()   Usage: pc.buy(pc_id, freq=pc.once_per_bar_close())   Returns: "once_per_bar_close" na0(value)   Checks if given value is either 'na' or 0. Useful for streamlining scripts with float user setting inputs which default values to 0 since na is unavailable as a user input default.   Parameters:      value (float) : The value to check   Returns: True if the given value is 0 or na getDecimals()   Calculates how many decimals are on the quote price of the current market.   Returns: The current decimal places on the market quote price truncate(number, decimals)   Truncates the given number. Required params: mumber.   Parameters:      number (float) : Number to truncate      decimals (int) : Decimal places to cut down to   Returns: The input number, but as a string truncated to X decimals getPipSize(multiplier)   Calculates the pip size of the current market.   Parameters:      multiplier (int) : The mintick point multiplier (1 by default, 10 for FX/Crypto/CFD but can be used to override when certain markets require)   Returns: The pip size for the current market toWhole(number)   Converts pips into whole numbers. Required params: number.   Parameters:      number (float) : The pip number to convert into a whole number   Returns: The converted number toPips(number)   Converts whole numbers back into pips. Required params: number.   Parameters:      number (float) : The whole number to convert into pips   Returns: The converted number debug(txt, tooltip, displayLabel)   Prints to console and generates a debug label with the given text. Required params: txt.   Parameters:      txt (string) : Text to display      tooltip (string) : Tooltip to display (optional)      displayLabel (bool) : Turns on/off chart label (default: off)   Returns: Nothing order(licenseID, command, symbol, parameters, accfilter, comment, secret, freq, debug)   Generates an alert string. Required params: licenseID, command.   Parameters:      licenseID (string) : Your PC license ID      command (string) : Command to send      symbol (string) : The symbol to trigger this order on      parameters (string) : Other optional parameters to include      accfilter (float) : Optional minimum account balance filter      comment (string) : Optional comment (maximum 20 characters)      secret (string) : Optional secret key (must be enabled in dashboard)      freq (string) : Alert frequency. Default = "all", options = "once_per_bar", "once_per_bar_close" and "none"      debug (bool) : Turns on/off debug label   Returns: An alert string with valid PC syntax based on supplied parameters market_order(licenseID, buy, risk, sl, tp, betrigger, beoffset, spread, trailtrig, traildist, trailstep, atrtimeframe, atrperiod, atrmultiplier, atrshift, atrtrigger, symbol, accfilter, comment, secret, freq, debug)   Generates a market entry alert with relevant syntax commands. Required params: licenseID, buy, risk.   Parameters:      licenseID (string) : Your PC license ID      buy (bool) : true=buy/long, false=sell/short      risk (float) : Risk quantity (according to EA settings)      sl (float) : Stop loss distance in pips or price      tp (float) : Take profit distance in pips or price      betrigger (float) : Breakeven will be activated after the position gains this number of pips      beoffset (float) : Offset from entry price. This is the amount of pips you'd like to protect      spread (float) : Enter the position only if the spread is equal or less than the specified value in pips      trailtrig (float) : Trailing stop-loss will be activated after a trade gains this number of pips      traildist (float) : Distance of the trailing stop-loss from current price      trailstep (float) : Moves trailing stop-loss once price moves to favourable by a specified number of pips      atrtimeframe (int) : ATR Trailing Stop timeframe, only updates once per bar close. Options: 1, 5, 15, 30, 60, 240, 1440      atrperiod (int) : ATR averaging period      atrmultiplier (float) : Multiple of ATR to utilise in the new SL computation, default = 1      atrshift (int) : Relative shift of price information, 0 uses latest candle, 1 uses second last, etc. Default = 0      atrtrigger (int) : Activate the trigger of ATR Trailing after market moves favourably by a number of pips. Default = 0 (instant)      symbol (string) : The symbol to trigger this order on (defaults to current symbol)      accfilter (float) : Optional minimum account balance filter      comment (string) : Optional comment (maximum 20 characters)      secret (string) : Optional secret key (must be enabled in dashboard)      freq (string) : Alert frequency. Default = "all", options = "once_per_bar", "once_per_bar_close" and "none"      debug (bool) : Turns on/off debug label   Returns: A market order alert string with valid PC syntax based on supplied parameters buy(licenseID, risk, sl, tp, betrigger, beoffset, spread, trailtrig, traildist, trailstep, atrtimeframe, atrperiod, atrmultiplier, atrshift, atrtrigger, symbol, accfilter, comment, secret, freq, debug)   Generates a market buy alert with relevant syntax commands. Required params: licenseID, risk.   Parameters:      licenseID (string) : Your PC license ID      risk (float) : Risk quantity (according to EA settings)      sl (float) : Stop loss distance in pips or price      tp (float) : Take profit distance in pips or price      betrigger (float) : Breakeven will be activated after the position gains this number of pips      beoffset (float) : Offset from entry price. This is the amount of pips you'd like to protect      spread (float) : Enter the position only if the spread is equal or less than the specified value in pips      trailtrig (float) : Trailing stop-loss will be activated after a trade gains this number of pips      traildist (float) : Distance of the trailing stop-loss from current price      trailstep (float) : Moves trailing stop-loss once price moves to favourable by a specified number of pips      atrtimeframe (int) : ATR Trailing Stop timeframe, only updates once per bar close. Options: 1, 5, 15, 30, 60, 240, 1440      atrperiod (int) : ATR averaging period      atrmultiplier (float) : Multiple of ATR to utilise in the new SL computation, default = 1      atrshift (int) : Relative shift of price information, 0 uses latest candle, 1 uses second last, etc. Default = 0      atrtrigger (int) : Activate the trigger of ATR Trailing after market moves favourably by a number of pips. Default = 0 (instant)      symbol (string) : The symbol to trigger this order on (defaults to current symbol)      accfilter (float) : Optional minimum account balance filter      comment (string) : Optional comment (maximum 20 characters)      secret (string) : Optional secret key (must be enabled in dashboard)      freq (string) : Alert frequency. Default = "all", options = "once_per_bar", "once_per_bar_close" and "none"      debug (bool) : Turns on/off debug label   Returns: A market order alert string with valid PC syntax based on supplied parameters sell(licenseID, risk, sl, tp, betrigger, beoffset, spread, trailtrig, traildist, trailstep, atrtimeframe, atrperiod, atrmultiplier, atrshift, atrtrigger, symbol, accfilter, comment, secret, freq, debug)   Generates a market sell alert with relevant syntax commands. Required params: licenseID, risk.   Parameters:      licenseID (string) : Your PC license ID      risk (float) : Risk quantity (according to EA settings)      sl (float) : Stop loss distance in pips or price      tp (float) : Take profit distance in pips or price      betrigger (float) : Breakeven will be activated after the position gains this number of pips      beoffset (float) : Offset from entry price. This is the amount of pips you'd like to protect      spread (float) : Enter the position only if the spread is equal or less than the specified value in pips      trailtrig (float) : Trailing stop-loss will be activated after a trade gains this number of pips      traildist (float) : Distance of the trailing stop-loss from current price      trailstep (float) : Moves trailing stop-loss once price moves to favourable by a specified number of pips      atrtimeframe (int) : ATR Trailing Stop timeframe, only updates once per bar close. Options: 1, 5, 15, 30, 60, 240, 1440      atrperiod (int) : ATR averaging period      atrmultiplier (float) : Multiple of ATR to utilise in the new SL computation, default = 1      atrshift (int) : Relative shift of price information, 0 uses latest candle, 1 uses second last, etc. Default = 0      atrtrigger (int) : Activate the trigger of ATR Trailing after market moves favourably by a number of pips. Default = 0 (instant)      symbol (string) : The symbol to trigger this order on (defaults to current symbol)      accfilter (float) : Optional minimum account balance filter      comment (string) : Optional comment (maximum 20 characters)      secret (string) : Optional secret key (must be enabled in dashboard)      freq (string) : Alert frequency. Default = "all", options = "once_per_bar", "once_per_bar_close" and "none"      debug (bool) : Turns on/off debug label   Returns: A market order alert string with valid PC syntax based on supplied parameters closeall(licenseID, comment, secret, freq, debug)   Closes all open trades at market regardless of symbol. Required params: licenseID.   Parameters:      licenseID (string) : Your PC license ID      comment (string) : Optional comment to include (max 20 characters)      secret (string) : Optional secret key (must be enabled in dashboard)      freq (string) : Alert frequency. Default = "all", options = "once_per_bar", "once_per_bar_close" and "none"      debug (bool) : Turns on/off debug label   Returns: The required alert syntax as a string closealleaoff(licenseID, comment, secret, freq, debug)   Closes all open trades at market regardless of symbol, and turns the EA off. Required params: licenseID.   Parameters:      licenseID (string) : Your PC license ID      comment (string) : Optional comment to include (max 20 characters)      secret (string) : Optional secret key (must be enabled in dashboard)      freq (string) : Alert frequency. Default = "all", options = "once_per_bar", "once_per_bar_close" and "none"      debug (bool) : Turns on/off debug label   Returns: The required alert syntax as a string closelong(licenseID, symbol, comment, secret, freq, debug)   Closes all long trades at market for the given symbol. Required params: licenseID.   Parameters:      licenseID (string) : Your PC license ID      symbol (string) : Symbol to act on (defaults to current symbol)      comment (string) : Optional comment to include (max 20 characters)      secret (string) : Optional secret key (must be enabled in dashboard)      freq (string) : Alert frequency. Default = "all", options = "once_per_bar", "once_per_bar_close" and "none"      debug (bool) : Turns on/off debug label   Returns: The required alert syntax as a string closeshort(licenseID, symbol, comment, secret, freq, debug)   Closes all open short trades at market for the given symbol. Required params: licenseID.   Parameters:      licenseID (string) : Your PC license ID      symbol (string) : Symbol to act on (defaults to current symbol)      comment (string) : Optional comment to include (max 20 characters)      secret (string) : Optional secret key (must be enabled in dashboard)      freq (string) : Alert frequency. Default = "all", options = "once_per_bar", "once_per_bar_close" and "none"      debug (bool) : Turns on/off debug label   Returns: The required alert syntax as a string closelongshort(licenseID, symbol, comment, secret, freq, debug)   Closes all open trades at market for the given symbol. Required params: licenseID.   Parameters:      licenseID (string) : Your PC license ID      symbol (string) : Symbol to act on (defaults to current symbol)      comment (string) : Optional comment to include (max 20 characters)      secret (string) : Optional secret key (must be enabled in dashboard)      freq (string) : Alert frequency. Default = "all", options = "once_per_bar", "once_per_bar_close" and "none"      debug (bool) : Turns on/off debug label   Returns: The required alert syntax as a string closelongbuy(licenseID, risk, symbol, comment, secret, freq, debug)   Close all long positions and open a new long at market for the given symbol with given risk/contracts. Required params: licenseID.   Parameters:      licenseID (string) : Your PC license ID      risk (float) : Risk or contracts (according to EA settings)      symbol (string) : Symbol to act on (defaults to current symbol)      comment (string) : Optional comment to include (max 20 characters)      secret (string) : Optional secret key (must be enabled in dashboard)      freq (string) : Alert frequency. Default = "all", options = "once_per_bar", "once_per_bar_close" and "none"      debug (bool) : Turns on/off debug label   Returns: The required alert syntax as a string closeshortsell(licenseID, risk, symbol, comment, secret, freq, debug)   Close all short positions and open a new short at market for the given symbol with given risk/contracts. Required params: licenseID, risk.   Parameters:      licenseID (string) : Your PC license ID      risk (float) : Risk or contracts (according to EA settings)      symbol (string) : Symbol to act on (defaults to current symbol)      comment (string) : Optional comment to include (max 20 characters)      secret (string) : Optional secret key (must be enabled in dashboard)      freq (string) : Alert frequency. Default = "all", options = "once_per_bar", "once_per_bar_close" and "none"      debug (bool) : Turns on/off debug label   Returns: The required alert syntax as a string newsltplong(licenseID, sl, tp, symbol, accfilter, comment, secret, freq, debug)   Updates the stop loss and/or take profit of any open long trades on the given symbol with the given values. Required params: licenseID, sl and/or tp.   Parameters:      licenseID (string) : Your PC license ID      sl (float) : Stop loss pips or price (according to EA settings)      tp (float) : Take profit pips or price (according to EA settings)      symbol (string) : Symbol to act on (defaults to current symbol)      accfilter (float) : Optional minimum account balance filter      comment (string) : Optional comment to include (max 20 characters)      secret (string) : Optional secret key (must be enabled in dashboard)      freq (string) : Alert frequency. Default = "all", options = "once_per_bar", "once_per_bar_close" and "none"      debug (bool) : Turns on/off debug label   Returns: The required alert syntax as a string newsltpshort(licenseID, sl, tp, symbol, accfilter, comment, secret, freq, debug)   Updates the stop loss and/or take profit of any open short trades on the given symbol with the given values. Required params: licenseID, sl and/or tp.   Parameters:      licenseID (string) : Your PC license ID      sl (float) : Stop loss pips or price (according to EA settings)      tp (float) : Take profit pips or price (according to EA settings)      symbol (string) : Symbol to act on (defaults to current symbol)      accfilter (float) : Optional minimum account balance filter      comment (string) : Optional comment to include (max 20 characters)      secret (string) : Optional secret key (must be enabled in dashboard)      freq (string) : Alert frequency. Default = "all", options = "once_per_bar", "once_per_bar_close" and "none"      debug (bool) : Turns on/off debug label   Returns: The required alert syntax as a string closelongpct(licenseID, symbol, comment, secret, freq, debug)   Close a percentage of open long positions (according to EA settings). Required params: licenseID.   Parameters:      licenseID (string) : Your PC license ID      symbol (string) : Symbol to act on (defaults to current symbol)      comment (string) : Optional comment to include (max 20 characters)      secret (string) : Optional secret key (must be enabled in dashboard)      freq (string) : Alert frequency. Default = "all", options = "once_per_bar", "once_per_bar_close" and "none"      debug (bool) : Turns on/off debug label   Returns: The required alert syntax as a string closeshortpct(licenseID, symbol, comment, secret, freq, debug)   Close a percentage of open short positions (according to EA settings). Required params: licenseID.   Parameters:      licenseID (string) : Your PC license ID      symbol (string) : Symbol to act on (defaults to current symbol)      comment (string) : Optional comment to include (max 20 characters)      secret (string) : Optional secret key (must be enabled in dashboard)      freq (string) : Alert frequency. Default = "all", options = "once_per_bar", "once_per_bar_close" and "none"      debug (bool) : Turns on/off debug label   Returns: The required alert syntax as a string closelongvol(licenseID, risk, symbol, comment, secret, freq, debug)   Close all open long contracts on the current symbol until the given risk value is remaining. Required params: licenseID, risk.   Parameters:      licenseID (string) : Your PC license ID      risk (float) : The quantity to leave remaining      symbol (string) : Symbol to act on (defaults to current symbol)      comment (string) : Optional comment to include (max 20 characters)      secret (string) : Optional secret key (must be enabled in dashboard)      freq (string) : Alert frequency. Default = "all", options = "once_per_bar", "once_per_bar_close" and "none"      debug (bool) : Turns on/off debug label   Returns: The required alert syntax as a string closeshortvol(licenseID, risk, symbol, comment, secret, freq, debug)   Close all open short contracts on the current symbol until the given risk value is remaining. Required params: licenseID, risk.   Parameters:      licenseID (string) : Your PC license ID      risk (float) : The quantity to leave remaining      symbol (string) : Symbol to act on (defaults to current symbol)      comment (string) : Optional comment to include (max 20 characters)      secret (string) : Optional secret key (must be enabled in dashboard)      freq (string) : Alert frequency. Default = "all", options = "once_per_bar", "once_per_bar_close" and "none"      debug (bool) : Turns on/off debug label   Returns: The required alert syntax as a string limit_order(licenseID, buy, price, risk, sl, tp, betrigger, beoffset, spread, trailtrig, traildist, trailstep, atrtimeframe, atrperiod, atrmultiplier, atrshift, atrtrigger, symbol, accfilter, comment, secret, freq, debug)   Generates a limit order alert with relevant syntax commands. Required params: licenseID, buy, price, risk.   Parameters:      licenseID (string) : Your PC license ID      buy (bool) : true=buy/long, false=sell/short      price (float) : Price or pips to set limit order (according to EA settings)      risk (float) : Risk quantity (according to EA settings)      sl (float) : Stop loss distance in pips or price      tp (float) : Take profit distance in pips or price      betrigger (float) : Breakeven will be activated after the position gains this number of pips      beoffset (float) : Offset from entry price. This is the amount of pips you'd like to protect      spread (float) : Enter the position only if the spread is equal or less than the specified value in pips      trailtrig (float) : Trailing stop-loss will be activated after a trade gains this number of pips      traildist (float) : Distance of the trailing stop-loss from current price      trailstep (float) : Moves trailing stop-loss once price moves to favourable by a specified number of pips      atrtimeframe (int) : ATR Trailing Stop timeframe, only updates once per bar close. Options: 1, 5, 15, 30, 60, 240, 1440      atrperiod (int) : ATR averaging period      atrmultiplier (float) : Multiple of ATR to utilise in the new SL computation, default = 1      atrshift (int) : Relative shift of price information, 0 uses latest candle, 1 uses second last, etc. Default = 0      atrtrigger (int) : Activate the trigger of ATR Trailing after market moves favourably by a number of pips. Default = 0 (instant)      symbol (string) : The symbol to trigger this order on (defaults to current symbol)      accfilter (float) : Optional minimum account balance filter      comment (string) : Optional comment (maximum 20 characters)      secret (string) : Optional secret key (must be enabled in dashboard)      freq (string) : Alert frequency. Default = "all", options = "once_per_bar", "once_per_bar_close" and "none"      debug (bool) : Turns on/off debug label   Returns: A limit order alert string with valid PC syntax based on supplied parameters buylimit(licenseID, price, risk, sl, tp, betrigger, beoffset, spread, trailtrig, traildist, trailstep, atrtimeframe, atrperiod, atrmultiplier, atrshift, atrtrigger, symbol, accfilter, comment, secret, freq, debug)   Generates a buylimit order alert with relevant syntax commands. Required params: licenseID, price, risk.   Parameters:      licenseID (string) : Your PC license ID      price (float) : Price or pips to set limit order (according to EA settings)      risk (float) : Risk quantity (according to EA settings)      sl (float) : Stop loss distance in pips or price      tp (float) : Take profit distance in pips or price      betrigger (float) : Breakeven will be activated after the position gains this number of pips      beoffset (float) : Offset from entry price. This is the amount of pips you'd like to protect      spread (float) : Enter the position only if the spread is equal or less than the specified value in pips      trailtrig (float) : Trailing stop-loss will be activated after a trade gains this number of pips      traildist (float) : Distance of the trailing stop-loss from current price      trailstep (float) : Moves trailing stop-loss once price moves to favourable by a specified number of pips      atrtimeframe (int) : ATR Trailing Stop timeframe, only updates once per bar close. Options: 1, 5, 15, 30, 60, 240, 1440      atrperiod (int) : ATR averaging period      atrmultiplier (float) : Multiple of ATR to utilise in the new SL computation, default = 1      atrshift (int) : Relative shift of price information, 0 uses latest candle, 1 uses second last, etc. Default = 0      atrtrigger (int) : Activate the trigger of ATR Trailing after market moves favourably by a number of pips. Default = 0 (instant)      symbol (string) : The symbol to trigger this order on (defaults to current symbol)      accfilter (float) : Optional minimum account balance filter      comment (string) : Optional comment (maximum 20 characters)      secret (string) : Optional secret key (must be enabled in dashboard)      freq (string) : Alert frequency. Default = "all", options = "once_per_bar", "once_per_bar_close" and "none"      debug (bool) : Turns on/off debug label   Returns: A limit order alert string with valid PC syntax based on supplied parameters selllimit(licenseID, price, risk, sl, tp, betrigger, beoffset, spread, trailtrig, traildist, trailstep, atrtimeframe, atrperiod, atrmultiplier, atrshift, atrtrigger, symbol, accfilter, comment, secret, freq, debug)   Generates a selllimit order alert with relevant syntax commands. Required params: licenseID, price, risk.   Parameters:      licenseID (string) : Your PC license ID      price (float) : Price or pips to set limit order (according to EA settings)      risk (float) : Risk quantity (according to EA settings)      sl (float) : Stop loss distance in pips or price      tp (float) : Take profit distance in pips or price      betrigger (float) : Breakeven will be activated after the position gains this number of pips      beoffset (float) : Offset from entry price. This is the amount of pips you'd like to protect      spread (float) : Enter the position only if the spread is equal or less than the specified value in pips      trailtrig (float) : Trailing stop-loss will be activated after a trade gains this number of pips      traildist (float) : Distance of the trailing stop-loss from current price      trailstep (float) : Moves trailing stop-loss once price moves to favourable by a specified number of pips      atrtimeframe (int) : ATR Trailing Stop timeframe, only updates once per bar close. Options: 1, 5, 15, 30, 60, 240, 1440      atrperiod (int) : ATR averaging period      atrmultiplier (float) : Multiple of ATR to utilise in the new SL computation, default = 1      atrshift (int) : Relative shift of price information, 0 uses latest candle, 1 uses second last, etc. Default = 0      atrtrigger (int) : Activate the trigger of ATR Trailing after market moves favourably by a number of pips. Default = 0 (instant)      symbol (string) : The symbol to trigger this order on (defaults to current symbol)      accfilter (float) : Optional minimum account balance filter      comment (string) : Optional comment (maximum 20 characters)      secret (string) : Optional secret key (must be enabled in dashboard)      freq (string) : Alert frequency. Default = "all", options = "once_per_bar", "once_per_bar_close" and "none"      debug (bool) : Turns on/off debug label   Returns: A limit order alert string with valid PC syntax based on supplied parameters stop_order(licenseID, buy, price, risk, sl, tp, betrigger, beoffset, spread, trailtrig, traildist, trailstep, atrtimeframe, atrperiod, atrmultiplier, atrshift, atrtrigger, symbol, accfilter, comment, secret, freq, debug)   Generates a stop order alert with relevant syntax commands. Required params: licenseID, buy, price, risk.   Parameters:      licenseID (string) : Your PC license ID      buy (bool) : true=buy/long, false=sell/short      price (float) : Price or pips to set limit order (according to EA settings)      risk (float) : Risk quantity (according to EA settings)      sl (float) : Stop loss distance in pips or price      tp (float) : Take profit distance in pips or price      betrigger (float) : Breakeven will be activated after the position gains this number of pips      beoffset (float) : Offset from entry price. This is the amount of pips you'd like to protect      spread (float) : Enter the position only if the spread is equal or less than the specified value in pips      trailtrig (float) : Trailing stop-loss will be activated after a trade gains this number of pips      traildist (float) : Distance of the trailing stop-loss from current price      trailstep (float) : Moves trailing stop-loss once price moves to favourable by a specified number of pips      atrtimeframe (int) : ATR Trailing Stop timeframe, only updates once per bar close. Options: 1, 5, 15, 30, 60, 240, 1440      atrperiod (int) : ATR averaging period      atrmultiplier (float) : Multiple of ATR to utilise in the new SL computation, default = 1      atrshift (int) : Relative shift of price information, 0 uses latest candle, 1 uses second last, etc. Default = 0      atrtrigger (int) : Activate the trigger of ATR Trailing after market moves favourably by a number of pips. Default = 0 (instant)      symbol (string) : The symbol to trigger this order on (defaults to current symbol)      accfilter (float) : Optional minimum account balance filter      comment (string) : Optional comment (maximum 20 characters)      secret (string) : Optional secret key (must be enabled in dashboard)      freq (string) : Alert frequency. Default = "all", options = "once_per_bar", "once_per_bar_close" and "none"      debug (bool) : Turns on/off debug label   Returns: A stop order alert string with valid PC syntax based on supplied parameters buystop(licenseID, price, risk, sl, tp, betrigger, beoffset, spread, trailtrig, traildist, trailstep, atrtimeframe, atrperiod, atrmultiplier, atrshift, atrtrigger, symbol, accfilter, comment, secret, freq, debug)   Generates a buystop order alert with relevant syntax commands. Required params: licenseID, price, risk.   Parameters:      licenseID (string) : Your PC license ID      price (float) : Price or pips to set limit order (according to EA settings)      risk (float) : Risk quantity (according to EA settings)      sl (float) : Stop loss distance in pips or price      tp (float) : Take profit distance in pips or price      betrigger (float) : Breakeven will be activated after the position gains this number of pips      beoffset (float) : Offset from entry price. This is the amount of pips you'd like to protect      spread (float) : Enter the position only if the spread is equal or less than the specified value in pips      trailtrig (float) : Trailing stop-loss will be activated after a trade gains this number of pips      traildist (float) : Distance of the trailing stop-loss from current price      trailstep (float) : Moves trailing stop-loss once price moves to favourable by a specified number of pips      atrtimeframe (int) : ATR Trailing Stop timeframe, only updates once per bar close. Options: 1, 5, 15, 30, 60, 240, 1440      atrperiod (int) : ATR averaging period      atrmultiplier (float) : Multiple of ATR to utilise in the new SL computation, default = 1      atrshift (int) : Relative shift of price information, 0 uses latest candle, 1 uses second last, etc. Default = 0      atrtrigger (int) : Activate the trigger of ATR Trailing after market moves favourably by a number of pips. Default = 0 (instant)      symbol (string) : The symbol to trigger this order on (defaults to current symbol)      accfilter (float) : Optional minimum account balance filter      comment (string) : Optional comment (maximum 20 characters)      secret (string) : Optional secret key (must be enabled in dashboard)      freq (string) : Alert frequency. Default = "all", options = "once_per_bar", "once_per_bar_close" and "none"      debug (bool) : Turns on/off debug label   Returns: A stop order alert string with valid PC syntax based on supplied parameters sellstop(licenseID, price, risk, sl, tp, betrigger, beoffset, spread, trailtrig, traildist, trailstep, atrtimeframe, atrperiod, atrmultiplier, atrshift, atrtrigger, symbol, accfilter, comment, secret, freq, debug)   Generates a sellstop order alert with relevant syntax commands. Required params: licenseID, price, risk.   Parameters:      licenseID (string) : Your PC license ID      price (float) : Price or pips to set limit order (according to EA settings)      risk (float) : Risk quantity (according to EA settings)      sl (float) : Stop loss distance in pips or price      tp (float) : Take profit distance in pips or price      betrigger (float) : Breakeven will be activated after the position gains this number of pips      beoffset (float) : Offset from entry price. This is the amount of pips you'd like to protect      spread (float) : Enter the position only if the spread is equal or less than the specified value in pips      trailtrig (float) : Trailing stop-loss will be activated after a trade gains this number of pips      traildist (float) : Distance of the trailing stop-loss from current price      trailstep (float) : Moves trailing stop-loss once price moves to favourable by a specified number of pips      atrtimeframe (int) : ATR Trailing Stop timeframe, only updates once per bar close. Options: 1, 5, 15, 30, 60, 240, 1440      atrperiod (int) : ATR averaging period      atrmultiplier (float) : Multiple of ATR to utilise in the new SL computation, default = 1      atrshift (int) : Relative shift of price information, 0 uses latest candle, 1 uses second last, etc. Default = 0      atrtrigger (int) : Activate the trigger of ATR Trailing after market moves favourably by a number of pips. Default = 0 (instant)      symbol (string) : The symbol to trigger this order on (defaults to current symbol)      accfilter (float) : Optional minimum account balance filter      comment (string) : Optional comment (maximum 20 characters)      secret (string) : Optional secret key (must be enabled in dashboard)      freq (string) : Alert frequency. Default = "all", options = "once_per_bar", "once_per_bar_close" and "none"      debug (bool) : Turns on/off debug label   Returns: A stop order alert string with valid PC syntax based on supplied parameters cancel_neworder(licenseID, order, price, risk, sl, tp, betrigger, beoffset, spread, trailtrig, traildist, trailstep, atrtimeframe, atrperiod, atrmultiplier, atrshift, atrtrigger, symbol, accfilter, comment, secret, freq, debug)   Cancel + place new order template function.   Parameters:      licenseID (string) : Your PC license ID      order (string) : Cancel order type      price (float) : Price or pips to set limit order (according to EA settings)      risk (float) : Risk quantity (according to EA settings)      sl (float) : Stop loss distance in pips or price      tp (float) : Take profit distance in pips or price      betrigger (float) : Breakeven will be activated after the position gains this number of pips      beoffset (float) : Offset from entry price. This is the amount of pips you'd like to protect      spread (float) : Enter the position only if the spread is equal or less than the specified value in pips      trailtrig (float) : Trailing stop-loss will be activated after a trade gains this number of pips      traildist (float) : Distance of the trailing stop-loss from current price      trailstep (float) : Moves trailing stop-loss once price moves to favourable by a specified number of pips      atrtimeframe (int) : ATR Trailing Stop timeframe, only updates once per bar close. Options: 1, 5, 15, 30, 60, 240, 1440      atrperiod (int) : ATR averaging period      atrmultiplier (float) : Multiple of ATR to utilise in the new SL computation, default = 1      atrshift (int) : Relative shift of price information, 0 uses latest candle, 1 uses second last, etc. Default = 0      atrtrigger (int) : Activate the trigger of ATR Trailing after market moves favourably by a number of pips. Default = 0 (instant)      symbol (string) : The symbol to trigger this order on (defaults to current symbol)      accfilter (float) : Optional minimum account balance filter      comment (string) : Optional comment (maximum 20 characters)      secret (string) : Optional secret key (must be enabled in dashboard)      freq (string) : Alert frequency. Default = "all", options = "once_per_bar", "once_per_bar_close" and "none"      debug (bool) : Turns on/off debug label   Returns: A stop order alert string with valid PC syntax based on supplied parameters cancellongbuystop(licenseID, price, risk, sl, tp, betrigger, beoffset, spread, trailtrig, traildist, trailstep, atrtimeframe, atrperiod, atrmultiplier, atrshift, atrtrigger, symbol, accfilter, comment, secret, freq, debug)   Cancels all long orders with the specified symbol and places a new buystop order. Required params: licenseID, price, risk.   Parameters:      licenseID (string) : Your PC license ID      price (float) : Price or pips to set limit order (according to EA settings)      risk (float) : Risk quantity (according to EA settings)      sl (float) : Stop loss distance in pips or price      tp (float) : Take profit distance in pips or price      betrigger (float) : Breakeven will be activated after the position gains this number of pips      beoffset (float) : Offset from entry price. This is the amount of pips you'd like to protect      spread (float) : Enter the position only if the spread is equal or less than the specified value in pips      trailtrig (float) : Trailing stop-loss will be activated after a trade gains this number of pips      traildist (float) : Distance of the trailing stop-loss from current price      trailstep (float) : Moves trailing stop-loss once price moves to favourable by a specified number of pips      atrtimeframe (int) : ATR Trailing Stop timeframe, only updates once per bar close. Options: 1, 5, 15, 30, 60, 240, 1440      atrperiod (int) : ATR averaging period      atrmultiplier (float) : Multiple of ATR to utilise in the new SL computation, default = 1      atrshift (int) : Relative shift of price information, 0 uses latest candle, 1 uses second last, etc. Default = 0      atrtrigger (int) : Activate the trigger of ATR Trailing after market moves favourably by a number of pips. Default = 0 (instant)      symbol (string) : The symbol to trigger this order on (defaults to current symbol)      accfilter (float) : Optional minimum account balance filter      comment (string) : Optional comment (maximum 20 characters)      secret (string) : Optional secret key (must be enabled in dashboard)      freq (string) : Alert frequency. Default = "all", options = "once_per_bar", "once_per_bar_close" and "none"      debug (bool) : Turns on/off debug label   Returns: A stop order alert string with valid PC syntax based on supplied parameters cancellongbuylimit(licenseID, price, risk, sl, tp, betrigger, beoffset, spread, trailtrig, traildist, trailstep, atrtimeframe, atrperiod, atrmultiplier, atrshift, atrtrigger, symbol, accfilter, comment, secret, freq, debug)   Cancels all long orders with the specified symbol and places a new buylimit order. Required params: licenseID, price, risk.   Parameters:      licenseID (string) : Your PC license ID      price (float) : Price or pips to set limit order (according to EA settings)      risk (float) : Risk quantity (according to EA settings)      sl (float) : Stop loss distance in pips or price      tp (float) : Take profit distance in pips or price      betrigger (float) : Breakeven will be activated after the position gains this number of pips      beoffset (float) : Offset from entry price. This is the amount of pips you'd like to protect      spread (float) : Enter the position only if the spread is equal or less than the specified value in pips      trailtrig (float) : Trailing stop-loss will be activated after a trade gains this number of pips      traildist (float) : Distance of the trailing stop-loss from current price      trailstep (float) : Moves trailing stop-loss once price moves to favourable by a specified number of pips      atrtimeframe (int) : ATR Trailing Stop timeframe, only updates once per bar close. Options: 1, 5, 15, 30, 60, 240, 1440      atrperiod (int) : ATR averaging period      atrmultiplier (float) : Multiple of ATR to utilise in the new SL computation, default = 1      atrshift (int) : Relative shift of price information, 0 uses latest candle, 1 uses second last, etc. Default = 0      atrtrigger (int) : Activate the trigger of ATR Trailing after market moves favourably by a number of pips. Default = 0 (instant)      symbol (string) : The symbol to trigger this order on (defaults to current symbol)      accfilter (float) : Optional minimum account balance filter      comment (string) : Optional comment (maximum 20 characters)      secret (string) : Optional secret key (must be enabled in dashboard)      freq (string) : Alert frequency. Default = "all", options = "once_per_bar", "once_per_bar_close" and "none"      debug (bool) : Turns on/off debug label   Returns: A stop order alert string with valid PC syntax based on supplied parameters cancelshortsellstop(licenseID, price, risk, sl, tp, betrigger, beoffset, spread, trailtrig, traildist, trailstep, atrtimeframe, atrperiod, atrmultiplier, atrshift, atrtrigger, symbol, accfilter, comment, secret, freq, debug)   Cancels all short orders with the specified symbol and places a sellstop order. Required params: licenseID, price, risk.   Parameters:      licenseID (string) : Your PC license ID      price (float) : Price or pips to set limit order (according to EA settings)      risk (float) : Risk quantity (according to EA settings)      sl (float) : Stop loss distance in pips or price      tp (float) : Take profit distance in pips or price      betrigger (float) : Breakeven will be activated after the position gains this number of pips      beoffset (float) : Offset from entry price. This is the amount of pips you'd like to protect      spread (float) : Enter the position only if the spread is equal or less than the specified value in pips      trailtrig (float) : Trailing stop-loss will be activated after a trade gains this number of pips      traildist (float) : Distance of the trailing stop-loss from current price      trailstep (float) : Moves trailing stop-loss once price moves to favourable by a specified number of pips      atrtimeframe (int) : ATR Trailing Stop timeframe, only updates once per bar close. Options: 1, 5, 15, 30, 60, 240, 1440      atrperiod (int) : ATR averaging period      atrmultiplier (float) : Multiple of ATR to utilise in the new SL computation, default = 1      atrshift (int) : Relative shift of price information, 0 uses latest candle, 1 uses second last, etc. Default = 0      atrtrigger (int) : Activate the trigger of ATR Trailing after market moves favourably by a number of pips. Default = 0 (instant)      symbol (string) : The symbol to trigger this order on (defaults to current symbol)      accfilter (float) : Optional minimum account balance filter      comment (string) : Optional comment (maximum 20 characters)      secret (string) : Optional secret key (must be enabled in dashboard)      freq (string) : Alert frequency. Default = "all", options = "once_per_bar", "once_per_bar_close" and "none"      debug (bool) : Turns on/off debug label   Returns: A stop order alert string with valid PC syntax based on supplied parameters cancelshortselllimit(licenseID, price, risk, sl, tp, betrigger, beoffset, spread, trailtrig, traildist, trailstep, atrtimeframe, atrperiod, atrmultiplier, atrshift, atrtrigger, symbol, accfilter, comment, secret, freq, debug)   Cancels all short orders with the specified symbol and places a selllimit order. Required params: licenseID, price, risk.   Parameters:      licenseID (string) : Your PC license ID      price (float) : Price or pips to set limit order (according to EA settings)      risk (float) : Risk quantity (according to EA settings)      sl (float) : Stop loss distance in pips or price      tp (float) : Take profit distance in pips or price      betrigger (float) : Breakeven will be activated after the position gains this number of pips      beoffset (float) : Offset from entry price. This is the amount of pips you'd like to protect      spread (float) : Enter the position only if the spread is equal or less than the specified value in pips      trailtrig (float) : Trailing stop-loss will be activated after a trade gains this number of pips      traildist (float) : Distance of the trailing stop-loss from current price      trailstep (float) : Moves trailing stop-loss once price moves to favourable by a specified number of pips      atrtimeframe (int) : ATR Trailing Stop timeframe, only updates once per bar close. Options: 1, 5, 15, 30, 60, 240, 1440      atrperiod (int) : ATR averaging period      atrmultiplier (float) : Multiple of ATR to utilise in the new SL computation, default = 1      atrshift (int) : Relative shift of price information, 0 uses latest candle, 1 uses second last, etc. Default = 0      atrtrigger (int) : Activate the trigger of ATR Trailing after market moves favourably by a number of pips. Default = 0 (instant)      symbol (string) : The symbol to trigger this order on (defaults to current symbol)      accfilter (float) : Optional minimum account balance filter      comment (string) : Optional comment (maximum 20 characters)      secret (string) : Optional secret key (must be enabled in dashboard)      freq (string) : Alert frequency. Default = "all", options = "once_per_bar", "once_per_bar_close" and "none"      debug (bool) : Turns on/off debug label   Returns: A stop order alert string with valid PC syntax based on supplied parameters cancellong(licenseID, symbol, accfilter, comment, secret, freq, debug)   Cancels all pending long orders with the specified symbol. Required params: licenseID.   Parameters:      licenseID (string) : Your PC license ID      symbol (string) : Symbol to act on (defaults to current symbol)      accfilter (float) : Optional minimum account balance filter      comment (string) : Optional comment to include (max 20 characters)      secret (string) : Optional secret key (must be enabled in dashboard)      freq (string) : Alert frequency. Default = "all", options = "once_per_bar", "once_per_bar_close" and "none"      debug (bool) : Turns on/off debug label   Returns: A cancel long alert command cancelshort(licenseID, symbol, accfilter, comment, secret, freq, debug)   Cancels all pending short orders with the specified symbol. Required params: licenseID.   Parameters:      licenseID (string) : Your PC license ID      symbol (string) : Symbol to act on (defaults to current symbol)      accfilter (float) : Optional minimum account balance filter      comment (string) : Optional comment to include (max 20 characters)      secret (string) : Optional secret key (must be enabled in dashboard)      freq (string) : Alert frequency. Default = "all", options = "once_per_bar", "once_per_bar_close" and "none"      debug (bool) : Turns on/off debug label   Returns: A cancel short alert command newsltpbuystop(licenseID, sl, tp, symbol, accfilter, comment, secret, freq, debug)   Updates the stop loss and/or take profit of any pending buy stop orders on the given symbol. Required params: licenseID, sl and/or tp.   Parameters:      licenseID (string) : Your PC license ID      sl (float) : Stop loss pips or price (according to EA settings)      tp (float) : Take profit pips or price (according to EA settings)      symbol (string) : Symbol to act on (defaults to current symbol)      accfilter (float) : Optional minimum account balance filter      comment (string) : Optional comment to include (max 20 characters)      secret (string) : Optional secret key (must be enabled in dashboard)      freq (string) : Alert frequency. Default = "all", options = "once_per_bar", "once_per_bar_close" and "none"      debug (bool) : Turns on/off debug label   Returns: The required alert syntax as a string newsltpbuylimit(licenseID, sl, tp, symbol, accfilter, comment, secret, freq, debug)   Updates the stop loss and/or take profit of any pending buy limit orders on the given symbol. Required params: licenseID, sl and/or tp.   Parameters:      licenseID (string) : Your PC license ID      sl (float) : Stop loss pips or price (according to EA settings)      tp (float) : Take profit pips or price (according to EA settings)      symbol (string) : Symbol to act on (defaults to current symbol)      accfilter (float) : Optional minimum account balance filter      comment (string) : Optional comment to include (max 20 characters)      secret (string) : Optional secret key (must be enabled in dashboard)      freq (string) : Alert frequency. Default = "all", options = "once_per_bar", "once_per_bar_close" and "none"      debug (bool) : Turns on/off debug label   Returns: The required alert syntax as a string newsltpsellstop(licenseID, sl, tp, symbol, accfilter, comment, secret, freq, debug)   Updates the stop loss and/or take profit of any pending sell stop orders on the given symbol. Required params: licenseID, sl and/or tp.   Parameters:      licenseID (string) : Your PC license ID      sl (float) : Stop loss pips or price (according to EA settings)      tp (float) : Take profit pips or price (according to EA settings)      symbol (string) : Symbol to act on (defaults to current symbol)      accfilter (float) : Optional minimum account balance filter      comment (string) : Optional comment to include (max 20 characters)      secret (string) : Optional secret key (must be enabled in dashboard)      freq (string) : Alert frequency. Default = "all", options = "once_per_bar", "once_per_bar_close" and "none"      debug (bool) : Turns on/off debug label   Returns: The required alert syntax as a string newsltpselllimit(licenseID, sl, tp, symbol, accfilter, comment, secret, freq, debug)   Updates the stop loss and/or take profit of any pending sell limit orders on the given symbol. Required params: licenseID, sl and/or tp.   Parameters:      licenseID (string) : Your PC license ID      sl (float) : Stop loss pips or price (according to EA settings)      tp (float) : Take profit pips or price (according to EA settings)      symbol (string) : Symbol to act on (defaults to current symbol)      accfilter (float) : Optional minimum account balance filter      comment (string) : Optional comment to include (max 20 characters)      secret (string) : Optional secret key (must be enabled in dashboard)      freq (string) : Alert frequency. Default = "all", options = "once_per_bar", "once_per_bar_close" and "none"      debug (bool) : Turns on/off debug label   Returns: The required alert syntax as a string eaoff(licenseID, secret, freq, debug)   Turns the EA off. Required params: licenseID.   Parameters:      licenseID (string) : Your PC license ID      secret (string) : Optional secret key (must be enabled in dashboard)      freq (string) : Alert frequency. Default = "all", options = "once_per_bar", "once_per_bar_close" and "none"      debug (bool) : Turns on/off debug label   Returns: The required alert syntax as a string eaon(licenseID, secret, freq, debug)   Turns the EA on. Required params: licenseID.   Parameters:      licenseID (string) : Your PC license ID      secret (string) : Optional secret key (must be enabled in dashboard)      freq (string) : Alert frequency. Default = "all", options = "once_per_bar", "once_per_bar_close" and "none"      debug (bool) : Turns on/off debug label   Returns: The required alert syntax as a string
Biblioteca Pine Script®
por ZenAndTheArtOfTrading
2
Rollover LTEThis indicator shows where price needs to be and when in order to cause the 20-sma and 50-sma moving averages to change directions. A change in direction requires the slope of a moving average to change from negative to positive or from positive to negative. When a moving average changes direction, it can be said that it has “rolled over” or “rolled up,” with the latter only applying if slope went from negative to positive. Theory: In order to solve for the price of the current bar that will cause the moving average to roll up, the slope from the previous bar’s average to the current bar’s average must be set equal to zero which is to say that the averages must be the same. For the 20-sma, the equation simply stated in words is as follows: Current MA as a function of current price and previous 19 values = previous MA which is fixed based on previous 20 values The denominators which are both 20 cancel and the previous 19 values cancel. What’s left is current price on the left side and the value from 20 bars ago on the right. Current price = value from 20 bars ago and since the equation was set up for solving for the price of the current bar that will cause the MA to roll over Rollover price = value from 20 bars ago This makes plotting rollover price, both current and forecasted, fairly simple, as it’s merely the closing price plotted with an offset to the right the same distance as the moving average length. Application: The 20-sma and 50-sma rollover prices are plotted because they are considered to be the two most important moving averages for rollover analysis. Moving average lengths can be modified in the indicator settings. The 20-sma and 20-sma rollover price are both plotted in white and the 50-sma and 50-sma rollover price are both plotted in blue. There are two rollover prices because the 20-sma rollover price is the price that will cause the 20-sma to roll over and the 50-sma rollover price is the price that will cause the 50-sma to roll over. The one that's vertically furthest away from the current price is the one that will cause both to rollover, as should become clearer upon reading the explanation below. The distance between the current price and the 20-sma rollover price is referred to as the “rollover strength” of the price relative to the 20-sma. A large disparity between the current price and the rollover price suggests bearishness (negative rollover strength) if the rollover price is overhead because price would need to travel all that distance in order to cause the moving average to roll up. If the rollover price and price are converging, as is often the case, a change in moving average and price direction becomes more plausible. The rollover strengths of the 20-sma and 50-sma are added together to calculate the Rollover Strength and if a negative number is the result then the background color of the plot cloud turns red. If the result is positive, it turns green. Rollover Strength is plotted below price as a separate indicator in this publication for reference only and it's not part of this indicator. It does not look much different from momentum indicators. The code is below if anybody wants to try to use it. The important thing is that the distances between the rollover prices and the price action are kept in mind as having shrinking, growing, or neutral bearish and bullish effects on current and forecasted price direction. Trades should not be entered based on cloud colorization changes alone. If you are about to crash into a wall of the 20-sma rollover price, as is indicated on the chart by the green arrow, you might consider going long so long as the rollover strength, both current and forecasted, of the 50-sma isn’t questionably bearish. This is subject to analysis and interpretation. There was a 20-sma rollover wall as indicated with yellow arrow, but the bearish rollover strength of the 50-sma was growing and forecasted to remain strong for a while at that time so a long entry would have not been suggested by both rollover prices. If you are about to crash into both the 20-sma and 50-sma rollover prices at the same time (not shown on this chart), that’s a good time to place a trade in anticipation of both slopes changing direction. You may, in the case of this chart, see that a 20-sma rollover wall precedes a 50-sma rollover convergence with price and anticipate a cascade which turned out to be the case with this recent NQ rally. Price exiting the cloud entirely to either the upside or downside has strong implications. When exiting to the downside, the 20-sma and 50-sma have both rolled over and price is below both of them. The same is true for upside exits. Re-entering the cloud after a rally may indicate a reversal is near, especially if the forecasted rollover prices, particularly the 50-sma, agree. This indicator should be used in conjunction with other technical analysis tools. Additional Notes: The original version of this script which will not be published was much heavier, cluttered, and is not as useful. This is the light version, hence the “LTE” suffix. LTE stands for “long-term evolution” in telecommunications, not “light.” Bar colorization (red, yellow, and green bars) was added using the MACD Hybrid BSH script which is another script I’ve published. If you’re not sure what a bar is, it’s the same thing as a candle or a data point on a line chart. Every vertical line showing price action on the chart above is a bar and it is a bar chart. sma = simple moving average Rollover Strength Script: // This source code is subject to the terms of the Mozilla Public License 2.0 at mozilla.org // © Skipper86 //@version=5 indicator(title="Rollover Strength", shorttitle="Rollover Strength", overlay=false) source = input.source(close) length1 = input.int(20, "Length 1", minval=1) length2 = input.int(50, "Length 2", minval=1) RolloverPrice1 = source RolloverPrice2 = source RolloverStrength1 = source-RolloverPrice1 RolloverStrength2 = source-RolloverPrice2 RolloverStrength = RolloverStrength1 + RolloverStrength2 Color1 = color.rgb(155, 155, 155, 0) Color2 = color.rgb(0, 0, 200, 0) Color3 = color.rgb(0, 200, 0, 0) plot(RolloverStrength, title="Rollover Strength", color=Color3) hline(0, "Middle Band", color=Color1) //End of Rollover Strength Script
Indicador Pine Script®
por Skipper86
[FS] Pivot Measurements# Pivot Measurements An advanced TradingView indicator that combines LuxAlgo's pivot point detection algorithm with automatic measurement calculations between consecutive pivots. ## Features ### Pivot Detection - **Regular Pivots**: Detects standard pivot highs and lows using configurable pivot length - **Missed Pivots**: Identifies missed reversal levels that occurred between regular pivots - **Visual Indicators**: - Regular pivot highs: Red downward triangle (▼) - Regular pivot lows: Teal upward triangle (▲) - Missed pivots: Ghost emoji (👻) - **Zigzag Lines**: Connects pivots with colored lines (solid for regular, dashed for missed) - **Ghost Levels**: Horizontal lines indicating missed pivot levels ### Measurement System - **Automatic Measurements**: Calculates price movements between consecutive pivots - **Visual Display**: - Transparent colored boxes (blue for upward, red for downward movements) - Measurement labels showing: - Price change (absolute and percentage) - Duration (bars, days, hours, minutes) - Volume approximation - **Smart Positioning**: Labels positioned outside boxes (above for upward, below for downward) - **Color Coding**: Blue for positive movements, red for negative movements ## Parameters ### Pivot Detection - **Pivot Length** (default: 50): Number of bars on each side to identify a pivot point - **Regular Pivots**: Toggle and colors for regular pivot highs and lows - **Missed Pivots**: Toggle and colors for missed pivot detection ### Measurements - **Number of Measurements** (1-10, default: 10): Maximum number of measurements to display - **Show Measurement Boxes**: Toggle to show/hide measurement boxes and labels - **Box Transparency** (0-100, default: 90): Transparency level for measurement boxes - **Border Transparency** (0-100, default: 50): Transparency level for box borders - **Label Background Transparency** (0-100, default: 30): Transparency level for label backgrounds - **Label Size**: Size of measurement labels (tiny, small, normal, large) ## Usage 1. Add the indicator to your chart 2. Configure the **Pivot Length** based on your timeframe: - Lower values for shorter timeframes (e.g., 10-20 for 1-5 min) - Higher values for longer timeframes (e.g., 50-100 for daily) 3. Adjust pivot colors and visibility as needed 4. Customize measurement display settings: - Set the number of measurements to display - Adjust transparency levels for boxes, borders, and labels - Choose label size ## Technical Details - **Pine Script Version**: v6 - **Pivot Detection**: Based on () algorithm for detecting regular and missed pivots - **Measurement Calculation**: - Measures between consecutive pivots (from most recent to older) - Calculates price change, percentage change, duration, and approximate volume - Automatically sorts pivots chronologically - **Performance**: Optimized with helper functions to reduce code duplication ## Notes - The indicator automatically limits the number of stored pivots to optimize performance - Measurements are only created when there are at least 2 pivots detected - All measurements are recalculated on each bar update - The indicator uses `max_bars_back=5000` to ensure sufficient historical data ## License This indicator uses LuxAlgo's pivot detection algorithm from (). Please refer to the original LuxAlgo license for pivot detection components.
Indicador Pine Script®
por SF_Trade
Turtle Trader StrategyTurtle Trader Strategy : Introduction : This strategy is based on the well known « Turtle Trader Strategy », that has proven itself over the years. It sends long and short signals with pyramid orders of up to 5, meaning that the strategy can trigger up to 5 orders in the same direction. Good risk and money management. It's important to note that the strategy combines 2 systems working together (S1 and S2). Let’s describe the specific features of this strategy. 1/ Position size : Position size is very important for turtle traders to manage risk properly. This position sizing strategy adapts to market volatility and to account (gains and losses). It’s based on ATR (Average True Range) which can also be called « N ». Its length is per default 20. ATR(20) = (previous_atr(20)*19 + actual_true_range)/20 The number of units to buy is : Unit = 1% * account/(ATR(20)*dollar_per_point) where account is the actual account value and dollar_per_point is the variation in dollar of the asset with a 1 point move. Depending on your risk aversion, you can increase the percentage of your account, but turtle traders default to 1%. If you trade contracts, units must be rounded down by default. There is also an additional rule to reduce the risk if the value of the account falls below the initial capital : in this case and only in this case, account in the unit formula must be replace by : account = actual_account*actual_account/initial capital 2/ Open a position : 2 systems are working together : System 1 : Entering a new 20 day breakout System 2 : Entering a new 55 day breakout A breakout is a new high or new low. If it’s a new high, we open long position and vice versa if it’s a new low we enter in short position. We add an additional rule : System 1 : Breakout is ignored if last long/short position was a winner System 2 : All signals are taken This additional rule allows the trader to be in the major trends if the system 1 signal has been skipped. If a signal for system 1 has been skipped, and next candle is also a new 20 day breakout, S1 doesn’t give a signal. We have to wait S2 signal or wait for a candle that doesn’t make a new breakout to reactivate S1. 3/ Pyramid orders : Turtle Strategy allows us to add extra units to the position if the price moves in our favor. I've configured the strategy to allow up to 5 orders to be added in the same direction. So if the price varies from 0.5*ATR(20) , we add units with the position size formula. Note that the value of account will be replaced by "remaining_account", i.e. the cash remaining in our account after subtracting the value of open positions. 4/ Stop Loss : We set a stop loss at 1.5*ATR(20) below the entry price for longs and above the entry price for shorts. If pyramid units are added, the stop is increased/decreased by 0.5*ATR(20). Note that if SL is configured for a loss of more than 10%, we set the SL to 10% for the first entry order to avoid big losses. This configuration does not work for pyramid orders as SL moves by 0.5*ATR(20). 5/ Exit signals : System 1 : Exit long on a 10 day low Exit short on a 10 day high System 2 : Exit long on a 20 day low Exit short on a 20 day high 6/ What types of orders are placed ? To enter in a position, stop orders are placed meaning that we place orders that will be automatically triggered by the signal at the exact breakout price. Stop loss and exit signals are also stop orders. Pyramid orders are market orders which will be triggered at the opening of the next candle to avoid repainting. PARAMETERS : Risk % of capital : Percentage used in the position size formula. Default is 1% ATR period : ATR length used to calculate ATR. Default is 20 Stop ATR : Parameters used to fix stop loss. Default is 1.5 meaning that stop loss will be set at : buy_price - 1.5*ATR(20) for long and buy_price + 1.5*ATR(20) for short. Turtle traders default is 2 but 1.5 is better for cryptocurrency as there is a huge volatility. S1 Long : System 1 breakout length for long. Default is 20 S2 Long : System 2 breakout length for long. Default is 55 S1 Long Exit : System 1 breakout length to exit long. Default is 10 S2 Long Exit : System 2 breakout length to exit long. Default is 20 S1 Short : System 1 breakout length for short. Default is 15 S2 Short : System 2 breakout length for short. Default is 55 S1 Short Exit : System 1 breakout length to exit short. Default is 7 S2 Short Exit : System 2 breakout length to exit short. Default is 20 Initial capital : $1000 Fees : Interactive Broker fees apply to this strategy. They are set at 0.18% of the trade value. Slippage : 3 ticks or $0.03 per trade. Corresponds to the latency time between the moment the signal is received and the moment the order is executed by the broker. Pyramiding : Number of orders that can be passed in the same direction. Default is 5. Important : Turtle traders don't trade crypto. For this specific asset type, I modify some parameters such as SL and Short S1 in order to maximize return while limiting drawdown. This strategy is the most optimal on BINANCE:BTCUSD in 1D timeframe with the parameters set per default. If you want to use this strategy for a different crypto please adapt parameters. NOTE : It's important to note that the first entry order (long or short) will be the largest. Subsequent pyramid orders will have fewer units than the first order. We've set a maximum SL for the first order of 10%, meaning that you won't lose more than 10% of the value of your first order. However, it is possible to lose more on your pyramid orders, as the SL is increased/decreased by 0.5*ATR(20), which does not secure a loss of more than 10% on your pyramid orders. The risk remains well managed because the value of these orders is less than the value of the first order. Remain vigilant to this small detail and adjust your risk according to your risk aversion. Enjoy the strategy and don’t forget to take the trade :)
Estrategia Pine Script®
por geneZ_fi
14
Keltner Channel Enhanced [DCAUT]█ Keltner Channel Enhanced 📊 ORIGINALITY & INNOVATION The Keltner Channel Enhanced represents an important advancement over standard Keltner Channel implementations by introducing dual flexibility in moving average selection for both the middle band and ATR calculation. While traditional Keltner Channels typically use EMA for the middle band and RMA (Wilder's smoothing) for ATR, this enhanced version provides access to 25+ moving average algorithms for both components, enabling traders to fine-tune the indicator's behavior to match specific market characteristics and trading approaches. Key Advancements: Dual MA Algorithm Flexibility: Independent selection of moving average types for middle band (25+ options) and ATR smoothing (25+ options), allowing optimization of both trend identification and volatility measurement separately Enhanced Trend Sensitivity: Ability to use faster algorithms (HMA, T3) for middle band while maintaining stable volatility measurement with traditional ATR smoothing, or vice versa for different trading strategies Adaptive Volatility Measurement: Choice of ATR smoothing algorithm affects channel responsiveness to volatility changes, from highly reactive (SMA, EMA) to smoothly adaptive (RMA, TEMA) Comprehensive Alert System: Five distinct alert conditions covering breakouts, trend changes, and volatility expansion, enabling automated monitoring without constant chart observation Multi-Timeframe Compatibility: Works effectively across all timeframes from intraday scalping to long-term position trading, with independent optimization of trend and volatility components This implementation addresses key limitations of standard Keltner Channels: fixed EMA/RMA combination may not suit all market conditions or trading styles. By decoupling the trend component from volatility measurement and allowing independent algorithm selection, traders can create highly customized configurations for specific instruments and market phases. 📐 MATHEMATICAL FOUNDATION Keltner Channel Enhanced uses a three-component calculation system that combines a flexible moving average middle band with ATR-based (Average True Range) upper and lower channels, creating volatility-adjusted trend-following bands. Core Calculation Process: 1. Middle Band (Basis) Calculation: The basis line is calculated using the selected moving average algorithm applied to the price source over the specified period: basis = ma(source, length, maType) Supported algorithms include EMA (standard choice, trend-biased), SMA (balanced and symmetric), HMA (reduced lag), WMA, VWMA, TEMA, T3, KAMA, and 17+ others. 2. Average True Range (ATR) Calculation: ATR measures market volatility by calculating the average of true ranges over the specified period: trueRange = max(high - low, abs(high - close ), abs(low - close )) atrValue = ma(trueRange, atrLength, atrMaType) ATR smoothing algorithm significantly affects channel behavior, with options including RMA (standard, very smooth), SMA (moderate smoothness), EMA (fast adaptation), TEMA (smooth yet responsive), and others. 3. Channel Calculation: Upper and lower channels are positioned at specified multiples of ATR from the basis: upperChannel = basis + (multiplier × atrValue) lowerChannel = basis - (multiplier × atrValue) Standard multiplier is 2.0, providing channels that dynamically adjust width based on market volatility. Keltner Channel vs. Bollinger Bands - Key Differences: While both indicators create volatility-based channels, they use fundamentally different volatility measures: Keltner Channel (ATR-based): Uses Average True Range to measure actual price movement volatility Incorporates gaps and limit moves through true range calculation More stable in trending markets, less prone to extreme compression Better reflects intraday volatility and trading range Typically fewer band touches, making touches more significant More suitable for trend-following strategies Bollinger Bands (Standard Deviation-based): Uses statistical standard deviation to measure price dispersion Based on closing prices only, doesn't account for intraday range Can compress significantly during consolidation (squeeze patterns) More touches in ranging markets Better suited for mean-reversion strategies Provides statistical probability framework (95% within 2 standard deviations) Algorithm Combination Effects: The interaction between middle band MA type and ATR MA type creates different indicator characteristics: Trend-Focused Configuration (Fast MA + Slow ATR): Middle band uses HMA/EMA/T3, ATR uses RMA/TEMA, quick trend changes with stable channel width, suitable for trend-following Volatility-Focused Configuration (Slow MA + Fast ATR): Middle band uses SMA/WMA, ATR uses EMA/SMA, stable trend with dynamic channel width, suitable for volatility trading Balanced Configuration (Standard EMA/RMA): Classic Keltner Channel behavior, time-tested combination, suitable for general-purpose trend following Adaptive Configuration (KAMA + KAMA): Self-adjusting indicator responding to efficiency ratio, suitable for markets with varying trend strength and volatility regimes 📊 COMPREHENSIVE SIGNAL ANALYSIS Keltner Channel Enhanced provides multiple signal categories optimized for trend-following and breakout strategies. Channel Position Signals: Upper Channel Interaction: Price Touching Upper Channel: Strong bullish momentum, price moving more than typical volatility range suggests, potential continuation signal in established uptrends Price Breaking Above Upper Channel: Exceptional strength, price exceeding normal volatility expectations, consider adding to long positions or tightening trailing stops Price Riding Upper Channel: Sustained strong uptrend, characteristic of powerful bull moves, stay with trend and avoid premature profit-taking Price Rejection at Upper Channel: Momentum exhaustion signal, consider profit-taking on longs or waiting for pullback to middle band for reentry Lower Channel Interaction: Price Touching Lower Channel: Strong bearish momentum, price moving more than typical volatility range suggests, potential continuation signal in established downtrends Price Breaking Below Lower Channel: Exceptional weakness, price exceeding normal volatility expectations, consider adding to short positions or protecting against further downside Price Riding Lower Channel: Sustained strong downtrend, characteristic of powerful bear moves, stay with trend and avoid premature covering Price Rejection at Lower Channel: Momentum exhaustion signal, consider covering shorts or waiting for bounce to middle band for reentry Middle Band (Basis) Signals: Trend Direction Confirmation: Price Above Basis: Bullish trend bias, middle band acts as dynamic support in uptrends, consider long positions or holding existing longs Price Below Basis: Bearish trend bias, middle band acts as dynamic resistance in downtrends, consider short positions or avoiding longs Price Crossing Above Basis: Potential trend change from bearish to bullish, early signal to establish long positions Price Crossing Below Basis: Potential trend change from bullish to bearish, early signal to establish short positions or exit longs Pullback Trading Strategy: Uptrend Pullback: Price pulls back from upper channel to middle band, finds support, and resumes upward, ideal long entry point Downtrend Bounce: Price bounces from lower channel to middle band, meets resistance, and resumes downward, ideal short entry point Basis Test: Strong trends often show price respecting the middle band as support/resistance on pullbacks Failed Test: Price breaking through middle band against trend direction signals potential reversal Volatility-Based Signals: Narrow Channels (Low Volatility): Consolidation Phase: Channels contract during periods of reduced volatility and directionless price action Breakout Preparation: Narrow channels often precede significant directional moves as volatility cycles Trading Approach: Reduce position sizes, wait for breakout confirmation, avoid range-bound strategies within channels Breakout Direction: Monitor for price breaking decisively outside channel range with expanding width Wide Channels (High Volatility): Trending Phase: Channels expand during strong directional moves and increased volatility Momentum Confirmation: Wide channels confirm genuine trend with substantial volatility backing Trading Approach: Trend-following strategies excel, wider stops necessary, mean-reversion strategies risky Exhaustion Signs: Extreme channel width (historical highs) may signal approaching consolidation or reversal Advanced Pattern Recognition: Channel Walking Pattern: Upper Channel Walk: Price consistently touches or exceeds upper channel while staying above basis, very strong uptrend signal, hold longs aggressively Lower Channel Walk: Price consistently touches or exceeds lower channel while staying below basis, very strong downtrend signal, hold shorts aggressively Basis Support/Resistance: During channel walks, price typically uses middle band as support/resistance on minor pullbacks Pattern Break: Price crossing basis during channel walk signals potential trend exhaustion Squeeze and Release Pattern: Squeeze Phase: Channels narrow significantly, price consolidates near middle band, volatility contracts Direction Clues: Watch for price positioning relative to basis during squeeze (above = bullish bias, below = bearish bias) Release Trigger: Price breaking outside narrow channel range with expanding width confirms breakout Follow-Through: Measure squeeze height and project from breakout point for initial profit targets Channel Expansion Pattern: Breakout Confirmation: Rapid channel widening confirms volatility increase and genuine trend establishment Entry Timing: Enter positions early in expansion phase before trend becomes overextended Risk Management: Use channel width to size stops appropriately, wider channels require wider stops Basis Bounce Pattern: Clean Bounce: Price touches middle band and immediately reverses, confirms trend strength and entry opportunity Multiple Bounces: Repeated basis bounces indicate strong, sustainable trend Bounce Failure: Price penetrating basis signals weakening trend and potential reversal Divergence Analysis: Price/Channel Divergence: Price makes new high/low while staying within channel (not reaching outer band), suggests momentum weakening Width/Price Divergence: Price breaks to new extremes but channel width contracts, suggests move lacks conviction Reversal Signal: Divergences often precede trend reversals or significant consolidation periods Multi-Timeframe Analysis: Keltner Channels work particularly well in multi-timeframe trend-following approaches: Three-Timeframe Alignment: Higher Timeframe (Weekly/Daily): Identify major trend direction, note price position relative to basis and channels Intermediate Timeframe (Daily/4H): Identify pullback opportunities within higher timeframe trend Lower Timeframe (4H/1H): Time precise entries when price touches middle band or lower channel (in uptrends) with rejection Optimal Entry Conditions: Best Long Entries: Higher timeframe in uptrend (price above basis), intermediate timeframe pulls back to basis, lower timeframe shows rejection at middle band or lower channel Best Short Entries: Higher timeframe in downtrend (price below basis), intermediate timeframe bounces to basis, lower timeframe shows rejection at middle band or upper channel Risk Management: Use higher timeframe channel width to set position sizing, stops below/above higher timeframe channels 🎯 STRATEGIC APPLICATIONS Keltner Channel Enhanced excels in trend-following and breakout strategies across different market conditions. Trend Following Strategy: Setup Requirements: Identify established trend with price consistently on one side of basis line Wait for pullback to middle band (basis) or brief penetration through it Confirm trend resumption with price rejection at basis and move back toward outer channel Enter in trend direction with stop beyond basis line Entry Rules: Uptrend Entry: Price pulls back from upper channel to middle band, shows support at basis (bullish candlestick, momentum divergence) Enter long on rejection/bounce from basis with stop 1-2 ATR below basis Aggressive: Enter on first touch; Conservative: Wait for confirmation candle Downtrend Entry: Price bounces from lower channel to middle band, shows resistance at basis (bearish candlestick, momentum divergence) Enter short on rejection/reversal from basis with stop 1-2 ATR above basis Aggressive: Enter on first touch; Conservative: Wait for confirmation candle Trend Management: Trailing Stop: Use basis line as dynamic trailing stop, exit if price closes beyond basis against position Profit Taking: Take partial profits at opposite channel, move stops to basis Position Additions: Add to winners on subsequent basis bounces if trend intact Breakout Strategy: Setup Requirements: Identify consolidation period with contracting channel width Monitor price action near middle band with reduced volatility Wait for decisive breakout beyond channel range with expanding width Enter in breakout direction after confirmation Breakout Confirmation: Price breaks clearly outside channel (upper for longs, lower for shorts), channel width begins expanding from contracted state Volume increases significantly on breakout (if using volume analysis) Price sustains outside channel for multiple bars without immediate reversal Entry Approaches: Aggressive: Enter on initial break with stop at opposite channel or basis, use smaller position size Conservative: Wait for pullback to broken channel level, enter on rejection and resumption, tighter stop Volatility-Based Position Sizing: Adjust position sizing based on channel width (ATR-based volatility): Wide Channels (High ATR): Reduce position size as stops must be wider, calculate position size using ATR-based risk calculation: Risk / (Stop Distance in ATR × ATR Value) Narrow Channels (Low ATR): Increase position size as stops can be tighter, be cautious of impending volatility expansion ATR-Based Risk Management: Use ATR-based risk calculations, position size = 0.01 × Capital / (2 × ATR), use multiples of ATR (1-2 ATR) for adaptive stops Algorithm Selection Guidelines: Different market conditions benefit from different algorithm combinations: Strong Trending Markets: Middle band use EMA or HMA, ATR use RMA, capture trends quickly while maintaining stable channel width Choppy/Ranging Markets: Middle band use SMA or WMA, ATR use SMA or WMA, avoid false trend signals while identifying genuine reversals Volatile Markets: Middle band and ATR both use KAMA or FRAMA, self-adjusting to changing market conditions reduces manual optimization Breakout Trading: Middle band use SMA, ATR use EMA or SMA, stable trend with dynamic channels highlights volatility expansion early Scalping/Day Trading: Middle band use HMA or T3, ATR use EMA or TEMA, both components respond quickly Position Trading: Middle band use EMA/TEMA/T3, ATR use RMA or TEMA, filter out noise for long-term trend-following 📋 DETAILED PARAMETER CONFIGURATION Understanding and optimizing parameters is essential for adapting Keltner Channel Enhanced to specific trading approaches. Source Parameter: Close (Most Common): Uses closing price, reflects daily settlement, best for end-of-day analysis and position trading, standard choice HL2 (Median Price): Smooths out closing bias, better represents full daily range in volatile markets, good for swing trading HLC3 (Typical Price): Gives more weight to close while including full range, popular for intraday applications, slightly more responsive than HL2 OHLC4 (Average Price): Most comprehensive price representation, smoothest option, good for gap-prone markets or highly volatile instruments Length Parameter: Controls the lookback period for middle band (basis) calculation: Short Periods (10-15): Very responsive to price changes, suitable for day trading and scalping, higher false signal rate Standard Period (20 - Default): Represents approximately one month of trading, good balance between responsiveness and stability, suitable for swing and position trading Medium Periods (30-50): Smoother trend identification, fewer false signals, better for position trading and longer holding periods Long Periods (50+): Very smooth, identifies major trends only, minimal false signals but significant lag, suitable for long-term investment Optimization by Timeframe: 1-15 minute charts use 10-20 period, 30-60 minute charts use 20-30 period, 4-hour to daily charts use 20-40 period, weekly charts use 20-30 weeks. ATR Length Parameter: Controls the lookback period for Average True Range calculation, affecting channel width: Short ATR Periods (5-10): Very responsive to recent volatility changes, standard is 10 (Keltner's original specification), may be too reactive in whipsaw conditions Standard ATR Period (10 - Default): Chester Keltner's original specification, good balance between responsiveness and stability, most widely used Medium ATR Periods (14-20): Smoother channel width, ATR 14 aligns with Wilder's original ATR specification, good for position trading Long ATR Periods (20+): Very smooth channel width, suitable for long-term trend-following Length vs. ATR Length Relationship: Equal values (20/20) provide balanced responsiveness, longer ATR (20/14) gives more stable channel width, shorter ATR (20/10) is standard configuration, much shorter ATR (20/5) creates very dynamic channels. Multiplier Parameter: Controls channel width by setting ATR multiples: Lower Values (1.0-1.5): Tighter channels with frequent price touches, more trading signals, higher false signal rate, better for range-bound and mean-reversion strategies Standard Value (2.0 - Default): Chester Keltner's recommended setting, good balance between signal frequency and reliability, suitable for both trending and ranging strategies Higher Values (2.5-3.0): Wider channels with less frequent touches, fewer but potentially higher-quality signals, better for strong trending markets Market-Specific Optimization: High volatility markets (crypto, small-caps) use 2.5-3.0 multiplier, medium volatility markets (major forex, large-caps) use 2.0 multiplier, low volatility markets (bonds, utilities) use 1.5-2.0 multiplier. MA Type Parameter (Middle Band): Critical selection that determines trend identification characteristics: EMA (Exponential Moving Average - Default): Standard Keltner Channel choice, Chester Keltner's original specification, emphasizes recent prices, faster response to trend changes, suitable for all timeframes SMA (Simple Moving Average): Equal weighting of all data points, no directional bias, slower than EMA, better for ranging markets and mean-reversion HMA (Hull Moving Average): Minimal lag with smooth output, excellent for fast trend identification, best for day trading and scalping TEMA (Triple Exponential Moving Average): Advanced smoothing with reduced lag, responsive to trends while filtering noise, suitable for volatile markets T3 (Tillson T3): Very smooth with minimal lag, excellent for established trend identification, suitable for position trading KAMA (Kaufman Adaptive Moving Average): Automatically adjusts speed based on market efficiency, slow in ranging markets, fast in trends, suitable for markets with varying conditions ATR MA Type Parameter: Determines how Average True Range is smoothed, affecting channel width stability: RMA (Wilder's Smoothing - Default): J. Welles Wilder's original ATR smoothing method, very smooth, slow to adapt to volatility changes, provides stable channel width SMA (Simple Moving Average): Equal weighting, moderate smoothness, faster response to volatility changes than RMA, more dynamic channel width EMA (Exponential Moving Average): Emphasizes recent volatility, quick adaptation to new volatility regimes, very responsive channel width changes TEMA (Triple Exponential Moving Average): Smooth yet responsive, good balance for varying volatility, suitable for most trading styles Parameter Combination Strategies: Conservative Trend-Following: Length 30/ATR Length 20/Multiplier 2.5, MA Type EMA or TEMA/ATR MA Type RMA, smooth trend with stable wide channels, suitable for position trading Standard Balanced Approach: Length 20/ATR Length 10/Multiplier 2.0, MA Type EMA/ATR MA Type RMA, classic Keltner Channel configuration, suitable for general purpose swing trading Aggressive Day Trading: Length 10-15/ATR Length 5-7/Multiplier 1.5-2.0, MA Type HMA or EMA/ATR MA Type EMA or SMA, fast trend with dynamic channels, suitable for scalping and day trading Breakout Specialist: Length 20-30/ATR Length 5-10/Multiplier 2.0, MA Type SMA or WMA/ATR MA Type EMA or SMA, stable trend with responsive channel width Adaptive All-Conditions: Length 20/ATR Length 10/Multiplier 2.0, MA Type KAMA or FRAMA/ATR MA Type KAMA or TEMA, self-adjusting to market conditions Offset Parameter: Controls horizontal positioning of channels on chart. Positive values shift channels to the right (future) for visual projection, negative values shift left (past) for historical analysis, zero (default) aligns with current price bars for real-time signal analysis. Offset affects only visual display, not alert conditions or actual calculations. 📈 PERFORMANCE ANALYSIS & COMPETITIVE ADVANTAGES Keltner Channel Enhanced provides improvements over standard implementations while maintaining proven effectiveness. Response Characteristics: Standard EMA/RMA Configuration: Moderate trend lag (approximately 0.4 × length periods), smooth and stable channel width from RMA smoothing, good balance for most market conditions Fast HMA/EMA Configuration: Approximately 60% reduction in trend lag compared to EMA, responsive channel width from EMA ATR smoothing, suitable for quick trend changes and breakouts Adaptive KAMA/KAMA Configuration: Variable lag based on market efficiency, automatic adjustment to trending vs. ranging conditions, self-optimizing behavior reduces manual intervention Comparison with Traditional Keltner Channels: Enhanced Version Advantages: Dual Algorithm Flexibility: Independent MA selection for trend and volatility vs. fixed EMA/RMA, separate tuning of trend responsiveness and channel stability Market Adaptation: Choose configurations optimized for specific instruments and conditions, customize for scalping, swing, or position trading preferences Comprehensive Alerts: Enhanced alert system including channel expansion detection Traditional Version Advantages: Simplicity: Fewer parameters, easier to understand and implement Standardization: Fixed EMA/RMA combination ensures consistency across users Research Base: Decades of backtesting and research on standard configuration When to Use Enhanced Version: Trading multiple instruments with different characteristics, switching between trending and ranging markets, employing different strategies, algorithm-based trading systems requiring customization, seeking optimization for specific trading style and timeframe. When to Use Standard Version: Beginning traders learning Keltner Channel concepts, following published research or trading systems, preferring simplicity and standardization, wanting to avoid optimization and curve-fitting risks. Performance Across Market Conditions: Strong Trending Markets: EMA or HMA basis with RMA or TEMA ATR smoothing provides quicker trend identification, pullbacks to basis offer excellent entry opportunities Choppy/Ranging Markets: SMA or WMA basis with RMA ATR smoothing and lower multipliers, channel bounce strategies work well, avoid false breakouts Volatile Markets: KAMA or FRAMA with EMA or TEMA, adaptive algorithms excel by automatic adjustment, wider multipliers (2.5-3.0) accommodate large price swings Low Volatility/Consolidation: Channels narrow significantly indicating consolidation, algorithm choice less impactful, focus on detecting channel width contraction for breakout preparation Keltner Channel vs. Bollinger Bands - Usage Comparison: Favor Keltner Channels When: Trend-following is primary strategy, trading volatile instruments with gaps, want ATR-based volatility measurement, prefer fewer higher-quality channel touches, seeking stable channel width during trends. Favor Bollinger Bands When: Mean-reversion is primary strategy, trading instruments with limited gaps, want statistical framework based on standard deviation, need squeeze patterns for breakout identification, prefer more frequent trading opportunities. Use Both Together: Bollinger Band squeeze + Keltner Channel breakout is powerful combination, price outside Bollinger Bands but inside Keltner Channels indicates moderate signal, price outside both indicates very strong signal, Bollinger Bands for entries and Keltner Channels for trend confirmation. Limitations and Considerations: General Limitations: Lagging Indicator: All moving averages lag price, even with reduced-lag algorithms Trend-Dependent: Works best in trending markets, less effective in choppy conditions No Direction Prediction: Indicates volatility and deviation, not future direction, requires confirmation Enhanced Version Specific Considerations: Optimization Risk: More parameters increase risk of curve-fitting historical data Complexity: Additional choices may overwhelm beginning traders Backtesting Challenges: Different algorithms produce different historical results Mitigation Strategies: Use Confirmation: Combine with momentum indicators (RSI, MACD), volume, or price action Test Parameter Robustness: Ensure parameters work across range of values, not just optimized ones Multi-Timeframe Analysis: Confirm signals across different timeframes Proper Risk Management: Use appropriate position sizing and stops Start Simple: Begin with standard EMA/RMA before exploring alternatives Optimal Usage Recommendations: For Maximum Effectiveness: Start with standard EMA/RMA configuration to understand classic behavior Experiment with alternatives on demo account or paper trading Match algorithm combination to market condition and trading style Use channel width analysis to identify market phases Combine with complementary indicators for confirmation Implement strict risk management using ATR-based position sizing Focus on high-quality setups rather than trading every signal Respect the trend: trade with basis direction for higher probability Complementary Indicators: RSI or Stochastic: Confirm momentum at channel extremes MACD: Confirm trend direction and momentum shifts Volume: Validate breakouts and trend strength ADX: Measure trend strength, avoid Keltner signals in weak trends Support/Resistance: Combine with traditional levels for high-probability setups Bollinger Bands: Use together for enhanced breakout and volatility analysis USAGE NOTES This indicator is designed for technical analysis and educational purposes. Keltner Channel Enhanced has limitations and should not be used as the sole basis for trading decisions. While the flexible moving average selection for both trend and volatility components provides valuable adaptability across different market conditions, algorithm performance varies with market conditions, and past characteristics do not guarantee future results. Key considerations: Always use multiple forms of analysis and confirmation before entering trades Backtest any parameter combination thoroughly before live trading Be aware that optimization can lead to curve-fitting if not done carefully Start with standard EMA/RMA settings and adjust only when specific conditions warrant Understand that no moving average algorithm can eliminate lag entirely Consider market regime (trending, ranging, volatile) when selecting parameters Use ATR-based position sizing and risk management on every trade Keltner Channels work best in trending markets, less effective in choppy conditions Respect the trend direction indicated by price position relative to basis line The enhanced flexibility of dual algorithm selection provides powerful tools for adaptation but requires responsible use, thorough understanding of how different algorithms behave under various market conditions, and disciplined risk management.
Indicador Pine Script®
por DCAUT
Adv EMA Cloud v6 (ADX, Alerts)Summary: This indicator provides a multi-faceted view of market trends using Exponential Moving Averages (EMAs) arranged in visually intuitive clouds, enhanced with an optional ADX-based range filter and configurable alerts for key market conditions. It aims to help traders quickly gauge trend alignment across short, medium, and long timeframes while filtering signals during potentially choppy market conditions. Key Features: Multiple EMAs: Displays 10-period (Fast), 20-period (Mid), and 50-period (Slow) EMAs. Long-Term Trend Filter: Includes a 200-period EMA to provide context for the overall dominant trend direction. Dual EMA Clouds: Fast/Mid Cloud (10/20 EMA): Fills the area between the 10 and 20 EMAs. Defaults to Green when 10 > 20 (bullish short-term momentum) and Red when 10 < 20 (bearish short-term momentum). Mid/Slow Cloud (20/50 EMA): Fills the area between the 20 and 50 EMAs. Defaults to Aqua when 20 > 50 (bullish mid-term trend) and Fuchsia when 20 < 50 (bearish mid-term trend). Optional ADX Range Filter: Uses the Average Directional Index (ADX) to identify potentially non-trending or choppy markets. When enabled and ADX falls below a user-defined threshold, the EMA clouds will turn grey, visually warning that trend-following signals may be less reliable. Configurable Alerts: Provides several built-in alert conditions using Pine Script's alertcondition function: Confluence Condition: Triggers when a 10/20 EMA crossover occurs while both EMA clouds show alignment (both bullish/green/aqua or both bearish/red/fuchsia) and price respects the 200 EMA filter and the ADX filter indicates a trend (if filters are enabled). MA Filter Cross: Triggers when price crosses above or below the 200 EMA filter line. Full Alignment Start: Triggers on the first bar where full bullish or bearish alignment occurs (both clouds aligned + MA filter respected + ADX trending, if filters are enabled). How It Works: EMA Calculation: Standard Exponential Moving Averages are calculated for the 10, 20, 50, and 200 periods based on the closing price. Cloud Creation: The fill() function visually shades the area between the 10 & 20 EMAs and the 20 & 50 EMAs. Cloud Coloring: The color of each cloud is determined by the relationship between the two EMAs that define it (e.g., if EMA 10 is above EMA 20, the first cloud is bullish-colored). ADX Filter Logic: The script calculates the ADX value. If the "Use ADX Trend Filter?" input is checked and the calculated ADX is below the specified "ADX Trend Threshold", the script considers the market potentially ranging. ADX Visual Effect: During detected ranging periods (if the ADX filter is active), the plotCloud12Color and plotCloud23Color variables are assigned a neutral grey color instead of their normal bullish/bearish colors before being passed to the fill() function. Alert Logic: Boolean variables track the specific conditions (crossovers, cloud alignment, filter positions, ADX state). The alertcondition() function creates triggerable alerts based on these pre-defined conditions. Potential Interpretation (Not Financial Advice): Trend Alignment: When both clouds share the same directional color (e.g., both bullish - Green & Aqua) and price is on the corresponding side of the 200 EMA filter, it may suggest a stronger, more aligned trend. Conversely, conflicting cloud colors may indicate indecision or transition. Dynamic Support/Resistance: The EMA lines themselves (especially the 20, 50, and 200) can sometimes act as dynamic levels where price might react. Range Warning: Greyed-out clouds (when ADX filter is enabled) serve as a visual warning that trend-based strategies might face increased difficulty or whipsaws. Confluence Alerts: The specific confluence alerts signal moments where multiple conditions align (crossover + cloud agreement + filters), which some traders might view as higher-probability setups. Customization: All EMA lengths (10, 20, 50, 200) are adjustable via the Inputs menu. The ADX length and threshold are configurable. The MA Trend Filter and ADX Trend Filter can be independently enabled or disabled. Disclaimer: This indicator is provided for informational and educational purposes only. Trading financial markets involves significant risk. Past performance is not indicative of future results. Always conduct your own thorough analysis and consider your risk tolerance before making any trading decisions. This indicator should be used in conjunction with other analysis methods and tools. Do not trade based solely on the signals or visuals provided by this indicator.
Indicador Pine Script®
por epphllps
1
Dynamic Equity Allocation Model"Cash is Trash"? Not Always. Here's Why Science Beats Guesswork. Every retail trader knows the frustration: you draw support and resistance lines, you spot patterns, you follow market gurus on social media—and still, when the next bear market hits, your portfolio bleeds red. Meanwhile, institutional investors seem to navigate market turbulence with ease, preserving capital when markets crash and participating when they rally. What's their secret? The answer isn't insider information or access to exotic derivatives. It's systematic, scientifically validated decision-making. While most retail traders rely on subjective chart analysis and emotional reactions, professional portfolio managers use quantitative models that remove emotion from the equation and process multiple streams of market information simultaneously. This document presents exactly such a system—not a proprietary black box available only to hedge funds, but a fully transparent, academically grounded framework that any serious investor can understand and apply. The Dynamic Equity Allocation Model (DEAM) synthesizes decades of financial research from Nobel laureates and leading academics into a practical tool for tactical asset allocation. Stop drawing colorful lines on your chart and start thinking like a quant. This isn't about predicting where the market goes next week—it's about systematically adjusting your risk exposure based on what the data actually tells you. When valuations scream danger, when volatility spikes, when credit markets freeze, when multiple warning signals align—that's when cash isn't trash. That's when cash saves your portfolio. The irony of "cash is trash" rhetoric is that it ignores timing. Yes, being 100% cash for decades would be disastrous. But being 100% equities through every crisis is equally foolish. The sophisticated approach is dynamic: aggressive when conditions favor risk-taking, defensive when they don't. This model shows you how to make that decision systematically, not emotionally. Whether you're managing your own retirement portfolio or seeking to understand how institutional allocation strategies work, this comprehensive analysis provides the theoretical foundation, mathematical implementation, and practical guidance to elevate your investment approach from amateur to professional. The choice is yours: keep hoping your chart patterns work out, or start using the same quantitative methods that professionals rely on. The tools are here. The research is cited. The methodology is explained. All you need to do is read, understand, and apply. The Dynamic Equity Allocation Model (DEAM) is a quantitative framework for systematic allocation between equities and cash, grounded in modern portfolio theory and empirical market research. The model integrates five scientifically validated dimensions of market analysis—market regime, risk metrics, valuation, sentiment, and macroeconomic conditions—to generate dynamic allocation recommendations ranging from 0% to 100% equity exposure. This work documents the theoretical foundations, mathematical implementation, and practical application of this multi-factor approach. 1. Introduction and Theoretical Background 1.1 The Limitations of Static Portfolio Allocation Traditional portfolio theory, as formulated by Markowitz (1952) in his seminal work "Portfolio Selection," assumes an optimal static allocation where investors distribute their wealth across asset classes according to their risk aversion. This approach rests on the assumption that returns and risks remain constant over time. However, empirical research demonstrates that this assumption does not hold in reality. Fama and French (1989) showed that expected returns vary over time and correlate with macroeconomic variables such as the spread between long-term and short-term interest rates. Campbell and Shiller (1988) demonstrated that the price-earnings ratio possesses predictive power for future stock returns, providing a foundation for dynamic allocation strategies. The academic literature on tactical asset allocation has evolved considerably over recent decades. Ilmanen (2011) argues in "Expected Returns" that investors can improve their risk-adjusted returns by considering valuation levels, business cycles, and market sentiment. The Dynamic Equity Allocation Model presented here builds on this research tradition and operationalizes these insights into a practically applicable allocation framework. 1.2 Multi-Factor Approaches in Asset Allocation Modern financial research has shown that different factors capture distinct aspects of market dynamics and together provide a more robust picture of market conditions than individual indicators. Ross (1976) developed the Arbitrage Pricing Theory, a model that employs multiple factors to explain security returns. Following this multi-factor philosophy, DEAM integrates five complementary analytical dimensions, each tapping different information sources and collectively enabling comprehensive market understanding. 2. Data Foundation and Data Quality 2.1 Data Sources Used The model draws its data exclusively from publicly available market data via the TradingView platform. This transparency and accessibility is a significant advantage over proprietary models that rely on non-public data. The data foundation encompasses several categories of market information, each capturing specific aspects of market dynamics. First, price data for the S&P 500 Index is obtained through the SPDR S&P 500 ETF (ticker: SPY). The use of a highly liquid ETF instead of the index itself has practical reasons, as ETF data is available in real-time and reflects actual tradability. In addition to closing prices, high, low, and volume data are captured, which are required for calculating advanced volatility measures. Fundamental corporate metrics are retrieved via TradingView's Financial Data API. These include earnings per share, price-to-earnings ratio, return on equity, debt-to-equity ratio, dividend yield, and share buyback yield. Cochrane (2011) emphasizes in "Presidential Address: Discount Rates" the central importance of valuation metrics for forecasting future returns, making these fundamental data a cornerstone of the model. Volatility indicators are represented by the CBOE Volatility Index (VIX) and related metrics. The VIX, often referred to as the market's "fear gauge," measures the implied volatility of S&P 500 index options and serves as a proxy for market participants' risk perception. Whaley (2000) describes in "The Investor Fear Gauge" the construction and interpretation of the VIX and its use as a sentiment indicator. Macroeconomic data includes yield curve information through US Treasury bonds of various maturities and credit risk premiums through the spread between high-yield bonds and risk-free government bonds. These variables capture the macroeconomic conditions and financing conditions relevant for equity valuation. Estrella and Hardouvelis (1991) showed that the shape of the yield curve has predictive power for future economic activity, justifying the inclusion of these data. 2.2 Handling Missing Data A practical problem when working with financial data is dealing with missing or unavailable values. The model implements a fallback system where a plausible historical average value is stored for each fundamental metric. When current data is unavailable for a specific point in time, this fallback value is used. This approach ensures that the model remains functional even during temporary data outages and avoids systematic biases from missing data. The use of average values as fallback is conservative, as it generates neither overly optimistic nor pessimistic signals. 3. Component 1: Market Regime Detection 3.1 The Concept of Market Regimes The idea that financial markets exist in different "regimes" or states that differ in their statistical properties has a long tradition in financial science. Hamilton (1989) developed regime-switching models that allow distinguishing between different market states with different return and volatility characteristics. The practical application of this theory consists of identifying the current market state and adjusting portfolio allocation accordingly. DEAM classifies market regimes using a scoring system that considers three main dimensions: trend strength, volatility level, and drawdown depth. This multidimensional view is more robust than focusing on individual indicators, as it captures various facets of market dynamics. Classification occurs into six distinct regimes: Strong Bull, Bull Market, Neutral, Correction, Bear Market, and Crisis. 3.2 Trend Analysis Through Moving Averages Moving averages are among the oldest and most widely used technical indicators and have also received attention in academic literature. Brock, Lakonishok, and LeBaron (1992) examined in "Simple Technical Trading Rules and the Stochastic Properties of Stock Returns" the profitability of trading rules based on moving averages and found evidence for their predictive power, although later studies questioned the robustness of these results when considering transaction costs. The model calculates three moving averages with different time windows: a 20-day average (approximately one trading month), a 50-day average (approximately one quarter), and a 200-day average (approximately one trading year). The relationship of the current price to these averages and the relationship of the averages to each other provide information about trend strength and direction. When the price trades above all three averages and the short-term average is above the long-term, this indicates an established uptrend. The model assigns points based on these constellations, with longer-term trends weighted more heavily as they are considered more persistent. 3.3 Volatility Regimes Volatility, understood as the standard deviation of returns, is a central concept of financial theory and serves as the primary risk measure. However, research has shown that volatility is not constant but changes over time and occurs in clusters—a phenomenon first documented by Mandelbrot (1963) and later formalized through ARCH and GARCH models (Engle, 1982; Bollerslev, 1986). DEAM calculates volatility not only through the classic method of return standard deviation but also uses more advanced estimators such as the Parkinson estimator and the Garman-Klass estimator. These methods utilize intraday information (high and low prices) and are more efficient than simple close-to-close volatility estimators. The Parkinson estimator (Parkinson, 1980) uses the range between high and low of a trading day and is based on the recognition that this information reveals more about true volatility than just the closing price difference. The Garman-Klass estimator (Garman and Klass, 1980) extends this approach by additionally considering opening and closing prices. The calculated volatility is annualized by multiplying it by the square root of 252 (the average number of trading days per year), enabling standardized comparability. The model compares current volatility with the VIX, the implied volatility from option prices. A low VIX (below 15) signals market comfort and increases the regime score, while a high VIX (above 35) indicates market stress and reduces the score. This interpretation follows the empirical observation that elevated volatility is typically associated with falling markets (Schwert, 1989). 3.4 Drawdown Analysis A drawdown refers to the percentage decline from the highest point (peak) to the lowest point (trough) during a specific period. This metric is psychologically significant for investors as it represents the maximum loss experienced. Calmar (1991) developed the Calmar Ratio, which relates return to maximum drawdown, underscoring the practical relevance of this metric. The model calculates current drawdown as the percentage distance from the highest price of the last 252 trading days (one year). A drawdown below 3% is considered negligible and maximally increases the regime score. As drawdown increases, the score decreases progressively, with drawdowns above 20% classified as severe and indicating a crisis or bear market regime. These thresholds are empirically motivated by historical market cycles, in which corrections typically encompassed 5-10% drawdowns, bear markets 20-30%, and crises over 30%. 3.5 Regime Classification Final regime classification occurs through aggregation of scores from trend (40% weight), volatility (30%), and drawdown (30%). The higher weighting of trend reflects the empirical observation that trend-following strategies have historically delivered robust results (Moskowitz, Ooi, and Pedersen, 2012). A total score above 80 signals a strong bull market with established uptrend, low volatility, and minimal losses. At a score below 10, a crisis situation exists requiring defensive positioning. The six regime categories enable a differentiated allocation strategy that not only distinguishes binarily between bullish and bearish but allows gradual gradations. 4. Component 2: Risk-Based Allocation 4.1 Volatility Targeting as Risk Management Approach The concept of volatility targeting is based on the idea that investors should maximize not returns but risk-adjusted returns. Sharpe (1966, 1994) defined with the Sharpe Ratio the fundamental concept of return per unit of risk, measured as volatility. Volatility targeting goes a step further and adjusts portfolio allocation to achieve constant target volatility. This means that in times of low market volatility, equity allocation is increased, and in times of high volatility, it is reduced. Moreira and Muir (2017) showed in "Volatility-Managed Portfolios" that strategies that adjust their exposure based on volatility forecasts achieve higher Sharpe Ratios than passive buy-and-hold strategies. DEAM implements this principle by defining a target portfolio volatility (default 12% annualized) and adjusting equity allocation to achieve it. The mathematical foundation is simple: if market volatility is 20% and target volatility is 12%, equity allocation should be 60% (12/20 = 0.6), with the remaining 40% held in cash with zero volatility. 4.2 Market Volatility Calculation Estimating current market volatility is central to the risk-based allocation approach. The model uses several volatility estimators in parallel and selects the higher value between traditional close-to-close volatility and the Parkinson estimator. This conservative choice ensures the model does not underestimate true volatility, which could lead to excessive risk exposure. Traditional volatility calculation uses logarithmic returns, as these have mathematically advantageous properties (additive linkage over multiple periods). The logarithmic return is calculated as ln(P_t / P_{t-1}), where P_t is the price at time t. The standard deviation of these returns over a rolling 20-trading-day window is then multiplied by √252 to obtain annualized volatility. This annualization is based on the assumption of independently identically distributed returns, which is an idealization but widely accepted in practice. The Parkinson estimator uses additional information from the trading range (High minus Low) of each day. The formula is: σ_P = (1/√(4ln2)) × √(1/n × Σln²(H_i/L_i)) × √252, where H_i and L_i are high and low prices. Under ideal conditions, this estimator is approximately five times more efficient than the close-to-close estimator (Parkinson, 1980), as it uses more information per observation. 4.3 Drawdown-Based Position Size Adjustment In addition to volatility targeting, the model implements drawdown-based risk control. The logic is that deep market declines often signal further losses and therefore justify exposure reduction. This behavior corresponds with the concept of path-dependent risk tolerance: investors who have already suffered losses are typically less willing to take additional risk (Kahneman and Tversky, 1979). The model defines a maximum portfolio drawdown as a target parameter (default 15%). Since portfolio volatility and portfolio drawdown are proportional to equity allocation (assuming cash has neither volatility nor drawdown), allocation-based control is possible. For example, if the market exhibits a 25% drawdown and target portfolio drawdown is 15%, equity allocation should be at most 60% (15/25). 4.4 Dynamic Risk Adjustment An advanced feature of DEAM is dynamic adjustment of risk-based allocation through a feedback mechanism. The model continuously estimates what actual portfolio volatility and portfolio drawdown would result at the current allocation. If risk utilization (ratio of actual to target risk) exceeds 1.0, allocation is reduced by an adjustment factor that grows exponentially with overutilization. This implements a form of dynamic feedback that avoids overexposure. Mathematically, a risk adjustment factor r_adjust is calculated: if risk utilization u > 1, then r_adjust = exp(-0.5 × (u - 1)). This exponential function ensures that moderate overutilization is gently corrected, while strong overutilization triggers drastic reductions. The factor 0.5 in the exponent was empirically calibrated to achieve a balanced ratio between sensitivity and stability. 5. Component 3: Valuation Analysis 5.1 Theoretical Foundations of Fundamental Valuation DEAM's valuation component is based on the fundamental premise that the intrinsic value of a security is determined by its future cash flows and that deviations between market price and intrinsic value are eventually corrected. Graham and Dodd (1934) established in "Security Analysis" the basic principles of fundamental analysis that remain relevant today. Translated into modern portfolio context, this means that markets with high valuation metrics (high price-earnings ratios) should have lower expected returns than cheaply valued markets. Campbell and Shiller (1988) developed the Cyclically Adjusted P/E Ratio (CAPE), which smooths earnings over a full business cycle. Their empirical analysis showed that this ratio has significant predictive power for 10-year returns. Asness, Moskowitz, and Pedersen (2013) demonstrated in "Value and Momentum Everywhere" that value effects exist not only in individual stocks but also in asset classes and markets. 5.2 Equity Risk Premium as Central Valuation Metric The Equity Risk Premium (ERP) is defined as the expected excess return of stocks over risk-free government bonds. It is the theoretical heart of valuation analysis, as it represents the compensation investors demand for bearing equity risk. Damodaran (2012) discusses in "Equity Risk Premiums: Determinants, Estimation and Implications" various methods for ERP estimation. DEAM calculates ERP not through a single method but combines four complementary approaches with different weights. This multi-method strategy increases estimation robustness and avoids dependence on single, potentially erroneous inputs. The first method (35% weight) uses earnings yield, calculated as 1/P/E or directly from operating earnings data, and subtracts the 10-year Treasury yield. This method follows Fed Model logic (Yardeni, 2003), although this model has theoretical weaknesses as it does not consistently treat inflation (Asness, 2003). The second method (30% weight) extends earnings yield by share buyback yield. Share buybacks are a form of capital return to shareholders and increase value per share. Boudoukh et al. (2007) showed in "The Total Shareholder Yield" that the sum of dividend yield and buyback yield is a better predictor of future returns than dividend yield alone. The third method (20% weight) implements the Gordon Growth Model (Gordon, 1962), which models stock value as the sum of discounted future dividends. Under constant growth g assumption: Expected Return = Dividend Yield + g. The model estimates sustainable growth as g = ROE × (1 - Payout Ratio), where ROE is return on equity and payout ratio is the ratio of dividends to earnings. This formula follows from equity theory: unretained earnings are reinvested at ROE and generate additional earnings growth. The fourth method (15% weight) combines total shareholder yield (Dividend + Buybacks) with implied growth derived from revenue growth. This method considers that companies with strong revenue growth should generate higher future earnings, even if current valuations do not yet fully reflect this. The final ERP is the weighted average of these four methods. A high ERP (above 4%) signals attractive valuations and increases the valuation score to 95 out of 100 possible points. A negative ERP, where stocks have lower expected returns than bonds, results in a minimal score of 10. 5.3 Quality Adjustments to Valuation Valuation metrics alone can be misleading if not interpreted in the context of company quality. A company with a low P/E may be cheap or fundamentally problematic. The model therefore implements quality adjustments based on growth, profitability, and capital structure. Revenue growth above 10% annually adds 10 points to the valuation score, moderate growth above 5% adds 5 points. This adjustment reflects that growth has independent value (Modigliani and Miller, 1961, extended by later growth theory). Net margin above 15% signals pricing power and operational efficiency and increases the score by 5 points, while low margins below 8% indicate competitive pressure and subtract 5 points. Return on equity (ROE) above 20% characterizes outstanding capital efficiency and increases the score by 5 points. Piotroski (2000) showed in "Value Investing: The Use of Historical Financial Statement Information" that fundamental quality signals such as high ROE can improve the performance of value strategies. Capital structure is evaluated through the debt-to-equity ratio. A conservative ratio below 1.0 multiplies the valuation score by 1.2, while high leverage above 2.0 applies a multiplier of 0.8. This adjustment reflects that high debt constrains financial flexibility and can become problematic in crisis times (Korteweg, 2010). 6. Component 4: Sentiment Analysis 6.1 The Role of Sentiment in Financial Markets Investor sentiment, defined as the collective psychological attitude of market participants, influences asset prices independently of fundamental data. Baker and Wurgler (2006, 2007) developed a sentiment index and showed that periods of high sentiment are followed by overvaluations that later correct. This insight justifies integrating a sentiment component into allocation decisions. Sentiment is difficult to measure directly but can be proxied through market indicators. The VIX is the most widely used sentiment indicator, as it aggregates implied volatility from option prices. High VIX values reflect elevated uncertainty and risk aversion, while low values signal market comfort. Whaley (2009) refers to the VIX as the "Investor Fear Gauge" and documents its role as a contrarian indicator: extremely high values typically occur at market bottoms, while low values occur at tops. 6.2 VIX-Based Sentiment Assessment DEAM uses statistical normalization of the VIX by calculating the Z-score: z = (VIX_current - VIX_average) / VIX_standard_deviation. The Z-score indicates how many standard deviations the current VIX is from the historical average. This approach is more robust than absolute thresholds, as it adapts to the average volatility level, which can vary over longer periods. A Z-score below -1.5 (VIX is 1.5 standard deviations below average) signals exceptionally low risk perception and adds 40 points to the sentiment score. This may seem counterintuitive—shouldn't low fear be bullish? However, the logic follows the contrarian principle: when no one is afraid, everyone is already invested, and there is limited further upside potential (Zweig, 1973). Conversely, a Z-score above 1.5 (extreme fear) adds -40 points, reflecting market panic but simultaneously suggesting potential buying opportunities. 6.3 VIX Term Structure as Sentiment Signal The VIX term structure provides additional sentiment information. Normally, the VIX trades in contango, meaning longer-term VIX futures have higher prices than short-term. This reflects that short-term volatility is currently known, while long-term volatility is more uncertain and carries a risk premium. The model compares the VIX with VIX9D (9-day volatility) and identifies backwardation (VIX > 1.05 × VIX9D) and steep backwardation (VIX > 1.15 × VIX9D). Backwardation occurs when short-term implied volatility is higher than longer-term, which typically happens during market stress. Investors anticipate immediate turbulence but expect calming. Psychologically, this reflects acute fear. The model subtracts 15 points for backwardation and 30 for steep backwardation, as these constellations signal elevated risk. Simon and Wiggins (2001) analyzed the VIX futures curve and showed that backwardation is associated with market declines. 6.4 Safe-Haven Flows During crisis times, investors flee from risky assets into safe havens: gold, US dollar, and Japanese yen. This "flight to quality" is a sentiment signal. The model calculates the performance of these assets relative to stocks over the last 20 trading days. When gold or the dollar strongly rise while stocks fall, this indicates elevated risk aversion. The safe-haven component is calculated as the difference between safe-haven performance and stock performance. Positive values (safe havens outperform) subtract up to 20 points from the sentiment score, negative values (stocks outperform) add up to 10 points. The asymmetric treatment (larger deduction for risk-off than bonus for risk-on) reflects that risk-off movements are typically sharper and more informative than risk-on phases. Baur and Lucey (2010) examined safe-haven properties of gold and showed that gold indeed exhibits negative correlation with stocks during extreme market movements, confirming its role as crisis protection. 7. Component 5: Macroeconomic Analysis 7.1 The Yield Curve as Economic Indicator The yield curve, represented as yields of government bonds of various maturities, contains aggregated expectations about future interest rates, inflation, and economic growth. The slope of the yield curve has remarkable predictive power for recessions. Estrella and Mishkin (1998) showed that an inverted yield curve (short-term rates higher than long-term) predicts recessions with high reliability. This is because inverted curves reflect restrictive monetary policy: the central bank raises short-term rates to combat inflation, dampening economic activity. DEAM calculates two spread measures: the 2-year-minus-10-year spread and the 3-month-minus-10-year spread. A steep, positive curve (spreads above 1.5% and 2% respectively) signals healthy growth expectations and generates the maximum yield curve score of 40 points. A flat curve (spreads near zero) reduces the score to 20 points. An inverted curve (negative spreads) is particularly alarming and results in only 10 points. The choice of two different spreads increases analysis robustness. The 2-10 spread is most established in academic literature, while the 3M-10Y spread is often considered more sensitive, as the 3-month rate directly reflects current monetary policy (Ang, Piazzesi, and Wei, 2006). 7.2 Credit Conditions and Spreads Credit spreads—the yield difference between risky corporate bonds and safe government bonds—reflect risk perception in the credit market. Gilchrist and Zakrajšek (2012) constructed an "Excess Bond Premium" that measures the component of credit spreads not explained by fundamentals and showed this is a predictor of future economic activity and stock returns. The model approximates credit spread by comparing the yield of high-yield bond ETFs (HYG) with investment-grade bond ETFs (LQD). A narrow spread below 200 basis points signals healthy credit conditions and risk appetite, contributing 30 points to the macro score. Very wide spreads above 1000 basis points (as during the 2008 financial crisis) signal credit crunch and generate zero points. Additionally, the model evaluates whether "flight to quality" is occurring, identified through strong performance of Treasury bonds (TLT) with simultaneous weakness in high-yield bonds. This constellation indicates elevated risk aversion and reduces the credit conditions score. 7.3 Financial Stability at Corporate Level While the yield curve and credit spreads reflect macroeconomic conditions, financial stability evaluates the health of companies themselves. The model uses the aggregated debt-to-equity ratio and return on equity of the S&P 500 as proxies for corporate health. A low leverage level below 0.5 combined with high ROE above 15% signals robust corporate balance sheets and generates 20 points. This combination is particularly valuable as it represents both defensive strength (low debt means crisis resistance) and offensive strength (high ROE means earnings power). High leverage above 1.5 generates only 5 points, as it implies vulnerability to interest rate increases and recessions. Korteweg (2010) showed in "The Net Benefits to Leverage" that optimal debt maximizes firm value, but excessive debt increases distress costs. At the aggregated market level, high debt indicates fragilities that can become problematic during stress phases. 8. Component 6: Crisis Detection 8.1 The Need for Systematic Crisis Detection Financial crises are rare but extremely impactful events that suspend normal statistical relationships. During normal market volatility, diversified portfolios and traditional risk management approaches function, but during systemic crises, seemingly independent assets suddenly correlate strongly, and losses exceed historical expectations (Longin and Solnik, 2001). This justifies a separate crisis detection mechanism that operates independently of regular allocation components. Reinhart and Rogoff (2009) documented in "This Time Is Different: Eight Centuries of Financial Folly" recurring patterns in financial crises: extreme volatility, massive drawdowns, credit market dysfunction, and asset price collapse. DEAM operationalizes these patterns into quantifiable crisis indicators. 8.2 Multi-Signal Crisis Identification The model uses a counter-based approach where various stress signals are identified and aggregated. This methodology is more robust than relying on a single indicator, as true crises typically occur simultaneously across multiple dimensions. A single signal may be a false alarm, but the simultaneous presence of multiple signals increases confidence. The first indicator is a VIX above the crisis threshold (default 40), adding one point. A VIX above 60 (as in 2008 and March 2020) adds two additional points, as such extreme values are historically very rare. This tiered approach captures the intensity of volatility. The second indicator is market drawdown. A drawdown above 15% adds one point, as corrections of this magnitude can be potential harbingers of larger crises. A drawdown above 25% adds another point, as historical bear markets typically encompass 25-40% drawdowns. The third indicator is credit market spreads above 500 basis points, adding one point. Such wide spreads occur only during significant credit market disruptions, as in 2008 during the Lehman crisis. The fourth indicator identifies simultaneous losses in stocks and bonds. Normally, Treasury bonds act as a hedge against equity risk (negative correlation), but when both fall simultaneously, this indicates systemic liquidity problems or inflation/stagflation fears. The model checks whether both SPY and TLT have fallen more than 10% and 5% respectively over 5 trading days, adding two points. The fifth indicator is a volume spike combined with negative returns. Extreme trading volumes (above twice the 20-day average) with falling prices signal panic selling. This adds one point. A crisis situation is diagnosed when at least 3 indicators trigger, a severe crisis at 5 or more indicators. These thresholds were calibrated through historical backtesting to identify true crises (2008, 2020) without generating excessive false alarms. 8.3 Crisis-Based Allocation Override When a crisis is detected, the system overrides the normal allocation recommendation and caps equity allocation at maximum 25%. In a severe crisis, the cap is set at 10%. This drastic defensive posture follows the empirical observation that crises typically require time to develop and that early reduction can avoid substantial losses (Faber, 2007). This override logic implements a "safety first" principle: in situations of existential danger to the portfolio, capital preservation becomes the top priority. Roy (1952) formalized this approach in "Safety First and the Holding of Assets," arguing that investors should primarily minimize ruin probability. 9. Integration and Final Allocation Calculation 9.1 Component Weighting The final allocation recommendation emerges through weighted aggregation of the five components. The standard weighting is: Market Regime 35%, Risk Management 25%, Valuation 20%, Sentiment 15%, Macro 5%. These weights reflect both theoretical considerations and empirical backtesting results. The highest weighting of market regime is based on evidence that trend-following and momentum strategies have delivered robust results across various asset classes and time periods (Moskowitz, Ooi, and Pedersen, 2012). Current market momentum is highly informative for the near future, although it provides no information about long-term expectations. The substantial weighting of risk management (25%) follows from the central importance of risk control. Wealth preservation is the foundation of long-term wealth creation, and systematic risk management is demonstrably value-creating (Moreira and Muir, 2017). The valuation component receives 20% weight, based on the long-term mean reversion of valuation metrics. While valuation has limited short-term predictive power (bull and bear markets can begin at any valuation), the long-term relationship between valuation and returns is robustly documented (Campbell and Shiller, 1988). Sentiment (15%) and Macro (5%) receive lower weights, as these factors are subtler and harder to measure. Sentiment is valuable as a contrarian indicator at extremes but less informative in normal ranges. Macro variables such as the yield curve have strong predictive power for recessions, but the transmission from recessions to stock market performance is complex and temporally variable. 9.2 Model Type Adjustments DEAM allows users to choose between four model types: Conservative, Balanced, Aggressive, and Adaptive. This choice modifies the final allocation through additive adjustments. Conservative mode subtracts 10 percentage points from allocation, resulting in consistently more cautious positioning. This is suitable for risk-averse investors or those with limited investment horizons. Aggressive mode adds 10 percentage points, suitable for risk-tolerant investors with long horizons. Adaptive mode implements procyclical adjustment based on short-term momentum: if the market has risen more than 5% in the last 20 days, 5 percentage points are added; if it has declined more than 5%, 5 points are subtracted. This logic follows the observation that short-term momentum persists (Jegadeesh and Titman, 1993), but the moderate size of adjustment avoids excessive timing bets. Balanced mode makes no adjustment and uses raw model output. This neutral setting is suitable for investors who wish to trust model recommendations unchanged. 9.3 Smoothing and Stability The allocation resulting from aggregation undergoes final smoothing through a simple moving average over 3 periods. This smoothing is crucial for model practicality, as it reduces frequent trading and thus transaction costs. Without smoothing, the model could fluctuate between adjacent allocations with every small input change. The choice of 3 periods as smoothing window is a compromise between responsiveness and stability. Longer smoothing would excessively delay signals and impede response to true regime changes. Shorter or no smoothing would allow too much noise. Empirical tests showed that 3-period smoothing offers an optimal ratio between these goals. 10. Visualization and Interpretation 10.1 Main Output: Equity Allocation DEAM's primary output is a time series from 0 to 100 representing the recommended percentage allocation to equities. This representation is intuitive: 100% means full investment in stocks (specifically: an S&P 500 ETF), 0% means complete cash position, and intermediate values correspond to mixed portfolios. A value of 60% means, for example: invest 60% of wealth in SPY, hold 40% in money market instruments or cash. The time series is color-coded to enable quick visual interpretation. Green shades represent high allocations (above 80%, bullish), red shades low allocations (below 20%, bearish), and neutral colors middle allocations. The chart background is dynamically colored based on the signal, enhancing readability in different market phases. 10.2 Dashboard Metrics A tabular dashboard presents key metrics compactly. This includes current allocation, cash allocation (complement), an aggregated signal (BULLISH/NEUTRAL/BEARISH), current market regime, VIX level, market drawdown, and crisis status. Additionally, fundamental metrics are displayed: P/E Ratio, Equity Risk Premium, Return on Equity, Debt-to-Equity Ratio, and Total Shareholder Yield. This transparency allows users to understand model decisions and form their own assessments. Component scores (Regime, Risk, Valuation, Sentiment, Macro) are also displayed, each normalized on a 0-100 scale. This shows which factors primarily drive the current recommendation. If, for example, the Risk score is very low (20) while other scores are moderate (50-60), this indicates that risk management considerations are pulling allocation down. 10.3 Component Breakdown (Optional) Advanced users can display individual components as separate lines in the chart. This enables analysis of component dynamics: do all components move synchronously, or are there divergences? Divergences can be particularly informative. If, for example, the market regime is bullish (high score) but the valuation component is very negative, this signals an overbought market not fundamentally supported—a classic "bubble warning." This feature is disabled by default to keep the chart clean but can be activated for deeper analysis. 10.4 Confidence Bands The model optionally displays uncertainty bands around the main allocation line. These are calculated as ±1 standard deviation of allocation over a rolling 20-period window. Wide bands indicate high volatility of model recommendations, suggesting uncertain market conditions. Narrow bands indicate stable recommendations. This visualization implements a concept of epistemic uncertainty—uncertainty about the model estimate itself, not just market volatility. In phases where various indicators send conflicting signals, the allocation recommendation becomes more volatile, manifesting in wider bands. Users can understand this as a warning to act more cautiously or consult alternative information sources. 11. Alert System 11.1 Allocation Alerts DEAM implements an alert system that notifies users of significant events. Allocation alerts trigger when smoothed allocation crosses certain thresholds. An alert is generated when allocation reaches 80% (from below), signaling strong bullish conditions. Another alert triggers when allocation falls to 20%, indicating defensive positioning. These thresholds are not arbitrary but correspond with boundaries between model regimes. An allocation of 80% roughly corresponds to a clear bull market regime, while 20% corresponds to a bear market regime. Alerts at these points are therefore informative about fundamental regime shifts. 11.2 Crisis Alerts Separate alerts trigger upon detection of crisis and severe crisis. These alerts have highest priority as they signal large risks. A crisis alert should prompt investors to review their portfolio and potentially take defensive measures beyond the automatic model recommendation (e.g., hedging through put options, rebalancing to more defensive sectors). 11.3 Regime Change Alerts An alert triggers upon change of market regime (e.g., from Neutral to Correction, or from Bull Market to Strong Bull). Regime changes are highly informative events that typically entail substantial allocation changes. These alerts enable investors to proactively respond to changes in market dynamics. 11.4 Risk Breach Alerts A specialized alert triggers when actual portfolio risk utilization exceeds target parameters by 20%. This is a warning signal that the risk management system is reaching its limits, possibly because market volatility is rising faster than allocation can be reduced. In such situations, investors should consider manual interventions. 12. Practical Application and Limitations 12.1 Portfolio Implementation DEAM generates a recommendation for allocation between equities (S&P 500) and cash. Implementation by an investor can take various forms. The most direct method is using an S&P 500 ETF (e.g., SPY, VOO) for equity allocation and a money market fund or savings account for cash allocation. A rebalancing strategy is required to synchronize actual allocation with model recommendation. Two approaches are possible: (1) rule-based rebalancing at every 10% deviation between actual and target, or (2) time-based monthly rebalancing. Both have trade-offs between responsiveness and transaction costs. Empirical evidence (Jaconetti, Kinniry, and Zilbering, 2010) suggests rebalancing frequency has moderate impact on performance, and investors should optimize based on their transaction costs. 12.2 Adaptation to Individual Preferences The model offers numerous adjustment parameters. Component weights can be modified if investors place more or less belief in certain factors. A fundamentally-oriented investor might increase valuation weight, while a technical trader might increase regime weight. Risk target parameters (target volatility, max drawdown) should be adapted to individual risk tolerance. Younger investors with long investment horizons can choose higher target volatility (15-18%), while retirees may prefer lower volatility (8-10%). This adjustment systematically shifts average equity allocation. Crisis thresholds can be adjusted based on preference for sensitivity versus specificity of crisis detection. Lower thresholds (e.g., VIX > 35 instead of 40) increase sensitivity (more crises are detected) but reduce specificity (more false alarms). Higher thresholds have the reverse effect. 12.3 Limitations and Disclaimers DEAM is based on historical relationships between indicators and market performance. There is no guarantee these relationships will persist in the future. Structural changes in markets (e.g., through regulation, technology, or central bank policy) can break established patterns. This is the fundamental problem of induction in financial science (Taleb, 2007). The model is optimized for US equities (S&P 500). Application to other markets (international stocks, bonds, commodities) would require recalibration. The indicators and thresholds are specific to the statistical properties of the US equity market. The model cannot eliminate losses. Even with perfect crisis prediction, an investor following the model would lose money in bear markets—just less than a buy-and-hold investor. The goal is risk-adjusted performance improvement, not risk elimination. Transaction costs are not modeled. In practice, spreads, commissions, and taxes reduce net returns. Frequent trading can cause substantial costs. Model smoothing helps minimize this, but users should consider their specific cost situation. The model reacts to information; it does not anticipate it. During sudden shocks (e.g., 9/11, COVID-19 lockdowns), the model can only react after price movements, not before. This limitation is inherent to all reactive systems. 12.4 Relationship to Other Strategies DEAM is a tactical asset allocation approach and should be viewed as a complement, not replacement, for strategic asset allocation. Brinson, Hood, and Beebower (1986) showed in their influential study "Determinants of Portfolio Performance" that strategic asset allocation (long-term policy allocation) explains the majority of portfolio performance, but this leaves room for tactical adjustments based on market timing. The model can be combined with value and momentum strategies at the individual stock level. While DEAM controls overall market exposure, within-equity decisions can be optimized through stock-picking models. This separation between strategic (market exposure) and tactical (stock selection) levels follows classical portfolio theory. The model does not replace diversification across asset classes. A complete portfolio should also include bonds, international stocks, real estate, and alternative investments. DEAM addresses only the US equity allocation decision within a broader portfolio. 13. Scientific Foundation and Evaluation 13.1 Theoretical Consistency DEAM's components are based on established financial theory and empirical evidence. The market regime component follows from regime-switching models (Hamilton, 1989) and trend-following literature. The risk management component implements volatility targeting (Moreira and Muir, 2017) and modern portfolio theory (Markowitz, 1952). The valuation component is based on discounted cash flow theory and empirical value research (Campbell and Shiller, 1988; Fama and French, 1992). The sentiment component integrates behavioral finance (Baker and Wurgler, 2006). The macro component uses established business cycle indicators (Estrella and Mishkin, 1998). This theoretical grounding distinguishes DEAM from purely data-mining-based approaches that identify patterns without causal theory. Theory-guided models have greater probability of functioning out-of-sample, as they are based on fundamental mechanisms, not random correlations (Lo and MacKinlay, 1990). 13.2 Empirical Validation While this document does not present detailed backtest analysis, it should be noted that rigorous validation of a tactical asset allocation model should include several elements: In-sample testing establishes whether the model functions at all in the data on which it was calibrated. Out-of-sample testing is crucial: the model should be tested in time periods not used for development. Walk-forward analysis, where the model is successively trained on rolling windows and tested in the next window, approximates real implementation. Performance metrics should be risk-adjusted. Pure return consideration is misleading, as higher returns often only compensate for higher risk. Sharpe Ratio, Sortino Ratio, Calmar Ratio, and Maximum Drawdown are relevant metrics. Comparison with benchmarks (Buy-and-Hold S&P 500, 60/40 Stock/Bond portfolio) contextualizes performance. Robustness checks test sensitivity to parameter variation. If the model only functions at specific parameter settings, this indicates overfitting. Robust models show consistent performance over a range of plausible parameters. 13.3 Comparison with Existing Literature DEAM fits into the broader literature on tactical asset allocation. Faber (2007) presented a simple momentum-based timing system that goes long when the market is above its 10-month average, otherwise cash. This simple system avoided large drawdowns in bear markets. DEAM can be understood as a sophistication of this approach that integrates multiple information sources. Ilmanen (2011) discusses various timing factors in "Expected Returns" and argues for multi-factor approaches. DEAM operationalizes this philosophy. Asness, Moskowitz, and Pedersen (2013) showed that value and momentum effects work across asset classes, justifying cross-asset application of regime and valuation signals. Ang (2014) emphasizes in "Asset Management: A Systematic Approach to Factor Investing" the importance of systematic, rule-based approaches over discretionary decisions. DEAM is fully systematic and eliminates emotional biases that plague individual investors (overconfidence, hindsight bias, loss aversion). References Ang, A. (2014) *Asset Management: A Systematic Approach to Factor Investing*. Oxford: Oxford University Press. Ang, A., Piazzesi, M. and Wei, M. (2006) 'What does the yield curve tell us about GDP growth?', *Journal of Econometrics*, 131(1-2), pp. 359-403. Asness, C.S. (2003) 'Fight the Fed Model', *The Journal of Portfolio Management*, 30(1), pp. 11-24. Asness, C.S., Moskowitz, T.J. and Pedersen, L.H. (2013) 'Value and Momentum Everywhere', *The Journal of Finance*, 68(3), pp. 929-985. Baker, M. and Wurgler, J. (2006) 'Investor Sentiment and the Cross-Section of Stock Returns', *The Journal of Finance*, 61(4), pp. 1645-1680. Baker, M. and Wurgler, J. (2007) 'Investor Sentiment in the Stock Market', *Journal of Economic Perspectives*, 21(2), pp. 129-152. Baur, D.G. and Lucey, B.M. (2010) 'Is Gold a Hedge or a Safe Haven? An Analysis of Stocks, Bonds and Gold', *Financial Review*, 45(2), pp. 217-229. Bollerslev, T. (1986) 'Generalized Autoregressive Conditional Heteroskedasticity', *Journal of Econometrics*, 31(3), pp. 307-327. Boudoukh, J., Michaely, R., Richardson, M. and Roberts, M.R. (2007) 'On the Importance of Measuring Payout Yield: Implications for Empirical Asset Pricing', *The Journal of Finance*, 62(2), pp. 877-915. Brinson, G.P., Hood, L.R. and Beebower, G.L. (1986) 'Determinants of Portfolio Performance', *Financial Analysts Journal*, 42(4), pp. 39-44. Brock, W., Lakonishok, J. and LeBaron, B. (1992) 'Simple Technical Trading Rules and the Stochastic Properties of Stock Returns', *The Journal of Finance*, 47(5), pp. 1731-1764. Calmar, T.W. (1991) 'The Calmar Ratio', *Futures*, October issue. Campbell, J.Y. and Shiller, R.J. (1988) 'The Dividend-Price Ratio and Expectations of Future Dividends and Discount Factors', *Review of Financial Studies*, 1(3), pp. 195-228. Cochrane, J.H. (2011) 'Presidential Address: Discount Rates', *The Journal of Finance*, 66(4), pp. 1047-1108. Damodaran, A. (2012) *Equity Risk Premiums: Determinants, Estimation and Implications*. Working Paper, Stern School of Business. Engle, R.F. (1982) 'Autoregressive Conditional Heteroskedasticity with Estimates of the Variance of United Kingdom Inflation', *Econometrica*, 50(4), pp. 987-1007. Estrella, A. and Hardouvelis, G.A. (1991) 'The Term Structure as a Predictor of Real Economic Activity', *The Journal of Finance*, 46(2), pp. 555-576. Estrella, A. and Mishkin, F.S. (1998) 'Predicting U.S. Recessions: Financial Variables as Leading Indicators', *Review of Economics and Statistics*, 80(1), pp. 45-61. Faber, M.T. (2007) 'A Quantitative Approach to Tactical Asset Allocation', *The Journal of Wealth Management*, 9(4), pp. 69-79. Fama, E.F. and French, K.R. (1989) 'Business Conditions and Expected Returns on Stocks and Bonds', *Journal of Financial Economics*, 25(1), pp. 23-49. Fama, E.F. and French, K.R. (1992) 'The Cross-Section of Expected Stock Returns', *The Journal of Finance*, 47(2), pp. 427-465. Garman, M.B. and Klass, M.J. (1980) 'On the Estimation of Security Price Volatilities from Historical Data', *Journal of Business*, 53(1), pp. 67-78. Gilchrist, S. and Zakrajšek, E. (2012) 'Credit Spreads and Business Cycle Fluctuations', *American Economic Review*, 102(4), pp. 1692-1720. Gordon, M.J. (1962) *The Investment, Financing, and Valuation of the Corporation*. Homewood: Irwin. Graham, B. and Dodd, D.L. (1934) *Security Analysis*. New York: McGraw-Hill. Hamilton, J.D. (1989) 'A New Approach to the Economic Analysis of Nonstationary Time Series and the Business Cycle', *Econometrica*, 57(2), pp. 357-384. Ilmanen, A. (2011) *Expected Returns: An Investor's Guide to Harvesting Market Rewards*. Chichester: Wiley. Jaconetti, C.M., Kinniry, F.M. and Zilbering, Y. (2010) 'Best Practices for Portfolio Rebalancing', *Vanguard Research Paper*. Jegadeesh, N. and Titman, S. (1993) 'Returns to Buying Winners and Selling Losers: Implications for Stock Market Efficiency', *The Journal of Finance*, 48(1), pp. 65-91. Kahneman, D. and Tversky, A. (1979) 'Prospect Theory: An Analysis of Decision under Risk', *Econometrica*, 47(2), pp. 263-292. Korteweg, A. (2010) 'The Net Benefits to Leverage', *The Journal of Finance*, 65(6), pp. 2137-2170. Lo, A.W. and MacKinlay, A.C. (1990) 'Data-Snooping Biases in Tests of Financial Asset Pricing Models', *Review of Financial Studies*, 3(3), pp. 431-467. Longin, F. and Solnik, B. (2001) 'Extreme Correlation of International Equity Markets', *The Journal of Finance*, 56(2), pp. 649-676. Mandelbrot, B. (1963) 'The Variation of Certain Speculative Prices', *The Journal of Business*, 36(4), pp. 394-419. Markowitz, H. (1952) 'Portfolio Selection', *The Journal of Finance*, 7(1), pp. 77-91. Modigliani, F. and Miller, M.H. (1961) 'Dividend Policy, Growth, and the Valuation of Shares', *The Journal of Business*, 34(4), pp. 411-433. Moreira, A. and Muir, T. (2017) 'Volatility-Managed Portfolios', *The Journal of Finance*, 72(4), pp. 1611-1644. Moskowitz, T.J., Ooi, Y.H. and Pedersen, L.H. (2012) 'Time Series Momentum', *Journal of Financial Economics*, 104(2), pp. 228-250. Parkinson, M. (1980) 'The Extreme Value Method for Estimating the Variance of the Rate of Return', *Journal of Business*, 53(1), pp. 61-65. Piotroski, J.D. (2000) 'Value Investing: The Use of Historical Financial Statement Information to Separate Winners from Losers', *Journal of Accounting Research*, 38, pp. 1-41. Reinhart, C.M. and Rogoff, K.S. (2009) *This Time Is Different: Eight Centuries of Financial Folly*. Princeton: Princeton University Press. Ross, S.A. (1976) 'The Arbitrage Theory of Capital Asset Pricing', *Journal of Economic Theory*, 13(3), pp. 341-360. Roy, A.D. (1952) 'Safety First and the Holding of Assets', *Econometrica*, 20(3), pp. 431-449. Schwert, G.W. (1989) 'Why Does Stock Market Volatility Change Over Time?', *The Journal of Finance*, 44(5), pp. 1115-1153. Sharpe, W.F. (1966) 'Mutual Fund Performance', *The Journal of Business*, 39(1), pp. 119-138. Sharpe, W.F. (1994) 'The Sharpe Ratio', *The Journal of Portfolio Management*, 21(1), pp. 49-58. Simon, D.P. and Wiggins, R.A. (2001) 'S&P Futures Returns and Contrary Sentiment Indicators', *Journal of Futures Markets*, 21(5), pp. 447-462. Taleb, N.N. (2007) *The Black Swan: The Impact of the Highly Improbable*. New York: Random House. Whaley, R.E. (2000) 'The Investor Fear Gauge', *The Journal of Portfolio Management*, 26(3), pp. 12-17. Whaley, R.E. (2009) 'Understanding the VIX', *The Journal of Portfolio Management*, 35(3), pp. 98-105. Yardeni, E. (2003) 'Stock Valuation Models', *Topical Study*, 51, Yardeni Research. Zweig, M.E. (1973) 'An Investor Expectations Stock Price Predictive Model Using Closed-End Fund Premiums', *The Journal of Finance*, 28(1), pp. 67-78.
Indicador Pine Script®
por EdgeTools
12
DAX ORB Ultimate - ALGO Suite//@version=5 indicator("DAX ORB Ultimate - ALGO Suite", overlay=true, max_labels_count=200, max_lines_count=100) // ═══════════════════════════════════════════════════════════════════════════════ // DAX OPENING RANGE BREAKOUT - ULTIMATE EDITION // Real-time ORB building | Multi-timeframe support | Key levels with bias // Works on ANY timeframe - uses M1 data for ORB construction // ═══════════════════════════════════════════════════════════════════════════════ // ════════════════════════ INPUTS ════════════════════════ orb_start_h = input.int(7, "Start Hour (UTC)", minval=0, maxval=23, group="ORB Settings") orb_start_m = input.int(40, "Start Minute", minval=0, maxval=59, group="ORB Settings") orb_end_h = input.int(8, "End Hour (UTC)", minval=0, maxval=23, group="ORB Settings") orb_end_m = input.int(0, "End Minute", minval=0, maxval=59, group="ORB Settings") exclude_wicks = input.bool(true, "Exclude Wicks", group="ORB Settings") close_hour = input.int(16, "Market Close Hour", minval=0, maxval=23, group="ORB Settings") use_tf = input.bool(true, "1. Trend Following", group="Strategies") use_mr = input.bool(true, "2. Mean Reversion", group="Strategies") use_sa = input.bool(true, "3. Statistical Arb", group="Strategies") use_mm = input.bool(true, "4. Market Making", group="Strategies") use_ba = input.bool(true, "5. Basis Arb", group="Strategies") use_ema = input.bool(true, "EMA Filter", group="Technical Filters") use_rsi = input.bool(true, "RSI Filter", group="Technical Filters") use_macd = input.bool(true, "MACD Filter", group="Technical Filters") use_vol = input.bool(true, "Volume Filter", group="Technical Filters") use_bb = input.bool(true, "Bollinger Filter", group="Technical Filters") use_fixed = input.bool(false, "Fixed SL/TP", group="Risk Management") fixed_sl = input.float(50, "Fixed SL Points", minval=10, group="Risk Management") fixed_tp = input.float(150, "Fixed TP Points", minval=10, group="Risk Management") atr_sl = input.float(2.0, "ATR SL Mult", minval=0.5, group="Risk Management") atr_tp = input.float(3.0, "ATR TP Mult", minval=0.5, group="Risk Management") min_rr = input.float(2.0, "Min R:R", minval=1.0, group="Risk Management") show_dash = input.bool(true, "Show Dashboard", group="Display") show_lines = input.bool(true, "Show Lines", group="Display") show_levels = input.bool(true, "Show Key Levels", group="Display") // ════════════════════════ FUNCTIONS ════════════════════════ is_orb_period(_h, _m) => start = orb_start_h * 60 + orb_start_m end = orb_end_h * 60 + orb_end_m curr = _h * 60 + _m curr >= start and curr < end orb_ended(_h, _m) => end = orb_end_h * 60 + orb_end_m curr = _h * 60 + _m curr == end is_market_open() => h = hour(time) h >= orb_start_h and h <= close_hour // ════════════════════════ DATA GATHERING (M1) ════════════════════════ // Get M1 data for ORB construction (works on ANY chart timeframe) = request.security(syminfo.tickerid, "1", , barmerge.gaps_off, barmerge.lookahead_off) // Daily data d_high = request.security(syminfo.tickerid, "D", high, barmerge.gaps_off, barmerge.lookahead_on) d_low = request.security(syminfo.tickerid, "D", low, barmerge.gaps_off, barmerge.lookahead_on) d_open = request.security(syminfo.tickerid, "D", open, barmerge.gaps_off, barmerge.lookahead_on) // Current day high/low (intraday) var float today_high = na var float today_low = na var float prev_day_high = na var float prev_day_low = na var float yest_size = 0 if ta.change(time("D")) != 0 prev_day_high := d_high prev_day_low := d_low yest_size := d_high - d_low today_high := high today_low := low else today_high := math.max(na(today_high) ? high : today_high, high) today_low := math.min(na(today_low) ? low : today_low, low) // ════════════════════════ ORB CONSTRUCTION (REAL-TIME) ════════════════════════ var float orb_h = na var float orb_l = na var bool orb_ready = false var float orb_building_h = na var float orb_building_l = na var bool is_building = false // Get M1 bar time components m1_hour = hour(m1_time) m1_minute = minute(m1_time) // Reset daily if ta.change(time("D")) != 0 orb_h := na orb_l := na orb_ready := false orb_building_h := na orb_building_l := na is_building := false // Build ORB using M1 data if is_orb_period(m1_hour, m1_minute) and not orb_ready is_building := true val_h = exclude_wicks ? m1_close : m1_high val_l = exclude_wicks ? m1_close : m1_low if na(orb_building_h) orb_building_h := val_h orb_building_l := val_l else orb_building_h := math.max(orb_building_h, val_h) orb_building_l := math.min(orb_building_l, val_l) // FIX #1: Set is_building to false when NOT in ORB period anymore if not is_orb_period(m1_hour, m1_minute) and is_building and not orb_ready is_building := false // Finalize ORB when period ends if orb_ended(m1_hour, m1_minute) and not orb_ready orb_h := orb_building_h orb_l := orb_building_l orb_ready := true is_building := false // Display building values in real-time current_orb_h = is_building ? orb_building_h : orb_h current_orb_l = is_building ? orb_building_l : orb_l // ════════════════════════ INDICATORS ════════════════════════ ema9 = ta.ema(close, 9) ema21 = ta.ema(close, 21) ema50 = ta.ema(close, 50) rsi = ta.rsi(close, 14) = ta.macd(close, 12, 26, 9) = ta.bb(close, 20, 2) atr = ta.atr(14) vol_ma = ta.sma(volume, 20) // ════════════════════════ STRATEGY SIGNALS ════════════════════════ // 1. Trend Following tf_short = ta.sma(close, 10) tf_long = ta.sma(close, 30) tf_bull = tf_short > tf_long tf_bear = tf_short < tf_long // 2. Mean Reversion mr_mean = ta.sma(close, 20) mr_dev = (close - mr_mean) / mr_mean * 100 mr_bull = mr_dev <= -0.5 mr_bear = mr_dev >= 0.5 // 3. Statistical Arb sa_mean = ta.sma(close, 120) sa_std = ta.stdev(close, 120) sa_z = sa_std > 0 ? (close - sa_mean) / sa_std : 0 var string sa_st = "flat" if sa_st == "flat" if sa_z <= -2.0 sa_st := "long" else if sa_z >= 2.0 sa_st := "short" else if math.abs(sa_z) <= 0.5 or math.abs(sa_z) >= 4.0 sa_st := "flat" sa_bull = sa_st == "long" sa_bear = sa_st == "short" // 4. Market Making mm_spread = (high - low) / close * 100 mm_mid = (high + low) / 2 mm_bull = close < mm_mid and mm_spread >= 0.5 mm_bear = close > mm_mid and mm_spread >= 0.5 // 5. Basis Arb ba_fair = ta.sma(close, 50) ba_bps = ba_fair != 0 ? (close - ba_fair) / ba_fair * 10000 : 0 ba_bull = ba_bps <= -8.0 ba_bear = ba_bps >= 8.0 // Vote counting bull_v = 0 bear_v = 0 if use_tf bull_v := bull_v + (tf_bull ? 1 : 0) bear_v := bear_v + (tf_bear ? 1 : 0) if use_mr bull_v := bull_v + (mr_bull ? 1 : 0) bear_v := bear_v + (mr_bear ? 1 : 0) if use_sa bull_v := bull_v + (sa_bull ? 1 : 0) bear_v := bear_v + (sa_bear ? 1 : 0) if use_mm bull_v := bull_v + (mm_bull ? 1 : 0) bear_v := bear_v + (mm_bear ? 1 : 0) if use_ba bull_v := bull_v + (ba_bull ? 1 : 0) bear_v := bear_v + (ba_bear ? 1 : 0) // Technical filters - Simplified scoring system ema_ok_b = not use_ema or (ema9 > ema21 and close > ema50) ema_ok_s = not use_ema or (ema9 < ema21 and close < ema50) rsi_ok_b = not use_rsi or (rsi > 40 and rsi < 80) // More lenient rsi_ok_s = not use_rsi or (rsi < 60 and rsi > 20) // More lenient macd_ok_b = not use_macd or macd > sig macd_ok_s = not use_macd or macd < sig vol_ok = not use_vol or volume > vol_ma * 1.2 // More lenient bb_ok_b = not use_bb or close > bb_mid bb_ok_s = not use_bb or close < bb_mid // Technical score (need at least 2 out of 5 filters) tech_score_b = (ema_ok_b ? 1 : 0) + (rsi_ok_b ? 1 : 0) + (macd_ok_b ? 1 : 0) + (bb_ok_b ? 1 : 0) + (vol_ok ? 1 : 0) tech_score_s = (ema_ok_s ? 1 : 0) + (rsi_ok_s ? 1 : 0) + (macd_ok_s ? 1 : 0) + (bb_ok_s ? 1 : 0) + (vol_ok ? 1 : 0) tech_bull = tech_score_b >= 2 tech_bear = tech_score_s >= 2 // Breakout - SIMPLIFIED (just need close above/below ORB) brk_bull = orb_ready and close > current_orb_h brk_bear = orb_ready and close < current_orb_l // Consensus - At least 2 strategies agree (not majority) total_st = (use_tf ? 1 : 0) + (use_mr ? 1 : 0) + (use_sa ? 1 : 0) + (use_mm ? 1 : 0) + (use_ba ? 1 : 0) consensus_b = bull_v >= 2 consensus_s = bear_v >= 2 // Final signals - MUCH MORE LENIENT daily_ok = yest_size >= 50 // Reduced from 100 buy = brk_bull and consensus_b and tech_bull and is_market_open() sell = brk_bear and consensus_s and tech_bear and is_market_open() // ════════════════════════ SL/TP ════════════════════════ // IMMEDIATE SL/TP LEVELS - Calculated as soon as ORB is ready (at 8:00) var float long_entry = na var float long_sl = na var float long_tp = na var float short_entry = na var float short_sl = na var float short_tp = na // Calculate potential levels immediately when ORB is ready if orb_ready and not na(orb_h) and not na(orb_l) // Long scenario: Entry at ORB high breakout long_entry := orb_h long_sl := use_fixed ? long_entry - fixed_sl : long_entry - atr * atr_sl long_tp := use_fixed ? long_entry + fixed_tp : long_entry + atr * atr_tp // Short scenario: Entry at ORB low breakout short_entry := orb_l short_sl := use_fixed ? short_entry + fixed_sl : short_entry + atr * atr_sl short_tp := use_fixed ? short_entry - fixed_tp : short_entry - atr * atr_tp // Signal-based entry tracking (for dashboard and alerts) var float buy_entry = na var float buy_sl = na var float buy_tp = na var float sell_entry = na var float sell_sl = na var float sell_tp = na if buy buy_entry := close buy_sl := use_fixed ? buy_entry - fixed_sl : buy_entry - atr * atr_sl buy_tp := use_fixed ? buy_entry + fixed_tp : buy_entry + atr * atr_tp if sell sell_entry := close sell_sl := use_fixed ? sell_entry + fixed_sl : sell_entry + atr * atr_sl sell_tp := use_fixed ? sell_entry - fixed_tp : sell_entry - atr * atr_tp buy_rr = not na(buy_entry) ? (buy_tp - buy_entry) / (buy_entry - buy_sl) : 0 sell_rr = not na(sell_entry) ? (sell_entry - sell_tp) / (sell_sl - sell_entry) : 0 buy_final = buy and buy_rr >= min_rr sell_final = sell and sell_rr >= min_rr // ════════════════════════ TRAILING STOPS ════════════════════════ // Trailing Stop Loss and Take Profit Management var float trailing_sl_long = na var float trailing_sl_short = na var float trailing_tp_long = na var float trailing_tp_short = na var bool in_long = false var bool in_short = false var float highest_since_entry = na var float lowest_since_entry = na // Enter long position if buy_final and not in_long in_long := true in_short := false trailing_sl_long := buy_sl trailing_tp_long := buy_tp highest_since_entry := close // Enter short position if sell_final and not in_short in_short := true in_long := false trailing_sl_short := sell_sl trailing_tp_short := sell_tp lowest_since_entry := close // Update trailing stops for LONG if in_long // Track highest price since entry highest_since_entry := math.max(highest_since_entry, high) // Trail stop loss (moves up as price moves up) // When price moves 1 ATR in profit, move SL to breakeven // When price moves 2 ATR in profit, move SL to +1 ATR profit_atr = (highest_since_entry - buy_entry) / atr if profit_atr >= 2.0 trailing_sl_long := math.max(trailing_sl_long, buy_entry + atr * 1.0) else if profit_atr >= 1.0 trailing_sl_long := math.max(trailing_sl_long, buy_entry) // Smart trailing TP - extends TP if strong momentum if highest_since_entry > trailing_tp_long * 0.9 and rsi > 60 // Within 10% of TP and strong momentum trailing_tp_long := trailing_tp_long + atr * 0.5 // Extend TP // Exit conditions if close <= trailing_sl_long or close >= trailing_tp_long in_long := false trailing_sl_long := na trailing_tp_long := na highest_since_entry := na // Update trailing stops for SHORT if in_short // Track lowest price since entry lowest_since_entry := math.min(lowest_since_entry, low) // Trail stop loss (moves down as price moves down) profit_atr = (sell_entry - lowest_since_entry) / atr if profit_atr >= 2.0 trailing_sl_short := math.min(trailing_sl_short, sell_entry - atr * 1.0) else if profit_atr >= 1.0 trailing_sl_short := math.min(trailing_sl_short, sell_entry) // Smart trailing TP - extends TP if strong momentum if lowest_since_entry < trailing_tp_short * 1.1 and rsi < 40 // Within 10% of TP and strong momentum trailing_tp_short := trailing_tp_short - atr * 0.5 // Extend TP // Exit conditions if close >= trailing_sl_short or close <= trailing_tp_short in_short := false trailing_sl_short := na trailing_tp_short := na lowest_since_entry := na // ════════════════════════ ANALYTICS ════════════════════════ prob_strat = total_st > 0 ? math.max(bull_v, bear_v) / total_st * 100 : 50 prob_tech = (tech_bull or tech_bear) ? 75 : 35 prob_vol = vol_ok ? 85 : 50 prob_daily = daily_ok ? 85 : 30 prob_orb = orb_ready ? 80 : 20 probability = prob_strat * 0.3 + prob_tech * 0.25 + prob_vol * 0.15 + prob_daily * 0.15 + prob_orb * 0.15 dir_score = 0 dir_score := dir_score + (ema9 > ema21 ? 2 : -2) dir_score := dir_score + (tf_bull ? 2 : -2) dir_score := dir_score + (macd > sig ? 1 : -1) dir_score := dir_score + (rsi > 50 ? 1 : -1) direction = dir_score >= 2 ? "STRONG BULL" : (dir_score > 0 ? "BULL" : (dir_score <= -2 ? "STRONG BEAR" : (dir_score < 0 ? "BEAR" : "NEUTRAL"))) clean_trend = math.abs(ema9 - ema21) / close * 100 clean_noise = atr / close * 100 clean_struct = close > ema9 and close > ema21 and close > ema50 or close < ema9 and close < ema21 and close < ema50 clean_score = (clean_trend > 0.5 ? 30 : 10) + (clean_noise < 1.5 ? 30 : 10) + (clean_struct ? 40 : 10) quality = clean_score >= 70 ? "CLEAN" : (clean_score >= 50 ? "GOOD" : (clean_score >= 30 ? "OK" : "CHOPPY")) mom = ta.mom(close, 10) mom_str = math.abs(mom) / close * 100 vol_rat = atr / ta.sma(atr, 20) movement = buy_final or sell_final ? (mom_str > 0.8 and vol_rat > 1.3 ? "STRONG" : (mom_str > 0.5 ? "MODERATE" : "GRADUAL")) : "WAIT" ok_score = (daily_ok ? 25 : 0) + (orb_ready ? 25 : 0) + (is_market_open() ? 20 : 0) + (clean_score >= 50 ? 20 : 5) + (probability >= 60 ? 10 : 0) ok_trade = ok_score >= 65 // ════════════════════════ KEY LEVELS WITH BIAS ════════════════════════ // Calculate potential reaction levels with directional bias var float key_levels = array.new_float(0) var string key_bias = array.new_string(0) if barstate.islast and show_levels array.clear(key_levels) array.clear(key_bias) // Add levels with bias if not na(current_orb_h) array.push(key_levels, current_orb_h) array.push(key_bias, consensus_b ? "BULL BREAK" : "RESISTANCE") if not na(current_orb_l) array.push(key_levels, current_orb_l) array.push(key_bias, consensus_s ? "BEAR BREAK" : "SUPPORT") if not na(prev_day_high) array.push(key_levels, prev_day_high) bias_pdh = close > prev_day_high ? "BULLISH" : (close < prev_day_high and close > prev_day_high * 0.995 ? "WATCH" : "RESIST") array.push(key_bias, bias_pdh) if not na(prev_day_low) array.push(key_levels, prev_day_low) bias_pdl = close < prev_day_low ? "BEARISH" : (close > prev_day_low and close < prev_day_low * 1.005 ? "WATCH" : "SUPPORT") array.push(key_bias, bias_pdl) if not na(today_high) array.push(key_levels, today_high) array.push(key_bias, "TODAY HIGH") if not na(today_low) array.push(key_levels, today_low) array.push(key_bias, "TODAY LOW") // Add EMA50 as dynamic level array.push(key_levels, ema50) ema_bias = close > ema50 ? "BULL SUPPORT" : "BEAR RESIST" array.push(key_bias, ema_bias) // ════════════════════════ VISUALS ════════════════════════ // Previous day lines plot(show_lines ? prev_day_high : na, "Prev Day H", color.new(color.yellow, 0), 1, plot.style_line) plot(show_lines ? prev_day_low : na, "Prev Day L", color.new(color.orange, 0), 1, plot.style_line) // Current day high/low plot(show_lines ? today_high : na, "Today High", color.new(color.lime, 40), 2, plot.style_circles) plot(show_lines ? today_low : na, "Today Low", color.new(color.red, 40), 2, plot.style_circles) // ORB lines (show building values in real-time with separate plots) // Building phase - circles (orange during building) plot(show_lines and is_building and not na(current_orb_h) ? current_orb_h : na, "ORB High Building", color.new(color.orange, 30), 3, plot.style_circles) plot(show_lines and is_building and not na(current_orb_l) ? current_orb_l : na, "ORB Low Building", color.new(color.orange, 30), 3, plot.style_circles) // Ready phase - ULTRA BRIGHT solid lines plot(show_lines and not is_building and not na(current_orb_h) ? current_orb_h : na, "ORB High Ready", color.new(color.aqua, 0), 4, plot.style_line) plot(show_lines and not is_building and not na(current_orb_l) ? current_orb_l : na, "ORB Low Ready", color.new(color.aqua, 0), 4, plot.style_line) // ORB zone fill p1 = plot(not na(current_orb_h) ? current_orb_h : na, display=display.none) p2 = plot(not na(current_orb_l) ? current_orb_l : na, display=display.none) fill_color = is_building ? color.new(color.blue, 93) : color.new(color.blue, 88) fill(p1, p2, fill_color, title="ORB Zone") // FIX #2: Draw ORB rectangle box ONLY ONCE when ready (use var to track if already drawn) var box orb_box = na var int orb_start_bar = na var bool orb_box_drawn = false // Reset box drawn flag on new day if ta.change(time("D")) != 0 orb_box_drawn := false // Capture the bar when ORB becomes ready if orb_ready and not orb_ready orb_start_bar := bar_index orb_box_drawn := false // Allow new box to be drawn // Draw box ONLY ONCE when ORB first becomes ready if orb_ready and not orb_box_drawn and not na(orb_h) and not na(orb_l) and show_lines if not na(orb_box) box.delete(orb_box) // Ultra clear rectangle with thick bright borders box_color = color.new(color.aqua, 85) // Bright aqua fill border_color = color.new(color.aqua, 0) // Solid bright aqua border orb_box := box.new(orb_start_bar, orb_h, bar_index + 50, orb_l, border_color=border_color, border_width=3, // Thicker border bgcolor=box_color, extend=extend.right, text="ORB ZONE", text_size=size.normal, // Larger text text_color=color.new(color.aqua, 0)) // Bright text orb_box_drawn := true // Update box right edge on each bar (without creating new box) if orb_box_drawn and not na(orb_box) and show_lines box.set_right(orb_box, bar_index) // EMAs plot(use_ema ? ema9 : na, "EMA9", color.new(color.blue, 20), 1) plot(use_ema ? ema21 : na, "EMA21", color.new(color.orange, 20), 1) plot(use_ema ? ema50 : na, "EMA50", color.new(color.purple, 30), 2) // Signals plotshape(buy_final, "BUY", shape.triangleup, location.belowbar, color.new(color.lime, 0), size=size.small, text="BUY") plotshape(sell_final, "SELL", shape.triangledown, location.abovebar, color.new(color.red, 0), size=size.small, text="SELL") // Exit signals plotshape(in_long and not in_long, "EXIT LONG", shape.xcross, location.abovebar, color.new(color.orange, 0), size=size.tiny, text="EXIT") plotshape(in_short and not in_short, "EXIT SHORT", shape.xcross, location.belowbar, color.new(color.orange, 0), size=size.tiny, text="EXIT") // Trailing stop lines plot(in_long and not na(trailing_sl_long) ? trailing_sl_long : na, "Trail SL Long", color.new(color.red, 0), 2, plot.style_cross) plot(in_long and not na(trailing_tp_long) ? trailing_tp_long : na, "Trail TP Long", color.new(color.lime, 0), 2, plot.style_cross) plot(in_short and not na(trailing_sl_short) ? trailing_sl_short : na, "Trail SL Short", color.new(color.red, 0), 2, plot.style_cross) plot(in_short and not na(trailing_tp_short) ? trailing_tp_short : na, "Trail TP Short", color.new(color.lime, 0), 2, plot.style_cross) // FIX #3: IMMEDIATE SL/TP LINES - Draw ONLY ONCE when ORB is ready var line long_sl_ln = na var line long_tp_ln = na var line short_sl_ln = na var line short_tp_ln = na var label long_sl_lbl = na var label long_tp_lbl = na var label short_sl_lbl = na var label short_tp_lbl = na var bool sltp_lines_drawn = false // Reset lines drawn flag on new day if ta.change(time("D")) != 0 sltp_lines_drawn := false // Draw lines ONLY ONCE when ORB first becomes ready if orb_ready and not orb_ready and show_lines sltp_lines_drawn := false // Allow new lines to be drawn if orb_ready and not sltp_lines_drawn and show_lines // Delete old lines if not na(long_sl_ln) line.delete(long_sl_ln) line.delete(long_tp_ln) line.delete(short_sl_ln) line.delete(short_tp_ln) label.delete(long_sl_lbl) label.delete(long_tp_lbl) label.delete(short_sl_lbl) label.delete(short_tp_lbl) // LONG scenario (green - bullish breakout above ORB high) if not na(long_sl) and not na(long_tp) long_sl_ln := line.new(bar_index, long_sl, bar_index + 100, long_sl, color=color.new(color.red, 0), width=2, style=line.style_solid, extend=extend.right) long_tp_ln := line.new(bar_index, long_tp, bar_index + 100, long_tp, color=color.new(color.lime, 0), width=2, style=line.style_solid, extend=extend.right) long_sl_lbl := label.new(bar_index, long_sl, "LONG SL: " + str.tostring(long_sl, "#.##"), style=label.style_label_left, color=color.new(color.red, 0), textcolor=color.white, size=size.small) long_tp_lbl := label.new(bar_index, long_tp, "LONG TP: " + str.tostring(long_tp, "#.##"), style=label.style_label_left, color=color.new(color.lime, 0), textcolor=color.black, size=size.small) // SHORT scenario (red - bearish breakout below ORB low) if not na(short_sl) and not na(short_tp) short_sl_ln := line.new(bar_index, short_sl, bar_index + 100, short_sl, color=color.new(color.red, 0), width=2, style=line.style_solid, extend=extend.right) short_tp_ln := line.new(bar_index, short_tp, bar_index + 100, short_tp, color=color.new(color.lime, 0), width=2, style=line.style_solid, extend=extend.right) short_sl_lbl := label.new(bar_index, short_sl, "SHORT SL: " + str.tostring(short_sl, "#.##"), style=label.style_label_left, color=color.new(color.red, 0), textcolor=color.white, size=size.small) short_tp_lbl := label.new(bar_index, short_tp, "SHORT TP: " + str.tostring(short_tp, "#.##"), style=label.style_label_left, color=color.new(color.lime, 0), textcolor=color.black, size=size.small) sltp_lines_drawn := true // FIX #4: Key level labels - Track and delete old labels to prevent duplication var label key_level_labels = array.new_label(0) // Delete all old key level labels if array.size(key_level_labels) > 0 for i = 0 to array.size(key_level_labels) - 1 label.delete(array.get(key_level_labels, i)) array.clear(key_level_labels) // Create key level labels only on last bar if barstate.islast and show_levels and array.size(key_levels) > 0 for i = 0 to array.size(key_levels) - 1 lvl = array.get(key_levels, i) bias = array.get(key_bias, i) // Color based on bias lbl_color = str.contains(bias, "BULL") ? color.new(color.green, 70) : (str.contains(bias, "BEAR") ? color.new(color.red, 70) : (str.contains(bias, "SUPPORT") ? color.new(color.blue, 70) : (str.contains(bias, "RESIST") ? color.new(color.orange, 70) : color.new(color.gray, 70)))) txt_color = str.contains(bias, "BULL") ? color.green : (str.contains(bias, "BEAR") ? color.red : (str.contains(bias, "SUPPORT") ? color.blue : (str.contains(bias, "RESIST") ? color.orange : color.gray))) new_lbl = label.new(bar_index + 2, lvl, str.tostring(lvl, "#.##") + "\n" + bias, style=label.style_label_left, color=lbl_color, textcolor=txt_color, size=size.tiny, textalign=text.align_left) array.push(key_level_labels, new_lbl) // FIX #5: Compact chart info labels - Track and delete to prevent duplication var label prob_label = na var label dir_label = na if barstate.islast and show_lines // Delete old labels if not na(prob_label) label.delete(prob_label) if not na(dir_label) label.delete(dir_label) // Create new labels prob_c = probability >= 70 ? color.green : (probability >= 50 ? color.yellow : color.red) prob_label := label.new(bar_index, high + atr * 1.2, str.tostring(probability, "#") + "%", style=label.style_none, textcolor=prob_c, size=size.small) dir_c = str.contains(direction, "BULL") ? color.green : (str.contains(direction, "BEAR") ? color.red : color.gray) dir_label := label.new(bar_index, high + atr * 2, direction, style=label.style_none, textcolor=dir_c, size=size.tiny) // ════════════════════════ DASHBOARD ════════════════════════ var table dash = table.new(position.top_right, 2, 20, bgcolor=color.new(color.black, 5), border_width=1, border_color=color.new(color.gray, 60)) if barstate.islast and show_dash r = 0 // Header table.cell(dash, 0, r, "DAX ORB ULTIMATE", text_color=color.white, bgcolor=color.new(color.blue, 30), text_size=size.small) table.cell(dash, 1, r, timeframe.period, text_color=color.yellow, bgcolor=color.new(color.blue, 30), text_size=size.tiny) // Current Day r += 1 table.cell(dash, 0, r, "TODAY H/L", text_color=color.aqua, text_size=size.tiny) table.cell(dash, 1, r, "", text_color=color.white) r += 1 table.cell(dash, 0, r, "High", text_color=color.gray, text_size=size.tiny) table.cell(dash, 1, r, str.tostring(today_high, "#.##"), text_color=color.lime, text_size=size.tiny) r += 1 table.cell(dash, 0, r, "Low", text_color=color.gray, text_size=size.tiny) table.cell(dash, 1, r, str.tostring(today_low, "#.##"), text_color=color.red, text_size=size.tiny) r += 1 table.cell(dash, 0, r, "Range", text_color=color.gray, text_size=size.tiny) today_range = today_high - today_low table.cell(dash, 1, r, str.tostring(today_range, "#") + "p", text_color=color.aqua, text_size=size.tiny) // Previous Day r += 1 table.cell(dash, 0, r, "PREV H/L", text_color=color.aqua, text_size=size.tiny) table.cell(dash, 1, r, str.tostring(yest_size, "#") + "p", text_color=daily_ok ? color.lime : color.red, text_size=size.tiny) // ORB Status with real-time values r += 1 table.cell(dash, 0, r, "ORB 7:40-8:00", text_color=color.aqua, text_size=size.tiny) orb_status = is_building ? "BUILDING" : (orb_ready ? "READY" : "WAIT") orb_clr = is_building ? color.orange : (orb_ready ? color.lime : color.gray) table.cell(dash, 1, r, orb_status, text_color=orb_clr, text_size=size.tiny) r += 1 table.cell(dash, 0, r, "High", text_color=color.gray, text_size=size.tiny) orb_h_txt = not na(current_orb_h) ? str.tostring(current_orb_h, "#.##") : "---" table.cell(dash, 1, r, orb_h_txt, text_color=is_building ? color.orange : color.green, text_size=size.tiny) r += 1 table.cell(dash, 0, r, "Low", text_color=color.gray, text_size=size.tiny) orb_l_txt = not na(current_orb_l) ? str.tostring(current_orb_l, "#.##") : "---" table.cell(dash, 1, r, orb_l_txt, text_color=is_building ? color.orange : color.red, text_size=size.tiny) r += 1 table.cell(dash, 0, r, "Size", text_color=color.gray, text_size=size.tiny) orb_size = not na(current_orb_h) and not na(current_orb_l) ? current_orb_h - current_orb_l : 0 table.cell(dash, 1, r, str.tostring(orb_size, "#") + "p", text_color=color.yellow, text_size=size.tiny) // Strategies r += 1 table.cell(dash, 0, r, "STRATEGIES", text_color=color.aqua, text_size=size.tiny) table.cell(dash, 1, r, str.tostring(bull_v) + "B " + str.tostring(bear_v) + "S", text_color=color.yellow, text_size=size.tiny) // Analytics r += 1 table.cell(dash, 0, r, "PROBABILITY", text_color=color.white, bgcolor=color.new(color.purple, 70), text_size=size.small) prob_c = probability >= 70 ? color.lime : (probability >= 50 ? color.yellow : color.red) table.cell(dash, 1, r, str.tostring(probability, "#") + "%", text_color=prob_c, bgcolor=color.new(color.purple, 70), text_size=size.small) r += 1 table.cell(dash, 0, r, "Direction", text_color=color.gray, text_size=size.tiny) dir_c = str.contains(direction, "BULL") ? color.lime : (str.contains(direction, "BEAR") ? color.red : color.gray) table.cell(dash, 1, r, direction, text_color=dir_c, text_size=size.tiny) r += 1 table.cell(dash, 0, r, "Chart", text_color=color.gray, text_size=size.tiny) qual_c = quality == "CLEAN" ? color.lime : (quality == "GOOD" ? color.green : (quality == "OK" ? color.yellow : color.red)) table.cell(dash, 1, r, quality, text_color=qual_c, text_size=size.tiny) r += 1 table.cell(dash, 0, r, "OK Trade?", text_color=color.gray, text_size=size.tiny) table.cell(dash, 1, r, ok_trade ? "YES" : "NO", text_color=ok_trade ? color.lime : color.red, text_size=size.tiny) // Position Status r += 1 pos_txt = in_long ? "IN LONG" : (in_short ? "IN SHORT" : "NO POSITION") pos_c = in_long ? color.lime : (in_short ? color.red : color.gray) table.cell(dash, 0, r, "POSITION", text_color=color.white, bgcolor=color.new(color.blue, 50), text_size=size.small) table.cell(dash, 1, r, pos_txt, text_color=pos_c, bgcolor=color.new(color.blue, 50), text_size=size.small) // Show trailing stops if in position if in_long and not na(trailing_sl_long) r += 1 table.cell(dash, 0, r, "Trail SL", text_color=color.gray, text_size=size.tiny) table.cell(dash, 1, r, str.tostring(trailing_sl_long, "#.##"), text_color=color.red, text_size=size.tiny) r += 1 table.cell(dash, 0, r, "Trail TP", text_color=color.gray, text_size=size.tiny) table.cell(dash, 1, r, str.tostring(trailing_tp_long, "#.##"), text_color=color.lime, text_size=size.tiny) r += 1 table.cell(dash, 0, r, "Profit", text_color=color.gray, text_size=size.tiny) pnl = close - buy_entry pnl_c = pnl > 0 ? color.lime : color.red table.cell(dash, 1, r, str.tostring(pnl, "#.#") + "p", text_color=pnl_c, text_size=size.tiny) if in_short and not na(trailing_sl_short) r += 1 table.cell(dash, 0, r, "Trail SL", text_color=color.gray, text_size=size.tiny) table.cell(dash, 1, r, str.tostring(trailing_sl_short, "#.##"), text_color=color.red, text_size=size.tiny) r += 1 table.cell(dash, 0, r, "Trail TP", text_color=color.gray, text_size=size.tiny) table.cell(dash, 1, r, str.tostring(trailing_tp_short, "#.##"), text_color=color.lime, text_size=size.tiny) r += 1 table.cell(dash, 0, r, "Profit", text_color=color.gray, text_size=size.tiny) pnl = sell_entry - close pnl_c = pnl > 0 ? color.lime : color.red table.cell(dash, 1, r, str.tostring(pnl, "#.#") + "p", text_color=pnl_c, text_size=size.tiny) // Signal r += 1 table.cell(dash, 0, r, "SIGNAL", text_color=color.white, bgcolor=color.new(color.green, 50), text_size=size.small) sig_txt = buy_final ? "BUY NOW" : (sell_final ? "SELL NOW" : "WAIT") sig_c = buy_final ? color.lime : (sell_final ? color.red : color.gray) table.cell(dash, 1, r, sig_txt, text_color=sig_c, bgcolor=color.new(color.green, 50), text_size=size.small) // IMMEDIATE Trade Levels - Show as soon as ORB is ready if orb_ready and not na(long_entry) and not na(short_entry) r += 1 table.cell(dash, 0, r, "LONG LEVELS", text_color=color.lime, bgcolor=color.new(color.green, 70), text_size=size.tiny) table.cell(dash, 1, r, "", text_color=color.white) r += 1 table.cell(dash, 0, r, "Entry", text_color=color.gray, text_size=size.tiny) table.cell(dash, 1, r, str.tostring(long_entry, "#.##"), text_color=color.white, text_size=size.tiny) r += 1 table.cell(dash, 0, r, "SL", text_color=color.gray, text_size=size.tiny) table.cell(dash, 1, r, str.tostring(long_sl, "#.##"), text_color=color.red, text_size=size.tiny) r += 1 table.cell(dash, 0, r, "TP", text_color=color.gray, text_size=size.tiny) table.cell(dash, 1, r, str.tostring(long_tp, "#.##"), text_color=color.lime, text_size=size.tiny) r += 1 table.cell(dash, 0, r, "SHORT LEVELS", text_color=color.red, bgcolor=color.new(color.red, 70), text_size=size.tiny) table.cell(dash, 1, r, "", text_color=color.white) r += 1 table.cell(dash, 0, r, "Entry", text_color=color.gray, text_size=size.tiny) table.cell(dash, 1, r, str.tostring(short_entry, "#.##"), text_color=color.white, text_size=size.tiny) r += 1 table.cell(dash, 0, r, "SL", text_color=color.gray, text_size=size.tiny) table.cell(dash, 1, r, str.tostring(short_sl, "#.##"), text_color=color.red, text_size=size.tiny) r += 1 table.cell(dash, 0, r, "TP", text_color=color.gray, text_size=size.tiny) table.cell(dash, 1, r, str.tostring(short_tp, "#.##"), text_color=color.lime, text_size=size.tiny) // ════════════════════════ ALERTS ════════════════════════ alertcondition(buy_final, "BUY Signal", "DAX ORB BUY") alertcondition(sell_final, "SELL Signal", "DAX ORB SELL") alertcondition(orb_ready and not orb_ready , "ORB Ready", "DAX ORB READY") alertcondition(is_building and not is_building , "ORB Building", "DAX ORB BUILDING") alertcondition(ok_trade and not ok_trade , "Ready to Trade", "DAX OK")
Indicador Pine Script®
por Dylan_Millson
ADX Color Change by BehemothI find this tool to be the most valuable and accurate entry point indicator along with moving averages and the VWAP. ADX Color Indicator - Controls & Intraday Trading Benefits Indicator Controls: 1. ADX Length (default: 14) - Controls the calculation period for ADX - Lower values (7-10) = more sensitive, faster signals (better for scalping) - Higher values (14-20) = smoother, fewer false signals (better for swing trades) - *Intraday tip:* Try 10-14 for most intraday timeframes 2. Show Threshold Levels (default: On) - Displays the 20 and 25 horizontal lines - Helps you quickly identify when ADX crosses key strength levels 3. Use Custom Timeframe (default: Off) - Allows viewing higher timeframe ADX on lower timeframe charts - *Example:* Trade on 5-min chart but see 15-min or 1-hour ADX 4. Custom Timeframe - Select any timeframe: 1m, 5m, 15m, 30m, 1H, 4H, D, etc. - *Intraday tip:* Use 15m or 1H ADX on 5m charts for better trend context 5. Show +DI and -DI (default: Off) - Shows directional movement indicators - Green line (+DI) > Red line (-DI) = bullish trend - Red line (-DI) > Green line (+DI) = bearish trend 6. Show Background Zon es (default: Off) - Visual background colors for quick trend strength identification - Green = strong trend (ADX > 25) - Yellow = moderate trend (ADX 20-25) Intraday Trading Benefits: 1. Avoid Choppy Markets - When ADX < 20 (no background color), market is ranging - Reduces false breakout trades and whipsaws - Save time and capital by stepping aside during low-quality setups 2. Identify High-Probability Trend Trades - **Green line + Green zone** = strong trend building, look for pullback entries - Yellow line crossing above 20 = early trend formation signal - Catch trends early when ADX starts rising from below 20 3. Multi-Timeframe Analysis - Use custom timeframe to align with higher timeframe trends - *Example:* If 1H ADX shows green (strong trend), take breakout trades on 5m chart in same direction - Increases win rate by trading with the bigger picture 4. Exit Signals - When ADX turns red (falling), trend is weakening - Consider tightening stops or taking profits - Avoid entering new positions when ADX is declining 5. Quick Visual Confirmation - Color coding eliminates need to analyze numbers - Instant recognition: Green = go, Yellow = caution, Red = trend dying - Faster decision-making during fast market moves 6. Scalping Strategy - Set ADX length to 7-10 for sensitive signals - Only scalp when ADX is rising (blue, yellow, or green) - Exit when ADX turns red 7. Breakout Confirmation - Wait for ADX to rise above 20 after a breakout - Filters false breakouts in ranging markets - Yellow or green color confirms momentum behind the move Optimal Intraday Settings: - Day Trading (5-15 min charts):** ADX Length = 10-14 - Scalping (1-5 min charts):** ADX Length = 7-10, watch custom 15m timeframe - Swing Intraday (30min-1H charts):** ADX Length = 14-20 Simple Trading Rules: ✅ Trade: ADX rising + above 20 (yellow or green) ⚠️ Caution: ADX flat or just crossed 20 ❌ Avoid:*ADX falling (red) or below 20 The key advantage is staying out of low-quality, choppy price action which is where most intraday traders lose money!
Indicador Pine Script®
por humidhaney
Price Action Brooks ProPrice Action Brooks Pro (PABP) - Professional Trading Indicator ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 📊 OVERVIEW Price Action Brooks Pro (PABP) is a professional-grade TradingView indicator developed based on Al Brooks' Price Action trading methodology. It integrates decades of Al Brooks' trading experience and price action analysis techniques into a comprehensive technical analysis tool, helping traders accurately interpret market structure and identify trading opportunities. • Applicable Markets: Stocks, Futures, Forex, Cryptocurrencies • Timeframes: 1-minute to Daily (5-minute chart recommended) • Theoretical Foundation: Al Brooks Price Action Trading Method ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 🎯 CORE FEATURES ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 1️⃣ INTELLIGENT GAP DETECTION SYSTEM Automatically identifies and marks three critical types of gaps in the market. TRADITIONAL GAP • Detects complete price gaps between bars • Upward gap: Current bar's low > Previous bar's high • Downward gap: Current bar's high < Previous bar's low • Hollow border design - doesn't obscure price action • Color coding: Upward gaps (light green), Downward gaps (light pink) • Adjustable border: 1-5 pixel width options TAIL GAP • Detects price gaps between bar wicks/shadows • Analyzes across 3 bars for precision • Identifies hidden market structure BODY GAP • Focuses only on gaps between bar bodies (open/close) • Filters out wick noise • Disabled by default, enable as needed Trading Significance: • Gaps signal strong momentum • Gap fills provide trading opportunities • Consecutive gaps indicate trend continuation ✓ Independent alert system for all gap types ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 2️⃣ RTH BAR COUNT (Trading Session Counter) Intelligent counting system designed for US stock intraday trading. FEATURES • RTH Only Display: Regular Trading Hours (09:30-15:00 EST) • 5-Minute Chart Optimized: Displays every 3 bars (15-minute intervals) • Daily Auto-Reset: Counting starts from 1 each trading day SMART COLOR CODING • 🔴 Red (Bars 18 & 48): Critical turning moments (1.5h & 4h) • 🔵 Sky Blue (Multiples of 12): Hourly markers (12, 24, 36...) • 🟢 Light Green (Bar 6): Half-hour marker (30 minutes) • ⚫ Gray (Others): Regular 15-minute interval markers Al Brooks Time Theory: • Bar 18 (90 min): First 90 minutes determine daily trend • Bar 48 (4 hours): Important afternoon turning point • Hourly markers: Track institutional trading rhythm ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 3️⃣ FOUR-LINE EMA SYSTEM Professional-grade configurable moving average system. DEFAULT CONFIGURATION • EMA 20: Short-term trend (Al Brooks' most important MA) • EMA 50: Medium-short term reference • EMA 100: Medium-long term confirmation • EMA 200: Long-term trend and bull/bear dividing line FLEXIBLE CUSTOMIZATION Each EMA can be independently configured: • On/Off toggle • Data source selection (close/high/low/open, etc.) • Custom period length • Offset adjustment • Color and transparency COLOR SCHEME • EMA 20: Dark brown, opaque (most important) • EMA 50/100/200: Blue-purple gradient, 70% transparent TRADING APPLICATIONS • Bullish Alignment: Price > 20 > 50 > 100 > 200 • Bearish Alignment: 200 > 100 > 50 > 20 > Price • EMA Confluence: All within <1% = major move precursor Al Brooks Quote: "The EMA 20 is the most important moving average. Almost all trading decisions should reference it." ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 4️⃣ PREVIOUS VALUES (Key Prior Price Levels) Automatically marks important price levels that often act as support/resistance. THREE INDEPENDENT CONFIGURATIONS Each group configurable for: • Timeframe (1D/60min/15min, etc.) • Price source (close/high/low/open/CurrentOpen, etc.) • Line style and color • Display duration (Today/TimeFrame/All) SMART OPEN PRICE LABELS ⭐ • Auto-displays "Open" label when CurrentOpen selected • Label color matches line color • Customizable label size TYPICAL SETUP • 1st Line: Previous close (Support/Resistance) • 2nd Line: Previous high (Breakout target) • 3rd Line: Previous low (Support level) Al Brooks Magnet Price Theory: • Previous open: Price frequently tests opening price • Previous high/low: Strongest support/resistance • Breakout confirmation: Breaking prior levels = trend continuation ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 5️⃣ INSIDE & OUTSIDE BAR PATTERN RECOGNITION Automatically detects core candlestick patterns from Al Brooks' theory. ii PATTERN (Consecutive Inside Bars) • Current bar contained within previous bar • Two or more consecutive • Labels: ii, iii, iiii (auto-accumulates) • High-probability breakout setup • Stop loss: Outside both bars Trading Significance: "Inside bars are one of the most reliable breakout setups, especially three or more consecutive inside bars." - Al Brooks OO PATTERN (Consecutive Outside Bars) • Current bar engulfs previous bar • Two or more consecutive • Labels: oo, ooo (auto-accumulates) • Indicates indecision or volatility increase ioi PATTERN (Inside-Outside-Inside) • Three-bar combination: Inside → Outside → Inside • Auto-detected and labeled • Tug-of-war pattern • Breakout direction often very strong SMART LABEL SYSTEM • Auto-accumulation counting • Dynamic label updates • Customizable size and color • Positioned above bars ✓ Independent alerts for all patterns ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 💡 USE CASES INTRADAY TRADING ✓ Bar Count (timing rhythm) ✓ Traditional Gap (strong signals) ✓ EMA 20 + 50 (quick trend) ✓ ii/ioi Patterns (breakout points) SWING TRADING ✓ Previous Values (key levels) ✓ EMA 20 + 50 + 100 (trend analysis) ✓ Gaps (trend confirmation) ✓ iii Patterns (entry timing) TREND FOLLOWING ✓ All four EMAs (alignment analysis) ✓ Gaps (continuation signals) ✓ Previous Values (targets) BREAKOUT TRADING ✓ iii Pattern (high-reliability setup) ✓ Previous Values (targets) ✓ EMA 20 (trend direction) ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 🎨 DESIGN FEATURES PROFESSIONAL COLOR SCHEME • Gaps: Hollow borders + light colors • Bar Count: Smart multi-color coding • EMAs: Gradient colors + transparency hierarchy • Previous Values: Customizable + smart labels CLEAR VISUAL HIERARCHY • Important elements: Opaque (EMA 20, bar count) • Reference elements: Semi-transparent (other EMAs, gaps) • Hollow design: Doesn't obscure price action USER-FRIENDLY INTERFACE • Clear functional grouping • Inline layout saves space • All colors and sizes customizable ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 📚 AL BROOKS THEORY CORE READING PRICE ACTION "Don't try to predict the market, read what the market is telling you." PABP converts core concepts into visual tools: • Trend Assessment: EMA system • Time Rhythm: Bar Count • Market Structure: Gap analysis • Trade Setups: Inside/Outside Bars • Support/Resistance: Previous Values PROBABILITY THINKING • ii pattern: Medium probability • iii pattern: High probability • iii + EMA 20 support: Very high probability ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ⚙️ TECHNICAL SPECIFICATIONS • Pine Script Version: v6 • Maximum Objects: 500 lines, 500 labels, 500 boxes • Alert Functions: 8 independent alerts • Supported Timeframes: All (5-min recommended for Bar Count) • Compatibility: All TradingView plans, Mobile & Desktop ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 🚀 RECOMMENDED INITIAL SETTINGS GAPS • Traditional Gap: ✓ • Tail Gap: ✓ • Border Width: 2 BAR COUNT • Use Bar Count: ✓ • Label Size: Normal EMA • EMA 20: ✓ • EMA 50: ✓ • EMA 100: ✓ • EMA 200: ✓ PREVIOUS VALUES • 1st: close (Previous close) • 2nd: high (Previous high) • 3rd: low (Previous low) INSIDE & OUTSIDE BAR • All patterns: ✓ • Label Size: Large ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 🌟 WHY CHOOSE PABP? ✅ Solid Theoretical Foundation Based on Al Brooks' decades of trading experience ✅ Complete Professional Features Systematizes complex price action analysis ✅ Highly Customizable Every feature adjustable to personal style ✅ Excellent Performance Optimized code ensures smooth experience ✅ Continuous Updates Constantly improving based on feedback ✅ Suitable for All Levels Benefits beginners to professionals ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 📖 RECOMMENDED LEARNING Al Brooks Books: • "Trading Price Action Trends" • "Trading Price Action Trading Ranges" • "Trading Price Action Reversals" Learning Path: 1. Understand basic candlestick patterns 2. Learn EMA applications 3. Master market structure analysis 4. Develop trading system 5. Continuous practice and optimization ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ⚠️ RISK DISCLOSURE IMPORTANT NOTICE: • For educational and informational purposes only • Does not constitute investment advice • Past performance doesn't guarantee future results • Trading involves risk and may result in capital loss • Trade according to your risk tolerance • Test thoroughly in demo account first RESPONSIBLE TRADING: • Always use stop losses • Control position sizes reasonably • Don't overtrade • Continuous learning and improvement • Keep trading journal ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 📜 COPYRIGHT Price Action Brooks Pro (PABP) Author: © JimmC98 License: Mozilla Public License 2.0 Pine Script Version: v6 Acknowledgments: Thanks to Dr. Al Brooks for his contributions to price action trading. This indicator is developed based on his theories. ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ Experience professional-grade price action analysis now! "The best traders read price action, not indicators. But when indicators help you read price action better, use them." - Al Brooks
Indicador Pine Script®
por JimmC98
1