ROOT   6.08/07 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>
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>
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>
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
#define SF23
#define SF03
#define SM24
#define SM11
This namespace contains pre-defined functions to be used in conjuction with TExecutor::Map and TExecu...
Definition: StringConv.hxx:21
#define SM21
#define SF30
#define SF32
double T(double x)
Definition: ChebyshevPol.h:34
MatRepSym Matrix storage representation for a symmetric matrix of dimension NxN This class is a templ...
Definition: HelperOps.h:35
#define SM14
#define SF12
static bool Dinv(MatrixRep &rhs)
Definition: Dinv.h:152
#define SF13
#define SF11
#define SM13
#define SM33
TLatex * t1
Definition: textangle.C:20
#define SM23
#define SM10
#define SM34
#define SF20
#define SF02
#define SF10
#define SF22
#define SM01
#define SM04
#define SM03
#define SM02
#define SM41
#define SF00
#define SM31
#define SM44
#define SM40
#define SF33
#define SM32
#define SM42
#define SM00
#define SF21
#define SF31
#define SM12
Namespace for new Math classes and functions.
#define SM22
#define SM30
#define SF01
Plane3D::Scalar Scalar
Definition: Plane3D.cxx:29
#define SM20
#define SM43