Auto-magnifier / quantifytools- Overview
Auto-magnifier shows a lower timeframe view of candles and volume bars inside any main timeframe candle by zooming into it. Candles and volume bars as they develop are shown chronologically from left to right. By default, magnifier is triggered when less than 3 candles are visible on the chart.
By default, 20 lower timeframe candles are displayed by splitting main timeframe into 20 parts. The amount of candles displayed is a target rate, meaning the script will use a lower timeframe that has the closest match to 20 candles and therefore will vary a bit. Users can override automatic timeframe calculation and opt in to display any specific lower timeframe or adjust amount of candles shown (e.g. 20 -> 30 candles) per each main timeframe candle.
Example
Main timeframe set to 30 minute, candles displayed set to 20 -> Magnifying using 2 minute candles (30 minute/20 candles = 1.5 min, rounded to 2 min)
Main timeframe set to 30 minute, override set to 5 minutes -> Displaying 5 minute candles
Size of volume bars is calculated using relative volume (volume relative to volume SMA20), lowest bar representing relative volume values of under or equal to 1x the moving average and from there onwards progressively growing.
- Limitations and considerations
Amount of candles shown might flow over from the background on smaller screen sizes, in which case you would want to decrease the amount shown. Opposite is true for bigger screens, this value can be increased as more candles fit.
This indicator involves a lot of tricks with text elements to make it work automatically by zooming in. Size of wicks, bodies and volume bars are calculated by adding more text elements on big candles and less text elements on smaller candles. This means the displayed candles won't be a 100% match, but a rather a fair representation of the view, e.g. candle is green = lower timeframe candle is green, candle has a big wick = lower timeframe candle has a big wick (but not a 100% match).
Example
Magnified lower timeframe chart vs. Actual lower timeframe chart
Most mismatch will be found on the price levels where lower timeframe candles are shown, which is sacrificed for the sake of getting a better readability on the overall shape of lower timeframe price action. Users can alternatively optimize calculations for more accuracy, giving a better representation of the price levels where candles truly originated. This typically comes with the cost of worse readability however.
Example
Optimized for readability vs. Optimized for accuracy
- Visuals
All visual elements are fully customizable.
Cerca negli script per "text"
Monte Carlo Future Moves [ChartPrime]ORIGINS AND HISTORICAL BACKGROUND:
Prior to the the advent of the Monte Carlo method, examining well-understood deterministic problems via simulation generally utilized statistical sampling to gauge uncertainty estimations. The Monte Carlo (MC) approach inverts this paradigm by modeling with probabilistic metaheuristics to address deterministic problems. Addressing Buffon's needle problem, an early form of the Monte Carlo method estimated π (3.14159) by dropping needles on a floor. Later, the modern MC inception primarily began when Stanislaw Ulam was playing solitaire games while experiencing illness and recovery.
Ulam further developed, applied, and ascribed "Monte Carlo" as a classified code name to maintain a level of secrecy for the modern method applications during collaborative investigations on neutron diffusion and collision intricacies with John von Neumann. Despite having relevant data, physicist's conventional deterministic mathematical methods were unable to solve mysterious "neutronion problems". Monte Carlo filled in the gaps necessary to resolve this perplexing neutron problem with innovative statistics, and the resilient MC continues onward to have diverse application in many fields of science. MC also extends into the realm of relevance within finance.
APPLICATION IN FINANCE:
Building on its historical roots, the Monte Carlo method's transition into finance opened new avenues for risk assessment and predictive analysis. In financial markets, characterized by uncertainty and complex variables, this method offers a powerful tool for simulating a wide range of scenarios and assessing probabilities of different outcomes. By employing probabilistic models to predict price movements, the Monte Carlo method helps in creating more resilient and informed trading strategies. This approach is particularly valuable in options pricing, portfolio management, and risk assessment, where understanding the range of potential outcomes is crucial for making sound investment decisions. Our indicator utilizes this methodology, blending traditional financial analysis with advanced statistical techniques.
THE INDICATOR:
The Monte Carlo Future Moves (ChartPrime) indicator is designed to predict future price movements. It simulates various possible price paths, showing the likelihood of different outcomes. We have designed it to be simple to use and understand by displaying lines indicating the most likely bullish and bearish outcomes. The arrows point to these areas making it intuitive to understand. Also included is extreme price levels shown in blue and yellow. This is the most likely extreme range that the price will move to. The outcome distribution is there to show you the range of outcomes along with a visual representation of the possible future outcomes. To make things more user friendly we have also included a representation of this distribution as a background heatmap. The brighter the price level, the more likely the price will end at that level. Finally, we have also included a market bias indication on the side that shows you the general bullish/bearish probabilities.
HOW TO USE:
To use this indicator you want to first assess the market bias. From there you want to target the most likely polar outcome. You can use the range of outcomes to assess your risk and set a stop within a reasonable range of the desired target. By default the indicator projects 10 steps into the future, however this can be easily adjusted in the settings. Generally this indicator excels at mid-term estimations and may yield inconclusive results if the prediction period is too short or too long. You can change the granularity of the outcomes to give you a more or less detailed view of the future. That being said, a lower resolution can make the predictions less useful while a higher resolution can give you a less useful picture. If you decide to use a higher resolution we have included an option to smooth the final result. This is intended to reduce the uncertainty and noise in the predicted outcomes. It is advised to use the minimum level of smoothing possible as a high level of smoothing will greatly reduce the accuracy.
INPUT SECTION:
Derivative Source changes how the indicator sees the price movements. When you set this to Candle it will use the difference between the open and close of each candle. If set to Move, it will use the difference between closing prices. If you are in a market with gaps, you might want to use Candle as this will prevent the indicator from seeing gaps.
Number of Simulations is a crucial setting as it is the core of this indicator. This determines the number of simulations the indicator will use to get its final result. By default it is set to 1000 as we feel like that is around the minimum number of simulations required to get a reasonable output while maintaining stability. In tests the maximum number of simulations we have been able to consistently achieve is 2000.
Lookback is the number of historical candles to account for. A lookback that is too short will not have enough data to accurately assess the likelihood of a price movement, while a period that is too large can make the data less relevant. By default this is set to 1000 as we feel like this is a reasonable tradeoff between volume of data and relevance.
Steps Into Future is the prediction period. By default we have picked a period of 10 steps as this has a good balance between accuracy and usability. The more steps into the future you go, the more uncertain the future outcome will be.
Outcome Granularity controls the precision of the simulated outcomes. By default this is set to 40 as its a good balance between resolution and accuracy.
Outcome Smoothing allows you to smooth the outcome distribution. By default this is set to 0 as it is generally not needed for lower resolutions. Smoothing levels beyond 2 are not recommended as it will negatively impact the output.
Returns Granularity controls the level of definition in the collected price movements. This directly impacts indicator performance and is set to 50 by default because its a good balance between fidelity and usability. When this number is too small, the simulations will be less accurate while numbers too large will negatively impact the probabilities of the movements.
Drift is the trend component in the simulation. This adds the directionality of the simulations by biasing the movements in the current direction of the market. We have included both the standard formula for drift and linear regression. Both methods are well suited for simulating future price movements and have their own advantages. The drift period is set to 100 by default as its a good balance between current and historical directionality. You may want to increase or decrease this number depending on the current market conditions but it is advised to use a period that isn't too small. If your period is too small it can skew the outcomes too much resulting in poor performance. When this is set to 0 it will use the same period as your lookback.
Volatility Adjust , adjusts the simulation to include current volatility. This makes sure that the price movements in the simulation reflects the current market conditions better by making sure that each price move is at least a minimum size.
Returns Style allows you to pick between using percent moves and log returns. We have opted to make percent move the default as it is more intuitive for beginners however both settings yield similar results. Log returns can be less cpu intensive so it might be desirable for longer term predictions.
Precision adjusts the rounding of used when collecting the frequency of price movement sizes. By default this is set to 4 as its is fairly accurate without impacting performance too much. A larger number will make the indicator more precise but at the cost of cpu time. Precision levels that are too small can greatly reduce the accuracy of the simulation and even break the indicator all together.
Update Every Bar allows you to recalculate the prediction every bar and is there for you if you want to strictly use the market bias. It is not recommended to enable this feature but it is there for flexibility.
Side of Chart allows you to pick what side of the price action you want the visuals to be on. When its set to the right everything will be to the right of the starting point and when its set to Left it will position everything to the left of the starting point.
Move Visualization is there to give you an arrow to the most likely bullish and bearish moves. It is meant as a visual aid and visualization tool. The color of these arrows use the same colors as the distribution.
Most Likely Move is a horizontal line that indicates the most likely move. It is positioned in the same location as the Move Visualization.
Standard Deviation is horizontal lines at the extremities of the simulated price action. These represent the most likely range of the future outcomes. You can adjust the multiplier of the standard deviation but by default it is set to 2.
Most Likely Direction is a vertical bar that shows you the sum of the up and down probabilities. It is there to show you the bias of the outcomes and guide you in decision making.
Max Probability Zone is a horizontal line that highlights the location of the highest probability move. You can think of it almost like the POC in a volume distribution but in this case it is the "most likely" single outcome.
Outcome Distribution allows you to toggle the distribution on or off. This is the distribution of all of the simulated outcomes. You can toggle the scale width of the distribution to fit your visual style.
Distribution Text toggles the probability text inside of the distribution bars. When you have a large number for the outcome granularity this text may not be visible and you may want to disable this feature.
Background is a heatmap of the outcome distribution. This allows you to visualize the underlying distribution without the need for the distribution histogram. The brighter the color, the more likely the outcome is for that level. It can be useful for visualizing the range of possible outcomes.
Starting Line is simply a horizontal line indicating the starting point of the simulation. It just the opening price for the starting position.
Extend Lines allows you to extend the lines and background past the prediction period.
CONCLUSION:
With its intuitive visuals and flexible settings, the Monte Carlo Future Moves (ChartPrime) indicator is practice and easy to use. It brings clarity to price movement predictions, helping you to build confidence in your strategies. This indicator not only reflects the evolution of technical analysis but also touches on data-driven insights.
Enjoy
forex_factory_utilityLibrary "forex_factory_utility"
Supporting Utility Library for the Live Economic Calendar by toodegrees Indicator; responsible for data handling, and plotting news event data.
isLeapYear()
Finds if it's currently a leap year or not.
Returns: Returns True if the current year is a leap year.
daysMonth(M)
Provides the days in a given month of the year, adjusted during leap years.
Parameters:
M (int) : Month in numerical integer format (i.e. Jan=1).
Returns: Days in the provided month.
size(S, N)
Converts a size string into the corresponding Pine Script v5 format, or N times smaller/bigger.
Parameters:
S (string) : Size string: "Tiny", "Small", "Normal", "Large", or "Huge".
N (int) : Size variation, can be positive (larger than S), or negative (smaller than S).
Returns: Size string in Pine Script v5 format.
lineStyle(S)
Converts a line style string into the corresponding Pine Script v5 format.
Parameters:
S (string) : Line style string: "Dashed", "Dotted" or "Solid".
Returns: Line style string in Pine Script v5 format.
lineTrnsp(S)
Converts a transparency style string into the corresponding integer value.
Parameters:
S (string) : Line style string: "Light", "Medium" or "Heavy".
Returns: Transparency integer.
boxLoc(X, Y)
Converts position strings of X and Y into a table position in Pine Script v5 format.
Parameters:
X (string) : X-axis string: "Left", "Center", or "Right".
Y (string) : Y-axis string: "Top", "Middle", or "Bottom".
Returns: Table location string in Pine Script v5 format.
method bubbleSort_NewsTOD(N)
Performs bubble sort on a Forex Factory News array of all news from the same date, ordering them in ascending order based on the time of the day.
Namespace types: News
Parameters:
N (News ) : Forex Factory News array.
Returns: void
bubbleSort_News(N)
Performs bubble sort on a Forex Factory News array, ordering them in ascending order based on the time of the day, and date.
Parameters:
N (News ) : Forex Factory News array.
Returns: Sorted Forex Factory News array.
weekNews(N, C, I)
Creates a Forex Factory News array containing the current week's Forex Factory News.
Parameters:
N (News ) : Forex Factory News array containing this week's unfiltered Forex Factory News.
C (string ) : Currency filter array (string array).
I (color ) : Impact filter array (color array).
Returns: Forex Factory News array containing the current week's Forex Factory News.
todayNews(W, D, M)
Creates a Forex Factory News array containing the current day's Forex Factory News.
Parameters:
W (News ) : Forex Factory News array containing this week's Forex Factory News.
D (News ) : Forex Factory News array for the current day's Forex Factory News.
M (bool) : Boolean that marks whether the current chart has a Day candle-switch at Midnight New York Time.
Returns: Forex Factory News array containing the current day's Forex Factory News.
impFilter(X, L, M, H)
Creates a filter array from the User's desired Forex Facory News to be shown based on Impact.
Parameters:
X (bool) : Boolean - if True Holidays listed on Forex Factory will be shown.
L (bool) : Boolean - if True Low Impact listed on Forex Factory News will be shown.
M (bool) : Boolean - if True Medium Impact listed on Forex Factory News will be shown.
H (bool) : Boolean - if True High Impact listed on Forex Factory News will be shown.
Returns: Color array with the colors corresponding to the Forex Factory News to be shown.
curFilter(A, C1, C2, C3, C4, C5, C6, C7, C8, C9)
Creates a filter array from the User's desired Forex Facory News to be shown based on Currency.
Parameters:
A (bool) : Boolean - if True News related to the current Chart's symbol listed on Forex Factory will be shown.
C1 (bool) : Boolean - if True News related to the Australian Dollar listed on Forex Factory will be shown.
C2 (bool) : Boolean - if True News related to the Canadian Dollar listed on Forex Factory will be shown.
C3 (bool) : Boolean - if True News related to the Swiss Franc listed on Forex Factory will be shown.
C4 (bool) : Boolean - if True News related to the Chinese Yuan listed on Forex Factory will be shown.
C5 (bool) : Boolean - if True News related to the Euro listed on Forex Factory will be shown.
C6 (bool) : Boolean - if True News related to the British Pound listed on Forex Factory will be shown.
C7 (bool) : Boolean - if True News related to the Japanese Yen listed on Forex Factory will be shown.
C8 (bool) : Boolean - if True News related to the New Zealand Dollar listed on Forex Factory will be shown.
C9 (bool) : Boolean - if True News related to the US Dollar listed on Forex Factory will be shown.
Returns: String array with the currencies corresponding to the Forex Factory News to be shown.
FF_OnChartLine(N, T, S)
Plots vertical lines where a Forex Factory News event will occur, or has already occurred.
Parameters:
N (News ) : News-type array containing all the Forex Factory News.
T (int) : Transparency integer value (0-100) for the lines.
S (string) : Line style in Pine Script v5 format.
Returns: void
method updateStringMatrix(M, P, V)
Namespace types: matrix
Parameters:
M (matrix)
P (int)
V (string)
FF_OnChartLabel(N, Y, S)
Plots labels where a Forex Factory News has already occurred based on its/their impact.
Parameters:
N (News ) : News-type array containing all the Forex Factory News.
Y (string) : String that gives direction on where to plot the label (options= "Above", "Below", "Auto").
S (string) : Label size in Pine Script v5 format.
Returns: void
historical(T, D, W, X)
Deletes Forex Factory News drawings which are ourside a specific Time window.
Parameters:
T (int) : Number of days input used for Forex Factory News drawings' history.
D (bool) : Boolean that when true will only display Forex Factory News drawings of the current day.
W (bool) : Boolean that when true will only display Forex Factory News drawings of the current week.
X (string) : String that gives direction on what lines to plot based on Time (options= "Past", "Future", "Both").
Returns: void
newTable(P)
Creates a new Table object with parameters tailored to the Forex Factory News Table.
Parameters:
P (string) : Position string for the Table, in Pine Script v5 format.
Returns: Empty Forex Factory News Table.
resetTable(P, S, headTextC, headBgC)
Resets a Table object with parameters and headers tailored to the Forex Factory News Table.
Parameters:
P (string) : Position string for the Table, in Pine Script v5 format.
S (string) : Size string for the Table's text, in Pine Script v5 format.
headTextC (color)
headBgC (color)
Returns: Empty Forex Factory News Table.
logNews(N, TBL, R, S, rowTextC, rowBgC)
Adds an event to the Forex Factory News Table.
Parameters:
N (News) : News-type object.
TBL (table) : Forex Factory News Table object to add the News to.
R (int) : Row to add the event to in the Forex Factory News Table.
S (string) : Size string for the event's text, in Pine Script v5 format.
rowTextC (color)
rowBgC (color)
Returns: void
FF_Table(N, P, S, headTextC, headBgC, rowTextC, rowBgC)
Creates the Forex Factory News Table.
Parameters:
N (News ) : News-type array containing all the Forex Factory News.
P (string) : Position string for the Table, in Pine Script v5 format.
S (string) : Size string for the Table's text, in Pine Script v5 format.
headTextC (color)
headBgC (color)
rowTextC (color)
rowBgC (color)
Returns: Forex Factory News Table.
timeline(N, T, F, D)
Shades Forex Factory News events in the Forex Factory News Table after they occur.
Parameters:
N (News ) : News-type array containing all the Forex Factory News.
T (table) : Forex Facory News table object.
F (color) : Color used as shading once the Forex Factory News has occurred.
D (bool) : Daily Forex Factory News flag.
Returns: Forex Factory News Table.
News
Custom News type which contains informatino about a Forex Factory News Event.
Fields:
dow (series string) : Day of the week, in DDD format (i.e. 'Mon').
dat (series string) : Date, in MMM D format (i.e. 'Jan 1').
_t (series int)
tod (series string) : Time of the day, in hh:mm 24-Hour format (i.e 17:10).
cur (series string) : Currency, in CCC format (i.e. "USD").
imp (series color) : Impact, the respective impact color for Forex Factory News Events.
ttl (series string) : Title, encoded in a custom number mapping (see the toodegrees/toodegrees_forex_factory library to learn more).
tmst (series int)
ln (series line)
Minervini Stage 2 AnalysisHandbook for Minervini Stage 2 Analysis Indicator
Introduction
This handbook provides detailed instructions and guidelines for using the Minervini Stage 2 Analysis Indicator based on Mark Minervini's swing trading methodology. This indicator is designed for traders focusing on US stocks, aiming to capture gains in medium to short-term uptrends (swing trading).
Understanding Stage 2
Stage 2 represents a bullish uptrend in a stock's price. Mark Minervini emphasizes entering long positions during this phase. The stage is identified using four key criteria related to moving averages (MAs).
Indicator Criteria
Stock Price Above MA 150 and 200: Indicates an overall uptrend.
MA 150 Above MA 200: Signals a stronger medium-term trend compared to the long-term trend.
MA 200 Trending Up for At Least 1 Month (22 Days): Confirms a stable uptrend.
MA 50 Above Both MA 150 and 200: Shows short-term strength and momentum.
Using the Indicator
Entering Trades: Consider long positions when all four criteria are met. This signifies that the stock is in a Stage 2 uptrend.
Monitoring Trades: Regularly check if the stock continues to meet these criteria. The indicator provides a clear visual and textual representation for ease of monitoring.
Alarm Signals and Exit Strategy
One Criterion Not Met: This serves as an alarm signal. Increased vigilance is required, and traders should prepare for a potential exit.
Two Criteria Not Met: Strong indication to close the trade. This suggests the stock may be transitioning out of Stage 2, increasing the risk of holding the position.
Risk Management
Stop-Loss Orders: Consider setting a trailing stop-loss to protect profits and minimize losses.
Position Sizing: Adjust position sizes according to your risk tolerance and portfolio strategy.
Volume and Relative Strength Analysis
Volume Analysis: Look for increased trading volume as confirmation when the stock price moves above key MAs.
Relative Strength (RS) Rating: Compare the stock's performance to the broader market to gauge its strength.
Limitations and Considerations
Market Conditions: The indicator's effectiveness may vary with market conditions. It is more reliable in a bullish market environment.
Supplementary Analysis: Combine this indicator with other analysis methods (fundamental, technical) for a holistic approach.
Continuous Learning: Stay updated with market trends and adjust your strategy accordingly.
Conclusion
The Minervini Stage 2 Analysis Indicator is a powerful tool for identifying potential long positions in uptrending stocks. Its reliance on specific criteria aligns with Mark Minervini's proven swing trading strategy. However, always exercise due diligence and risk management in your trading decisions.
Adaptive MFT Extremum Pivots [Elysian_Mind]Adaptive MFT Extremum Pivots
Overview:
The Adaptive MFT Extremum Pivots indicator, developed by Elysian_Mind, is a powerful Pine Script tool that dynamically displays key market levels, including Monthly Highs/Lows, Weekly Extremums, Pivot Points, and dynamic Resistances/Supports. The term "dynamic" emphasizes the adaptive nature of the calculated levels, ensuring they reflect real-time market conditions. I thank Zandalin for the excellent table design.
---
Chart Explanation:
The table, a visual output of the script, is conveniently positioned in the bottom right corner of the screen, showcasing the indicator's dynamic results. The configuration block, elucidated in the documentation, empowers users to customize the display position. The default placement is at the bottom right, exemplified in the accompanying chart.
The deliberate design ensures that the table does not obscure the candlesticks, with traders commonly situating it outside the candle area. However, the flexibility exists to overlay the table onto the candles. Thanks to transparent cells, the underlying chart remains visible even with the table displayed atop.
In the initial column of the table, users will find labels for the monthly high and low, accompanied by their respective numerical values. The default precision for these values is set at #.###, yet this can be adjusted within the configuration block to suit markets with varying degrees of volatility.
Mirroring this layout, the last column of the table presents the weekly high and low data. This arrangement is part of the upper half of the table. Transitioning to the lower half, users encounter the resistance levels in the first column and the support levels in the last column.
At the center of the table, prominently displayed, is the monthly pivot point. For a comprehensive understanding of the calculations governing these values, users can refer to the documentation. Importantly, users retain the freedom to modify these mathematical calculations, with the table seamlessly updating to reflect any adjustments made.
Noteworthy is the table's persistence; it continues to display reliably even if users choose to customize the mathematical calculations, providing a consistent and adaptable tool for informed decision-making in trading.
This detailed breakdown offers traders a clear guide to interpreting the information presented by the table, ensuring optimal use and understanding of the Adaptive MFT Extremum Pivots indicator.
---
Usage:
Table Layout:
The table is a crucial component of this indicator, providing a structured representation of various market levels. Color-coded cells enhance readability, with blue indicating key levels and a semi-transparent background to maintain chart visibility.
1. Utilizing a Table for Enhanced Visibility:
In presenting this wealth of information, the indicator employs a table format beneath the chart. The use of a table is deliberate and offers several advantages:
2. Structured Organization:
The table organizes the diverse data into a structured format, enhancing clarity and making it easier for traders to locate specific information.
3. Concise Presentation:
A table allows for the concise presentation of multiple data points without cluttering the main chart. Traders can quickly reference key levels without distraction.
4. Dynamic Visibility:
As the market dynamically evolves, the table seamlessly updates in real-time, ensuring that the most relevant information is readily visible without obstructing the candlestick chart.
5. Color Coding for Readability:
Color-coded cells in the table not only add visual appeal but also serve a functional purpose by improving readability. Key levels are easily distinguishable, contributing to efficient analysis.
Data Values:
Numerical values for each level are displayed in their respective cells, with precision defined by the iPrecision configuration parameter.
Configuration:
// User configuration: You can modify this part without code understanding
// Table location configuration
// Position: Table
const string iPosition = position.bottom_right
// Width: Table borders
const int iBorderWidth = 1
// Color configuration
// Color: Borders
const color iBorderColor = color.new(color.white, 75)
// Color: Table background
const color iTableColor = color.new(#2B2A29, 25)
// Color: Title cell background
const color iTitleCellColor = color.new(#171F54, 0)
// Color: Characters
const color iCharColor = color.white
// Color: Data cell background
const color iDataCellColor = color.new(#25456E, 0)
// Precision: Numerical data
const int iPrecision = 3
// End of configuration
The code includes a configuration block where users can customize the following parameters:
Precision of Numerical Table Data (iPrecision):
// Precision: Numerical data
const int iPrecision = 3
This parameter (iPrecision) sets the precision of the numerical values displayed in the table. The default value is 3, displaying numbers in #.### format.
Position of the Table (iPosition):
// Position: Table
const string iPosition = position.bottom_right
This parameter (iPosition) sets the position of the table on the chart. The default is position.bottom_right.
Color preferences
Table borders (iBorderColor):
// Color: Borders
const color iBorderColor = color.new(color.white, 75)
This parameters (iBorderColor) sets the color of the borders everywhere within the window.
Table Background (iTableColor):
// Color: Table background
const color iTableColor = color.new(#2B2A29, 25)
This is the background color of the table. If you've got cells without custom background color, this color will be their background.
Title Cell Background (iTitleCellColor):
// Color: Title cell background
const color iTitleCellColor = color.new(#171F54, 0)
This is the background color the title cells. You can set the background of data cells and text color elsewhere.
Text (iCharColor):
// Color: Characters
const color iCharColor = color.white
This is the color of the text - titles and data - within the table window. If you change any of the background colors, you might want to change this parameter to ensure visibility.
Data Cell Background: (iDataCellColor):
// Color: Data cell background
const color iDataCellColor = color.new(#25456E, 0)
The data cells have a background color to differ from title cells. You can configure this is a different parameter (iDataColor). You might even set the same color for data as for the titles if you will.
---
Mathematical Background:
Monthly and Weekly Extremums:
The indicator calculates the High (H) and Low (L) of the previous month and week, ensuring accurate representation of these key levels.
Standard Monthly Pivot Point:
The standard pivot point is determined based on the previous month's data using the formula:
PivotPoint = (PrevMonthHigh + PrevMonthLow + Close ) / 3
Monthly Pivot Points (R1, R2, R3, S1, S2, S3):
Additional pivot points are calculated for Resistances (R) and Supports (S) using the monthly data:
R1 = 2 * PivotPoint - PrevMonthLow
S1 = 2 * PivotPoint - PrevMonthHigh
R2 = PivotPoint + (PrevMonthHigh - PrevMonthLow)
S2 = PivotPoint - (PrevMonthHigh - PrevMonthLow)
R3 = PrevMonthHigh + 2 * (PivotPoint - PrevMonthLow)
S3 = PrevMonthLow - 2 * (PrevMonthHigh - PivotPoint)
---
Code Explanation and Interpretation:
The table displayed beneath the chart provides the following information:
Monthly Extremums:
(H) High of the previous month
(L) Low of the previous month
// Function to get the high and low of the previous month
getPrevMonthHighLow() =>
var float prevMonthHigh = na
var float prevMonthLow = na
monthChanged = month(time) != month(time )
if (monthChanged)
prevMonthHigh := high
prevMonthLow := low
Weekly Extremums:
(H) High of the previous week
(L) Low of the previous week
// Function to get the high and low of the previous week
getPrevWeekHighLow() =>
var float prevWeekHigh = na
var float prevWeekLow = na
weekChanged = weekofyear(time) != weekofyear(time )
if (weekChanged)
prevWeekHigh := high
prevWeekLow := low
Monthly Pivots:
Pivot: Standard pivot point based on the previous month's data
// Function to calculate the standard pivot point based on the previous month's data
getStandardPivotPoint() =>
= getPrevMonthHighLow()
pivotPoint = (prevMonthHigh + prevMonthLow + close ) / 3
Resistances:
R3, R2, R1: Monthly resistance levels
// Function to calculate additional pivot points based on the monthly data
getMonthlyPivotPoints() =>
= getPrevMonthHighLow()
pivotPoint = (prevMonthHigh + prevMonthLow + close ) / 3
r1 = (2 * pivotPoint) - prevMonthLow
s1 = (2 * pivotPoint) - prevMonthHigh
r2 = pivotPoint + (prevMonthHigh - prevMonthLow)
s2 = pivotPoint - (prevMonthHigh - prevMonthLow)
r3 = prevMonthHigh + 2 * (pivotPoint - prevMonthLow)
s3 = prevMonthLow - 2 * (prevMonthHigh - pivotPoint)
Initializing and Populating the Table:
The myTable variable initializes the table with a blue background, and subsequent table.cell functions populate the table with headers and data.
// Initialize the table with adjusted bgcolor
var myTable = table.new(position = iPosition, columns = 5, rows = 10, bgcolor = color.new(color.blue, 90), border_width = 1, border_color = color.new(color.blue, 70))
Dynamic Data Population:
Data is dynamically populated in the table using the calculated values for Monthly Extremums, Weekly Extremums, Monthly Pivot Points, Resistances, and Supports.
// Add rows dynamically with data
= getPrevMonthHighLow()
= getPrevWeekHighLow()
= getMonthlyPivotPoints()
---
Conclusion:
The Adaptive MFT Extremum Pivots indicator offers traders a detailed and clear representation of critical market levels, empowering them to make informed decisions. However, users should carefully analyze the market and consider their individual risk tolerance before making any trading decisions. The indicator's disclaimer emphasizes that it is not investment advice, and the author and script provider are not responsible for any financial losses incurred.
---
Disclaimer:
This indicator is not investment advice. Trading decisions should be made based on a careful analysis of the market and individual risk tolerance. The author and script provider are not responsible for any financial losses incurred.
Kind regards,
Ely
Time-itTime-it = Time based indicator
The Time-it indicator parses data by the day of week. Every tradeable instrument has its own personality. Some are more volatile on Mondays, and some are more bullish / bearish on Fridays or any day in between. The key metrics Time-it parses is range, open, high, low, close and +volume-.
The Time-it parsed data is printed in a table format. The table, position, size & color and text color & size can be changed to your preference. Each column parsed data is the last 10 which is numbered 0-9 which refers to the number of the selected day bars ago. For example: if Monday is chosen, 0 is the last closed Monday bar and 9 is the last closed Monday 9 Monday bars ago.
Range = measures the range between high and low for the day.
Open = is the opening price for the day.
High = is the high price for the day.
Low = is the low price for the day.
Close = is the closing price for the day.
+volume- = is the positive or negative volume for the day.
Default settings:
*Represents a how to use tooltip*
Source = ohlc4
* The source used for MA
MA length = 20
* The moving average used
Day bar color on / off
* checked on / unchecked off
Monday = blue
Tuesday = yellow
Wednesday = purple
Thursday = orange
Friday = white
Saturday = red
Sunday = green
Day M, T, W, TH, F, ST, SN.
* Parsed data for the day of week tables
Table, position, size & color:
Top, middle, bottom, left, center, right
* Table position on the chart.
Frame width & border width = 1
Text color and text size
Border color and frame color
Decimal place = 0
* example: use 0 for a round number, use 4 for Forex
*** The Time-it indicator uses parts and/or pieces of code from "Tradingview Up/Down Volume" and "Tradingview Financials on Chart".
Previous Day High and Low + Separators Daily/WeeklyPrevious Day High and Low + Separators Daily/Weekly is an indicator based on separators of days and weeks and at the same time points out the previous highs and lows, everything is marked by lines, it consists of creating a clean graph and separated by the different trading days, referring to the extreme points created the previous day.
USEAGE
Point to each day of the week at the top of the chart to get a time location in your trading week and day sparation determined by 00:00 of any timezone.
The reference of the previous day's higs and LOWS is vitally important to understand which direction is most likely for the next day, either continuation or reversal.
DETAILS
As you can see you will be able to adapt these lines according to your chart design and with the desired intensity of appearance.
SETTINGS
UTC OFFSET: Determine your TIMEZONE in this section.
DAILY SEPARATOR: You have the option to change the color, style, width and text color.
WEEKLY SEPARATOR: You have the option to change the color, style, width and text color.
PREVIOUS HIGS & LOWS: You have the option to change the color, style, width and text color.
AMT: Gamma Levels PlotterAMT: Custom Levels Plotter Indicator
Purpose:
This indicator is designed to allow users to directly visualize custom price levels and their associated labels on a trading chart by copying and pasting data from the Gamma spreadsheet.
Features and Functionalities:
Direct Input from Gamma Spreadsheet:
Users can effortlessly copy rows of data from the Gamma spreadsheet and paste them into the indicator's input field. Each row should represent a price level followed by a tab (\t) and its associated label. There's no need for any adjustments or formatting changes; the indicator handles it all.
Label Size Selection:
A dropdown menu lets users select the desired size for the labels. Options include "Tiny", "Small", "Normal", and "Large".
Merge Levels Option:
A checkbox determines if labels for identical price levels should be merged. When activated, labels for the same price will consolidate; otherwise, they'll display individually.
Dynamic Visualization:
A horizontal line represents the specified price level on the chart.
An adjacent label displays the associated text.
If the "Merge Levels" option is active and there are multiple labels for the same price, they merge into one.
Automatic Cleanup:
The script automatically removes all previously plotted lines and labels before drawing the new set. This ensures the chart only displays the most recent set of levels and remains uncluttered.
Efficient Data Handling:
The indicator uses the levels and counts arrays to track unique price levels and their counts. This aids in accurately positioning labels, especially when merging is enabled.
Debugging Feature:
For diagnostic purposes, the indicator plots the size of the levels array. This helps monitor the array's growth and ensures it remains within expected limits.
ATR Stop Loss v4This indicator plots the current ATR value, and the Long and Short stop losses. Watch the indicator and move your stop loss to the Long or Short as necessary.
Unlike other ATR indicators this one allows the user to customize the table placement of the ATR calculations, and the colors of each row on the table, and the text. The ATR factors can also be edited.
JavaScript-style Debug ConsoleThis library provides a JavaScript-style debug console to Pine Coders. It supports the most commonly used utilities from the WHATWG Console Standard including the following:
• console.log
• console.debug
• console.info
• console.warn
• console.error
• console.assert
• console.count
• console.countReset
• console.group
• console.groupEnd
• console.clear
In addition to the WHATWG standard, this library also supports the following methods:
• console.show
• console.hide
FEATURES
• Follows the WHATWG Console Standard, which is widely adopted by all major JavaScript runtimes including browsers and Node.js.
• Provides an out-of-box UI with pre-configured theming, ensuring a clean and professional-looking console.
• Allows for easy UI customizations to fit your personal preferences.
• Has extremely simple import and initialization, making it easy to integrate with your existing codebase.
USAGE
1. Import this library:
import algotraderdev/Console/1
2. Initialize the console object:
var console = Console.new()
// You can also specify optional params to customize the look & feel.
var console = Console.new(
position = position.bottom_right,
max_rows = 50,
width = 0,
text_size = size.normal,
background_color = #000000CC,
timestamp_color = #AAAAAA,
info_message_color = #DDDDDD,
debug_message_color = #AAAAAA,
warn_message_color = #FFEB3B,
error_message_color = #ff3c00)
3. Use the console object to debug your code. Here are some examples:
// Basic logging
console.log('hello world!') // prints 'hello world'
console.warn('warn') // prints 'warn' in yellow
console.error('error') // prints 'error' in red
console.clear() // clears the console
// Assertion
console.assert(a.isEmpty(), 'array should be empty') // prints 'assertion failed: array should be empty' if the array is not empty
// Counter
console.count('fooFunction') // prints 'fooFunction: 1'
console.count('fooFunction') // prints 'fooFunction: 2'
console.countReset('fooFunction') // resets the counter
console.count('fooFunction') // prints 'fooFunction: 1'
// Group
console.log('A')
console.group()
console.log('B')
console.group()
console.log('C')
console.log('D')
console.groupEnd()
console.log('E')
console.groupEnd()
console.log('F')
// prints
// A
// B
// C
// D
// E
// F
// Hide and show
console.hide()
console.show()
Position_controlLibrary "Position_control"
This is a library for defining positions and working with them.
f_calculateLeverage(_Leverage, _maintenance, _value, _direction)
Calculate the leverage used in a trade.
@description This function calculates the leverage used in a trade, based on the value of the trade, the maintenance margin, and the direction of the trade.
Parameters:
_Leverage (float) : The leverage used in the trade, as a floating point number.
_maintenance (float) : The maintenance margin percentage, as a floating point number.
_value (float) : The value of the trade, as a floating point number.
_direction (string) : The direction of the trade, either "long" or "short".
Returns: The leverage used in the trade, as a floating point number.
f_calculate_PL(_Position, _max_TP, _Position_index, _show_profit, _i_decimals_contracts, _i_decimals_prercent)
Calculate the profit or loss for a given trade.
@description This function calculates the profit or loss for a given trade, based on the position type, maximum take profit, position index, and whether to show the profit as a percentage or a value.
Parameters:
_Position (t_Position_type ) : An array of position types for the trade.
_max_TP (int) : The maximum take profit for the trade, as an integer value.
_Position_index (int) : The index of the position in the array, as an integer value.
_show_profit (bool) : A boolean value indicating whether to show the profit as a percentage or a value.
_i_decimals_contracts (int)
_i_decimals_prercent (int)
Returns: The profit or loss for the trade, as a floating point number.
f_drawposition(_Position, _Parameters, _Position_index)
draws a position on the chart
@description via sending in a typo of Position this function is able to drawout Stoploss, Entrybox, Takeprofits and the required labels with information
Parameters:
_Position (t_Position_type ) : array of type t_Position_type containing the position information.
_Parameters (t_drawing_parameters)
_Position_index (int) : the index of the current position.
Returns: None but boxes / lines / labels on the chart itself
t_TP_Variant
Fields:
TP_Type (series__string)
TP_Parameter_1 (series__integer)
TP_Parameter_2 (series__integer)
TP_Parameter_3 (series__float)
TP_Parameter_4 (series__float)
t_TPs
Fields:
TP_Price (series__float)
TP_Lot (series__float)
TP_Variant (|t_TP_Variant|#OBJ)
TP_Active (series__bool)
t_SLs
Fields:
SL_Price (series__float)
SL_Lot (series__float)
SL_Active (series__bool)
t_Position_type
Fields:
Lot (series__float)
Leverage (series__float)
Maintenance (series__float)
Starttime (series__integer)
Entry_Start (series__float)
Stoptime (series__integer)
Entry_Stop (series__float)
Entryprice (series__float)
TPs (array__|t_TPs|#OBJ)
SLs (array__|t_SLs|#OBJ)
t_drawing_parameters
Fields:
ShowPos (series__bool)
ShowLIQ (series__bool)
A_Colors (array__color)
Prolong_lines (series__bool)
Str_fontsize (series__string)
Textshift (series__integer)
Decimals_contracts (series__integer)
Decimals_price (series__integer)
Decimals_percent (series__integer)
bartime (series__integer)
See inside Candles: Directionality %; Constituent Bars & GapsSee inside candles based on user-input LTF setting: get data on 'Directionality' of your candle; Gaps (total and Sum; UP and DOWN); Number of Bull or Bear constituent candles
//Features:
-DIRECTIONALITY: compare length of the 'zig-zag' random walk of lower time frame constituent candles, to the full height of the current candle. Resulting % I refer to as 'directionality'.
-GAPs: what i refer to as 'gaps' are also known as Volume imbalances: the gap between previous candles close and current candle's open (if there is one).
--Gaps total (up vs down gaps). Number of Up gaps printed above bar in green, down gaps printed below bar in red.
--Gaps Sum (total summed UP gap, total summed down gaps. Sum of Up gaps printed above bar in green, Sum of down gaps printed below bar in red.
-Candles Total: Numer of LTF up vs down candles within current timeframe candle. Number of up candles printed above bar in green, Number of down candles printed below bar in red.
//USAGE:
-Primary purpose in this was the Directionality aspect. Wanted to get a measure of how choppy vs how directional the internals of a candle were. Idea being that a candle with high % directionality (approaching 100) would imply trending conditions; while a candle which was large range and full bodies but had a low % directionality would imply the internals were back-and-forth and => rebalanced, potentially indicating price may not need to retrace back into it and rebalance further. All rather experimental, please treat it as such: have a play around with it.
-Number of gaps, Sums of up and down gaps, ratio of up and down constituent candles also intended to serve a similar purpose as the above.
-Set the input lower timeframe; this must obviously be lower then your current timeframe. You will significant differences in results depending on the ratio your timeframes (chart timeframe vs user-input timeframe).
//User Inputs:
-Lower timeframe input (setting child candle size within current chart parent candle).
-Choose function from the four listed above.
-typical formating options: Bull color/bear color txt for gaps functions.
-display % unit or not.
-display vertical or horizontal text.
-Set min / max directionality thresholds; and color code results.
-Toggle on/off 'hide results outside of threshold' to declutter the chart.
-choose label style.
//NOTES:
-Directionality thresholds can be set manually; Max and Min thresholds can be set to filter out 'non-extreme' readings.
-Note that directionality % can sometimes exceed 100%, in cases where price trends very strongly and gaps up continuously such that sum of constituent candles is less than total range of parent candle.
-Personally i like the idea of seeking bold, large-range, full bodied candles, with a lower than typical directionality %; indicating that a price move is both significant and it's already done it's rebalancing; I would see this as potentially favourable for continuation (obviously depending on context).
---- Showcase of the other functions beyond Directionality percentage ----
Candles Total (bull vs Bear). ES1! Hourly; ltf = 5min: Candles total: LTF up candles and LTF down candles making up the current HTF candle (constituent number of UP candles printed above in green, Down candles printed below in red):
Gaps SUM. SPX hourly, ltf = 5min. Sum of 'UP' gaps within candle printed above in green, sum of 'DOWN' gaps printed below in red:
Gaps TOTAL: SPX hourly, ltf = 1min. Simply the total of 'up' gaps vs 'down' gaps withing our candle; based on the user input constituent candles within:
Ignition Cha Cha ChaIgnition Cha Cha Cha (ICCC) is a 3 color coded moving average indicator which numerically quantify the angle of their trends. I have labeled them as fast, medium and slow. The trend colors are Green for bullish, Red for bearish and Grey for sideways. The sideways movement can be user defined for all 3 in the settings under Threshold. If you regard for example anything under 10º as sideways then place 10 in the corresponding threshold and any angle under 10º will give a grey moving average and a grey labeled text. I use this chart in several ways. If you don't want moving averages all over your Chartistic Masterpiece you can turn off the plots and leave the numeric angles which will give you an overview of the trend. Conversely if you want to make the ultimate trend chart you can setup a 4 chart layout, Weekly, Daily, 12 hour and 4 hour and add the indicator with 200/50/25 moving averages and look for confluence. I find the best way for this is turn off the candles and use the moving averages with the numeric labels. You also have the ability to turn off and on different aspects of the indicator so that there is good control over its look. Also I have given the indicator lots of Alert presets for all 3 of the moving averages so you can avoid demented screen-stairing. Please forgive the name, my mother made me do Ballroom dancing lessons as a kid.
Trading Checklist - SonarlabTrading Checklist is a customizable indicator designed for traders who want to stay disciplined and stick to their trading rules. Using this indicator, you can easily create and display your own personalized checklist of trading rules directly on your TradingView chart.
The Title and the Body are two different sections, so you can set two different styles.
This indicator allows you to customize:
Text color
Text size
Text alignment
X48 - Strategy | BreakOut & Consecutive (11in1) + Alert | V.1.2================== Read This First Before Use This Strategy ==============
*********** Please be aware that this strategy is not a guarantee of success and may lead to losses.
*********** Trading involves risk and you should always do your own research before making any decisions.
================= Thanks Source Script and Explain This Strategy ===================
► Description
Write a detailed and meaningful description that allows users to understand how your script is original, what it does, how it does it and how to use it
This Strategy Are Combine Strategy and Indicators Alert Function For Systematic Trading User.
Strategy List, Thanks For Original Source Script , From Tradingview Build-in Script From fmzquant Github
// Channel BreakOut Strategy : Calculate BreakOut Zone For Buy and Sell.
// Consecutive Bars UP/Down Strategy : The consecutive bars up/down strategy is a trading strategy used to identify potential buy and sell signals in the stock market. This strategy involves looking for a series of bars (or candles) that are either all increasing or all decreasing in price. If the bars are all increasing, it can be a signal to buy, and if the bars are all decreasing, it can be a signal to sell. This strategy can be used on any timeframe, from a daily chart to an intraday chart.
// 15m Range Length SD : Range Of High and Low Candle Price and Lookback For Calculate Buy and Sell.
Indicators Are Simple Source Script (Almost I'm Chating With CHAT-GPT and Convert pinescript V4 to V5 again for complete almost script and combine after)
// SwingHigh and SwingLow Plot For SL (StopLoss by Last Swing).
// Engulfing and 3 Candle Engulfing Plot.
// Stochastic RSI for Plot and Fill Background Paint and Plot TEXT For BULL and BEAR TREND.
// MA TYPE MODE are plot 2 line of MA Type (EMA, SMA, HMA, WMA, VWMA) for Crossover and Crossunder.
// Donchian Fans MODE are Plot Dot Line With Triangle Degree Bull Trend is Green Plot and Bear Trend is Red Plot.
// Ichimoku Cloud Are Plot Cloud A-B For Bull and Bear Trend.
// RSI OB and OS for TEXT PLOT 'OB' , 'OS' you will know after OB and OS, you can combo with other indicators that's make you know what's the similar trend look like?
// MACD for Plot Diamond when MACD > 0 and MACD < 0, you can combo with other indicators that's make you know what's the similar trend look like?
Alert Can Alert Sent When Buy and Sell or TP and SL, you can adjust text to alert sent by your self or use default setting.
========== Let'e Me Explain How To Use This Strategy =============
========== Properties Setting ==========
// Capital : Default : 1,000 USDT For Alot Of People Are Beginner Investor = It's Capital Your Cash For Investment
// Ordersize : Default Are Setting 5% / Order We Call Compounded
========== INPUT Setting ==========
// First Part Use Must Choose Checkbox For Use of Strategy and Choose TP/SL by Swing or % (can choose both)
// In Detail Of Setting Are Not Too Much, Please Read The Header Of Setting Before Change The Value
// For The Indicator In List You Want To Add Just Check ✅ From MODE Setting, It's Show On Your Chart
// You Can Custom TP/SL % You Want
========== ##### No trading strategy is guaranteed to be 100% successful. ###### =========
For Example In My Systematic Trading
Select 1/3 Strategy Setting TP/SL % Match With Timeframe TP Long Are Not Set It's Can 161.8 - 423.6% but Short Position Are Not Than 100% Just Fine From Your Aset
Choose Indicators For Make Sure Trend and Strategy are the same way like Strategy are Long Position but MACD and Sto background is bear. that's mean this time not open position.
Donchian Fans is Simple Support and Ressistant If You Don't Know How To Plot That's, This indicator plot a simple for you ><.
Make Sure With Engulfing and 3 Candle Engulfing If You Don't Know, What's The Engulfing, This Indicator are plot for you too ><.
For a Big Trend You can use Ichimoku Cloud For Check Trend, Candle Upper Than Cloud or Lower Than Cloud for Bull and Bear Trend.
DataChartLibrary "DataChart"
Library to plot scatterplot or heatmaps for your own set of data samples
draw(this)
draw contents of the chart object
Parameters:
this : Chart object
Returns: current chart object
init(this)
Initialize Chart object.
Parameters:
this : Chart object to be initialized
Returns: current chart object
addSample(this, sample, trigger)
Add sample data to chart using Sample object
Parameters:
this : Chart object
sample : Sample object containing sample x and y values to be plotted
trigger : Samples are added to chart only if trigger is set to true. Default value is true
Returns: current chart object
addSample(this, x, y, trigger)
Add sample data to chart using x and y values
Parameters:
this : Chart object
x : x value of sample data
y : y value of sample data
trigger : Samples are added to chart only if trigger is set to true. Default value is true
Returns: current chart object
addPriceSample(this, priceSampleData, config)
Add price sample data - special type of sample designed to measure price displacements of events
Parameters:
this : Chart object
priceSampleData : PriceSampleData object containing event driven displacement data of x and y
config : PriceSampleConfig object containing configurations for deriving x and y from priceSampleData
Returns: current chart object
Sample
Sample data for chart
Fields:
xValue : x value of the sample data
yValue : y value of the sample data
ChartProperties
Properties of plotting chart
Fields:
title : Title of the chart
suffix : Suffix for values. It can be used to reference 10X or 4% etc. Used only if format is not format.percent
matrixSize : size of the matrix used for plotting
chartType : Can be either scatterplot or heatmap. Default is scatterplot
outliersStart : Indicates the percentile of data to filter out from the starting point to get rid of outliers
outliersEnd : Indicates the percentile of data to filter out from the ending point to get rid of outliers.
backgroundColor
plotColor : color of plots on the chart. Default is color.yellow. Only used for scatterplot type
heatmapColor : color of heatmaps on the chart. Default is color.red. Only used for heatmap type
borderColor : border color of the chart table. Default is color.yellow.
plotSize : size of scatter plots. Default is size.large
format : data representation format in tooltips. Use mintick.percent if measuring any data in terms of percent. Else, use format.mintick
showCounters : display counters which shows totals on each quadrants. These are single cell tables at the corners displaying number of occurences on each quadrant.
showTitle : display title at the top center. Uses the title string set in the properties
counterBackground : background color of counter table cells. Default is color.teal
counterTextColor : text color of counter table cells. Default is color.white
counterTextSize : size of counter table cells. Default is size.large
titleBackground : background color of chart title. Default is color.maroon
titleTextColor : text color of the chart title. Default is color.white
titleTextSize : text size of the title cell. Default is size.large
addOutliersToBorder : If set, instead of removing the outliers, it will be added to the border cells.
useCommonScale : Use common scale for both x and y. If not selected, different scales are calculated based on range of x and y values from samples. Default is set to false.
plotchar : scatter plot character. Default is set to ascii bullet.
ChartDrawing
Chart drawing objects collection
Fields:
properties : ChartProperties object which determines the type and characteristics of chart being plotted
titleTable : table containing title of the chart.
mainTable : table containing plots or heatmaps.
quadrantTables : Array of tables containing counters of all 4 quandrants
Chart
Chart type which contains all the information of chart being plotted
Fields:
properties : ChartProperties object which determines the type and characteristics of chart being plotted
samples : Array of Sample objects collected over period of time for plotting on chart.
displacements : Array containing displacement values. Both x and y values
displacementX : Array containing only X displacement values.
displacementY : Array containing only Y displacement values.
drawing : ChartDrawing object which contains all the drawing elements
PriceSampleConfig
Configs used for adding specific type of samples called PriceSamples
Fields:
duration : impact duration for which price displacement samples are calculated.
useAtrReference : Default is true. If set to true, price is measured in terms of Atr. Else is measured in terms of percentage of price.
atrLength : atrLength to be used for measuring the price based on ATR. Used only if useAtrReference is set to true.
PriceSampleData
Special type of sample called price sample. Can be used instead of basic Sample type
Fields:
trigger : consider sample only if trigger is set to true. Default is true.
source : Price source. Default is close
highSource : High price source. Default is high
lowSource : Low price source. Default is low
tr : True range value. Default is ta.tr
DiscordLibraryLibrary "DiscordLibrary"
BoldString(str)
Bold String in Discord Function
Parameters:
str
ItalicizeString(str)
Italicize String in Discord Function
Parameters:
str
StrikeThroughString(str)
Strikethrough a String in Discord Function
Parameters:
str
UnderlineString(str)
Underline a String in Discord Function
Parameters:
str
SpoilerString(str)
When you send the text, it will be shown as a black block, and only by clicking on it will you be able to see what is written below, in a way, unveiling the text or giving spoilers
Parameters:
str
HighlightString(str)
Highlight String Function
Parameters:
str
BoxedString(str)
Put String in a Box Function
Parameters:
str
NonEmbeddedURLString(str)
Format URL String so that it is not an embedded Image but just the Link
Parameters:
str
InvisibleString(str)
Send Inivisible Text
Parameters:
str
FormatTimePeriodForDiscord(_timeperiod)
Parameters:
_timeperiod
GetDiscordEmbedJSON(_message, _avatarURL, _botName, _role, _color, _embed_title, _embed_subtitle, _title, _url, _icon_url, _icon2_url, _footer, _description)
Generate discord embed JSON
Parameters:
_message
_avatarURL
_botName
_role
_color
_embed_title
_embed_subtitle
_title
_url
_icon_url
_icon2_url
_footer
_description
GetDiscordTextJSON(_description)
Formats Content Only JSON Message
Parameters:
_description
Truncate(_number, _decimalPlaces)
Custom function to truncate (cut) excess decimal places
Parameters:
_number
_decimalPlaces
FormatDiscordMessage(_textmessage, _ticker, _timeframe)
format Content message
Parameters:
_textmessage
_ticker
_timeframe
FormatCoin(_coinText)
Format Ticker Symbol
Parameters:
_coinText
Economic Calendar (Import from Spreadsheet)This script draws vertical lines to mark Economic Calendar Events.
Datetime of events is defined by user in Settings via a standardized line of text.
Motivation for coding this script:
All traders should be aware of economic calendar events. At times, when you really need to pay attention to an upcoming major event, you might even decide to use the vertical-line drawing tool to mark it. However, this takes manual effort.
This script provides a solution to performing mundane tasks such as drawing vertical lines and dragging them ever so slightly, just to have them approximately aligned with exact time.
Parameters:
(1) Source data - String representation of collection of datetime referencing to Economic Calendar Events
(2) Line color, & (3) Width of line - For displaying vertical lines drawn by script.
Standardized format for Source Data :
Example:
If 'GMT;2022,6,1,14,0,0;2022,6,2,12,15,0;' is provided to PineScript, then two vertical lines will be drawn on June 6, 2022 according to the exact time in 'YYYY,MM,DD,hh,mm,ss' format at the specified timezone (GMT in this case).
Template for Source Data :
Included here, link below, is a shared Google Sheet that systematically processes Economic Calendar data provided in the 'Raw Data' tab.
drive.google.com
Users are advised to use their preferred methods* to format the string (for source data param.), and apply their own criteria to sort down the Events. (ie. only include Events of High Impact, etc.)
* Preferred methods (as mentioned above) does not mean being limited to using the template as provided in this post.
HH-LL ZZAnother ZigZag, yes...
I believe though this concerns another angle/principle, therefore I wanted to share
How does it work?
Given:
source for level breach -> close
X breaches -> 3
Let's say this is the latest found 'lower low' (LL - blue dot under bar):
This bar has been triggered because 3 bars closed under low of previous 'trigger bar' (TB )
The high and low of this new TB will act as triggers
(aqua blue lines, seen in image above)
Then there are 2 options:
- again 3 bars closes under the latest TB , in that case the TB moves to that new LL.
- 3 bars closes higher than the high of previous TB
The high and low of this new TB act again as trigger
If a new TB LL/HH is found, the script checks previous LL/HH
and searches the highest/lowest point in between.
If necessary, the temporary highest/lowest will be adjusted:
Another example:
The last 2 points can change (repaint).
Yellow coloured lines/labels are set and won't change anymore.
Concluded:
In case of these settings:
source for level breach -> close
X breaches -> 3
once a new TB is found, the high and low act as trigger lines
- when 3 bars closes under that low , a new LL is found, this will be the new TB
- when 3 bars closes above that high , a new HH is found, this will be the new TB
and so on...
Settings:
source for level breach -> close or high/low - H/L
X breaches -> 1 -> 10
line style -> solid, dotted, dashed
show level breaches -> new found TB (blue/lime coloured)
show Support/Resistance (lines at the right)
repaint warning can be removed
show labels / lines
This ZZ can be used for Harmonic patterns, Trend evaluation, support/resistance,...
In this script, I also used new features
- text_font_family = font.family_monospace -> link
- display=display.pane -> link
Cheers!
DiscordLibraryLibrary "DiscordLibrary"
BoldString()
Bold String in Discord Function
ItalicizeString()
Italicize String in Discord Function
StrikeThroughString()
Strikethrough a String in Discord Function
UnderlineString()
Underline a String in Discord Function
SpoilerString()
When you send the text, it will be shown as a black block, and only by clicking on it will you be able to see what is written below, in a way, unveiling the text or giving spoilers
HighlightString()
Highlight String Function
BoxedString()
Put String in a Box Function
NonEmbeddedURLString()
Format URL String so that it is not an embedded Image but just the Link
InvisibleString()
Send Inivisible Text
FormatTimePeriodForDiscord()
GetDiscordEmbedJSON()
Generate discord embed JSON
GetDiscordTextJSON()
Formats Content Only JSON Message
Truncate()
Custom function to truncate (cut) excess decimal places
FormatDiscordMessage()
format Content message
FormatCoin()
Format Ticker Symbol
[blackcat] L3 RMI Trading StrategyLevel 3
Background
My view of correct usage of RSI and the relationship between RMI and RSI. A proposed RMI indicator with features is introduced
Descriptions
The Relative Strength Index (RSI) is a technical indicator that many people use. Its focus indicates the strength or weakness of a stock. In the traditional usage of this point, when the RSI is above 50, it is strong, otherwise it is weak. Above 80 is overbought, below 20 is oversold. This is what the textbook says. However, if you follow the principles in this textbook and enter the actual trading, you would lose a lot and win a little! What is the reason for this? When the RSI is greater than 50, that is, a stock enters the strong zone. At this time, the emotions of market may just be brewing, and as a result, you run away and watch others win profit. On the contrary, when RSI<20, that is, a stock enters the weak zone, you buy it. At this time, the effect of losing money is spreading. You just took over the chips that were dumped by the whales. Later, you thought that you had bought at the bottom, but found that you were in half mountainside. According to this cycle, there is a high probability that a phenomenon will occur: if you sell, price will rise, and if you buy, price will fall, who have similar experiences should quickly recall whether their RSI is used in this way. Technical indicators are weapons. It can be either a tool of bull or a sharp blade of bear. Don't learn from dogma and give it away. Trading is a game of people. There is an old saying called “people’s hearts are unpredictable”. Do you really think that there is a tool that can detect the true intentions of people’s hearts 100% of the time?
For the above problems, I suggest that improvements can be made in two aspects (in other words, once the strategy is widely spread, it is only a matter of time before it fails. The market is an adaptive and complex system, as long as it can be fully utilized under the conditions that can be used, it is not easy to use. throw or evolve):
1. RSI usage is the opposite. When a stock has undergone a deep adjustment from a high level, and the RSI has fallen from a high of more than 80 to below 50, it has turned from strong to weak, and cannot be bought in the short term. But when the RSI first moved from a low to a high of 80, it just proved that the stock was in a strong zone. There are funds in the activity, put into the stock pool.
Just wait for RSI to intervene in time when it shrinks and pulls back (before it rises when the main force washes the market). It is emphasized here that the use of RSI should be combined with trading volume, rising volume, and falling volume are all healthy performances. A callback that does not break an important moving average is a confirmed buying point or a second step back on an important moving average is a more certain buying point.
2. The RSI is changed to a more stable and adjustable RMI (Relative Momentum Indicator), which is characterized by an additional momentum parameter, which can not only be very close to the RSI performance, but also adjust the momentum parameter m when the market environment changes to ensure more A good fit for a changing market.
The Relative Momentum Index (RMI) was developed by Roger Altman and described its principles in his article in the February 1993 issue of the journal Technical Analysis of Stocks and Commodities. He developed RMI based on the RSI principle. For example, RSI is calculated from the close to yesterday's close in a period of time compared to the ups and downs, while the RMI is compared from the close to the close of m days ago. Therefore, in principle, when m=1, RSI should be equal to RMI. But it is precisely because of the addition of this m parameter that the RMI result may be smoother than the RSI.
Not much more to say, the below picture: when m=1, RMI and RSI overlap, and the result is the same.
The Shanghai 50 Index is from TradingView (m=1)
The Shanghai 50 Index is from TradingView (m=3)
The Shanghai 50 Index is from TradingView (m=5)
For this indicator function, I also make a brief introduction:
1. 50 is the strength line (white), do not operate offline, pay attention online. 80 is the warning line (yellow), indicating that the stock has entered a strong area; 90 is the lightening line (orange), once it is greater than 90 and a sell K-line pattern appears, the position will be lightened; the 95 clearing line (red) means that selling is at a climax. This is seen from the daily and weekly cycles, and small cycles may not be suitable.
2. The purple band indicates that the momentum is sufficient to hold a position, and the green band indicates that the momentum is insufficient and the position is short.
3. Divide the RMI into 7, 14, and 21 cycles. When the golden fork appears in the two resonances, a golden fork will appear to prompt you to buy, and when the two periods of resonance have a dead fork, a purple fork will appear to prompt you to sell.
4. Add top-bottom divergence judgment algorithm. Top_Div red label indicates top divergence; Bot_Div green label indicates bottom divergence. These signals are only for auxiliary judgment and are not 100% accurate.
5. This indicator needs to be combined with VOL energy, K-line shape and moving average for comprehensive judgment. It is still in its infancy, and open source is published in the TradingView community. A more complete advanced version is also considered for subsequent release (because the K-line pattern recognition algorithm is still being perfected).
Remarks
Feedbacks are appreciated.
(Quartile Vol.; Vol. Aggregation; Range US Bars; Gaps) [Kioseff]Hello!
This indicator is a multifaceted tool that's, hopefully, useful for price action and volume analysis.
(This script makes use of the newly introduced "text_font" parameter)
With this script you'll have access to:
Range US Chart
Volume Aggregation Chart
Gaps Chart
Volume by Quartile
Consequently, you'll have access to:
First Quartile Volume Threshold
Second Quartile Volume Threshold
Third Quartile Volume Threshold
90th Percentile Volume Threshold
Fourth Quartile Volume Threshold
Q2 - Q1 Dispersion
Q3 - Q2 Dispersion
Q4 - Q3 Dispersion
Quartile Deviation
Interquartile Range
Avg. "n" bar return following "high" volume
Avg. "n" bar positive return following "high" volume
Avg. "n" bar negative following "high" volume
# of Positive Returns Following a Gap
# of Negative Returns Following a Gap
# of Gaps
# of Up Gaps
# of Down Gaps
Average # of bars to fill Up Gaps
Average # of bars to dill Down Gaps
Average Gap Up % increase
Average Gap Down % decrease
Cumulative % increase of all Up Gaps
Cumulative % decrease of all Down Gaps
Sort gaps by distance from price
Hide gaps that price substantially deviates from (gaps will reappear when price trades near the gap)
Segment Range US bars by date
Manually configure Range US price thresholds
Identify "congestion" areas with Range US bars
Range US Levels that must be exceeded for a new Range US bar to produce
Manually configure cumulative volume threshold for Volume Aggregation bars
Segment Volume Aggregation bars by date
Largest Volume Aggregation bar increases
Largest Volume Aggregation bar decreases
Calculate log returns after "high" volume sessions
Quartile Volume
The Quartile Volume portion of the script segments price/volume intervals by quartile.
The image above shows features of the indicator.
For statistics, the following metrics are recorded:
First Quartile
Second Quartile
Third Quartile
90th Percentile
Fourth Quartile
Q2 - Q1 Dispersion
Q3 - Q2 Dispersion
Q4 - Q3 Dispersion
Quartile Deviation
Interquartile Range
Color-coordinated price bars (by volume quartiles)
The percent rank for the volume of the current bar
Avg. "n" bar return following "high" volume
Avg. "n" bar positive return following "high" volume
Avg. "n" bar negative following "high" volume
The script colors bars via gradient.
By default, bars are colored lime when volume for the interval is "high" (exceeds upper quartile thresholds). The greener the bar, the higher the volume for the interval.
Bars are colored red when volume for the interval is "low" (fails to exceed lower quartile thresholds). The redder the bar, the lower the volume for the interval.
Naturally, brownish-colored bars reflect a volume interval that concluded near the median.
The image above exemplifies the process. This feature might be useful to categorize / objectively define high-volume clusters, low-volume clusters, high-volume price moves, low-volume price moves, etc.
For greater precision, you can select to color bars by volume quartile they belong to.
The image above shows color-coordinated price bars. More details shown in the image.
Additionally, you can select to plot the quartile/percentile that a price bar belongs to on the chart.
The image above shows price bars numbered by the volume quartile they belong to.
The script will distinguish successive 90th percentile violations, superimpose a linear regression channel atop the data sequence, and record pertinent statistics.
The image above shows the process.
Lastly, the user can plot an anchored VWAP using a built-in time function.
The image above shows the anchored VWAP.
Range US Chart
A Range US chart operates irrespective of time and volume - simply - bars produce after a user-defined price move is achieved/exceeded in either direction. A range us chart produces “trend candles” and “reversal candles”. A reversal candle always moves against the most immediate bar; a trend candle always moves in favor of the most immediate bar. The user defines the dollar amount price must travel up/down for a trend candle to fulfill, and for a reversal candle to fulfill.
Note: if a “down reversal” candle (red) Is produced, it’s impossible for the next candle to also be a down reversal candle - for the downside move to continue the criteria for a down trend candle must be fulfilled. Similarly, if an “up reversal” candle (green) Is produced, it’s impossible for the next candle to also be an up reversal candle - for the upside move to continue, the criteria for an uptrend trend candle must be fulfilled. Consequently, Range US bars frequently trade at the same level for extended periods. This is intentional, as this chart type is theorized to “filter noise” (whether Range US charts fulfill this theory is to your discretion).
Lastly, if an up trend candle (green) is produced, the next candle cannot be up a reversal up candle - only a trend up candle or reversal down candle can produce - vice versa for a trend down candle (the subsequent candle cannot be a reversal down candle). In this sense, an uptrend continues on successive trend up candles; a down trend continues on successive trend down candles.
The image above exemplifies Range US chart functionality.
The lower-right stats table shows the requisite price move for a "Trend" candle to produce and for a "Reversal" candle to produce.
The default settings for this chart time automatically calculate the required "Trend" candle price move and the required "Reversal" candle price move. However, both settings are configurable.
The image above shows manually configured parameters for a trend bar and reversal bar to produce. This feature allows the user to replicate the Range US chart hosted on extrinsic charting platforms.
However, please consider that this script does not use tick data; 1-minute OHLC data is used for calculations.
Consequently, configuring the trend bar and reversal bar requirement too low may return inaccurate data. For instance, if you set trend candles to form after a $1 price move then trend candles will form if price moves up $1 from a green Range US bar or down $1 from a red Range US bar. This is sufficient for lower priced assets; however, if you were trading, for instance, Bitcoin - a $1 price move can happen numerous times in one minute. This script can’t plot bars and record data until a 1-minute bar closes and a new 1-minute bar opens. Further, if Bitcoin moves up $1 twenty times and down $1 twenty times in a 1-minute bar - your Range US chart will record such variations as one price move. This data is inaccurate and likely useless.
To counter this quandary, a warning message will appear if you configure trend bar price moves or reversal bar price moves too low.
The image above shows the concealable warning message.
The image above is a flow diagram (made with shaky hands) illustrating the Range US bar formation process.
A google search will return additional information on the Range US chart type.
Volume Aggregation Bars
TradingView user and member of the TradingView Discord server @ferreirajames informed me of the Volume Aggregation chart type. The user commented in the "Suggestions" channel for the TradingView Discord server asking for the Volume Aggregation chart type. As an interim fix, I tried my hand at recreating the process, which is available in this script.
Similar to the Range US chart type, Volume Aggregation bars aren’t bound to a time-axis; the bars form after a user-defined, cumulative amount of volume is achieved or exceeded. Consequently, once the cumulative amount of volume is achieved or exceeded - a bar is produced at the corresponding price level.
Underlying theory: The chat type is conducive to identifying price levels where traders are “trapped”. Whether the process adequately distinguishes this circumstance is to your discretion.
The image above exemplifies the Volume Aggregation chart type.
Regardless of the current price, Volume Aggregation bars for after a requisite amount of volume is achieved/exceeded. Tick data isn't used; therefore, remainder values are carry over.
By default, the script automatically calculates a proportional cumulative volume total to dictate the formation of Volume Aggregation bars. However, the cumulative threshold is configurable.
The image above shows Volume Aggregation bars forming subsequent a user-defined cumulative volume total being exceeded.
Note: This chart type uses OHLC data from the timeframe of your chart. Therefore, for instance, setting the volume threshold too low will produce inaccurate, useless data.
A warning message will appear for such occurrence.
Gaps
The indicator incorporates a "Gaps" chart type.
The image above shows accompanying features.
A list of all unfilled gaps is accessible - gaps for this list are sorted by distance from current price.
Partially filled gaps are displayed in the corresponding gap box - the percentage amount the gap was filled is also displayed.
Gap statistics show:
# of Gaps
# of Up Gaps
# of Down Gaps
Average # of bars to fill Up Gaps
Average # of bars to dill Down Gaps
Average Gap Up % increase
Average Gap Down % decrease
Cumulative % increase of all Up Gaps
Cumulative % decrease of all Down Gaps
Naturally, there may be gaps formed thousands of bars ago that aren't close to price. Showing these gaps on the chart will "scrunch" the y-axis and make prices indistinguishable.
I've added a setting that allows the user to hide gaps that are "n" % away from the current price. The gap, if unfilled, will reappear when price trades within the user-defined percentage.
The image above shows an example. There's an unfilled down gap that's "hidden" because the current price is a further % away from price than what I've specified in the settings (1%). When prices trade back within 1% of the gap - it will reappear.
The image above shows the process in action. Prices moved back within 1% (can be any %) of the gap; therefore, it reappeared on the chart.
You can also set the % distance a gap must achieve for it to be considered a gap, recorded and plotted. Additionally, you can select to "visualize" gaps. Similar to the Range US chart and the Volume Aggregation chart, this setting will bars reflecting the most recent sequence of gaps - date and percentage distance of the gap are superimposed atop the bar.
Let me know if there's anything else you'd like included!
Note: The initial compilation time for this script is.... high. However, once the script's compiled, calculation load times are quick and you can sift through assets and timeframes relatively quick.
There's also a setting to "Improve Load Times" in the user-inputs table. This setting only improves the load times for post-compilation calculations and plots. The initial compilation load time is unchanged. Simply, once the indicator has "first loaded", all subsequent loads are quick.
Thank you! (:
Annual Returns % Comparison [By MUQWISHI]Overview
The Annual Returns % Comparison indicator aimed to compare the historical annual percentage change of any two symbols. The indicator output shows a column-plot that was developed by two using a pine script table, so each period has pair columns showing the yearly percentage change for entered symbols.
Features
- Enter date range.
- Fill up with any two symbols.
- Choose the output data whether adjusted or not.
- Change the location of the table plot
- Color columns by a symbol.
- Size the height and width of columns.
- Color background, border, and text.
- The tooltip of the column value appears once the cursor sets above the specific column. As it seen below.
Let me know if you have any questions.
Thanks.
