Logo ROOT   6.13/01
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 #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 
30 namespace ROOT {
31 
32  namespace Math {
33 
34 
35 
36 
37 //==============================================================================
38 /**
39  Inversion for a 3x3 symmetric matrix
40  */
41 template <class T>
42 bool 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  */
127 template <class T>
128 bool 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  */
244 template <class T>
245 bool 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
SF23
#define SF23
Definition: CramerInversionSym.icc:116
SF03
#define SF03
Definition: CramerInversionSym.icc:106
SM24
#define SM24
Definition: CramerInversionSym.icc:227
SM11
#define SM11
Definition: CramerInversionSym.icc:218
ROOT
Namespace for new ROOT classes and functions.
Definition: TFoamSampler.h:19
SM21
#define SM21
Definition: CramerInversionSym.icc:224
SF30
#define SF30
Definition: CramerInversionSym.icc:118
SF32
#define SF32
Definition: CramerInversionSym.icc:120
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:221
SF12
#define SF12
Definition: CramerInversionSym.icc:110
ROOT::Math::FastInverter::Dinv
static bool Dinv(MatrixRep &rhs)
Definition: Dinv.h:148
SF13
#define SF13
Definition: CramerInversionSym.icc:111
SF11
#define SF11
Definition: CramerInversionSym.icc:109
SM13
#define SM13
Definition: CramerInversionSym.icc:220
SM33
#define SM33
Definition: CramerInversionSym.icc:232
SM23
#define SM23
Definition: CramerInversionSym.icc:226
SM10
#define SM10
Definition: CramerInversionSym.icc:217
SM34
#define SM34
Definition: CramerInversionSym.icc:233
SF20
#define SF20
Definition: CramerInversionSym.icc:113
SF02
#define SF02
Definition: CramerInversionSym.icc:105
SF10
#define SF10
Definition: CramerInversionSym.icc:108
SF22
#define SF22
Definition: CramerInversionSym.icc:115
SM01
#define SM01
Definition: CramerInversionSym.icc:212
SM04
#define SM04
Definition: CramerInversionSym.icc:215
SM03
#define SM03
Definition: CramerInversionSym.icc:214
SM02
#define SM02
Definition: CramerInversionSym.icc:213
SM41
#define SM41
Definition: CramerInversionSym.icc:236
SF00
#define SF00
Definition: CramerInversionSym.icc:103
SM31
#define SM31
Definition: CramerInversionSym.icc:230
SM44
#define SM44
Definition: CramerInversionSym.icc:239
SM40
#define SM40
Definition: CramerInversionSym.icc:235
SF33
#define SF33
Definition: CramerInversionSym.icc:121
SM32
#define SM32
Definition: CramerInversionSym.icc:231
SM42
#define SM42
Definition: CramerInversionSym.icc:237
SM00
#define SM00
Definition: CramerInversionSym.icc:211
SF21
#define SF21
Definition: CramerInversionSym.icc:114
SF31
#define SF31
Definition: CramerInversionSym.icc:119
SM12
#define SM12
Definition: CramerInversionSym.icc:219
Math
Namespace for new Math classes and functions.
SM22
#define SM22
Definition: CramerInversionSym.icc:225
SM30
#define SM30
Definition: CramerInversionSym.icc:229
SF01
#define SF01
Definition: CramerInversionSym.icc:104
ROOT::Math::Scalar
Rotation3D::Scalar Scalar
Definition: Rotation3DxAxial.cxx:69
SM20
#define SM20
Definition: CramerInversionSym.icc:223
SM43
#define SM43
Definition: CramerInversionSym.icc:238