Horizontal Volume Profile

    @Override public int getLookback() {
        return Math.max(intOptIns[ OPT_IN_RISING_PERIOD ], intOptIns[ OPT_IN_CLIMAX_PERIOD ]) - 1;
    }

    @Override protected int calculate(int firstIndex, int lastIndex, boolean isOfferSideChanged, boolean isPeriodChanged, boolean isInstrumentChanged, boolean isFeedChanged, boolean isNewBar, boolean isVisibleNewBar, boolean isFirstCalculation) {
        numOfCalculations++;

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

        int numOfElems = 0;

        IBar[] ins = getOfferSide().equals(OfferSide.ASK) ? barIns[ IN_ASK ] : barIns[ IN_BID ];

        int higherPeriod = Math.max(intOptIns[ OPT_IN_RISING_PERIOD ], intOptIns[ OPT_IN_CLIMAX_PERIOD ]);

        for (int inIndex = lastIndex, outIndex = lastIndex - firstIndex ; inIndex >= firstIndex ; inIndex--, outIndex--, numOfElems++) {
            int askInIndex = getOfferSide().equals(OfferSide.ASK) ? inIndex : getTimedIndex(ins[ inIndex ].getTime(), barIns[ IN_ASK ]);
            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;
            }

            double totalVolume = barIns[ IN_ASK ][ askInIndex ].getVolume() + barIns[ IN_BID ][ bidInIndex ].getVolume();

            double averageVolume = 0;

            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;

            for (int prevInIndex = inIndex - 1 ; prevInIndex > inIndex - higherPeriod ; prevInIndex--) {
                int prevAskInIndex = getOfferSide().equals(OfferSide.ASK) ? prevInIndex : getTimedIndex(ins[ prevInIndex ].getTime(), barIns[ IN_ASK ]);

                int prevBidInIndex = getOfferSide().equals(OfferSide.BID) ? prevInIndex : getTimedIndex(ins[ prevInIndex ].getTime(), barIns[ IN_BID ]);

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

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