Get started

Search in scripts for "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)
Pine Script® indicator
by RagingRocketBull
13
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
Pine Script® indicator
by VasilySergeev
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.
Pine Script® indicator
by prashanthraju
14
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.
Pine Script® indicator
by starbolt
8
Realized Volatility IIR Filters with BandsDISCLAIMER: The Following indicator/code IS NOT intended to be a formal investment advice or recommendation by the author, nor should be construed as such. Users will be fully responsible by their use regarding their own trading vehicles/assets. The following indicator was made for NON LUCRATIVE ACTIVITIES and must remain as is following TradingView's regulations. Use of indicator and their code are published by Invitation Only for work and knowledge sharing. All access granted over it, their use, copy or re-use should mention authorship(s) and origin(s). WARNING NOTICE! THE INCLUDED FUNCTION MUST BE CONSIDERED AS TESTING. The models included in the indicator have been taken from open sources on the web and some of them has been modified by the author, problems could occur at diverse data sceneries. WHAT'S THIS...? Work derived by previous own research for study: This is mainly an INFINITE IMPULSE RESPONSE FILTERING INDICATOR , it's purpose is to catch trend given by the nature of lag given by a VOLATILITY ESTIMATION ALGORITHM as it's coefficient. It provides as well an INFINITE IMPULSE RESPONSE DEVIATION FILTER that uses the same coefficients of the main filter to plot deviation bands as an auxiliary tool. The given Filter based indicator provides my own Multi Volatility-Estimators Function with only 3 models: ELASTIC VOLUME WEIGHTED VOLATILITY : This is a Modified Daigler & Padungsaksawasdi "Volume Weighted Volatility" as on DOI: 10.1504/IJBAAF.2018.089423 but with Elastic Volume Weighted Moving Average instead of VWAP (intraday) for faster (but inaccurate) calculation. A future version is planned on the way using intra-bar inspection for intraday timeframe as described in original paper. GARMAN & KLASS / YANG-ZANG EXTENSION : As one of the best range based (OHLC) with open gaps inclusion in a single bar. PETER MARTIN'S ULCER INDEX : This is a better approach to measure realized volatility than standard deviation of log returns given it's proven convex risk metric for DrawDowns as shown in Chekhlov et al. (2005) . Regarding this particular model, I take a different approach to use it as coefficient feed: Given that the UI only takes in consideration DrawDawns, I code myself the inverse of this to compute Draw-Ups as well and use both of them to filter minimums volatility levels in order to create a SLOW version of the IIR filter, and maximums of both to calculate as FAST variation. This approach can be used as a better proxy instead of any other common moving average given that with NO COMPOUND IN TIME AT ALL (N=1) or only using as long as N=3 bars of compund, the filter can catch a trend easily, making the indicator nearly a NON PARAMETRIC FILTER. NOTES: This version DO NOT INCLUDE ALERTS. This version DO NOT INCLUDE STRATEGY: ALL Feedback welcome. DERIVED WORK: Incremental calculation of weighted mean and variance by Tony Finch (fanf2@cam. ac .uk) (dot@dotat.at), 2009. Volume weighted volatility: empirical evidence for a new realised volatility measure by Chaiyuth Padungsaksawasdi & Robert T. Daigler, 2018. Basic DSP Tips & Trics by TradingView user @alexgrover CHEERS! @XeL_Arjona 2020.
Pine Script® indicator
by xel_arjona
11
Dynamic Money FlowDynamic Money Flow is a volume indicator based on Marc Chaikin's Money Flow with a few improvements. It can be used to confirm break-outs and trends. Zero line crosses and divergences can provide useful signals while considering chart analysis as well. Two weaknesses of CMF have been already fixed by Colin Twiggs (IncredibleCharts)... 1.CMF uses Chaikin's accumulation/distribution line to calculate the flow of money. Accumulation/distribution line does not take the gaps into account. This can be solved using true range. I call it true accumulation/distribution. 2.Oscillators have a tendency to center because of averaging calculations. DMF is average of flowing volume divided by average of total volume. This means indicator plots the change of first factor compared to the other one. In Simple Averaging method every data is given an equal weight thus when the last data drops it will have heavy impact on the averages and the change of them. It is much easier to identity these impacts after the drop of very high or very low data... So reducing the weight exponentially is a better option. 3.There is something else with CMF... changes of close price is ignored, because the formula only compares close price to its range. To include the movements of close beside the close to range comparison, the distance between two last close prices should be compared to true range as well. So volume can be distributed between close to range comparison (True Accumulation/Distribution) and close to close comparison automatically. And then results are summed to have a single multiplier. An example for how close to close comparison affects DMF... Or here you can see how lower wicks keep TMF (same as CMF in this case) from crossing zero line while price is trending down.
Pine Script® indicator
by RezzaHmt
44
Combo Strategy 123 Reversal & ECO This is combo strategies for get a cumulative signal. First strategy This System was created from the Book "How I Tripled My Money In The Futures Market" by Ulf Jensen, Page 183. This is reverse type of strategies. The strategy buys at market, if close price is higher than the previous close during 2 days and the meaning of 9-days Stochastic Slow Oscillator is lower than 50. The strategy sells at market, if close price is lower than the previous close price during 2 days and the meaning of 9-days Stochastic Fast Oscillator is higher than 50. Second strategy We call this one the ECO for short, but it will be listed on the indicator list at W. Blau’s Ergodic Candlestick Oscillator. The ECO is a momentum indicator. It is based on candlestick bars, and takes into account the size and direction of the candlestick "body". We have found it to be a very good momentum indicator, and especially smooth, because it is unaffected by gaps in price, unlike many other momentum indicators. We like to use this indicator as an additional trend confirmation tool, or as an alternate trend definition tool, in place of a weekly indicator. The simplest way of using the indicator is simply to define the trend based on which side of the "0" line the indicator is located on. If the indicator is above "0", then the trend is up. If the indicator is below "0" then the trend is down. You can add an additional qualifier by noting the "slope" of the indicator, and the crossing points of the slow and fast lines. Some like to use the slope alone to define trend direction. If the lines are sloping upward, the trend is up. Alternately, if the lines are sloping downward, the trend is down. In this view, the point where the lines "cross" is the point where the trend changes. When the ECO is below the "0" line, the trend is down, and we are qualified only to sell on new short signals from the Hi-Lo Activator. In other words, when the ECO is above 0, we are not allowed to take short signals, and when the ECO is below 0, we are not allowed to take long signals. WARNING: - For purpose educate only - This script to change bars colors.
Pine Script® indicator
by HPotter
6
Candle State (The Strat)This script identifies the 2 different Candle States for use in #TheStrat. Candle Up - The close of the current candle is greater than the close of the previous candle. Candle Down - The close of the current candle is less than the close of the previous candle. Though this script is extremely simple it is a teaching aid for #TheStrat. The script also assists in the identification of up and down candles with gaps where the color of candle will not always match the Candle State. Analysis of the candle types can help you define actionable signals and draw broadening formations. Disclaimer: All scripts from this account are for informational purposes only and do not produce buy or sell recommendations. © 2020 Crinklebine
Pine Script® indicator
by Crinklebine
4
My VWAP Reversal + Pivot Points StandardThis indicator, with the addition of a standard VWAP indicator to the 5m chart, helps the operator when using a closing candle Price to initiate a VWAP Reversal strategy. The strategy involves Price gapping up, look for a Close below the 1st 5m candle Low; else look for a Close above the 1st 5m candle High. On a break of VWAP, take the trade in the opposite direction of the gap, hence the VWAP Reversal. Not my own strat, credit to T3 Newsbeat, publicly posted on YouTube. The Pivot Points Standard in the Pine 4 user manual, was the base source code, and leaving it here will allow me to remove the PP indicator I was using.
Pine Script® indicator
by mikeram1971
8
Sequentially Filtered Moving AverageThe previously proposed sequential filter aimed to filter variations lower than a certain period, this allowed to remove noisy variations and retain only the closing price values that occurred after a consecutive up/down, however because of the noisy nature of the closing price large filtering was impossible, in order to tackle to this problem the same indicator using a simple moving average as input is proposed, this allow for smoother results. We will see that the proposed indicator can provide an alternative moving average that could be used as slow moving average in crossover systems. The Indicator The length parameter as the same function as the one described in the sequential filter post, however here length also control the period of the moving average used input, in short larger values of length will return a smoother but less reactive output. In blue the moving average with length = 200, and in red the moving average with length = 50. It is interesting to see how the moving average remain flat during ranging/flat market periods Unfortunately like the sequential filter the sequentially filtered moving average (SFMA) is not affected by large short term variations such as gaps or short term volatile events. This is because of the nature of the sequential filter to ignore movements amplitude and only focus on the variation period. Moving Average Crossover System The SFMA is equal to a simple moving average of period length when a consecutive up/down sequence of size length has occurred, else the SFMA is equal to its precedent value, therefore we could expect less crosses between a fast moving average and the SFMA as slow moving average. We can see on the figure above that the fast moving average of period 50 (in green) cross more with the slow moving average of period 200 (in red) than with the SFMA of period 200 (in blue). Crosses can occur at the same time as with the classical slow moving average (in red) or a bit later. Conclusion A new moving average based on the recently proposed sequential filter has been proposed, it can be seen that under a moving average crossover system the proposed moving average seems to be more effective at producing less crosses without necessarily doing it with an excessive lag, in fact the moving average has either lag (length-1)/2 or lag length . In the future it could be interesting to provide an hybrid alternative that take into account volatility as well as variations period. Thanks for reading !
Pine Script® indicator
by alexgrover
15
Sequential Filter - An Original Filtering ApproachRemoving irregular variations in the closing price remain a major task in technical analysis, indicators used to this end mostly include moving averages and other kind of low-pass filters. Understanding what kind of variations we want to remove is important, irregular (noisy) variations have mostly a short term period, fully removing them can be complicated if the filter is not properly selected, for example we might want to fully remove variations with a period of 2 bars and lower, if we select an arithmetic moving average the filter output might still contain such variations because of the ripples in the frequency response passband, all it would take is a variation of high amplitude for that variation to be clearly visible. Although all it would take for better filtering is a filter with better performance in the frequency domain (gaussian, Butterworth, Bessel...) we can design innovative approaches that does not rely on the model of classical moving averages, today a new technical indicator is proposed, the technical indicator fully remove variations lower than the selected period. The Indicator Approach In order for the indicator output to change the closing price need to produce length consecutive up's/down's, length control the variation threshold of the indicator, variations lower than length are fully removed. Lets see a visual example : Here length = 3, the closing price need to make 3 consecutive up's/down's, when the sequence happen the indicator output is equal to src , here the closing price, else the indicator is equal to its precedent value, hence removing other variations. The value of 3 is the value by default, this is because i have seen in the past that the average smallest variations period where in general of 3 bars. Because the indicator focus only on the variation sign, it totally ignore the amplitude of the movement, this provide an effective way to filter short term retracement in a fluctuation as show'n below : The candle option of the indicator allow the indicator to only focus on the body color of a candle, thus ignoring potential gaps, below is an example with the candle option off : If we activate the "candle" option we end up with : Note that the candle option is based on the closing and opening price, if you use the indicator on another indicator output make sure to have the candle option off. Length and Indicator Color The closing price is infected by noise, and will rarely make a large sequence of consecutive up's/down's, the indicator can therefore be useful to detect consecutive sequence of length period, here 6 is selected on BTCUSD : A consecutive up's/down's of period 6 can be considered a relatively rare event. It is important to note that the color of the indicator used by default has nothing to do with the consecutive sequence detected, that is the indicator turning red doesn't necessarily mean that a consecutive down's sequence has occurred, but only that this sequence has occurred at a lower value than the precedent detected sequence. This is show'n below : In order to make the indicator color based on the detected sequence check the "Color Based On Detected Sequence" option. Conclusion An original approach on filtering price variations has been proposed, i believe the indicator code is elegant as well as relatively efficient, and since high values of length can't really be used the indicator execution speed will remain relatively fast. Thanks for reading !
Pine Script® indicator
by alexgrover
7
Currency Strength ALT v1.0Description: This study is a version of Currency Strength Meter, that utilises TradingViews built-in 8 Currency indices (?XY), rather calculate them from currency pair values. It also utilises the built-in TSI function, the TSI uses moving averages of the underlying momentum of a financial instrument. The advantage of using the Currency Indices for strength is the fact that they are based on multiple Exchange sources and so hopefully making it more representative. ***WARNING*** The TradingView Currency Indices do tend to have gaps between candles especially on the low volume currencies like NZD and AUD, so strength chart can also jump around. I suggest using the indicator with higher TF (4H+) charts.
Pine Script® indicator
by JustUncleL
19
Setting-Less Trend-Step FilteringIntroduction Indicators settings have been a major concern in trading strategies, in order to provide the best results each indicators involved in the strategy must have its settings optimized, when using only 1 indicator this task can easily be achieved, but an increasing number of indicators involve more slower computations, lot of softwares will use brute force for indicators settings optimization, this involve testing each indicator settings and see which setting/combination maximize the equity, in order to fasten this process softwares can use a user defined range for the indicator settings. Nonetheless the combination that maximize the equity at time t might be different at time t+1...n . Therefore i propose an indicator without any numerical setting that aim to filter small price variations using the architecture of the T-step lsma, such indicator can provide robust filtering and can therefore be used as input for other indicators. Robustness Vs Non Robustness Robustness is often defined as the ability of certain statistical tools to be less affected by outliers, outliers are defined as huge variations in a data-set, high volatility movements and large gaps might be considered as outliers. However here we define robustness as the ability of an indicator to be non affected by price variations that are not correlated with the main trend, which can be defined in technical analysis as pullbacks. Some small pullbacks in INTEL, the indicator is not affected by them, which allow the indicator to filter the price in a "smart" way. This effect is made possible by using exponential averaging in the indicator, exponential averaging is defined as y = sc*x + (1-sc)*y , with 1 > sc > 0 . Here sc is calculated in a similar way as the kalman gain, which is in the form of a/(a + b) , in our case this is done with : sc = abs(input - nz(b ))/(abs(input - nz(b )) + nz(a )) Non Robust Version Of The Indicator The user is allowed to use the non robust version of the indicator by unchecking "robust" in the setting panel, this allow a better fit with the price at the cost of less filtering. robust checked robust unchecked Conclusion I proposed a technical indicator that aim to filter short frequencies without the use of parameters, the indicator proven to be robust to various pullbacks and therefore was able to follow the main trend, although using the term trend for such small price variations might be wrong. Removing high frequencies is always beneficial in trading, noisy series are harder to manipulate, this is why you'll see a lot of indicators using median price often defined as hl2 instead of the closing price. Like previous settings-less indicators i published this one can behave differently depending on the time frame selected by the user, lower time frames will make the indicator filter more. I'll try to make more setting-less indicators that will correct this effect. Acknowledgements The support and interest of the community is only thing that allowed me to be where i'am today, i'am thankful. Special thanks to the tv staff, LucF, and my family who may not have believed in this project but are still proud of their son.
Pine Script® indicator
by alexgrover
23
[RESEARCH] Heikin-Ashi Chart IdentifierA deterministic approach to identify Heikin-Ashi chart type. The script checks the next statements about HA: HA chart does not have any gaps in a classic sense Every new HA open price is calculated using a specific recurrence formula. This fact also means that initial HA open price is used to calculate all the next and so on (a construction of Infinite Impulse Response filters) The script works correctly being applied to other chart types: Classic Candlestick Range Bars Line Break Traditional Renko ATR Renko Traditional Point-and-Figure ATR Point-and-Figure Kagi For special ones: this code allows you to check whether your script is being executed with Heikin-Ashi candles or not inside your script. Ev sistr 'ta Laou!
Pine Script® indicator
by everget
Volume Profile Free Pro (25 Levels Value Area VWAP) by RRBVolume Profile Free Pro by RagingRocketBull 2019 Version 1.0 All available Volume Profile Free Pro versions are listed below (They are very similar and I don't want to publish them as separate indicators): ver 1.0: style columns implementation ver 2.0: style histogram implementation ver 3.0: style line implementation This indicator calculates Volume Profile for a given range and shows it as a histogram consisting of 25 horizontal bars. It can also show Point of Control (POC), Developing POC, Value Area/VWAP StdDev High/Low as dynamically moving levels. Free accounts can't access Standard TradingView Volume Profile, hence this indicator. There are 3 basic methods to calculate the Value Area for a session. - original method developed by Steidlmayr (calculated around POC) - classical method using StdDev (calculated around the mean VWAP) - another method based on the mean absolute deviation (calculated around the median) POC is a high volume node and can be used as support/resistance. But when far from the day's average price it may not be as good a trend filter as the other methods. The 80% Rule: When the market opens above/below the Value Area and then returns/stays back inside for 2 consecutive 30min periods it has 80% chance of filling VA (like a gap). There are several versions: Free, Free Pro, Free MAX. This is the Free Pro version. The Differences are listed below: - Free: 30 levels, Buy/Sell/Total Volume Profile views, POC - Free Pro: 25 levels, +Developing POC, Value Area/VWAP High/Low Levels, Above/Below Area Dimming - Free MAX: 50 levels, packed to the limit Features: - Volume Profile with up to 25 levels (3 implementations) - POC, Developing POC Levels - Buy/Sell/Total/Side by Side View modes - Side Cover - Value Area, VAH/VAL dynamic levels - VWAP High/Low dynamic levels with Source, Length, StdDev as params - Show/Hide all levels - Dim Non Value Area Zones - Custom Range with Highlighting - 3 Anchor points for Volume Profile - Flip Levels Horizontally - Adjustable width, offset and spacing of levels - Custom Color for POC/VA/VWAP levels and Transparency for buy/sell levels Usage: - specify max_level/min_level for a range (required in ver 1.0/2.0, auto/optional in ver 3.0 = set to highest/lowest) - select range (start_bar, range length), confirm with range highlighting - select mode Value Area or VWAP to show corresponding levels. - flip/select anchor point to position the buy/sell levels, adjust width and spacing as needed - select Buy/Sell/Total/Side by Side view mode - use POC/Developing POC/VA/VWAP High/Low as S/R levels. Usually daily values from 1-3 days back are used as levels for the current day. - Green - buy volume of a specific price level in a range, Red - sell volume. Green + Red = Total volume of a price level in a range There's no native support for vertical histograms in Pinescript (with price axis as base) Basically, there are 4 ways to plot a series of horizontal bars stacked on top of each other: 1. plotshape style labeldown (ver 0 prototype discarded) - you can have a set of fixed width/height text labels consisting of a series of underscores and moving dynamically as levels. Level offset controls visible length. - you can move levels and scale the base width of the volume profile histogram dynamically - you can calculate the highest/lowest range values automatically. max_level/min_level inputs are optional - you can't fill the gaps between levels/adjust/extend width, height - this results in a half baked volume profile and looks ugly - fixed text level height doesn't adjust and looks bad on a log scale - fixed font width also doesn't scale and can't be properly aligned with bars when zooming 2. plot style columns + hist_base (ver 1.0) - you can plot long horizontal bars using a series of small adjacent vertical columns with level offsets controlling visible length. - you can't hide/move levels of the volume profile histogram dynamically on each bar, they must be plotted at all times regardless - you can't delete the history of a plot. - you can't scale the base width of the volume profile histogram dynamically, can't set show_last from input, must use a preset fixed width for each level - hist_base can only be a static const expression, can't be assigned highest/lowest range values automatically - you have to specify max_level/min_level manually from input - you can't control spacing between columns - there's an equalizer bar effect when you zoom in, and solid bars when you zoom out - using hist_base for levels results in ugly load/redraw times - give it 3-5 sec to finalize its shape after each UI param change - level top can be properly aligned with another level's bottom producing a clean good looking histogram - columns are properly aligned with bars automatically 3. plot style histogram + hist_base (ver 2.0) - you can plot long horizontal bars using a series of small vertical bars (horizontal histogram) instead of columns. - you can control the width of each histogram bar comprising a level (spacing/horiz density). Large enough width will cause bar overlapping and give level a "solid" look regardless of zoom - you can only set width <= 4 in UI Style - custom textbox input is provided for larger values. You can set width and plot transparency from input - this method still uses hist_base and inherits other limitations of ver 2.0 4. plot style lines (ver 3.0) - you can also plot long horizontal bars using lines with level offsets controlling visible length. - lines don't need hist_base - fast and smooth redraw times - you can calculate the highest/lowest range values automatically. max_level/min_level inputs are optional - level top can't be properly aligned with another level's bottom and have a proper spacing because line width uses its own units and doesn't scale - fixed line width of a level (vertical thickness) doesn't scale and looks bad on log (level overlapping) - you can only set width <= 4 in UI Style, a custom textbox input is provided for larger values. You can set width and plot transparency from input Notes: - hist_base for levels results in ugly load/redraw times - give it 3-5 sec to finalize its shape after each UI param change - indicator is slow on TFs with long history 10000+ bars - Volume Profile/Value Area are calculated for a given range and updated on each bar. Each level has a fixed width. Offsets control visible level parts. Side Cover hides the invisible parts. - Custom Color for POC/VA/VWAP levels - UI Style color/transparency can only change shape's color and doesn't affect textcolor, hence this additional option - Custom Widh for levels - UI Style supports only width <= 4, hence this additional option - POC is visible in both modes. In VWAP mode Developing POC becomes VWAP, VA High and Low => VWAP High and Low correspondingly to minimize the number of plot outputs - You can't change buy/sell level colors (only plot transparency) - this requires 2x plot outputs exceeding max 64 limit. That's why 2 additional plots are used to dim the non Value Area zones - Use Side by Side view to compare buy and sell volumes between each other: base width = max(total_buy_vol, total_sell_vol) - All buy/sell volume lengths are calculated as % of a fixed base width = 100 bars (100%). You can't set show_last from input - Sell Offset is calculated relative to Buy Offset to stack/extend sell on top of buy. Buy Offset = Zero - Buy Length. Sell Offset = Buy Offset - Sell Length = Zero - Buy Length - Sell Length - If you see "loop too long error" - change some values in UI and it will recalculate - no need to refresh the chart - There's no such thing as buy/sell volume, there's just volume, but for the purposes of the Volume Profile method, assume: bull candle = buy volume, bear candle = sell volume - Volume Profile Range is limited to 5000 bars for free accounts P.S. Cantaloupia Will be Free! Links on Volume Profile and Value Area calculation and usage: www.tradingview.com stockcharts.com onlinelibrary.wiley.com
Pine Script® indicator
by RagingRocketBull
33
Repainting? Yes/NoSuppose, you'd like to avoid repainting issues in your scripts. How to achieve this?.. If you do not use `security` function, then simply calculate only on confirmed (closed) bars. Use either `close ` as a source or/and `barstate.isconfirmed` variable in your logic. But if you use `security` to get data of a higher timeframe, then what? In such a case to get the same result - use `security` with * `lookahead` param switched ON * in `expr` param use "square brackets of 1" - previous bar value of your signal (`data` variable is your "signal"). NOTE 1: that `gaps` param doesn't affect repainting in any way. NOTE 2: `lookahead` param when switched OFF affects the `security` behaviour only on history data. And indicator still repaints (realtime calculations change after chart reload). In my example, script uses 5 minute closed bars (that means they will not change after chart reload, so there will be no repainting) on 1 minute chart. Plots that "repaint" are hidden. You may make them visible to see how they look like.
Pine Script® indicator
by pinetech
1
Rogers & Satchell Volatility EstimationFirst off, a huge thank you to the following people: theheirophant: www.tradingview.com alexgrover: www.tradingview.com NGBaltic: www.tradingview.com The Rogers & Satchell function is a volatility estimator that outperforms other estimators when the underlying follows a geometric Brownian motion with a drift (historical data mean returns different from zero). As a result, it provides a better volatility estimation when the underlying is trending. However, the Rogers & Satchell estimator does not account for jumps in price (gaps). It assumes no opening jump. The function uses the open, close, high, and low price series in its calculation and it has only one parameter, which is the period to use to estimate the volatility. This script allows you to transform the volatility reading. The intention of this is to be able to compare volatility across different assets and timeframes. Having a relative reading of volatility also allows you to better gauge volatility within the context of current market conditions. For the signal lie I chose a repulsion moving average to remove choppy crossovers of the estimator and the signal. This may have been a mistake, so in the near-future I might update so that the MA can be selected. Let me know if you have any opinions either way. Want to Learn? If you'd like the opportunity to learn Pine but you have difficulty finding resources to guide you, take a look at this rudimentary list: docs.google.com The list will be updated in the future as more people share the resources that have helped, or continue to help, them. Follow me on Twitter to keep up-to-date with the growing list of resources. Suggestions or Questions? Don't even kinda hesitate to forward them to me. My (metaphorical) door is always open.
Pine Script® indicator
by chrysopoetics
1