Method lup

JSAT/src/jsat/linear/GenericMatrix.java:491–563

()

    }
    
    @Override
    public Matrix[] lup()
    {
        Matrix[] lup = new Matrix[3];
        
        Matrix P = eye(rows());
        Matrix L;
        Matrix U = this;
        
        //Initalization is a little wierd b/c we want to handle rectangular cases as well!
        if(rows() > cols())//In this case, we will be changing U before returning it (have to make it smaller, but we can still avoid allocating extra space
            L = getMatrixOfSameType(rows(), cols());
        else
            L = getMatrixOfSameType(rows(), rows());        
        
        for(int i = 0; i < U.rows(); i++)
        {
            //If rectangular, we still need to loop through to update ther est of L - even though we wont make many other changes
            if(i < U.cols())
            {
                //Partial pivoting, find the largest value in this colum and move it to the top! 
                //Find the largest magintude value in the colum k, row j
                int largestRow = i;
                double largestVal = Math.abs(U.get(i, i));
                for (int j = i + 1; j < U.rows(); j++)
                {
                    double rowJLeadVal = Math.abs(U.get(j, i));
                    if (rowJLeadVal > largestVal)
                    {
                        largestRow = j;
                        largestVal = rowJLeadVal;
                    }
                }

                //SWAP!
                U.swapRows(largestRow, i);
                P.swapRows(largestRow, i);
                L.swapRows(largestRow, i);
                
                L.set(i, i, 1);
            }   

            //Seting up L 
            for(int k = 0; k < Math.min(i, U.cols()); k++)
            {
                double tmp = U.get(i, k)/U.get(k, k); 
                L.set(i, k, (Double.isNaN(tmp) ? 0.0 : tmp) );
                U.set(i, k, 0.0);

                for(int j = k+1; j < U.cols(); j++)
                {
                    U.increment(i, j, -L.get(i, k)*U.get(k, j));
                }
            }
        }
        
        
        if(rows() > cols())//Clean up!