WhispererRealtimeVolumeLibrary "WhispererRealtimeVolume"
▮ Overview
The Whisperer Realtime Volume Library is a lightweight and reusable Pine Script® library designed for real-time volume analysis.
It calculates up, down, and neutral volumes dynamically, making it an essential tool for traders who want to gain deeper insights into market activity.
This library is a simplified and modular version of the original "Realtime Volume Bars w Market Buy/Sell/Neutral split & Mkt Delta" indicator by the_MarketWhisperer , tailored for integration into custom scripts.
How bars are classified
- Up Bars
If the current bar’s closing price is higher than the previous bar’s closing price, it is classified as an up bar.
Volume handling:
The increase in volume for this bar is added to the up volume.
This represents buying pressure.
- Down Bars
If the current bar’s closing price is lower than the previous bar’s closing price, it is classified as a down bar.
Volume handling:
The increase in volume for this bar is added to the down volume.
This represents selling pressure.
- Neutral Bars
If the current bar’s closing price is the same as the previous bar’s closing price, it is classified as a neutral bar.
Volume handling:
If neutral volume is enabled, the volume is added to the neutral volume.
If neutral volume is not enabled, the volume is assigned to the same direction as the previous bar (up or down). If the previous direction is unknown, it is added to the neutral volume.
▮ What to look for
Real-Time Volume Calculation : Analyze up, down, and neutral volumes in real-time based on price movements and bar volume.
Customizable Start Line : Add a visual reference line to your chart for better context by viewing the starting point of real-time bars.
Ease of Integration : Designed as a library for seamless use in other Pine Script® indicators or strategies.
▮ How to use
Example code:
//@version=6
indicator("Volume Realtime from Whisperer")
import andre_007/WhispererRealtimeVolume/4 as MW
MW.displayStartLine(startLineColor = color.gray, startLineWidth = 1, startLineStyle = line.style_dashed,
displayStartLine = true, y1=volume, y2=volume + 10)
= MW.mw_upDownVolumeRealtime(true)
plot(volume, style=plot.style_columns, color=color.gray)
plot(volumeUp, style=plot.style_columns, color=color.green)
plot(volumeDown, style=plot.style_columns, color=color.red)
plot(volumeNeutral, style=plot.style_columns, color=color.purple)
▮ Credits
This library is inspired by the original work of the_MarketWhisperer , whose "Realtime Volume Bars" indicator served as the foundation.
Link to original indicator :
Cari dalam skrip untuk "bar"
Anchored Darvas Box## ANCHORED DARVAS BOX
---
### OVERVIEW
**Anchored Darvas Box** lets you drop a single timestamp on your chart and build a Darvas-style consolidation zone forward from that exact candle. The indicator freezes the first user-defined number of bars to establish the range, verifies that price respects that range for another user-defined number of bars, then waits for the first decisive breakout. The resulting rectangle captures every tick of the accumulation phase and the exact moment of expansion—no manual drawing, complete timestamp precision.
---
### HISTORICAL BACKGROUND
Nicolas Darvas’s 1950s box theory tracked institutional accumulation by hand-drawing rectangles around tight price ranges. A trade was triggered only when price escaped the rectangle.
The anchored version preserves Darvas’s logic but pins the entire sequence to a user-chosen candle: perfect for analysing a market open, an earnings release, FOMC minute, or any other catalytic bar.
---
### ALGORITHM DETAIL
1. **ANCHOR BAR**
*You provide a timestamp via the settings panel.* The script waits until the chart reaches that bar and records its index as **startBar**.
2. **RANGE DEFINITION — BARS 1-7**
• `rangeHigh` = highest high of bars 1-7 plus optional tolerance.
• `rangeLow` = lowest low of bars 1-7 minus optional tolerance.
3. **RANGE VALIDATION — BARS 8-14**
• Price must stay inside ` `.
• Any violation aborts the test; no box is created.
4. **ARMED STATE**
• If bars 8-14 hold the range, two live guide-lines appear:
– **Green** at `rangeHigh`
– **Red** at `rangeLow`
• The script is now “armed,” waiting indefinitely for the first true breakout.
5. **BREAKOUT & BOX CREATION**
• **Up breakout** =`high > rangeHigh` → rectangle drawn in **green**.
• **Down breakout**=`low < rangeLow` → rectangle drawn in **red**.
• Box extends from **startBar** to the breakout bar and never updates again.
• Optional labels print the dollar and percentage height of the box at its left edge.
6. **OPTIONAL COOLDOWN**
• After the box is painted the script can stay silent for a user-defined number of bars, letting you study the fallout without another range immediately arming on top of it.
---
### INPUT PARAMETERS
• **ANCHOR TIME** – Precise yyyy-mm-dd HH:MM:SS that seeds the sequence.
• **BARS TO DEFINE RANGE** – Default 7; affects both definition and validation windows.
• **OPTIONAL TOLERANCE** – Absolute price buffer to ignore micro-wicks.
• **COOLDOWN BARS AFTER BREAKOUT** – Pause length before the indicator is allowed to re-anchor (set to zero to disable).
• **SHOW BOX DISTANCE LABELS** – Toggle to print Δ\$ and Δ% on every completed box.
---
### USER WORKFLOW
1. Add the indicator, open settings, and set **ANCHOR TIME** to the candle you care about (e.g., “2025-04-23 09:30:00” for NYSE open).
2. Watch live as the script:
– Paints the seven-bar range.
– Draws validation lines.
– Locks in the box on breakout.
3. Use the box boundaries as structural stops, targets, or context for further trades.
---
### PRACTICAL APPLICATIONS
• **OPENING RANGE BREAKOUTS** – Anchor at the first second of the session; capture the initial 7-bar range and trade the first clean break.
• **EVENT STUDIES** – Anchor at a news candle to measure immediate post-event volatility.
• **VOLUME PROFILE FUSION** – Combine the anchored box with VPVR to see if the breakout occurs at a high-volume node or a low-liquidity pocket.
• **RISK DISCIPLINE** – Stop-loss can sit just inside the opposite edge of the anchored range, enforcing objective risk.
---
### ADVANCED CUSTOMISATION IDEAS
• **MULTIPLE ANCHORS** – Clone the indicator and anchor several boxes (e.g., London open, New York open).
• **DYNAMIC WINDOW** – Switch the 7-bar fixed length to a volatility-scaled length (ATR percentile).
• **STRATEGY WRAPPER** – Turn the indicator into a `strategy{}` script and back-test anchored boxes on decades of data.
---
### FINAL THOUGHTS
Anchored Darvas Boxes give you Darvas’s timeless range-break methodology anchored to any candle of interest—perfect for dissecting openings, economic releases, or your own bespoke “important” bars with laboratory precision.
PIP Algorithm
# **Script Overview (For Non-Coders)**
1. **Purpose**
- The script tries to capture the essential “shape” of price movement by selecting a limited number of “key points” (anchors) from the latest bars.
- After selecting these anchors, it draws straight lines between them, effectively simplifying the price chart into a smaller set of points without losing major swings.
2. **How It Works, Step by Step**
1. We look back a certain number of bars (e.g., 50).
2. We start by drawing a straight line from the **oldest** bar in that range to the **newest** bar—just two points.
3. Next, we find the bar whose price is *farthest away* from that straight line. That becomes a new anchor point.
4. We “snap” (pin) the line to go exactly through that new anchor. Then we re-draw (re-interpolate) the entire line from the first anchor to the last, in segments.
5. We repeat the process (adding more anchors) until we reach the desired number of points. Each time, we choose the biggest gap between our line and the actual price, then re-draw the entire shape.
6. Finally, we connect these anchors on the chart with red lines, visually simplifying the price curve.
3. **Why It’s Useful**
- It highlights the most *important* bends or swings in the price over the chosen window.
- Instead of plotting every single bar, it condenses the information down to the “key turning points.”
4. **Key Takeaway**
- You’ll see a small number of red line segments connecting the **most significant** points in the price data.
- This is especially helpful if you want a simplified view of recent price action without minor fluctuations.
## **Detailed Logic Explanation**
# **Script Breakdown (For Coders)**
//@version=5
indicator(title="PIP Algorithm", overlay=true)
// 1. Inputs
length = input.int(50, title="Lookback Length")
num_points = input.int(5, title="Number of PIP Points (≥ 3)")
// 2. Helper Functions
// ---------------------------------------------------------------------
// reInterpSubrange(...):
// Given two “anchor” indices in `linesArr`, linearly interpolate
// the array values in between so that the subrange forms a straight line
// from linesArr to linesArr .
reInterpSubrange(linesArr, segmentLeft, segmentRight) =>
float leftVal = array.get(linesArr, segmentLeft)
float rightVal = array.get(linesArr, segmentRight)
int segmentLen = segmentRight - segmentLeft
if segmentLen > 1
for i = segmentLeft + 1 to segmentRight - 1
float ratio = (i - segmentLeft) / segmentLen
float interpVal = leftVal + (rightVal - leftVal) * ratio
array.set(linesArr, i, interpVal)
// reInterpolateAllSegments(...):
// For the entire “linesArr,” re-interpolate each subrange between
// consecutive breakpoints in `lineBreaksArr`.
// This ensures the line is globally correct after each new anchor insertion.
reInterpolateAllSegments(linesArr, lineBreaksArr) =>
array.sort(lineBreaksArr, order.asc)
for i = 0 to array.size(lineBreaksArr) - 2
int leftEdge = array.get(lineBreaksArr, i)
int rightEdge = array.get(lineBreaksArr, i + 1)
reInterpSubrange(linesArr, leftEdge, rightEdge)
// getMaxDistanceIndex(...):
// Return the index (bar) that is farthest from the current “linesArr.”
// We skip any indices already in `lineBreaksArr`.
getMaxDistanceIndex(linesArr, closeArr, lineBreaksArr) =>
float maxDist = -1.0
int maxIdx = -1
int sizeData = array.size(linesArr)
for i = 1 to sizeData - 2
bool isBreak = false
for b = 0 to array.size(lineBreaksArr) - 1
if i == array.get(lineBreaksArr, b)
isBreak := true
break
if not isBreak
float dist = math.abs(array.get(linesArr, i) - array.get(closeArr, i))
if dist > maxDist
maxDist := dist
maxIdx := i
maxIdx
// snapAndReinterpolate(...):
// "Snap" a chosen index to its actual close price, then re-interpolate the entire line again.
snapAndReinterpolate(linesArr, closeArr, lineBreaksArr, idxToSnap) =>
if idxToSnap >= 0
float snapVal = array.get(closeArr, idxToSnap)
array.set(linesArr, idxToSnap, snapVal)
reInterpolateAllSegments(linesArr, lineBreaksArr)
// 3. Global Arrays and Flags
// ---------------------------------------------------------------------
// We store final data globally, then use them outside the barstate.islast scope to draw lines.
var float finalCloseData = array.new_float()
var float finalLines = array.new_float()
var int finalLineBreaks = array.new_int()
var bool didCompute = false
var line pipLines = array.new_line()
// 4. Main Logic (Runs Once at the End of the Current Bar)
// ---------------------------------------------------------------------
if barstate.islast
// A) Prepare closeData in forward order (index 0 = oldest bar, index length-1 = newest)
float closeData = array.new_float()
for i = 0 to length - 1
array.push(closeData, close )
// B) Initialize linesArr with a simple linear interpolation from the first to the last point
float linesArr = array.new_float()
float firstClose = array.get(closeData, 0)
float lastClose = array.get(closeData, length - 1)
for i = 0 to length - 1
float ratio = (length > 1) ? (i / float(length - 1)) : 0.0
float val = firstClose + (lastClose - firstClose) * ratio
array.push(linesArr, val)
// C) Initialize lineBreaks with two anchors: 0 (oldest) and length-1 (newest)
int lineBreaks = array.new_int()
array.push(lineBreaks, 0)
array.push(lineBreaks, length - 1)
// D) Iteratively insert new breakpoints, always re-interpolating globally
int iterationsNeeded = math.max(num_points - 2, 0)
for _iteration = 1 to iterationsNeeded
// 1) Re-interpolate entire shape, so it's globally up to date
reInterpolateAllSegments(linesArr, lineBreaks)
// 2) Find the bar with the largest vertical distance to this line
int maxDistIdx = getMaxDistanceIndex(linesArr, closeData, lineBreaks)
if maxDistIdx == -1
break
// 3) Insert that bar index into lineBreaks and snap it
array.push(lineBreaks, maxDistIdx)
array.sort(lineBreaks, order.asc)
snapAndReinterpolate(linesArr, closeData, lineBreaks, maxDistIdx)
// E) Save results into global arrays for line drawing outside barstate.islast
array.clear(finalCloseData)
array.clear(finalLines)
array.clear(finalLineBreaks)
for i = 0 to array.size(closeData) - 1
array.push(finalCloseData, array.get(closeData, i))
array.push(finalLines, array.get(linesArr, i))
for b = 0 to array.size(lineBreaks) - 1
array.push(finalLineBreaks, array.get(lineBreaks, b))
didCompute := true
// 5. Drawing the Lines in Global Scope
// ---------------------------------------------------------------------
// We cannot create lines inside barstate.islast, so we do it outside.
array.clear(pipLines)
if didCompute
// Connect each pair of anchors with red lines
if array.size(finalLineBreaks) > 1
for i = 0 to array.size(finalLineBreaks) - 2
int idxLeft = array.get(finalLineBreaks, i)
int idxRight = array.get(finalLineBreaks, i + 1)
float x1 = bar_index - (length - 1) + idxLeft
float x2 = bar_index - (length - 1) + idxRight
float y1 = array.get(finalCloseData, idxLeft)
float y2 = array.get(finalCloseData, idxRight)
line ln = line.new(x1, y1, x2, y2, extend=extend.none)
line.set_color(ln, color.red)
line.set_width(ln, 2)
array.push(pipLines, ln)
1. **Data Collection**
- We collect the **most recent** `length` bars in `closeData`. Index 0 is the oldest bar in that window, index `length-1` is the newest bar.
2. **Initial Straight Line**
- We create an array called `linesArr` that starts as a simple linear interpolation from `closeData ` (the oldest bar’s close) to `closeData ` (the newest bar’s close).
3. **Line Breaks**
- We store “anchor points” in `lineBreaks`, initially ` `. These are the start and end of our segment.
4. **Global Re-Interpolation**
- Each time we want to add a new anchor, we **re-draw** (linear interpolation) for *every* subrange ` [lineBreaks , lineBreaks ]`, ensuring we have a globally consistent line.
- This avoids the “local subrange only” approach, which can cause clustering near existing anchors.
5. **Finding the Largest Distance**
- After re-drawing, we compute the vertical distance for each bar `i` that isn’t already a line break. The bar with the biggest distance from the line is chosen as the next anchor (`maxDistIdx`).
6. **Snapping and Re-Interpolate**
- We “snap” that bar’s line value to the actual close, i.e. `linesArr = closeData `. Then we globally re-draw all segments again.
7. **Repeat**
- We repeat these insertions until we have the desired number of points (`num_points`).
8. **Drawing**
- Finally, we connect each consecutive pair of anchor points (`lineBreaks`) with a `line.new(...)` call, coloring them red.
- We offset the line’s `x` coordinate so that the anchor at index 0 lines up with `bar_index - (length - 1)`, and the anchor at index `length-1` lines up with `bar_index` (the current bar).
**Result**:
You get a simplified representation of the price with a small set of line segments capturing the largest “jumps” or swings. By re-drawing the entire line after each insertion, the anchors tend to distribute more *evenly* across the data, mitigating the issue where anchors bunch up near each other.
Enjoy experimenting with different `length` and `num_points` to see how the simplified lines change!
William Fractals + SignalsWilliams Fractals + Trading Signals
This indicator identifies Williams Fractals and generates trading signals based on price sweeps of these fractal levels.
Williams Fractals are specific candlestick patterns that identify potential market turning points. Each fractal requires a minimum of 5 bars (2 before, 1 center, 2 after), though this indicator allows you to customize the number of bars checked.
Up Fractal (High Point) forms when you have a center bar whose HIGH is higher than the highs of 'n' bars before and after it. For example, with n=2, you'd see a pattern where the center bar's high is higher than 2 bars before and 2 bars after it. The indicator also recognizes patterns where up to 4 bars after the center can have equal highs before requiring a lower high.
Down Fractal (Low Point) forms when you have a center bar whose LOW is lower than the lows of 'n' bars before and after it. For example, with n=2, you'd see a pattern where the center bar's low is lower than 2 bars before and 2 bars after it. The indicator also recognizes patterns where up to 4 bars after the center can have equal lows before requiring a higher low.
Trading Signals:
The indicator generates signals when price "sweeps" these fractal levels:
Buy Signal (Green Triangle) triggers when price sweeps a down fractal. This requires price to go BELOW the down fractal's low level and then CLOSE ABOVE it . This pattern often indicates a failed breakdown and potential reversal upward.
Sell Signal (Red Triangle) triggers when price sweeps an up fractal. This requires price to go ABOVE the up fractal's high level and then CLOSE BELOW it. This pattern often indicates a failed breakout and potential reversal downward.
Customizable Settings:
1. Periods (default: 10) - How many bars to check before and after the center bar (minimum value: 2)
2. Maximum Stored Fractals (default: 1) - How many fractal levels to keep in memory. Older levels are removed when this limit is reached to prevent excessive signals and maintain indicator performance.
Important Notes:
• The indicator checks the actual HIGH and LOW prices of each bar, not just closing prices
• Fractal levels are automatically removed after generating a signal to prevent repeated triggers
• Signals are only generated on bar close to avoid false triggers
• Alerts include the ticker symbol and the exact price level where the sweep occurred
Common Use Cases:
• Identifying potential reversal points
• Finding stop-hunt levels where price might reverse
• Setting stop-loss levels above up fractals or below down fractals
• Trading failed breakouts/breakdowns at fractal levels
Salman Indicator: Multi-Purpose Price ActionSalman Indicator: Multi-Purpose Price Action Tool for Pin Bars, Breakouts, and VWAP Anchoring
This indicator provides a comprehensive suite of price action insights, designed for active traders looking to identify key market structures and potential reversals. The script incorporates a Quarterly VWAP for trend bias, marks pin bars for possible reversal points, highlights outside bars for volatility signals, and indicates simple breakouts and pivot-level breaks. Customizable settings allow for flexibility in various trading styles, with default settings optimized for daily charts.
Outside Bars : Represented by an ⤬ symbol on the chart, these indicate bars where the current high is greater than the previous bar’s high, and the low is lower than the previous bar’s low, signaling high volatility and potential market reversals.
Pin Bars : Denoted by a small dot at the top or bottom of a candle’s wick, these are crucial signals of potential reversal areas. Pin bars are identified based on the percentage length of their shadows, with adjustable strictness in settings.
Quarterly VWAP : The light blue line on the chart represents the VWAP (Volume-Weighted Average Price), which is anchored to the Quarterly period by default. The VWAP acts as a directional bias filter, helping you to determine underlying market trends. This period, source, and offset are fully adjustable in the script’s settings.
Simple Breaks : Hollow candles on the chart indicate "simple breaks," defined when the current bar closes above the previous high or below the previous low. This is an effective way to highlight directional momentum in the market.
Bonus Pivot Breaks : The tilde symbol ~ appears when the price closes above or below prior pivot high/low levels, helping traders spot significant breakout or breakdown points relative to recent pivots.
Alerts
Simple Breaks : Alerts you when a breakout occurs beyond the previous bar’s high or low. Pin Bars : Notifies you of potential reversal points as indicated by bullish or bearish pin bars. Outside Bars : Triggers an alert whenever an outside bar is detected, indicating possible volatility changes.
How to Use
VWAP for Trend Bias : Use the Quarterly VWAP line to gauge overall market trend, with settings that allow adjustment to daily, weekly, monthly, or even larger time frames.
Pin Bars for Reversal Potential : Look for the dot markers on candle wicks, where the strictness of the pin bar detection can be adjusted via settings to match your trading preference.
Simple and Pivot Breaks for Momentum : Watch for hollow candles and the tilde symbol ~ as indicators of potential breakout momentum and pivot break levels, respectively.
This script can serve traders on multiple timeframes, from daily to weekly and beyond. The flexible configuration allows for adjustments in VWAP anchoring and pin bar criteria, providing a tailored fit for individual trading strategies.
D9 IndicatorD9 Indicator
Category
Technical Indicators
Overview
The D9 Indicator is designed to identify potential trend reversals by counting the number of consecutive closes that are higher or lower than the close four bars earlier. This indicator highlights key moments in the price action where a trend might be exhausting and potentially reversing, providing valuable insights for traders.
Features
Up Signal: Plots a downward triangle or a cross above the bar when the count of consecutive closes higher than the close four bars earlier reaches 7, 8, or 9.
Down Signal: Plots an upward triangle or a checkmark below the bar when the count of consecutive closes lower than the close four bars earlier reaches 7, 8, or 9.
Visual Signals
Red Downward Triangle (7): Indicates the seventh consecutive bar with a higher close.
Red Downward Triangle (8): Indicates the eighth consecutive bar with a higher close.
Red Cross (❌): Indicates the ninth consecutive bar with a higher close, suggesting a potential bearish reversal.
Green Upward Triangle (7): Indicates the seventh consecutive bar with a lower close.
Green Upward Triangle (8): Indicates the eighth consecutive bar with a lower close.
Green Checkmark (✅): Indicates the ninth consecutive bar with a lower close, suggesting a potential bullish reversal.
Usage
The D9 Indicator is useful for traders looking for visual cues to identify potential trend exhaustion and reversals. It can be applied to any market and timeframe, providing flexibility in various trading strategies.
How to Read
When a red cross (❌) appears above a bar, it may signal an overextended uptrend and a potential bearish reversal.
When a green checkmark (✅) appears below a bar, it may signal an overextended downtrend and a potential bullish reversal.
Example
When the price has consecutively closed higher than four bars ago for nine bars, a red cross (❌) will appear above the ninth bar. This suggests that the uptrend might be exhausting, and traders could look for potential short opportunities. Conversely, when the price has consecutively closed lower than four bars ago for nine bars, a green checkmark (✅) will appear below the ninth bar, indicating a potential buying opportunity.
chrono_utilsLibrary "chrono_utils"
Collection of objects and common functions that are related to datetime windows session days and time
ranges. The main purpose of this library is to handle time-related functionality and make it easy to reason about a
future bar checking if it will be part of a predefined session and/or inside a datetime window. All existing session
functionality I found in the documentation e.g. "not na(time(timeframe, session, timezone))" are not suitable for
strategy scripts, since the execution of the orders is delayed by one bar, due to the script execution happening at
the bar close. Moreover, a history operator with a negative value that looks forward is not allowed in any pinescript
expression. So, a prediction for the next bar using the bars_back argument of "time()"" and "time_close()" was
necessary. Thus, I created this library to overcome this small but very important limitation. In the meantime, I
added useful functionality to handle session-based behavior. An interesting utility that emerged from this
development is the data anomaly detection where a comparison between the prediction and the actual value is happening.
If those two values are different then a data inconsistency happened between the prediction bar and the actual bar
(probably due to a holiday, half session day, a timezone change etc..)
exTimezone(timezone)
exTimezone - Convert extended timezone to timezone string
Parameters:
timezone (simple string) : - The timezone or a special string
Returns: string representing the timezone
nameOfDay(day)
nameOfDay - Convert the day id into a short nameOfDay
Parameters:
day (int) : - The day id to convert
Returns: - The short name of the day
today()
today - Get the day id of this day
Returns: - The day id
nthDayAfter(day, n)
nthDayAfter - Get the day id of n days after the given day
Parameters:
day (int) : - The day id of the reference day
n (int) : - The number of days to go forward
Returns: - The day id of the day that is n days after the reference day
nextDayAfter(day)
nextDayAfter - Get the day id of next day after the given day
Parameters:
day (int) : - The day id of the reference day
Returns: - The day id of the next day after the reference day
nthDayBefore(day, n)
nthDayBefore - Get the day id of n days before the given day
Parameters:
day (int) : - The day id of the reference day
n (int) : - The number of days to go forward
Returns: - The day id of the day that is n days before the reference day
prevDayBefore(day)
prevDayBefore - Get the day id of previous day before the given day
Parameters:
day (int) : - The day id of the reference day
Returns: - The day id of the previous day before the reference day
tomorrow()
tomorrow - Get the day id of the next day
Returns: - The next day day id
normalize(num, min, max)
normalizeHour - Check if number is inthe range of
Parameters:
num (int)
min (int)
max (int)
Returns: - The normalized number
normalizeHour(hourInDay)
normalizeHour - Check if hour is valid and return a noralized hour range from
Parameters:
hourInDay (int)
Returns: - The normalized hour
normalizeMinute(minuteInHour)
normalizeMinute - Check if minute is valid and return a noralized minute from
Parameters:
minuteInHour (int)
Returns: - The normalized minute
monthInMilliseconds(mon)
monthInMilliseconds - Calculate the miliseconds in one bar of the timeframe
Parameters:
mon (int) : - The month of reference to get the miliseconds
Returns: - The number of milliseconds of the month
barInMilliseconds()
barInMilliseconds - Calculate the miliseconds in one bar of the timeframe
Returns: - The number of milliseconds in one bar
method to_string(this)
to_string - Formats the time window into a human-readable string
Namespace types: DateTimeWindow
Parameters:
this (DateTimeWindow) : - The time window object with the from and to datetimes
Returns: - The string of the time window
method to_string(this)
to_string - Formats the session days into a human-readable string with short day names
Namespace types: SessionDays
Parameters:
this (SessionDays) : - The session days object with the day selection
Returns: - The string of the session day short names
method to_string(this)
to_string - Formats the session time into a human-readable string
Namespace types: SessionTime
Parameters:
this (SessionTime) : - The session time object with the hour and minute of the time of the day
Returns: - The string of the session time
method to_string(this)
to_string - Formats the session time into a human-readable string
Namespace types: SessionTimeRange
Parameters:
this (SessionTimeRange) : - The session time range object with the start and end time of the daily session
Returns: - The string of the session time
method to_string(this)
to_string - Formats the session into a human-readable string
Namespace types: Session
Parameters:
this (Session) : - The session object with the day and the time range selection
Returns: - The string of the session
method init(this, fromDateTime, toDateTime)
init - Initialize the time window object from boolean values of each session day
Namespace types: DateTimeWindow
Parameters:
this (DateTimeWindow) : - The time window object that will hold the from and to datetimes
fromDateTime (int) : - The starting datetime of the time window
toDateTime (int) : - The ending datetime of the time window
Returns: - The time window object
method init(this, refTimezone, chTimezone, fromDateTime, toDateTime)
init - Initialize the time window object from boolean values of each session day
Namespace types: DateTimeWindow
Parameters:
this (DateTimeWindow) : - The time window object that will hold the from and to datetimes
refTimezone (simple string) : - The timezone of reference of the 'from' and 'to' dates
chTimezone (simple string) : - The target timezone to convert the 'from' and 'to' dates
fromDateTime (int) : - The starting datetime of the time window
toDateTime (int) : - The ending datetime of the time window
Returns: - The time window object
method init(this, sun, mon, tue, wed, thu, fri, sat)
init - Initialize the session days object from boolean values of each session day
Namespace types: SessionDays
Parameters:
this (SessionDays) : - The session days object that will hold the day selection
sun (bool) : - Is Sunday a trading day?
mon (bool) : - Is Monday a trading day?
tue (bool) : - Is Tuesday a trading day?
wed (bool) : - Is Wednesday a trading day?
thu (bool) : - Is Thursday a trading day?
fri (bool) : - Is Friday a trading day?
sat (bool) : - Is Saturday a trading day?
Returns: - The session days object
method init(this, unixTime)
init - Initialize the object from the hour and minute of the session time in exchange timezone (syminfo.timezone)
Namespace types: SessionTime
Parameters:
this (SessionTime) : - The session time object with the hour and minute of the time of the day
unixTime (int) : - The unix time
Returns: - The session time object
method init(this, hourInDay, minuteInHour)
init - Initialize the object from the hour and minute of the session time in exchange timezone (syminfo.timezone)
Namespace types: SessionTime
Parameters:
this (SessionTime) : - The session time object with the hour and minute of the time of the day
hourInDay (int) : - The hour of the time
minuteInHour (int) : - The minute of the time
Returns: - The session time object
method init(this, hourInDay, minuteInHour, refTimezone)
init - Initialize the object from the hour and minute of the session time
Namespace types: SessionTime
Parameters:
this (SessionTime) : - The session time object with the hour and minute of the time of the day
hourInDay (int) : - The hour of the time
minuteInHour (int) : - The minute of the time
refTimezone (string) : - The timezone of reference of the 'hour' and 'minute'
Returns: - The session time object
method init(this, startTime, endTime)
init - Initialize the object from the start and end session time in exchange timezone (syminfo.timezone)
Namespace types: SessionTimeRange
Parameters:
this (SessionTimeRange) : - The session time range object that will hold the start and end time of the daily session
startTime (SessionTime) : - The time the session begins
endTime (SessionTime) : - The time the session ends
Returns: - The session time range object
method init(this, startTimeHour, startTimeMinute, endTimeHour, endTimeMinute, refTimezone)
init - Initialize the object from the start and end session time
Namespace types: SessionTimeRange
Parameters:
this (SessionTimeRange) : - The session time range object that will hold the start and end time of the daily session
startTimeHour (int) : - The time hour the session begins
startTimeMinute (int) : - The time minute the session begins
endTimeHour (int) : - The time hour the session ends
endTimeMinute (int) : - The time minute the session ends
refTimezone (string)
Returns: - The session time range object
method init(this, days, timeRanges)
init - Initialize the session object from session days and time range
Namespace types: Session
Parameters:
this (Session) : - The session object that will hold the day and the time range selection
days (SessionDays) : - The session days object that defines the days the session is happening
timeRanges (array) : - The array of all the session time ranges during a session day
Returns: - The session object
method init(this, days, timeRanges, names, colors)
init - Initialize the session object from session days and time range
Namespace types: SessionView
Parameters:
this (SessionView) : - The session view object that will hold the session, the names and the color selections
days (SessionDays) : - The session days object that defines the days the session is happening
timeRanges (array) : - The array of all the session time ranges during a session day
names (array) : - The array of the names of the sessions
colors (array) : - The array of the colors of the sessions
Returns: - The session object
method get_size_in_secs(this)
get_size_in_secs - Count the seconds from start to end in the given timeframe
Namespace types: DateTimeWindow
Parameters:
this (DateTimeWindow) : - The time window object with the from and to datetimes
Returns: - The number of seconds inside the time widow for the given timeframe
method get_size_in_secs(this)
get_size_in_secs - Calculate the seconds inside the session
Namespace types: SessionTimeRange
Parameters:
this (SessionTimeRange) : - The session time range object with the start and end time of the daily session
Returns: - The number of seconds inside the session
method get_size_in_bars(this)
get_size_in_bars - Count the bars from start to end in the given timeframe
Namespace types: DateTimeWindow
Parameters:
this (DateTimeWindow) : - The time window object with the from and to datetimes
Returns: - The number of bars inside the time widow for the given timeframe
method get_size_in_bars(this)
get_size_in_bars - Calculate the bars inside the session
Namespace types: SessionTimeRange
Parameters:
this (SessionTimeRange) : - The session time range object with the start and end time of the daily session
Returns: - The number of bars inside the session for the given timeframe
method is_bar_included(this, offset_forward)
is_bar_included - Check if the given bar is between the start and end dates of the window
Namespace types: DateTimeWindow
Parameters:
this (DateTimeWindow) : - The time window object with the from and to datetimes
offset_forward (simple int) : - The number of bars forward. Default is 1
Returns: - Whether the current bar is inside the datetime window
method is_bar_included(this, offset_forward)
is_bar_included - Check if the given bar is inside the session as defined by the input params (what "not na(time(timeframe.period, this.to_sess_string()) )" should return if you could write it
Namespace types: Session
Parameters:
this (Session) : - The session with the day and the time range selection
offset_forward (simple int) : - The bar forward to check if it is between the from and to datetimes. Default is 1
Returns: - Whether the current time is inside the session
method to_sess_string(this)
to_sess_string - Formats the session days into a session string with day ids
Namespace types: SessionDays
Parameters:
this (SessionDays) : - The session days object
Returns: - The string of the session day ids
method to_sess_string(this)
to_sess_string - Formats the session time into a session string
Namespace types: SessionTime
Parameters:
this (SessionTime) : - The session time object with the hour and minute of the time of the day
Returns: - The string of the session time
method to_sess_string(this)
to_sess_string - Formats the session time into a session string
Namespace types: SessionTimeRange
Parameters:
this (SessionTimeRange) : - The session time range object with the start and end time of the daily session
Returns: - The string of the session time
method to_sess_string(this)
to_sess_string - Formats the session into a session string
Namespace types: Session
Parameters:
this (Session) : - The session object with the day and the time range selection
Returns: - The string of the session
method from_sess_string(this, sess)
from_sess_string - Initialize the session days object from the session string
Namespace types: SessionDays
Parameters:
this (SessionDays) : - The session days object that will hold the day selection
sess (string) : - The session string part that represents the days
Returns: - The session days object
method from_sess_string(this, sess)
from_sess_string - Initialize the session time object from the session string in exchange timezone (syminfo.timezone)
Namespace types: SessionTime
Parameters:
this (SessionTime) : - The session time object that will hold the hour and minute of the time
sess (string) : - The session string part that represents the time HHmm
Returns: - The session time object
method from_sess_string(this, sess, refTimezone)
from_sess_string - Initialize the session time object from the session string
Namespace types: SessionTime
Parameters:
this (SessionTime) : - The session time object that will hold the hour and minute of the time
sess (string) : - The session string part that represents the time HHmm
refTimezone (simple string) : - The timezone of reference of the 'hour' and 'minute'
Returns: - The session time object
method from_sess_string(this, sess)
from_sess_string - Initialize the session time range object from the session string in exchange timezone (syminfo.timezone)
Namespace types: SessionTimeRange
Parameters:
this (SessionTimeRange) : - The session time range object that will hold the start and end time of the daily session
sess (string) : - The session string part that represents the time range HHmm-HHmm
Returns: - The session time range object
method from_sess_string(this, sess, refTimezone)
from_sess_string - Initialize the session time range object from the session string
Namespace types: SessionTimeRange
Parameters:
this (SessionTimeRange) : - The session time range object that will hold the start and end time of the daily session
sess (string) : - The session string part that represents the time range HHmm-HHmm
refTimezone (simple string) : - The timezone of reference of the time ranges
Returns: - The session time range object
method from_sess_string(this, sess)
from_sess_string - Initialize the session object from the session string in exchange timezone (syminfo.timezone)
Namespace types: Session
Parameters:
this (Session) : - The session object that will hold the day and the time range selection
sess (string) : - The session string that represents the session HHmm-HHmm,HHmm-HHmm:ddddddd
Returns: - The session time range object
method from_sess_string(this, sess, refTimezone)
from_sess_string - Initialize the session object from the session string
Namespace types: Session
Parameters:
this (Session) : - The session object that will hold the day and the time range selection
sess (string) : - The session string that represents the session HHmm-HHmm,HHmm-HHmm:ddddddd
refTimezone (simple string) : - The timezone of reference of the time ranges
Returns: - The session time range object
method nth_day_after(this, day, n)
nth_day_after - The nth day after the given day that is a session day (true) in the object
Namespace types: SessionDays
Parameters:
this (SessionDays) : - The session days object with the day selection
day (int) : - The day id of the reference day
n (int) : - The number of days after
Returns: - The day id of the nth session day of the week after the given day
method nth_day_before(this, day, n)
nth_day_before - The nth day before the given day that is a session day (true) in the object
Namespace types: SessionDays
Parameters:
this (SessionDays) : - The session days object with the day selection
day (int) : - The day id of the reference day
n (int) : - The number of days after
Returns: - The day id of the nth session day of the week before the given day
method next_day(this)
next_day - The next day that is a session day (true) in the object
Namespace types: SessionDays
Parameters:
this (SessionDays) : - The session days object with the day selection
Returns: - The day id of the next session day of the week
method previous_day(this)
previous_day - The previous day that is session day (true) in the object
Namespace types: SessionDays
Parameters:
this (SessionDays) : - The session days object with the day selection
Returns: - The day id of the previous session day of the week
method get_sec_in_day(this)
get_sec_in_day - Count the seconds since the start of the day this session time represents
Namespace types: SessionTime
Parameters:
this (SessionTime) : - The session time object with the hour and minute of the time of the day
Returns: - The number of seconds passed from the start of the day until that session time
method get_ms_in_day(this)
get_ms_in_day - Count the milliseconds since the start of the day this session time represents
Namespace types: SessionTime
Parameters:
this (SessionTime) : - The session time object with the hour and minute of the time of the day
Returns: - The number of milliseconds passed from the start of the day until that session time
method is_day_included(this, day)
is_day_included - Check if the given day is inside the session days
Namespace types: SessionDays
Parameters:
this (SessionDays) : - The session days object with the day selection
day (int) : - The day to check if it is a trading day
Returns: - Whether the current day is included in the session days
DateTimeWindow
DateTimeWindow - Object that represents a datetime window with a beginning and an end
Fields:
fromDateTime (series int) : - The beginning of the datetime window
toDateTime (series int) : - The end of the datetime window
SessionDays
SessionDays - Object that represent the trading days of the week
Fields:
days (map) : - The map that contains all days of the week and their session flag
SessionTime
SessionTime - Object that represents the time (hour and minutes)
Fields:
hourInDay (series int) : - The hour of the day that ranges from 0 to 24
minuteInHour (series int) : - The minute of the hour that ranges from 0 to 59
minuteInDay (series int) : - The minute of the day that ranges from 0 to 1440. They will be calculated based on hourInDay and minuteInHour when method is called
SessionTimeRange
SessionTimeRange - Object that represents a range that extends from the start to the end time
Fields:
startTime (SessionTime) : - The beginning of the time range
endTime (SessionTime) : - The end of the time range
isOvernight (series bool) : - Whether or not this is an overnight time range
Session
Session - Object that represents a session
Fields:
days (SessionDays) : - The map of the trading days
timeRanges (array) : - The array with all time ranges of the session during the trading days
SessionView
SessionView - Object that visualize a session
Fields:
sess (Session) : - The Session object to be visualized
names (array) : - The names of the session time ranges
colors (array) : - The colors of the session time ranges
[TTI] High Volume Close (HVC) Setup📜 ––––HISTORY & CREDITS––––
The High Volume Close (HVC) Setup is a specialised indicator designed for the TradingView platform used to identify specific bar. This tool was developed with the objective of identifying a technical pattern that trades have claimed is significant trading opportunities through a unique blend of volume analysis and price action strategies. It is based on the premise that high-volume bars, when combined with specific price action criteria, can signal key market movements.
The HVC is applicable both for swing and longer term trading and as a technical tool it can be used by traders of any asset type (stocks, ETF, crypto, forex etc).
🦄 –––UNIQUENESS–––
The uniqueness of the HVC Setup lies in its flexibility to determine an important price level based on historically important bar. The idea is to identify significant bars (e.g. those who have created the HIGHEST VOLUME: Ever, Yearly, Quarterly and meet additional criteria from the settings) and plot on the chart the close on that day as a significant level as well as theoretical stop loss and target levels. This approach allows traders to discern high volume bars that are contextually significant — a method not commonly found in standard trading tools.
🎯 ––––WHAT IT DOES––––
The HVC Setup indicator performs a series of calculations to identify high volume close bars/bar (HVC bars) based on the user requirements.
These bars are determined based on the highest volume recorded within a user-inputs:
👉 Period (Ever, Yearly, Quarterly) and must meet additional criteria such as:
👉 a minimum percentage Price Change (change is calculated based on a close/close) and
👉 specific Closing Range requirements for the HVC da.
The theory is that this is a significant bar that is important to know where it is on the chart.
The script includes a comparative analysis of the HVC bar's price against historical price highs (all-time, yearly, quarterly), which provides further context and significance to the identified bars. All of these USER input requirement are then taken into account as a condition to identity the High Volume Close Bar (HVC).
The visual representation includes color-coded bar (default is yellow) and lines to delineate these key trading signals. It then draws a blue line for the place where the close ofthe bar is, a red line that would signify a stop loss and 2 target profit levels equal to 2R and 3R of the risked level (close-stop loss). Additional lines can be turned on/off with their coresponding checkboxes in the settings.
If the user chooses "Ever" for Period - the script will look at the first available bar ever in Tradingview - this is generally the IPO bar;
If the users chooses "Yearly" - the script would look at the highest available bar for a completed year;
If the users chooses "Quarterly" - it would do the same for the quarter. (works on daily timeframe only);
While we have not backtested the performance of the script, this methodology has been widely publicised.
🛠️ ––––HOW TO USE IT––––
To utilize the HVC Setup effectively:
👉Customize Input Settings: Choose the HVC period, percentage change threshold, closing range, stop loss distance, and target multiples according to your trading strategy. Use the tick boxes to enable and disable if a given condition is used within the calculation.
👉Identify HVC Bars: The script highlights HVC bars, indicating potential opportunities based on volume and price action analysis.
👉Interpret Targets and Stop Losses: Use the color-coded lines (green for targets, red for stop losses) to guide your trade entries and exits.
👉Contextual Analysis: Always consider the HVC bar signals in conjunction with overall market trends and additional technical indicators for comprehensive trading decisions.
This script is designed to assist traders in identifying high-potential trading setups by using a combination of volume and price analysis, enhancing traditional methods with a unique, algorithmically driven approach.
Price Volume Harmony Indicator [Nasan]The indicator "Price Volume Harmony Indicator " (abbreviated as PVHI) combines relative volume intensity (RVI) and relative price change (PC) to identify potential synergy or divergence between price and volume movements. Let's break down the key components and discuss how to interpret the output:
Relative Volume Intensity (RVI):
It calculates the mean volume intensity using simple moving averages (SMA) of different periods (5, 8, 13, and 144).
It then computes point volume intensity based on the current volume compared to the previous bar's volume.
The final RVI is a combination of mean and point volume intensities.
Relative Price Change (PC):
It calculates the median absolute deviation (MAD) and the price change relative to MAD for three different lengths (5, 8, and 13).
The average relative PC is a weighted combination of the three PC values.
Normalization:
RVI and PC are normalized using Z-scores (standard scores) to bring them to the same scale. This enables easier comparison.
Histogram Plotting:
The RVI and PC are plotted as histograms below the main price chart. Green color bars represent RVI, and blue color bars indicate PC. The RVI bars are light green when the RVI values are decreasing compared to previous bar. Similarly, when PC bars are light blue it indicates that the PC values are decreasing compared to previous bars.
There is a zero line +/- 0.5 SD lines movements above and below the SD lines are practically
significant.
Interpretation :
(1) Strong Bullish Movement :
This is when both the green bars (RVI) and blue bars (PC) increases and are on the same side above zero .
(2) Strong Bearish Movement :
This is when the green bars (RVI) increases and blue bars (PC) decreases. The green bars above zero but blue bars below zero.
(3) Weak Bullish Movement :
This is when the green bars (RVI) decreases and are below zero but the blue bars (PC) increases and are above zero .
(2) Weak Bearish Movement :
This is when both the green bars (RVI) and blue bars (PC) decreases. The green bars and blue bars are below zero.
This output is slightly hard to read but with practice can be read easily.
chrono_utilsLibrary "chrono_utils"
📝 Description
Collection of objects and common functions that are related to datetime windows session days and time ranges. The main purpose of this library is to handle time-related functionality and make it easy to reason about a future bar checking if it will be part of a predefined session and/or inside a datetime window. All existing session functionality I found in the documentation e.g. "not na(time(timeframe, session, timezone))" are not suitable for strategy scripts, since the execution of the orders is delayed by one bar, due to the script execution happening at the bar close. Moreover, a history operator with a negative value that looks forward is not allowed in any pinescript expression. So, a prediction for the next bar using the bars_back argument of "time()"" and "time_close()" was necessary. Thus, I created this library to overcome this small but very important limitation. In the meantime, I added useful functionality to handle session-based behavior. An interesting utility that emerged from this development is data anomaly detection where a comparison between the prediction and the actual value is happening. If those two values are different then a data inconsistency happens between the prediction bar and the actual bar (probably due to a holiday, half session day, a timezone change etc..)
🤔 How to Guide
To use the functionality this library provides in your script you have to import it first!
Copy the import statement of the latest release by pressing the copy button below and then paste it into your script. Give a short name to this library so you can refer to it later on. The import statement should look like this:
import jason5480/chrono_utils/2 as chr
To check if a future bar will be inside a window first of all you have to initialize a DateTimeWindow object.
A code example is the following:
var dateTimeWindow = chr.DateTimeWindow.new().init(fromDateTime = timestamp('01 Jan 2023 00:00'), toDateTime = timestamp('01 Jan 2024 00:00'))
Then you have to "ask" the dateTimeWindow if the future bar defined by an offset (default is 1 that corresponds th the next bar), will be inside that window:
// Filter bars outside of the datetime window
bool dateFilterApproval = dateTimeWindow.is_bar_included()
You can visualize the result by drawing the background of the bars that are outside the given window:
bgcolor(color = dateFilterApproval ? na : color.new(color.fuchsia, 90), offset = 1, title = 'Datetime Window Filter')
In the same way, you can "ask" the Session if the future bar defined by an offset it will be inside that session.
First of all, you should initialize a Session object.
A code example is the following:
var sess = chr.Session.new().from_sess_string(sess = '0800-1700:23456', refTimezone = 'UTC')
Then check if the given bar defined by the offset (default is 1 that corresponds th the next bar), will be inside the session like that:
// Filter bars outside the sessions
bool sessionFilterApproval = view.sess.is_bar_included()
You can visualize the result by drawing the background of the bars that are outside the given session:
bgcolor(color = sessionFilterApproval ? na : color.new(color.red, 90), offset = 1, title = 'Session Filter')
In case you want to visualize multiple session ranges you can create a SessionView object like that:
var view = SessionView.new().init(SessionDays.new().from_sess_string('2345'), array.from(SessionTimeRange.new().from_sess_string('0800-1600'), SessionTimeRange.new().from_sess_string('1300-2200')), array.from('London', 'New York'), array.from(color.blue, color.orange))
and then call the draw method of the SessionView object like that:
view.draw()
🏋️♂️ Please refer to the "EXAMPLE DATETIME WINDOW FILTER" and "EXAMPLE SESSION FILTER" regions of the script for more advanced code examples of how to utilize the full potential of this library, including user input settings and advanced visualization!
⚠️ Caveats
As I mentioned in the description there are some cases that the prediction of the next bar is not accurate. A wrong prediction will affect the outcome of the filtering. The main reasons this could happen are the following:
Public holidays when the market is closed
Half trading days usually before public holidays
Change in the daylight saving time (DST)
A data anomaly of the chart, where there are missing and/or inconsistent data.
A bug in this library (Please report by PM sending the symbol, timeframe, and settings)
Special thanks to @robbatt and @skinra for the constructive feedback 🏆. Without them, the exposed API of this library would be very lengthy and complicated to use. Thanks to them, now the user of this library will be able to get the most, with only a few lines of code!
Trend Lines [LuxAlgo]Our new "Trend Lines" indicator detects and highlights relevant trendlines on the user chart while keeping it free of as much clutter as possible.
The indicator is thought for real-time usage and includes several filters as well as the ability to estimate trendline angles.
🔶 USAGE
Trendlines can act as support/resistance, with a higher number of tests indicating a more significant support/resistance role.
A broken TrendLine can be indicative of a potential trend reversal. The script highlights breaks with a label.
Users can additionally filter trendlines, only showing trendlines whose angles fall within a user set range:
This allows for the removal of potential clutter from the chart but also helps keep steeper or more horizontal trendlines.
🔶 DETAILS
When a swing (pivot point) is found, a Trendline is drawn when certain conditions are fulfilled.
An essential condition is that a Bearish Trendline (red) always occurs on a lower high, while a Bullish Trendline (blue) occurs on a higher low.
Our implementation will first show an initial dotted-styled TrendLine on confirmation, after which a solid-styled secondary TrendLine will develop. The latter will be used for the real-time detection of breaks at that line:
Furthermore, the script allows you to add more conditions:
🔹 Length (Swings)
A swing develops when a high/low is the highest/lowest against x highs/lows on the left AND right of that bar. x can be set by "Length" in settings.
The following images clarify this. The script confirms a swing where the yellow flag is shown; the high (here visualized with a purple label) is the highest point against x bars left and right of that point.
At that moment, this swing is checked against the previous swing. If all conditions are fulfilled, an initial TrendLine is drawn on confirmation.
After that point, a secondary thicker solid line is seen which keeps progressing bar after bar, until:
• a new TrendLine is formed
• the TrendLine is broken
🔹 Breaks between Swings
Once there is confirmation that a TrendLine can be drawn, the script allows you to filter for breakthroughs on that line. This can be set with "Check breaks between"
Disabled : the initial TrendLine is allowed to be pierced:
Check breaks between point A - point B : no breaks are allowed between both Swing points:
Point A - Current bar : no breaks are allowed between the first Swing point and the point of confirmation ('current' bar):
🔹 TrendLine breaks
As mentioned, the secondary TrendLine (solid line) progresses bar after bar until a new TrendLine is formed or the TrendLine is broken. When a TrendLine is broken, the TrendLine stops progressing, but if there isn't a new TrendLine and price return back, the TrendLine will re-appear, potentially giving several signals when the TrendLine is broken again.
Minimal bars allow you to regulate the amount of signals when the TrendLine is broken.
-> The secondary TrendLine must be uninterrupted for at least x bars before a potential break can be considered.
The following example shows 1 signal against 3 by adjusting this setting from 2 to 5:
🔹 Angles
Angles should normally be calculated when the units of the X and Y axis are the same. However, on our charts, the unit of the X-axis is bar_index (bars), and on the Y-axis the unit is price (¥, €, £, $,...).
It is not easy to normalize and create reasonably valid angles. Often certain angle calculations can differ through price changes or volatility.
Our calculate_slope() function tries to make corresponding angles through all bars.
We do this by calculating the difference between the highest/lowest price values in a certain bar range. The bar range is our X-axis, and the price difference is our Y-axis.
Zooming in/out will not change the amount of bars or the price. Since it does change our view on the chart, and thereby how we see the angles, we have included a setting where you can personalize the ratio between X and Y-axis (Angles -> Ratio X-Y axis).
Settings: Angles - Ratio X-Y axis:
🔶 SETTINGS
🔹 Swings
Length: Lookback period for the detection of swing points.
🔹 Trendline validation
Check breaks between :
Disabled : the initial TrendLine is allowed to be pierced
Check breaks between point A - point B : no breaks are allowed between both Swing points
Point A - Current bar : no breaks are allowed between the first Swing point and the point of confirmation ('current' bar)
Source (breaks) : Source which invalidates TrendLine, default: close
🔹 TrendLine breaks
Minimal bars : The secondary TrendLine must be uninterrupted for at least x bars before a potential break can be considered.
🔹 Angles
Show : Toggle labels.
Ratio X-Y axis : Every user has his preferences regarding zoom, chart layout,...
If the shown angles are not according to your expectations, you can adjust this number.
Only TrendLine between : Only allow TrendLines between the minimum and maximum degrees. Set only the minimal and maximum values above 0.
Lower timeframe chartHi all!
I've made this script to help with my laziness (and to help me (and now you) with efficiency). It's purpose is to, without having to change the chart timeframe, being able to view the lower timeframe bars (and trend) within the last chart bar. The defaults are just my settings (It's based on daily bars), so feel free to change them and maybe share yours! It's also based on stocks, which have limited trading hours, but if you want to view this for forex trading I suggest changing the 'lower time frame' to a higher value since it has more trading hours.
The script prints a label chart (ASCII) based on your chosen timeframe and the trend, based on @KivancOzbilgic script SuperTrend The printed ASCII chart has rows (slots) that are based on ATR (14 bars) and empty gaps are removed. The current trend is decided by a percentage of bars (user defined but defaults to 80%, which is really big but let's you be very conservative in defining a trend to be bullish. Set to 50% to have the trend being decided equally or lower to be more conservative in defining a trend to be bearish) that must have a bullish SuperTrend, it's considered to be bearish otherwise. Big price range (based on the ATR for 14 bars) and big volume (true if the volume is bigger than a user defined simple moving average (defaults to 20 bars)) can be disabled for faster execution.
The chart displayed will consist of bars and thicker bars that has a higher volume than the defined simple moving average. The bars that has a 'big range' (user defined value of ATR (14 days) factor that defaults to 0.5) will also have a wick. The characters used are the following:
Green bar = ┼
Green bar with large volume = ╪
Green bar wick = │
Red bar = ╋
Red bar with large volume = ╬
Red bar wick = ┃
Bar with no range = ─
Bar with no range and high volume = ═
Best of trading!
MW Volume ImpulseMW Volume Impulse
Settings
* Moving Average Period: The moving average period used to generate the moving average line for the bar chart. Default=14
* Dot Size: The size of the dot that indicates when the moving average of the CVD is breached. Default=10
* Dot Transparency: The transparency of the dot that indicates when the moving average of the CVD is breached. Default=50
* EMA: The exponential moving average that the price must break through, in addition to the CVD moving
* Accumulation Length: Period used to generate the Cumulative Volume Delta (CVD) for the bar chart. Default=14
Introduction
Velocity = Change in Position over time
Acceleration = Change in Velocity over time
For this indicator, Position is synonymous with the Cumulative Volume Delta (CVD) value. What the indicator attempts to do is to determine when the rate of acceleration of buying or selling volume is changing in either or buying or selling direction in a meaningful way.
Calculations
The CVD, upon which these changes is calculated using candle bodies and wicks. For a red candle, buying volume is calculated by multiplying the volume by the spread percentage of the average of the top and bottom wicks, while Selling Volume is calculated multiplying the volume by the spread percentage of the average of the top and bottom wicks - in addition to the spread percentage of the candle body.
For a green candle, buying volume is calculated by multiplying the volume by the spread percentage of the average of the top and bottom wicks - plus the spread percentage of the candle body - while Selling Volume is calculated using only the spread percentage average of the top and bottom wicks.
How to Interpret
The difference between the buying volume and selling volume is the source of what generates the red and green bars on the indicator. But, more specifically, this indicator uses an exponential moving average of these volumes (14 EMA by default) to determine that actual bar size. The change in this value indicates the velocity of volume and, ultimately, the red and green bars on the indicator.
- When the bar height is zero, that means that there is no velocity, which indicates either a balance between buyers and sellers, or very little volume.
- When the bar height remains largely unchanged from period to period - and not zero - it means that the velocity of volume is constant in one direction. That direction is indicated by the color of the bar. Buyers are dominating when the bars are green, and sellers are dominating when the bars are red.
- When the bar height increases, regardless of bar color, it means that volume is accelerating in a buying direction.
- When the bar height decreases, regardless of bar color, it means that volume is accelerating in a selling direction.
The white line represents the moving average of the bar values, while the red and white - and green and white - dots show when the moving average has been breached by the Cumulative Volume Delta value AND the price has broken the 7 EMA (which is user editable). As with most moving averages, a breach can indicate a move in a bearish or bullish direction, and the sensitivity can be adjusted for differing market conditions
Other Usage Notes and Limitations
For better use of the signal, consider the following,
1. Volume moving below the moving average can indicate that the volume may be ready to exit an overbought condition, especially if the bars were making lower highs prior to the signal - regardless of bar color.
3. Volume moving above the moving average can indicate that the volume may be ready to exit an oversold condition, especially if the bars were making higher lows prior to the signal - regardless of bar color.
Additionally, a green dot that occurs with a positive (green) Cumulative Volume Delta can indicate a buying condition, while a red dot that occurs with a negative (red) Cumulative Volume Delta can indicate a selling condition. What this means is that buying or selling momentum briefly went against the direction of buying or selling Cumulative Volume Delta , but was not strong enough to change the buying or selling direction. In cases like this, once the volume begins to accelerate again in the direction of the buying or selling volume - indicated by a red or green dot - then the price is more likely to favor the direction of the Cumulative Volume Delta and its corresponding acceleration.
Although a red or green signal can indicate a change in direction, this script cannot predict the magnitude or duration of the change. It is best used with accompanying indicators that can be used to confirm a direction change, such as a moving average, or a supply or demand range.
Weis V5 zigzag jayySomehow, I deleted version 5 of the zigzag script. Same name. I have added some older notes describing how the Weis Wave works.
I have also changed the date restriction that stopped the script from working after Dec 31, 2022.
What you see here is the Weis zigzag wave plotted directly on the price chart. This script is the companion to the Weis cumulative wave volume script.
What is a Weis wave? David Weis has been recognized as a Wyckoff method analyst he has written two books one of which, Trades About to Happen, describes the evolution of the now-popular Weis wave. The method employed by Weis is to identify waves of price action and to compare the strength of the waves on characteristics of wave strength. Chief among the characteristics of strength is the cumulative volume of the wave. There are other markers that Weis uses as well for example how the actual price difference between the start of the Weis wave from start to finish. Weis also uses time, particularly when using a Renko chart
David Weis did a futures io video which is a popular source of information about his method. (Search David Weis and futures.io. I strongly suggest you also read “Trades About to Happen” by David Weis.
This will get you up and running more quickly when studying charts. However, you should choose the Traditional method to be true to David Weis technique as described in his book "Trades About to Happen" and in the Futures IO Webcast featuring David Weis
. The Weis pip zigzag wave shows how far in terms of bar close price a Weis wave has traveled through the duration of a Weis wave. The Weis zigzag wave is used in combination with the Weis cumulative volume wave. The two waves should be set to the same "wave size".
To use this script, you must set the wave size: Using the traditional Weis method simply enter the desired wave size in the box "How should wave size be calculated", in this example I am using a traditional wave size of .25. Each wave for each security and each timeframe requires its own wave size. Although not the traditional method devised by David Weis a more automatic way to set wave size would be to use Average True Range (ATR). Using ATR is not the true Weis method but it does give you similar waves and, importantly, without the hassle described above. Once the Weis wave size is set then the zigzag wave will be shown with volume. Because Weis used the closing price of a wave to define waves a line Bar highs and bar lows are not captured by the Weis Wave. The default script setting is now cumulative volume waves using an ATR of 7 and a multiplication factor of .5.
To display volume in a way that does not crowd out neighbouring volumes Weis displayed volume as a maximum of 3 digits (usually). Consider two Weis Wave volumes 176,895,570 and 2,654,763,889. To display wave volume as three digits it is necessary to take a number such as 176,895,570 and truncate it. 176,895,570 can be represented as 177 X 10 to the power of 6. The number displayed must also be relative to other numbers in the field. If the highest volume on the page is: 2,654,763,889 and with only three numbers available to display the result the value shown must be 265 (265 X 10 to the power of 7). Since 176,895,570 is an order of magnitude smaller than 2,654,763,889 therefore 175,895,570 must be shown as 18 instead of 177. In this way, the relative magnitudes of the two volumes can be understood. All numbers in the field of view must be truncated by the same order of magnitude to make the relative volumes understandable. The script attempts to calculate the order of magnitude value automatically. If you see a red number in the field of view it means the script has failed to do the calculation automatically and you should use the manual method – use the dialogue box “Calculate truncated wave value automatically or manually”. Scroll down from the automatic method and select manual. Once "manual" is selected the values displayed become the power values or multipliers for each wave.
Using the manual method you will select a “Multiplier” in the next dialogue box. Scan the field and select the largest value in the field of view (visible chart) is the multiplier of interest. If you select a lower number than the maximum value will see at least one red “up”. If you are too high you will see at least one red “down”. Scroll in the direction recommended or the values on the screen will be totally incorrect. With volume truncated to the highest order values, the eye can quickly get a feel for relative volumes. It also reduces the crowding and overlapping of values on the screen. You can opt to show the full volume to help get a sense of the magnitude of the true volumes.
How does the script determine if a Weis wave is continuing to grow or not?
The script evaluates the closing price of each new bar relative to the "Weis wave size". Suppose the current bar closes at a new low close, within the current down wave, at $30.00. If the Weis wave size is $0.10 then the algorithm will remember the $30.00 close and compare it to the close of the next bar. If the bar close price does not close equal to or lower than $30.00 or close equal to or higher than $30.10 then the wave is still a down wave with a current low of $30.00. This is true even if the bar low is less than $30.00 or the bar high is greater than 30.10 – only the bar’s closing price matters. If a bar's closing price climbs back up to a close of $30.11 then because the closing price has moved more than $0.10 (the Weis wave size) then that is a wave reversal with a new up-trending wave. In the above example if there was currently a downward trending wave and the bar closes were as follows $30.00, $30.09, $30.01, $30.05, $30.10 The wave direction would continue to stay downward trending until the close of $30.10 was achieved. As such $30.00 would be the low and the following closes $30.09, $30.01, $30.05 would be allocated to the new upward-trending wave. If however There was a series of bar closes like this $30.00, $30.09, $30.01, $30.05, $29.99 since none of the closes was equal to above the 10-cent reversal target of $30.10 but instead, a new Weis wave low was achieved ($29.99). As such the closes of $30.09, $30.01, $30.05 would all be attributed to the continued down-trending wave with a current low of $29.99, even though the closing price for the interim bars was above $30.00. Now that the Weis Wave low is now 429.99 then, in order to reverse this continued downtrend price will need to close at or above $30.09 on subsequent bar closes assuming now new low bar close is achieved. With large wave sizes, wave direction can be in limbo for many bars before a close either renews wave direction or reverses it and confirms wave direction as either a reversal or a continuation. On the zig-zag, a wave line and its volume will not be "printed" until a wave reversal is confirmed.
The wave attribution is similar when using other methods to define wave size. If ATR is used for wave size instead of a traditional wave constant size such as $0.10 or $2 or 2000 pips or ... then the wave size is calculated based on current ATR instead of the Weis wave constant (Traditional selected value).
I have the option to display pseudo-Ord volume. In truth, Ord used more traditional zig-zag pivots of bar highs and lows. Waves using closes as pivots can have some significant differences. This difference can be lessened by using smaller time frames and larger wave sizes.
There are other options such to display the delta price or pip size of a Weis Wave, the number of bars in a wave, and a few other options.
tunnel trading betaThe original author of the tunnel trading system: youtuber：Teacher Jin
This is a set of indicators system that trades completely based on the moving average. It belongs to the right trading. The idea is as follows:
(1) Basic trend (major trend)
When the short-term moving average is higher than the long-term moving average, it is an upward trend; otherwise, it is a downward trend.
The tentative short-term moving average is ema12, and the long-term moving average is ema169.
(2) The first type of buying point (or short point): trend establishment
Starting from the bar where the uptrend is established, the first outgoing bar is the first buying point. (Outgoing means that the closing price is higher than the opening price and higher than the high point of the previous bar)
Starting from the bar where the downtrend is established, the first bar to fall is the first shorting point. (Fall means that the closing price is lower than the opening price and lower than the low point of the previous bar)
(3) The second type of buying point (or short point): the buying point when pulling back (or the short point when rebounding)
The buying point at the time of pullback (callback) means that the general trend is up, but the small trend is down. You can buy when it is clear that the down trend is over.
Two concepts need to be defined here: "pullback (callback)" and "end of down trend". The definition of pullback is that when the general trend is rising, bar falls below the long-term moving average, and at this time the short-term moving average is still higher than the long-term moving average; The definition of the end of a down trend is that it is outgoing and ema12 is on the rise.
In the same way, we can know what is the "short point when rebounding":
The big trend is down, but the small trend is up. When it is clear that the rise is over, you can go short.
(4) Setting of Stop Loss and Take Profit
When going long:
Stop Loss Price: The low point of a bar before the buying point.
Stop-profit price: After the stop-loss price is determined, the profit-loss ratio is 3:1 to determine the stop-profit price. (The default value is 3, the user can modify it)
When shorting:
Stop Loss Price: The high point of a bar before the purchase point.
Stop-profit price: After the stop-loss price is determined, the profit-loss ratio is 3:1 to determine the stop-profit level. (The default value is 3, the user can modify it)
Chinese introduction:
隧道交易体系的原作者：油管金老师看盘室
这是一套完全根据均线进行交易的指标体系，属于右侧交易，思路如下：
（1） 基本趋势（大趋势）
短期均线高于长期均线时，是上涨趋势；反之，是下降趋势。
暂定短期均线为ema12，长期均线为ema169。
（2） 第一种买入点（或做空点）：趋势确立
从上涨趋势确立的那根bar开始，第一个出头的bar，是第一买入点。（出头，是指收盘价高于开盘价，且高于前一根bar的高点）
从下降趋势确立的那根bar开始，第一个落尾的bar，是第一做空点。（落尾，是指收盘价低于开盘价，且低于前一根bar的低点）
（3） 第二种买入点（或做空点）：拉回时的买入点（或反弹时的做空点）
拉回时（回调时）的买入点，是指大趋势是上涨，但小趋势是下跌，当明确下跌结束时，可以买入。
这里需要定义2个概念：“拉回（回调）”和“下跌结束”。拉回的定义是，大趋势是上涨时，bar跌破长期均线，此时短期均线仍高于长期均线；下跌结束的定义是，出头且ema12在上升。
同理可知什么是“反弹时的做空点”：
大趋势是下跌，但小趋势是上涨，当明确上涨结束时，可以做空。
（4） 止损位和止盈位的设置
做多时：
止损位：买入点前一根bar的低点。
止盈位：止损位确定后，按盈亏比3:1确定止盈位。（默认值为3，用户可以修改）
做空时：
止损位：买入点前一根bar的高点。
止盈位：止损位确定后，按盈亏比3:1确定止盈位。（默认值为3，用户可以修改）
ATRWhat the Indicator Shows:
A compact table with four cells is displayed in the bottom-left corner of the chart:
| ATR | % | Level | Lvl+ATR |
Explanation of the Columns:
ATR — The averaged daily range (volatility) calculated with filtering of abnormal bars (extremely large or small daily candles are ignored).
% — The percentage of the daily ATR that the price has already covered today (the difference between the daily Open and Close relative to ATR).
Level — A custom user-defined level set through the indicator settings.
Lvl+ATR — The sum of the daily ATR and the user-defined level. This can be used, for example, as a target or stop-loss reference.
Color Highlighting of the "%" Cell:
The background color of the "%" ATR cell changes depending on the value:
✅ If the value is less than 10% — the cell is green (market is calm, small movement).
➖ If the value is between 10% and 50% — no highlighting (average movement, no signal).
🟡 If the value is between 50% and 70% — the cell is yellow (movement is increasing, be alert).
🔴 If the value is above 70% — the cell is red (the market is actively moving, high volatility).
Key Features:
✔ All ATR calculations and percentage progress are performed strictly based on daily data, regardless of the chart's current timeframe.
✔ The indicator is ideal for intraday traders who want to monitor daily volatility levels.
✔ The table always displays up-to-date information for quick decision-making.
✔ Filtering of abnormal bars makes ATR more stable and objective.
What is Adaptive ATR in this Indicator:
Instead of the classic ATR, which simply averages the true range, this indicator uses a custom algorithm:
✅ It analyzes daily bars over the past 100 days.
✅ Calculates the range High - Low for each bar.
✅ If the bar's range deviates too much from the average (more than 1.8 times higher or lower), the bar is considered abnormal and ignored.
✅ Only "normal" bars are included in the calculation.
✅ The average range of these normal bars is the adaptive ATR.
Detailed Algorithm of the getAdaptiveATR() Function:
The function takes the number of bars to include in the calculation (for example, 5):
The average of the last 5 normal bars is calculated.
pinescript
Копировать
Редактировать
adaptiveATR = getAdaptiveATR(5)
Step-by-Step Process:
An empty array ranges is created to store the ranges.
Daily bars with indices from 1 to 100 are iterated over.
For each bar:
🔹 The daily High and Low with the required offset are loaded via request.security().
🔹 The range High - Low is calculated.
🔹 The temporary average range of the current array is calculated.
🔹 The bar is checked for abnormality (too large or too small).
🔹 If the bar is normal or it's the first bar — its range is added to the array.
Once the array accumulates the required number of bars (count), their average is calculated — this is the adaptive ATR.
If it's not possible to accumulate the required number of bars — na is returned.
Что показывает индикатор:
На графике внизу слева отображается компактная таблица из четырех ячеек:
ATR % Уровень Ур+ATR
Пояснения к столбцам:
ATR — усреднённый дневной диапазон (волатильность), рассчитанный с фильтрацией аномальных баров (слишком большие или маленькие дневные свечи игнорируются).
% — процент дневного ATR, который уже "прошла" цена на текущий день (разница между открытием и закрытием относительно ATR).
Уровень — пользовательский уровень, который задаётся вручную через настройки индикатора.
Ур+ATR — сумма уровня и дневного ATR. Может использоваться, например, как ориентир для целей или стопов.
Цветовая подсветка ячейки "%":
Цвет фона ячейки с процентом ATR меняется в зависимости от значения:
✅ Если значение меньше 10% — ячейка зелёная (рынок пока спокоен, маленькое движение).
➖ Если значение от 10% до 50% — фон не подсвечивается (среднее движение, нет сигнала).
🟡 Если значение от 50% до 70% — ячейка жёлтая (движение усиливается, повышенное внимание).
🔴 Если значение выше 70% — ячейка красная (рынок активно движется, высокая волатильность).
Особенности работы:
✔ Все расчёты ATR и процентного прохождения производятся исключительно по дневным данным, независимо от текущего таймфрейма графика.
✔ Индикатор подходит для трейдеров, которые торгуют внутри дня, но хотят ориентироваться на дневные уровни волатильности.
✔ В таблице всегда отображается актуальная информация для принятия быстрых торговых решений.
✔ Фильтрация аномальных баров делает ATR более устойчивым и объективным.
Что такое адаптивный ATR в этом индикаторе
Вместо классического ATR, который просто усредняет истинный диапазон, здесь используется собственный алгоритм:
✅ Он берет дневные бары за последние 100 дней.
✅ Для каждого из них рассчитывает диапазон High - Low.
✅ Если диапазон бара слишком сильно отличается от среднего (более чем в 1.8 раза больше или меньше), бар считается аномальным и игнорируется.
✅ Только нормальные бары попадают в расчёт.
✅ В итоге считается среднее из диапазонов этих нормальных баров — это и есть адаптивный ATR.
Подробный алгоритм функции getAdaptiveATR()
Функция принимает количество баров для расчёта (например, 5):
Считается 5 последних нормальных баров
pinescript
Копировать
Редактировать
adaptiveATR = getAdaptiveATR(5)
Пошагово:
Создаётся пустой массив ranges для хранения диапазонов.
Перебираются дневные бары с индексами от 1 до 100.
Для каждого бара:
🔹 Через request.security() подгружаются дневные High и Low с нужным смещением.
🔹 Считается диапазон High - Low.
🔹 Считается временное среднее диапазона по текущему массиву.
🔹 Проверяется, не является ли бар аномальным (слишком большой или маленький).
🔹 Если бар нормальный или это самый первый бар — его диапазон добавляется в массив.
Как только массив набирает заданное количество баров (count), берётся их среднее значение — это и есть адаптивный ATR.
Если не удалось набрать нужное количество баров — возвращается na.
Tensor Market Analysis Engine (TMAE)# Tensor Market Analysis Engine (TMAE)
## Advanced Multi-Dimensional Mathematical Analysis System
*Where Quantum Mathematics Meets Market Structure*
---
## 🎓 THEORETICAL FOUNDATION
The Tensor Market Analysis Engine represents a revolutionary synthesis of three cutting-edge mathematical frameworks that have never before been combined for comprehensive market analysis. This indicator transcends traditional technical analysis by implementing advanced mathematical concepts from quantum mechanics, information theory, and fractal geometry.
### 🌊 Multi-Dimensional Volatility with Jump Detection
**Hawkes Process Implementation:**
The TMAE employs a sophisticated Hawkes process approximation for detecting self-exciting market jumps. Unlike traditional volatility measures that treat price movements as independent events, the Hawkes process recognizes that market shocks cluster and exhibit memory effects.
**Mathematical Foundation:**
```
Intensity λ(t) = μ + Σ α(t - Tᵢ)
```
Where market jumps at times Tᵢ increase the probability of future jumps through the decay function α, controlled by the Hawkes Decay parameter (0.5-0.99).
**Mahalanobis Distance Calculation:**
The engine calculates volatility jumps using multi-dimensional Mahalanobis distance across up to 5 volatility dimensions:
- **Dimension 1:** Price volatility (standard deviation of returns)
- **Dimension 2:** Volume volatility (normalized volume fluctuations)
- **Dimension 3:** Range volatility (high-low spread variations)
- **Dimension 4:** Correlation volatility (price-volume relationship changes)
- **Dimension 5:** Microstructure volatility (intrabar positioning analysis)
This creates a volatility state vector that captures market behavior impossible to detect with traditional single-dimensional approaches.
### 📐 Hurst Exponent Regime Detection
**Fractal Market Hypothesis Integration:**
The TMAE implements advanced Rescaled Range (R/S) analysis to calculate the Hurst exponent in real-time, providing dynamic regime classification:
- **H > 0.6:** Trending (persistent) markets - momentum strategies optimal
- **H < 0.4:** Mean-reverting (anti-persistent) markets - contrarian strategies optimal
- **H ≈ 0.5:** Random walk markets - breakout strategies preferred
**Adaptive R/S Analysis:**
Unlike static implementations, the TMAE uses adaptive windowing that adjusts to market conditions:
```
H = log(R/S) / log(n)
```
Where R is the range of cumulative deviations and S is the standard deviation over period n.
**Dynamic Regime Classification:**
The system employs hysteresis to prevent regime flipping, requiring sustained Hurst values before regime changes are confirmed. This prevents false signals during transitional periods.
### 🔄 Transfer Entropy Analysis
**Information Flow Quantification:**
Transfer entropy measures the directional flow of information between price and volume, revealing lead-lag relationships that indicate future price movements:
```
TE(X→Y) = Σ p(yₜ₊₁, yₜ, xₜ) log
```
**Causality Detection:**
- **Volume → Price:** Indicates accumulation/distribution phases
- **Price → Volume:** Suggests retail participation or momentum chasing
- **Balanced Flow:** Market equilibrium or transition periods
The system analyzes multiple lag periods (2-20 bars) to capture both immediate and structural information flows.
---
## 🔧 COMPREHENSIVE INPUT SYSTEM
### Core Parameters Group
**Primary Analysis Window (10-100, Default: 50)**
The fundamental lookback period affecting all calculations. Optimization by timeframe:
- **1-5 minute charts:** 20-30 (rapid adaptation to micro-movements)
- **15 minute-1 hour:** 30-50 (balanced responsiveness and stability)
- **4 hour-daily:** 50-100 (smooth signals, reduced noise)
- **Asset-specific:** Cryptocurrency 20-35, Stocks 35-50, Forex 40-60
**Signal Sensitivity (0.1-2.0, Default: 0.7)**
Master control affecting all threshold calculations:
- **Conservative (0.3-0.6):** High-quality signals only, fewer false positives
- **Balanced (0.7-1.0):** Optimal risk-reward ratio for most trading styles
- **Aggressive (1.1-2.0):** Maximum signal frequency, requires careful filtering
**Signal Generation Mode:**
- **Aggressive:** Any component signals (highest frequency)
- **Confluence:** 2+ components agree (balanced approach)
- **Conservative:** All 3 components align (highest quality)
### Volatility Jump Detection Group
**Volatility Dimensions (2-5, Default: 3)**
Determines the mathematical space complexity:
- **2D:** Price + Volume volatility (suitable for clean markets)
- **3D:** + Range volatility (optimal for most conditions)
- **4D:** + Correlation volatility (advanced multi-asset analysis)
- **5D:** + Microstructure volatility (maximum sensitivity)
**Jump Detection Threshold (1.5-4.0σ, Default: 3.0σ)**
Standard deviations required for volatility jump classification:
- **Cryptocurrency:** 2.0-2.5σ (naturally volatile)
- **Stock Indices:** 2.5-3.0σ (moderate volatility)
- **Forex Major Pairs:** 3.0-3.5σ (typically stable)
- **Commodities:** 2.0-3.0σ (varies by commodity)
**Jump Clustering Decay (0.5-0.99, Default: 0.85)**
Hawkes process memory parameter:
- **0.5-0.7:** Fast decay (jumps treated as independent)
- **0.8-0.9:** Moderate clustering (realistic market behavior)
- **0.95-0.99:** Strong clustering (crisis/event-driven markets)
### Hurst Exponent Analysis Group
**Calculation Method Options:**
- **Classic R/S:** Original Rescaled Range (fast, simple)
- **Adaptive R/S:** Dynamic windowing (recommended for trading)
- **DFA:** Detrended Fluctuation Analysis (best for noisy data)
**Trending Threshold (0.55-0.8, Default: 0.60)**
Hurst value defining persistent market behavior:
- **0.55-0.60:** Weak trend persistence
- **0.65-0.70:** Clear trending behavior
- **0.75-0.80:** Strong momentum regimes
**Mean Reversion Threshold (0.2-0.45, Default: 0.40)**
Hurst value defining anti-persistent behavior:
- **0.35-0.45:** Weak mean reversion
- **0.25-0.35:** Clear ranging behavior
- **0.15-0.25:** Strong reversion tendency
### Transfer Entropy Parameters Group
**Information Flow Analysis:**
- **Price-Volume:** Classic flow analysis for accumulation/distribution
- **Price-Volatility:** Risk flow analysis for sentiment shifts
- **Multi-Timeframe:** Cross-timeframe causality detection
**Maximum Lag (2-20, Default: 5)**
Causality detection window:
- **2-5 bars:** Immediate causality (scalping)
- **5-10 bars:** Short-term flow (day trading)
- **10-20 bars:** Structural flow (swing trading)
**Significance Threshold (0.05-0.3, Default: 0.15)**
Minimum entropy for signal generation:
- **0.05-0.10:** Detect subtle information flows
- **0.10-0.20:** Clear causality only
- **0.20-0.30:** Very strong flows only
---
## 🎨 ADVANCED VISUAL SYSTEM
### Tensor Volatility Field Visualization
**Five-Layer Resonance Bands:**
The tensor field creates dynamic support/resistance zones that expand and contract based on mathematical field strength:
- **Core Layer (Purple):** Primary tensor field with highest intensity
- **Layer 2 (Neutral):** Secondary mathematical resonance
- **Layer 3 (Info Blue):** Tertiary harmonic frequencies
- **Layer 4 (Warning Gold):** Outer field boundaries
- **Layer 5 (Success Green):** Maximum field extension
**Field Strength Calculation:**
```
Field Strength = min(3.0, Mahalanobis Distance × Tensor Intensity)
```
The field amplitude adjusts to ATR and mathematical distance, creating dynamic zones that respond to market volatility.
**Radiation Line Network:**
During active tensor states, the system projects directional radiation lines showing field energy distribution:
- **8 Directional Rays:** Complete angular coverage
- **Tapering Segments:** Progressive transparency for natural visual flow
- **Pulse Effects:** Enhanced visualization during volatility jumps
### Dimensional Portal System
**Portal Mathematics:**
Dimensional portals visualize regime transitions using category theory principles:
- **Green Portals (◉):** Trending regime detection (appear below price for support)
- **Red Portals (◎):** Mean-reverting regime (appear above price for resistance)
- **Yellow Portals (○):** Random walk regime (neutral positioning)
**Tensor Trail Effects:**
Each portal generates 8 trailing particles showing mathematical momentum:
- **Large Particles (●):** Strong mathematical signal
- **Medium Particles (◦):** Moderate signal strength
- **Small Particles (·):** Weak signal continuation
- **Micro Particles (˙):** Signal dissipation
### Information Flow Streams
**Particle Stream Visualization:**
Transfer entropy creates flowing particle streams indicating information direction:
- **Upward Streams:** Volume leading price (accumulation phases)
- **Downward Streams:** Price leading volume (distribution phases)
- **Stream Density:** Proportional to information flow strength
**15-Particle Evolution:**
Each stream contains 15 particles with progressive sizing and transparency, creating natural flow visualization that makes information transfer immediately apparent.
### Fractal Matrix Grid System
**Multi-Timeframe Fractal Levels:**
The system calculates and displays fractal highs/lows across five Fibonacci periods:
- **8-Period:** Short-term fractal structure
- **13-Period:** Intermediate-term patterns
- **21-Period:** Primary swing levels
- **34-Period:** Major structural levels
- **55-Period:** Long-term fractal boundaries
**Triple-Layer Visualization:**
Each fractal level uses three-layer rendering:
- **Shadow Layer:** Widest, darkest foundation (width 5)
- **Glow Layer:** Medium white core line (width 3)
- **Tensor Layer:** Dotted mathematical overlay (width 1)
**Intelligent Labeling System:**
Smart spacing prevents label overlap using ATR-based minimum distances. Labels include:
- **Fractal Period:** Time-based identification
- **Topological Class:** Mathematical complexity rating (0, I, II, III)
- **Price Level:** Exact fractal price
- **Mahalanobis Distance:** Current mathematical field strength
- **Hurst Exponent:** Current regime classification
- **Anomaly Indicators:** Visual strength representations (○ ◐ ● ⚡)
### Wick Pressure Analysis
**Rejection Level Mathematics:**
The system analyzes candle wick patterns to project future pressure zones:
- **Upper Wick Analysis:** Identifies selling pressure and resistance zones
- **Lower Wick Analysis:** Identifies buying pressure and support zones
- **Pressure Projection:** Extends lines forward based on mathematical probability
**Multi-Layer Glow Effects:**
Wick pressure lines use progressive transparency (1-8 layers) creating natural glow effects that make pressure zones immediately visible without cluttering the chart.
### Enhanced Regime Background
**Dynamic Intensity Mapping:**
Background colors reflect mathematical regime strength:
- **Deep Transparency (98% alpha):** Subtle regime indication
- **Pulse Intensity:** Based on regime strength calculation
- **Color Coding:** Green (trending), Red (mean-reverting), Neutral (random)
**Smoothing Integration:**
Regime changes incorporate 10-bar smoothing to prevent background flicker while maintaining responsiveness to genuine regime shifts.
### Color Scheme System
**Six Professional Themes:**
- **Dark (Default):** Professional trading environment optimization
- **Light:** High ambient light conditions
- **Classic:** Traditional technical analysis appearance
- **Neon:** High-contrast visibility for active trading
- **Neutral:** Minimal distraction focus
- **Bright:** Maximum visibility for complex setups
Each theme maintains mathematical accuracy while optimizing visual clarity for different trading environments and personal preferences.
---
## 📊 INSTITUTIONAL-GRADE DASHBOARD
### Tensor Field Status Section
**Field Strength Display:**
Real-time Mahalanobis distance calculation with dynamic emoji indicators:
- **⚡ (Lightning):** Extreme field strength (>1.5× threshold)
- **● (Solid Circle):** Strong field activity (>1.0× threshold)
- **○ (Open Circle):** Normal field state
**Signal Quality Rating:**
Democratic algorithm assessment:
- **ELITE:** All 3 components aligned (highest probability)
- **STRONG:** 2 components aligned (good probability)
- **GOOD:** 1 component active (moderate probability)
- **WEAK:** No clear component signals
**Threshold and Anomaly Monitoring:**
- **Threshold Display:** Current mathematical threshold setting
- **Anomaly Level (0-100%):** Combined volatility and volume spike measurement
- **>70%:** High anomaly (red warning)
- **30-70%:** Moderate anomaly (orange caution)
- **<30%:** Normal conditions (green confirmation)
### Tensor State Analysis Section
**Mathematical State Classification:**
- **↑ BULL (Tensor State +1):** Trending regime with bullish bias
- **↓ BEAR (Tensor State -1):** Mean-reverting regime with bearish bias
- **◈ SUPER (Tensor State 0):** Random walk regime (neutral)
**Visual State Gauge:**
Five-circle progression showing tensor field polarity:
- **🟢🟢🟢⚪⚪:** Strong bullish mathematical alignment
- **⚪⚪🟡⚪⚪:** Neutral/transitional state
- **⚪⚪🔴🔴🔴:** Strong bearish mathematical alignment
**Trend Direction and Phase Analysis:**
- **📈 BULL / 📉 BEAR / ➡️ NEUTRAL:** Primary trend classification
- **🌪️ CHAOS:** Extreme information flow (>2.0 flow strength)
- **⚡ ACTIVE:** Strong information flow (1.0-2.0 flow strength)
- **😴 CALM:** Low information flow (<1.0 flow strength)
### Trading Signals Section
**Real-Time Signal Status:**
- **🟢 ACTIVE / ⚪ INACTIVE:** Long signal availability
- **🔴 ACTIVE / ⚪ INACTIVE:** Short signal availability
- **Components (X/3):** Active algorithmic components
- **Mode Display:** Current signal generation mode
**Signal Strength Visualization:**
Color-coded component count:
- **Green:** 3/3 components (maximum confidence)
- **Aqua:** 2/3 components (good confidence)
- **Orange:** 1/3 components (moderate confidence)
- **Gray:** 0/3 components (no signals)
### Performance Metrics Section
**Win Rate Monitoring:**
Estimated win rates based on signal quality with emoji indicators:
- **🔥 (Fire):** ≥60% estimated win rate
- **👍 (Thumbs Up):** 45-59% estimated win rate
- **⚠️ (Warning):** <45% estimated win rate
**Mathematical Metrics:**
- **Hurst Exponent:** Real-time fractal dimension (0.000-1.000)
- **Information Flow:** Volume/price leading indicators
- **📊 VOL:** Volume leading price (accumulation/distribution)
- **💰 PRICE:** Price leading volume (momentum/speculation)
- **➖ NONE:** Balanced information flow
- **Volatility Classification:**
- **🔥 HIGH:** Above 1.5× jump threshold
- **📊 NORM:** Normal volatility range
- **😴 LOW:** Below 0.5× jump threshold
### Market Structure Section (Large Dashboard)
**Regime Classification:**
- **📈 TREND:** Hurst >0.6, momentum strategies optimal
- **🔄 REVERT:** Hurst <0.4, contrarian strategies optimal
- **🎲 RANDOM:** Hurst ≈0.5, breakout strategies preferred
**Mathematical Field Analysis:**
- **Dimensions:** Current volatility space complexity (2D-5D)
- **Hawkes λ (Lambda):** Self-exciting jump intensity (0.00-1.00)
- **Jump Status:** 🚨 JUMP (active) / ✅ NORM (normal)
### Settings Summary Section (Large Dashboard)
**Active Configuration Display:**
- **Sensitivity:** Current master sensitivity setting
- **Lookback:** Primary analysis window
- **Theme:** Active color scheme
- **Method:** Hurst calculation method (Classic R/S, Adaptive R/S, DFA)
**Dashboard Sizing Options:**
- **Small:** Essential metrics only (mobile/small screens)
- **Normal:** Balanced information density (standard desktop)
- **Large:** Maximum detail (multi-monitor setups)
**Position Options:**
- **Top Right:** Standard placement (avoids price action)
- **Top Left:** Wide chart optimization
- **Bottom Right:** Recent price focus (scalping)
- **Bottom Left:** Maximum price visibility (swing trading)
---
## 🎯 SIGNAL GENERATION LOGIC
### Multi-Component Convergence System
**Component Signal Architecture:**
The TMAE generates signals through sophisticated component analysis rather than simple threshold crossing:
**Volatility Component:**
- **Jump Detection:** Mahalanobis distance threshold breach
- **Hawkes Intensity:** Self-exciting process activation (>0.2)
- **Multi-dimensional:** Considers all volatility dimensions simultaneously
**Hurst Regime Component:**
- **Trending Markets:** Price above SMA-20 with positive momentum
- **Mean-Reverting Markets:** Price at Bollinger Band extremes
- **Random Markets:** Bollinger squeeze breakouts with directional confirmation
**Transfer Entropy Component:**
- **Volume Leadership:** Information flow from volume to price
- **Volume Spike:** Volume 110%+ above 20-period average
- **Flow Significance:** Above entropy threshold with directional bias
### Democratic Signal Weighting
**Signal Mode Implementation:**
- **Aggressive Mode:** Any single component triggers signal
- **Confluence Mode:** Minimum 2 components must agree
- **Conservative Mode:** All 3 components must align
**Momentum Confirmation:**
All signals require momentum confirmation:
- **Long Signals:** RSI >50 AND price >EMA-9
- **Short Signals:** RSI <50 AND price 0.6):**
- **Increase Sensitivity:** Catch momentum continuation
- **Lower Mean Reversion Threshold:** Avoid counter-trend signals
- **Emphasize Volume Leadership:** Institutional accumulation/distribution
- **Tensor Field Focus:** Use expansion for trend continuation
- **Signal Mode:** Aggressive or Confluence for trend following
**Range-Bound Markets (Hurst <0.4):**
- **Decrease Sensitivity:** Avoid false breakouts
- **Lower Trending Threshold:** Quick regime recognition
- **Focus on Price Leadership:** Retail sentiment extremes
- **Fractal Grid Emphasis:** Support/resistance trading
- **Signal Mode:** Conservative for high-probability reversals
**Volatile Markets (High Jump Frequency):**
- **Increase Hawkes Decay:** Recognize event clustering
- **Higher Jump Threshold:** Avoid noise signals
- **Maximum Dimensions:** Capture full volatility complexity
- **Reduce Position Sizing:** Risk management adaptation
- **Enhanced Visuals:** Maximum information for rapid decisions
**Low Volatility Markets (Low Jump Frequency):**
- **Decrease Jump Threshold:** Capture subtle movements
- **Lower Hawkes Decay:** Treat moves as independent
- **Reduce Dimensions:** Simplify analysis
- **Increase Position Sizing:** Capitalize on compressed volatility
- **Minimal Visuals:** Reduce distraction in quiet markets
---
## 🚀 ADVANCED TRADING STRATEGIES
### The Mathematical Convergence Method
**Entry Protocol:**
1. **Fractal Grid Approach:** Monitor price approaching significant fractal levels
2. **Tensor Field Confirmation:** Verify field expansion supporting direction
3. **Portal Signal:** Wait for dimensional portal appearance
4. **ELITE/STRONG Quality:** Only trade highest quality mathematical signals
5. **Component Consensus:** Confirm 2+ components agree in Confluence mode
**Example Implementation:**
- Price approaching 21-period fractal high
- Tensor field expanding upward (bullish mathematical alignment)
- Green portal appears below price (trending regime confirmation)
- ELITE quality signal with 3/3 components active
- Enter long position with stop below fractal level
**Risk Management:**
- **Stop Placement:** Below/above fractal level that generated signal
- **Position Sizing:** Based on Mahalanobis distance (higher distance = smaller size)
- **Profit Targets:** Next fractal level or tensor field resistance
### The Regime Transition Strategy
**Regime Change Detection:**
1. **Monitor Hurst Exponent:** Watch for persistent moves above/below thresholds
2. **Portal Color Change:** Regime transitions show different portal colors
3. **Background Intensity:** Increasing regime background intensity
4. **Mathematical Confirmation:** Wait for regime confirmation (hysteresis)
**Trading Implementation:**
- **Trending Transitions:** Trade momentum breakouts, follow trend
- **Mean Reversion Transitions:** Trade range boundaries, fade extremes
- **Random Transitions:** Trade breakouts with tight stops
**Advanced Techniques:**
- **Multi-Timeframe:** Confirm regime on higher timeframe
- **Early Entry:** Enter on regime transition rather than confirmation
- **Regime Strength:** Larger positions during strong regime signals
### The Information Flow Momentum Strategy
**Flow Detection Protocol:**
1. **Monitor Transfer Entropy:** Watch for significant information flow shifts
2. **Volume Leadership:** Strong edge when volume leads price
3. **Flow Acceleration:** Increasing flow strength indicates momentum
4. **Directional Confirmation:** Ensure flow aligns with intended trade direction
**Entry Signals:**
- **Volume → Price Flow:** Enter during accumulation/distribution phases
- **Price → Volume Flow:** Enter on momentum confirmation breaks
- **Flow Reversal:** Counter-trend entries when flow reverses
**Optimization:**
- **Scalping:** Use immediate flow detection (2-5 bar lag)
- **Swing Trading:** Use structural flow (10-20 bar lag)
- **Multi-Asset:** Compare flow between correlated assets
### The Tensor Field Expansion Strategy
**Field Mathematics:**
The tensor field expansion indicates mathematical pressure building in market structure:
**Expansion Phases:**
1. **Compression:** Field contracts, volatility decreases
2. **Tension Building:** Mathematical pressure accumulates
3. **Expansion:** Field expands rapidly with directional movement
4. **Resolution:** Field stabilizes at new equilibrium
**Trading Applications:**
- **Compression Trading:** Prepare for breakout during field contraction
- **Expansion Following:** Trade direction of field expansion
- **Reversion Trading:** Fade extreme field expansion
- **Multi-Dimensional:** Consider all field layers for confirmation
### The Hawkes Process Event Strategy
**Self-Exciting Jump Trading:**
Understanding that market shocks cluster and create follow-on opportunities:
**Jump Sequence Analysis:**
1. **Initial Jump:** First volatility jump detected
2. **Clustering Phase:** Hawkes intensity remains elevated
3. **Follow-On Opportunities:** Additional jumps more likely
4. **Decay Period:** Intensity gradually decreases
**Implementation:**
- **Jump Confirmation:** Wait for mathematical jump confirmation
- **Direction Assessment:** Use other components for direction
- **Clustering Trades:** Trade subsequent moves during high intensity
- **Decay Exit:** Exit positions as Hawkes intensity decays
### The Fractal Confluence System
**Multi-Timeframe Fractal Analysis:**
Combining fractal levels across different periods for high-probability zones:
**Confluence Zones:**
- **Double Confluence:** 2 fractal levels align
- **Triple Confluence:** 3+ fractal levels cluster
- **Mathematical Confirmation:** Tensor field supports the level
- **Information Flow:** Transfer entropy confirms direction
**Trading Protocol:**
1. **Identify Confluence:** Find 2+ fractal levels within 1 ATR
2. **Mathematical Support:** Verify tensor field alignment
3. **Signal Quality:** Wait for STRONG or ELITE signal
4. **Risk Definition:** Use fractal level for stop placement
5. **Profit Targeting:** Next major fractal confluence zone
---
## ⚠️ COMPREHENSIVE RISK MANAGEMENT
### Mathematical Position Sizing
**Mahalanobis Distance Integration:**
Position size should inversely correlate with mathematical field strength:
```
Position Size = Base Size × (Threshold / Mahalanobis Distance)
```
**Risk Scaling Matrix:**
- **Low Field Strength (<2.0):** Standard position sizing
- **Moderate Field Strength (2.0-3.0):** 75% position sizing
- **High Field Strength (3.0-4.0):** 50% position sizing
- **Extreme Field Strength (>4.0):** 25% position sizing or no trade
### Signal Quality Risk Adjustment
**Quality-Based Position Sizing:**
- **ELITE Signals:** 100% of planned position size
- **STRONG Signals:** 75% of planned position size
- **GOOD Signals:** 50% of planned position size
- **WEAK Signals:** No position or paper trading only
**Component Agreement Scaling:**
- **3/3 Components:** Full position size
- **2/3 Components:** 75% position size
- **1/3 Components:** 50% position size or skip trade
### Regime-Adaptive Risk Management
**Trending Market Risk:**
- **Wider Stops:** Allow for trend continuation
- **Trend Following:** Trade with regime direction
- **Higher Position Size:** Trend probability advantage
- **Momentum Stops:** Trail stops based on momentum indicators
**Mean-Reverting Market Risk:**
- **Tighter Stops:** Quick exits on trend continuation
- **Contrarian Positioning:** Trade against extremes
- **Smaller Position Size:** Higher reversal failure rate
- **Level-Based Stops:** Use fractal levels for stops
**Random Market Risk:**
- **Breakout Focus:** Trade only clear breakouts
- **Tight Initial Stops:** Quick exit if breakout fails
- **Reduced Frequency:** Skip marginal setups
- **Range-Based Targets:** Profit targets at range boundaries
### Volatility-Adaptive Risk Controls
**High Volatility Periods:**
- **Reduced Position Size:** Account for wider price swings
- **Wider Stops:** Avoid noise-based exits
- **Lower Frequency:** Skip marginal setups
- **Faster Exits:** Take profits more quickly
**Low Volatility Periods:**
- **Standard Position Size:** Normal risk parameters
- **Tighter Stops:** Take advantage of compressed ranges
- **Higher Frequency:** Trade more setups
- **Extended Targets:** Allow for compressed volatility expansion
### Multi-Timeframe Risk Alignment
**Higher Timeframe Trend:**
- **With Trend:** Standard or increased position size
- **Against Trend:** Reduced position size or skip
- **Neutral Trend:** Standard position size with tight management
**Risk Hierarchy:**
1. **Primary:** Current timeframe signal quality
2. **Secondary:** Higher timeframe trend alignment
3. **Tertiary:** Mathematical field strength
4. **Quaternary:** Market regime classification
---
## 📚 EDUCATIONAL VALUE AND MATHEMATICAL CONCEPTS
### Advanced Mathematical Concepts
**Tensor Analysis in Markets:**
The TMAE introduces traders to tensor analysis, a branch of mathematics typically reserved for physics and advanced engineering. Tensors provide a framework for understanding multi-dimensional market relationships that scalar and vector analysis cannot capture.
**Information Theory Applications:**
Transfer entropy implementation teaches traders about information flow in markets, a concept from information theory that quantifies directional causality between variables. This provides intuition about market microstructure and participant behavior.
**Fractal Geometry in Trading:**
The Hurst exponent calculation exposes traders to fractal geometry concepts, helping understand that markets exhibit self-similar patterns across multiple timeframes. This mathematical insight transforms how traders view market structure.
**Stochastic Process Theory:**
The Hawkes process implementation introduces concepts from stochastic process theory, specifically self-exciting point processes. This provides mathematical framework for understanding why market events cluster and exhibit memory effects.
### Learning Progressive Complexity
**Beginner Mathematical Concepts:**
- **Volatility Dimensions:** Understanding multi-dimensional analysis
- **Regime Classification:** Learning market personality types
- **Signal Democracy:** Algorithmic consensus building
- **Visual Mathematics:** Interpreting mathematical concepts visually
**Intermediate Mathematical Applications:**
- **Mahalanobis Distance:** Statistical distance in multi-dimensional space
- **Rescaled Range Analysis:** Fractal dimension measurement
- **Information Entropy:** Quantifying uncertainty and causality
- **Field Theory:** Understanding mathematical fields in market context
**Advanced Mathematical Integration:**
- **Tensor Field Dynamics:** Multi-dimensional market force analysis
- **Stochastic Self-Excitation:** Event clustering and memory effects
- **Categorical Composition:** Mathematical signal combination theory
- **Topological Market Analysis:** Understanding market shape and connectivity
### Practical Mathematical Intuition
**Developing Market Mathematics Intuition:**
The TMAE serves as a bridge between abstract mathematical concepts and practical trading applications. Traders develop intuitive understanding of:
- **How markets exhibit mathematical structure beneath apparent randomness**
- **Why multi-dimensional analysis reveals patterns invisible to single-variable approaches**
- **How information flows through markets in measurable, predictable ways**
- **Why mathematical models provide probabilistic edges rather than certainties**
---
## 🔬 IMPLEMENTATION AND OPTIMIZATION
### Getting Started Protocol
**Phase 1: Observation (Week 1)**
1. **Apply with defaults:** Use standard settings on your primary trading timeframe
2. **Study visual elements:** Learn to interpret tensor fields, portals, and streams
3. **Monitor dashboard:** Observe how metrics change with market conditions
4. **No trading:** Focus entirely on pattern recognition and understanding
**Phase 2: Pattern Recognition (Week 2-3)**
1. **Identify signal patterns:** Note what market conditions produce different signal qualities
2. **Regime correlation:** Observe how Hurst regimes affect signal performance
3. **Visual confirmation:** Learn to read tensor field expansion and portal signals
4. **Component analysis:** Understand which components drive signals in different markets
**Phase 3: Parameter Optimization (Week 4-5)**
1. **Asset-specific tuning:** Adjust parameters for your specific trading instrument
2. **Timeframe optimization:** Fine-tune for your preferred trading timeframe
3. **Sensitivity adjustment:** Balance signal frequency with quality
4. **Visual customization:** Optimize colors and intensity for your trading environment
**Phase 4: Live Implementation (Week 6+)**
1. **Paper trading:** Test signals with hypothetical trades
2. **Small position sizing:** Begin with minimal risk during learning phase
3. **Performance tracking:** Monitor actual vs. expected signal performance
4. **Continuous optimization:** Refine settings based on real performance data
### Performance Monitoring System
**Signal Quality Tracking:**
- **ELITE Signal Win Rate:** Track highest quality signals separately
- **Component Performance:** Monitor which components provide best signals
- **Regime Performance:** Analyze performance across different market regimes
- **Timeframe Analysis:** Compare performance across different session times
**Mathematical Metric Correlation:**
- **Field Strength vs. Performance:** Higher field strength should correlate with better performance
- **Component Agreement vs. Win Rate:** More component agreement should improve win rates
- **Regime Alignment vs. Success:** Trading with mathematical regime should outperform
### Continuous Optimization Process
**Monthly Review Protocol:**
1. **Performance Analysis:** Review win rates, profit factors, and maximum drawdown
2. **Parameter Assessment:** Evaluate if current settings remain optimal
3. **Market Adaptation:** Adjust for changes in market character or volatility
4. **Component Weighting:** Consider if certain components should receive more/less emphasis
**Quarterly Deep Analysis:**
1. **Mathematical Model Validation:** Verify that mathematical relationships remain valid
2. **Regime Distribution:** Analyze time spent in different market regimes
3. **Signal Evolution:** Track how signal characteristics change over time
4. **Correlation Analysis:** Monitor correlations between different mathematical components
---
## 🌟 UNIQUE INNOVATIONS AND CONTRIBUTIONS
### Revolutionary Mathematical Integration
**First-Ever Implementations:**
1. **Multi-Dimensional Volatility Tensor:** First indicator to implement true tensor analysis for market volatility
2. **Real-Time Hawkes Process:** First trading implementation of self-exciting point processes
3. **Transfer Entropy Trading Signals:** First practical application of information theory for trade generation
4. **Democratic Component Voting:** First algorithmic consensus system for signal generation
5. **Fractal-Projected Signal Quality:** First system to predict signal quality at future price levels
### Advanced Visualization Innovations
**Mathematical Visualization Breakthroughs:**
- **Tensor Field Radiation:** Visual representation of mathematical field energy
- **Dimensional Portal System:** Category theory visualization for regime transitions
- **Information Flow Streams:** Real-time visual display of market information transfer
- **Multi-Layer Fractal Grid:** Intelligent spacing and projection system
- **Regime Intensity Mapping:** Dynamic background showing mathematical regime strength
### Practical Trading Innovations
**Trading System Advances:**
- **Quality-Weighted Signal Generation:** Signals rated by mathematical confidence
- **Regime-Adaptive Strategy Selection:** Automatic strategy optimization based on market personality
- **Anti-Spam Signal Protection:** Mathematical prevention of signal clustering
- **Component Performance Tracking:** Real-time monitoring of algorithmic component success
- **Field-Strength Position Sizing:** Mathematical volatility integration for risk management
---
## ⚖️ RESPONSIBLE USAGE AND LIMITATIONS
### Mathematical Model Limitations
**Understanding Model Boundaries:**
While the TMAE implements sophisticated mathematical concepts, traders must understand fundamental limitations:
- **Markets Are Not Purely Mathematical:** Human psychology, news events, and fundamental factors create unpredictable elements
- **Past Performance Limitations:** Mathematical relationships that worked historically may not persist indefinitely
- **Model Risk:** Complex models can fail during unprecedented market conditions
- **Overfitting Potential:** Highly optimized parameters may not generalize to future market conditions
### Proper Implementation Guidelines
**Risk Management Requirements:**
- **Never Risk More Than 2% Per Trade:** Regardless of signal quality
- **Diversification Mandatory:** Don't rely solely on mathematical signals
- **Position Sizing Discipline:** Use mathematical field strength for sizing, not confidence
- **Stop Loss Non-Negotiable:** Every trade must have predefined risk parameters
**Realistic Expectations:**
- **Mathematical Edge, Not Certainty:** The indicator provides probabilistic advantages, not guaranteed outcomes
- **Learning Curve Required:** Complex mathematical concepts require time to master
- **Market Adaptation Necessary:** Parameters must evolve with changing market conditions
- **Continuous Education Important:** Understanding underlying mathematics improves application
### Ethical Trading Considerations
**Market Impact Awareness:**
- **Information Asymmetry:** Advanced mathematical analysis may provide advantages over other market participants
- **Position Size Responsibility:** Large positions based on mathematical signals can impact market structure
- **Sharing Knowledge:** Consider educational contributions to trading community
- **Fair Market Participation:** Use mathematical advantages responsibly within market framework
### Professional Development Path
**Skill Development Sequence:**
1. **Basic Mathematical Literacy:** Understand fundamental concepts before advanced application
2. **Risk Management Mastery:** Develop disciplined risk control before relying on complex signals
3. **Market Psychology Understanding:** Combine mathematical analysis with behavioral market insights
4. **Continuous Learning:** Stay updated on mathematical finance developments and market evolution
---
## 🔮 CONCLUSION
The Tensor Market Analysis Engine represents a quantum leap forward in technical analysis, successfully bridging the gap between advanced pure mathematics and practical trading applications. By integrating multi-dimensional volatility analysis, fractal market theory, and information flow dynamics, the TMAE reveals market structure invisible to conventional analysis while maintaining visual clarity and practical usability.
### Mathematical Innovation Legacy
This indicator establishes new paradigms in technical analysis:
- **Tensor analysis for market volatility understanding**
- **Stochastic self-excitation for event clustering prediction**
- **Information theory for causality-based trade generation**
- **Democratic algorithmic consensus for signal quality enhancement**
- **Mathematical field visualization for intuitive market understanding**
### Practical Trading Revolution
Beyond mathematical innovation, the TMAE transforms practical trading:
- **Quality-rated signals replace binary buy/sell decisions**
- **Regime-adaptive strategies automatically optimize for market personality**
- **Multi-dimensional risk management integrates mathematical volatility measures**
- **Visual mathematical concepts make complex analysis immediately interpretable**
- **Educational value creates lasting improvement in trading understanding**
### Future-Proof Design
The mathematical foundations ensure lasting relevance:
- **Universal mathematical principles transcend market evolution**
- **Multi-dimensional analysis adapts to new market structures**
- **Regime detection automatically adjusts to changing market personalities**
- **Component democracy allows for future algorithmic additions**
- **Mathematical visualization scales with increasing market complexity**
### Commitment to Excellence
The TMAE represents more than an indicator—it embodies a philosophy of bringing rigorous mathematical analysis to trading while maintaining practical utility and visual elegance. Every component, from the multi-dimensional tensor fields to the democratic signal generation, reflects a commitment to mathematical accuracy, trading practicality, and educational value.
### Trading with Mathematical Precision
In an era where markets grow increasingly complex and computational, the TMAE provides traders with mathematical tools previously available only to institutional quantitative research teams. Yet unlike academic mathematical models, the TMAE translates complex concepts into intuitive visual representations and practical trading signals.
By combining the mathematical rigor of tensor analysis, the statistical power of multi-dimensional volatility modeling, and the information-theoretic insights of transfer entropy, traders gain unprecedented insight into market structure and dynamics.
### Final Perspective
Markets, like nature, exhibit profound mathematical beauty beneath apparent chaos. The Tensor Market Analysis Engine serves as a mathematical lens that reveals this hidden order, transforming how traders perceive and interact with market structure.
Through mathematical precision, visual elegance, and practical utility, the TMAE empowers traders to see beyond the noise and trade with the confidence that comes from understanding the mathematical principles governing market behavior.
Trade with mathematical insight. Trade with the power of tensors. Trade with the TMAE.
*"In mathematics, you don't understand things. You just get used to them." - John von Neumann*
*With the TMAE, mathematical market understanding becomes not just possible, but intuitive.*
— Dskyz, Trade with insight. Trade with anticipation.
DDDDD: ATR & ADR Table + Suggested Time-based Exit📈 DDDDD: ATR & ADR Table + Suggested Time-based Exit
This indicator provides a simple yet powerful table displaying key volatility metrics for any timeframe you apply it to. It is designed for traders who want to assess the volatility of an asset, estimate the average time required for a potential move, and define a time-based exit strategy.
🔍 Features:
Displays ATR (Average True Range) for the selected length
Shows Average Range (High-Low) and Maximum Range over a configurable number of bars
Calculates Avg Bars/Move → average number of bars needed to achieve the maximum range
Calculates Recommended Exit Bars → suggested maximum holding period (in bars) before considering an exit if price hasn’t moved as expected
All values dynamically adjust based on the chart’s current timeframe
Outputs values directly in a table overlay on your main chart for quick reference
📝 How to interpret the table:
Field Meaning
ATR (14) Average True Range over the last 14 bars (volatility indicator)
Avg Range (20) Average High-Low range over the last 20 bars
Max Range Maximum High-Low range observed in the last 20 bars
Avg Bars/Move Average number of bars it takes to achieve a Max Range move
Rec. Exit Bars Suggested max holding period (bars) → consider exit if move hasn’t occurred
✅ How to use:
Apply this indicator to any chart (works on minutes, hourly, daily, weekly…)
It will automatically calculate based on the chart’s current timeframe
Use ATR & Avg Range to gauge volatility
Use Avg Bars/Move to estimate how long the market usually takes to achieve a big move
Use Rec. Exit Bars as a soft stop — if price hasn’t moved by this time, consider exiting due to declining probability of a breakout
⚠️ Notes:
All values are relative to your current chart timeframe. For example:
→ On a daily chart, ATR represents daily volatility
→ On a 1H chart, ATR represents hourly volatility
“Bars” refers to the bars of the current timeframe. Always interpret time accordingly.
Perfect for traders who want to:
Time their trades based on average volatility
Avoid overholding losing positions
Set time-based exit rules to complement price-based stoplosses
Dskyz (DAFE) Aurora Divergence – Quant Master Dskyz (DAFE) Aurora Divergence – Quant Master
Introducing the Dskyz (DAFE) Aurora Divergence – Quant Master , a strategy that’s your secret weapon for mastering futures markets like MNQ, NQ, MES, and ES. Born from the legendary Aurora Divergence indicator, this fully automated system transforms raw divergence signals into a quant-grade trading machine, blending precision, risk management, and cyberpunk DAFE visuals that make your charts glow like a neon skyline. Crafted with care and driven by community passion, this strategy stands out in a sea of generic scripts, offering traders a unique edge to outsmart institutional traps and navigate volatile markets.
The Aurora Divergence indicator was a cult favorite for spotting price-OBV divergences with its aqua and fuchsia orbs, but traders craved a system to act on those signals with discipline and automation. This strategy delivers, layering advanced filters (z-score, ATR, multi-timeframe, session), dynamic risk controls (kill switches, adaptive stops/TPs), and a real-time dashboard to turn insights into profits. Whether you’re a newbie dipping into futures or a pro hunting reversals, this strat’s got your back with a beginner guide, alerts, and visuals that make trading feel like a sci-fi mission. Let’s dive into every detail and see why this original DAFE creation is a must-have.
Why Traders Need This Strategy
Futures markets are a battlefield—fast-paced, volatile, and riddled with institutional games that can wipe out undisciplined traders. From the April 28, 2025 NQ 1k-point drop to sneaky ES slippage, the stakes are high. Meanwhile, platforms are flooded with unoriginal, low-effort scripts that promise the moon but deliver noise. The Aurora Divergence – Quant Master rises above, offering:
Unmatched Originality: A bespoke system built from the ground up, with custom divergence logic, DAFE visuals, and quant filters that set it apart from copycat clutter.
Automation with Precision: Executes trades on divergence signals, eliminating emotional slip-ups and ensuring consistency, even in chaotic sessions.
Quant-Grade Filters: Z-score, ATR, multi-timeframe, and session checks filter out noise, targeting high-probability reversals.
Robust Risk Management: Daily loss and rolling drawdown kill switches, plus ATR-based stops/TPs, protect your capital like a fortress.
Stunning DAFE Visuals: Aqua/fuchsia orbs, aurora bands, and a glowing dashboard make signals intuitive and charts a work of art.
Community-Driven: Evolved from trader feedback, this strat’s a labor of love, not a recycled knockoff.
Traders need this because it’s a complete, original system that blends accessibility, sophistication, and style. It’s your edge to trade smarter, not harder, in a market full of traps and imitators.
1. Divergence Detection (Core Signal Logic)
The strategy’s core is its ability to detect bullish and bearish divergences between price and On-Balance Volume (OBV), pinpointing reversals with surgical accuracy.
How It Works:
Price Slope: Uses linear regression over a lookback (default: 9 bars) to measure price momentum (priceSlope).
OBV Slope: OBV tracks volume flow (+volume if price rises, -volume if falls), with its slope calculated similarly (obvSlope).
Bullish Divergence: Price slope negative (falling), OBV slope positive (rising), and price above 50-bar SMA (trend_ma).
Bearish Divergence: Price slope positive (rising), OBV slope negative (falling), and price below 50-bar SMA.
Smoothing: Requires two consecutive divergence bars (bullDiv2, bearDiv2) to confirm signals, reducing false positives.
Strength: Divergence intensity (divStrength = |priceSlope * obvSlope| * sensitivity) is normalized (0–1, divStrengthNorm) for visuals.
Why It’s Brilliant:
- Divergences catch hidden momentum shifts, often exploited by institutions, giving you an edge on reversals.
- The 50-bar SMA filter aligns signals with the broader trend, avoiding choppy markets.
- Adjustable lookback (min: 3) and sensitivity (default: 1.0) let you tune for different instruments or timeframes.
2. Filters for Precision
Four advanced filters ensure signals are high-probability and market-aligned, cutting through the noise of volatile futures.
Z-Score Filter:
Logic: Calculates z-score ((close - SMA) / stdev) over a lookback (default: 50 bars). Blocks entries if |z-score| > threshold (default: 1.5) unless disabled (useZFilter = false).
Impact: Avoids trades during extreme price moves (e.g., blow-off tops), keeping you in statistically safe zones.
ATR Percentile Volatility Filter:
Logic: Tracks 14-bar ATR in a 100-bar window (default). Requires current ATR > 80th percentile (percATR) to trade (tradeOk).
Impact: Ensures sufficient volatility for meaningful moves, filtering out low-volume chop.
Multi-Timeframe (HTF) Trend Filter:
Logic: Uses a 50-bar SMA on a higher timeframe (default: 60min). Longs require price > HTF MA (bullTrendOK), shorts < HTF MA (bearTrendOK).
Impact: Aligns trades with the bigger trend, reducing counter-trend losses.
US Session Filter:
Logic: Restricts trading to 9:30am–4:00pm ET (default: enabled, useSession = true) using America/New_York timezone.
Impact: Focuses on high-liquidity hours, avoiding overnight spreads and erratic moves.
Evolution:
- These filters create a robust signal pipeline, ensuring trades are timed for optimal conditions.
- Customizable inputs (e.g., zThreshold, atrPercentile) let traders adapt to their style without compromising quality.
3. Risk Management
The strategy’s risk controls are a masterclass in balancing aggression and safety, protecting capital in volatile markets.
Daily Loss Kill Switch:
Logic: Tracks daily loss (dayStartEquity - strategy.equity). Halts trading if loss ≥ $300 (default) and enabled (killSwitch = true, killSwitchActive).
Impact: Caps daily downside, crucial during events like April 27, 2025 ES slippage.
Rolling Drawdown Kill Switch:
Logic: Monitors drawdown (rollingPeak - strategy.equity) over 100 bars (default). Stops trading if > $1000 (rollingKill).
Impact: Prevents prolonged losing streaks, preserving capital for better setups.
Dynamic Stop-Loss and Take-Profit:
Logic: Stops = entry ± ATR * multiplier (default: 1.0x, stopDist). TPs = entry ± ATR * 1.5x (profitDist). Longs: stop below, TP above; shorts: vice versa.
Impact: Adapts to volatility, keeping stops tight but realistic, with TPs targeting 1.5:1 reward/risk.
Max Bars in Trade:
Logic: Closes trades after 8 bars (default) if not already exited.
Impact: Frees capital from stagnant trades, maintaining efficiency.
Kill Switch Buffer Dashboard:
Logic: Shows smallest buffer ($300 - daily loss or $1000 - rolling DD). Displays 0 (red) if kill switch active, else buffer (green).
Impact: Real-time risk visibility, letting traders adjust dynamically.
Why It’s Brilliant:
- Kill switches and ATR-based exits create a safety net, rare in generic scripts.
- Customizable risk inputs (maxDailyLoss, dynamicStopMult) suit different account sizes.
- Buffer metric empowers disciplined trading, a DAFE signature.
4. Trade Entry and Exit Logic
The entry/exit rules are precise, filtered, and adaptive, ensuring trades are deliberate and profitable.
Entry Conditions:
Long Entry: bullDiv2, cooldown passed (canSignal), ATR filter passed (tradeOk), in US session (inSession), no kill switches (not killSwitchActive, not rollingKill), z-score OK (zOk), HTF trend bullish (bullTrendOK), no existing long (lastDirection != 1, position_size <= 0). Closes shorts first.
Short Entry: Same, but for bearDiv2, bearTrendOK, no long (lastDirection != -1, position_size >= 0). Closes longs first.
Adaptive Cooldown: Default 2 bars (cooldownBars). Doubles (up to 10) after a losing trade, resets after wins (dynamicCooldown).
Exit Conditions:
Stop-Loss/Take-Profit: Set per trade (ATR-based). Exits on stop/TP hits.
Other Exits: Closes if maxBarsInTrade reached, ATR filter fails, or kill switch activates.
Position Management: Ensures no conflicting positions, closing opposites before new entries.
Built To Be Reliable and Consistent:
- Multi-filtered entries minimize false signals, a stark contrast to basic scripts.
- Adaptive cooldown prevents overtrading, especially after losses.
- Clean position handling ensures smooth execution, even in fast markets.
5. DAFE Visuals
The visuals are a DAFE hallmark, blending function with clean flair to make signals intuitive and charts stunning.
Aurora Bands:
Display: Bands around price during divergences (bullish: below low, bearish: above high), sized by ATR * bandwidth (default: 0.5).
Colors: Aqua (bullish), fuchsia (bearish), with transparency tied to divStrengthNorm.
Purpose: Highlights divergence zones with a glowing, futuristic vibe.
Divergence Orbs:
Display: Large/small circles (aqua below for bullish, fuchsia above for bearish) when bullDiv2/bearDiv2 and canSignal. Labels show strength (0–1).
Purpose: Pinpoints entries with eye-catching clarity.
Gradient Background:
Display: Green (bullish), red (bearish), or gray (neutral), 90–95% transparent.
Purpose: Sets the market mood without clutter.
Strategy Plots:
- Stop/TP Lines: Red (stops), green (TPs) for active trades.
- HTF MA: Yellow line for trend context.
- Z-Score: Blue step-line (if enabled).
- Kill Switch Warning: Red background flash when active.
What Makes This Next-Level?:
- Visuals make complex signals (divergences, filters) instantly clear, even for beginners.
- DAFE’s unique aesthetic (orbs, bands) sets it apart from generic scripts, reinforcing originality.
- Functional plots (stops, TPs) enhance trade management.
6. Metrics Dashboard
The top-right dashboard (2x8 table) is your command center, delivering real-time insights.
Metrics:
Daily Loss ($): Current loss vs. day’s start, red if > $300.
Rolling DD ($): Drawdown vs. 100-bar peak, red if > $1000.
ATR Threshold: Current percATR, green if ATR exceeds, red if not.
Z-Score: Current value, green if within threshold, red if not.
Signal: “Bullish Div” (aqua), “Bearish Div” (fuchsia), or “None” (gray).
Action: “Consider Buying”/“Consider Selling” (signal color) or “Wait” (gray).
Kill Switch Buffer ($): Smallest buffer to kill switch, green if > 0, red if 0.
Why This Is Important?:
- Consolidates critical data, making decisions effortless.
- Color-coded metrics guide beginners (e.g., green action = go).
- Buffer metric adds transparency, rare in off-the-shelf scripts.
7. Beginner Guide
Beginner Guide: Middle-right table (shown once on chart load), explains aqua orbs (bullish, buy) and fuchsia orbs (bearish, sell).
Key Features:
Futures-Optimized: Tailored for MNQ, NQ, MES, ES with point-value adjustments.
Highly Customizable: Inputs for lookback, sensitivity, filters, and risk settings.
Real-Time Insights: Dashboard and visuals update every bar.
Backtest-Ready: Fixed qty and tick calc for accurate historical testing.
User-Friendly: Guide, visuals, and dashboard make it accessible yet powerful.
Original Design: DAFE’s unique logic and visuals stand out from generic scripts.
How to Use
Add to Chart: Load on a 5min MNQ/ES chart in TradingView.
Configure Inputs: Adjust instrument, filters, or risk (defaults optimized for MNQ).
Monitor Dashboard: Watch signals, actions, and risk metrics (top-right).
Backtest: Run in strategy tester to evaluate performance.
Live Trade: Connect to a broker (e.g., Tradovate) for automation. Watch for slippage (e.g., April 27, 2025 ES issues).
Replay Test: Use bar replay (e.g., April 28, 2025 NQ drop) to test volatility handling.
Disclaimer
Trading futures involves significant risk of loss and is not suitable for all investors. Past performance is not indicative of future results. Backtest results may not reflect live trading due to slippage, fees, or market conditions. Use this strategy at your own risk, and consult a financial advisor before trading. Dskyz (DAFE) Trading Systems is not responsible for any losses incurred.
Backtesting:
Frame: 2023-09-20 - 2025-04-29
Fee Typical Range (per side, per contract)
CME Exchange $1.14 – $1.20
Clearing $0.10 – $0.30
NFA Regulatory $0.02
Firm/Broker Commis. $0.25 – $0.80 (retail prop)
TOTAL $1.60 – $2.30 per side
Round Turn: (enter+exit) = $3.20 – $4.60 per contract
Final Notes
The Dskyz (DAFE) Aurora Divergence – Quant Master isn’t just a strategy—it’s a movement. Crafted with originality and driven by community passion, it rises above the flood of generic scripts to deliver a system that’s as powerful as it is beautiful. With its quant-grade logic, DAFE visuals, and robust risk controls, it empowers traders to tackle futures with confidence and style. Join the DAFE crew, light up your charts, and let’s outsmart the markets together!
(This publishing will most likely be taken down do to some miscellaneous rule about properly displaying charting symbols, or whatever. Once I've identified what part of the publishing they want to pick on, I'll adjust and repost.)
Use it with discipline. Use it with clarity. Trade smarter.
**I will continue to release incredible strategies and indicators until I turn this into a brand or until someone offers me a contract.
Created by Dskyz, powered by DAFE Trading Systems. Trade fast, trade bold.
NYCSessionLibrary "NYCSession"
Library for New York trading session time functions
@author abneralvarado
@version 1.0
isInNYSession(sessionStart, sessionEnd)
Determines if the current bar is within New York trading session
Parameters:
sessionStart (simple int) : Starting time of NY session in 24hr format (HHMM) like 0930 for 9:30 AM ET
sessionEnd (simple int) : Ending time of NY session in 24hr format (HHMM) like 1600 for 4:00 PM ET
Returns: True if current bar is within the NY session time, false otherwise
getNYSessionStartTime(lookback, sessionStart)
Gets the start time of NY session for a given bar
Parameters:
lookback (simple int) : Bar index to check (0 is current bar)
sessionStart (simple int) : Starting time of NY session in 24hr format (HHMM)
Returns: Unix timestamp for the start of NY session on the given bar's date
getNYSessionEndTime(lookback, sessionEnd)
Gets the end time of NY session for a given bar
Parameters:
lookback (simple int) : Bar index to check (0 is current bar)
sessionEnd (simple int) : Ending time of NY session in 24hr format (HHMM)
Returns: Unix timestamp for the end of NY session on the given bar's date
isNYSessionOpen(sessionStart)
Checks if current bar opens the NY session
Parameters:
sessionStart (simple int) : Starting time of NY session in 24hr format (HHMM)
Returns: True if current bar marks the session opening, false otherwise
isNYSessionClose(sessionEnd)
Checks if current bar closes the NY session
Parameters:
sessionEnd (simple int) : Ending time of NY session in 24hr format (HHMM)
Returns: True if current bar marks the session closing, false otherwise
isWeekday()
Determines if the current day is a weekday (Mon-Fri)
Returns: True if current bar is on a weekday, false otherwise
getSessionBackgroundColor(sessionStart, sessionEnd, bgColor)
Gets session background color with transparency
Parameters:
sessionStart (simple int) : Starting time of NY session in 24hr format (HHMM)
sessionEnd (simple int) : Ending time of NY session in 24hr format (HHMM)
bgColor (color) : Background color for session highlighting
Returns: Color value for background or na if not in session
BCVC - Volume & Big Candle ColorThe BCVC (Volume & Big Candle Color) indicator helps traders identify significant price movements accompanied by unusual volume activity. By dynamically coloring bars based on volume spikes and candle size, it highlights potential momentum shifts, breakouts, or reversals. This tool is ideal for traders who want to:
Spot institutional buying/selling activity.
Confirm trend strength using volume and price volatility.
Filter noise by focusing on high-impact bars.
Key Features
Volume Spike Detection:
Compares current volume to a moving average (EMA) of volume.
Highlights bars where volume exceeds the average by a user-defined multiplier.
Big Candle Detection:
Identifies bars with a range (high-low) larger than the historical average range (EMA of candle ranges).
Thresholds for "big candles" are customizable.
Color-Coded Logic:
White Bars: High volume + Big candle + Bullish (close > open).
Orange Bars: High volume + Big candle + Bearish (close < open).
Blue Bars: High volume + Regular candle + Bullish.
Maroon Bars: High volume + Regular candle + Bearish.
Input Parameters
Volume Settings:
Volume Period: EMA length for average volume calculation (default: 20).
Volume Multiplier: Threshold multiplier for volume spikes (e.g., 1.25 = 25% above average).
Candle Size Settings:
Lookback Period: EMA length for average candle range (default: 7).
Big Candle Multiplier: Threshold multiplier for large candles (e.g., 1.3 = 30% above average range).
How It Works
Volume Analysis:
The indicator calculates an EMA of volume over the specified period.
If the current bar’s volume exceeds Average Volume × Volume Multiplier, it’s flagged as a high-volume bar.
Candle Range Analysis:
The average candle range (high-low) is calculated using an EMA over the lookback period.
A "big candle" is identified when the current bar’s range exceeds Average Range × Big Candle Multiplier.
Combined Signals:
High-volume bars are colored based on whether they are bullish/bearish and whether their range exceeds the big-candle threshold.
Example: A white bar (high volume + big candle + bullish) suggests strong buying pressure with institutional participation.
Usage Scenarios
Breakout Confirmation: A white/orange bar at a support/resistance level may validate a breakout.
Reversal Signals: A maroon/orange bar after a long trend could indicate exhaustion and potential reversal.
Trend Strength: Clusters of blue/white bars during uptrends (or maroon/orange in downtrends) confirm momentum.
Benefits
Visual Clarity: Instantly spot high-impact bars without manually scanning volume or candle size.
Customizable Sensitivity: Adjust multipliers to filter noise (e.g., increase for fewer signals).
Universal Application: Works on all timeframes and instruments (stocks, forex, crypto).
Notes
Best Paired With: Trendlines, support/resistance levels, or momentum oscillators (e.g., RSI).
Avoid False Signals: Use higher multipliers (e.g., 1.5) on lower timeframes to reduce noise.
Recency-Weighted Market Memory w/ Quantile-Based DriftRecency-Weighted Market Memory w/ Quantile-Based Drift
This indicator combines market memory, recency-weighted drift, quantile-based volatility analysis, momentum (RoC) filtering, and historical correlation checks to generate dynamic forecasts of possible future price levels. It calculates bullish and bearish forecast lines at each horizon, reflecting how the price might behave based on historical similarities.
Trading Concepts & Mathematical Foundations Explained
1) Market Memory
Concept:
Markets tend to repeat past behaviors under similar conditions. By identifying historical market states that closely match current conditions, we predict future price movements based on what happened historically.
Calculation Steps:
We select a historical lookback window (for example, 210 bars).
Each historical bar within this window is evaluated to see if its conditions match the current market. Conditions include:
Correlation between price change and bullish/bearish volume changes (over a user-defined correlation lookback period).
Momentum (Rate of Change, RoC) measured over a separate lookback period.
Only bars closely matching current conditions (within user-defined tolerance percentages) are included.
2) Recency-Weighted Drift
Concept:
Recent market movements often influence future direction. We assign more importance to recent bars to capture the current market bias effectively.
Calculation Steps:
Consider recent price changes between opens and closes for a user-defined drift lookback (for example, last 20 bars).
Give higher weight to recent bars (the most recent bar gets the highest weight, and weights decrease progressively for older bars).
Average these weighted changes separately for upward and downward movements, then combine these averages to calculate a final drift percentage relative to the current price.
3) Correlation Filtering
Concept:
Price changes often correlate strongly with bullish or bearish volume activity. By using historical correlation comparisons, we focus only on past market states with similar volume-price dynamics.
Calculation Steps:
Compute current correlations between price changes and bullish/bearish volume over the user-defined correlation lookback.
Evaluate each historical bar to see if its correlation closely matches the current correlation (within a user-specified percentage tolerance).
Only historical bars meeting this correlation criterion are selected.
4) Momentum (RoC) Filtering
Concept:
Two market periods may exhibit similar correlation structures but differ in how fast prices move (momentum). To ensure true similarity, momentum is checked as an additional filter.
Calculation Steps:
Compute the current Rate of Change (RoC) over the specified RoC lookback.
For each candidate historical bar, calculate its historical RoC.
Only include historical bars whose RoC closely matches the current RoC (within the RoC percentage tolerance).
5) Quantile-Based Volatility and Drift Amplification
Concept:
Quantiles (such as the 95th, 50th, and 5th percentiles) help gauge if current prices are near historical extremes or the median. Quantile bands measure volatility expansions and contractions.
Calculation Steps:
Calculate the 95%, 50%, and 5% quantiles of price over the quantile lookback period.
Add and subtract multiples of the standard deviation to these quantiles, creating upper and lower bands.
Measure the bands' widths relative to the current price as volatility indicators.
Determine the active quantile (95%, 50%, or 5%) based on proximity to the current price (within a percentage tolerance).
Compute the rate of change (RoC) of the active quantile to detect directional bias.
Combine volatility and quantile RoC into a scaling factor that amplifies or dampens expected price moves.
6) Expected Value (EV) Computation & Forecast Lines
Concept:
We forecast future prices based on how similarly-conditioned historical periods performed. We average historical moves to estimate the expected future price.
Calculation Steps:
For each forecast horizon (e.g., 1 to 27 bars ahead), collect all historical price moves that passed correlation and RoC filters.
Calculate average historical moves for bullish and bearish cases separately.
Adjust these averages by applying recency-weighted drift and quantile-based scaling.
Translate adjusted percentages into absolute future price forecasts.
Draw bullish and bearish forecast lines accordingly.
Indicator Inputs & Their Roles
Correlation Tolerance (%)
Adjusts how strictly the indicator matches historical correlation. Higher tolerance includes more matches, lower tolerance selects fewer but closer matches.
Price RoC Lookback and Price RoC Tolerance (%)
Controls how momentum (speed of price moves) is matched historically. Increasing tolerance broadens historical matches.
Drift Lookback (bars)
Determines the number of recent bars influencing current drift estimation.
Quantile Lookback Period and Std Dev Multipliers
Defines quantile calculation and the size of the volatility bands.
Quantile Contact Tolerance (%)
Sets how close the current price must be to a quantile for it to be considered "active."
Forecast Horizons
Specifies how many future bars to forecast.
Continuous Forecast Lines
Toggles between drawing continuous lines or separate horizontal segments for each forecast horizon.
Practical Trading Applications
Bullish & Bearish EV Lines
These forecast lines indicate expected price levels based on historical similarity. Green indicates positive expectations; red indicates negative.
Momentum vs. Mean Reversion
Wide quantile bands and high drift suggest momentum, while extremes may signal possible reversals.
Volatility Sensitivity
Forecasts adapt dynamically to market volatility. Broader bands increase forecasted price movements.
Filtering Non-Relevant Historical Data
By using both correlation and RoC filtering, irrelevant past periods are excluded, enhancing forecast reliability.
Multi-Timeframe Suitability
Adaptable parameters make this indicator suitable for different trading styles and timeframes.
Complementary Tool
This indicator provides probabilistic projections rather than direct buy or sell signals. Combine it with other trading signals and analyses for optimal results.
Important Considerations
While historically-informed forecasts are valuable, market behavior can evolve unpredictably. Always manage risks and use supplementary analysis.
Experiment extensively with input settings for your specific market and timeframe to optimize forecasting performance.
Summary
The Recency-Weighted Market Memory w/ Quantile-Based Drift indicator uniquely merges multiple sophisticated concepts, delivering dynamic, historically-informed price forecasts. By combining historical similarity, adaptive drift, momentum filtering, and quantile-driven volatility scaling, traders gain an insightful perspective on future price possibilities.
Feel free to experiment, explore, and enjoy this powerful addition to your trading toolkit!
beanBean's Multi-Instrument Pattern Scanner.
This indicator scans H1 timeframe for specific technical patterns. Here's how each pattern is detected:
PATTERN DETECTION CRITERIA:
1. Hammer
- Body Size: ≤ 30% of total candle length
- Lower Wick: > 50% of total candle length
- Upper Wick: < 20% of total candle length
- Formula:
* bodySize = |close - open|
* upperWick = high - max(open, close)
* lowerWick = min(open, close) - low
* totalLength = high - low
2. Shooting Star
- Body Size: ≤ 30% of total candle length
- Upper Wick: > 50% of total candle length
- Lower Wick: < 20% of total candle length
- Uses same measurements as Hammer but inverted
3. Outside/Inside (OI)
Checks three consecutive bars:
- Outside Bar: Bar2 high ≥ Bar3 high AND Bar2 low ≤ Bar3 low
- Inside Bar: Bar1 high ≤ Bar2 high AND Bar1 low ≥ Bar2 low
Pattern confirms when both conditions are met
4. Bullish/Bearish Umbrella
Checks two consecutive bars:
Bullish:
- Current bar's high ≤ previous bar's high
- Current body high ≤ previous bar's high
- Current body low ≥ previous body high
Bearish:
- Current bar's low ≥ previous bar's low
- Current body low ≥ previous bar's low
- Current body high ≤ previous body low
5. Three Bar Triangle (3BT)
Checks three consecutive bars:
- Current bar's high ≤ max(previous two highs)
- Current bar's low ≥ min(previous two lows)
- Indicates price compression
DISPLAY AND ALERTS:
- Patterns are displayed in real-time in the table
- Multiple patterns can be detected simultaneously
- Pattern detection resets each new H1 candle
CONFIGURATION:
- Each row can be independently configured
- Patterns are checked on H1 timeframe close
- Alert frequency: Once per H1 bar close
Note: All measurements use standard OHLC values from only completed H1 candles.
