AROON

Download script

To implement the Lowest and Highest methods, we need to first ensure that the arrays are set up correctly with appropriate values for calculating the minimum or maximum. Here's a step-by-step breakdown:

Assumptions:

Array Length: The length of the array is determined by the input count.
Symbol Functionality: We assume Symbol() provides some numeric value that can be adjusted by subtracting PERIOD_CURRENT.
Array Initialization: Arrays are initialized with a specific pattern or values based on the context.
Constants:
- PERIOD_CURRENT is a constant used to adjust values retrieved from Symbol().
- WRONG_VALUE represents an error condition, like when calculations cannot be performed due to incorrect inputs.

Implementation:

#include <vector>
#include <algorithm> // for std::min_element and std::max_element

const int PERIOD_CURRENT = 10; // Example constant value
const double WRONG_VALUE = -1.0e99; // Represents an erroneous or invalid result

double Symbol() {
    // Simulating a function that returns some symbolic numeric value.
    return 100.0; // Placeholder value for demonstration purposes
}

void ArraySetAsSeries(std::vector<double>& array, bool flag) {
    // Assuming this sets up the array in a way it's used later.
    // This is just a placeholder implementation.
    if (flag) {
        double baseValue = Symbol() - PERIOD_CURRENT;
        for (size_t i = 0; i < array.size(); ++i) {
            array[i] = baseValue + static_cast<double>(i); // Example pattern
        }
    }
}

int Highest(const int count, const int start) {
    if (count <= 0 || start < 0) return WRONG_VALUE;

    std::vector<double> array(count);
    ArraySetAsSeries(array, true);

    auto it = std::max_element(array.begin() + start, array.begin() + start + count);
    return (it != array.end()) ? static_cast<int>(*it + start) : WRONG_VALUE;
}

int Lowest(const int count, const int start) {
    if (count <= 0 || start < 0) return WRONG_VALUE;

    std::vector<double> array(count);
    ArraySetAsSeries(array, true);

    auto it = std::min_element(array.begin() + start, array.begin() + start + count);
    return (it != array.end()) ? static_cast<int>(*it + start) : WRONG_VALUE;
}

Key Points:

Validation: We check if count and start are valid to prevent out-of-bounds errors.
Array Initialization: ArraySetAsSeries sets up the array with a specific pattern based on a base value derived from Symbol().
Algorithm: Use std::max_element and std::min_element to find the highest or lowest value within the specified range in the array.
Error Handling: Return WRONG_VALUE if inputs are invalid, ensuring robustness against incorrect usage.

This code assumes you have some mechanism to define PERIOD_CURRENT, and that Symbol() returns a valid numeric type. Adjust these parts as necessary to fit your specific requirements.

Price Data Components

12 Views

0 Downloads

0 Favorites

AROON

ÿþ//+------------------------------------------------------------------+

//|                                                        AROON.mq5 |

//|                        Copyright 2018, MetaQuotes Software Corp. |

//|                                                 https://mql5.com |

//+------------------------------------------------------------------+

#property copyright "Copyright 2018, MetaQuotes Software Corp."

#property link      "https://mql5.com"

#property version   "1.00"

#property description "AROON Indicator"

#property indicator_separate_window

#property indicator_buffers 2

#property indicator_plots   2

//--- plot UP

#property indicator_label1  "Aroon Up"

#property indicator_type1   DRAW_LINE

#property indicator_color1  clrGreen

#property indicator_style1  STYLE_SOLID

#property indicator_width1  1

//--- plot DN

#property indicator_label2  "Aroon down"

#property indicator_type2   DRAW_LINE

#property indicator_color2  clrRed

#property indicator_style2  STYLE_SOLID

#property indicator_width2  1

//--- input parameters

input uint     InpPeriod      =  25;   // Period

input double   InpOverbought  =  70.0; // Overbought

input double   InpOversold    =  30.0; // Oversold

//--- indicator buffers

double         BufferUP[];

double         BufferDN[];

//--- global variables

double         overbought;

double         oversold;

int            period;

//+------------------------------------------------------------------+

//| Custom indicator initialization function                         |

//+------------------------------------------------------------------+

int OnInit()

  {

//--- set global variables

   period=int(InpPeriod<2 ? 2 : InpPeriod);

   oversold=(InpOversold<0 ? 0 : InpOversold>99.9 ? 99.9 : InpOversold);

   overbought=(InpOverbought>100 ? 100 : InpOverbought<0.1 ? 0.1 : InpOverbought);

   if(overbought<=oversold) overbought=oversold+0.1;

   if(oversold>=overbought) oversold=overbought-0.1;

//--- indicator buffers mapping

   SetIndexBuffer(0,BufferUP,INDICATOR_DATA);

   SetIndexBuffer(1,BufferDN,INDICATOR_DATA);

//--- setting indicator parameters

   IndicatorSetString(INDICATOR_SHORTNAME,"AROON ("+(string)period+")");

   IndicatorSetInteger(INDICATOR_DIGITS,Digits());

   IndicatorSetDouble(INDICATOR_MINIMUM,0);

   IndicatorSetInteger(INDICATOR_LEVELS,3);

   IndicatorSetDouble(INDICATOR_LEVELVALUE,0,overbought);

   IndicatorSetDouble(INDICATOR_LEVELVALUE,1,50.0);

   IndicatorSetDouble(INDICATOR_LEVELVALUE,2,oversold);

//--- setting buffer arrays as timeseries

   ArraySetAsSeries(BufferUP,true);

   ArraySetAsSeries(BufferDN,true);

//---

   return(INIT_SUCCEEDED);

  }

//+------------------------------------------------------------------+

//| Custom indicator iteration function                              |

//+------------------------------------------------------------------+

int OnCalculate(const int rates_total,

                const int prev_calculated,

                const datetime &time[],

                const double &open[],

                const double &high[],

                const double &low[],

                const double &close[],

                const long &tick_volume[],

                const long &volume[],

                const int &spread[])

  {

//--- @>25@:0 8 @0AGQB :>;8G5AB20 ?@>AG8BK205<KE 10@>2

   if(rates_total<4) return 0;

//--- @>25@:0 8 @0AGQB :>;8G5AB20 ?@>AG8BK205<KE 10@>2

   int limit=rates_total-prev_calculated;

   if(limit>1)

     {

      limit=rates_total-1;

      ArrayInitialize(BufferUP,EMPTY_VALUE);

      ArrayInitialize(BufferDN,EMPTY_VALUE);

     }



//---  0AGQB 8=48:0B>@0

   for(int i=limit; i>=0 && !IsStopped(); i--)

     {

      int MinBar=Lowest(period,i);

      int MaxBar=Highest(period,i);

      if(MinBar==WRONG_VALUE || MaxBar==WRONG_VALUE)

         continue;

      BufferUP[i]=100.*(period-MaxBar+i)/period;

      BufferDN[i]=100.*(period-MinBar+i)/period;

     }



//--- return value of prev_calculated for next call

   return(rates_total);

  }

//+------------------------------------------------------------------+

//| >72@0I05B 8=45:A <0:A8<0;L=>3> 7=0G5=8O B09<A5@88 High          |

//+------------------------------------------------------------------+

int Highest(const int count,const int start)

  {

   double array[];

   ArraySetAsSeries(array,true);

   return(CopyHigh(Symbol(),PERIOD_CURRENT,start,count,array)==count ? ArrayMaximum(array)+start : WRONG_VALUE);

  }

//+------------------------------------------------------------------+

//| >72@0I05B 8=45:A <8=8<0;L=>3> 7=0G5=8O B09<A5@88 Low            |

//+------------------------------------------------------------------+

int Lowest(const int count,const int start)

  {

   double array[];

   ArraySetAsSeries(array,true);

   return(CopyLow(Symbol(),PERIOD_CURRENT,start,count,array)==count ? ArrayMinimum(array)+start : WRONG_VALUE);

   return WRONG_VALUE;

  }

//+------------------------------------------------------------------+

AROON

Assumptions:

Implementation:

Key Points:

Similar scripts

Comments

Privacy Settings

Customize Cookie Preferences

Essential Cookies Required

Analytics & Performance

Advertising & Personalization

User Data Collection