Eigen  3.4.1 (git rev 28ded8800c26864e537852658428ab44c8399e87)
 
Loading...
Searching...
No Matches
InverseSize4.h
1// This file is part of Eigen, a lightweight C++ template library
2// for linear algebra.
3//
4// Copyright (C) 2001 Intel Corporation
5// Copyright (C) 2010 Gael Guennebaud <gael.guennebaud@inria.fr>
6// Copyright (C) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
7//
8// This Source Code Form is subject to the terms of the Mozilla
9// Public License v. 2.0. If a copy of the MPL was not distributed
10// with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
11//
12// The algorithm below is a reimplementation of former \src\LU\Inverse_SSE.h using PacketMath.
13// inv(M) = M#/|M|, where inv(M), M# and |M| denote the inverse of M,
14// adjugate of M and determinant of M respectively. M# is computed block-wise
15// using specific formulae. For proof, see:
16// https://lxjk.github.io/2017/09/03/Fast-4x4-Matrix-Inverse-with-SSE-SIMD-Explained.html
17// Variable names are adopted from \src\LU\Inverse_SSE.h.
18//
19// The SSE code for the 4x4 float and double matrix inverse in former (deprecated) \src\LU\Inverse_SSE.h
20// comes from the following Intel's library:
21// http://software.intel.com/en-us/articles/optimized-matrix-library-for-use-with-the-intel-pentiumr-4-processors-sse2-instructions/
22//
23// Here is the respective copyright and license statement:
24//
25// Copyright (c) 2001 Intel Corporation.
26//
27// Permition is granted to use, copy, distribute and prepare derivative works
28// of this library for any purpose and without fee, provided, that the above
29// copyright notice and this statement appear in all copies.
30// Intel makes no representations about the suitability of this software for
31// any purpose, and specifically disclaims all warranties.
32// See LEGAL.TXT for all the legal information.
33//
34// TODO: Unify implementations of different data types (i.e. float and double).
35#ifndef EIGEN_INVERSE_SIZE_4_H
36#define EIGEN_INVERSE_SIZE_4_H
37
38#if EIGEN_COMP_GNUC_STRICT
39// These routines requires bit manipulation of the sign, which is not compatible
40// with fastmath.
41#pragma GCC push_options
42#pragma GCC optimize ("no-fast-math")
43#endif
44
45namespace Eigen
46{
47namespace internal
48{
49template <typename MatrixType, typename ResultType>
50struct compute_inverse_size4<Architecture::Target, float, MatrixType, ResultType>
51{
52 enum
53 {
54 MatrixAlignment = traits<MatrixType>::Alignment,
55 ResultAlignment = traits<ResultType>::Alignment,
56 StorageOrdersMatch = (MatrixType::Flags & RowMajorBit) == (ResultType::Flags & RowMajorBit)
57 };
58 typedef typename conditional<(MatrixType::Flags & LinearAccessBit), MatrixType const &, typename MatrixType::PlainObject>::type ActualMatrixType;
59
60 static void run(const MatrixType &mat, ResultType &result)
61 {
62 ActualMatrixType matrix(mat);
63
64 const float* data = matrix.data();
65 const Index stride = matrix.innerStride();
66 Packet4f _L1 = ploadt<Packet4f,MatrixAlignment>(data);
67 Packet4f _L2 = ploadt<Packet4f,MatrixAlignment>(data + stride*4);
68 Packet4f _L3 = ploadt<Packet4f,MatrixAlignment>(data + stride*8);
69 Packet4f _L4 = ploadt<Packet4f,MatrixAlignment>(data + stride*12);
70
71 // Four 2x2 sub-matrices of the input matrix
72 // input = [[A, B],
73 // [C, D]]
74 Packet4f A, B, C, D;
75
76 if (!StorageOrdersMatch)
77 {
78 A = vec4f_unpacklo(_L1, _L2);
79 B = vec4f_unpacklo(_L3, _L4);
80 C = vec4f_unpackhi(_L1, _L2);
81 D = vec4f_unpackhi(_L3, _L4);
82 }
83 else
84 {
85 A = vec4f_movelh(_L1, _L2);
86 B = vec4f_movehl(_L2, _L1);
87 C = vec4f_movelh(_L3, _L4);
88 D = vec4f_movehl(_L4, _L3);
89 }
90
91 Packet4f AB, DC;
92
93 // AB = A# * B, where A# denotes the adjugate of A, and * denotes matrix product.
94 AB = pmul(vec4f_swizzle2(A, A, 3, 3, 0, 0), B);
95 AB = psub(AB, pmul(vec4f_swizzle2(A, A, 1, 1, 2, 2), vec4f_swizzle2(B, B, 2, 3, 0, 1)));
96
97 // DC = D#*C
98 DC = pmul(vec4f_swizzle2(D, D, 3, 3, 0, 0), C);
99 DC = psub(DC, pmul(vec4f_swizzle2(D, D, 1, 1, 2, 2), vec4f_swizzle2(C, C, 2, 3, 0, 1)));
100
101 // determinants of the sub-matrices
102 Packet4f dA, dB, dC, dD;
103
104 dA = pmul(vec4f_swizzle2(A, A, 3, 3, 1, 1), A);
105 dA = psub(dA, vec4f_movehl(dA, dA));
106
107 dB = pmul(vec4f_swizzle2(B, B, 3, 3, 1, 1), B);
108 dB = psub(dB, vec4f_movehl(dB, dB));
109
110 dC = pmul(vec4f_swizzle2(C, C, 3, 3, 1, 1), C);
111 dC = psub(dC, vec4f_movehl(dC, dC));
112
113 dD = pmul(vec4f_swizzle2(D, D, 3, 3, 1, 1), D);
114 dD = psub(dD, vec4f_movehl(dD, dD));
115
116 Packet4f d, d1, d2;
117
118 d = pmul(vec4f_swizzle2(DC, DC, 0, 2, 1, 3), AB);
119 d = padd(d, vec4f_movehl(d, d));
120 d = padd(d, vec4f_swizzle2(d, d, 1, 0, 0, 0));
121 d1 = pmul(dA, dD);
122 d2 = pmul(dB, dC);
123
124 // determinant of the input matrix, det = |A||D| + |B||C| - trace(A#*B*D#*C)
125 Packet4f det = vec4f_duplane(psub(padd(d1, d2), d), 0);
126
127 // reciprocal of the determinant of the input matrix, rd = 1/det
128 Packet4f rd = pdiv(pset1<Packet4f>(1.0f), det);
129
130 // Four sub-matrices of the inverse
131 Packet4f iA, iB, iC, iD;
132
133 // iD = D*|A| - C*A#*B
134 iD = pmul(vec4f_swizzle2(C, C, 0, 0, 2, 2), vec4f_movelh(AB, AB));
135 iD = padd(iD, pmul(vec4f_swizzle2(C, C, 1, 1, 3, 3), vec4f_movehl(AB, AB)));
136 iD = psub(pmul(D, vec4f_duplane(dA, 0)), iD);
137
138 // iA = A*|D| - B*D#*C
139 iA = pmul(vec4f_swizzle2(B, B, 0, 0, 2, 2), vec4f_movelh(DC, DC));
140 iA = padd(iA, pmul(vec4f_swizzle2(B, B, 1, 1, 3, 3), vec4f_movehl(DC, DC)));
141 iA = psub(pmul(A, vec4f_duplane(dD, 0)), iA);
142
143 // iB = C*|B| - D * (A#B)# = C*|B| - D*B#*A
144 iB = pmul(D, vec4f_swizzle2(AB, AB, 3, 0, 3, 0));
145 iB = psub(iB, pmul(vec4f_swizzle2(D, D, 1, 0, 3, 2), vec4f_swizzle2(AB, AB, 2, 1, 2, 1)));
146 iB = psub(pmul(C, vec4f_duplane(dB, 0)), iB);
147
148 // iC = B*|C| - A * (D#C)# = B*|C| - A*C#*D
149 iC = pmul(A, vec4f_swizzle2(DC, DC, 3, 0, 3, 0));
150 iC = psub(iC, pmul(vec4f_swizzle2(A, A, 1, 0, 3, 2), vec4f_swizzle2(DC, DC, 2, 1, 2, 1)));
151 iC = psub(pmul(B, vec4f_duplane(dC, 0)), iC);
152
153 EIGEN_ALIGN_MAX const float sign_mask[4] = {0.0f, -0.0f, -0.0f, 0.0f};
154 const Packet4f p4f_sign_PNNP = pload<Packet4f>(sign_mask);
155 rd = pxor(rd, p4f_sign_PNNP);
156 iA = pmul(iA, rd);
157 iB = pmul(iB, rd);
158 iC = pmul(iC, rd);
159 iD = pmul(iD, rd);
160
161 Index res_stride = result.outerStride();
162 float *res = result.data();
163
164 pstoret<float, Packet4f, ResultAlignment>(res + 0, vec4f_swizzle2(iA, iB, 3, 1, 3, 1));
165 pstoret<float, Packet4f, ResultAlignment>(res + res_stride, vec4f_swizzle2(iA, iB, 2, 0, 2, 0));
166 pstoret<float, Packet4f, ResultAlignment>(res + 2 * res_stride, vec4f_swizzle2(iC, iD, 3, 1, 3, 1));
167 pstoret<float, Packet4f, ResultAlignment>(res + 3 * res_stride, vec4f_swizzle2(iC, iD, 2, 0, 2, 0));
168 }
169};
170
171#if !(defined EIGEN_VECTORIZE_NEON && !(EIGEN_ARCH_ARM64 && !EIGEN_APPLE_DOUBLE_NEON_BUG))
172// same algorithm as above, except that each operand is split into
173// halves for two registers to hold.
174template <typename MatrixType, typename ResultType>
175struct compute_inverse_size4<Architecture::Target, double, MatrixType, ResultType>
176{
177 enum
178 {
179 MatrixAlignment = traits<MatrixType>::Alignment,
180 ResultAlignment = traits<ResultType>::Alignment,
181 StorageOrdersMatch = (MatrixType::Flags & RowMajorBit) == (ResultType::Flags & RowMajorBit)
182 };
183 typedef typename conditional<(MatrixType::Flags & LinearAccessBit),
184 MatrixType const &,
185 typename MatrixType::PlainObject>::type
186 ActualMatrixType;
187
188 static void run(const MatrixType &mat, ResultType &result)
189 {
190 ActualMatrixType matrix(mat);
191
192 // Four 2x2 sub-matrices of the input matrix, each is further divided into upper and lower
193 // row e.g. A1, upper row of A, A2, lower row of A
194 // input = [[A, B], = [[[A1, [B1,
195 // [C, D]] A2], B2]],
196 // [[C1, [D1,
197 // C2], D2]]]
198
199 Packet2d A1, A2, B1, B2, C1, C2, D1, D2;
200
201 const double* data = matrix.data();
202 const Index stride = matrix.innerStride();
203 if (StorageOrdersMatch)
204 {
205 A1 = ploadt<Packet2d,MatrixAlignment>(data + stride*0);
206 B1 = ploadt<Packet2d,MatrixAlignment>(data + stride*2);
207 A2 = ploadt<Packet2d,MatrixAlignment>(data + stride*4);
208 B2 = ploadt<Packet2d,MatrixAlignment>(data + stride*6);
209 C1 = ploadt<Packet2d,MatrixAlignment>(data + stride*8);
210 D1 = ploadt<Packet2d,MatrixAlignment>(data + stride*10);
211 C2 = ploadt<Packet2d,MatrixAlignment>(data + stride*12);
212 D2 = ploadt<Packet2d,MatrixAlignment>(data + stride*14);
213 }
214 else
215 {
216 Packet2d temp;
217 A1 = ploadt<Packet2d,MatrixAlignment>(data + stride*0);
218 C1 = ploadt<Packet2d,MatrixAlignment>(data + stride*2);
219 A2 = ploadt<Packet2d,MatrixAlignment>(data + stride*4);
220 C2 = ploadt<Packet2d,MatrixAlignment>(data + stride*6);
221 temp = A1;
222 A1 = vec2d_unpacklo(A1, A2);
223 A2 = vec2d_unpackhi(temp, A2);
224
225 temp = C1;
226 C1 = vec2d_unpacklo(C1, C2);
227 C2 = vec2d_unpackhi(temp, C2);
228
229 B1 = ploadt<Packet2d,MatrixAlignment>(data + stride*8);
230 D1 = ploadt<Packet2d,MatrixAlignment>(data + stride*10);
231 B2 = ploadt<Packet2d,MatrixAlignment>(data + stride*12);
232 D2 = ploadt<Packet2d,MatrixAlignment>(data + stride*14);
233
234 temp = B1;
235 B1 = vec2d_unpacklo(B1, B2);
236 B2 = vec2d_unpackhi(temp, B2);
237
238 temp = D1;
239 D1 = vec2d_unpacklo(D1, D2);
240 D2 = vec2d_unpackhi(temp, D2);
241 }
242
243 // determinants of the sub-matrices
244 Packet2d dA, dB, dC, dD;
245
246 dA = vec2d_swizzle2(A2, A2, 1);
247 dA = pmul(A1, dA);
248 dA = psub(dA, vec2d_duplane(dA, 1));
249
250 dB = vec2d_swizzle2(B2, B2, 1);
251 dB = pmul(B1, dB);
252 dB = psub(dB, vec2d_duplane(dB, 1));
253
254 dC = vec2d_swizzle2(C2, C2, 1);
255 dC = pmul(C1, dC);
256 dC = psub(dC, vec2d_duplane(dC, 1));
257
258 dD = vec2d_swizzle2(D2, D2, 1);
259 dD = pmul(D1, dD);
260 dD = psub(dD, vec2d_duplane(dD, 1));
261
262 Packet2d DC1, DC2, AB1, AB2;
263
264 // AB = A# * B, where A# denotes the adjugate of A, and * denotes matrix product.
265 AB1 = pmul(B1, vec2d_duplane(A2, 1));
266 AB2 = pmul(B2, vec2d_duplane(A1, 0));
267 AB1 = psub(AB1, pmul(B2, vec2d_duplane(A1, 1)));
268 AB2 = psub(AB2, pmul(B1, vec2d_duplane(A2, 0)));
269
270 // DC = D#*C
271 DC1 = pmul(C1, vec2d_duplane(D2, 1));
272 DC2 = pmul(C2, vec2d_duplane(D1, 0));
273 DC1 = psub(DC1, pmul(C2, vec2d_duplane(D1, 1)));
274 DC2 = psub(DC2, pmul(C1, vec2d_duplane(D2, 0)));
275
276 Packet2d d1, d2;
277
278 // determinant of the input matrix, det = |A||D| + |B||C| - trace(A#*B*D#*C)
279 Packet2d det;
280
281 // reciprocal of the determinant of the input matrix, rd = 1/det
282 Packet2d rd;
283
284 d1 = pmul(AB1, vec2d_swizzle2(DC1, DC2, 0));
285 d2 = pmul(AB2, vec2d_swizzle2(DC1, DC2, 3));
286 rd = padd(d1, d2);
287 rd = padd(rd, vec2d_duplane(rd, 1));
288
289 d1 = pmul(dA, dD);
290 d2 = pmul(dB, dC);
291
292 det = padd(d1, d2);
293 det = psub(det, rd);
294 det = vec2d_duplane(det, 0);
295 rd = pdiv(pset1<Packet2d>(1.0), det);
296
297 // rows of four sub-matrices of the inverse
298 Packet2d iA1, iA2, iB1, iB2, iC1, iC2, iD1, iD2;
299
300 // iD = D*|A| - C*A#*B
301 iD1 = pmul(AB1, vec2d_duplane(C1, 0));
302 iD2 = pmul(AB1, vec2d_duplane(C2, 0));
303 iD1 = padd(iD1, pmul(AB2, vec2d_duplane(C1, 1)));
304 iD2 = padd(iD2, pmul(AB2, vec2d_duplane(C2, 1)));
305 dA = vec2d_duplane(dA, 0);
306 iD1 = psub(pmul(D1, dA), iD1);
307 iD2 = psub(pmul(D2, dA), iD2);
308
309 // iA = A*|D| - B*D#*C
310 iA1 = pmul(DC1, vec2d_duplane(B1, 0));
311 iA2 = pmul(DC1, vec2d_duplane(B2, 0));
312 iA1 = padd(iA1, pmul(DC2, vec2d_duplane(B1, 1)));
313 iA2 = padd(iA2, pmul(DC2, vec2d_duplane(B2, 1)));
314 dD = vec2d_duplane(dD, 0);
315 iA1 = psub(pmul(A1, dD), iA1);
316 iA2 = psub(pmul(A2, dD), iA2);
317
318 // iB = C*|B| - D * (A#B)# = C*|B| - D*B#*A
319 iB1 = pmul(D1, vec2d_swizzle2(AB2, AB1, 1));
320 iB2 = pmul(D2, vec2d_swizzle2(AB2, AB1, 1));
321 iB1 = psub(iB1, pmul(vec2d_swizzle2(D1, D1, 1), vec2d_swizzle2(AB2, AB1, 2)));
322 iB2 = psub(iB2, pmul(vec2d_swizzle2(D2, D2, 1), vec2d_swizzle2(AB2, AB1, 2)));
323 dB = vec2d_duplane(dB, 0);
324 iB1 = psub(pmul(C1, dB), iB1);
325 iB2 = psub(pmul(C2, dB), iB2);
326
327 // iC = B*|C| - A * (D#C)# = B*|C| - A*C#*D
328 iC1 = pmul(A1, vec2d_swizzle2(DC2, DC1, 1));
329 iC2 = pmul(A2, vec2d_swizzle2(DC2, DC1, 1));
330 iC1 = psub(iC1, pmul(vec2d_swizzle2(A1, A1, 1), vec2d_swizzle2(DC2, DC1, 2)));
331 iC2 = psub(iC2, pmul(vec2d_swizzle2(A2, A2, 1), vec2d_swizzle2(DC2, DC1, 2)));
332 dC = vec2d_duplane(dC, 0);
333 iC1 = psub(pmul(B1, dC), iC1);
334 iC2 = psub(pmul(B2, dC), iC2);
335
336 EIGEN_ALIGN_MAX const double sign_mask1[2] = {0.0, -0.0};
337 EIGEN_ALIGN_MAX const double sign_mask2[2] = {-0.0, 0.0};
338 const Packet2d sign_PN = pload<Packet2d>(sign_mask1);
339 const Packet2d sign_NP = pload<Packet2d>(sign_mask2);
340 d1 = pxor(rd, sign_PN);
341 d2 = pxor(rd, sign_NP);
342
343 Index res_stride = result.outerStride();
344 double *res = result.data();
345 pstoret<double, Packet2d, ResultAlignment>(res + 0, pmul(vec2d_swizzle2(iA2, iA1, 3), d1));
346 pstoret<double, Packet2d, ResultAlignment>(res + res_stride, pmul(vec2d_swizzle2(iA2, iA1, 0), d2));
347 pstoret<double, Packet2d, ResultAlignment>(res + 2, pmul(vec2d_swizzle2(iB2, iB1, 3), d1));
348 pstoret<double, Packet2d, ResultAlignment>(res + res_stride + 2, pmul(vec2d_swizzle2(iB2, iB1, 0), d2));
349 pstoret<double, Packet2d, ResultAlignment>(res + 2 * res_stride, pmul(vec2d_swizzle2(iC2, iC1, 3), d1));
350 pstoret<double, Packet2d, ResultAlignment>(res + 3 * res_stride, pmul(vec2d_swizzle2(iC2, iC1, 0), d2));
351 pstoret<double, Packet2d, ResultAlignment>(res + 2 * res_stride + 2, pmul(vec2d_swizzle2(iD2, iD1, 3), d1));
352 pstoret<double, Packet2d, ResultAlignment>(res + 3 * res_stride + 2, pmul(vec2d_swizzle2(iD2, iD1, 0), d2));
353 }
354};
355#endif
356} // namespace internal
357} // namespace Eigen
358
359#if EIGEN_COMP_GNUC_STRICT
360#pragma GCC pop_options
361#endif
362
363#endif
Eigen::LinearAccessBit
const unsigned int LinearAccessBit
Definition Constants.h:130
Eigen::RowMajorBit
const unsigned int RowMajorBit
Definition Constants.h:66
Eigen
Namespace containing all symbols from the Eigen library.
Definition B01_Experimental.dox:1
Eigen::Index
EIGEN_DEFAULT_DENSE_INDEX_TYPE Index
The Index type as used for the API.
Definition Meta.h:74