Order Block Refiner [TradingFinder]🔵 Introduction
The "Refinement" feature allows you to adjust the width of the order block according to your strategy. There are two modes, "Aggressive" and "Defensive," in the "Order Block Refine". The difference between "Aggressive" and "Defensive" lies in the width of the order block.
For risk-averse traders, the "Defensive" mode is suitable as it provides a lower loss limit and a greater reward-to-risk ratio. For risk-taking traders, the "Aggressive" mode is more appropriate. These traders prefer to enter trades at higher prices, and this mode, which has a wider order block width, is more suitable for this group of individuals.
Important :
One of the advantages of using this library is increased code accuracy. Not only does it have the capability to create order blocks, but you can also simply define the condition for order block creation (true/false) and "bar_index," and you'll find the primary range without applying any filters.
🟣 Order Block Refinement Algorithm
The order block ranges are filtered in two stages. In the first stage, the "Open," "High," "Low," and "Close" of the current order block candle, its two or three previous candles, and one subsequent candle (if available) are examined. In this stage, minimum and maximum distances are calculated, and logical range filters are applied.
In the second stage, two modes, "Aggressive" and "Defensive," are calculated.
For the "Defensive" mode, the width of these ranges is compared with the "ATR" (Average True Range) of period 55, and if they are smaller than "ATR" or 1 to more than 4 times "ATR," the width of the range is reduced from 0 to 80 percent.
For the "Aggressive" mode, you get the same output as the first filter, which usually has a wider width than the "Defensive" mode.
• Order Block Refiner : Off
• Order Block Refiner : On / "Aggressive Mode"
• Order Block Refiner : On / "Defensive Mode"
🔵 How to Use
OBRefiner(string OBType, string OBRefine, string RefineMethod, bool TriggerCondition, int Index) =>
Parameters:
• OBType (string)
• OBRefine (string)
• RefineMethod (string)
• TriggerCondition (bool)
• Index (int)
To add "Order Block Refiner Library", you must first add the following code to your script.
import TFlab/OrderBlockRefiner_TradingFinder/1
OBType : This parameter receives 2 inputs. If the order block you want to "Refine" is of type demand, you should enter "Demand," and if it's of type supply, you should enter "Supply."
OBRefine : Set to "On" if you want the "Refine" operation to be performed. Otherwise, set to "Off."
RefineMethod : This input receives 2 modes, "Aggressive" and "Defensive." You can switch between these modes according to your needs.
TriggerCondition : Enter the condition with which the order block is formed in this parameter.
Index : Enter the "bar_index" of the candle where the order block is formed in this parameter.
🟣 Function Outputs
This function has 6 outputs: "bar_index" at the beginning of the "Distal" line, "bar_index+1" at the end of the "Distal" line, "Price" at the "Distal" line, "bar_index" at the beginning of the "Proximal" line, "bar_index+1" at the end of the "Proximal" line, and "Price" at the "Proximal" line, which can be used to draw order blocks.
Sample :
= Refiner.OBRefiner('Demand', 'Off', 'Aggressive',BuMChMain_Trigger, BuMChMain_Index)
if BuMChMain_Trigger
BuMChHlineMain := line.new(BuMChMain_Xp1 , BuMChMain_Yp12 , bar_index , BuMChMain_Yp12, color = color.black , style = line.style_dotted)
BuMChLlineMain := line.new(BuMChMain_Xd1 , BuMChMain_Yd12 , bar_index , BuMChMain_Yd12, color = color.black , style = line.style_dotted)
BuMChFilineMain := linefill.new(BuMChHlineMain ,BuMChLlineMain , color = color.rgb(76, 175, 80 , 75 ) )
Techindicator
divergingchartpatternLibrary "divergingchartpattern"
Library having implementation of converging chart patterns
getPatternNameByType(patternType)
Returns pattern name based on type
Parameters:
patternType (int) : integer value representing pattern type
Returns: string name of the pattern
method find(this, sProperties, dProperties, patterns, ohlcArray)
find converging patterns for given zigzag
Namespace types: zg.Zigzag
Parameters:
this (Zigzag type from Trendoscope/ZigzagLite/2) : Current zigzag Object
sProperties (ScanProperties) : ScanProperties Object
dProperties (DrawingProperties type from Trendoscope/abstractchartpatterns/5) : DrawingProperties Object
patterns (array type from Trendoscope/abstractchartpatterns/5) : array of existing patterns to check for duplicates
ohlcArray (array type from Trendoscope/ohlc/1) : array of OHLC values for historical reference
Returns: string name of the pattern
ScanProperties
Object containing properties for pattern scanning
Fields:
baseProperties (ScanProperties type from Trendoscope/abstractchartpatterns/5) : Object of Base Scan Properties
convergingDistanceMultiplier (series float)
swinglibraryLibrary "swinglibrary"
This library is for calculating non-repainting swings for further calculation on them.
These swings can later be drawn, but drawing is not part of this library, only the calculation.
What do I need to use the library?
You better include the following constants into your script using this library:
int SWING_NO_ACTION = 0
int SWING_FLIP = 1
int SWING_FLIP_NEW_SWING = 2
int SWING_FLIP_UPDATED = 3
int RELATION_HIGHER = 1
int RELATION_EQUAL = 0
int RELATION_LOWER = -1
Choosing the function, that fits your needs
This library contains 4 functions for calculating swings, the difference between them are the data you get for every swing point and additional average values for length and duration:
swings()
swingsR()
swingsL()
swingsLDR()
The naming scheme of these functions is the following:
The base version swings() is only for the swings containing the following swingPoint type:
swingPoint
Fields:
x (integer) : bar index
y (float) : price
hilo (integer) 1 -> high, -1 -> low
and the return type:
swingReturn
Fields:
swings (array) : array of the last x swing points
newSwingHigh (integer) : flag to detect changes for swing highs see constants (SWING_NO_ACTION, SWING_FLIP_NEW_SWING, SWING_FLIP_UPDATED)
newSwingLow (integer) : flag to detect changes for swing lows see constants (SWING_NO_ACTION, SWING_FLIP_NEW_SWING, SWING_FLIP_UPDATED)
The R in swingsR() stands for relation where the previously shown types do also contain the relation between the swings of the same swing type (highs and lows respectively).
The same goes for L in swingsL() for length containing the price difference between the current and previous swing point in ticks.
And in the following version swingsLDR() there is also the duration between the current and previous point included.
The parameters for the other functions and type definitions include only the ones, that are needed, the "full" version of the function is described here:
swingsLDR(swingSize, dtbStrength, init, SWING_HISTORY_NUM)
Parameters:
swingSize (int) This parameter defines the size of the swings to look after, meaning higher values will lead to bigger swings
dtbStrength (int) Value between 0 and 100 is a factor (%) to the ATR that is used to calculate equal highs/lows (double tops / bottoms).
Higher values will result in a higher tolerance of price difference between the swings.
init (bool) This value is usually set to false on default.
It has a special use case, where we need to reduce memory usage and calculation time on the script using this library by start calculating at x bars back instead of the beginning of the chart.
In this case, we set init = true on the first bar we start calculating the swings on to perform the correct initialization.
SWING_HISTORY_NUM (int) This is the max number of swings that are stored in the array, so only the last SWING_HISTORY_NUM swings are stored in the array to reduce the memory usage.
New ones remove the oldest ones like in a ring buffer.
This is also influencing the average duration and average swing length.
swingPointLDR
Fields:
x (integer) : bar index
y (float) : price
hilo (integer) : 1 -> high, -1 -> low
length (float) : price difference to the previous swing point in ticks
duration (integer) : duration difference to the previous swing point in number of bars
relation (integer) : see constants RELATION_HIGHER, RELATION_EQUAL, RELATION_LOWER: reelation to the previous swing points of the same type (previous high or previous low respectively)
swingReturnLDR
Fields:
swings (array) : array of the last x swing points
newSwingHigh (integer) : flag to detect changes for swing highs see constants (SWING_NO_ACTION, SWING_FLIP_NEW_SWING, SWING_FLIP_UPDATED)
newSwingLow (integer) : flag to detect changes for swing lows see constants (SWING_NO_ACTION, SWING_FLIP_NEW_SWING, SWING_FLIP_UPDATED)
avSwLength (float) : average swing length for the last x swings (depending on the max number of swings)
avSwingDuration (float) : average swing duration for the last x swings (depending on the max number of swings)
YPLibrary "YP"
TODO: add library description here
breakUp(previousHigh)
breakUp: Determines if the low of the first bar of the current day
is above a given previous high.
Parameters:
previousHigh (float)
Returns: : Boolean value indicating whether the condition is met (true) or not (false).
Moving point of controlLibrary "moving_poc"
method getMovingPoc(averagePriceByVolumeHistory, ltfVolumeSerie, ltfPriceSerie, nbBarsToLookback)
Volume point of control (PoC) extracted from lower time frame data and previous time period
Namespace types: array
Parameters:
averagePriceByVolumeHistory (array) : An array of float to record previous PoC average
ltfVolumeSerie (array) : Source of volume for the lower timeframe (ltf)
ltfPriceSerie (array) : Source of price for the lower timeframe
nbBarsToLookback (int) : A number of bars determining the lookback period of this PoC
Returns: Serie of PoC
MyLibrary_functions_D_S_3D_D_T_PART_2Library "MyLibrary_functions_D_S_3D_D_T_PART_2"
TODO: add library description here
N_Re_Fib(Source_low, Source_high, lw, hg, x3_P, x1_P, x2_P)
Parameters:
Source_low (float)
Source_high (float)
lw (int)
hg (int)
x3_P (int)
x1_P (int)
x2_P (int)
P_lb_Re_Fib(Source_low, Source_high, lw, hg, x3_P, x1_P)
Parameters:
Source_low (float)
Source_high (float)
lw (int)
hg (int)
x3_P (int)
x1_P (int)
label_New(lw_hg, zigzag_Indicator_1_, zigzag_Indicator_2_, zigzag_Indicator_3_, Number_Of_Labels_Printed_MS_MN, x1_, i_, label_id_, style_lable_, color_lable_, size_txt_lable_, color_txt_lable_)
Parameters:
lw_hg (string)
zigzag_Indicator_1_ (bool)
zigzag_Indicator_2_ (bool)
zigzag_Indicator_3_ (bool)
Number_Of_Labels_Printed_MS_MN (int)
x1_ (int)
i_ (int)
label_id_ (string)
style_lable_ (string)
color_lable_ (color)
size_txt_lable_ (string)
color_txt_lable_ (color)
Num_last_lebel_for_scan_no(Number_Of_Labels_Printed_, array_ad, array_id, gap, scan_no)
Parameters:
Number_Of_Labels_Printed_ (int)
array_ad (array)
array_id (array)
gap (int)
scan_no (string)
Previous_piote(lw_hg, arr_x_P_lw, arr_x_P_hg, Num_last_lebel_for_scan_no_MSMN)
Parameters:
lw_hg (string)
arr_x_P_lw (array)
arr_x_P_hg (array)
Num_last_lebel_for_scan_no_MSMN (int)
Required_drawing_information(lw__, hg__, last_l__, last_h__, Source_Zigzag_low_, Source_Zigzag_high_, upcolor_li__, dncolor_li__, upcolor_txt__, dncolor_txt__)
Parameters:
lw__ (int)
hg__ (int)
last_l__ (int)
last_h__ (int)
Source_Zigzag_low_ (float)
Source_Zigzag_high_ (float)
upcolor_li__ (color)
dncolor_li__ (color)
upcolor_txt__ (color)
dncolor_txt__ (color)
draw_line_(zigzag_Indicator_, i__lw, i__hg, Scan_No, lw_, hg_, last_l_, last_h_, arr_ad_lw_, arr_ad_hg_, arr_id_lw_, arr_id_hg_, arr_x_P_lw_, arr_x_P_hg_, Num_last_lebel_for_scan_no_123_MS_, Num_last_lebel_for_scan_no_123_MN_, Source_Zigzag_low_, Source_Zigzag_high_, MS_Div_, MN_Div_, Fibonacci_Retracement_, x_P_lb_Re_Fib_, y_P_lb_Re_Fib_, N_Re_Fib_, size_txt_lable, Fibonacci_txt, line_thick_, sty_line_, upcolor_li_, dncolor_li_, upcolor_txt_, dncolor_txt_)
Parameters:
zigzag_Indicator_ (bool)
i__lw (int)
i__hg (int)
Scan_No (int)
lw_ (int)
hg_ (int)
last_l_ (int)
last_h_ (int)
arr_ad_lw_ (array)
arr_ad_hg_ (array)
arr_id_lw_ (array)
arr_id_hg_ (array)
arr_x_P_lw_ (array)
arr_x_P_hg_ (array)
Num_last_lebel_for_scan_no_123_MS_ (int)
Num_last_lebel_for_scan_no_123_MN_ (int)
Source_Zigzag_low_ (float)
Source_Zigzag_high_ (float)
MS_Div_ (bool)
MN_Div_ (bool)
Fibonacci_Retracement_ (bool)
x_P_lb_Re_Fib_ (int)
y_P_lb_Re_Fib_ (float)
N_Re_Fib_ (string)
size_txt_lable (string)
Fibonacci_txt (string)
line_thick_ (int)
sty_line_ (string)
upcolor_li_ (color)
dncolor_li_ (color)
upcolor_txt_ (color)
dncolor_txt_ (color)
draw_line_123(zigzag_Indicator_, scan_no_, lw_, hg_, last_l_, last_h_, lw_D_POINT_ad_, hg_D_POINT_ad_, lw_D_POINT_id_, hg_D_POINT_id_, x_P_123_lw_, x_P_123_hg_, lw_D_P_1__, lw_D_P_2__, lw_D_P_3__, lw_D_P_4__, lw_D_P_5__, hg_D_P_1__, hg_D_P_2__, hg_D_P_3__, hg_D_P_4__, hg_D_P_5__, Num_last_lebel_for_scan_no_123_MS_, Num_last_lebel_for_scan_no_123_MN_, Source_Zigzag_123_F_low_, Source_Zigzag_123_F_high_, MS_Div_123_, MN_Div_123_, Fibonacci_Retracement_123_, x_P_lb_Re_Fib_123_, y_P_lb_Re_Fib_123_, N_Re_Fib_123_, size_txt_lable_lb_, Fibonacci_Re_text_, line_thick_123_, sty_line_123_, upcolor_li_123_, dncolor_li_123_, upcolor_txt_123_, dncolor_txt_123_)
Parameters:
zigzag_Indicator_ (bool)
scan_no_ (int)
lw_ (int)
hg_ (int)
last_l_ (int)
last_h_ (int)
lw_D_POINT_ad_ (array)
hg_D_POINT_ad_ (array)
lw_D_POINT_id_ (array)
hg_D_POINT_id_ (array)
x_P_123_lw_ (array)
x_P_123_hg_ (array)
lw_D_P_1__ (int)
lw_D_P_2__ (int)
lw_D_P_3__ (int)
lw_D_P_4__ (int)
lw_D_P_5__ (int)
hg_D_P_1__ (int)
hg_D_P_2__ (int)
hg_D_P_3__ (int)
hg_D_P_4__ (int)
hg_D_P_5__ (int)
Num_last_lebel_for_scan_no_123_MS_ (int)
Num_last_lebel_for_scan_no_123_MN_ (int)
Source_Zigzag_123_F_low_ (float)
Source_Zigzag_123_F_high_ (float)
MS_Div_123_ (bool)
MN_Div_123_ (bool)
Fibonacci_Retracement_123_ (bool)
x_P_lb_Re_Fib_123_ (int)
y_P_lb_Re_Fib_123_ (float)
N_Re_Fib_123_ (string)
size_txt_lable_lb_ (string)
Fibonacci_Re_text_ (string)
line_thick_123_ (int)
sty_line_123_ (string)
upcolor_li_123_ (color)
dncolor_li_123_ (color)
upcolor_txt_123_ (color)
dncolor_txt_123_ (color)
draw_point_123(zigzag_Indicator_123, points_, lw, hg, last_l, last_h, Source_Zigzag_F_low, Source_Zigzag_F_high, arr_x_P_lw_, arr_x_P_hg_, Num_last_lebel_for_scan_no_123_MS_, Num_last_lebel_for_scan_no_123_MN_, size_points, style_label_upper, style_label_lower, upcolor_lebel, dncolor_lebel)
Parameters:
zigzag_Indicator_123 (bool)
points_ (bool)
lw (int)
hg (int)
last_l (int)
last_h (int)
Source_Zigzag_F_low (float)
Source_Zigzag_F_high (float)
arr_x_P_lw_ (array)
arr_x_P_hg_ (array)
Num_last_lebel_for_scan_no_123_MS_ (int)
Num_last_lebel_for_scan_no_123_MN_ (int)
size_points (string)
style_label_upper (string)
style_label_lower (string)
upcolor_lebel (color)
dncolor_lebel (color)
MyLibrary_functions_D_S_3D_D_T_PART_1Library "MyLibrary_functions_D_S_3D_D_T_PART_1"
TODO: add library description here
color_(upcolor_txt, upcolor, dncolor_txt, dncolor, theme)
Parameters:
upcolor_txt (color)
upcolor (color)
dncolor_txt (color)
dncolor (color)
theme (string)
Source_Zigzag_F(Source)
Parameters:
Source (string)
p_lw_hg(Source_low, Source_high, Depth)
Parameters:
Source_low (float)
Source_high (float)
Depth (int)
lowing_highing(Source_low, Source_high, p_lw, p_hg, Deviation)
Parameters:
Source_low (float)
Source_high (float)
p_lw (int)
p_hg (int)
Deviation (int)
ll_lh(lowing, highing)
Parameters:
lowing (bool)
highing (bool)
down_ll_down_lh(ll, lh, Backstep)
Parameters:
ll (int)
lh (int)
Backstep (int)
down(down_ll, down_lh, lw, hg)
Parameters:
down_ll (bool)
down_lh (bool)
lw (int)
hg (int)
f_x_P_S123_lw(lw_, hg_, p_lw_, down, Source_low)
Parameters:
lw_ (int)
hg_ (int)
p_lw_ (int)
down (int)
Source_low (float)
f_x_P_S123_hg(lw_, hg_, p_hg_, down, Source_high)
Parameters:
lw_ (int)
hg_ (int)
p_hg_ (int)
down (int)
Source_high (float)
Update_lw_hg_last_l_last_h(lw, hg, last_l, last_h, p_lw, p_hg, down, Source_low, Source_high)
Parameters:
lw (int)
hg (int)
last_l (int)
last_h (int)
p_lw (int)
p_hg (int)
down (int)
Source_low (float)
Source_high (float)
x1_P_y1_P_x2_P_y2_P_x3_P_y3_P_x4_P_y4_P(lw, hg, last_l, last_h, Source)
Parameters:
lw (int)
hg (int)
last_l (int)
last_h (int)
Source (string)
x1_P_os(lw, hg, x2_D, Diverjence_MACD_Line_, Diverjence_MACD_Histagram_, Diverjence_RSI_, Diverjence_Stochastic_, Diverjence_volume_, Diverjence_CCI_, Diverjence_MFI_, Diverjence_Momentum_, Diverjence_OBV_, Diverjence_ADX_, MACD, hist_MACD, RSI, volume_ok, Stochastic_K, CCI, MFI, momentum, OBV, adx)
Parameters:
lw (int)
hg (int)
x2_D (int)
Diverjence_MACD_Line_ (bool)
Diverjence_MACD_Histagram_ (bool)
Diverjence_RSI_ (bool)
Diverjence_Stochastic_ (bool)
Diverjence_volume_ (bool)
Diverjence_CCI_ (bool)
Diverjence_MFI_ (bool)
Diverjence_Momentum_ (bool)
Diverjence_OBV_ (bool)
Diverjence_ADX_ (bool)
MACD (float)
hist_MACD (float)
RSI (float)
volume_ok (float)
Stochastic_K (float)
CCI (float)
MFI (float)
momentum (float)
OBV (float)
adx (float)
x3_P_os(lw, hg, x2_D, x4_D, Diverjence_MACD_Line_, Diverjence_MACD_Histagram_, Diverjence_RSI_, Diverjence_Stochastic_, Diverjence_volume_, Diverjence_CCI_, Diverjence_MFI_, Diverjence_Momentum_, Diverjence_OBV_, Diverjence_ADX_, MACD, hist_MACD, RSI, volume_ok, Stochastic_K, CCI, MFI, momentum, OBV, adx)
Parameters:
lw (int)
hg (int)
x2_D (int)
x4_D (int)
Diverjence_MACD_Line_ (bool)
Diverjence_MACD_Histagram_ (bool)
Diverjence_RSI_ (bool)
Diverjence_Stochastic_ (bool)
Diverjence_volume_ (bool)
Diverjence_CCI_ (bool)
Diverjence_MFI_ (bool)
Diverjence_Momentum_ (bool)
Diverjence_OBV_ (bool)
Diverjence_ADX_ (bool)
MACD (float)
hist_MACD (float)
RSI (float)
volume_ok (float)
Stochastic_K (float)
CCI (float)
MFI (float)
momentum (float)
OBV (float)
adx (float)
Err_test(lw, hg, x1, y1, x2, y2, y_d, start, finish, Err_Rate)
Parameters:
lw (int)
hg (int)
x1 (int)
y1 (float)
x2 (int)
y2 (float)
y_d (float)
start (int)
finish (int)
Err_Rate (float)
divergence_calculation(Feasibility_RD, Feasibility_HD, Feasibility_ED, lw, hg, Source_low, Source_high, x1_P_pr, x3_P_pr, x1_P_os, x3_P_os, x2_P_pr, x4_P_pr, oscillator, Fix_Err_Mid_Point_Pr, Fix_Err_Mid_Point_Os, Err_Rate_permissible_Mid_Line_Pr, Err_Rate_permissible_Mid_Line_Os, Number_of_price_periods_R_H, Permissible_deviation_factor_in_Pr_R_H, Number_of_oscillator_periods_R_H, Permissible_deviation_factor_in_OS_R_H, Number_of_price_periods_E, Permissible_deviation_factor_in_Pr_E, Number_of_oscillator_periods_E, Permissible_deviation_factor_in_OS_E)
Parameters:
Feasibility_RD (bool)
Feasibility_HD (bool)
Feasibility_ED (bool)
lw (int)
hg (int)
Source_low (float)
Source_high (float)
x1_P_pr (int)
x3_P_pr (int)
x1_P_os (int)
x3_P_os (int)
x2_P_pr (int)
x4_P_pr (int)
oscillator (float)
Fix_Err_Mid_Point_Pr (bool)
Fix_Err_Mid_Point_Os (bool)
Err_Rate_permissible_Mid_Line_Pr (float)
Err_Rate_permissible_Mid_Line_Os (float)
Number_of_price_periods_R_H (int)
Permissible_deviation_factor_in_Pr_R_H (float)
Number_of_oscillator_periods_R_H (int)
Permissible_deviation_factor_in_OS_R_H (float)
Number_of_price_periods_E (int)
Permissible_deviation_factor_in_Pr_E (float)
Number_of_oscillator_periods_E (int)
Permissible_deviation_factor_in_OS_E (float)
label_txt(label_ID, zigzag_Indicator_1_, zigzag_Indicator_2_, zigzag_Indicator_3_)
Parameters:
label_ID (string)
zigzag_Indicator_1_ (bool)
zigzag_Indicator_2_ (bool)
zigzag_Indicator_3_ (bool)
delet_scan_item_1(string_, NO_1, GAP)
Parameters:
string_ (string)
NO_1 (int)
GAP (int)
delet_scan_item_2(string_, NO_1, GAP)
Parameters:
string_ (string)
NO_1 (int)
GAP (int)
calculation_Final_total(MS_MN, Scan_zigzag_NO, zigzag_Indicator, zigzag_Indicator_1, zigzag_Indicator_2, zigzag_Indicator_3, LW_hg_P2, LW_hg_P1, lw_1, lw_2, lw_3, hg_1, hg_2, hg_3, lw_hg_D_POINT_ad_Array, lw_hg_D_POINT_id_Array, Array_Regular_MS, Array_Hidden_MS, Array_Exaggerated_MS, Array_Regular_MN, Array_Hidden_MN, Array_Exaggerated_MN)
Parameters:
MS_MN (string)
Scan_zigzag_NO (string)
zigzag_Indicator (bool)
zigzag_Indicator_1 (bool)
zigzag_Indicator_2 (bool)
zigzag_Indicator_3 (bool)
LW_hg_P2 (int)
LW_hg_P1 (int)
lw_1 (int)
lw_2 (int)
lw_3 (int)
hg_1 (int)
hg_2 (int)
hg_3 (int)
lw_hg_D_POINT_ad_Array (array)
lw_hg_D_POINT_id_Array (array)
Array_Regular_MS (array)
Array_Hidden_MS (array)
Array_Exaggerated_MS (array)
Array_Regular_MN (array)
Array_Hidden_MN (array)
Array_Exaggerated_MN (array)
Search_piote_1(array_id_7, scan_no)
Parameters:
array_id_7 (array)
scan_no (int)
DynamicFunctionsLibrary "DynamicFunctions"
Custom Dynamic functions that allow an adaptive calculation beginning from the first bar
RoC(src, period)
Dynamic RoC
Parameters:
src (float) : and period
Custom function to calculate the actual period considering non-na source values
period (int)
dynamicMedian(src, length)
Dynamic Median
Parameters:
src (float) : and length
length (int)
kernelRegression(src, bandwidth, kernel_type)
Dynamic Kernel Regression Calculation Uses either of the following inputs for kernel_type: Epanechnikov Logistic Wave
Parameters:
src (float)
bandwidth (int)
kernel_type (string)
waveCalculation(source, bandwidth, width)
Use together with kernelRegression function to get chart applicable band
Parameters:
source (float)
bandwidth (int)
width (float)
Rsi(src, length)
Dynamic RSI function
Parameters:
src (float)
length (int)
dynamicStdev(src, period)
Dynamic SD function
Parameters:
src (float)
period (int)
stdv_bands(src, length, mult)
Dynamic SD Bands
Parameters:
src (float)
length (int)
mult (float)
Returns: Basis, Positive SD, Negative SD
Adx(dilen, adxlen)
Dynamic ADX
Parameters:
dilen (int)
adxlen (int)
Returns: adx
Atr(length)
Dynamic ATR
Parameters:
length (int)
Returns: ATR
Macd(source, fastLength, slowLength, signalSmoothing)
Dynamic MACD
Parameters:
source (float)
fastLength (int)
slowLength (int)
signalSmoothing (int)
Returns: macdLine, signalLine, histogram
ZigZag Library [TradingFinder]🔵 Introduction
The "Zig Zag" indicator is an analytical tool that emerges from pricing changes. Essentially, it connects consecutive high and low points in an oscillatory manner. This method helps decipher price changes and can also be useful in identifying traditional patterns.
By sifting through partial price changes, "Zig Zag" can effectively pinpoint price fluctuations within defined time intervals.
🔵 Key Features
1. Drawing the Zig Zag based on Pivot points :
The algorithm is based on pivots that operate consecutively and alternately (switch between high and low swing). In this way, zigzag lines are connected from a swing high to a swing low and from a swing low to a swing high.
Also, with a very low probability, it is possible to have both low pivots and high pivots in one candle. In these cases, the algorithm tries to make the best decision to make the most suitable choice.
You can control what period these decisions are based on through the "PiPe" parameter.
2.Naming and labeling each pivot based on its position as "Higher High" (HH), "Lower Low" (LL), "Higher Low" (HL), and "Lower High" (LH).
Additionally, classic patterns such as HH, LH, LL, and HL can be recognized. All traders analyzing financial markets using classic patterns and Elliot Waves can benefit from the "zigzag" indicator to facilitate their analysis.
" HH ": When the price is higher than the previous peak (Higher High).
" HL ": When the price is higher than the previous low (Higher Low).
" LH ": When the price is lower than the previous peak (Lower High).
" LL ": When the price is lower than the previous low (Lower Low).
🔵 How to Use
First, you can add the library to your code as shown in the example below.
import TFlab/ZigZagLibrary_TradingFinder/1 as ZZ
Function "ZigZag" Parameters :
🟣 Logical Parameters
1. HIGH : You should place the "high" value here. High is a float variable.
2. LOW : You should place the "low" value here. Low is a float variable.
3. BAR_INDEX : You should place the "bar_index" value here. Bar_index is an integer variable.
4. PiPe : The desired pivot period for plotting Zig Zag is placed in this parameter. For example, if you intend to draw a Zig Zag with a Swing Period of 5, you should input 5.
PiPe is an integer variable.
Important :
Apart from the "PiPe" indicator, which is part of the customization capabilities of this indicator, you can create a multi-time frame mode for the indicator using 3 parameters "High", "Low" and "BAR_INDEX". In this way, instead of the data of the current time frame, use the data of other time frames.
Note that it is better to use the current time frame data, because using the multi-time frame mode is associated with challenges that may cause bugs in your code.
🟣 Setting Parameters
5. SHOW_LINE : It's a boolean variable. When true, the Zig Zag line is displayed, and when false, the Zig Zag line display is disabled.
6. STYLE_LINE : In this variable, you can determine the style of the Zig Zag line. You can input one of the 3 options: line.style_solid, line.style_dotted, line.style_dashed. STYLE_LINE is a constant string variable.
7. COLOR_LINE : This variable takes the input of the line color.
8. WIDTH_LINE : The input for this variable is a number from 1 to 3, which is used to adjust the thickness of the line that draws the Zig Zag. WIDTH_LINE is an integer variable.
9. SHOW_LABEL : It's a boolean variable. When true, labels are displayed, and when false, label display is disabled.
10. COLOR_LABEL : The color of the labels is set in this variable.
11. SIZE_LABEL : The size of the labels is set in this variable. You should input one of the following options: size.auto, size.tiny, size.small, size.normal, size.large, size.huge.
12. Show_Support : It's a boolean variable that, when true, plots the last support line, and when false, disables its plotting.
13. Show_Resistance : It's a boolean variable that, when true, plots the last resistance line, and when false, disables its plotting.
Suggestion :
You can use the following code snippet to import Zig Zag into your code for time efficiency.
//import Library
import TFlab/ZigZagLibrary_TradingFinder/1 as ZZ
// Input and Setting
// Zig Zag Line
ShZ = input.bool(true , 'Show Zig Zag Line', group = 'Zig Zag') //Show Zig Zag
PPZ = input.int(5 ,'Pivot Period Zig Zag Line' , group = 'Zig Zag') //Pivot Period Zig Zag
ZLS = input.string(line.style_dashed , 'Zig Zag Line Style' , options = , group = 'Zig Zag' )
//Zig Zag Line Style
ZLC = input.color(color.rgb(0, 0, 0) , 'Zig Zag Line Color' , group = 'Zig Zag') //Zig Zag Line Color
ZLW = input.int(1 , 'Zig Zag Line Width' , group = 'Zig Zag')//Zig Zag Line Width
// Label
ShL = input.bool(true , 'Label', group = 'Label') //Show Label
LC = input.color(color.rgb(0, 0, 0) , 'Label Color' , group = 'Label')//Label Color
LS = input.string(size.tiny , 'Label size' , options = , group = 'Label' )//Label size
Show_Support= input.bool(false, 'Show Last Support',
tooltip = 'Last Support' , group = 'Support and Resistance')
Show_Resistance = input.bool(false, 'Show Last Resistance',
tooltip = 'Last Resistance' , group = 'Support and Resistance')
//Call Function
ZZ.ZigZag(high ,low ,bar_index ,PPZ , ShZ ,ZLS , ZLC, ZLW ,ShL , LC , LS , Show_Support , Show_Resistance )
Liquidity Finder Library🔵 Introduction
You may intend to utilize the "Liquidity" detection capability in your indicators. Instead of writing it, you can import the "Liquidity Finder" library into your code. One of the advantages of this approach is time-saving and reduction in scripting errors.
🔵 Key Features
Identification of "Statics Liquidity"
Identification of "Dynamics Liquidity"
🔵 How to Use
Firstly, you can add the library to your code as shown in the example below :
import TFlab/LiquidityFinderLibrary/1 as Liq
The parameters of the "LLF" function are as follows :
sPP : A float variable ranging from 0 to 0.4. Increasing this number decreases the sensitivity of the "Statics Liquidity Line Detection" function and increases the number of detected lines. The default value is 0.3.
dPP : A float variable ranging from 0.4 to 1.95. Increasing this number increases the sensitivity of the "Dynamics Liquidity Line Detection" function and decreases the number of detected lines. The default value is 1.
SRs : An int variable. By default, it's set to 8. You can change this number to specify the periodicity of static liquidity pivot lines.
SRd : An int variable. By default, it's set to 3. You can change this number to specify the periodicity of dynamic liquidity pivot lines.
ShowHLLs : A bool variable. You can enable or disable the display of "High Statics Liquidity Line".
ShowLLLs : A bool variable. You can enable or disable the display of "Low Statics Liquidity Line".
ShowHLLd : A bool variable. You can enable or disable the display of "High Dynamics Liquidity Line".
ShowLLd : A bool variable. You can enable or disable the display of "High Dynamics Liquidity Line".
🟣Recommendation
You can use the following code snippet to import Liquidity Finder into your code for time-saving.
//import Library
import TFlab/LiquidityFinderLibrary/1 as Liq
//input
SLLS = input.float(0.30 , 'Statics Liquidity Line Sensitivity', maxval = 0.4 ,minval = 0.0, step = 0.01) // Statics Liquidity Line Sensitivity
DLLS = input.float(1.00 , 'Dynamics Liquidity Line Sensitivity', maxval = 1.95 ,minval = 0.4, step = 0.01) // Dynamics Liquidity Line Sensitivity
SPP = input.int(8 , 'Statics Period Pivot') // Statics Period Pivot
DPP = input.int(3 , 'Dynamics Period Pivot') // Dynamics Period Pivot
ShowSHLL = input.bool(true , 'Show Statics High Liquidity Line')
ShowSLLL = input.bool(true , 'Show Statics Low Liquidity Line')
ShowDHLL = input.bool(true , 'Show Dynamics High Liquidity Line')
ShowDLLL = input.bool(true , 'Show Dynamics Low Liquidity Line')
//call function
Liq.LLF(SPP,DPP,SLLS,DLLS,ShowSHLL,ShowSLLL,ShowDHLL,ShowDLLL)
LTI_FiltersLinear Time-Invariant (LTI) filters are fundamental tools in signal processing that operate with consistent behavior over time and linearly respond to input signals. They are crucial for analyzing and manipulating signals in various applications, ensuring the output signal's integrity is maintained regardless of when an input is applied or its magnitude. The Windowed Sinc filter is a specific type of LTI filter designed for digital signal processing. It employs a Sinc function, ideal for low-pass filtering, truncated and shaped within a finite window to make it practically implementable. This process involves multiplying the Sinc function by a window function, which tapers off towards the ends, making the filter finite and suitable for digital applications. Windowed Sinc filters are particularly effective for tasks like data smoothing and removing unwanted frequency components, balancing between sharp cutoff characteristics and minimal distortion. The efficiency of Windowed Sinc filters in digital signal processing lies in their adept use of linear algebra, particularly in the convolution process, which combines input data with filter coefficients to produce the desired output. This mathematical foundation allows for precise control over the filtering process, optimizing the balance between filtering performance and computational efficiency. By leveraging linear algebra techniques such as matrix multiplication and Toeplitz matrices, these filters can efficiently handle large datasets and complex filtering tasks, making them invaluable in applications requiring high precision and speed, such as audio processing, financial signal analysis, and image restoration.
Library "LTI_Filters"
offset(length, enable)
Calculates the time offset required for aligning the output of a filter with its input, based on the filter's length. This is useful for centered filters where the output is naturally shifted due to the filter's operation.
Parameters:
length (simple int) : The length of the filter.
enable (simple bool) : A boolean flag to enable or dissable the offset calculation.
Returns: The calculated offset if enabled; otherwise, returns 0.
lti_filter(filter_type, source, length, prefilter, centered, fc, window_type)
General-purpose Linear Time-Invariant (LTI) filter function that can apply various filter types to a data series. Can be used to apply a variety of LTI filters with different characteristics to financial data series or other time series data.
Parameters:
filter_type (simple string) : Specifies the type of filter. ("Sinc", "SMA", "WMA")
source (float) : The input data series to filter.
length (simple int) : The length of the filter.
prefilter (simple bool) : Boolean indicating whether to prefilter the input data.
centered (simple bool) : Determines whether the filter coefficients are centered.
fc (simple float) : Filter cutoff. Expressed like a length.
window_type (simple string) : Type of window function to apply. ("Hann", "Hamming", "Blackman", "Triangular", "Lanczos", "None")
Returns: The filtered data series.
lti_sma(source, length, prefilter)
Applies a Simple Moving Average (SMA) filter to the data series. Useful for smoothing data series to identify trends or for use as a component in more complex indicators.
Parameters:
source (float) : The input data series to filter.
length (simple int) : The length of the SMA filter.
prefilter (simple bool) : Boolean indicating whether to prefilter the input data.
Returns: The SMA-filtered data series.
lti_wma(source, length, prefilter, centered)
Applies a Weighted Moving Average (WMA) filter to a data series. Ideal for smoothing data with emphasis on more recent values, allowing for dynamic adjustments to the weighting scheme.
Parameters:
source (float) : The input data series to filter.
length (simple int) : The length of the WMA filter.
prefilter (simple bool) : Boolean indicating whether to prefilter the input data.
centered (simple bool) : Determines whether the filter coefficients are centered.
Returns: The WMA-filtered data series.
lti_sinc(source, length, prefilter, centered, fc, window_type)
Applies a Sinc filter to a data series, optionally using a window function. Particularly useful for signal processing tasks within financial analysis, such as smoothing or trend identification, with the ability to fine-tune filter characteristics.
Parameters:
source (float) : The input data series to filter.
length (simple int) : The length of the Sinc filter.
prefilter (simple bool) : Boolean indicating whether to prefilter the input data.
centered (simple bool) : Determines whether the filter coefficients are centered.
fc (simple float) : Filter cutoff. Expressed like a length.
window_type (simple string) : Type of window function to apply. ("Hann", "Hamming", "Blackman", "Triangular", "Lanczos", "None")
Returns: The Sinc-filtered data series.
ZigZag LibraryThis is yet another ZigZag library.
🔵 Key Features
1. Lightning-Fast Performance : Optimized code ensures minimal lag and swift chart updates.
2. Real-Time Swing Detection : No more waiting for swings to finalize! This library continuously identifies the latest swing formation.
3. Amplitude-Aware : Discover significant swings earlier, even if they haven't reached the standard bar length.
4. Customizable Visualization : Draw ZigZag on-demand using polylines for a tailored analysis experience.
Stay tuned for more features as this library is being continuously enhanced. For the latest updates, please refer to the release information.
🔵 API
// Import this library. Remember to check the latest version of this library and replace the version number below.
import algotraderdev/zigzag/1 as zz
// Initialize the ZigZag instance.
var zz.ZigZag zig = zz.ZigZag.new().init(
zz.Settings.new(
swingLen = 5,
lineColor = color.blue,
lineStyle = line.style_solid,
lineWidth = 1))
// Analyze the ZigZag using the latest bar's data.
zig.tick()
// Draw the ZigZag.
if barstate.islast
zig.draw()
HT: Levels LibLibrary "Levels"
method initialize(id)
Namespace types: levels_collection
Parameters:
id (levels_collection)
method create_level(id, name, value, level_start_bar, level_color, show)
Namespace types: levels_collection
Parameters:
id (levels_collection)
name (string)
value (float)
level_start_bar (int)
level_color (color)
show (bool)
method set_level(id, name, value, level_start_bar, show)
Namespace types: levels_collection
Parameters:
id (levels_collection)
name (string)
value (float)
level_start_bar (int)
show (bool)
method find_resistance(id)
Namespace types: levels_collection
Parameters:
id (levels_collection)
method find_support(id)
Namespace types: levels_collection
Parameters:
id (levels_collection)
method draw_level(id)
Namespace types: level_info
Parameters:
id (level_info)
method draw_all_levels(id)
Namespace types: levels_collection
Parameters:
id (levels_collection)
level_info
Fields:
name (series__string)
value (series__float)
bar_num (series__integer)
level_line (series__line)
line_start_bar (series__integer)
level_color (series__color)
show (series__bool)
ss (series__bool)
sr (series__bool)
levels_collection
Fields:
levels (array__|level_info|#OBJ)
FVG Detector LibraryLibrary "FVG Detector Library"
🔵 Introduction
To save time and improve accuracy in your scripts for identifying Fair Value Gaps (FVGs), you can utilize this library. Apart from detecting and plotting FVGs, one of the most significant advantages of this script is the ability to filter FVGs, which you'll learn more about below. Additionally, the plotting of each FVG continues until either a new FVG occurs or the current FVG is mitigated.
🔵 Definition
Fair Value Gap (FVG) refers to a situation where three consecutive candlesticks do not overlap. Based on this definition, the minimum conditions for detecting a fair gap in the ascending scenario are that the minimum price of the last candlestick should be greater than the maximum price of the third candlestick, and in the descending scenario, the maximum price of the last candlestick should be smaller than the minimum price of the third candlestick.
If the filter is turned off, all FVGs that meet at least the minimum conditions are identified. This mode is simplistic and results in a high number of identified FVGs.
If the filter is turned on, you have four options to filter FVGs :
1. Very Aggressive : In addition to the initial condition, another condition is added. For ascending FVGs, the maximum price of the last candlestick should be greater than the maximum price of the middle candlestick. Similarly, for descending FVGs, the minimum price of the last candlestick should be smaller than the minimum price of the middle candlestick. In this mode, a very small number of FVGs are eliminated.
2. Aggressive : In addition to the conditions of the Very Aggressive mode, in this mode, the size of the middle candlestick should not be small. This mode eliminates more FVGs compared to the Very Aggressive mode.
3. Defensive : In addition to the conditions of the Very Aggressive mode, in this mode, the size of the middle candlestick should be relatively large, and most of it should consist of the body. Also, for identifying ascending FVGs, the second and third candlesticks must be positive, and for identifying descending FVGs, the second and third candlesticks must be negative. In this mode, a significant number of FVGs are eliminated, and the remaining FVGs have a decent quality.
4. Very Defensive : In addition to the conditions of the Defensive mode, the first and third candlesticks should not resemble very small-bodied doji candlesticks. In this mode, the majority of FVGs are filtered out, and the remaining ones are of higher quality.
By default, we recommend using the Defensive mode.
🔵 How to Use
🟣 Parameters
To utilize this library, you need to provide four input parameters to the function.
"FVGFilter" determines whether you wish to apply a filter on FVGs or not. The possible inputs for this parameter are "On" and "Off", provided as strings.
"FVGFilterType" determines the type of filter to be applied to the found FVGs. These filters include four modes: "Very Defensive", "Defensive", "Aggressive", and "Very Aggressive", respectively exhibiting decreasing sensitivity and indicating a higher number of Fair Value Gaps (FVG).
The parameter "ShowDeFVG" is a Boolean value defined as either "true" or "false". If this value is "true", FVGs are shown during the Bullish Trend; however, if it is "false", they are not displayed.
The parameter "ShowSuFVG" is a Boolean value defined as either "true" or "false". If this value is "true", FVGs are displayed during the Bearish Trend; however, if it is "false", they are not displayed.
FVGDetector(FVGFilter, FVGFilterType, ShowDeFVG, ShowSuFVG)
Parameters:
FVGFilter (string)
FVGFilterType (string)
ShowDeFVG (bool)
ShowSuFVG (bool)
🟣 Import Library
You can use the "FVG Detector" library in your script using the following expression:
import TFlab/FVGDetectorLibrary/1 as FVG
🟣 Input Parameters
The descriptions related to the input parameters were provided in the "Parameter" section. In this section, for your convenience, the code related to the inputs is also included, and you can copy and paste it into your script.
PFVGFilter = input.string('On', 'FVG Filter', )
PFVGFilterType = input.string('Defensive', 'FVG Filter Type', )
PShowDeFVG = input.bool(true, ' Show Demand FVG')
PShowSuFVG = input.bool(true, ' Show Supply FVG')
🟣 Call Function
You can copy the following code into your script to call the FVG function. This code is based on the naming conventions provided in the "Input Parameter" section, so if you want to use exactly this code, you should have similar parameter names or have copied the "Input Parameter" values.
FVG.FVGDetector(PFVGFilter, PFVGFilterType, PShowDeFVG, PShowSuFVG)
FibonacciAveragesOscillatorLibraryLibrary "FibonacciAveragesOscillatorLibrary"
The FibonacciAveragesOscillator library provides a streamlined way to analyze market trends using Fibonacci intervals and smoothed averages.
fibAvgOscillator(maxFibNumber, smoothLevel)
Parameters:
maxFibNumber (string) : string: The maximum Fibonacci number to use, affecting analysis depth.
smoothLevel (simple int) : simple int: Smoothing level for the oscillator, higher values produce smoother results.
@return series float: The Fibonacci averages trend oscillator value, smoothed over the specified level.
MLMomentumIndexLibrary "MLMomentumIndex"
Enables market momentum analysis with k-NN predictions on pivot points, offering customizable parameters for dynamic trading strategies.
momentumIndexPivots(source, pivotBars, momentumWindow, maxData, numNeighbors, predictionSmoothing)
Parameters:
source (float)
pivotBars (int)
momentumWindow (int)
maxData (int)
numNeighbors (int)
predictionSmoothing (int)
MLPivotsBreakoutsLibrary "MLPivotsBreakouts"
Utilizes k-NN machine learning to predict breakout zones from pivot points, aiding traders in identifying potential bullish and bearish market movements. Ideal for trend-following and breakout strategies.
breakouts(source, pivotBars, numNeighbors, maxData, predictionSmoothing)
Parameters:
source (float) : series float: Price data for analysis.
pivotBars (int) : int: Number of bars for pivot point detection.
numNeighbors (int) : int: Neighbors count for k-NN prediction.
maxData (int) : int: Maximum pivot data points for analysis.
predictionSmoothing (int) : int: Smoothing period for predictions.
@return : Lower and higher prediction bands plus pivot signal, 1 for ph and -1 for pl.
ATE_Common_Functions_LibraryLibrary "ATE_Common_Functions_Library"
- ATE_Common_Functions_Library was created to assist in constructing CCOMET Scanners
RCI(_rciLength, _source, _interval)
You will see me using this a lot. DEFINITELY my favorite oscillator to utilize for SO many different things from
timing entries/exits to determining trends.Calculation of this indicator based on Spearmans Correlation.
Parameters:
_rciLength (int) : (int)
Amount of bars back to use in RCI calculations.
_source (float) : (float)
Source to use in RCI calculations (can use ANY source series. Ie, open,close,high,low,etc).
_interval (int) : (int)
Optional (if parameter not included, it defaults to 3). RCI calculation groups bars by this amount and then will.
rank these groups of bars.
Returns: (float)
Returns a single RCI value that will oscillates between -100 and +100.
RCIAVG(_rciSMAlen, _source, _interval, firstLength, lastLength)
20 RCI's are averaged together to get this RCI Avg (Rank Correlation Index Average). Each RCI (of the 20 total RCI)
has a progressively LARGER Lookback Length. Rather than having ALL of the RCI Lengths be individually adjustable (because of too many inputs),
I have made the FIRST Length used (smallest Length value in the set) and the LAST Length used (largest length value in the set) be adjustable
and all other 18 Lengths are equally spread out between the 'firstLength' and the 'lastLength'.
Parameters:
_rciSMAlen (int) : (int)
Unlike the Single RCI Function, this function smooths out the end result using an SMA with a length value that is this parameter.
_source (float) : (float)
Source to use in RCI calculations (can use ANY source series. Ie, open,close,high,low,etc).
_interval (int) : (int)
Optional (if parameter not included, it defaults to 3). Within the RCI calculation, bars next to each other are grouped together
and then these groups are Ranked against each other. This parameter is the number of adjacent bars that are grouped together.
firstLength (int) : (int)
Optional (if parameter is not included when the function is called on in the script, then it defaults to 200).
This parameter is the Lookback Length for the 1st RCI used (so the SMALLEST Length used) in the RCI Avg.
lastLength (int) : (int)
Optional (if parameter is not included when the function is called on in the script, then it defaults to 2500).
This parameter is the Lookback Length for the 20th(the LAST) RCI used (so the LARGEST Length used) in the RCI Avg.
***** BEWARE ***** The 'lastLength' must be less than (or possibly equal to) 5000 because Tradingview has capped it at 5000, causing an error.
***** BEWARE ***** If the script gives a compiler "time out" error then the 'lastLength' must be lowered until it no longer times out when compiling.
Returns: (float)
Returns a single RCI value that is the Avg of many RCI values that will oscillate between -100 and +100.
PercentChange(_startingValue, _endingValue)
This is a quick function to calculate how much % change has occurred between the '_startingValue' and the '_endingValue'
that you input into the function.
Parameters:
_startingValue (float) : (float)
The source value to START the % change calculation from.
_endingValue (float) : (float)
The source value to END the % change caluclation from.
Returns: Returns a single output being the % value between 0-100 (with trailing numbers behind a decimal). If you want only
a certain amount of numbers behind the decimal, this function needs to be put within a formatting function to do so.
Rescale(_source, _oldMin, _oldMax, _newMin, _newMax)
Rescales series with a known '_oldMin' & '_oldMax'. Use this when the scale of the '_source' to
rescale is known (bounded).
Parameters:
_source (float) : (float)
Source to be normalized.
_oldMin (int) : (float)
The known minimum of the '_source'.
_oldMax (int) : (float)
The known maximum of the '_source'.
_newMin (int) : (float)
What you want the NEW minimum of the '_source' to be.
_newMax (int) : (float)
What you want the NEW maximum of the '_source' to be.
Returns: Outputs your previously bounded '_source', but now the value will only move between the '_newMin' and '_newMax'
values you set in the variables.
Normalize_Historical(_source, _minimumLvl, _maximumLvl)
Normalizes '_source' that has a previously unknown min/max(unbounded) determining the max & min of the '_source'
FROM THE ENTIRE CHARTS HISTORY. ]
Parameters:
_source (float) : (float)
Source to be normalized.
_minimumLvl (int) : (float)
The Lower Boundary Level.
_maximumLvl (int) : (float)
The Upper Boundary Level.
Returns: Returns your same '_source', but now the value will MOSTLY stay between the minimum and maximum values you set in the
'_minimumLvl' and '_maximumLvl' variables (ie. if the source you input is an RSI...the output is the same RSI value but
instead of moving between 0-100 it will move between the maxand min you set).
Normailize_Local(_source, _length, _minimumLvl, _maximumLvl)
Normalizes series with previously unknown min/max(unbounded). Much like the Normalize_Historical function above this one,
but rather than using the Highest/Lowest Values within the ENTIRE charts history, this on looks for the Highest/Lowest
values of '_source' within the last ___ bars (set by user as/in the '_length' parameter. ]
Parameters:
_source (float) : (float)
Source to be normalized.
_length (int) : (float)
The amount of bars to look back to determine the highest/lowest '_source' value.
_minimumLvl (int) : (float)
The Lower Boundary Level.
_maximumLvl (int) : (float)
The Upper Boundary Level.
Returns: Returns a single output variable being the previously unbounded '_source' that is now normalized and bound between
the values used for '_minimumLvl'/'_maximumLvl' of the '_source' within the user defined lookback period.
convergingpatternsLibrary "convergingpatterns"
Library having implementation of converging chart patterns
getPatternNameByType(patternType)
Returns pattern name based on type
Parameters:
patternType (int) : integer value representing pattern type
Returns: string name of the pattern
method find(this, sProperties, dProperties, patterns, ohlcArray)
find converging patterns for given zigzag
Namespace types: zg.Zigzag
Parameters:
this (Zigzag type from Trendoscope/ZigzagLite/2) : Current zigzag Object
sProperties (ScanProperties) : ScanProperties Object
dProperties (DrawingProperties type from Trendoscope/abstractchartpatterns/5) : DrawingProperties Object
patterns (array type from Trendoscope/abstractchartpatterns/5) : array of existing patterns to check for duplicates
ohlcArray (array type from Trendoscope/ohlc/1) : array of OHLC values for historical reference
Returns: string name of the pattern
ScanProperties
Object containing properties for pattern scanning
Fields:
baseProperties (ScanProperties type from Trendoscope/abstractchartpatterns/5) : Object of Base Scan Properties
convergingDistanceMultiplier (series float) : when multiplied with pattern size gets the max number of bars within which the pattern should converge
basechartpatternsLibrary "basechartpatterns"
Library having complete chart pattern implementation
getPatternNameById(id)
Returns pattern name by id
Parameters:
id (int) : pattern id
Returns: Pattern name
method find(points, properties, dProperties, ohlcArray)
Find patterns based on array of points
Namespace types: chart.point
Parameters:
points (chart.point ) : array of chart.point objects
properties (ScanProperties type from Trendoscope/abstractchartpatterns/1) : ScanProperties object
dProperties (DrawingProperties type from Trendoscope/abstractchartpatterns/1) : DrawingProperties object
ohlcArray (OHLC type from Trendoscope/ohlc/1)
Returns: Flag indicating if the pattern is valid, Current Pattern object
method find(this, properties, dProperties, patterns, ohlcArray)
Find patterns based on the currect zigzag object but will not store them in the pattern array.
Namespace types: zg.Zigzag
Parameters:
this (Zigzag type from Trendoscope/ZigzagLite/2) : Zigzag object containing pivots
properties (ScanProperties type from Trendoscope/abstractchartpatterns/1) : ScanProperties object
dProperties (DrawingProperties type from Trendoscope/abstractchartpatterns/1) : DrawingProperties object
patterns (Pattern type from Trendoscope/abstractchartpatterns/1) : Array of Pattern objects
ohlcArray (OHLC type from Trendoscope/ohlc/1)
Returns: Flag indicating if the pattern is valid, Current Pattern object
abstractchartpatternsLibrary "abstractchartpatterns"
Library having abstract types and methods for chart pattern implementations
checkBarRatio(p1, p2, p3, properties)
checks if three zigzag pivot points are having uniform bar ratios
Parameters:
p1 (chart.point) : First pivot point
p2 (chart.point) : Second pivot point
p3 (chart.point) : Third pivot point
properties (ScanProperties)
Returns: true if points are having uniform bar ratio
getRatioDiff(p1, p2, p3)
gets ratio difference between 3 pivot combinations
Parameters:
p1 (chart.point)
p2 (chart.point)
p3 (chart.point)
Returns: returns the ratio difference between pivot2/pivot1 ratio and pivot3/pivot2 ratio
method inspect(points, stratingBar, endingBar, direction, ohlcArray)
Creates a trend line between 2 or 3 points and validates and selects best combination
Namespace types: chart.point
Parameters:
points (chart.point ) : Array of chart.point objects used for drawing trend line
stratingBar (int) : starting bar of the trend line
endingBar (int) : ending bar of the trend line
direction (float) : direction of the last pivot. Tells whether the line is joining upper pivots or the lower pivots
ohlcArray (OHLC type from Trendoscope/ohlc/1) : Array of OHLC values
Returns: boolean flag indicating if the trend line is valid and the trend line object as tuple
method draw(this)
draws pattern on the chart
Namespace types: Pattern
Parameters:
this (Pattern) : Pattern object that needs to be drawn
Returns: Current Pattern object
method erase(this)
erase the given pattern on the chart
Namespace types: Pattern
Parameters:
this (Pattern) : Pattern object that needs to be erased
Returns: Current Pattern object
method push(this, p, maxItems)
push Pattern object to the array by keeping maxItems limit
Namespace types: Pattern
Parameters:
this (Pattern ) : array of Pattern objects
p (Pattern) : Pattern object to be added to array
@oaram maxItems Max number of items the array can hold
maxItems (int)
Returns: Current Pattern array
method deepcopy(this)
Perform deep copy of a chart point array
Namespace types: chart.point
Parameters:
this (chart.point ) : array of chart.point objects
Returns: deep copy array
DrawingProperties
Object containing properties for pattern drawing
Fields:
patternLineWidth (series int) : Line width of the pattern trend lines
showZigzag (series bool) : show zigzag associated with pattern
zigzagLineWidth (series int) : line width of the zigzag lines. Used only when showZigzag is set to true
zigzagLineColor (series color) : color of the zigzag lines. Used only when showZigzag is set to true
showPatternLabel (series bool) : display pattern label containing the name
patternLabelSize (series string) : size of the pattern label. Used only when showPatternLabel is set to true
showPivotLabels (series bool) : Display pivot labels of the patterns marking 1-6
pivotLabelSize (series string) : size of the pivot label. Used only when showPivotLabels is set to true
pivotLabelColor (series color) : color of the pivot label outline. chart.bg_color or chart.fg_color are the appropriate values.
deleteOnPop (series bool) : delete the pattern when popping out from the array of Patterns.
Pattern
Object containing Individual Pattern data
Fields:
points (chart.point )
originalPoints (chart.point )
trendLine1 (Line type from Trendoscope/LineWrapper/1) : First trend line joining pivots 1, 3, 5
trendLine2 (Line type from Trendoscope/LineWrapper/1) : Second trend line joining pivots 2, 4 (, 6)
properties (DrawingProperties) : DrawingProperties Object carrying common properties
patternColor (series color) : Individual pattern color. Lines and labels will be using this color.
ratioDiff (series float) : Difference between trendLine1 and trendLine2 ratios
zigzagLine (series polyline) : Internal zigzag line drawing Object
pivotLabels (label ) : array containning Pivot labels
patternLabel (series label) : pattern label Object
patternType (series int) : integer representing the pattern type
patternName (series string) : Type of pattern in string
ScanProperties
Object containing properties for pattern scanning
Fields:
offset (series int) : Zigzag pivot offset. Set it to 1 for non repainting scan.
numberOfPivots (series int) : Number of pivots to be used in pattern search. Can be either 5 or 6
errorRatio (series float) : Error Threshold to be considered for comparing the slope of lines
flatRatio (series float) : Retracement ratio threshold used to determine if the lines are flat
checkBarRatio (series bool) : Also check bar ratio are within the limits while scanning the patterns
barRatioLimit (series float) : Bar ratio limit used for checking the bars. Used only when checkBarRatio is set to true
avoidOverlap (series bool) : avoid overlapping patterns.
allowedPatterns (bool ) : array of bool encoding the allowed pattern types.
allowedLastPivotDirections (int ) : array of int representing allowed last pivot direction for each pattern types
themeColors (color ) : color array of themes to be used.
series_collectionLibrary "series_collection"
A personal collection of commonly used series types like moving averages that are supported directly by
the pinescript library ('ALMA', 'DEMA', 'EMA', 'HMA', 'RMA', 'SMA', 'SWMA', 'VWMA', 'WMA'), highest and lowest source,
median and pivots. One single function (with overloads) that can be configured easily by the user input and can be
used as a core piece of functionality for many user cases. This library was created to abstract away and re-use this
commonly used functionality in my "Two MA Signal Indicator" script and the "Template Trailing Strategy" script. Both
of them use the "two_ma_logic" for defining entry and exit signals. While this piece of work does not contain any
novel mathematical expressions and just adds a convinient (and configurable) way to do things, I hope that might add
value to other scripts as well and future projects.
cust_series(length, seriesType, source)
cust_series - Calculate the custom series of the given source for the given length and type
Parameters:
length (simple int) : - The length of the custom series
seriesType (simple string) : - The type of the custom series
source (float) : - The source of the values
Returns: - The resulting value of the calculations of the custom series
cust_series(length, seriesType, source)
cust_series - Calculate the custom series of the given source for the given length and type
Parameters:
length (simple float) : - The length of the custom series (ceiled)
seriesType (simple string) : - The type of the custom series
source (float) : - The source of the values
Returns: - The resulting value of the calculations of the custom series
FunctionsLibrary "Functions"
half_candle()
Half Candles
Returns: half candles (difference between open and close)
super_smoother(source, len)
Ehlers Super Smoother
Parameters:
source (float) : Source
len (int)
Returns: super smoothed moving average
quotient(length, K)
Ehlers early onset trend
Parameters:
length (int) : Length (default = 1)
K (float) : Factor (default = 0.8)
Returns: Ehlers early onset trend
butterworth_2Pole(src, length)
Ehlers 2 Pole Butterworth Filter
Parameters:
src (float) : Source
length (int) : Length
Returns: Ehlers 2 Pole Butterworth Filter
hann_ma(src, length)
Ehler's Hann Moving Average
Parameters:
src (float) : Source
length (int) : Length
Returns: Ehler's Hann Moving Average
oef(src)
Ehlers Optimum Elliptic Filter
Parameters:
src (float) : Source
Returns: Ehlers Optimum Elliptic Filter
moef(src)
Ehlers Modified Optimum Elliptic Filter
Parameters:
src (float) : Source
Returns: Ehlers Modified Optimum Elliptic Filter
arsi(src, length)
Advanced RSI
Parameters:
src (float) : Source
length (simple int) : Length (default = 14)
Returns: ARSI
smoothrng(src, length, multi)
Smooth Range
Parameters:
src (float) : Source
length (simple int) : Length
multi (float) : Multiplikator (default 3.0)
Returns: Smooth Range
