ColorGradientLibrary "ColorGradient"
Library for creating color gradients and palettes with hex colors
hexToColor(hexStr)
hexToColor
Parameters:
hexStr (string) : Hex color string (e.g., "#FF0000" or "FF0000")
Returns: color value
gradientStep(color1, color2, steps, step)
gradientStep
Parameters:
color1 (string) : Starting color (hex string)
color2 (string) : Ending color (hex string)
steps (int) : Number of steps including start and end
step (int) : Current step (0 to steps-1)
Returns: Interpolated color
multiGradientStep(colors, totalSteps, step)
multiGradientStep
Parameters:
colors (array) : Array of hex color strings
totalSteps (int) : Total number of steps across all colors
step (int) : Current step (0 to totalSteps-1)
Returns: Interpolated color
applyPaletteStyle(hexStr, style)
applyPaletteStyle
Parameters:
hexStr (string) : Hex color string
style (string) : "normal", "pale", "pastel", "bright", "matte"
Returns: Adjusted color
getStyledGradient(colors, totalSteps, step, style)
getStyledGradient
Parameters:
colors (array) : Array of hex color strings
totalSteps (int) : Total number of steps
step (int) : Current step
style (string) : Palette style ("normal", "pale", "pastel", "bright", "matte")
Returns: Styled color
지표 및 전략
ma_PLibrary "ma_P"
This library is made to expand traders moving average arsenal.
sma(src, length)
Parameters:
src (float)
length (simple int)
sma(src, length)
Parameters:
src (float)
length (int)
eit(src)
Parameters:
src (float)
ema(src, length)
Parameters:
src (float)
length (simple int)
ema(src, length)
Parameters:
src (float)
length (int)
ahma(src, length)
Parameters:
src (float)
length (simple int)
ahma(src, length)
Parameters:
src (float)
length (int)
bmf(src, length)
Parameters:
src (float)
length (simple int)
bmf(src, length)
Parameters:
src (float)
length (int)
cma(src, length)
Parameters:
src (float)
length (simple int)
cma(src, length)
Parameters:
src (float)
length (int)
dema(src, length)
Parameters:
src (float)
length (simple int)
dema(src, length)
Parameters:
src (float)
length (int)
dswf(src, length)
Parameters:
src (float)
length (simple int)
dswf(src, length)
Parameters:
src (float)
length (int)
evwma(src, length, volume)
Parameters:
src (float)
length (simple int)
volume (float)
evwma(src, length, volume)
Parameters:
src (float)
length (int)
volume (float)
esd(src, length)
Parameters:
src (float)
length (simple int)
esd(src, length)
Parameters:
src (float)
length (int)
frama(src, length)
Parameters:
src (float)
length (simple int)
frama(src, length)
Parameters:
src (float)
length (int)
flsma(src, len)
Parameters:
src (float)
len (simple int)
flsma(src, len)
Parameters:
src (float)
len (int)
gmma(src, length)
Parameters:
src (float)
length (simple int)
gmma(src, length)
Parameters:
src (float)
length (int)
hcf(src, length)
Parameters:
src (float)
length (simple int)
hcf(src, length)
Parameters:
src (float)
length (int)
hma(src, length)
Parameters:
src (float)
length (simple int)
hma(src, length)
Parameters:
src (float)
length (int)
jma(src, length)
Parameters:
src (float)
length (simple int)
jma(src, length)
Parameters:
src (float)
length (int)
kama(source, length, min_length, max_length)
Parameters:
source (float)
length (int)
min_length (int)
max_length (int)
kijun(src, length)
Parameters:
src (float)
length (simple int)
kijun(src, length)
Parameters:
src (float)
length (int)
lsma(src, length)
Parameters:
src (float)
length (simple int)
lsma(src, length)
Parameters:
src (float)
length (int)
lma(src, length)
Parameters:
src (float)
length (simple int)
lma(src, length)
Parameters:
src (float)
length (int)
mf(src, length)
Parameters:
src (float)
length (simple int)
mf(src, length)
Parameters:
src (float)
length (int)
mm(src, length)
Parameters:
src (float)
length (simple int)
mm(src, length)
Parameters:
src (float)
length (int)
smma(src, length)
Parameters:
src (float)
length (simple int)
smma(src, length)
Parameters:
src (float)
length (int)
ssma(src, length)
Parameters:
src (float)
length (simple int)
ssma(src, length)
Parameters:
src (float)
length (int)
swma(src, length)
Parameters:
src (float)
length (simple int)
swma(src, length)
Parameters:
src (float)
length (int)
tma(src, length)
Parameters:
src (float)
length (simple int)
tma(src, length)
Parameters:
src (float)
length (int)
tema(src, length)
Parameters:
src (float)
length (simple int)
tema(src, length)
Parameters:
src (float)
length (int)
tsf(src, length)
Parameters:
src (float)
length (simple int)
tsf(src, length)
Parameters:
src (float)
length (int)
varma(src, length)
Parameters:
src (float)
length (simple int)
varma(src, length)
Parameters:
src (float)
length (int)
vama(src, length)
Parameters:
src (float)
length (simple int)
vama(src, length)
Parameters:
src (float)
length (int)
vma(src, length)
Parameters:
src (float)
length (simple int)
vma(src, length)
Parameters:
src (float)
length (int)
vbma(src, length)
Parameters:
src (float)
length (simple int)
vbma(src, length)
Parameters:
src (float)
length (int)
vida(src, length)
Parameters:
src (float)
length (simple int)
vida(src, length)
Parameters:
src (float)
length (int)
qma(src, length)
Parameters:
src (float)
length (simple int)
qma(src, length)
Parameters:
src (float)
length (int)
rpma(src, len)
Parameters:
src (float)
len (simple int)
rpma(src, len)
Parameters:
src (float)
len (int)
rma(src, length)
Parameters:
src (float)
length (simple int)
rma(src, length)
Parameters:
src (float)
length (int)
rsrma(src, length)
Parameters:
src (float)
length (simple int)
rsrma(src, length)
Parameters:
src (float)
length (int)
zlema(src, length)
Parameters:
src (float)
length (simple int)
zlema(src, length)
Parameters:
src (float)
length (int)
selector(src, length, selectMA, min_length, max_length)
This function gives trader an instrument to test different kinds of moving averages on their strategy.
Parameters:
src (float)
length (simple int)
selectMA (string)
min_length (int)
max_length (int)
Returns: user selected moving average
selector(src, length, selectMA, min_length, max_length)
Parameters:
src (float)
length (int)
selectMA (string)
min_length (int)
max_length (int)
iQFFTLibrary "iQFFT"
TODO: add library description here
fft(x, y, dir)
Parameters:
x (array)
y (array)
dir (string)
fftPower(x, y)
Parameters:
x (array)
y (array)
fftFreq(N)
Parameters:
N (int)
CoreMACDHTF [CHE]Library "CoreMACDHTF"
calc_macd_htf(src, preset_str, smooth_len)
Parameters:
src (float)
preset_str (simple string)
smooth_len (int)
is_hist_rising(src, preset_str, smooth_len)
Parameters:
src (float)
preset_str (simple string)
smooth_len (int)
hist_rising_01(src, preset_str, smooth_len)
Parameters:
src (float)
preset_str (simple string)
smooth_len (int)
CoreMACDHTF — Hardcoded HTF MACD Presets with Smoothed Histogram Regime Flags
Summary
CoreMACDHTF provides a reusable MACD engine that approximates higher-timeframe behavior by selecting hardcoded EMA lengths based on the current chart timeframe, then optionally smoothing the resulting histogram with a stateful filter. It is published as a Pine v6 library but intentionally includes a minimal demo plot so you can validate behavior directly on a chart. The primary exported outputs are MACD, signal, a smoothed histogram, and the resolved lengths plus a timeframe tag. In addition, it exposes a histogram rising condition so importing scripts can reuse the same regime logic instead of re-implementing it.
Motivation: Why this design?
Classic MACD settings are often tuned to one timeframe. When you apply the same parameters to very different chart intervals, the histogram can become either too noisy or too sluggish. This script addresses that by using a fixed mapping from the chart timeframe into a precomputed set of EMA lengths, aiming for more consistent “tempo” across intervals. A second problem is histogram micro-chop around turning points; the included smoother reduces short-run flips so regime-style conditions can be more stable for alerts and filters.
What’s different vs. standard approaches?
Reference baseline: a standard MACD using fixed fast, slow, and signal lengths on the current chart timeframe.
Architecture differences:
Automatic timeframe bucketing that selects a hardcoded length set for the chosen preset.
Two preset families: one labeled A with lengths three, ten, sixteen; one labeled B with lengths twelve, twenty-six, nine.
A custom, stateful histogram smoother intended to damp noisy transitions.
Library exports that return both signals and metadata, plus a dedicated “histogram rising” boolean.
Practical effect:
The MACD lengths change when the chart timeframe changes, so the oscillator’s responsiveness is not constant across intervals by design.
The rising-flag logic is based on the smoothed histogram, which typically reduces single-bar flip noise compared to using the raw histogram directly.
How it works (technical)
1. The script reads the chart timeframe and converts it into milliseconds using built-in timeframe helpers.
2. It assigns the timeframe into a bucket label, such as an intraday bucket or a daily-and-above bucket, using fixed thresholds.
3. It resolves a hardcoded fast, slow, and signal length triplet based on:
The selected preset family.
The bucket label.
In some cases, the current minute multiplier for finer mapping.
4. It computes fast and slow EMAs on the selected source and subtracts them to obtain MACD, then computes an EMA of MACD for the signal line.
5. The histogram is derived from the difference between MACD and signal, then passed through a custom smoother.
6. The smoother uses persistent internal state to carry forward its intermediate values from bar to bar. This is intentional and means the smoothing output depends on contiguous bar history.
7. The histogram rising flag compares the current smoothed histogram to its prior value. On the first comparable bar it defaults to “rising” to avoid a missing prior reference.
8. Exports:
A function that returns MACD, signal, smoothed histogram, the resolved lengths, and a text tag.
A function that returns the boolean rising state.
A function that returns a numeric one-or-zero series for direct plotting or downstream numeric logic.
HTF note: this is not a true higher-timeframe request. It does not fetch higher-timeframe candles. It approximates HTF feel by selecting different lengths on the current timeframe.
Parameter Guide
Source — Input price series used for EMA calculations — Default close — Trade-offs/Tips
Preset — Selects the hardcoded mapping family — Default preset A — Preset A is more reactive than preset B in typical use
Table Position — Anchor for an information table — Default top right — Present but not wired in the provided code (Unknown/Optional)
Table Size — Text size for the information table — Default normal — Present but not wired in the provided code (Unknown/Optional)
Dark Mode — Theme toggle for the table — Default enabled — Present but not wired in the provided code (Unknown/Optional)
Show Table — Visibility toggle for the table — Default enabled — Present but not wired in the provided code (Unknown/Optional)
Zero dead-band (epsilon) — Intended neutral band around zero for regime classification — Default zero — Present but not used in the provided code (Unknown/Optional)
Acceptance bars (n) — Intended debounce count for regime confirmation — Default three — Present but not used in the provided code (Unknown/Optional)
Smoothing length — Length controlling the histogram smoother’s responsiveness — Default nine — Smaller values react faster but can reintroduce flip noise
Reading & Interpretation
Smoothed histogram: use it as the momentum core. A positive value implies MACD is above signal, a negative value implies the opposite.
Histogram rising flag:
True means the smoothed histogram increased compared to the prior bar.
False means it did not increase compared to the prior bar.
Demo plot:
The included plot outputs one when rising is true and zero otherwise. It is a diagnostic-style signal line, not a scaled oscillator display.
Practical Workflows & Combinations
Trend following:
Use rising as a momentum confirmation filter after structural direction is established by higher highs and higher lows, or lower highs and lower lows.
Combine with a simple trend filter such as a higher-timeframe moving average from your main script (Unknown/Optional).
Exits and risk management:
If you use rising to stay in trends, consider exiting or reducing exposure when rising turns false for multiple consecutive bars rather than reacting to a single flip.
If you build alerts, evaluate on closed bars to avoid intra-bar flicker in live candles.
Multi-asset and multi-timeframe:
Because the mapping is hardcoded, validate on each asset class you trade. Volatility regimes differ and the perceived “equivalence” across timeframes is not guaranteed.
For consistent behavior, keep the smoothing length aligned across assets and adjust only when flip frequency becomes problematic.
Behavior, Constraints & Performance
Repaint and confirmation:
There is no forward-looking indexing. The logic uses current and prior values only.
Live-bar values can change until the bar closes, so rising can flicker intra-bar if you evaluate it in real time.
security and HTF:
No higher-timeframe candle requests are used. Length mapping is internal and deterministic per chart timeframe.
Resources:
No loops and no arrays in the core calculation path.
The smoother maintains persistent state, which is lightweight but means results depend on uninterrupted history.
Known limits:
Length mappings are fixed. If your chart timeframe is unusual, the bucket choice may not represent what you expect.
Several table and regime-related inputs are declared but not used in the provided code (Unknown/Optional).
The smoother is stateful; resetting chart history or changing symbol can alter early bars until state settles.
Sensible Defaults & Quick Tuning
S tarting point:
Preset A
Smoothing length nine
Source close
Tuning recipes:
Too many flips: increase smoothing length and evaluate rising only on closed bars.
Too sluggish: reduce smoothing length, but expect more short-run reversals.
Different timeframe feel after switching intervals: keep preset fixed and adjust smoothing length first before changing preset.
Want a clean plot signal: use the exported numeric rising series and apply your own display rules in the importing script.
What this indicator is—and isn’t
This is a momentum and regime utility layer built around a MACD-style backbone with hardcoded timeframe-dependent parameters and an optional smoother. It is not a complete trading system, not a risk model, and not predictive. Use it in context with market structure, execution rules, and risk controls.
Disclaimer
The content provided, including all code and materials, is strictly for educational and informational purposes only. It is not intended as, and should not be interpreted as, financial advice, a recommendation to buy or sell any financial instrument, or an offer of any financial product or service. All strategies, tools, and examples discussed are provided for illustrative purposes to demonstrate coding techniques and the functionality of Pine Script within a trading context.
Any results from strategies or tools provided are hypothetical, and past performance is not indicative of future results. Trading and investing involve high risk, including the potential loss of principal, and may not be suitable for all individuals. Before making any trading decisions, please consult with a qualified financial professional to understand the risks involved.
By using this script, you acknowledge and agree that any trading decisions are made solely at your discretion and risk.
Do not use this indicator on Heikin-Ashi, Renko, Kagi, Point-and-Figure, or Range charts, as these chart types can produce unrealistic results for signal markers and alerts.
Best regards and happy trading
Chervolino
CoreTFRSIMD CoreTFRSIMD library — Reusable TFRSI core for consistent momentum inputs across scripts
The library provides a reusable exported function such as calcTfrsi(src, len, signalLen) so you can compute TFRSI in your own indicators or strategies, e.g. tfrsi = CoreTFRSIMD.calcTfrsi(close, 6, 2)
Summary
CoreTFRSIMD is a Pine Script v6 library that implements a TFRSI-style oscillator core and exposes it as a reusable exported function. It is designed for authors who want the same TFRSI calculation across multiple indicators or strategies without duplicating logic. The library includes a simple demo plot and band styling so you can visually sanity-check the output. No higher-timeframe sampling is used, and there are no loops or arrays, so runtime cost is minimal for typical chart usage.
Motivation: Why this design?
When you reuse an oscillator across different tools, small implementation differences create inconsistent signals and hard-to-debug results. This library isolates the signal path into one exported function so that every dependent script consumes the exact same oscillator output. The design combines filtering, normalization, and a final smoothing pass to produce a stable, RSI-like readout intended for momentum and regime context.
What’s different vs. standard approaches?
Baseline: Traditional RSI computed directly from gains and losses with standard smoothing.
Architecture differences:
A high-pass stage to attenuate slower components before the main smoothing.
A multi-pole smoothing stage implemented with persistent state to reduce noise.
A running peak-tracker style normalization that adapts to changing signal amplitude.
A final signal smoothing layer using a simple moving average.
Practical effect:
The oscillator output tends to be less dominated by raw volatility spikes and more consistent across changing conditions.
The normalization step helps keep the output in an RSI-like reading space without relying on fixed scaling.
How it works (technical)
1. Input source: The exported function accepts a source series and two integer parameters controlling responsiveness and final smoothing.
2. High-pass stage: A recursive filter is applied to the source to emphasize shorter-term movement. This stage uses persistent storage so it can reference prior internal states across bars.
3. Smoothing stage: The filtered stream is passed through a SuperSmoother-like recursive smoother derived from the chosen length. This again uses persistent state and prior values for continuity.
4. Adaptive normalization: The absolute magnitude of the smoothed stream is compared to a slowly decaying reference level. If the current magnitude exceeds the reference, the reference is updated. This acts like a “peak hold with decay” so the oscillator scales relative to recent conditions.
5. Oscillator mapping: The normalized value is mapped into an RSI-like reading range.
6. Signal smoothing: A simple moving average is applied over the requested signal length to reduce bar-to-bar chatter.
7. Demo rendering: The library script plots the oscillator, draws horizontal guide levels, and applies background plus gradient fills for overbought and oversold regions.
Parameter Guide
Parameter — Effect — Default — Trade-offs/Tips
src — Input series used by the oscillator — close in demo — Use close for general momentum, or a derived series if you want to emphasize a specific behavior.
len — Controls the responsiveness of internal filtering and smoothing — six in demo — Smaller values react faster but can increase short-term noise; larger values smooth more but can lag turns.
signalLen — Controls the final smoothing of the mapped oscillator — two in demo — Smaller values preserve detail but can flicker; larger values reduce flicker but can delay transitions.
Reading & Interpretation
The plot is an oscillator intended to be read similarly to an RSI-style momentum gauge.
The demo includes three reference levels: upper at one hundred, mid at fifty, and lower at zero.
The fills visually emphasize zones above the midline and below the midline. Treat these as context, not as standalone entries.
If the oscillator appears unusually compressed or unusually jumpy, the normalization reference may be adapting to an abrupt change in amplitude. That is expected behavior for adaptive normalization.
Practical Workflows & Combinations
Trend following:
Use structure first, then confirm with oscillator behavior around the midline.
Prefer signals aligned with higher-high higher-low or lower-low lower-high context from price.
Exits/Stops:
Use oscillator loss of momentum as a caution flag rather than an automatic exit trigger.
In strong trends, consider keeping risk rules price-based and use the oscillator mainly to avoid adding into exhaustion.
Multi-asset/Multi-timeframe:
Start with the demo defaults when you want a responsive oscillator.
If an asset is noisier, increase the main length or the signal smoothing length to reduce false flips.
Behavior, Constraints & Performance
Repaint/confirmation: No higher-timeframe sampling is used. Output updates on the live bar like any normal series. There is no explicit closed-bar gating in the library.
security or HTF: Not used, so there is no HTF synchronization risk.
Resources: No loops, no arrays, no large history buffers. Persistent variables are used for filter state.
Known limits: Like any filtered oscillator, sharp gaps and extreme one-bar events can produce transient distortions. The adaptive normalization can also make early bars unstable until enough history has accumulated.
Sensible Defaults & Quick Tuning
Starting values: length six, signal smoothing two.
Too many flips: Increase signal smoothing length, or increase the main length.
Too sluggish: Reduce the main length, or reduce signal smoothing length.
Choppy around midline: Increase signal smoothing length slightly and rely more on price structure filters.
What this indicator is—and isn’t
This library is a reusable signal component and visualization aid. It is not a complete trading system, not predictive, and not a substitute for market structure, execution rules, and risk controls. Use it as a momentum and regime context layer, and validate behavior per asset and timeframe before relying on it.
Disclaimer
The content provided, including all code and materials, is strictly for educational and informational purposes only. It is not intended as, and should not be interpreted as, financial advice, a recommendation to buy or sell any financial instrument, or an offer of any financial product or service. All strategies, tools, and examples discussed are provided for illustrative purposes to demonstrate coding techniques and the functionality of Pine Script within a trading context.
Any results from strategies or tools provided are hypothetical, and past performance is not indicative of future results. Trading and investing involve high risk, including the potential loss of principal, and may not be suitable for all individuals. Before making any trading decisions, please consult with a qualified financial professional to understand the risks involved.
By using this script, you acknowledge and agree that any trading decisions are made solely at your discretion and risk.
Do not use this indicator on Heikin-Ashi, Renko, Kagi, Point-and-Figure, or Range charts, as these chart types can produce unrealistic results for signal markers and alerts.
Best regards and happy trading
Chervolino
BybitMinOrderSizeBybit Order Quantity Compliance Library
This library provides all utility functions required for TradingView strategies
that execute orders on Bybit via webhooks.
Problem:
Bybit enforces two strict rules on every order submitted:
Minimum Order Size – each symbol has its own minimum quantity.
Quantity Precision – each symbol requires rounding to the correct number of decimals.
TradingView does not expose this metadata, so strategies can easily submit
quantities that Bybit rejects as invalid.
Solution (This Library):
This library embeds full Bybit contract metadata, including:
A complete mapping of Bybit symbols → minimum order size
A complete mapping of Bybit symbols → allowed precision (decimal places)
A helper to normalize tickers (removing `.P` suffix for Bybit perpetuals)
It also exposes utility functions to automatically make your quantities valid:
`normalizeTicker()` — removes `.P` for consistent lookup
`getMinOrderSize()` — returns the correct minimum order size
`getPrecisionForTicker()` — returns required quantity precision
`floorQty()` — floors quantities to valid minimum increments
`roundQty()` — rounds quantities to valid decimal precision
Use Cases:
Ensuring webhook strategies never send too-small orders
Rounding limit/market orders correctly before execution
Making Pine strategies execution-accurate for Bybit
Avoiding "order rejected: qty too small / invalid precision" errors
This library is recommended for:
Live trading via TradingView → Bybit webhooks
Backtesting strategies that simulate real Bybit constraints
Source: www.bybit.com
Updated: 2025-11-25 — Bybit contract metadata
normalizeTicker(symbol)
Normalizes Bybit perpetual tickers by removing the ".P" suffix.
precisionFromMinOrder(minOrder)
Derives precision (decimal places) from minimum order size.
getMinOrderSize(symbol)
Retrieves the minimum order size for the current or given symbol.
getPrecisionForTicker(symbol)
Retrieves the required quantity precision (decimal places) for a given Bybit symbol.
floorQty(qty, symbol)
Rounds a quantity down to the nearest valid minimum order size for a given symbol.
roundQty(qty, symbol)
Rounds a quantity to the valid precision for the specified symbol.
RLSR logreg_support_libLibrary "logreg_support_lib"
sigmoid(z)
Parameters:
z (float)
prng01(seed1, seed2)
Parameters:
seed1 (float)
seed2 (float)
normalize(value, minval, maxval)
Parameters:
value (float)
minval (float)
maxval (float)
calcpercentilefast(arr, percentile)
Parameters:
arr (array)
percentile (float)
calcpercentile_series_sampled(s, length, percentile, stride)
Parameters:
s (float)
length (int)
percentile (float)
stride (int)
calcRangeWithLog(value, minval, maxval, uselog)
Parameters:
value (float)
minval (float)
maxval (float)
uselog (bool)
calcMomentumAdvanced(src, length, momType)
Parameters:
src (float)
length (simple int)
momType (string)
normalizeMomentumByType(rawMom, momType, momMin, momMax, momNorm)
Parameters:
rawMom (float)
momType (string)
momMin (float)
momMax (float)
momNorm (float)
normalizeMomentumByTypeExt(rawMom, momType, momMin, momMax, momNorm, bouncingdecay)
Parameters:
rawMom (float)
momType (string)
momMin (float)
momMax (float)
momNorm (float)
bouncingdecay (float)
calcrollingstddev(src, length)
Parameters:
src (float)
length (int)
addlog(buffer, level, msg)
Parameters:
buffer (string)
level (string)
msg (string)
calcfeaturecorrelation(x1, x2)
Parameters:
x1 (array)
x2 (array)
calcnoiseratio(src, lookback)
Parameters:
src (float)
lookback (int)
calccompatibilityscore(x1, x2)
Parameters:
x1 (array)
x2 (array)
getfuturereturn(offset, returnlookback)
Parameters:
offset (int)
returnlookback (int)
calculatema(source, length, matype)
Parameters:
source (float)
length (simple int)
matype (string)
adaptive_trigger_for_source(src, enabled, freeze, lookback, threshold, volahistory)
Parameters:
src (float)
enabled (bool)
freeze (bool)
lookback (int)
threshold (float)
volahistory (array)
checkadaptivetrigger5(s1, enabled1, freeze1, hist1, s2, enabled2, freeze2, hist2, s3, enabled3, freeze3, hist3, s4, enabled4, freeze4, hist4, s5, enabled5, freeze5, hist5, lookback, threshold)
Parameters:
s1 (float)
enabled1 (bool)
freeze1 (bool)
hist1 (array)
s2 (float)
enabled2 (bool)
freeze2 (bool)
hist2 (array)
s3 (float)
enabled3 (bool)
freeze3 (bool)
hist3 (array)
s4 (float)
enabled4 (bool)
freeze4 (bool)
hist4 (array)
s5 (float)
enabled5 (bool)
freeze5 (bool)
hist5 (array)
lookback (int)
threshold (float)
ring_start_index(rb_write_idx, rb_count, rb_cap)
Parameters:
rb_write_idx (int)
rb_count (int)
rb_cap (int)
reversalLibrary "reversals"
psar(af_start, af_increment, af_max)
Calculates Parabolic Stop And Reverse (SAR)
Parameters:
af_start (simple float) : Initial acceleration factor (Wilder's original: 0.02)
af_increment (simple float) : Acceleration factor increment per new extreme (Wilder's original: 0.02)
af_max (simple float) : Maximum acceleration factor (Wilder's original: 0.20)
Returns: SAR value (stop level for current trend)
fractals()
Detects Williams Fractal patterns (5-bar pattern)
Returns: Tuple with fractal values (na if no fractal)
swings(lookback, source_high, source_low)
Detects swing highs and swing lows using lookback period
Parameters:
lookback (simple int) : Number of bars on each side to confirm swing point
source_high (float) : Price series for swing high detection (typically high)
source_low (float) : Price series for swing low detection (typically low)
Returns: Tuple with swing point values (na if no swing)
pivot(tf)
Calculates classic/standard/floor pivot points
Parameters:
tf (simple string) : Timeframe for pivot calculation ("D", "W", "M")
Returns: Tuple with pivot levels
pivotcam(tf)
Calculates Camarilla pivot points with 8 levels for short-term trading
Parameters:
tf (simple string) : Timeframe for pivot calculation ("D", "W", "M")
Returns: Tuple with pivot levels
pivotdem(tf)
Calculates d-mark pivot points with conditional open/close logic
Parameters:
tf (simple string) : Timeframe for pivot calculation ("D", "W", "M")
Returns: Tuple with pivot levels (only 3 levels)
pivotext(tf)
Calculates extended traditional pivot points with R4-R5 and S4-S5 levels
Parameters:
tf (simple string) : Timeframe for pivot calculation ("D", "W", "M")
Returns: Tuple with pivot levels
pivotfib(tf)
Calculates Fibonacci pivot points using Fibonacci ratios
Parameters:
tf (simple string) : Timeframe for pivot calculation ("D", "W", "M")
Returns: Tuple with pivot levels
pivotwood(tf)
Calculates Woodie's pivot points with weighted closing price
Parameters:
tf (simple string) : Timeframe for pivot calculation ("D", "W", "M")
Returns: Tuple with pivot levels
libpublicLibrary "libpublic"
sma(src, len)
Simple Moving Average
Parameters:
src (float) : Series to use
len (int) : Filtering length
Returns: Filtered series
ema(src, len)
Exponential Moving Average
Parameters:
src (float) : Series to use
len (int) : Filtering length
Returns: Filtered series
rma(src, len)
Wilder's Smoothing (Running Moving Average)
Parameters:
src (float) : Series to use
len (int) : Filtering length
Returns: Filtered series
hma(src, len)
Hull Moving Average
Parameters:
src (float) : Series to use
len (int) : Filtering length
Returns: Filtered series
vwma(src, len)
Volume Weighted Moving Average
Parameters:
src (float) : Series to use
len (int) : Filtering length
Returns: Filtered series
jma(src, len, phase)
Jurik MA
Parameters:
src (float) : Series to use
len (int) : Filtering length
phase (int) : JMA Phase
Returns: Filtered series
c_Ema(_src, _length)
Parameters:
_src (float)
_length (int)
c_zlema(_src, _length)
Parameters:
_src (float)
_length (int)
to_pips(_v)
Convert price to pips.
Parameters:
_v (float) : Price
Returns: Pips
toPips(_v)
Parameters:
_v (float)
get_day(_n)
Get the day of the week
Parameters:
_n (int) : Number of day of week
clear_lines(_arr, _min)
Deletes the lines included in the array.
Parameters:
_arr (array) : Array of lines
_min (int) : Deletes the lines included in the array.
clear_labels(_arr, _min)
Deletes the labels included in the array.
Parameters:
_arr (array) : Array of labels
_min (int) : Deletes the labels included in the array.
clear_boxes(_arr, _min)
Deletes the boxes included in the array.
Parameters:
_arr (array) : Array of boxes
_min (int) : Deletes the boxes included in the array.
tfToInt(_timeframe)
Parameters:
_timeframe (string)
tfCurrentView(_tf)
Parameters:
_tf (float)
f_round(_val, _decimals)
Parameters:
_val (float)
_decimals (int)
getTablePos(_switch)
Parameters:
_switch (string)
getTxtSize(_switch)
Parameters:
_switch (string)
getTendChar(_trendChar)
Parameters:
_trendChar (string)
blueWaves(src, chlLen, avgLen)
Parameters:
src (float)
chlLen (int)
avgLen (int)
candleType(_candle)
Parameters:
_candle (int)
normalizeVolume(_vol, _precision)
Parameters:
_vol (float)
_precision (string)
InSession(sessionTime, sessionTimeZone)
Parameters:
sessionTime (string)
sessionTimeZone (string)
IsSessionStart(sessionTime, sessionTimeZone)
Parameters:
sessionTime (string)
sessionTimeZone (string)
createSessionTime(_timeOffsetStart, _timeOffsetEnd, _offsetTypeStart, _offsetTypeEnd, sessionTimeZone)
Parameters:
_timeOffsetStart (int)
_timeOffsetEnd (int)
_offsetTypeStart (string)
_offsetTypeEnd (string)
sessionTimeZone (string)
clrsLibrary "clrs"
Helpers for color manipulations
opacify(oldColor, opacity)
Applies opacity to color
Parameters:
oldColor (color) : color
opacity (float) : opacity
Returns: color with opacity
getColorsRange(topColor, bottomColor, numColors)
Gets two colors as parameters and number of colors you need. Returns range of colors between them
Parameters:
topColor (color) : color color
bottomColor (color) : color
numColors (int) : number of colors in range
Mirpapa_Lib_SumBoxLibrary "Mirpapa_Lib_SumBox"
CreateSumCandleStates()
CreateSumCandleStates
@desc Creates a set of sum candle state strings.
Returns (SumCandleStates): State string set (pending, confirmed, completed)
Returns: SumCandleStates state string set
CreateSumCandleData(sumOpen, sumHigh, sumLow, sumClose, sumStartTime, sumEndTime, sumHighTime, sumLowTime, state)
CreateSumCandleData
@desc Creates sum candle data (factory function).
sumOpen (float): Sum open price
sumHigh (float): Sum high price
sumLow (float): Sum low price
sumClose (float): Sum close price
sumStartTime (int): Sum start time (milliseconds)
sumEndTime (int): Sum end time (milliseconds)
sumHighTime (int): High point occurrence time (milliseconds)
sumLowTime (int): Low point occurrence time (milliseconds)
state (string): State (pending/confirmed/completed)
Returns (SumCandleData): Created sum candle data
Parameters:
sumOpen (float): (float) Sum open price
sumHigh (float): (float) Sum high price
sumLow (float): (float) Sum low price
sumClose (float): (float) Sum close price
sumStartTime (int): (int) Sum start time
sumEndTime (int): (int) Sum end time
sumHighTime (int): (int) High point occurrence time
sumLowTime (int): (int) Low point occurrence time
state (string): (string) State
Returns: SumCandleData Created sum candle data
ValidateSumCandleData(sumData, confirmedState)
ValidateSumCandleData
@desc Validates sum candle data.
sumData (SumCandleData): Sum candle data to validate
confirmedState (string): CONFIRMED state string
Returns ( ):
Parameters:
sumData (SumCandleData): (SumCandleData) Sum candle data to validate
confirmedState (string): (string) CONFIRMED state string
Returns:
CanConfirmSumCandle(sumData, pendingState, confirmedState, completedState)
CanConfirmSumCandle
@desc Validates whether a sum candle can be confirmed.
sumData (SumCandleData): Sum candle data to confirm
pendingState (string): PENDING state string
confirmedState (string): CONFIRMED state string
completedState (string): COMPLETED state string
Returns ( ):
Parameters:
sumData (SumCandleData): (SumCandleData) Sum candle data to confirm
pendingState (string): (string) PENDING state string
confirmedState (string): (string) CONFIRMED state string
completedState (string): (string) COMPLETED state string
Returns:
UpdateSumCandleState(sumData, newState, pendingState, confirmedState, completedState)
UpdateSumCandleState
@desc Updates the state of a sum candle (includes validation).
sumData (SumCandleData): Sum candle data to update
newState (string): New state
pendingState (string): PENDING state string
confirmedState (string): CONFIRMED state string
completedState (string): COMPLETED state string
Returns ( ):
Parameters:
sumData (SumCandleData): (SumCandleData) Sum candle data to update
newState (string): (string) New state
pendingState (string): (string) PENDING state string
confirmedState (string): (string) CONFIRMED state string
completedState (string): (string) COMPLETED state string
Returns:
CreateSumCandleBox(sumOpen, sumClose, sumStartTime, endTime, bullColor, bearColor, borderColor, borderWidth)
CreateSumCandleBox
@desc Creates a sum candle body box.
sumOpen (float): Sum open price
sumClose (float): Sum close price
sumStartTime (int): Sum start time (milliseconds)
endTime (int): Sum end time (milliseconds)
bullColor (color): Bullish candle color
bearColor (color): Bearish candle color
borderColor (color): Border color
borderWidth (int): Border width (1-5)
Returns (box): Created body box
Parameters:
sumOpen (float): (float) Sum open price
sumClose (float): (float) Sum close price
sumStartTime (int): (int) Sum start time
endTime (int): (int) Sum end time
bullColor (color): (color) Bullish candle color
bearColor (color): (color) Bearish candle color
borderColor (color): (color) Border color
borderWidth (int): (int) Border width
Returns: box Body box
CreateSumCandleLine(x, y1, y2, lineColor, lineWidth)
CreateSumCandleLine
@desc Creates a sum candle wick line.
x (int): Line x coordinate (time, milliseconds)
y1 (float): Line start y coordinate (price)
y2 (float): Line end y coordinate (price)
lineColor (color): Line color
lineWidth (int): Line width (1-5)
Returns (line): Created wick line
Parameters:
x (int): (int) Line x coordinate (time)
y1 (float): (float) Line start y coordinate
y2 (float): (float) Line end y coordinate
lineColor (color): (color) Line color
lineWidth (int): (int) Line width
Returns: line Wick line
DeleteSumCandleVisuals(sumData)
DeleteSumCandleVisuals
@desc Deletes visualization objects (boxes, lines) of a sum candle.
sumData (SumCandleData): Sum candle data to delete
Returns (void): No return value
Parameters:
sumData (SumCandleData): (SumCandleData) Sum candle data to delete
Returns: void
GetBodyBounds(sumOpen, sumClose)
GetBodyBounds
@desc Calculates the top and bottom boundaries of the body.
sumOpen (float): Sum open price
sumClose (float): Sum close price
Returns ( ):
Parameters:
sumOpen (float): (float) Sum open price
sumClose (float): (float) Sum close price
Returns:
ManageMemory(sumArray, maxSize)
ManageMemory
@desc Manages array size and deletes old data.
sumArray (array): Sum candle array to manage
maxSize (int): Maximum size
Returns (void): No return value
Parameters:
sumArray (array): (array) Sum candle array to manage
maxSize (int): (int) Maximum size
Returns: void
IsSingleCandle(sumData)
IsSingleCandle
@desc Checks if it's a sum consisting of only one candle.
sumData (SumCandleData): Sum candle data to check
Returns (bool): true if single candle, false otherwise
Parameters:
sumData (SumCandleData): (SumCandleData) Sum candle data to check
Returns: bool Single candle status
CalculateWickCenterTime(startTime, endTime)
CalculateWickCenterTime
@desc Calculates the center time where the wick will be displayed.
startTime (int): Sum start time (milliseconds)
endTime (int): Sum end time (milliseconds)
Returns (int): Center time (milliseconds)
Parameters:
startTime (int): (int) Sum start time
endTime (int): (int) Sum end time
Returns: int Center time
SumCandleStates
Fields:
pending (series string)
confirmed (series string)
completed (series string)
SumCandleData
Fields:
_open (series float)
_high (series float)
_low (series float)
_close (series float)
_startTime (series int)
_endTime (series int)
_highTime (series int)
_lowTime (series int)
_isBull (series bool)
_state (series string)
_boxBody (series box)
_wickHigh (series line)
_wickLow (series line)
oct25libLibrary of technical indicators for use in scripts.
1) salmav3(src, length, smooth, mult, sd_len)
Parameters:
src (float)
length (int)
smooth (simple int)
mult(float)
sd_len(int)
2) boltzman(src, length, T, alpha, smoothLen)
Parameters:
src (float)
length (int)
T(float)
Alpha(float)
smoothLen (simple int)
3) shannon(src, vol, len, bc, vc, smooth)
Parameters:
src (float)
vol (float)
len (int)
bc (bool)
vc (bool)
smooth (simple int)
4) vama(src, baseLen, volLen, beta)
Parameters:
src (float)
baseLen (int)
volLen (int)
beta (float)
5) fwma(src, period, lambda, smooth)
Parameters:
src (float)
period (int)
lambda (float)
smooth (simple int)
6) savitzky(srcc, srch, srcl, length)
Parameters:
srcc (float)
srch (float)
srcl (float)
length (int)
7) butterworth(src, length, poles, smooth)
Parameters:
src (float)
length (int)
poles (int)
smooth (simple int)
8) rti(src, trend_data_count, trend_sensitivity_percentage, midline, smooth)
Parameters:
src (float)
trend_data_count (int)
trend_sensitivity_percentage (int)
midline (int)
smooth (simple int)
9) chandemo(src, length, smooth)
Parameters:
src (float)
length (int)
smooth (simple int)
10) hsma(assetClose, length, emalen, midline)
Parameters:
assetClose (float)
length (int)
emalen (simple int)
midline (float)
11) rsi(src, rsiLengthInput, rsiemalen, midline)
Parameters:
src (float)
rsiLengthInput (simple int)
rsiemalen (simple int)
midline (float)
12) lacoca(src, lookback, malen, matype)
Parameters:
src (float)
lookback (int)
malen (simple int)
matype (string)
AdjCloseLibLibrary "AdjCloseLib"
Library for producing gap-adjusted price series that removes intraday gaps at market open
get_adj_close(_gapThresholdPct)
Calculates gap-adjusted close price by detecting and removing gaps at market open (09:15)
Parameters:
_gapThresholdPct (float) : Minimum gap size (in percentage) required to trigger adjustment. Example: 0.5 for 0.5%
Returns: Adjusted close price for the current bar (always returns a numeric value, never na)
@details Detects gaps by comparing 09:15 open with previous day's close. If gap exceeds threshold,
subtracts the gap value from all bars between 09:15-15:29 inclusive. State resets after session close.
get_adj_ohlc(_gapThresholdPct)
Calculates gap-adjusted OHLC values by subtracting detected gap from all price components
Parameters:
_gapThresholdPct (float) : Minimum gap size (in percentage) required to trigger adjustment. Example: 0.5 for 0.5%
Returns: Tuple of
@details Useful for calculating indicators (ATR, Heikin-Ashi, etc.) on gap-adjusted data.
Applies the same gap adjustment logic to all OHLC components simultaneously.
smaemarvwapClaireLibrary "smaemarvwapClaire"
repeat_character(count)
Parameters:
count (int)
f_1_k_line_width()
is_price_in_merge_range(p1, p2, label_merge_range)
Parameters:
p1 (float)
p2 (float)
label_merge_range (float)
get_pre_label_string(kc, t, is_every)
Parameters:
kc (VWAP_key_levels_draw_settings)
t (int)
is_every (bool)
f_is_new_period_from_str(str)
Parameters:
str (string)
total_for_time_when(source, days, ma_set)
Parameters:
source (float)
days (int)
ma_set (ma_setting)
f_calculate_sma_ema_rolling_vwap(src, length, ma_settings)
Parameters:
src (float)
length (simple int)
ma_settings (ma_setting)
f_calculate_sma_ema_rvwap(ma_settings)
Parameters:
ma_settings (ma_setting)
f_get_ma_pre_label(ma_settings, sma, ema, rolling_vwap)
Parameters:
ma_settings (ma_setting)
sma (float)
ema (float)
rolling_vwap (float)
f_smart_ma_calculation(ma_settings2)
Parameters:
ma_settings2 (ma_setting)
f_calculate_endpoint(start_time, kc, is_every, endp, extend1, extend2, line_label_extend_length)
Parameters:
start_time (int)
kc (VWAP_key_levels_draw_settings)
is_every (bool)
endp (int)
extend1 (bool)
extend2 (bool)
line_label_extend_length (int)
f_single_line_label_fatory(left_point, right_point, line_col, line_width, lines_style_select, labeltext_col, label_text_size, label_array, line_array, label_col, label_text, l1, label1)
根据两个点创建线段和/或标签，并将其添加到对应的数组中
Parameters:
left_point (chart.point) : 左侧起点坐标
right_point (chart.point) : 右侧终点坐标
line_col (color) : 线段颜色
line_width (int) : 线段宽度
lines_style_select (string) : 线段样式（实线、虚线等）
labeltext_col (color) : 标签文字颜色
label_text_size (string) : 标签文字大小
label_array (array) : 存储标签对象的数组
line_array (array) : 存储线段对象的数组
label_col (color) : 标签背景颜色（默认：半透明色）
label_text (string) : 标签文字内容（默认：空字符串）
l1 (bool) : 是否创建线段（默认：false）
label1 (bool) : 是否创建标签（默认：false）
Returns: void
f_line_and_label_merge_func(t, data, l_text, kc, is_every, endp, merge_str_map, label_array, line_array, extend1, extend2, line_label_extend_length, label_merge_control, line_width, lines_style_select, label_text_size)
Parameters:
t (int)
data (float)
l_text (string)
kc (VWAP_key_levels_draw_settings)
is_every (bool)
endp (int)
merge_str_map (map)
label_array (array)
line_array (array)
extend1 (bool)
extend2 (bool)
line_label_extend_length (int)
label_merge_control (bool)
line_width (int)
lines_style_select (string)
label_text_size (string)
plot_ohlc(kc, ohlc_data, extend1, extend2, merge_str_map, label_array, line_array, is_every, line_label_extend_length, label_merge_control, line_width, lines_style_select, label_text_size)
Parameters:
kc (VWAP_key_levels_draw_settings)
ohlc_data (bardata)
extend1 (bool)
extend2 (bool)
merge_str_map (map)
label_array (array)
line_array (array)
is_every (bool)
line_label_extend_length (int)
label_merge_control (bool)
line_width (int)
lines_style_select (string)
label_text_size (string)
plot_vwap_keylevels(kc, vwap_data, extend1, extend2, merge_str_map, label_array, line_array, is_every, line_label_extend_length, label_merge_control, line_width, lines_style_select, label_text_size)
Parameters:
kc (VWAP_key_levels_draw_settings)
vwap_data (vwap_snapshot)
extend1 (bool)
extend2 (bool)
merge_str_map (map)
label_array (array)
line_array (array)
is_every (bool)
line_label_extend_length (int)
label_merge_control (bool)
line_width (int)
lines_style_select (string)
label_text_size (string)
plot_vwap_bardata(kc, ohlc_data, vwap_data, extend1, extend2, merge_str_map, label_array, line_array, is_every, line_label_extend_length, label_merge_control, line_width, lines_style_select, label_text_size)
Parameters:
kc (VWAP_key_levels_draw_settings)
ohlc_data (bardata)
vwap_data (vwap_snapshot)
extend1 (bool)
extend2 (bool)
merge_str_map (map)
label_array (array)
line_array (array)
is_every (bool)
line_label_extend_length (int)
label_merge_control (bool)
line_width (int)
lines_style_select (string)
label_text_size (string)
f_start_end_total_min(session)
Parameters:
session (string)
f_get_vwap_array(anchor1, data_manager, is_historical)
Parameters:
anchor1 (string)
data_manager (data_manager)
is_historical (bool)
f_get_bardata_array(anchorh, data_manager, is_historical)
Parameters:
anchorh (string)
data_manager (data_manager)
is_historical (bool)
vwap_snapshot
Fields:
t (series int)
vwap (series float)
upper1 (series float)
lower1 (series float)
upper2 (series float)
lower2 (series float)
upper3 (series float)
lower3 (series float)
VWAP_key_levels_draw_settings
Fields:
enable (series bool)
index (series int)
anchor (series string)
session (series string)
vwap_col (series color)
bands_col (series color)
bg_color (series color)
text_color (series color)
val (series bool)
poc (series bool)
vah (series bool)
enable2x (series bool)
enable3x (series bool)
o_control (series bool)
h_control (series bool)
l_control (series bool)
c_control (series bool)
extend_control (series bool)
only_show_the_lastone_control (series bool)
bg_control (series bool)
line_col_labeltext_col (series color)
bardata
Fields:
o (series float)
h (series float)
l (series float)
c (series float)
v (series float)
start_time (series int)
end_time (series int)
ma_setting
Fields:
day_control (series bool)
kline_numbers (series int)
ma_color (series color)
ema_color (series color)
rvwap_color (series color)
ma_control (series bool)
ema_control (series bool)
rvwap_control (series bool)
session (series string)
merge_label_template
Fields:
left_point (chart.point)
right_point (chart.point)
label_text (series string)
p (series float)
label_color (series color)
merge_init_false (series bool)
anchor_snapshots
Fields:
vwap_current (array)
vwap_historical (array)
bardata_current (array)
bardata_historical (array)
data_manager
Fields:
snapshots_map (map)
draw_settings_map (map)
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
LapseBacktestingTableLibrary "LapseBacktestingMetrics"
This library provides a robust set of quantitative backtesting and performance evaluation functions for Pine Script strategies. It’s designed to help traders, quants, and developers assess risk, return, and robustness through detailed statistical metrics — including Sharpe, Sortino, Omega, drawdowns, and trade efficiency.
Built to enhance any trading strategy’s evaluation framework, this library allows you to visualize performance with the quantlapseTable() function, producing an interactive on-chart performance table.
Credit to EliCobra and BikeLife76 for original concept inspiration.
curve(disp_ind)
Retrieves a selected performance curve of your strategy.
Parameters:
disp_ind (simple string): Type of curve to plot. Options include "Equity", "Open Profit", "Net Profit", "Gross Profit".
Returns: (float) Corresponding performance curve value.
cleaner(disp_ind, plot)
Filters and displays selected strategy plots for clean visualization.
Parameters:
disp_ind (simple string): Type of display.
plot (simple float): Strategy plot variable.
Returns: (float) Filtered plot value.
maxEquityDrawDown()
Calculates the maximum equity drawdown during the strategy’s lifecycle.
Returns: (float) Maximum equity drawdown percentage.
maxTradeDrawDown()
Computes the worst intra-trade drawdown among all closed trades.
Returns: (float) Maximum intra-trade drawdown percentage.
consecutive_wins()
Finds the highest number of consecutive winning trades.
Returns: (int) Maximum consecutive wins.
consecutive_losses()
Finds the highest number of consecutive losing trades.
Returns: (int) Maximum consecutive losses.
no_position()
Counts the maximum consecutive bars where no position was held.
Returns: (int) Maximum flat days count.
long_profit()
Calculates total profit generated by long positions as a percentage of initial capital.
Returns: (float) Total long profit %.
short_profit()
Calculates total profit generated by short positions as a percentage of initial capital.
Returns: (float) Total short profit %.
prev_month()
Measures the previous month’s profit or loss based on equity change.
Returns: (float) Monthly equity delta.
w_months()
Counts the number of profitable months in the backtest.
Returns: (int) Total winning months.
l_months()
Counts the number of losing months in the backtest.
Returns: (int) Total losing months.
checktf()
Returns the time-adjusted scaling factor used in Sharpe and Sortino ratio calculations based on chart timeframe.
Returns: (float) Annualization multiplier.
stat_calc()
Performs complete statistical computation including drawdowns, Sharpe, Sortino, Omega, trade stats, and profit ratios.
Returns: (array)
.
f_colors(x, nv)
Generates a color gradient for performance values, supporting dynamic table visualization.
Parameters:
x (simple string): Metric label name.
nv (simple float): Metric numerical value.
Returns: (color) Gradient color value for table background.
quantlapseTable(option, position)
Displays an interactive Performance Table summarizing all major backtesting metrics.
Includes Sharpe, Sortino, Omega, Profit Factor, drawdowns, profitability %, and trade statistics.
Parameters:
option (simple string): Table type — "Full", "Simple", or "None".
position (simple string): Table position — "Top Left", "Middle Right", "Bottom Left", etc.
Returns: (table) On-chart performance visualization table.
This library empowers advanced quantitative evaluation directly within Pine Script®, ideal for strategy developers seeking deeper performance diagnostics and intuitive on-chart metrics.
LibVeloLibrary "LibVelo"
This library provides a sophisticated framework for **Velocity
Profile (Flow Rate)** analysis. It measures the physical
speed of trading at specific price levels by relating volume
to the time spent at those levels.
## Core Concept: Market Velocity
Unlike Volume Profiles, which only answer "how much" traded,
Velocity Profiles answer "how fast" it traded.
It is calculated as:
`Velocity = Volume / Duration`
This metric (contracts per second) reveals hidden market
dynamics invisible to pure Volume or TPO profiles:
1. **High Velocity (Fast Flow):**
* **Aggression:** Initiative buyers/sellers hitting market
orders rapidly.
* **Liquidity Vacuum:** Price slips through a level because
order book depth is thin (low resistance).
2. **Low Velocity (Slow Flow):**
* **Absorption:** High volume but very slow price movement.
Indicates massive passive limit orders ("Icebergs").
* **Apathy:** Little volume over a long time. Lack of
interest from major participants.
## Architecture: Triple-Engine Composition
To ensure maximum performance while offering full statistical
depth for all metrics, this library utilises **object
composition** with a lazy evaluation strategy:
#### Engine A: The Master (`vpVol`)
* **Role:** Standard Volume Profile.
* **Purpose:** Maintains the "ground truth" of volume distribution,
price buckets, and ranges.
#### Engine B: The Time Container (`vpTime`)
* **Role:** specialized container for time duration (in ms).
* **Hack:** It repurposes standard volume arrays (specifically
`aBuy`) to accumulate time duration for each bucket.
#### Engine C: The Calculator (`vpVelo`)
* **Role:** Temporary scratchpad for derived metrics.
* **Purpose:** When complex statistics (like Value Area or Skewness)
are requested for **Velocity**, this engine is assembled
on-demand to leverage the full statistical power of `LibVPrf`
without rewriting complex algorithms.
---
**DISCLAIMER**
This library is provided "AS IS" and for informational and
educational purposes only. It does not constitute financial,
investment, or trading advice.
The author assumes no liability for any errors, inaccuracies,
or omissions in the code. Using this library to build
trading indicators or strategies is entirely at your own risk.
As a developer using this library, you are solely responsible
for the rigorous testing, validation, and performance of any
scripts you create based on these functions. The author shall
not be held liable for any financial losses incurred directly
or indirectly from the use of this library or any scripts
derived from it.
create(buckets, rangeUp, rangeLo, dynamic, valueArea, allot, estimator, cdfSteps, split, trendLen)
Construct a new `Velo` controller, initializing its engines.
Parameters:
buckets (int) : series int Number of price buckets ≥ 1.
rangeUp (float) : series float Upper price bound (absolute).
rangeLo (float) : series float Lower price bound (absolute).
dynamic (bool) : series bool Flag for dynamic adaption of profile ranges.
valueArea (int) : series int Percentage for Value Area (1..100).
allot (series AllotMode) : series AllotMode Allocation mode `Classic` or `PDF` (default `PDF`).
estimator (series PriceEst enum from AustrianTradingMachine/LibBrSt/1) : series PriceEst PDF model for distribution attribution (default `Uniform`).
cdfSteps (int) : series int Resolution for PDF integration (default 20).
split (series SplitMode) : series SplitMode Buy/Sell split for the master volume engine (default `Classic`).
trendLen (int) : series int Look‑back for trend factor in dynamic split (default 3).
Returns: Velo Freshly initialised velocity profile.
method clone(self)
Create a deep copy of the composite profile.
Namespace types: Velo
Parameters:
self (Velo) : Velo Profile object to copy.
Returns: Velo A completely independent clone.
method clear(self)
Reset all engines and accumulators.
Namespace types: Velo
Parameters:
self (Velo) : Velo Profile object to clear.
Returns: Velo Cleared profile (chaining).
method merge(self, srcVolBuy, srcVolSell, srcTime, srcRangeUp, srcRangeLo, srcVolCvd, srcVolCvdHi, srcVolCvdLo)
Merges external data (Volume and Time) into the current profile.
Automatically handles resizing and re-bucketing if ranges differ.
Namespace types: Velo
Parameters:
self (Velo) : Velo The profile object.
srcVolBuy (array) : array Source Buy Volume bucket array.
srcVolSell (array) : array Source Sell Volume bucket array.
srcTime (array) : array Source Time bucket array (ms).
srcRangeUp (float) : series float Upper price bound of the source data.
srcRangeLo (float) : series float Lower price bound of the source data.
srcVolCvd (float) : series float Source Volume CVD final value.
srcVolCvdHi (float) : series float Source Volume CVD High watermark.
srcVolCvdLo (float) : series float Source Volume CVD Low watermark.
Returns: Velo `self` (chaining).
method addBar(self, offset)
Main data ingestion. Distributes Volume and Time to buckets.
Namespace types: Velo
Parameters:
self (Velo) : Velo The profile object.
offset (int) : series int Offset of the bar to add (default 0).
Returns: Velo `self` (chaining).
method setBuckets(self, buckets)
Sets the number of buckets for the profile.
Namespace types: Velo
Parameters:
self (Velo) : Velo The profile object.
buckets (int) : series int New number of buckets.
Returns: Velo `self` (chaining).
method setRanges(self, rangeUp, rangeLo)
Sets the price range for the profile.
Namespace types: Velo
Parameters:
self (Velo) : Velo The profile object.
rangeUp (float) : series float New upper price bound.
rangeLo (float) : series float New lower price bound.
Returns: Velo `self` (chaining).
method setValueArea(self, va)
Set the percentage of volume/time for the Value Area.
Namespace types: Velo
Parameters:
self (Velo) : Velo The profile object.
va (int) : series int New Value Area percentage (0..100).
Returns: Velo `self` (chaining).
method getBuckets(self)
Returns the current number of buckets in the profile.
Namespace types: Velo
Parameters:
self (Velo) : Velo The profile object.
Returns: series int The number of buckets.
method getRanges(self)
Returns the current price range of the profile.
Namespace types: Velo
Parameters:
self (Velo) : Velo The profile object.
Returns:
rangeUp series float The upper price bound of the profile.
rangeLo series float The lower price bound of the profile.
method getArrayBuyVol(self)
Returns the internal raw data array for **Buy Volume** directly.
Namespace types: Velo
Parameters:
self (Velo) : Velo The profile object.
Returns: array The internal array for buy volume.
method getArraySellVol(self)
Returns the internal raw data array for **Sell Volume** directly.
Namespace types: Velo
Parameters:
self (Velo) : Velo The profile object.
Returns: array The internal array for sell volume.
method getArrayTime(self)
Returns the internal raw data array for **Time** (in ms) directly.
Namespace types: Velo
Parameters:
self (Velo) : Velo The profile object.
Returns: array The internal array for time duration.
method getArrayBuyVelo(self)
Returns the internal raw data array for **Buy Velocity** directly.
Automatically executes _assemble() if data is dirty.
Namespace types: Velo
Parameters:
self (Velo) : Velo The profile object.
Returns: array The internal array for buy velocity.
method getArraySellVelo(self)
Returns the internal raw data array for **Sell Velocity** directly.
Automatically executes _assemble() if data is dirty.
Namespace types: Velo
Parameters:
self (Velo) : Velo The profile object.
Returns: array The internal array for sell velocity.
method getBucketBuyVol(self, idx)
Returns the **Buy Volume** of a specific bucket.
Namespace types: Velo
Parameters:
self (Velo) : Velo The profile object.
idx (int) : series int The index of the bucket.
Returns: series float The buy volume.
method getBucketSellVol(self, idx)
Returns the **Sell Volume** of a specific bucket.
Namespace types: Velo
Parameters:
self (Velo) : Velo The profile object.
idx (int) : series int The index of the bucket.
Returns: series float The sell volume.
method getBucketTime(self, idx)
Returns the raw accumulated time (in ms) spent in a specific bucket.
Namespace types: Velo
Parameters:
self (Velo) : Velo The profile object.
idx (int) : series int The index of the bucket.
Returns: series float The time in milliseconds.
method getBucketBuyVelo(self, idx)
Returns the **Buy Velocity** (Aggressive Buy Flow) of a bucket.
Namespace types: Velo
Parameters:
self (Velo) : Velo The profile object.
idx (int) : series int The index of the bucket.
Returns: series float The buy velocity in .
method getBucketSellVelo(self, idx)
Returns the **Sell Velocity** (Aggressive Sell Flow) of a bucket.
Namespace types: Velo
Parameters:
self (Velo) : Velo The profile object.
idx (int) : series int The index of the bucket.
Returns: series float The sell velocity in .
method getBktBnds(self, idx)
Returns the price boundaries of a specific bucket.
Namespace types: Velo
Parameters:
self (Velo) : Velo The profile object.
idx (int) : series int The index of the bucket.
Returns:
up series float The upper price bound of the bucket.
lo series float The lower price bound of the bucket.
method getPoc(self, target)
Returns Point of Control (POC) information for the specified target metric.
Calculates on-demand if the target is 'Velocity' and data changed.
Namespace types: Velo
Parameters:
self (Velo) : Velo The profile object.
target (series Metric) : Metric The data aspect to analyse (Volume, Time, Velocity).
Returns:
pocIdx series int The index of the POC bucket.
pocPrice series float The mid-price of the POC bucket.
method getVA(self, target)
Returns Value Area (VA) information for the specified target metric.
Calculates on-demand if the target is 'Velocity' and data changed.
Namespace types: Velo
Parameters:
self (Velo) : Velo The profile object.
target (series Metric) : Metric The data aspect to analyse (Volume, Time, Velocity).
Returns:
vaUpIdx series int The index of the upper VA bucket.
vaUpPrice series float The upper price bound of the VA.
vaLoIdx series int The index of the lower VA bucket.
vaLoPrice series float The lower price bound of the VA.
method getMedian(self, target)
Returns the Median price for the specified target metric distribution.
Calculates on-demand if the target is 'Velocity' and data changed.
Namespace types: Velo
Parameters:
self (Velo) : Velo The profile object.
target (series Metric) : Metric The data aspect to analyse (Volume, Time, Velocity).
Returns:
medianIdx series int The index of the bucket containing the median.
medianPrice series float The median price.
method getAverage(self, target)
Returns the weighted average price (VWAP/TWAP) for the specified target.
Calculates on-demand if the target is 'Velocity' and data changed.
Namespace types: Velo
Parameters:
self (Velo) : Velo The profile object.
target (series Metric) : Metric The data aspect to analyse (Volume, Time, Velocity).
Returns:
avgIdx series int The index of the bucket containing the average.
avgPrice series float The weighted average price.
method getStdDev(self, target)
Returns the standard deviation for the specified target distribution.
Calculates on-demand if the target is 'Velocity' and data changed.
Namespace types: Velo
Parameters:
self (Velo) : Velo The profile object.
target (series Metric) : Metric The data aspect to analyse (Volume, Time, Velocity).
Returns: series float The standard deviation.
method getSkewness(self, target)
Returns the skewness for the specified target distribution.
Calculates on-demand if the target is 'Velocity' and data changed.
Namespace types: Velo
Parameters:
self (Velo) : Velo The profile object.
target (series Metric) : Metric The data aspect to analyse (Volume, Time, Velocity).
Returns: series float The skewness.
method getKurtosis(self, target)
Returns the excess kurtosis for the specified target distribution.
Calculates on-demand if the target is 'Velocity' and data changed.
Namespace types: Velo
Parameters:
self (Velo) : Velo The profile object.
target (series Metric) : Metric The data aspect to analyse (Volume, Time, Velocity).
Returns: series float The excess kurtosis.
method getSegments(self, target)
Returns the fundamental unimodal segments for the specified target metric.
Calculates on-demand if the target is 'Velocity' and data changed.
Namespace types: Velo
Parameters:
self (Velo) : Velo The profile object.
target (series Metric) : Metric The data aspect to analyse (Volume, Time, Velocity).
Returns: matrix A 2-column matrix where each row is an pair.
method getCvd(self, target)
Returns Cumulative Volume/Velo Delta (CVD) information for the target metric.
Namespace types: Velo
Parameters:
self (Velo) : Velo The profile object.
target (series Metric) : Metric The data aspect to analyse (Volume, Time, Velocity).
Returns:
cvd series float The final delta value.
cvdHi series float The historical high-water mark of the delta.
cvdLo series float The historical low-water mark of the delta.
Velo
Velo Composite Velocity Profile Controller.
Fields:
_vpVol (VPrf type from AustrianTradingMachine/LibVPrf/2) : LibVPrf.VPrf Engine A: Master Volume source.
_vpTime (VPrf type from AustrianTradingMachine/LibVPrf/2) : LibVPrf.VPrf Engine B: Time duration container (ms).
_vpVelo (VPrf type from AustrianTradingMachine/LibVPrf/2) : LibVPrf.VPrf Engine C: Scratchpad for velocity stats.
_aTime (array) : array Pointer alias to `vpTime.aBuy` (Time storage).
_valueArea (series float) : int Percentage of total volume to include in the Value Area (1..100)
_estimator (series PriceEst enum from AustrianTradingMachine/LibBrSt/1) : LibBrSt.PriceEst PDF model for distribution attribution.
_allot (series AllotMode) : AllotMode Attribution model (Classic or PDF).
_cdfSteps (series int) : int Integration resolution for PDF.
_isDirty (series bool) : bool Lazy evaluation flag for vpVelo.
TrendDetectorLibLibrary "TrendDetector_Lib"
method formatTF(timeframe)
Namespace types: series string, simple string, input string, const string
Parameters:
timeframe (string) : (string) The timeframe to convert (e.g., "15", "60", "240").
Returns: (string) The formatted timeframe (e.g., "15M", "1H", "4H").
f_ma(type, src, len)
Computes a Moving Average value based on type and length.
Parameters:
type (simple string) : (string) One of: "SMA", "EMA", "RMA", "WMA", "VWMA".
src (float) : (series float) Source series for MA (e.g., close).
len (simple int) : (simple int) Length of the MA.
Returns: (float) The computed MA series.
render(tbl, trendDetectorSwitch, frameColor, frameWidth, borderColor, borderWidth, textColor, ma1ShowTrendData, ma1Timeframe, ma1Value, ma2ShowTrendData, ma2Timeframe, ma2Value, ma3ShowTrendData, ma3Timeframe, ma3Value)
Fills the provided table with Trend Detector contents.
@desc This renderer does NOT plot and does NOT create tables; call from indicator after your table exists.
Parameters:
tbl (table) : (table) Existing table to render into.
trendDetectorSwitch (bool) : (bool) Master toggle to draw the table content.
frameColor (color) : (color) Table frame color.
frameWidth (int) : (int) Table frame width (0–5).
borderColor (color) : (color) Table border color.
borderWidth (int) : (int) Table border width (0–5).
textColor (color) : (color) Table text color.
ma1ShowTrendData (bool) : (bool) Show MA #1 in table.
ma1Timeframe (simple string) : (string) MA #1 timeframe.
ma1Value (float)
ma2ShowTrendData (bool) : (bool) Show MA #2 in table.
ma2Timeframe (simple string) : (string) MA #2 timeframe.
ma2Value (float)
ma3ShowTrendData (bool) : (bool) Show MA #3 in table.
ma3Timeframe (simple string) : (string) MA #3 timeframe.
ma3Value (float)
QuickInputsLevelParserLibrary "QuickInputsLevelParser"
Provides a parsing library that indicator authors can use in order to parse Quick Inputs Levels.
parseLevels(s)
Parses the string content and returns the `QILevels` found within.
Parameters:
s (string) : The string to parse.
Returns: The parsed WTD levels.
zoneRange
Fields:
high (series float)
low (series float)
QILevels
Fields:
supplyLines (array)
supplyZones (array)
majorLines (array)
onZones (array)
onLines (array)
highLines (array)
lowLines (array)
htfZones (array)
mansupLines (array)
mansupmajLines (array)
mansupZones (array)
mansupmajZones (array)
manresLines (array)
manresmajLines (array)
manresZones (array)
manresmajZones (array)
fibonacci2Library "fibonacci2"
Useful methods to calculate and display fibonacci retracement
modelParamsNew(point_0, point_1)
Parameters:
point_0 (chart.point)
point_1 (chart.point)
modelParamsNew(this, point_0, point_1)
Parameters:
this (viewParams)
point_0 (chart.point)
point_1 (chart.point)
method toModelParams(this, point_0, point_1)
Namespace types: viewParams
Parameters:
this (viewParams)
point_0 (chart.point)
point_1 (chart.point)
method createModel(params)
Namespace types: modelParams
Parameters:
params (modelParams)
method createView(this, params)
Namespace types: model
Parameters:
this (model)
params (viewParams)
method delete(view)
Namespace types: view
Parameters:
view (view)
levelModelParams
Fields:
level (series float)
levelViewParams
Fields:
level (series float)
color (series color)
line_width (series int)
line_style (series lineStyleEnum enum from Hamster-Coder/drawing/1)
levelModel
Represents a Fibonacci retracement level
Fields:
level (series float) : The Fibonacci level ratio (e.g., 0.382, 0.5, 0.618)
value (series float) : The Y-coordinate on the chart corresponding to this level
modelParams
Represents the full parameter set for the Fibonacci retracement model
Fields:
point_1 (chart.point) : Coordinates of the anchor Point (1) of the model
point_0 (chart.point) : Coordinates of the anchor Point (0) of the model
levels (array) : List of levels to display for this model
model
Fields:
point_1 (chart.point)
point_0 (chart.point)
levels (array)
viewParams
Fields:
levels (array)
x1 (series int)
x2 (series int)
xloc (series string)
show_level_value (series bool)
value_format (series string)
force_overlay (series bool)
view
Fields:
model (model)
lines (array)
labels (array)
drawingLibrary "drawing"
Contains common types and methods to draw objects on the chart.
method toTextAlign(input)
Namespace types: series textHorizontalAlignEnum
Parameters:
input (series textHorizontalAlignEnum)
method toTextAlign(input)
Namespace types: series textVertialAlignEnum
Parameters:
input (series textVertialAlignEnum)
method toSize(input)
Namespace types: series sizeEnum
Parameters:
input (series sizeEnum)
method toStyle(input)
Namespace types: series lineStyleEnum
Parameters:
input (series lineStyleEnum)
TraderMathLibrary "TraderMath"
A collection of essential trading utilities and mathematical functions used for technical analysis,
including DEMA, Fisher Transform, directional movement, and ADX calculations.
dema(source, length)
Calculates the value of the Double Exponential Moving Average (DEMA).
Parameters:
source (float) : (series int/float) Series of values to process.
length (simple int) : (simple int) Length for the smoothing parameter calculation.
Returns: (float) The double exponentially weighted moving average of the `source`.
roundVal(val)
Constrains a value to the range .
Parameters:
val (float) : (float) Value to constrain.
Returns: (float) Value limited to the range .
fisherTransform(length)
Computes the Fisher Transform oscillator, enhancing turning point sensitivity.
Parameters:
length (int) : (int) Lookback length used to normalize price within the high-low range.
Returns: (float) Fisher Transform value.
dirmov(len)
Calculates the Plus and Minus Directional Movement components (DI+ and DI−).
Parameters:
len (simple int) : (int) Lookback length for directional movement.
Returns: (float ) Array containing .
adx(dilen, adxlen)
Computes the Average Directional Index (ADX) based on DI+ and DI−.
Parameters:
dilen (simple int) : (int) Lookback length for directional movement calculation.
adxlen (simple int) : (int) Smoothing length for ADX computation.
Returns: (float) Average Directional Index value (0–100).
MirPapa_Lib_trendLibrary: MirPapa_Lib_trend
getMaColor(level)
Parameters:
level (int): 1 = lowest, 2 = low, 3 = mid, 4 = high, 5 = highest, 6 = base
getMA(mode, src, len)
Parameters:
mode (string): MA type
src (float): source
len (simple int): period
Returns: selected MA
getMA(maName, src, intLow, intMid, intHigh)
Parameters:
maName (string): MA type
src (float): source
intLow (simple int): short-term
intMid (simple int): mid-term
intHigh (simple int): long-term
Returns: array
getMA(maName, src, intLowest, intLow, intMid, intHigh, intHighest, intBase)
Parameters:
maName (string): MA type
src (float): source
intLowest (simple int): ultra-short
intLow (simple int): short
intMid (simple int): mid
intHigh (simple int): long
intHighest (simple int): ultra-long
intBase (simple int): base line
Returns: array
getStochastic(src, intLen)
Parameters:
src (float): source
intLen (int): period
Returns: selected stochastic
getStochastic(src, intLow, intMid, intHigh)
Parameters:
src (float): source
intLow (int): short-term
intMid (int): mid-term
intHigh (int): long-term
Returns:
getStochastic(src, intLowest, intLow, intMid, intHigh, intHighest, intBase)
Parameters:
src (float): source
intLowest (int): ultra-short
intLow (int): short
intMid (int): mid
intHigh (int): long
intHighest (int): ultra-long
intBase (int): base
Returns:
getRSX(src, intLen)
Parameters:
src (float): source
intLen (int): period
Returns: selected RSX
getRSX(src, intLow, intMid, intHigh)
Parameters:
src (float): source
intLow (int): short-term
intMid (int): mid-term
intHigh (int): long-term
Returns:
getRSX(src, intLowest, intLow, intMid, intHigh, intHighest, intBase)
Parameters:
src (float): source
intLowest (int): ultra-short
intLow (int): short
intMid (int): mid
intHigh (int): long
intHighest (int): ultra-long
intBase (int): base
Returns:
getMACD(src, fastLen, slowLen, signalLen)
Parameters:
src (float): source
fastLen (simple int): fast EMA period
slowLen (simple int): slow EMA period
signalLen (simple int): signal line period
Returns:
getBollingerBand(src, len, mult)
Parameters:
src (float): source
len (int): period
mult (float): standard deviation multiplier
Returns:
getATR(intLen)
Parameters:
intLen (simple int): ATR period
Returns: selected ATR
getATR(intLow, intMid, intHigh)
Parameters:
intLow (simple int): short-term
intMid (simple int): mid-term
intHigh (simple int): long-term
Returns: array
getATR(intLowest, intLow, intMid, intHigh, intHighest, intBase)
Parameters:
intLowest (simple int): ultra-short
intLow (simple int): short
intMid (simple int): mid
intHigh (simple int): long
intHighest (simple int): ultra-long
intBase (simple int): base
isCross(fastLine, baseLine)
Parameters:
fastLine (float): fast line
baseLine (float): base line
Returns: state (true/false)
isMAtrend(maLow, maMid, maHigh)
Parameters:
maLow (float): fast MA
maMid (float): mid MA
maHigh (float): slow MA
Returns: trend state
isMAline(val, valPrev, intBaseLine)
Parameters:
val (float): current value
valPrev (float): previous value
intBaseLine (int): base value
Returns: state
getStage(v1, v2, v3)
Parameters:
v1 (float): first value
v2 (float): second value
v3 (float): third value
Returns: stage number (1–6)
getBgColor(stage)
Parameters:
stage (int): stage number
Returns: color
getBgColor(stage, transp)
Parameters:
stage (int): stage number
transp (int): transparency
Returns: color
getBGColor(v1, v2, v3)
Parameters:
v1 (float): first value
v2 (float): second value
v3 (float): third value
Returns: color
getBGColor(v1, v2, v3, transp)
Parameters:
v1 (float): first value
v2 (float): second value
v3 (float): third value
transp (int): transparency
Returns: color
createStackedLabel(labelText, isUp, maLowest, maLow, maMid, maHigh, maHighest, maBase)
Parameters:
labelText (string): label text
isUp (bool): true = up, false = down
maLowest (float)
maLow (float)
maMid (float)
maHigh (float)
maHighest (float)
maBase (float)
Returns: created label
isDoubleBottom(src, left, right)
Parameters:
src (float): reference series (e.g., mid MA or low)
left (int): left bar count for pivot search
right (int): right bar count for pivot search
Returns: true if double bottom detected (previous pivot low < current pivot low)
isDoubleTop(src, left, right)
Parameters:
src (float): reference series (e.g., mid MA or high)
left (int): left bar count for pivot search
right (int): right bar count for pivot search
Returns: true if double top detected (previous pivot high > current pivot high)
isFractalHigh(src, left, right)
Parameters:
src (float): high series (e.g., high or mid MA)
left (int): left confirmation bars
right (int): right confirmation bars
Returns: true if fractal high detected
isFractalLow(src, left, right)
Parameters:
src (float): low series (e.g., low or mid MA)
left (int): left confirmation bars
right (int): right confirmation bars
Returns: true if fractal low detected
