Indicator
Sequential Exhaustion Tracker [AGPro Series]Sequential Exhaustion Tracker
🔷 Overview
Sequential Exhaustion Tracker is a price-action based trend maturity tool built for traders who want to read how far a directional candle sequence has developed, when that sequence is becoming late-stage, and whether the market is more likely to recycle the move or fail back through its terminal zone.
The script is not an oscillator, not a crossover tool, and not a protected-brand sequential clone. It does not depend on classic overbought or oversold thresholds. Instead, it tracks qualified directional progress bar by bar, measures the quality of the active count, opens a visual exhaustion window when the run becomes mature, and then follows the next phase as either recycle, testing, or failure.
That makes the script useful for a very specific question:
Is the current directional run still building cleanly, or has it entered the kind of late-sequence area where follow-through, failure, and reset behavior need closer attention?
🔷 What The Script Measures
The engine combines four practical components:
1. Directional candle count
The script counts qualified progress candles in the active direction. A candle must show meaningful close-to-close progress, sufficient body commitment, and optional trend-filter alignment before it can advance the count.
2. Exhaustion threshold
The count becomes mature only after it reaches the selected threshold. This avoids treating every small move as exhaustion and keeps the tool focused on developed directional sequences.
3. Exhaustion quality
The quality model blends count maturity, ATR-normalized stretch from the baseline, opposing wick absorption, and body-efficiency fade. A high reading means the sequence is not only long enough, but also showing late-run characteristics.
4. Recycle/failure lifecycle
Once a qualified exhaustion window appears, the script continues tracking price behavior. Strong continuation through the terminal zone can classify the sequence as recycled. A break back through the zone can classify it as failed. This turns the indicator into a lifecycle tracker instead of a one-bar label generator.
🔷 Visual Design
The chart output is designed to stay premium and readable:
- Compact count labels use milestone-based defaults so the chart shows sequence progress without turning into a label wall.
- ATR-based label offsets keep labels away from candle bodies.
- Exhaustion zones are drawn as rectangular terminal windows, not generic support/resistance blocks.
- Recycle and failure markers are intentionally short and selective.
- Older labels and zones are automatically removed to protect chart performance.
- The summary panel uses the AGPro standard merged blue title row and a clean four-line state readout.
🔷 Panel Readout
The panel summarizes the active condition in a compact format:
Direction
Shows whether the current qualified run is bullish, bearish, or neutral.
Count
Shows the active sequential count against the selected exhaustion threshold.
Exhaustion Quality
Shows the maturity score and the current quality band.
Recycle Status
Shows whether the sequence is building, mature, testing an exhaustion window, recycling, recycled, failed, or waiting.
🔷 How This Differs From Other AGPro Scripts
This script is intentionally separated from AGPro oscillator exhaustion tools.
Stochastic Exhaustion Map focuses on stochastic behavior, momentum fatigue, and reset context inside an oscillator framework.
Williams %R Exhaustion Map focuses on Williams %R extension behavior and release-corridor logic.
Sequential Exhaustion Tracker focuses on the visible candle sequence itself: directional progress, count maturity, terminal exhaustion zone, and post-exhaustion lifecycle behavior.
It is also different from support/resistance reaction tools because the rectangles are not structural S/R zones. They are temporary terminal sequence windows created only when a mature count and exhaustion quality condition are present.
🔷 How This Differs From Common Sequential Count Scripts
Many sequential scripts focus mainly on printing a fixed count and stopping there. Sequential Exhaustion Tracker takes a different path.
It does not simply count bars for visual decoration. It asks whether the count is supported by meaningful directional progress, whether the run has become stretched relative to its own volatility, whether the candle structure is showing absorption, and what happens after the mature sequence appears.
The key difference is the lifecycle layer:
- Building sequence
- Mature count
- Exhaustion window
- Testing window
- Recycle build
- Recycled continuation
- Failed exhaustion window
This gives the script a cleaner analytical role than a basic numbered label tool.
🔷 Suggested Use
The script is best used as a chart-context layer for:
- identifying late-stage directional runs
- separating fresh continuation from mature extension
- watching terminal sequence zones
- studying continuation recycle behavior
- spotting failed late-run pressure
- keeping sequential count context visible without overcrowding the chart
It is designed to complement market structure, trend context, volatility conditions, and the trader's broader workflow.
🔷 Default Settings
The default settings are built for a balanced public-chart presentation:
- Count threshold: 8
- Quality threshold: 62
- Trend alignment: enabled
- Count label mode: Mature Milestones
- Count label start: 6
- Minimum label spacing: 8 bars
- Exhaustion zones: enabled
- Panel: enabled
- Label and panel font sizes: Normal
These defaults aim to keep the chart informative without turning it into a noisy label wall.
🔷 Why It Was Built
Directional markets often move in phases. Early movement can be clean and efficient. Middle movement can be supported and persistent. Late movement can still continue, but the character of the candles often starts to change.
Sequential Exhaustion Tracker was built to make that progression easier to read directly on the chart. The goal is not to call every top or bottom. The goal is to show where the current sequence sits in its own lifecycle and whether the post-exhaustion behavior is confirming continuation, stalling, or failing.
That narrow focus is what makes the tool distinct: it is not a general momentum dashboard, not an oscillator map, not a support/resistance engine, and not a signal checklist. It is a dedicated sequential maturity and lifecycle tracker.
Indicator
Count█ OVERVIEW
A library of functions for counting the number of times (frequency) that elements occur in an array or matrix.
█ USAGE
Import the Count library.
import joebaus/count/1 as c
Create an array or matrix that is a `float`, `int`, `string`, or `bool` type to count elements from, then call the count function on the array or matrix.
id = array.from(1.00, 1.50, 1.25, 1.00, 0.75, 1.25, 1.75, 1.25)
countMap = id.count() // Alternatively: countMap = c.count(id)
The "count map" will return a map with keys for each unique element in the array or matrix, and with respective values representing the number of times the unique element was counted. The keys will be the same type as the array or matrix counted. The values will always be an `int` type.
array mapKeys = countMap.keys() // Returns unique keys
array mapValues = countMap.values() // Returns counts
If an array is in ascending or descending order, then the keys of the map will also generate in the same order.
intArray = array.from(2, 2, 2, 3, 4, 4, 4, 4, 4, 6, 6) // Ascending order
map countMap = intArray.count() // Creates a "count map" of all unique elements
array mapKeys = countMap.keys() // Returns // Ascending order
array mapValues = countMap.values() // Returns count
Include a value to get the count of only that value in an array or matrix.
floatMatrix = matrix.new(3, 3, 0.0)
floatMatrix.set(0, 0, 1.0), floatMatrix.set(1, 0, 1.0), floatMatrix.set(2, 0, 1.0)
floatMatrix.set(0, 1, 1.5), floatMatrix.set(1, 1, 2.0), floatMatrix.set(2, 1, 2.5)
floatMatrix.set(0, 2, 1.0), floatMatrix.set(1, 2, 2.5), floatMatrix.set(2, 2, 1.5)
int countFloatMatrix = floatMatrix.count(1.0) // Counts all 1.0 elements, returns 5
// Alternatively: int countFloatMatrix = c.count(floatMatrix, 1.0)
The string method of count() can use strings or regular expressions like "bull*" to count all matching occurrences in a string array.
stringArray = array.from('bullish', 'bull', 'bullish', 'bear', 'bull', 'bearish', 'bearish')
int countString = stringArray.count('bullish') // Returns 2
int countStringRegex = stringArray.count('bull*') // Returns 4
To count multiple values, use an array of values instead of a single value. Returning a count map only of elements in the array.
countArray = array.from(1.0, 2.5)
map countMap = floatMatrix.count(countArray)
array mapKeys = countMap.keys() // Returns keys
array mapValues = countMap.values() // Returns counts
Multiple regex patterns or strings can be counted as well.
stringMatrix = matrix.new(3, 3, '')
stringMatrix.set(0, 0, 'a'), stringMatrix.set(1, 0, 'a'), stringMatrix.set(2, 0, 'a')
stringMatrix.set(0, 1, 'b'), stringMatrix.set(1, 1, 'c'), stringMatrix.set(2, 1, 'd')
stringMatrix.set(0, 2, 'a'), stringMatrix.set(1, 2, 'd'), stringMatrix.set(2, 2, 'b')
// Count the number of times the regex patterns `'^(a|c)$'` and `'^(b|d)$'` occur
array regexes = array.from('^(a|c)$', '^(b|d)$')
map countMap = stringMatrix.count(regexes)
array mapKeys = countMap.keys() // Returns
array mapValues = countMap.values() // Returns
An optional comparison operator can be specified to count the number of times an equality was satisfied for `float`, `int`, and `bool` methods of `count()`.
intArray = array.from(2, 2, 2, 3, 4, 4, 4, 4, 4, 6, 6)
// Count the number of times an element is greater than 4
countInt = intArray.count(4, '>') // Returns 2
When passing an array of values to count and a comparison operator, the operator will apply to each value.
intArray = array.from(2, 2, 2, 3, 4, 4, 4, 4, 4, 6, 6)
values = array.from(3, 4)
// Count the number of times and element is greater than 3 and 4
map countMap = intArray.count(values, '>')
array mapKeys = countMap.keys() // Returns
array mapValues = countMap.values() // Returns
Multiple comparison operators can be applied when counting multiple values.
intMatrix = matrix.new(3, 3, 0)
intMatrix.set(0, 0, 2), intMatrix.set(1, 0, 3), intMatrix.set(2, 0, 5)
intMatrix.set(0, 1, 2), intMatrix.set(1, 1, 4), intMatrix.set(2, 1, 2)
intMatrix.set(0, 2, 5), intMatrix.set(1, 2, 2), intMatrix.set(2, 2, 3)
values = array.from(3, 4)
comparisons = array.from('<', '>')
// Count the number of times an element is less than 3 and greater than 4
map countMap = intMatrix.count(values, comparisons)
array mapKeys = countMap.keys() // Returns
array mapValues = countMap.values() // Returns
Library
Indicator
Indicator
Smart Bar Counter with Alerts🚀 Smart Bar Counter with Alerts 🚀
-----------------------------------------------------
Overview
-----------------------------------------------------
Ever wanted to count a specific number of bars from a key point on your chart—such as after a Break of Structure (BOS), the start of a new trading session, or from any point of interest— without having to stare at the screen?
This "Smart Bar Counter" indicator was created to solve this exact problem. It's a simple yet powerful tool that allows you to define a custom "Start Point" and a "Target Bar Count." Once the target count is reached, it can trigger an Alert to notify you immediately.
-----------------------------------------------------
Key Features
-----------------------------------------------------
• Manual Start Point: Precisely select the date and time from which you want the count to begin, offering maximum flexibility in your analysis.
• Custom Bar Target: Define exactly how many bars you want to count, whether it's 50, 100, or 200 bars.
• On-Chart Display: A running count is displayed on each bar after the start time, allowing you to visually track the progress.
• Automatic Alerts: Set up alerts to be notified via PulseWire's various channels (pop-up, mobile app, email) once the target count is reached.
-----------------------------------------------------
How to Use
-----------------------------------------------------
1. Add this indicator to your chart.
2. Go to the indicator's Settings (Gear Icon ⚙️).
- Select Start Time: Set the date and time you wish to begin counting.
- Number of Bars to Count: Input your target number.
3. Set up the Alert ( Very Important! ).
- Right-click on the chart > Select " Add alert ."
- In the " Condition " dropdown, select this indicator: Smart Bar Counter with Alerts .
- In the next dropdown, choose the available alert condition.
- Set " Options " to Once Per Bar Close .
- Choose your desired notification methods under " Alert Actions ."
- Click " Create ."
-----------------------------------------------------
Use Cases
-----------------------------------------------------
• Post-Event Analysis: Count bars after a key event like a Break of Structure (BOS) or Change of Character (CHoCH) to observe subsequent price action.
• Time-based Analysis: Use it to count bars after a market open for a specific session (e.g., London, New York).
• Strategy Backtesting: Useful for testing trading rules that are based on time or a specific number of bars.
-----------------------------------------------------
Final Words
-----------------------------------------------------
Hope you find this indicator useful for your analysis and trading strategies! Feel free to leave comments or suggestions below. Indicator
Indicator
Indicator
Indicator
FiboSequFiboSequ: Fibonacci Sequence Marking
Leonardo Fibonacci was an Italian mathematician who lived in the 12th century. His real name was Leonardo of Pisa, but he is commonly known as "Fibonacci." Fibonacci is famous for introducing the Hindu-Arabic numeral system to the Western world. This system is the basis of the modern decimal number system we use today.
Fibonacci Sequence
The Fibonacci sequence is a series of numbers that frequently appears in mathematics and nature. The first two numbers in the sequence are 0 and 1, and each subsequent number is the sum of the two preceding numbers.
The sequence is as follows:
0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, ...
Fibonacci Time Zones:
Fibonacci time zones are used to identify potential turning points in the market at specific time intervals. These time zones correspond to the Fibonacci sequence in terms of consecutive days or weeks.
The Fibonacci sequence has a wide range of applications in both mathematics and nature. Leonardo Fibonacci's work has had a significant impact on the development of modern mathematics and numeral systems. In financial markets, the Fibonacci sequence and ratios are frequently used by technical analysts to predict and analyze market movements.
Description:
Overview:
The FiboSequ indicator marks significant days on a price chart based on the Fibonacci sequence. This can help traders identify potential turning points or areas of interest in the market. The Fibonacci sequence is a series of numbers where each number is the sum of the two preceding ones, often found in nature and financial markets.
Fibonacci Sequence:
The sequence used in this indicator includes: 1, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, and 2584.
These numbers represent the days to be marked on the chart, highlighting possible significant market movements.
How It Works:
User Input:
Users can input the starting date (Year, Month, and Day) from which the Fibonacci sequence will begin to be calculated.
This allows flexibility and customization based on the trader's analysis needs.
Calculation:
The starting date is converted into a timestamp in seconds.
For each bar on the chart, the number of days since the starting date is calculated.
The indicator checks if the current day matches any of the Fibonacci sequence days, the previous day, or the next day.
In this indicator, Fibonacci numbers can be displayed on the chart as plus and minus 2 days. For example, for the 145th day, signals start to appear as 143,144 and 145. This is due to dates that sometimes coincide with weekends and public holidays.
Marking the Chart:
When a match is found, a label is placed above the bar indicating the day number from the Fibonacci sequence.
These labels are colored blue with white text for easy visibility.
Usage:
This indicator can be used on any timeframe and market to help identify potential areas where price might react.
It is especially useful for those who employ Fibonacci analysis in their trading strategy.
Example:
If the starting date is January 1, 2020, the indicator will mark significant Fibonacci days (e.g., 1, 3, 5, 8 days, etc.) on the chart from this date onward.
Community Guidelines Compliance:
This indicator adheres to PulseWire's Pine Script community guidelines.
It provides customizable user inputs and does not violate any terms of use.
By using the FiboSequ indicator, traders can enhance their technical analysis by incorporating time-based Fibonacci levels, potentially leading to better market timing and decision-making.
Frequently Asked Questions (FAQ)
Q: What is the FiboSequ indicator?
A: The FiboSequ indicator is a technical analysis tool that marks significant days on a price chart based on the Fibonacci sequence. This indicator helps traders identify potential turning points or areas of interest in the market.
Q: What is the Fibonacci sequence and why is it important?
A: The Fibonacci sequence is a series of numbers where each number is the sum of the two preceding ones. The first two numbers are 0 and 1. This sequence frequently appears in nature and financial markets and is used in technical analysis to identify important support and resistance levels.
Q: How do the Fibonacci time zones in the indicator work?
A: Fibonacci time zones are used to identify potential market turning points at specific time intervals. The indicator calculates days based on the Fibonacci sequence (e.g., 1, 3, 5, 8 days, etc.) from the starting date and marks them on the chart.
Q: How can users set the starting date?
A: Users can input the starting date by specifying the year, month, and day. This sets the date from which the indicator begins its calculations, providing flexibility for user analysis.
Q: What do the labels in the indicator represent?
A: The labels mark specific days in the Fibonacci sequence. For example, 1st day, 3rd day, 5th day, etc. These labels are displayed in blue with white text for easy visibility.
Q: Which timeframes can I use the FiboSequ indicator on?
A: The FiboSequ indicator can be used on any timeframe. This includes daily, weekly, or monthly charts, as well as shorter timeframes.
Q: Which markets can the FiboSequ indicator be used in?
A: The FiboSequ indicator can be used in various financial markets, including stocks, forex, cryptocurrencies, commodities, and more.
Q: How can I achieve better market timing with the FiboSequ indicator?
A: The FiboSequ indicator helps identify potential market turning points using time-based Fibonacci levels. This can lead to better market timing and more informed trading decisions for traders.
-Please feel free to write your valuable comments and opinions. I attach importance to your valuable opinions so that I can improve myself. Indicator
Indicator
Strategy
Trend Direction Sequence | Auto-Multi-TimeframeThe main benefit of this indicator is the ability to see multiple higher timeframes at ones to get a better overview of signals that could mark possible trend reversals with more weight than those on the selected timeframe. Since the higher timeframes are calculated automatically, the user needs to set a Period Multiplier that multiplies the selected timeframe several times to determine the higher timeframes. Equal periods are filtered out. And the current highest timeframe is capped at 1 year by PulseWire.
It is possible to alter the sequence Count Limit and the underlying Wavelength. The Wavelength defines the distance between the starting and ending candle. This builds the minimum condition to find a trend. A longer Wavelength means that the distortions between the start and end candle can be bigger, so it can become easier to find a trending sequence. But be careful not to set the length too high as this could mean that the resulting sequence does not really represent a trend anymore. The Count Limit defines the completion of a trending sequence. A higher number makes it more difficult to find a completed sequence, but also makes the result more reliable. If the Wavelength is changed, the Count Limit should be adjusted accordingly.
There is also a qualifier for the completion of a sequence. A completed sequence only will be labeled on the chart, if it is proved that the lowest low/highest high of the last two candlesticks of a period is lower/higher than that of the previous two candlesticks. It does not require the trend to be continuous on the last candlestick. On the contrary, a trend shift may already have begun.
By default, the labeling of completed sequences will appear on the highs and lows of the specific periods. Because the higher periods will take time and several candlesticks to appear, the labels will be redrawn accordingly. As an option it is possible to disable the Count Limit for completed sequences so that the labels will be fluently redrawn until the corresponding sequences are interrupted by trend breaks. Only activate this option, if it can serve a plausible strategy.
The count status of all sequences in the specific timeframe periods is listed in a table. Also the results of the trends in higher timeframes are accumulated and combined into an overall trend. Positive trends are counted as positive, negative in the opposite case. To see the resulting Trend Shift Signals, the user can set a filter under 100% so that not all of them will be filtered out and therefore labeled on the chart (this signals cannot be redrawn). An “External Indicator Analysis Overlay” can be used to analyze the profitability with the provided Trend Shift Signal (TSS) which switches from 0 to 1, if the trend becomes positive or from 0 to -1, if the trend becomes negative. Indicator
Indicator
Indicator
FunctionPatternFrequencyLibrary "FunctionPatternFrequency"
Counts the word or integer number pattern frequency on a array.
reference:
rosettacode.org
count(pattern)
counts the number a pattern is repeated.
Parameters:
pattern : : array : array with patterns to be counted.
Returns:
array : list of unique patterns.
array : list of counters per pattern.
usage:
count(array.from('a','b','c','a','b','a'))
count(pattern)
counts the number a pattern is repeated.
Parameters:
pattern : : array : array with patterns to be counted.
Returns:
array : list of unique patterns.
array : list of counters per pattern.
usage:
count(array.from(1,2,3,1,2,1)) Library
Indicator
Indicator
FunctionElementsInArrayLibrary "FunctionElementsInArray"
Methods to count number of elements in arrays
count_float(sample, value) Counts the number of elements equal to provided value in array.
Parameters:
sample : float array, sample data to process.
value : float value to check for equality.
Returns: int.
count_int(sample, value) Counts the number of elements equal to provided value in array.
Parameters:
sample : int array, sample data to process.
value : int value to check for equality.
Returns: int.
count_string(sample, value) Counts the number of elements equal to provided value in array.
Parameters:
sample : string array, sample data to process.
value : string value to check for equality.
Returns: int.
count_bool(sample, value) Counts the number of elements equal to provided value in array.
Parameters:
sample : bool array, sample data to process.
value : bool value to check for equality.
Returns: int.
count_color(sample, value) Counts the number of elements equal to provided value in array.
Parameters:
sample : color array, sample data to process.
value : color value to check for equality.
Returns: int.
extract_indices_float(sample, value) Counts the number of elements equal to provided value in array, and returns its indices.
Parameters:
sample : float array, sample data to process.
value : float value to check for equality.
Returns: int.
extract_indices_int(sample, value) Counts the number of elements equal to provided value in array, and returns its indices.
Parameters:
sample : int array, sample data to process.
value : int value to check for equality.
Returns: int.
extract_indices_string(sample, value) Counts the number of elements equal to provided value in array, and returns its indices.
Parameters:
sample : string array, sample data to process.
value : string value to check for equality.
Returns: int.
extract_indices_bool(sample, value) Counts the number of elements equal to provided value in array, and returns its indices.
Parameters:
sample : bool array, sample data to process.
value : bool value to check for equality.
Returns: int.
extract_indices_color(sample, value) Counts the number of elements equal to provided value in array, and returns its indices.
Parameters:
sample : color array, sample data to process.
value : color value to check for equality.
Returns: int. Library
Indicator
Indicator
Indicator
Indicator
