Time Locked Moving AverageSuccinct Description
Generates moving average that stays locked to users desired time preference.
Verbose Description
The default moving average indicator does not stay locked to the chart timeframe. Meaning, if you want to see a 1 day SMA on a 15 minute chart, you have to do math and adjust the moving average length to 96.
Needing to do this constantly (especially while flipping through multiple time frames) was really annoying, so I codded up this script to do it for me... and now it can for you too!
Error Handling
If you receive a 'study error' that says, "function sma references too many candles in history".
Go to the Time Locked Moving Average settings and increase the timeframe interval until error goes away.
Furthermore, UNCHECK gaps, to show real-time approximated moving average values.
Enjoy :)
ค้นหาในสคริปต์สำหรับ "gaps"
TLS Psychological Levels (GOLD)This script automatically marks out your $5 levels on XAU/USD. Custom gaps can be set in the settings, you can also adjust the height of the bottom line if needed (Then all other levels will follow). -JG
Daily DeviationShows you the normal deviation from the OPEN based upon historical data.
Levels measured:
Normal range (1 standard deviation) of the CLOSE (vs the OPEN).
Normal daily HIGH +1, +2, +3, and +4 standard deviations.
Normal daily LOW -1, -2, -3, and -4 standard deviations.
Configuration:
Always shows you the normal CLOSE vs OPEN range for the current session.
Can display previous day's ranges (extra days) based upon the calendar (not trading days).
Normally displays which levels have been exceeded (to reduce noise and keep auto-scale to a minimum), but can show all the ranges for the current session.
The default number of days to measure (50) will affect the accuracy but outliers are cleaned to avoid dramatic variance.
Note:
These are only statistical representations of what has occurred in the past. You can interpret the current price as oversold or overbought for the day (and only that day) relative to the OPEN. Gaps high or low are not considered in the equation.
GMT Offset, without using security fn - showcaseThis script is a demo of how one can avoid the use of the request.security function and get values for a number of previous day's open/high/low/close
where the user can define a custom "start of the day" using the GMT input. This allows the user to be independent of the exchange timezone
that the security function uses internally.
Implications of this include:
Suppose you want to treat the start of your day as the NZX market open which is at 2000 UTC+0 and base you indicator calculations
on the NZK market midnight as opposed to the chart exchange timezone.
The indicator purpose is to showcase how that can be achieved in code.
If security function in the future is modified to accept a timezone parameter - obviously this code will no longer be needed as such.
We do two things here:
We plot the values for open high low close using the calc_ohlc_daysback as circles
Then we use the f_security function to get the same values but using security and plot them using solid lines
We do this both on the daily and weekly values.
What we expect to see is the lines matching thus proving that the calc_ohlc_daysback works correctly as compared to security function.
Note - the chart gmt default value is set to 0 which means the comparison will work correctly out of the box on exchanges that have weekend data.
The script is designed to work on intraday timeframes highest being 4 hour and lowest being 3 min
(programmatically the script is no bounded as sich to the intraday timeframe however if not enough data is present at a particular timeframe
values needed to display the lines will be null and hence the lines will not print.)
You can get the same results on other exchanges but might need to change the value of chart gmt
Script does not work on exchanges that have gaps on the weekend at this time
Now all of this can obviously be done with the security function - why go through the trouble? Well with security function you are bound to
the timezone of the exchange you are on. Doing it this way you are no longer bound by the exchange timezone and you can effectively change
the time at which the day starts independent of any exchange. Go ahead - change the GMT offset in settings
Future enhancements:
a) Deal with exchanges where "bar merge" is required - if possible (detect that an exchange does not have weekend data basically)
b) Deal with lower timeframes if possible (on the minute timeframe there is usually not enough data in the series to calc values several weeks back)
c) Make a library for this functionality - this will be optimal so one does not need to copy paste code.
d) Expand library to add GMT auto adjust (specifically around DST in different countries). Today this is a challenge as no relizble way exists to
extract the UTC offset from an syminfo.timezone given that syminfo.timezone returns text such as "America/New York"
For example - one might have 3 session thst they want to work with. Tokio, London and New York. Tokio does not follow DST so the market session starts at the same time all year round. London observes DST but at a different time from New York. So in order to have all this in the same chart and have it auto adjust is a bit of a challenge. With the DST offset functions - this is possible to do. (
Well, that is unless the awesome TV devs push out v6 where that is build in the security function (for it to accept a timezone offset other) in which case the code here will become useless.
Foot notes:
This script is inspired by Traders Reality indicator by @infernixx (developed by @plasmapug with additional modifications by @infernixx and @Peshocore)
Special thanks to @JayRogers for INSECURITY() which inspired the development of calc_ohlc_daysback
Elder Impulse System + ATR BandsDisregard the above chart, I am not sure why it isn't showing the one I want, which is linked below:
This is as far as I can tell the closest representation to Dr. Alexander Elder's updated "Elder Impulse System" that has added ATR-volatility bands up to 3x deviations from price. I got the idea from watching this recent video (www.youtube.com) of Dr. Elder reviewing some recent trades and noticed he had updated his system from his original books. The Impulse System colour coding was inspired by AstralLoverFlow and LazyBear. ATR Bands are pre-programmed Keltner Channels with some modifications such as filing in the ATR Zones with user-selected colour bands and modifying the ATR value to better suit the volatility of the market being traded.
The script has several components, which I will detail below:
Exponential Moving Averages:
1) A 13-period EMA that is used as a staple in all of Dr. Elder's technical analysis. He uses this EMA as the basis for all of his indicators and why it is included here.
2) A 26-period EMA which can be used as a base-line of sorts to filter when to go long or when to go short. For instance, price over the 26-EMA, price is strong and the rally upwards is likely to continue, underneath it, price is weak and likely to continue downwards for a time.
Volatility Bands:
By definition these are nothing more than 3 separate Keltner Channels of a 13-period EMA each set to one additional multiplier from the moving average. This gives us a 1x, 2x, and 3x multiplier of average volatility from the 13-period EMA based on a 14-period Average True Range (ATR) reading. The ATR was chosen as it accommodates price gaps and also is the standard formula calculation in TradingView. The values of the bands cannot be adjusted but the colour coding of them can be.
Elder Impulse System:
These colour-coded bars show you the strength and direction of the current chart resolution, calculated by the slope of a 13-period EMA and the slope of a MACD histogram. These are used not as a buying or selling recommendation alone but as trend filters, as per Dr. Elder's own description of them.
Green Bars = The 13-period EMA is sloping positively and the MACD histogram is rising compared to previous bars. The trader should only consider buying/long opportunities when a green bar is most recent.
Red Bars = The 13-period EMA is sloping negatively and the MACD histogram is falling compared to previous bars. The trader should only consider selling/short opportunities when a red bar is most recent.
Blue Bars = The 13-period EMA and the MACD histogram are not aligned. One of the indicators is sloping opposite to the other indicator. These are known as indecision bars and are typically seen near the end of a previously established trend. The trader can choose to wait for either a green or red bar to shape their trading bias if they are more risk-averse while a counter-trend trader may decide to try opening a position against the currently-established trend.
How To Trade the System:
This system is unique in that it is so versatile and will fit the styles of many traders, be it trend following traders (generally the original Elder Impulse System design) or mean-reversion/counter-trend trading (the original Keltner Channel design). None of the examples below or in the chart above are financial advice and are just there for demonstration purposes only.
1) The most basic signal given would be the moving average cross up or down. A cross of the 13-EMA over the 26-EMA signals upward trend strength and the trader could look for buying opportunities. Conversely, the 13-EMA under the 26-EMA shows downward trend strength and the trader could look for selling opportunities.
2) Following the Elder Impulse system in conjunction with the EMAs. Look for long opportunities when a green bar is printed and price is over both of the 13- and 26-period EMAs. Look for short opportunities when a red bar is printed and price is below both of the 13- and 26-period EMAs. Keep in mind this does not necessarily need a moving average cross to be viable, a green or red bar over both EMAs is a valid signal in this system, usually. Examine price more closely for better entry signals when a blue bar is printed and price is either above or below both EMAs if you are a trend trader. This is how Dr. Elder originally intended the system to be used in conjunction with his famous Triple Screen Trading System. I am not going into detail here as it is a deep subject but I would suggest an interested trader to examine this Triple Screen System further as it is widely accepted as a strong strategy.
3) Mean Reversion and Counter-Trend Trading. Dr. Elder mentions that the zone between the two EMAs is called the Value Zone. A mean reversion trader could look for buying opportunities if price has generally been in an uptrend and falls back to value, conversely, they could look for shorting opportunities if price has generally been in a downtrend and rises back to value. These are your very basic pull backs found in trends that create your higher lows in an uptrend or your lower highs in a downtrend. A mean reversion/scalper trader may also look to use the upper and lower most ATR bands as an indication of price being overbought or oversold and could look to enter a counter-trend trade here once a blue indecision bar is printed and to ride that move back down to the Value Zone.
Taking Profits and Risk Management
This system again is very versatile and will fit a wide range of trading styles. It has built in take profit levels and risk management depending on your style of trading.
1a) In original Triple Screen Trading (and the original Elder Impulse system), a trader was to place a buy order one tick above a newly printed green bar with a stop loss one tick below the most recent 2-day low, and vice-versa for red bars on short selling. as long as other criteria were met, that I will not go into. It is all over YouTube and in his books and on Investopedia if you want more information. The general idea is to continue the trend in the direction if price is strong and you are bought into that move with a close stop, or if price falls back a little bit, you can get in at a better price. This would be a system typically better suited to a scalper.
1b) The updated risk management according to the above video is to place a stop loss at least 2ATR away from price. These bands already have calculated these values so a trader can place a stop one tick below the 2 or even 3ATR zones depending on their risk appetite. This is assuming you have already received a strong buy signal based on the system you follow. This would be a system typically better suited to a trend-trader.
2a) Taking profits if you are a trend trader has several possibilities. The first, as Dr. Elder suggests, is to place a price target 2ATR values away from your entry giving you approximately a 1:1 risk-reward ratio.
2b) The second possibility if the trade is successful is to ride the trend upwards until a blue bar is printed, suggesting indecision in the market. A modified version of this that could let a winning trade run longer is to wait for the price to close under the 13-EMA in fast markets, or close under the 26-EMA in slightly slower markets to maximize potential winnings.
2c) A scalper trader may wish to have a target at either the value zone if they are playing an extended buy/short back to the mean, or if they are being at the mean, to sell or cover when price extends back out to the 2x or 3x zone.
3) Trend traders can additionally use the ATR zones as a sort of safety guidelines for entering a trade. Anything within the 1ATR zone is typically a safer entry as the market is less volatile at this time. Entering when price has gone into the 2ATR zone is signaled as a strong momentum move and can signal a stronger move in the direction of the current closing bar. While not always the case, it is suggested by Dr. Elder to not enter trend trades at the 3ATR zone as this is where you will be likely looking for a counter-trend retracement back to value and a trader entering here in the direction of the trade has a higher chance of being stopped out or not getting in at the best possible price.
Special Time PeriodWith this indicator, you can choose candles in the period you want on your chart.
How ?
• If your chart is 5 minutes, the duration should be greater than 5 on this indicator.
If you do not do it this way, there will be gaps in the price, it will not give the right result.
• If you want to see it in minutes, you must enter a direct numerical value. For example, to see 2 hours, you must enter the number 120. Because 2 hours is 120 minutes.
Like the warning above, if you want to plot a 2-hour chart with this indicator, a maximum of 1 hour should be selected on your main chart.
• Resolution, eg. '60' - 60 minutes, 'D' - daily, 'W' - weekly, 'M' - monthly, '5D' - 5 days, '12M' - one year, '3M' - one quarter
• For example, if you want to see the 2-day chart, you should have a maximum of 1 day chart open on your home screen and write "2D" to the indicator value.
• You will get much better results if the period on your main chart and the period on this indicator are multiples of each other.
• In the image below, the period on the main chart is 30 minutes, but the period on the indicator is 90
• Click on the facing brackets at the top right of the legend and your chart will enlarge.
MTF WatchList Charts [Anan]█ OVERVIEW
I am happy to present this script with a nice idea!
You can now customize a watchlist with your preferred time frame and any symbol from any market.
The main purpose is to be aware of any moves and watch a brief overview of the chart.
█ FEATURES
- 8 customizable symbols with the option to show/hide anyone
- Multi time frame support
- 3 Types of charts (Candles / Heikin Ashi / Line)
- Displaying up to 10 candles for every chart
- Customizable chart colors
- Option to Show/hide Price
- Option to Show/hide Price Line
- Option to change Labels and Text Size
- Show Symbol name and used time frame
- Option to change gaps between charts
- Hover over on the top of any candle to see (Open/High/Low/Close) Prices
█ SCREENSHOTS
-----------------------------------------------
Special thanks to @dgtrd for inspiration and for the amazing framework used here ( HTF Candles by DGT )
Special thanks to Pine Chat @fareidzulkifli @Bjorgum @JohnBaron @fpainchaud
Gap Indicator (Ruscio)Gap Indicator
This indicator allows you to view the market gaps on any underlying, and check through the statistics panel how many times the stock closes the session in the direction of the opening gap.
CME Gap BTCThis script highlights the CME gap. It takes the daily close from Friday from CME Futures Bitcoin security (can be switched) and plots the difference from current close.
With the premise that CME gaps will be filled next week; when the current close is higher than Friday close, it plots a bear color, when the current close is lower, it plots a bull color. Colors can be changed
Single Prints - Session Initial BalancesDisclaimer: Expose yourself to the knowledge of different trading methods. If you are unaware of what a Single Print is then do some research and broaden your knowledge.
This indicator has only been tested on BTCUSDT Binance pair. This indicator is meant to be used on the 30 minute timeframe to highlight Single Prints.
The calculations are base on 0000 UTC and what Single Prints are created during that day.
Single Prints
Single Prints are where prices moves to fast through an area (on a 30 minute timeframe), in the case of this indicator in $50 intervals, where the price has not yet cross back past, represented as orange lines. If you were viewing this on a Time Price Opportunity Chart (TPO) each $50 would be represented as a square with a letter in it. If price has only been through that area once, within that 24 hour period, then it is called a Single Print. If however the Single Print is on the lower wick of the candle it is called a Buying Tail and on the Upper Wick a Selling Tail.
Single Prints leave low volume nodes with liquidity gaps, these inefficient moves tend to get filled, and we can seek trading opportunities once they get filled, or we can also enter before they get filled and use these single prints as targets.
Single Prints are a sign of emotional buying or selling as very little time was spent at those levels and thus there is no value there.
The endpoints of single print sections are considered to be potential support or resistance points and or get filled (like a CME gap).
The above is only a very short summary, to understand Single Prints, Buying Tails and Selling Tails more please do your own research (DYOR).
References:
Trading Riot Volume Profile - Website
TOROS TPO Charts Explained - Youtube
Session Boxes
Session Boxes are the high and low of that markets session before the new market session opens. I used the data from the website Trading Hours for the time input.
White box – Start of day UTC 0000 to Market Close UTC 2000
Purple box – Asia Start UTC 0130 to London Start UTC 0700
Yellow box – London Start UTC 0700 to New York Start UTC 1330
Blue box – New York Start UTC 1330 to Market Close UTC 2000
Red box – Market Close UTC 2000 to End of day UTC 2359
References:
Trading Hours - Website
Initial Balance
The Initial Balance is the market range between the high and low of the first hour of trading for the market. In the case of crypto when is the Initial Balance if it is 24/7.
Context of Initial Balance:
The Initial Balance is traditionally the range of prices transacted in the first hour of trade. Many regard the Initial Balance as a significant range because, especially for the index futures which are tied to the underlying stocks, orders entered overnight or before the open are typically executed prior to the end of the first hour of trade. Some use it to understand how the rest of the day may develop, while others use it as a span of time to avoid trading altogether because of its potential volatility.
For this indicator I have coded the Initial Balance time as below:
White Box - To appear for the first hour of the day 0000 to 0100 UTC .
Purple Box - To appear for the first hour of the day 0130 to 0230 UTC .
Yellow Box - To appear for the first hour of the day 0700 to 0800 UTC .
Blue Box - To appear for the first hour of the day 1330 to 1430 UTC .
Red Box - To appear for the first hour of the day 2000 to 2100 UTC .
The diagram above shows some examples:
How price (white arrows) retraces the single prints.
How price (red arrows) uses the single prints as S/R.
References:
Not Hard Trading – Website
My Pivots Initial Balance - Website
Thanks go to:
StackOverFlow Bjorn Mistiaen
Trading View user mvs1231
Please message me if you have any feedback/questions.
I am looking at developing this indicator further in the future.
Net VolumeNet Volume, or NV in short, is a cumulative volume indicator similar to OBV and A/D. Though it might look similar to these two indicators (especially A/D), rest assured it's better and more accurate than both. What it basically does, is dividing the volume session into buyers and sellers volumes; then subtracts former from the latter and adds the result to previous session's net volume (In the script, these two intermediate volumes are not calculated and only the subtraction is formulated in an integrated form).
Another important difference between NV and A/D indicator, is that it brings price gaps into account. That's why it requires next session's open price to calculate current session's NV. What it actually mean is that the price gap, in either direction, is the result of the traders' efforts in respective direction in previous session, as if the current session closes where next session opens.
Imbalance FinderImbalance Finder
I struggled to always see it visually this marks whether there is or isn't imbalance
Very quick way of finding imbalance between bars
HTF Candles by Prosum SolutionsOverview of Features
This indicator was inspired by the work of "informanerd" in the script called "HTF Candles" as well as the built-in script called "Multi-Time Period Charts" by TradingView. The script will provide a highly customizable interface to specify the higher timeframe resolution for the candlesticks, the type of candle, as well as various styling options for the body, borders and wicks.
Usage Information
The indicator can be applied to any chart at any time frame, but resolutions less than 1 minute may demonstrate gaps between bars and the candles may not render properly.
When the "Same as chart" option is chosen for the "Resolution" field, the indicator will attempt to find a higher timeframe resolution to ensure the candlesticks are drawn.
Enjoy! 👍
How to use Leverage and Margin in PineScriptEn route to being absolutely the best and most complete trading platform out there, TradingView has just closed 2 gaps in their PineScript language.
It is now possible to create and backtest a strategy for trading with leverage.
Backtester now produces Margin Calls - so recognizes mid-trade drawdown and if it is too big for the broker to maintain your trade, some part of if will be instantly closed.
New additions were announced in official blogpost , but it lacked code examples, so I have decided to publish this script. Having said that - this is purely educational stuff.
█ LEVERAGE
Let's start with the Leverage. I will discuss this assuming we are always entering trades with some percentage of our equity balance (default_qty_type = strategy.percent_of_equity), not fixed order quantity.
If you want to trade with 1:1 leverage (so no leverage) and enter a trade with all money in your trading account, then first line of your strategy script must include this parameter:
default_qty_value = 100 // which stands for 100%
Now, if you want to trade with 30:1 leverage, you need to multipy the quantity by 30x, so you'd get 30 x 100 = 3000:
default_qty_value = 3000 // which stands for 3000%
And you can play around with this value as you wish, so if you want to enter each trade with 10% equity on 15:1 leverage you'd get default_qty_value = 150.
That's easy. Of course you can modify this quantity value not only in the script, but also afterwards in Script Settings popup, "Properties" tab.
█ MARGIN
Second newly released feature is Margin calculation together with Margin Calls. If the market goes against your trades and your trading account cannot maintain mid-trade drawdown - those trades will be closed in full or partly. Also, if your trading account cannot afford to open more trades (pyramiding those trades), Margin mechanism will prevent them from being entered.
I will not go into details about how Margin calculation works, it was all explainged in above mentioned blogpost and documentation .
All you need to do is to add two parameters to the opening line of your script:
margin_long = 1./30*50, margin_short = 1./30*50
Whereas "30" is a leverage scale as in 30:1, and "50" stands for 50% of Margin required by your broker. Personally the Required Margin number I've met most often is 50%, so I'm using value 50 here, but there are literally 1000+ brokers in this world and this is individual decision by each of them, so you'd better ask yourself.
--------------------
Please note, that if you ever encounter a strategy which triggers Margin Call at least once, then it is probably a very bad strategy. Margin Call is a last resort, last security measure - all the risks should be calculated by the strategy algorithm before it is ever hit. So if you see a Margin Call being triggred, then something is wrong with risk management of the strategy. Therefore - don't use it!
Crypto Tripple RSIGives an ability to compare 3 RSIs:
current altcoin + BTC (e.g. ADABTC) - green by default
current pair (e.g. ADAUSDT) - blue by default
BTC (e.g. BTCUSDT) - yellow by default
It helps to understand the cause of price change - whether BTC provokes price change or not. Also it shows performance of an altcoin - the bigger gaps between RSIs, the stronger (RSI of BTC is on the bottom)/ weaker (RSI of BTC is on the top) altcoin is.
FibFans on Previous HTF HL [FaizanNawaz] by DGTFibonacci Fans application on top of Previous Higher TimeFrame High and Low. Idea owner is @faizannawaz1, special thanks to him for both the idea and tesing the application
WARNING : Study includes plottings in the future, and due to temporal gaps in non 7/24 markets such as weekends, holidays etc plotting of the fans will move to the open session (the effect will be observed on Friday and Monday). With crypto no any side affect will be observed.
More about Fibonacci Fans, how to apply fibonacci fans and automated fibonacci speed and resistance fans study
Adiitonally the study includes some addons, such as
Central Pivot Range and Traditional Pivot Points
Volume Weighted Colored Bars
Price Range Meter - Horizontal HTF Candle
Disclaimer :
Trading success is all about following your trading strategy and the indicators should fit within your trading strategy, and not to be traded upon solely
The script is for informational and educational purposes only. Use of the script does not constitute professional and/or financial advice. You alone have the sole responsibility of evaluating the script output and risks associated with the use of the script. In exchange for using the script, you agree not to hold dgtrd TradingView user liable for any possible claim for damages arising from any decision you make based on use of the script
Data Gap PointerUpdating the v3 script made by u/Lemrin + some mods
What this does:
Paints a blue "down arrow" pointer at an intraday bar that has occurred with a skip (e.g. a 1min bar that occurs a few minutes after the previous bar)
Checks for whether the market is open, and only paints arrows if inside open hours (because Extended Hours have lots of bar gaps)
Pinescript - Common Label & Line Array Functions Library by RRBPinescript - Common Label & Line Array Functions Library by RagingRocketBull 2021
Version 1.0
This script provides a library of common array functions for arrays of label and line objects with live testing of all functions.
Using this library you can easily create, update, delete, join label/line object arrays, and get/set properties of individual label/line object array items.
You can find the full list of supported label/line array functions below.
There are several libraries:
- Common String Functions Library
- Standard Array Functions Library
- Common Fixed Type Array Functions Library
- Common Label & Line Array Functions Library
- Common Variable Type Array Functions Library
Features:
- 30 array functions in categories create/update/delete/join/get/set with support for both label/line objects (45+ including all implementations)
- Create, Update label/line object arrays from list/array params
- GET/SET properties of individual label/line array items by index
- Join label/line objects/arrays into a single string for output
- Supports User Input of x,y coords of 5 different types: abs/rel/rel%/inc/inc% list/array, auto transforms x,y input into list/array based on type, base and xloc, translates rel into abs bar indexes
- Supports User Input of lists with shortened names of string properties, auto expands all standard string properties to their full names for use in functions
- Live Output for all/selected functions based on User Input. Test any function for possible errors you may encounter before using in script.
- Output filters: hide all excluded and show only allowed functions using a list of function names
- Output Panel customization options: set custom style, color, text size, and line spacing
Usage:
- select create function - create label/line arrays from lists or arrays (optional). Doesn't affect the update functions. The only change in output should be function name regardless of the selected implementation.
- specify num_objects for both label/line arrays (default is 7)
- specify common anchor point settings x,y base/type for both label/line arrays and GET/SET items in Common Settings
- fill lists with items to use as inputs for create label/line array functions in Create Label/Line Arrays section
- specify label/line array item index and properties to SET in corresponding sections
- select label/line SET function to see the changes applied live
Code Structure:
- translate x,y depending on x,y type, base and xloc as specified in UI (required for all functions)
- expand all shortened standard property names to full names (required for create/update* from arrays and set* functions, not needed for create/update* from lists) to prevent errors in label.new and line.new
- create param arrays from string lists (required for create/update* from arrays and set* functions, not needed for create/update* from lists)
- create label/line array from string lists (property names are auto expanded) or param arrays (requires already expanded properties)
- update entire label/line array or
- get/set label/line array item properties by index
Transforming/Expanding Input values:
- for this script to work on any chart regardless of price/scale, all x*,y* are specified as % increase relative to x0,y0 base levels by default, but user can enter abs x,price values specific for that chart if necessary.
- all lists can be empty, contain 1 or several items, have the same/different lengths. Array Length = min(min(len(list*)), mum_objects) is used to create label/line objects. Missing list items are replaced with default property values.
- when a list contains only 1 item it is duplicated (label name/tooltip is also auto incremented) to match the calculated Array Length
- since this script processes user input, all x,y values must be translated to abs bar indexes before passing them to functions. Your script may provide all data internally and doesn't require this step.
- at first int x, float y arrays are created from user string lists, transformed as described below and returned as x,y arrays.
- translated x,y arrays can then be passed to create from arrays function or can be converted back to x,y string lists for the create from lists function if necessary.
- all translation logic is separated from create/update/set functions for the following reasons:
- to avoid redundant code/dependency on ext functions/reduce local scopes and to be able to translate everything only once in one place - should be faster
- to simplify internal logic of all functions
- because your script may provide all data internally without user input and won't need the translation step
- there are 5 types available for both x,y: abs, rel, rel%, inc, inc%. In addition to that, x can be: bar index or time, y is always price.
- abs - absolute bar index/time from start bar0 (x) or price (y) from 0, is >= 0
- rel - relative bar index/time from cur bar n (x) or price from y0 base level, is >= 0
- rel% - relative % increase of bar index/time (x) or price (y) from corresponding base level (x0 or y0), can be <=> 0
- inc - relative increment (step) for each new level of bar index/time (x) or price (y) from corresponding base level (x0 or y0), can be <=> 0
- inc% - relative % increment (% step) for each new level of bar index/time (x) or price (y) from corresponding base level (x0 or y0), can be <=> 0
- x base level >= 0
- y base level can be 0 (empty) or open, close, high, low of cur bar
- single item x1_list = "50" translates into:
- for x type abs: "50, 50, 50 ..." num_objects times regardless of xloc => x = 50
- for x type rel: "50, 50, 50 ... " num_objects times => x = x_base + 50
- for x type rel%: "50%, 50%, 50% ... " num_objects times => x_base * (1 + 0.5)
- for x type inc: "0, 50, 100 ... " num_objects times => x_base + 50 * i
- for x type inc%: "0%, 50%, 100% ... " num_objects times => x_base * (1 + 0.5 * i)
- when xloc = xloc.bar_index each rel*/inc* value in the above list is then subtracted from n: n - x to convert rel to abs bar index, values of abs type are not affected
- x1_list = "0, 50, 100, ..." of type rel is the same as "50" of type inc
- x1_list = "50, 50, 50, ..." of type abs/rel/rel% produces a sequence of the same values and can be shortened to just "50"
- single item y1_list = "2" translates into (ragardless of yloc):
- for y type abs: "2, 2, 2 ..." num_objects times => y = 2
- for y type rel: "2, 2, 2 ... " num_objects times => y = y_base + 2
- for y type rel%: "2%, 2%, 2% ... " num_objects times => y = y_base * (1 + 0.02)
- for y type inc: "0, 2, 4 ... " num_objects times => y = y_base + 2 * i
- for y type inc%: "0%, 2%, 4% ... " num_objects times => y = y_base * (1 + 0.02 * i)
- when yloc != yloc.price all calculated values above are simply ignored
- y1_list = "0, 2, 4" of type rel% is the same as "2" with type inc%
- y1_list = "2, 2, 2" of type abs/rel/rel% produces a sequence of the same values and can be shortened to just "2"
- you can enter shortened property names in lists. To lookup supported shortened names use corresponding dropdowns in Set Label/Line Array Item Properties sections
- all shortened standard property names must be expanded to full names (required for create/update* from arrays and set* functions, not needed for create/update* from lists) to prevent errors in label.new and line.new
- examples of shortened property names that can be used in lists: bar_index, large, solid, label_right, white, left, left, price
- expanded to their corresponding full names: xloc.bar_index, size.large, line.style_solid, label.style_label_right, color.white, text.align_left, extend.left, yloc.price
- all expanding logic is separated from create/update* from arrays and set* functions for the same reasons as above, and because param arrays already have different types, implying the use of final values.
- all expanding logic is included in the create/update* from lists functions because it seemed more natural to process string lists from user input directly inside the function, since they are already strings.
Creating Label/Line Objects:
- use study max_lines_count and max_labels_count params to increase the max number of label/line objects to 500 (+3) if necessary. Default number of label/line objects is 50 (+3)
- all functions use standard param sequence from methods in reference, except style always comes before colors.
- standard label/line.get* functions only return a few properties, you can't read style, color, width etc.
- label.new(na, na, "") will still create a label with x = n-301, y = NaN, text = "" because max default scope for a var is 300 bars back.
- there are 2 types of color na, label color requires color(na) instead of color_na to prevent error. text_color and line_color can be color_na
- for line to be visible both x1, x2 ends must be visible on screen, also when y1 == y2 => abs(x1 - x2) >= 2 bars => line is visible
- xloc.bar_index line uses abs x1, x2 indexes and can only be within 0 and n ends, where n <= 5000 bars (free accounts) or 10000 bars (paid accounts) limit, can't be plotted into the future
- xloc.bar_time line uses abs x1, x2 times, can't go past bar0 time but can continue past cur bar time into the future, doesn't have a length limit in bars.
- xloc.bar_time line with length = exact number of bars can be plotted only within bar0 and cur bar, can't be plotted into the future reliably because of future gaps due to sessions on some charts
- xloc.bar_index line can't be created on bar 0 with fixed length value because there's only 1 bar of horiz length
- it can be created on cur bar using fixed length x < n <= 5000 or
- created on bar0 using na and then assigned final x* values on cur bar using set_x*
- created on bar0 using n - fixed_length x and then updated on cur bar using set_x*, where n <= 5000
- default orientation of lines (for style_arrow* and extend) is from left to right (from bar 50 to bar 0), it reverses when x1 and x2 are swapped
- price is a function, not a line object property
Variable Type Arrays:
- you can't create an if/function that returns var type value/array - compiler uses strict types and doesn't allow that
- however you can assign array of any type to another array of any type creating an arr pointer of invalid type that must be reassigned to a matching array type before used in any expression to prevent error
- create_any_array2 uses this loophole to return an int_arr pointer of a var type array
- this works for all array types defined with/without var keyword and doesn't work for string arrays defined with var keyword for some reason
- you can't do this with var type vars, only var type arrays because arrays are pointers passed by reference, while vars are actual values passed by value.
- you can only pass a var type value/array param to a function if all functions inside support every type - otherwise error
- alternatively values of every type must be passed simultaneously and processed separately by corresponding if branches/functions supporting these particular types returning a common single type result
- get_var_types solves this problem by generating a list of dummy values of every possible type including the source type, tricking the compiler into allowing a single valid branch to execute without error, while ignoring all dummy results
Notes:
- uses Pinescript v3 Compatibility Framework
- uses Common String Functions Library, Common Fixed Type Array Functions Library, Common Variable Type Array Functions Library
- has to be a separate script to reduce the number of local scopes/compiled file size, can't be merged with another library.
- lets you live test all label/line array functions for errors. If you see an error - change params in UI
- if you see "Loop too long" error - hide/unhide or reattach the script
- if you see "Chart references too many candles" error - change x type or value between abs/rel*. This can happen on charts with 5000+ bars when a rel bar index x is passed to label.new or line.new instead of abs bar index n - x
- create/update_label/line_array* use string lists, while create/update_label/line_array_from_arrays* use array params to create label/line arrays. "from_lists" is dropped to shorten the names of the most commonly used functions.
- create_label/line_array2,4 are preferable, 5,6 are listed for pure demonstration purposes only - don't use them, they don't improve anything but dramatically increase local scopes/compiled file size
- for this reason you would mainly be using create/update_label/line_array2,4 for list params or create/update_label/line_array_from_arrays2 for array params
- all update functions are executed after each create as proof of work and can be disabled. Only create functions are required. Use update functions when necessary - when list/array params are changed by your script.
- both lists and array item properties use the same x,y_type, x,y_base from common settings
- doesn't use pagination, a single str contains all output
- why is this so complicated? What are all these functions for?
- this script merges standard label/line object methods with standard array functions to create a powerful set of label/line object array functions to simplify manipulation of these arrays.
- this library also extends the functionality of Common Variable Type Array Functions Library providing support for label/line types in var type array functions (any_to_str6, join_any_array5)
- creating arrays from either lists or arrays adds a level of flexibility that comes with complexity. It's very likely that in your script you'd have to deal with both string lists as input, and arrays internally, once everything is converted.
- processing user input, allowing customization and targeting for any chart adds a whole new layer of complexity, all inputs must be translated and expanded before used in functions.
- different function implementations can increase/reduce local scopes and compiled file size. Select a version that best suits your needs. Creating complex scripts often requires rewriting your code multiple times to fit the limits, every line matters.
P.S. Don't rely too much on labels, for too often they are fables.
List of functions*:
* - functions from other libraries are not listed
1. Join Functions
Labels
- join_label_object(label_, d1, d2)
- join_label_array(arr, d1, d2)
- join_label_array2(arr, d1, d2, d3)
Lines
- join_line_object(line_, d1, d2)
- join_line_array(arr, d1, d2)
- join_line_array2(arr, d1, d2, d3)
Any Type
- any_to_str6(arr, index, type)
- join_any_array4(arr, d1, d2, type)
- join_any_array5(arr, d, type)
2. GET/SET Functions
Labels
- label_array_get_text(arr, index)
- label_array_get_xy(arr, index)
- label_array_get_fields(arr, index)
- label_array_set_text(arr, index, str)
- label_array_set_xy(arr, index, x, y)
- label_array_set_fields(arr, index, x, y, str)
- label_array_set_all_fields(arr, index, x, y, str, xloc, yloc, label_style, label_color, text_color, text_size, text_align, tooltip)
- label_array_set_all_fields2(arr, index, x, y, str, xloc, yloc, label_style, label_color, text_color, text_size, text_align, tooltip)
Lines
- line_array_get_price(arr, index, bar)
- line_array_get_xy(arr, index)
- line_array_get_fields(arr, index)
- line_array_set_text(arr, index, width)
- line_array_set_xy(arr, index, x1, y1, x2, y2)
- line_array_set_fields(arr, index, x1, y1, x2, y2, width)
- line_array_set_all_fields(arr, index, x1, y1, x2, y2, xloc, extend, line_style, line_color, width)
- line_array_set_all_fields2(arr, index, x1, y1, x2, y2, xloc, extend, line_style, line_color, width)
3. Create/Update/Delete Functions
Labels
- delete_label_array(label_arr)
- create_label_array(list1, list2, list3, list4, list5, d)
- create_label_array2(x_list, y_list, str_list, xloc_list, yloc_list, style_list, color1_list, color2_list, size_list, align_list, tooltip_list, d)
- create_label_array3(x_list, y_list, str_list, xloc_list, yloc_list, style_list, color1_list, color2_list, size_list, align_list, tooltip_list, d)
- create_label_array4(x_list, y_list, str_list, xloc_list, yloc_list, style_list, color1_list, color2_list, size_list, align_list, tooltip_list, d)
- create_label_array5(x_list, y_list, str_list, xloc_list, yloc_list, style_list, color1_list, color2_list, size_list, align_list, tooltip_list, d)
- create_label_array6(x_list, y_list, str_list, xloc_list, yloc_list, style_list, color1_list, color2_list, size_list, align_list, tooltip_list, d)
- update_label_array2(label_arr, x_list, y_list, str_list, xloc_list, yloc_list, style_list, color1_list, color2_list, size_list, align_list, tooltip_list, d)
- update_label_array4(label_arr, x_list, y_list, str_list, xloc_list, yloc_list, style_list, color1_list, color2_list, size_list, align_list, tooltip_list, d)
- create_label_array_from_arrays2(x_arr, y_arr, str_arr, xloc_arr, yloc_arr, style_arr, color1_arr, color2_arr, size_arr, align_arr, tooltip_arr, d)
- create_label_array_from_arrays4(x_arr, y_arr, str_arr, xloc_arr, yloc_arr, style_arr, color1_arr, color2_arr, size_arr, align_arr, tooltip_arr, d)
- update_label_array_from_arrays2(label_arr, x_arr, y_arr, str_arr, xloc_arr, yloc_arr, style_arr, color1_arr, color2_arr, size_arr, align_arr, tooltip_arr, d)
Lines
- delete_line_array(line_arr)
- create_line_array(list1, list2, list3, list4, list5, list6, d)
- create_line_array2(x1_list, y1_list, x2_list, y2_list, xloc_list, extend_list, style_list, color_list, width_list, d)
- create_line_array3(x1_list, y1_list, x2_list, y2_list, xloc_list, extend_list, style_list, color_list, width_list, d)
- create_line_array4(x1_list, y1_list, x2_list, y2_list, xloc_list, extend_list, style_list, color_list, width_list, d)
- create_line_array5(x1_list, y1_list, x2_list, y2_list, xloc_list, extend_list, style_list, color_list, width_list, d)
- create_line_array6(x1_list, y1_list, x2_list, y2_list, xloc_list, extend_list, style_list, color_list, width_list, d)
- update_line_array2(line_arr, x1_list, y1_list, x2_list, y2_list, xloc_list, extend_list, style_list, color_list, width_list, d)
- update_line_array4(line_arr, x1_list, y1_list, x2_list, y2_list, xloc_list, extend_list, style_list, color_list, width_list, d)
- create_line_array_from_arrays2(x1_arr, y1_arr, x2_arr, y2_arr, xloc_arr, extend_arr, style_arr, color_arr, width_arr, d)
- update_line_array_from_arrays2(line_arr, x1_arr, y1_arr, x2_arr, y2_arr, xloc_arr, extend_arr, style_arr, color_arr, width_arr, d)
ADL Balance of PowerThis script brings together Price (blue), Volume (red) in form of adjusted ADL (including gaps) and every ADL candle is split into Buying Volume ADL (green line) and Selling Volume ADL (magenta).
Fundamentally there are a few cases here:
- ADL action normally precedes price action when it corresponds with buying/selling power positions (higher or lower)
- when money flows out and Selling Volume ADL higher than buying volume ADL then price will be trying to catch down until they meet (price and ADL) or until Selling ADL reverses downwards (e.g. selling power is receding)
- when money flows out and Buying Volume higher than Selling ADL it means price is being pushed up on lower volume
- when money flows in and Buying Volume ADL higher than selling volume ADL then price will be trying to catch up until they meet (price and ADL) or until Buying ADL reverses downwards (e.g. buying power is receding)
- when money flows in and Selling Volume higher than Buying ADL it means price is being pushed down on lower volume
VWAP + Fibo Dev Extensions StrategyBased on my VWAP + Fibo deviations indicator, I tested some strategies to see if the indicator can be profitable; and I got it !
This strategy uses:
H1 timeframe
Weekly VWAP
+1.618 / +2.618 / -1.618 / -2.618 Deviations Extensions to create 2 bands
The value of the deviation
First, the 2 bands are plotted : +1.618/+2.618 painted in red and -1.618/-2.618 painted in lime.
Then, we wait for the deviation value to reach at least 150 (see thumbnail) to avoid littles moves when the gaps between bands are too short.
Entry long position :
first candle must crossunder the -1.618 level and low have to stay over the -2.618
low of the second one must stay in the lime band
enter the third one if the deviation value is over limit (150)
Exit long position :
TP : when a high crossover VWAP
SL : when a low crossunder -2.618
Entry short position :
first candle must crossover the +1.618 level and high have to stay under the +2.618
high of the second one must stay in the red band
enter the third one if the deviation value is over limit (150)
Exit short position :
TP : when a low crossunder VWAP
SL : when a high crossover +2.618
Notes :
this strategy uses pyramiding (5), be careful and calculate your risk management
the comission value is set to 0.08% to include slippages when entering a trade because of market orders
This strategy is not an advice to invest, make your own decisions.
Body Gap Detector
This script was inherited from "GAP DETECTOR" by Asch- and the modified version is being published with consent of the author.
This script identifies gap up or gap down between candle bodies (for the selected time frame). The original script has been reworked to consider Open/Close instead of the High/Low. It identifies "Gap" up/down and indicates them with markers drawn from "Open/Close" of one candle to the "Close/Open" of another.
The default setting is to consider the last 1500 candles. "Gap Up" is indicated by Green bars and "Gap Down" is indicated with Red bars.
Freedom of MovementFreedom of Movement Indicator
---------------------------------------------------------
In “Evidence-Based Support & Resistance” article, author Melvin Dickover introduces two new indicators to help traders note support and resistance areas by identifying supply and demand pools. Here you can find the support-resistance technical indicator called "Freedom of Movement".
The indicator takes into account price-volume behavior in order to detect points where movement of price is suddenly restricted, the possible supply and demand pools. These points are also marked by Defended Price Lines (DPLs).
DPLs are horizontal lines that run across the chart at levels defined by following conditions:
* Overlapping bars: If the indicator spike (i.e., indicator is above 2.0 or a custom value) corresponds to a price bar overlapping the previous one, the previous close can be used as the DPL value.
* Very large bars: If the indicator spike corresponds to a price bar of a large size, use its close price as the DPL value.
* Gapping bars: If the indicator spike corresponds to a price bar gapping from the previous bar, the DPL value will depend on the gap size. Small gaps can be ignored: the author suggests using the previous close as the DPL value. When the gap is big, the close of the latter bar is used instead.
* Clustering spikes: If the indicator spikes come in clusters, use the extreme close or open price of the bar corresponding to the last or next to last spike in cluster.
DPLs can be used as support and resistance levels. In order confirm and refine them, FoM (Freedom of Movement) is used along with the Relative Volume Indicator (RVI), which you can find here:
Clustering spikes provide the strongest DPLs while isolated spikes can be used to confirm and refine those provided by the RVI. Coincidence of spikes of the two indicator can be considered a sign of greater strength of the DPL.
More info:
S&C magazine, April 2014.
Grid Like StrategyIt is possible to use progressive position sizing in order to recover from past losses, a well-known position sizing system being the "martingale", which consists of doubling your position size after a loss, this allows you to recover any previous losses in a losing streak + winning an extra. This system has seen a lot of attention from the trading community (mostly from beginners), and many strategies have been designed around the martingale, one of them being "grid trading strategies".
While such strategies often shows promising results on paper, they are often subjects to many frictions during live trading that makes them totally unusable and dangerous to the trader. The motivations behind posting such a strategy isn't to glorify such systems, but rather to present the problems behind them, many users come to me with their ideas and glorious ways to make money, sometimes they present strategies using the martingale, and it is important to present the flaws of this methodology rather than blindly saying "you shouldn't use it".
Strategy Settings
Point determines the "grid" size and should be adjusted accordingly to the scale of the symbol you are applying the strategy to. Higher value would require larger price movements in order to trigger a trade, as such higher values will generate fewer trades.
The order size determines the number of contracts/shares to purchase.
The martingale multiplier determines the factor by which the position size is multiplied after a loss, using values higher to 2 will "squarify" your balance, while a value of 1 would use a constant position sizing.
Finally, the anti-martingale parameter determines whether the strategy uses a reverse martingale or not, if set to true then the position size is multiplied after any wins.
The Grid
Grid strategies are commons and do not present huge problems until we use certain position sizing methods such as the martingale. A martingale is extremely sensitive to any kind of friction (frictional costs, slippage...etc), the grid strategy aims to provide a stable and simple environment where a martingale might possibly behave well.
The goal of a simple grid strategy is to go long once the price crossover a certain level, a take profit is set at the level above the current one and stop loss is placed at the level below the current one, in a winning scenario the price reach the take profit, the position is closed and a new one is opened with the same setup. In a losing scenario, the price reaches the stop loss level, the position is closed and a short one is opened, the take profit is set at the level below the current one, and a stop loss is set at the level above the current one. Note that all levels are equally spaced.
It follows from this strategy that wins and losses should be constant over time, as such our balance would evolve in a linear fashion. This is a great setup for a martingale, as we are theoretically assured to recover all the looses in a losing streak.
Martingale - Exponential Decays - Risk/Reward
By using a martingale we double our position size (exposure) each time we lose a trade, if we look at our balance when using a martingale we see significant drawdowns, with our balance peaking down significantly. The martingale sequence is subject to exponential growth, as such using a martingale makes our balance exposed to exponential decays, that's really bad, we could basically lose all the initially invested capital in a short amount of time, it follows from this that the theoretical success of a martingale is determined by what is the maximum losing streak you can endure
Now consider how a martingale affects our risk-reward ratio, assuming unity position sizing our martingale sequence can be described by 2^(x-1) , using this formula we would get the amount of shares/contracts we need to purchase at the x trade of a losing streak, we would need to purchase 256 contracts in order to recover from a losing streak of size 9, this is enormous when you take into account that your wins are way smaller, the risk-reward ratio is totally unfair.
Of course, some users might think that a losing streak of size 9 is pretty unlikely, if the probability of winning and losing are both equal to 0.5, then the probability of 9 consecutive losses is equal to 0.5^9 , there are approximately 0.2% of chance of having such large losing streak, note however that under a ranging market such case scenario could happen, but we will see later that the length of a losing streak is not the only problem.
Other Problems
Having a capital large enough to tank 9any number of consecutive losses is not the only thing one should focus on, as we have to take into account market prices and trading dynamics, that's where the ugly part start.
Our first problem is frictional costs, one example being the spread, but this is a common problem for any strategy, however here a martingale is extra sensitive to it, if the strategy does not account for it then we will still double our positions costs but we might not recover all the losses of a losing streak, instead we would be recovering only a proportion of it, under such scenario you would be certain to lose over time.
Another problem are gaps, market price might open under a stop-loss without triggering it, and this is a big no-no.
Equity of the strategy on AMD, in a desired scenario the equity at the second arrow should have been at a higher position than the equity at the first arrow.
In order for the strategy to be more effective, we would need to trade a market that does not close, such as the cryptocurrency market. Finally, we might be affected by slippage, altho only extreme values might drastically affect our balance.
The Anti Martingale
The strategy lets you use an anti-martingale, which double the position size after a win instead of a loss, the goal here is not to recover from a losing strike but instead to profit from a potential winning streak.
Here we are exposing your balance to exponential gross but you might also lose a trade at the end a winning streak, you will generally want to reinitialize your position size after a few wins instead of waiting for the end of a streak.
Alternative
You can use other-kind of progressions for position sizing, such as a linear one, increasing your position size by a constant number each time you lose. More gentle progressions will recover a proportion of your losses in a losing streak.
You can also simulate the effect of a martingale without doubling your position size by doubling your target profit, if for example you have a 10$ profit-target/stop-loss and lose a trade, you can use a 20$ profit target to recover from the lost trade + gain a profit of 10$. While this approach does not introduce exponential decay in your balance, you are betting on the market reaching your take profits, considering the fact that you are doubling their size you are expecting market volatility to increase drastically over time, as such this approach would not be extremely effective for high losing streak.
Conclusion
You will see a lot of auto-trading strategies that are based on a grid approach, they might even use a martingale. While the backtests will look appealing, you should think twice before using such kind of strategy, remember that frictional costs will be a huge challenge for the strategy, and that it assumes that the trader has an important initial capital. We have also seen that the risk/reward ratio is theoretically the worst you can have on a strategy, having a low reward and a high risk. This does not mean that progressive position sizing is bad, but it should not be pushed to the extreme.
It is nice to note that the martingale is originally a betting system designed for casino games, which unlike trading are not subject to frictional costs, but even casino players don't use it, so why would you?
Thx for reading