10 #ifndef EIGEN_TRIANGULAR_SOLVER_MATRIX_H
11 #define EIGEN_TRIANGULAR_SOLVER_MATRIX_H
18 template <
typename Scalar,
typename Index,
int S
ide,
int Mode,
bool Conjugate,
int TriStorageOrder>
19 struct triangular_solve_matrix<Scalar,Index,Side,Mode,Conjugate,TriStorageOrder,
RowMajor>
21 static EIGEN_DONT_INLINE
void run(
22 Index size, Index cols,
23 const Scalar* tri, Index triStride,
24 Scalar* _other, Index otherStride,
25 level3_blocking<Scalar,Scalar>& blocking)
27 triangular_solve_matrix<
30 NumTraits<Scalar>::IsComplex && Conjugate,
32 ::run(size, cols, tri, triStride, _other, otherStride, blocking);
38 template <
typename Scalar,
typename Index,
int Mode,
bool Conjugate,
int TriStorageOrder>
39 struct triangular_solve_matrix<Scalar,Index,
OnTheLeft,Mode,Conjugate,TriStorageOrder,
ColMajor>
41 static EIGEN_DONT_INLINE
void run(
42 Index size, Index otherSize,
43 const Scalar* _tri, Index triStride,
44 Scalar* _other, Index otherStride,
45 level3_blocking<Scalar,Scalar>& blocking)
47 Index cols = otherSize;
48 const_blas_data_mapper<Scalar, Index, TriStorageOrder> tri(_tri,triStride);
49 blas_data_mapper<Scalar, Index, ColMajor> other(_other,otherStride);
51 typedef gebp_traits<Scalar,Scalar> Traits;
53 SmallPanelWidth = EIGEN_PLAIN_ENUM_MAX(Traits::mr,Traits::nr),
57 Index kc = blocking.kc();
58 Index mc = (std::min)(size,blocking.mc());
60 std::size_t sizeA = kc*mc;
61 std::size_t sizeB = kc*cols;
62 std::size_t sizeW = kc*Traits::WorkSpaceFactor;
64 ei_declare_aligned_stack_constructed_variable(Scalar, blockA, sizeA, blocking.blockA());
65 ei_declare_aligned_stack_constructed_variable(Scalar, blockB, sizeB, blocking.blockB());
66 ei_declare_aligned_stack_constructed_variable(Scalar, blockW, sizeW, blocking.blockW());
68 conj_if<Conjugate>
conj;
69 gebp_kernel<Scalar, Scalar, Index, Traits::mr, Traits::nr, Conjugate, false> gebp_kernel;
70 gemm_pack_lhs<Scalar, Index, Traits::mr, Traits::LhsProgress, TriStorageOrder> pack_lhs;
71 gemm_pack_rhs<Scalar, Index, Traits::nr, ColMajor, false, true> pack_rhs;
75 std::ptrdiff_t l1, l2;
76 manage_caching_sizes(GetAction, &l1, &l2);
77 Index subcols = cols>0 ? l2/(4 *
sizeof(Scalar) * otherStride) : 0;
78 subcols = std::max<Index>((subcols/Traits::nr)*Traits::nr, Traits::nr);
80 for(Index k2=IsLower ? 0 : size;
81 IsLower ? k2<size : k2>0;
82 IsLower ? k2+=kc : k2-=kc)
84 const Index actual_kc = (std::min)(IsLower ? size-k2 : k2, kc);
99 for(Index j2=0; j2<cols; j2+=subcols)
101 Index actual_cols = (std::min)(cols-j2,subcols);
103 for (Index k1=0; k1<actual_kc; k1+=SmallPanelWidth)
105 Index actualPanelWidth = std::min<Index>(actual_kc-k1, SmallPanelWidth);
107 for (Index k=0; k<actualPanelWidth; ++k)
110 Index i = IsLower ? k2+k1+k : k2-k1-k-1;
111 Index s = IsLower ? k2+k1 : i+1;
112 Index rs = actualPanelWidth - k - 1;
114 Scalar a = (Mode &
UnitDiag) ? Scalar(1) : Scalar(1)/
conj(tri(i,i));
115 for (Index j=j2; j<j2+actual_cols; ++j)
120 const Scalar* l = &tri(i,s);
121 Scalar* r = &other(s,j);
122 for (Index i3=0; i3<k; ++i3)
123 b +=
conj(l[i3]) * r[i3];
125 other(i,j) = (other(i,j) - b)*a;
129 Index s = IsLower ? i+1 : i-rs;
130 Scalar b = (other(i,j) *= a);
131 Scalar* r = &other(s,j);
132 const Scalar* l = &tri(s,i);
133 for (Index i3=0;i3<rs;++i3)
134 r[i3] -= b *
conj(l[i3]);
139 Index lengthTarget = actual_kc-k1-actualPanelWidth;
140 Index startBlock = IsLower ? k2+k1 : k2-k1-actualPanelWidth;
141 Index blockBOffset = IsLower ? k1 : lengthTarget;
144 pack_rhs(blockB+actual_kc*j2, &other(startBlock,j2), otherStride, actualPanelWidth, actual_cols, actual_kc, blockBOffset);
149 Index startTarget = IsLower ? k2+k1+actualPanelWidth : k2-actual_kc;
151 pack_lhs(blockA, &tri(startTarget,startBlock), triStride, actualPanelWidth, lengthTarget);
153 gebp_kernel(&other(startTarget,j2), otherStride, blockA, blockB+actual_kc*j2, lengthTarget, actualPanelWidth, actual_cols, Scalar(-1),
154 actualPanelWidth, actual_kc, 0, blockBOffset, blockW);
161 Index start = IsLower ? k2+kc : 0;
162 Index end = IsLower ? size : k2-kc;
163 for(Index i2=start; i2<end; i2+=mc)
165 const Index actual_mc = (std::min)(mc,end-i2);
168 pack_lhs(blockA, &tri(i2, IsLower ? k2 : k2-kc), triStride, actual_kc, actual_mc);
170 gebp_kernel(_other+i2, otherStride, blockA, blockB, actual_mc, actual_kc, cols, Scalar(-1), -1, -1, 0, 0, blockW);
180 template <
typename Scalar,
typename Index,
int Mode,
bool Conjugate,
int TriStorageOrder>
181 struct triangular_solve_matrix<Scalar,Index,
OnTheRight,Mode,Conjugate,TriStorageOrder,
ColMajor>
183 static EIGEN_DONT_INLINE
void run(
184 Index size, Index otherSize,
185 const Scalar* _tri, Index triStride,
186 Scalar* _other, Index otherStride,
187 level3_blocking<Scalar,Scalar>& blocking)
189 Index rows = otherSize;
190 const_blas_data_mapper<Scalar, Index, TriStorageOrder> rhs(_tri,triStride);
191 blas_data_mapper<Scalar, Index, ColMajor> lhs(_other,otherStride);
193 typedef gebp_traits<Scalar,Scalar> Traits;
195 RhsStorageOrder = TriStorageOrder,
196 SmallPanelWidth = EIGEN_PLAIN_ENUM_MAX(Traits::mr,Traits::nr),
200 Index kc = blocking.kc();
201 Index mc = (std::min)(rows,blocking.mc());
203 std::size_t sizeA = kc*mc;
204 std::size_t sizeB = kc*size;
205 std::size_t sizeW = kc*Traits::WorkSpaceFactor;
207 ei_declare_aligned_stack_constructed_variable(Scalar, blockA, sizeA, blocking.blockA());
208 ei_declare_aligned_stack_constructed_variable(Scalar, blockB, sizeB, blocking.blockB());
209 ei_declare_aligned_stack_constructed_variable(Scalar, blockW, sizeW, blocking.blockW());
211 conj_if<Conjugate>
conj;
212 gebp_kernel<Scalar,Scalar, Index, Traits::mr, Traits::nr, false, Conjugate> gebp_kernel;
213 gemm_pack_rhs<Scalar, Index, Traits::nr,RhsStorageOrder> pack_rhs;
214 gemm_pack_rhs<Scalar, Index, Traits::nr,RhsStorageOrder,false,true> pack_rhs_panel;
215 gemm_pack_lhs<Scalar, Index, Traits::mr, Traits::LhsProgress, ColMajor, false, true> pack_lhs_panel;
217 for(Index k2=IsLower ? size : 0;
218 IsLower ? k2>0 : k2<size;
219 IsLower ? k2-=kc : k2+=kc)
221 const Index actual_kc = (std::min)(IsLower ? k2 : size-k2, kc);
222 Index actual_k2 = IsLower ? k2-actual_kc : k2 ;
224 Index startPanel = IsLower ? 0 : k2+actual_kc;
225 Index rs = IsLower ? actual_k2 : size - actual_k2 - actual_kc;
226 Scalar* geb = blockB+actual_kc*actual_kc;
228 if (rs>0) pack_rhs(geb, &rhs(actual_k2,startPanel), triStride, actual_kc, rs);
233 for (Index j2=0; j2<actual_kc; j2+=SmallPanelWidth)
235 Index actualPanelWidth = std::min<Index>(actual_kc-j2, SmallPanelWidth);
236 Index actual_j2 = actual_k2 + j2;
237 Index panelOffset = IsLower ? j2+actualPanelWidth : 0;
238 Index panelLength = IsLower ? actual_kc-j2-actualPanelWidth : j2;
241 pack_rhs_panel(blockB+j2*actual_kc,
242 &rhs(actual_k2+panelOffset, actual_j2), triStride,
243 panelLength, actualPanelWidth,
244 actual_kc, panelOffset);
248 for(Index i2=0; i2<rows; i2+=mc)
250 const Index actual_mc = (std::min)(mc,rows-i2);
255 for (Index j2 = IsLower
256 ? (actual_kc - ((actual_kc%SmallPanelWidth) ? Index(actual_kc%SmallPanelWidth)
257 : Index(SmallPanelWidth)))
259 IsLower ? j2>=0 : j2<actual_kc;
260 IsLower ? j2-=SmallPanelWidth : j2+=SmallPanelWidth)
262 Index actualPanelWidth = std::min<Index>(actual_kc-j2, SmallPanelWidth);
263 Index absolute_j2 = actual_k2 + j2;
264 Index panelOffset = IsLower ? j2+actualPanelWidth : 0;
265 Index panelLength = IsLower ? actual_kc - j2 - actualPanelWidth : j2;
270 gebp_kernel(&lhs(i2,absolute_j2), otherStride,
271 blockA, blockB+j2*actual_kc,
272 actual_mc, panelLength, actualPanelWidth,
274 actual_kc, actual_kc,
275 panelOffset, panelOffset,
280 for (Index k=0; k<actualPanelWidth; ++k)
282 Index j = IsLower ? absolute_j2+actualPanelWidth-k-1 : absolute_j2+k;
284 Scalar* r = &lhs(i2,j);
285 for (Index k3=0; k3<k; ++k3)
287 Scalar b =
conj(rhs(IsLower ? j+1+k3 : absolute_j2+k3,j));
288 Scalar* a = &lhs(i2,IsLower ? j+1+k3 : absolute_j2+k3);
289 for (Index i=0; i<actual_mc; ++i)
292 Scalar b = (Mode &
UnitDiag) ? Scalar(1) : Scalar(1)/
conj(rhs(j,j));
293 for (Index i=0; i<actual_mc; ++i)
298 pack_lhs_panel(blockA, _other+absolute_j2*otherStride+i2, otherStride,
299 actualPanelWidth, actual_mc,
305 gebp_kernel(_other+i2+startPanel*otherStride, otherStride, blockA, geb,
306 actual_mc, actual_kc, rs, Scalar(-1),
307 -1, -1, 0, 0, blockW);
317 #endif // EIGEN_TRIANGULAR_SOLVER_MATRIX_H