TIME_FRAME

Download script
Author:
TIME_FRAME

This script is designed to act as a sophisticated visual analytical tool for traders who want to understand the structural "geometry" of price action. Rather than using traditional indicators like Moving Averages or RSI, this tool uses a mathematical approach based on Fractal Geometry and Octave Scaling to divide the current trading range into 13 specific zones.

Here is a breakdown of how the logic works in plain English:

1. Identifying the Trading Range

The script begins by looking back at a specific number of previous candles (defined by the "LookBack" setting) to find the highest price point and the lowest price point reached. This establishes the current "playground" or boundaries within which the market is currently moving.

2. Fractal Scaling Logic

Instead of treating all markets the same, the script automatically detects the magnitude of the asset (e.g., whether it is a low-value currency pair or a high-value stock) and chooses an appropriate mathematical "fractal." It then calculates an "Octave"—a specific scale that allows it to mathematically subdivide the price range into consistent proportions.

3. Dynamic Zone Calculation

Once the scale is established, the script performs a series of complex calculations to identify "Key Points" within that range. It isn't just dividing the space equally; it looks for specific mathematical intersections:

  • It calculates several primary and secondary coordinates (referred to in the logic as x-points and y-points).
  • These coordinates represent structural landmarks such as pivots, support levels, resistance zones, and "exhaustion" points.

4. The 13-Zone Visualization

The script takes these calculated mathematical markers and projects them onto your chart as 13 horizontal lines. These lines are categorized into a hierarchy of market conditions:

  • Extreme Zones: The top and bottom lines represent "Overshoots," where the price has moved so far from the norm that it may be reaching an extreme limit.
  • Support and Resistance: The middle lines identify the "Ultimate Support" and "Ultimate Resistance," as well as major pivot points where the market is likely to stall or reverse direction.
  • Actionable Areas: Specific lines are labeled for "Buy Bottoms" (where the price is structurally low) and "Sell Tops" (where the price is structurally high).

5. Visual Feedback

To make this data easy to read, the script provides:

  • Color-Coded Lines: Each of the 13 levels has a unique color to help you distinguish between a "Weak Stall" and a "Major Pivot."
  • On-Screen Labels: Every line is accompanied by a text description (e.g., "Pivot, Reverse," "Ultimate Resistance," or "Extreme Overshoot") so you can understand the mathematical significance of that specific price level instantly.
  • Live Data Display: A text summary appears on your chart showing the raw numbers—like the current High/Low, the Range, and the Octave values—so you can see the exact math driving the lines.

Summary for the User: Think of this tool as a "map" of the current market territory. It automatically measures how big the current move is and then draws 13 "landmarks" on your screen. These landmarks tell you where the price is most likely to find support, where it might face resistance, and which areas represent extreme over-extension.

12 Views
0 Downloads
0 Favorites
TIME_FRAME 
//+------------------------------------------------------------------+
//|                                                   TIME_FRAME.mq4 |
//|                      Copyright © 2006, MetaQuotes Software Corp. |
//|                                        http://www.metaquotes.net |
//+------------------------------------------------------------------+
#property copyright "  "
#property link      "  "
#property indicator_chart_window
//+------------------------------------------------------------------+
//| Define the Variables to use.....                                 |
//+------------------------------------------------------------------+
extern int P = 64;
extern int StepBack = 0;
double  dmml = 0,dvtl = 0,sum  = 0,v1 = 0,v2 = 0,mn = 0,mx = 0,
        x1 = 0,x2 = 0,x3 = 0,x4 = 0,x5 = 0,x6 = 0,y1 = 0,y2 = 0,y3 = 0,y4 = 0,y5 = 0,y6 = 0,
        octave = 0,Octv = 0,fractal = 0,range = 0,finalH  = 0,finalL  = 0,mml[13];
string  ln_txt[13],        
        buff_str = "";
int     bn_v1 = 0,bn_v2 = 0,OctLinesCnt = 13,
        mml_thk = 8,mml_clr[13],mml_shft = 3,
        nTime = 0,CurPeriod = 0,nDigits = 0,i = 0;
//+------------------------------------------------------------------+
//| Setup On-Screen Text                                             |
//+------------------------------------------------------------------+
int init() {
   ln_txt[0]  = "Extreme Overshoot [-2/8]            ";
   ln_txt[1]  = "Overshoot [-1/8]";// "overshoot [-1/8]";
   ln_txt[2]  = "Ultimate Support [0/8]       ";
   ln_txt[3]  = "Weak, Stall & Reverse [1/8]                ";
   ln_txt[4]  = "Pivot, Reverse - major [2/8]              ";
   ln_txt[5]  = "BUY Bottom of Trading Range [3/8]                          ";
   ln_txt[6]  = "Major Support/Resistance  Point [4/8]                          ";
   ln_txt[7]  = "SELL Top of Trading Range [5/8]                     ";
   ln_txt[8]  = "Pivot, Reverse - major [6/8]            ";
   ln_txt[9]  = "Weak, Stall & Reverse [7/8]              ";
   ln_txt[10] = "Ultimate Resistance [8/8]            ";
   ln_txt[11] = "Overshoot [+1/8]";
   ln_txt[12] = "Extreme Overshoot [+2/8]            ";
   mml_shft = 3;mml_thk  = 3;
   //color settings.....  
   mml_clr[0]  = Red;    // [-2]/8
   mml_clr[1]  = OrangeRed;  // [-1]/8
   mml_clr[2]  = DeepSkyBlue;  //  [0]/8
   mml_clr[3]  = Yellow;      //  [1]/8
   mml_clr[4]  = HotPink;     //  [2]/8
   mml_clr[5]  = Lime;  //  [3]/8
   mml_clr[6]  = DeepSkyBlue;  //  [4]/8
   mml_clr[7]  = Lime;  //  [5]/8
   mml_clr[8]  = HotPink;     //  [6]/8
   mml_clr[9]  = Yellow;      //  [7]/8
   mml_clr[10] = DeepSkyBlue;  //  [8]/8
   mml_clr[11] = OrangeRed;  // [+1]/8
   mml_clr[12] = Red;    // [+2]/8
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Code to print On-Screen Lines                                    |
//+------------------------------------------------------------------+
int deinit() {
//---- TODO: add your code here
Comment(" ");   
for(i=0;i<OctLinesCnt;i++) {
    buff_str = "mml"+i;
    ObjectDelete(buff_str);
    buff_str = "mml_txt"+i;
    ObjectDelete(buff_str);
    }
//----
   return(0);
  }
int start() {
//+------------------------------------------------------------------+
//| Define the LookBack Period                                       |
//+------------------------------------------------------------------+
if( (nTime != Time[0]) || (CurPeriod != Period()) ) {
  //price
   bn_v1 = Lowest(NULL,0,MODE_CLOSE,P+StepBack,0);
   bn_v2 = Highest(NULL,0,MODE_CLOSE,P+StepBack,0);
   v1 = Low[bn_v1]; v2 = High[bn_v2];
//+------------------------------------------------------------------+
//| Determine which Fractal to use.....                              |
//+------------------------------------------------------------------+
   if(v2<=250000 && v2>25000) fractal = 100000;
   if(v2<=25000 && v2>2500) fractal = 10000;
   if(v2<=2500 && v2>250) fractal = 1000;
   if(v2<=250 && v2>25) fractal = 100;
   if(v2<=25 && v2>12.5) fractal = 12.5;
   if(v2<=12.5 && v2>6.25) fractal = 12.5;
   if(v2<=6.25 && v2>3.125) fractal = 6.25;
   if(v2<=3.125 && v2>1.5625) fractal = 3.125;
   if(v2<=1.5625 && v2>0.390625) fractal = 1.5625;
   if(v2<=0.390625 && v2>0) fractal = 0.1953125;
// calculating our octave....      
   range=(v2-v1); sum=MathFloor(MathLog(fractal/range)/MathLog(2));
   octave=fractal*(MathPow(0.5,sum)); mn=MathFloor(v1/octave)*octave;
   if((mn+octave)>v2)mx=mn+octave; mx=mn+(2*octave);
// calculating which octave fits best.....
//x2
    if( (v1>=(3*(mx-mn)/16+mn)) && (v2<=(9*(mx-mn)/16+mn)) )
    x2=mn+(mx-mn)/2; 
    else x2=0;
//x1
    if( (v1>=(mn-(mx-mn)/8))&& (v2<=(5*(mx-mn)/8+mn)) && (x2==0) )
    x1=mn+(mx-mn)/2; 
    else x1=0;
//x4
    if( (v1>=(mn+7*(mx-mn)/16))&& (v2<=(13*(mx-mn)/16+mn)) )
    x4=mn+3*(mx-mn)/4; 
    else x4=0;
//x5
    if( (v1>=(mn+3*(mx-mn)/8))&& (v2<=(9*(mx-mn)/8+mn))&& (x4==0) )
    x5=mx; 
    else x5=0;
//x3
    if( (v1>=(mn+(mx-mn)/8))&& (v2<=(7*(mx-mn)/8+mn))&& (x1==0) && (x2==0) && (x4==0) && (x5==0) )
    x3=mn+3*(mx-mn)/4; 
    else x3=0;
//x6
    if( (x1+x2+x3+x4+x5) ==0 )
    x6=mx; 
    else x6=0;
    finalH = x1+x2+x3+x4+x5+x6;
// calculating yy
//y1
    if( x1>0 )
    y1=mn; 
    else y1=0;
//y2
    if( x2>0 )
    y2=mn+(mx-mn)/4; 
    else y2=0;
//y3
    if( x3>0 )
    y3=mn+(mx-mn)/4; 
    else y3=0;
//y4
    if( x4>0 )
    y4=mn+(mx-mn)/2; 
    else y4=0;
//y5
    if( x5>0 )
    y5=mn+(mx-mn)/2; 
    else y5=0;
//y6
    if( (finalH>0) && ((y1+y2+y3+y4+y5)==0) )
    y6=mn; 
    else y6=0;
    finalL = y1+y2+y3+y4+y5+y6;
    for( i=0; i<OctLinesCnt; i++) {
         mml[i] = 0;
         }
// We now have our final Octave for the current timeframe.....         
   dmml = (finalH-finalL)/8;Octv = finalH/(fractal/128);
   Comment("\n","TIMEFRAME","\n","HighClose = ",v2,"\n","LowClose = ",v1,"\n","Range = ",range,"\n","Fractal = ",fractal,"\n","OctMax = ",mx,"\n","OctMin = ",mn,"\n","MxMnRange = ",mx-mn,"\n","Octave 8/8ths = ",finalH,"\n","Octave 0/8ths = ",finalL,"\n","Octave 8ths = ",dmml);
   mml[0] =(finalL-dmml*2); //-2/8
   for( i=1; i<OctLinesCnt; i++) {
        mml[i] = mml[i-1] + dmml;
        }
   for( i=0; i<OctLinesCnt; i++ ){
        buff_str = "mml"+i;
        if(ObjectFind(buff_str) == -1) {
           ObjectCreate(buff_str, OBJ_HLINE, 0, Time[0], mml[i]);
           ObjectSet(buff_str, OBJPROP_STYLE, STYLE_SOLID);
           ObjectSet(buff_str, OBJPROP_WIDTH,2);
           ObjectSet(buff_str, OBJPROP_COLOR, mml_clr[i]);
           ObjectMove(buff_str, 0, Time[0],  mml[i]);
           }
        else {
           ObjectMove(buff_str, 0, Time[0],  mml[i]);
           }
        buff_str = "mml_txt"+i;
        if(ObjectFind(buff_str) == -1) {
           ObjectCreate(buff_str, OBJ_TEXT, 0, Time[mml_shft], mml_shft);
           ObjectSetText(buff_str, ln_txt[i], 10, "Arial", mml_clr[i]);
           ObjectMove(buff_str, 0, Time[mml_shft],  mml[i]);
           }
        else {
           ObjectMove(buff_str, 0, Time[mml_shft],  mml[i]);
           }
        } // for( i=1; i<=OctLinesCnt; i++ ){
   nTime    = Time[0]; CurPeriod= Period();
   }
  return(0);
  }

Similar scripts

Murrey Math Lines F

This indicator utilizes a fractal-based logarithmic scale to segment price action into eight distinct octaves, identifying high-probability support and resistance levels.

Murrey_Math_MT4_VG1

Murrey_Math_MT4_VG1_v1

Murrey_Math_MT4_Even

This indicator utilizes logarithmic fractal scaling to project 13 dynamic price levels that identify major structural pivots, premium zones, and exhaustion points.

Murrey_Math_MT4_VGb

Murrey_Math_MT4_VG1b1

This indicator utilizes fractal geometry and multi-level price partitioning to project 13 distinct support and resistance zones based on market volatility.

Murrey Math Lines F_v1

This indicator utilizes fractal geometry and logarithmic scaling to partition market volatility into eight distinct octaves, identifying precise zones of equilibrium, premium distribution, and major structural pivot points.

MurrayMath_v1

This indicator dynamically projects a multi-level horizontal price grid by calculating the fractal recursive range and identifying pivotal structural boundaries.

Murrey_Math_MT4_VGb_v1

This indicator utilizes fractal geometry and logarithmic scaling to segment market price action into a 13-level octave system, identifying precise pivot points for high-probability trend reversals and structural support zones.

Murrey_Math

This indicator dynamically calculates multi-layered price zones by blending fractal geometry with octaval scaling to identify high-probability pivot points and trading range boundaries.

MurrayMath

This indicator utilizes a fractal-based octave decomposition to segment market volatility into a multi-layered support and resistance grid, identifying specific equilibrium zones and potential reversal pivot points.

Comments