[@btc_charlie] Trader XO Macro Trend ScannerWhat is this script?
This script has two main functions focusing on EMAs (Exponential Moving Average) and Stochastic RSI.
EMAs
EMAs are typically used to give a view of bullish / bearish momentum. When the shorter EMA (calculated off more recent price action) crosses, or is above, the slower moving EMA (calculated off a longer period of price action), it suggests that the market is in an uptrend. This can be an indication to either go long on said asset, or that it is more preferable to take long setups over short setups. Invalidation on long setups is usually found via price action (e.g. previous lows) or simply waiting for an EMA cross in the opposite direction (i.e. shorter EMA crosses under longer term EMA).
This is not a perfect system for trade entry or exit, but it does give a good indication of market trends. The settings for the EMAs can be changed based on user inputs, and by default the candles are coloured based on the crosses to make it more visual. The default settings are based on “Trader XO’s” settings who is an exceptional swing trader.
RSI
Stochastic RSI is a separate indicator that has been added to this script. RSI measures Relative Strength (RSI = Relative Strength Index). When RSI is <20 it is considered oversold, and when >80 it is overbought. These conditions suggests that momentum is very strong in the direction of the trend.
If there is a divergence between the price (e.g. price is creating higher highs, and stoch RSI is creating lower highs) it suggests the strength of the trend is weakening. Whilst this script does not highlight divergences, what it does highlight is when the shorter term RSI (K) crosses over D (the average of last 3 periods). This can give an indication that the trend is losing strength.
Combination
The EMAs indicate when trend shifts (bullish or bearish).
The RSI indicates when the trend is losing momentum.
The combination of the two can be used to suggest when to prefer a directional bias, and subsequently shift in anticipation of a trend reversal.
Note that no signal is 100% accurate and an interpretation of market conditions and price action will need to be overlayed to
Why is it different to others?
I have not found other scripts that are available in this way visually including alerts when Stoch RSI crosses over/under the extremes; or the mid points.
Whilst these indicators are default, the combination of them and how they are presented is not and makes use of the TradingView colouring functionalities.
What are the features?
Customise the variables (averages) used in the script.
Display as one EMA or two EMAs (the crossing ones).
Alerts on EMA crosses.
Alerts on Stoch RSI crosses - slow/fast, upper, lower areas.
- Currently set on the chart to show alerts when Stoch RSI is above 80, then falls below 80 (and colours it red).
Customisable colours.
What are the best conditions for this?
It is designed for high timeframe charts and analysis in crypto, since crypto tends to trend.
It can however be used for lower timeframes.
Disclaimer/Notes:
I have noticed several videos appearing suggesting that this is a "100% win rate indicator" .
NO indicator has 100% win rate.
An indicator is an *indicator* that is all.
Please use responsibly and let me know if there are any mods or updates you would like to see.
Cerca negli script per "THE SCRIPT"
logLibrary "log"
Logging library for easily displaying debug, info, warn, error and critical messages.
No real need to explain why you might want to use this library! I'm sure you've all experienced the frustration of trying to understand the data state of your scripts... so, enjoy! More on it's way...
(Don't forget to check the helpers in the script and the useful tips below)
Some Useful Tips
By default the log console persists between bars (for history) and bars and ticks (for realtime).
Sometimes it is useful to clear the log after each candle or tick (assuming we are using the above helpers):
```
log_print(clear = true) // starts afresh on every bar and tick (excludes historical bars but good realtime tick analysis)
log_print(clear = barstate.isnew) // clears the log at the start of each bar (again, excludes historical but good realtime candle analysis)
```
It is also useful to be able to selectively understand the state of data at specific points or times within a script:
```
if log.once()
debug('useful variable', my_var) // this log only gets written once, upon first execution of this statement
if log.only(5)
debug3(a, b, c) // these variables are only logged the first five times this statement is executed
log_print(clear = false) // clear must be false and you should not write other logs on every bar, or the above will be lost
```
Final tip. If you want to view ONLY log entries of a particular level, then negate the constant:
```
log_print(level = -LOG_DEBUG)
```
Detailed Interface
once() Restrict execution to only happen once. Usage: if assert.once()\n happens_once()
Returns: bool, true on first execution within scope, false subsequently
only(repeat) Restrict execution to happen a set number of times. Usage: if assert.only(5)\n happens_five_times()
Parameters:
repeat : int, the number of times to return true
Returns: bool, true for the set number of times within scope, false subsequently
init() Initialises the log array
Returns: string , tuple based array to contain all pending log entries (__LOG)
clear(msgs) Clears the log array
Parameters:
msgs : string , the current collection of unfiltered and unprocessed logs (__LOG)
trace(msgs, msg) Writes a trace message to the log console
Parameters:
msgs : string , the current collection of unfiltered and unprocessed logs (__LOG)
msg : string, the trace message to write to the log
debug(msgs, msg) Writes a debug message to the log console
Parameters:
msgs : string , the current collection of unfiltered and unprocessed logs (__LOG)
msg : string, the debug message to write to the log
info(msgs, msg) Writes an info message to the log console
Parameters:
msgs : string , the current collection of unfiltered and unprocessed logs (__LOG)
msg : string, the info message to write to the log
warn(msgs, msg) Writes a warning message to the log console
Parameters:
msgs : string , the current collection of unfiltered and unprocessed logs (__LOG)
msg : string, the warn message to write to the log
error(msgs, msg) Writes an error message to the log console
Parameters:
msgs : string , the current collection of unfiltered and unprocessed logs (__LOG)
msg : string, the error message to write to the log
fatal(msgs, msg) Writes a critical message to the log console
Parameters:
msgs : string , the current collection of unfiltered and unprocessed logs (__LOG)
msg : string, the fatal message to write to the log
log(msgs, level, msg) Write a log message to the log console with a custom level
Parameters:
msgs : string , the current collection of unfiltered and unprocessed logs (__LOG)
level : ing, the logging level to assign to the message
msg : string, the log message to write to the log
severity(msgs) Checks the unprocessed log messages and returns the highest present level
Parameters:
msgs : string , the current collection of unfiltered and unprocessed logs (__LOG)
Returns: int, the highest level found within the unfiltered logs
print(msgs, level, clear, rows, text_size, position) Prints all log messages to the screen
Parameters:
msgs : string , the current collection of unfiltered and unprocessed logs (__LOG)
level : int, the minimum required log level of each message to be displayed
clear : bool, clear the printed log console after each render (useful with realtime when set to barstate.isconfirmed)
rows : int, the number of rows to display in the log console
text_size : string, the text size of the log console (global size vars)
position : string, the position of the log console (global position vars)
unittest_log(case) Log module unit tests, for inclusion in parent script test suite. Usage: log.unittest_log(__ASSERTS)
Parameters:
case : string , the current test case and array of previous unit tests (__ASSERTS)
unittest(verbose) Run the log module unit tests as a stand alone. Usage: log.unittest()
Parameters:
verbose : bool, optionally disable the full report to only display failures
assertLibrary "assert"
Production ready assertions and auto-reporting for unit testing pine scripts.
This library was born from the need to maintain production level stability and catch regressions / bugs early and fast. I hope this help you trust your pine scripts too. More libraries and tools on their way... please follow for more.
Please see the script for helpers to copy into your own scripts as well as examples at the bottom of the library unit testing itself.
Quick Reference
```
case = assert.init()
new_case(case, 'Asserts for floats and ints')
assert.equal(a, b, case, 'a == b')
assert.not_equal(a, b, case, 'a != b')
assert.nan(a, case, 'a == na')
assert.not_nan(a, case, 'a != na')
assert.is_in(a, b, case, 'a in b ')
assert.is_not_in(a, b, case, 'a not in b ')
assert.array_equal(a, b, case, 'a == b ')
new_case(case, 'Asserts for ints only')
assert.int_in(a, b, case, 'a in b ')
assert.int_not_in(a, b, case, 'a not in b ')
assert.int_array_equal(a, b, case, 'a == b ')
new_case(case, 'Asserts for bools only')
assert.is_true(a, case, 'a == true')
assert.is_false(a, case, 'a == false')
assert.bool_equal(a, b, case, 'a == b')
assert.bool_not_equal(a, b, case, 'a != b')
assert.bool_nan(a, case, 'a == na')
assert.bool_not_nan(a, case, 'a != na')
assert.bool_array_equal(a, b, case, 'a == b ')
new_case(case, 'Asserts for strings only')
assert.str_equal(a, b, case, 'a == b')
assert.str_not_equal(a, b, case, 'a != b')
assert.str_nan(a, case, 'a == na')
assert.str_not_nan(a, case, 'a != na')
assert.str_in(a, b, case, 'a in b ')
assert.str_not_in(a, b, case, 'a not in b ')
assert.str_array_equal(a, b, case, 'a == b ')
assert.report(case)
```
Detailed Interface
once() Restrict execution to only happen once. Usage: if assert.once()\n happens_once()
Returns: bool, true on first execution within scope, false subsequently
init() Initialises the asserts array
Returns: string , tuple based array containing all unit test results and current case details (__ASSERTS)
equal(a, b, case, name) Numeric assert equal. Usage: assert.equal(1, 1, case, 'one == one')
Parameters:
a : float, numeric value "a" to compare equal to "b"
b : float, numeric value "b" to compare equal to "a"
case : string , the current test case and array of previous unit tests (__ASSERTS)
name : string, the current unit test name, if undefined the test index of the current case is used
Returns: bool, true if the assertion passes, false otherwise
not_equal(a, b, case, name) Numeric assert not equal. Usage: assert.not_equal(1, 2, case, 'one != two')
Parameters:
a : float, numeric value "a" to compare not equal "b"
b : float, numeric value "b" to compare not equal "a"
case : string , the current test case and array of previous unit tests (__ASSERTS)
name : string, the current unit test name, if undefined the test index of the current case is used
Returns: bool, true if the assertion passes, false otherwise
nan(a, case, name) Numeric assert is NaN. Usage: assert.nan(float(na), case, 'number is NaN')
Parameters:
a : float, numeric value "a" to check is NaN
case : string , the current test case and array of previous unit tests (__ASSERTS)
name : string, the current unit test name, if undefined the test index of the current case is used
Returns: bool, true if the assertion passes, false otherwise
not_nan(a, case, name) Numeric assert is not NaN. Usage: assert.not_nan(1, case, 'number is not NaN')
Parameters:
a : float, numeric value "a" to check is not NaN
case : string , the current test case and array of previous unit tests (__ASSERTS)
name : string, the current unit test name, if undefined the test index of the current case is used
Returns: bool, true if the assertion passes, false otherwise
is_in(a, b, case, name) Numeric assert value in float array. Usage: assert.is_in(1, array.from(1.0), case, '1 is in ')
Parameters:
a : float, numeric value "a" to check is in array "b"
b : float , array "b" to check contains "a"
case : string , the current test case and array of previous unit tests (__ASSERTS)
name : string, the current unit test name, if undefined the test index of the current case is used
Returns: bool, true if the assertion passes, false otherwise
is_not_in(a, b, case, name) Numeric assert value not in float array. Usage: assert.is_not_in(2, array.from(1.0), case, '2 is not in ')
Parameters:
a : float, numeric value "a" to check is not in array "b"
b : float , array "b" to check does not contain "a"
case : string , the current test case and array of previous unit tests (__ASSERTS)
name : string, the current unit test name, if undefined the test index of the current case is used
Returns: bool, true if the assertion passes, false otherwise
array_equal(a, b, case, name) Float assert arrays are equal. Usage: assert.array_equal(array.from(1.0), array.from(1.0), case, ' == ')
Parameters:
a : float , array "a" to check is identical to array "b"
b : float , array "b" to check is identical to array "a"
case : string , the current test case and array of previous unit tests (__ASSERTS)
name : string, the current unit test name, if undefined the test index of the current case is used
Returns: bool, true if the assertion passes, false otherwise
int_in(a, b, case, name) Integer assert value in integer array. Usage: assert.int_in(1, array.from(1), case, '1 is in ')
Parameters:
a : int, value "a" to check is in array "b"
b : int , array "b" to check contains "a"
case : string , the current test case and array of previous unit tests (__ASSERTS)
name : string, the current unit test name, if undefined the test index of the current case is used
Returns: bool, true if the assertion passes, false otherwise
int_not_in(a, b, case, name) Integer assert value not in integer array. Usage: assert.int_not_in(2, array.from(1), case, '2 is not in ')
Parameters:
a : int, value "a" to check is not in array "b"
b : int , array "b" to check does not contain "a"
case : string , the current test case and array of previous unit tests (__ASSERTS)
name : string, the current unit test name, if undefined the test index of the current case is used
Returns: bool, true if the assertion passes, false otherwise
int_array_equal(a, b, case, name) Integer assert arrays are equal. Usage: assert.int_array_equal(array.from(1), array.from(1), case, ' == ')
Parameters:
a : int , array "a" to check is identical to array "b"
b : int , array "b" to check is identical to array "a"
case : string , the current test case and array of previous unit tests (__ASSERTS)
name : string, the current unit test name, if undefined the test index of the current case is used
Returns: bool, true if the assertion passes, false otherwise
is_true(a, case, name) Boolean assert is true. Usage: assert.is_true(true, case, 'is true')
Parameters:
a : bool, value "a" to check is true
case : string , the current test case and array of previous unit tests (__ASSERTS)
name : string, the current unit test name, if undefined the test index of the current case is used
Returns: bool, true if the assertion passes, false otherwise
is_false(a, case, name) Boolean assert is false. Usage: assert.is_false(false, case, 'is false')
Parameters:
a : bool, value "a" to check is false
case : string , the current test case and array of previous unit tests (__ASSERTS)
name : string, the current unit test name, if undefined the test index of the current case is used
Returns: bool, true if the assertion passes, false otherwise
bool_equal(a, b, case, name) Boolean assert equal. Usage: assert.bool_equal(true, true, case, 'true == true')
Parameters:
a : bool, value "a" to compare equal to "b"
b : bool, value "b" to compare equal to "a"
case : string , the current test case and array of previous unit tests (__ASSERTS)
name : string, the current unit test name, if undefined the test index of the current case is used
Returns: bool, true if the assertion passes, false otherwise
bool_not_equal(a, b, case, name) Boolean assert not equal. Usage: assert.bool_not_equal(true, false, case, 'true != false')
Parameters:
a : bool, value "a" to compare not equal "b"
b : bool, value "b" to compare not equal "a"
case : string , the current test case and array of previous unit tests (__ASSERTS)
name : string, the current unit test name, if undefined the test index of the current case is used
Returns: bool, true if the assertion passes, false otherwise
bool_nan(a, case, name) Boolean assert is NaN. Usage: assert.bool_nan(bool(na), case, 'bool is NaN')
Parameters:
a : bool, value "a" to check is NaN
case : string , the current test case and array of previous unit tests (__ASSERTS)
name : string, the current unit test name, if undefined the test index of the current case is used
Returns: bool, true if the assertion passes, false otherwise
bool_not_nan(a, case, name) Boolean assert is not NaN. Usage: assert.bool_not_nan(true, case, 'bool is not NaN')
Parameters:
a : bool, value "a" to check is not NaN
case : string , the current test case and array of previous unit tests (__ASSERTS)
name : string, the current unit test name, if undefined the test index of the current case is used
Returns: bool, true if the assertion passes, false otherwise
bool_array_equal(a, b, case, name) Boolean assert arrays are equal. Usage: assert.bool_array_equal(array.from(true), array.from(true), case, ' == ')
Parameters:
a : bool , array "a" to check is identical to array "b"
b : bool , array "b" to check is identical to array "a"
case : string , the current test case and array of previous unit tests (__ASSERTS)
name : string, the current unit test name, if undefined the test index of the current case is used
Returns: bool, true if the assertion passes, false otherwise
str_equal(a, b, case, name) String assert equal. Usage: assert.str_equal('hi', 'hi', case, '"hi" == "hi"')
Parameters:
a : string, value "a" to compare equal to "b"
b : string, value "b" to compare equal to "a"
case : string , the current test case and array of previous unit tests (__ASSERTS)
name : string, the current unit test name, if undefined the test index of the current case is used
Returns: bool, true if the assertion passes, false otherwise
str_not_equal(a, b, case, name) String assert not equal. Usage: assert.str_not_equal('hi', 'bye', case, '"hi" != "bye"')
Parameters:
a : string, value "a" to compare not equal "b"
b : string, value "b" to compare not equal "a"
case : string , the current test case and array of previous unit tests (__ASSERTS)
name : string, the current unit test name, if undefined the test index of the current case is used
Returns: bool, true if the assertion passes, false otherwise
str_nan(a, case, name) String assert is NaN. Usage: assert.str_nan(string(na), case, 'string is NaN')
Parameters:
a : string, value "a" to check is NaN
case : string , the current test case and array of previous unit tests (__ASSERTS)
name : string, the current unit test name, if undefined the test index of the current case is used
Returns: bool, true if the assertion passes, false otherwise
str_not_nan(a, case, name) String assert is not NaN. Usage: assert.str_not_nan('hi', case', 'string is not NaN')
Parameters:
a : string, value "a" to check is not NaN
case : string , the current test case and array of previous unit tests (__ASSERTS)
name : string, the current unit test name, if undefined the test index of the current case is used
Returns: bool, true if the assertion passes, false otherwise
str_in(a, b, case, name) String assert value in string array. Usage: assert.str_in('hi', array.from('hi'), case, '"hi" in ')
Parameters:
a : string, value "a" to check is in array "b"
b : string , array "b" to check contains "a"
case : string , the current test case and array of previous unit tests (__ASSERTS)
name : string, the current unit test name, if undefined the test index of the current case is used
Returns: bool, true if the assertion passes, false otherwise
str_not_in(a, b, case, name) String assert value not in string array. Usage: assert.str_in('hi', array.from('bye'), case, '"hi" in ')
Parameters:
a : string, value "a" to check is not in array "b"
b : string , array "b" to check does not contain "a"
case : string , the current test case and array of previous unit tests (__ASSERTS)
name : string, the current unit test name, if undefined the test index of the current case is used
Returns: bool, true if the assertion passes, false otherwise
str_array_equal(a, b, case, name) String assert arrays are equal. Usage: assert.str_array_equal(array.from('hi'), array.from('hi'), case, ' == ')
Parameters:
a : string , array "a" to check is identical to array "b"
b : string , array "b" to check is identical to array "a"
case : string , the current test case and array of previous unit tests (__ASSERTS)
name : string, the current unit test name, if undefined the test index of the current case is used
Returns: bool, true if the assertion passes, false otherwise
new_case(case, name) Assign a new test case name, for the next set of unit tests. Usage: assert.new_case(case, 'My tests')
Parameters:
case : string , the current test case and array of previous unit tests (__ASSERTS)
name : string, the case name for the next suite of tests
clear(case) Clear all stored unit tests from all cases. Usage: assert.clear(case)
Parameters:
case : string , the current test case and array of previous unit tests (__ASSERTS)
revert(case) Revert the previous unit test. Usage: = assert.revert(case)
Parameters:
case : string , the current test case and array of previous unit tests (__ASSERTS)
Returns: , tuple containing the msg and result of the reverted test
passed(case, revert) Check if the last unit test has passed. Usage: bool success = assert.passed(case)
Parameters:
case : string , the current test case and array of previous unit tests (__ASSERTS)
revert : bool, optionally revert the test
Returns: bool, true only if the test passed
failed(case, revert) Check if the last unit test has failed. Usage: bool failure = assert.failed(case)
Parameters:
case : string , the current test case and array of previous unit tests (__ASSERTS)
revert : bool, optionally revert the test
Returns: bool, true only if the test failed
report(case, verbose) Report the outcome of unit tests that fail. Usage: bool passed = assert.report(case)
Parameters:
case : string , the current test case and array of previous unit tests (__ASSERTS)
verbose : bool, optionally display full report that includes the outcome of all tests
Returns: bool, true only if all tests passed
unittest_assert(case) Assert module unit tests, for inclusion in parent script test suite. Usage: assert.unittest_assert(__ASSERTS)
Parameters:
case : string , the current test case and array of previous unit tests (__ASSERTS)
unittest(verbose) Run the assert module unit tests as a stand alone. Usage: assert.unittest()
Parameters:
verbose : bool, optionally toggle report to display the outcome of all unit tests
Barholle eMA and RSI Movement TestThis is a test that offers insight into whether and asset is heading into bullish or bearish territory.
This indicator/test offers insight into the Exponential Moving Average's velocity and acceleration as well as the Stochastic RSI's velocity, acceleration and jerk. Included is a 'Stochastic Difference' and 'Stochastic Growth' indicators (commented out) that measure the difference between K and D in the Stoch RSI as well as the rate of it's change. This test is all about crossovers - the best leading indicator is a downward cross of the eMA velocity over the eMA acceleration, indicating a drop in price in the current or next bar.
The lines or importance have been set to -2 and 5, but these should be adjusted to suit your preferences. These numbers were chosen in order to try and create some kind of threshold after which action might be suggested. Backtesting is highly recommended so you can see how the test does and does not work. It is super powerful, but it is not omniscient - its an RSI and eMA derivative, past success does not necessarily dictate future success.
Please look at the code for several more plots you can use of derivatives and other ideas explore but commented out for greater legibility of the graph. Commenting and commenting (or uncommenting all and just disabling some in the settings) and comparing the graphs and crossovers is a useful exercise. To that end, one last concept - the MARSI - a combined moving averages and RSI measurement - was abandoned because it didn't appear to indicate anything of use, however you may find crossovers or patterns with it comparing it to other graphs, so it was left in but commented.
Please take a look at the comments and all the math and indicators 'left on the cutting room floor' in the script. Maybe you'll find a gem in the redux version of this script.
Outreach regarding the script, patterns noticed and full-on stealing of the script are all permitted. Many elements of this script were nabbed from other scripts - thank you to a community of coders who put it all out there.
CommonUtils█ OVERVIEW
This library is a utility tool for Pine Script™ developers. It provides a collection of helper functions designed to simplify common tasks such as mapping user-friendly string inputs to Pine Script™ constants and formatting timeframe strings for display. The primary goal is to make main scripts cleaner, more readable, and reduce repetitive boilerplate code. It is envisioned as an evolving resource, with potential for new utilities to be added over time based on community needs and feedback.
█ CONCEPTS
The library primarily focuses on two main concepts:
Input Mapping
Pine Script™ often requires specific constants for function parameters (e.g., `line.style_dashed` for line styles, `position.top_center` for table positions). However, presenting these technical constants directly to users in script inputs can be confusing. Input mapping involves:
Allowing users to select options from more descriptive, human-readable strings (e.g., "Dashed", "Top Center") in the script's settings.
Providing functions within this library (e.g., `mapLineStyle`, `mapTablePosition`) that take these user-friendly strings as input.
Internally, these functions use switch statements or similar logic to convert (map) the input string to the corresponding Pine Script™ constant required by built-in functions.
This approach enhances user experience and simplifies the main script's logic by centralizing the mapping process.
Timeframe Formatting
Raw timeframe strings obtained from variables like `timeframe.period` (e.g., "1", "60", "D", "W") or user inputs are not always ideal for direct display in labels or panels. The `formatTimeframe` function addresses this by:
Taking a raw timeframe string as input.
Parsing this string to identify its numerical part and unit (e.g., minutes, hours, days, weeks, months, seconds, milliseconds).
Converting it into a more standardized and readable format (e.g., "1min", "60min", "Daily", "Weekly", "1s", "10M").
Offering an optional `customSuffix` parameter (e.g., " FVG", " Period") to append to the formatted string, making labels more descriptive, especially in multi-timeframe contexts.
The function is designed to correctly interpret various common timeframe notations used in TradingView.
█ NOTES
Ease of Use: The library functions are designed with simple and understandable signatures. They typically take a string input and return the corresponding Pine Script™ constant or a formatted string.
Default Behaviors: Mapping functions (`mapLineStyle`, `mapTablePosition`, `mapTextSize`) generally return a sensible default value (e.g., `line.style_solid` for `mapLineStyle`) in case of a non-matching input. This helps prevent errors in the main script.
Extensibility of Formatting: The `formatTimeframe` function, with its `customSuffix` parameter, allows for flexible customization of timeframe labels to suit the specific descriptive needs of different indicators or contexts.
Performance Considerations: These utility functions primarily use basic string operations and switch statements. For typical use cases, their impact on overall script performance is negligible. However, if a function like `formatTimeframe` were to be called excessively in a loop with dynamic inputs (which is generally not its intended use), performance should be monitored.
No Dependencies: This library is self-contained and does not depend on any other external Pine Script™ libraries.
█ EXPORTED FUNCTIONS
mapLineStyle(styleString)
Maps a user-provided line style string to its corresponding Pine Script™ line style constant.
Parameters:
styleString (simple string) : The input string representing the desired line style (e.g., "Solid", "Dashed", "Dotted" - typically from constants like LS1, LS2, LS3).
Returns: The Pine Script™ constant for the line style (e.g., line.style_solid). Defaults to line.style_solid if no match.
mapTablePosition(positionString)
Maps a user-provided table position string to its corresponding Pine Script™ position constant.
Parameters:
positionString (simple string) : The input string representing the desired table position (e.g., "Top Right", "Top Center" - typically from constants like PP1, PP2).
Returns: The Pine Script™ constant for the table position (e.g., position.top_right). Defaults to position.top_right if no match.
mapTextSize(sizeString)
Maps a user-provided text size string to its corresponding Pine Script™ size constant.
Parameters:
sizeString (simple string) : The input string representing the desired text size (e.g., "Tiny", "Small" - typically from constants like PTS1, PTS2).
Returns: The Pine Script™ constant for the text size (e.g., size.tiny). Defaults to size.small if no match.
formatTimeframe(tfInput, customSuffix)
Formats a raw timeframe string into a more display-friendly string, optionally appending a custom suffix.
Parameters:
tfInput (simple string) : The raw timeframe string from user input or timeframe.period (e.g., "1", "60", "D", "W", "1S", "10M", "2H").
customSuffix (simple string) : An optional suffix to append to the formatted timeframe string (e.g., " FVG", " Period"). Defaults to an empty string.
Returns: The formatted timeframe string (e.g., "1min", "60min", "Daily", "Weekly", "1s", "10min", "2h") with the custom suffix appended.
[blackcat] L2 FiboKAMA Adaptive TrendOVERVIEW
The L2 FiboKAMA Adaptive Trend indicator leverages advanced technical analysis techniques by integrating Fibonacci principles with the Kaufman Adaptive Moving Average (KAMA). This combination creates a dynamic and responsive tool designed to adapt seamlessly to changing market conditions. By providing clear buy and sell signals based on adaptive momentum, this indicator helps traders identify potential entry and exit points effectively. Its intuitive design and robust features make it a valuable addition to any trader’s arsenal 📊💹.
According to the principle of Kaufman's Adaptive Moving Average (KAMA), it is a type of moving average line specifically designed for markets with high volatility. Unlike traditional moving averages, KAMA can automatically adjust its period based on market conditions to improve accuracy and responsiveness. This makes it particularly useful for capturing market trends and reducing false signals in varying market environments.
The use of Fibonacci magic numbers (3, 8, 13) enhances the performance and accuracy of KAMA. These numbers have special mathematical properties that align well with the changing trends of KAMA moving averages. Combining them with KAMA can significantly boost its effectiveness, making it a popular choice among traders seeking reliable signals.
This fusion not only smoothens price fluctuations but also ensures quick responses to market changes, offering dependable entry and exit points. Thanks to the flexibility and precision of KAMA combined with Fibonacci magic numbers, traders can better manage risks and aim for higher returns.
FEATURES
Enhanced Kaufman Adaptive Moving Average (KAMA): Incorporates Fibonacci principles for improved adaptability:
Source Price: Allows customization of the price series used for calculation (default: HLCC4).
Fast Length: Determines the period for quicker adjustments to recent price changes.
Slow Length: Sets the period for smoother transitions over longer-term trends.
Dynamic Lines:
KAMA Line: A yellow line representing the primary adaptive moving average, which adapts quickly to new trends.
Trigger Line: A fuchsia line serving as a reference point for detecting crossovers and generating signals.
Visual Cues:
Buy Signals: Green 'B' labels indicating potential buying opportunities.
Sell Signals: Red 'S' labels signaling possible selling points.
Fill Areas: Colored regions between the KAMA and Trigger lines to visually represent trend directions and strength.
Alert Functionality: Generates real-time alerts for both buy and sell signals, ensuring timely notifications for actionable insights 🔔.
Customizable Parameters: Offers flexibility through adjustable inputs, allowing users to tailor the indicator to their specific trading strategies and preferences.
HOW TO USE
Adding the Indicator:
Open your TradingView chart and navigate to the indicators list.
Select L2 FiboKAMA Adaptive Trend and add it to your chart.
Configuring Parameters:
Adjust the Source Price to choose the desired price series (e.g., close, open, high, low).
Set the Fast Length to define how quickly the indicator responds to recent price movements.
Configure the Slow Length to determine the smoothness of long-term trend adaptations.
Interpreting Signals:
Monitor the chart for green 'B' labels indicating buy signals and red 'S' labels for sell signals.
Observe the colored fill areas between the KAMA and Trigger lines to gauge trend strength and direction.
Setting Up Alerts:
Enable alerts within the indicator settings to receive notifications whenever buy or sell signals are triggered.
Customize alert messages and frequencies according to your trading plan.
Combining with Other Tools:
Integrate this indicator with additional technical analysis tools and fundamental research for comprehensive decision-making.
Confirm signals using other indicators like RSI, MACD, or Bollinger Bands for increased reliability.
Optimizing Performance:
Backtest the indicator across various assets and timeframes to understand its behavior under different market conditions.
Fine-tune parameters based on historical performance and current market dynamics.
Integrating Magic Numbers:
Understand the basic principles of KAMA to find suitable entry points for Fibonacci magic numbers.
Utilize the efficiency ratio to measure market volatility and adjust moving average parameters accordingly.
Apply Fibonacci magic numbers (3, 8, 13) to enhance the responsiveness and accuracy of KAMA.
LIMITATIONS
Market Volatility: May produce false signals during periods of extreme volatility or sideways movement.
Parameter Sensitivity: Requires careful tuning of fast and slow lengths to balance responsiveness and stability.
Asset-Specific Behavior: Effectiveness can vary significantly across different financial instruments and time horizons.
Complementary Analysis: Should be used alongside other analytical methods to enhance accuracy and reduce risk.
NOTES
Historical Data: Ensure adequate historical data availability for precise calculations and backtesting.
Demo Testing: Thoroughly test the indicator on demo accounts before deploying it in live trading environments.
Continuous Learning: Stay updated with market trends and continuously refine your strategy incorporating feedback from the indicator's performance.
Risk Management: Always implement proper risk management practices regardless of the signals provided by the indicator.
ADVANCED USAGE TIPS
Multi-Timeframe Analysis: Apply the indicator across multiple timeframes to gain deeper insights into underlying trends.
Divergence Strategy: Look for divergences between price action and the KAMA line to spot potential reversals early.
Volume Integration: Combine volume analysis with the indicator to confirm the strength of identified trends.
Custom Scripting: Modify the script to include additional filters or conditions tailored to your unique trading approach.
IMPROVING KAMA PERFORMANCE
Increase Length: Extend the KAMA length to consider more historical data, reducing the impact of short-term price fluctuations.
Adjust Fast and Slow Lengths: Make KAMA smoother by increasing the fast length and decreasing the slow length.
Use Smoothing Factor: Apply a smoothing factor to control the level of smoothness; typical values range from 0 to 1.
Combine with Other Indicators: Pair KAMA with other smoothing indicators like EMA or SMA for more reliable signals.
Filter Noise: Use filters or other technical analysis tools to eliminate price noise, enhancing KAMA's effectiveness.
Dynamic Customizable 50% Line & Daily High/Low + True Day OpenA Unique Indicator for Precise Market-Level Analysis
This indicator is a fully integrated solution that automates complex market-level calculations and visualizations, offering traders a tool that goes beyond the functionality of existing open-source alternatives. By seamlessly combining several trading concepts into a single script, it delivers efficiency, accuracy, and customization that cater to both novice and professional traders.
Key Features: A Breakdown of What Makes It Unique
1. Adaptive Daily Highs and Lows
Automatically detects and plots daily high and low levels based on the selected time frame, dynamically updating in real time.
Features session-based adjustments, allowing traders to focus on levels that matter for specific trading sessions (e.g., London, New York).
Fully customizable styling, visibility, and alerts tailored to each trader’s preferences.
How It Works:
The indicator calculates daily high and low levels directly from price data, integrating session-specific time offsets to account for global trading hours. These levels provide traders with clear visual markers for key liquidity zones.
2. Automated ICT 50% Range Line
A pioneering implementation of ICT’s mid-range concept, this feature dynamically calculates and displays the midpoint of the daily range.
Offers traders a visual guide to identify premium and discount zones, aiding in determining market bias and potential trade setups.
How It Works:
The script calculates the range between the day’s high and low, dividing it by two to generate the midline. This line updates in real-time, ensuring that traders always see the most current premium and discount levels as price action evolves.
3. Dynamic Market Open Levels
Plots session opens (e.g., Asia, London, New York) and the True Day Open to provide actionable reference points for intra-day trading strategies.
Enhances precision in identifying liquidity shifts and aligning trades with institutional price movements.
How It Works:
The indicator uses predefined session times to calculate and display the opening levels for key trading sessions. It dynamically adjusts for time zones, ensuring accuracy regardless of the trader’s location.
4. Custom Watermark for Enhanced Visualization
Includes an optional watermark feature that allows users to display custom text on their charts.
Ideal for personalization, branding, or highlighting session notes without disrupting the clarity of the chart.
Why This Indicator Stands Out
First-to-Market Automation:
While the ICT 50% range line is a widely recognized concept, this is the first script to automate its calculation, combining it with other pivotal trading levels in a single tool.
All-in-One Functionality:
Unlike open-source alternatives that focus on individual features, this script integrates daily highs/lows, mid-range levels, session opens, and customizable watermarks into one cohesive system. The consolidation reduces the need for multiple indicators and ensures a clean, efficient chart setup.
Dynamic Customization:
Every feature can be adjusted to align with a trader’s strategy, time zone, or aesthetic preferences. This level of adaptability is unmatched in existing tools.
Proprietary Logic:
The indicator’s underlying calculations are built from scratch, leveraging advanced programming techniques to ensure accuracy and reliability. These proprietary methods differentiate it from similar open-source scripts.
How to Use This Indicator
Apply the Indicator:
Add it to your TradingView chart from the library.
Configure Settings:
Use the intuitive settings panel to adjust plotted levels, colors, styles, and visibility. Tailor the indicator to your trading strategy.
Incorporate into Analysis:
Combine the plotted levels with your preferred trading approach to identify liquidity zones, establish market bias, and pinpoint potential reversals or entries.
Stay Focused:
With all key levels automated and updated in real time, traders can focus on execution rather than manual plotting.
Originality and Justification for Closed Source
This script is closed-source due to its unique combination of features and proprietary logic that automates complex trading concepts like the ICT 50% range line and session-specific levels. Open-source alternatives lack this level of integration and customization, making this indicator a valuable and original contribution to the TradingView ecosystem.
What Sets It Apart from Open-Source Scripts?
Unlike open-source tools, this indicator doesn’t just replicate individual features—it enhances and integrates them into a seamless, all-in-one solution that offers traders a more efficient and effective way to analyze the market.
Fibonacci Retracement MTF/LOGIn Pine Script, there’s always a shorter way to achieve a result. As far as I can see, there isn’t an indicator among the community scripts that can produce Fibonacci Retracement levels (linear and logarithmic) as multiple time frame results based on a reference 🍺 This script, which I developed a long time ago, might serve as a starting point to fill this gap.
OVERVIEW
This indicator is a short and simple script designed to display Fibonacci Retracement levels on the chart according to user preferences, aiming to build the structure of support and resistance.
ORIGINALITY
This script:
Can calculate 'retracement' results from higher time frames.
Can recall previous time frame results using its reference parameter.
Performs calculations based on both linear and logarithmic scales.
Offers optional multipliers and appearance settings to simplify users’ tasks
CONCEPTS
Fibonacci Retracement is a technical analysis tool used to predict potential reversal points in an asset's price after a significant movement. This indicator identifies possible support and resistance levels by measuring price movements between specific points in a trend, using certain ratios derived from the Fibonacci sequence. It is based on impulsive price actions.
MECHANICS
This indicator first identifies the highest and lowest prices in the time frame specified by the user. Next, it determines the priority order of the bars where these prices occurred. Finally, it defines the trend direction. Once the trend direction is determined, the "Retracement" levels are constructed.
FUNCTIONS
The script contains two functions:
f_ret(): Generates levels based on the multiplier parameter.
f_print(): Handles the visualization by drawing the levels on the chart and positioning the labels in alignment with the levels. It utilizes parameters such as ordinate, confirmation, multiplier, and color for customization
NOTES
The starting bar for the time frame entered by the user must exist on the chart. Otherwise, the trend direction cannot be determined correctly, and the levels may be drawn inaccurately. This is also mentioned in the tooltip of the TimeFrame parameter.
I hope it helps everyone. Do not forget to manage your risk. And trade as safely as possible. Best of luck!
Black-Scholes option price model & delta hedge strategyBlack-Scholes Option Pricing Model Strategy
The strategy is based on the Black-Scholes option pricing model and allows the calculation of option prices, various option metrics (the Greeks), and the creation of synthetic positions through delta hedging.
ATTENTION!
Trading derivative financial instruments involves high risks. The author of the strategy is not responsible for your financial results! The strategy is not self-sufficient for generating profit! It is created exclusively for constructing a synthetic derivative financial instrument. Also, there might be errors in the script, so use it at your own risk! I would appreciate it if you point out any mistakes in the comments! I would be even more grateful if you send the corrected code!
Application Scope
This strategy can be used for delta hedging short positions in sold options. For example, suppose you sold a call option on Bitcoin on the Deribit exchange with a strike price of $60,000 and an expiration date of September 27, 2024. Using this script, you can create a delta hedge to protect against the risk of loss in the option position if the price of Bitcoin rises.
Another example: Suppose you use staking of altcoins in your strategies, for which options are not available. By using this strategy, you can hedge the risk of a price drop (Put option). In this case, you won't lose money if the underlying asset price increases, unlike with a short futures position.
Another example: You received an airdrop, but your tokens will not be fully unlocked soon. Using this script, you can fully hedge your position and preserve their dollar value by the time the tokens are fully unlocked. And you won't fear the underlying asset price increasing, as the loss in the event of a price rise is limited to the option premium you will pay if you rebalance the portfolio.
Of course, this script can also be used for simple directional trading of momentum and mean reversion strategies!
Key Features and Input Parameters
1. Option settings:
- Style of option: "European vanilla", "Binary", "Asian geometric".
- Type of option: "Call" (bet on the rise) or "Put" (bet on the fall).
- Strike price: the option contract price.
- Expiration: the expiry date and time of the option contract.
2. Market statistic settings:
- Type of price source: open, high, low, close, hl2, hlc3, ohlc4, hlcc4 (using hl2, hlc3, ohlc4, hlcc4 allows smoothing the price in more volatile series).
- Risk-free return symbol: the risk-free rate for the market where the underlying asset is traded. For the cryptocurrency market, the return on the funding rate arbitrage strategy is accepted (a special function is written for its calculation based on the Premium Price).
- Volatility calculation model: realized (standard deviation over a moving period), implied (e.g., DVOL or VIX), or custom (you can specify a specific number in the field below). For the cryptocurrency market, the calculation of implied volatility is implemented based on the product of the realized volatility ratio of the considered asset and Bitcoin to the Bitcoin implied volatility index.
- User implied volatility: fixed implied volatility (used if "Custom" is selected in the "Volatility Calculation Method").
3. Display settings:
- Choose metric: what to display on the indicator scale – the price of the underlying asset, the option price, volatility, or Greeks (all are available).
- Measure: bps (basis points), percent. This parameter allows choosing the unit of measurement for the displayed metric (for all except the Greeks).
4. Trading settings:
- Hedge model: None (do not trade, default), Simple (just open a position for the full volume when the strike price is crossed), Synthetic option (creating a synthetic option based on the Black-Scholes model).
- Position side: Long, Short.
- Position size: the number of units of the underlying asset needed to create the option.
- Strategy start time: the moment in time after which the strategy will start working to create a synthetic option.
- Delta hedge interval: the interval in minutes for rebalancing the portfolio. For example, a value of 5 corresponds to rebalancing the portfolio every 5 minutes.
Post scriptum
My strategy based on the SegaRKO model. Many thanks to the author! Unfortunately, I don't have enough reputation points to include a link to the author in the description. You can find the original model via the link in the code, as well as through the search indicators on the charts by entering the name: "Black-Scholes Option Pricing Model". I have significantly improved the model: the calculation of volatility, risk-free rate and time value of the option have been reworked. The code performance has also been significantly optimized. And the most significant change is the execution, with which you can now trade using this script.
Helacator Ai ThetaHelacator Ai Theta is a state-of-the-art advanced script. It helps the trader find the possibility of a trend reversal in the market. By finding that point at which the three black crows pattern combines with the three white soldiers pattern, it is the most cherished pattern in technical analysis for its signal of strong bullish or bearish momentum. Therefore, it is a very strong predictive tool in the ability of shifting markets.
Key Highlights: Three White Soldiers and Three Black Crows Patterns
The script identifies these candlestick formations that consist of three consecutive candles, either bullish (Three White Soldiers) or bearish (Three Black Crows). These patterns help the trader identify possible trend reversal points as they provide an early signal of a change in the market direction. It is with great care that the script is written to evaluate the position and relationship between the candlesticks for maintaining the accuracy of pattern recognition. Moving Averages for Trend Filtering:
Two important ones used are moving averages for filtering any signals not in accordance with the general trend. The length of these MAs is variable, allowing the traders to be in a position to adapt the script for use under different market conditions. The moving averages ensure that signals are only taken in the direction that supports the general market flow, so it leads to more reliability within the signals. The MAs are not plotted on the chart for the sake of clarity, but they still perform a crucial function in signal filtering and can be displayed optionally for a more detailed investigation. Cooldown filter to reduce over-trading
This is part of what is implemented in the script to prevent generation of consecutive signals too quickly. All this helps to reduce market noise and not overtrade—only when market conditions are at their best. The cooldown period can be set to be adjusted according to the trader's preference, making the script more versatile in its use. Practical Considerations: Educational Purpose: This script is for educational purposes only and should be part of a comprehensive trading approach. Proper risk management techniques should be observed while at the same time taking into consideration prevailing market conditions before making any trading decision.
No Guaranteed Results: The script is aimed at bringing signal accuracy into improvement to align with the broader market trend and reducing noise, but past performance cannot guarantee future success. Traders should use this script within their broad trading approach. Clean and Simple Chart Display: The primary goal of this script is to have a clear and simple display on the chart. The signals are prominently marked with "BUY" and "SELL," and the color of the bars has changed according to the last signal, thus traders can easily read the output. Community and Open Source Open Source Contribution: This script is open for contribution by the TradingView community. Any suggestions regarding improvements are highly welcomed. Candlestick patterns, moving averages, and the combination of the cooldown filter are presented in such a way as to give traders something special, and any modifications or extra touch by the community is appreciated. Attribution and Transparency: The script is based on standard technical analysis principles and for all parts inspired by or derivated from other available open-source scripts, credit is given where it is due. In this way, transparency ensures that the script adheres to TradingView's standards and promotes a collaborative community environment.
Dynamic Cycle Oscillator [Quantigenics]This script is designed to navigate through the ebbs and flows of financial markets. At its core, this script is a sophisticated yet user-friendly tool that helps you identify potential market turning points and trend continuations.
How It Works:
The script operates by plotting two distinct lines and a central histogram that collectively form a band structure: a center line and two outer boundaries, indicating overbought and oversold conditions. The lines are calculated based on a blend of exponential moving averages, which are then refined by a root mean square (RMS) over a specified number of bars to establish the cyclic envelope.
The input parameters:
Fast and Slow Periods:
These determine the sensitivity of the script. Shorter periods react quicker to price changes, while longer periods offer a smoother view.
RMS Length:
This parameter controls the range of the cyclic envelope, influencing the trigger levels for trading signals.
Using the Script:
On your chart, you’ll notice how the Dynamic Cycle Oscillator’s lines and histogram weave through the price action. Here’s how to interpret the movements.
Breakouts and Continuations:
Buy Signal: Consider a long position when the histogram crosses above the upper boundary. This suggests a possible strong bullish run.
Sell Signal: Consider a short position when the histogram crosses below the lower boundary. This suggests a possible strong bearish run.
Reversals:
Buy Signal: Consider a long position when the histogram crosses above the lower boundary. This suggests an oversold market turning bullish.
Sell Signal: Consider a short position when the histogram crosses below the upper boundary. This implies an overbought market turning bearish.
The script’s real-time analysis can serve as a robust addition to your trading strategy, offering clarity in choppy markets and an edge in trend-following systems.
Thanks! Hope you enjoy!
Triple MA HTF Indicator - Dynamic SmoothingThe indicator version of the "Triple MA HTF Strategy - Dynamic Smoothing" strategy script. In summary the indicator consist of 3 higher time frame moving averages. In which the highest timeframe is used for confirmation on the trend (filter). Moving average 1 and 2 are used to enter and exit the trade (crossover / crossunder). The main principle is to detect momentum when the faster MA 1 crosses the slower MA 2 and only trade with the trend (MA3). The dynamic smoothing in the code makes the indicator suitable to trade on lower tramecharts. The indicator script comes with the following features:
options for different types of MA.
options to choose from different timeframes & select # bars of that timeframe to calculate the MA value.
visualizations of the MA using Dynamic Smoothing calculations on lower timecharts. Note that the chart opened should be lower than the selected timeframes in the configurations.
Alerts for entry long, shorts and exits.
For more details on the script and possibility for backtesting the Triple MA HTF indicator I refer to my earlier published strategy script:
Buy Sell Volume SeparateDescription:
The script is designed to provide traders with a unique and comprehensive analysis of trading volume dynamics. Unlike existing scripts, the script offers a distinct advantage by presenting both buy and sell volumes on separate scales, simplifying trading decisions.
Key Features:
1. Dual Volume Scales: The script provides two separate volume scales, one for buy volumes and another for sell volumes. This separation allows to easily distinguish between buying and selling pressure, aiding in more precise trade entries and exits.
2. Clear and Intuitive Chart: The script ensures that the chart it generates is clean and easy to understand. The buy and sell volumes are color-coded for clarity, and you can quickly identify significant volume spikes and trends.
How to Use:
1. Adding the Script: To use the script, simply add it to your TradingView chart.
2. Interpreting Buy and Sell Volumes: On the chart, you will see two separate volume scales—one for buy volumes and one for sell volumes. Green bars represent buying pressure, while red bars indicate selling pressure. Pay attention to the relative strengths and patterns of these bars to gauge market sentiment.
3. Informed Trading Decisions: Armed with insights into both buy and sell volumes, you can make more informed trading decisions. Look for divergences, patterns, or significant volume spikes to identify potential entry and exit points.
Risk Management and Positionsize - MACD exampleMastering Risk Management
Risk management is the cornerstone of successful trading, and it's often the difference between turning a profit and suffering a loss. In light of its importance, I share a risk management tool which you can use for your trading strategies. The script not only assists in position sizing but also comes with built-in technical features that help in market timing. Let's delve into the nitty-gritty details.
Input Parameter: MarginFactor
One of the key features of the script is the MarginFactor input parameter. This element lets you control the portion of your equity used for placing each trade. A MarginFactor of -0.5 means 50% of your total equity will be deployed in placing the position size. Although Tradingview has a built-in option to adjust position sizing in a same way, I personally prefer to have the logic in my pinecode script. The main reason is userexperience in managing and testing different settings for different charts, timeframes and instruments (with the same strategy).
Stoploss and MarginFactor
If your strategy has a 4% stop-loss, you can choose to use only 50% of your equity by setting the MarginFactor to -0.5. In this case, you are effectively risking only 2% of your total capital per trade, which aligns well with the widely-accepted rule of thumb suggesting a 1-2% risk per trade. Similar if your stoploss is only 1% you can choose to change the MarginFactor to 1, resulting in a positionsize of 200% of your equity. The total risk would be again 2% per trade if your stoploss is set to 1%.
Max Drawdown and MarginFactor
Your MarginFactor setting can also be aligned with the maximum drawdown of your strategy, seen during a backtested period of 2-3 years. For example, if the max drawdown is 15%, you could calibrate your MarginFactor accordingly to limit your risk exposure.
Option to Toggle Number of Contracts
The script offers the option to toggle between using a percentage of equity for position sizing or specifying a fixed number of contracts. Utilizing a percentage of equity might yield unrealistic backtest results, especially over longer periods. This occurs because as the capital grows, the absolute position size also increases, potentially inflating the accumulated returns generated by the backtester. On the other hand, setting a fixed number of contracts as your position size offers a more stable and realistic ROI over the backtested period, as it removes the compounding effect on position sizes.
Key Features Strategy
MACD High Time Frame Entry and Exit Logic
The strategy employs a high time frame MACD (Moving Average Convergence Divergence) to make entry and exit decisions. You can easily adjust the timeframe settings and MACD settings in the inputsection to trade on lower timeframes. For more information on the HTF MACD with dynamic smoothing see:
Moving Average High Time Frame Filter
To reduce market 'noise', the strategy incorporates a high time frame moving average filter. This ensures that the trades are aligned with the dominant market trend (trading the trend). In the inputsection traders can easily switch between different type of moving averages. For more information about this HTF filter see:
Dynamic Smoothing
The script includes a feature for dynamic smoothing. The script contains The timeframeToMinutes(tf) function to convert any given time frame into its equivalent in minutes. For example, a daily (D) time frame is converted into 1440 minutes, a weekly (W) into 10,080 minutes, and so forth. Next the smoothing factor is calculated by dividing the minutes of the higher time frame by those of the current time frame. Finally, the script applies a Simple Moving Average (SMA) over the MACD, SIGNAL, and HIST values, MA filter using the dynamically calculated smoothing factor.
User Convenience: One of the major benefits is that traders don't need to manually adjust the smoothing factor when switching between different time frames. The script does this dynamically.
Visual Consistency: Dynamic smoothing helps traders to more accurately visualize and interpret HTF indicators when trading on lower time frames.
Time Frame Restriction: It's crucial to note that the operational time frame should always be lower than the time frame selected in the input sections for dynamic smoothing to function as intended.
By incorporating this dynamic smoothing logic, the script offers traders a nuanced yet straightforward way to adapt High Time Frame indicators for lower time frame trading, enhancing both adaptability and user experience.
Limitations: Exit Strategy
It's crucial to note that the script comes with a simplified exit strategy, devoid of features like a stop-loss, trailing stop-loss or multiple take profits. This means that while the script focuses on entries and risk management, it might result in higher losses if market conditions unexpectedly turn unfavorable.
Conclusion
Effective risk management is pivotal for trading success, and this TradingView script is designed to give you a better idea how to implement positions sizing with your preferred strategy. However, it's essential to note that this tool should not be considered financial advice. Always perform your due diligence and consult with financial advisors before making any trading decisions.
Feel free to use this risk management tool as building block in your trading scripts, Happy Trading!
Machine Learning : Cosine Similarity & Euclidean DistanceIntroduction:
This script implements a comprehensive trading strategy that adheres to the established rules and guidelines of housing trading. It leverages advanced machine learning techniques and incorporates customised moving averages, including the Conceptive Price Moving Average (CPMA), to provide accurate signals for informed trading decisions in the housing market. Additionally, signal processing techniques such as Lorentzian, Euclidean distance, Cosine similarity, Know sure thing, Rational Quadratic, and sigmoid transformation are utilised to enhance the signal quality and improve trading accuracy.
Features:
Market Analysis: The script utilizes advanced machine learning methods such as Lorentzian, Euclidean distance, and Cosine similarity to analyse market conditions. These techniques measure the similarity and distance between data points, enabling more precise signal identification and enhancing trading decisions.
Cosine similarity:
Cosine similarity is a measure used to determine the similarity between two vectors, typically in a high-dimensional space. It calculates the cosine of the angle between the vectors, indicating the degree of similarity or dissimilarity.
In the context of trading or signal processing, cosine similarity can be employed to compare the similarity between different data points or signals. The vectors in this case represent the numerical representations of the data points or signals.
Cosine similarity ranges from -1 to 1, with 1 indicating perfect similarity, 0 indicating no similarity, and -1 indicating perfect dissimilarity. A higher cosine similarity value suggests a closer match between the vectors, implying that the signals or data points share similar characteristics.
Lorentzian Classification:
Lorentzian classification is a machine learning algorithm used for classification tasks. It is based on the Lorentzian distance metric, which measures the similarity or dissimilarity between two data points. The Lorentzian distance takes into account the shape of the data distribution and can handle outliers better than other distance metrics.
Euclidean Distance:
Euclidean distance is a distance metric widely used in mathematics and machine learning. It calculates the straight-line distance between two points in Euclidean space. In two-dimensional space, the Euclidean distance between two points (x1, y1) and (x2, y2) is calculated using the formula sqrt((x2 - x1)^2 + (y2 - y1)^2).
Dynamic Time Windows: The script incorporates a dynamic time window function that allows users to define specific time ranges for trading. It checks if the current time falls within the specified window to execute the relevant trading signals.
Custom Moving Averages: The script includes the CPMA, a powerful moving average calculation. Unlike traditional moving averages, the CPMA provides improved support and resistance levels by considering multiple price types and employing a combination of Exponential Moving Averages (EMAs) and Simple Moving Averages (SMAs). Its adaptive nature ensures responsiveness to changes in price trends.
Signal Processing Techniques: The script applies signal processing techniques such as Know sure thing, Rational Quadratic, and sigmoid transformation to enhance the quality of the generated signals. These techniques improve the accuracy and reliability of the trading signals, aiding in making well-informed trading decisions.
Trade Statistics and Metrics: The script provides comprehensive trade statistics and metrics, including total wins, losses, win rate, win-loss ratio, and early signal flips. These metrics offer valuable insights into the performance and effectiveness of the trading strategy.
Usage:
Configuring Time Windows: Users can customize the time windows by specifying the start and finish time ranges according to their trading preferences and local market conditions.
Signal Interpretation: The script generates long and short signals based on the analysis, custom moving averages, and signal processing techniques. Users should pay attention to these signals and take appropriate action, such as entering or exiting trades, depending on their trading strategies.
Trade Statistics: The script continuously tracks and updates trade statistics, providing users with a clear overview of their trading performance. These statistics help users assess the effectiveness of the strategy and make informed decisions.
Conclusion:
With its adherence to housing trading rules, advanced machine learning methods, customized moving averages like the CPMA, and signal processing techniques such as Lorentzian, Euclidean distance, Cosine similarity, Know sure thing, Rational Quadratic, and sigmoid transformation, this script offers users a powerful tool for housing market analysis and trading. By leveraging the provided signals, time windows, and trade statistics, users can enhance their trading strategies and improve their overall trading performance.
Disclaimer:
Please note that while this script incorporates established tradingview housing rules, advanced machine learning techniques, customized moving averages, and signal processing techniques, it should be used for informational purposes only. Users are advised to conduct their own analysis and exercise caution when making trading decisions. The script's performance may vary based on market conditions, user settings, and the accuracy of the machine learning methods and signal processing techniques. The trading platform and developers are not responsible for any financial losses incurred while using this script.
By publishing this script on the platform, traders can benefit from its professional presentation, clear instructions, and the utilisation of advanced machine learning techniques, customised moving averages, and signal processing techniques for enhanced trading signals and accuracy.
I extend my gratitude to TradingView, LUX ALGO, and JDEHORTY for their invaluable contributions to the trading community. Their innovative scripts, meticulous coding patterns, and insightful ideas have profoundly enriched traders' strategies, including my own.
Trend Line Adam Moradi v1 (Tutorial Content)
The Pine Script strategy that plots pivot points and trend lines on a chart. The strategy allows the user to specify the period for calculating pivot points and the number of pivot points to be used for generating trend lines. The user can also specify different colors for the up and down trend lines.
The script starts by defining the input parameters for the strategy and then calculates the pivot high and pivot low values using the pivothigh() and pivotlow() functions. It then stores the pivot points in two arrays called trend_top_values and trend_bottom_values. The script also has two arrays called trend_top_position and trend_bottom_position which store the positions of the pivot points.
The script then defines a function called add_to_array() which takes in three arguments: apointer1, apointer2, and val. This function adds val to the beginning of the array pointed to by apointer1, and adds bar_index to the beginning of the array pointed to by apointer2. It then removes the last element from both arrays.
The script then checks if a pivot high or pivot low value has been calculated, and if so, it adds the value and its position to the appropriate arrays using the add_to_array() function.
Next, the script defines two arrays called bottom_lines and top_lines which will be used to store trend lines. It also defines a variable called starttime which is set to the current time.
The script then enters a loop to calculate and plot the trend lines. It first deletes any existing trend lines from the chart. It then enters two nested loops which iterate over the pivot points stored in the trend_bottom_values and trend_top_values arrays. For each pair of pivot points, the script calculates the slope of the line connecting them and checks if the line is a valid trend line by iterating over the price bars between the two pivot points and checking if the line is above or below the close price of each bar. If the line is found to be a valid trend line, it is plotted on the chart using the line.new() function.
Finally, the script colors the trend lines using the colors specified by the user.
Tutorial Content
'PivotPointNumber' is an input parameter for the script that specifies the number of pivot points to consider when calculating the trend lines. The value of 'PivotPointNumber' is set by the user when they configure the script. It is used to determine the size of the arrays that store the values and positions of the pivot points, as well as the number of pivot points to loop through when calculating the trend lines.
'up_trend_color' is an input parameter for the script that specifies the color to use for drawing the trend lines that are determined to be upward trends. The value of 'up_trend_color' is set by the user when they configure the script and is passed to the color parameter of the line.new() function when drawing the upward trend lines. It determines the visual appearance of the upward trend lines on the chart.
'down_trend_color' is an input parameter for the script that specifies the color to use for drawing the trend lines that are determined to be downward trends. The value of 'down_trend_color' is set by the user when they configure the script and is passed to the color parameter of the line.new() function when drawing the downward trend lines. It determines the visual appearance of the downward trend lines on the chart.
'pivothigh' is a variable in the script that stores the value of the pivot high point. It is calculated using the pivothigh() function, which returns the highest high over a specified number of bars. The value of 'pivothigh' is used in the calculation of the trend lines.
'pivotlow' is a variable in the script that stores the value of the pivot low point. It is calculated using the pivotlow() function, which returns the lowest low over a specified number of bars. The value of 'pivotlow' is used in the calculation of the trend lines.
'trend_top_values' is an array in the script that stores the values of the pivot points that are determined to be at the top of the trend. These are the pivot points that are used to calculate the upward trend lines.
'trend_top_position' is an array in the script that stores the positions (i.e., bar indices) of the pivot points that are stored in the 'trend_top_values' array. These positions correspond to the locations of the pivot points on the chart.
'trend_bottom_values' is an array in the script that stores the values of the pivot points that are determined to be at the bottom of the trend. These are the pivot points that are used to calculate the downward trend lines.
'trend_bottom_position' is an array in the script that stores the positions (i.e., bar indices) of the pivot points that are stored in the 'trend_bottom_values' array. These positions correspond to the locations of the pivot points on the chart.
apointer1 and apointer2 are variables used in the add_to_array() function, which is defined in the script. They are both pointers to arrays, meaning that they hold the memory addresses of the arrays rather than the arrays themselves. They are used to manipulate the arrays by adding new elements to the beginning of the arrays and removing elements from the end of the arrays.
apointer1 is a pointer to an array of floating-point values, while apointer2 is a pointer to an array of integers. The specific arrays that they point to depend on the arguments passed to the add_to_array() function when it is called. For example, if add_to_array(trend_top_values, trend_top_posisiton, pivothigh) is called, then apointer1 would point to the tval array and apointer2 would point to the tpos array.
'bottom_lines' (short for "Bottom Lines") is an array in the script that stores the line objects for the downward trend lines that are drawn on the chart. Each element of the array corresponds to a different trend line.
'top_lines' (short for "Top Lines") is an array in the script that stores the line objects for the upward trend lines that are drawn on the chart. Each element of the array corresponds to a different trend line.
Both 'bottom_lines' and 'top_lines' are arrays of type "line", which is a data type in PineScript that represents a line drawn on a chart. The line objects are created using the line.new() function and are used to draw the trend lines on the chart. The variables are used to store the line objects so that they can be manipulated and deleted later in the script.
Loops
maxline is a variable in the script that specifies the maximum number of trend lines that can be drawn on the chart. It is used to determine the size of the bottom_lines and top_lines arrays, which store the line objects for the trend lines.
The value of maxline is set to 3 at the beginning of the script, meaning that at most 3 trend lines can be drawn on the chart at a time. This value can be changed by the user if desired by modifying the assignment statement "maxline = 3".
'count_line_low' (short for "Count Line Low") is a variable in the script that keeps track of the number of downward trend lines that have been drawn on the chart. It is used to ensure that the maximum number of trend lines (as specified by the maxline variable) is not exceeded.
'count_line_high' (short for "Count Line High") is a variable in the script that keeps track of the number of upward trend lines that have been drawn on the chart. It is used to ensure that the maximum number of trend lines (as specified by the maxline variable) is not exceeded.
Both 'count_line_low' and 'count_line_high' are initialized to 0 at the beginning of the script and are incremented each time a new trend line is drawn. If either variable exceeds the value of maxline, then no more trend lines are drawn.
'pivot1', 'up_val1', 'up_val2', up1, and up2 are variables used in the loop that calculates the downward trend lines in the script. They are used to store intermediate values during the calculation process.
'pivot1' is a loop variable that is used to iterate through the pivot points (stored in the trend_bottom_values and trend_bottom_position arrays) that are being considered for use in the trend line calculation.
'up_val1' and 'up_val2' are variables that store the values of the pivot points that are used to calculate the downward trend line.
up1 and up2 are variables that store the positions (i.e., bar indices) of the pivot points that are stored in 'up_val1' and 'up_val2', respectively. These positions correspond to the locations of the pivot points on the chart.
'value1' and 'value2' are variables that are used to store the values of the pivot points that are being compared in the loop that calculates the trend lines in the script. They are used to determine whether a trend line can be drawn between the two pivot points.
For example, if 'value1' is the value of a pivot point at the top of the trend and 'value2' is the value of a pivot point at the bottom of the trend, then a trend line can be drawn between the two points if 'value1' is greater than 'value2'. The values of 'value1' and 'value2' are used in the calculation of the slope and intercept of the trend line.
'position1' and 'position2' are variables that are used to store the positions (i.e., bar indices) of the pivot points that are being compared in the loop that calculates the trend lines in the script. They are used to determine the distance between the pivot points, which is necessary for calculating the slope of the trend line.
For example, if 'position1' is the position of a pivot point at the top of the trend and 'position2' is the position of a pivot point at the bottom of the trend, then the distance between the two points is given by 'position1' - 'position2'. This distance is used in the calculation of the slope of the trend line.
'different', 'high_line', 'low_location', 'low_value', and 'valid' are variables that are used in the loop that calculates the downward trend lines in the script. They are used to store intermediate values during the calculation process.
'different' is a variable that stores the slope of the downward trend line being calculated. It is calculated as the difference in value between the two pivot points (stored in up_val1 and up_val2) divided by the distance between the pivot points (calculated using their positions, stored in up1 and up2).
'high_line' is a variable that stores the current value of the trend line being calculated at a given point in the loop. It is initialized to the value of the second pivot point (stored in up_val2) and is updated on each iteration of the loop using the value of different.
'low_location' is a variable that stores the position (i.e., bar_index) on the chart of the point where the trend line being calculated first touches the low price. It is initialized to the position of the second pivot point (stored in up2) and is updated on each iteration of the loop if the trend line touches a lower low.
'low_value' is a variable that stores the value of the trend line at the point where it first touches the low price. It is initialized to the value of the second pivot point (stored in up_val2) and is updated on each iteration of the loop if the trend line touches a lower low.
'valid' is a Boolean variable that is used to indicate whether the trend line being calculated is valid. It is initialized to true and is set to false if the trend line does not pass through all the lows between the pivot points. If valid is still true after the loop has completed, then the trend line is considered valid and is drawn on the chart.
d_value1, d_value2, d_position1, and d_position2 are variables that are used in the loop that calculates the upward trend lines in the script. They are used to store intermediate values during the calculation process.
d_value1 and d_value2 are variables that store the values of the pivot points that are used to calculate the upward trend line.
d_position1 and d_position2 are variables that store the positions (i.e., bar indices) of the pivot points that are stored in d_value1 and d_value2, respectively. These positions correspond to the locations of the pivot points on the chart.
The variables d_value1, d_value2, d_position1, and d_position2 have the same function as the variables uv1, uv2, up1, and up2, respectively, but for the calculation of the upward trend lines rather than the downward trend lines. They are used in a similar way to store intermediate values during the calculation process.
thank you.
Stoch/RSI with EMA50 Cross & HHLLA hybrid but simple indicator that plots 4 strategies in one pane .
1) RSI Indicator
2) Stoch RSI
3) EMA50 Cross (To determine direction in current timeframe)
4) Higher Highs & Lower Lows to analyze the trend and break of trend
The relative strength index (RSI) is a momentum indicator used in technical analysis. It is displayed as an oscillator (a line graph) on a scale of zero to 100. When the RSI indicator crosses 30 on the RSI chart, it is a bullish sign and when it crosses 70, it is a bearish sign.
The Stochastic RSI (StochRSI) is also a momentum indicator used in technical analysis. It is displayed as an oscillator (a line graph) on a scale of zero to 100. When the StochRSI indicator crosses 20 on the RSI chart, it is a bullish sign and when it crosses 80, it is a bearish sign.
The EMA50Cross denotes two cases in the script:
a) A crossover of CMP on the EMA50 is highlighted by a green bar signals a possible bullish trend
b) A crossunder of CMP on the EMA50 is highlighted by a red bar signals a possible bearish trend
The HHLL is denoted by mneumonics HH, HL,LH, LL. A combination of HHs and HLs denotes a uptrend while the combination of LLs and LHs denoted a downtrend
The current script should be used in confluence of other trading strategies and not in isolation.
Scenario 1:
If a EMA50Cross over bar (GREEN) is highlighted with the StochRSI below 20 and the given script is plotting HHs and HLs, we are most likely in a bullish trend for the given timeframe and a long can be initiated in confluence with other trading strategies used by the user. The RSI signal may now be utilized to determine a good range of entry/exit.
Scenario 2:
If a EMA50Cross under bar (RED) is highlighted with the StochRSI above 80 and the given script is plotting LLs and LHs, we are most likely in a bearish trend for the given timeframe and a short can be initiated in confluence with other trading strategies used by the user. The RSI signal may now be utilized to determine a good range of entry/exit.
Disclaimer:
The current script should be used in confluence with other trading strategies and not in isolation. The scripts works best on 4H and 1D Timeframes and should be used with caution on lower timeframes.
This indicator is not intended to give exact entry or exit points for a trade but to provide a general idea of the trend & determine a good range for entering or exiting the trade. Please DYOR
Credit & References:
This script uses the default technical analysis reference library provided by PineScript (denoted as ta)
MTFindicatorsQuite recently TradingView added the possibility to create and use Libraries in PineScript. With this feature PineScript became higher quality of coding language overnight. Libraries enable splitting your code into multiple files, providing easier access to code reusability.
I was working on a script which included 3000 lines of code, which was recompiling 1:30 min, and recalculating over 1 minute as well. So I split it into 2 parts: main part + library containing "main logic", which I reuse in variety of scripts, but don't change too often. Result? Now recompilation of my main script takes 10 and recalculation 8 seconds!!!. I instantly fell in love with libraries.
Having said that, and being dedicated hater of security() calls, I have decided to publish a library of MTF indicators created with my own approach: "dig into formula". I have explained reasons for such approach in desription to this script:
So this library script will be a set of indicators reaching to higher timeframes. Just include one line at the beginning of the script you are creating:
import Peter_O/MTFindicators/1 as LIB
and then somewhere is the code add this line:
rsimtf=LIB.rsi_mtf(close,5,14)
All of a sudden you have access to rsimtf from 5x higher timeframe without any hassle :)
I start with RSI MTF, next ones will be ADX, Stochastic and some more. I will update this library with them here as well. Feel free to request particular indicators in comments. Maybe PSAR? Maybe Bollinger Bands?
Exponential MA Channel, Daily Timeframe (Crypto)Moving averages are some of the most common tools for traders. Some of the most widely used ones are simple moving averages (e.g. 20SMA, 50 SMA, 100 SMA, 200SMA,...). There are endless combinations of moving averages that can be used. I prefer to use exponential moving averages because they react more quickly to price data (essentially they filter back through the data over a discrete number of timesteps, with more recent history receiving the highest weighting in the final calculation).
This script uses a combination of the 21EMA, 53 EMA, and 100EMA. The idea of this script is to provide insight into when an asset might be close to a local top/bottom by monitoring price within the middle channel (yellow, blue, and orange lines), as well as identifying longer timeframe opportunities to buy/sell by examining the upper (green) and lower (red) bands. Disclaimer: this is not a guarantee that if price enters a region, that it will be a top or bottom, it is simply an indicator to get an idea based on price history.
As far as I know, this particular combination of exponential moving averages has not yet been published. I do not have an infinite amount of time to check through the entire library of published scripts. If someone else has already done this, I was unaware. Numerical computations were performed on ETHBTC price data in order to find the coefficients used in this script. Essentially, each EMA has a multiplier of either 1, a fraction of 1, or a number larger than 1 (these are the numbers in the script being multiplied by 'out1', 'out2', 'out3'; feel free to change these and see how this changes the indicator). I have found it to be useful for myself, and hope other people can tinker with this idea. My only wish is to allow other people to use this starting point to explore for themselves. I hope that I am allowed to publish this script without it being taken down so that others can freely use it.
Recommendations: although this was fit specifically for ETHBTC, it appears useful for many crypto pairs, specifically alt-BTC pairs and crypto-USD pairs. For example, I have found it useful for BTCUSD, ETHUSD, LINKUSD, LINKBTC, ETHBTC, ADABTC, etc. Only use on the DAILY timeframe.
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!
Tick Data DetailedHello All,
After Tick Chart and Tick Chart RSI scripts, this is Tick Data Detailed script. Like other tick scrips this one only works on real-time bars too. it creates two tables: the table at the right shows the detailed data for Current Bar and the table at the left shows the detailed data for all calculated bars (cumulative). the script checks the volume on each tick and add the tick and volume to the specified level (you can set/change levels)
The volume is multiplied by close price to calculate real volume .There are 7 levels/zones and the default levels are:
0 - 10.000
10.000 - 20.000
20.000 - 50.000
50.000 - 100.000
100.000 - 200.000
200.000 - 400.000
> 400.000
With this info, you will get number of ticks and total volumes on each levels. The idea to separate this levels is in order to know which type of traders trade at that moment. for example volume of whale moves are probably greater than 400.000 or at least 100.000. Or volume of small traders is less than 10.000 or between 20.000-50.000.
You will get info if there is anomaly on each candle as well. what is anomaly definition? Current candle is green but Sell volume is greater than Buy volume or current candle is red but Buy volume is greater than Sell volume . it is shown as (!). you should think/search why/how this anomaly occurs. You can see screenshot about it below.
also "TOTAL" text color changes automatically. if Buy volume is greater than Sell volume then its color becomes Green, if Sell volume is greater than Buy volume then its color becomes Red (or any color you set)
Optionally you can change background and text colors as shown in the example below.
Explanation:
How anomaly is shown:
You can enable coloring background and set the colors as you wish:
And Thanks to @Duyck for letting me use the special characters from his great script.
Enjoy!
Risk Management: Position Size & Risk RewardHere is a Risk Management Indicator that calculates stop loss and position sizing based on the volatility of the stock. Most traders use a basic 1 or 2% Risk Rule, where they will not risk more than 1 or 2% of their capital on any one trade. I went further and applied four levels of risk: 0.25%, 0.50%, 1% and 2%. How you apply these different levels of risk is what makes this indicator extremely useful. Here are some common ways to apply this script:
• If the stock is extremely volatile and has a better than 50% chance of hitting the stop loss, then risk only 0.25% of your capital on that trade.
• If a stock has low volatility and has less than 20% change of hitting the stop loss, then risk 2% of your capital on that trade.
• Risking anywhere between 0.25% and 2% is purely based on your intuition and assessment of the market.
• If you are on a losing streak and you want to cut back on your position sizing, then lowering the Risk % can help you weather the storm.
• If you are on a winning streak and your entries are experiencing a higher level of success, then gradually increase the Risk % to reap bigger profits.
• If you want to trade outside the noise of the market or take on more noise/risk, you can adjust the ATR Factor.
• … and whatever else you can imagine using it to benefit your trading.
The position size is calculated using the Capital and Risk % fields, which is the percentage of your total trading capital (a.k.a net liquidity or Capital at Risk). If you instead want to calculate the position size based on a specific amount of money, then enter the amount in the Custom Risk Amt input box. Any amount greater than 0 in the Custom Risk Amt field will override the values in the Capital and Risk % fields.
The stop loss is calculated by using the ATR. The default setting is the 14 RMA, but you can change the length and smoothing of the true range moving average to your liking. Selecting a different length and smoothing affects the stop loss and position size, so choose these values very carefully.
The ATR Factor is a multiplier of the ATR. The ATR Factor can be used to adjust the stop loss and move it outside of the market noise. For the more volatile stock, increase the factor to lower the stop loss and reduce the chance of getting stopped out. For stocks with less volatility , you can lower the factor to raise the stop loss and increase position size. Adjusting the ATR Factor can also be useful when you want the stop loss to be at or below key levels of support.
The Market Session is the hours the market is open. The Market Session only affects the Opening Range Breakout (ORB) option, so it’s important to change these values if you’re trading the ORB and you’re outside of Eastern Standard Time or you’re trading in a foreign exchange.
The ORB is a bonus to the script. When enabled, the indicator will only appear in the first green candle of the day (09:30:00 or 09:30 AM EST or the start time specified in Market Session). When using the ORB, the stop loss is based on the spread of the first candle at the Open. The spread is the difference between the High and Low of the green candle. On 1-day or higher timeframes, the indicator will be the spread of the last (or current) candle.
The output of the indicator is a label overlaying the chart:
1. ATR (14 RMA x2) – This indicated that the stop loss is determined by the ATR. The x2 is the ATR Factor. If ORB is selected, then the first line will show SPREAD, instead of ATR.
2. Capital – This is your total capital or capital at risk.
3. Risk X% of Capital – The amount you’re risking on a % of the Capital. If a Custom Risk Amt is entered, then Risk Amount will be shown in place of Capital and Risk % of Capital.
4. Entry – The current price.
5. Stop Loss – The stop loss price.
6. -1R – The stop loss price and the amount that will be lost of the stop loss is hit.
7. – These are the target prices, or levels where you will want to take profit.
This script is primarily meant for people who are new to active trading and who are looking for a sound risk management strategy based on market volatility . This script can also be used by the more experienced trader who is using a similar system, but also wants to see it applied as an indicator on TradingView. I’m looking forward to maintaining this script and making it better in future revisions. If you want to include or change anything you believe will be a good change or feature, then please contact me in TradingView.
Daily GAP StatsI did not write the script from scratch but rather started editing code of an existing one. The original code came from a script called GAP DETECTOR by @Asch-
First up: I am a trader, not a programmer and therefore my code most likely is inefficient. If someone with more expertise would like to help and optimize it - feel free to get in touch, I am always happy to learn some new tricks. :)
This script does 2 things:
- It shows daily gaps stats based on user inputs
- It shows color coded labels on gap days with additional information in tooltips ( important: make sure to read 'known issues/limitations' at the end )
User Inputs
==========
Although the input dialog is pretty straight forward, I do a quick rundown:
- Length: max lookback time
- Gap Direction: self explanatory
- Show All Gaps | Cont Only | Reversal Only | Off:
This refers to the way labels are displayed on gap days (again: make sure to read known issues/limitations!)
- Show All Gaps: does what it says
- Cont Only: only shows gaps where price continued in the gap direction. If you filter for gap ups and chose 'Cont only' you will only see labels on gap days where price closed above the open (and vice versa if you scan for gap downs).
- Reversal Only: you will only see labels for closes below the open on gap up days (and the opposite on gap down days)
- Off: self explanatory
- Gap Measure in ATR/PCT: self explanatory, ATR is calculated over a 10d period
- Gap Size (Abs Values): no negative values allowed here. If you filter for gap downs and enter 3 it means it will show gaps where the stock fell more than 3 ATR/PCT on the open.
- RVOL Factor: along with significant gaps should come significant volume. RVOL = volume of the gap day / 20d average volume
- Viewing Options: Placing the stats label in the window is a bit tricky (see knonw issues/limitations) and I was not sure which way I liked better. See for yourself what works best for you.
Known Isusses/Limitations:
=======================
- Positioning of the stats table:
As to my knowledge, Tradingview only allows label positioning relative to price and not relative to the chart window. I tried to always display the gap stats table in the upper right corner, using 52wk high as y-coordinate. This works ok most of the time, but is not pretty. If anybody has some fancy way to tag the label in a fixed position, please get in touch.
- Max number of labels per script:
TradingView has a limitation that allows a maxium of ~50 labels per script. If there are more labels, TradingView will automatically cut the oldest ones, without any notification. I have found this behaviour to be rather inconsistent - sometimes it'll dump labels even if there are a lot fewer than 50. Hopefully TradingView will drop this limitation at one point in the future.
Important: The inconsistent display of the gap day labels has NO INFLUENCE on the calculations in the gap stats table - the count and the calculations are complete and correct!
