pandas_taLibrary "pandas_ta"
Level: 3
Background
Today is the first day of 2022 and happy new year every tradingviewers! May health and wealth go along with you all the time. I use this chance to publish my 1st PINE v5 lib : pandas_ta
This is not a piece of cake like thing, which cost me a lot of time and efforts to build this lib. Beyond 300 versions of this script was iterated in draft.
Function
Library "pandas_ta"
PINE v5 Counterpart of Pandas TA - A Technical Analysis Library in Python 3 at github.com
The Original Pandas Technical Analysis (Pandas TA) is an easy to use library that leverages the Pandas package with more than 130 Indicators and Utility functions and more than 60 TA Lib Candlestick Patterns.
I realized most of indicators except Candlestick Patterns because tradingview built-in Candlestick Patterns are even more powerful!
I use this to verify pandas_ta python version indicators for myself, but I realize that maybe many may need similar lib for pine v5 as well.
Function Brief Descriptions (Pls find details in script comments)
bton --> Binary to number
wcp --> Weighted Closing Price (WCP)
counter --> Condition counter
xbt --> Between
ebsw --> Even Better SineWave (EBSW)
ao --> Awesome Oscillator (AO)
apo --> Absolute Price Oscillator (APO)
xrf --> Dynamic shifted values
bias --> Bias (BIAS)
bop --> Balance of Power (BOP)
brar --> BRAR (BRAR)
cci --> Commodity Channel Index (CCI)
cfo --> Chande Forcast Oscillator (CFO)
cg --> Center of Gravity (CG)
cmo --> Chande Momentum Oscillator (CMO)
coppock --> Coppock Curve (COPC)
cti --> Correlation Trend Indicator (CTI)
dmi --> Directional Movement Index(DMI)
er --> Efficiency Ratio (ER)
eri --> Elder Ray Index (ERI)
fisher --> Fisher Transform (FISHT)
inertia --> Inertia (INERTIA)
kdj --> KDJ (KDJ)
kst --> 'Know Sure Thing' (KST)
macd --> Moving Average Convergence Divergence (MACD)
mom --> Momentum (MOM)
pgo --> Pretty Good Oscillator (PGO)
ppo --> Percentage Price Oscillator (PPO)
psl --> Psychological Line (PSL)
pvo --> Percentage Volume Oscillator (PVO)
qqe --> Quantitative Qualitative Estimation (QQE)
roc --> Rate of Change (ROC)
rsi --> Relative Strength Index (RSI)
rsx --> Relative Strength Xtra (rsx)
rvgi --> Relative Vigor Index (RVGI)
slope --> Slope
smi --> SMI Ergodic Indicator (SMI)
sqz* --> Squeeze (SQZ) * NOTE: code sufferred from very strange error, code was commented.
sqz_pro --> Squeeze PRO(SQZPRO)
xfl --> Condition filter
stc --> Schaff Trend Cycle (STC)
stoch --> Stochastic (STOCH)
stochrsi --> Stochastic RSI (STOCH RSI)
trix --> Trix (TRIX)
tsi --> True Strength Index (TSI)
uo --> Ultimate Oscillator (UO)
willr --> William's Percent R (WILLR)
alma --> Arnaud Legoux Moving Average (ALMA)
xll --> Dynamic rolling lowest values
dema --> Double Exponential Moving Average (DEMA)
ema --> Exponential Moving Average (EMA)
fwma --> Fibonacci's Weighted Moving Average (FWMA)
hilo --> Gann HiLo Activator(HiLo)
hma --> Hull Moving Average (HMA)
hwma --> HWMA (Holt-Winter Moving Average)
ichimoku --> Ichimoku Kinkō Hyō (ichimoku)
jma --> Jurik Moving Average Average (JMA)
kama --> Kaufman's Adaptive Moving Average (KAMA)
linreg --> Linear Regression Moving Average (linreg)
mgcd --> McGinley Dynamic Indicator
rma --> wildeR's Moving Average (RMA)
sinwma --> Sine Weighted Moving Average (SWMA)
ssf --> Ehler's Super Smoother Filter (SSF) © 2013
supertrend --> Supertrend (supertrend)
xsa --> X simple moving average
swma --> Symmetric Weighted Moving Average (SWMA)
t3 --> Tim Tillson's T3 Moving Average (T3)
tema --> Triple Exponential Moving Average (TEMA)
trima --> Triangular Moving Average (TRIMA)
vidya --> Variable Index Dynamic Average (VIDYA)
vwap --> Volume Weighted Average Price (VWAP)
vwma --> Volume Weighted Moving Average (VWMA)
wma --> Weighted Moving Average (WMA)
zlma --> Zero Lag Moving Average (ZLMA)
entropy --> Entropy (ENTP)
kurtosis --> Rolling Kurtosis
skew --> Rolling Skew
xev --> Condition all
zscore --> Rolling Z Score
adx --> Average Directional Movement (ADX)
aroon --> Aroon & Aroon Oscillator (AROON)
chop --> Choppiness Index (CHOP)
xex --> Condition any
cksp --> Chande Kroll Stop (CKSP)
dpo --> Detrend Price Oscillator (DPO)
long_run --> Long Run
psar --> Parabolic Stop and Reverse (psar)
short_run --> Short Run
vhf --> Vertical Horizontal Filter (VHF)
vortex --> Vortex
accbands --> Acceleration Bands (ACCBANDS)
atr --> Average True Range (ATR)
bbands --> Bollinger Bands (BBANDS)
donchian --> Donchian Channels (DC)
kc --> Keltner Channels (KC)
massi --> Mass Index (MASSI)
natr --> Normalized Average True Range (NATR)
pdist --> Price Distance (PDIST)
rvi --> Relative Volatility Index (RVI)
thermo --> Elders Thermometer (THERMO)
ui --> Ulcer Index (UI)
ad --> Accumulation/Distribution (AD)
cmf --> Chaikin Money Flow (CMF)
efi --> Elder's Force Index (EFI)
ecm --> Ease of Movement (EOM)
kvo --> Klinger Volume Oscillator (KVO)
mfi --> Money Flow Index (MFI)
nvi --> Negative Volume Index (NVI)
obv --> On Balance Volume (OBV)
pvi --> Positive Volume Index (PVI)
dvdi --> Dual Volume Divergence Index (DVDI)
xhh --> Dynamic rolling highest values
pvt --> Price-Volume Trend (PVT)
Remarks
I also incorporated func descriptions and func test script in commented mode, you can test the functino with the embedded test script and modify them as you wish.
This is a Level 3 free and open source indicator library.
Feedbacks are appreciated.
This is not the end of pandas_ta lib publication, but it is start point with pine v5 lib function and I will add more and more funcs into this lib for my own indicators.
Function Name List:
bton()
wcp()
count()
xbt()
ebsw()
ao()
apo()
xrf()
bias()
bop()
brar()
cci()
cfo()
cg()
cmo()
coppock()
cti()
dmi()
er()
eri()
fisher()
inertia()
kdj()
kst()
macd()
mom()
pgo()
ppo()
psl()
pvo()
qqe()
roc()
rsi()
rsx()
rvgi()
slope()
smi()
sqz_pro()
xfl()
stc()
stoch()
stochrsi()
trix()
tsi()
uo()
willr()
alma()
wcx()
xll()
dema()
ema()
fwma()
hilo()
hma()
hwma()
ichimoku()
jma()
kama()
linreg()
mgcd()
rma()
sinwma()
ssf()
supertrend()
xsa()
swma()
t3()
tema()
trima()
vidya()
vwap()
vwma()
wma()
zlma()
entropy()
kurtosis()
skew()
xev()
zscore()
adx()
aroon()
chop()
xex()
cksp()
dpo()
long_run()
psar()
short_run()
vhf()
vortex()
accbands()
atr()
bbands()
donchian()
kc()
massi()
natr()
pdist()
rvi()
thermo()
ui()
ad()
cmf()
efi()
ecm()
kvo()
mfi()
nvi()
obv()
pvi()
dvdi()
xhh()
pvt()
Indicators and strategies
HarmonicPatternLibrary "HarmonicPattern"
Functions to detect/check harmonic patterns from provided values.
line_price_rate(point_c, point_b, point_a) Compute the price rate of the line AB divided by the the line BC
Parameters:
point_c : float, the price at point C.
point_b : float, the price at point B.
point_a : float, the price at point A.
Returns: float
line_time_rate(_c, _b, _a) Compute the time rate of the line AB divided by the the line BC
Parameters:
_c : float, the time or bar_index at point C.
_b : float, the time or bar_index at point B.
_a : float, the time or bar_index at point A.
Returns: float
is_inrange(value, min, max) Check if value is within min/max range of tolerance.
Parameters:
value : float, value to check tolerance.
min : float, minimum value in range of tolerance.
max : float, maximum value in range of tolerance.
Returns: bool
isHarmonicTriangle(rate_cba, margin_of_error) Check if the rate(s) correspond to pattern ("Harmonic Triangle").
Parameters:
rate_cba : float, percent rate of the triangle CBA. expects a negative rate.
margin_of_error : float, percent rate of expected error margin, default 0.05(5%).
Returns: bool
is2Tap(rate_cba, margin_of_error) Check if the rate(s) correspond to pattern ("2Tap", 'Double Top / Bottom').
Parameters:
rate_cba : float, percent rate of the triangle CBA. expects a negative rate.
margin_of_error : float, percent rate of expected error margin, default 0.05(5%).
Returns: bool
is3Tap(rate_edc, rate_cba, margin_of_error) Check if the rate(s) correspond to pattern ("3Tap", "Triple Top / Bottom").
Parameters:
rate_edc : float, percent rate of the triangle EDC. expects a negative rate.
rate_cba : float, percent rate of the triangle CBA. expects a negative rate.
margin_of_error : float, percent rate of expected error margin, default 0.05(5%).
Returns: bool
is4Tap(rate_gfe, rate_edc, rate_cba, margin_of_error) Check if the rate(s) correspond to pattern ("4Tap", "Quadruple Top / Bottom").
Parameters:
rate_gfe : float, percent rate of the triangle GFE. expects a negative rate.
rate_edc : float, percent rate of the triangle EDC. expects a negative rate.
rate_cba : float, percent rate of the triangle CBA. expects a negative rate.
margin_of_error : float, percent rate of expected error margin, default 0.05(5%).
Returns: bool
isABCD(rate_cba, rate_dcb, margin_of_error) Check if the rate(s) correspond to pattern ("AB=CD").
Parameters:
rate_cba : float, percent rate of the triangle CBA. expects a negative rate.
rate_dcb : float, percent rate of the triangle DCB. expects a negative rate.
margin_of_error : float, percent rate of expected error margin, default 0.05(5%).
Returns: bool
isBat(rate_edc, rate_dcb, rate_cba, rate_eda, margin_of_error) Check if the rate(s) correspond to pattern ("Bat").
Parameters:
rate_edc : float, percent rate of the triangle EDC. expects a negative rate.
rate_dcb : float, percent rate of the triangle DCB. expects a negative rate.
rate_cba : float, percent rate of the triangle CBA. expects a negative rate.
rate_eda : float, percent rate of the triangle EDA. expects a negative rate.
margin_of_error : float, percent rate of expected error margin, default 0.05(5%).
Returns: bool
isButterfly(rate_edc, rate_dcb, rate_cba, rate_eda, margin_of_error) Check if the rate(s) correspond to pattern ("Butterfly").
Parameters:
rate_edc : float, percent rate of the triangle EDC. expects a negative rate.
rate_dcb : float, percent rate of the triangle DCB. expects a negative rate.
rate_cba : float, percent rate of the triangle CBA. expects a negative rate.
rate_eda : float, percent rate of the triangle EDA. expects a negative rate.
margin_of_error : float, percent rate of expected error margin, default 0.05(5%).
Returns: bool
isGartley(rate_edc, rate_dcb, rate_cba, rate_eda, margin_of_error) Check if the rate(s) correspond to pattern ("Gartley").
Parameters:
rate_edc : float, percent rate of the triangle EDC. expects a negative rate.
rate_dcb : float, percent rate of the triangle DCB. expects a negative rate.
rate_cba : float, percent rate of the triangle CBA. expects a negative rate.
rate_eda : float, percent rate of the triangle EDA. expects a negative rate.
margin_of_error : float, percent rate of expected error margin, default 0.05(5%).
Returns: bool
isCrab(rate_edc, rate_dcb, rate_cba, rate_eda, margin_of_error) Check if the rate(s) correspond to pattern ("Crab").
Parameters:
rate_edc : float, percent rate of the triangle EDC. expects a negative rate.
rate_dcb : float, percent rate of the triangle DCB. expects a negative rate.
rate_cba : float, percent rate of the triangle CBA. expects a negative rate.
rate_eda : float, percent rate of the triangle EDA. expects a negative rate.
margin_of_error : float, percent rate of expected error margin, default 0.05(5%).
Returns: bool
isShark(rate_edc, rate_dcb, rate_cba, rate_eda, margin_of_error) Check if the rate(s) correspond to pattern ("Shark").
Parameters:
rate_edc : float, percent rate of the triangle EDC. expects a negative rate.
rate_dcb : float, percent rate of the triangle DCB. expects a negative rate.
rate_cba : float, percent rate of the triangle CBA. expects a negative rate.
rate_eda : float, percent rate of the triangle EDA. expects a negative rate.
margin_of_error : float, percent rate of expected error margin, default 0.05(5%).
Returns: bool
is5o(rate_edc, rate_dcb, rate_cba, rate_eda, margin_of_error) Check if the rate(s) correspond to pattern ("5o").
Parameters:
rate_edc : float, percent rate of the triangle EDC. expects a negative rate.
rate_dcb : float, percent rate of the triangle DCB. expects a negative rate.
rate_cba : float, percent rate of the triangle CBA. expects a negative rate.
rate_eda : float, percent rate of the triangle EDA. expects a negative rate.
margin_of_error : float, percent rate of expected error margin, default 0.05(5%).
Returns: bool
isWolfe(rate_edc, rate_dcb, rate_cba, rate_eda, margin_of_error) Check if the rate(s) correspond to pattern ("Wolfe").
Parameters:
rate_edc : float, percent rate of the triangle EDC. expects a negative rate.
rate_dcb : float, percent rate of the triangle DCB. expects a negative rate.
rate_cba : float, percent rate of the triangle CBA. expects a negative rate.
rate_eda : float, percent rate of the triangle EDA. expects a negative rate.
margin_of_error : float, percent rate of expected error margin, default 0.05(5%).
Returns: bool
is3Driver(rate_edc, rate_dcb, rate_cba, rate_eda, margin_of_error) Check if the rate(s) correspond to pattern ("3 Driver").
Parameters:
rate_edc : float, percent rate of the triangle EDC. expects a negative rate.
rate_dcb : float, percent rate of the triangle DCB. expects a negative rate.
rate_cba : float, percent rate of the triangle CBA. expects a negative rate.
rate_eda : float, percent rate of the triangle EDA. expects a negative rate.
margin_of_error : float, percent rate of expected error margin, default 0.05(5%).
Returns: bool
isConTria(rate_edc, rate_dcb, rate_cba, rate_eda, margin_of_error) Check if the rate(s) correspond to pattern ("Contracting Triangle").
Parameters:
rate_edc : float, percent rate of the triangle EDC. expects a negative rate.
rate_dcb : float, percent rate of the triangle DCB. expects a negative rate.
rate_cba : float, percent rate of the triangle CBA. expects a negative rate.
rate_eda : float, percent rate of the triangle EDA. expects a negative rate.
margin_of_error : float, percent rate of expected error margin, default 0.05(5%).
Returns: bool
isExpTria(rate_edc, rate_dcb, rate_cba, rate_eda, margin_of_error) Check if the rate(s) correspond to pattern ("Expanding Triangle").
Parameters:
rate_edc : float, percent rate of the triangle EDC. expects a negative rate.
rate_dcb : float, percent rate of the triangle DCB. expects a negative rate.
rate_cba : float, percent rate of the triangle CBA. expects a negative rate.
rate_eda : float, percent rate of the triangle EDA. expects a negative rate.
margin_of_error : float, percent rate of expected error margin, default 0.05(5%).
Returns: bool
isHnS(rate_fed, rate_feb, rate_edc, rate_dcb, rate_cba, rate_eda, margin_of_error) Check if the rate(s) correspond to pattern ("Head and Shoulders").
Parameters:
rate_fed : float, percent rate of the triangle FED. expects a negative rate.
rate_feb : float, percent rate of the triangle FEB. expects a negative rate.
rate_edc : float, percent rate of the triangle EDC. expects a negative rate.
rate_dcb : float, percent rate of the triangle DCB. expects a negative rate.
rate_cba : float, percent rate of the triangle CBA. expects a negative rate.
rate_eda : float, percent rate of the triangle EDA. expects a negative rate.
margin_of_error : float, percent rate of expected error margin, default 0.05(5%).
Returns: bool
benchLibrary "bench"
A simple banchmark library to analyse script performance and bottlenecks.
Very useful if you are developing an overly complex application in Pine Script, or trying to optimise a library / function / algorithm...
Supports artificial looping benchmarks (of fast functions)
Supports integrated linear benchmarks (of expensive scripts)
One important thing to note is that the Pine Script compiler will completely ignore any calculations that do not eventually produce chart output. Therefore, if you are performing an artificial benchmark you will need to use the bench.reference(value) function to ensure the calculations are executed.
Please check the examples towards the bottom of the script.
Quick Reference
(Be warned this uses non-standard space characters to get the line indentation to work in the description!)
```
// Looping benchmark style
benchmark = bench.new(samples = 500, loops = 5000)
data = array.new_int()
if bench.start(benchmark)
while bench.loop(benchmark)
array.unshift(data, timenow)
bench.mark(benchmark)
while bench.loop(benchmark)
array.unshift(data, timenow)
bench.mark(benchmark)
while bench.loop(benchmark)
array.unshift(data, timenow)
bench.stop(benchmark)
bench.reference(array.get(data, 0))
bench.report(benchmark, '1x array.unshift()')
// Linear benchmark style
benchmark = bench.new()
data = array.new_int()
bench.start(benchmark)
for i = 0 to 1000
array.unshift(data, timenow)
bench.mark(benchmark)
for i = 0 to 1000
array.unshift(data, timenow)
bench.stop(benchmark)
bench.reference(array.get(data, 0))
bench.report(benchmark,'1000x array.unshift()')
```
Detailed Interface
new(samples, loops) Initialises a new benchmark array
Parameters:
samples : int, the number of bars in which to collect samples
loops : int, the number of loops to execute within each sample
Returns: int , the benchmark array
active(benchmark) Determing if the benchmarks state is active
Parameters:
benchmark : int , the benchmark array
Returns: bool, true only if the state is active
start(benchmark) Start recording a benchmark from this point
Parameters:
benchmark : int , the benchmark array
Returns: bool, true only if the benchmark is unfinished
loop(benchmark) Returns true until call count exceeds bench.new(loop) variable
Parameters:
benchmark : int , the benchmark array
Returns: bool, true while looping
reference(number, string) Add a compiler reference to the chart so the calculations don't get optimised away
Parameters:
number : float, a numeric value to reference
string : string, a string value to reference
mark(benchmark, number, string) Marks the end of one recorded interval and the start of the next
Parameters:
benchmark : int , the benchmark array
number : float, a numeric value to reference
string : string, a string value to reference
stop(benchmark, number, string) Stop the benchmark, ending the final interval
Parameters:
benchmark : int , the benchmark array
number : float, a numeric value to reference
string : string, a string value to reference
report(Prints, benchmark, title, text_size, position)
Parameters:
Prints : the benchmarks results to the screen
benchmark : int , the benchmark array
title : string, add a custom title to the report
text_size : string, the text size of the log console (global size vars)
position : string, the position of the log console (global position vars)
unittest_bench(case) Cache module unit tests, for inclusion in parent script test suite. Usage: bench.unittest_bench(__ASSERTS)
Parameters:
case : string , the current test case and array of previous unit tests (__ASSERTS)
unittest(verbose) Run the bench module unit tests as a stand alone. Usage: bench.unittest()
Parameters:
verbose : bool, optionally disable the full report to only display failures
LibraryCOT█ OVERVIEW
This library is a Pine programmer's tool that provides functions to access Commitment of Traders (COT) data for futures. Four of our scripts use it:
• Commitment of Traders: Legacy Metrics
• Commitment of Traders: Disaggregated Metrics
• Commitment of Traders: Financial Metrics
• Commitment of Traders: Total
If you do not program in Pine and want to use COT data, please see the indicators linked above.
█ CONCEPTS
Commitment of Traders (COT) data is tallied by the Commodity Futures Trading Commission (CFTC) , a US federal agency that oversees the trading of derivative markets such as futures in the US. It is weekly data that provides traders with information about open interest for an asset. The CFTC oversees derivative markets traded on different exchanges, so COT data is available for assets that can be traded on CBOT, CME, NYMEX, COMEX, and ICEUS.
Accessing COT data from a Pine script requires the generation of a ticker ID string for use with request.security() . The ticker string must be encoded in a special format that includes both CFTC and TradingView-specific content. The format of the ticker IDs is somewhat complex; this library's functions make their generation easier. Note that if you know the COT ticker ID string for specific data, you can enter it from the chart's "Symbol Search" dialog box.
A ticker for COT data in Pine has the following structure:
COT:__<_metricDirection><_metricType>
where an underscore prefixing a component name inside <> is only included if the component is not a null string, and:
Is a digit representing the type of the COT report the data comes from: "" for legacy COT data, "2" for disaggregated data and "3" for financial data.
Is a six digit code that represents a commodity. Example: wheat futures (root "ZW") have the code "001602".
Is either "F" if the report data should exclude Options data, or "FO" if such data is included.
Is the TradingView code of the metric. This library's `metricNameAndDirectionToTicker()` function creates both
the and components of a COT ticker from the metric names and directions listed in the above chart.
The different metrics are explained in the CFTC's Explanatory Notes .
Is the direction of the metric: "Long", "Short", "Spreading" or "No direction".
Not all directions are applicable to all metrics. The valid ones are listed next to each metric in the above chart.
Is the type of the metric, possible values are "All", "Old" and "Other".
The difference between the types is explained in the "Old and Other Futures" section of the CFTC's Explanatory Notes .
As an example, the Legacy report Open Interest data for ZW futures (options included) in the old standard has the ticker "COT:001602_FO_OI_OLD". The same data using the current standard without futures has the ticker "COT:001602_F_OI".
█ USING THE LIBRARY
The first functions in the library are helper functions that generate components of a COT ticker ID. The last function, `COTTickerid()`, is the one that generates the full ticker ID string by calling some of the helper functions. We use it like this in our example:
exampleTicker = COTTickerid(
COTType = "Legacy",
CFTCCode = convertRootToCOTCode("Auto"),
includeOptions = false,
metricName = "Open Interest",
metricDirection = "No direction",
metricType = "All")
This library's chart displays the valid values for the `metricName` and `metricDirection` arguments. They vary for each of the three types of COT data (the `COTType` argument). The chart also displays the COT ticker ID string in the `exampleTicker` variable.
Look first. Then leap.
The library's functions are:
rootToCFTCCode(root)
Accepts a futures root and returns the relevant CFTC code.
Parameters:
root : Root prefix of the future's symbol, e.g. "ZC" for "ZC1!"" or "ZCU2021".
Returns: The part of a COT ticker corresponding to `root`, or "" if no CFTC code exists for the `root`.
currencyToCFTCCode(curr)
Converts a currency string to its corresponding CFTC code.
Parameters:
curr : Currency code, e.g., "USD" for US Dollar.
Returns: The corresponding to the currency, if one exists.
optionsToTicker(includeOptions)
Returns the part of a COT ticker using the `includeOptions` value supplied, which determines whether options data is to be included.
Parameters:
includeOptions : A "bool" value: 'true' if the symbol should include options and 'false' otherwise.
Returns: The part of a COT ticker: "FO" for data that includes options and "F" for data that doesn't.
metricNameAndDirectionToTicker(metricName, metricDirection)
Returns a string corresponding to a metric name and direction, which is one component required to build a valid COT ticker ID.
Parameters:
metricName : One of the metric names listed in this library's chart. Invalid values will cause a runtime error.
metricDirection : Metric direction. Possible values are: "Long", "Short", "Spreading", and "No direction".
Valid values vary with metrics. Invalid values will cause a runtime error.
Returns: The part of a COT ticker ID string, e.g., "OI_OLD" for "Open Interest" and "No direction",
or "TC_L" for "Traders Commercial" and "Long".
typeToTicker(metricType)
Converts a metric type into one component required to build a valid COT ticker ID.
See the "Old and Other Futures" section of the CFTC's Explanatory Notes for details on types.
Parameters:
metricType : Metric type. Accepted values are: "All", "Old", "Other".
Returns: The part of a COT ticker.
convertRootToCOTCode(mode, convertToCOT)
Depending on the `mode`, returns a CFTC code using the chart's symbol or its currency information when `convertToCOT = true`.
Otherwise, returns the symbol's root or currency information. If no COT data exists, a runtime error is generated.
Parameters:
mode : A string determining how the function will work. Valid values are:
"Root": the function extracts the futures symbol root (e.g. "ES" in "ESH2020") and looks for its CFTC code.
"Base currency": the function extracts the first currency in a pair (e.g. "EUR" in "EURUSD") and looks for its CFTC code.
"Currency": the function extracts the quote currency ("JPY" for "TSE:9984" or "USDJPY") and looks for its CFTC code.
"Auto": the function tries the first three modes (Root -> Base Currency -> Currency) until a match is found.
convertToCOT : "bool" value that, when `true`, causes the function to return a CFTC code.
Otherwise, the root or currency information is returned. Optional. The default is `true`.
Returns: If `convertToCOT` is `true`, the part of a COT ticker ID string.
If `convertToCOT` is `false`, the root or currency extracted from the current symbol.
COTTickerid(COTType, CTFCCode, includeOptions, metricName, metricDirection, metricType)
Returns a valid TradingView ticker for the COT symbol with specified parameters.
Parameters:
COTType : A string with the type of the report requested with the ticker, one of the following: "Legacy", "Disaggregated", "Financial".
CTFCCode : The for the asset, e.g., wheat futures (root "ZW") have the code "001602".
includeOptions : A boolean value. 'true' if the symbol should include options and 'false' otherwise.
metricName : One of the metric names listed in this library's chart.
metricDirection : Direction of the metric, one of the following: "Long", "Short", "Spreading", "No direction".
metricType : Type of the metric. Possible values: "All", "Old", and "Other".
Returns: A ticker ID string usable with `request.security()` to fetch the specified Commitment of Traders data.
█ AVAILABLE METRICS
Different COT types provide different metrics. The table of all metrics available for each of the types can be found below.
+------------------------------+------------------------+
| Legacy (COT) Metric Names | Directions |
+------------------------------+------------------------+
| Open Interest | No direction |
| Noncommercial Positions | Long, Short, Spreading |
| Commercial Positions | Long, Short |
| Total Reportable Positions | Long, Short |
| Nonreportable Positions | Long, Short |
| Traders Total | No direction |
| Traders Noncommercial | Long, Short, Spreading |
| Traders Commercial | Long, Short |
| Traders Total Reportable | Long, Short |
| Concentration Gross LT 4 TDR | Long, Short |
| Concentration Gross LT 8 TDR | Long, Short |
| Concentration Net LT 4 TDR | Long, Short |
| Concentration Net LT 8 TDR | Long, Short |
+------------------------------+------------------------+
+-----------------------------------+------------------------+
| Disaggregated (COT2) Metric Names | Directions |
+-----------------------------------+------------------------+
| Open Interest | No Direction |
| Producer Merchant Positions | Long, Short |
| Swap Positions | Long, Short, Spreading |
| Managed Money Positions | Long, Short, Spreading |
| Other Reportable Positions | Long, Short, Spreading |
| Total Reportable Positions | Long, Short |
| Nonreportable Positions | Long, Short |
| Traders Total | No Direction |
| Traders Producer Merchant | Long, Short |
| Traders Swap | Long, Short, Spreading |
| Traders Managed Money | Long, Short, Spreading |
| Traders Other Reportable | Long, Short, Spreading |
| Traders Total Reportable | Long, Short |
| Concentration Gross LE 4 TDR | Long, Short |
| Concentration Gross LE 8 TDR | Long, Short |
| Concentration Net LE 4 TDR | Long, Short |
| Concentration Net LE 8 TDR | Long, Short |
+-----------------------------------+------------------------+
+-------------------------------+------------------------+
| Financial (COT3) Metric Names | Directions |
+-------------------------------+------------------------+
| Open Interest | No Direction |
| Dealer Positions | Long, Short, Spreading |
| Asset Manager Positions | Long, Short, Spreading |
| Leveraged Funds Positions | Long, Short, Spreading |
| Other Reportable Positions | Long, Short, Spreading |
| Total Reportable Positions | Long, Short |
| Nonreportable Positions | Long, Short |
| Traders Total | No Direction |
| Traders Dealer | Long, Short, Spreading |
| Traders Asset Manager | Long, Short, Spreading |
| Traders Leveraged Funds | Long, Short, Spreading |
| Traders Other Reportable | Long, Short, Spreading |
| Traders Total Reportable | Long, Short |
| Concentration Gross LE 4 TDR | Long, Short |
| Concentration Gross LE 8 TDR | Long, Short |
| Concentration Net LE 4 TDR | Long, Short |
| Concentration Net LE 8 TDR | Long, Short |
+-------------------------------+------------------------+
Range Volume ChangeI was looking for a way to see if today's premarket volume is higher or lower than the previous day's premarket, but did not find any, hence, I made my own which I share with you now.
I call it 'Range Volume Change' or just RVC.
RVC will show the percentage of change between the selected time range and the previous day for the same time range.
This will allow us to see if the volume is increasing or decreasing today compared to the previous day by a specific time range that we set in PVC settings. It can do more than just premarket, you can use it for any time range of your interest which will work on 24hours assets like crypto and forex.
RVC visualizes the incremental of the volume using increasing size columns giving you a better view of how the volume changes compared to the past. The column shows the accumulated volume from when the time range started.
As an extra feature, it will also show the volume percentage of change outside the time range (can be disabled from settings).
In addition, RVC is also designed to work on real-time data.
Example of BTCUSDT (24-hour asset) with volume 'outside the time range', enabled (purple columns):
Follow for more awesome indicators/strategies: www.tradingview.com
Commitment of Traders: Legacy Metrics█ OVERVIEW
This indicator displays the Commitment of Traders (COT) legacy data for futures markets.
█ CONCEPTS
Commitment of Traders (COT) data is tallied by the Commodity Futures Trading Commission (CFTC) , a US federal agency that oversees the trading of derivative markets such as futures in the US. It is weekly data that provides traders with information about open interest for an asset. The CFTC oversees derivative markets traded on different exchanges, so COT data is available for assets that can be traded on CBOT, CME, NYMEX, COMEX, and ICEUS.
A detailed description of the COT report can be found on the CFTC's website .
COT data is separated into three notable reports: Legacy, Disaggregated, and Financial. This indicator presents data from the legacy report, which is broken down by exchange. Legacy reports break down the reportable open interest positions into two classifications: non-commercial and commercial traders.
Our other COT indicators are:
• Commitment of Traders: Disaggregated Metrics
• Commitment of Traders: Financial Metrics
• Commitment of Traders: Total
█ HOW TO USE IT
Load the indicator on an active chart (see here if you don't know how).
By default, the indicator uses the chart's symbol to derive the COT data it displays. You can also specify a CFTC code in the "CFTC code" field of the script's inputs to display COT data from a symbol different than the chart's.
The rest of this section documents the script's input fields.
Metric
Each metric represents a different column of the Commitment of Traders report. Details are available in the explanatory notes on the CFTC's website .
Here is a summary of the metrics:
• "Open Interest" is the total of all futures and/or option contracts entered into and not yet offset by a transaction, by delivery, by exercise, etc.
The aggregate of all long open interest is equal to the aggregate of all short open interest.
• "Traders Total" is the number of all unique reportable traders, regardless of the trading direction.
• "Traders Total Reportable/Traders Noncommercial/Traders Commercial" are the quantities of traders reported to hold any position with the specified direction.
All of a trader's reported futures positions in a commodity are classified as commercial if the trader uses futures contracts in that particular commodity for hedging.
To determine the total number of reportable traders in a market, a trader is counted only once, whether or not the trader appears in more than one category.
• "Total Reportable/Noncommercial/Commercial Positions" are all positions held by all reportable/non-commercial/commercial traders.
• "Non-reportable Positions" is derived by subtracting total long and short "Reportable Positions" from the total open interest.
Accordingly, the number of traders involved and the commercial/non-commercial classification of each trader are unknown.
• "Concentration Gross/Net LT 4/8 TDR" is the percentage of open interest held by 4/8 of the largest traders, by gross/net positions,
without regard to whether they are classified as commercial or non-commercial. The Net position ratios are computed after offsetting each trader’s equal long and short positions.
A reportable trader with relatively large, balanced long and short positions in a single market, therefore,
may be among the four and eight largest traders in both the gross long and gross short categories, but will probably not be included among the four and eight largest traders on a net basis.
Direction
Each metric is available for a particular set of directions. Valid directions for each metric are specified with its name in the "Metric" field's dropdown menu.
Type
Possible values are: All, Old, Other. When commodities have a well-defined marketing season or crop year (e.g. Wheat or Lean Hogs futures), this determines how the data is aggregated. Detailed explanation can be found in the "Old and Other Futures" section of the CTFC Explanatory Notes linked above. The "Major Markets for Which the COT Data Is Shown by Crop Year" table in the Explanatory Notes specifies the commodities that this distinction applies to; selecting "Old" for any of the commodities not in that list will return the same data as in "All", while selecting "Other" will return 0.
COT Selection Mode
This field's value determines how the script determines which COT data to return from the chart's symbol:
- "Root" uses the root of a futures symbol ("ES" for "ESH2020").
- "Base currency" uses the base currency in a forex pair ("EUR" for "EURUSD").
- "Currency" uses the quote currency, i.e., the currency the symbol is traded in ("JPY" for "TSE:9984" or "USDJPY").
- "Auto" tries all modes, in turn.
If no COT data can be found, a runtime error is generated.
Note that if the "CTFC Code" input field contains a code, it will override this input.
Futures/Options
Specifies the type of Commitment of Traders data to display: data concerning only Futures, only Options, or both.
CTFC Code
Instead of letting the script generate the CFTC COT code from the chart and the "COT Selection Mode" input when this field is empty, you can specify an unrelated CFTC COT code here, e.g., 001602 for wheat futures.
Look first. Then leap.
XABCD Harmonic Pattern Custom Range Interactive█ OVERVIEW
This indicator was designed based on Harmonic Pattern Book written by Scott Carney. It was simplified to user who may always used tools such as XABCD Pattern and Long Position / Short Position, which consume a lot of time, recommended for both beginner and expert of Harmonic Pattern Traders. XABCD Pattern require tool usage of Magnet tool either Strong Magnet, Week Magnet or none, which cause error or human mistake especially daily practice.
Simplified Guideline by sequence for Harmonic Pattern if using manual tools :
Step 1 : Trade Identification - XABCD Pattern
Step 2 : Trade Execution - Any manual tools of your choice
Step 3 : Trade Management - Position / Short Position
█ INSPIRATION
Inspired by design, code and usage of CAGR. Basic usage of custom range / interactive, pretty much explained here . Credits to TradingView.
I use a lot of XABCD Pattern and Long Position / Short Position, require 5 to 10 minutes on average, upon determine the validity of harmonic pattern.
Upon creating this indicator, I believed that time can be reduced, gain more confidence, reduce error during drawing XABCD, which helps most of harmonic pattern users.
█ FEATURES
Table can positioned by any postion and font size can be resized.
Table can be display through optimized display or manual control.
Validility of harmonic pattern depends on BC ratio.
Harmonic pattern can be displayed fully or optimized while showing BC ratio validity.
Trade Execution at point D can be displayed on / off.
Stop Loss and Take Profit can be calculated automatically or manually.
Optimized table display based extend line setup and profit and loss setup.
Execution zone can be offset to Point C, by default using Point D.
Currency can be show or hide.
Profit and Loss can be displayed on axis once line is extended.
█ HOW TO USE
Step 1 : Trade Identification - Draw points from Point X to Point C. Dont worry about magnet, point will attached depends on High or Low of the candle.
Step 2 : Trade Execution - Check the validity of BC to determine the validity of harmonic pattern generated. Pattern only generate 1 pattern upon success. Otherwise, redraw to other points.
Step 3 : Trade Management - Determine the current candle either reach Point D or Potential Reversal Zone (PRZ). Check for Profit & Loss once reach PRZ.
█ USAGE LIMITATIONS
Harmonic Patterns only limits to patterns mentioned in Harmonic Trading Volume 3 due to other pattern may have other or different philosophy.
Only can be used for Daily timeframe and below due to bar_time is based on minutes by default.
Not recommended for Weekly and Monthly timeframe.
If Point X, A, B, C and D is next to each other, it is recommend to use lower timeframe.
Automated alert is not supported for this release. However, alert can be done manually. Alert will updated on the version.
█ PINE SCRIPT LIMITATIONS
Known bug for when calculate time in array, causing label may not appeared or offset.
Unable to convert to library due to usage of array.get(). I prefer usage for a combination of array.get(id, 0), array.get(id, 1), array.get(id, 2) into custom function, however I faced this issue during make arrays of label. Index can be simply refered as int, for id, i not sure, already try id refered as simple, nothing happens.
linefill.new() will appeared as diamond box if overused.
Text in box.new() unable to use ternary condition or switch to change color. Bgcolor also affected.
Label display is larger than XABCD tool. Hopefully in future, have function to resize label similar to XABCD tools.
█ IMPORTANTS
Trade Management (Profit & Loss) is calculated from Point A to D.
Take Profit is calculated based on ratio 0.382 and 0.618 of Point A to D.
Always check BC validity before proceed to Trade Management.
Length of XABCD is equal to XAB plus BCD, where XAB and BCD are one to one ratio. Length is measured in time.
Use other oscillator to countercheck. Normally use built-in Relative Strength Index (RSI) and Divergence Indicator to determine starting point of Point X and A.
█ HARMONIC PATTERNS SUPPORTED
// Credits to Scott M Carney, author of Harmonic Trading Volume 3: Reaction vs. Reversal
Alt Bat - Page 101
Bat - Page 98
Crab - Page 104
Gartley - Page 92
Butterfly - Page 113
Deep Crab - Page 107
Shark - Page 119 - 220
█ FAQ
Pattern such as 5-0, perfect XABCD and ABCD that not included, will updated on either next version or new release.
Point D time is for approximation only, not including holidays and extended session.
Basic explaination for Harmonic Trading System (Trade Identification, Trade Execution and Trade Management).
Harmonic Patterns values is pretty much summarized here including Stop Loss.
Basic explanation for Alt Bat, Bat, Crab, Gartley, Deep Crab and Butterfly.
█ USAGE / TIPS EXAMPLES (Description explained in each image)
Financial Statement Indicator by zdmreKnowing how to work with the datas in a company's financial statements is an essential skill for stock investors. The meaningful interpretation and analysis of balance sheets, income statements, and cash flow statements to discern a company's investment qualities is the basis for smart investment choices.
You can access to the financials tables of the companies as a summary with this indicator.
3 Tables;
Income Statement Table:
Revenue
Net Profit
EPS
EPS-D
P/E
Balance Sheet Table:
Current Asset
Total Asset
Total Equity
Book Value per Share
Total Debt
Debt/Equity
Statistics & Cash Flow Table:
Return On Equity
Return On Asset
Return On Invested Capital
Quick Ratio
Free Cash Flow
PSv5 Color Magic and Chart Theme SimulatorKEEP YOUR COINS FOLKS! I DON'T NEED THEM, DON'T WANT THEM. Many other talented authors on TV deserve them.
INTRODUCTION:
This is my "PSv5 Color Magic and Chart Theme Simulator" displayed using Pine Script version 5.0. The purpose of this PSv5 colorcator is to show vivid colors that are most suitable in my opinion for modifying or developing Pine scripts. Whether you are new to Pine or an experienced Pine poet, this should aid you in developing indicators with stunning color from the provided color list that is easily copied and pasted into any novel script you should possess. Whichever colors you choose, and how, is up to your imagination's capacity.
COMMENTARY:
I have a thesis. Pine essentially is a gigantor calculator with a lot of programmable bells and whistles to perform intense analytics. Zillions of numbers per day are blended up into another cornucopia of numbers to analyze. The thing is, ALL of those numbers are moot unless we can informatively portray them in various colorized forms with unique methods to point out significant numeric events. By graphically displaying them with specific modes of operation, only then do these numbers truly make any sense to us and become quantitatively beneficial.
I have to admit... I hate numbers. I never really liked them, even before I knew what an ema() was. Some days I almost can't stand them, and on occasion I feel they deserve to be flushed down the toilet at times. However, I'm a stickler for a proper gauge of measurements. Numbers are a mental burden, but they do have "purpose and meaning". That's where COLOR comes in! By applying color in specific ways in varying dynamic forms, we can generate smarter visual aids from these numerics. Numbers can be "transformed" into something colorful it wasn't before, into a tool, like a hammer. But we don't need a hammer, we need an impressive jack hammer for BIG problem solving that we could never achieve in the not to distant past.
As time goes on, we analytically measure more, and more, and more each year. It's necessary to our continual evolution. That's one significant difference between us and cave men, and the pertinent reason why we are quickly evolving as a species, while animals haven't. Humankind is gifted to enumerate very well AND blessed to see in color. We use it for innumerable things in the technological present for purpose and pleasure. Day in and day out, we take color for granted, because it's every where we can look. The fact is, color is the most important apparatus in humankind's existence EVER. We wouldn't have survived this far without it.
By utilizing color to it's grand potential, greater advancements can be attained while simultaneously being enjoyed visually. Once color is transformed from it's numeric origins into applicable tools, we can enjoy the style, elegance, and QUALITATIVE nature of the indication that can be forged. Quantities can't reveal all. Color on the other hand has a handy "quality" factor to it, often revealing things we can't ordinarily recognize. When high quality tools provide us with obtained goals, that's when we will realize how magical color truly is, always has been, and shall always be.
The future emerging economies and future financial vessels of people around the globe are going to be dependent on the secured construction of intelligent applications with a rock solid color foundation, not just math alone. I have no doubt about that. I can envision that with my eyes closed. To make an informed choice, it should be charted or graphed somehow prior to a final executive decision to trade. Going back to abysmal black and white with double decimal points placed next to cartoons within extinction doomed newspapers is not a viable option any more.
OBSERVATIONS AND UTILITY:
One thing you will notice is the code is very dense. Looks almost hideous right? Well, the variable naming is lengthy, but it's purpose is to be self explanatory, even for those who don't know how to program, YET. I'm simply not a notation enthusiast. My main intention was to provide clearly identifiable variables from their origin of assignment to their intended destination of use, clearly visible for anyone visiting. The empowerment of well versed words that are easier to understand, is a close rival to the prominent influence color has.
Secondly, I'm displaying hline() and label.new() as prime candidates to exemplify by demonstration how the "Power of Color" can be embraced with the "Power of Pine". Color in Pine has been extensively upgraded to serve novel purposes to accomplish next generation indicators that do and WILL come to exist. New functions included with PSv5 are color.rgb(), color.from_gradient(), color.r(), color.g(), color.b(), and color.t() to accompany color.new() in our mutual TV adventures. Keep in mind, the extreme agility of color also extends to line.new(), the "entirely new" linefill.new(), table.new(), bgcolor() and every other function that may utilize color.
There's a wide range of adjustability in Settings to make selections to see how they perform on different backgrounds, with their size and form. As you curiously toy with those, you're going to notice how some jump out like laser beams while others don't. Things that aren't visually appealing, still have very viable purposes, even if they don't stand out in the crowd. Often, that's preferable. The important thing is that when pertinent information relative to indication is crucial, you can program it with distinction from an assortment of a potential 1.67 million colors that can be created in Pine. "These" are my chosen favorite few, and I hope you adopt them.
PURPOSES:
For those of you who are new to Pine Script, this also may help you understand color hex/rgb and how it is utilized in Pine in a most effective manner. The most skilled of programmers can garner perks as well. There is countless examples of code diversity present here that are applicable in other scripts with adequate mutation. Any member has the freedom use any of this code in this script any way they see fit. It's specifically intended for all. There is absolutely no need for accreditation for any of this code reuse ever, in the present case. Don't worry about, I'm not.
The color_tostring() will be most valuable in troubleshooting color when using color.rgb() and becoming adept with it. I'm not going to be able to use color.rgb() without it. Chameleon indicators of the polychromatic variety are most likely going to be fine tuned with color_tostring() divulging it's results to label.new() or even table.new() maybe. One the best virtues of this script in chart, is when you hover over the generated labels, there's a hidden gift for those who truly wish to learn the intricate mechanics of diverse color in Pine. Settings has informative tooltips too.
AFTERTHOUGHTS:
Colors are most vibrant on the "Black Chart" which is the default, but it doesn't currently exist as a chart theme. With the extreme luminous intensity of LCDs in millicandela( mcd ), you may notice "Light" charts may saturate the colors making charts challenging to analyze. Because of this, I personally use "Dark Charts" and design my indicators specifically for these. I hope this provides inspiration for the future developers who are contemplating the creation of next generation indicators and how color may enhance their usefulness.
When available time provides itself, I will consider your inquiries, thoughts, and concepts presented below in the comments section, should you have any questions or comments regarding this indicator. When my indicators achieve more prevalent use by TV members , I may implement more ideas when they present themselves as worthy additions. Have a profitable future everyone!
Probability ConesA probability cone is an indicator that forecasts a statistical distribution from a set point in time into the future.
Features
Forecast a Standard or Laplace distribution.
Change the how many bars the cones will lookback and sample in their calculations.
Set how many bars to forecast the cones.
Let the cones follow price from a set number of bars back.
Anchor the cones and they will not update from their last location.
Show or hide any set of cones.
Change the deviation used of any cone's upper or lower line.
Change any line's color, style, or width.
Change or toggle the fill colors between any two cone lines.
Basic Interpretations
First, there is an assumption that the distribution starting from the cone's origin, based on the number of historical bars sampled, is likely to represent the distribution of future price.
Price typically hangs around the mean.
About 68% of price stays within the first deviation cones.
About 95% of price stays within the second deviation cones.
About 99.7% of price stays within the third deviation cones.
When price is between the first and second deviation cones, there is a higher probability for a reversal.
However, strong momentum while above or below the first deviation can indicate a trend where price maintains itself past the first deviation. For this reason it's recommended to use a momentum indicator alongside the cones.
There is no mean reversion assumption when price deviates. Price can continue to stay deviated.
It's recommended that the cones are placed at the beginning of calendar periods. Like the month, week, or day.
Be mindful when using the cones on various timeframes. As the lookback setting, which selects the number of bars back to load from the cone's origin, will load the number of bars back based on the current timeframe.
Second Deviation Strategy
How to react when price goes beyond the second deviation is contingent on your trading position.
If you are holding a losing trade and price has moved past the second deviation, it could be time to stop trading and exit.
If you are holding a winning trade and price has moved past the second deviation, it would be best to look at exit strategies to capitalize on the outperformance.
If price has moved beyond the second deviation and you hold no position, then do not open any new trades.
Synthetic Price Action GeneratorNOTICE:
First thing you need to know, it "DOES NOT" reflect the price of the ticker you will load it on. THIS IS NOT AN INDICATOR FOR TRADING! It's a developer tool solely generating random values that look exactly like the fractals we observe every single day. This script's generated candles are as fake as the never ending garbage news cycles we are often force fed and expected to believe by using carefully scripted narratives peddled as hypnotic truth to psychologically and emotionally influence you to the point of control by coercion and subjugation. I wanted to make the script's synthetic nature very clear using that analogy, it's dynamically artificial. Do not accidentally become disillusioned by this scripts values, make trading decisions from it, and lastly don't become victim to predatory media magic ministry parrots with pretty, handsome smiles, compelling you to board their ferris wheel of fear. Now, on to the good stuff...
BACKSTORY:
Occasionally I find myself in situations where I have to build analyzers in Pine to actually build novel quantitative analytic indicators and tools worthy of future use. These analyzers certainly don't exist on this platform, but usually are required to engineer and tweak algorithms of the highest quality with the finest computational caliber. I have numerous other synthesizers to publish besides this one.
For many reasons, I needed a synthetic environment to utilize the analyzers I built in Pine, to even pursue building some exotic indicators and algorithms. Pine doesn't allow sourcing of tuples. Not to mention, I required numerous Pine advancements to make long held dreams into tangible realities. Many Pine upgrades have arrived and MANY, MANY more are in need of implementation for all. Now that I have this, intending to use it in the future often when in need, you can now use it too. I do anticipate some skilled Pine poets will employ this intended handy utility to design and/or improved indicators for trading.
ORIGIN:
This was inspired by the brilliance from the world renowned ALGOmist John F. Ehlers, but it's taken on a completely alien form from its original DNA. Browsing on the internet for something else, I came across an article with a small code snippet, and I remembered an old wish of mine. I have long known that by flipping back and forth on specific tickers and timeframes in my Watchlist is not the most efficient way to evaluate indicators in multiple theatres of price action. I realized, I always wanted to possess and use this sort of tool, so... I put it into Pine form, but now have decided to inject it with Pine Script steroids. The outcome is highly mutable candle formations in a reusable mutagenic package, observable above and masquerading as genuine looking price candles.
OVERVIEW:
I guess you could call it a price action synthesizer, but I entitled it "Synthetic Price Action Generator" for those who may be searching for such a thing. You may find this more useful on the All or 5Y charts initially to witness indication from beginning (barstate.isfirst === barindex==0) to end (last_bar_index), but you may also use keyboard shortcuts + + to view the earliest plottable bars on any timeframe. I often use that keyboard shortcut to qualify an indicator through the entirety of it's runtime.
A lot can go wrong unexpectedly with indicator initialization, and you will never know it if you don't inspect it. Many recursively endowed Infinite Impulse Response (IIR) Filters can initialize with unintended results that minutely ring in slightly erroneous fashion for the entire runtime, beginning to end, causing deviations from "what should of been..." values with false signals. Looking closely at spg(), you will recognize that 3 EMAs are employed to manage and maintain randomness of CLOSE, HIGH, and LOW. In fact, any indicator's barindex==0 initialization can be inspected with the keyboard shortcuts above. If you see anything obviously strange in an authors indicator, please contact the developer if possible and respectfully notify them.
PURPOSE:
The primary intended application of this script, is to offer developers from advanced to even novice skill levels assistance with building next generation indicators. Mostly, it's purpose is for testing and troubleshooting indicators AND evaluating how they perform in a "manageable" randomized environment. Some times indicators flake out on rare but problematic price fluctuations, and this may help you with finding your issues/errata sooner than later. While the candles upon initial loading look pristine, by tweaking it to the minval/maxval parameters limits OR beyond with a few code modifications, you can generate unusual volatility, for instance... huge wicks. Limits of minval= and maxval= of are by default set to a comfort zone of operation. Massive wicks or candle bodies will undoubtedly affect your indication and often render them useless on tickers that exhibit that behavior, like WGMCF intraday currently.
Copy/paste boundaries are provided for relevant insertion into another script. Paste placement should happen at the very top of a script. Note that by overwriting the close, open, high, etc... values, your compiler will give you generous warnings of "variable shadowing" in abundance, but this is an expected part of applying it to your novel script, no worries. plotcandle() can be copied over too and enabled/disabled in Settings->Style. Always remember to fully remove this scripts' code and those assignments properly before actual trading use of your script occurs, AND specifically when publishing. The entirety of this provided code should never, never exist in a published indicator.
OTHER INTENTIONS:
Even though these are 100% synthetic generated price points, you will notice ALL of the fractal pseudo-patterns that commonly exist in the markets, are naturally occurring with this generator too. You can also swiftly immerse yourself in pattern recognition exercises with increased efficiency in real time by clicking any SPAG Setting in focus and then using the up/down arrow keys. I hope I explained potential uses adequately...
On a personal note, the existence of fractal symmetry often makes me wonder, do we truly live in a totality chaotic universe or is it ordered mathematically for some outcomes to a certain extent. I think both. My observations, it's a pre-deterministic reality completely influenced by infinitesimal amounts of sentient free will with unimaginable existing and emerging quantities. Some how an unknown mysterious mechanism governing the totality of universal physics and mathematics counts this 100.0% flawlessly and perpetually. Anyways, you can't change the past that long existed before your birth or even yesterday, but you can choose to dream, create, and forge the future into your desires and hopes. As always, shite always happens when your not looking for it. What you choose to do after stepping in it unintentionally... is totally up to you. :) Maybe this tool and tips provided will aid you in not stepping in an algo cachucha up to your ankles somehow.
SCRIPTING LESSONS PORTRAYED IN THIS SCRIPT:
Pine etiquette and code cleanliness
Overwrite capabilities of built-in Pine variables for testing indicators
Various techniques to organize Settings panel while providing ease of adjustment utility
Use of tooltip= to provide users adequate valuable information. Most people want to trade with indicators, not blindly make adjustments to them without any knowledge of their intended operation/effects
When available time provides itself, I will consider your inquiries, thoughts, and concepts presented below in the comments section, should you have any questions or comments regarding this indicator. When my indicators achieve more prevalent use by TV members , I may implement more ideas when they present themselves as worthy additions. Have a profitable future everyone!
Manual Harmonic Patterns - With interactive inputsThis script is a drawing tool which allows users to draw XABCD on the chart and script will tell whether there is any harmonic patterns on the drawings made. The script is based on interactive inputs and requires users to chose XABCD points.
Please note
This is not a scanner and it will not scan historical bars for harmonic patterns. This needs to be used rather as drawing tool instead.
Script will not check if selected pivots are correct. It assumes users to know how to select the right XABCD based on pivot high/lows. Bullish pattern will have X, B and D as pivot lows and A,C as pivot highs. Similarly bearish patterns will have X, B, D as pivot highs and A, C as pivot lows.
Script will not check for overflow conditions. For example, if price crosses, XB or BD line, then pattern is considered to be invalid. But, this check cannot be made in this script and we require users to be aware of this condition and select input accordingly.
Order of inputs should be in ascending order. X pivot should come before A and then, B, C, D and F. This again is users responsibility to select pivots in right order.
What happens after selecting XABCD?
If selected pattern is valid harmonic pattern, it will
Draw XABCD lines and labels
Fill harmonic triangles
Show PRZ box which shoes the name of valid patterns.
If it is not valid harmonic pattern, then users will see blank XABCD line without any PRZ or filled harmonic triangles.
Example:
1. When it is valid pattern
2. When it is not valid pattern
Median Convergence DivergenceIntroduction
The Median Convergence Divergence (MCD) is a derivative of the Moving Average Convergence Divergence (MACD). The difference is the change in the use of the measure of central tendency. In MACD, moving average (mean) is used, whereas, in MCD, the median is used instead. The purpose of using the median is to eliminate the outlying values, which would be calculated for a moving average. The outliers would affect the value of the moving average.
For example: 3, 5, 7, 8, 5, 4, 2, 1, 6, 21, 8. The data set average is 6.3, whereas the median value is 5. There is a difference of about 23% in the example. The reason is the outlying value '21' in the data set.
As the markets are volatile, outlying values can always emerge. A moving average will consider those values; on the other hand, the median will ignore. If the strategy calls for a tool to ignore the outliers, the Median Convergence Divergence would be a great centered oscillator.
The default values have changed to suit the current trading days in a week. When the MACD was introduced, there would be six trading days in a week. Therefore, it used 12 (2 weeks), 26(4 weeks), and 9 ( 1.5 weeks). But now that there are five trading days per week. The default values are adapted to them. Feel free to change them as per your wish.
Recommended Settings
The current settings are set to be used for the Daily Time Frame: 5 day period for the fast line, a 20 day period for the slow line, and a 10 day period for the signal line. (5 days represent a trading week, 10 days is two weeks, and 20 days is 4 weeks or a month)
For the weekly charts, use 4 week period for the fast line, 13 week period for the slow line, and 8 week period for the signal line. (4 weeks represent a month, 8 weeks is two months, and 13 weeks is 3 months or quarterly)
And for monthly charts, use 3 month period for the fast line, 12 month period for the slow line, and 6 month period for the signal line. (3 months is quarterly, 6 months is bi-yearly, and 12 month is yearly)
It'll be challenging to measure for intraday since there are many different timeframes within intraday. The settings mentioned above should also be customized as per the requirements of the trading strategy.
Strategy
The strategy application is the same as the MACD, i.e., Signal Line Crossovers, Zero Line Crossovers, and Divergence.
Signal Line Crossovers: When the MCD line crosses above the Signal line, it's a bullish crossover. When the MCD line crosses below the Signal line, it's a bearish crossover.
Zero Line Crossovers: It's a bullish crossover when the MCD line crosses above the Zero line. When the MCD line crosses below the Zero Line, it's a bearish crossover.
Divergence: When price shows a lower low, but MCD shows a higher low, it's a bullish divergence. When the price shows a higher high but MCD shows a lower high, it's a bearish divergence.
Using other indicators in conjunction with the Median Convergence Divergence is recommended to take entry and exit signals.
Head & Shoulders S/R RegularThis is my take in Head & Shoulders (regular H&S)
The script will wait until a valid point E is found, which means A, C and E are alined
Then it will find the highest point between C - E -> Head (= D),
together with the highest point between A - C -> Left Shoulder (= B)
After this, the pattern is drawn, together with a 'trigger' area (E-G - E'-G' ~ 'Right shoulder area')
ONLY in this field, when a close is higher than E'-G', the figure will turn green, if lower than E-G, it will turn red, else, it will be blue
Settings:
Date range filtering
Here you can filter the patterns by setting the date period (for E)
Pivot Points -> Leftbars - Rightbars
min/max retrace AD -> E
Set the retracement for E (retracement A -> D -> E, here between 1.4 & 1.5)
% tolerance
Tolerance of Right shoulder height against Left shoulder height
0% (= the same relative height):
85% (-> now close isn't higher than E'-G' -> blue coloured):
min/max %
Sets the desired B height against D (here B is between 35-45% of D):
width R shoulder = L shoulder + x%
Sets the width of Right shoulder against Left shoulder
0% (nothing extra, just the same width as Left shoulder)
100% (Right shoulder area is double as large as the Left shoulder):
-70% (Right shoulder area much narrower than Left shoulder):
maximum visible patterns:
Set the maximum visible amount of patterns
This script uses one of the latest fantastic Pinescript features:
linefill and for ... in loop
Cheers!
+ Klinger OscillatorThis is a version of Stephen J. Klinger's, Klinger Oscillator (sometimes called Klinger Volume Oscillator). I've changed virtually nothing about the indicator itself, but added some lookback inputs for the EMAs the oscillator is derived from (traditionally 34 and 55), and added a few other things, as is my wont.
But what is the Klinger Oscillator? Essentially, the calculation looks at the high, low, and close of the current period, and compares that to the previous period's. If it is greater, it adds volume, and if it is less, it subtracts volume. It then takes an EMA of two different lookback periods of that calculation and subtracts one from the other. That's your oscillator. There is then made a signal line of the oscillator that a trader can use, in combination with the zero line, for taking trades. Investopedia has a good article on it, so if you're looking for more specifics, check there.
What I've done is add a selection of different moving averages that you may choose for the signal line. Usually it's a 13 period EMA, and that comes default, but here you could use an ALMA or HMA, or modular filter, etc. Find something that works for your style/algorithm.
Of course there are all the usual additions of mine with the various ways of coloring the indicator and candles, adjustable Donchian Bands, and alerts. A new addition that I've just added to all my indicators (oscillators, anyway) are divergences. This is more or less just a copy and paste of the divergence indicator available in TradingView. In this case you can set it to plot divergences off either the Klinger or the signal line. Depending on which one you choose you may have to adjust pivot lookbacks, and lookback range. I've kept the settings default from the RSI TradingView version.
Average LinesAverage Lines
This script beholds several new exiting Pine stuff:
- linefill, fill of line.new
- last_bar_index, gives the bar_index of the last bar, already at the beginning of the script! (like 'timenow', but now with bar_index)
The script is about pivot points, if there is one, it draws a line from the last to every previous one, then it extends this line to the future. On every next bar, all these lines and added and averaged, this gives an average line of all extended lines which are projected in the 'future'.
In that way, we create a new kind of moving average
Do mind, since the visible lines maximum of 500 it can easily happen that an average is made of way more lines than 500, but that you cannot see all of them
Cheers!
Volume-based Support & Resistance ZonesThe new and improved Support & Resistance Zones indicator is here. This indicator is based on high volume at fractal lows or fractal highs with the zones based on the size of the wick for that timeframe’s candle.
This helps traders visualize which price levels are of the most significance for either reversals or continuation of the trend when zones are broken and then re-tested.
Original script is thanks to synapticex and additional modifications is thanks to Lij_MC. Credit to both of them for most of the logic behind this script.
Since then I have made many changes to this script as noted below:
Changed default S/R lines from plots to lines, and gave option to user to change between solid line, dashed line, or dotted line for both S/R lines.
Added additional time frame and gave more TF options for TF1 other than current TF. Now you will have 4 time frames to plot S/R zones from.
Gave user option to easily change line thickness for all S/R lines.
Made it easier to change colors of S/R lines and zones by consolidating the options under settings (rather than under style).
Added extensions to active SR Zones to extend all the way right.
Added option to extend or not extend the previous S/R zones up to next S/R zone.
Added optional time frame labels to active S/R zones, with left and right options as well as option to adjust how far to the right label is set.
Fixed issue where the higher time frame S/R zone was not properly starting from the high/low of fractal. Now any higher time frame S/R will begin exactly at the High/Low points. Note that this may not work perfectly on stocks and if a fractal high/low is too many bars in the past, it will revert to a default max bars back to avoid script errors.
Added to script a function that will prevent S/R zones from lower time frames displaying while on a higher time frame. This helps clean up the chart quite a bit.
Created arrays for each time frame's boxes and lines so that the number of S/R zones can be controlled for each time frame and limit memory consumption.
New alert options added and customized alert messages.
- The way this indicator works is it looks for fractal highs or fractal lows with volume that pierces above the volume's Moving Average. This moving average value can be modified in the settings for each time frame.
- The fractal highs will be confirmed with 3 successive higher highs followed by 2 successive lower highs and vice versa for the fractal lows.
- The zone is created from the fractal high/low and the close of the candle for whatever time frame you selected. The bigger the zone, the more significant that zone is.
- You can disable any zone, change the zones to show lines only, and modify all the colors, transparencies, and thickness of lines for all the zones.
- To create alerts, you first want to enable the types of alerts you want for each time frame in the indicator's settings. Then after you apply changes, right click on one of the zones on the chart, and click "Add Alert on Vol S/R Zones". You do not need to add a title as the correct alert messages are already built-in.
- More changes will be coming in the future!
I hope you find this indicator useful, if so please give it a thumbs up!
If you have any suggestions or features you would like to see, just let me know in the comment section. Thanks and enjoy!
Diluted Earnings Per Share Signal [AstrideUnicorn]Earnings Per Share (EPS) is a financial metric closely monitored by investors. The so-called "positive earnings surprise" - a situation when EPS reading for a stock beats the value forecasted by analysts gives a bullish signal for this stock. The EPS reading lower than the analysts' estimate gives a bearish signal.
The Diluted Earnings Per Share (Diluted EPS) metric calculates a company's potential earnings per share value in the case if all convertible securities get converted to common shares. Convertible securities include preferred shares, stock options, warrants, convertible debt, etc. Diluted EPS is a more scientific way to estimate earnings per share, and it is usually lower than the ordinary EPS.
The Diluted EPS Signal indicator (DEPSS) is a fundamental indicator that calculates trading signals by comparing the Diluted EPS to the EPS Estimate. In many cases, Diluted EPS gives better insight into how a reported EPS reading may impact the stock price.
HOW TO USE
For each earnings date, the indicator calculates the Diluted Earnings Surprise percentage value :
Diluted Earnings Surprise = (Diluted EPS - EPS Estimate)/ EPS Estimate.
Diluted Earnings Surprise higher than the specified threshold value is a bullish signal. In this case, the indicator displays a green triangle pointing up.
Diluted Earnings Surprise lower than the specified threshold value is a bearish signal displayed as a red triangle pointing down.
As one can see on the chart, there are a lot of situations where EPS readings with green labels (the ones that beat analysts' estimates) lead to down moves. The DEPSS indicator can spot weak earnings and give opposite signals.
SETTINGS
Earnings Surprise Threshold (%) : the threshold value (in percentage units) for the Diluted Earnings Surprise. The calculated Diluted Earnings Surprise must be higher than Earnings Surprise Threshold to be considered a BUY signal or lower than minus Earnings Surprise Threshold to be considered a SELL signal. The default value for Earnings Surprise Threshold is 20%.
Supertrend - Ladder ATRThis is a supertrend with slight twisted concept which can be very benefecial in strong trending markets to reduce stop loss distance and exit slightly quicker.
⬜ Concept
▶ When the instrument is trending up, regular ATR shows high values if there are big green candles. This affect the stoploss distance in regular supertrend which leads to wide stops or delayed lagging. When you are in long trade, what matters for stoploss is how much a negative candle can move within bar. Hence, using ATR derived only based on red candles is more beneficial for trailing stops on long signals. Same applies to short trades where using ATR derived from only green candles is more efficient than overall ATR.
▶ ATR will be minimal when the volatility is less and ATR will increase with volatility. That means, once you are in trade, the trailing of stoploss also will vary based on ATR (or volatility). With regular ATR and supertrend, chances of stop loss distance widening is high with increased volatility even though stoploss levels will not move down. This again poses the risk of higher drawdown during trade closure and also keeps in the trade during ranging market. To avoid this, the second trick we are using here is only to reduce the atr stoploss difference when in trade. That is, when in long trade and negative candles ATR is increasing, we will not consider that. We will consider the new ATR only if it is lesser than previous bar ATR.
Effect of these changes on the trending market is quite visual. Lets take example of USDTRY
Settings are quite simple and does not vary much from regular supertrend settings.
RedK Auto-Stepping Ladder TraderThe RedK Auto-Stepping Ladder Trader is an experimental tool to help identify trade entry and exits for various types of trades (Trend / Momentum / Breakout and Swing trades)
The underlying concept here is loosely similar to the SMAC script - in case you'd like to read some of the "script-specific" write-up . I even borrowed some of the SMAC code, but upgraded the script to Pine v5 while working. So i won't repeat write-up here on how the script works - and we'll get right into how to use in trading
How to use / trade the Ladder Trader:
-------------------------------------------------
The idea is to set the auto-stepping ladder to a higher timeframe, the "ladder view" helps simplify the price action to show a clear direction, then use the lower timeframe to find best entries (close or at the ladder line) and exits (on the ATR as TP target)
- Entries should be as close to the ladder line as possible - a trader may decide to have a small margin above or below the ladder line where they set entry limit order
- note that when stepping is enabled, the auto-stepping algo will choose the step value based on the underlying price range and the selected timeframe to move with common trader "mental values" where traders will usually gravitate
- exits can be set using the optional ATR or Pct channels - by default, there's an ATR channel (golden color) for that purpose
Possible usage scenarios of the Ladder Trader:
--------------------------------------------------------------
- Trend / long(er) term: enter position once the ladder line switches to the color corresponding to my desired direction (example: blue for long), and hold all the way until the color changes
- Swing: Take only trades in the direction of the ladder (long with blue, short with orange) - enter at the ladder line value, set TP at the desired ATR, repeat as long as the direction holds
- Feel free to experiment and share back other uses you find. There are so many settings and tweaks provided for flexibility - the downside is this adds a certain level of complexity - however, i hope this will be a valuable tool to add to your trading.
Few Notes:
-----------------------
- The Auto-stepping algo is a bit improved to be more FOREX and Crypto-friendly - i do not trade these instruments myself, but will continue to improve the auto-stepping technique in upcoming updates
- the signal line (hidden by default, and is what causes the ladder to change color) is based on my Compound Ratio Moving Average - since it's the moving average i found to provide best combination of speed and smoothness. It is used as a proxy to the price, to signal when the price is above or below the ladder level - while removing some of the whipsaws if we use the price value directly.
- Broader analysis of price action should still be made using other indicators - and possibly other chart setups - we shouldn't rely on the Ladder Trader signal only - Check for overall momentum, volume movement and market sentiment before using the Ladder Trader
- Also test your settings in PaperMoney - i noticed that different instruments may need different settings (for Ladder Type, Length, Rounding Technique, ATR multiplier..etc) for optimal setup that shows best signals.. Get very familiar with the Ladder Trader and it should hopefully become more helpful to you as a tradiing tool.
Comments and Feedback are welcome. Good luck.
Bjorgum Key Levels
Key Levels Aims to capture 3 of the most significant points in price action
Breakouts
False Breakouts (Traps)
Back Checks
These 3 points alone, if properly identified, can be some of the most significant points of movement in the price history of an asset and bring significant gains to traders, if capitalized on. Here are a few examples of these setups
Breakouts
Breakouts can bring significant rallies as the market swings one sided after key levels are breached. This entry type can bring large trending runs to follow. Momentum is on your side, but the trade off is a higher entry.
False Breakouts
Also known as a bull trap or a bear trap, false breaks can lead to swift and significant reversals and potential for a large and sudden move to the opposite side. When a key level breakout fails to hold, parties entering to capitalize on the "epic breakout" can get left holding the bag forcing them to exit at a loss, which can double the force of pressure. Traps can bring swift gains from good entry prices. However, price is still in a larger trend against you so momentum is weak, so price action is susceptible to roll over.
Backchecks
Back checks are pull backs in trend that find middle ground to the 2 areas already described. Both momentum and entry price are decent, but risk is defined as a key level has flipped offering entry with stops below demand, or above supply.
Combining these 3 methods helps to diversify risk, understand trend development, and bring steady gains. This script helps to identify these points to traders with analysis of key levels, price structure, and trend direction, while providing visual signals and alerts for when they occur.
Best of luck in your coding and trading and thank you for your support
TASC 2021.12 Directional Movement w/Hann█ OVERVIEW
Presented here is code for the "Directional Movement w/Hann" indicator originally conceived by John Ehlers. The code is also published in the December 2021 issue of Trader's Tips by Technical Analysis of Stocks & Commodities (TASC) magazine.
Ehlers continues here his exploration of the application of Hann windowing to conventional trading indicators.
█ FEATURES
The rolling length can be modified in the script's inputs, as well as the width of the line.
█ NOTES
Calculations
The calculation starts with the classic definition of PlusDM and MinusDM. These directional movements are summed in an exponential moving average (EMA). Then, this EMA is further smoothed in a finite impulse response (FIR) filter using Hann window coefficients over the calculation period.
Background
The DMI and ADX indicators were designed by J. Welles Wilder and presented in his "New Concepts in Technical Trading Systems" book published in 1978.
Join TradingView!
RKs Notepad++ Pine Script V5█ OVERVIEW
After reading all the new names and renames that Pine Script V5 brought to us, I knew that my old Notepad++ User Defined Language (UDL) would need a big update, so I decided to do a complete remake using the same Dark color scheme theme of the Pine Editor.
Then, I create a Notepad++ Theme and the Auto-Completion file with the Parameter hints for every built-in function to make everything look nicer
█ IMPORTANT
This is not an indicator!!
These are 3 XML files to copy and paste inside the Notepad++ folder.
You can use any Notepad Software to create the XML files.
The main Notepad++ folder is normally on %AppData%\Notepad++\
To avoid mistakes, always make a Backup of your files before anything.
█ INSTALLATION
Just follow these steps:
1. open a New Document File;
2. Copy everything between ↓↓↓ and ↑↑↑ symbols to this new document;
3. Remove the "//" of every single line;
4. Save each document with the correct name in the right folder;
5. Restart the Notepad++
█ NOTES:
If you have some problem installing, ask me, and I will try to help you.
But, in any case, here is the link to these files on my GitHub:
