Logo ROOT  

Reference Guide
 
Loading...
Searching...
No Matches
CramerInversionSym.icc
Go to the documentation of this file.
1// @(#)root/smatrix:$Id$
2// Authors: L. Moneta 2005
3
4
5/**********************************************************************
6 * *
7 * Copyright (c) 2005 , LCG ROOT MathLib Team *
8 * *
9 * *
10 **********************************************************************/
11//
12// Cramer optimized inversion for symmetric matrices up to size 5x5.
13// Code from ROOT TMatrixDCramerInv which originates from CLHEP
14// (original author Mark Fischler)
15//
16// Modified by L. Moneta 22/03/07: specialize only until 5x5 (before was up to 6x6)
17// tests show that on 64 machines (like on slc4) it is faster the general method
18//
19
20#ifndef ROOT_Math_CramerInversionSym_icc
21#define ROOT_Math_CramerInversionSym_icc
22
23#ifndef ROOT_Math_Dinv
24#error "Do not use CramerInversionSym.icc directly. #include \"Math/Dinv.h\" instead."
25#endif // ROOT_Math_Dinv
26
27#include <cmath>
28
29
30namespace ROOT {
31
32 namespace Math {
33
34
35
36
37//==============================================================================
38/**
39 Inversion for a 3x3 symmetric matrix
40 */
41template <class T>
42bool FastInverter<3>::Dinv(MatRepSym<T,3> & rhs) {
43
44 typedef T Scalar;
45
46 // check matrix sizes ??
47
48
49 const Scalar c00 = rhs[4] * rhs[8] - rhs[5] * rhs[5];
50 const Scalar c01 = rhs[5] * rhs[2] - rhs[1] * rhs[8];
51 const Scalar c02 = rhs[1] * rhs[5] - rhs[4] * rhs[2];
52 const Scalar c11 = rhs[8] * rhs[0] - rhs[2] * rhs[2];
53 const Scalar c12 = rhs[2] * rhs[1] - rhs[5] * rhs[0];
54 const Scalar c22 = rhs[0] * rhs[4] - rhs[1] * rhs[1];
55
56 const Scalar t0 = std::abs(rhs[0]);
57 const Scalar t1 = std::abs(rhs[1]);
58 const Scalar t2 = std::abs(rhs[2]);
59
60 Scalar det;
61 Scalar tmp;
62
63 if (t0 >= t1) {
64 if (t2 >= t0) {
65 tmp = rhs[2];
66 det = c12*c01-c11*c02;
67 } else {
68 tmp = rhs[0];
69 det = c11*c22-c12*c12;
70 }
71 } else if (t2 >= t1) {
72 tmp = rhs[2];
73 det = c12*c01-c11*c02;
74 } else {
75 tmp = rhs[1];
76 det = c02*c12-c01*c22;
77 }
78
79 if ( det == 0 || tmp == 0)
80 return false;
81
82 Scalar s = tmp/det;
83// if (determ)
84// *determ = 1./s;
85
86 rhs[0] = s*c00;
87 rhs[1] = s*c01;
88 rhs[2] = s*c02;
89 rhs[4] = s*c11;
90 rhs[5] = s*c12;
91 rhs[8] = s*c22;
92
93 return true;
94}
95
96
97//==============================================================================
98// Inversion for 4x4 matrices
99//==============================================================================
100
101// SFij are indices for a 4x4 symmetric matrix.
102
103#define SF00 0
104#define SF01 1
105#define SF02 2
106#define SF03 3
107
108#define SF10 1
109#define SF11 5
110#define SF12 6
111#define SF13 7
112
113#define SF20 2
114#define SF21 6
115#define SF22 10
116#define SF23 11
117
118#define SF30 3
119#define SF31 7
120#define SF32 11
121#define SF33 15
122
123
124/**
125 Inversion for a 4x4 symmetric matrix
126 */
127template <class T>
128bool FastInverter<4>::Dinv(MatRepSym<T,4> & rhs) {
129
130 typedef T Scalar;
131
132
133 // Find all NECESSARY 2x2 dets: (14 of them)
134
135 const Scalar mDet2_12_01 = rhs[SF10]*rhs[SF21] - rhs[SF11]*rhs[SF20];
136 const Scalar mDet2_12_02 = rhs[SF10]*rhs[SF22] - rhs[SF12]*rhs[SF20];
137 const Scalar mDet2_12_12 = rhs[SF11]*rhs[SF22] - rhs[SF12]*rhs[SF21];
138 const Scalar mDet2_13_01 = rhs[SF10]*rhs[SF31] - rhs[SF11]*rhs[SF30];
139 const Scalar mDet2_13_02 = rhs[SF10]*rhs[SF32] - rhs[SF12]*rhs[SF30];
140 const Scalar mDet2_13_03 = rhs[SF10]*rhs[SF33] - rhs[SF13]*rhs[SF30];
141 const Scalar mDet2_13_12 = rhs[SF11]*rhs[SF32] - rhs[SF12]*rhs[SF31];
142 const Scalar mDet2_13_13 = rhs[SF11]*rhs[SF33] - rhs[SF13]*rhs[SF31];
143 const Scalar mDet2_23_01 = rhs[SF20]*rhs[SF31] - rhs[SF21]*rhs[SF30];
144 const Scalar mDet2_23_02 = rhs[SF20]*rhs[SF32] - rhs[SF22]*rhs[SF30];
145 const Scalar mDet2_23_03 = rhs[SF20]*rhs[SF33] - rhs[SF23]*rhs[SF30];
146 const Scalar mDet2_23_12 = rhs[SF21]*rhs[SF32] - rhs[SF22]*rhs[SF31];
147 const Scalar mDet2_23_13 = rhs[SF21]*rhs[SF33] - rhs[SF23]*rhs[SF31];
148 const Scalar mDet2_23_23 = rhs[SF22]*rhs[SF33] - rhs[SF23]*rhs[SF32];
149
150 // SFind all NECESSSFRY 3x3 dets: (10 of them)
151
152 const Scalar mDet3_012_012 = rhs[SF00]*mDet2_12_12 - rhs[SF01]*mDet2_12_02
153 + rhs[SF02]*mDet2_12_01;
154 const Scalar mDet3_013_012 = rhs[SF00]*mDet2_13_12 - rhs[SF01]*mDet2_13_02
155 + rhs[SF02]*mDet2_13_01;
156 const Scalar mDet3_013_013 = rhs[SF00]*mDet2_13_13 - rhs[SF01]*mDet2_13_03
157 + rhs[SF03]*mDet2_13_01;
158 const Scalar mDet3_023_012 = rhs[SF00]*mDet2_23_12 - rhs[SF01]*mDet2_23_02
159 + rhs[SF02]*mDet2_23_01;
160 const Scalar mDet3_023_013 = rhs[SF00]*mDet2_23_13 - rhs[SF01]*mDet2_23_03
161 + rhs[SF03]*mDet2_23_01;
162 const Scalar mDet3_023_023 = rhs[SF00]*mDet2_23_23 - rhs[SF02]*mDet2_23_03
163 + rhs[SF03]*mDet2_23_02;
164 const Scalar mDet3_123_012 = rhs[SF10]*mDet2_23_12 - rhs[SF11]*mDet2_23_02
165 + rhs[SF12]*mDet2_23_01;
166 const Scalar mDet3_123_013 = rhs[SF10]*mDet2_23_13 - rhs[SF11]*mDet2_23_03
167 + rhs[SF13]*mDet2_23_01;
168 const Scalar mDet3_123_023 = rhs[SF10]*mDet2_23_23 - rhs[SF12]*mDet2_23_03
169 + rhs[SF13]*mDet2_23_02;
170 const Scalar mDet3_123_123 = rhs[SF11]*mDet2_23_23 - rhs[SF12]*mDet2_23_13
171 + rhs[SF13]*mDet2_23_12;
172
173 // Find the 4x4 det:
174
175 const Scalar det = rhs[SF00]*mDet3_123_123 - rhs[SF01]*mDet3_123_023
176 + rhs[SF02]*mDet3_123_013 - rhs[SF03]*mDet3_123_012;
177
178// if (determ)
179// *determ = det;
180
181 if ( det == 0 )
182 return false;
183
184 const Scalar oneOverDet = 1.0f / det;
185 const Scalar mn1OverDet = - oneOverDet;
186
187 rhs[SF00] = mDet3_123_123 * oneOverDet;
188 rhs[SF01] = mDet3_123_023 * mn1OverDet;
189 rhs[SF02] = mDet3_123_013 * oneOverDet;
190 rhs[SF03] = mDet3_123_012 * mn1OverDet;
191
192 rhs[SF11] = mDet3_023_023 * oneOverDet;
193 rhs[SF12] = mDet3_023_013 * mn1OverDet;
194 rhs[SF13] = mDet3_023_012 * oneOverDet;
195
196 rhs[SF22] = mDet3_013_013 * oneOverDet;
197 rhs[SF23] = mDet3_013_012 * mn1OverDet;
198
199 rhs[SF33] = mDet3_012_012 * oneOverDet;
200
201 return true;
202}
203
204
205//==============================================================================
206// Inversion for 5x5 matrices
207//==============================================================================
208
209// Mij are indices for a 5x5 matrix.
210
211#define SM00 0
212#define SM01 1
213#define SM02 2
214#define SM03 3
215#define SM04 4
216
217#define SM10 1
218#define SM11 6
219#define SM12 7
220#define SM13 8
221#define SM14 9
222
223#define SM20 2
224#define SM21 7
225#define SM22 12
226#define SM23 13
227#define SM24 14
228
229#define SM30 3
230#define SM31 8
231#define SM32 13
232#define SM33 18
233#define SM34 19
234
235#define SM40 4
236#define SM41 9
237#define SM42 14
238#define SM43 19
239#define SM44 24
240
241/**
242 Inversion for a 5x5 symmetric matrix
243 */
244template <class T>
245bool FastInverter<5>::Dinv(MatRepSym<T,5> & rhs) {
246
247 typedef T Scalar;
248
249 // Find all NECESSARY 2x2 dets: (25 of them)
250
251 const Scalar mDet2_23_01 = rhs[SM20]*rhs[SM31] - rhs[SM21]*rhs[SM30];
252 const Scalar mDet2_23_02 = rhs[SM20]*rhs[SM32] - rhs[SM22]*rhs[SM30];
253 const Scalar mDet2_23_03 = rhs[SM20]*rhs[SM33] - rhs[SM23]*rhs[SM30];
254 const Scalar mDet2_23_12 = rhs[SM21]*rhs[SM32] - rhs[SM22]*rhs[SM31];
255 const Scalar mDet2_23_13 = rhs[SM21]*rhs[SM33] - rhs[SM23]*rhs[SM31];
256 const Scalar mDet2_23_23 = rhs[SM22]*rhs[SM33] - rhs[SM23]*rhs[SM32];
257 const Scalar mDet2_24_01 = rhs[SM20]*rhs[SM41] - rhs[SM21]*rhs[SM40];
258 const Scalar mDet2_24_02 = rhs[SM20]*rhs[SM42] - rhs[SM22]*rhs[SM40];
259 const Scalar mDet2_24_03 = rhs[SM20]*rhs[SM43] - rhs[SM23]*rhs[SM40];
260 const Scalar mDet2_24_04 = rhs[SM20]*rhs[SM44] - rhs[SM24]*rhs[SM40];
261 const Scalar mDet2_24_12 = rhs[SM21]*rhs[SM42] - rhs[SM22]*rhs[SM41];
262 const Scalar mDet2_24_13 = rhs[SM21]*rhs[SM43] - rhs[SM23]*rhs[SM41];
263 const Scalar mDet2_24_14 = rhs[SM21]*rhs[SM44] - rhs[SM24]*rhs[SM41];
264 const Scalar mDet2_24_23 = rhs[SM22]*rhs[SM43] - rhs[SM23]*rhs[SM42];
265 const Scalar mDet2_24_24 = rhs[SM22]*rhs[SM44] - rhs[SM24]*rhs[SM42];
266 const Scalar mDet2_34_01 = rhs[SM30]*rhs[SM41] - rhs[SM31]*rhs[SM40];
267 const Scalar mDet2_34_02 = rhs[SM30]*rhs[SM42] - rhs[SM32]*rhs[SM40];
268 const Scalar mDet2_34_03 = rhs[SM30]*rhs[SM43] - rhs[SM33]*rhs[SM40];
269 const Scalar mDet2_34_04 = rhs[SM30]*rhs[SM44] - rhs[SM34]*rhs[SM40];
270 const Scalar mDet2_34_12 = rhs[SM31]*rhs[SM42] - rhs[SM32]*rhs[SM41];
271 const Scalar mDet2_34_13 = rhs[SM31]*rhs[SM43] - rhs[SM33]*rhs[SM41];
272 const Scalar mDet2_34_14 = rhs[SM31]*rhs[SM44] - rhs[SM34]*rhs[SM41];
273 const Scalar mDet2_34_23 = rhs[SM32]*rhs[SM43] - rhs[SM33]*rhs[SM42];
274 const Scalar mDet2_34_24 = rhs[SM32]*rhs[SM44] - rhs[SM34]*rhs[SM42];
275 const Scalar mDet2_34_34 = rhs[SM33]*rhs[SM44] - rhs[SM34]*rhs[SM43];
276
277 // Find all NECESSARY 3x3 dets: (30 of them)
278
279 const Scalar mDet3_123_012 = rhs[SM10]*mDet2_23_12 - rhs[SM11]*mDet2_23_02 + rhs[SM12]*mDet2_23_01;
280 const Scalar mDet3_123_013 = rhs[SM10]*mDet2_23_13 - rhs[SM11]*mDet2_23_03 + rhs[SM13]*mDet2_23_01;
281 const Scalar mDet3_123_023 = rhs[SM10]*mDet2_23_23 - rhs[SM12]*mDet2_23_03 + rhs[SM13]*mDet2_23_02;
282 const Scalar mDet3_123_123 = rhs[SM11]*mDet2_23_23 - rhs[SM12]*mDet2_23_13 + rhs[SM13]*mDet2_23_12;
283 const Scalar mDet3_124_012 = rhs[SM10]*mDet2_24_12 - rhs[SM11]*mDet2_24_02 + rhs[SM12]*mDet2_24_01;
284 const Scalar mDet3_124_013 = rhs[SM10]*mDet2_24_13 - rhs[SM11]*mDet2_24_03 + rhs[SM13]*mDet2_24_01;
285 const Scalar mDet3_124_014 = rhs[SM10]*mDet2_24_14 - rhs[SM11]*mDet2_24_04 + rhs[SM14]*mDet2_24_01;
286 const Scalar mDet3_124_023 = rhs[SM10]*mDet2_24_23 - rhs[SM12]*mDet2_24_03 + rhs[SM13]*mDet2_24_02;
287 const Scalar mDet3_124_024 = rhs[SM10]*mDet2_24_24 - rhs[SM12]*mDet2_24_04 + rhs[SM14]*mDet2_24_02;
288 const Scalar mDet3_124_123 = rhs[SM11]*mDet2_24_23 - rhs[SM12]*mDet2_24_13 + rhs[SM13]*mDet2_24_12;
289 const Scalar mDet3_124_124 = rhs[SM11]*mDet2_24_24 - rhs[SM12]*mDet2_24_14 + rhs[SM14]*mDet2_24_12;
290 const Scalar mDet3_134_012 = rhs[SM10]*mDet2_34_12 - rhs[SM11]*mDet2_34_02 + rhs[SM12]*mDet2_34_01;
291 const Scalar mDet3_134_013 = rhs[SM10]*mDet2_34_13 - rhs[SM11]*mDet2_34_03 + rhs[SM13]*mDet2_34_01;
292 const Scalar mDet3_134_014 = rhs[SM10]*mDet2_34_14 - rhs[SM11]*mDet2_34_04 + rhs[SM14]*mDet2_34_01;
293 const Scalar mDet3_134_023 = rhs[SM10]*mDet2_34_23 - rhs[SM12]*mDet2_34_03 + rhs[SM13]*mDet2_34_02;
294 const Scalar mDet3_134_024 = rhs[SM10]*mDet2_34_24 - rhs[SM12]*mDet2_34_04 + rhs[SM14]*mDet2_34_02;
295 const Scalar mDet3_134_034 = rhs[SM10]*mDet2_34_34 - rhs[SM13]*mDet2_34_04 + rhs[SM14]*mDet2_34_03;
296 const Scalar mDet3_134_123 = rhs[SM11]*mDet2_34_23 - rhs[SM12]*mDet2_34_13 + rhs[SM13]*mDet2_34_12;
297 const Scalar mDet3_134_124 = rhs[SM11]*mDet2_34_24 - rhs[SM12]*mDet2_34_14 + rhs[SM14]*mDet2_34_12;
298 const Scalar mDet3_134_134 = rhs[SM11]*mDet2_34_34 - rhs[SM13]*mDet2_34_14 + rhs[SM14]*mDet2_34_13;
299 const Scalar mDet3_234_012 = rhs[SM20]*mDet2_34_12 - rhs[SM21]*mDet2_34_02 + rhs[SM22]*mDet2_34_01;
300 const Scalar mDet3_234_013 = rhs[SM20]*mDet2_34_13 - rhs[SM21]*mDet2_34_03 + rhs[SM23]*mDet2_34_01;
301 const Scalar mDet3_234_014 = rhs[SM20]*mDet2_34_14 - rhs[SM21]*mDet2_34_04 + rhs[SM24]*mDet2_34_01;
302 const Scalar mDet3_234_023 = rhs[SM20]*mDet2_34_23 - rhs[SM22]*mDet2_34_03 + rhs[SM23]*mDet2_34_02;
303 const Scalar mDet3_234_024 = rhs[SM20]*mDet2_34_24 - rhs[SM22]*mDet2_34_04 + rhs[SM24]*mDet2_34_02;
304 const Scalar mDet3_234_034 = rhs[SM20]*mDet2_34_34 - rhs[SM23]*mDet2_34_04 + rhs[SM24]*mDet2_34_03;
305 const Scalar mDet3_234_123 = rhs[SM21]*mDet2_34_23 - rhs[SM22]*mDet2_34_13 + rhs[SM23]*mDet2_34_12;
306 const Scalar mDet3_234_124 = rhs[SM21]*mDet2_34_24 - rhs[SM22]*mDet2_34_14 + rhs[SM24]*mDet2_34_12;
307 const Scalar mDet3_234_134 = rhs[SM21]*mDet2_34_34 - rhs[SM23]*mDet2_34_14 + rhs[SM24]*mDet2_34_13;
308 const Scalar mDet3_234_234 = rhs[SM22]*mDet2_34_34 - rhs[SM23]*mDet2_34_24 + rhs[SM24]*mDet2_34_23;
309
310 // Find all NECESSARY 4x4 dets: (15 of them)
311
312 const Scalar mDet4_0123_0123 = rhs[SM00]*mDet3_123_123 - rhs[SM01]*mDet3_123_023
313 + rhs[SM02]*mDet3_123_013 - rhs[SM03]*mDet3_123_012;
314 const Scalar mDet4_0124_0123 = rhs[SM00]*mDet3_124_123 - rhs[SM01]*mDet3_124_023
315 + rhs[SM02]*mDet3_124_013 - rhs[SM03]*mDet3_124_012;
316 const Scalar mDet4_0124_0124 = rhs[SM00]*mDet3_124_124 - rhs[SM01]*mDet3_124_024
317 + rhs[SM02]*mDet3_124_014 - rhs[SM04]*mDet3_124_012;
318 const Scalar mDet4_0134_0123 = rhs[SM00]*mDet3_134_123 - rhs[SM01]*mDet3_134_023
319 + rhs[SM02]*mDet3_134_013 - rhs[SM03]*mDet3_134_012;
320 const Scalar mDet4_0134_0124 = rhs[SM00]*mDet3_134_124 - rhs[SM01]*mDet3_134_024
321 + rhs[SM02]*mDet3_134_014 - rhs[SM04]*mDet3_134_012;
322 const Scalar mDet4_0134_0134 = rhs[SM00]*mDet3_134_134 - rhs[SM01]*mDet3_134_034
323 + rhs[SM03]*mDet3_134_014 - rhs[SM04]*mDet3_134_013;
324 const Scalar mDet4_0234_0123 = rhs[SM00]*mDet3_234_123 - rhs[SM01]*mDet3_234_023
325 + rhs[SM02]*mDet3_234_013 - rhs[SM03]*mDet3_234_012;
326 const Scalar mDet4_0234_0124 = rhs[SM00]*mDet3_234_124 - rhs[SM01]*mDet3_234_024
327 + rhs[SM02]*mDet3_234_014 - rhs[SM04]*mDet3_234_012;
328 const Scalar mDet4_0234_0134 = rhs[SM00]*mDet3_234_134 - rhs[SM01]*mDet3_234_034
329 + rhs[SM03]*mDet3_234_014 - rhs[SM04]*mDet3_234_013;
330 const Scalar mDet4_0234_0234 = rhs[SM00]*mDet3_234_234 - rhs[SM02]*mDet3_234_034
331 + rhs[SM03]*mDet3_234_024 - rhs[SM04]*mDet3_234_023;
332 const Scalar mDet4_1234_0123 = rhs[SM10]*mDet3_234_123 - rhs[SM11]*mDet3_234_023
333 + rhs[SM12]*mDet3_234_013 - rhs[SM13]*mDet3_234_012;
334 const Scalar mDet4_1234_0124 = rhs[SM10]*mDet3_234_124 - rhs[SM11]*mDet3_234_024
335 + rhs[SM12]*mDet3_234_014 - rhs[SM14]*mDet3_234_012;
336 const Scalar mDet4_1234_0134 = rhs[SM10]*mDet3_234_134 - rhs[SM11]*mDet3_234_034
337 + rhs[SM13]*mDet3_234_014 - rhs[SM14]*mDet3_234_013;
338 const Scalar mDet4_1234_0234 = rhs[SM10]*mDet3_234_234 - rhs[SM12]*mDet3_234_034
339 + rhs[SM13]*mDet3_234_024 - rhs[SM14]*mDet3_234_023;
340 const Scalar mDet4_1234_1234 = rhs[SM11]*mDet3_234_234 - rhs[SM12]*mDet3_234_134
341 + rhs[SM13]*mDet3_234_124 - rhs[SM14]*mDet3_234_123;
342
343 // Find the 5x5 det:
344
345 const Scalar det = rhs[SM00]*mDet4_1234_1234 - rhs[SM01]*mDet4_1234_0234 + rhs[SM02]*mDet4_1234_0134
346 - rhs[SM03]*mDet4_1234_0124 + rhs[SM04]*mDet4_1234_0123;
347// if (determ)
348// *determ = det;
349
350 if ( det == 0 )
351 return false;
352
353 const Scalar oneOverDet = 1.0f / det;
354 const Scalar mn1OverDet = - oneOverDet;
355
356 rhs[SM00] = mDet4_1234_1234 * oneOverDet;
357 rhs[SM01] = mDet4_1234_0234 * mn1OverDet;
358 rhs[SM02] = mDet4_1234_0134 * oneOverDet;
359 rhs[SM03] = mDet4_1234_0124 * mn1OverDet;
360 rhs[SM04] = mDet4_1234_0123 * oneOverDet;
361
362 rhs[SM11] = mDet4_0234_0234 * oneOverDet;
363 rhs[SM12] = mDet4_0234_0134 * mn1OverDet;
364 rhs[SM13] = mDet4_0234_0124 * oneOverDet;
365 rhs[SM14] = mDet4_0234_0123 * mn1OverDet;
366
367 rhs[SM22] = mDet4_0134_0134 * oneOverDet;
368 rhs[SM23] = mDet4_0134_0124 * mn1OverDet;
369 rhs[SM24] = mDet4_0134_0123 * oneOverDet;
370
371 rhs[SM33] = mDet4_0124_0124 * oneOverDet;
372 rhs[SM34] = mDet4_0124_0123 * mn1OverDet;
373
374 rhs[SM44] = mDet4_0123_0123 * oneOverDet;
375
376
377 return true;
378}
379
380
381
382 } // namespace Math
383
384} // namespace ROOT
385
386
387// undef Smacros to avoid conflicts
388
389// undef SF 4x4
390#undef SF00
391#undef SF01
392#undef SF02
393#undef SF03
394
395#undef SF10
396#undef SF11
397#undef SF12
398#undef SF13
399
400#undef SF20
401#undef SF21
402#undef SF22
403#undef SF23
404
405#undef SF30
406#undef SF31
407#undef SF32
408#undef SF33
409
410// undef SM 5x5
411#undef SM00
412#undef SM01
413#undef SM02
414#undef SM03
415#undef SM04
416
417#undef SM10
418#undef SM11
419#undef SM12
420#undef SM13
421#undef SM14
422
423#undef SM20
424#undef SM21
425#undef SM22
426#undef SM23
427#undef SM24
428
429#undef SM30
430#undef SM31
431#undef SM32
432#undef SM33
433#undef SM34
434
435#undef SM40
436#undef SM41
437#undef SM42
438#undef SM43
439#undef SM44
440
441
442
443
444#endif
TRangeDynCast
ROOT::Detail::TRangeCast< T, true > TRangeDynCast
TRangeDynCast is an adapter class that allows the typed iteration through a TCollection.
Definition TCollection.h:358
SM33
#define SM33
Definition TMatrixTSymCramerInv.cxx:278
SM12
#define SM12
Definition TMatrixTSymCramerInv.cxx:265
SM13
#define SM13
Definition TMatrixTSymCramerInv.cxx:266
SM40
#define SM40
Definition TMatrixTSymCramerInv.cxx:281
SF03
#define SF03
Definition TMatrixTSymCramerInv.cxx:145
SM14
#define SM14
Definition TMatrixTSymCramerInv.cxx:267
SF02
#define SF02
Definition TMatrixTSymCramerInv.cxx:144
SF31
#define SF31
Definition TMatrixTSymCramerInv.cxx:158
SF00
#define SF00
Definition TMatrixTSymCramerInv.cxx:142
SF13
#define SF13
Definition TMatrixTSymCramerInv.cxx:150
SF22
#define SF22
Definition TMatrixTSymCramerInv.cxx:154
SF32
#define SF32
Definition TMatrixTSymCramerInv.cxx:159
SM23
#define SM23
Definition TMatrixTSymCramerInv.cxx:272
SF10
#define SF10
Definition TMatrixTSymCramerInv.cxx:147
SM22
#define SM22
Definition TMatrixTSymCramerInv.cxx:271
SF33
#define SF33
Definition TMatrixTSymCramerInv.cxx:160
SM10
#define SM10
Definition TMatrixTSymCramerInv.cxx:263
SM00
#define SM00
Definition TMatrixTSymCramerInv.cxx:257
SF21
#define SF21
Definition TMatrixTSymCramerInv.cxx:153
SM30
#define SM30
Definition TMatrixTSymCramerInv.cxx:275
SF12
#define SF12
Definition TMatrixTSymCramerInv.cxx:149
SM01
#define SM01
Definition TMatrixTSymCramerInv.cxx:258
SF23
#define SF23
Definition TMatrixTSymCramerInv.cxx:155
SM02
#define SM02
Definition TMatrixTSymCramerInv.cxx:259
SF20
#define SF20
Definition TMatrixTSymCramerInv.cxx:152
SM41
#define SM41
Definition TMatrixTSymCramerInv.cxx:282
SM21
#define SM21
Definition TMatrixTSymCramerInv.cxx:270
SM32
#define SM32
Definition TMatrixTSymCramerInv.cxx:277
SM11
#define SM11
Definition TMatrixTSymCramerInv.cxx:264
SM20
#define SM20
Definition TMatrixTSymCramerInv.cxx:269
SM44
#define SM44
Definition TMatrixTSymCramerInv.cxx:285
SM04
#define SM04
Definition TMatrixTSymCramerInv.cxx:261
SF30
#define SF30
Definition TMatrixTSymCramerInv.cxx:157
SF11
#define SF11
Definition TMatrixTSymCramerInv.cxx:148
SM43
#define SM43
Definition TMatrixTSymCramerInv.cxx:284
SM31
#define SM31
Definition TMatrixTSymCramerInv.cxx:276
SM03
#define SM03
Definition TMatrixTSymCramerInv.cxx:260
SM34
#define SM34
Definition TMatrixTSymCramerInv.cxx:279
SM42
#define SM42
Definition TMatrixTSymCramerInv.cxx:283
SF01
#define SF01
Definition TMatrixTSymCramerInv.cxx:143
SM24
#define SM24
Definition TMatrixTSymCramerInv.cxx:273
ROOT::Math::FastInverter::Dinv
static bool Dinv(MatrixRep &rhs)
Definition Dinv.h:148
Math
Namespace for new Math classes and functions.
ROOT::Math::Scalar
Rotation3D::Scalar Scalar
Definition Rotation3DxAxial.cxx:69
ROOT
tbb::task_arena is an alias of tbb::interface7::task_arena, which doesn't allow to forward declare tb...
Definition EExecutionPolicy.hxx:4
t1
auto * t1
Definition textangle.C:20