MathEasingFunctionsLibrary   "MathEasingFunctions" 
A collection of Easing functions.
Easing functions are commonly used for smoothing actions over time, They are used to smooth out the sharp edges
of a function and make it more pleasing to the eye, like for example the motion of a object through time.
Easing functions can be used in a variety of applications, including animation, video games, and scientific 
simulations. They are a powerful tool for creating realistic visual effects and can help to make your work more 
engaging and enjoyable to the eye.
---
Includes functions for ease in, ease out, and, ease in and out, for the following constructs:
sine, quadratic, cubic, quartic, quintic, exponential, elastic, circle, back, bounce.
---
Reference:
easings.net
learn.microsoft.com
 ease_in_sine_unbound(v) 
  Sinusoidal function, the position over elapsed time (unbound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_in_sine(v) 
  Sinusoidal function, the position over elapsed time (bound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_out_sine_unbound(v) 
  Sinusoidal function, the position over elapsed time (unbound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_out_sine(v) 
  Sinusoidal function, the position over elapsed time (bound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_in_out_sine_unbound(v) 
  Sinusoidal function, the position over elapsed time (unbound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_in_out_sine(v) 
  Sinusoidal function, the position over elapsed time (bound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_in_quad_unbound(v) 
  Quadratic function, the position equals the square of elapsed time (unbound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_in_quad(v) 
  Quadratic function, the position equals the square of elapsed time (bound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_out_quad_unbound(v) 
  Quadratic function, the position equals the square of elapsed time (unbound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_out_quad(v) 
  Quadratic function, the position equals the square of elapsed time (bound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_in_out_quad_unbound(v) 
  Quadratic function, the position equals the square of elapsed time (unbound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_in_out_quad(v) 
  Quadratic function, the position equals the square of elapsed time (bound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_in_cubic_unbound(v) 
  Cubic function, the position equals the cube of elapsed time (unbound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_in_cubic(v) 
  Cubic function, the position equals the cube of elapsed time (bound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_out_cubic_unbound(v) 
  Cubic function, the position equals the cube of elapsed time (unbound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_out_cubic(v) 
  Cubic function, the position equals the cube of elapsed time (bound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_in_out_cubic_unbound(v) 
  Cubic function, the position equals the cube of elapsed time (unbound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_in_out_cubic(v) 
  Cubic function, the position equals the cube of elapsed time (bound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_in_quart_unbound(v) 
  Quartic function, the position equals the formula `f(t)=t^4` of elapsed time (unbound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_in_quart(v) 
  Quartic function, the position equals the formula `f(t)=t^4` of elapsed time (bound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_out_quart_unbound(v) 
  Quartic function, the position equals the formula `f(t)=t^4` of elapsed time (unbound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_out_quart(v) 
  Quartic function, the position equals the formula `f(t)=t^4` of elapsed time (bound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_in_out_quart_unbound(v) 
  Quartic function, the position equals the formula `f(t)=t^4` of elapsed time (unbound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_in_out_quart(v) 
  Quartic function, the position equals the formula `f(t)=t^4` of elapsed time (bound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_in_quint_unbound(v) 
  Quintic function, the position equals the formula `f(t)=t^5` of elapsed time (unbound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_in_quint(v) 
  Quintic function, the position equals the formula `f(t)=t^5` of elapsed time (bound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_out_quint_unbound(v) 
  Quintic function, the position equals the formula `f(t)=t^5` of elapsed time (unbound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_out_quint(v) 
  Quintic function, the position equals the formula `f(t)=t^5` of elapsed time (bound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_in_out_quint_unbound(v) 
  Quintic function, the position equals the formula `f(t)=t^5` of elapsed time (unbound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_in_out_quint(v) 
  Quintic function, the position equals the formula `f(t)=t^5` of elapsed time (bound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_in_expo_unbound(v) 
  Exponential function, the position equals the exponential formula of elapsed time (unbound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_in_expo(v) 
  Exponential function, the position equals the exponential formula of elapsed time (bound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_out_expo_unbound(v) 
  Exponential function, the position equals the exponential formula of elapsed time (unbound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_out_expo(v) 
  Exponential function, the position equals the exponential formula of elapsed time (bound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_in_out_expo_unbound(v) 
  Exponential function, the position equals the exponential formula of elapsed time (unbound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_in_out_expo(v) 
  Exponential function, the position equals the exponential formula of elapsed time (bound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_in_circ_unbound(v) 
  Circular function, the position equals the circular formula of elapsed time (unbound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_in_circ(v) 
  Circular function, the position equals the circular formula of elapsed time (bound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_out_circ_unbound(v) 
  Circular function, the position equals the circular formula of elapsed time (unbound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_out_circ(v) 
  Circular function, the position equals the circular formula of elapsed time (bound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_in_out_circ_unbound(v) 
  Circular function, the position equals the circular formula of elapsed time (unbound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_in_out_circ(v) 
  Circular function, the position equals the circular formula of elapsed time (bound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_in_back_unbound(v) 
  Back function, the position retreats a bit before resuming (unbound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_in_back(v) 
  Back function, the position retreats a bit before resuming (bound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_out_back_unbound(v) 
  Back function, the position retreats a bit before resuming (unbound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_out_back(v) 
  Back function, the position retreats a bit before resuming (bound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_in_out_back_unbound(v) 
  Back function, the position retreats a bit before resuming (unbound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_in_out_back(v) 
  Back function, the position retreats a bit before resuming (bound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_in_elastic_unbound(v) 
  Elastic function, the position oscilates back and forth like a spring (unbound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_in_elastic(v) 
  Elastic function, the position oscilates back and forth like a spring (bound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_out_elastic_unbound(v) 
  Elastic function, the position oscilates back and forth like a spring (unbound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_out_elastic(v) 
  Elastic function, the position oscilates back and forth like a spring (bound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_in_out_elastic_unbound(v) 
  Elastic function, the position oscilates back and forth like a spring (unbound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_in_out_elastic(v) 
  Elastic function, the position oscilates back and forth like a spring (bound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_in_bounce_unbound(v) 
  Bounce function, the position bonces from the boundery (unbound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_in_bounce(v) 
  Bounce function, the position bonces from the boundery (bound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_out_bounce_unbound(v) 
  Bounce function, the position bonces from the boundery (unbound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_out_bounce(v) 
  Bounce function, the position bonces from the boundery (bound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_in_out_bounce_unbound(v) 
  Bounce function, the position bonces from the boundery (unbound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 ease_in_out_bounce(v) 
  Bounce function, the position bonces from the boundery (bound).
  Parameters:
     v (float) : `float` Elapsed time.
  Returns: Ratio of change.
 select(v, formula, effect, bounded) 
  Parameters:
     v (float) 
     formula (string) 
     effect (string) 
     bounded (bool)
MASA
Sessions - AlgoLabA script in UTC for London, New York, Tokyo, & Sydney sessions. 
Recommended on any timeframe < 1H.
---
Using this script, a box is plotted on the opening candle of each session; this can show us valuable areas on each chart where price may mediate to show a standing move.
You may also select each of the session boxes, in the settings; this will show you a box of the opening, low, high, and close of each selected sessions.
Each and all boxes are closed at the end of each session.
-The script produces a time table that will show you when each session occurs, and if the current time is within one of those sessions.
---
On this chart you can see boxes formed on the opening candles of the sessions, 
London is red, New York is blue, Sydney is green, Tokyo is yellow.
-A key point to notice, before using this script, is how price may mediate around each box, before causing a move.
-Some boxes may be larger / smaller than others, due to the size of the opening candle. 
---
Lots of updates to come, any recommendations? Feel free to leave a comment. 
Hope it helps, enjoy!
FX Sessions & Killzones ETJust another sessions indicator. Among all the many existing ones, I didn't find anything simple that would cover my needs and that would actually be correct.
New York time is forced here for plotting the stripes so you don't need to worry about the time zone currently set on your chart. The indicator will be accurate during Daylight Saving Time (which, in 2023 for example, started on Sunday, 12 March , 02:00:00 and will be in effect until Sunday, 5 November, 02:00:00).
ICT Algorithmic Macro Tracker° (Open-Source) by toodegreesDescription: 
The ICT Algorithmic Macro Tracker° Indicator is a powerful tool designed to enhance your trading experience by clearly and efficiently plotting the known ICT Macro Times on your chart. 
Based on the teachings of the  Inner Circle Trader , these Time windows correspond to periods when the Interbank Price Delivery Algorithm undergoes a series of checks ( Macros ) and is probable to move towards Liquidity. 
The indicator allows traders to visualize and analyze these crucial moments in NY Time: 
- 2:33-3:00 
- 4:03-4:30
- 8:50-9:10
- 9:50-10:10
- 10:50-11:10
- 11:50-12:10
- 13:10-13:50
- 15:15-15:45
By providing a clean and clutter-free representation of ICT Macros, this indicator empowers traders to make more informed decisions, optimize and build their strategies based on Time.
Massive shoutout to @reastruth for his  ICT Macros Indicator , and for allowing to create one of my own, go check him out!
 Indicator Features: 
– Track ongoing ICT Macros to aid your Live analysis.
- Gain valuable insights by hovering over the plotted ICT Macros to reveal tooltips with interval information.
– Plot the ICT Macros in one of two ways:
 "On Chart":  visualize ICT Macro timeframes directly on your chart, with automatic adjustments as Price moves.
  
 Pro Tip: toggle Projections to see exactly where Macros begin and end without difficulty. 
 "New Pane":  move the indicator two a New Pane to see both Live and Upcoming Macro events with ease in a dedicated section
  
 Pro Tip: this section can be collapsed by double-clicking on the main chart, allowing for seamless trading preparation. 
 This indicator is available only on the TradingView platform. 
⚠️ Open Source ⚠️
Coders and TV users are authorized to copy this code base, but a paid distribution is prohibited. A mention to the original author is expected, and appreciated.
⚠️ Terms and Conditions ⚠️
This financial tool is for educational purposes only and not financial advice. Users assume responsibility for decisions made based on the tool's information. Past performance doesn't guarantee future results. By using this tool, users agree to these terms.
AstroLibLibrary "AstroLib", or Astro Library, is a collection of public Pinescript functions & calculations for use in astrology & astronomy indicators. Unless noted otherwise, this library was written jointly by @badsector666 and @BarefootJoey.
Library   "AstroLib" 
 t_(txt) 
  Parameters:
     txt (string) 
 JDNv2(t, withFraction) 
  Parameters:
     t (float) 
     withFraction (bool) 
 J2K(t) 
  Parameters:
     t (float) 
 J2KtoUnix(TimeInJDN) 
  Parameters:
     TimeInJDN (float) 
 atan2(y, x) 
  Parameters:
     y (float) 
     x (float) 
 DegSin(x) 
  Parameters:
     x (float) 
 DegCos(x) 
  Parameters:
     x (float) 
 DegTan(x) 
  Parameters:
     x (float) 
 DegArcsin(x) 
  Parameters:
     x (float) 
 DegArccos(x) 
  Parameters:
     x (float) 
 DegArctan(x) 
  Parameters:
     x (float) 
 DegAtan2(y, x) 
  Parameters:
     y (float) 
     x (float) 
 range2pi(x) 
  Parameters:
     x (float) 
 range360(x) 
  Parameters:
     x (float) 
 gst(days) 
  Parameters:
     days (float) 
 DegDecimal(Degrees, Minutes, Seconds) 
  Parameters:
     Degrees (float) 
     Minutes (float) 
     Seconds (float) 
 Rectangular(R, theta, phi, Index) 
  Parameters:
     R (float) 
     theta (float) 
     phi (float) 
     Index (float) 
 rLength(x, y, z) 
  Parameters:
     x (float) 
     y (float) 
     z (float) 
 spherical(x, y, z, Index) 
  Parameters:
     x (float) 
     y (float) 
     z (float) 
     Index (float) 
 obliquity(d) 
  Parameters:
     d (float) 
 requatorial(x, y, z, d, Index) 
  Parameters:
     x (float) 
     y (float) 
     z (float) 
     d (float) 
     Index (float) 
 recliptic(x, y, z, d, Index) 
  Parameters:
     x (float) 
     y (float) 
     z (float) 
     d (float) 
     Index (float) 
 sequatorial(R, theta, phi, d, Index) 
  Parameters:
     R (float) 
     theta (float) 
     phi (float) 
     d (float) 
     Index (float) 
 secliptic(R, theta, phi, d, Index) 
  Parameters:
     R (float) 
     theta (float) 
     phi (float) 
     d (float) 
     Index (float) 
 precess(d1, d2, DEC, RA, Index, ddec, dra) 
  Parameters:
     d1 (float) 
     d2 (float) 
     DEC (float) 
     RA (float) 
     Index (float) 
     ddec (float) 
     dra (float) 
 riset(J2000, DEC, RA, GLat, GLong, Index) 
  Parameters:
     J2000 (float) 
     DEC (float) 
     RA (float) 
     GLat (float) 
     GLong (float) 
     Index (float) 
 ssun(d, Index) 
  Parameters:
     d (float) 
     Index (float) 
 rsun(d, Index) 
  Parameters:
     d (float) 
     Index (float) 
 sun(d, Index) 
  Parameters:
     d (float) 
     Index (float) 
 SunLongitude(d, Index) 
  Parameters:
     d (float) 
     Index (float) 
 Sunrise(J2000, GLat, GLong, Index, altitudex) 
  Parameters:
     J2000 (float) 
     GLat (float) 
     GLong (float) 
     Index (float) 
     altitudex (float) 
 smoon(dx, Index) 
  Parameters:
     dx (float) 
     Index (float) 
 rmoon(d, Index) 
  Parameters:
     d (float) 
     Index (float) 
 tmoon(d, GLat, GLong, Index) 
  Parameters:
     d (float) 
     GLat (float) 
     GLong (float) 
     Index (float) 
 moon(d, Index) 
  Parameters:
     d (float) 
     Index (float) 
 Element(d, pnum) 
  Parameters:
     d (float) 
     pnum (int) 
 kepler(m, ecc, eps) 
  Parameters:
     m (float) 
     ecc (float) 
     eps (float) 
 rplanet(d, pnumber, Index) 
  Parameters:
     d (float) 
     pnumber (int) 
     Index (float) 
 planet(d, pnumber, Index) 
  Parameters:
     d (float) 
     pnumber (int) 
     Index (float) 
 altaz(d, DEC, RA, GLat, GLong, Index) 
  Parameters:
     d (float) 
     DEC (float) 
     RA (float) 
     GLat (float) 
     GLong (float) 
     Index (float) 
 prise(d, P, GLat, GLong, Index) 
  Parameters:
     d (float) 
     P (int) 
     GLat (float) 
     GLong (float) 
     Index (float) 
 MoonSize(d) 
  Parameters:
     d (float) 
 Refraction(Temperature_C, Atmospheric_Pressure_mBar, Altitude_Deg) 
  Parameters:
     Temperature_C (float) 
     Atmospheric_Pressure_mBar (float) 
     Altitude_Deg (float) 
 MoonRise(d, Longitude, Latitude, Index) 
  Parameters:
     d (float) 
     Longitude (float) 
     Latitude (float) 
     Index (float) 
 f_to_sec(dec) 
  Parameters:
     dec (float) 
 f_to_time(sec) 
  Parameters:
     sec (float) 
 deg_to_time(deg) 
  Parameters:
     deg (float) 
 toDMS(coordinate) 
  Parameters:
     coordinate (float) 
 convertDMS(lat, lng) 
  Parameters:
     lat (float) 
     lng (float) 
 convlatdec(deg) 
  Parameters:
     deg (float) 
 PlanetName(pnum) 
  Parameters:
     pnum (int) 
 PlanetNameV(pnum) 
  Parameters:
     pnum (int) 
 PlanetSign(pnum) 
  Parameters:
     pnum (int) 
 PlanetColor(pnum) 
  Parameters:
     pnum (int) 
 zodiaccolor(deg) 
  Parameters:
     deg (float) 
 degsign(deg) 
  Parameters:
     deg (float) 
 degsignf(deg) 
  Parameters:
     deg (float) 
 degnash(deg) 
  Parameters:
     deg (float) 
 degname(deg) 
  Parameters:
     deg (float) 
 retrogradesym(deg) 
  Parameters:
     deg (float) 
 degaspsign(deg) 
  Parameters:
     deg (float) 
 degaspname(deg) 
  Parameters:
     deg (float) 
 degaspfull(deg) 
  Parameters:
     deg (float) 
 degaspfullV2(deg) 
  Parameters:
     deg (float) 
 degaspnameV2(deg) 
  Parameters:
     deg (float) 
 degtolowest180(deg) 
  Parameters:
     deg (float) 
 degaspfullapproach(deg) 
  Parameters:
     deg (float) 
 virinchiaspectcol(deg, bull_col, bear_col) 
  Parameters:
     deg (float) 
     bull_col (color) 
     bear_col (color) 
 virinchiaspectemo(deg, bull_emo, bear_emo) 
  Parameters:
     deg (float) 
     bull_emo (string) 
     bear_emo (string) 
 aspectfastsigndeg(deg) 
  Parameters:
     deg (float) 
 aspectfastfull(deg) 
  Parameters:
     deg (float) 
 aspectslowfull(deg) 
  Parameters:
     deg (float) 
 aspectslowsigndeg(deg) 
  Parameters:
     deg (float) 
 aspectslowsign(deg) 
  Parameters:
     deg (float) 
 aspectsignprecision(deg, precision) 
  Parameters:
     deg (float) 
     precision (int) 
 aspectsignprecisionV2(deg, precision) 
  Parameters:
     deg (float) 
     precision (float) 
 aspectsignprecisionV2ext(deg, precision) 
  Parameters:
     deg (float) 
     precision (float) 
 IPaspectsignprecision(planet1, planet2, precision) 
  Parameters:
     planet1 (float) 
     planet2 (float) 
     precision (float) 
 IPaspectsignprecisionFull(planet1, planet2, precision) 
  Parameters:
     planet1 (float) 
     planet2 (float) 
     precision (float) 
 IPaspectlineprecision(planet1, planet2, precision, style, width) 
  Parameters:
     planet1 (float) 
     planet2 (float) 
     precision (float) 
     style (string) 
     width (int) 
 rDeg(deg) 
  Parameters:
     deg (float) 
 AngToCirc(angle) 
  Parameters:
     angle (float) 
 AngToCirc180(angle) 
  Parameters:
     angle (float) 
 sidereal(deg, sidereal) 
  Parameters:
     deg (float) 
     sidereal (bool) 
 J2000(JDN) 
  Parameters:
     JDN (float) 
 JDN(t, d, tz) 
  Parameters:
     t (float) 
     d (float) 
     tz (float) 
 getsun(index, day, dayr, latitude, longitude, tz) 
  Parameters:
     index (int) 
     day (float) 
     dayr (float) 
     latitude (float) 
     longitude (float) 
     tz (float) 
 getmoon(index, day, dayr, latitude, longitude) 
  Parameters:
     index (int) 
     day (float) 
     dayr (float) 
     latitude (float) 
     longitude (float) 
 getplanet(planet, index, day, dayr, latitude, longitude, tz) 
  Parameters:
     planet (int) 
     index (int) 
     day (float) 
     dayr (float) 
     latitude (float) 
     longitude (float) 
     tz (float)
Day of Week - Volatility Report█ OVERVIEW 
The indicator analyses the volatility and reports statistics by the days of the week.
 █ CONCEPTS 
On business days and weekends, different market participants get involved in the markets. How does this affect the markets during the week?
Here are some ideas to explore:
 
  When are the best days for trading?
  Which day of the week is the market the most volatile?
  Should you trade on business days? Is it worth trading during the weekend?
  How does this relate to your most profitable trades?
  Is there a confluence with the days having the highest win rate?
  Which days of the week should you stop trading? 
 
  
 Ethereum 
  
 USDCAD 
  
 NZDUSD 
 █ FEATURES 
 Configurable outputs 
Output the report statistics as mean or median.
 █ HOW TO USE 
Plot the indicator and visit the 1D, 24H, or 1440 minutes timeframe.
 █ NOTES 
 Gaps 
The indicator includes the volatility  from gaps. 
 Calculation 
The statistics are not reported from absolute prices (does not favor trending markets) nor percentage prices (does not depict the different periods of  volatility  that markets can go through). Instead, the script uses the prices relative to the average range of previous weeks (weekly ATR).
 Trading session 
The indicator analyses weekdays from the daily chart, defined by the exchange trading session (see Symbol Info).
 Extended trading session 
The indicator can include the extended hours when activated on the chart, using the 24H or 1440 minutes timeframe.
 Overnight session 
The indicator supports overnight sessions (open and close on different calendar days). For example, EURUSD will report Monday’s volatility from Sunday open at 17:00 to Monday close at 17:00.
This is a PREMIUM indicator. In complement, you might find useful my free  Time of Day - Volatility Report .
Highest/Lowest value since X time ago, various indicatorsThis script will count the bars back since the last time the current bar indicator value was either this low or this high.
It will provide the time in either, seconds, minutes, hours, days, weeks, months, or years.
please note:
There are currently no alerts setup for this script.
the length options only apply to the sources that have the "(MA)" in their name.
There is a horizontal line display issue which corrects once you adjust the amount of sources you want to use.
Once you select the amount of sources you would like to use, align the indicator so the horizontal lines match up with the table lines.
If find any bugs in the script, let me know.
Time of Day - Volatility Report█ OVERVIEW 
The indicator analyses the  volatility  and reports statistics by the time of day.
 █ CONCEPTS 
Around the world and at various times, different market participants get involved in the markets. How does this affect the market?
Knowing this gets you better prepared and improves your trading. Here are some ideas to explore:
 
  When is the market busy and quiet?
  What time is it the most volatile?
  Which pairs in your watchlist are moving while you are actively trading?
  Should you adjust your trading time? Should you change your trading pairs?
  When does your strategy perform the best?
  What entry times do your winners have in common? What about the exit times of your losers?
  Is it worth keeping your trade open overnight?
 
  
 Bitcoin (UTC+0) 
  
 Gold (UTC+0) 
  
 Tesla, Inc. (UTC+0) 
 █ FEATURES 
 Selectable time zones 
Display the statistics in your geographical time zone (or other market participants), the exchange time zone, or UTC+0. 
 Configurable outputs 
Output the report statistics as mean or median.
 █ HOW TO USE 
Plot the indicator and visit the 1H timeframe.
 █ NOTES 
 Gaps 
The indicator includes the volatility  from gaps. 
 Calculation 
The statistics are not reported from absolute prices (does not favor trending markets) nor percentage prices (does not depict the different periods of  volatility that markets can go through). Instead, the script uses the prices relative to the average range of previous days (daily ATR).
 Extended trading session 
The script analyses extended hours when activated on the chart.
 Daylight Saving Time (DST) 
The exchange time or geographical time zone selected may observe Daylight Saving Time. For example,  NASDAQ:TSLA  always opens at 9:30 AM New York time but may see different opening times in another part of the globe (New York time corresponds to UTC-4 and UTC-5 during the year).
ICT MacrosThis script allows traders to visualize the range of time when a macro (an automated series of instructions/trades from large fund traders, executed by an algorithm) will likely occur in the market. It does this by drawing vertical lines and labels on the chart at these specific times:
(Macro Open) - 9:50 AM EST
(Macro Close) - 10:10 AM EST
(Macro Open) - 10:50 AM EST
(Macro Close) - 11:10 AM EST
(Macro Open) - 1:10 PM EST
(Macro Close) - 1:40 PM EST
(Macro Open) - 3:15 PM EST
(Macro Close) - 3:45 PM EST
The theory behind the use of these macros - is that the market will either seek buy side or sell side liquidity, or seek to rebalance price at a point of interest in between the open and close of the macro. Traders who follow this theory can use that information to anticipate how price might behave.
When a macro occurs, the script draws a vertical line on the chart using a dotted line style with a user-defined color. Additionally, a label is placed above the line to indicate whether it is a Macro Open or Macro Close event.
To preserve space, the labels are abbreviated on chart - "Macro Open" (M.O.) and "Macro Close" (M.C.) for both the morning and afternoon trading sessions. The labels may be turned on/off by the user.
The script also includes alerts that can notify traders when a macro occurs. These alerts can be set to go off once per bar close, and the alert message indicates the specific macro type and time.
This script is entirely open-source, meaning that traders can read the code and modify it as needed. Credit to the foundation of this script goes to TradingView user @rickyzcarroll for his open source Strat Assistant Hour Flip script. Important changes include the specific time changes and alert function.
 
FrizLabz_Time_Utility_MethodsLibrary   "FrizLabz_Time_Utility_Methods" 
Some time to index and index to time helper methods made them for another library thought I would try to make
them as methods
 UTC_helper(utc) 
  UTC helper function this adds the + to the positive utc times, add "UTC" to the string
       and can be used in the timezone arg of for format_time()
  Parameters:
     utc : (int) | +/- utc offset
  Returns: string | string to be added to the timezone paramater for utc timezone usage
 bar_time(bar_amount) 
  from a time to index
  Parameters:
     bar_amount : (int) | default - 1)
  Returns: int bar_time
 time_to_index(_time) 
  from time to bar_index
  Parameters:
     _time : (int) 
  Returns: int time_to_index | bar_index that corresponds to time provided
 time_to_bars_back(_time) 
  from a time quanity to bar quanity for use with  .
  Parameters:
     _time : (int) 
  Returns: int bars_back | yeilds the amount of bars from current bar to reach _time provided
 bars_back_to_time(bars_back) 
  from bars_back to time
  Parameters:
     bars_back 
  Returns: int | using same logic as   this will return the 
                    time of the bar = to the bar that corresponds to   bars_back
 index_time(index) 
  bar_index to UNIX time
  Parameters:
     index : (int) 
  Returns: int time | time in unix that corrresponds to the bar_index
 to_utc(time_or_index, timezone, format) 
  method to use with a time or bar_index variable that will detect if it is an index or unix time
       and convert it to a printable string
  Parameters:
     time_or_index : (int) required) | time in unix or bar_index
     timezone : (int) required) | utc offset to be appled to output
     format : (string) | default - "yyyy-MM-dd'T'HH:mm:ssZ") | the format for the time, provided string is 
                                     default one from str.format_time()
  Returns: string | time formatted string
 GET(line) 
  Gets the location paramaters of a Line
  Parameters:
     line : (line)
  Returns: tuple  
 GET(box) 
  Gets the location paramaters of a Box
  Parameters:
     box : (box)
  Returns: tuple  
 GET(label) 
  Gets the location paramaters and text of a Label
  Parameters:
     label : (label)
  Returns: tuple  
 GET(linefill) 
  Gets line 1 and 2 from a Linefill
  Parameters:
     linefill : (linefill)
  Returns: tuple  
 Format(line, timezone) 
  converts Unix time in time or index params to formatted time
       and returns a tuple of the params as string with the time/index params formatted
  Parameters:
     line : (line) | required
     timezone : (int) | default - na
  Returns: tuple  
 Line(x1, y1, x2, y2, extend, color, style, width) 
  similar to line.new() with the exception
       of not needing to include y2 for a flat line, y1 defaults to close, 
       and it doesnt require xloc.bar_time or xloc.bar_index, if no x1
  Parameters:
     x1 : (int) default - time
     y1 : (float) default - close
     x2 : (int) default - last_bar_time/last_bar_index | not required for line that ends on current bar
     y2 : (float) default - y1 | not required for flat line
     extend : (string) default - extend.none | extend.left, extend.right, extend.both
     color : (color) default - chart.fg_color
     style : (string) default - line.style_solid | line.style_dotted, line.style_dashed, 
                                  line.style_arrow_both, line.style_arrow_left, line.style_arrow_right
     width 
  Returns: line
 Box(left, top, right, bottom, extend, border_color, bgcolor, text_color, border_width, border_style, txt, text_halign, text_valign, text_size, text_wrap) 
  similar to box.new() but only requires top and bottom to create box,
       auto detects if it is bar_index or time used in the (left) arg. xloc.bar_time and xloc.bar_index are not used
       args are ordered by purpose | position -> colors -> styling -> text options
  Parameters:
     left : (int) default - time 
     top : (float) required 
     right : (int) default - last_bar_time/last_bar_index | will default to current bar index or time 
                                  depending on (left) arg
     bottom : (float) required
     extend : (string) default - extend.none | extend.left, extend.right, extend.both
     border_color : (color) default - chart.fg_color
     bgcolor : (color) default - color.new(chart.fg_color,75)
     text_color : (color) default - chart.bg_color
     border_width : (int) default - 1 
     border_style : (string) default - line.style_solid | line.style_dotted, line.style_dashed, 
     txt : (string) default - ''
     text_halign : (string) default - text.align_center | text.align_left, text.align_right
     text_valign : (string) default - text.align_center | text.align_top, text.align_bottom 
     text_size : (string) default - size.normal | size.tiny, size.small, size.large, size.huge 
     text_wrap : (string) default - text.wrap_auto | text.wrap_none
  Returns: box
 Label(x, y, txt, yloc, color, textcolor, style, size, textalign, text_font_family, tooltip) 
  similar to label.new() but only requires no args to create label,
       auto detects if it is bar_index or time used in the (x) arg. xloc.bar_time and xloc.bar_index are not used
       args are ordered by purpose | position -> colors -> styling -> text options
  Parameters:
     x : (int) default - time
     y : (float) default - high or low | depending on bar direction
     txt : (string) default - ''
     yloc : (string) default - yloc.price | yloc.price, yloc.abovebar, yloc.belowbar
     color : (color) default - chart.fg_color
     textcolor : (color) default - chart.bg_color
     style : (string) default - label.style_label_down | label.style_none
                                  label.style_xcross,label.style_cross,label.style_triangleup,label.style_triangledown
                                  label.style_flag, label.style_circle, label.style_arrowup, label.style_arrowdown, 
                                  label.style_label_up, label.style_label_down, label.style_label_left, label.style_label_right, 
                                  label.style_label_lower_left, label.style_label_lower_right, label.style_label_upper_left, 
                                  label.style_label_upper_right, label.style_label_center, label.style_square, 
                                  label.style_diamond
     size : (string) default - size.normal | size.tiny, size.small, size.large, size.huge
     textalign : (string) default - text.align_center | text.align_left, text.align_right
     text_font_family : (string) default - font.family_default | font.family_monospace
     tooltip : (string) default - na
  Returns: label
HTF Bar Close CountdownThis simple indicator displays a countdown for the amount of time left until a bar of your chosen timeframe closes.
Displays up to 5 different HTF countdowns.
Fully Customizable to fit any style, change the text colors, background colors, frame colors, display size and border & frame widths. 
Flat display option for a sleek look to mesh with your charts.
 Notes/Tips: 
 
 Higher Time Frames only! This is only intended to view HTF countdowns, will not work when trying to use a timeframe lower than your current chart's.
 Some weird timeframes do not work, you'll know when.
 Only works on live charts! Will display "Closed" when on an inactive chart.
 Does not work for replay! A countdown is pretty pointless on a replay that is not real-time anyways...
 
Enjoy!
Trading Day and Time SessionThis script provides options for the user to choose:
- Start date and End date
- Trade time during a day (With UTC offset)
- Which days of the week to trade
It return a condition if all the date and time conditions are true. It's very easy to integrate with any script. 
 
Chart Time and Price Range It is easy to loose track of time and price volatility when the chart automatically scales to the bars on the chart. This helps you keep track. 
This is a very simple indicator that is designed to ensure that you're looking at a segment of the chart that is relevant to the trade you're considering in both price distance and time. 
 The Problem: 
When looking at a chart the lowest price is at the bottom of the screen, the highest price is at the top. The time at the beginning of the chart is based on how many bars and what timeframe you're looking at.
But is the price difference between the two wide or narrow? Are you seeing minutes, hours, or days of price action? 
You can get the measure tool out, but you'll change the zoom level and now its different. You change the timeframe and its different. 
 This Solution: 
This indicator puts a table on the screen that will tell you the X/Y distance of everything that is on your chart. If your hold period is 5 minutes, why would you be looking at 3 days of price action to find s/r or make a decision on a trade? 
This will show you how much price opportunity was available in the amount of time you are currently viewing. Using the PineCoders VisibleChart library, we're retrieving the time and bar_index of the beginning of the chart so that everything that is currently on the chart is measured and it adapts as that changes. 
It will work with light and dark themes (you can change the colors) and can be positioned wherever you prefer to see the information. 
Disclaimer: This was a quick release script. I wrote it and published the same day. There could be bugs, so send me a message or add a comment to report anything that isn't behaving correctly.
ISODateTimeLibrary   "ISODateTime" 
 getDateParts(dateStr) 
  Get year, month, day from date string.
  Parameters:
     dateStr :  : ISO 8601 format, i.e. "2022-05-04T14:00:00.001000-04:00" or "2022-05-04T14:00:00Z"
  Returns: array of int  
 getTimeParts(dateStr) 
  Get hour, minute, seconds from date string.
  Parameters:
     dateStr :  : ISO 8601 format, i.e. "2022-05-04T14:00:00.001000-04:00" or "2022-05-04T14:00:00Z"
  Returns: array of int  
 getUTCTimezone(dateStr) 
  Get UTC timezone.
  Parameters:
     dateStr :  : ISO 8601 format, i.e. "2022-05-04T14:00:00.001000-04:00" or "2022-05-04T14:00:00Z"
  Returns: string UTC timezone
Time Zone / Market SessionsTime Zone / Market Sessions indicator is a handy tool to display current major Market Open / Close condition along with present time at that Exchange. Sydney, Tokyo, London, New York market sessions are included. Clear display of Overlap Zones and Kill Zones.. Can be used to estimate market Pumping and Dumping. Alerts can be set when a market opens.
 
 Time is Displayed in Table Layout
 Active Market is displayed as Dots on top and bottom
 You can select as Timeline or Table display
 Overlap is clearly displayed on top and bottom without any mess
  Gray color in Table layout Shows Closed Markets
 You are free to reuse this code No Limitations.
 Kill Zones are indicated in Table format. When some of the markets are closed
 Alerts included for market openings
 
Day Trading Booster by DGTTiming when day trading can be everything 
In  Stock markets  typically more volatility (or price activity) occurs at market opening and closings  
 
When it comes to  Forex  (foreign exchange market),  the world’s most traded market, unlike other financial markets, there is no centralized marketplace, currencies trade over the counter in whatever market is open at that time, where time becomes of more importance and key to get better trading opportunities. There are four major forex trading sessions, which are  Sydney ,  Tokyo ,  London  and  New York  sessions 
Forex market is traded 24 hours a day, 5 days a week across by banks, institutions and individual traders worldwide, but that doesn’t mean it’s always active the entire day.  It may be very difficult time trying to make money when the market doesn’t move at all. The busiest times with highest trading volume occurs during the overlap of the London and New York trading sessions, because U.S. dollar (USD) and the Euro (EUR) are the two most popular currencies traded. Typically most of the trading activity for a specific currency pair will occur when the trading sessions of the individual currencies overlap. For example, Australian Dollar (AUD) and Japanese Yen (JPY) will experience a higher trading volume when both Sydney and Tokyo sessions are open
There is one influence that impacts Forex matkets and should not be forgotten : the release of the significant news and reports. When a major announcement is made regarding economic data, currency can lose or gain value within a matter of seconds
 Cryptocurrency markets  on the other hand remain open 24/7, even during public holidays
Until 2021, the Asian impact was so significant in Cryptocurrency markets but recent reasearch reports shows that those patterns have changed and the correlation with the U.S. trading hours is becoming a clear evolving trend. 
Unlike any other market Crypto doesn’t rest on weekends, there’s a drop-off in participation and yet algorithmic trading bots and market makers (or liquidity providers) can create a high volume of activity. Never trust the weekend’ is a good thing to remind yourself
One more factor that needs to be taken into accout is Blockchain transaction fees, which are responsive to network congestion and can change dramatically from one hour to the next
In general, Cryptocurrency markets are highly volatile, which means that the price of a coin can change dramatically over a short time period in either direction
 The Bottom Line 
The more traders trading, the higher the trading volume, and the more active the market. The more active the market, the higher the liquidity (availability of counterparties at any given time to exit or enter a trade), hence the tighter the spreads (the difference between ask and bid price) and the less slippage (the difference between the expected fill price and the actual fill price) - in a nutshell, yield to many good trading opportunities and better order execution (a process of filling the requested buy or sell order)
The best time to trade is when the market is the most active and therefore has the largest trading volume, trading all day long will not only deplete a trader's reserves quickly, but it can burn out even the most persistent trader. Knowing when the markets are more active will give traders peace of mind, that opportunities are not slipping away when they take their eyes off the markets or need to get a few hours of sleep
 What does the Day Trading Booster do? 
Day Trading Booster is designed ;
  - to assist in determining market peak times, the times where better trading opportunities may arise
  - to assist in determining the probable trading opportunities
  - to help traders create their own strategies. An example strategy of when to trade or not is presented below
For Forex markets specifically includes
  - Opening channel of Asian session, Europien session or both  
  - Opening price, opening range (5m or 15m) and day (session) range of the major trading center sessions, including Frankfurt
  - A tabular view of the major forex markets oppening/closing hours, with a countdown timer
  - A graphical presentation of typically traded volume and various forext markets oppening/clossing events (not only the major markets but many other around the world)
For All type of markets Day Trading Booster plots 
   - Day (Session) Open, 5m, 15m or 1h Opening Range 
   - Day (Session) Referance Levels, based on Average True Range (ATR) or Previous Day (Session) Range (PH - PL)
   - Week and Month Open
Day Trading Booster also includes some of the day trader's preffered indicaotrs, such as ;
   - VWAP - A custom interpretaion of VWAP is presented here with Auto, Interactive and Manual anchoring options. 
   - Pivot High/Low detection - Another custom interpretation of Pivot Points High Low indicator.  
   - A Moving Average with option to choose among SMA, EMA, WMA and HMA
 An example strategy - Channel Bearkout Strategy 
When day trading a trader usually monitors/analyzes lower timeframe charts and from time to time may loose insight of what really happens on the market from higher time porspective.  Do not to forget to look at the larger time frame (than the one chosen to trade with) which gives the bigger picture of market price movements and thus helps to clearly define the trend
 Disclaimer : Trading success is all about following your trading strategy and the indicators should fit within your trading strategy, and not to be traded upon solely
The script is for informational and educational purposes only. Use of the script does not constitutes professional and/or financial advice. You alone the sole responsibility of evaluating the script output and risks associated with the use of the script. In exchange for using the script, you agree not to hold dgtrd TradingView user liable for any possible claim for damages arising from any decision you make based on use of the script
SFC Smart Money Manipulation - Time, Advanced Market StructureThis indicator shows the market structure in more advanced way and different time cycles.
Markets moves in cycles and swings. The indicator will help to determine these cycles and swings by time and price. These are the two columns of the market understanding. The third one is volume/ momentum, but it will not be discussed here.
 Advanced Market Structure 
According to ICT and Larry Williams Market Structure is not only Highs and Lows. 
They present more advanced understanding of the MS:
-Short Term Highs/ Lows
-Intermediate  Term Highs/ Lows
-Long Term Highs/ Lows
Rules of how to determine the Swing Points according to Larry Williams:
"A market has made a short-term low when we have a day (or bar if you are using different time periods) that has a higher low on both sides. By the same token a short-term high will be a day (or bar) that has lower bars on both sides of it."
"A short-term high with lower short-term highs on both sides is an intermediate- term high. By the same token, a short-term low with higher short-term lows on both sides is an intermediate-term low."
"An intermediate-term high with lower intermediate-term highs on both sides of it is just naturally a long-term high by our definition, thanks to understanding market structure.
An intermediate-term low with higher intermediate-term lows on both sides of it is just naturally a long-term low by our definition, thanks to understanding market structure."
If the Highs and Lows are labeled properly there is  high probability to predict the next High or Low. In this way the trader will know how the current trend is changing and what kind of retracement is coming - deep or shallow.
 Timing 
Market moves in time cycles. 
There is a theory that the swings are equal by time and length. This is not always the case, but very very often.
Indicator time features:
- Swing Trading days - how many time market needed to form a swing. Only Long term(main) Swings are measured. This will help trader to label T-formations.
     " T Formations is cyclically related for formations that can be drawn to project the time frame of likely turning points. Basically T-formations are based on the concept that the time distance between the starting low/high of the cyclical wave and its peak is likely to be subsequently repeated between that peak and the final low/high of that cycle."
- Seasonality - theoretically an asset should go up or down in particular yearly quarter. Practically the direction not always match to quarters. Thats why the indicator shows the theoretical seasonal direction and historical real direction.
     Seasonal direction is automatically displayed or XAUUSD, XAGUSD, EURUSD, AUDUSD, GBPUSD. There is a ways to set the seasonality manually.
- Earnings Season - This time is very important for Stocks and Indices. Most of the time the assets are in bullish trend during the Earnings Seasons.
- Monthly separator - Shows the monthly time cycle
- Gold bullish months - There are studies on Gold market. They shows that Gold is very bullish in particular months. These are displayed.
The indicator works only on Daily Time Frame.
Estimated Time At Price [Kioseff Trading]Hello!
This script uses the same formula as the recently released "Volume Delta" script to ascertain lower timeframe values.
Instead, this script looks to estimate the approximate time spent at price blocks; all time estimates are in minute.second format. 
  
The image above shows functionality. Time spent at price levels/blocks are estimated in duration. The highest estimated block is the highlighted level and a POC line is extended right until violated. Colors, the presence of POC lines and whether they're removed subsequent violation are all configurable.
  
As show in the image above, the data is displayable in an additional format. When select the "non-classic" format shown above - precise price levels are calculated and the estimated time spent at those levels is summed and displayed right of the current bar. The off-colored level (yellow in the example) denotes the price level encompassing the highest *estimated* time spent. 
You can deselect the neon effect and choose to have the script recalculate after any conceivable amount of time has passed.
The script can also calculate for the most current bar should you configure it to do so.
That's all! (for now). A quick/easy script building off an existing foundation. 
If you've any ideas for features and ways to "spice up" this script please let me know (: I'll gladly incorporate requests.
Thank you! 
New Trading DayThis indicator creates an alert for a new trading day - as well as contains a variable that counts the number of bars that has passed since the trading day opened. 
It posts the alert both on the chart and has an alert condition so it can be sent to you. 
Time_FilterLibrary   "Time_Filter" 
Time filters for trading strategies.
 f_isInWeekDay(_timeZone, _byWeekDay, _byMon, _byTue, _byWed, _byThu, _byFri, _bySat, _bySun) 
  f_isInWeekDay - Filter by week day or by time delimited session.
  Parameters:
     _timeZone : - Time zone to use when filter allowed trading by days of the week.
     _byWeekDay : - Filter allowed trading time by days of the week.
     _byMon : - Is Monday a trading day?
     _byTue : - Is Tuesday a trading day?
     _byWed : - Is Wednesday a trading day?
     _byThu : - Is Thursday a trading day?
     _byFri : - Is Friday a trading day?
     _bySat : - Is Saturday a trading day?
     _bySun : - Is Sunday a trading day?
  Returns: series of bool whether or not the time is inside the current day.
 f_isInSession(_timeZone, _bySession_1, _timeSession_1, _bySession_2, _timeSession_2) 
  f_isInSession - Is the current time with in the allowed trading session time.
  Parameters:
     _timeZone : - Time zone to use when filter allowed trading by days of the week.
     _bySession_1 : - Filter allowed trading time with in hours defined in _timeSession_1
     _timeSession_1 : - Hours with in trading is allowed.
     _bySession_2 : - Filter allowed trading time with in hours defined in _timeSession_2
     _timeSession_2 : - Hours with in trading is allowed.
  Returns: series of bool whether or not the time is inside selected session.
 f_isTradingAllowed(_timeZone, _byWeekDay, _byMon, _byTue, _byWed, _byThu, _byFri, _bySat, _bySun, _bySession_1, _timeSession_1, _bySession_2, _timeSession_2) 
  f_isTradingAllowed - Is the current time with in the allowed.
  Parameters:
     _timeZone : - Time zone to use when filter allowed trading by days of the week.
     _byWeekDay : - Filter allowed trading time by days of the week.
     _byMon : - Is Monday a trading day?
     _byTue : - Is Tuesday a trading day?
     _byWed : - Is Wednesday a trading day?
     _byThu : - Is Thursday a trading day?
     _byFri : - Is Friday a trading day?
     _bySat : - Is Saturday a trading day?
     _bySun : - Is Sunday a trading day?
     _bySession_1 : - Filter allowed trading time with in hours defined in _timeSession_1
     _timeSession_1 : - Hours with in trading is allowed.
     _bySession_2 : - Filter allowed trading time with in hours defined in _timeSession_2
     _timeSession_2 : - Hours with in trading is allowed.
  Returns: series of bool whether or not trading is allowed at the current time.
[VTaL] Vertical Time Alert Lines - By BlueJayBird🦾 USE
- Vertical lines drawn ON TOP of chart at selected key times of the day, week, month, year.
- You can use it at any symbol (as far as I know).
- Programmatic alerts available.
- Lines from lower time-frames are selectively NOT visible at higher time-frames. Example: At 1h time-frame, vertical lines from 1h and 4h intervals are not visible. Drawing them is considered not really useful.
🎭 MAIN FEATURES
- Available targeted times: 3m, 15m, 1h, 4h, 1D, 1W, 1M, 1Y.
- Offset available for all lines. Example: 1 offset for 4h moves lines from 4AM to 8AM.
- Programmatic alerts for all lines. Example: If alert is enabled for 15m lines, every time those lines are reached, alert will trigger.
- Available drawing themes: Custom, Light, Dark.
💻 NOTES ON CODE
- Vertical lines are drawn using a custom function, which uses line.new() built-in function.
- Alerts are triggered using ta.cross() built-in function. Alert is triggered when close price crosses a given time value from the line.get_x1() built-in function.
- I've added, where necessary, several comments to the code for understanding what's going on. If you have additional questions, you may ask them in the comment section of the publication.
- 3m lines are not really useful in day-trading, they were added for debugging purposes mainly. Useful for learning how to use alerts, though.
👉🏼 NOTES ON ALERTS
- When setting up an alert, the targeted line must be enabled/visible.
- Every time any alert is enabled or disabled, you must create AGAIN the alert from the "Alerts" panel (remember, alerts run in the back-end).
- Alerts contain really useful information. If you have any idea for adding some other data, tell in the comment section. 💡
⚠️ KNOWN ISSUES
- None. Let me know please if you find any.
--------------------------------------------
~ Comment , Follow and Boost ~ 🚀
SetSessionTimesIndiaLibrary   "SetSessionTimesIndia" 
This library might be useful to code an indicator or strategy that requires to call Indian trading sessions at NSE and MCX.
 SetSessionTimes()






















