dashboard MTF,EMA User Guide: Dashboard MTF EMA
Script Installation:
Copy the script code.
Go to the script window (Pine Editor) on TradingView.
Paste the code into the script window.
Save the script.
Adding the Script to the Chart:
Return to your chart on TradingView.
Look for the script in the list of available scripts.
Add the script to the chart.
Interpreting the Table:
On the right side of the chart, you will see a table labeled "EMA" with arrows.
The rows correspond to different timeframes: 5 minutes (5M), 15 minutes (15M), 1 hour (1H), 4 hours (4H), and 1 day (1D).
Understanding the Arrows:
Each row of the table has two columns: "EMA" and an arrow.
"EMA" indicates the trend of the Exponential Moving Average (EMA) for the specified period.
The arrow indicates the direction of the trend: ▲ for bullish, ▼ for bearish.
Table Colors:
The colors of the table reflect the current trend based on the comparison between fast and slow EMAs.
Blue (▲) indicates a bullish trend.
Red (▼) indicates a bearish trend.
Table Theme:
The table has a dark (Dark) or light (Light) theme according to your preference.
The background, frame, and colors are adjusted based on the selected theme.
Usage:
Use the table as a quick indicator of trends on different timeframes.
The arrows help you quickly identify trends without navigating between different time units.
Designed to simplify analysis and avoid cluttering the chart with multiple indicators.
Komut dosyalarını "TradingView+手机版" için ara
UtilsLibrary "Utils"
A collection of convenience and helper functions for indicator and library authors on TradingView
formatNumber(num)
My version of format number that doesn't have so many decimal places...
Parameters:
num (float) : (float) the number to be formatted
Returns: (string) The formatted number
getDateString(timestamp)
Convenience function returns timestamp in yyyy/MM/dd format.
Parameters:
timestamp (int) : (int) The timestamp to stringify
Returns: (int) The date string
getDateTimeString(timestamp)
Convenience function returns timestamp in yyyy/MM/dd hh:mm format.
Parameters:
timestamp (int) : (int) The timestamp to stringify
Returns: (int) The date string
getInsideBarCount()
Gets the number of inside bars for the current chart. Can also be passed to request.security to get the same for different timeframes.
Returns: (int) The # of inside bars on the chart right now.
getLabelStyleFromString(styleString, acceptGivenIfNoMatch)
Tradingview doesn't give you a nice way to put the label styles into a dropdown for configuration settings. So, I specify them in the following format: . This function takes care of converting those custom strings back to the ones expected by tradingview scripts.
Parameters:
styleString (string)
acceptGivenIfNoMatch (bool) : (bool) If no match for styleString is found and this is true, the function will return styleString, otherwise it will return tradingview's preferred default
Returns: (string) The string expected by tradingview functions
getTime(hourNumber, minuteNumber)
Given an hour number and minute number, adds them together and returns the sum. To be used by getLevelBetweenTimes when fetching specific price levels during a time window on the day.
Parameters:
hourNumber (int) : (int) The hour number
minuteNumber (int) : (int) The minute number
Returns: (int) The sum of all the minutes
getHighAndLowBetweenTimes(start, end)
Given a start and end time, returns the high or low price during that time window.
Parameters:
start (int) : The timestamp to start with (# of seconds)
end (int) : The timestamp to end with (# of seconds)
Returns: (float) The high or low value
getPremarketHighsAndLows()
Returns an expression that can be used by request.security to fetch the premarket high & low levels in a tuple.
Returns: (tuple)
getAfterHoursHighsAndLows()
Returns an expression that can be used by request.security to fetch the after hours high & low levels in a tuple.
Returns: (tuple)
getOvernightHighsAndLows()
Returns an expression that can be used by request.security to fetch the overnight high & low levels in a tuple.
Returns: (tuple)
getNonRthHighsAndLows()
Returns an expression that can be used by request.security to fetch the high & low levels for premarket, after hours and overnight in a tuple.
Returns: (tuple)
getLineStyleFromString(styleString, acceptGivenIfNoMatch)
Tradingview doesn't give you a nice way to put the line styles into a dropdown for configuration settings. So, I specify them in the following format: . This function takes care of converting those custom strings back to the ones expected by tradingview scripts.
Parameters:
styleString (string) : (string) Plain english (or TV Standard) version of the style string
acceptGivenIfNoMatch (bool) : (bool) If no match for styleString is found and this is true, the function will return styleString, otherwise it will return tradingview's preferred default
Returns: (string) The string expected by tradingview functions
getPercentFromPrice(price)
Get the % the current price is away from the given price.
Parameters:
price (float)
Returns: (float) The % the current price is away from the given price.
getPositionFromString(position)
Tradingview doesn't give you a nice way to put the positions into a dropdown for configuration settings. So, I specify them in the following format: . This function takes care of converting those custom strings back to the ones expected by tradingview scripts.
Parameters:
position (string) : (string) Plain english position string
Returns: (string) The string expected by tradingview functions
getTimeframeOfChart()
Get the timeframe of the current chart for display
Returns: (string) The string of the current chart timeframe
getTimeNowPlusOffset(candleOffset)
Helper function for drawings that use xloc.bar_time to help you know the time offset if you want to place the end of the drawing out into the future. This determines the time-size of one candle and then returns a time n candleOffsets into the future.
Parameters:
candleOffset (int) : (int) The number of items to find singular/plural for.
Returns: (int) The future time
getVolumeBetweenTimes(start, end)
Given a start and end time, returns the sum of all volume across bars during that time window.
Parameters:
start (int) : The timestamp to start with (# of seconds)
end (int) : The timestamp to end with (# of seconds)
Returns: (float) The volume
isToday()
Returns true if the current bar occurs on today's date.
Returns: (bool) True if current bar is today
padLabelString(labelText, labelStyle)
Pads a label string so that it appears properly in or not in a label. When label.style_none is used, this will make sure it is left-aligned instead of center-aligned. When any other type is used, it adds a single space to the right so there is padding against the right end of the label.
Parameters:
labelText (string) : (string) The string to be padded
labelStyle (string) : (string) The style of the label being padded for.
Returns: (string) The padded string
plural(num, singular, plural)
Helps format a string for plural/singular. By default, if you only provide num, it will just return "s" for plural and nothing for singular (eg. plural(numberOfCats)). But you can optionally specify the full singular/plural words for more complicated nomenclature (eg. plural(numberOfBenches, 'bench', 'benches'))
Parameters:
num (int) : (int) The number of items to find singular/plural for.
singular (string) : (string) The string to return if num is singular. Defaults to an empty string.
plural (string) : (string) The string to return if num is plural. Defaults to 's' so you can just add 's' to the end of a word.
Returns: (string) The singular or plural provided strings depending on the num provided.
timeframeInSeconds(timeframe)
Get the # of seconds in a given timeframe. Tradingview's timeframe.in_seconds() expects a simple string, and we often need to use series string, so this is an alternative to get you the value you need.
Parameters:
timeframe (string)
Returns: (int) The number of secondsof that timeframe
timeframeToString(tf)
Convert a timeframe string to a consistent standard.
Parameters:
tf (string) : (string) The timeframe string to convert
Returns: (string) The standard format for the string, or the unchanged value if it is unknown.
True Strength [PINESCRIPTLABS]This indicator is an implementation of the "True Strength Index" (TSI) developed by PINE_LABS for the Pine Script trading platform on TradingView. The True Strength Index is a technical indicator used to measure the strength and direction of a trend in a financial asset.
Here's an explanation of how this particular indicator works:
Buy Signal:
A buy signal is generated when the value of the True Strength Index (TSI) falls at or below the specified buy_tsi_value. This indicates a potential buying opportunity as the TSI suggests that the asset might be oversold or experiencing a potential reversal. When this condition is met, a green triangle shape is plotted below the corresponding price bar, indicating a potential buy signal.
Sell Signal:
Conversely, a sell signal is generated when the value of the TSI rises to or above the specified sell_tsi_value. This implies a potential selling opportunity as the TSI indicates that the asset might be overbought or facing a possible reversal. When this condition is met, a red triangle shape is plotted above the corresponding price bar, indicating a potential sell signal.
Note:
When we observe that the value of TSI (blue line) crosses above our parameter called TSI Sell (red Plot) it will open a sell operation, and on the contrary when our TSI (blue line) crosses below our TSI parameter ( Green Plot) will open a buy trade.
Este indicador es una implementación del "True Strength Index" (TSI) desarrollada por PINE_LABS para la plataforma de trading de Pine Script en TradingView. El True Strength Index es un indicador técnico que se utiliza para medir la fuerza y la dirección de una tendencia en un activo financiero.
Aquí hay una explicación de cómo funciona este indicador en particular:
Señal de Compra:
Una señal de compra se genera cuando el valor del Índice de Fuerza Verdadera (TSI) cae igual o por debajo del valor especificado en buy_tsi_value. Esto indica una posible oportunidad de compra, ya que el TSI sugiere que el activo podría estar sobrevendido o experimentando una reversión potencial. Cuando se cumple esta condición, se traza un triángulo verde debajo de la barra de precios correspondiente, indicando una posible señal de compra.
Señal de Venta:
Por otro lado, se genera una señal de venta cuando el valor del TSI sube igual o por encima del valor especificado en sell_tsi_value. Esto implica una posible oportunidad de venta, ya que el TSI indica que el activo podría estar sobrecomprado o enfrentando una posible reversión. Cuando se cumple esta condición, se traza un triángulo rojo encima de la barra de precios correspondiente, indicando una posible señal de venta.
Nota:
Cuando observamos que el valor de TSI ( linea azul) , cruza por arriba de nuestro parámetro llamado TSI Sell ( Plot rojo) abrirá una operacion de venta, y por el contrario cuando nuestro TSI ( linea azul) cruza por abajo de nuestro parámetro TSI ( Plot Verde) abrirá una operacion de compra.
Show Extended Hours (Futures & Crypto)OVERVIEW
This indicator mimics TradingViews "Extended trading hours" background color settings. It is most useful on symbols that do not conventionally have extended hours, but are available to trade during those hours (ie. Futures and Crypto). Because market participation (ie. volatility) in a given symbol can change dramatically at or near these transitions, seeing conventional market open / closures expedites price action context around these transitions.
INPUTS
You can configure:
Background colors for both Premarket and After Hours
Which extended hours you would like to see
Market Hours and Time Zone
Tape (Time and Sales)OVERVIEW
This indicator is a synthesized "Tape" (aka. Time and Sales) from real time market data. It's specifically designed to be performant, expediting trading insights and decisions.
The table contains color-coded price action, volume size, and a timestamp data for each chart update. Because chart updates are independent of exchange orders, 1 chart update may combine more than 1 exchange and/or order. Even so, you're able to see very small and fast order flow changes, made possible by measuring real time volume differentials, and correlating them with price action.
Real time volume differentials are required for this indicator to be most useful. This is not ideal for historical analysis or TradingViews Replay feature.
INPUTS
You can can configure:
Table Position and Text Size
The Timestamp (visibility, format, timezone)
The number of lines to print
Volume Parameters (minimum size, large sizes, decimal precision)
Highlighting and Enlarging large sized prints
All the colors
DEV NOTES
This script illustrates:
The complimentary nature of loops and arrays
A method for iterative table management
Options Price CalculatorIn the team, we continue to explore and expand the boundaries of TradingView.
For now, there is not much an options trader can do with options in TradingView.
We wanted to change that and created a simple option pricer.
You can set up in parameters a set of strikes, implied volatility, and days to expiry.
The indicators will take a risk-free rate from US01Y and the underlying price from your current chart.
It will compute prices and greeks for both put and call options.
Thanks to @MUQWISHI for helping code it.
Disclaimer
Please remember that past performance may not indicate future results.
Due to various factors, including changing market conditions, the strategy may no longer perform as well as in historical backtesting.
This post and the script don’t provide any financial advice.
MTF CCI + Realtime DivergencesMulti-timeframe Commodity Channel Index (CCI) + Realtime Divergences + Alerts
This version of the CCI includes the following features:
- Optional 2x sets of triple-timeframe overbought and oversold signals with fully configurable timeframes and overbought and oversold thresholds, can indicate where 3 selected timeframes are all overbought or all oversold at the same time, with alert option.
- Optional divergence lines drawn directly onto the oscillator in realtime, with alert options.
- Configurable pivot periods to fine tune the divergences drawn in order to suit different trading styles and timeframes, including the ability to enable automatic adjustment of pivot period per chart timeframe.
- Alternate timeframe feature allows you to configure the oscillator to use data from a different timeframe than the chart it is loaded on.
- 'Hide oscillator' feature allows traders to hide the oscillator itself, leaving only the background colours indicating the overbought and oversold periods and/or MTF overbought and oversold confluences, as seen in the chart image.
- Also includes standard configurable CCI options, including CCI length and source type. Defaults set to length 20, and hlc3 source type.
- Optional Flip oscillator feature, allows users to flip the oscillator upside down, for use with Tradingviews 'Flip chart' feature (Alt+i), for the purpose of manually spotting divergences, where the trader has a strong natural bias in one direction, so that they can flip both the chart and the oscillator.
- Optional 'Fade oscillator' feature, which will fade out all but the most recent period, reducing visual noise on the chart.
While this version of the CCI has the ability to draw divergences in realtime along with related alerts so you can be notified as divergences occur without spending all day watching the charts, the main purpose of this indicator was to provide the triple-timeframe overbought and oversold confluence signals, in an attempt to add more confluence, weight and reliability to the single timeframe overbought and oversold states, commonly used for trade entry confluence. It's primary purpose is intended for scalping reversal trades on lower timeframes, typically between 1-15 minutes, which can be used in conjunction with the regular divergences the indicator can highlight. The triple timeframe overbought can often indicate near term reversals to the downside, with the triple timeframe oversold often indicating neartime reversals to the upside. The default timeframes for this confluence are set to check the 1m, 5m and 15m timeframes together, ideal for scalping the < 15 minute charts. The default settings for the MTF #1 timeframes (1m, 5m and 15m) are best used on a <5 minute chart.
Its design and use case is based upon the original MTF Stoch RSI + Realtime Divergences found here .
Commodity Channel Index (CCI)
Investopedia has described the popular oscillator as follows:
“The Commodity Channel Index (CCI) is a momentum-based oscillator used to help determine when an investment vehicle is reaching a condition of being overbought or oversold.
Developed by Donald Lambert, this technical indicator assesses price trend direction and strength, allowing traders to determine if they want to enter or exit a trade, refrain from taking a trade, or add to an existing position. In this way, the indicator can be used to provide trade signals when it acts in a certain way.”
You can read more about the CCI, its use cases and calculations here .
How do traders use overbought and oversold levels in their trading?
The oversold level, that is traditionally when the CCI is above the 100 level is typically interpreted as being 'overbought', and below the -100 level is typically considered 'oversold'. Traders will often use the CCI at an overbought level as a confluence for entry into a short position, and the CCI at an oversold level as a confluence for an entry into a long position. These levels do not mean that price will necessarily reverse at those levels in a reliable way, however. This is why this version of the CCI employs the triple timeframe overbought and oversold confluence, in an attempt to add a more confluence and reliability to this usage of the CCI. While traditionally, the overbought and oversold levels are below -100 for oversold, and above 100 for overbought, he default threshold settings of this indicator have been increased to provide fewer, stronger signals, especially suited to the low timeframes and highly volatile assets.
What are divergences?
Divergence is when the price of an asset is moving in the opposite direction of a technical indicator, such as an oscillator, or is moving contrary to other data. Divergence warns that the current price trend may be weakening, and in some cases may lead to the price changing direction.
There are 4 main types of divergence, which are split into 2 categories;
regular divergences and hidden divergences. Regular divergences indicate possible trend reversals, and hidden divergences indicate possible trend continuation.
Regular bullish divergence: An indication of a potential trend reversal, from the current downtrend, to an uptrend.
Regular bearish divergence: An indication of a potential trend reversal, from the current uptrend, to a downtrend.
Hidden bullish divergence: An indication of a potential uptrend continuation.
Hidden bearish divergence: An indication of a potential downtrend continuation.
How do traders use divergences in their trading?
A divergence is considered a leading indicator in technical analysis , meaning it has the ability to indicate a potential price move in the short term future.
Hidden bullish and hidden bearish divergences, which indicate a potential continuation of the current trend are sometimes considered a good place for traders to begin, since trend continuation occurs more frequently than reversals, or trend changes.
When trading regular bullish divergences and regular bearish divergences, which are indications of a trend reversal, the probability of it doing so may increase when these occur at a strong support or resistance level . A common mistake new traders make is to get into a regular divergence trade too early, assuming it will immediately reverse, but these can continue to form for some time before the trend eventually changes, by using forms of support or resistance as an added confluence, such as when price reaches a moving average, the success rate when trading these patterns may increase.
Typically, traders will manually draw lines across the swing highs and swing lows of both the price chart and the oscillator to see whether they appear to present a divergence, this indicator will draw them for you, quickly and clearly, and can notify you when they occur.
Setting alerts.
With this indicator you can set alerts to notify you when any/all of the above types of divergences occur, on any chart timeframe you choose, and also when the triple timeframe overbought and oversold confluences occur.
Configurable pivot period.
You can adjust the default pivot period values to suit your prefered trading style and timeframe. If you like to trade a shorter time frame, lowering the default lookback values will make the divergences drawn more sensitive to short term price action. By default, this indicator has enabled the automatic adjustment of the pivot periods for 4 configurable timeframes, in a bid to optimise the divergences drawn when the indicator is loaded onto any of the 4 timeframes. These timeframes and the auto adjusted pivot periods on each of them can also be reconfigured within the settings menu.
Disclaimer: This script includes code adapted from the Divergence for Many Indicators v4 by LonesomeTheBlue . With special thanks.
Stochastic by BTBSA little word before you are going to use it, this indicator is just a MODIFIED script.
The calculation part is NOT FROM ME , its still the original script by TradingView.
The Usage is still the same as you can take out of the info tab by TradingView.
The only difference is that the Color Changes red when:
1. %K is over 80 (Upper Band-High Band)=(OVERBOUGHT)
2. %D lays over %K (%D>%K)
Changes green when:
1.%K is under 20 (Lower Band-Low Band)=(OVERSOLD)
%K lays over %D (%K>%D)
Tell me what I can add or do better :)
Tag me if you use this in a public Analysis :)
MTF Stochastic ScannerThis Stochastic scanner can be use to identify overbought and oversold of 10 symbols over multiple timeframes
it will give you a quick overview which pair is more overbough or more oversold and also signals tops and bottoms in the AVG row
light red/green cell = weak bearish (Stoch = 30-20) / bullish (Stoch = 70-80)
medium red/green cell = bearish (Stoch = 20-10) / bullish (Stoch = 80-90)
dark red/green cell = strong bearish (Stoch <= 10) / bullish (Stoch >= 90)
gray cell = neutral (Stoch = 30-70)
Usage
If AVG (average of all 4 timeframes) falls below 20, the cell will get green, indicating a good time to enter long (buy)
If AVG (average of all 4 timeframes) rises above 80, the cell will get red, indicating a good time to enter short (sell)
Use the "MTF Stochastic Scanner" in combination with the " MTF RSI Scanner "
to find tops (RSI MTF avg >=70 AND Stochastic MTF avg >= 80)
or bottoms (RSI MTF avg <= 30 AND Stochastic MTF avg <= 20)
Here is how the two MTF scanners looked on Nov 08 2021 (ATH) »
and here how the MTF scanners looked on June 21 2022
use TradingViews Replay function to check how it would have worked in the past and when not.
As always… there NOT a single indicator that can show to the top & bottom 100% every single time. So use with caution, with other indicators and/or deeper understanding of technicals analysis ☝️☝️☝️
Settings
You can change the timeframes, symbols, Stochastic settings, overbought/oversold levels and colors to your liking
Drag the table onto the price chart, if you want to use it as an overlay.
NOTE:
Because of the 4x10 security requests, it can take up to 1 minute for changed settings to take effect! Please be patient 🙃
If you have any idea on how to optimise the code, please feel free to share 🙏
*** Inspired by "Binance CHOP Dashboard" from @Cazimiro and "RSI MTF Table" from @mobester16 ***
MTF RSI ScannerThis RSI scanner can be use to identify the relative strength of 10 symbols over multiple timeframes
it will give you a quick overview which pair is more bearish or more bullish and also signals tops and bottoms in the AVG row
light red/green cell = weak bearish (RSI = 45-35) / bullish (RSI = 55-65)
medium red/green cell = bearish (RSI = 35-25) / bullish (RSI = 65-75)
dark red/green cell = strong bearish (RSI <= 25) / bullish (RSI >= 75)
gray cell = neutral (RSI= 45-55)
Usage
If AVG (average of all 4 timeframes) falls below 30, the cell will get green, indicating a good time to enter long (buy)
If AVG (average of all 4 timeframes) rises above 70, the cell will get red, indicating a good time to enter short (sell)
Use the "MTF RSI Scanner" in combination with the "MTF Stochastic Scanner"
to find tops (RSI MTF avg >=70 AND Stochastic MTF avg >= 80)
or bottoms (RSI MTF avg <= 30 AND Stochastic MTF avg <= 20)
Here is how the two MTF scanners looked on Nov 08 2021 (ATH) »
and here how the MTF scanners looked on June 21 2022
use TradingViews Replay function to check how it would have worked in the past and when not.
As always… there NOT a single indicator that can show to the top & bottom 100% every single time. So use with caution, with other indicators and/or deeper understanding of technicals analysis ☝️☝️☝️
Settings
You can change the timeframes, symbols, RSI settings, overbought/oversold levels and colors to your liking
Drag the table onto the price chart, if you want to use it as an overlay.
NOTE:
Because of the 4x10 security requests, it can take up to 1 minute for changed settings to take effect! Please be patient 🙃
If you have any idea on how to optimise the code, please feel free to share 🙏
*** Inspired by "Binance CHOP Dashboard" from @Cazimiro and "RSI MTF Table" from @mobester16 ***
Central Pivot Range 2xBased on a modified Hancock Pivot Range.
Displays the Central Pivot Range for 2 customisable Timeframes Along with Targets which are based on Classic Pivot Point Extensions.
The Pivot Point Extensions are Extended to the right of the price chart which helps eliminate unnecessary clutter
TF1 Displays Right Extensions R3 to S3 + the pivot point
TF2 Displays only Right Extensions R2 to S2
I would have liked to have provided more Right Extensions plus Labels however that would have exceeded Tradingviews memory limits, having said that R3 to S3 for both timeframes can still be displayed as historical levels
Central Pivot Range High Low and Mid Levels + the Targets work great as Support and Resistance and help with analysing the trend
A Thick Central Pivot Range generally indicates consolidation whereas a Thin Central Pivot Range generally indicates a trending market
RSI Overbought Oversold Divergence Strategy w/ Buy/Sell SignalsThis indicator is a copy of my RSI Overbought/Oversold Divergence Indicator with-Alerts
Only difference is that the alerts are disabled, instead it uses tradingviews strategy tester signals
If you want alerts just use the other indicator
Exponential Regression Channel with novel volatilityThis code is a modified version of the built-in "linear regression" script of Tradingviews which can be plotted correctly on logarithmic charts
The log reg code of Forza was adjusted by altustro to generate an exponential regression (or a correct linear regression on the log scale, this is equivalent).
The standard deviation in the log scale is a better volatility measure which we call novola, and which defines the trend channel displayed in addition to the main indicator.
The exponential regression slope and channel also defines the typical holding time of the stock and the SL/TP boundaries, which are calculated and displayed at the last bar.
The display works both in log and regular scale. But only in the log scale it can be compared to the linear extension, which can also be plotted when activated in the properties.
The underlying exponential fit can not be displayed in regular scale as only lines can be plotted by TV. But with the related script Exponental Regression also the exponential regression can be exactly displayed using a workaround.
MY:Aggregated Volume BTC:DERIVATIVES█ MY Aggregated Volume BTC DERIVATIVES
This indicator shows a panel to display the Bitcoin Trading Volume of different exchanges. A lot of traders follow the default volume indicator provided by tradingview. This default indicator shows the volume for the current ticker (example BTCUSD:BITSTAMP), but each exchange has its own volume.
In a matter of visibility and accessibility, I've decided to aggregate the volume of almost all the Bitcoin exchanges (tickers) in tradingview.
This indicator helps identifying decreasing volume, where the volume comes from (spot or derivatives). A decreasing DERIVATIVES volume isn't a good sign as it shows a decrease in the buying pressure.
The panel has 1 main configuration : Display mode, showing Aggregated (all exchanges in one bar) or Difference (Stacked bar)
The other configuration Legend Item Gap and Legend X Gap is for when the difference mode is selected. It affects the position of the legend. Some might have smaller screens, bigger screens, viewport zoomed in etc.
Due to the number of exchanges, and pinescript limitations, I had to split the volume in 2 indicators, the SPOT volume, and the DERIVATIVES volume. The script in this page is specific to the DERIVATIVES volume. For the SPOT, please refer to my other available script.
Exchange list :
// OKEX:BTCUSDPERP
// OKEX:BTCUSDTPERP
// FTX:BTCPERP
// BTSE:BTCPFC
// KRAKEN:XBTUSDPERP
// BITMEX:XBTUSD
// HUOBI:BTCPERP
// DERIBIT:BTCPERP
// BINANCE:BTCPERP
// BINANCE:BTCUSDTPERP
// PHEMEX:BTCUSD
// BITGET:BTCUSDPERP
// BITGET:BTCUSDTPERP
MY:Aggregated Volume BTC:SPOT█ MY Aggregated Volume BTC SPOT
This indicator shows a panel to display the Bitcoin Trading Volume of different exchanges. A lot of traders follow the default volume indicator provided by tradingview. This default indicator shows the volume for the current ticker (example BTCUSD:BITSTAMP), but each exchange has its own volume.
In a matter of visibility and accessibility, I've decided to aggregate the volume of almost all the Bitcoin exchanges (tickers) in tradingview. Some have been commented out (Kucoin, FTX) due to high volume data which was hiding the other ones.
This indicator helps identifying decreasing volume, where the volume comes from (spot or derivatives). A decreasing SPOT volume isn't a good sign as it shows a decrease in the buying pressure.
The panel has 1 main configuration : Display mode, showing Aggregated (all exchanges in one bar) or Difference (Stacked bar)
The other configuration Legend Item Gap and Legend X Gap is for when the difference mode is selected. It affects the position of the legend. Some might have smaller screens, bigger screens, viewport zoomed in etc.
Due to the number of exchanges, and pinescript limitations, I had to split the volume in 2 indicators, the SPOT volume, and the DERIVATIVES volume. The script in this page is specific to the SPOT volume. For the DERIVATIVES, please refer to my other available script.
Exchange list :
// BINANCE:BTCUSD
// BINANCE:BTCUSDT
// BINANCE:BTCEUR
// COINBASE:BTCUSD
// COINBASE:BTCUSDT
// COINBASE:BTCEUR
// KRAKEN:XBTUSD
// KRAKEN:XBTUSDT
// KRAKEN:XBTEUR
// BITFINEX:BTCUSD
// BITFINEX:BTCEUR
// HUOBI:BTCUSDT
// HUOBI:BTCUSDC
// OKEX:BTCUSDT
// FTX:BTCUSD DISABLED FOR NOW, TO MUCH VOLUME
// FTX:BTCUSDT DISABLED FOR NOW, TO MUCH VOLUME
// KUCOIN:BTCUSDT DISABLED FOR NOW, TO MUCH VOLUME
// KUCOIN:BTCUSDC DISABLED FOR NOW, TO MUCH VOLUME
// GEMINI:BTCUSD
// GEMINI:BTCEUR
// PHEMEX:BTCUSDT
// BITTREX:BTCUSD
// BITTREX:BTCUSDT
// BITTREX:BTCEUR
All in one [Liubam]Hey tradingviewers!
This is an All in one Indicator for those who can't add too many indicators on your charts. Inspired by ©LonesomeTheBlue "Indicators all in one" script. I found a lot of very interesting scripts on the public library and I decided to make a tool with some of the greatest IMO, adding some modifications to improve the indicators. With this tool you can plot 1 of 6 different indicators by selecting it from a drop-down list (on the indicator settings).
All the credit goes to it's respective owners (taggeds).
THIS INDICATOR INCLUDES:
1. Classic RSI with some OB/OS tools:
The relative strength index (RSI) is a popular momentum indicator displayed as an oscillator (a line graph that moves between two extremes) that measures the magnitude of recent price changes to evaluate overbought or oversold conditions, in other words it shows signals about bullish and bearish price momentum. I added some visual improvements to help you finding the OB/OS zones.
2. Classic CCI with some OB/OS tools.
The Commodity Channel Index (CCI) is a momentum-based oscillator used as market indicator to help determine market movements that may indicate buying or selling. Added some vistual improvements to the chart.
3. ADX and DMI oscillator with the keylevel coded by @console:
The Average Directional Index (ADX) is non-directional indicator used by some traders to determine the strength of a trend. When the ADX line is rising (Above the keylevel) trend strength is increasing, and the price moves in the direction of the trend whether up or down. Otherwise, low ADX (Below the keylevel) is usually a sign of accumulation or distribution (Range). Non-trending doesn't mean the price isn't moving. It may not be, but the price could also be making a trend change or is too volatile for a clear direction to be present.
Suggested settings of the keylevel is 23-25.... REMEMBER: The trend may be your friend.
4. MFI
The Money Flow Index (MFI) is a technical oscillator for identifying overbought or oversold signals in an asset. Unlike conventional oscillators such as the RSI, the Money Flow Index incorporates both price and volume data, as opposed to just price. It can also be used to spot divergences which warn of a trend change in price.
5. Stochastic:
A stochastic oscillator is range-bound, meaning it is always between 0 and 100. This makes it a useful indicator of overbought and oversold conditions. Traditionally, readings over 80 are considered in the overbought range, and readings under 20 are considered oversold. However, these are not always indicative of impending reversal; very strong trends can maintain overbought or oversold conditions for an extended period. Instead, traders should look to changes in the stochastic oscillator for clues about future trend shifts. I added some features for this popular indicator to show the stochastic crosses.
6. The famous Squeeze momentum Indicator made by @Lazybear:
This is derivate of John Carter's "TTM Squeeze" volatility indicator and its very strong when using with trending indicator such a ADX. Black line (or no-line) on the midline show that the market just entered a squeeze ( Bollinger Bands are with in Keltner Channel). This signifies low volatility , market preparing itself for an explosive move (up or down). Gray line signify "Squeeze release". Mr.Carter suggests waiting till the gray line after a blackline, and taking a position in the direction of the momentum (for ex., if momentum value is above zero, go long). Exit the position when the momentum changes.
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
This script is source code protected, but you can add to your favorite list to use it. Also you can add twice to use 2 different indicators at the same time (E.g. Squeeze Momentum Indicator + ADX)
An additional indicator I made (MA Hunterz + InfoPanel) is needed to not miss good entry points.
Your valuable comment and feedback is much appreciated...
And remember indicators can be really helpfull but always use Price Action.
Using `varip` variables [PineCoders]█ OVERVIEW
The new varip keyword in Pine can be used to declare variables that escape the rollback process, which is explained in the Pine User Manual's page on the execution model . This publication explains how Pine coders can use variables declared with varip to implement logic that was impossible to code in Pine before, such as timing events during the realtime bar, or keeping track of sequences of events that occur during successive realtime updates. We present code that allows you to calculate for how much time a given condition is true during a realtime bar, and show how this can be used to generate alerts.
█ WARNINGS
1. varip is an advanced feature which should only be used by coders already familiar with Pine's execution model and bar states .
2. Because varip only affects the behavior of your code in the realtime bar, it follows that backtest results on strategies built using logic based on varip will be meaningless,
as varip behavior cannot be simulated on historical bars. This also entails that plots on historical bars will not be able to reproduce the script's behavior in realtime.
3. Authors publishing scripts that behave differently in realtime and on historical bars should imperatively explain this to traders.
█ CONCEPTS
Escaping the rollback process
Whereas scripts only execute once at the close of historical bars, when a script is running in realtime, it executes every time the chart's feed detects a price or volume update. At every realtime update, Pine's runtime normally resets the values of a script's variables to their last committed value, i.e., the value they held when the previous bar closed. This is generally handy, as each realtime script execution starts from a known state, which simplifies script logic.
Sometimes, however, script logic requires code to be able to save states between different executions in the realtime bar. Declaring variables with varip now makes that possible. The "ip" in varip stands for "intrabar persist".
Let's look at the following code, which does not use varip :
//@version=4
study("")
int updateNo = na
if barstate.isnew
updateNo := 1
else
updateNo := updateNo + 1
plot(updateNo, style = plot.style_circles)
On historical bars, barstate.isnew is always true, so the plot shows a value of "1". On realtime bars, barstate.isnew is only true when the script first executes on the bar's opening. The plot will then briefly display "1" until subsequent executions occur. On the next executions during the realtime bar, the second branch of the if statement is executed because barstate.isnew is no longer true. Since `updateNo` is initialized to `na` at each execution, the `updateNo + 1` expression yields `na`, so nothing is plotted on further realtime executions of the script.
If we now use varip to declare the `updateNo` variable, the script behaves very differently:
//@version=4
study("")
varip int updateNo = na
if barstate.isnew
updateNo := 1
else
updateNo := updateNo + 1
plot(updateNo, style = plot.style_circles)
The difference now is that `updateNo` tracks the number of realtime updates that occur on each realtime bar. This can happen because the varip declaration allows the value of `updateNo` to be preserved between realtime updates; it is no longer rolled back at each realtime execution of the script. The test on barstate.isnew allows us to reset the update count when a new realtime bar comes in.
█ OUR SCRIPT
Let's move on to our script. It has three parts:
— Part 1 demonstrates how to generate alerts on timed conditions.
— Part 2 calculates the average of realtime update prices using a varip array.
— Part 3 presents a function to calculate the up/down/neutral volume by looking at price and volume variations between realtime bar updates.
Something we could not do in Pine before varip was to time the duration for which a condition is continuously true in the realtime bar. This was not possible because we could not save the beginning time of the first occurrence of the true condition.
One use case for this is a strategy where the system modeler wants to exit before the end of the realtime bar, but only if the exit condition occurs for a specific amount of time. One can thus design a strategy running on a 1H timeframe but able to exit if the exit condition persists for 15 minutes, for example. REMINDER: Using such logic in strategies will make backtesting their complete logic impossible, and backtest results useless, as historical behavior will not match the strategy's behavior in realtime, just as using `calc_on_every_tick = true` will do. Using `calc_on_every_tick = true` is necessary, by the way, when using varip in a strategy, as you want the strategy to run like a study in realtime, i.e., executing on each price or volume update.
Our script presents an `f_secondsSince(_cond, _resetCond)` function to calculate the time for which a condition is continuously true during, or even across multiple realtime bars. It only works in realtime. The abundant comments in the script hopefully provide enough information to understand the details of what it's doing. If you have questions, feel free to ask in the Comments section.
Features
The script's inputs allow you to:
• Specify the number of seconds the tested conditions must last before an alert is triggered (the default is 20 seconds).
• Determine if you want the duration to reset on new realtime bars.
• Require the direction of alerts (up or down) to alternate, which minimizes the number of alerts the script generates.
The inputs showcase the new `tooltip` parameter, which allows additional information to be displayed for each input by hovering over the "i" icon next to it.
The script only displays useful information on realtime bars. This information includes:
• The MA against which the current price is compared to determine the bull or bear conditions.
• A dash which prints on the chart when the bull or bear condition is true.
• An up or down triangle that prints when an alert is generated. The triangle will only appear on the update where the alert is triggered,
and unless that happens to be on the last execution of the realtime bar, it will not persist on the chart.
• The log of all triggered alerts to the right of the realtime bar.
• A gray square on top of the elapsed realtime bars where one or more alerts were generated. The square's tooltip displays the alert log for that bar.
• A yellow dot corresponding to the average price of all realtime bar updates, which is calculated using a varip array in "Part 2" of the script.
• Various key values in the Data Window for each parts of the script.
Note that the directional volume information calculated in Part 3 of the script is not plotted on the chart—only in the Data Window.
Using the script
You can try running the script on an open market with a 30sec timeframe. Because the default settings reset the duration on new realtime bars and require a 20 second delay, a reasonable amount of alerts will trigger.
Creating an alert on the script
You can create a script alert on the script. Keep in mind that when you create an alert from this script, the duration calculated by the instance of the script running the alert will not necessarily match that of the instance running on your chart, as both started their calculations at different times. Note that we use alert.freq_all in our alert() calls, so that alerts will trigger on all instances where the associated condition is met. If your alert is being paused because it reaches the maximum of 15 triggers in 3 minutes, you can configure the script's inputs so that up/down alerts must alternate. Also keep in mind that alerts run a distinct instance of your script on different servers, so discrepancies between the behavior of scripts running on charts and alerts can occur, especially if they trigger very often.
Challenges
Events detected in realtime using variables declared with varip can be transient and not leave visible traces at the close of the realtime bar, as is the case with our script, which can trigger multiple alerts during the same realtime bar, when the script's inputs allow for this. In such cases, elapsed realtime bars will be of no use in detecting past realtime bar events unless dedicated code is used to save traces of events, as we do with our alert log in this script, which we display as a tooltip on elapsed realtime bars.
█ NOTES
Realtime updates
We have no control over when realtime updates occur. A realtime bar can open, and then no realtime updates can occur until the open of the next realtime bar. The time between updates can vary considerably.
Past values
There is no mechanism to refer to past values of a varip variable across realtime executions in the same bar. Using the history-referencing operator will, as usual, return the variable's committed value on previous bars. If you want to preserve past values of a varip variable, they must be saved in other variables or in an array .
Resetting variables
Because varip variables not only preserve their values across realtime updates, but also across bars, you will typically need to plan conditions that will at some point reset their values to a known state. Testing on barstate.isnew , as we do, is a good way to achieve that.
Repainting
The fact that a script uses varip does not make it necessarily repainting. A script could conceivably use varip to calculate values saved when the realtime bar closes, and then use confirmed values of those calculations from the previous bar to trigger alerts or display plots, avoiding repaint.
timenow resolution
Although the variable is expressed in milliseconds it has an actual resolution of seconds, so it only increments in multiples of 1000 milliseconds.
Warn script users
When using varip to implement logic that cannot be replicated on historical bars, it's really important to explain this to traders in published script descriptions, even if you publish open-source. Remember that most TradingViewers do not know Pine.
New Pine features used in this script
This script uses three new Pine features:
• varip
• The `tooltip` parameter in input() .
• The new += assignment operator. See these also: -= , *= , /= and %= .
Example scripts
These are other scripts by PineCoders that use varip :
• Tick Delta Volume , by RicadoSantos .
• Tick Chart and Volume Info from Lower Time Frames by LonesomeTheBlue .
Thanks
Thanks to the PineCoders who helped improve this publication—especially to bmistiaen .
Look first. Then leap.
Bitcoin Funds OverlayOverlay the Net Asset Value per Unit (NAVPU) of 4 different Bitcoin Funds on your Bitcoin chart.
BTCC ETF
QBTC Fund
GBTC Trust
VBTC ETN
This indicator uses the metrics from the fund management websites to calculate the "Net Asset Value per Unit (NAVPU)" to display the true underlying value of the fund.
Note that the metrics can change and therefore the graph is not accurate for long past timeframes.
You can update the metrics for each fund in the settings dialogue.
The script will autodetect the currency pairs of your current graph and only display compatible funds:
BTC / USD will show BTCC.U, QBTC.U and GBTC
BTC / CAD will show BTCC and QBTC
BTC / EUR will show VBTC
The script should not show in other currency pairs so it will not mess up other charts you might switch to.
If you find bugs with this logic, please comment below so I can fix them.
Due to TradingViews "no-links in description" policy, you need to google each funds website yourself to find the current metrics. These search terms should help:
BTCC search "Purpose Bitcoin ETF"
QBTC search "3iq The Bitcoin Fund (QBTC)"
GBTC search "Grayscale® Bitcoin Trust"
VBTC search "VanEck Vectors Bitcoin ETN"
Risk Management: Position Size & Risk RewardHere is a Risk Management Indicator that calculates stop loss and position sizing based on the volatility of the stock. Most traders use a basic 1 or 2% Risk Rule, where they will not risk more than 1 or 2% of their capital on any one trade. I went further and applied four levels of risk: 0.25%, 0.50%, 1% and 2%. How you apply these different levels of risk is what makes this indicator extremely useful. Here are some common ways to apply this script:
• If the stock is extremely volatile and has a better than 50% chance of hitting the stop loss, then risk only 0.25% of your capital on that trade.
• If a stock has low volatility and has less than 20% change of hitting the stop loss, then risk 2% of your capital on that trade.
• Risking anywhere between 0.25% and 2% is purely based on your intuition and assessment of the market.
• If you are on a losing streak and you want to cut back on your position sizing, then lowering the Risk % can help you weather the storm.
• If you are on a winning streak and your entries are experiencing a higher level of success, then gradually increase the Risk % to reap bigger profits.
• If you want to trade outside the noise of the market or take on more noise/risk, you can adjust the ATR Factor.
• … and whatever else you can imagine using it to benefit your trading.
The position size is calculated using the Capital and Risk % fields, which is the percentage of your total trading capital (a.k.a net liquidity or Capital at Risk). If you instead want to calculate the position size based on a specific amount of money, then enter the amount in the Custom Risk Amt input box. Any amount greater than 0 in the Custom Risk Amt field will override the values in the Capital and Risk % fields.
The stop loss is calculated by using the ATR. The default setting is the 14 RMA, but you can change the length and smoothing of the true range moving average to your liking. Selecting a different length and smoothing affects the stop loss and position size, so choose these values very carefully.
The ATR Factor is a multiplier of the ATR. The ATR Factor can be used to adjust the stop loss and move it outside of the market noise. For the more volatile stock, increase the factor to lower the stop loss and reduce the chance of getting stopped out. For stocks with less volatility , you can lower the factor to raise the stop loss and increase position size. Adjusting the ATR Factor can also be useful when you want the stop loss to be at or below key levels of support.
The Market Session is the hours the market is open. The Market Session only affects the Opening Range Breakout (ORB) option, so it’s important to change these values if you’re trading the ORB and you’re outside of Eastern Standard Time or you’re trading in a foreign exchange.
The ORB is a bonus to the script. When enabled, the indicator will only appear in the first green candle of the day (09:30:00 or 09:30 AM EST or the start time specified in Market Session). When using the ORB, the stop loss is based on the spread of the first candle at the Open. The spread is the difference between the High and Low of the green candle. On 1-day or higher timeframes, the indicator will be the spread of the last (or current) candle.
The output of the indicator is a label overlaying the chart:
1. ATR (14 RMA x2) – This indicated that the stop loss is determined by the ATR. The x2 is the ATR Factor. If ORB is selected, then the first line will show SPREAD, instead of ATR.
2. Capital – This is your total capital or capital at risk.
3. Risk X% of Capital – The amount you’re risking on a % of the Capital. If a Custom Risk Amt is entered, then Risk Amount will be shown in place of Capital and Risk % of Capital.
4. Entry – The current price.
5. Stop Loss – The stop loss price.
6. -1R – The stop loss price and the amount that will be lost of the stop loss is hit.
7. – These are the target prices, or levels where you will want to take profit.
This script is primarily meant for people who are new to active trading and who are looking for a sound risk management strategy based on market volatility . This script can also be used by the more experienced trader who is using a similar system, but also wants to see it applied as an indicator on TradingView. I’m looking forward to maintaining this script and making it better in future revisions. If you want to include or change anything you believe will be a good change or feature, then please contact me in TradingView.
Theil–Sen EstimatorThe Theil-Sen estimator is a nonparametric statistics method for robustly fitting a regression line to sample points (1,2).
As stated in the Wikipedia article (3), the method is " the most popular nonparametric technique for estimating a linear trend " in the applied sciences due to its robustness to outliers and limited assumptions regarding measurement errors.
Relation with other Methods
The Theil-Sen estimator can be significantly more accurate than simple linear regression (least squares) for skewed and heteroskedastic data.
Method Description
The script computes all the slopes between pairs of points and takes the median as the estimate of the regression slope, m . Subsequently, the intercept, b , is determined from the sample points as the median of y(i) − m x(i) values. The regression line in the slope–intercept form, y = m x + b , is then plotted along with the calculated prediction interval (estimated by means of the root-mean-square error).
I have added two options for how to handle pairs of points:
Method == "All" to use the slopes of all pairs of points;
Method == "Random" to use the slopes of randomly generated pairs of points.
The random choice of the pairs of points is based on the Wichmann–Hill is a pseudorandom number generator.
The reason for introducing the "Random" method is that the calculation of the median involves sorting the array of slopes (the size of N*(N-1)/2, where N is the number of sample points). This is a computationally demanding procedure, which runs into the limit on the cycle computation time (200 ms) set in TradingView. Therefore, the "All" method works only with Length < 50.
Also note that the number of lookback points is limited by by the maximum array size allowed in TradingView.
Literature
1. Sen, P. K. (1968) "Estimates of the regression coefficient based on Kendall's tau." JASA, 1379-1389.
2. Theil, H. (1950) "A rank-invariant method of linear and polynomial regression analysis." Reprinted in 1992 in Henri Theil’s contributions to economics and econometrics, Springer, 345-381.
3. en.wikipedia.org
Machine Learning: LVQ-based StrategyLVQ-based Strategy (FX and Crypto)
Description:
Learning Vector Quantization (LVQ) can be understood as a special case of an artificial neural network, more precisely, it applies a winner-take-all learning-based approach. It is based on prototype supervised learning classification task and trains its weights through a competitive learning algorithm.
Algorithm:
Initialize weights
Train for 1 to N number of epochs
- Select a training example
- Compute the winning vector
- Update the winning vector
Classify test sample
The LVQ algorithm offers a framework to test various indicators easily to see if they have got any *predictive value*. One can easily add cog, wpr and others.
Note: TradingViews's playback feature helps to see this strategy in action. The algo is tested with BTCUSD/1Hour.
Warning: This is a preliminary version! Signals ARE repainting.
***Warning***: Signals LARGELY depend on hyperparams (lrate and epochs).
Style tags: Trend Following, Trend Analysis
Asset class: Equities, Futures, ETFs, Currencies and Commodities
Dataset: FX Minutes/Hours+++/Days
Machine Learning: Logistic RegressionMulti-timeframe Strategy based on Logistic Regression algorithm
Description:
This strategy uses a classic machine learning algorithm that came from statistics - Logistic Regression (LR).
The first and most important thing about logistic regression is that it is not a 'Regression' but a 'Classification' algorithm. The name itself is somewhat misleading. Regression gives a continuous numeric output but most of the time we need the output in classes (i.e. categorical, discrete). For example, we want to classify emails into “spam” or 'not spam', classify treatment into “success” or 'failure', classify statement into “right” or 'wrong', classify election data into 'fraudulent vote' or 'non-fraudulent vote', classify market move into 'long' or 'short' and so on. These are the examples of logistic regression having a binary output (also called dichotomous).
You can also think of logistic regression as a special case of linear regression when the outcome variable is categorical, where we are using log of odds as dependent variable. In simple words, it predicts the probability of occurrence of an event by fitting data to a logit function.
Basically, the theory behind Logistic Regression is very similar to the one from Linear Regression, where we seek to draw a best-fitting line over data points, but in Logistic Regression, we don’t directly fit a straight line to our data like in linear regression. Instead, we fit a S shaped curve, called Sigmoid, to our observations, that best SEPARATES data points. Technically speaking, the main goal of building the model is to find the parameters (weights) using gradient descent.
In this script the LR algorithm is retrained on each new bar trying to classify it into one of the two categories. This is done via the logistic_regression function by updating the weights w in the loop that continues for iterations number of times. In the end the weights are passed through the sigmoid function, yielding a prediction.
Mind that some assets require to modify the script's input parameters. For instance, when used with BTCUSD and USDJPY, the 'Normalization Lookback' parameter should be set down to 4 (2,...,5..), and optionally the 'Use Price Data for Signal Generation?' parameter should be checked. The defaults were tested with EURUSD.
Note: TradingViews's playback feature helps to see this strategy in action.
Warning: Signals ARE repainting.
Style tags: Trend Following, Trend Analysis
Asset class: Equities, Futures, ETFs, Currencies and Commodities
Dataset: FX Minutes/Hours/Days
Machine Learning: Perceptron-based strategyPerceptron-based strategy
Description:
The Learning Perceptron is the simplest possible artificial neural network (ANN), consisting of just a single neuron and capable of learning a certain class of binary classification problems. The idea behind ANNs is that by selecting good values for the weight parameters (and the bias), the ANN can model the relationships between the inputs and some target.
Generally, ANN neurons receive a number of inputs, weight each of those inputs, sum the weights, and then transform that sum using a special function called an activation function. The output of that activation function is then either used as the prediction (in a single neuron model) or is combined with the outputs of other neurons for further use in more complex models.
The purpose of the activation function is to take the input signal (that’s the weighted sum of the inputs and the bias) and turn it into an output signal. Think of this activation function as firing (activating) the neuron when it returns 1, and doing nothing when it returns 0. This sort of computation is accomplished with a function called step function: f(z) = {1 if z > 0 else 0}. This function then transforms any weighted sum of the inputs and converts it into a binary output (either 1 or 0). The trick to making this useful is finding (learning) a set of weights that lead to good predictions using this activation function.
Training our perceptron is simply a matter of initializing the weights to zero (or random value) and then implementing the perceptron learning rule, which just updates the weights based on the error of each observation with the current weights. This has the effect of moving the classifier’s decision boundary in the direction that would have helped it classify the last observation correctly. This is achieved via a for loop which iterates over each observation, making a prediction of each observation, calculating the error of that prediction and then updating the weights accordingly. In this way, weights are gradually updated until they converge. Each sweep through the training data is called an epoch.
In this script the perceptron is retrained on each new bar trying to classify this bar by drawing the moving average curve above or below the bar.
This script was tested with BTCUSD, USDJPY, and EURUSD.
Note: TradingViews's playback feature helps to see this strategy in action.
Warning: Signals ARE repainting.
Style tags: Trend Following, Trend Analysis
Asset class: Equities, Futures, ETFs, Currencies and Commodities
Dataset: FX Minutes/Hours+/Days
