Backgrounds

I'm writing a code that searches for the maximum index, starting from the input row index idx through the final row, and changes the input into the maximum index. (This is my own version of subroutine for Gaussian Elimination with Partial Pivoting, for those who are interested).

For example, for the following matrix

Background

I'm writing code that searches for the row number of the maximum value in a partial column of a matrix. The partial column corresponds with the non-zero values of an equivalent lower triangular matrix. That is, starting from the input row index idx through the final row. (This is my own version of subroutine for Gaussian Elimination with Partial Pivoting, for those who are interested).

For example, for the following matrix $$ A = \begin{bmatrix}1 & 2 & 3 \\ 4 & 5 & 6 \\ 7 & 8 & 9 \end{bmatrix} $$

(An excuse for the exclusion of the code : Matrix is just from typedef std::vector<Vector> Matrix;)

But I'm not sure exactly where in MaxLocColumnWise() to blame. Any help will be appreciated.

But I'm not sure exactly where in MaxLocColumnWise() to blame. Any help will be appreciated.

(An excuse for the exclusion of the code : Matrix is just from typedef std::vector<Vector> Matrix;, and the Vector is typedef std::vector<double> Vector;)

For example, for the following matrix

MaxLocColumnWise(A,k) where k=1 should search the maximum of the vector [5,8] and changes k from 1 to 2, which is the row location of 8 in the original matrix.

And interestingly it turns out that the following code takes quite long time.

(An excuse for the exclusion of the code : Matrix is just from typedef std::vector<Vector> Matrix;)

Basically, the behavior of MaxLocColumnWise is the search of columnwise maximum location in the submatrices of A. Passing by reference, MaxLocColumnWise changes the value of k.

For example, for the following matrix

• when k=0, MaxLocColumnWise(A,k) converts k to the index of maximum element in [1,4,7], which is 2, which is the index of 7 i.e. we get 2 as a result of

    int k = 0;
    `MaxLocColumnWise(A,k)`;
    std::cout << k <<"\n";

• when k=1, MaxLocColumnWise(A,k) converts k to the index of maximum element in [5,8], which is 2, which is the index of 8. (This case is highlighted in red here)

• when k=2, MaxLocColumnWise(A,k) converts k to the index of maximum element in [9], which is 2, which is the index of 9

Interestingly it turns out that the following code takes quite long time.

(An excuse for the exclusion of the code : Matrix is just from typedef std::vector<Vector> Matrix;)

I have implemented this subroutine to the following Gaussian elimination with partial pivoting routine:

void GaussElimPartialPivot(Matrix& A, Vector& b){
    int n = A.size();

    for (int j=0; j<(n-1); j++){
        int index = j; 
        MaxLocColumnWise(A, index);
        SwapMatrixRows(A, j, index);
        SwapVector(b, j, index);

        // main loop
        for (int i=(j+1); i<n; i++){
            double m = A[i][j]/A[j][j];
            b[i] -= m*b[j];
            for(int k=j; k<n; k++){
                A[i][k] -= m*A[j][k];
            }
        }
    }
}

But when A gets large, the program gets slower exactly due to the subroutine MaxLocColumnWise, which was verified from excluding each subroutine in the main code.

But I'm not sure exactly where in MaxLocColumnWise() to blame. Any help will be appreciated.