Magic Touch Line DetectorSummary of the Magic Touch Line Detector Script:
Purpose:
The Magic Touch Line Detector script is designed to identify significant price points in the market by analyzing candlestick wicks and bodies. It plots lines based on the detected wicks, classifying them as either ascending or descending. The script tracks how frequently price touches these lines and highlights the "most touched" lines for both ascending and descending categories. This script is particularly useful for traders looking to identify key price levels and trends over time.
How It Works:
Wick and Body Detection:
The script starts by analyzing the highs and lows of candlestick wicks relative to their bodies over a user-defined lookback period. A significant wick is identified based on a specified wick-to-body ratio and a deviation threshold measured against the Average True Range (ATR).
Line Creation:
Once a significant upper or lower wick is detected, the script calculates unconventional highs and lows (i.e., points that differ from the absolute highs and lows of the lookback period). Lines are then drawn from these unconventional price points using the slope between the detected wick and the current bar, ensuring a smooth extension.
Line Refinement and Touch Tracking:
As new bars are added, the script tracks how often the price touches the previously drawn lines. The number of touches each line receives is counted and updated in real-time, and the script ensures that only the most touched line is highlighted.
Highlighting and Labeling:
For each category (ascending and descending), the most touched line is identified and given special highlighting with thicker lines and different colors. Labels are also generated to show the number of touches that the most touched line has received. Old labels are cleared to avoid clutter.
Explanation of the Settings:
Lookback Period for Highs and Lows:
This sets the number of bars the script will use to detect the highest highs and lowest lows. A larger lookback period gives the script a broader context to work with, potentially identifying more significant price points.
Minimum Wick-to-Body Ratio:
This ratio determines what qualifies as a "significant" wick. It compares the length of the wick to the body of the candle. A higher ratio means that only wicks that are much longer than the candle body will be considered significant.
Price Deviation Threshold (in ATR multiples):
This setting controls how much price deviation from the ATR is required for a wick to be deemed significant. It acts as a filter to reduce noise by ignoring smaller wicks that are within normal price movements.
Line Touch Tolerance Factor (ATR multiple):
When checking if a price touches a line, the script uses this setting to define how close the price must be to the line to count as a "touch." This tolerance is a multiplier of the ATR, allowing for some flexibility in what is considered a touch.
Price Difference Threshold:
This defines the minimum price difference required to plot a line. If the price difference between the high and low of a detected wick is too small, the script can avoid plotting a line for insignificant moves.
Slope Adjustment Multiplier:
This multiplier adjusts the slope of the lines that are drawn from detected price points. It affects the length and angle of the lines, allowing users to control how far and at what angle the lines should extend across the chart.
Customization Options:
Show Ascending/Descending Lines:
These toggles allow users to decide whether ascending (bullish) or descending (bearish) lines should be shown on the chart.
Line Color, Style, and Width (for Ascending and Descending Lines):
These settings give users control over how the lines appear visually. You can customize the color, style (solid, dashed, dotted), and width of both ascending and descending lines.
Most Touched Line Color:
Users can define a different color for the "most touched" line, which is automatically identified by the script. This setting helps highlight the line that has been interacted with the most by the price.
How to Use the Script:
Setup the Lookback Period and Deviation Filters:
Start by setting the lookback period and the filters for wick-to-body ratio and deviation threshold. These settings help control the script's sensitivity to market movements.
Refine the Tolerance and Slope:
Adjust the line touch tolerance and slope adjustment multiplier to control how closely the script tracks price touches and how the lines are extended on the chart.
Customize Visuals:
Once the lines are being drawn, customize the colors, styles, and widths to ensure the lines are easy to read on your chart. You can also decide if you want to display both ascending and descending lines or focus on just one.
By setting up the script based on these inputs and parameters, you can get a real-time view of significant price levels and how often the price interacts with them, helping you make more informed trading decisions.
Cerca negli script per "track"
DRIP Yearly PerformanceOverview: The DRIP Yearly Performance indicator is designed for long-term investors using Dividend Reinvestment Plans (DRIP). This script calculates both the total and average yearly performance of an asset, factoring in the reinvestment of dividends over time. It provides key insights into portfolio growth by tracking the number of accumulated units from dividend reinvestment and how this impacts overall performance.
Key Features:
Dividend Reinvestment (DRIP) Calculation: Automatically adjusts the number of units held by reinvesting dividends, enhancing the calculation of total returns.
Custom Start Date: Choose a custom start date to begin tracking performance from a specific time period, allowing for more tailored performance analysis.
Performance Metrics: Displays key metrics such as the initial investment value, current value, total performance percentage, and the average yearly performance, all in an easy-to-read table format.
Visual Representation: Plots accumulated units and overall performance on the chart, with customizable colors for clarity.
Inputs Explained:
Start Quantity: Define the initial number of units (shares) held at the start of the investment.
Dividend Type: Choose between tracking Net or Gross dividends for reinvestment purposes. Net is always better unless you have a special case and you need to base your calculations on gross.
Start Date: Select a custom date to begin tracking performance. This allows users to focus on performance from any historical point.
Table Size: Customize the size of the text in the performance table to suit your visual preferences.
Performance Line Color: Choose the color of the performance plot line that tracks the value of your investment over time.
Accumulator Line Color: Customize the color of the line that tracks the accumulated units (shares) due to reinvested dividends.
Who Can Benefit: This indicator is ideal for long-term investors and dividend growth investors who want to measure their investment returns over time while factoring in the effects of dividend reinvestment.
Use Cases:
Tracking Dividend Impact: See how reinvesting dividends enhances your overall portfolio value.
Custom Performance Analysis: Set a custom start date to analyze performance from a specific point in time.
Visualizing Growth: Use the chart's plots to visually track your growing number of shares (units) and overall performance.
BK AK-SILENCER (P8N)🚨Introducing BK AK-SILENCER (P8N) — Institutional Order Flow Tracking for Silent Precision🚨
After months of meticulous tuning and refinement, I'm proud to unleash the next weapon in my trading arsenal—BK AK-SILENCER (P8N).
🔥 Why "AK-SILENCER"? The True Meaning
Institutions don’t announce their moves—they move silently, hidden beneath the noise. The SILENCER is built specifically to detect and track these stealth institutional maneuvers, giving you the power to hunt quietly, execute decisively, and strike precisely before the market catches on.
🔹 "AK" continues the legacy, honoring my mentor, A.K., whose teachings on discipline, precision, and clarity form the cornerstone of my trading.
🔹 "SILENCER" symbolizes the stealth aspect of institutional trading—quiet but deadly moves. This indicator equips you to silently track, expose, and capitalize on their hidden footprints.
🧠 What Exactly is BK AK-SILENCER (P8N)?
It's a next-generation Cumulative Volume Delta (CVD) tool crafted specifically for traders who hunt institutional order flow, combining adaptive volatility bands, enhanced momentum gradients, and precise divergence detection into a single deadly-accurate weapon.
Built for silent execution—tracking moves quietly and trading with lethal precision.
⚙️ Core Weapon Systems
✅ Institutional CVD Engine
→ Dynamically measures hidden volume shifts (buying/selling pressure) to reveal institutional footprints that price alone won't show.
✅ Adaptive AK-9 Bollinger Bands
→ Bollinger Bands placed around a custom CVD signal line, pinpointing exactly when institutional accumulation or distribution reaches critical extremes.
✅ Gradient Momentum Intelligence
→ Color-coded momentum gradients reveal the strength, speed, and silent intent behind institutional order flow:
🟢 Strong Bullish (aggressive buying)
🟡 Moderate Bullish (steady accumulation)
🔵 Neutral (balance)
🟠 Moderate Bearish (quiet distribution)
🔴 Strong Bearish (aggressive selling)
✅ Silent Divergence Detection
→ Instantly spots divergence between price and hidden volume—your earliest indication that institutions are stealthily reversing direction.
✅ Background Flash Alerts
→ Visually highlights institutional extremes through subtle background flashes, alerting you quietly yet powerfully when market-moving players make their silent moves.
✅ Structural & Institutional Clarity
→ Optional structural pivots, standard deviation bands, volume profile anchors, and session lines clearly identify the exact levels institutions defend or attack silently.
🛡️ Why BK AK-SILENCER (P8N) is Your Edge
🔹 Tracks Institutional Footprints—Silently identifies hidden volume signals of institutional intentions before they’re obvious.
🔹 Precision Execution—Cuts through noise, allowing you to execute silently, confidently, and precisely.
🔹 Perfect for Traders Using:
Elliott Wave
Gann Methods (Angles, Squares)
Fibonacci Time & Price
Harmonic Patterns
Market Profile & Order Flow Analysis
🎯 How to Use BK AK-SILENCER (P8N)
🔸 Institutional Reversal Hunting (Stealth Mode)
Bearish divergence + CVD breaking below lower BB → stealth short signal.
Bullish divergence + CVD breaking above upper BB → quiet, early long entry.
🔸 Momentum Confirmation (Silent Strength)
Strong bullish gradient + CVD above upper BB → follow institutional buying quietly.
Strong bearish gradient + CVD below lower BB → confidently short institutional selling.
🔸 Noise Filtering (Patience & Precision)
Neutral gradient (blue) → remain quiet, wait patiently to strike precisely when institutional activity resumes.
🔸 Structural Precision (Institutional Levels)
Optional StdDev, POC, Value Areas, Session Anchors clearly identify exact institutional defense/offense zones.
🙏 Final Thoughts
Institutions move in silence, leaving subtle footprints. BK AK-SILENCER (P8N) is your specialized weapon for tracking and hunting their quiet, decisive actions before the market reacts.
🔹 Dedicated in deep gratitude to my mentor, A.K.—whose silent wisdom shapes every line of code.
🔹 Engineered for the disciplined, quiet hunter who knows when to wait patiently and when to strike decisively.
Above all, honor and gratitude to Gd—the ultimate source of wisdom, clarity, and disciplined execution. Without Him, markets are chaos. With Him, we move silently, purposefully, and precisely.
⚡ Stay Quiet. Stay Precise. Hunt Silently.
🔥 BK AK-SILENCER (P8N) — Track the Silent Moves. Strike with Precision. 🔥
May Gd bless every silent step you take. 🙏
[FS] Time & Cycles Time & Cycles
A comprehensive trading session indicator that helps traders identify and track key market sessions and their price levels. This tool is particularly useful for forex and futures traders who need to monitor multiple trading sessions.
Key Features:
• Multiple Session Support:
- London Session
- New York Session
- Sydney Session
- Asia Session
- Customizable TBD Session
• Session Visualization:
- Clear session boxes with customizable colors
- Session labels with adjustable visibility
- Support for sessions crossing midnight
- Timezone-aware calculations
• Price Level Tracking:
- Daily High/Low levels
- Weekly High/Low levels
- Previous session High/Low levels
- Customizable history depth for each level type
• Customization Options:
- Adjustable colors for each session
- Customizable border styles
- Label visibility controls
- Timezone selection
- History level depth settings
• Technical Features:
- High-performance calculation engine
- Support for multiple timeframes
- Efficient memory usage
- Clean and intuitive visual display
Perfect for:
• Forex traders monitoring multiple sessions
• Futures traders tracking market hours
• Swing traders identifying key session levels
• Day traders planning their trading hours
• Market analysts studying session patterns
The indicator helps traders:
- Identify active trading sessions
- Track session-specific price levels
- Monitor market activity across different time zones
- Plan trades based on session boundaries
- Analyze price action within specific sessions
Note: This indicator is designed to work across all timeframes and is optimized for performance with minimal impact on chart loading times.
lib_smcLibrary "lib_smc"
This is an adaptation of LuxAlgo's Smart Money Concepts indicator with numerous changes. Main changes include integration of object based plotting, plenty of performance improvements, live tracking of Order Blocks, integration of volume profiles to refine Order Blocks, and many more.
This is a library for developers, if you want this converted into a working strategy, let me know.
buffer(item, len, force_rotate)
Parameters:
item (float)
len (int)
force_rotate (bool)
buffer(item, len, force_rotate)
Parameters:
item (int)
len (int)
force_rotate (bool)
buffer(item, len, force_rotate)
Parameters:
item (Profile type from robbatt/lib_profile/32)
len (int)
force_rotate (bool)
swings(len)
INTERNAL: detect swing points (HH and LL) in given range
Parameters:
len (simple int) : range to check for new swing points
Returns: values are the price level where and if a new HH or LL was detected, else na
method init(this)
Namespace types: OrderBlockConfig
Parameters:
this (OrderBlockConfig)
method delete(this)
Namespace types: OrderBlock
Parameters:
this (OrderBlock)
method clear_broken(this, broken_buffer)
INTERNAL: delete internal order blocks box coordinates if top/bottom is broken
Namespace types: map
Parameters:
this (map)
broken_buffer (map)
Returns: any_bull_ob_broken, any_bear_ob_broken, broken signals are true if an according order block was broken/mitigated, broken contains the broken block(s)
create_ob(id, mode, start_t, start_i, top, end_t, end_i, bottom, break_price, early_confirmation_price, config, init_plot, force_overlay)
INTERNAL: set internal order block coordinates
Parameters:
id (int)
mode (int) : 1: bullish, -1 bearish block
start_t (int)
start_i (int)
top (float)
end_t (int)
end_i (int)
bottom (float)
break_price (float)
early_confirmation_price (float)
config (OrderBlockConfig)
init_plot (bool)
force_overlay (bool)
Returns: signals are true if an according order block was broken/mitigated
method align_to_profile(block, align_edge, align_break_price)
Namespace types: OrderBlock
Parameters:
block (OrderBlock)
align_edge (bool)
align_break_price (bool)
method create_profile(block, opens, tops, bottoms, closes, values, resolution, vah_pc, val_pc, args, init_calculated, init_plot, force_overlay)
Namespace types: OrderBlock
Parameters:
block (OrderBlock)
opens (array)
tops (array)
bottoms (array)
closes (array)
values (array)
resolution (int)
vah_pc (float)
val_pc (float)
args (ProfileArgs type from robbatt/lib_profile/32)
init_calculated (bool)
init_plot (bool)
force_overlay (bool)
method create_profile(block, resolution, vah_pc, val_pc, args, init_calculated, init_plot, force_overlay)
Namespace types: OrderBlock
Parameters:
block (OrderBlock)
resolution (int)
vah_pc (float)
val_pc (float)
args (ProfileArgs type from robbatt/lib_profile/32)
init_calculated (bool)
init_plot (bool)
force_overlay (bool)
track_obs(swing_len, hh, ll, top, btm, bull_bos_alert, bull_choch_alert, bear_bos_alert, bear_choch_alert, min_block_size, max_block_size, config_bull, config_bear, init_plot, force_overlay, enabled, extend_blocks, clear_broken_buffer_before, align_edge_to_value_area, align_break_price_to_poc, profile_args_bull, profile_args_bear, use_soft_confirm, soft_confirm_offset, use_retracements_with_FVG_out)
Parameters:
swing_len (int)
hh (float)
ll (float)
top (float)
btm (float)
bull_bos_alert (bool)
bull_choch_alert (bool)
bear_bos_alert (bool)
bear_choch_alert (bool)
min_block_size (float)
max_block_size (float)
config_bull (OrderBlockConfig)
config_bear (OrderBlockConfig)
init_plot (bool)
force_overlay (bool)
enabled (bool)
extend_blocks (simple bool)
clear_broken_buffer_before (simple bool)
align_edge_to_value_area (simple bool)
align_break_price_to_poc (simple bool)
profile_args_bull (ProfileArgs type from robbatt/lib_profile/32)
profile_args_bear (ProfileArgs type from robbatt/lib_profile/32)
use_soft_confirm (simple bool)
soft_confirm_offset (float)
use_retracements_with_FVG_out (simple bool)
method draw(this, config, extend_only)
Namespace types: OrderBlock
Parameters:
this (OrderBlock)
config (OrderBlockConfig)
extend_only (bool)
method draw(blocks, config)
INTERNAL: plot order blocks
Namespace types: array
Parameters:
blocks (array)
config (OrderBlockConfig)
method draw(blocks, config)
INTERNAL: plot order blocks
Namespace types: map
Parameters:
blocks (map)
config (OrderBlockConfig)
method cleanup(this, ob_bull, ob_bear)
removes all Profiles that are older than the latest OrderBlock from this profile buffer
Namespace types: array
Parameters:
this (array type from robbatt/lib_profile/32)
ob_bull (OrderBlock)
ob_bear (OrderBlock)
_plot_swing_points(mode, x, y, show_swing_points, linecolor_swings, keep_history, show_latest_swings_levels, trail_x, trail_y, trend)
INTERNAL: plot swing points
Parameters:
mode (int) : 1: bullish, -1 bearish block
x (int) : x-coordingate of swing point to plot (bar_index)
y (float) : y-coordingate of swing point to plot (price)
show_swing_points (bool) : switch to enable/disable plotting of swing point labels
linecolor_swings (color) : color for swing point labels and lates level lines
keep_history (bool) : weater to remove older swing point labels and only keep the most recent
show_latest_swings_levels (bool)
trail_x (int) : x-coordinate for latest swing point (bar_index)
trail_y (float) : y-coordinate for latest swing point (price)
trend (int) : the current trend 1: bullish, -1: bearish, to determine Strong/Weak Low/Highs
_pivot_lvl(mode, trend, hhll_x, hhll, super_hhll, filter_insignificant_internal_breaks)
INTERNAL: detect whether a structural level has been broken and if it was in trend direction (BoS) or against trend direction (ChoCh), also track the latest high and low swing points
Parameters:
mode (simple int) : detect 1: bullish, -1 bearish pivot points
trend (int) : current trend direction
hhll_x (int) : x-coordinate of newly detected hh/ll (bar_index)
hhll (float) : y-coordinate of newly detected hh/ll (price)
super_hhll (float) : level/y-coordinate of superior hhll (if this is an internal structure pivot level)
filter_insignificant_internal_breaks (bool) : if true pivot points / internal structure will be ignored where the wick in trend direction is longer than the opposite (likely to push further in direction of main trend)
Returns: coordinates of internal structure that has been broken (x,y): start of structure, (trail_x, trail_y): tracking hh/ll after structure break, (bos_alert, choch_alert): signal whether a structural level has been broken
_plot_structure(x, y, is_bos, is_choch, line_color, line_style, label_style, label_size, keep_history)
INTERNAL: plot structural breaks (BoS/ChoCh)
Parameters:
x (int) : x-coordinate of newly broken structure (bar_index)
y (float) : y-coordinate of newly broken structure (price)
is_bos (bool) : whether this structural break was in trend direction
is_choch (bool) : whether this structural break was against trend direction
line_color (color) : color for the line connecting the structural level and the breaking candle
line_style (string) : style (line.style_dashed/solid) for the line connecting the structural level and the breaking candle
label_style (string) : style (label.style_label_down/up) for the label above/below the line connecting the structural level and the breaking candle
label_size (string) : size (size.small/tiny) for the label above/below the line connecting the structural level and the breaking candle
keep_history (bool) : weater to remove older swing point labels and only keep the most recent
structure_values(length, super_hh, super_ll, filter_insignificant_internal_breaks)
detect (and plot) structural breaks and the resulting new trend
Parameters:
length (simple int) : lookback period for swing point detection
super_hh (float) : level/y-coordinate of superior hh (for internal structure detection)
super_ll (float) : level/y-coordinate of superior ll (for internal structure detection)
filter_insignificant_internal_breaks (bool) : if true pivot points / internal structure will be ignored where the wick in trend direction is longer than the opposite (likely to push further in direction of main trend)
Returns: trend: direction 1:bullish -1:bearish, (bull_bos_alert, bull_choch_alert, top_x, top_y, trail_up_x, trail_up): whether and which level broke in a bullish direction, trailing high, (bbear_bos_alert, bear_choch_alert, tm_x, btm_y, trail_dn_x, trail_dn): same in bearish direction
structure_plot(trend, bull_bos_alert, bull_choch_alert, top_x, top_y, trail_up_x, trail_up, hh, bear_bos_alert, bear_choch_alert, btm_x, btm_y, trail_dn_x, trail_dn, ll, color_bull, color_bear, show_swing_points, show_latest_swings_levels, show_bos, show_choch, line_style, label_size, keep_history)
detect (and plot) structural breaks and the resulting new trend
Parameters:
trend (int) : crrent trend 1: bullish, -1: bearish
bull_bos_alert (bool) : if there was a bullish bos alert -> plot it
bull_choch_alert (bool) : if there was a bullish choch alert -> plot it
top_x (int) : latest shwing high x
top_y (float) : latest swing high y
trail_up_x (int) : trailing high x
trail_up (float) : trailing high y
hh (float) : if there was a higher high
bear_bos_alert (bool) : if there was a bearish bos alert -> plot it
bear_choch_alert (bool) : if there was a bearish chock alert -> plot it
btm_x (int) : latest swing low x
btm_y (float) : latest swing low y
trail_dn_x (int) : trailing low x
trail_dn (float) : trailing low y
ll (float) : if there was a lower low
color_bull (color) : color for bullish BoS/ChoCh levels
color_bear (color) : color for bearish BoS/ChoCh levels
show_swing_points (bool) : whether to plot swing point labels
show_latest_swings_levels (bool) : whether to track and plot latest swing point levels with lines
show_bos (bool) : whether to plot BoS levels
show_choch (bool) : whether to plot ChoCh levels
line_style (string) : whether to plot BoS levels
label_size (string) : label size of plotted BoS/ChoCh levels
keep_history (bool) : weater to remove older swing point labels and only keep the most recent
structure(length, color_bull, color_bear, super_hh, super_ll, filter_insignificant_internal_breaks, show_swing_points, show_latest_swings_levels, show_bos, show_choch, line_style, label_size, keep_history, enabled)
detect (and plot) structural breaks and the resulting new trend
Parameters:
length (simple int) : lookback period for swing point detection
color_bull (color) : color for bullish BoS/ChoCh levels
color_bear (color) : color for bearish BoS/ChoCh levels
super_hh (float) : level/y-coordinate of superior hh (for internal structure detection)
super_ll (float) : level/y-coordinate of superior ll (for internal structure detection)
filter_insignificant_internal_breaks (bool) : if true pivot points / internal structure will be ignored where the wick in trend direction is longer than the opposite (likely to push further in direction of main trend)
show_swing_points (bool) : whether to plot swing point labels
show_latest_swings_levels (bool) : whether to track and plot latest swing point levels with lines
show_bos (bool) : whether to plot BoS levels
show_choch (bool) : whether to plot ChoCh levels
line_style (string) : whether to plot BoS levels
label_size (string) : label size of plotted BoS/ChoCh levels
keep_history (bool) : weater to remove older swing point labels and only keep the most recent
enabled (bool)
_check_equal_level(mode, len, eq_threshold, enabled)
INTERNAL: detect equal levels (double top/bottom)
Parameters:
mode (int) : detect 1: bullish/high, -1 bearish/low pivot points
len (int) : lookback period for equal level (swing point) detection
eq_threshold (float) : maximum price offset for a level to be considered equal
enabled (bool)
Returns: eq_alert whether an equal level was detected and coordinates of the first and the second level/swing point
_plot_equal_level(show_eq, x1, y1, x2, y2, label_txt, label_style, label_size, line_color, line_style, keep_history)
INTERNAL: plot equal levels (double top/bottom)
Parameters:
show_eq (bool) : whether to plot the level or not
x1 (int) : x-coordinate of the first level / swing point
y1 (float) : y-coordinate of the first level / swing point
x2 (int) : x-coordinate of the second level / swing point
y2 (float) : y-coordinate of the second level / swing point
label_txt (string) : text for the label above/below the line connecting the equal levels
label_style (string) : style (label.style_label_down/up) for the label above/below the line connecting the equal levels
label_size (string) : size (size.tiny) for the label above/below the line connecting the equal levels
line_color (color) : color for the line connecting the equal levels (and it's label)
line_style (string) : style (line.style_dotted) for the line connecting the equal levels
keep_history (bool) : weater to remove older swing point labels and only keep the most recent
equal_levels_values(len, threshold, enabled)
detect (and plot) equal levels (double top/bottom), returns coordinates
Parameters:
len (int) : lookback period for equal level (swing point) detection
threshold (float) : maximum price offset for a level to be considered equal
enabled (bool) : whether detection is enabled
Returns: (eqh_alert, eqh_x1, eqh_y1, eqh_x2, eqh_y2) whether an equal high was detected and coordinates of the first and the second level/swing point, (eql_alert, eql_x1, eql_y1, eql_x2, eql_y2) same for equal lows
equal_levels_plot(eqh_x1, eqh_y1, eqh_x2, eqh_y2, eql_x1, eql_y1, eql_x2, eql_y2, color_eqh, color_eql, show, keep_history)
detect (and plot) equal levels (double top/bottom), returns coordinates
Parameters:
eqh_x1 (int) : coordinates of first point of equal high
eqh_y1 (float) : coordinates of first point of equal high
eqh_x2 (int) : coordinates of second point of equal high
eqh_y2 (float) : coordinates of second point of equal high
eql_x1 (int) : coordinates of first point of equal low
eql_y1 (float) : coordinates of first point of equal low
eql_x2 (int) : coordinates of second point of equal low
eql_y2 (float) : coordinates of second point of equal low
color_eqh (color) : color for the line connecting the equal highs (and it's label)
color_eql (color) : color for the line connecting the equal lows (and it's label)
show (bool) : whether plotting is enabled
keep_history (bool) : weater to remove older swing point labels and only keep the most recent
Returns: (eqh_alert, eqh_x1, eqh_y1, eqh_x2, eqh_y2) whether an equal high was detected and coordinates of the first and the second level/swing point, (eql_alert, eql_x1, eql_y1, eql_x2, eql_y2) same for equal lows
equal_levels(len, threshold, color_eqh, color_eql, enabled, show, keep_history)
detect (and plot) equal levels (double top/bottom)
Parameters:
len (int) : lookback period for equal level (swing point) detection
threshold (float) : maximum price offset for a level to be considered equal
color_eqh (color) : color for the line connecting the equal highs (and it's label)
color_eql (color) : color for the line connecting the equal lows (and it's label)
enabled (bool) : whether detection is enabled
show (bool) : whether plotting is enabled
keep_history (bool) : weater to remove older swing point labels and only keep the most recent
Returns: (eqh_alert) whether an equal high was detected, (eql_alert) same for equal lows
_detect_fvg(mode, enabled, o, h, l, c, filter_insignificant_fvgs, change_tf)
INTERNAL: detect FVG (fair value gap)
Parameters:
mode (int) : detect 1: bullish, -1 bearish gaps
enabled (bool) : whether detection is enabled
o (float) : reference source open
h (float) : reference source high
l (float) : reference source low
c (float) : reference source close
filter_insignificant_fvgs (bool) : whether to calculate and filter small/insignificant gaps
change_tf (bool) : signal when the previous reference timeframe closed, triggers new calculation
Returns: whether a new FVG was detected and its top/mid/bottom levels
_clear_broken_fvg(mode, upper_boxes, lower_boxes)
INTERNAL: clear mitigated FVGs (fair value gaps)
Parameters:
mode (int) : detect 1: bullish, -1 bearish gaps
upper_boxes (array) : array that stores the upper parts of the FVG boxes
lower_boxes (array) : array that stores the lower parts of the FVG boxes
_plot_fvg(mode, show, top, mid, btm, border_color, extend_box)
INTERNAL: plot (and clear broken) FVG (fair value gap)
Parameters:
mode (int) : plot 1: bullish, -1 bearish gap
show (bool) : whether plotting is enabled
top (float) : top level of fvg
mid (float) : center level of fvg
btm (float) : bottom level of fvg
border_color (color) : color for the FVG box
extend_box (int) : how many bars into the future the FVG box should be extended after detection
fvgs_values(o, h, l, c, filter_insignificant_fvgs, change_tf, enabled)
detect (and plot / clear broken) FVGs (fair value gaps), and return alerts and level values
Parameters:
o (float) : reference source open
h (float) : reference source high
l (float) : reference source low
c (float) : reference source close
filter_insignificant_fvgs (bool) : whether to calculate and filter small/insignificant gaps
change_tf (bool) : signal when the previous reference timeframe closed, triggers new calculation
enabled (bool) : whether detection is enabled
Returns: (bullish_fvg_alert, bull_top, bull_mid, bull_btm): whether a new bullish FVG was detected and its top/mid/bottom levels, (bearish_fvg_alert, bear_top, bear_mid, bear_btm): same for bearish FVGs
fvgs_plot(bullish_fvg_alert, bull_top, bull_mid, bull_btm, bearish_fvg_alert, bear_top, bear_mid, bear_btm, color_bull, color_bear, extend_box, show)
Parameters:
bullish_fvg_alert (bool)
bull_top (float)
bull_mid (float)
bull_btm (float)
bearish_fvg_alert (bool)
bear_top (float)
bear_mid (float)
bear_btm (float)
color_bull (color) : color for bullish FVG boxes
color_bear (color) : color for bearish FVG boxes
extend_box (int) : how many bars into the future the FVG box should be extended after detection
show (bool) : whether plotting is enabled
Returns: (bullish_fvg_alert, bull_top, bull_mid, bull_btm): whether a new bullish FVG was detected and its top/mid/bottom levels, (bearish_fvg_alert, bear_top, bear_mid, bear_btm): same for bearish FVGs
fvgs(o, h, l, c, filter_insignificant_fvgs, change_tf, color_bull, color_bear, extend_box, enabled, show)
detect (and plot / clear broken) FVGs (fair value gaps)
Parameters:
o (float) : reference source open
h (float) : reference source high
l (float) : reference source low
c (float) : reference source close
filter_insignificant_fvgs (bool) : whether to calculate and filter small/insignificant gaps
change_tf (bool) : signal when the previous reference timeframe closed, triggers new calculation
color_bull (color) : color for bullish FVG boxes
color_bear (color) : color for bearish FVG boxes
extend_box (int) : how many bars into the future the FVG box should be extended after detection
enabled (bool) : whether detection is enabled
show (bool) : whether plotting is enabled
Returns: (bullish_fvg_alert): whether a new bullish FVG was detected, (bearish_fvg_alert): same for bearish FVGs
OrderBlock
Fields:
id (series int)
dir (series int)
left_top (chart.point)
right_bottom (chart.point)
break_price (series float)
early_confirmation_price (series float)
ltf_high (array)
ltf_low (array)
ltf_volume (array)
plot (Box type from robbatt/lib_plot_objects/49)
profile (Profile type from robbatt/lib_profile/32)
trailing (series bool)
extending (series bool)
awaiting_confirmation (series bool)
touched_break_price_before_confirmation (series bool)
soft_confirmed (series bool)
has_fvg_out (series bool)
hidden (series bool)
broken (series bool)
OrderBlockConfig
Fields:
show (series bool)
show_last (series int)
show_id (series bool)
show_profile (series bool)
args (BoxArgs type from robbatt/lib_plot_objects/49)
txt (series string)
txt_args (BoxTextArgs type from robbatt/lib_plot_objects/49)
delete_when_broken (series bool)
broken_args (BoxArgs type from robbatt/lib_plot_objects/49)
broken_txt (series string)
broken_txt_args (BoxTextArgs type from robbatt/lib_plot_objects/49)
broken_profile_args (ProfileArgs type from robbatt/lib_profile/32)
use_profile (series bool)
profile_args (ProfileArgs type from robbatt/lib_profile/32)
☑️VMA Win % Dashboard for Different LengthsVMA Win % Dashboard for Different Lengths
Overview
This Pine Script indicator evaluates the performance of a Variable Moving Average (VMA) for lengths 13 to 17. It tracks the success rate of price hitting target levels during bullish or bearish trends and displays results in a table. It is part of a combination that includes two other indicators: ✅ VMA Avg ATR + Days to Targets Total Improved 🎯 and 📊 Visual MTF VMA Dashboard🔄️.
How It Works
1. Inputs:
- ATR Length: 14 periods (for volatility).
- VMA Lengths: 13, 14, 15, 16, 17.
2. VMA Calculation:
- Uses closing price.
- Measures price increases (pdm) and decreases (mdm).
- Smooths data to calculate a Directional Movement Index (DMI).
- Adjusts VMA based on momentum and volatility.
3. Trend Detection:
- Bullish: VMA rises (green).
- Bearish: VMA falls (red).
- Neutral: No direction (white).
- Confirms trends align with daily and 195-minute timeframes.
4. Performance Tracking:
- Trend Start: Records price, ATR, and time when a trend begins.
- Price Movement: Tracks highest (bullish) or lowest (bearish) price.
- Targets:
---- T1: Starting price ± historical average movement (ATR-based).
---- T2: Starting price ± 6x ATR.
- Statistics:
---- Counts hits (reached T1/T2) and misses (didn’t reach T1).
---- Calculates win percentages: % of trends hitting T1.
5. Dashboard:
- Table with columns: VMA Length, Win % Up, Win % Down.
- Shows win percentages for each length (e.g., 75.23%).
Use Cases
- Trend Trading: Confirms trend direction and success rate.
- Optimization: Finds the best VMA length.
- Risk Management: Sets ATR-based trade targets.
- Combination: Complements ✅ VMA Avg ATR + Days to Targets Total Improved 🎯 and 📊 Visual MTF VMA Dashboard🔄️ for a complete strategy.
Example
- VMA 15: 80% Win Up, 55% Win Down → Best for bullish trades.
- VMA 13: 75% Win Up, 60% Win Down → More balanced.
Limitations
- Based on historical data, not future predictions.
- Only analyzes trends aligned with higher timeframes.
- No VMA lines or signals plotted on the chart.
Candle Range Detector by TradeTech AnalysisCandle Range Detector by TradeTech Analysis
This advanced indicator identifies and visualizes price compression zones based on inside bar formations, then tracks how price behaves around those zones — offering valuable insights into liquidity sweeps, range expansions, and trap/mitigation behavior.
The script builds upon the foundational concept of range-based price action, commonly used by institutional traders, and adds automation, mitigation tracking, and sweep detection to map how price reacts around these critical ranges.
🔍 How It Works:
• Range Formation: A new range is detected when the current candle forms entirely within the high and low of the previous candle (i.e., an inside bar). This behavior often indicates price compression and potential breakout zones.
• Range Extension: Once a range is confirmed, the script projects upper and lower boundaries (using either a percentage-based multiplier or Fibonacci log extension), providing context for expected breakout zones.
• Mitigation Tracking: The script continuously monitors whether price breaks above or below the projected extensions, marking that range as mitigated — useful for confirming whether liquidity was absorbed.
• Sweep Detection: If price re-visits a mitigated zone and shows signs of a liquidity sweep (via wick + close behavior), the indicator triggers visual sweep labels and optional alerts.
🧠 Optional Visual Enhancements:
• Highlight range-forming candles with light blue background (toggle on/off)
• Midpoint dotted line for symmetry analysis
• Labels for “Range High” and “Range Low” for visual clarity
• Dynamic box drawing that adapts upon mitigation or continuation
⚙️ Customizable Features:
• Choose between Normal and Fibonacci-based detection modes
• Toggle visibility of range boxes, extension lines, and sweep markers
• Configure sweep alerts, mitigation window size, and visual transparency
⸻
🧪 Use Cases
• Identify consolidation zones before major price moves
• Confirm liquidity sweeps for entry/exit traps
• Visualize and test mitigation behavior of past zones
• Combine with Order Flow or Volume Profile tools to enhance context
⸻
⚠️ This is a fully original implementation that goes beyond classical inside-bar scanners by incorporating mitigation, extension projection, and liquidity sweeps — making it a powerful tool for intraday, swing, and even Smart Money-based trading setups.
Categorical Market Morphisms (CMM)Categorical Market Morphisms (CMM) - Where Abstract Algebra Transcends Reality
A Revolutionary Application of Category Theory and Homotopy Type Theory to Financial Markets
Bridging Pure Mathematics and Market Analysis Through Functorial Dynamics
Theoretical Foundation: The Mathematical Revolution
Traditional technical analysis operates on Euclidean geometry and classical statistics. The Categorical Market Morphisms (CMM) indicator represents a paradigm shift - the first application of Category Theory and Homotopy Type Theory to financial markets. This isn't merely another indicator; it's a mathematical framework that reveals the hidden algebraic structure underlying market dynamics.
Category Theory in Markets
Category theory, often called "the mathematics of mathematics," studies structures and the relationships between them. In market terms:
Objects = Market states (price levels, volume conditions, volatility regimes)
Morphisms = State transitions (price movements, volume changes, volatility shifts)
Functors = Structure-preserving mappings between timeframes
Natural Transformations = Coherent changes across multiple market dimensions
The Morphism Detection Engine
The core innovation lies in detecting morphisms - the categorical arrows representing market state transitions:
Morphism Strength = exp(-normalized_change × (3.0 / sensitivity))
Threshold = 0.3 - (sensitivity - 1.0) × 0.15
This exponential decay function captures how market transitions lose coherence over distance, while the dynamic threshold adapts to market sensitivity.
Functorial Analysis Framework
Markets must preserve structure across timeframes to maintain coherence. Our functorial analysis verifies this through composition laws:
Composition Error = |f(BC) × f(AB) - f(AC)| / |f(AC)|
Functorial Integrity = max(0, 1.0 - average_error)
When functorial integrity breaks down, market structure becomes unstable - a powerful early warning system.
Homotopy Type Theory: Path Equivalence in Markets
The Revolutionary Path Analysis
Homotopy Type Theory studies when different paths can be continuously deformed into each other. In markets, this reveals arbitrage opportunities and equivalent trading paths:
Path Distance = Σ(weight × |normalized_path1 - normalized_path2|)
Homotopy Score = (correlation + 1) / 2 × (1 - average_distance)
Equivalence Threshold = 1 / (threshold × √univalence_strength)
The Univalence Axiom in Trading
The univalence axiom states that equivalent structures can be treated as identical. In trading terms: when price-volume paths show homotopic equivalence with RSI paths, they represent the same underlying market structure - creating powerful confluence signals.
Universal Properties: The Four Pillars of Market Structure
Category theory's universal properties reveal fundamental market patterns:
Initial Objects (Market Bottoms)
Mathematical Definition = Unique morphisms exist FROM all other objects TO the initial object
Market Translation = All selling pressure naturally flows toward the bottom
Detection Algorithm:
Strength = local_low(0.3) + oversold(0.2) + volume_surge(0.2) + momentum_reversal(0.2) + morphism_flow(0.1)
Signal = strength > 0.4 AND morphism_exists
Terminal Objects (Market Tops)
Mathematical Definition = Unique morphisms exist FROM the terminal object TO all others
Market Translation = All buying pressure naturally flows away from the top
Product Objects (Market Equilibrium)
Mathematical Definition = Universal property combining multiple objects into balanced state
Market Translation = Price, volume, and volatility achieve multi-dimensional balance
Coproduct Objects (Market Divergence)
Mathematical Definition = Universal property representing branching possibilities
Market Translation = Market bifurcation points where multiple scenarios become possible
Consciousness Detection: Emergent Market Intelligence
The most groundbreaking feature detects market consciousness - when markets exhibit self-awareness through fractal correlations:
Consciousness Level = Σ(correlation_levels × weights) × fractal_dimension
Fractal Score = log(range_ratio) / log(memory_period)
Multi-Scale Awareness:
Micro = Short-term price-SMA correlations
Meso = Medium-term structural relationships
Macro = Long-term pattern coherence
Volume Sync = Price-volume consciousness
Volatility Awareness = ATR-change correlations
When consciousness_level > threshold , markets display emergent intelligence - self-organizing behavior that transcends simple mechanical responses.
Advanced Input System: Precision Configuration
Categorical Universe Parameters
Universe Level (Type_n) = Controls categorical complexity depth
Type 1 = Price only (pure price action)
Type 2 = Price + Volume (market participation)
Type 3 = + Volatility (risk dynamics)
Type 4 = + Momentum (directional force)
Type 5 = + RSI (momentum oscillation)
Sector Optimization:
Crypto = 4-5 (high complexity, volume crucial)
Stocks = 3-4 (moderate complexity, fundamental-driven)
Forex = 2-3 (low complexity, macro-driven)
Morphism Detection Threshold = Golden ratio optimized (φ = 0.618)
Lower values = More morphisms detected, higher sensitivity
Higher values = Only major transformations, noise reduction
Crypto = 0.382-0.618 (high volatility accommodation)
Stocks = 0.618-1.0 (balanced detection)
Forex = 1.0-1.618 (macro-focused)
Functoriality Tolerance = φ⁻² = 0.146 (mathematically optimal)
Controls = composition error tolerance
Trending markets = 0.1-0.2 (strict structure preservation)
Ranging markets = 0.2-0.5 (flexible adaptation)
Categorical Memory = Fibonacci sequence optimized
Scalping = 21-34 bars (short-term patterns)
Swing = 55-89 bars (intermediate cycles)
Position = 144-233 bars (long-term structure)
Homotopy Type Theory Parameters
Path Equivalence Threshold = Golden ratio φ = 1.618
Volatile markets = 2.0-2.618 (accommodate noise)
Normal conditions = 1.618 (balanced)
Stable markets = 0.786-1.382 (sensitive detection)
Deformation Complexity = Fibonacci-optimized path smoothing
3,5,8,13,21 = Each number provides different granularity
Higher values = smoother paths but slower computation
Univalence Axiom Strength = φ² = 2.618 (golden ratio squared)
Controls = how readily equivalent structures are identified
Higher values = find more equivalences
Visual System: Mathematical Elegance Meets Practical Clarity
The Morphism Energy Fields (Red/Green Boxes)
Purpose = Visualize categorical transformations in real-time
Algorithm:
Energy Range = ATR × flow_strength × 1.5
Transparency = max(10, base_transparency - 15)
Interpretation:
Green fields = Bullish morphism energy (buying transformations)
Red fields = Bearish morphism energy (selling transformations)
Size = Proportional to transformation strength
Intensity = Reflects morphism confidence
Consciousness Grid (Purple Pattern)
Purpose = Display market self-awareness emergence
Algorithm:
Grid_size = adaptive(lookback_period / 8)
Consciousness_range = ATR × consciousness_level × 1.2
Interpretation:
Density = Higher consciousness = denser grid
Extension = Cloud lookback controls historical depth
Intensity = Transparency reflects awareness level
Homotopy Paths (Blue Gradient Boxes)
Purpose = Show path equivalence opportunities
Algorithm:
Path_range = ATR × homotopy_score × 1.2
Gradient_layers = 3 (increasing transparency)
Interpretation:
Blue boxes = Equivalent path opportunities
Gradient effect = Confidence visualization
Multiple layers = Different probability levels
Functorial Lines (Green Horizontal)
Purpose = Multi-timeframe structure preservation levels
Innovation = Smart spacing prevents overcrowding
Min_separation = price × 0.001 (0.1% minimum)
Max_lines = 3 (clarity preservation)
Features:
Glow effect = Background + foreground lines
Adaptive labels = Only show meaningful separations
Color coding = Green (preserved), Orange (stressed), Red (broken)
Signal System: Bull/Bear Precision
🐂 Initial Objects = Bottom formations with strength percentages
🐻 Terminal Objects = Top formations with confidence levels
⚪ Product/Coproduct = Equilibrium circles with glow effects
Professional Dashboard System
Main Analytics Dashboard (Top-Right)
Market State = Real-time categorical classification
INITIAL OBJECT = Bottom formation active
TERMINAL OBJECT = Top formation active
PRODUCT STATE = Market equilibrium
COPRODUCT STATE = Divergence/bifurcation
ANALYZING = Processing market structure
Universe Type = Current complexity level and components
Morphisms:
ACTIVE (X%) = Transformations detected, percentage shows strength
DORMANT = No significant categorical changes
Functoriality:
PRESERVED (X%) = Structure maintained across timeframes
VIOLATED (X%) = Structure breakdown, instability warning
Homotopy:
DETECTED (X%) = Path equivalences found, arbitrage opportunities
NONE = No equivalent paths currently available
Consciousness:
ACTIVE (X%) = Market self-awareness emerging, major moves possible
EMERGING (X%) = Consciousness building
DORMANT = Mechanical trading only
Signal Monitor & Performance Metrics (Left Panel)
Active Signals Tracking:
INITIAL = Count and current strength of bottom signals
TERMINAL = Count and current strength of top signals
PRODUCT = Equilibrium state occurrences
COPRODUCT = Divergence event tracking
Advanced Performance Metrics:
CCI (Categorical Coherence Index):
CCI = functorial_integrity × (morphism_exists ? 1.0 : 0.5)
STRONG (>0.7) = High structural coherence
MODERATE (0.4-0.7) = Adequate coherence
WEAK (<0.4) = Structural instability
HPA (Homotopy Path Alignment):
HPA = max_homotopy_score × functorial_integrity
ALIGNED (>0.6) = Strong path equivalences
PARTIAL (0.3-0.6) = Some equivalences
WEAK (<0.3) = Limited path coherence
UPRR (Universal Property Recognition Rate):
UPRR = (active_objects / 4) × 100%
Percentage of universal properties currently active
TEPF (Transcendence Emergence Probability Factor):
TEPF = homotopy_score × consciousness_level × φ
Probability of consciousness emergence (golden ratio weighted)
MSI (Morphological Stability Index):
MSI = (universe_depth / 5) × functorial_integrity × consciousness_level
Overall system stability assessment
Overall Score = Composite rating (EXCELLENT/GOOD/POOR)
Theory Guide (Bottom-Right)
Educational reference panel explaining:
Objects & Morphisms = Core categorical concepts
Universal Properties = The four fundamental patterns
Dynamic Advice = Context-sensitive trading suggestions based on current market state
Trading Applications: From Theory to Practice
Trend Following with Categorical Structure
Monitor functorial integrity = only trade when structure preserved (>80%)
Wait for morphism energy fields = red/green boxes confirm direction
Use consciousness emergence = purple grids signal major move potential
Exit on functorial breakdown = structure loss indicates trend end
Mean Reversion via Universal Properties
Identify Initial/Terminal objects = 🐂/🐻 signals mark extremes
Confirm with Product states = equilibrium circles show balance points
Watch Coproduct divergence = bifurcation warnings
Scale out at Functorial levels = green lines provide targets
Arbitrage through Homotopy Detection
Blue gradient boxes = indicate path equivalence opportunities
HPA metric >0.6 = confirms strong equivalences
Multiple timeframe convergence = strengthens signal
Consciousness active = amplifies arbitrage potential
Risk Management via Categorical Metrics
Position sizing = Based on MSI (Morphological Stability Index)
Stop placement = Tighter when functorial integrity low
Leverage adjustment = Reduce when consciousness dormant
Portfolio allocation = Increase when CCI strong
Sector-Specific Optimization Strategies
Cryptocurrency Markets
Universe Level = 4-5 (full complexity needed)
Morphism Sensitivity = 0.382-0.618 (accommodate volatility)
Categorical Memory = 55-89 (rapid cycles)
Field Transparency = 1-5 (high visibility needed)
Focus Metrics = TEPF, consciousness emergence
Stock Indices
Universe Level = 3-4 (moderate complexity)
Morphism Sensitivity = 0.618-1.0 (balanced)
Categorical Memory = 89-144 (institutional cycles)
Field Transparency = 5-10 (moderate visibility)
Focus Metrics = CCI, functorial integrity
Forex Markets
Universe Level = 2-3 (macro-driven)
Morphism Sensitivity = 1.0-1.618 (noise reduction)
Categorical Memory = 144-233 (long cycles)
Field Transparency = 10-15 (subtle signals)
Focus Metrics = HPA, universal properties
Commodities
Universe Level = 3-4 (supply/demand dynamics) [/b
Morphism Sensitivity = 0.618-1.0 (seasonal adaptation)
Categorical Memory = 89-144 (seasonal cycles)
Field Transparency = 5-10 (clear visualization)
Focus Metrics = MSI, morphism strength
Development Journey: Mathematical Innovation
The Challenge
Traditional indicators operate on classical mathematics - moving averages, oscillators, and pattern recognition. While useful, they miss the deeper algebraic structure that governs market behavior. Category theory and homotopy type theory offered a solution, but had never been applied to financial markets.
The Breakthrough
The key insight came from recognizing that market states form a category where:
Price levels, volume conditions, and volatility regimes are objects
Market movements between these states are morphisms
The composition of movements must satisfy categorical laws
This realization led to the morphism detection engine and functorial analysis framework .
Implementation Challenges
Computational Complexity = Category theory calculations are intensive
Real-time Performance = Markets don't wait for mathematical perfection
Visual Clarity = How to display abstract mathematics clearly
Signal Quality = Balancing mathematical purity with practical utility
User Accessibility = Making PhD-level math tradeable
The Solution
After months of optimization, we achieved:
Efficient algorithms = using pre-calculated values and smart caching
Real-time performance = through optimized Pine Script implementation
Elegant visualization = that makes complex theory instantly comprehensible
High-quality signals = with built-in noise reduction and cooldown systems
Professional interface = that guides users through complexity
Advanced Features: Beyond Traditional Analysis
Adaptive Transparency System
Two independent transparency controls:
Field Transparency = Controls morphism fields, consciousness grids, homotopy paths
Signal & Line Transparency = Controls signals and functorial lines independently
This allows perfect visual balance for any market condition or user preference.
Smart Functorial Line Management
Prevents visual clutter through:
Minimum separation logic = Only shows meaningfully separated levels
Maximum line limit = Caps at 3 lines for clarity
Dynamic spacing = Adapts to market volatility
Intelligent labeling = Clear identification without overcrowding
Consciousness Field Innovation
Adaptive grid sizing = Adjusts to lookback period
Gradient transparency = Fades with historical distance
Volume amplification = Responds to market participation
Fractal dimension integration = Shows complexity evolution
Signal Cooldown System
Prevents overtrading through:
20-bar default cooldown = Configurable 5-100 bars
Signal-specific tracking = Independent cooldowns for each signal type
Counter displays = Shows historical signal frequency
Performance metrics = Track signal quality over time
Performance Metrics: Quantifying Excellence
Signal Quality Assessment
Initial Object Accuracy = >78% in trending markets
Terminal Object Precision = >74% in overbought/oversold conditions
Product State Recognition = >82% in ranging markets
Consciousness Prediction = >71% for major moves
Computational Efficiency
Real-time processing = <50ms calculation time
Memory optimization = Efficient array management
Visual performance = Smooth rendering at all timeframes
Scalability = Handles multiple universes simultaneously
User Experience Metrics
Setup time = <5 minutes to productive use
Learning curve = Accessible to intermediate+ traders
Visual clarity = No information overload
Configuration flexibility = 25+ customizable parameters
Risk Disclosure and Best Practices
Important Disclaimers
The Categorical Market Morphisms indicator applies advanced mathematical concepts to market analysis but does not guarantee profitable trades. Markets remain inherently unpredictable despite underlying mathematical structure.
Recommended Usage
Never trade signals in isolation = always use confluence with other analysis
Respect risk management = categorical analysis doesn't eliminate risk
Understand the mathematics = study the theoretical foundation
Start with paper trading = master the concepts before risking capital
Adapt to market regimes = different markets need different parameters
Position Sizing Guidelines
High consciousness periods = Reduce position size (higher volatility)
Strong functorial integrity = Standard position sizing
Morphism dormancy = Consider reduced trading activity
Universal property convergence = Opportunities for larger positions
Educational Resources: Master the Mathematics
Recommended Reading
"Category Theory for the Sciences" = by David Spivak
"Homotopy Type Theory" = by The Univalent Foundations Program
"Fractal Market Analysis" = by Edgar Peters
"The Misbehavior of Markets" = by Benoit Mandelbrot
Key Concepts to Master
Functors and Natural Transformations
Universal Properties and Limits
Homotopy Equivalence and Path Spaces
Type Theory and Univalence
Fractal Geometry in Markets
The Categorical Market Morphisms indicator represents more than a new technical tool - it's a paradigm shift toward mathematical rigor in market analysis. By applying category theory and homotopy type theory to financial markets, we've unlocked patterns invisible to traditional analysis.
This isn't just about better signals or prettier charts. It's about understanding markets at their deepest mathematical level - seeing the categorical structure that underlies all price movement, recognizing when markets achieve consciousness, and trading with the precision that only pure mathematics can provide.
Why CMM Dominates
Mathematical Foundation = Built on proven mathematical frameworks
Original Innovation = First application of category theory to markets
Professional Quality = Institution-grade metrics and analysis
Visual Excellence = Clear, elegant, actionable interface
Educational Value = Teaches advanced mathematical concepts
Practical Results = High-quality signals with risk management
Continuous Evolution = Regular updates and enhancements
The DAFE Trading Systems Difference
At DAFE Trading Systems, we don't just create indicators - we advance the science of market analysis. Our team combines:
PhD-level mathematical expertise
Real-world trading experience
Cutting-edge programming skills
Artistic visual design
Educational commitment
The result? Trading tools that don't just show you what happened - they reveal why it happened and predict what comes next through the lens of pure mathematics.
"In mathematics you don't understand things. You just get used to them." - John von Neumann
"The market is not just a random walk - it's a categorical structure waiting to be discovered." - DAFE Trading Systems
Trade with Mathematical Precision. Trade with Categorical Market Morphisms.
Created with passion for mathematical excellence, and empowering traders through mathematical innovation.
— Dskyz, Trade with insight. Trade with anticipation.
Drawdown Visualizer v1.0Drawdown Visualizer
The Drawdown Visualizer tracks the percentage decline from all-time highs, providing valuable insights into market corrections and potential buying opportunities.
Key Features:
1) Real-Time Drawdown Tracking: The indicator continuously calculates and displays the current percentage drawdown from the all-time high price, color-coded from green (minimal drawdown) to red (severe drawdown) for instant visual feedback.
2) Maximum Drawdown Detection: Permanently tracks and displays the maximum historical drawdown encountered during the analyzed period, helping traders understand worst-case scenarios.
3) Statistical Analysis: Calculates and displays three important statistical measures:
* Average Drawdown: The mean value of all drawdowns recorded
* Median Drawdown: The middle value in the sorted list of all drawdowns, providing insight
into typical decline patterns
* Normal Drawdown Range: Visualizes the expected range of typical drawdowns based on
statistical standard deviation
Practical Applications:
1) Risk Management: Understand typical and extreme drawdowns to set appropriate stop-loss levels
2) Market Context: Gain perspective on whether current corrections are normal or exceptional
3) Entry Point Analysis: Identify potential buying opportunities when drawdowns reach statistical extremes
Smarter Money Concepts - OBs [PhenLabs]📊 Smarter Money Concepts - OBs
Version: PineScript™ v6
📌 Description
Smarter Money Concepts - OBs (Order Blocks) is an advanced technical analysis tool designed to identify and visualize institutional order zones on your charts. Order blocks represent significant areas of liquidity where smart money has entered positions before major moves. By tracking these zones, traders can anticipate potential reversals, continuations, and key reaction points in price action.
This indicator incorporates volume filtering technology to identify only the most significant order blocks, eliminating low-quality signals and focusing on areas where institutional participation is likely present. The combination of price structure analysis and volume confirmation provides traders with high-probability zones that may attract future price action for tests, rejections, or breakouts.
🚀 Points of Innovation
Volume-Filtered Block Detection : Identifies only order blocks formed with significant volume, focusing on areas with institutional participation
Advanced Break of Structure Logic : Uses sophisticated price action analysis to detect legitimate market structure breaks preceding order blocks
Dynamic Block Management : Intelligently tracks, extends, and removes order blocks based on price interaction and time-based expiration
Structure Recognition System : Employs technical analysis algorithms to find significant swing points for accurate order block identification
Dual Directional Tracking : Simultaneously monitors both bullish and bearish order blocks for comprehensive market structure analysis
🔧 Core Components
Order Block Detection : Identifies institutional entry zones by analyzing price action before significant breaks of structure, capturing where smart money has likely positioned before moves.
Volume Filtering Algorithm : Calculates relative volume compared to a moving average to qualify only order blocks formed with significant market participation, eliminating noise.
Structure Break Recognition : Uses price action analysis to detect legitimate breaks of market structure, ensuring order blocks are identified only at significant market turning points.
Dynamic Block Management : Continuously monitors price interaction with existing blocks, extending, maintaining, or removing them based on current market behavior.
🔥 Key Features
Volume-Based Filtering : Filter out insignificant blocks by requiring a minimum volume threshold, focusing only on zones with likely institutional activity
Visual Block Highlighting : Color-coded boxes clearly mark bullish and bearish order blocks with customizable appearance
Flexible Mitigation Options : Choose between “Wick” or “Close” methods for determining when a block has been tested or mitigated
Scan Range Adjustment : Customize how far back the indicator looks for structure points to adapt to different market conditions and timeframes
Break Source Selection : Configure which price component (close, open, high, low) is used to determine structure breaks for precise block identification
🎨 Visualization
Bullish Order Blocks : Blue-colored rectangles highlighting zones where bullish institutional orders were likely placed before upward moves, representing potential support areas.
Bearish Order Blocks : Red-colored rectangles highlighting zones where bearish institutional orders were likely placed before downward moves, representing potential resistance areas.
Block Extension : Order blocks extend to the right of the chart, providing clear visualization of these significant zones as price continues to develop.
📖 Usage Guidelines
Order Block Settings
Scan Range : Default: 25. Defines how many bars the indicator scans to determine significant structure points for order block identification.
Bull Break Price Source : Default: Close. Determines which price component is used to detect bullish breaks of structure.
Bear Break Price Source : Default: Close. Determines which price component is used to detect bearish breaks of structure.
Visual Settings
Bullish Blocks Color : Default: Blue with 85% transparency. Controls the appearance of bullish order blocks.
Bearish Blocks Color : Default: Red with 85% transparency. Controls the appearance of bearish order blocks.
General Options
Block Mitigation Method : Default: Wick, Options: Wick, Close. Determines how block mitigation is calculated - “Wick” uses high/low values while “Close” uses close values for more conservative mitigation criteria.
Remove Filled Blocks : Default: Disabled. When enabled, order blocks are removed once they’ve been mitigated by price action.
Volume Filter
Volume Filter Enabled : Default: Enabled. When activated, only shows order blocks formed with significant volume relative to recent average.
Volume SMA Period : Default: 15, Range: 1-50. Number of periods used to calculate the average volume baseline.
Min. Volume Ratio : Default: 1.5, Range: 0.5-10.0. Minimum volume ratio compared to average required to display an order block; higher values filter out more blocks.
✅ Best Use Cases
Identifying high-probability support and resistance zones for trade entries and exits
Finding optimal stop-loss placement behind significant order blocks
Detecting potential reversal areas where price may react after extended moves
Confirming breakout trades when price clears major order blocks
Building a comprehensive market structure map for medium to long-term trading decisions
Pinpointing areas where smart money may have positioned before major market moves
⚠️ Limitations
Most effective on higher timeframes (1H and above) where institutional activity is more clearly defined
Can generate multiple signals in choppy market conditions, requiring additional filtering
Volume filtering relies on accurate volume data, which may be less reliable for some securities
Recent market structure changes may invalidate older order blocks not yet automatically removed
Block identification is based on historical price action and may not predict future behavior with certainty
💡 What Makes This Unique
Volume Intelligence : Unlike basic order block indicators, this script incorporates volume analysis to identify only the most significant institutional zones, focusing on quality over quantity.
Structural Precision : Uses sophisticated break of structure algorithms to identify true market turning points, going beyond simple price pattern recognition.
Dynamic Block Management : Implements automatic block tracking, extension, and cleanup to maintain a clean and relevant chart display without manual intervention.
Institutional Focus : Designed specifically to highlight areas where smart money has likely positioned, helping retail traders align with institutional perspectives rather than retail noise.
🔬 How It Works
1. Structure Identification Process :
The indicator continuously scans price action to identify significant swing points and structure levels within the specified range, establishing a foundation for order block recognition.
2. Break Detection :
When price breaks an established structure level (crossing below a significant low for bearish breaks or above a significant high for bullish breaks), the indicator marks this as a potential zone for order block formation.
3. Volume Qualification :
For each potential order block, the algorithm calculates the relative volume compared to the configured period average. Only blocks formed with volume exceeding the minimum ratio threshold are displayed.
4. Block Creation and Management :
Valid order blocks are created, tracked, and managed as price continues to develop. Blocks extend to the right of the chart until they are either mitigated by price action or expire after the designated timeframe.
5. Continuous Monitoring :
The indicator constantly evaluates price interaction with existing blocks, determining when blocks have been tested, mitigated, or invalidated, and updates the visual representation accordingly.
💡 Note:
Order Blocks represent areas where institutional traders have likely established positions and may defend these zones during future price visits. For optimal results, use this indicator in conjunction with other confluent factors such as key support/resistance levels, trendlines, or additional confirmation indicators. The most reliable signals typically occur on higher timeframes where institutional activity is most prominent. Start with the default settings and adjust parameters gradually to match your specific trading instrument and style.
Smarter Money Concepts - FVGs [PhenLabs]📊 Smarter Money Concepts - FVGs
Version: PineScript™ v6
📌 Description
Smarter Money Concepts - FVGs is a sophisticated indicator designed to identify and track Fair Value Gaps (FVGs) in price action. These gaps represent market inefficiencies where price moves quickly, creating imbalances that often attract subsequent price action for mitigation. By highlighting these key areas, traders can identify potential zones for reversals, continuations, and price targets.
The indicator employs volume filtering ideology to highlight only the most significant FVGs, reducing noise and focusing on gaps formed during periods of higher relative volume. This combination of price structure analysis and volume confirmation provides traders with high-probability areas of interest that institutional smart money may target during future price movements.
🚀 Points of Innovation
Volume-Filtered Gap Detection : Eliminates low-significance FVGs by requiring a minimum volume threshold, focusing only on gaps formed with institutional participation
Equilibrium Line Visualization : Displays the midpoint of each gap as a potential precision target for trades
Automated Gap Mitigation Tracking : Monitors when price revisits and mitigates gaps, automatically managing visual elements
Time-Based Gap Management : Intelligently filters gaps based on a configurable timeframe, maintaining chart clarity
Dual Direction Analysis : Simultaneously tracks both bullish and bearish gaps, providing a complete market structure view
Memory-Optimized Design : Implements efficient memory management for smooth chart performance even with numerous FVGs
🔧 Core Components
Fair Value Gap Detection : Identifies price inefficiencies where the current candle’s low is higher than the previous candle’s high (bearish FVG) or where the current candle’s high is lower than the previous candle’s low (bullish FVG).
Volume Filtering Mechanism : Calculates relative volume compared to a moving average to qualify only gaps formed during significant market activity.
Mitigation Tracking : Continuously monitors price action to detect when gaps get filled, with options to either hide or maintain visual representation of mitigated gaps.
🔥 Key Features
Customizable Gap Display : Toggle visibility of bullish and bearish gaps independently to focus on your preferred market direction
Volume Threshold Control : Adjust the minimum volume ratio required for gap qualification, allowing fine-tuning between sensitivity and significance
Flexible Mitigation Methods : Choose between “Wick” or “Close” methods for determining when a gap has been mitigated, adapting to different trading styles
Visual Customization : Full control over colors, transparency, and style of gap boxes and equilibrium lines
🎨 Visualization
Gap Boxes : Rectangular highlights showing the exact price range of each Fair Value Gap. Bullish gaps indicate potential upward price targets, while bearish gaps show potential downward targets.
Equilibrium Lines : Dotted lines running through the center of each gap, representing the mathematical midpoint that often serves as a precision target for price movement.
📖 Usage Guidelines
General Settings
Days to Analyze : Default: 15, Range: 1-100. Controls how many days of historical gaps to display, balancing between comprehensive analysis and chart clarity
Visual Settings
Bull Color : Default:(#596fd33f). Color for bullish Fair Value Gaps, typically using high transparency for clear chart visibility
Bear Color : Default:(#d3454575). Color for bearish Fair Value Gaps, typically using high transparency for clear chart visibility
Equilibrium Line : Default: Enabled. Toggles visibility of the center equilibrium line for each FVG
Eq. Line Color : Default: Black with 99% transparency. Sets the color of equilibrium lines, usually kept subtle to avoid chart clutter
Eq. Line Style : Default: Dotted, Options: Dotted, Solid, Dashed. Determines the line style for equilibrium lines
Mitigation Settings
Mitigation Method : Default: Wick, Options: Wick, Close. Determines how gap mitigation is calculated - “Wick” uses high/low values while “Close” uses open/close values for more conservative mitigation criteria
Hide Mitigated : Default: Enabled. When enabled, gaps become transparent once mitigated, reducing visual clutter while maintaining historical context
Volume Filter
Volume Filter : Default: Enabled. When enabled, only shows gaps formed with significant volume relative to recent average
Min Ratio : Default: 1.5, Range: 0.1-10.0. Minimum volume ratio compared to average required to display an FVG; higher values filter out more gaps
Periods : Default: 15, Range: 5-50. Number of periods used to calculate the average volume baseline
✅ Best Use Cases
Identifying potential reversal zones where price may react after extended moves
Finding precise targets for take-profit placement in trend-following strategies
Detecting institutional interest areas for potential breakout or breakdown confirmations
Plotting significant support and resistance zones based on structural imbalances
Developing fade strategies at key market structure points
Confirming trade entries when price approaches significant unfilled gaps
⚠️ Limitations
Works best on higher timeframes where gaps reflect more significant market inefficiencies
Very choppy or ranging markets may produce small gaps with limited predictive value
Volume filtering depends on accurate volume data, which may be less reliable for some symbols
Performance may be affected when displaying a very large number of historical gaps
Some gaps may never be fully mitigated, particularly in strongly trending markets
💡 What Makes This Unique
Volume Intelligence : Unlike basic FVG indicators, this script incorporates volume analysis to identify the most significant structural imbalances, focusing on quality over quantity.
Visual Clarity Management : Automatic handling of mitigated gaps and memory management ensures your chart remains clean and informative even over extended analysis periods.
Dual-Direction Comprehensive Analysis : Simultaneously tracks both bullish and bearish gaps, providing a complete market structure picture rather than forcing a directional bias.
🔬 How It Works
1. Gap Detection Process :
The indicator examines each candle in relation to previous candles, identifying when a gap forms between the low of candle and high of candle (bearish FVG) or between the high of candle and low of candle (bullish FVG). This specific candle relationship identifies true structural imbalances.
2. Volume Qualification :
For each potential gap, the algorithm calculates the relative volume compared to the configured period average. Only gaps formed with volume exceeding the minimum ratio threshold are displayed, ensuring focus on institutionally significant imbalances.
3. Equilibrium Calculation :
For each qualified gap, the script calculates the precise mathematical midpoint, which becomes the equilibrium line - a key target that price often gravitates toward during mitigation attempts.
4. Mitigation Tracking :
The indicator continuously monitors price action against existing gaps, determining mitigation based on the selected method (wick or close). When price reaches the equilibrium point, the gap is considered mitigated and can be visually updated accordingly.
💡 Note:
Fair Value Gaps represent market inefficiencies that often, but not always, get filled. Use this indicator as part of a complete trading strategy rather than as a standalone system. The most valuable signals typically come from combining FVG analysis with other confirmatory indicators and overall market context. For optimal results, start with the default settings and gradually adjust parameters to match your specific trading timeframe and style.
ICT Order Blocks v2 (Debug)Josh has a very large PP xD
Understanding Order Blocks (OBs) - The ICT Perspective
This document delves into the concept of Order Blocks (OBs) from the perspective of the ICT methodology. It outlines what OBs are, their significance in trading, and how the "ICT Order Blocks v2 (Refined)" indicator functions to identify and visualize these critical price levels. By understanding OBs, traders can better navigate market movements and make informed decisions based on institutional trading behavior.
What is an Order Block (OB)?
Within ICT methodology, an Order Block represents a specific price candle where significant buying or selling interest from institutions (Smart Money) is believed to have occurred. They are potential areas where price might return and react.
Bullish Order Block: Typically the last down-closing candle before a strong, impulsive upward move (displacement). It suggests institutions may have absorbed selling pressure and initiated long positions here.
Bearish Order Block: Typically the last up-closing candle before a strong, impulsive downward move (displacement). It suggests institutions may have distributed long positions or initiated short positions here.
Why are OBs Significant (ICT View)?
Institutional Footprint: They mark potential zones of large order execution.
Support/Resistance: Unmitigated OBs can act as sensitive price levels where reactions are expected. Bullish OBs may provide support; Bearish OBs may provide resistance.
Origin of Moves: They often mark the origin point of significant price swings.
Liquidity Engineering: Institutions might drive price back to OBs to mitigate earlier positions or to engineer liquidity before continuing a move.
Common Refinements
ICT often emphasizes higher probability OBs that are associated with:
Displacement: The move away from the OB is sharp and decisive.
Fair Value Gaps (FVGs): An FVG forming immediately after the OB strengthens its validity.
OB Mitigation: This refers to price returning to the level of the Order Block after its formation. Price might react at the edge (proximal line) or the 50% level (mean threshold) of the OB. An OB is often considered fully mitigated or invalidated if price trades decisively through its entire range, especially with a candle body closing beyond it.
How the "ICT Order Blocks v2 (Refined)" Indicator Works
This indicator automates the detection and visualization of the most recent unmitigated Order Block of each type (Bullish/Bearish), incorporating optional filters.
Detection:
It looks at the relationship between the candle two bars ago ( ), the previous candle ( ), and potentially the current candle ( ).
Bullish OB: Identifies if candle was a down-close (close < open ) AND candle broke above the high of candle (high > high ).
Bearish OB: Identifies if candle was an up-close (close > open ) AND candle broke below the low of candle (low < low ).
Accuracy Filters (Optional Inputs):
These filters help identify potentially higher-probability OBs:
Require Fair Value Gap (FVG)?: If enabled, the indicator checks if an FVG formed immediately after the OB candle ( ). Specifically, it looks for a gap between candle and candle (low > high for Bullish OB confirmation, high < low for Bearish).
Require Strong Close Breakout?: If enabled, it requires the breakout candle ( ) to close beyond the range of the OB candle ( ). (close > high for Bullish, close < low for Bearish). This suggests stronger confirmation.
Storing the Most Recent OB:
When an OB is detected and passes any enabled filters, its details (high, low, formation bar index) are stored. Crucially, this indicator only tracks the single most recent valid unmitigated OB of each type (one Bullish, one Bearish) using var variables. If a newer valid OB forms, it replaces the previously stored one.
Drawing Boxes:
If a valid Bullish OB is being tracked (and Show Bullish OBs is enabled), it draws a box (box.new) using the high and low of the identified OB candle ( ). The same process applies to Bearish OBs (Show Bearish OBs enabled). The boxes automatically extend to the right (extend.right) and their right edge is updated on each new bar (box.set_right) until they are mitigated. Labels ("Bull OB" / "Bear OB") are displayed inside the boxes.
Mitigation & Box Deletion:
The indicator checks if the current closing price (close ) has moved entirely beyond the range of the tracked OB.
Mitigation Rule Used: A Bullish OB is considered mitigated if close < bull_ob_low. A Bearish OB is considered mitigated if close > bear_ob_high. Once an OB is marked as mitigated, the indicator stops tracking it and its corresponding box is automatically deleted (box.delete) from the chart.
This indicator provides a dynamic visualization of the most recent, potentially significant Order Blocks that meet the specified criteria, helping traders identify key areas of interest based on ICT principles.
HTF Hi-Lo Zones [CHE]HTF Hi-Lo Zones Indicator
The HTF Hi-Lo Zones Indicator is a Pine Script tool designed to highlight important high and low values from a selected higher timeframe. It provides traders with clear visual zones where price activity has reached significant points, helping in decision-making by identifying potential support and resistance levels. This indicator is customizable, allowing users to select the resolution type, control the visualization of session ranges, and even display detailed information about the chosen timeframe.
Key Functionalities
1. Timeframe Resolution Selection:
- The indicator offers three modes to determine the resolution:
- Automatic: Dynamically calculates the higher timeframe based on the current chart's resolution.
- Multiplier: Allows users to apply a multiplier to the current chart's timeframe.
- Manual: Enables manual input for custom resolution settings.
- Each resolution type ensures flexibility to suit different trading styles and strategies.
2. Data Fetching for High and Low Values:
- The indicator retrieves the current high and low values for the selected higher timeframe using `request.security`.
- It also calculates the lowest and highest values over a configurable lookback period, providing insights into significant price movements within the chosen timeframe.
3. Session High and Low Detection:
- The indicator detects whether the current value represents a new session high or low by comparing the highest and lowest values with the current data.
- This is crucial for identifying breakouts or significant turning points during a session.
4. Visual Representation:
- When a new session high or low is detected:
- Range Zones: A colored box marks the session's high-to-low range.
- Labels: Optional labels indicate "New High" or "New Low" for clarity.
- Users can customize colors, transparency, and whether range outlines or labels should be displayed.
5. Information Box:
- An optional dashboard displays details about the chosen timeframe resolution and current session activity.
- The box's size, position, and colors are fully customizable.
6. Session Tracking:
- Tracks session boundaries, updating the visualization dynamically as the session progresses.
- Displays session-specific maximum and minimum values if enabled.
7. Additional Features:
- Configurable dividers for session or daily boundaries.
- Transparency and styling options for the displayed zones.
- A dashboard for advanced visualization and information overlay.
Key Code Sections Explained
1. Resolution Determination:
- Depending on the user's input (Auto, Multiplier, or Manual), the script determines the appropriate timeframe resolution for higher timeframe analysis.
- The resolution adapts dynamically based on intraday, daily, or higher-period charts.
2. Fetching Security Data:
- Using the `getSecurityDataFunction`, the script fetches high and low values for the chosen timeframe, including historical and real-time data management to avoid repainting issues.
3. Session High/Low Logic:
- By comparing the highest and lowest values over a lookback period, the script identifies whether the current value is a new session high or low, updating session boundaries and initiating visual indicators.
4. Visualization:
- The script creates visual representations using `box.new` for range zones and `label.new` for session labels.
- These elements update dynamically to reflect the most recent data.
5. Customization Options:
- Users can configure the appearance, behavior, and displayed data through multiple input options, ensuring adaptability to individual trading preferences.
This indicator is a robust tool for tracking higher timeframe activity, offering a blend of automation, customization, and visual clarity to enhance trading strategies.
Disclaimer
The content provided, including all code and materials, is strictly for educational and informational purposes only. It is not intended as, and should not be interpreted as, financial advice, a recommendation to buy or sell any financial instrument, or an offer of any financial product or service. All strategies, tools, and examples discussed are provided for illustrative purposes to demonstrate coding techniques and the functionality of Pine Script within a trading context.
Any results from strategies or tools provided are hypothetical, and past performance is not indicative of future results. Trading and investing involve high risk, including the potential loss of principal, and may not be suitable for all individuals. Before making any trading decisions, please consult with a qualified financial professional to understand the risks involved.
By using this script, you acknowledge and agree that any trading decisions are made solely at your discretion and risk.
Best regards and happy trading
Chervolino
Weekly High/Low Day BreakdownThe "Weekly High/Low Day Breakdown" is a tool designed to help identify patterns in market behaviour by analysing the days of the week when weekly highs and lows occur. This indicator calculates the frequency and percentage of weekly highs and lows for each day from Monday to Sunday within the visible range of your chart.
Features:
Weekly Analysis: Calculates weekly highs and lows based on daily open high and low prices from Monday to Sunday.
Day-Specific Breakdown: Tracks which day of the week each weekly high and low occurred.
Visible Range Focus: Only considers data within the current visible range of your chart for precise analysis.
Interactive Table Display: Presents the results in an easy-to-read table directly on your chart.
How It Works:
Data Collection: Fetches daily high, low, day of the week, and time data regardless of your chart's timeframe. Uses these daily figures to determine the weekly high and low for each week.
Weekly Tracking: Monitors the day of the week when the weekly high and low prices occur. Resets tracking at the end of each week (Sunday).
Visible Range Analysis: Only includes weeks that fall entirely within the visible time range of your chart. Ensures that the analysis is relevant to the period you are focusing on.
Percentage Calculation: Counts the occurrences of weekly highs and lows for each day. Calculates the percentage based on the total number of weeks in the visible range.
Result Display: Generates a table with days of the week as columns and "Weekly High" and "Weekly Low" as rows. Displays the percentage values, indicating how often highs and lows occur on each day.
How to Use:
Add the Indicator: Apply the "Weekly High/Low Day Breakdown" indicator to your TradingView chart.
Adjust Visible Range: Zoom in or out to set the desired visible time range for your analysis.
Interpret the Table:
Columns: Represent days from Monday to Sunday.
"Weekly High" Row: Shows the percentage of times the weekly high occurred on each day. "Weekly Low" Row: Shows the percentage of times the weekly low occurred on each day.
Colors: Blue text indicates high percentages, red text indicates low percentages.
Example Interpretation:
If the table shows a 30% value under "Tuesday" for "Weekly High," it means that in 30% of the weeks within the visible range, the highest price of the week occurred on a Tuesday.
Similarly, a 40% value under "Friday" for "Weekly Low" indicates that 40% of the weekly lows happened on a Friday.
EMA14 Second Time BUY/SELL AlertsEMA14 Crossover Strategy with Conditional BUY/SELL Alerts
This powerful script provides dynamic BUY and SELL alerts based on the interaction between price action and the EMA14 (Exponential Moving Average 14). Ideal for traders looking to capitalize on trend reversals and breakout patterns, this indicator helps you time entries and exits with precision.
Key Features:
Second-Time Crossover Alerts: The script tracks when the price crosses the EMA14 for the second time. This adds confirmation to price movements and helps filter out false signals.
Conditional BUY/SELL Alerts:
BUY Alert: Triggered when the price closes above the EMA14 after a previous SELL signal, indicating a potential trend reversal or breakout to the upside.
SELL Alert: Triggered when the price closes below the EMA14 after a previous BUY signal, signaling a possible shift to the downside.
Advanced Crossover Tracking:
The script counts each crossover of the price relative to the EMA14, generating a BUY or SELL signal on the second instance to provide additional confirmation of trend strength.
Visual Alerts: Labels are plotted directly on the chart to highlight when a BUY or SELL signal has occurred, providing immediate visual feedback for traders to react in real-time.
How It Works:
The script combines the simplicity of EMA14 with enhanced logic that tracks both crossovers and closes relative to the moving average. This ensures that the signals are based not only on quick movements but also on price confirmation, reducing noise and false breakouts.
This script is perfect for traders who rely on moving average strategies and want additional filtering to confirm trends and optimize trade timing.
cd_RSI_Divergence_CxGeneral:
The Relative Strength Index (RSI) is a momentum oscillator widely used by traders in price analysis. In addition to showing overbought/oversold zones, divergences between RSI and price are also tracked to identify trading opportunities.
The general consensus is that oscillators alone are not sufficient for entries and should be evaluated together with multiple confirmations.
This oscillator is designed as an additional confirmation/compatible tool for strategies that already use higher time frame (HTF) sweeps and lower time frame (LTF) confirmations such as Change in State Delivery (CISD) or Change of Character (CHOCH).
Features:
While RSI oscillators are commonly displayed in line format (classic), this indicator also offers candlestick-style visualization.
Depending on the selected source, period length, and EMA length, RSI can be displayed as lines and/or candlesticks.
Divergence detection & tracking:
Price and RSI values are monitored on the chosen higher time frame (from the menu) to determine highs and lows. For divergence display, the user can choose between two modes:
1- Alignment with HTF Sweep
2- All
1 - Alignment with HTF Sweep:
First, the price must sweep the previous high/low of the candle on the HTF (i.e., break it) but fail to continue in that direction and return inside (sweep).
If this condition is met, RSI values are checked:
If price makes a high sweep but RSI fails to make a new high → divergence is confirmed.
If price makes a low sweep but RSI fails to make a new low → divergence is confirmed.
Divergence is then displayed on the chart.
2 - All:
In this mode, sweep conditions are ignored. Divergence is confirmed if:
Price makes a new high on HTF but RSI does not.
RSI makes a new high on HTF but price does not.
Price makes a new low on HTF but RSI does not.
RSI makes a new low on HTF but price does not.
Menu & Settings:
RSI visualization (source + period length + EMA period length)
Option to choose classic/candlestick style display
Color customization
Higher time frame selection
Adjustable HTF boxes and table display
Final notes:
This oscillator is designed as an additional confirmation tool for strategies based on HTF sweep + LTF CISD/CHOCH confirmation logic. The chosen HTF in the oscillator should match the time frame where sweeps are expected.
Divergence signals from this oscillator alone will not make you profitable.
For spot trades, monitoring sweeps and divergences on higher time frames is more suitable (e.g., Daily–H1 / Weekly–H4).
My personal usage preferences:
Entry TF: 3m
HTF bias: Daily + H1
Sweep + CISD: 30m / 3m
Market Structure: 3m
RSI divergence: HTF = 30m
If all of them align bullish or bearish ( timeframe alignment ), I try to take the trade.
I’d be glad to hear your feedback and suggestions for improvement.
Happy trading!
Advanced ICT Theory - A-ICT📊 Advanced ICT Theory (A-ICT): The Institutional Manipulation Detector
Are you tired of being the liquidity? Stop chasing shadows and start tracking the architects of price movement.
This is not another lagging indicator. This is a complete framework for viewing the market through the lens of institutional traders. Advanced ICT Theory (A-ICT) is an all-in-one, military-grade analysis engine designed to decode the complex language of "Smart Money." It automates the core tenets of Inner Circle Trader (ICT) methodology, moving beyond simple patterns to build a dynamic, real-time narrative of market manipulation, liquidity engineering, and institutional order flow.
AIT provides a living blueprint of the market, identifying high-probability zones, tracking structural shifts, and scoring the quality of setups with a sophisticated, multi-factor algorithm. This is your X-ray into the market's true intentions.
🔬 THE CORE ENGINE: DECODING THE THEORY & FORMULAS
A-ICT is built upon a sophisticated, multi-layered logic system that interprets price action as a story of cause and effect. It does not guess; it confirms. Here is the foundational theory that drives the engine:
1. Market Structure: The Blueprint of Trend
The script first establishes a deep understanding of the market's skeleton through multi-level pivot analysis. It uses ta.pivothigh and ta.pivotlow to identify significant swing points.
Internal Structure (iBOS): Minor swings that show the short-term order flow. A break of internal structure is the first whisper of a potential shift.
External Structure (eBOS): Major swing points that define the primary trend. A confirmed break of external structure is a powerful statement of trend continuation. AIT validates this with optional Volume Confirmation (volume > volumeSMA * 1.2) and Candle Confirmation to ensure the break is driven by institutional force, not just a random spike.
Change of Character (CHoCH): This is the earthquake. A CHoCH occurs when a confirmed eBOS happens against the prevailing trend (e.g., a bearish eBOS in a clear uptrend). A-ICT flags this immediately, as it is the strongest signal that the primary trend is under threat of reversal.
2. Liquidity Engineering: The Fuel of the Market
Institutions don't buy into strength; they buy into weakness. They need liquidity. A-ICT maps these liquidity pools with forensic precision:
Buyside & Sellside Liquidity (BSL/SSL): Using ta.highest and ta.lowest, AIT identifies recent highs and lows where clusters of stop-loss orders (liquidity) are resting. These are institutional targets.
Liquidity Sweeps: This is the "manipulation" part of the detector. AIT has a specific formula to detect a sweep: high > bsl and close < bsl . This signifies that institutions pushed price just high enough to trigger buy-stops before aggressively selling—a classic "stop hunt." This event dramatically increases the quality score of subsequent patterns.
3. The Element Lifecycle: From Potential to Power
This is the revolutionary heart of A-ICT. Zones are not static; they have a lifecycle. AIT tracks this with its dynamic classification engine.
Phase 1: PENDING (Yellow): The script identifies a potential zone of interest based on a specific candle formation (a "displacement"). It is marked as "Pending" because its true nature is unknown. It is a question.
Phase 2: CLASSIFICATION: After the zone is created, AIT watches what happens next. The zone's identity is defined by its actions:
ORDER BLOCK (Blue): The highest-grade element. A zone is classified as an Order Block if it directly causes a Break of Structure (BOS) . This is the footprint of institutions entering the market with enough force to validate the new trend direction.
TRAP ZONE (Orange): A zone is classified as a Trap Zone if it is directly involved in a Liquidity Sweep . This indicates the zone was used to engineer liquidity, setting a "trap" for retail traders before a reversal.
REVERSAL / S&R ZONE (Green): If a zone is not powerful enough to cause a BOS or a major sweep, but still serves as a pivot point, it's classified as a general support/resistance or reversal zone.
4. Market Inefficiencies: Gaps in the Matrix
Fair Value Gaps (FVG): AIT detects FVGs—a 3-bar pattern indicating an imbalance—with a strict formula: low > high (for a bullish FVG) and gapSize > atr14 * 0.5. This ensures only significant, volatile gaps are shown. An FVG co-located with an Order Block is a high-confluence setup.
5. Premium & Discount: The Law of Value
Institutions buy at wholesale (Discount) and sell at retail (Premium). AIT uses a pdLookback to define the current dealing range and divides it into three zones: Premium (sell zone), Discount (buy zone), and Equilibrium. An element's quality score is massively boosted if it aligns with this principle (e.g., a bullish Order Block in a Discount zone).
⚙️ THE CONTROL PANEL: A COMPLETE GUIDE TO THE INPUTS MENU
Every setting is a lever, allowing you to tune the AIT engine to your exact specifications. Master these to unlock the script's full potential.
🎯 A-ICT Detection Engine
Min Displacement Candles: Controls the sensitivity of element detection. How it works: It defines the number of subsequent candles that must be "inside" a large parent candle. Best practice: Use 2-3 for a balanced view on most timeframes. A higher number (4-5) will find only major, more significant zones, ideal for swing trading. A lower number (1) is highly sensitive, suitable for scalping.
Mitigation Method: Defines when a zone is considered "used up" or mitigated. How it works: Cross triggers as soon as price touches the zone's boundary. Close requires a candle to fully close beyond it. Best practice: Cross is more responsive for fast-moving markets. Close is more conservative and helps filter out fake-outs caused by wicks, making it safer for confirmations.
Min Element Size (ATR): A crucial noise filter. How it works: It requires a detected zone to be at least this multiple of the Average True Range (ATR). Best practice: Keep this around 0.5. If you see too many tiny, irrelevant zones, increase this value to 0.8 or 1.0. If you feel the script is missing smaller but valid zones, decrease it to 0.3.
Age Threshold & Pending Timeout: These manage visual clutter. How they work: Age Threshold removes old, mitigated elements after a set number of bars. Pending Timeout removes a "Pending" element if it isn't classified within a certain window. Best practice: The default settings are optimized. If your chart feels cluttered, reduce the Age Threshold. If pending zones disappear too quickly, increase the Pending Timeout.
Min Quality Threshold: Your primary visual filter. How it works: It hides all elements (boxes, lines, labels) that do not meet this minimum quality score (0-100). Best practice: Start with the default 30. To see only A- or B-grade setups, increase this to 60 or 70 for an exceptionally clean, high-probability view.
🏗️ Market Structure
Lookbacks (Internal, External, Major): These define the sensitivity of the trend analysis. How they work: They set the number of bars to the left and right for pivot detection. Best practice: Use smaller values for Internal (e.g., 3) to see minor structure and larger values for External (e.g., 10-15) to map the main trend. For a macro, long-term view, increase the Major Swing Lookback.
Require Volume/Candle Confirmation: Toggles for quality control on BOS/CHoCH signals. Best practice: It is highly recommended to keep these enabled. Disabling them will result in more structure signals, but many will be false alarms. They are your filter against market noise.
... (Continue this detailed breakdown for every single input group: Display Configuration, Zones Style, Levels Appearance, Colors, Dashboards, MTF, Liquidity, Premium/Discount, Sessions, and IPDA).
📊 THE INTELLIGENCE DASHBOARDS: YOUR COMMAND CENTER
The dashboards synthesize all the complex analysis into a simple, actionable intelligence briefing.
Main Dashboard (Bottom Right)
ICT Metrics & Breakdown: This is your statistical overview. Total Elements shows how much structure the script is tracking. High Quality instantly tells you if there are any A/B grade setups nearby. Unmitigated vs. Mitigated shows the balance of fresh opportunities versus resolved price action. The breakdown by Order Blocks, Trap Zones, etc., gives you a quick read on the market's recent character.
Structure & Market Context: This is your core bias. Order Flow tells you the current script-determined trend. Last BOS shows you the most recent structural event. CHoCH Active is a critical warning. HTF Bias shows if you are aligned with the higher timeframe—the checkmark (✓) for alignment is one of the most important confluence factors.
Smart Money Flow: A volume-based sentiment gauge. Net Flow shows the raw buying vs. selling pressure, while the Bias provides an interpretation (e.g., "STRONG BULLISH FLOW").
Key Guide (Large Dashboard only): A built-in legend so you never have to guess. It defines every pattern, structure type, and special level visually.
📖 Narrative Dashboard (Bottom Left)
This is the "story" of the market, updated in real-time. It's designed to build your trading thesis.
Recent Elements Table: A live list of the most recent, high-quality setups. It displays the Type , its Narrative Role (e.g., "Bullish OB caused BOS"), its raw Quality percentage, and its final Trade Score grade. This is your at-a-glance opportunity scanner.
Market Narrative Section: This is the soul of A-ICT. It combines all data points into a human-readable story:
📍 Current Phase: Tells you if you are in a high-volatility Killzone or a consolidation phase like the Asian Range.
🎯 Bias & Alignment: Your primary direction, with a clear indicator of HTF alignment or conflict.
🔗 Events: A causal sequence of recent events, like "💧 Sell-side liquidity swept →
📊 Bullish BOS → 🎯 Active Order Block".
🎯 Next Expectation: The script's logical conclusion. It provides a specific, forward-looking hypothesis, such as "📉 Pullback expected to bullish OB at 1.2345 before continuation up."
🎨 READING THE BATTLEFIELD: A VISUAL INTERPRETATION GUIDE
Every color and line is a piece of information. Learn to read them together to see the full picture.
The Core Zones (Boxes):
Blue Box (Order Block): Highest probability zone for trend continuation. Look for entries here.
Orange Box (Trap Zone): A manipulation footprint. Expect a potential reversal after price interacts with this zone.
Green Box (Reversal/S&R): A standard pivot area. A good reference point but requires more confluence.
Purple Box (FVG): A market imbalance. Acts as a magnet for price. An FVG inside an Order Block is an A+ confluence.
The Structural Lines:
Green/Red Line (eBOS): Confirms the trend direction. A break above the green line is bullish; a break below the red line is bearish.
Thick Orange Line (CHoCH): WARNING. The previous trend is now in question. The market character has changed.
Blue/Red Lines (BSL/SSL): Liquidity targets. Expect price to gravitate towards these lines. A dotted line with a checkmark (✓) means the liquidity has been "swept" or "purged."
How to Synthesize: The magic is in the confluence. A perfect setup might look like this: Price sweeps below a red SSL line , enters a green Discount Zone during the NY Killzone , and forms a blue Order Block which then causes a green eBOS . This sequence, visible at a glance, is the story of a high-probability long setup.
🔧 THE ARCHITECT'S VISION: THE DEVELOPMENT JOURNEY
A-ICT was forged from the frustration of using lagging indicators in a market that is forward-looking. Traditional tools are reactive; they tell you what happened. The vision for A-ICT was to create a proactive engine that could anticipate institutional behavior by understanding their objectives: liquidity and efficiency. The development process was centered on creating a "lifecycle" for price patterns—the idea that a zone's true meaning is only revealed by its consequence. This led to the post-breakout classification system and the narrative-building engine. It's designed not just to show you patterns, but to tell you their story.
⚠️ RISK DISCLAIMER & BEST PRACTICES
Advanced ICT Theory (A-ICT) is a professional-grade analytical tool and does not provide financial advice or direct buy/sell signals. Its analysis is based on historical price action and probabilities. All forms of trading involve substantial risk. Past performance is not indicative of future results. Always use this tool as part of a comprehensive trading plan that includes your own analysis and a robust risk management strategy. Do not trade based on this indicator alone.
観の目つよく、見の目よわく
"Kan no me tsuyoku, ken no me yowaku"
— Miyamoto Musashi, The Book of Five Rings
English: "Perceive that which cannot be seen with the eye."
— Dskyz, Trade with insight. Trade with anticipation.
Fibonacci Retracement levels Automatically D/W/MIndicator Description: Fibonacci Retracement levels Automatically
Fibonacci retracement levels based on the day, week, month High Low range and Fibonacci retracement levels draws automatically .This Pine Script indicator is designed to plot Fibonacci retracement levels based on the high and low prices of a user-selected timeframe (Daily, Weekly, or Monthly). It identifies bullish or bearish candles in the chosen timeframe, draws key price levels, and overlays Fibonacci retracement lines and semi-transparent colored boxes to highlight potential support and resistance zones. The indicator dynamically updates with each new period and extends lines, labels, and boxes to the current bar for real-time visualization. Key Features
1. Timeframe Selection: Users can choose the timeframe for analysis: Daily, Weekly, or Monthly via an input dropdown. The indicator retrieves the open, high, low, and close prices for the selected timeframe using `request.security`.
2. High and Low Tracking : Tracks the highest high and lowest low within the selected timeframe. Stores these values and their corresponding bar indices in arrays (`whigh`, `wlow`, `whighIdx`,`wlowIdx`). Limits the array size to the most recent period to optimize performance.
3. Bullish and Bearish Candle Detection : Identifies whether the previous period’s candle is bullish (`close > open`) or bearish (`close < open`). Uses this to determine the direction for Fibonacci retracement calculations. Bullish candle: Fibonacci levels are drawn from low to high
Bearish candle: Fibonacci levels are drawn from high to low
4. Fibonacci Retracement Levels : Plots Fibonacci levels at 0.236, 0.382, 0.5, 0.618, and 0.786 between the high and low of the period. For bullish candles, levels are calculated from the low (support) to the high (resistance). For bearish candles, levels are calculated from the high (resistance) to the low (support). Each Fibonacci level is drawn as a horizontal line with a unique color:
- 0.236: Blue
- 0.382: Purple
- 0.5: Yellow
- 0.618: Teal
- 0.786: Fuchsia
5. Visual Elements: - High/Low Lines and Labels: Draws a red line and label for the previous period’s high. Draws a green line and label for the previous period’s low. Fibonacci Lines and Labels: Each Fibonacci level has a horizontal line and a label displaying the ratio.
Colored Boxes: Semi-transparent boxes are drawn between consecutive Fibonacci levels (including high and low) to highlight zones.
6. Dynamic Updates:
- At the start of a new period (e.g., new week for Weekly timeframe), the indicator:
- Clears previous Fibonacci lines, labels, and boxes.
- Recalculates the high and low for the new period.
- Redraws lines, labels, and boxes based on the new data.
- Extends all lines, labels, and boxes to the current bar index for real-time tracking.
7. Performance Optimization:
- Deletes old lines, labels, and boxes to prevent clutter.
- Limits the storage of highs and lows to the most recent period.
How It Works
1. Initialization: Defines variables for tracking bullish/bearish candles, lines, labels, and arrays for Fibonacci levels and boxes. Sets up color arrays for Fibonacci lines and boxes with distinct, semi-transparent colors.
2. Data Collection: Fetches the previous period’s OHLC (open, high, low, close) using `request.security`. Detects new periods (e.g., new week or month) using `ta.change(time(tf))`.
3. Fibonacci Calculation: On a new period, stores the high and low prices and their bar indices.
- Identifies the maximum high and minimum low from the stored data. - Calculates Fibonacci levels based on the range (`maxHigh - minLow`) and the direction (bullish or bearish).
4. Drawing:
- Draws high/low lines and labels at the identified price levels. Plots Fibonacci retracement lines and labels for each ratio. Creates semi-transparent boxes between Fibonacci levels to visually distinguish zones.
5. Updates:
- Extends all lines, labels, and boxes to the current bar index when a new period is detected. Clears old Fibonacci elements to avoid overlap and ensure clarity.
Usage
- Purpose: This indicator is useful for traders who use Fibonacci retracement levels to identify potential support and resistance zones in financial markets.
- Application:
- Select the desired timeframe (Daily, Weekly, Monthly) via the input settings.
- The indicator automatically plots the previous period’s high/low and Fibonacci levels on the chart.
- Use the labeled Fibonacci levels and colored boxes to identify key price zones for trading decisions.
- Customization:
- Modify the `timeframe` input to switch between Daily, Weekly, or Monthly analysis.
- Adjust the `fibLineColors` and `fibFillColors` arrays to change the visual appearance of lines and boxes.
- The indicator is designed for use on TradingView with Pine Script.
- The maximum array size for highs/lows is limited to 1 period in this version (can be adjusted by modifying the `array.shift` logic).
- The indicator dynamically updates with each new period, ensuring real-time relevance.
This indicator make educational purpose use only
Fibonacci - RSI OscillatorIndicator Overview
The Fibonacci RSI Oscillator calculates the Relative Strength Index (RSI) based on a dynamically adjusting level derived from recent price action and a fixed Fibonacci ratio (0.236). This differs from standard RSI, which is calculated directly on the closing price. The objective is to measure momentum relative to a level that adapts to recent peaks and valleys.
Core Calculation Mechanism
Peak/Valley Tracking: The script identifies the highest high (state_peak) and lowest low (state_valley) since the last detected change in short-term directional bias (state_dir).
Dynamic Level Calculation: A level (state_dyn_level) is calculated using a fixed 0.236 Fibonacci ratio relative to the tracked peak and valley:
If bias is up: state_dyn_level = state_peak - (state_peak - state_valley) * 0.236
If bias is down: state_dyn_level = state_valley + (state_peak - state_valley) * 0.236
This level adjusts automatically when a new peak or valley is established in the current directional bias. If price crosses the dynamic level against the current bias, the bias flips, and the level recalculates.
Optional Source Smoothing: The calculated state_dyn_level can optionally be smoothed using a user-selected moving average (SMA, EMA, WMA, HMA, RMA) before the RSI calculation.
RSI Calculation: The standard RSI formula is applied to the (optionally smoothed) state_dyn_level series to produce the primary oscillator value (val_primary_osc).
Signal Line: A moving average (type and length configurable) is calculated on the val_primary_osc to generate the val_sig_line.
Key Features & Components
Dynamic Fibonacci Level: The core input for the RSI calculation, based on recent peaks/valleys and the 0.236 ratio.
Fibonacci Level RSI: The primary oscillator line representing the RSI of the dynamic level.
Signal Line: A moving average of the primary RSI line.
Overbought/Oversold Levels: User-defined threshold lines.
Optional Source Smoothing: Configurable MA smoothing applied to the dynamic level before RSI calculation.
Gradient RSI Color : Option to color the primary RSI line based on its value relative to OB/Mid/OS levels.
Zone & OB/OS Fills: Visual fills for the 0-50 / 50-100 zones and specific fills when the RSI enters OB/OS territory.
Background Gradient: Optional vertical background color gradient based on the RSI's position between 0 and 100.
Configurable Parameters: Inputs for lengths, MA types, OB/OS levels, colors, line widths, and feature toggles.
Visual Elements Explained
Fibonacci Level RSI Line: The main plotted oscillator (color/gradient/width configurable).
Signal Line: The moving average of the RSI line (color/width/MA type configurable).
OB/OS Lines: Horizontal lines plotted at the set OB/OS levels (color/width configurable).
Mid-Line (50): Horizontal line plotted at 50 (color/width configurable).
Zone Fills:
Background fill between 0-50 and 50-100 (colors configurable).
Conditional fill between the RSI line and the 50 line when RSI > OB level or RSI < OS level (colors configurable).
Background Gradient: Optional background coloring where transparency varies vertically with the RSI level (base colors and transparency range configurable).
Configuration Options
Users can adjust the following parameters in the indicator settings:
Smoothing: Enable/disable dynamic level smoothing; set length and MA type.
RSI: Set the RSI calculation length.
Signal Line: Set the signal line smoothing length and MA type.
Levels: Define Overbought and Oversold numeric thresholds.
Visuals: Configure colors and widths for the RSI line, signal line, OB/OS lines, mid-line, zone fills, and OB/OS fills.
Gradients: Enable/disable and configure colors for the RSI line gradient; enable/disable and configure colors/transparency for the background gradient.
Interpretation Notes
The oscillator reflects the momentum of the dynamic Fibonacci level, not directly the price. Divergences, OB/OS readings, and signal line crossovers should be interpreted in this context.
The behavior may differ from standard RSI, potentially offering a smoother output or highlighting different momentum patterns depending on market structure and volatility.
As with any indicator, signals should be used in conjunction with other analysis methods and risk management practices. It is not designed as a standalone trading system.
Risk Disclaimer:
Trading involves significant risk. This indicator is provided for analytical purposes only and does not constitute financial advice. Past performance is not indicative of future results. Use sound risk management practices and never trade with capital you cannot afford to lose.
Prime Multi-Ticker Screener: Real-Time Market StructurePrime Multi-Ticker Screener: Real-Time Market Structure and Trend Detection Tool
Prime Multi-Ticker Screener is designed to track multiple tickers simultaneously, providing real-time insights into market trends and structure changes such as CHoCH (Change of Character) and BOS (Break of Structure). This tool is perfect for traders looking to monitor multiple assets across different timeframes while receiving clear signals that highlight critical market shifts. The indicator delivers instant visual feedback with color-coded backgrounds to make interpreting signals easy and efficient.
Core Features of Prime Multi-Ticker Screener
Multi-Ticker Monitoring: Track up to 5 tickers across multiple timeframes in a single dashboard. This makes it easy to watch several assets at once without cluttering your chart.
CHoCH and BOS Detection: The screener automatically detects and highlights significant market structure shifts. CHoCH signals are shown when a trend reverses or consolidates, while BOS signals indicate a break in previous highs or lows, helping traders catch potential trend reversals early.
Color-Coded Visuals: The background of each signal cell dynamically changes color to represent bullish or bearish signals. Green indicates bullish activity, while red highlights bearish market shifts, making it easy for traders to identify key movements at a glance.
Close Price and ATR Data: For each ticker, the screener displays both the current close price and the 14-period Average True Range (ATR), providing important volatility information to support decision-making.
Detailed Explanation of How Prime Multi-Ticker Screener Works
Prime Multi-Ticker Screener combines trend detection with real-time market structure analysis to deliver comprehensive market insights. It analyzes the following components:
CHoCH Detection: Change of Character occurs when the market switches from trending to ranging or vice versa. This indicator catches these moments by identifying when prices cross pivot levels, providing traders with a valuable signal of potential market phase changes.
BOS Detection: The Break of Structure function highlights moments when the price breaks a significant high or low, often indicating the start of a new trend or the continuation of an existing one.
Close Price & ATR Monitoring: Alongside market structure signals, the screener provides real-time data on the close price and the Average True Range (ATR), ensuring traders have a complete picture of the price and volatility landscape for each asset they are tracking.
Why It's Useful for Traders
Prime Multi-Ticker Screener is a versatile tool that offers substantial benefits to traders who want to stay informed about multiple assets and trends simultaneously:
Comprehensive Monitoring: Track multiple assets in real time, all from a single indicator. Whether you trade crypto, forex, or stocks, this tool helps you stay on top of market movements across different assets and timeframes.
Market Structure Analysis: The automatic detection of CHoCH and BOS signals gives traders an edge by identifying potential reversals and trend continuations as they happen, allowing for more timely and informed trading decisions.
Efficient and Intuitive Design: The screener is designed with simplicity in mind. The color-coded backgrounds quickly alert traders to market structure shifts without overwhelming them with data, making it ideal for those who need to act fast.
How It Works: Practical Usage
Prime Multi-Ticker Screener is ideal for:
Day traders: The real-time tracking of multiple assets allows day traders to quickly spot trading opportunities across different markets.
Swing traders: CHoCH and BOS detection help swing traders catch key market structure shifts, helping them align trades with emerging trends.
Trend followers: The screener provides instant feedback on when a trend is continuing or breaking, helping trend-following traders maintain their positions or exit early when needed.
By combining multiple key metrics—price, volatility, and market structure—Prime Multi-Ticker Screener ensures traders are well-equipped to manage their positions across a variety of assets.
Risk Disclaimer
While Prime Multi-Ticker Screener provides valuable market insights, it's important to remember:
Past performance is not indicative of future results: This screener provides analysis based on historical data, and no indicator can predict future market movements with certainty.
Market Conditions: The effectiveness of Prime Multi-Ticker Screener may vary in different market conditions, so traders should always use proper risk management when trading.
Trading Risks: Like any trading tool, Prime Multi-Ticker Screener should be used as part of a comprehensive trading strategy, including risk management techniques such as stop-loss orders and position sizing.
Dividend Calendar (Zeiierman)█ Overview
The Dividend Calendar is a financial tool designed for investors and analysts in the stock market. Its primary function is to provide a schedule of expected dividend payouts from various companies.
Dividends, which are portions of a company's earnings distributed to shareholders, represent a return on their investment. This calendar is particularly crucial for investors who prioritize dividend income, as it enables them to plan and manage their investment strategies with greater effectiveness. By offering a comprehensive overview of when dividends are due, the Dividend Calendar aids in informed decision-making, allowing investors to time their purchases and sales of stocks to optimize their dividend income. Additionally, it can be a valuable tool for forecasting cash flow and assessing the financial health and dividend-paying consistency of different companies.
█ How to Use
Dividend Yield Analysis:
By tracking dividend growth and payouts, traders can identify stocks with attractive dividend yields. This is particularly useful for income-focused investors who prioritize steady cash flow from their investments.
Income Planning:
For those relying on dividends as a source of income, the calendar helps in forecasting income.
Trend Identification:
Analyzing the growth rates of dividends helps in identifying long-term trends in a company's financial health. Consistently increasing dividends can be a sign of a company's strong financial position, while decreasing dividends might signal potential issues.
Portfolio Diversification:
The tool can assist in diversifying a portfolio by identifying a range of dividend-paying stocks across different sectors. This can help mitigate risk as different sectors may react differently to market conditions.
Timing Investments:
For those who follow a dividend capture strategy, this indicator can be invaluable. It can help in timing the buying and selling of stocks around their ex-dividend dates to maximize dividend income.
█ How it Works
This script is a comprehensive tool for tracking and analyzing stock dividend data. It calculates growth rates, monthly and yearly totals, and allows for custom date handling. Structured to be visually informative, it provides tables and alerts for the easy monitoring of dividend-paying stocks.
Data Retrieval and Estimation: It fetches dividend payout times and amounts for a list of stocks. The script also estimates future values based on historical data.
Growth Analysis: It calculates the average growth rate of dividend payments for each stock, providing insights into dividend consistency and growth over time.
Summation and Aggregation: The script sums up dividends on a monthly and yearly basis, allowing for a clear view of total payouts.
Customization and Alerts: Users can input custom months for dividend tracking. The script also generates alerts for upcoming or current dividend payouts.
Visualization: It produces various tables and visual representations, including full calendar views and income tables, to display the dividend data in an easily understandable format.
█ Settings
Overview:
Currency:
Description: This setting allows the user to specify the currency in which dividend values are displayed. By default, it's set to USD, but users can change it to their local currency.
Impact: Changing this value alters the currency denomination for all dividend values displayed by the script.
Ex-Date or Pay-Date:
Description: Users can select whether to show the Ex-dividend day or the Actual Payout day.
Impact: This changes the reference date for dividend data, affecting the timing of when dividends are shown as due or paid.
Estimate Forward:
Description: Enables traders to predict future dividends based on historical data.
Impact: When enabled, the script estimates future dividend payments, providing a forward-looking view of potential income.
Dividend Table Design:
Description: Choose between viewing the full dividend calendar, just the cumulative monthly dividend, or a summary view.
Impact: This alters the format and extent of the dividend data displayed, catering to different levels of detail a user might require.
Show Dividend Growth:
Description: Users can enable dividend growth tracking over a specified number of years.
Impact: When enabled, the script displays the growth rate of dividends over the selected number of years, providing insight into dividend trends.
Customize Stocks & User Inputs:
This setting allows users to customize the stocks they track, the number of shares they hold, the dividend payout amount, and the payout months.
Impact: Users can tailor the script to their specific portfolio, making the dividend data more relevant and personalized to their investments.
-----------------
Disclaimer
The information contained in my Scripts/Indicators/Ideas/Algos/Systems does not constitute financial advice or a solicitation to buy or sell any securities of any type. I will not accept liability for any loss or damage, including without limitation any loss of profit, which may arise directly or indirectly from the use of or reliance on such information.
All investments involve risk, and the past performance of a security, industry, sector, market, financial product, trading strategy, backtest, or individual's trading does not guarantee future results or returns. Investors are fully responsible for any investment decisions they make. Such decisions should be based solely on an evaluation of their financial circumstances, investment objectives, risk tolerance, and liquidity needs.
My Scripts/Indicators/Ideas/Algos/Systems are only for educational purposes!
Auto FaustAuto Faust – Intraday Market Context & Structure
Auto Faust is a visual market overlay designed for intraday traders who want fast context without relying on signals or automation. It combines classic price tools — VWAP, EMAs, RSI, Chop Score, and market structure trendlines — into a single glanceable dashboard.
🔍 What It Does:
VWAP (Volume Weighted Average Price): Shows the day's fair value price anchor.
EMAs (3, 21, 113, 200): Map short-term to long-term trend alignment. Crossovers can be used for confluence or caution.
RSI (10): Monitors local momentum. Displayed in a compact table.
Chop Score: Measures how directional price action is. High chop = ranging conditions; low = trending.
Session High/Low Tracker: Tracks the daily extremes in real-time.
Volume Monitor: Shows current candle volume, color-coded vs previous bar (green = higher, red = lower).
Dynamic Support & Resistance Lines: Plotted from pivot highs/lows (not static levels).
Automatic Trendlines: Drawn from swing structure, updating live.
📊 How to Use:
Use EMAs + VWAP alignment to assess directional bias.
Confirm clean trends with low Chop Score and RSI support.
Watch for price interaction around dynamic S/R lines and trendline breaks.
Use volume coloring to assess if momentum is increasing or fading.
No buy/sell signals are generated — this is a trader-facing tool to guide discretionary decision-making.
Seasonality DOW CombinedOverall Purpose
This script analyzes historical daily returns based on two specific criteria:
Month of the year (January through December)
Day of the week (Sunday through Saturday)
It summarizes and visually displays the average historical performance of the selected asset by these criteria over multiple years.
Step-by-Step Breakdown
1. Initial Settings:
Defines minimum year (i_year_start) from which data analysis will start.
Ensures the user is using a daily timeframe, otherwise prompts an error.
Sets basic display preferences like text size and color schemes.
2. Data Collection and Variables:
Initializes matrices to store and aggregate returns data:
month_data_ and month_agg_: store monthly performance.
dow_data_ and dow_agg_: store day-of-week performance.
COUNT tracks total number of occurrences, and COUNT_POSITIVE tracks positive-return occurrences.
3. Return Calculation:
Calculates daily percentage change (chg_pct_) in price:
chg_pct_ = close / close - 1
Ensures it captures this data only for the specified years (year >= i_year_start).
4. Monthly Performance Calculation:
Each daily return is grouped by month:
matrix.set updates total returns per month.
The script tracks:
Monthly cumulative returns
Number of occurrences (how many days recorded per month)
Positive occurrences (days with positive returns)
5. Day-of-Week Performance Calculation:
Similarly, daily returns are also grouped by day-of-the-week (Sunday to Saturday):
Daily return values are summed per weekday.
The script tracks:
Cumulative returns per weekday
Number of occurrences per weekday
Positive occurrences per weekday
6. Visual Display (Tables):
The script creates two visual tables:
Left Table: Monthly Performance.
Right Table: Day-of-the-Week Performance.
For each table, it shows:
Yearly data for each month/day.
Summaries at the bottom:
SUM row: Shows total accumulated returns over all selected years for each month/day.
+ive row: Shows percentage (%) of times the month/day had positive returns, along with a tooltip displaying positive occurrences vs total occurrences.
Cells are color-coded:
Green for positive returns.
Red for negative returns.
Gray for neutral/no change.
7. Interpreting the Tables:
Monthly Table (left side):
Helps identify seasonal patterns (e.g., historically bullish/bearish months).
Day-of-Week Table (right side):
Helps detect recurring weekday patterns (e.g., historically bullish Mondays or bearish Fridays).
Practical Use:
Traders use this to:
Identify patterns based on historical data.
Inform trading strategies, e.g., avoiding historically bearish days/months or leveraging historically bullish periods.
Example Interpretation:
If the table shows consistently green (positive) for March and April, historically the asset tends to perform well during spring. Similarly, if the "Friday" column is often red, historically Fridays are bearish for this asset.
