Análisis técnico - Cálculo del Indicador Aroon Serie

Question

Estoy tratando de construir una clase para crear Aroon de la serie. Pero parece que no entienden los pasos bien. No estoy seguro acerca de cuál es el propósito que tengo que utilizar el parámetro del periodo.

Aquí está mi primer intento:

/// <summary>
/// Aroon
/// </summary>
public class Aroon : IndicatorCalculatorBase
{
    public override List<Ohlc> OhlcList { get; set; }
    public int Period { get; set; }

    public Aroon(int period) 
    {
        this.Period = period;
    }

    /// <summary>
    /// Aroon up: {((number of periods) - (number of periods since highest high)) / (number of periods)} x 100
    /// Aroon down: {((number of periods) - (number of periods since lowest low)) / (number of periods)} x 100
    /// </summary>
    /// <see cref="http://www.investopedia.com/ask/answers/112814/what-aroon-indicator-formula-and-how-indicator-calculated.asp"/>
    /// <returns></returns>
    public override IIndicatorSerie Calculate()
    {
        AroonSerie aroonSerie = new AroonSerie();

        int indexToProcess = 0;

        while (indexToProcess < this.OhlcList.Count)
        {
            List<Ohlc> tempOhlc = this.OhlcList.Skip(indexToProcess).Take(Period).ToList();
            indexToProcess += tempOhlc.Count;

            for (int i = 0; i < tempOhlc.Count; i++)
            {   
                int highestHighIndex = 0, lowestLowIndex = 0;
                double highestHigh = tempOhlc.Min(x => x.High), lowestLow = tempOhlc.Max(x => x.Low);
                for (int j = 0; j < i; j++)
                {
                    if (tempOhlc[j].High > highestHigh)
                    {
                        highestHighIndex = j;
                        highestHigh = tempOhlc[j].High;
                    }

                    if (tempOhlc[j].Low < lowestLow)
                    {
                        lowestLowIndex = j;
                        lowestLow = tempOhlc[j].Low;
                    }
                }

                int up = ((this.Period - (i - highestHighIndex)) / this.Period) * 100;
                aroonSerie.Up.Add(up);

                int down = ((this.Period - (i - lowestLowIndex)) / this.Period) * 100;
                aroonSerie.Down.Add(down);
            }
        }

        return aroonSerie;
    }
}

Hay alguien trató de hacer que antes? Aquí está un par de puntos de referencia sobre el indicador:

• http://www.investopedia.com/ask/answers/112814/what-aroon-indicator-formula-and-how-indicator-calculated.asp
• http://www.investopedia.com/articles/trading/06/aroon.asp
• http://stockcharts.com/school/doku.php?id=chart_school:technical_indicators:aroon

Answer 1

Me respondió @Anilca la pregunta ASÍ (y la respuesta fue aceptada)

Voy a resumir mi respuesta con la solución de trabajo:

public class Aroon : IndicatorCalculatorBase
{

    public override List<OhlcSample> OhlcList { get; set; }
    private readonly int _period;

    public int Period
    {
        get { return _period; }
    }

    public Aroon(int period)
    {
        _period = period;
    }

    public override IIndicatorSerie Calculate()
    {
        var aroonSerie = new AroonSerie();
        for (var i = _period; i < OhlcList.Count; i++)
        {

            var aroonUp = CalculateAroonUp(i);
            var aroonDown = CalculateAroonDown(i);

            aroonSerie.Down.Add(aroonDown);
            aroonSerie.Up.Add(aroonUp);
        }

        return aroonSerie;
    }

    private double CalculateAroonUp(int i)
    {
        var maxIndex = FindMax(i - _period, i);

        var up = CalcAroon(i - maxIndex);

        return up;
    }

    private double CalculateAroonDown(int i)
    {
        var minIndex = FindMin(i - _period, i);

        var down = CalcAroon(i - minIndex);

        return down;
    }

    private double CalcAroon(int numOfDays)
    {
        var result = ((_period - numOfDays)) * ((double)100 / _period);
        return result;
    }

    private int FindMin(int startIndex, int endIndex)
    {
        var min = double.MaxValue;
        var index = startIndex;
        for (var i = startIndex; i <= endIndex; i++)
        {
            if (min < OhlcList[i].Low)
                continue;

            min = OhlcList[i].Low;
            index = i;
        }
        return index;
    }

    private int FindMax(int startIndex, int endIndex)
    {
        var max = double.MinValue;
        var index = startIndex;
        for (var i = startIndex; i <= endIndex; i++)
        {
            if (max > OhlcList[i].High)
                continue;

            max = OhlcList[i].High;
            index = i;
        }
        return index;
    }
}

P. S

Chicos, yo generalmente activa en ASÍ que... si alguien necesita aclaraciones, por favor pregunte en el origen de la pregunta (y se sienten libres para hacer esto)

Answer 2

 public class Aroon
    {
        public bool AroonDown
        {
            get;
            set;
        }
        public double Period
        {
            get;
            set;
        }
        public Aroon()
        {
        }
        public Aroon(double period)
        {
            Period = period;
        }
        public IList<double> Execute(IList<double> src)
        {
            if (!this.AroonDown)
            {
                return this.ExecuteUp(src);
            }
            return this.ExecuteDown(src);
        }
        public IList<double> ExecuteDown(IList<double> src)
        {
            double[] period = new double[src.Count];
            for (int i = 0; i < src.Count; i++)
            {
                double num = IndUtil.LowestBarNum(src, i, Period);
                period[i] = 100 * (Period - num) / Period;
            }
            return period;
        }
        public IList<double> ExecuteUp(IList<double> src)
    {
        double[] period = new double[src.Count];
        for (int i = 0; i < src.Count; i++)
        {
            double num = IndUtil.HighestBarNum(src, i, Period);
            period[i] = 100 * ((Period - num) / Period);
        }
        return period;
    }
    }

    public class IndUtil
    {
      public static double  HighestBarNum(IList<double> src, int i, double Period)
        {
             int maxIndex = -1;
         double maxValue = Double.MinValue; // Immediately overwritten anyway

            int index = 0;

            int srccount = src.Count();
            var mincount = Math.Min(i + Period, srccount);

            for (int k = i; k < mincount; k++)
            {
                double value = src[k];
                if (value.CompareTo(maxValue) > 0 || maxIndex == -1)
                {
                    maxIndex = index;
                    maxValue = value;
                }
                index++;
            }
            return maxIndex;
        }
      public static double LowestBarNum(IList<double> src, int i, double Period)
      {
          int minIndex = -1;
          double minValue = Double.MaxValue; // Immediately overwritten anyway

          int index = 0;


           int srccount=src.Count();
           var mincount = Math.Min(i + Period, srccount);
          for (int k = i; k < mincount; k++)
          {

              double value = src[k];
              if (value.CompareTo(minValue) < 0 || minIndex == -1)
              {
                  minIndex = index;
                  minValue = value;
              }
              index++;
          }
          return minIndex;
      }
    }

Answer 3

AROON Indicador es una función integrada en el TA-lib, debe probarlo primero en vez de aplicar a ti mismo.