Horizontal Volume Profile

    /**
     * Získa počet elementov potrebných na výpočet hodnoty prvého elementu.
     *
     * @return
     *   Vráti počet elementov potrebných na výpočet hodnoty prvého elementu.
     */
    @Override public int getLookback() {
        /*
         * Dokumentácia:
         *   IIndicator => http://www.dukascopy.com/wiki/#IIndicator_interface/Method_getLookback
         */

        return Math.max(intOptIns[ OPT_IN_RISING_PERIOD ], intOptIns[ OPT_IN_CLIMAX_PERIOD ]) - 1;
    }

    /**
     * Vypočíta hodnoty indikátora.
     *
     * @param
     *   firstIndex Prvý index v zoskupení vstupných elementov.
     * @param
     *   lastIndex Posledný index v zoskupení vstupných elementov.
     * @param
     *   isOfferSideChanged Zmenila sa ponuková strana na danom grafe?
     * @param
     *   isPeriodChanged Zmenil sa časový rámec na danom grafe?
     * @param
     *   isInstrumentChanged Zmenil sa obchodovaný nástroj na danom grafe?
     * @param
     *   isFeedChanged Zmenila sa ponuková strana, časový rámec alebo obchodovaný
     *   nástroj na danom grafe?
     * @param
     *   isNewBar Vytvorila sa nová sviečka na danom grafe?
     * @param
     *   isVisibleNewBar Vytvorila sa viditeľne nová sviečka na danom grafe?
     * @param
     *   isFirstCalculation Jedná sa o úplne prvý výpočet indikátora na danom grafe?
     * @return
     *   Vráti počet elementov na výstupe.
     */
    @Override protected int calculate(int firstIndex, int lastIndex, boolean isOfferSideChanged, boolean isPeriodChanged, boolean isInstrumentChanged, boolean isFeedChanged, boolean isNewBar, boolean isVisibleNewBar, boolean isFirstCalculation) {
        /*
         * Dokumentácia:
         *   IIndicator => http://www.dukascopy.com/wiki/#IIndicator_interface/Method_calculate
         */

        numOfCalculations++;

        if (!boolOptIns[ OPT_IN_DISPLAY ]) {
            return lastIndex - firstIndex + 1;
        }

        /**
         * Počet elementov na výstupe.
         */
        int numOfElems = 0;

        /**
         * Hlavné zoskupenie vstupných elementov.
         */
        IBar[] ins = getOfferSide().equals(OfferSide.ASK) ? barIns[ IN_ASK ] : barIns[ IN_BID ];

        /**
         * Vyšší časový rámec.
         */
        int higherPeriod = Math.max(intOptIns[ OPT_IN_RISING_PERIOD ], intOptIns[ OPT_IN_CLIMAX_PERIOD ]);

        /**
         * @var
         *   int inIndex Index v zoskupení vstupných elementov.
         * @var
         *   int outIndex Index v zoskupení výstupných elementov.
         */
        for (int inIndex = lastIndex, outIndex = lastIndex - firstIndex ; inIndex >= firstIndex ; inIndex--, outIndex--, numOfElems++) {
            /**
             * Index na strane ponuky v zoskupení vstupných elementov.
             */
            int askInIndex = getOfferSide().equals(OfferSide.ASK) ? inIndex : getTimedIndex(ins[ inIndex ].getTime(), barIns[ IN_ASK ]);

            /**
             * Index na strane dopytu v zoskupení vstupných elementov.
             */
            int bidInIndex = getOfferSide().equals(OfferSide.BID) ? inIndex : getTimedIndex(ins[ inIndex ].getTime(), barIns[ IN_BID ]);

            doubleOuts[ OUT_LINE_OF_ASK_VOLUME ][ outIndex ] = 0;
            doubleOuts[ OUT_LINE_OF_BID_VOLUME ][ outIndex ] = 0;
            doubleOuts[ OUT_LINE_OF_VOLUME     ][ outIndex ] = 0;

            if (askInIndex == -1 || bidInIndex == -1) {
                continue;
            }

            /**
             * Celkový objem uskutočnených obchodov.
             */
            double totalVolume = barIns[ IN_ASK ][ askInIndex ].getVolume() + barIns[ IN_BID ][ bidInIndex ].getVolume();

            /**
             * Priemerný objem uskutočnených obchodov.
             */
            double averageVolume = 0;

            /**
             * Najvyššia vrcholiaca hodnota.
             */
            double highestVal = 0;

            doubleOuts[ OUT_LINE_OF_ASK_VOLUME ][ outIndex ] =  barIns[ IN_ASK ][ askInIndex ].getVolume();
            doubleOuts[ OUT_LINE_OF_BID_VOLUME ][ outIndex ] = -barIns[ IN_BID ][ bidInIndex ].getVolume();
            doubleOuts[ OUT_LINE_OF_VOLUME     ][ outIndex ] =  totalVolume;

            /**
             * Predchádzajúci index v zoskupení vstupných elementov.
             *
             * @var
             *   int prevInIndex
             */
            for (int prevInIndex = inIndex - 1 ; prevInIndex > inIndex - higherPeriod ; prevInIndex--) {
                /**
                 * Predchádzajúci index na strane ponuky v zoskupení vstupných elementov.
                 */
                int prevAskInIndex = getOfferSide().equals(OfferSide.ASK) ? prevInIndex : getTimedIndex(ins[ prevInIndex ].getTime(), barIns[ IN_ASK ]);

                /**
                 * Predchádzajúci index na strane dopytu v zoskupení vstupných elementov.
                 */
                int prevBidInIndex = getOfferSide().equals(OfferSide.BID) ? prevInIndex : getTimedIndex(ins[ prevInIndex ].getTime(), barIns[ IN_BID ]);

                if (prevAskInIndex == -1 || prevBidInIndex == -1) {
                    continue;
                }

                /**
                 * Predchádzajúci celkový objem uskutočnených obchodov.
                 */
                double prevTotalVolume = barIns[ IN_ASK ][ prevAskInIndex ].getVolume() + barIns[ IN_BID ][ prevBidInIndex ].getVolume();

                if (prevInIndex > inIndex - intOptIns[ OPT_IN_RISING_PERIOD ]) {
                    averageVolume += prevTotalVolume;
                }

                if (prevInIndex > inIndex - intOptIns[ OPT_IN_CLIMAX_PERIOD ]) {
                    highestVal = Math.max(highestVal, prevTotalVolume * (ins[ prevInIndex ].getHigh() - ins[ prevInIndex ].getLow()));
                }
            }

            averageVolume /= intOptIns[ OPT_IN_RISING_PERIOD ];

            if (averageVolume * doubleOptIns[ OPT_IN_CLIMAX_FACTOR ] <= totalVolume || totalVolume * (ins[ inIndex ].getHigh() - ins[ inIndex ].getLow()) >= highestVal) {
                doubleOuts[ OUT_CLIMAX_VOLUME ][ outIndex ] = totalVolume;

                if (!isClimaxVolumeReported && boolOptIns[ OPT_IN_NOTIFY ] && numOfCalculations > 9 && ins[ inIndex ].getTime() == getCurrentTime() && (isClimaxVolumeReported = true)) {
                    notify("Climax Volume", boolOptIns[ OPT_IN_NOTIFY_CLIMAX_VOLUME ], 2);
                }
            } else if (averageVolume * doubleOptIns[ OPT_IN_RISING_FACTOR ] <= totalVolume) {
                doubleOuts[ OUT_RISING_VOLUME ][ outIndex ] = totalVolume;

                if (!isRisingVolumeReported && boolOptIns[ OPT_IN_NOTIFY ] && numOfCalculations > 9 && ins[ inIndex ].getTime() == getCurrentTime() && (isRisingVolumeReported = true)) {
                    notify("Rising Volume", boolOptIns[ OPT_IN_NOTIFY_RISING_VOLUME ]);
                }
            } else {
                doubleOuts[ OUT_VOLUME ][ outIndex ] = totalVolume;
            }
        }

        return numOfElems;
    }