public StepFunction add()

in modules/ml-ext/ml/src/main/java/org/apache/ignite/ml/tree/impurity/util/StepFunction.java [56:122]
51 lines of code
27 McCabe index (conditional complexity)

    public StepFunction<T> add(StepFunction<T> b) {
        int resSize = 0, leftPtr = 0, rightPtr = 0;
        double previousPnt = 0;

        while (leftPtr < x.length || rightPtr < b.x.length) {
            if (rightPtr >= b.x.length || (leftPtr < x.length && x[leftPtr] < b.x[rightPtr])) {
                if (resSize == 0 || x[leftPtr] != previousPnt) {
                    previousPnt = x[leftPtr];
                    resSize++;
                }

                leftPtr++;
            }
            else {
                if (resSize == 0 || b.x[rightPtr] != previousPnt) {
                    previousPnt = b.x[rightPtr];
                    resSize++;
                }

                rightPtr++;
            }
        }

        double[] resX = new double[resSize];
        T[] resY = Arrays.copyOf(y, resSize);

        leftPtr = 0;
        rightPtr = 0;

        for (int i = 0; leftPtr < x.length || rightPtr < b.x.length; i++) {
            if (rightPtr >= b.x.length || (leftPtr < x.length && x[leftPtr] < b.x[rightPtr])) {
                boolean override = i > 0 && x[leftPtr] == resX[i - 1];
                int target = override ? i - 1 : i;

                resY[target] = override ? resY[target] : null;
                resY[target] = i > 0 ? resY[i - 1] : null;
                resY[target] = resY[target] == null ? y[leftPtr] : resY[target].add(y[leftPtr]);

                if (leftPtr > 0)
                    resY[target] = resY[target].subtract(y[leftPtr - 1]);

                resX[target] = x[leftPtr];
                i = target;

                leftPtr++;
            }
            else {
                boolean override = i > 0 && b.x[rightPtr] == resX[i - 1];
                int target = override ? i - 1 : i;

                resY[target] = override ? resY[target] : null;
                resY[target] = i > 0 ? resY[i - 1] : null;

                resY[target] = resY[target] == null ? b.y[rightPtr] : resY[target].add(b.y[rightPtr]);

                if (rightPtr > 0)
                    resY[target] = resY[target].subtract(b.y[rightPtr - 1]);

                resX[target] = b.x[rightPtr];
                i = target;

                rightPtr++;
            }
        }

        return new StepFunction<>(resX, resY);
    }