Exemplo n.º 1
0
        /**
         * <p>
         * Computes the 'y' vector and stores the result in 'v'<br>
         * <br>
         * y = -&gamma;(A + U*V^T + V*U^T)u
         * </p>
         *
         * @param blockLength
         * @param A Contains the reflectors and the row being updated.
         * @param V Contains previously computed 'v' vectors.
         * @param row The row of 'A' that is to be updated.
         */
        public static void computeY(int blockLength,
                                    FSubmatrixD1 A,
                                    FSubmatrixD1 V,
                                    int row,
                                    float gamma)
        {
            // Elements in 'y' before 'row' are known to be zero and the element at 'row'
            // is not used. Thus only elements after row and after are computed.
            // y = A*u
            multA_u(blockLength, A, V, row);

            for (int i = 0; i < row; i++)
            {
                // y = y + u_i*v_i^t*u + v_i*u_i^t*u

                // v_i^t*u
                float dot_v_u = BlockHouseHolder_FDRB.innerProdRow(blockLength, A, row, V, i, 1);

                // u_i^t*u
                float dot_u_u = BlockHouseHolder_FDRB.innerProdRow(blockLength, A, row, A, i, 1);

                // y = y + u_i*(v_i^t*u)
                // the ones in these 'u' are skipped over since the next submatrix of A
                // is only updated
                VectorOps_FDRB.add_row(blockLength, V, row, 1, A, i, dot_v_u, V, row, row + 1, A.col1 - A.col0);

                // y = y + v_i*(u_i^t*u)
                // the 1 in U is taken account above
                VectorOps_FDRB.add_row(blockLength, V, row, 1, V, i, dot_u_u, V, row, row + 1, A.col1 - A.col0);
            }

            // y = -gamma*y
            VectorOps_FDRB.scale_row(blockLength, V, row, -gamma, V, row, row + 1, V.col1 - V.col0);
        }
Exemplo n.º 2
0
        /**
         * Scales the elements in the specified row starting at element colStart by 'val'.<br>
         * W = val*Y
         *
         * Takes in account zeros and leading one automatically.
         *
         * @param zeroOffset How far off the diagonal is the first element in the vector.
         */
        public static void scale_row(int blockLength,
                                     FSubmatrixD1 Y,
                                     FSubmatrixD1 W,
                                     int row,
                                     int zeroOffset,
                                     float val)
        {
            int offset = row + zeroOffset;

            if (offset >= W.col1 - W.col0)
            {
                return;
            }

            // handle the one
            W.set(row, offset, val);

            // scale rest of the vector
            VectorOps_FDRB.scale_row(blockLength, Y, row, val, W, row, offset + 1, Y.col1 - Y.col0);
        }