| // This file is part of Eigen, a lightweight C++ template library |
| // for linear algebra. |
| // |
| // Copyright (C) 2012 Désiré Nuentsa-Wakam <desire.nuentsa_wakam@inria.fr> |
| // Copyright (C) 2012 Gael Guennebaud <gael.guennebaud@inria.fr> |
| // |
| // This Source Code Form is subject to the terms of the Mozilla |
| // Public License v. 2.0. If a copy of the MPL was not distributed |
| // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. |
| |
| /* |
| |
| * NOTE: This file is the modified version of [s,d,c,z]panel_bmod.c file in SuperLU |
| |
| * -- SuperLU routine (version 3.0) -- |
| * Univ. of California Berkeley, Xerox Palo Alto Research Center, |
| * and Lawrence Berkeley National Lab. |
| * October 15, 2003 |
| * |
| * Copyright (c) 1994 by Xerox Corporation. All rights reserved. |
| * |
| * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY |
| * EXPRESSED OR IMPLIED. ANY USE IS AT YOUR OWN RISK. |
| * |
| * Permission is hereby granted to use or copy this program for any |
| * purpose, provided the above notices are retained on all copies. |
| * Permission to modify the code and to distribute modified code is |
| * granted, provided the above notices are retained, and a notice that |
| * the code was modified is included with the above copyright notice. |
| */ |
| #ifndef SPARSELU_PANEL_BMOD_H |
| #define SPARSELU_PANEL_BMOD_H |
| |
| namespace Eigen { |
| namespace internal { |
| |
| /** |
| * \brief Performs numeric block updates (sup-panel) in topological order. |
| * |
| * Before entering this routine, the original nonzeros in the panel |
| * were already copied into the spa[m,w] |
| * |
| * \param m number of rows in the matrix |
| * \param w Panel size |
| * \param jcol Starting column of the panel |
| * \param nseg Number of segments in the U part |
| * \param dense Store the full representation of the panel |
| * \param tempv working array |
| * \param segrep segment representative... first row in the segment |
| * \param repfnz First nonzero rows |
| * \param glu Global LU data. |
| * |
| * |
| */ |
| template <typename Scalar, typename StorageIndex> |
| void SparseLUImpl<Scalar,StorageIndex>::panel_bmod(const Index m, const Index w, const Index jcol, |
| const Index nseg, ScalarVector& dense, ScalarVector& tempv, |
| IndexVector& segrep, IndexVector& repfnz, GlobalLU_t& glu) |
| { |
| |
| Index ksub,jj,nextl_col; |
| Index fsupc, nsupc, nsupr, nrow; |
| Index krep, kfnz; |
| Index lptr; // points to the row subscripts of a supernode |
| Index luptr; // ... |
| Index segsize,no_zeros ; |
| // For each nonz supernode segment of U[*,j] in topological order |
| Index k = nseg - 1; |
| const Index PacketSize = internal::packet_traits<Scalar>::size; |
| |
| for (ksub = 0; ksub < nseg; ksub++) |
| { // For each updating supernode |
| /* krep = representative of current k-th supernode |
| * fsupc = first supernodal column |
| * nsupc = number of columns in a supernode |
| * nsupr = number of rows in a supernode |
| */ |
| krep = segrep(k); k--; |
| fsupc = glu.xsup(glu.supno(krep)); |
| nsupc = krep - fsupc + 1; |
| nsupr = glu.xlsub(fsupc+1) - glu.xlsub(fsupc); |
| nrow = nsupr - nsupc; |
| lptr = glu.xlsub(fsupc); |
| |
| // loop over the panel columns to detect the actual number of columns and rows |
| Index u_rows = 0; |
| Index u_cols = 0; |
| for (jj = jcol; jj < jcol + w; jj++) |
| { |
| nextl_col = (jj-jcol) * m; |
| VectorBlock<IndexVector> repfnz_col(repfnz, nextl_col, m); // First nonzero column index for each row |
| |
| kfnz = repfnz_col(krep); |
| if ( kfnz == emptyIdxLU ) |
| continue; // skip any zero segment |
| |
| segsize = krep - kfnz + 1; |
| u_cols++; |
| u_rows = (std::max)(segsize,u_rows); |
| } |
| |
| if(nsupc >= 2) |
| { |
| Index ldu = internal::first_multiple<Index>(u_rows, PacketSize); |
| Map<ScalarMatrix, Aligned, OuterStride<> > U(tempv.data(), u_rows, u_cols, OuterStride<>(ldu)); |
| |
| // gather U |
| Index u_col = 0; |
| for (jj = jcol; jj < jcol + w; jj++) |
| { |
| nextl_col = (jj-jcol) * m; |
| VectorBlock<IndexVector> repfnz_col(repfnz, nextl_col, m); // First nonzero column index for each row |
| VectorBlock<ScalarVector> dense_col(dense, nextl_col, m); // Scatter/gather entire matrix column from/to here |
| |
| kfnz = repfnz_col(krep); |
| if ( kfnz == emptyIdxLU ) |
| continue; // skip any zero segment |
| |
| segsize = krep - kfnz + 1; |
| luptr = glu.xlusup(fsupc); |
| no_zeros = kfnz - fsupc; |
| |
| Index isub = lptr + no_zeros; |
| Index off = u_rows-segsize; |
| for (Index i = 0; i < off; i++) U(i,u_col) = 0; |
| for (Index i = 0; i < segsize; i++) |
| { |
| Index irow = glu.lsub(isub); |
| U(i+off,u_col) = dense_col(irow); |
| ++isub; |
| } |
| u_col++; |
| } |
| // solve U = A^-1 U |
| luptr = glu.xlusup(fsupc); |
| Index lda = glu.xlusup(fsupc+1) - glu.xlusup(fsupc); |
| no_zeros = (krep - u_rows + 1) - fsupc; |
| luptr += lda * no_zeros + no_zeros; |
| MappedMatrixBlock A(glu.lusup.data()+luptr, u_rows, u_rows, OuterStride<>(lda) ); |
| U = A.template triangularView<UnitLower>().solve(U); |
| |
| // update |
| luptr += u_rows; |
| MappedMatrixBlock B(glu.lusup.data()+luptr, nrow, u_rows, OuterStride<>(lda) ); |
| eigen_assert(tempv.size()>w*ldu + nrow*w + 1); |
| |
| Index ldl = internal::first_multiple<Index>(nrow, PacketSize); |
| Index offset = (PacketSize-internal::first_default_aligned(B.data(), PacketSize)) % PacketSize; |
| MappedMatrixBlock L(tempv.data()+w*ldu+offset, nrow, u_cols, OuterStride<>(ldl)); |
| |
| L.setZero(); |
| internal::sparselu_gemm<Scalar>(L.rows(), L.cols(), B.cols(), B.data(), B.outerStride(), U.data(), U.outerStride(), L.data(), L.outerStride()); |
| |
| // scatter U and L |
| u_col = 0; |
| for (jj = jcol; jj < jcol + w; jj++) |
| { |
| nextl_col = (jj-jcol) * m; |
| VectorBlock<IndexVector> repfnz_col(repfnz, nextl_col, m); // First nonzero column index for each row |
| VectorBlock<ScalarVector> dense_col(dense, nextl_col, m); // Scatter/gather entire matrix column from/to here |
| |
| kfnz = repfnz_col(krep); |
| if ( kfnz == emptyIdxLU ) |
| continue; // skip any zero segment |
| |
| segsize = krep - kfnz + 1; |
| no_zeros = kfnz - fsupc; |
| Index isub = lptr + no_zeros; |
| |
| Index off = u_rows-segsize; |
| for (Index i = 0; i < segsize; i++) |
| { |
| Index irow = glu.lsub(isub++); |
| dense_col(irow) = U.coeff(i+off,u_col); |
| U.coeffRef(i+off,u_col) = 0; |
| } |
| |
| // Scatter l into SPA dense[] |
| for (Index i = 0; i < nrow; i++) |
| { |
| Index irow = glu.lsub(isub++); |
| dense_col(irow) -= L.coeff(i,u_col); |
| L.coeffRef(i,u_col) = 0; |
| } |
| u_col++; |
| } |
| } |
| else // level 2 only |
| { |
| // Sequence through each column in the panel |
| for (jj = jcol; jj < jcol + w; jj++) |
| { |
| nextl_col = (jj-jcol) * m; |
| VectorBlock<IndexVector> repfnz_col(repfnz, nextl_col, m); // First nonzero column index for each row |
| VectorBlock<ScalarVector> dense_col(dense, nextl_col, m); // Scatter/gather entire matrix column from/to here |
| |
| kfnz = repfnz_col(krep); |
| if ( kfnz == emptyIdxLU ) |
| continue; // skip any zero segment |
| |
| segsize = krep - kfnz + 1; |
| luptr = glu.xlusup(fsupc); |
| |
| Index lda = glu.xlusup(fsupc+1)-glu.xlusup(fsupc);// nsupr |
| |
| // Perform a trianglar solve and block update, |
| // then scatter the result of sup-col update to dense[] |
| no_zeros = kfnz - fsupc; |
| if(segsize==1) LU_kernel_bmod<1>::run(segsize, dense_col, tempv, glu.lusup, luptr, lda, nrow, glu.lsub, lptr, no_zeros); |
| else if(segsize==2) LU_kernel_bmod<2>::run(segsize, dense_col, tempv, glu.lusup, luptr, lda, nrow, glu.lsub, lptr, no_zeros); |
| else if(segsize==3) LU_kernel_bmod<3>::run(segsize, dense_col, tempv, glu.lusup, luptr, lda, nrow, glu.lsub, lptr, no_zeros); |
| else LU_kernel_bmod<Dynamic>::run(segsize, dense_col, tempv, glu.lusup, luptr, lda, nrow, glu.lsub, lptr, no_zeros); |
| } // End for each column in the panel |
| } |
| |
| } // End for each updating supernode |
| } // end panel bmod |
| |
| } // end namespace internal |
| |
| } // end namespace Eigen |
| |
| #endif // SPARSELU_PANEL_BMOD_H |
