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>
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 template <
typename Scalar,
typename Index,
int Mode,
bool Conjugate,
int TriStorageOrder>
48 EIGEN_DONT_INLINE
void triangular_solve_matrix<Scalar,Index,OnTheLeft,Mode,Conjugate,TriStorageOrder,ColMajor>::run(
49 Index size, Index otherSize,
50 const Scalar* _tri, Index triStride,
51 Scalar* _other, Index otherStride,
52 level3_blocking<Scalar,Scalar>& blocking)
54 Index cols = otherSize;
56 typedef const_blas_data_mapper<Scalar, Index, TriStorageOrder> TriMapper;
57 typedef blas_data_mapper<Scalar, Index, ColMajor> OtherMapper;
58 TriMapper tri(_tri, triStride);
59 OtherMapper other(_other, otherStride);
61 typedef gebp_traits<Scalar,Scalar> Traits;
64 SmallPanelWidth = EIGEN_PLAIN_ENUM_MAX(Traits::mr,Traits::nr),
68 Index kc = blocking.kc();
69 Index mc = (std::min)(size,blocking.mc());
71 std::size_t sizeA = kc*mc;
72 std::size_t sizeB = kc*cols;
74 ei_declare_aligned_stack_constructed_variable(Scalar, blockA, sizeA, blocking.blockA());
75 ei_declare_aligned_stack_constructed_variable(Scalar, blockB, sizeB, blocking.blockB());
77 conj_if<Conjugate> conj;
78 gebp_kernel<Scalar, Scalar, Index, OtherMapper, Traits::mr, Traits::nr, Conjugate, false> gebp_kernel;
79 gemm_pack_lhs<Scalar, Index, TriMapper, Traits::mr, Traits::LhsProgress, TriStorageOrder> pack_lhs;
80 gemm_pack_rhs<Scalar, Index, OtherMapper, Traits::nr, ColMajor, false, true> pack_rhs;
84 std::ptrdiff_t l1, l2, l3;
85 manage_caching_sizes(GetAction, &l1, &l2, &l3);
86 Index subcols = cols>0 ? l2/(4 *
sizeof(Scalar) * otherStride) : 0;
87 subcols = std::max<Index>((subcols/Traits::nr)*Traits::nr, Traits::nr);
89 for(Index k2=IsLower ? 0 : size;
90 IsLower ? k2<size : k2>0;
91 IsLower ? k2+=kc : k2-=kc)
93 const Index actual_kc = (std::min)(IsLower ? size-k2 : k2, kc);
108 for(Index j2=0; j2<cols; j2+=subcols)
110 Index actual_cols = (std::min)(cols-j2,subcols);
112 for (Index k1=0; k1<actual_kc; k1+=SmallPanelWidth)
114 Index actualPanelWidth = std::min<Index>(actual_kc-k1, SmallPanelWidth);
116 for (Index k=0; k<actualPanelWidth; ++k)
119 Index i = IsLower ? k2+k1+k : k2-k1-k-1;
120 Index rs = actualPanelWidth - k - 1;
121 Index s = TriStorageOrder==
RowMajor ? (IsLower ? k2+k1 : i+1)
122 : IsLower ? i+1 : i-rs;
124 Scalar a = (Mode &
UnitDiag) ? Scalar(1) : Scalar(1)/conj(tri(i,i));
125 for (Index j=j2; j<j2+actual_cols; ++j)
130 const Scalar* l = &tri(i,s);
131 Scalar* r = &other(s,j);
132 for (Index i3=0; i3<k; ++i3)
133 b += conj(l[i3]) * r[i3];
135 other(i,j) = (other(i,j) - b)*a;
139 Scalar b = (other(i,j) *= a);
140 Scalar* r = &other(s,j);
141 const Scalar* l = &tri(s,i);
142 for (Index i3=0;i3<rs;++i3)
143 r[i3] -= b * conj(l[i3]);
148 Index lengthTarget = actual_kc-k1-actualPanelWidth;
149 Index startBlock = IsLower ? k2+k1 : k2-k1-actualPanelWidth;
150 Index blockBOffset = IsLower ? k1 : lengthTarget;
153 pack_rhs(blockB+actual_kc*j2, other.getSubMapper(startBlock,j2), actualPanelWidth, actual_cols, actual_kc, blockBOffset);
158 Index startTarget = IsLower ? k2+k1+actualPanelWidth : k2-actual_kc;
160 pack_lhs(blockA, tri.getSubMapper(startTarget,startBlock), actualPanelWidth, lengthTarget);
162 gebp_kernel(other.getSubMapper(startTarget,j2), blockA, blockB+actual_kc*j2, lengthTarget, actualPanelWidth, actual_cols, Scalar(-1),
163 actualPanelWidth, actual_kc, 0, blockBOffset);
170 Index start = IsLower ? k2+kc : 0;
171 Index end = IsLower ? size : k2-kc;
172 for(Index i2=start; i2<end; i2+=mc)
174 const Index actual_mc = (std::min)(mc,end-i2);
177 pack_lhs(blockA, tri.getSubMapper(i2, IsLower ? k2 : k2-kc), actual_kc, actual_mc);
179 gebp_kernel(other.getSubMapper(i2, 0), blockA, blockB, actual_mc, actual_kc, cols, Scalar(-1), -1, -1, 0, 0);
188 template <
typename Scalar,
typename Index,
int Mode,
bool Conjugate,
int TriStorageOrder>
189 struct triangular_solve_matrix<Scalar,Index,
OnTheRight,Mode,Conjugate,TriStorageOrder,
ColMajor>
191 static EIGEN_DONT_INLINE
void run(
192 Index size, Index otherSize,
193 const Scalar* _tri, Index triStride,
194 Scalar* _other, Index otherStride,
195 level3_blocking<Scalar,Scalar>& blocking);
197 template <
typename Scalar,
typename Index,
int Mode,
bool Conjugate,
int TriStorageOrder>
198 EIGEN_DONT_INLINE
void triangular_solve_matrix<Scalar,Index,OnTheRight,Mode,Conjugate,TriStorageOrder,ColMajor>::run(
199 Index size, Index otherSize,
200 const Scalar* _tri, Index triStride,
201 Scalar* _other, Index otherStride,
202 level3_blocking<Scalar,Scalar>& blocking)
204 Index rows = otherSize;
206 typedef blas_data_mapper<Scalar, Index, ColMajor> LhsMapper;
207 typedef const_blas_data_mapper<Scalar, Index, TriStorageOrder> RhsMapper;
208 LhsMapper lhs(_other, otherStride);
209 RhsMapper rhs(_tri, triStride);
211 typedef gebp_traits<Scalar,Scalar> Traits;
213 RhsStorageOrder = TriStorageOrder,
214 SmallPanelWidth = EIGEN_PLAIN_ENUM_MAX(Traits::mr,Traits::nr),
218 Index kc = blocking.kc();
219 Index mc = (std::min)(rows,blocking.mc());
221 std::size_t sizeA = kc*mc;
222 std::size_t sizeB = kc*size;
224 ei_declare_aligned_stack_constructed_variable(Scalar, blockA, sizeA, blocking.blockA());
225 ei_declare_aligned_stack_constructed_variable(Scalar, blockB, sizeB, blocking.blockB());
227 conj_if<Conjugate> conj;
228 gebp_kernel<Scalar, Scalar, Index, LhsMapper, Traits::mr, Traits::nr, false, Conjugate> gebp_kernel;
229 gemm_pack_rhs<Scalar, Index, RhsMapper, Traits::nr, RhsStorageOrder> pack_rhs;
230 gemm_pack_rhs<Scalar, Index, RhsMapper, Traits::nr, RhsStorageOrder,false,true> pack_rhs_panel;
231 gemm_pack_lhs<Scalar, Index, LhsMapper, Traits::mr, Traits::LhsProgress, ColMajor, false, true> pack_lhs_panel;
233 for(Index k2=IsLower ? size : 0;
234 IsLower ? k2>0 : k2<size;
235 IsLower ? k2-=kc : k2+=kc)
237 const Index actual_kc = (std::min)(IsLower ? k2 : size-k2, kc);
238 Index actual_k2 = IsLower ? k2-actual_kc : k2 ;
240 Index startPanel = IsLower ? 0 : k2+actual_kc;
241 Index rs = IsLower ? actual_k2 : size - actual_k2 - actual_kc;
242 Scalar* geb = blockB+actual_kc*actual_kc;
244 if (rs>0) pack_rhs(geb, rhs.getSubMapper(actual_k2,startPanel), actual_kc, rs);
249 for (Index j2=0; j2<actual_kc; j2+=SmallPanelWidth)
251 Index actualPanelWidth = std::min<Index>(actual_kc-j2, SmallPanelWidth);
252 Index actual_j2 = actual_k2 + j2;
253 Index panelOffset = IsLower ? j2+actualPanelWidth : 0;
254 Index panelLength = IsLower ? actual_kc-j2-actualPanelWidth : j2;
257 pack_rhs_panel(blockB+j2*actual_kc,
258 rhs.getSubMapper(actual_k2+panelOffset, actual_j2),
259 panelLength, actualPanelWidth,
260 actual_kc, panelOffset);
264 for(Index i2=0; i2<rows; i2+=mc)
266 const Index actual_mc = (std::min)(mc,rows-i2);
271 for (Index j2 = IsLower
272 ? (actual_kc - ((actual_kc%SmallPanelWidth) ? Index(actual_kc%SmallPanelWidth)
273 : Index(SmallPanelWidth)))
275 IsLower ? j2>=0 : j2<actual_kc;
276 IsLower ? j2-=SmallPanelWidth : j2+=SmallPanelWidth)
278 Index actualPanelWidth = std::min<Index>(actual_kc-j2, SmallPanelWidth);
279 Index absolute_j2 = actual_k2 + j2;
280 Index panelOffset = IsLower ? j2+actualPanelWidth : 0;
281 Index panelLength = IsLower ? actual_kc - j2 - actualPanelWidth : j2;
286 gebp_kernel(lhs.getSubMapper(i2,absolute_j2),
287 blockA, blockB+j2*actual_kc,
288 actual_mc, panelLength, actualPanelWidth,
290 actual_kc, actual_kc,
291 panelOffset, panelOffset);
295 for (Index k=0; k<actualPanelWidth; ++k)
297 Index j = IsLower ? absolute_j2+actualPanelWidth-k-1 : absolute_j2+k;
299 Scalar* r = &lhs(i2,j);
300 for (Index k3=0; k3<k; ++k3)
302 Scalar b = conj(rhs(IsLower ? j+1+k3 : absolute_j2+k3,j));
303 Scalar* a = &lhs(i2,IsLower ? j+1+k3 : absolute_j2+k3);
304 for (Index i=0; i<actual_mc; ++i)
309 Scalar b = conj(rhs(j,j));
310 for (Index i=0; i<actual_mc; ++i)
316 pack_lhs_panel(blockA, LhsMapper(_other+absolute_j2*otherStride+i2, otherStride),
317 actualPanelWidth, actual_mc,
323 gebp_kernel(lhs.getSubMapper(i2, startPanel), blockA, geb,
324 actual_mc, actual_kc, rs, Scalar(-1),
334 #endif // EIGEN_TRIANGULAR_SOLVER_MATRIX_H
Definition: Constants.h:208
Definition: Constants.h:206
Definition: Constants.h:320
Definition: Constants.h:335
Definition: Constants.h:322
Definition: Constants.h:204
Definition: Eigen_Colamd.h:54
Definition: Constants.h:333