- Banned exZERO(), exONE(), exMINUSHALF() and all this from the interface.
[ginac.git] / ginac / utils.cpp
1 /** @file utils.cpp
2  *
3  *  Implementation of several small and furry utilities needed within GiNaC
4  *  but not of any interest to the user of the library. */
5
6 /*
7  *  GiNaC Copyright (C) 1999 Johannes Gutenberg University Mainz, Germany
8  *
9  *  This program is free software; you can redistribute it and/or modify
10  *  it under the terms of the GNU General Public License as published by
11  *  the Free Software Foundation; either version 2 of the License, or
12  *  (at your option) any later version.
13  *
14  *  This program is distributed in the hope that it will be useful,
15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  *  GNU General Public License for more details.
18  *
19  *  You should have received a copy of the GNU General Public License
20  *  along with this program; if not, write to the Free Software
21  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
22  */
23
24 #include "ex.h"
25 #include "numeric.h"
26 #include "utils.h"
27
28 #ifndef NO_GINAC_NAMESPACE
29 namespace GiNaC {
30 #endif // ndef NO_GINAC_NAMESPACE
31
32 /** Integer binary logarithm */
33 unsigned log2(unsigned n)
34 {
35     unsigned k;
36     for (k = 0; n > 1; n >>= 1) ++k;
37     return k;
38 }
39
40 /** Compare two pointers (just to establish some sort of canonical order).
41  *  @return -1, 0, or 1 */
42 int compare_pointers(void const * a, void const * b)
43 {
44     if (a<b) {
45         return -1;
46     } else if (a>b) {
47         return 1;
48     }
49     return 0;
50 }
51
52 //////////
53 // `construct on first use' chest of numbers
54 //////////
55
56 // numeric -12
57 numeric const & _num_12(void)
58 {
59     const static ex e = ex(numeric(-12));
60     const static numeric * n = static_cast<const numeric *>(e.bp);
61     return *n;
62 }
63
64 ex const & _ex_12(void)
65 {
66     static ex * e = new ex(_num_12());
67     return *e;
68 }
69
70 // numeric -11
71 numeric const & _num_11(void)
72 {
73     const static ex e = ex(numeric(-11));
74     const static numeric * n = static_cast<const numeric *>(e.bp);
75     return *n;
76 }
77
78 ex const & _ex_11(void)
79 {
80     static ex * e = new ex(_num_11());
81     return *e;
82 }
83
84 // numeric -10
85 numeric const & _num_10(void)
86 {
87     const static ex e = ex(numeric(-10));
88     const static numeric * n = static_cast<const numeric *>(e.bp);
89     return *n;
90 }
91
92 ex const & _ex_10(void)
93 {
94     static ex * e = new ex(_num_10());
95     return *e;
96 }
97
98 // numeric -9
99 numeric const & _num_9(void)
100 {
101     const static ex e = ex(numeric(-9));
102     const static numeric * n = static_cast<const numeric *>(e.bp);
103     return *n;
104 }
105
106 ex const & _ex_9(void)
107 {
108     static ex * e = new ex(_num_9());
109     return *e;
110 }
111
112 // numeric -8
113 numeric const & _num_8(void)
114 {
115     const static ex e = ex(numeric(-8));
116     const static numeric * n = static_cast<const numeric *>(e.bp);
117     return *n;
118 }
119
120 ex const & _ex_8(void)
121 {
122     static ex * e = new ex(_num_8());
123     return *e;
124 }
125
126 // numeric -7
127 numeric const & _num_7(void)
128 {
129     const static ex e = ex(numeric(-7));
130     const static numeric * n = static_cast<const numeric *>(e.bp);
131     return *n;
132 }
133
134 ex const & _ex_7(void)
135 {
136     static ex * e = new ex(_num_7());
137     return *e;
138 }
139
140 // numeric -6
141 numeric const & _num_6(void)
142 {
143     const static ex e = ex(numeric(-6));
144     const static numeric * n = static_cast<const numeric *>(e.bp);
145     return *n;
146 }
147
148 ex const & _ex_6(void)
149 {
150     static ex * e = new ex(_num_6());
151     return *e;
152 }
153
154 // numeric -5
155 numeric const & _num_5(void)
156 {
157     const static ex e = ex(numeric(-5));
158     const static numeric * n = static_cast<const numeric *>(e.bp);
159     return *n;
160 }
161
162 ex const & _ex_5(void)
163 {
164     static ex * e = new ex(_num_5());
165     return *e;
166 }
167
168 // numeric -4
169 numeric const & _num_4(void)
170 {
171     const static ex e = ex(numeric(-4));
172     const static numeric * n = static_cast<const numeric *>(e.bp);
173     return *n;
174 }
175
176 ex const & _ex_4(void)
177 {
178     static ex * e = new ex(_num_4());
179     return *e;
180 }
181
182 // numeric -3
183 numeric const & _num_3(void)
184 {
185     const static ex e = ex(numeric(-3));
186     const static numeric * n = static_cast<const numeric *>(e.bp);
187     return *n;
188 }
189
190 ex const & _ex_3(void)
191 {
192     static ex * e = new ex(_num_3());
193     return *e;
194 }
195
196 // numeric -2
197 numeric const & _num_2(void)
198 {
199     const static ex e = ex(numeric(-2));
200     const static numeric * n = static_cast<const numeric *>(e.bp);
201     return *n;
202 }
203
204 ex const & _ex_2(void)
205 {
206     static ex * e = new ex(_num_2());
207     return *e;
208 }
209
210 // numeric -1
211 numeric const & _num_1(void)
212 {
213     const static ex e = ex(numeric(-1));
214     const static numeric * n = static_cast<const numeric *>(e.bp);
215     return *n;
216 }
217
218 ex const & _ex_1(void)
219 {
220     static ex * e = new ex(_num_1());
221     return *e;
222 }
223
224 // numeric -1/2
225 numeric const & _num_1_2(void)
226 {
227     const static ex e = ex(numeric(-1,2));
228     const static numeric * n = static_cast<const numeric *>(e.bp);
229     return *n;
230 }
231
232 ex const & _ex_1_2(void)
233 {
234     static ex * e = new ex(_num_1_2());
235     return *e;
236 }    
237
238 // numeric -1/3
239 numeric const & _num_1_3(void)
240 {
241     const static ex e = ex(numeric(-1,3));
242     const static numeric * n = static_cast<const numeric *>(e.bp);
243     return *n;
244 }
245
246 ex const & _ex_1_3(void)
247 {
248     static ex * e = new ex(_num_1_3());
249     return *e;
250 }    
251
252 // numeric  0
253 numeric const & _num0(void)
254 {
255     const static ex e = ex(numeric(0));
256     const static numeric * n = static_cast<const numeric *>(e.bp);
257     return *n;
258 }
259
260 ex const & _ex0(void)
261 {
262     static ex * e = new ex(_num0());
263     return *e;
264 }
265
266 // numeric  1/3
267 numeric const & _num1_3(void)
268 {
269     const static ex e = ex(numeric(1,3));
270     const static numeric * n = static_cast<const numeric *>(e.bp);
271     return *n;
272 }
273
274 ex const & _ex1_3(void)
275 {
276     static ex * e = new ex(_num1_3());
277     return *e;
278 }    
279
280 // numeric  1/2
281 numeric const & _num1_2(void)
282 {
283     const static ex e = ex(numeric(1,2));
284     const static numeric * n = static_cast<const numeric *>(e.bp);
285     return *n;
286 }
287
288 ex const & _ex1_2(void)
289 {
290     static ex * e = new ex(_num1_2());
291     return *e;
292 }    
293
294 // numeric  1
295 numeric const & _num1(void)
296 {
297     const static ex e = ex(numeric(1));
298     const static numeric * n = static_cast<const numeric *>(e.bp);
299     return *n;
300 }
301
302 ex const & _ex1(void)
303 {
304     static ex * e = new ex(_num1());
305     return *e;
306 }
307
308 // numeric  2
309 numeric const & _num2(void)
310 {
311     const static ex e = ex(numeric(2));
312     const static numeric * n = static_cast<const numeric *>(e.bp);
313     return *n;
314 }
315
316 ex const & _ex2(void)
317 {
318     static ex * e = new ex(_num2());
319     return *e;
320 }
321
322 // numeric  3
323 numeric const & _num3(void)
324 {
325     const static ex e = ex(numeric(3));
326     const static numeric * n = static_cast<const numeric *>(e.bp);
327     return *n;
328 }
329
330 ex const & _ex3(void)
331 {
332     static ex * e = new ex(_num3());
333     return *e;
334 }
335
336 // numeric  4
337 numeric const & _num4(void)
338 {
339     const static ex e = ex(numeric(4));
340     const static numeric * n = static_cast<const numeric *>(e.bp);
341     return *n;
342 }
343
344 ex const & _ex4(void)
345 {
346     static ex * e = new ex(_num4());
347     return *e;
348 }
349
350 // numeric  5
351 numeric const & _num5(void)
352 {
353     const static ex e = ex(numeric(5));
354     const static numeric * n = static_cast<const numeric *>(e.bp);
355     return *n;
356 }
357
358 ex const & _ex5(void)
359 {
360     static ex * e = new ex(_num5());
361     return *e;
362 }
363
364 // numeric  6
365 numeric const & _num6(void)
366 {
367     const static ex e = ex(numeric(6));
368     const static numeric * n = static_cast<const numeric *>(e.bp);
369     return *n;
370 }
371
372 ex const & _ex6(void)
373 {
374     static ex * e = new ex(_num6());
375     return *e;
376 }
377
378 // numeric  7
379 numeric const & _num7(void)
380 {
381     const static ex e = ex(numeric(7));
382     const static numeric * n = static_cast<const numeric *>(e.bp);
383     return *n;
384 }
385
386 ex const & _ex7(void)
387 {
388     static ex * e = new ex(_num7());
389     return *e;
390 }
391
392 // numeric  8
393 numeric const & _num8(void)
394 {
395     const static ex e = ex(numeric(8));
396     const static numeric * n = static_cast<const numeric *>(e.bp);
397     return *n;
398 }
399
400 ex const & _ex8(void)
401 {
402     static ex * e = new ex(_num8());
403     return *e;
404 }
405
406 // numeric  9
407 numeric const & _num9(void)
408 {
409     const static ex e = ex(numeric(9));
410     const static numeric * n = static_cast<const numeric *>(e.bp);
411     return *n;
412 }
413
414 ex const & _ex9(void)
415 {
416     static ex * e = new ex(_num9());
417     return *e;
418 }
419
420 // numeric  10
421 numeric const & _num10(void)
422 {
423     const static ex e = ex(numeric(10));
424     const static numeric * n = static_cast<const numeric *>(e.bp);
425     return *n;
426 }
427
428 ex const & _ex10(void)
429 {
430     static ex * e = new ex(_num10());
431     return *e;
432 }
433
434 // numeric  11
435 numeric const & _num11(void)
436 {
437     const static ex e = ex(numeric(11));
438     const static numeric * n = static_cast<const numeric *>(e.bp);
439     return *n;
440 }
441
442 ex const & _ex11(void)
443 {
444     static ex * e = new ex(_num11());
445     return *e;
446 }
447
448 // numeric  12
449 numeric const & _num12(void)
450 {
451     const static ex e = ex(numeric(12));
452     const static numeric * n = static_cast<const numeric *>(e.bp);
453     return *n;
454 }
455
456 ex const & _ex12(void)
457 {
458     static ex * e = new ex(_num12());
459     return *e;
460 }
461
462 // comment skeleton for header files
463
464
465 // member functions
466
467     // default constructor, destructor, copy constructor assignment operator and helpers
468     // none
469
470     // other constructors
471     // none
472
473     // functions overriding virtual functions from bases classes
474     // none
475     
476     // new virtual functions which can be overridden by derived classes
477     // none
478
479     // non-virtual functions in this class
480     // none
481
482 // member variables
483 // none
484     
485
486
487 // comment skeleton for implementation files
488
489
490 //////////
491 // default constructor, destructor, copy constructor assignment operator and helpers
492 //////////
493
494 // public
495 // protected
496
497 //////////
498 // other constructors
499 //////////
500
501 // public
502 // none
503
504 //////////
505 // functions overriding virtual functions from bases classes
506 //////////
507
508 // public
509 // protected
510 // none
511
512 //////////
513 // new virtual functions which can be overridden by derived classes
514 //////////
515
516 // public
517 // protected
518 // none
519
520 //////////
521 // non-virtual functions in this class
522 //////////
523
524 // public
525 // protected
526 // none
527
528 //////////
529 // static member variables
530 //////////
531
532 // protected
533 // private
534 // none
535
536
537 #ifndef NO_GINAC_NAMESPACE
538 } // namespace GiNaC
539 #endif // ndef NO_GINAC_NAMESPACE