1 // This file is part of Eigen, a lightweight C++ template library 2 // for linear algebra. 3 // 4 // Copyright (C) 2012 Dsir Nuentsa-Wakam <desire.nuentsa_wakam (at) inria.fr> 5 // Copyright (C) 2012 Gael Guennebaud <gael.guennebaud (at) inria.fr> 6 // 7 // This Source Code Form is subject to the terms of the Mozilla 8 // Public License v. 2.0. If a copy of the MPL was not distributed 9 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/. 10 11 #ifndef SPARSELU_KERNEL_BMOD_H 12 #define SPARSELU_KERNEL_BMOD_H 13 14 namespace Eigen { 15 namespace internal { 16 17 template <int SegSizeAtCompileTime> struct LU_kernel_bmod 18 { 19 /** \internal 20 * \brief Performs numeric block updates from a given supernode to a single column 21 * 22 * \param segsize Size of the segment (and blocks ) to use for updates 23 * \param[in,out] dense Packed values of the original matrix 24 * \param tempv temporary vector to use for updates 25 * \param lusup array containing the supernodes 26 * \param lda Leading dimension in the supernode 27 * \param nrow Number of rows in the rectangular part of the supernode 28 * \param lsub compressed row subscripts of supernodes 29 * \param lptr pointer to the first column of the current supernode in lsub 30 * \param no_zeros Number of nonzeros elements before the diagonal part of the supernode 31 */ 32 template <typename BlockScalarVector, typename ScalarVector, typename IndexVector> 33 static EIGEN_DONT_INLINE void run(const Index segsize, BlockScalarVector& dense, ScalarVector& tempv, ScalarVector& lusup, Index& luptr, const Index lda, 34 const Index nrow, IndexVector& lsub, const Index lptr, const Index no_zeros); 35 }; 36 37 template <int SegSizeAtCompileTime> 38 template <typename BlockScalarVector, typename ScalarVector, typename IndexVector> 39 EIGEN_DONT_INLINE void LU_kernel_bmod<SegSizeAtCompileTime>::run(const Index segsize, BlockScalarVector& dense, ScalarVector& tempv, ScalarVector& lusup, Index& luptr, const Index lda, 40 const Index nrow, IndexVector& lsub, const Index lptr, const Index no_zeros) 41 { 42 typedef typename ScalarVector::Scalar Scalar; 43 // First, copy U[*,j] segment from dense(*) to tempv(*) 44 // The result of triangular solve is in tempv[*]; 45 // The result of matric-vector update is in dense[*] 46 Index isub = lptr + no_zeros; 47 Index i; 48 Index irow; 49 for (i = 0; i < ((SegSizeAtCompileTime==Dynamic)?segsize:SegSizeAtCompileTime); i++) 50 { 51 irow = lsub(isub); 52 tempv(i) = dense(irow); 53 ++isub; 54 } 55 // Dense triangular solve -- start effective triangle 56 luptr += lda * no_zeros + no_zeros; 57 // Form Eigen matrix and vector 58 Map<Matrix<Scalar,SegSizeAtCompileTime,SegSizeAtCompileTime, ColMajor>, 0, OuterStride<> > A( &(lusup.data()[luptr]), segsize, segsize, OuterStride<>(lda) ); 59 Map<Matrix<Scalar,SegSizeAtCompileTime,1> > u(tempv.data(), segsize); 60 61 u = A.template triangularView<UnitLower>().solve(u); 62 63 // Dense matrix-vector product y <-- B*x 64 luptr += segsize; 65 const Index PacketSize = internal::packet_traits<Scalar>::size; 66 Index ldl = internal::first_multiple(nrow, PacketSize); 67 Map<Matrix<Scalar,Dynamic,SegSizeAtCompileTime, ColMajor>, 0, OuterStride<> > B( &(lusup.data()[luptr]), nrow, segsize, OuterStride<>(lda) ); 68 Index aligned_offset = internal::first_default_aligned(tempv.data()+segsize, PacketSize); 69 Index aligned_with_B_offset = (PacketSize-internal::first_default_aligned(B.data(), PacketSize))%PacketSize; 70 Map<Matrix<Scalar,Dynamic,1>, 0, OuterStride<> > l(tempv.data()+segsize+aligned_offset+aligned_with_B_offset, nrow, OuterStride<>(ldl) ); 71 72 l.setZero(); 73 internal::sparselu_gemm<Scalar>(l.rows(), l.cols(), B.cols(), B.data(), B.outerStride(), u.data(), u.outerStride(), l.data(), l.outerStride()); 74 75 // Scatter tempv[] into SPA dense[] as a temporary storage 76 isub = lptr + no_zeros; 77 for (i = 0; i < ((SegSizeAtCompileTime==Dynamic)?segsize:SegSizeAtCompileTime); i++) 78 { 79 irow = lsub(isub++); 80 dense(irow) = tempv(i); 81 } 82 83 // Scatter l into SPA dense[] 84 for (i = 0; i < nrow; i++) 85 { 86 irow = lsub(isub++); 87 dense(irow) -= l(i); 88 } 89 } 90 91 template <> struct LU_kernel_bmod<1> 92 { 93 template <typename BlockScalarVector, typename ScalarVector, typename IndexVector> 94 static EIGEN_DONT_INLINE void run(const Index /*segsize*/, BlockScalarVector& dense, ScalarVector& /*tempv*/, ScalarVector& lusup, Index& luptr, 95 const Index lda, const Index nrow, IndexVector& lsub, const Index lptr, const Index no_zeros); 96 }; 97 98 99 template <typename BlockScalarVector, typename ScalarVector, typename IndexVector> 100 EIGEN_DONT_INLINE void LU_kernel_bmod<1>::run(const Index /*segsize*/, BlockScalarVector& dense, ScalarVector& /*tempv*/, ScalarVector& lusup, Index& luptr, 101 const Index lda, const Index nrow, IndexVector& lsub, const Index lptr, const Index no_zeros) 102 { 103 typedef typename ScalarVector::Scalar Scalar; 104 typedef typename IndexVector::Scalar StorageIndex; 105 Scalar f = dense(lsub(lptr + no_zeros)); 106 luptr += lda * no_zeros + no_zeros + 1; 107 const Scalar* a(lusup.data() + luptr); 108 const StorageIndex* irow(lsub.data()+lptr + no_zeros + 1); 109 Index i = 0; 110 for (; i+1 < nrow; i+=2) 111 { 112 Index i0 = *(irow++); 113 Index i1 = *(irow++); 114 Scalar a0 = *(a++); 115 Scalar a1 = *(a++); 116 Scalar d0 = dense.coeff(i0); 117 Scalar d1 = dense.coeff(i1); 118 d0 -= f*a0; 119 d1 -= f*a1; 120 dense.coeffRef(i0) = d0; 121 dense.coeffRef(i1) = d1; 122 } 123 if(i<nrow) 124 dense.coeffRef(*(irow++)) -= f * *(a++); 125 } 126 127 } // end namespace internal 128 129 } // end namespace Eigen 130 #endif // SPARSELU_KERNEL_BMOD_H 131
