AROON

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

2 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;

  }

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

Comments

Markdown supported. Formatting help

Markdown Formatting Guide

Element	Markdown Syntax
Heading	`# H1 ## H2 ### H3`
Bold	`bold text`
Italic	`italicized text`
Link	`[title](https://www.example.com)`
Image	`![alt text](image.jpg)`
Code	`code`
Code Block	``` code block ```
Quote	`> blockquote`
Unordered List	`- Item 1 - Item 2`
Ordered List	`1. First item 2. Second item`
Horizontal Rule	`---`

AROON

Assumptions:

Implementation:

Key Points:

Similar scripts

Comments

Markdown Formatting Guide