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