private void vmove()

in commons-math-legacy/src/main/java/org/apache/commons/math4/legacy/stat/regression/MillerUpdatingRegression.java [690:806]

• 109 lines of code
• 17 McCabe index (conditional complexity)

    private void vmove(int from, int to) {
        double d1;
        double d2;
        double x;
        double d1new;
        double d2new;
        double cbar;
        double sbar;
        double y;
        int first;
        int inc;
        int m1;
        int m2;
        int mp1;
        int pos;
        boolean bSkipTo40 = false;
        if (from == to) {
            return;
        }
        if (!this.rssSet) {
            ss();
        }
        int count = 0;
        if (from < to) {
            first = from;
            inc = 1;
            count = to - from;
        } else {
            first = from - 1;
            inc = -1;
            count = from - to;
        }

        int m = first;
        int idx = 0;
        while (idx < count) {
            m1 = m * (nvars + nvars - m - 1) / 2;
            m2 = m1 + nvars - m - 1;
            mp1 = m + 1;

            d1 = d[m];
            d2 = d[mp1];
            // Special cases.
            if (d1 > this.epsilon || d2 > this.epsilon) {
                x = r[m1];
                if (JdkMath.abs(x) * JdkMath.sqrt(d1) < tol[mp1]) {
                    x = 0.0;
                }
                if (d1 < this.epsilon || JdkMath.abs(x) < this.epsilon) {
                    d[m] = d2;
                    d[mp1] = d1;
                    r[m1] = 0.0;
                    for (int col = m + 2; col < nvars; col++) {
                        ++m1;
                        x = r[m1];
                        r[m1] = r[m2];
                        r[m2] = x;
                        ++m2;
                    }
                    x = rhs[m];
                    rhs[m] = rhs[mp1];
                    rhs[mp1] = x;
                    bSkipTo40 = true;
                    //break;
                } else if (d2 < this.epsilon) {
                    d[m] = d1 * x * x;
                    r[m1] = 1.0 / x;
                    for (int i = m1 + 1; i < m1 + nvars - m - 1; i++) {
                        r[i] /= x;
                    }
                    rhs[m] /= x;
                    bSkipTo40 = true;
                    //break;
                }
                if (!bSkipTo40) {
                    d1new = d2 + d1 * x * x;
                    cbar = d2 / d1new;
                    sbar = x * d1 / d1new;
                    d2new = d1 * cbar;
                    d[m] = d1new;
                    d[mp1] = d2new;
                    r[m1] = sbar;
                    for (int col = m + 2; col < nvars; col++) {
                        ++m1;
                        y = r[m1];
                        r[m1] = cbar * r[m2] + sbar * y;
                        r[m2] = y - x * r[m2];
                        ++m2;
                    }
                    y = rhs[m];
                    rhs[m] = cbar * rhs[mp1] + sbar * y;
                    rhs[mp1] = y - x * rhs[mp1];
                }
            }
            if (m > 0) {
                pos = m;
                for (int row = 0; row < m; row++) {
                    x = r[pos];
                    r[pos] = r[pos - 1];
                    r[pos - 1] = x;
                    pos += nvars - row - 2;
                }
            }
            // Adjust variable order (VORDER), the tolerances (TOL) and
            // the vector of residual sums of squares (RSS).
            m1 = vorder[m];
            vorder[m] = vorder[mp1];
            vorder[mp1] = m1;
            x = tol[m];
            tol[m] = tol[mp1];
            tol[mp1] = x;
            rss[m] = rss[mp1] + d[mp1] * rhs[mp1] * rhs[mp1];

            m += inc;
            ++idx;
        }
    }