My script//@version=5
strategy("Algo Bot Starter (EMA+ATR, RR, Webhook)",
overlay=true,
initial_capital=10000,
commission_type=strategy.commission.percent,
commission_value=0.02,
calc_on_every_tick=false,
calc_on_order_fills=true,
pyramiding=0,
process_orders_on_close=true)
//================ Inputs ================
emaFastLen = input.int(20, "EMA Fast", minval=1)
emaSlowLen = input.int(50, "EMA Slow", minval=1)
atrLen = input.int(14, "ATR Length", minval=1)
atrMultSL = input.float(2.0, "SL = ATR x", step=0.1)
rr = input.float(1.5, "Risk:Reward (TP = RR x Risk)", step=0.1, minval=0.2)
riskPct = input.float(1.0, "Risk % per Trade", step=0.1, minval=0.1, maxval=5)
slipPips = input.float(0.0, "Extra buffer (price units)", step=0.0001)
sessionFilt = input.session("0000-2400", "Trading Session")
useSession = input.bool(false, "Use Session Filter?")
closeOnFlip = input.bool(true, "Close & Reverse on signal flip?")
useBarClose = input.bool(true, "Signal on Bar Close? (recommended)")
//================ Helpers ================
inSess = useSession ? time(timeframe.period, sessionFilt) : true
emaFast = ta.ema(close, emaFastLen)
emaSlow = ta.ema(close, emaSlowLen)
atr = ta.atr(atrLen)
// Cross conditions (optionally on bar close)
bull = useBarClose ? ta.crossover(emaFast, emaSlow) : ta.cross(emaFast, emaSlow) and (emaFast > emaSlow)
bear = useBarClose ? ta.crossunder(emaFast, emaSlow) : ta.cross(emaFast, emaSlow) and (emaFast < emaSlow)
//================ Risk & Position Sizing ================
// ملاحظة: TradingView ما يعرف رصيدك الحقيقي، فاعتمدنا على initial_capital أو عدّل أدناه يدويًا
equity = strategy.equity
riskAmount = equity * (riskPct/100.0)
// سنحسب الكمية حسب المسافة إلى وقف الخسارة بالوحدات السعرية (تقريب عام)
calcQty(entryPrice, slPrice) =>
riskPerUnit = math.abs(entryPrice - slPrice)
riskPerUnit := risk
חפש סקריפטים עבור "entry"
J12Matic Builder by galgoomA flexible Renko/tick strategy that lets you choose between two entry engines (Multi-Source 3-way or QBand+Moneyball), with a unified trailing/TP exit engine, NY-time trading windows with auto-flatten, daily profit/loss and trade-count limits (HALT mode), and clean webhook routing using {{strategy.order.alert_message}}.
Highlights
Two entry engines
Multi-Source (3): up to three long/short sources with Single / Dual / Triple logic and optional lookback.
QBand + Moneyball: Gate → Trigger workflow with timing windows, OR/AND trigger modes, per-window caps, optional same-bar fire.
Unified exit engine: Trailing by Bricks or Ticks, plus optional static TP/SL.
Session control (NY time): Evening / Overnight / NY Session windows; auto-flatten at end of any enabled window.
Day controls: Profit/Loss (USD) and Trade-count limits. When hit, strategy HALTS new entries, shows an on-chart label/background.
Alert routing designed for webhooks: Every order sets alert_message= so you can run alerts with:
Condition: this strategy
Notify on: Order fills only
Message: {{strategy.order.alert_message}}
Default JSONs or Custom payloads: If a Custom field is blank, a sensible default JSON is sent. Fill a field to override.
How to set up alerts (the 15-second version)
Create a TradingView alert with this strategy as Condition.
Notify on: Order fills only.
Message: {{strategy.order.alert_message}} (exactly).
If you want your own payloads, paste them into Inputs → 08) Custom Alert Payloads.
Leave blank → the strategy sends a default JSON.
Fill in → your text is sent as-is.
Note: Anything you type into the alert dialog’s Message box is ignored except the {{strategy.order.alert_message}} token, which forwards the payload supplied by the strategy at order time.
Publishing notes / best practices
Renko users: Make sure “Renko Brick Size” in Inputs matches your chart’s brick size exactly.
Ticks vs Bricks: Exit distances switch instantly when you toggle Exit Units.
Same-bar flips: If enabled, a new opposite signal will first close the open trade (with its exit payload), then enter the new side.
HALT mode: When day profit/loss limit or trade-count limit triggers, new entries are blocked for the rest of the session day. You’ll see a label and a soft background tint.
Session end flatten: Auto-closes positions at window ends; these exits use the “End of Session Window Exit” payload.
Bar magnifier: Strategy is configured for on-close execution; you can enable Bar Magnifier in Properties if needed.
Default JSONs (used when a Custom field is empty)
Open: {"event":"open","side":"long|short","symbol":""}
Close: {"event":"close","side":"long|short|flat","reason":"tp|sl|flip|session|limit_profit|limit_loss","symbol":""}
You can paste any text/JSON into the Custom fields; it will be forwarded as-is when that event occurs.
Input sections — user guide
01) Entries & Signals
Entry Logic: Choose Multi-Source (3) or QBand + Moneyball (pick one).
Enable Long/Short Signals: Master on/off switches for entering long/short.
Flip on opposite signal: If enabled, a new opposite signal will close the current position first, then open the other side.
Signal Logic (Multi-Source):
Single: any 1 of the 3 sources > 0
Dual: Source1 AND Source2 > 0
Triple (default): 1 AND 2 AND 3 > 0
Long/Short Signal Sources 1–3: Provide up to three series (often indicators). A positive value (> 0) is treated as a “pulse”.
Use Lookback: Keeps a source “true” for N bars after it pulses (helps catch late triggers).
Long/Short Lookback (bars): How many bars to remember that pulse.
01b) QBands + Moneyball (Gate -> Trigger)
Allow same-bar Gate->Trigger: If ON, a trigger can fire on the same bar as the gate pulse.
Trigger must fire within N bars after Gate: Size of the gate window (in bars).
Max signals per window (0 = unlimited): Cap the number of entries allowed while a gate window is open.
Buy/Sell Source 1 – Gate: Gate pulse sources that open the buy/sell window (often a regime/zone, e.g., QBands bull/bear).
Trigger Pulse Mode (Buy/Sell): How to detect a trigger pulse from the trigger sources (Change / Appear / Rise>0 / Fall<0).
Trigger A/B sources + Extend Bars: Primary/secondary triggers plus optional extension to persist their pulse for N bars.
Trigger Mode: Pick S2 only, S3 only, S2 OR S3, or S2 AND S3. AND mode remembers both pulses inside the window before firing.
02) Exit Units (Trailing/TP)
Exit Units: Choose Bricks (Renko) or Ticks. All distances below switch accordingly.
03) Tick-based Trailing / Stops (active when Exit Units = Ticks)
Initial SL (ticks): Starting stop distance from entry.
Start Trailing After (ticks): Start trailing once price moves this far in your favor.
Trailing Distance (ticks): Offset of the trailing stop from peak/trough once trailing begins.
Take Profit (ticks): Optional static TP distance.
Stop Loss (ticks): Optional static SL distance (overrides trailing if enabled).
04) Brick-based Trailing / Stops (active when Exit Units = Bricks)
Renko Brick Size: Must match your chart’s brick size.
Initial SL / Start Trailing After / Trailing Distance (bricks): Same definitions as tick mode, measured in bricks.
Take Profit / Stop Loss (bricks): Optional static distances.
05) TP / SL Switch
Enable Static Take Profit: If ON, closes the trade at the fixed TP distance.
Enable Static Stop Loss (Overrides Trailing): If ON, trailing is disabled and a fixed SL is used.
06) Trading Windows (NY time)
Use Trading Windows: Master toggle for all windows.
Evening / Overnight / NY Session: Define each session in NY time.
Flatten at End of : Auto-close any open position when a window ends (sends the Session Exit payload).
07) Day Controls & Limits
Enable Profit Limits / Profit Limit (Dollars): When daily net PnL ≥ limit → auto-flatten and HALT.
Enable Loss Limits / Loss Limit (Dollars): When daily net PnL ≤ −limit → auto-flatten and HALT.
Enable Trade Count Limits / Number of Trades Allowed: After N entries, HALT new entries (does not auto-flatten).
On-chart HUD: A label and soft background tint appear when HALTED; a compact status table shows Day PnL, trade count, and mode.
08) Custom Alert Payloads (used as strategy.order.alert_message)
Long/Short Entry: Payload sent on entries (if blank, a default open JSON is sent).
Regular Long/Short Exit: Payload sent on closes from SL/TP/flip (if blank, a default close JSON is sent).
End of Session Window Exit: Payload sent when any enabled window ends and positions are flattened.
Profit/Loss/Trade Limit Close: Payload sent when daily profit/loss limit causes auto-flatten.
Tip: Any tokens you include here are forwarded “as is”. If your downstream expects variables, do the substitution on the receiver side.
Known limitations
No bracket orders from Pine: This strategy doesn’t create OCO/attached brackets on the broker; it simulates exits with strategy logic and forwards your payloads for external automation.
alert_message is per order only: Alerts fire on order events. General status pings aren’t sent unless you wire a separate indicator/alert.
Renko specifics: Backtests on synthetic Renko can differ from live execution. Always forward-test on your instrument and settings.
Quick checklist before you publish
✅ Brick size in Inputs matches your Renko chart
✅ Exit Units set to Bricks or Ticks as you intend
✅ Day limits/Windows toggled as you want
✅ Custom payloads filled (or leave blank to use defaults)
✅ Your alert uses Order fills only + {{strategy.order.alert_message}}
Cnagda Liquidit Trading SystemCnagda Liquidit Trading System helps spot where price is likely to trap traders and reverse, then gives simple, actionable Level to entry, place SL, and take profits with confidence. It blends imbalance zones, trend bias, order blocks, liquidity pools, high-probability fake Signal, and context-aware candle patterns into one clean workflow.
🟩🟥 Imbalance boxes: “Crowd rushed, gaps left”
What it is: Green/red boxes mark fast, one-sided moves where price “skipped” orders—think FVG-like zones that often get revisited.
Why it helps: Price frequently pulls back to “fill” these zones, creating clean retest entries with logical stops.
⏩How to use:
Green box = potential demand retest; Red box = potential supply retest. Enter on pullback into box, not on first impulse. Put stop on far side of box and aim first targets at recent swing points.
↕️ Swing bias (HH/HL vs LH/LL): “Which way is the road?”
What it is: Higher-highs/higher-lows = up-bias; Lower-highs/lower-lows = down-bias. system plots Buy/Sell OB levels aligned with that bias.
Why it helps: Trading with the broader flow reduces “hero trades” against institutions. Bias gives clearer entries and cleaner drawdowns.
⏩How to use:
Up-bias: look for long on Buy OB retests. Down-bias: look for short on Sell OB retests. Wait for a small rejection/engulfing to confirm before triggering.
🧱Order blocks: “Where big players remember”
What it is: last opposite-colored candle before an impulsive move—these zones often hold memory and reaction. system plots these as Buy/Sell OB lines.
Why it helps: Many breakouts pull back to the origin. Good entries often happen on retest, not on the breakout chase.
⏩ How to use:
Let price return into the OB, show wick rejection, and decent volume. Enter with stop beyond OB; define risk-reward before entry.
📊Volume coloring: “How Volume is move?”
What it is: Bar color reflects relative volume; inside bars are black. The dashboard also shows Volume and “Volume vs Prev.”
Why it helps: Patterns without volume often fade; volume validates strength and intent of moves.
⏩ How to use:
Favor entries where imbalance/OB/liquidity-grab coincide with higher volume. If volume is weak, reduce size or skip.
🧲 BSL/SSL liquidity pools: “Fishing for stops”
What it is: Equal highs cluster stops above (BSL); equal lows cluster stops below (SSL). system plots these and highlights the nearest one (“magnet”).
Why it helps: Price often sweeps these pools to trigger stops before reversing. This is a prime trap-reversal location.
⏩ How to use:
Watch nearest BSL/SSL. If price wicks through and closes back inside, anticipate a reversal. Trade reaction, not first poke. When price closes beyond, consider that pool mitigated and move on.
🟢🔴 Advanced liquidity grab: “Catch fakeout”
What it is: Bullish grab = makes a new low beyond a prior low but closes back above it, with a long lower wick, small body, and higher volume. Bearish is mirror. Labeled automatically.
Why it helps: It exposes trap moves (stop hunts) and often precedes true direction.
⏩ How to use:
Best when it aligns with a nearby imbalance/OB and supportive volume. Enter on reversal candle break or on retest. Stop goes beyond sweep wick.
🧠 Smart candlestick patterns (only in right place)
What it is: Engulfing, Hammer, Shooting Star, Hanging Man, Doji (with high volume), Morning/Evening Star, Piercing—but marked “effective” only if context (swing/trend/location) agrees.
Why it helps: same pattern in the wrong place is noise; in the right place, it’s signal.
⏩ How to use:
Location first (BSL/SSL/OB/imbalance), then pattern. Treat pattern as trigger/confirmation—one fresh label shows to keep chart clean.
🧭 Dashboard: “Context in a glance”
⏩ Reversal Level: current swing anchor—expect turns or reactions nearby; great for alerts and planning.
⏩ Volume vs Prev + Volume: Strength meter for signal candle—higher adds conviction.
⏩ Nearest Pool: next “magnet” area—look for sweeps/rejections there.
🧩Step-by-step trading flow (with mindset)
⏩ Set bias: HH/HL = long bias, LH/LL = short bias. Counter-trend only on clean sweeps with strong confirmation.
⏩ Find magnet: Check Nearest Pool (BSL/SSL). Focus attention there; it saves screen time.
⏩ Wait for event: Look for a sweep/grab label, or sharp rejection at pool/OB/imbalance. Avoid FOMO.
⏩ Add confluence: Stack 2–3 of these—imbalance box, OB, contextual pattern, supportive volume.
⏩Plan entry: Bullish: trigger above reversal candle high or take retest of FVG/OB. Stop below sweep wick/zone. Target at least 1:1.5–1:2.
Bearish: mirror above.
⏩Manage smartly: Take partials, move to breakeven or trail thoughtfully. Don’t drag stops inside zone out of emotion.
🎛️ Parameter tuning (to reduce human error)
⏩ swingLen: Smaller = faster but noisier; larger = cleaner but slower. Backtest first, then go live.
⏩ Tolerance (ATR or percent): ATR tolerance adapts to volatility (good for fast markets and lower TFs). Start around 0.15–0.30. In calm markets, try percent 0.05–0.15%.
⏩ minBarsGap: Start with 3–5 so equal highs/lows are truly equal—reduces false pools.
❌Common mistakes → ✅ Better habits
⏩Chasing every breakout → Wait for sweep/rejection, then confirm.
⏩Ignoring volume → Validate strength; cut size or skip on weak volume.
⏩Losing history of pools → If reviewing/backtesting, keep mitigated pools visible (dashed/faded).
⏩Over-tight tolerance/too small swingLen → Increases false signals; backtest to find balance.
📝 checklist (before entry)
⏩ Is there a nearby BSL/SSL and did a sweep/grab happen there?
⏩ Is there a close imbalance/OB that price can retest?
⏩ Do we have an effective pattern plus supportive volume?
⏩Is the stop beyond the wick/zone and RR ≥ 1:1.5?
•?((¯°·._.• 🎀 𝐻𝒶𝓅𝓅𝓎 𝒯𝓇𝒶𝒹𝒾𝓃𝑔 🎀 •._.·°¯((?•
RifleShooterLibLibrary "RifleShooterLib"
Provides a collection of helper functions in support of the Rifle Shooter Indicators.
Functions support the key components of the Rifle Trade algorithm including
* measuring momentum
* identifying paraboloic price action (to disable the algorthim during such time)
* determine the lookback criteria of X point movement in last N minutes
* processing and navigating between the 23/43/73 levels
* maintaining a status table of algorithm progress
toStrRnd(val, digits)
Parameters:
val (float)
digits (int)
_isValidTimeRange(startTimeInput, endTimeInput)
Parameters:
startTimeInput (string)
endTimeInput (string)
_normalize(_src, _min, _max)
_normalize Normalizes series with unknown min/max using historical min/max.
Parameters:
_src (float) : Source series to normalize
_min (float) : minimum value of the rescaled series
_max (float) : maximum value of the rescaled series
Returns: The series scaled with values between min and max
arrayToSeries(arrayInput)
arrayToSeries Return an array from the provided series.
Parameters:
arrayInput (array) : Source array to convert to a series
Returns: The array as a series datatype
f_parabolicFiltering(_activeCount, long, shooterRsi, shooterRsiLongThreshold, shooterRsiShortThreshold, fiveMinuteRsi, fiveMinRsiLongThreshold, fiveMinRsiShortThreshold, shooterRsiRoc, shooterRsiRocLongThreshold, shooterRsiRocShortThreshold, quickChangeLookbackBars, quckChangeThreshold, curBarChangeThreshold, changeFromPrevBarThreshold, maxBarsToholdParabolicMoveActive, generateLabels)
f_parabolicFiltering Return true when price action indicates a parabolic active movement based on the provided inputs and thresholds.
Parameters:
_activeCount (int)
long (bool)
shooterRsi (float)
shooterRsiLongThreshold (float)
shooterRsiShortThreshold (float)
fiveMinuteRsi (float)
fiveMinRsiLongThreshold (float)
fiveMinRsiShortThreshold (float)
shooterRsiRoc (float)
shooterRsiRocLongThreshold (float)
shooterRsiRocShortThreshold (float)
quickChangeLookbackBars (int)
quckChangeThreshold (int)
curBarChangeThreshold (int)
changeFromPrevBarThreshold (int)
maxBarsToholdParabolicMoveActive (int)
generateLabels (bool)
rsiValid(rsi, buyThreshold, sellThreshold)
rsiValid Returns true if the provided RSI value is withing the associated threshold. For the unused threshold set it to na
Parameters:
rsi (float)
buyThreshold (float)
sellThreshold (float)
squezeBands(source, length)
squezeBands Returns the squeeze bands momentum color of current source series input
Parameters:
source (float)
length (int)
f_momentumOscilator(source, length, transperency)
f_momentumOscilator Returns the squeeze pro momentum value and bar color states of the series input
Parameters:
source (float)
length (int)
transperency (int)
f_getLookbackExtreme(lowSeries, highSeries, lbBars, long)
f_getLookbackExtreme Return the highest high or lowest low over the look back window
Parameters:
lowSeries (float)
highSeries (float)
lbBars (int)
long (bool)
f_getInitialMoveTarget(lbExtreme, priveMoveOffset, long)
f_getInitialMoveTarget Return the point delta required to achieve an initial rifle move (X points over Y lookback)
Parameters:
lbExtreme (float)
priveMoveOffset (int)
long (bool)
isSymbolSupported(sym)
isSymbolSupported Return true if provided symbol is one of the supported DOW Rifle Indicator symbols
Parameters:
sym (string)
getBasePrice(price)
getBasePrice Returns integer portion of provided float
Parameters:
price (float)
getLastTwoDigitsOfPrice(price)
getBasePrice Returns last two integer numerals of provided float value
Parameters:
price (float)
getNextLevelDown(price, lowestLevel, middleLevel, highestLevel)
getNextLevelDown Returns the next level above the provided price value
Parameters:
price (float)
lowestLevel (float)
middleLevel (float)
highestLevel (float)
getNextLevelUp(price, lowestLevel, middleLevel, highestLevel)
getNextLevelUp Returns the next level below the provided price value
Parameters:
price (float)
lowestLevel (float)
middleLevel (float)
highestLevel (float)
isALevel(price, lowestLevel, middleLevel, highestLevel)
isALevel Returns true if the provided price is onve of the specified levels
Parameters:
price (float)
lowestLevel (float)
middleLevel (float)
highestLevel (float)
getClosestLevel(price, lowestLevel, middleLevel, highestLevel)
getClosestLevel Returns the level closest to the price value provided
Parameters:
price (float)
lowestLevel (float)
middleLevel (float)
highestLevel (float)
f_fillSetupTableCell(_table, _col, _row, _text, _bgcolor, _txtcolor, _text_size)
f_fillSetupTableCell Helper function to fill a setup table celll
Parameters:
_table (table)
_col (int)
_row (int)
_text (string)
_bgcolor (color)
_txtcolor (color)
_text_size (string)
f_fillSetupTableRow(_table, _row, _col0Str, _col1Str, _col2Str, _bgcolor, _textColor, _textSize)
f_fillSetupTableRow Helper function to fill a setup table row
Parameters:
_table (table)
_row (int)
_col0Str (string)
_col1Str (string)
_col2Str (string)
_bgcolor (color)
_textColor (color)
_textSize (string)
f_addBlankRow(_table, _row)
f_addBlankRow Helper function to fill a setup table row with empty values
Parameters:
_table (table)
_row (int)
f_updateVersionTable(versionTable, versionStr, versionDateStr)
f_updateVersionTable Helper function to fill the version table with provided values
Parameters:
versionTable (table)
versionStr (string)
versionDateStr (string)
f_updateSetupTable(_table, parabolicMoveActive, initialMoveTargetOffset, initialMoveAchieved, shooterRsi, shooterRsiValid, rsiRocEnterThreshold, shooterRsiRoc, fiveMinuteRsi, fiveMinuteRsiValid, requireValid5MinuteRsiForEntry, stallLevelOffset, stallLevelExceeded, stallTargetOffset, recoverStallLevelValid, curBarChangeValid, volumeRoc, volumeRocThreshold, enableVolumeRocForTrigger, tradeActive, entryPrice, curCloseOffset, curSymCashDelta, djiCashDelta, showDjiDelta, longIndicator, fontSize)
f_updateSetupTable Manages writing current data to the setup table
Parameters:
_table (table)
parabolicMoveActive (bool)
initialMoveTargetOffset (float)
initialMoveAchieved (bool)
shooterRsi (float)
shooterRsiValid (bool)
rsiRocEnterThreshold (float)
shooterRsiRoc (float)
fiveMinuteRsi (float)
fiveMinuteRsiValid (bool)
requireValid5MinuteRsiForEntry (bool)
stallLevelOffset (float)
stallLevelExceeded (bool)
stallTargetOffset (float)
recoverStallLevelValid (bool)
curBarChangeValid (bool)
volumeRoc (float)
volumeRocThreshold (float)
enableVolumeRocForTrigger (bool)
tradeActive (bool)
entryPrice (float)
curCloseOffset (float)
curSymCashDelta (float)
djiCashDelta (float)
showDjiDelta (bool)
longIndicator (bool)
fontSize (string)
light_logLight Log - A Defensive Programming Library for Pine Script
Overview
The Light Log library transforms Pine Script development by introducing structured logging and defensive programming patterns typically found in enterprise languages like C#. This library addresses a fundamental challenge in Pine Script: the lack of sophisticated error handling and debugging tools that developers expect when building complex trading systems.
At its core, Light Log provides three transformative capabilities that work together to create more reliable and maintainable code. First, it wraps all native Pine Script types in error-aware containers, allowing values to carry validation state alongside their data. Second, it offers a comprehensive logging system with severity levels and conditional rendering. Third, it includes defensive programming utilities that catch errors early and make code self-documenting.
The Philosophy of Errors as Values
Traditional Pine Script error handling relies on runtime errors that halt execution, making it difficult to build resilient systems that can gracefully handle edge cases. Light Log introduces a paradigm shift by treating errors as first-class values that flow through your program alongside regular data.
When you wrap a value using Light Log's type system, you're not just storing data – you're creating a container that can carry both the value and its validation state. For example, when you call myNumber.INT() , you receive an INT object that contains both the integer value and a Log object that can describe any issues with that value. This approach, inspired by functional programming languages, allows errors to propagate through calculations without causing immediate failures.
Consider how this changes error handling in practice. Instead of a calculation failing catastrophically when it encounters invalid input, it can produce a result object that contains both the computed value (which might be na) and a detailed log explaining what went wrong. Subsequent operations can check has_error() to decide whether to proceed or handle the error condition gracefully.
The Typed Wrapper System
Light Log provides typed wrappers for every native Pine Script type: INT, FLOAT, BOOL, STRING, COLOR, LINE, LABEL, BOX, TABLE, CHART_POINT, POLYLINE, and LINEFILL. These wrappers serve multiple purposes beyond simple value storage.
Each wrapper type contains two fields: the value field v holds the actual data, while the error field e contains a Log object that tracks the value's validation state. This dual nature enables powerful programming patterns. You can perform operations on wrapped values and accumulate error information along the way, creating an audit trail of how values were processed.
The wrapper system includes convenient methods for converting between wrapped and unwrapped values. The extension methods like INT() , FLOAT() , etc., make it easy to wrap existing values, while the from_INT() , from_FLOAT() methods extract the underlying values when needed. The has_error() method provides a consistent interface for checking whether any wrapped value has encountered issues during processing.
The Log Object: Your Debugging Companion
The Log object represents the heart of Light Log's debugging capabilities. Unlike simple string concatenation for error messages, the Log object provides a structured approach to building, modifying, and rendering diagnostic information.
Each Log object carries three essential pieces of information: an error type (info, warning, error, or runtime_error), a message string that can be built incrementally, and an active flag that controls conditional rendering. This structure enables sophisticated logging patterns where you can build up detailed diagnostic information throughout your script's execution and decide later whether and how to display it.
The Log object's methods support fluent chaining, allowing you to build complex messages in a readable way. The write() and write_line() methods append text to the log, while new_line() adds formatting. The clear() method resets the log for reuse, and the rendering methods ( render_now() , render_condition() , and the general render() ) control when and how messages appear.
Defensive Programming Made Easy
Light Log's argument validation functions transform how you write defensive code. Instead of cluttering your functions with verbose validation logic, you can use concise, self-documenting calls that make your intentions clear.
The argument_error() function provides strict validation that halts execution when conditions aren't met – perfect for catching programming errors early. For less critical issues, argument_log_warning() and argument_log_error() record problems without stopping execution, while argument_log_info() provides debug visibility into your function's behavior.
These functions follow a consistent pattern: they take a condition to check, the function name, the argument name, and a descriptive message. This consistency makes error messages predictable and helpful, automatically formatting them to show exactly where problems occurred.
Building Modular, Reusable Code
Light Log encourages a modular approach to Pine Script development by providing tools that make functions more self-contained and reliable. When functions validate their inputs and return wrapped values with error information, they become true black boxes that can be safely composed into larger systems.
The void_return() function addresses Pine Script's requirement that all code paths return a value, even in error handling branches. This utility function provides a clean way to satisfy the compiler while making it clear that a particular code path should never execute.
The static log pattern, initialized with init_static_log() , enables module-wide error tracking. You can create a persistent Log object that accumulates information across multiple function calls, building a comprehensive diagnostic report that helps you understand complex behaviors in your indicators and strategies.
Real-World Applications
In practice, Light Log shines when building sophisticated trading systems. Imagine developing a complex indicator that processes multiple data streams, performs statistical calculations, and generates trading signals. With Light Log, each processing stage can validate its inputs, perform calculations, and pass along both results and diagnostic information.
For example, a moving average calculation might check that the period is positive, that sufficient data exists, and that the input series contains valid values. Instead of failing silently or throwing runtime errors, it can return a FLOAT object that contains either the calculated average or a detailed explanation of why the calculation couldn't be performed.
Strategy developers benefit even more from Light Log's capabilities. Complex entry and exit logic often involves multiple conditions that must all be satisfied. With Light Log, each condition check can contribute to a comprehensive log that explains exactly why a trade was or wasn't taken, making strategy debugging and optimization much more straightforward.
Performance Considerations
While Light Log adds a layer of abstraction over raw Pine Script values, its design minimizes performance impact. The wrapper objects are lightweight, containing only two fields. The logging operations only consume resources when actually rendered, and the conditional rendering system ensures that production code can run with logging disabled for maximum performance.
The library follows Pine Script best practices for performance, using appropriate data structures and avoiding unnecessary operations. The var keyword in init_static_log() ensures that persistent logs don't create new objects on every bar, maintaining efficiency even in real-time calculations.
Getting Started
Adopting Light Log in your Pine Script projects is straightforward. Import the library, wrap your critical values, add validation to your functions, and use Log objects to track important events. Start small by adding logging to a single function, then expand as you see the benefits of better error visibility and code organization.
Remember that Light Log is designed to grow with your needs. You can use as much or as little of its functionality as makes sense for your project. Even simple uses, like adding argument validation to key functions, can significantly improve code reliability and debugging ease.
Transform your Pine Script development experience with Light Log – because professional trading systems deserve professional development tools.
Light Log Technical Deep Dive: Advanced Patterns and Architecture
Understanding Errors as Values
The concept of "errors as values" represents a fundamental shift in how we think about error handling in Pine Script. In traditional Pine Script development, errors are events – they happen at a specific moment in time and immediately interrupt program flow. Light Log transforms errors into data – they become information that flows through your program just like any other value.
This transformation has profound implications. When errors are values, they can be stored, passed between functions, accumulated, transformed, and inspected. They become part of your program's data flow rather than exceptions to it. This approach, popularized by languages like Rust with its Result type and Haskell with its Either monad, brings functional programming's elegance to Pine Script.
Consider a practical example. Traditional Pine Script might calculate a momentum indicator like this:
momentum = close - close
If period is invalid or if there isn't enough historical data, this calculation might produce na or cause subtle bugs. With Light Log's approach:
calculate_momentum(src, period)=>
result = src.FLOAT()
if period <= 0
result.e.write("Invalid period: must be positive", true, ErrorType.error)
result.v := na
else if bar_index < period
result.e.write("Insufficient data: need " + str.tostring(period) + " bars", true, ErrorType.warning)
result.v := na
else
result.v := src - src
result.e.write("Momentum calculated successfully", false, ErrorType.info)
result
Now the function returns not just a value but a complete computational result that includes diagnostic information. Calling code can make intelligent decisions based on both the value and its associated metadata.
The Monad Pattern in Pine Script
While Pine Script lacks the type system features to implement true monads, Light Log brings monadic thinking to Pine Script development. The wrapped types (INT, FLOAT, etc.) act as computational contexts that carry both values and metadata through a series of transformations.
The key insight of monadic programming is that you can chain operations while automatically propagating context. In Light Log, this context is the error state. When you have a FLOAT that contains an error, operations on that FLOAT can check the error state and decide whether to proceed or propagate the error.
This pattern enables what functional programmers call "railway-oriented programming" – your code follows a success track when all is well but can switch to an error track when problems occur. Both tracks lead to the same destination (a result with error information), but they take different paths based on the validity of intermediate values.
Composable Error Handling
Light Log's design encourages composition – building complex functionality from simpler, well-tested components. Each component can validate its inputs, perform its calculation, and return a result with appropriate error information. Higher-level functions can then combine these results intelligently.
Consider building a complex trading signal from multiple indicators:
generate_signal(src, fast_period, slow_period, signal_period) =>
log = init_static_log(ErrorType.info)
// Calculate components with error tracking
fast_ma = calculate_ma(src, fast_period)
slow_ma = calculate_ma(src, slow_period)
// Check for errors in components
if fast_ma.has_error()
log.write_line("Fast MA error: " + fast_ma.e.message, true)
if slow_ma.has_error()
log.write_line("Slow MA error: " + slow_ma.e.message, true)
// Proceed with calculation if no errors
signal = 0.0.FLOAT()
if not (fast_ma.has_error() or slow_ma.has_error())
macd_line = fast_ma.v - slow_ma.v
signal_line = calculate_ma(macd_line, signal_period)
if signal_line.has_error()
log.write_line("Signal line error: " + signal_line.e.message, true)
signal.e := log
else
signal.v := macd_line - signal_line.v
log.write("Signal generated successfully")
else
signal.e := log
signal.v := na
signal
This composable approach makes complex calculations more reliable and easier to debug. Each component is responsible for its own validation and error reporting, and the composite function orchestrates these components while maintaining comprehensive error tracking.
The Static Log Pattern
The init_static_log() function introduces a powerful pattern for maintaining state across function calls. In Pine Script, the var keyword creates variables that persist across bars but are initialized only once. Light Log leverages this to create logging objects that can accumulate information throughout a script's execution.
This pattern is particularly valuable for debugging complex strategies where you need to understand behavior across multiple bars. You can create module-level logs that track important events:
// Module-level diagnostic log
diagnostics = init_static_log(ErrorType.info)
// Track strategy decisions across bars
check_entry_conditions() =>
diagnostics.clear() // Start fresh each bar
diagnostics.write_line("Bar " + str.tostring(bar_index) + " analysis:")
if close > sma(close, 20)
diagnostics.write_line("Price above SMA20", false)
else
diagnostics.write_line("Price below SMA20 - no entry", true, ErrorType.warning)
if volume > sma(volume, 20) * 1.5
diagnostics.write_line("Volume surge detected", false)
else
diagnostics.write_line("Normal volume", false)
// Render diagnostics based on verbosity setting
if debug_mode
diagnostics.render_now()
Advanced Validation Patterns
Light Log's argument validation functions enable sophisticated precondition checking that goes beyond simple null checks. You can implement complex validation logic while keeping your code readable:
validate_price_data(open_val, high_val, low_val, close_val) =>
argument_error(na(open_val) or na(high_val) or na(low_val) or na(close_val),
"validate_price_data", "OHLC values", "contain na values")
argument_error(high_val < low_val,
"validate_price_data", "high/low", "high is less than low")
argument_error(close_val > high_val or close_val < low_val,
"validate_price_data", "close", "is outside high/low range")
argument_log_warning(high_val == low_val,
"validate_price_data", "high/low", "are equal (no range)")
This validation function documents its requirements clearly and fails fast with helpful error messages when assumptions are violated. The mix of errors (which halt execution) and warnings (which allow continuation) provides fine-grained control over how strict your validation should be.
Performance Optimization Strategies
While Light Log adds abstraction, careful design minimizes overhead. Understanding Pine Script's execution model helps you use Light Log efficiently.
Pine Script executes once per bar, so operations that seem expensive in traditional programming might have negligible impact. However, when building real-time systems, every optimization matters. Light Log provides several patterns for efficient use:
Lazy Evaluation: Log messages are only built when they'll be rendered. Use conditional logging to avoid string concatenation in production:
if debug_mode
log.write_line("Calculated value: " + str.tostring(complex_calculation))
Selective Wrapping: Not every value needs error tracking. Wrap values at API boundaries and critical calculation points, but use raw values for simple operations:
// Wrap at boundaries
input_price = close.FLOAT()
validated_period = validate_period(input_period).INT()
// Use raw values internally
sum = 0.0
for i = 0 to validated_period.v - 1
sum += close
Error Propagation: When errors occur early, avoid expensive calculations:
process_data(input) =>
validated = validate_input(input)
if validated.has_error()
validated // Return early with error
else
// Expensive processing only if valid
perform_complex_calculation(validated)
Integration Patterns
Light Log integrates smoothly with existing Pine Script code. You can adopt it incrementally, starting with critical functions and expanding coverage as needed.
Boundary Validation: Add Light Log at the boundaries of your system – where user input enters and where final outputs are produced. This catches most errors while minimizing changes to existing code.
Progressive Enhancement: Start by adding argument validation to existing functions. Then wrap return values. Finally, add comprehensive logging. Each step improves reliability without requiring a complete rewrite.
Testing and Debugging: Use Light Log's conditional rendering to create debug modes for your scripts. Production users see clean output while developers get detailed diagnostics:
// User input for debug mode
debug = input.bool(false, "Enable debug logging")
// Conditional diagnostic output
if debug
diagnostics.render_now()
else
diagnostics.render_condition() // Only shows errors/warnings
Future-Proofing Your Code
Light Log's patterns prepare your code for Pine Script's evolution. As Pine Script adds more sophisticated features, code that uses structured error handling and defensive programming will adapt more easily than code that relies on implicit assumptions.
The type wrapper system, in particular, positions your code to take advantage of potential future features or more sophisticated type inference. By thinking in terms of wrapped values and error propagation today, you're building code that will remain maintainable and extensible tomorrow.
Light Log doesn't just make your Pine Script better today – it prepares it for the trading systems you'll need to build tomorrow.
Library "light_log"
A lightweight logging and defensive programming library for Pine Script.
Designed for modular and extensible scripts, this utility provides structured runtime validation,
conditional logging, and reusable `Log` objects for centralized error propagation.
It also introduces a typed wrapping system for all native Pine values (e.g., `INT`, `FLOAT`, `LABEL`),
allowing values to carry errors alongside data. This enables functional-style flows with built-in
validation tracking, error detection (`has_error()`), and fluent chaining.
Inspired by structured logging patterns found in systems like C#, it reduces boilerplate,
enforces argument safety, and encourages clean, maintainable code architecture.
method INT(self, error_type)
Wraps an `int` value into an `INT` struct with an optional log severity.
Namespace types: series int, simple int, input int, const int
Parameters:
self (int) : The raw `int` value to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: An `INT` object containing the value and a default Log instance.
method FLOAT(self, error_type)
Wraps a `float` value into a `FLOAT` struct with an optional log severity.
Namespace types: series float, simple float, input float, const float
Parameters:
self (float) : The raw `float` value to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `FLOAT` object containing the value and a default Log instance.
method BOOL(self, error_type)
Wraps a `bool` value into a `BOOL` struct with an optional log severity.
Namespace types: series bool, simple bool, input bool, const bool
Parameters:
self (bool) : The raw `bool` value to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `BOOL` object containing the value and a default Log instance.
method STRING(self, error_type)
Wraps a `string` value into a `STRING` struct with an optional log severity.
Namespace types: series string, simple string, input string, const string
Parameters:
self (string) : The raw `string` value to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `STRING` object containing the value and a default Log instance.
method COLOR(self, error_type)
Wraps a `color` value into a `COLOR` struct with an optional log severity.
Namespace types: series color, simple color, input color, const color
Parameters:
self (color) : The raw `color` value to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `COLOR` object containing the value and a default Log instance.
method LINE(self, error_type)
Wraps a `line` object into a `LINE` struct with an optional log severity.
Namespace types: series line
Parameters:
self (line) : The raw `line` object to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `LINE` object containing the value and a default Log instance.
method LABEL(self, error_type)
Wraps a `label` object into a `LABEL` struct with an optional log severity.
Namespace types: series label
Parameters:
self (label) : The raw `label` object to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `LABEL` object containing the value and a default Log instance.
method BOX(self, error_type)
Wraps a `box` object into a `BOX` struct with an optional log severity.
Namespace types: series box
Parameters:
self (box) : The raw `box` object to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `BOX` object containing the value and a default Log instance.
method TABLE(self, error_type)
Wraps a `table` object into a `TABLE` struct with an optional log severity.
Namespace types: series table
Parameters:
self (table) : The raw `table` object to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `TABLE` object containing the value and a default Log instance.
method CHART_POINT(self, error_type)
Wraps a `chart.point` value into a `CHART_POINT` struct with an optional log severity.
Namespace types: chart.point
Parameters:
self (chart.point) : The raw `chart.point` value to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `CHART_POINT` object containing the value and a default Log instance.
method POLYLINE(self, error_type)
Wraps a `polyline` object into a `POLYLINE` struct with an optional log severity.
Namespace types: series polyline, series polyline, series polyline, series polyline
Parameters:
self (polyline) : The raw `polyline` object to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `POLYLINE` object containing the value and a default Log instance.
method LINEFILL(self, error_type)
Wraps a `linefill` object into a `LINEFILL` struct with an optional log severity.
Namespace types: series linefill
Parameters:
self (linefill) : The raw `linefill` object to wrap.
error_type (series ErrorType) : Optional severity level to associate with the log. Default is `ErrorType.error`.
Returns: A `LINEFILL` object containing the value and a default Log instance.
method from_INT(self)
Extracts the integer value from an INT wrapper.
Namespace types: INT
Parameters:
self (INT) : The wrapped INT instance.
Returns: The underlying `int` value.
method from_FLOAT(self)
Extracts the float value from a FLOAT wrapper.
Namespace types: FLOAT
Parameters:
self (FLOAT) : The wrapped FLOAT instance.
Returns: The underlying `float` value.
method from_BOOL(self)
Extracts the boolean value from a BOOL wrapper.
Namespace types: BOOL
Parameters:
self (BOOL) : The wrapped BOOL instance.
Returns: The underlying `bool` value.
method from_STRING(self)
Extracts the string value from a STRING wrapper.
Namespace types: STRING
Parameters:
self (STRING) : The wrapped STRING instance.
Returns: The underlying `string` value.
method from_COLOR(self)
Extracts the color value from a COLOR wrapper.
Namespace types: COLOR
Parameters:
self (COLOR) : The wrapped COLOR instance.
Returns: The underlying `color` value.
method from_LINE(self)
Extracts the line object from a LINE wrapper.
Namespace types: LINE
Parameters:
self (LINE) : The wrapped LINE instance.
Returns: The underlying `line` object.
method from_LABEL(self)
Extracts the label object from a LABEL wrapper.
Namespace types: LABEL
Parameters:
self (LABEL) : The wrapped LABEL instance.
Returns: The underlying `label` object.
method from_BOX(self)
Extracts the box object from a BOX wrapper.
Namespace types: BOX
Parameters:
self (BOX) : The wrapped BOX instance.
Returns: The underlying `box` object.
method from_TABLE(self)
Extracts the table object from a TABLE wrapper.
Namespace types: TABLE
Parameters:
self (TABLE) : The wrapped TABLE instance.
Returns: The underlying `table` object.
method from_CHART_POINT(self)
Extracts the chart.point from a CHART_POINT wrapper.
Namespace types: CHART_POINT
Parameters:
self (CHART_POINT) : The wrapped CHART_POINT instance.
Returns: The underlying `chart.point` value.
method from_POLYLINE(self)
Extracts the polyline object from a POLYLINE wrapper.
Namespace types: POLYLINE
Parameters:
self (POLYLINE) : The wrapped POLYLINE instance.
Returns: The underlying `polyline` object.
method from_LINEFILL(self)
Extracts the linefill object from a LINEFILL wrapper.
Namespace types: LINEFILL
Parameters:
self (LINEFILL) : The wrapped LINEFILL instance.
Returns: The underlying `linefill` object.
method has_error(self)
Returns true if the INT wrapper has an active log entry.
Namespace types: INT
Parameters:
self (INT) : The INT instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the FLOAT wrapper has an active log entry.
Namespace types: FLOAT
Parameters:
self (FLOAT) : The FLOAT instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the BOOL wrapper has an active log entry.
Namespace types: BOOL
Parameters:
self (BOOL) : The BOOL instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the STRING wrapper has an active log entry.
Namespace types: STRING
Parameters:
self (STRING) : The STRING instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the COLOR wrapper has an active log entry.
Namespace types: COLOR
Parameters:
self (COLOR) : The COLOR instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the LINE wrapper has an active log entry.
Namespace types: LINE
Parameters:
self (LINE) : The LINE instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the LABEL wrapper has an active log entry.
Namespace types: LABEL
Parameters:
self (LABEL) : The LABEL instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the BOX wrapper has an active log entry.
Namespace types: BOX
Parameters:
self (BOX) : The BOX instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the TABLE wrapper has an active log entry.
Namespace types: TABLE
Parameters:
self (TABLE) : The TABLE instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the CHART_POINT wrapper has an active log entry.
Namespace types: CHART_POINT
Parameters:
self (CHART_POINT) : The CHART_POINT instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the POLYLINE wrapper has an active log entry.
Namespace types: POLYLINE
Parameters:
self (POLYLINE) : The POLYLINE instance to check.
Returns: True if an error or message is active in the log.
method has_error(self)
Returns true if the LINEFILL wrapper has an active log entry.
Namespace types: LINEFILL
Parameters:
self (LINEFILL) : The LINEFILL instance to check.
Returns: True if an error or message is active in the log.
void_return()
Utility function used when a return is syntactically required but functionally unnecessary.
Returns: Nothing. Function never executes its body.
argument_error(condition, function, argument, message)
Throws a runtime error when a condition is met. Used for strict argument validation.
Parameters:
condition (bool) : Boolean expression that triggers the runtime error.
function (string) : Name of the calling function (for formatting).
argument (string) : Name of the problematic argument.
message (string) : Description of the error cause.
Returns: Never returns. Halts execution if the condition is true.
argument_log_info(condition, function, argument, message)
Logs an informational message when a condition is met. Used for optional debug visibility.
Parameters:
condition (bool) : Boolean expression that triggers the log.
function (string) : Name of the calling function.
argument (string) : Argument name being referenced.
message (string) : Informational message to log.
Returns: Nothing. Logs if the condition is true.
argument_log_warning(condition, function, argument, message)
Logs a warning when a condition is met. Non-fatal but highlights potential issues.
Parameters:
condition (bool) : Boolean expression that triggers the warning.
function (string) : Name of the calling function.
argument (string) : Argument name being referenced.
message (string) : Warning message to log.
Returns: Nothing. Logs if the condition is true.
argument_log_error(condition, function, argument, message)
Logs an error message when a condition is met. Does not halt execution.
Parameters:
condition (bool) : Boolean expression that triggers the error log.
function (string) : Name of the calling function.
argument (string) : Argument name being referenced.
message (string) : Error message to log.
Returns: Nothing. Logs if the condition is true.
init_static_log(error_type, message, active)
Initializes a persistent (var) Log object. Ideal for global logging in scripts or modules.
Parameters:
error_type (series ErrorType) : Initial severity level (required).
message (string) : Optional starting message string. Default value of ("").
active (bool) : Whether the log should be flagged active on initialization. Default value of (false).
Returns: A static Log object with the given parameters.
method new_line(self)
Appends a newline character to the Log message. Useful for separating entries during chained writes.
Namespace types: Log
Parameters:
self (Log) : The Log instance to modify.
Returns: The updated Log object with a newline appended.
method write(self, message, flag_active, error_type)
Appends a message to a Log object without a newline. Updates severity and active state if specified.
Namespace types: Log
Parameters:
self (Log) : The Log instance being modified.
message (string) : The text to append to the log.
flag_active (bool) : Whether to activate the log for conditional rendering. Default value of (false).
error_type (series ErrorType) : Optional override for the severity level. Default value of (na).
Returns: The updated Log object.
method write_line(self, message, flag_active, error_type)
Appends a message to a Log object, prefixed with a newline for clarity.
Namespace types: Log
Parameters:
self (Log) : The Log instance being modified.
message (string) : The text to append to the log.
flag_active (bool) : Whether to activate the log for conditional rendering. Default value of (false).
error_type (series ErrorType) : Optional override for the severity level. Default value of (na).
Returns: The updated Log object.
method clear(self, flag_active, error_type)
Clears a Log object’s message and optionally reactivates it. Can also update the error type.
Namespace types: Log
Parameters:
self (Log) : The Log instance being cleared.
flag_active (bool) : Whether to activate the log after clearing. Default value of (false).
error_type (series ErrorType) : Optional new error type to assign. If not provided, the previous type is retained. Default value of (na).
Returns: The cleared Log object.
method render_condition(self, flag_active, error_type)
Conditionally renders the log if it is active. Allows overriding error type and controlling active state afterward.
Namespace types: Log
Parameters:
self (Log) : The Log instance to evaluate and render.
flag_active (bool) : Whether to activate the log after rendering. Default value of (false).
error_type (series ErrorType) : Optional error type override. Useful for contextual formatting just before rendering. Default value of (na).
Returns: The updated Log object.
method render_now(self, flag_active, error_type)
Immediately renders the log regardless of `active` state. Allows overriding error type and active flag.
Namespace types: Log
Parameters:
self (Log) : The Log instance to render.
flag_active (bool) : Whether to activate the log after rendering. Default value of (false).
error_type (series ErrorType) : Optional error type override. Allows dynamic severity adjustment at render time. Default value of (na).
Returns: The updated Log object.
render(self, condition, flag_active, error_type)
Renders the log conditionally or unconditionally. Allows full control over render behavior.
Parameters:
self (Log) : The Log instance to render.
condition (bool) : If true, renders only if the log is active. If false, always renders. Default value of (false).
flag_active (bool) : Whether to activate the log after rendering. Default value of (false).
error_type (series ErrorType) : Optional error type override passed to the render methods. Default value of (na).
Returns: The updated Log object.
Log
A structured object used to store and render logging messages.
Fields:
error_type (series ErrorType) : The severity level of the message (from the ErrorType enum).
message (series string) : The text of the log message.
active (series bool) : Whether the log should trigger rendering when conditionally evaluated.
INT
A wrapped integer type with attached logging for validation or tracing.
Fields:
v (series int) : The underlying `int` value.
e (Log) : Optional log object describing validation status or error context.
FLOAT
A wrapped float type with attached logging for validation or tracing.
Fields:
v (series float) : The underlying `float` value.
e (Log) : Optional log object describing validation status or error context.
BOOL
A wrapped boolean type with attached logging for validation or tracing.
Fields:
v (series bool) : The underlying `bool` value.
e (Log) : Optional log object describing validation status or error context.
STRING
A wrapped string type with attached logging for validation or tracing.
Fields:
v (series string) : The underlying `string` value.
e (Log) : Optional log object describing validation status or error context.
COLOR
A wrapped color type with attached logging for validation or tracing.
Fields:
v (series color) : The underlying `color` value.
e (Log) : Optional log object describing validation status or error context.
LINE
A wrapped line object with attached logging for validation or tracing.
Fields:
v (series line) : The underlying `line` value.
e (Log) : Optional log object describing validation status or error context.
LABEL
A wrapped label object with attached logging for validation or tracing.
Fields:
v (series label) : The underlying `label` value.
e (Log) : Optional log object describing validation status or error context.
BOX
A wrapped box object with attached logging for validation or tracing.
Fields:
v (series box) : The underlying `box` value.
e (Log) : Optional log object describing validation status or error context.
TABLE
A wrapped table object with attached logging for validation or tracing.
Fields:
v (series table) : The underlying `table` value.
e (Log) : Optional log object describing validation status or error context.
CHART_POINT
A wrapped chart point with attached logging for validation or tracing.
Fields:
v (chart.point) : The underlying `chart.point` value.
e (Log) : Optional log object describing validation status or error context.
POLYLINE
A wrapped polyline object with attached logging for validation or tracing.
Fields:
v (series polyline) : The underlying `polyline` value.
e (Log) : Optional log object describing validation status or error context.
LINEFILL
A wrapped linefill object with attached logging for validation or tracing.
Fields:
v (series linefill) : The underlying `linefill` value.
e (Log) : Optional log object describing validation status or error context.
CVD Divergence & Volume ProfileThis Pine Script indicator, named "CVD Divergence & Volume Profile," is designed to identify potential trading opportunities by combining Cumulative Volume Delta (CVD) divergence with Volume Profile levels and an optional Simple Moving Average (SMA) trend filter. It plots signals directly on the price chart.
Here's a breakdown of what each component does and how to potentially trade with it:
1. Cumulative Volume Delta (CVD) Divergence
What it does: CVD measures the cumulative difference between buying and selling volume. A rising CVD indicates more buying pressure, while a falling CVD indicates more selling pressure. Divergence occurs when the price action contradicts the CVD's direction, suggesting a potential shift in momentum or trend reversal.
Bearish Divergence: The price makes a higher high, but the CVD makes a lower high (or fails to make a new high). This suggests that despite the price increasing, the underlying buying pressure is weakening.
Bullish Divergence: The price makes a lower low, but the CVD makes a higher low (or fails to make a new low). This suggests that despite the price decreasing, the underlying selling pressure is weakening.
Visualization:
Red triangle pointing down on the chart indicates a Bearish Divergence signal.
Green triangle pointing up on the chart indicates a Bullish Divergence signal.
2. Volume Profile Levels (VAH, VAL, POC)
What it does: The indicator calculates simplified Volume Profile levels over a user-defined vp_range (number of candles). These levels represent areas where significant trading activity has occurred:
VAH (Value Area High): The upper boundary of the "Value Area," where 70% of the volume traded.
VAL (Value Area Low): The lower boundary of the "Value Area," where 70% of the volume traded.
POC (Point of Control): The price level within the vp_range where the most volume was traded.
Significance: These levels often act as significant support and resistance zones.
Visualization:
Orange lines for VAH and VAL.
Yellow line for POC.
Zone Proximity (zone_thresh): The indicator only generates divergence signals if the current close price is within a specified percentage zone_thresh of either VAH, VAL, or POC. This filters signals to areas of high liquidity and potential turning points.
3. Trend Filter (SMA)
What it does: This is an optional filter (use_trend_filter) that uses a Simple Moving Average (sma_period, default 200).
Significance: It helps ensure that divergence signals are traded in alignment with the broader market trend, potentially increasing their reliability.
For long signals (bullish divergence), the price (close) must be above the SMA (indicating an uptrend).
For short signals (bearish divergence), the price (close) must be below the SMA (indicating a downtrend).
Visualization: A blue line on the chart representing the SMA.
How to Trade with It (Potential Strategies)
The indicator aims to provide high-probability entry points by combining multiple confirming factors. Here's how you might interpret and trade the signals:
Identify Divergence: Look for the triangle signals on your chart (red for bearish, green for bullish).
Confirm Proximity to Volume Profile Levels: The signal itself confirms that the price is near a significant Volume Profile level (VAH, VAL, or POC). These are areas where price often reacts.
Bullish Signal (Green Triangle): This suggests buying momentum is returning after a price decline, especially when the price is near VAL or POC, which might act as support.
Bearish Signal (Red Triangle): This suggests selling momentum is increasing after a price rally, especially when the price is near VAH or POC, which might act as resistance.
Check Trend Alignment (SMA Filter):
For a long trade: You would ideally want to see a green triangle (bullish divergence) while the price is above the blue SMA line. This indicates a bullish divergence confirming a potential bounce within an existing uptrend.
For a short trade: You would ideally want to see a red triangle (bearish divergence) while the price is below the blue SMA line. This indicates a bearish divergence confirming a potential rejection within an existing downtrend.
Entry and Exit Considerations:
Entry: Consider entering a trade on the candle where the signal appears, or on the subsequent candle for confirmation.
Stop Loss: For a long trade, a logical stop-loss could be placed below the lowest point of the divergence, or below the VAL/POC if the signal occurred near it. For a short trade, above the highest point of the divergence or VAH/POC.
Take Profit: Targets could be set at the opposite Volume Profile level, previous swing highs/lows, or using a fixed risk-reward ratio.
Example Trading Scenario:
Long Trade: You see a green triangle (bullish divergence) printed on the chart. You notice the price is currently at the VAL (orange line). You check the blue SMA line and confirm that the price is above it (uptrend). This confluence of factors (bullish divergence, support at VAL, and uptrend) provides a strong potential long entry signal. You might enter, place your stop loss just below VAL, and target VAH or the next resistance level.
Short Trade: You see a red triangle (bearish divergence). The price is at the VAH (orange line). The price is also below the blue SMA line (downtrend). This suggests a potential short entry. You might enter, place your stop loss just above VAH, and target VAL or the next support level.
Strategy Stats [presentTrading]Hello! it's another weekend. This tool is a strategy performance analysis tool. Looking at the TradingView community, it seems few creators focus on this aspect. I've intentionally created a shared version. Welcome to share your idea or question on this.
█ Introduction and How it is Different
Strategy Stats is a comprehensive performance analytics framework designed specifically for trading strategies. Unlike standard strategy backtesting tools that simply show cumulative profits, this analytics suite provides real-time, multi-timeframe statistical analysis of your trading performance.
Multi-timeframe analysis: Automatically tracks performance metrics across the most recent time periods (last 7 days, 30 days, 90 days, 1 year, and 4 years)
Advanced statistical measures: Goes beyond basic metrics to include Information Coefficient (IC) and Sortino Ratio
Real-time feedback: Updates performance statistics with each new trade
Visual analytics: Color-coded performance table provides instant visual feedback on strategy health
Integrated risk management: Implements sophisticated take profit mechanisms with 3-step ATR and percentage-based exits
BTCUSD Performance
The table in the upper right corner is a comprehensive performance dashboard showing trading strategy statistics.
Note: While this presentation uses Vegas SuperTrend as the underlying strategy, this is merely an example. The Stats framework can be applied to any trading strategy. The Vegas SuperTrend implementation is included solely to demonstrate how the analytics module integrates with a trading strategy.
⚠️ Timeframe Limitations
Important: TradingView's backtesting engine has a maximum storage limit of 10,000 bars. When using this strategy stats framework on smaller timeframes such as 1-hour or 2-hour charts, you may encounter errors if your backtesting period is too long.
Recommended Timeframe Usage:
Ideal for: 4H, 6H, 8H, Daily charts and above
May cause errors on: 1H, 2H charts spanning multiple years
Not recommended for: Timeframes below 1H with long history
█ Strategy, How it Works: Detailed Explanation
The Strategy Stats framework consists of three primary components: statistical data collection, performance analysis, and visualization.
🔶 Statistical Data Collection
The system maintains several critical data arrays:
equityHistory: Tracks equity curve over time
tradeHistory: Records profit/loss of each trade
predictionSignals: Stores trade direction signals (1 for long, -1 for short)
actualReturns: Records corresponding actual returns from each trade
For each closed trade, the system captures:
float tradePnL = strategy.closedtrades.profit(tradeIndex)
float tradeReturn = strategy.closedtrades.profit_percent(tradeIndex)
int tradeType = entryPrice < exitPrice ? 1 : -1 // Direction
🔶 Performance Metrics Calculation
The framework calculates several key performance metrics:
Information Coefficient (IC):
The correlation between prediction signals and actual returns, measuring forecast skill.
IC = Correlation(predictionSignals, actualReturns)
Where Correlation is the Pearson correlation coefficient:
Correlation(X,Y) = (nΣXY - ΣXY) / √
Sortino Ratio:
Measures risk-adjusted return focusing only on downside risk:
Sortino = (Avg_Return - Risk_Free_Rate) / Downside_Deviation
Where Downside Deviation is:
Downside_Deviation = √
R_i represents individual returns, T is the target return (typically the risk-free rate), and n is the number of observations.
Maximum Drawdown:
Tracks the largest percentage drop from peak to trough:
DD = (Peak_Equity - Trough_Equity) / Peak_Equity * 100
🔶 Time Period Calculation
The system automatically determines the appropriate number of bars to analyze for each timeframe based on the current chart timeframe:
bars_7d = math.max(1, math.round(7 * barsPerDay))
bars_30d = math.max(1, math.round(30 * barsPerDay))
bars_90d = math.max(1, math.round(90 * barsPerDay))
bars_365d = math.max(1, math.round(365 * barsPerDay))
bars_4y = math.max(1, math.round(365 * 4 * barsPerDay))
Where barsPerDay is calculated based on the chart timeframe:
barsPerDay = timeframe.isintraday ?
24 * 60 / math.max(1, (timeframe.in_seconds() / 60)) :
timeframe.isdaily ? 1 :
timeframe.isweekly ? 1/7 :
timeframe.ismonthly ? 1/30 : 0.01
🔶 Visual Representation
The system presents performance data in a color-coded table with intuitive visual indicators:
Green: Excellent performance
Lime: Good performance
Gray: Neutral performance
Orange: Mediocre performance
Red: Poor performance
█ Trade Direction
The Strategy Stats framework supports three trading directions:
Long Only: Only takes long positions when entry conditions are met
Short Only: Only takes short positions when entry conditions are met
Both: Takes both long and short positions depending on market conditions
█ Usage
To effectively use the Strategy Stats framework:
Apply to existing strategies: Add the performance tracking code to any strategy to gain advanced analytics
Monitor multiple timeframes: Use the multi-timeframe analysis to identify performance trends
Evaluate strategy health: Review IC and Sortino ratios to assess predictive power and risk-adjusted returns
Optimize parameters: Use performance data to refine strategy parameters
Compare strategies: Apply the framework to multiple strategies to identify the most effective approach
For best results, allow the strategy to generate sufficient trade history for meaningful statistical analysis (at least 20-30 trades).
█ Default Settings
The default settings have been carefully calibrated for cryptocurrency markets:
Performance Tracking:
Time periods: 7D, 30D, 90D, 1Y, 4Y
Statistical measures: Return, Win%, MaxDD, IC, Sortino Ratio
IC color thresholds: >0.3 (green), >0.1 (lime), <-0.1 (orange), <-0.3 (red)
Sortino color thresholds: >1.0 (green), >0.5 (lime), <0 (red)
Multi-Step Take Profit:
ATR multipliers: 2.618, 5.0, 10.0
Percentage levels: 3%, 8%, 17%
Short multiplier: 1.5x (makes short take profits more aggressive)
Stop loss: 20%
Keltner Channel StrategyOverview
The Keltner Channel Strategy is a powerful trend-following and mean-reversion system that leverages the Keltner Channels, EMA crossovers, and ATR-based stop-losses to optimize trade entries and exits. This strategy has proven to be highly effective, particularly when applied to Gold (XAUUSD) and other commodities with strong trend characteristics.
📈 How It Works
This strategy incorporates two trading approaches: 1️⃣ Keltner Channel Reversal Trades – Identifies overbought and oversold conditions when price touches the outer bands.
2️⃣ Trend Following Trades – Uses the 9 EMA & 21 EMA crossover, with confirmation from the 50 EMA, to enter trades in the direction of the trend.
🔍 Entry & Exit Criteria
📊 Keltner Channel Entries (Reversal Strategy)
✅ Long Entry: When the price crosses below the lower Keltner Band (potential reversal).
✅ Short Entry: When the price crosses above the upper Keltner Band (potential reversal).
⏳ Exit Conditions:
Long positions close when price crosses back above the mid-band (EMA-based).
Short positions close when price crosses back below the mid-band (EMA-based).
📈 Trend Following Entries (Momentum Strategy)
✅ Long Entry: When the 9 EMA crosses above the 21 EMA, and price is above the 50 EMA (bullish momentum).
✅ Short Entry: When the 9 EMA crosses below the 21 EMA, and price is below the 50 EMA (bearish momentum).
⏳ Exit Conditions:
Long positions close when the 9 EMA crosses back below the 21 EMA.
Short positions close when the 9 EMA crosses back above the 21 EMA.
📌 Risk Management & Profit Targeting
ATR-based Stop-Losses:
Long trades: Stop set at 1.5x ATR below entry price.
Short trades: Stop set at 1.5x ATR above entry price.
Take-Profit Levels:
Long trades: Profit target 2x ATR above entry price.
Short trades: Profit target 2x ATR below entry price.
🚀 Why Use This Strategy?
✅ Works exceptionally well on Gold (XAUUSD) due to high volatility.
✅ Combines reversal & trend strategies for improved adaptability.
✅ Uses ATR-based risk management for dynamic position sizing.
✅ Fully automated alerts for trade entries and exits.
🔔 Alerts
This script includes automated TradingView alerts for:
🔹 Keltner Band touches (Reversal signals).
🔹 EMA crossovers (Momentum trades).
🔹 Stop-loss & Take-profit activations.
📊 Ideal Markets & Timeframes
Best for: Gold (XAUUSD), NASDAQ (NQ), Crude Oil (CL), and trending assets.
Recommended Timeframes: 15m, 1H, 4H, Daily.
⚡️ How to Use
1️⃣ Add this script to your TradingView chart.
2️⃣ Select a 15m, 1H, or 4H timeframe for optimal results.
3️⃣ Enable alerts to receive trade notifications in real time.
4️⃣ Backtest and tweak ATR settings to fit your trading style.
🚀 Optimize your Gold trading with this Keltner Channel Strategy! Let me know how it performs for you. 💰📊
Money Flow Indicator (Chaikin Oscillator) with VWAPStrategy Overview
Entry Conditions:
Buy Entry:
The Chaikin Oscillator crosses above the signal line.
The current price is above the VWAP.
Sell Entry:
The Chaikin Oscillator crosses below the signal line.
The current price is below the VWAP.
Exit Conditions:
Profit Taking:
Take profit when a target profit is reached (e.g., a 2% increase from the entry price).
Stop Loss:
Set a stop loss, for example, at a 1% decline from the entry price.
Risk Management:
Manage risk by limiting each trade to no more than 1-2% of the account balance.
Calculate position size based on risk and trade accordingly.
Trend Confirmation:
Use other indicators (like moving averages) to confirm the overall trend and focus trades in the direction of the trend.
In an uptrend, prioritize buy entries; in a downtrend, prioritize sell entries.
Specific Trade Scenarios
Example 1: Buy Entry:
Enter a buy position when the Chaikin Oscillator crosses above the signal line and the price is above the VWAP.
Set a stop loss 1% below the entry price and a profit target 2% above the entry price.
Example 2: Sell Entry:
Enter a sell position when the Chaikin Oscillator crosses below the signal line and the price is below the VWAP.
Set a stop loss 1% above the entry price and a profit target 2% below the entry price.
Additional Considerations
Backtesting: Test this strategy with historical data to evaluate performance and make adjustments as needed.
Market Conditions: Pay attention to market volatility and economic indicators, adjusting the trading strategy flexibly.
Psychological Factors: Avoid emotional decisions and follow clear rules when trading.
CapitalManagementLibrary "CapitalManagement"
TODO: Manage the capital
order_volume(percent_risk, order_entry_price, stop_loss_price)
: Function to calculate order volume according to give risk percent_risk
Parameters:
percent_risk (float)
order_entry_price (float)
stop_loss_price (float)
calculate_takeprofit_price(entry_price, stop_loss_price, risk_reward)
: Function to calculate take profit price according to given risk:reward ratio
Parameters:
entry_price (float)
stop_loss_price (float)
risk_reward (float)
Returns: Return take profit value according to given risk:reward ratio
Mean Reversion Cloud (Ornstein-Uhlenbeck) // AlgoFyreThe Mean Reversion Cloud (Ornstein-Uhlenbeck) indicator detects mean-reversion opportunities by applying the Ornstein-Uhlenbeck process. It calculates a dynamic mean using an Exponential Weighted Moving Average, surrounded by volatility bands, signaling potential buy/sell points when prices deviate.
TABLE OF CONTENTS
🔶 ORIGINALITY
🔸Adaptive Mean Calculation
🔸Volatility-Based Cloud
🔸Speed of Reversion (θ)
🔶 FUNCTIONALITY
🔸Dynamic Mean and Volatility Bands
🞘 How it works
🞘 How to calculate
🞘 Code extract
🔸Visualization via Table and Plotshapes
🞘 Table Overview
🞘 Plotshapes Explanation
🞘 Code extract
🔶 INSTRUCTIONS
🔸Step-by-Step Guidelines
🞘 Setting Up the Indicator
🞘 Understanding What to Look For on the Chart
🞘 Possible Entry Signals
🞘 Possible Take Profit Strategies
🞘 Possible Stop-Loss Levels
🞘 Additional Tips
🔸Customize settings
🔶 CONCLUSION
▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅▅
🔶 ORIGINALITY The Mean Reversion Cloud (Ornstein-Uhlenbeck) is a unique indicator that applies the Ornstein-Uhlenbeck stochastic process to identify mean-reverting behavior in asset prices. Unlike traditional moving average-based indicators, this model uses an Exponentially Weighted Moving Average (EWMA) to calculate the long-term mean, dynamically adjusting to recent price movements while still considering all historical data. It also incorporates volatility bands, providing a "cloud" that visually highlights overbought or oversold conditions. By calculating the speed of mean reversion (θ) through the autocorrelation of log returns, this indicator offers traders a more nuanced and mathematically robust tool for identifying mean-reversion opportunities. These innovations make it especially useful for markets that exhibit range-bound characteristics, offering timely buy and sell signals based on statistical deviations from the mean.
🔸Adaptive Mean Calculation Traditional MA indicators use fixed lengths, which can lead to lagging signals or over-sensitivity in volatile markets. The Mean Reversion Cloud uses an Exponentially Weighted Moving Average (EWMA), which adapts to price movements by dynamically adjusting its calculation, offering a more responsive mean.
🔸Volatility-Based Cloud Unlike simple moving averages that only plot a single line, the Mean Reversion Cloud surrounds the dynamic mean with volatility bands. These bands, based on standard deviations, provide traders with a visual cue of when prices are statistically likely to revert, highlighting potential reversal zones.
🔸Speed of Reversion (θ) The indicator goes beyond price averages by calculating the speed at which the price reverts to the mean (θ), using the autocorrelation of log returns. This gives traders an additional tool for estimating the likelihood and timing of mean reversion, making the signals more reliable in practice.
🔶 FUNCTIONALITY The Mean Reversion Cloud (Ornstein-Uhlenbeck) indicator is designed to detect potential mean-reversion opportunities in asset prices by applying the Ornstein-Uhlenbeck stochastic process. It calculates a dynamic mean through the Exponentially Weighted Moving Average (EWMA) and plots volatility bands based on the standard deviation of the asset's price over a specified period. These bands create a "cloud" that represents expected price fluctuations, helping traders to identify overbought or oversold conditions. By calculating the speed of reversion (θ) from the autocorrelation of log returns, the indicator offers a more refined way of assessing how quickly prices may revert to the mean. Additionally, the inclusion of volatility provides a comprehensive view of market conditions, allowing for more accurate buy and sell signals.
Let's dive into the details:
🔸Dynamic Mean and Volatility Bands The dynamic mean (μ) is calculated using the EWMA, giving more weight to recent prices but considering all historical data. This process closely resembles the Ornstein-Uhlenbeck (OU) process, which models the tendency of a stochastic variable (such as price) to revert to its mean over time. Volatility bands are plotted around the mean using standard deviation, forming the "cloud" that signals overbought or oversold conditions. The cloud adapts dynamically to price fluctuations and market volatility, making it a versatile tool for mean-reversion strategies. 🞘 How it works Step one: Calculate the dynamic mean (μ) The Ornstein-Uhlenbeck process describes how a variable, such as an asset's price, tends to revert to a long-term mean while subject to random fluctuations. In this indicator, the EWMA is used to compute the dynamic mean (μ), mimicking the mean-reverting behavior of the OU process. Use the EWMA formula to compute a weighted mean that adjusts to recent price movements. Assign exponentially decreasing weights to older data while giving more emphasis to current prices. Step two: Plot volatility bands Calculate the standard deviation of the price over a user-defined period to determine market volatility. Position the upper and lower bands around the mean by adding and subtracting a multiple of the standard deviation. 🞘 How to calculate Exponential Weighted Moving Average (EWMA)
The EWMA dynamically adjusts to recent price movements:
mu_t = lambda * mu_{t-1} + (1 - lambda) * P_t
Where mu_t is the mean at time t, lambda is the decay factor, and P_t is the price at time t. The higher the decay factor, the more weight is given to recent data.
Autocorrelation (ρ) and Standard Deviation (σ)
To measure mean reversion speed and volatility: rho = correlation(log(close), log(close ), length) Where rho is the autocorrelation of log returns over a specified period.
To calculate volatility:
sigma = stdev(close, length)
Where sigma is the standard deviation of the asset's closing price over a specified length.
Upper and Lower Bands
The upper and lower bands are calculated as follows:
upper_band = mu + (threshold * sigma)
lower_band = mu - (threshold * sigma)
Where threshold is a multiplier for the standard deviation, usually set to 2. These bands represent the range within which the price is expected to fluctuate, based on current volatility and the mean.
🞘 Code extract // Calculate Returns
returns = math.log(close / close )
// Calculate Long-Term Mean (μ) using EWMA over the entire dataset
var float ewma_mu = na // Initialize ewma_mu as 'na'
ewma_mu := na(ewma_mu ) ? close : decay_factor * ewma_mu + (1 - decay_factor) * close
mu = ewma_mu
// Calculate Autocorrelation at Lag 1
rho1 = ta.correlation(returns, returns , corr_length)
// Ensure rho1 is within valid range to avoid errors
rho1 := na(rho1) or rho1 <= 0 ? 0.0001 : rho1
// Calculate Speed of Mean Reversion (θ)
theta = -math.log(rho1)
// Calculate Volatility (σ)
sigma = ta.stdev(close, corr_length)
// Calculate Upper and Lower Bands
upper_band = mu + threshold * sigma
lower_band = mu - threshold * sigma
🔸Visualization via Table and Plotshapes
The table shows key statistics such as the current value of the dynamic mean (μ), the number of times the price has crossed the upper or lower bands, and the consecutive number of bars that the price has remained in an overbought or oversold state.
Plotshapes (diamonds) are used to signal buy and sell opportunities. A green diamond below the price suggests a buy signal when the price crosses below the lower band, and a red diamond above the price indicates a sell signal when the price crosses above the upper band.
The table and plotshapes provide a comprehensive visualization, combining both statistical and actionable information to aid decision-making.
🞘 Code extract // Reset consecutive_bars when price crosses the mean
var consecutive_bars = 0
if (close < mu and close >= mu) or (close > mu and close <= mu)
consecutive_bars := 0
else if math.abs(deviation) > 0
consecutive_bars := math.min(consecutive_bars + 1, dev_length)
transparency = math.max(0, math.min(100, 100 - (consecutive_bars * 100 / dev_length)))
🔶 INSTRUCTIONS
The Mean Reversion Cloud (Ornstein-Uhlenbeck) indicator can be set up by adding it to your TradingView chart and configuring parameters such as the decay factor, autocorrelation length, and volatility threshold to suit current market conditions. Look for price crossovers and deviations from the calculated mean for potential entry signals. Use the upper and lower bands as dynamic support/resistance levels for setting take profit and stop-loss orders. Combining this indicator with additional trend-following or momentum-based indicators can improve signal accuracy. Adjust settings for better mean-reversion detection and risk management.
🔸Step-by-Step Guidelines
🞘 Setting Up the Indicator
Adding the Indicator to the Chart:
Go to your TradingView chart.
Click on the "Indicators" button at the top.
Search for "Mean Reversion Cloud (Ornstein-Uhlenbeck)" in the indicators list.
Click on the indicator to add it to your chart.
Configuring the Indicator:
Open the indicator settings by clicking on the gear icon next to its name on the chart.
Decay Factor: Adjust the decay factor (λ) to control the responsiveness of the mean calculation. A higher value prioritizes recent data.
Autocorrelation Length: Set the autocorrelation length (θ) for calculating the speed of mean reversion. Longer lengths consider more historical data.
Threshold: Define the number of standard deviations for the upper and lower bands to determine how far price must deviate to trigger a signal.
Chart Setup:
Select the appropriate timeframe (e.g., 1-hour, daily) based on your trading strategy.
Consider using other indicators such as RSI or MACD to confirm buy and sell signals.
🞘 Understanding What to Look For on the Chart
Indicator Behavior:
Observe how the price interacts with the dynamic mean and volatility bands. The price staying within the bands suggests mean-reverting behavior, while crossing the bands signals potential entry points.
The indicator calculates overbought/oversold conditions based on deviation from the mean, highlighted by color-coded cloud areas on the chart.
Crossovers and Deviation:
Look for crossovers between the price and the mean (μ) or the bands. A bullish crossover occurs when the price crosses below the lower band, signaling a potential buying opportunity.
A bearish crossover occurs when the price crosses above the upper band, suggesting a potential sell signal.
Deviations from the mean indicate market extremes. A large deviation indicates that the price is far from the mean, suggesting a potential reversal.
Slope and Direction:
Pay attention to the slope of the mean (μ). A rising slope suggests bullish market conditions, while a declining slope signals a bearish market.
The steepness of the slope can indicate the strength of the mean-reversion trend.
🞘 Possible Entry Signals
Bullish Entry:
Crossover Entry: Enter a long position when the price crosses below the lower band with a positive deviation from the mean.
Confirmation Entry: Use additional indicators like RSI (above 50) or increasing volume to confirm the bullish signal.
Bearish Entry:
Crossover Entry: Enter a short position when the price crosses above the upper band with a negative deviation from the mean.
Confirmation Entry: Look for RSI (below 50) or decreasing volume to confirm the bearish signal.
Deviation Confirmation:
Enter trades when the deviation from the mean is significant, indicating that the price has strayed far from its expected value and is likely to revert.
🞘 Possible Take Profit Strategies
Static Take Profit Levels:
Set predefined take profit levels based on historical volatility, using the upper and lower bands as guides.
Place take profit orders near recent support/resistance levels, ensuring you're capitalizing on the mean-reversion behavior.
Trailing Stop Loss:
Use a trailing stop based on a percentage of the price deviation from the mean to lock in profits as the trend progresses.
Adjust the trailing stop dynamically along the calculated bands to protect profits as the price returns to the mean.
Deviation-Based Exits:
Exit when the deviation from the mean starts to decrease, signaling that the price is returning to its equilibrium.
🞘 Possible Stop-Loss Levels
Initial Stop Loss:
Place an initial stop loss outside the lower band (for long positions) or above the upper band (for short positions) to protect against excessive deviations.
Use a volatility-based buffer to avoid getting stopped out during normal price fluctuations.
Dynamic Stop Loss:
Move the stop loss closer to the mean as the price converges back towards equilibrium, reducing risk.
Adjust the stop loss dynamically along the bands to account for sudden market movements.
🞘 Additional Tips
Combine with Other Indicators:
Enhance your strategy by combining the Mean Reversion Cloud with momentum indicators like MACD, RSI, or Bollinger Bands to confirm market conditions.
Backtesting and Practice:
Backtest the indicator on historical data to understand how it performs in various market environments.
Practice using the indicator on a demo account before implementing it in live trading.
Market Awareness:
Keep an eye on market news and events that might cause extreme price movements. The indicator reacts to price data and might not account for news-driven events that can cause large deviations.
🔸Customize settings 🞘 Decay Factor (λ): Defines the weight assigned to recent price data in the calculation of the mean. A value closer to 1 places more emphasis on recent prices, while lower values create a smoother, more lagging mean.
🞘 Autocorrelation Length (θ): Sets the period for calculating the speed of mean reversion and volatility. Longer lengths capture more historical data, providing smoother calculations, while shorter lengths make the indicator more responsive.
🞘 Threshold (σ): Specifies the number of standard deviations used to create the upper and lower bands. Higher thresholds widen the bands, producing fewer signals, while lower thresholds tighten the bands for more frequent signals.
🞘 Max Gradient Length (γ): Determines the maximum number of consecutive bars for calculating the deviation gradient. This setting impacts the transparency of the plotted bands based on the length of deviation from the mean.
🔶 CONCLUSION
The Mean Reversion Cloud (Ornstein-Uhlenbeck) indicator offers a sophisticated approach to identifying mean-reversion opportunities by applying the Ornstein-Uhlenbeck stochastic process. This dynamic indicator calculates a responsive mean using an Exponentially Weighted Moving Average (EWMA) and plots volatility-based bands to highlight overbought and oversold conditions. By incorporating advanced statistical measures like autocorrelation and standard deviation, traders can better assess market extremes and potential reversals. The indicator’s ability to adapt to price behavior makes it a versatile tool for traders focused on both short-term price deviations and longer-term mean-reversion strategies. With its unique blend of statistical rigor and visual clarity, the Mean Reversion Cloud provides an invaluable tool for understanding and capitalizing on market inefficiencies.
Ichimoku Crosses_RSI_AITIchimoku Crosser_RSI_AIT
Overview
The "Ichimoku Cloud Crosses_AIT" strategy is a technical trading strategy that combines the Ichimoku Cloud components with the Relative Strength Index (RSI) to generate trade signals. This strategy leverages the crossovers of the Tenkan-sen and Kijun-sen lines of the Ichimoku Cloud, along with RSI levels, to identify potential entry and exit points for long and short trades. This guide explains the strategy components, conditions, and how to use it effectively in your trading.
1. Strategy Parameters
User Inputs
Tenkan-sen Period (tenkanLength): Default value is 21. This is the period used to calculate the Tenkan-sen line (conversion line) of the Ichimoku Cloud.
Kijun-sen Period (kijunLength): Default value is 120. This is the period used to calculate the Kijun-sen line (base line) of the Ichimoku Cloud.
Senkou Span B Period (senkouBLength): Default value is 52. This is the period used to calculate the Senkou Span B line (leading span B) of the Ichimoku Cloud.
RSI Period (rsiLength): Default value is 14. This period is used to calculate the Relative Strength Index (RSI).
RSI Long Entry Level (rsiLongLevel): Default value is 60. This level indicates the minimum RSI value for a long entry signal.
RSI Short Entry Level (rsiShortLevel): Default value is 40. This level indicates the maximum RSI value for a short entry signal.
2. Strategy Components
Ichimoku Cloud
Tenkan-sen: A short-term trend indicator calculated as the simple moving average (SMA) of the highest high and the lowest low over the Tenkan-sen period.
Kijun-sen: A medium-term trend indicator calculated as the SMA of the highest high and the lowest low over the Kijun-sen period.
Senkou Span A: Calculated as the average of the Tenkan-sen and Kijun-sen, plotted 26 periods ahead.
Senkou Span B: Calculated as the SMA of the highest high and lowest low over the Senkou Span B period, plotted 26 periods ahead.
Chikou Span: The closing price plotted 26 periods behind.
Relative Strength Index (RSI)
RSI: A momentum oscillator that measures the speed and change of price movements. It ranges from 0 to 100 and is used to identify overbought or oversold conditions.
3. Entry and Exit Conditions
Entry Conditions
Long Entry:
The Tenkan-sen crosses above the Kijun-sen (bullish crossover).
The RSI value is greater than or equal to the rsiLongLevel.
Short Entry:
The Tenkan-sen crosses below the Kijun-sen (bearish crossover).
The RSI value is less than or equal to the rsiShortLevel.
Exit Conditions
Exit Long Position: The Tenkan-sen crosses below the Kijun-sen.
Exit Short Position: The Tenkan-sen crosses above the Kijun-sen.
4. Visual Representation
Tenkan-sen Line: Plotted on the chart. The color changes based on its relation to the Kijun-sen (green if above, red if below) and is displayed with a line width of 2.
Kijun-sen Line: Plotted as a white line with a line width of 1.
Entry Arrows:
Long Entry: Displayed as a yellow triangle below the bar.
Short Entry: Displayed as a fuchsia triangle above the bar.
5. How to Use
Apply the Strategy: Apply the "Ichimoku Cloud Crosses_AIT" strategy to your chart in TradingView.
Configure Parameters: Adjust the strategy parameters (Tenkan-sen, Kijun-sen, Senkou Span B, and RSI settings) according to your trading preferences.
Interpret the Signals:
Long Entry: A yellow triangle appears below the bar when a long entry signal is generated.
Short Entry: A fuchsia triangle appears above the bar when a short entry signal is generated.
Monitor Open Positions: The strategy automatically exits positions based on the defined conditions.
Backtesting and Live Trading: Use the strategy for backtesting and live trading. Adjust risk management settings in the strategy properties as needed.
Conclusion
The "Ichimoku Cloud Crosses_AIT" strategy uses Ichimoku Cloud crossovers and RSI to generate trading signals. This strategy aims to capture market trends and potential reversals, providing a structured way to enter and exit trades. Make sure to backtest and optimize the strategy parameters to suit your trading style and market conditions before using it in a live trading environment.
TRADINGLibrary "TRADING"
This library is a client script for making a webhook signal formatted string to PoABOT server.
entry_message(password, percent, leverage, margin_mode, kis_number)
Create a entry message for POABOT
Parameters:
password (string) : (string) The password of your bot.
percent (float) : (float) The percent for entry based on your wallet balance.
leverage (int) : (int) The leverage of entry. If not set, your levereage doesn't change.
margin_mode (string) : (string) The margin mode for trade(only for OKX). "cross" or "isolated"
kis_number (int) : (int) The number of koreainvestment account. Default 1
Returns: (string) A json formatted string for webhook message.
order_message(password, percent, leverage, margin_mode, kis_number)
Create a order message for POABOT
Parameters:
password (string) : (string) The password of your bot.
percent (float) : (float) The percent for entry based on your wallet balance.
leverage (int) : (int) The leverage of entry. If not set, your levereage doesn't change.
margin_mode (string) : (string) The margin mode for trade(only for OKX). "cross" or "isolated"
kis_number (int) : (int) The number of koreainvestment account. Default 1
Returns: (string) A json formatted string for webhook message.
close_message(password, percent, margin_mode, kis_number)
Create a close message for POABOT
Parameters:
password (string) : (string) The password of your bot.
percent (float) : (float) The percent for close based on your wallet balance.
margin_mode (string) : (string) The margin mode for trade(only for OKX). "cross" or "isolated"
kis_number (int) : (int) The number of koreainvestment account. Default 1
Returns: (string) A json formatted string for webhook message.
exit_message(password, percent, margin_mode, kis_number)
Create a exit message for POABOT
Parameters:
password (string) : (string) The password of your bot.
percent (float) : (float) The percent for exit based on your wallet balance.
margin_mode (string) : (string) The margin mode for trade(only for OKX). "cross" or "isolated"
kis_number (int) : (int) The number of koreainvestment account. Default 1
Returns: (string) A json formatted string for webhook message.
manual_message(password, exchange, base, quote, side, qty, price, percent, leverage, margin_mode, kis_number, order_name)
Create a manual message for POABOT
Parameters:
password (string) : (string) The password of your bot.
exchange (string) : (string) The exchange
base (string) : (string) The base
quote (string) : (string) The quote of order message
side (string) : (string) The side of order messsage
qty (float) : (float) The qty of order message
price (float) : (float) The price of order message
percent (float) : (float) The percent for order based on your wallet balance.
leverage (int) : (int) The leverage of entry. If not set, your levereage doesn't change.
margin_mode (string) : (string) The margin mode for trade(only for OKX). "cross" or "isolated"
kis_number (int) : (int) The number of koreainvestment account.
order_name (string) : (string) The name of order message
Returns: (string) A json formatted string for webhook message.
in_trade(start_time, end_time, hide_trade_line)
Create a trade start line
Parameters:
start_time (int) : (int) The start of time.
end_time (int) : (int) The end of time.
hide_trade_line (bool) : (bool) if true, hide trade line. Default false.
Returns: (bool) Get bool for trade based on time range.
real_qty(qty, precision, leverage, contract_size, default_qty_type, default_qty_value)
Get exchange specific real qty
Parameters:
qty (float) : (float) qty
precision (float) : (float) precision
leverage (int) : (int) leverage
contract_size (float) : (float) contract_size
default_qty_type (string)
default_qty_value (float)
Returns: (float) exchange specific qty.
method set(this, password, start_time, end_time, leverage, initial_capital, default_qty_type, default_qty_value, margin_mode, contract_size, kis_number, entry_percent, close_percent, exit_percent, fixed_qty, fixed_cash, real, auto_alert_message, hide_trade_line)
Set bot object.
Namespace types: bot
Parameters:
this (bot)
password (string) : (string) password for poabot.
start_time (int) : (int) start_time timestamp.
end_time (int) : (int) end_time timestamp.
leverage (int) : (int) leverage.
initial_capital (float)
default_qty_type (string)
default_qty_value (float)
margin_mode (string) : (string) The margin mode for trade(only for OKX). "cross" or "isolated"
contract_size (float)
kis_number (int) : (int) kis_number for poabot.
entry_percent (float) : (float) entry_percent for poabot.
close_percent (float) : (float) close_percent for poabot.
exit_percent (float) : (float) exit_percent for poabot.
fixed_qty (float) : (float) fixed qty.
fixed_cash (float) : (float) fixed cash.
real (bool) : (bool) convert qty for exchange specific.
auto_alert_message (bool) : (bool) convert alert_message for exchange specific.
hide_trade_line (bool) : (bool) if true, Hide trade line. Default false.
Returns: (void)
method print(this, message)
Print message using log table.
Namespace types: bot
Parameters:
this (bot)
message (string)
Returns: (void)
method start_trade(this)
start trade using start_time and end_time
Namespace types: bot
Parameters:
this (bot)
Returns: (void)
method entry(this, id, direction, qty, limit, stop, oca_name, oca_type, comment, alert_message, when)
It is a command to enter market position. If an order with the same ID is already pending, it is possible to modify the order. If there is no order with the specified ID, a new order is placed. To deactivate an entry order, the command strategy.cancel or strategy.cancel_all should be used. In comparison to the function strategy.order, the function strategy.entry is affected by pyramiding and it can reverse market position correctly. If both 'limit' and 'stop' parameters are 'NaN', the order type is market order.
Namespace types: bot
Parameters:
this (bot)
id (string) : (string) A required parameter. The order identifier. It is possible to cancel or modify an order by referencing its identifier.
direction (string) : (string) A required parameter. Market position direction: 'strategy.long' is for long, 'strategy.short' is for short.
qty (float) : (float) An optional parameter. Number of contracts/shares/lots/units to trade. The default value is 'NaN'.
limit (float) : (float) An optional parameter. Limit price of the order. If it is specified, the order type is either 'limit', or 'stop-limit'. 'NaN' should be specified for any other order type.
stop (float) : (float) An optional parameter. Stop price of the order. If it is specified, the order type is either 'stop', or 'stop-limit'. 'NaN' should be specified for any other order type.
oca_name (string) : (string) An optional parameter. Name of the OCA group the order belongs to. If the order should not belong to any particular OCA group, there should be an empty string.
oca_type (string) : (string) An optional parameter. Type of the OCA group. The allowed values are: "strategy.oca.none" - the order should not belong to any particular OCA group; "strategy.oca.cancel" - the order should belong to an OCA group, where as soon as an order is filled, all other orders of the same group are cancelled; "strategy.oca.reduce" - the order should belong to an OCA group, where if X number of contracts of an order is filled, number of contracts for each other order of the same OCA group is decreased by X.
comment (string) : (string) An optional parameter. Additional notes on the order.
alert_message (string) : (string) An optional parameter which replaces the {{strategy.order.alert_message}} placeholder when it is used in the "Create Alert" dialog box's "Message" field.
when (bool) : (bool) An optional parmeter. Condition, deprecated.
Returns: (void)
method order(this, id, direction, qty, limit, stop, oca_name, oca_type, comment, alert_message, when)
It is a command to place order. If an order with the same ID is already pending, it is possible to modify the order. If there is no order with the specified ID, a new order is placed. To deactivate order, the command strategy.cancel or strategy.cancel_all should be used. In comparison to the function strategy.entry, the function strategy.order is not affected by pyramiding. If both 'limit' and 'stop' parameters are 'NaN', the order type is market order.
Namespace types: bot
Parameters:
this (bot)
id (string) : (string) A required parameter. The order identifier. It is possible to cancel or modify an order by referencing its identifier.
direction (string) : (string) A required parameter. Market position direction: 'strategy.long' is for long, 'strategy.short' is for short.
qty (float) : (float) An optional parameter. Number of contracts/shares/lots/units to trade. The default value is 'NaN'.
limit (float) : (float) An optional parameter. Limit price of the order. If it is specified, the order type is either 'limit', or 'stop-limit'. 'NaN' should be specified for any other order type.
stop (float) : (float) An optional parameter. Stop price of the order. If it is specified, the order type is either 'stop', or 'stop-limit'. 'NaN' should be specified for any other order type.
oca_name (string) : (string) An optional parameter. Name of the OCA group the order belongs to. If the order should not belong to any particular OCA group, there should be an empty string.
oca_type (string) : (string) An optional parameter. Type of the OCA group. The allowed values are: "strategy.oca.none" - the order should not belong to any particular OCA group; "strategy.oca.cancel" - the order should belong to an OCA group, where as soon as an order is filled, all other orders of the same group are cancelled; "strategy.oca.reduce" - the order should belong to an OCA group, where if X number of contracts of an order is filled, number of contracts for each other order of the same OCA group is decreased by X.
comment (string) : (string) An optional parameter. Additional notes on the order.
alert_message (string) : (string) An optional parameter which replaces the {{strategy.order.alert_message}} placeholder when it is used in the "Create Alert" dialog box's "Message" field.
when (bool) : (bool) An optional parmeter. Condition, deprecated.
Returns: (void)
method close_all(this, comment, alert_message, immediately, when)
Exits the current market position, making it flat.
Namespace types: bot
Parameters:
this (bot)
comment (string) : (string) An optional parameter. Additional notes on the order.
alert_message (string) : (string) An optional parameter which replaces the {{strategy.order.alert_message}} placeholder when it is used in the "Create Alert" dialog box's "Message" field.
immediately (bool) : (bool) An optional parameter. If true, the closing order will be executed on the tick where it has been placed, ignoring the strategy parameters that restrict the order execution to the open of the next bar. The default is false.
when (bool) : (bool) An optional parmeter. Condition, deprecated.
Returns: (void)
method cancel(this, id, when)
It is a command to cancel/deactivate pending orders by referencing their names, which were generated by the functions: strategy.order, strategy.entry and strategy.exit.
Namespace types: bot
Parameters:
this (bot)
id (string) : (string) A required parameter. The order identifier. It is possible to cancel an order by referencing its identifier.
when (bool) : (bool) An optional parmeter. Condition, deprecated.
Returns: (void)
method cancel_all(this, when)
It is a command to cancel/deactivate all pending orders, which were generated by the functions: strategy.order, strategy.entry and strategy.exit.
Namespace types: bot
Parameters:
this (bot)
when (bool) : (bool) An optional parmeter. Condition, deprecated.
Returns: (void)
method close(this, id, comment, qty, qty_percent, alert_message, immediately, when)
It is a command to exit from the entry with the specified ID. If there were multiple entry orders with the same ID, all of them are exited at once. If there are no open entries with the specified ID by the moment the command is triggered, the command will not come into effect. The command uses market order. Every entry is closed by a separate market order.
Namespace types: bot
Parameters:
this (bot)
id (string) : (string) A required parameter. The order identifier. It is possible to close an order by referencing its identifier.
comment (string) : (string) An optional parameter. Additional notes on the order.
qty (float) : (float) An optional parameter. Number of contracts/shares/lots/units to exit a trade with. The default value is 'NaN'.
qty_percent (float) : (float) Defines the percentage (0-100) of the position to close. Its priority is lower than that of the 'qty' parameter. Optional. The default is 100.
alert_message (string) : (string) An optional parameter which replaces the {{strategy.order.alert_message}} placeholder when it is used in the "Create Alert" dialog box's "Message" field.
immediately (bool) : (bool) An optional parameter. If true, the closing order will be executed on the tick where it has been placed, ignoring the strategy parameters that restrict the order execution to the open of the next bar. The default is false.
when (bool) : (bool) An optional parmeter. Condition, deprecated.
Returns: (void)
ticks_to_price(ticks, from)
Converts ticks to a price offset from the supplied price or the average entry price.
Parameters:
ticks (float) : (float) Ticks to convert to a price.
from (float) : (float) A price that can be used to calculate from. Optional. The default value is `strategy.position_avg_price`.
Returns: (float) A price level that has a distance from the entry price equal to the specified number of ticks.
method exit(this, id, from_entry, qty, qty_percent, profit, limit, loss, stop, trail_price, trail_points, trail_offset, oca_name, comment, comment_profit, comment_loss, comment_trailing, alert_message, alert_profit, alert_loss, alert_trailing, when)
It is a command to exit either a specific entry, or whole market position. If an order with the same ID is already pending, it is possible to modify the order. If an entry order was not filled, but an exit order is generated, the exit order will wait till entry order is filled and then the exit order is placed. To deactivate an exit order, the command strategy.cancel or strategy.cancel_all should be used. If the function strategy.exit is called once, it exits a position only once. If you want to exit multiple times, the command strategy.exit should be called multiple times. If you use a stop loss and a trailing stop, their order type is 'stop', so only one of them is placed (the one that is supposed to be filled first). If all the following parameters 'profit', 'limit', 'loss', 'stop', 'trail_points', 'trail_offset' are 'NaN', the command will fail. To use market order to exit, the command strategy.close or strategy.close_all should be used.
Namespace types: bot
Parameters:
this (bot)
id (string) : (string) A required parameter. The order identifier. It is possible to cancel or modify an order by referencing its identifier.
from_entry (string) : (string) An optional parameter. The identifier of a specific entry order to exit from it. To exit all entries an empty string should be used. The default values is empty string.
qty (float) : (float) An optional parameter. Number of contracts/shares/lots/units to exit a trade with. The default value is 'NaN'.
qty_percent (float) : (float) Defines the percentage of (0-100) the position to close. Its priority is lower than that of the 'qty' parameter. Optional. The default is 100.
profit (float) : (float) An optional parameter. Profit target (specified in ticks). If it is specified, a limit order is placed to exit market position when the specified amount of profit (in ticks) is reached. The default value is 'NaN'.
limit (float) : (float) An optional parameter. Profit target (requires a specific price). If it is specified, a limit order is placed to exit market position at the specified price (or better). Priority of the parameter 'limit' is higher than priority of the parameter 'profit' ('limit' is used instead of 'profit', if its value is not 'NaN'). The default value is 'NaN'.
loss (float) : (float) An optional parameter. Stop loss (specified in ticks). If it is specified, a stop order is placed to exit market position when the specified amount of loss (in ticks) is reached. The default value is 'NaN'.
stop (float) : (float) An optional parameter. Stop loss (requires a specific price). If it is specified, a stop order is placed to exit market position at the specified price (or worse). Priority of the parameter 'stop' is higher than priority of the parameter 'loss' ('stop' is used instead of 'loss', if its value is not 'NaN'). The default value is 'NaN'.
trail_price (float) : (float) An optional parameter. Trailing stop activation level (requires a specific price). If it is specified, a trailing stop order will be placed when the specified price level is reached. The offset (in ticks) to determine initial price of the trailing stop order is specified in the 'trail_offset' parameter: X ticks lower than activation level to exit long position; X ticks higher than activation level to exit short position. The default value is 'NaN'.
trail_points (float) : (float) An optional parameter. Trailing stop activation level (profit specified in ticks). If it is specified, a trailing stop order will be placed when the calculated price level (specified amount of profit) is reached. The offset (in ticks) to determine initial price of the trailing stop order is specified in the 'trail_offset' parameter: X ticks lower than activation level to exit long position; X ticks higher than activation level to exit short position. The default value is 'NaN'.
trail_offset (float) : (float) An optional parameter. Trailing stop price (specified in ticks). The offset in ticks to determine initial price of the trailing stop order: X ticks lower than 'trail_price' or 'trail_points' to exit long position; X ticks higher than 'trail_price' or 'trail_points' to exit short position. The default value is 'NaN'.
oca_name (string) : (string) An optional parameter. Name of the OCA group (oca_type = strategy.oca.reduce) the profit target, the stop loss / the trailing stop orders belong to. If the name is not specified, it will be generated automatically.
comment (string) : (string) Additional notes on the order. If specified, displays near the order marker on the chart. Optional. The default is na.
comment_profit (string) : (string) Additional notes on the order if the exit was triggered by crossing `profit` or `limit` specifically. If specified, supercedes the `comment` parameter and displays near the order marker on the chart. Optional. The default is na.
comment_loss (string) : (string) Additional notes on the order if the exit was triggered by crossing `stop` or `loss` specifically. If specified, supercedes the `comment` parameter and displays near the order marker on the chart. Optional. The default is na.
comment_trailing (string) : (string) Additional notes on the order if the exit was triggered by crossing `trail_offset` specifically. If specified, supercedes the `comment` parameter and displays near the order marker on the chart. Optional. The default is na.
alert_message (string) : (string) Text that will replace the '{{strategy.order.alert_message}}' placeholder when one is used in the "Message" field of the "Create Alert" dialog. Optional. The default is na.
alert_profit (string) : (string) Text that will replace the '{{strategy.order.alert_message}}' placeholder when one is used in the "Message" field of the "Create Alert" dialog. Only replaces the text if the exit was triggered by crossing `profit` or `limit` specifically. Optional. The default is na.
alert_loss (string) : (string) Text that will replace the '{{strategy.order.alert_message}}' placeholder when one is used in the "Message" field of the "Create Alert" dialog. Only replaces the text if the exit was triggered by crossing `stop` or `loss` specifically. Optional. The default is na.
alert_trailing (string) : (string) Text that will replace the '{{strategy.order.alert_message}}' placeholder when one is used in the "Message" field of the "Create Alert" dialog. Only replaces the text if the exit was triggered by crossing `trail_offset` specifically. Optional. The default is na.
when (bool) : (bool) An optional parmeter. Condition, deprecated.
Returns: (void)
percent_to_ticks(percent, from)
Converts a percentage of the supplied price or the average entry price to ticks.
Parameters:
percent (float) : (float) The percentage of supplied price to convert to ticks. 50 is 50% of the entry price.
from (float) : (float) A price that can be used to calculate from. Optional. The default value is `strategy.position_avg_price`.
Returns: (float) A value in ticks.
percent_to_price(percent, from)
Converts a percentage of the supplied price or the average entry price to a price.
Parameters:
percent (float) : (float) The percentage of the supplied price to convert to price. 50 is 50% of the supplied price.
from (float) : (float) A price that can be used to calculate from. Optional. The default value is `strategy.position_avg_price`.
Returns: (float) A value in the symbol's quote currency (USD for BTCUSD).
bot
Fields:
password (series__string)
start_time (series__integer)
end_time (series__integer)
leverage (series__integer)
initial_capital (series__float)
default_qty_type (series__string)
default_qty_value (series__float)
margin_mode (series__string)
contract_size (series__float)
kis_number (series__integer)
entry_percent (series__float)
close_percent (series__float)
exit_percent (series__float)
log_table (series__table)
fixed_qty (series__float)
fixed_cash (series__float)
real (series__bool)
auto_alert_message (series__bool)
hide_trade_line (series__bool)
[imba]lance algo🟩 INTRODUCTION
Hello, everyone!
Please take the time to review this description and source code to utilize this script to its fullest potential.
🟩 CONCEPTS
This is a trend indicator. The trend is the 0.5 fibonacci level for a certain period of time.
A trend change occurs when at least one candle closes above the level of 0.236 (for long) or below 0.786 (for short). Also it has massive amout of settings and features more about this below.
With good settings, the indicator works great on any market and any time frame!
A distinctive feature of this indicator is its backtest panel. With which you can dynamically view the results of setting up a strategy such as profit, what the deposit size is, etc.
Please note that the profit is indicated as a percentage of the initial deposit. It is also worth considering that all profit calculations are based on the risk % setting.
🟩 FEATURES
First, I want to show you what you see on the chart. And I’ll show you everything closer and in more detail.
1. Position
2. Statistic panel
3. Backtest panel
Indicator settings:
Let's go in order:
1. Strategies
This setting is responsible for loading saved strategies. There are only two preset settings, MANUAL and UNIVERSAL. If you choose any strategy other than MANUAL, then changing the settings for take profits, stop loss, sensitivity will not bring any results.
You can also save your customized strategies, this is discussed in a separate paragraph “🟩HOW TO SAVE A STRATEGY”
2. Sensitive
Responsible for the time period in bars to create Fibonacci levels
3. Start calculating date
This is the time to start backtesting strategies
4. Position group
Show checkbox - is responsible for displaying positions
Fill checkbox - is responsible for filling positions with background
Risk % - is responsible for what percentage of the deposit you are willing to lose if there is a stop loss
BE target - here you can choose when you reach which take profit you need to move your stop loss to breakeven
Initial deposit- starting deposit for profit calculation
5. Stoploss group
Fixed stoploss % checkbox - If choosed: stoploss will be calculated manually depending on the setting below( formula: entry_price * (1 - stoploss percent)) If NOT choosed: stoploss will be ( formula: fibonacci level(0.786/0.236) * (1 + stoploss percent))
6. Take profit group
This group of settings is responsible for how far from the entry point take profits will be and what % of the position to fix
7. RSI
Responsible for configuring the built-in RSI. Suitable bars will be highlighted with crosses above or below, depending on overbought/oversold
8. Infopanels group
Here I think everything is clear, you can hide or show information panels
9. Developer mode
If enabled, all events that occur will be shown, for example, reaching a take profit or stop loss with detailed information about the unfixed balance of the position
🟩 HOW TO USE
Very simple. All you need is to wait for the trend to change to long or short, you will immediately see a stop loss and four take profits, and you will also see prices. Like in this picture:
🟩 ALERTS
There are 3 types of alerts:
1. Long signal
2. Short signal
3. Any alert() function call - will be send to you json with these fields
{
"side": "LONG",
"entry": "64.454",
"tp1": "65.099",
"tp2": "65.743",
"tp3": "66.388",
"tp4": "67.032",
"winrate": "35.42%",
"strategy": "MANUAL",
"beTargetTrigger": "1",
"stop": "64.44"
}
🟩 HOW TO SAVE A STRATEGY
First, you need to make sure that the “MANUAL” strategy is selected in the strategy settings.
After this, you can start selecting parameters that will show the largest profit in the statistics panel.
I have highlighted what you need to pay attention to when choosing a strategy
Let's assume you have set up a strategy. The main question is how to preserve it?
Let’s say the strategy turned out with the following parameters:
Next we need to find this section of code:
// STRATS
selector(string strategy_name) =>
strategy_settings = Strategy_settings.new()
switch strategy_name
"MANUAL" =>
strategy_settings.sensitivity := 18
strategy_settings.risk_percent := 1
strategy_settings.break_even_target := "1"
strategy_settings.tp1_percent := 1
strategy_settings.tp1_percent_fix := 40
strategy_settings.tp2_percent := 2
strategy_settings.tp2_percent_fix := 30
strategy_settings.tp3_percent := 3
strategy_settings.tp3_percent_fix := 20
strategy_settings.tp4_percent := 4
strategy_settings.tp4_percent_fix := 10
strategy_settings.fixed_stop := false
strategy_settings.sl_percent := 0.0
"UNIVERSAL" =>
strategy_settings.sensitivity := 20
strategy_settings.risk_percent := 1
strategy_settings.break_even_target := "1"
strategy_settings.tp1_percent := 1
strategy_settings.tp1_percent_fix := 40
strategy_settings.tp2_percent := 2
strategy_settings.tp2_percent_fix := 30
strategy_settings.tp3_percent := 3
strategy_settings.tp3_percent_fix := 20
strategy_settings.tp4_percent := 4
strategy_settings.tp4_percent_fix := 10
strategy_settings.fixed_stop := false
strategy_settings.sl_percent := 0.0
// "NEW STRATEGY" =>
// strategy_settings.sensitivity := 20
// strategy_settings.risk_percent := 1
// strategy_settings.break_even_target := "1"
// strategy_settings.tp1_percent := 1
// strategy_settings.tp1_percent_fix := 40
// strategy_settings.tp2_percent := 2
// strategy_settings.tp2_percent_fix := 30
// strategy_settings.tp3_percent := 3
// strategy_settings.tp3_percent_fix := 20
// strategy_settings.tp4_percent := 4
// strategy_settings.tp4_percent_fix := 10
// strategy_settings.fixed_stop := false
// strategy_settings.sl_percent := 0.0
strategy_settings
// STRATS
Let's uncomment on the latest strategy called "NEW STRATEGY" rename it to "SOL 5m" and change the sensitivity:
// STRATS
selector(string strategy_name) =>
strategy_settings = Strategy_settings.new()
switch strategy_name
"MANUAL" =>
strategy_settings.sensitivity := 18
strategy_settings.risk_percent := 1
strategy_settings.break_even_target := "1"
strategy_settings.tp1_percent := 1
strategy_settings.tp1_percent_fix := 40
strategy_settings.tp2_percent := 2
strategy_settings.tp2_percent_fix := 30
strategy_settings.tp3_percent := 3
strategy_settings.tp3_percent_fix := 20
strategy_settings.tp4_percent := 4
strategy_settings.tp4_percent_fix := 10
strategy_settings.fixed_stop := false
strategy_settings.sl_percent := 0.0
"UNIVERSAL" =>
strategy_settings.sensitivity := 20
strategy_settings.risk_percent := 1
strategy_settings.break_even_target := "1"
strategy_settings.tp1_percent := 1
strategy_settings.tp1_percent_fix := 40
strategy_settings.tp2_percent := 2
strategy_settings.tp2_percent_fix := 30
strategy_settings.tp3_percent := 3
strategy_settings.tp3_percent_fix := 20
strategy_settings.tp4_percent := 4
strategy_settings.tp4_percent_fix := 10
strategy_settings.fixed_stop := false
strategy_settings.sl_percent := 0.0
"SOL 5m" =>
strategy_settings.sensitivity := 15
strategy_settings.risk_percent := 1
strategy_settings.break_even_target := "1"
strategy_settings.tp1_percent := 1
strategy_settings.tp1_percent_fix := 40
strategy_settings.tp2_percent := 2
strategy_settings.tp2_percent_fix := 30
strategy_settings.tp3_percent := 3
strategy_settings.tp3_percent_fix := 20
strategy_settings.tp4_percent := 4
strategy_settings.tp4_percent_fix := 10
strategy_settings.fixed_stop := false
strategy_settings.sl_percent := 0.0
strategy_settings
// STRATS
Now let's find this code:
strategy_input = input.string(title = "STRATEGY", options = , defval = "MANUAL", tooltip = "EN:\nTo manually configure the strategy, select MANUAL otherwise, changing the settings won't have any effect\nRU:\nЧтобы настроить стратегию вручную, выберите MANUAL в противном случае изменение настроек не будет иметь никакого эффекта")
And let's add our new strategy there, it turned out like this:
strategy_input = input.string(title = "STRATEGY", options = , defval = "MANUAL", tooltip = "EN:\nTo manually configure the strategy, select MANUAL otherwise, changing the settings won't have any effect\nRU:\nЧтобы настроить стратегию вручную, выберите MANUAL в противном случае изменение настроек не будет иметь никакого эффекта")
That's all. Our new strategy is now saved! It's simple! Now we can select it in the list of strategies:
PlurexSignalStrategyLibrary "PlurexSignalStrategy"
Provides functions that wrap the built in TradingView strategy functions so you can seemlessly integrate with Plurex Signal automation.
NOTE: Be sure to:
- set your strategy default_qty_value to the default entry percentage of your signal
- set your strategy default_qty_type to strategy.percent_of_equity
- set your strategy pyramiding to some value greater than 1 or something appropriate to your strategy in order to have multiple entries.
long(secret, budgetPercentage, priceLimit, marketOverride)
Open a new long entry. Wraps strategy function and sends plurex message as an alert.
Parameters:
secret : The secret for your Signal on plurex
budgetPercentage : Optional, The percentage of budget to use in the entry.
priceLimit : Optional, The worst price to accept for the entry.
marketOverride : Optional, defaults to the syminfo for the ticker. Use the `plurexMarket` function to build your own.
longAndFixedStopLoss(secret, stop, budgetPercentage, priceLimit, marketOverride)
Open a new long entry. Wraps strategy function and sends plurex message as an alert. Also sets a gobal stop loss for full open position
Parameters:
secret : The secret for your Signal on plurex
stop : The trigger price for the stop loss. See strategy.exit documentation
budgetPercentage : Optional, The percentage of budget to use in the entry.
priceLimit : Optional, The worst price to accept for the entry.
marketOverride : Optional, defaults to the syminfo for the ticker. Use the `plurexMarket` function to build your own.
longAndTrailingStopLoss(secret, trail_offset, trail_price, trail_points, budgetPercentage, priceLimit, marketOverride)
Open a new long entry. Wraps strategy function and sends plurex message as an alert. Also sets a gobal trailing stop loss for full open position. You must set one of trail_price or trail_points.
Parameters:
secret : The secret for your Signal on plurex
trail_offset : See strategy.exit documentation
trail_price : See strategy.exit documentation
trail_points : See strategy.exit documentation
budgetPercentage : Optional, The percentage of budget to use in the entry.
priceLimit : Optional, The worst price to accept for the entry.
marketOverride : Optional, defaults to the syminfo for the ticker. Use the `plurexMarket` function to build your own.
short(secret, budgetPercentage, priceLimit, marketOverride)
Open a new short entry. Wraps strategy function and sends plurex message as an alert.
Parameters:
secret : The secret for your Signal on plurex
budgetPercentage : Optional, The percentage of budget to use in the entry.
priceLimit : Optional, The worst price to accept for the entry.
marketOverride : Optional, defaults to the syminfo for the ticker. Use the `plurexMarket` function to build your own.
shortAndFixedStopLoss(secret, stop, budgetPercentage, priceLimit, marketOverride)
Open a new short entry. Wraps strategy function and sends plurex message as an alert. Also sets a gobal stop loss for full open position
Parameters:
secret : The secret for your Signal on plurex
stop : The trigger price for the stop loss. See strategy.exit documentation
budgetPercentage : Optional, The percentage of budget to use in the entry.
priceLimit : Optional, The worst price to accept for the entry.
marketOverride : Optional, defaults to the syminfo for the ticker. Use the `plurexMarket` function to build your own.
shortAndTrailingStopLoss(secret, trail_offset, trail_price, trail_points, budgetPercentage, priceLimit, marketOverride)
Open a new short entry. Wraps strategy function and sends plurex message as an alert. Also sets a gobal trailing stop loss for full open position. You must set one of trail_price or trail_points.
Parameters:
secret : The secret for your Signal on plurex
trail_offset : See strategy.exit documentation
trail_price : See strategy.exit documentation
trail_points : See strategy.exit documentation
budgetPercentage : Optional, The percentage of budget to use in the entry.
priceLimit : Optional, The worst price to accept for the entry.
marketOverride : Optional, defaults to the syminfo for the ticker. Use the `plurexMarket` function to build your own.
closeAll(secret, marketOverride)
Close all positions. Wraps strategy function and sends plurex message as an alert.
Parameters:
secret : The secret for your Signal on plurex
marketOverride : Optional, defaults to the syminfo for the ticker. Use the `plurexMarket` function to build your own.
closeLongs(secret, marketOverride)
close all longs. Wraps strategy function and sends plurex message as an alert.
Parameters:
secret : The secret for your Signal on plurex
marketOverride : Optional, defaults to the syminfo for the ticker. Use the `plurexMarket` function to build your own.
closeShorts(secret, marketOverride)
close all shorts. Wraps strategy function and sends plurex message as an alert.
Parameters:
secret : The secret for your Signal on plurex
marketOverride : Optional, defaults to the syminfo for the ticker. Use the `plurexMarket` function to build your own.
closeLastLong(secret, marketOverride)
Close last long entry. Wraps strategy function and sends plurex message as an alert.
Parameters:
secret : The secret for your Signal on plurex
marketOverride : Optional, defaults to the syminfo for the ticker. Use the `plurexMarket` function to build your own.
closeLastShort(secret, marketOverride)
Close last short entry. Wraps strategy function and sends plurex message as an alert.
Parameters:
secret : The secret for your Signal on plurex
marketOverride : Optional, defaults to the syminfo for the ticker. Use the `plurexMarket` function to build your own.
closeFirstLong(secret, marketOverride)
Close first long entry. Wraps strategy function and sends plurex message as an alert.
Parameters:
secret : The secret for your Signal on plurex
marketOverride : Optional, defaults to the syminfo for the ticker. Use the `plurexMarket` function to build your own.
closeFirstShort(secret, marketOverride)
Close first short entry. Wraps strategy function and sends plurex message as an alert.
Parameters:
secret : The secret for your Signal on plurex
marketOverride : Optional, defaults to the syminfo for the ticker. Use the `plurexMarket` function to build your own.
Price Pivots for NASDQ 100 StocksPrice Pivots for NASDQ 100 Stocks
What is this Indicator?
• This indicator calculates the price range a Stock can move in a Day.
Advantages of this Indicator
• This is a Leading indicator, not Dynamic or Repaint.
• Helps to identify the tight range of price movement.
• Can easily identify the Options strike price.
• Develops a discipline in placing Targets.
Disadvantages of this Indicator
• The indicator is specifically made for NASDQ 100 stocks. The levels won't work for other stocks.
• The indicator shows nothing for other indexes and stocks other than above mentioned.
• The data need to be entered manually.
Who to use?
Highly beneficial for Day Traders, it can be used for Swing and Positions as well.
What timeframe to use?
• Any timeframe.
• The highlighted levels in Red and Green will not show correct levels in 1 minute timeframe.
• 5min is recommended for Day Traders.
When to use?
• Wait for proper swing to form.
• Recommended to avoid 1st 1 hour or market open, that is 9.15am to 10.15 or 10.30am.
• Within this time a proper swing will be formed.
What are the Lines?
• The concept is the price will move from one pivot to another.
• Entry and Exit can be these levels as Reversal or Retracement.
Gray Lines:
• Every lines with price labels are the Strike Prices in the Option Chain.
• Price moves from 1 Strike Price level to another.
• The dashed lines are average levels of 2 Strike Prices.
Red & Green Lines:
• The Red and Green Lines will appear only after the first 1 hour.
• The levels are calculated based on the 1st 1 hour.
• Red Lines are important Resistance levels, these are strong Bearish reversal points. It is also a breakout level, this need to be figured out from the past levels, trend, percentage change and consolidation.
• Green Lines are important Support levels, these are strong Bullish reversal points. It is also a breakdown level, this need to be figured out from the past levels, trend, percentage change and consolidation.
What are the Labels?
• First Number: Price of that level.
• Numbers in (): Percentage change and Change of price from LTP (Last Traded Price) to that Level.
How to use?
Entry:
• Enter when price is closer to the Red or Green lines.
• Enter after considering previous Swing and Trend.
• Note the 50% of previous Swing.
• Enter Short when price reverse from each level.
• If 50% of swing and the pivot level is closer it can be a good entry.
Exit:
• Use the logic of Entry, each level can be a target.
• Exit when price is closer to the Red or Green lines.
Indicator Menu
Source
• Custom: Enter the price manually after choosing the Source as Custom to show the Pivots at that price.
• LTP: Pivot is calculated based on Last Traded Price.
• Day Open: Pivot is calculated based on current day opening price.
• PD Close: Pivot is calculated based on previous day closing price.
• PD HL2: Pivot is calculated based on previous day average of High and Low.
• PD HLC3: Pivot is calculated based on previous day average of High, Low and Close.
"Time (Vertical Lines)"
• This is a marker of every 1 hour.
• Usually major price movement happen between previous day last 1 hour to today first 1 hour.
• Two swings can happen between first 2 hour of current day.
• At the end of the day last 1 hour another important movement will happen.
• Usually rest of the time won't show any interesting movement.
To the Users
• Certain symbols may show the levels as a single line. For such symbols choose a different Source or Timeframe from the indicator menu.
• Please inform if any of the Symbol's price levels don't react to the pivots , include the Symbol a well.
• Also inform if you notice any wrong values, errors or abnormal behavior in the indicator.
• Feel free to suggest or adding new features and options.
General Tips
• It is good if Stock trend is same as that of Index trend.
• Lots of indicators creates lots of confusion.
• Keep the chart simple and clean.
• Buy Low and Sell High.
• Master averages or 50%.
• Previous Swing High and Swing Low are crucial.
Important Note
• Currently the levels are in testing stage.
• Eventually the levels of certain symbols will be corrected after each update and test.
Price Pivots for NSE Index & F&O StocksPrice Pivots for NSE Index & F&O Stocks
What is this Indicator?
• This indicator calculates the price range a Stock or Index can move in a Day, Week or Month.
Advantages of this Indicator
• This is a Leading indicator, not Dynamic or Repaint.
• Helps to identify the tight range of price movement.
• Can easily identify the Options strike price.
• The levels are more reliable and authentic than Gann Square of 9 Levels.
• Develops a discipline in placing Targets.
Disadvantages of this Indicator
• The indicator is specifically made for National Stock Exchange of India (NSE) listed index and stocks.
• The indicator is calculated only for index NIFTY, BANKNIFTY, FINNIFTY, MIDCPNIFTY and Stocks listed in Futures and Options.
• The indicator shows nothing for other indexes and stocks other than above mentioned.
• The data need to be entered manually.
• The data need to be updated manually when the F&O listed stocks are updated.
Who to use?
Highly beneficial for Day Traders, it can be used for Swing and Positions as well.
What timeframe to use?
• Any timeframe.
• The highlighted levels in Red and Green will not show correct levels in 1 minute timeframe.
• 5min is recommended for Day Traders.
When to use?
• Wait for proper swing to form.
• Recommended to avoid 1st 1 hour or market open, that is 9.15am to 10.15 or 10.30am.
• Within this time a proper swing will be formed.
How to use?
Entry
• Enter when the Price reach closer to the Blue line.
• Enter Long when the Price takes a pullback or breakout at the Red lines.
Exit
• Exit position when the Price reach closer to the Red lines in Long positions.
What are the Lines?
Gray Lines:
• Every lines with price labels are the Strike Prices in the Option Chain from NSE website.
• Price moves from 1 Strike Price level to another.
• The dashed lines are average levels of 2 Strike Prices.
Red & Green Lines:
• The Red and Green Lines will appear only after the first 1 hour.
• The levels are calculated based on the 1st 1 hour.
• Red Lines are important Resistance levels, these are strong Bearish reversal points. It is also a breakout level, this need to be figured out from the past levels, trend, percentage change and consolidation.
• Green Lines are important Support levels, these are strong Bullish reversal points. It is also a breakdown level, this need to be figured out from the past levels, trend, percentage change and consolidation.
What are the Labels?
• First Number: Price of that level.
• Numbers in (): Percentage change and Change of price from LTP(Last Traded Price) to that Level.
How to use?
Entry:
• Enter when price is closer to the Red or Green lines.
• Enter after considering previous Swing and Trend.
• Note the 50% of previous Swing.
• Enter Short when price reverse from each level.
• If 50% of swing and the pivot level is closer it can be a good entry.
Exit:
• Use the logic of Entry, each level can be a target.
• Exit when price is closer to the Red or Green lines.
Indicator Menu
Source
• Custom: Enter the price manually after choosing the Source as Custom to show the Pivots at that price.
• LTP: Pivot is calculated based on Last Traded Price.
• Day Open: Pivot is calculated based on current day opening price.
• PD Close: Pivot is calculated based on previous day closing price.
• PD HL2: Pivot is calculated based on previous day average of High and Low.
• PD HLC3: Pivot is calculated based on previous day average of High, Low and Close.
"Time (IST) (Vertical)"
• This is a marker of every 1 hour.
• Usually major price movement happen between previous day last 1 hour (2:15 pm) to today first 1 hour (10:15 pm).
• Two swings can happen between first 2 hour of current day.
• At the end of the day last 1 hour from 2.15 pm another important movement will happen.
• Usually rest of the time won't show any interesting movement.
To the Users
• Certain symbols may show the levels as a single line. For such symbols choose a different Source or Timeframe from the indicator menu.
• Please inform if any of the Symbol's price levels don't react to the pivots, include the Symbol a well.
• Also inform if you notice any wrong values, errors or abnormal behavior in the indicator.
• Feel free to suggest or adding new features and options.
General Tips
• It is good if Stock trend is same as that of NIFTY trend.
• Lots of indicators creates lots of confusion.
• Keep the chart simple and clean.
• Buy Low and Sell High.
• Master averages or 50%.
• Previous Swing High and Swing Low are crucial.
taLibrary "ta"
█ OVERVIEW
This library holds technical analysis functions calculating values for which no Pine built-in exists.
Look first. Then leap.
█ FUNCTIONS
cagr(entryTime, entryPrice, exitTime, exitPrice)
It calculates the "Compound Annual Growth Rate" between two points in time. The CAGR is a notional, annualized growth rate that assumes all profits are reinvested. It only takes into account the prices of the two end points — not drawdowns, so it does not calculate risk. It can be used as a yardstick to compare the performance of two instruments. Because it annualizes values, the function requires a minimum of one day between the two end points (annualizing returns over smaller periods of times doesn't produce very meaningful figures).
Parameters:
entryTime : The starting timestamp.
entryPrice : The starting point's price.
exitTime : The ending timestamp.
exitPrice : The ending point's price.
Returns: CAGR in % (50 is 50%). Returns `na` if there is not >=1D between `entryTime` and `exitTime`, or until the two time points have not been reached by the script.
█ v2, Mar. 8, 2022
Added functions `allTimeHigh()` and `allTimeLow()` to find the highest or lowest value of a source from the first historical bar to the current bar. These functions will not look ahead; they will only return new highs/lows on the bar where they occur.
allTimeHigh(src)
Tracks the highest value of `src` from the first historical bar to the current bar.
Parameters:
src : (series int/float) Series to track. Optional. The default is `high`.
Returns: (float) The highest value tracked.
allTimeLow(src)
Tracks the lowest value of `src` from the first historical bar to the current bar.
Parameters:
src : (series int/float) Series to track. Optional. The default is `low`.
Returns: (float) The lowest value tracked.
█ v3, Sept. 27, 2022
This version includes the following new functions:
aroon(length)
Calculates the values of the Aroon indicator.
Parameters:
length (simple int) : (simple int) Number of bars (length).
Returns: ( [float, float ]) A tuple of the Aroon-Up and Aroon-Down values.
coppock(source, longLength, shortLength, smoothLength)
Calculates the value of the Coppock Curve indicator.
Parameters:
source (float) : (series int/float) Series of values to process.
longLength (simple int) : (simple int) Number of bars for the fast ROC value (length).
shortLength (simple int) : (simple int) Number of bars for the slow ROC value (length).
smoothLength (simple int) : (simple int) Number of bars for the weigted moving average value (length).
Returns: (float) The oscillator value.
dema(source, length)
Calculates the value of the Double Exponential Moving Average (DEMA).
Parameters:
source (float) : (series int/float) Series of values to process.
length (simple int) : (simple int) Length for the smoothing parameter calculation.
Returns: (float) The double exponentially weighted moving average of the `source`.
dema2(src, length)
An alternate Double Exponential Moving Average (Dema) function to `dema()`, which allows a "series float" length argument.
Parameters:
src : (series int/float) Series of values to process.
length : (series int/float) Length for the smoothing parameter calculation.
Returns: (float) The double exponentially weighted moving average of the `src`.
dm(length)
Calculates the value of the "Demarker" indicator.
Parameters:
length (simple int) : (simple int) Number of bars (length).
Returns: (float) The oscillator value.
donchian(length)
Calculates the values of a Donchian Channel using `high` and `low` over a given `length`.
Parameters:
length (int) : (series int) Number of bars (length).
Returns: ( [float, float, float ]) A tuple containing the channel high, low, and median, respectively.
ema2(src, length)
An alternate ema function to the `ta.ema()` built-in, which allows a "series float" length argument.
Parameters:
src : (series int/float) Series of values to process.
length : (series int/float) Number of bars (length).
Returns: (float) The exponentially weighted moving average of the `src`.
eom(length, div)
Calculates the value of the Ease of Movement indicator.
Parameters:
length (simple int) : (simple int) Number of bars (length).
div (simple int) : (simple int) Divisor used for normalzing values. Optional. The default is 10000.
Returns: (float) The oscillator value.
frama(source, length)
The Fractal Adaptive Moving Average (FRAMA), developed by John Ehlers, is an adaptive moving average that dynamically adjusts its lookback period based on fractal geometry.
Parameters:
source (float) : (series int/float) Series of values to process.
length (int) : (series int) Number of bars (length).
Returns: (float) The fractal adaptive moving average of the `source`.
ft(source, length)
Calculates the value of the Fisher Transform indicator.
Parameters:
source (float) : (series int/float) Series of values to process.
length (simple int) : (simple int) Number of bars (length).
Returns: (float) The oscillator value.
ht(source)
Calculates the value of the Hilbert Transform indicator.
Parameters:
source (float) : (series int/float) Series of values to process.
Returns: (float) The oscillator value.
ichimoku(conLength, baseLength, senkouLength)
Calculates values of the Ichimoku Cloud indicator, including tenkan, kijun, senkouSpan1, senkouSpan2, and chikou. NOTE: offsets forward or backward can be done using the `offset` argument in `plot()`.
Parameters:
conLength (int) : (series int) Length for the Conversion Line (Tenkan). The default is 9 periods, which returns the mid-point of the 9 period Donchian Channel.
baseLength (int) : (series int) Length for the Base Line (Kijun-sen). The default is 26 periods, which returns the mid-point of the 26 period Donchian Channel.
senkouLength (int) : (series int) Length for the Senkou Span 2 (Leading Span B). The default is 52 periods, which returns the mid-point of the 52 period Donchian Channel.
Returns: ( [float, float, float, float, float ]) A tuple of the Tenkan, Kijun, Senkou Span 1, Senkou Span 2, and Chikou Span values. NOTE: by default, the senkouSpan1 and senkouSpan2 should be plotted 26 periods in the future, and the Chikou Span plotted 26 days in the past.
ift(source)
Calculates the value of the Inverse Fisher Transform indicator.
Parameters:
source (float) : (series int/float) Series of values to process.
Returns: (float) The oscillator value.
kvo(fastLen, slowLen, trigLen)
Calculates the values of the Klinger Volume Oscillator.
Parameters:
fastLen (simple int) : (simple int) Length for the fast moving average smoothing parameter calculation.
slowLen (simple int) : (simple int) Length for the slow moving average smoothing parameter calculation.
trigLen (simple int) : (simple int) Length for the trigger moving average smoothing parameter calculation.
Returns: ( [float, float ]) A tuple of the KVO value, and the trigger value.
pzo(length)
Calculates the value of the Price Zone Oscillator.
Parameters:
length (simple int) : (simple int) Length for the smoothing parameter calculation.
Returns: (float) The oscillator value.
rms(source, length)
Calculates the Root Mean Square of the `source` over the `length`.
Parameters:
source (float) : (series int/float) Series of values to process.
length (int) : (series int) Number of bars (length).
Returns: (float) The RMS value.
rwi(length)
Calculates the values of the Random Walk Index.
Parameters:
length (simple int) : (simple int) Lookback and ATR smoothing parameter length.
Returns: ( [float, float ]) A tuple of the `rwiHigh` and `rwiLow` values.
stc(source, fast, slow, cycle, d1, d2)
Calculates the value of the Schaff Trend Cycle indicator.
Parameters:
source (float) : (series int/float) Series of values to process.
fast (simple int) : (simple int) Length for the MACD fast smoothing parameter calculation.
slow (simple int) : (simple int) Length for the MACD slow smoothing parameter calculation.
cycle (simple int) : (simple int) Number of bars for the Stochastic values (length).
d1 (simple int) : (simple int) Length for the initial %D smoothing parameter calculation.
d2 (simple int) : (simple int) Length for the final %D smoothing parameter calculation.
Returns: (float) The oscillator value.
stochFull(periodK, smoothK, periodD)
Calculates the %K and %D values of the Full Stochastic indicator.
Parameters:
periodK (simple int) : (simple int) Number of bars for Stochastic calculation. (length).
smoothK (simple int) : (simple int) Number of bars for smoothing of the %K value (length).
periodD (simple int) : (simple int) Number of bars for smoothing of the %D value (length).
Returns: ( [float, float ]) A tuple of the slow %K and the %D moving average values.
stochRsi(lengthRsi, periodK, smoothK, periodD, source)
Calculates the %K and %D values of the Stochastic RSI indicator.
Parameters:
lengthRsi (simple int) : (simple int) Length for the RSI smoothing parameter calculation.
periodK (simple int) : (simple int) Number of bars for Stochastic calculation. (length).
smoothK (simple int) : (simple int) Number of bars for smoothing of the %K value (length).
periodD (simple int) : (simple int) Number of bars for smoothing of the %D value (length).
source (float) : (series int/float) Series of values to process. Optional. The default is `close`.
Returns: ( [float, float ]) A tuple of the slow %K and the %D moving average values.
supertrend(factor, atrLength, wicks)
Calculates the values of the SuperTrend indicator with the ability to take candle wicks into account, rather than only the closing price.
Parameters:
factor (float) : (series int/float) Multiplier for the ATR value.
atrLength (simple int) : (simple int) Length for the ATR smoothing parameter calculation.
wicks (simple bool) : (simple bool) Condition to determine whether to take candle wicks into account when reversing trend, or to use the close price. Optional. Default is false.
Returns: ( [float, int ]) A tuple of the superTrend value and trend direction.
szo(source, length)
Calculates the value of the Sentiment Zone Oscillator.
Parameters:
source (float) : (series int/float) Series of values to process.
length (simple int) : (simple int) Length for the smoothing parameter calculation.
Returns: (float) The oscillator value.
t3(source, length, vf)
Calculates the value of the Tilson Moving Average (T3).
Parameters:
source (float) : (series int/float) Series of values to process.
length (simple int) : (simple int) Length for the smoothing parameter calculation.
vf (simple float) : (simple float) Volume factor. Affects the responsiveness.
Returns: (float) The Tilson moving average of the `source`.
t3Alt(source, length, vf)
An alternate Tilson Moving Average (T3) function to `t3()`, which allows a "series float" `length` argument.
Parameters:
source (float) : (series int/float) Series of values to process.
length (float) : (series int/float) Length for the smoothing parameter calculation.
vf (simple float) : (simple float) Volume factor. Affects the responsiveness.
Returns: (float) The Tilson moving average of the `source`.
tema(source, length)
Calculates the value of the Triple Exponential Moving Average (TEMA).
Parameters:
source (float) : (series int/float) Series of values to process.
length (simple int) : (simple int) Length for the smoothing parameter calculation.
Returns: (float) The triple exponentially weighted moving average of the `source`.
tema2(source, length)
An alternate Triple Exponential Moving Average (TEMA) function to `tema()`, which allows a "series float" `length` argument.
Parameters:
source (float) : (series int/float) Series of values to process.
length (float) : (series int/float) Length for the smoothing parameter calculation.
Returns: (float) The triple exponentially weighted moving average of the `source`.
trima(source, length)
Calculates the value of the Triangular Moving Average (TRIMA).
Parameters:
source (float) : (series int/float) Series of values to process.
length (int) : (series int) Number of bars (length).
Returns: (float) The triangular moving average of the `source`.
trima2(src, length)
An alternate Triangular Moving Average (TRIMA) function to `trima()`, which allows a "series int" length argument.
Parameters:
src : (series int/float) Series of values to process.
length : (series int) Number of bars (length).
Returns: (float) The triangular moving average of the `src`.
trix(source, length, signalLength, exponential)
Calculates the values of the TRIX indicator.
Parameters:
source (float) : (series int/float) Series of values to process.
length (simple int) : (simple int) Length for the smoothing parameter calculation.
signalLength (simple int) : (simple int) Length for smoothing the signal line.
exponential (simple bool) : (simple bool) Condition to determine whether exponential or simple smoothing is used. Optional. The default is `true` (exponential smoothing).
Returns: ( [float, float, float ]) A tuple of the TRIX value, the signal value, and the histogram.
uo(fastLen, midLen, slowLen)
Calculates the value of the Ultimate Oscillator.
Parameters:
fastLen (simple int) : (series int) Number of bars for the fast smoothing average (length).
midLen (simple int) : (series int) Number of bars for the middle smoothing average (length).
slowLen (simple int) : (series int) Number of bars for the slow smoothing average (length).
Returns: (float) The oscillator value.
vhf(source, length)
Calculates the value of the Vertical Horizontal Filter.
Parameters:
source (float) : (series int/float) Series of values to process.
length (simple int) : (simple int) Number of bars (length).
Returns: (float) The oscillator value.
vi(length)
Calculates the values of the Vortex Indicator.
Parameters:
length (simple int) : (simple int) Number of bars (length).
Returns: ( [float, float ]) A tuple of the viPlus and viMinus values.
vzo(length)
Calculates the value of the Volume Zone Oscillator.
Parameters:
length (simple int) : (simple int) Length for the smoothing parameter calculation.
Returns: (float) The oscillator value.
williamsFractal(period)
Detects Williams Fractals.
Parameters:
period (int) : (series int) Number of bars (length).
Returns: ( [bool, bool ]) A tuple of an up fractal and down fractal. Variables are true when detected.
wpo(length)
Calculates the value of the Wave Period Oscillator.
Parameters:
length (simple int) : (simple int) Length for the smoothing parameter calculation.
Returns: (float) The oscillator value.
█ v7, Nov. 2, 2023
This version includes the following new and updated functions:
atr2(length)
An alternate ATR function to the `ta.atr()` built-in, which allows a "series float" `length` argument.
Parameters:
length (float) : (series int/float) Length for the smoothing parameter calculation.
Returns: (float) The ATR value.
changePercent(newValue, oldValue)
Calculates the percentage difference between two distinct values.
Parameters:
newValue (float) : (series int/float) The current value.
oldValue (float) : (series int/float) The previous value.
Returns: (float) The percentage change from the `oldValue` to the `newValue`.
donchian(length)
Calculates the values of a Donchian Channel using `high` and `low` over a given `length`.
Parameters:
length (int) : (series int) Number of bars (length).
Returns: ( [float, float, float ]) A tuple containing the channel high, low, and median, respectively.
highestSince(cond, source)
Tracks the highest value of a series since the last occurrence of a condition.
Parameters:
cond (bool) : (series bool) A condition which, when `true`, resets the tracking of the highest `source`.
source (float) : (series int/float) Series of values to process. Optional. The default is `high`.
Returns: (float) The highest `source` value since the last time the `cond` was `true`.
lowestSince(cond, source)
Tracks the lowest value of a series since the last occurrence of a condition.
Parameters:
cond (bool) : (series bool) A condition which, when `true`, resets the tracking of the lowest `source`.
source (float) : (series int/float) Series of values to process. Optional. The default is `low`.
Returns: (float) The lowest `source` value since the last time the `cond` was `true`.
relativeVolume(length, anchorTimeframe, isCumulative, adjustRealtime)
Calculates the volume since the last change in the time value from the `anchorTimeframe`, the historical average volume using bars from past periods that have the same relative time offset as the current bar from the start of its period, and the ratio of these volumes. The volume values are cumulative by default, but can be adjusted to non-accumulated with the `isCumulative` parameter.
Parameters:
length (simple int) : (simple int) The number of periods to use for the historical average calculation.
anchorTimeframe (simple string) : (simple string) The anchor timeframe used in the calculation. Optional. Default is "D".
isCumulative (simple bool) : (simple bool) If `true`, the volume values will be accumulated since the start of the last `anchorTimeframe`. If `false`, values will be used without accumulation. Optional. The default is `true`.
adjustRealtime (simple bool) : (simple bool) If `true`, estimates the cumulative value on unclosed bars based on the data since the last `anchor` condition. Optional. The default is `false`.
Returns: ( [float, float, float ]) A tuple of three float values. The first element is the current volume. The second is the average of volumes at equivalent time offsets from past anchors over the specified number of periods. The third is the ratio of the current volume to the historical average volume.
rma2(source, length)
An alternate RMA function to the `ta.rma()` built-in, which allows a "series float" `length` argument.
Parameters:
source (float) : (series int/float) Series of values to process.
length (float) : (series int/float) Length for the smoothing parameter calculation.
Returns: (float) The rolling moving average of the `source`.
supertrend2(factor, atrLength, wicks)
An alternate SuperTrend function to `supertrend()`, which allows a "series float" `atrLength` argument.
Parameters:
factor (float) : (series int/float) Multiplier for the ATR value.
atrLength (float) : (series int/float) Length for the ATR smoothing parameter calculation.
wicks (simple bool) : (simple bool) Condition to determine whether to take candle wicks into account when reversing trend, or to use the close price. Optional. Default is `false`.
Returns: ( [float, int ]) A tuple of the superTrend value and trend direction.
vStop(source, atrLength, atrFactor)
Calculates an ATR-based stop value that trails behind the `source`. Can serve as a possible stop-loss guide and trend identifier.
Parameters:
source (float) : (series int/float) Series of values that the stop trails behind.
atrLength (simple int) : (simple int) Length for the ATR smoothing parameter calculation.
atrFactor (float) : (series int/float) The multiplier of the ATR value. Affects the maximum distance between the stop and the `source` value. A value of 1 means the maximum distance is 100% of the ATR value. Optional. The default is 1.
Returns: ( [float, bool ]) A tuple of the volatility stop value and the trend direction as a "bool".
vStop2(source, atrLength, atrFactor)
An alternate Volatility Stop function to `vStop()`, which allows a "series float" `atrLength` argument.
Parameters:
source (float) : (series int/float) Series of values that the stop trails behind.
atrLength (float) : (series int/float) Length for the ATR smoothing parameter calculation.
atrFactor (float) : (series int/float) The multiplier of the ATR value. Affects the maximum distance between the stop and the `source` value. A value of 1 means the maximum distance is 100% of the ATR value. Optional. The default is 1.
Returns: ( [float, bool ]) A tuple of the volatility stop value and the trend direction as a "bool".
Removed Functions:
allTimeHigh(src)
Tracks the highest value of `src` from the first historical bar to the current bar.
allTimeLow(src)
Tracks the lowest value of `src` from the first historical bar to the current bar.
trima2(src, length)
An alternate Triangular Moving Average (TRIMA) function to `trima()`, which allows a
"series int" length argument.
ColorSchemeLibrary "ColorScheme"
A color scheme generator.
init() Initiate the array data registry that will hold the color profile. Returns: tuple with 2 arrays (string array, color array)
check_registry_integrity(key_registry, color_registry) Checks the integrity of the registers.
Parameters:
key_registry : string array, key data holder array.
color_registry : color array, color value data holder array.
Returns: void.
add(key_registry, color_registry, key, value) Add new (key, color) entry to the registry.
Parameters:
key_registry : string array, key data holder array.
color_registry : color array, color value data array.
key : string, the unique key to reference the value.
value : color, the color value of the specified key.
Returns: void.
get_color(key_registry, color_registry, key) Get a (key, color) entry from the registry.
Parameters:
key_registry : string array, key data holder array.
color_registry : color array, color value data array.
key : string, the unique key to reference the value.
Returns: void.
edit_key(key_registry, color_registry, key, new_key) Edit a (key, color) entry in the registry.
Parameters:
key_registry : string array, key data holder array.
color_registry : color array, color value data array.
key : string, the unique key to reference the value.
new_key : string, the unique key to reference the value.
Returns: void.
edit_color(key_registry, color_registry, key, new_value) Edit a (key, color) entry in the registry.
Parameters:
key_registry : string array, key data holder array.
color_registry : color array, color value data array.
key : string, the unique key to reference the value.
new_value : color, the color value of the specified key.
Returns: void.
delete(key_registry, color_registry, key) Delete a (key, color) entry from the registry.
Parameters:
key_registry : string array, key data holder array.
color_registry : color array, color value data array.
key : string, the unique key to reference the value.
Returns: void.
delete_all(key_registry, color_registry) Delete all (key, color) entrys from the registry.
Parameters:
key_registry : string array, key data holder array.
color_registry : color array, color value data array.
Returns: void.
model(index) Enumerate models available to profile colors.
Parameters:
index : int, index of model. (1:'monochromatic', 2:'analog', 3:'triadic', 4:'tetradic', 5:'square', anything else:'monochromatic')
Returns: string.
generate_scheme(key_registry, color_registry, primary, model) Generate a multi color scheme.
Parameters:
key_registry : string array, key data holder array.
color_registry : color array, color value data array.
primary : color, the origin color to base the profile.
model : string, default='monochromatic', options=('monochromatic', 'triadic near', 'triadic far', 'tetradic')
Returns: void.
Dual Volume Profiles: Session + Rolling (Range Delineation)Dual Volume Profiles: Session + Rolling (Range Delineation)
INTRO
This is a probability-centric take on volume profile. I treat the volume histogram as an empirical PDF over price, updated in real time, which makes multi-modality (multiple acceptance basins) explicit rather than assumed away. The immediate benefit is operational: if we can read the shape of the distribution, we can infer likely reversion levels (POC), acceptance boundaries (VAH/VAL), and low-friction corridors (LVNs).
My working hypothesis is that what traders often label “fat tails” or “power-law behavior” at short horizons is frequently a tail-conditioned view of a higher-level Gaussian regime. In other words, child distributions (shorter periodicities) sit within parent distributions (longer periodicities); when price operates in the parent’s tail, the child regime looks heavy-tailed without being fundamentally non-Gaussian. This is consistent with a hierarchical/mixture view and with the spirit of the central limit theorem—Gaussian structure emerges at aggregate scales, while local scales can look non-Gaussian due to nesting and conditioning.
This indicator operationalizes that view by plotting two nested empirical PDFs: a rolling (local) profile and a session-anchored profile. Their confluence makes ranges explicit and turns “regime” into something you can see. For additional nesting, run multiple instances with different lookbacks. When using the default settings combined with a separate daily VP, you effectively get three nested distributions (local → session → daily) on the chart.
This indicator plots two nested distributions side-by-side:
Rolling (Local) Profile — short-window, prorated histogram that “breathes” with price and maps the immediate auction.
Session Anchored Profile — cumulative distribution since the current session start (Premkt → RTH → AH anchoring), revealing the parent regime.
Use their confluence to identify range floors/ceilings, mean-reversion magnets, and low-volume “air pockets” for fast traverses.
What it shows
POC (dashed): central tendency / “magnet” (highest-volume bin).
VAH & VAL (solid): acceptance boundaries enclosing an exact Value Area % around each profile’s POC.
Volume histograms:
Rolling can auto-color by buy/sell dominance over the lookback (green = buying ≥ selling, red = selling > buying).
Session uses a fixed style (blue by default).
Session anchoring (exchange timezone):
Premarket → anchors at 00:00 (midnight).
RTH → anchors at 09:30.
After-hours → anchors at 16:00.
Session display span:
Session Max Span (bars) = 0 → draw from session start → now (anchored).
> 0 → draw a rolling window N bars back → now, while still measuring all volume since session start.
Why it’s useful
Think in terms of nested probability distributions: the rolling node is your local Gaussian; the session node is its parent.
VA↔VA overlap ≈ strong range boundary.
POC↔POC alignment ≈ reliable mean-reversion target.
LVNs (gaps) ≈ low-friction corridors—expect quick moves to the next node.
Quick start
Add to chart (great on 5–10s, 15–60s, 1–5m).
Start with: bins = 240, vaPct = 0.68, barsBack = 60.
Watch for:
First test & rejection at overlapping VALs/VAHs → fade back toward POC.
Acceptance beyond VA (several closes + growing outer-bin mass) → traverse to the next node.
Inputs (detailed)
General
Lookback Bars (Rolling)
Count of most-recent bars for the rolling/local histogram. Larger = smoother node that shifts slower; smaller = more reactive, “breathing” profile.
• Typical: 40–80 on 5–10s charts; 60–120 on 1–5m.
• If you increase this but keep Number of Bins fixed, each bin aggregates more volume (coarser bins).
Number of Bins
Vertical resolution (price buckets) for both rolling and session histograms. Higher = finer detail and crisper LVNs, but more line objects (closer to platform limits).
• Typical: 120–240 on 5–10s; 80–160 on 1–5m.
• If you hit performance or object limits, reduce this first.
Value Area %
Exact central coverage for VAH/VAL around POC. Computed empirically from the histogram (no Gaussian assumption): the algorithm expands from POC outward until the chosen % is enclosed.
• Common: 0.68 (≈“1σ-like”), 0.70 for slightly wider core.
• Smaller = tighter VA (more breakout flags). Larger = wider VA (more reversion bias).
Max Local Profile Width (px)
Horizontal length (in pixels) of the rolling bars/lines and its VA/POC overlays. Visual only (does not affect calculations).
Session Settings
RTH Start/End (exchange tz)
Defines the current session anchor (Premkt=00:00, RTH=your start, AH=your end). The session histogram always measures from the most recent session start and resets at each boundary.
Session Max Span (bars, 0 = full session)
Display window for session drawings (POC/VA/Histogram).
• 0 → draw from session start → now (anchored).
• > 0 → draw N bars back → now (rolling look), while still measuring all volume since session start.
This keeps the “parent” distribution measurable while letting the display track current action.
Local (Rolling) — Visibility
Show Local Profile Bars / POC / VAH & VAL
Toggle each overlay independently. If you approach object limits, disable bars first (POC/VA lines are lighter).
Local (Rolling) — Colors & Widths
Color by Buy/Sell Dominance
Fast uptick/downtick proxy over the rolling window (close vs open):
• Buying ≥ Selling → Bullish Color (default lime).
• Selling > Buying → Bearish Color (default red).
This color drives local bars, local POC, and local VA lines.
• Disable to use fixed Bars Color / POC Color / VA Lines Color.
Bars Transparency (0–100) — alpha for the local histogram (higher = lighter).
Bars Line Width (thickness) — draw thin-line profiles or chunky blocks.
POC Line Width / VA Lines Width — overlay thickness. POC is dashed, VAH/VAL solid by design.
Session — Visibility
Show Session Profile Bars / POC / VAH & VAL
Independent toggles for the session layer.
Session — Colors & Widths
Bars/POC/VA Colors & Line Widths
Fixed palette by design (default blue). These do not change with buy/sell dominance.
• Use transparency and width to make the parent profile prominent or subtle.
• Prefer minimal? Hide session bars; keep only session VA/POC.
Reading the signals (detailed playbook)
Core definitions
POC — highest-volume bin (fair price “magnet”).
VAH/VAL — upper/lower bounds enclosing your Value Area % around POC.
Node — contiguous block of high-volume bins (acceptance).
LVN — low-volume gap between nodes (low friction path).
Rejection vs Acceptance (practical rule)
Rejection at VA edge: 0–1 closes beyond VA and no persistent growth in outer bins.
Acceptance beyond VA: ≥3 closes beyond VA and outer-bin mass grows (e.g., added volume beyond the VA edge ≥ 5–10% of node volume over the last N bars). Treat acceptance as regime change.
Confluence scores (make boundary/target quality objective)
VA overlap strength (range boundary):
C_VA = 1 − |VA_edge_local − VA_edge_session| / ATR(n)
Values near 1.0 = tight overlap (stronger boundary).
Use: if C_VA ≥ 0.6–0.8, treat as high-quality fade zone.
POC alignment (magnet quality):
C_POC = 1 − |POC_local − POC_session| / ATR(n)
Higher C_POC = greater chance a rotation completes to that fair price.
(You can estimate these by eye.)
Setups
1) Range Fade at VA Confluence (mean reversion)
Context: Local VAL/VAH near Session VAL/VAH (tight overlap), clear node, local color not screaming trend (or flips to your side).
Entry: First test & rejection at the overlapped band (wick through ok; prefer close back inside).
Stop: A tick/pip beyond the wider of the two VA edges or beyond the nearest LVN, a small buffer zone can be used to judge whether price is truly rejecting a VAL/VAH or simply probing.
Targets: T1 node mid; T2 POC (size up when C_POC is high).
Flip: If acceptance (rule above) prints, flip bias or stand down.
2) LVN Traverse (continuation)
Context: Price exits VA and enters an LVN with acceptance and growing outer-bin volume.
Entry: Aggressive—first close into LVN; Conservative—retest of the VA edge from the far side (“kiss goodbye”).
Stop: Back inside the prior VA.
Targets: Next node’s VA edge or POC (edge = faster exits; POC = fuller rotations).
Note: Flatter VA edge (shallower curvature) tends to breach more easily.
3) POC→POC Magnet Trade (rotation completion)
Context: Local POC ≈ Session POC (high C_POC).
Entry: Fade a VA touch or pullback inside node, aiming toward the shared POC.
Stop: Past the opposite VA edge or LVN beyond.
Target: The shared POC; optional runner to opposite VA if the node is broad and time-of-day is supportive.
4) Failed Break (Reversion Snap-back)
Context: Push beyond VA fails acceptance (re-enters VA, outer-bin growth stalls/shrinks).
Entry: On the re-entry close, back toward POC.
Stop/Target: Stop just beyond the failed VA; target POC, then opposite VA if momentum persists.
How to read color & shape
Local color = most recent sentiment:
Green = buying ≥ selling; Red = selling > buying (over the rolling window). Treat as context, not a standalone signal. A green local node under a blue session VAH can still be a fade if the parent says “over-valued.”
Shape tells friction:
Fat nodes → rotation-friendly (fade edges).
Sharp LVN gaps → traversal-friendly (momentum continuation).
Time-of-day intuition
Right after session anchor (e.g., RTH 09:30): Session profile is young and moves quickly—treat confluence cautiously.
Mid-session: Cleanest behavior for rotations.
Close / news: Expect more traverses and POC migrations; tighten risk or switch playbooks.
Risk & execution guidance
Use tight, mechanical stops at/just beyond VA or LVN. If you need wide stops to survive noise, your entry is late or the node is unstable.
On micro-timeframes, account for fees & slippage—aim for targets paying ≥2–3× average cost.
If acceptance prints, don’t fight it—flip, reduce size, or stand aside.
Suggested presets
Scalp (5–10s): bins 120–240, barsBack 40–80, vaPct 0.68–0.70, local bars thin (small bar width).
Intraday (1–5m): bins 80–160, barsBack 60–120, vaPct 0.68–0.75, session bars more visible for parent context.
Performance & limits
Reuses line objects to stay under TradingView’s max_lines_count.
Very large bins × multiple overlays can still hit limits—use visibility toggles (hide bars first).
Session drawings use time-based coordinates to avoid “bar index too far” errors.
Known nuances
Rolling buy/sell dominance uses a simple uptick/downtick proxy (close vs open). It’s fast and practical, but it’s not a full tape classifier.
VA boundaries are computed from the empirical histogram—no Gaussian assumption.
This script does not calculate the full daily volume profile. Several other tools already provide that, including TradingView’s built-in Volume Profile indicators. Instead, this indicator focuses on pairing a rolling, short-term volume distribution with a session-wide distribution to make ranges more explicit. It is designed to supplement your use of standard or periodic volume profiles, not replace them. Think of it as a magnifying lens that helps you see where local structure aligns with the broader session.
How to trade it (TL;DR)
Fade overlapping VA bands on first rejection → target POC.
Continue through LVN on acceptance beyond VA → target next node’s VA/POC.
Respect acceptance: ≥3 closes beyond VA + growing outer-bin volume = regime change.
FAQ
Q: Why 68% Value Area?
A: It mirrors the “~1σ” idea, but we compute it exactly from empirical volume, not by assuming a normal distribution.
Q: Why are my profiles thin lines?
A: Increase Bars Line Width for chunkier blocks; reduce for fine, thin-line profiles.
Q: Session bars don’t reach session start—why?
A: Set Session Max Span (bars) = 0 for full anchoring; any positive value draws a rolling window while still measuring from session start.
Changelog (v1.0)
Dual profiles: Rolling + Session with independent POC/VA lines.
Session anchoring (Premkt/RTH/AH) with optional rolling display span.
Dynamic coloring for the rolling profile (buying vs selling).
Fully modular toggles + per-feature colors/widths.
Thin-line rendering via bar line width.
EMA 6/21/50 PROIndicator Description: EMAs 6/21/50 + MACD + AO + Panel + Alerts
This technical indicator combines several analysis tools to help identify opportunities to enter consolidated trends. It integrates Exponential Moving Averages (EMAs), the MACD, the Amazing Oscillator (AO), and an interactive information panel that allows you to visualize entry signals, trend direction, and potential exit levels (Take Profit and Stop Loss). It is designed for day or swing traders who want a quick and structured reading of the market.
What does the script do? The indicator does the following: It draws 6, 21, and 50-period EMAs on the chart to detect the direction of the trend. It generates LONG/SHORT entry signals based on EMA crossover, alignment with the overall trend (EMA50), and confirmation by indicators: MACD:
Momentum filter. AO: Impulse depletion filter. It visually displays the TP (Take Profit) and SL (Stop Loss) levels when there is a signal. It includes an informative graphical panel with icons and text summarizing the market status and entry conditions.
It issues customizable alerts for entry signals, allowing it to be used in automated strategies or as a manual guide. Allows you to enable/disable visual elements with buttons to customize the experience.
How does it do it?
EMAs and crossover signals: It uses three EMAs: 6 (fast), 21 (medium), and 50 (slow).
A LONG signal occurs when the 6-EMA crosses above the 21-EMA, the price is above the 50-EMA, the MACD confirms bullish momentum, and the AO shows no exhaustion.
A SHORT signal is given in reverse conditions, with the option to limit the system to long signals only (Long signals only).
Additional filters:
MACD: Entry is avoided if there is no favorable crossover between the MACD line and its signal.
AO: Entry is avoided if the OA shows signs of weakness or exhaustion. TP/SL Visual:
TP and SL levels are calculated based on user-defined pips, and are automatically drawn on the chart when there is a valid signal.
Information panel: Each bar is automatically updated. Samples: general trend, EMA crossover, MACD/AO filters, and presence of LONG/SHORT signal. It is possible to hide it with a button from the settings panel.
Alerts: Alerts are generated when the full LONG or SHORT entry conditions are met. They are useful for receiving automatic notifications or integrating them into automated systems.
How to use it?
Add to chart and configure options: Year of start of the analysis.
Activate only long signals if you wish.
Show/hide panel, EMAs, or TP/SL levels. Interpreting signals:
Green triangle under a candle = Possible LONG entry.
Red triangle above a candle = Possible SHORT entry.
Green Line = Suggested Take Profit. Red Line = Suggested Stop Loss. Trigger alerts from TradingView's alert settings to be notified in real-time.
Important Note
This script does not execute orders or represent an automated trading strategy.
It is a visual analysis tool that can support decision-making, but it is recommended to use it in conjunction with other elements of analysis and proper risk management.
Neuracap Gap AnalysisThe Neuracap Gap Analysis indicator is a comprehensive tool designed to identify and track price gaps, special candlestick patterns, and high-volume breakout signals. It combines multiple trading strategies into one powerful indicator for gap trading, pattern recognition, and momentum analysis.
🎯 What This Indicator Does
1. Gap Detection & Tracking
Automatically identifies price gaps (up and down)
Tracks gap fills with visual boxes that extend until closed
Manages gap history with customizable limits
Color-coded visualization (Green = Gap Up, Red = Gap Down)
2. Upside Tasuki Gap Pattern
Identifies the bullish continuation pattern
Colors candles yellow when pattern is detected
Confirms trend continuation signals
3. Episodic Pivot Detection
High-volume breakout identification
EMA filter ensures signals only in uptrends
Strong momentum confirmation
Fuchsia-colored candles with arrow markers
🔍 How to Use for Trading
📈 Gap Trading Strategy
Gap Up Trading:
Wait for gap up (green box appears)
Check volume - Higher volume = stronger signal
Entry options:
Aggressive: Enter at market open
Conservative: Wait for pullback to gap level
Stop loss: Below the gap fill level
Target: Previous resistance or 2:1 risk/reward
Gap Down Trading:
Identify gap down (red box appears)
Look for bounce opportunities
Entry: When price shows reversal signs
Stop: Below recent lows
Target: Gap fill level
💫 Tasuki Gap Strategy
Yellow candle indicates bullish continuation
Confirms uptrend is likely to continue
Entry: On next candle after pattern
Stop: Below the gap low
Target: Next resistance level
🚀 Episodic Pivot Strategy
Fuchsia candle + arrow = High probability breakout
All conditions met:
Price above EMA 20, 50, 200
High volume (2x+ average)
Strong price move (4%+)
Entry: At close or next open
Stop: Below EMA 20 or recent swing low
Target: Measured move or next resistance
📊 Reading the Visual Signals
Gap Boxes
🟢 Green Box: Gap up - potential bullish continuation
🔴 Red Box: Gap down - potential bounce or bearish continuation
Box extends until gap is filled
Box disappears when gap closes
Candle Colors
🟡 Yellow: Tasuki gap pattern (bullish continuation)
🟪 Fuchsia: Episodic pivot (high-volume breakout)
⬜ Normal: No special pattern detected
Arrows & Markers
⬆️ Triangle Arrow: Episodic pivot confirmation
💡 Trading Tips & Best Practices
✅ Do's
Combine with trend analysis - Trade gaps in direction of trend
Check volume - Higher volume = more reliable signals
Use multiple timeframes - Confirm on higher timeframes
Risk management - Always set stop losses
Wait for confirmation - Don't chase, let signals develop
❌ Don'ts
Don't trade all gaps - Focus on high-quality setups
Avoid low volume - Weak volume = unreliable signals
Don't ignore trend - Counter-trend trading is risky
Don't overtrade - Quality over quantity
Don't ignore context - Consider market conditions
⚠️ Risk Management
Position sizing: Risk 1-2% per trade
Stop losses: Always define before entry
Target levels: Set realistic profit targets
Market conditions: Avoid trading in choppy markets
📈 Performance Optimization
For Conservative Traders:
Increase minimum gap size to 1%
Set volume multiplier to 3.0x
Only trade episodic pivots in strong uptrends
Wait for gap fill confirmation
For Aggressive Traders:
Decrease minimum gap size to 0.3%
Set volume multiplier to 1.5x
Trade both gap types
Enter on pattern confirmation
🚨 Alert Setup
The indicator provides alerts for:
Gap Up Detected
Gap Down Detected
Upside Tasuki Gap
Episodic Pivot
Recommended: Enable all alerts and filter manually based on your strategy.
📝 Summary
This indicator excels at identifying high-probability trading opportunities through gap analysis, pattern recognition, and momentum confirmation. Use it as part of a complete trading system with proper risk management for best results.
Long/Short/Exit/Risk management Strategy # LongShortExit Strategy Documentation
## Overview
The LongShortExit strategy is a versatile trading system for TradingView that provides complete control over entry, exit, and risk management parameters. It features a sophisticated framework for managing long and short positions with customizable profit targets, stop-loss mechanisms, partial profit-taking, and trailing stops. The strategy can be enhanced with continuous position signals for visual feedback on the current trading state.
## Key Features
### General Settings
- **Trading Direction**: Choose to trade long positions only, short positions only, or both.
- **Max Trades Per Day**: Limit the number of trades per day to prevent overtrading.
- **Bars Between Trades**: Enforce a minimum number of bars between consecutive trades.
### Session Management
- **Session Control**: Restrict trading to specific times of the day.
- **Time Zone**: Specify the time zone for session calculations.
- **Expiration**: Optionally set a date when the strategy should stop executing.
### Contract Settings
- **Contract Type**: Select from common futures contracts (MNQ, MES, NQ, ES) or custom values.
- **Point Value**: Define the dollar value per point movement.
- **Tick Size**: Set the minimum price movement for accurate calculations.
### Visual Signals
- **Continuous Position Signals**: Implement 0 to 1 visual signals to track position states.
- **Signal Plotting**: Customize color and appearance of position signals.
- **Clear Visual Feedback**: Instantly see when entry conditions are triggered.
### Risk Management
#### Stop Loss and Take Profit
- **Risk Type**: Choose between percentage-based, ATR-based, or points-based risk management.
- **Percentage Mode**: Set SL/TP as a percentage of entry price.
- **ATR Mode**: Set SL/TP as a multiple of the Average True Range.
- **Points Mode**: Set SL/TP as a fixed number of points from entry.
#### Advanced Exit Features
- **Break-Even**: Automatically move stop-loss to break-even after reaching specified profit threshold.
- **Trailing Stop**: Implement a trailing stop-loss that follows price movement at a defined distance.
- **Partial Profit Taking**: Take partial profits at predetermined price levels:
- Set first partial exit point and percentage of position to close
- Set second partial exit point and percentage of position to close
- **Time-Based Exit**: Automatically exit a position after a specified number of bars.
#### Win/Loss Streak Management
- **Streak Cutoff**: Automatically pause trading after a series of consecutive wins or losses.
- **Daily Reset**: Option to reset streak counters at the start of each day.
### Entry Conditions
- **Source and Value**: Define the exact price source and value that triggers entries.
- **Equals Condition**: Entry signals occur when the source exactly matches the specified value.
### Performance Analytics
- **Real-Time Stats**: Track important performance metrics like win rate, P&L, and largest wins/losses.
- **Visual Feedback**: On-chart markers for entries, exits, and important events.
### External Integration
- **Webhook Support**: Compatible with TradingView's webhook alerts for automated trading.
- **Cross-Platform**: Connect to external trading systems and notification platforms.
- **Custom Order Execution**: Implement advanced order flows through external services.
## How to Use
### Setup Instructions
1. Add the script to your TradingView chart.
2. Configure the general settings based on your trading preferences.
3. Set session trading hours if you only want to trade specific times.
4. Select your contract specifications or customize for your instrument.
5. Configure risk parameters:
- Choose your preferred risk management approach
- Set appropriate stop-loss and take-profit levels
- Enable advanced features like break-even, trailing stops, or partial profit taking as needed
6. Define entry conditions:
- Select the price source (such as close, open, high, or an indicator)
- Set the specific value that should trigger entries
### Entry Condition Examples
- **Example 1**: To enter when price closes exactly at a whole number:
- Long Source: close
- Long Value: 4200 (for instance, to enter when price closes exactly at 4200)
- **Example 2**: To enter when an indicator reaches a specific value:
- Long Source: ta.rsi(close, 14)
- Long Value: 30 (triggers when RSI equals exactly 30)
### Best Practices
1. **Always backtest thoroughly** before using in live trading.
2. **Start with conservative risk settings**:
- Small position sizes
- Reasonable stop-loss distances
- Limited trades per day
3. **Monitor and adjust**:
- Use the performance table to track results
- Adjust parameters based on how the strategy performs
4. **Consider market volatility**:
- Use ATR-based stops during volatile periods
- Use fixed points during stable markets
## Continuous Position Signals Implementation
The LongShortExit strategy can be enhanced with continuous position signals to provide visual feedback about the current position state. These signals can help you track when the strategy is in a long or short position.
### Adding Continuous Position Signals
Add the following code to implement continuous position signals (0 to 1):
```pine
// Continuous position signals (0 to 1)
var float longSignal = 0.0
var float shortSignal = 0.0
// Update position signals based on your indicator's conditions
longSignal := longCondition ? 1.0 : 0.0
shortSignal := shortCondition ? 1.0 : 0.0
// Plot continuous signals
plot(longSignal, title="Long Signal", color=#00FF00, linewidth=2, transp=0, style=plot.style_line)
plot(shortSignal, title="Short Signal", color=#FF0000, linewidth=2, transp=0, style=plot.style_line)
```
### Benefits of Continuous Position Signals
- Provides clear visual feedback of current position state (long/short)
- Signal values stay consistent (0 or 1) until condition changes
- Can be used for additional calculations or alert conditions
- Makes it easier to track when entry conditions are triggered
### Using with Custom Indicators
You can adapt the continuous position signals to work with any custom indicator by replacing the condition with your indicator's logic:
```pine
// Example with moving average crossover
longSignal := fastMA > slowMA ? 1.0 : 0.0
shortSignal := fastMA < slowMA ? 1.0 : 0.0
```
## Webhook Integration
The LongShortExit strategy is fully compatible with TradingView's webhook alerts, allowing you to connect your strategy to external trading platforms, brokers, or custom applications for automated trading execution.
### Setting Up Webhooks
1. Create an alert on your chart with the LongShortExit strategy
2. Enable the "Webhook URL" option in the alert dialog
3. Enter your webhook endpoint URL (from your broker or custom trading system)
4. Customize the alert message with relevant information using TradingView variables
### Webhook Message Format Example
```json
{
"strategy": "LongShortExit",
"action": "{{strategy.order.action}}",
"price": "{{strategy.order.price}}",
"quantity": "{{strategy.position_size}}",
"time": "{{time}}",
"ticker": "{{ticker}}",
"position_size": "{{strategy.position_size}}",
"position_value": "{{strategy.position_value}}",
"order_id": "{{strategy.order.id}}",
"order_comment": "{{strategy.order.comment}}"
}
```
### TradingView Alert Condition Examples
For effective webhook automation, set up these alert conditions:
#### Entry Alert
```
{{strategy.position_size}} != {{strategy.position_size}}
```
#### Exit Alert
```
{{strategy.position_size}} < {{strategy.position_size}} or {{strategy.position_size}} > {{strategy.position_size}}
```
#### Partial Take Profit Alert
```
strategy.order.comment contains "Partial TP"
```
### Benefits of Webhook Integration
- **Automated Trading**: Execute trades automatically through supported brokers
- **Cross-Platform**: Connect to custom trading bots and applications
- **Real-Time Notifications**: Receive trade signals on external platforms
- **Data Collection**: Log trade data for further analysis
- **Custom Order Management**: Implement advanced order types not available in TradingView
### Compatible External Applications
- Trading bots and algorithmic trading software
- Custom order execution systems
- Discord, Telegram, or Slack notification systems
- Trade journaling applications
- Risk management platforms
### Implementation Recommendations
- Test webhook delivery using a free service like webhook.site before connecting to your actual trading system
- Include authentication tokens or API keys in your webhook URL or payload when required by your external service
- Consider implementing confirmation mechanisms to verify trade execution
- Log all webhook activities for troubleshooting and performance tracking
## Strategy Customization Tips
### For Scalping
- Set smaller profit targets (1-3 points)
- Use tighter stop-losses
- Enable break-even feature after small profit
- Set higher max trades per day
### For Day Trading
- Use moderate profit targets
- Implement partial profit taking
- Enable trailing stops
- Set reasonable session trading hours
### For Swing Trading
- Use longer-term charts
- Set wider stops (ATR-based often works well)
- Use higher profit targets
- Disable daily streak reset
## Common Troubleshooting
### Low Win Rate
- Consider widening stop-losses
- Verify that entry conditions aren't triggering too frequently
- Check if the equals condition is too restrictive; consider small tolerances
### Missing Obvious Trades
- The equals condition is extremely precise. Price must exactly match the specified value.
- Consider using floating-point precision for more reliable triggers
### Frequent Stop-Outs
- Try ATR-based stops instead of fixed points
- Increase the stop-loss distance
- Enable break-even feature to protect profits
## Important Notes
- The exact equals condition is strict and may result in fewer trade signals compared to other conditions.
- For instruments with decimal prices, exact equality might be rare. Consider the precision of your value.
- Break-even and trailing stop calculations are based on points, not percentage.
- Partial take-profit levels are defined in points distance from entry.
- The continuous position signals (0 to 1) provide valuable visual feedback but don't affect the strategy's trading logic directly.
- When implementing continuous signals, ensure they're aligned with the actual entry conditions used by the strategy.
---
*This strategy is for educational and informational purposes only. Always test thoroughly before using with real funds.*
