Goethe B - Mutiple Leading Indicator PackageGoethe B is an Indicator Package that contains multiple leading and lagging indicators.
The background is that shows the local trend is calculated by either two Moving Averages or by a Kumo Cloud. By default the Kumo Cloud calculation is used.
What is the main oscillator?
- The main oscillator is TSV, or time segmented volume. It is one of the more interesting leading indicators.
What is the top bar?
-The top bar shows a trend confirmation based on the wolfpack ID indicator.
What are those circles on the second top bar?
-Those are Divergences of an internally calculated PVT oscillator. Red for Regular-Bearish, Green for Regular-Bullish.
What are those circles on the main oscillator?
-These are Divergences. Red for Regular-Bearish. Orange for Hidden-Bearish. Green for Regular-Bullish. Aqua for Hidden-Bullish.
What are those circles on the second lower bar?
-Those are Divergences of an internally calculated CCI indicator. Red for Regular-Bearish, Green for Regular-Bullish.
What is the lower bar?
-The lower bar shows a trend confirmation based on the Acceleration Oscillator, in best case it showes how far in the trend the current price action is.
What are those orange or aqua squares?
- These are TSI (true strength indicator) entry signals . They are calculated by the TSI entry signal, the TSI oscillator threshold.
Most settings of the indicator package can be modified to your liking and based on your chosen strategy might have to be modified. Please keep in mind that this indicator is a tool and not a strategy, do not blindly trade signals, do your own research first! Use this indicator in conjunction with other indicators to get multiple confirmations.
"top" için komut dosyalarını ara
Logger Library For Pinescript (Logging and Debugging)Library "LoggerLib"
This is a logging library for Pinescript. It is aimed to help developers testing and debugging scripts with a simple to use logger function.
Pinescript lacks a native logging implementation. This library would be helpful to mitigate this insufficiency.
This library uses table to print outputs into its view. It is simple, customizable and robust.
You can start using it's .log() method just like any other logging method in other languages.
//////////////////
USAGE
//////////////////
-- Recommended: Please Read The Documentation From Source Code Below. It Is Much More Readable There And Will Be Updated Along With Newer Versions. --
Importing the Library
---------------------
import paragjyoti2012/LoggerLib/ as Logger
.init() : Initializes the library and returns the logger pointer. (Later will be used as a function parameter)
.initTable: Initializes the Table View for the Logger and returns the table id. (Later will be used as a function parameter)
parameters:
logger: The logger pointer got from .init()
max_rows_count: Number of Rows to display in the Logger Table (default is 10)
offset: The offset value for the rows (Used for scrolling the view)
position: Position of the Table View
Values could be:
left
right
top-right
(default is left)
size: Font Size of content
Values could be:
small
normal
large
(default is small)
hide_date: Whether to hide the Date/Time column in the Logger (default is false)
returns: Table
example usage of .initTable()
import paragjyoti2012/LoggerLib/1 as Logger
var logger=Logger.init()
var logTable=Logger.initTable(logger, max_rows_count=20, offset=0, position="top-right")
-------------------
LOGGING
-------------------
.log() : Logging Method
params: (string message, |string| logger, table table_id, string type="message")
logger: pass the logger pointer from .init()
table_id: pass the table pointer from .initTable()
message: The message to log
type: Type of the log message
Values could be:
message
warning
error
info
success
(default is message)
returns: void
///////////////////////////////////////
Full Boilerplate For Using In Indicator
///////////////////////////////////////
P.S: Change the | (pipe) character into square brackets while using in script (or copy it from the source code instead)
offset=input.int(0,"Offset",minval=0)
size=input.string("small","Font Size",options=|"normal","small","large"|)
rows=input.int(15,"No Of Rows")
position=input.string("left","Position",options=|"left","right","top-right"|)
hide_date=input.bool(false,"Hide Time")
import paragjyoti2012/LoggerLib/1 as Logger
var logger=Logger.init()
var logTable=Logger.initTable(logger,rows,offset,position,size,hide_date)
rsi=ta.rsi(close,14)
|macd,signal,hist|=ta.macd(close,12,26,9)
if(ta.crossunder(close,34000))
Logger.log("Dropped Below 34000",logger,logTable,"warning")
if(ta.crossunder(close,35000))
Logger.log("Dropped Below 35000",logger,logTable)
if(ta.crossover(close,38000))
Logger.log("Crossed 38000",logger,logTable,"info")
if(ta.crossunder(rsi,20))
Logger.log("RSI Below 20",logger,logTable,"error")
if(ta.crossover(macd,signal))
Logger.log("Macd Crossed Over Signal",logger,logTable)
if(ta.crossover(rsi,80))
Logger.log("RSI Above 80",logger,logTable,"success")
////////////////////////////
// For Scrolling the Table View
////////////////////////////
There is a subtle way of achieving nice scrolling behaviour for the Table view. Open the input properties panel for the table/indicator. Focus on the input field for "Offset", once it's focused, you could use your mouse scroll wheel to increment/decrement the offset values; It will smoothly scroll the Logger Table Rows as well.
/////////////////////
For any assistance using this library or reporting issues, please write in the comment section below.
I will try my best to guide you and update the library. Thanks :)
/////////////////////
[blackcat] L2 Reversal LabelsLevel: 2
Background
There is a Chinese proverb that says: "The great way leads to simplicity". This indicator is the representative of this meaning. Through the processing of the most common MACD indicator data, it is possible to quickly determine the market price: whether the current price is at a historical high or low, whether a reversal will happen soon, etc. at a glance.
Function
This indicator performs screening and filtering through the fast and slow line data corresponding to the output of the standard MACD indicator, so as to realize the function of judging the top and bottom of the trend.
Inputs
N/A
Key Signal
Near Top --> Top is reached and reversal may happen soon. (red labels)
Near Bottom --> Bottom is reached and reversal may happen soon. (green labels)
Remarks
This is a Level 2 free and open source indicator.
Feedbacks are appreciated.
Vertical LinesThis script plots vertical lines on charts or indicators. Unfortunately pinescript is lacking a vertical line plotting function. Vertical lines are useful to mark events, such as crossover of levels, indicators signals or as a time marker.
After searching the internet for a long time and trying different scripts, this script is the simplest and visually the best. You would think that plotting a vertical line would be relatively easy, it is not! I thank the unknow author for sharing this solution and now I will share it on tradingview to make it readily available to anybody that needs it.
RSI crossover signals are used as an example in this script. When the RSI crosses over 70 or below 30, the script plots a red or green vertical line.
The script plots a vertical line as a histogram bar. The histogram bar must have a height.
Setting the height near infinity like 1e20 will cover all the ranges from top to bottom in most charts, but doesn't work all the time. If the chart range is small in values, the line is not plotted or the chart is visually compressed because the top of the bar is also a data point in the chart. Another solution is to find the highest point in the chart and multiply it by a number from 2 to 10 to set the top of the histogram bar. But this solution doesn't work if the line is drawn in the indicator window. additionally if the chart or indicator includes negative values, a histogram bar with a negative height must be concatenated to the histogram bar with a positive height to cover the positive and negative range.
It would seem intuitive to include a vertical plot function since it is very useful and pinescript already has a horizontal line plot function called Hline. But pinescript is becoming less intuitive, and redundant. A case in point is Version 4 variable declaration and naming, it less intuitive and more redundant than previous versions. I beg Tradingview to adopt a more refined scripting language such as Matlab or Python for charting purposes. These languages can be easily ported to other analysis programs for AI or statistical analysis.
Wick Bodies [vnhilton]I noticed that changing the colour of the wicks through TradingView settings changes the colours of both the top and bottom wicks. I also noticed that the thickness of wicks couldn't be changed either so they remained very hard to see when zoomed out of charts. Wicks have the potential to show zones where price rejects from - this is useful for identifying potential support and resistance zones.
I created an alternative solution to this problem by creating bodies for the wicks. It's recommended that you hide the wicks so it shows candles as bars split into 3 segments (top segment representing top wick; middle segment representing candle; bottom segment representing bottom wick). Colours are customizable. Also includes borders for the wick bodies.
LeoLibraryLibrary "LeoLibrary"
A collection of custom tools & utility functions commonly used with my scripts
getDecimals() Calculates how many decimals are on the quote price of the current market
Returns: The current decimal places on the market quote price
truncate(float, float) Truncates (cuts) excess decimal places
Parameters:
float : _number The number to truncate
float : _decimalPlaces (default=2) The number of decimal places to truncate to
Returns: The given _number truncated to the given _decimalPlaces
toWhole(float) Converts pips into whole numbers
Parameters:
float : _number The pip number to convert into a whole number
Returns: The converted number
toPips(float) Converts whole numbers back into pips
Parameters:
float : _number The whole number to convert into pips
Returns: The converted number
av_getPositionSize(float, float, float, float) Calculates OANDA forex position size for AutoView based on the given parameters
Parameters:
float : _balance The account balance to use
float : _risk The risk percentage amount (as a whole number - eg. 1 = 1% risk)
float : _stopPoints The stop loss distance in POINTS (not pips)
float : _conversionRate The conversion rate of our account balance currency
Returns: The calculated position size (in units - only compatible with OANDA)
getMA(int, string) Gets a Moving Average based on type
Parameters:
int : _length The MA period
string : _maType The type of MA
Returns: A moving average with the given parameters
getEAP(float) Performs EAP stop loss size calculation (eg. ATR >= 20.0 and ATR < 30, returns 20)
Parameters:
float : _atr The given ATR to base the EAP SL calculation on
Returns: The EAP SL converted ATR size
barsAboveMA(int, float) Counts how many candles are above the MA
Parameters:
int : _lookback The lookback period to look back over
float : _ma The moving average to check
Returns: The bar count of how many recent bars are above the MA
barsBelowMA(int, float) Counts how many candles are below the MA
Parameters:
int : _lookback The lookback period to look back over
float : _ma The moving average to reference
Returns: The bar count of how many recent bars are below the EMA
barsCrossedMA(int, float) Counts how many times the EMA was crossed recently
Parameters:
int : _lookback The lookback period to look back over
float : _ma The moving average to reference
Returns: The bar count of how many times price recently crossed the EMA
getPullbackBarCount(int, int) Counts how many green & red bars have printed recently (ie. pullback count)
Parameters:
int : _lookback The lookback period to look back over
int : _direction The color of the bar to count (1 = Green, -1 = Red)
Returns: The bar count of how many candles have retraced over the given lookback & direction
getBodySize() Gets the current candle's body size (in POINTS, divide by 10 to get pips)
Returns: The current candle's body size in POINTS
getTopWickSize() Gets the current candle's top wick size (in POINTS, divide by 10 to get pips)
Returns: The current candle's top wick size in POINTS
getBottomWickSize() Gets the current candle's bottom wick size (in POINTS, divide by 10 to get pips)
Returns: The current candle's bottom wick size in POINTS
getBodyPercent() Gets the current candle's body size as a percentage of its entire size including its wicks
Returns: The current candle's body size percentage
isHammer(float, bool) Checks if the current bar is a hammer candle based on the given parameters
Parameters:
float : _fib (default=0.382) The fib to base candle body on
bool : _colorMatch (default=false) Does the candle need to be green? (true/false)
Returns: A boolean - true if the current bar matches the requirements of a hammer candle
isStar(float, bool) Checks if the current bar is a shooting star candle based on the given parameters
Parameters:
float : _fib (default=0.382) The fib to base candle body on
bool : _colorMatch (default=false) Does the candle need to be red? (true/false)
Returns: A boolean - true if the current bar matches the requirements of a shooting star candle
isDoji(float, bool) Checks if the current bar is a doji candle based on the given parameters
Parameters:
float : _wickSize (default=2) The maximum top wick size compared to the bottom (and vice versa)
bool : _bodySize (default=0.05) The maximum body size as a percentage compared to the entire candle size
Returns: A boolean - true if the current bar matches the requirements of a doji candle
isBullishEC(float, float, bool) Checks if the current bar is a bullish engulfing candle
Parameters:
float : _allowance (default=0) How many POINTS to allow the open to be off by (useful for markets with micro gaps)
float : _rejectionWickSize (default=disabled) The maximum rejection wick size compared to the body as a percentage
bool : _engulfWick (default=false) Does the engulfing candle require the wick to be engulfed as well?
Returns: A boolean - true if the current bar matches the requirements of a bullish engulfing candle
isBearishEC(float, float, bool) Checks if the current bar is a bearish engulfing candle
Parameters:
float : _allowance (default=0) How many POINTS to allow the open to be off by (useful for markets with micro gaps)
float : _rejectionWickSize (default=disabled) The maximum rejection wick size compared to the body as a percentage
bool : _engulfWick (default=false) Does the engulfing candle require the wick to be engulfed as well?
Returns: A boolean - true if the current bar matches the requirements of a bearish engulfing candle
timeFilter(string, bool) Determines if the current price bar falls inside the specified session
Parameters:
string : _sess The session to check
bool : _useFilter (default=false) Whether or not to actually use this filter
Returns: A boolean - true if the current bar falls within the given time session
dateFilter(int, int) Determines if this bar's time falls within date filter range
Parameters:
int : _startTime The UNIX date timestamp to begin searching from
int : _endTime the UNIX date timestamp to stop searching from
Returns: A boolean - true if the current bar falls within the given dates
dayFilter(bool, bool, bool, bool, bool, bool, bool) Checks if the current bar's day is in the list of given days to analyze
Parameters:
bool : _monday Should the script analyze this day? (true/false)
bool : _tuesday Should the script analyze this day? (true/false)
bool : _wednesday Should the script analyze this day? (true/false)
bool : _thursday Should the script analyze this day? (true/false)
bool : _friday Should the script analyze this day? (true/false)
bool : _saturday Should the script analyze this day? (true/false)
bool : _sunday Should the script analyze this day? (true/false)
Returns: A boolean - true if the current bar's day is one of the given days
atrFilter(float, float) Checks the current bar's size against the given ATR and max size
Parameters:
float : _atr (default=ATR 14 period) The given ATR to check
float : _maxSize The maximum ATR multiplier of the current candle
Returns: A boolean - true if the current bar's size is less than or equal to _atr x _maxSize
fillCell(table, int, int, string, string, color, color) This updates the given table's cell with the given values
Parameters:
table : _table The table ID to update
int : _column The column to update
int : _row The row to update
string : _title The title of this cell
string : _value The value of this cell
color : _bgcolor The background color of this cell
color : _txtcolor The text color of this cell
Returns: A boolean - true if the current bar falls within the given dates
FARAZ.MATI20vA personal indicator.
This indicator has the following features :
Thanks to the managers and administrators of TradingView site for the appropriate space with wide facilities for optimal use. All (indicators) were available on the site and I only defined certain settings for them.
FARAZ.MATI20v
EMA: 5
SMA : 20
SMA : 50
Collision and interruption of Moving 20 by Moving 5 can be the beginning of an upward trend. Provided that the Moving 5 is placed under the candles. (The best signal for the Moving 5 is to collide with the Moving 20 under the candles). Also, the collision of the Moing 5 with the Moing 20 on top of the candles can be a sign of falling. Especially if this collision occurs above the candles.The cut of the Moving 20 and the Moving 50 indicate the intensity of the wave. If Moving 20 is above Moving 50 in this collision, it shows the intensity of the uptrend and if it is below Moving 50, it shows the intensity of the downtrend.
SMA : 100
SMA : 200
Both (resistance and support) are very strong, which is very effective in larger timeframes (such as 1 day).
HMA : 20
To determine the entry point. In such a way that whenever the seeds (HMA) are below the candlesticks. 3 seeds are in ascending position. The body of the candle and the shadow should not touch them. It can be a good signal to enter. Also if the seeds are placed on top of the candlesticks. Show the descending direction of 3 seeds. Provided that the body of the candle and the shadow have not hit them. It is a signal for the short position.
SAR : With the applied settings, it is a kind (trending view) that can evaluate the volume of input to any currency much sooner and determine the probability of rising or falling. If our wave lines (stairs) are at the bottom of the candles, it means an upward trend, and if they are at the top of the candles, it means a downward trend. As the volume of inputs increases, the trend increases, and as the volume of inputs decreases, the trend will also decrease.
Ichimoku Cloud : To determine the lines (support and resistance) the peaks formed by the cloud can represent a resistance area. Price To cross the area marked by the Ichimoku cloud must have a strong candle. This can be very effective in determining the point of entry and purchase.
zig zag : For better diagnosis of the process. Using it to determine areas of support and resistance can be useful. Determining the points of the Fibonacci table is also very effective.
ZenLibraryLibrary "ZenLibrary"
A collection of custom tools & utility functions commonly used with my scripts.
getDecimals() Calculates how many decimals are on the quote price of the current market
Returns: The current decimal places on the market quote price
truncate(float, float) Truncates (cuts) excess decimal places
Parameters:
float : _number The number to truncate
float : _decimalPlaces (default=2) The number of decimal places to truncate to
Returns: The given _number truncated to the given _decimalPlaces
toWhole(float) Converts pips into whole numbers
Parameters:
float : _number The pip number to convert into a whole number
Returns: The converted number
toPips(float) Converts whole numbers back into pips
Parameters:
float : _number The whole number to convert into pips
Returns: The converted number
av_getPositionSize(float, float, float, float) Calculates OANDA forex position size for AutoView based on the given parameters
Parameters:
float : _balance The account balance to use
float : _risk The risk percentage amount (as a whole number - eg. 1 = 1% risk)
float : _stopPoints The stop loss distance in POINTS (not pips)
float : _conversionRate The conversion rate of our account balance currency
Returns: The calculated position size (in units - only compatible with OANDA)
getMA(int, string) Gets a Moving Average based on type
Parameters:
int : _length The MA period
string : _maType The type of MA
Returns: A moving average with the given parameters
getEAP(float) Performs EAP stop loss size calculation (eg. ATR >= 20.0 and ATR < 30, returns 20)
Parameters:
float : _atr The given ATR to base the EAP SL calculation on
Returns: The EAP SL converted ATR size
barsAboveMA(int, float) Counts how many candles are above the MA
Parameters:
int : _lookback The lookback period to look back over
float : _ma The moving average to check
Returns: The bar count of how many recent bars are above the MA
barsBelowMA(int, float) Counts how many candles are below the MA
Parameters:
int : _lookback The lookback period to look back over
float : _ma The moving average to reference
Returns: The bar count of how many recent bars are below the EMA
barsCrossedMA(int, float) Counts how many times the EMA was crossed recently
Parameters:
int : _lookback The lookback period to look back over
float : _ma The moving average to reference
Returns: The bar count of how many times price recently crossed the EMA
getPullbackBarCount(int, int) Counts how many green & red bars have printed recently (ie. pullback count)
Parameters:
int : _lookback The lookback period to look back over
int : _direction The color of the bar to count (1 = Green, -1 = Red)
Returns: The bar count of how many candles have retraced over the given lookback & direction
getBodySize() Gets the current candle's body size (in POINTS, divide by 10 to get pips)
Returns: The current candle's body size in POINTS
getTopWickSize() Gets the current candle's top wick size (in POINTS, divide by 10 to get pips)
Returns: The current candle's top wick size in POINTS
getBottomWickSize() Gets the current candle's bottom wick size (in POINTS, divide by 10 to get pips)
Returns: The current candle's bottom wick size in POINTS
getBodyPercent() Gets the current candle's body size as a percentage of its entire size including its wicks
Returns: The current candle's body size percentage
isHammer(float, bool) Checks if the current bar is a hammer candle based on the given parameters
Parameters:
float : _fib (default=0.382) The fib to base candle body on
bool : _colorMatch (default=false) Does the candle need to be green? (true/false)
Returns: A boolean - true if the current bar matches the requirements of a hammer candle
isStar(float, bool) Checks if the current bar is a shooting star candle based on the given parameters
Parameters:
float : _fib (default=0.382) The fib to base candle body on
bool : _colorMatch (default=false) Does the candle need to be red? (true/false)
Returns: A boolean - true if the current bar matches the requirements of a shooting star candle
isDoji(float, bool) Checks if the current bar is a doji candle based on the given parameters
Parameters:
float : _wickSize (default=2) The maximum top wick size compared to the bottom (and vice versa)
bool : _bodySize (default=0.05) The maximum body size as a percentage compared to the entire candle size
Returns: A boolean - true if the current bar matches the requirements of a doji candle
isBullishEC(float, float, bool) Checks if the current bar is a bullish engulfing candle
Parameters:
float : _allowance (default=0) How many POINTS to allow the open to be off by (useful for markets with micro gaps)
float : _rejectionWickSize (default=disabled) The maximum rejection wick size compared to the body as a percentage
bool : _engulfWick (default=false) Does the engulfing candle require the wick to be engulfed as well?
Returns: A boolean - true if the current bar matches the requirements of a bullish engulfing candle
isBearishEC(float, float, bool) Checks if the current bar is a bearish engulfing candle
Parameters:
float : _allowance (default=0) How many POINTS to allow the open to be off by (useful for markets with micro gaps)
float : _rejectionWickSize (default=disabled) The maximum rejection wick size compared to the body as a percentage
bool : _engulfWick (default=false) Does the engulfing candle require the wick to be engulfed as well?
Returns: A boolean - true if the current bar matches the requirements of a bearish engulfing candle
timeFilter(string, bool) Determines if the current price bar falls inside the specified session
Parameters:
string : _sess The session to check
bool : _useFilter (default=false) Whether or not to actually use this filter
Returns: A boolean - true if the current bar falls within the given time session
dateFilter(int, int) Determines if this bar's time falls within date filter range
Parameters:
int : _startTime The UNIX date timestamp to begin searching from
int : _endTime the UNIX date timestamp to stop searching from
Returns: A boolean - true if the current bar falls within the given dates
dayFilter(bool, bool, bool, bool, bool, bool, bool) Checks if the current bar's day is in the list of given days to analyze
Parameters:
bool : _monday Should the script analyze this day? (true/false)
bool : _tuesday Should the script analyze this day? (true/false)
bool : _wednesday Should the script analyze this day? (true/false)
bool : _thursday Should the script analyze this day? (true/false)
bool : _friday Should the script analyze this day? (true/false)
bool : _saturday Should the script analyze this day? (true/false)
bool : _sunday Should the script analyze this day? (true/false)
Returns: A boolean - true if the current bar's day is one of the given days
atrFilter(float, float) Checks the current bar's size against the given ATR and max size
Parameters:
float : _atr (default=ATR 14 period) The given ATR to check
float : _maxSize The maximum ATR multiplier of the current candle
Returns: A boolean - true if the current bar's size is less than or equal to _atr x _maxSize
fillCell(table, int, int, string, string, color, color) This updates the given table's cell with the given values
Parameters:
table : _table The table ID to update
int : _column The column to update
int : _row The row to update
string : _title The title of this cell
string : _value The value of this cell
color : _bgcolor The background color of this cell
color : _txtcolor The text color of this cell
Returns: A boolean - true if the current bar falls within the given dates
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
+ ATR Support and ResistanceThis, a very different script from most of mine, is my attempt at making a useful, and not messy, support and resistance indicator. If you've never looked into trader xkavalis, and his scripts and discord, I would highly recommend it. He talks about "pay attention candles" a lot. It got me thinking about what those are. Best as I can tell all he means by that phrase is large, impulsive candles. Sometimes these lead to break outs of ranges, or they may signal tops, bottoms, or near-tops and bottoms. The only way I could make sense of this in a mathematical way was by using the average true range. Basically, any candle's true range outside of the ATR is considered a "pay attention candle," by my definition.
This script originally began as just a candle coloring exercise with some optional shapes plotted above/below certain candles, but I quickly realized I wanted to draw lines or zones from these candles, so eventually, after many hours spent figuring out and learning 'line.new' and 'box.new' I got things sorted.
Essentially, my line of thinking is that on impulsive candles down, the origin of the impulse is more important than the close (not always of course, as there are no unbreakable rules in what markets can do), and with impulsive candles up, the same theory applies.
So, for upward impulsive candles I've marked out the zone from the open to the low as a support (until broken, in which case it may become resistance). For downward impulsive candles the zone encompasses the open to the high. I've given the option to plot a line from the close for all of these. It's turned off by default as it's just less stuff on the chart, but you may like it.
The line length is customizable in a menu. It does funny things on low timeframes on forex and stock charts (long lines that result in chart compression), but for some reason very rarely on crypto charts. If someone who is smart (not me) and has much experience with pinescript could perhaps help me out with a fix for this, that would be great. I suspect it has something to do with my "bar_index_duration" that I defined using the time function, but I'm not sure how or why.
Line length on time frames of one hour and up it is typically fine.
Use the ATR multiple to change the sensitivity of the indicator. This is basically the determination of when a candle is beyond the ATR. A multiple of two is two times the ATR. With lower volatile pairs you can maybe make this lower. On lower time frames or with more volatile pairs (illiquid alts in particular) a higher multiple might serve better. I find the default 1.75 is mostly acceptable.
As I started this I also thought adding some sort of volume information to the candles might be useful as well, so I added a simple candle coloring feature referencing the OBV and a 21 period EMA. Candles are colored based on the OBV's relation to its moving average.
I added some plot shapes and candle coloring utilizing the RSI as well. Options to turn on or off shapes plotted for overbought and oversold across the top of the chart. The most interesting feature that I implemented here is a support/resistance zone around the centerline of the RSI. If the RSI is between 49 and 51 then you can have optional candle coloring, shapes plotted above the candles, and s/r zones drawn on the chart. In trending markets the centerline of the RSI will frequetly act as support or resistance, so by being alerted of this condition on the chart you can use that with actual levels marked off in order to help make a judgement on a trade. I think it's a nice addition, and an oft overlooked aspect of the usefulness of the RSI.
I've also included a calculation, with candle coloring and/or plot shapes, for something like a stop run on high volume. The calculation for that is in its section below, and should be pretty self explanatory.
Lastly, typing this as I'm posting it, this indicator could also be useful for helping to find placement for trailing a stop. Just a thought!
Bollinger Bands + Moving Average (BBMA Oma Ally)Found this strategy in babypips forums.babypips.com
This strategy using BB and MA
BBMA Oma Ally Trading Technique
I’m just sharing this Forex Technique that helping me making positive result.
In BBMA, BB (Bollinger Bands) act as Dynamic Support and Resistance.
SETTING OF BBMA - BOLLINGER BANDS
Period : 20
Deviations : 2
Shift : 0
Apply to : Close
Style : Dodge Blue
MA (Moving Average) are used to detect potential entry point.
SETTING OF BBMA - MOVING AVERAGE
Ma5 Hi
Period : 5
Ma Method : Linear Weighted
Apply to : High
Style : Red
Ma10 Hi
Period : 10
Ma Method : Linear Weighted
Apply to : High
Style : Yellow
Ma5 Low
Period : 5
Ma Method : Linear Weighted
Apply to : Low
Style : Magenta
Ma10 Low
Period : 10
Ma Method : Linear Weighted
Apply to : Low
Style : White
Ma50
Period : 50
Ma Method : Exponential
Apply to : Close
Style : Lime
.
EXTREM (SIGNAL)
Extrem is an early signal to say the Market journey is beginning to end - but not yet confirmed
Will only confirm when there is a reversal candle.
Extrem is not valid when there is a CS momentum, although Ma outside BB.
CHARACTERISTICS OF EXTREM
Ma out of Top / Low BB (will not valid if there is cs momentum, although Ma is outside BB)
Reverse candle must exist, as it indicates the journey of a Market is ending (not necessarily 1 or 2 cs)
Retest candle (entry point)
Entry at Highest or Lowest volume
Entry retest candle at Ma5 or body candle
MHV (LOSS VOLUME MARKET) (SETUP)
It is a setup for the beginning of long distance Market journey
This setup gives a validation for the Extrem signal earlier
It is to show the loss of strength for the market.
MHV is valid once CSA (direction candle) appear
***If the candle close NOT above or below Top / Low BB after the first Reentry, after MHV there is a directional candlestick, then there will be a reentry and after the reentry there is no momentum “COMPULSORY TP”
CHARACTERISTICS OF MHV :
Candle CANNOT close above or below Top / Low BB
Must have reverse candle, because reverse candle is confirming the end of the journey (Marking at candle body)
Retest candle (entry point) at Ma5 or highest volume / lowest at that current time
Must happen after Extrem
TYPES OF MHV
5 types but i can only post 1 photo. So sorry i cant give more on this.
RE-ENTRY
CHARACTERISTICS OF REENTRY
Candle close can not pass Ma5 / Ma10
It will be strong when the candle close does not pass Ma5 / Ma10 and also Mid BB
Candle close did not come in. He found Ma5 / Ma10 and mid BB at that Time would make the re-entry stronger
If there is a re-entry in Ma5 / Ma10 and mid BB, the minimum of 3 drops of candles or increments (follow TF) re-entry will be strong
Following market trend, then just search for re-entry and entry
Wait for the second candle, because the first candle validates the reentry and the second candle is for entry
BankNifty Multi-TimeFrames Price Panel [MaestroTrader]█ OVERVIEW
Price Panel provides Nifty /BankNifty Index comprehensive Price Insights on different time intervals. It helps to determine the trend of Index using top Index Heavy Weights along with Dow, India VIX & Index Spot Prices. It helps to determine the price behavior of the underlying Index/stock to make informed decisions while trading.
█ FEATURES
a) Displays Price in Multi Time Frames for Multi time frame analysis
b) Displays Weighted Securities price for Weighted INDEX price analysis.
c) Displays INDIA VIX and DOW for Combined INDIX VOLATALITY Analysis
█ MUTLI TIME FRAME ANALYSIS
How to use Multiple time frame analysis?
Multiple time frame analysis follows a top-down approach when trading and allows traders to gauge the longer-term trend while spotting ideal entries on a smaller time frame. Traders can then conduct technical analysis using multiple time frames to confirm or reject their trading bias.
Multiple time frame analysis, is the process of viewing the same symbols under different time frames. Usually, the larger time frame is used to establish a longer-term trend, while a shorter time frame is used to spot ideal entries into the market.
Let’s Say 75 & 15 TF’s Trend is up, then shorter time 5M is used to spot ideal entries on long side.
█ WEIGHTED INDEXS PRICE ANALYSIS
How to use Weighted Index Price Movement in Multi timeframes?
The index future trading price is based on the trading prices of the individual securities (stocks) that comprise the index basket. In other words, the stocks with higher weights will have more impact on the movement of the index. Price Panel provides the insights of these heavy weight stock price movement in different time frames, that can help you confirm or reject your trading bias.
HDFC Bank (28% Weight) will have more impact on the BankNifty Movement. By looking the top 4 bank's price movement in different timeframes, you can derive the BankNifty price trend.
█ VOLATALITY ANALYSIS
India VIX is a short form for India Volatility Index. It is the volatility index that measures the market’s expectation of volatility over the near term.
A lower VIX level usually implies that the market is confident about the movement and is expecting lower volatility and a stable range.
A higher VIX level usually signals high volatility and lower trader confidence about the current range of the market. A major directional move can be expected in the market and a quick broadening of range can be expected.
█ SETTINGS
• Time Frame Settings: Configure Time Frames 5 Min, 15 Min, 75 Min
• Table Settings: Configure Table Styles- Position- Font Color
• Symbol Settings: Configure Securities. Toggle (on/Off) Securities display.
• Index Settings: Display Bank Nifty or Nifty Heavy Weights.
█ PANEL DISPLAY VARIATIONS
BANK NIFTY VIEW
NIFTY VIEW
WITHOUT STOCKS - ONLY INDEX, VIX, DOW
█ THANKS
Thanks to Pine Team for this new great feature tables & Thanks to PineCoders for the `f_strRightOf` function.
█ DISCLIAMER
Indicator is built for educational purposes. Test it before use.
Hope - These features help you get quick insights of the price movement to take informed trades.
You are free to use the code, please share the credit for reuse.
Happy Trading !!
{Gunzo} Vertical Horizontal Filter (Trading ranges)Vertical Horizontal Filter indicator is a tool that can be used to identify market conditions (ranging or trending). It measures if the price is going vertical (uni-directional) or horizontal (non-directional).
OVERVIEW :
The Vertical Horizontal Filter is a technical analysis indicator created by Adam White in 1991. He described it in the “Issues of Futures” magazine for the first time. The indicator is only composed of one line that measures the level of trend activity.
If the VHF line is increasing, we consider that the trend is getting stronger (up-trend or down-trend). Otherwise, if the VHF line is decreasing, we consider that the trend is weakening (going sideways or even ranging) as the market is getting calmer
CALCULATION :
The level of trend activity is calculated as the ratio between the distance from the highest to the lowest value (on the last N days) and the movement of the closing price.
VHF = ( highest (high) – lowest (low) ) / sum( close – previous close)
SETTINGS :
VHF length : Length of the vertical horizontal filter (28 or 18 recommended)
VHF source : Source of the vertical horizontal filter (close recommended)
VHF smoothing length : Extra smoothing applied on the VHF line to filter noise (1 or 6 or 9 or 14 recommended)
Display ranging market rectangles : Display rectangles on the chart around the area where VHF is decreasing (ranging market)
Display trending market rectangles : Display rectangles on the chart around the area where VHF is increasing (trending market up or down)
Minimum rectangle size : Hide rectangles that are smaller than X candles
Display signal line : Display circles at the bottom of the chart with the raw VHF direction (green if increasing /red if decreasing)
Display VHF tops and bottoms : Display triangles if the VHF line is reaching a new high or new low over the last 100 candles. When consecutive triangles appear, it may be a sign that the current market conditions are ending. Green triangles mean the possible end of the ranging market and red triangles mean the possible end of the trending market.
VISUALIZATIONS :
This indicator has 3 possible visualizations :
Rectangles : the rectangles are drawn on areas where the VHF is decreasing (red) or increasing (green) for a minimum number of consecutive candles. The first candles of an area may not be representative of the market conditions as the VHF line is still in extreme values but going slowly in the opposite direction. The market conditions (ranging or trending) get stronger with the VHF line keeping the same direction.
Signal line : The signal line is the VHF raw data : the red circle is a decreasing VHF line, and the green circle is an increasing VHF line.
Tops and bottoms : The tops and bottoms are signals indicating that the VHF line is reaching extreme values, there is a high probability that the market conditions are going to change after that.
USAGE :
This indicator can be used as a filter for strategies based on other technical analysis indicators.
If you are using trending indicators like moving averages, you should consider using them only when the market is trending. You can use VHF increasing to confirm that the market is not ranging.
If you are using oscillating indicators like stochastic or commodity channel index, you may prefer using them when the market is ranging as trending indicators may not be useful. You can use the VHF decreasing to confirm that the market is ranging.
Alt Golden Ratio by USCG_VetPine Script math based on the medium article by Philip Swift.
Idea based from Willy Woo Charts.
Disclaimer: None of this Pine Script, Title, nor Description should be used for Financial Advice. For Education Purposes Only.
Purpose: Identify a Golden Ratio Cross of the 350 Daily MA vs the 111 Daily MA with Multiplier to theorize where local valuation tops or bottoms could be approximated. NOT FINANCIAL ADVICE!
Parameters:
DMA A: short Daily Moving Average
DMA B: long Daily Moving Average
Golden Ratio: point where short Daily Moving Average crosses value assigned in parameter.
Indicators:
S2: Cross of DMA A vs DMA B in upward direction (approximate local top)
Sn: additional approximate top indicators
Sell1: first approximate local bottom
Selln: additional approximate local bottom indicators
GR: Golden-Ratio Cross of DMA A
Box Trade with RenatoTrade with Renato contains 3 tackled, Ichimoku Cloud, Various Moving Averages and Bollinger Bands.
This strategy is simple and effective, always looking for clearer entry signals to trade.
Description:
Long
Conversion Line crossing Ichimoku Baseline from bottom to top, Start at candlestick low after crossing!
Conversion Line Crossing Bollinger Band Base, End!
STOP on the Bottom Line of the Band.
Short
Conversion Line crossing Ichimoku Baseline from top to bottom, Start at candlestick low after crossing!
Conversion Line Crossing Bollinger Band Base, End!
STOP at the Top Line of the Band.
Settings:
You can edit as colors in the indicator settings and select the media you want to use.
Also the possibility to activate in settings such as Bollinger bands.
There is also the possibility to edit as medium media.
You can also disable or enable Ichimoku Cloud
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Trade with Renato contém 3 estratégias, Nuvem de Ichimoku, Diversas Médias Móveis e Bandas de Bollinger.
Essa estratégia é simples e eficaz, procurando sempre sinais de entradas mais claros para o trade.
Descrição:
Long
Conversion Line cruzando a Base Line Ichimoku de baixo para cima, Início na minima do candle após cruzamento!
Conversion Line cruzando a Base da Banda de Bollinger, Fim!
STOP na Linha Inferior da Banda.
Short
Conversion Line cruzando a Base Line Ichimoku de cima para baixo, Início na minima do candle após cruzamento!
Conversion Line cruzando a Base da Banda de Bollinger, Fim!
STOP Na Linha Superior da Banda.
Configuração:
Você pode editar as cores nas configurações do indicador e selecione as medias que deseja usar.
Também a possibilidade de ativar nas configurações, as Bandas de bollinger .
Há também a possibilidade de editar as médias moveís.
Você também pode desativar ou ativar a Nuvem de Ichimoku
{Gunzo} Bulls Power vs. Bears PowerBulls Power vs. Bears Power is a unique tool that displays on each candle the balance between the bears (sellers) and the bulls (buyers).
OVERWIEW :
This indicator is mainly based on the popular indicator “Elder ray” made by Dr. Alexander Elder in 1989. This indicator has been developed in order to determine the strength of the competing groups of buyers and sellers in the markets.
CALCULATION :
To measure the competing power of bulls and bears, the indicator compares the current high (maximum power of the bulls) and current low (maximum power of the bears) to the average price using a exponential moving average.
Bull Power = Current High – EMA 13 (closing)
Bear Power = Current Low – EMA 13 (closing)
This Elder ray indicator can also tell us more information about market conditions :
If the current high and current low are above the EMA 13, the bulls are totally in control on the market
If the current high and current low are under the EMA 13, the bears are totally in control of the market
If the EMA 13 is in between of the current high and current low, there is strong fight about controlling the market, there is possible reversal in this configuration
SETTINGS :
Fast MA Period : Fast moving average period (only used for buy sell signal)
Slow MA Period : Slow moving average period (only used for buy sell signal)
Display candle labels : Show/hide candle labels on the chart
Display only bear labels above X : Exclude all top candle labels on the chart below the value specified.
Display only bull labels above X : Exclude all bottom candle labels on the chart below the value specified.
Display opposite values : Show all candle labels on top (bearish) and bottom (bullish) or only show the candle labels for the winning force on the candle.
Display box for last candle : Show/hide the dominance boxes (red and blue) after last candle showing the last bear and bull power.
Display box after X candles : How many candles in the future the dominance boxes should be displayed.
Display slow / fast crossover (o) : Display crossover signals (circles) between fast line and slow line.
Display bear / bull fighting (x) : Display fighting signals (crosses) between bull and bears.
VISUALIZATIONS :
This indicator has 3 possible complementary visualizations:
Candle labels : The labels on top are the percentage of the bears on the candle, while the labels on the bottom are the percentage of the bulls on the candle. When the bulls are winning the labels are blue, when the bears are winning the labels are red, silver otherwise.
Box after last candle : The blue and red boxes after the last candle are the percentage of bears and bulls on the last candle of the chart. That boxes can be disabled in the settings if you feel it is redundant with the labels.
Signals : The signals are displayed at the bottom of the main area of trading. The orange “x” represents an area where bulls and bears are fighting hard. The blue “o” represents a buy signal (fast line crosses over the slow line) and the red “o” represents a sell sinal (fast line crosses under the slow line).
USAGE :
The most important rule in the usage of this indicator is :
“The higher the current bull power is (or bear power), the higher the chances are the next candle will also be bullish (or bearish).”
When the prices is increasing, it is very interesting to follow the bull power to verify that it is either stable or increasing. If the bull power keeps decreasing candle after candle, there is chances that in the next candles there will be a reversal.
When there is orange crosses in the signal area (bottom of the screen), it means that there is a big fight between bulls and bears and that the current price of the asset is probably stable. During these fighting areas, reversals are more likely to happen.
When there is a blue circle in the signal area (or red signal), it can be considered as a buy signal (or sell signal). These signals are determined by the crossover of the fast and slow lines of the total power of the bulls plus the bears.
LIMITATIONS :
As Pine script only allows to display about 50 drawings on the chart, the labels on the candles can not be printed on all the historical candles. The option “Display opposites” could be useful to hide unnecessary labels and then be able to display more older labels.
As the Elder ray indicator uses an average price (EMA 13 of closing price), the indicator may be lagging in some situations, but most of the time it will help to filter the bad signals contrary to the indicators that are too reactive.
Donchian Channel - trend filterTrend filter created based on donchian channel. I am using my custom donchian channel as base for this indicator:
Concept is simple.
We count how many times price is hitting donchian channel top or bottom without hitting the other side and keep counter for both. Thus:
upCount is the number of times price hits donchian channel top without hitting bottom
downCount is the number of times price hits donchian channel bottom without hittin top
trendCountLimit is the minimum value of upCount or downCount to call it uptrend or downtrend.
Gann Circle Swing LevelsThis indicator is based on W. D. Gann's Square of 9 Chart and can be interpreted as the Gann Circle / Gann Wheel / 360 Degree Circle Chart or Square of the Circle Chart.
Spiral arrangement of numbers on the Square of 9 chart creates a very unique square root relationship amongst the numbers on the chart. If you take any number on the Square of 9 chart, take the square root of the number, then add 2 to the root and re-square it, resulting in one full 360 degree cycle (i.e. a 360 degree Circle) out from the center of the chart.
For example,
the square root of 121 = 11,
11 + 2 = 13,
and the square of 13 = 169
The number 169 is one full 360 degree cycle out (with reference to 121) from the center of the Square of 9 chart.
Similarly, if you take any number on the Square of 9 chart, take the square root of the number, then subtract 2 from the root and re-square it, resulting in one full 360 degree inward rotation towards the center of the chart.
For example,
the square root of 565 = 23.77,
23.77 - 2 = 21.77,
and the square of 21.77 = 473.93 (approximately equal to 474, which is directly below 565 on the Square of 9 chart)
The number 474 is one full 360 degree inward rotation (with reference to 565) towards the center of the chart.
How to Use this Indicator ?
This indicator is useful for finding coordinate squares on the Gann Circle that are making hard aspects to a previous position (such as a significant top or bottom) on the circle.
Input :
Swing Point (Significant price point, such as a top or a bottom)
Low / High ? (Is it a bottom or a top)
Number of Gann Levels (Number of Gann Cycles to be projected)
Output :
Gann Support or Resistance Levels (color coded as follows) :
Swing High or Swing Low (BLUE)
Support levels calculated with reference to the Swing High (RED)
Resistance levels calculated with reference to the Swing Low (LIME)
Easy TrendThis signal is completely based on analysis and transformation of a single simple moving average. As with all signals and indicators, it should be combined with others.
This is how the signal is built:
1. First it takes the SMA of the closing price.
2. It then takes the ROC of that SMA using a length of 1.
3. It takes an 8-period SMA and also a 64-period SMA of that ROC.
4. These are plotted as follows:
- the ROC is plotted in green when above 0 (trending up) and red when below 0 (trending down).
- the 8-period SMA is plotted as a thin white line within the ROC signal
- the 64-period SMA is plotted as a thick white line within the ROC signal
When the trendline is green, this is a bullish zone. When the trendline is red, this is a bearish zone.
Moving averages (all types of moving averages) are inherently lagging signals. To compensate for that, I am offsetting each SMA series by half of its period. This may be confusing to some, but the end result is a mathematically accurate SMA signal, centered on the signal that it is providing the moving average of. It doesn't stop the lag, but it directly and obviously shows how lagged each signal is, which I personally find better to trade against.
Symbols on the top and bottom of indicator:
Yellow triangle at bottom of indicator shows where a downward trend is starting to bottom out and a buy/long opening may be available soon.
Green triangle at bottom of indicator shows that a downward trend has switched to an upward trend. This indicates a good time to buy.
Yellow triangle at top of indicator shows where an upward trend is starting to plateau and a sell/short opening may be available soon.
Red triangle at top of indicator shows that an upward trend has switched to a downward trend. This indicates a good time to sell.
Note: You may see multiple yellow triangles before seeing a green or red triangle. This can happen when multiple trend accelerations or decelerations occur within an overall green or red zone.
In addition there is a dotted line connecting the end of the 64-period SMA to the end of the 8-period SMA. This indicates the direction the trend is moving towards. When the dotted line crosses the zero line, this portrays a rough estimate of where the trend may switch from a downtrend to an uptrend or vice versa. This is the "best" time to buy or sell, depending on your strategy.
I recommend placing a SMA on your candles set to the same window size as this indicator, and also to offset that SMA to the left by half its window size. For example, a 90-period SMA should be offset by -45 periods. That will cause it to be correctly aligned with this trend signal.
FIBS S/R IndicatorHello,
I've decided to publish a new script. The previous version of this script was removed by admins for breaking community rules.
So I present to you the Fibonacci Support / Resistance.
1. How does it work
Ratio plots
I first take the input of pivot look back and search for pivots high and low.
And then it takes a second look back to search highest high and lowest low to establish the top bottom range.
Then using the top and bottom I plot ratios provided as input. Defaults to most relevant 5 ratios I've found (Fibonacci):
Ratio 0 = 0 - can't be changed
Ratio 1 = 0.5
Ratio 2 = 0.618
Ratio 3 = 1
Ratio 4 = 1.618
Ratio 5 = 2.618
Any changes done to these ratios should be in order, otherwise conditions could get messed up. So R1 needs to the lowest and R5 the highest.
Also the same ratios are used in reverse as negative ratios.
There is a option to plot all ratios but gets really confusing for me but maybe for you it works. By default there are certain conditions set so that as we go up new resistance ratio get displayed and as we go down we see new resistance plots.
Trendlines
I've also added some automatic trendline plots with breakout warning labels based on the pivots high and low. Start and end for trendlines can be changed via inputs.
Labels can be deactivated via input. On a older version the trendlines and labels where not removed from the chart but I felt like there was to much information.
Overcooked/Undercooked
I've also added some fills and background colors that indicate if the price action is over R5 or under Negative R5 ratios. This usually indicates some "overcooking" or "undecooking".
I've notices that after "crossunder"/"crossover" top bottom ratios it goes in consolidation or it dumps. So then I plot a bgcolor to signal that.
2. How to use it
Using plot lines we can determine where we have support and resistance. I found that the best way to use the default ratios values is on the 1H chart. Very good for trading on crypto because of current situation in the market where there is a lot of new people entering the space and volatility and sentiment make swings respect the Fibonacci ratios.
3. Examples
For instance lets look at BINANCE:BTCUSDT .
On the left we see that the price action between 20 and 21 February was "overcooked". So after we got the signal that we "crossunder" the R5 the signal was triggered and we got a small red candle followed by a small dip and after that we got a small bounce and a dump.
If we also look at MF-RSI we can also see we got multiple bear divs.
Lets entertain the idea that we went short at ~57.1k as soon as we get signaled and it starts dumping.
Where does it stop ?
We can see it went all the way down to Negative R5 ratio. Normally that should signal "undercooking" but this was not triggered as it did not close under it (signaled in green).
We can also see that previous support now becomes resistance (signaled in red).
If we take a look at BINANCE:ETHUSDT , we do see that the "undercooking" was triggered here.
I will be publishing a more detailed Idea with examples of using this on the BINANCE:BTCUSDT chart in combination with Volume and other technical analysis.
Use with caution, this is not 100% signal indicator as the markets do what they want. But by using this in combination with other indicators like MF-RSI, EMAs and regular patterns we can get some targets for Support/Resistance.
I'm trying to create a strategy based on this indicator but I'm not getting very good results. Best results were on the 15 min chart with gross profits around ~50%.
Please try to play around with the inputs and let me know if you find something interesting, maybe I can incorporate new features in the indicator.
You can find the MF-RSI indicator here
Price Action IndexI've created a simple oscillator which I think does a good job of easily showing you when price is worth watching or not. I think all too often you get stuck looking at something like an RSI and end up trading noise.
From my observations and experiences, I've found that there are 2 major catalysts for price movement--
Price is either trending and reaches a top or bottom, or
Price is consolidating and ready to make a move in some direction
These movements can be seen quite well from a Bollinger Band, which is what mostly gave me the inspiration. When I watch a chart with a BB on it I see that either you're looking to trade price moving out of a squeeze or riding price up/down the band until it crosses over and makes a move to the moving average.
My solution was to multiply the direction of price by the strength of its deviation.
Price gets converted into a signal between -1.0 (bottom of the range) and 1.0 (top of the range)
Standard Deviation gets converted into a stochastic signal between 0 (next to no deviation from mean) and 100 (highest deviation in lookback)
These 2 get multiplied by each other
The result tells you if price action is trending bullish and if its approaching max strength (perhaps Overbought), example: Price is hitting highs (1.0) and deviation is also at its highest (100) = 100, opposite for bearish
Result can also tell you if price is at the top of the range but the deviation is so tiny and we're mostly pinned to the mean (1.0 * 5 = only 5)
How to Trade this Indicator--
If the indicator is stuck near the middle and purple:
- Don't make directional trades or you'll be eaten alive by the chop
- Good idea to sell options, Iron Condors/Butterflies, etc
- Wait for a move to breakout --> the purple will fade away and give way to a direction
--- As in all trading scenarios, be mindful of fakeouts/short moves to one direction that very quickly get reversed
If the indicator is heading higher:
- This would indicate there is a bull trend going on, get long
- If we are reaching the overbought area, this is an ideal place to take profits or look at spreads like Bearish Call Spreads (sell calls)
- I think you can make your own determination of when to sell by either selling when we're in the overbought area (if it reaches there) or staying bullish so long as it is above the zone
If the indicator is heading lower:
- Bear trend, shorting is possible
- Can use this as a contrarian signal to buy lows
A couple of charts with the indicator and a purple squeeze box I've drawn (can sometimes get noisy in real-time, but hindsight is 20/20)--
Bitcoin on Daily with default 20 length
Gamestop on 30 minute time frame with 100 length
Please feel free to use this indicator for your trading or your own indicators. This particular script is very stripped down/bare bones from what I have been working on as an ongoing project. If TradingView ever returns scripts you can sell, I would probably open that up for a small premium.
RSI-Last-3-ExtremaThis script indicates when the current Relative Strength Index of the last 8 closes is beyond a level from center oscillation which signals the equity is likely to reverse course. When it is the lowest RSI reading of the prior 3 readings and below 25, a green vertical bar will appear signaling a potential BUY point. Likewise, the highest reading of the prior 3 RSI readings and above 75 will signal a vertical red bar or SELL signal. The bar has to have a final close price for the signal to be active. Reversal could take a few more bars to occur depending on the timeframe and equity symbol.
You will be able to find many charts that have this signal perfectly finding the top or bottom of a significant trend.
It successfully indicates profitable reversal around 80% of the time. So far, It is 85% accurate or better in determining downtrend start points on the Daily, 120, 60, 30 Minute charts according to the study of more than 10,000 occurrences. It is 86% accurate on the 30 Minute chart.
This is another tool I use in finding or confirming potential price action. Hope you find it useful.
To add this, favorite the script by clicking "Add to your Favorite Indicators" at the top of the code portion below. On your top tool bar is an "fx" button with a downward arrow to the right of it. Click on the downward arrow/caret and scroll down to "RSI-Last-3-Extrema". Click on this title and it should add to the bottom of your current chart. If you do not see BUY (green vertical bars) or SELL (red vertical bars) right away, try other charts and timeframes.
`security()` revisited [PineCoders]NOTE
The non-repainting technique in this publication that relies on bar states is now deprecated, as we have identified inconsistencies that undermine its credibility as a universal solution. The outputs that use the technique are still available for reference in this publication. However, we do not endorse its usage. See this publication for more information about the current best practices for requesting HTF data and why they work.
█ OVERVIEW
This script presents a new function to help coders use security() in both repainting and non-repainting modes. We revisit this often misunderstood and misused function, and explain its behavior in different contexts, in the hope of dispelling some of the coder lure surrounding it. The function is incredibly powerful, yet misused, it can become a dangerous WMD and an instrument of deception, for both coders and traders.
We will discuss:
• How to use our new `f_security()` function.
• The behavior of Pine code and security() on the three very different types of bars that make up any chart.
• Why what you see on a chart is a simulation, and should be taken with a grain of salt.
• Why we are presenting a new version of a function handling security() calls.
• Other topics of interest to coders using higher timeframe (HTF) data.
█ WARNING
We have tried to deliver a function that is simple to use and will, in non-repainting mode, produce reliable results for both experienced and novice coders. If you are a novice coder, stick to our recommendations to avoid getting into trouble, and DO NOT change our `f_security()` function when using it. Use `false` as the function's last argument and refrain from using your script at smaller timeframes than the chart's. To call our function to fetch a non-repainting value of close from the 1D timeframe, use:
f_security(_sym, _res, _src, _rep) => security(_sym, _res, _src )
previousDayClose = f_security(syminfo.tickerid, "D", close, false)
If that's all you're interested in, you are done.
If you choose to ignore our recommendation and use the function in repainting mode by changing the `false` in there for `true`, we sincerely hope you read the rest of our ramblings before you do so, to understand the consequences of your choice.
Let's now have a look at what security() is showing you. There is a lot to cover, so buckle up! But before we dig in, one last thing.
What is a chart?
A chart is a graphic representation of events that occur in markets. As any representation, it is not reality, but rather a model of reality. As Scott Page eloquently states in The Model Thinker : "All models are wrong; many are useful". Having in mind that both chart bars and plots on our charts are imperfect and incomplete renderings of what actually occurred in realtime markets puts us coders in a place from where we can better understand the nature of, and the causes underlying the inevitable compromises necessary to build the data series our code uses, and print chart bars.
Traders or coders complaining that charts do not reflect reality act like someone who would complain that the word "dog" is not a real dog. Let's recognize that we are dealing with models here, and try to understand them the best we can. Sure, models can be improved; TradingView is constantly improving the quality of the information displayed on charts, but charts nevertheless remain mere translations. Plots of data fetched through security() being modelized renderings of what occurs at higher timeframes, coders will build more useful and reliable tools for both themselves and traders if they endeavor to perfect their understanding of the abstractions they are working with. We hope this publication helps you in this pursuit.
█ FEATURES
This script's "Inputs" tab has four settings:
• Repaint : Determines whether the functions will use their repainting or non-repainting mode.
Note that the setting will not affect the behavior of the yellow plot, as it always repaints.
• Source : The source fetched by the security() calls.
• Timeframe : The timeframe used for the security() calls. If it is lower than the chart's timeframe, a warning appears.
• Show timeframe reminder : Displays a reminder of the timeframe after the last bar.
█ THE CHART
The chart shows two different pieces of information and we want to discuss other topics in this section, so we will be covering:
A — The type of chart bars we are looking at, indicated by the colored band at the top.
B — The plots resulting of calling security() with the close price in different ways.
C — Points of interest on the chart.
A — Chart bars
The colored band at the top shows the three types of bars that any chart on a live market will print. It is critical for coders to understand the important distinctions between each type of bar:
1 — Gray : Historical bars, which are bars that were already closed when the script was run on them.
2 — Red : Elapsed realtime bars, i.e., realtime bars that have run their course and closed.
The state of script calculations showing on those bars is that of the last time they were made, when the realtime bar closed.
3 — Green : The realtime bar. Only the rightmost bar on the chart can be the realtime bar at any given time, and only when the chart's market is active.
Refer to the Pine User Manual's Execution model page for a more detailed explanation of these types of bars.
B — Plots
The chart shows the result of letting our 5sec chart run for a few minutes with the following settings: "Repaint" = "On" (the default is "Off"), "Source" = `close` and "Timeframe" = 1min. The five lines plotted are the following. They have progressively thinner widths:
1 — Yellow : A normal, repainting security() call.
2 — Silver : Our recommended security() function.
3 — Fuchsia : Our recommended way of achieving the same result as our security() function, for cases when the source used is a function returning a tuple.
4 — White : The method we previously recommended in our MTF Selection Framework , which uses two distinct security() calls.
5 — Black : A lame attempt at fooling traders that MUST be avoided.
All lines except the first one in yellow will vary depending on the "Repaint" setting in the script's inputs. The first plot does not change because, contrary to all other plots, it contains no conditional code to adapt to repainting/no-repainting modes; it is a simple security() call showing its default behavior.
C — Points of interest on the chart
Historical bars do not show actual repainting behavior
To appreciate what a repainting security() call will plot in realtime, one must look at the realtime bar and at elapsed realtime bars, the bars where the top line is green or red on the chart at the top of this page. There you can see how the plots go up and down, following the close value of each successive chart bar making up a single bar of the higher timeframe. You would see the same behavior in "Replay" mode. In the realtime bar, the movement of repainting plots will vary with the source you are fetching: open will not move after a new timeframe opens, low and high will change when a new low or high are found, close will follow the last feed update. If you are fetching a value calculated by a function, it may also change on each update.
Now notice how different the plots are on historical bars. There, the plot shows the close of the previously completed timeframe for the whole duration of the current timeframe, until on its last bar the price updates to the current timeframe's close when it is confirmed (if the timeframe's last bar is missing, the plot will only update on the next timeframe's first bar). That last bar is the only one showing where the plot would end if that timeframe's bars had elapsed in realtime. If one doesn't understand this, one cannot properly visualize how his script will calculate in realtime when using repainting. Additionally, as published scripts typically show charts where the script has only run on historical bars, they are, in fact, misleading traders who will naturally assume the script will behave the same way on realtime bars.
Non-repainting plots are more accurate on historical bars
Now consider this chart, where we are using the same settings as on the chart used to publish this script, except that we have turned "Repainting" off this time:
The yellow line here is our reference, repainting line, so although repainting is turned off, it is still repainting, as expected. Because repainting is now off, however, plots on historical bars show the previous timeframe's close until the first bar of a new timeframe, at which point the plot updates. This correctly reflects the behavior of the script in the realtime bar, where because we are offsetting the series by one, we are always showing the previously calculated—and thus confirmed—higher timeframe value. This means that in realtime, we will only get the previous timeframe's values one bar after the timeframe's last bar has elapsed, at the open of the first bar of a new timeframe. Historical and elapsed realtime bars will not actually show this nuance because they reflect the state of calculations made on their close , but we can see the plot update on that bar nonetheless.
► This more accurate representation on historical bars of what will happen in the realtime bar is one of the two key reasons why using non-repainting data is preferable.
The other is that in realtime, your script will be using more reliable data and behave more consistently.
Misleading plots
Valiant attempts by coders to show non-repainting, higher timeframe data updating earlier than on our chart are futile. If updates occur one bar earlier because coders use the repainting version of the function, then so be it, but they must then also accept that their historical bars are not displaying information that is as accurate. Not informing script users of this is to mislead them. Coders should also be aware that if they choose to use repainting data in realtime, they are sacrificing reliability to speed and may be running a strategy that behaves very differently from the one they backtested, thus invalidating their tests.
When, however, coders make what are supposed to be non-repainting plots plot artificially early on historical bars, as in examples "c4" and "c5" of our script, they would want us to believe they have achieved the miracle of time travel. Our understanding of the current state of science dictates that for now, this is impossible. Using such techniques in scripts is plainly misleading, and public scripts using them will be moderated. We are coding trading tools here—not video games. Elementary ethics prescribe that we should not mislead traders, even if it means not being able to show sexy plots. As the great Feynman said: You should not fool the layman when you're talking as a scientist.
You can readily appreciate the fantasy plot of "c4", the thinnest line in black, by comparing its supposedly non-repainting behavior between historical bars and realtime bars. After updating—by miracle—as early as the wide yellow line that is repainting, it suddenly moves in a more realistic place when the script is running in realtime, in synch with our non-repainting lines. The "c5" version does not plot on the chart, but it displays in the Data Window. It is even worse than "c4" in that it also updates magically early on historical bars, but goes on to evaluate like the repainting yellow line in realtime, except one bar late.
Data Window
The Data Window shows the values of the chart's plots, then the values of both the inside and outside offsets used in our calculations, so you can see them change bar by bar. Notice their differences between historical and elapsed realtime bars, and the realtime bar itself. If you do not know about the Data Window, have a look at this essential tool for Pine coders in the Pine User Manual's page on Debugging . The conditional expressions used to calculate the offsets may seem tortuous but their objective is quite simple. When repainting is on, we use this form, so with no offset on all bars:
security(ticker, i_timeframe, i_source )
// which is equivalent to:
security(ticker, i_timeframe, i_source)
When repainting is off, we use two different and inverted offsets on historical bars and the realtime bar:
// Historical bars:
security(ticker, i_timeframe, i_source )
// Realtime bar (and thus, elapsed realtime bars):
security(ticker, i_timeframe, i_source )
The offsets in the first line show how we prevent repainting on historical bars without the need for the `lookahead` parameter. We use the value of the function call on the chart's previous bar. Since values between the repainting and non-repainting versions only differ on the timeframe's last bar, we can use the previous value so that the update only occurs on the timeframe's first bar, as it will in realtime when not repainting.
In the realtime bar, we use the second call, where the offsets are inverted. This is because if we used the first call in realtime, we would be fetching the value of the repainting function on the previous bar, so the close of the last bar. What we want, instead, is the data from the previous, higher timeframe bar , which has elapsed and is confirmed, and thus will not change throughout realtime bars, except on the first constituent chart bar belonging to a new higher timeframe.
After the offsets, the Data Window shows values for the `barstate.*` variables we use in our calculations.
█ NOTES
Why are we revisiting security() ?
For four reasons:
1 — We were seeing coders misuse our `f_secureSecurity()` function presented in How to avoid repainting when using security() .
Some novice coders were modifying the offset used with the history-referencing operator in the function, making it zero instead of one,
which to our horror, caused look-ahead bias when used with `lookahead = barmerge.lookahead_on`.
We wanted to present a safer function which avoids introducing the dreaded "lookahead" in the scripts of unsuspecting coders.
2 — The popularity of security() in screener-type scripts where coders need to use the full 40 calls allowed per script made us want to propose
a solid method of allowing coders to offer a repainting/no-repainting choice to their script users with only one security() call.
3 — We wanted to explain why some alternatives we see circulating are inadequate and produce misleading behavior.
4 — Our previous publication on security() focused on how to avoid repainting, yet many other considerations worthy of attention are not related to repainting.
Handling tuples
When sending function calls that return tuples with security() , our `f_security()` function will not work because Pine does not allow us to use the history-referencing operator with tuple return values. The solution is to integrate the inside offset to your function's arguments, use it to offset the results the function is returning, and then add the outside offset in a reassignment of the tuple variables, after security() returns its values to the script, as we do in our "c2" example.
Does it repaint?
We're pretty sure Wilder was not asked very often if RSI repainted. Why? Because it wasn't in fashion—and largely unnecessary—to ask that sort of question in the 80's. Many traders back then used daily charts only, and indicator values were calculated at the day's close, so everybody knew what they were getting. Additionally, indicator values were calculated by generally reputable outfits or traders themselves, so data was pretty reliable. Today, almost anybody can write a simple indicator, and the programming languages used to write them are complex enough for some coders lacking the caution, know-how or ethics of the best professional coders, to get in over their heads and produce code that does not work the way they think it does.
As we hope to have clearly demonstrated, traders do have legitimate cause to ask if MTF scripts repaint or not when authors do not specify it in their script's description.
► We recommend that authors always use our `f_security()` with `false` as the last argument to avoid repainting when fetching data dependent on OHLCV information. This is the only way to obtain reliable HTF data. If you want to offer users a choice, make non-repainting mode the default, so that if users choose repainting, it will be their responsibility. Non-repainting security() calls are also the only way for scripts to show historical behavior that matches the script's realtime behavior, so you are not misleading traders. Additionally, non-repainting HTF data is the only way that non-repainting alerts can be configured on MTF scripts, as users of MTF scripts cannot prevent their alerts from repainting by simply configuring them to trigger on the bar's close.
Data feeds
A chart at one timeframe is made up of multiple feeds that mesh seamlessly to form one chart. Historical bars can use one feed, and the realtime bar another, which brokers/exchanges can sometimes update retroactively so that elapsed realtime bars will reappear with very slight modifications when the browser's tab is refreshed. Intraday and daily chart prices also very often originate from different feeds supplied by brokers/exchanges. That is why security() calls at higher timeframes may be using a completely different feed than the chart, and explains why the daily high value, for example, can vary between timeframes. Volume information can also vary considerably between intraday and daily feeds in markets like stocks, because more volume information becomes available at the end of day. It is thus expected behavior—and not a bug—to see data variations between timeframes.
Another point to keep in mind concerning feeds it that when you are using a repainting security() plot in realtime, you will sometimes see discrepancies between its plot and the realtime bars. An artefact revealing these inconsistencies can be seen when security() plots sometimes skip a realtime chart bar during periods of high market activity. This occurs because of races between the chart and the security() feeds, which are being monitored by independent, concurrent processes. A blue arrow on the chart indicates such an occurrence. This is another cause of repainting, where realtime bar-building logic can produce different outcomes on one closing price. It is also another argument supporting our recommendation to use non-repainting data.
Alternatives
There is an alternative to using security() in some conditions. If all you need are OHLC prices of a higher timeframe, you can use a technique like the one Duyck demonstrates in his security free MTF example - JD script. It has the great advantage of displaying actual repainting values on historical bars, which mimic the code's behavior in the realtime bar—or at least on elapsed realtime bars, contrary to a repainting security() plot. It has the disadvantage of using the current chart's TF data feed prices, whereas higher timeframe data feeds may contain different and more reliable prices when they are compiled at the end of the day. In its current state, it also does not allow for a repainting/no-repainting choice.
When `lookahead` is useful
When retrieving non-price data, or in special cases, for experiments, it can be useful to use `lookahead`. One example is our Backtesting on Non-Standard Charts: Caution! script where we are fetching prices of standard chart bars from non-standard charts.
Warning users
Normal use of security() dictates that it only be used at timeframes equal to or higher than the chart's. To prevent users from inadvertently using your script in contexts where it will not produce expected behavior, it is good practice to warn them when their chart is on a higher timeframe than the one in the script's "Timeframe" field. Our `f_tfReminderAndErrorCheck()` function in this script does that. It can also print a reminder of the higher timeframe. It uses one security() call.
Intrabar timeframes
security() is not supported by TradingView when used with timeframes lower than the chart's. While it is still possible to use security() at intrabar timeframes, it then behaves differently. If no care is taken to send a function specifically written to handle the successive intrabars, security() will return the value of the last intrabar in the chart's timeframe, so the last 1H bar in the current 1D bar, if called at "60" from a "D" chart timeframe. If you are an advanced coder, see our FAQ entry on the techniques involved in processing intrabar timeframes. Using intrabar timeframes comes with important limitations, which you must understand and explain to traders if you choose to make scripts using the technique available to others. Special care should also be taken to thoroughly test this type of script. Novice coders should refrain from getting involved in this.
█ TERMINOLOGY
Timeframe
Timeframe , interval and resolution are all being used to name the concept of timeframe. We have, in the past, used "timeframe" and "resolution" more or less interchangeably. Recently, members from the Pine and PineCoders team have decided to settle on "timeframe", so from hereon we will be sticking to that term.
Multi-timeframe (MTF)
Some coders use "multi-timeframe" or "MTF" to name what are in fact "multi-period" calculations, as when they use MAs of progressively longer periods. We consider that a misleading use of "multi-timeframe", which should be reserved for code using calculations actually made from another timeframe's context and using security() , safe for scripts like Duyck's one mentioned earlier, or TradingView's Relative Volume at Time , which use a user-selected timeframe as an anchor to reset calculations. Calculations made at the chart's timeframe by varying the period of MAs or other rolling window calculations should be called "multi-period", and "MTF-anchored" could be used for scripts that reset calculations on timeframe boundaries.
Colophon
Our script was written using the PineCoders Coding Conventions for Pine .
The description was formatted using the techniques explained in the How We Write and Format Script Descriptions PineCoders publication.
Snippets were lifted from our MTF Selection Framework , then massaged to create the `f_tfReminderAndErrorCheck()` function.
█ THANKS
Thanks to apozdnyakov for his help with the innards of security() .
Thanks to bmistiaen for proofreading our description.
Look first. Then leap.
