"Fossies" - the Fresh Open Source Software Archive 
Member "mapm_4.9.5a/m_apm.h" (21 Feb 2010, 20548 Bytes) of package /linux/misc/old/mapm-4.9.5a.tar.gz:
As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style:
standard) with prefixed line numbers and
code folding option.
Alternatively you can here
view or
download the uninterpreted source code file.
For more information about "m_apm.h" see the
Fossies "Dox" file reference documentation.
1
2 /*
3 * M_APM - m_apm.h
4 *
5 * Copyright (C) 1999 - 2007 Michael C. Ring
6 *
7 * Permission to use, copy, and distribute this software and its
8 * documentation for any purpose with or without fee is hereby granted,
9 * provided that the above copyright notice appear in all copies and
10 * that both that copyright notice and this permission notice appear
11 * in supporting documentation.
12 *
13 * Permission to modify the software is granted. Permission to distribute
14 * the modified code is granted. Modifications are to be distributed by
15 * using the file 'license.txt' as a template to modify the file header.
16 * 'license.txt' is available in the official MAPM distribution.
17 *
18 * This software is provided "as is" without express or implied warranty.
19 */
20
21 /*
22 * This is the header file that the user will include.
23 *
24 * $Log: m_apm.h,v $
25 * Revision 1.42 2007/12/03 02:28:25 mike
26 * update copyright
27 *
28 * Revision 1.41 2007/12/03 01:21:35 mike
29 * Update license
30 * Update version to 4.9.5
31 *
32 * Revision 1.40 2004/05/31 22:06:02 mike
33 * add % operator to C++ wrapper
34 *
35 * Revision 1.39 2004/05/24 04:11:41 mike
36 * updated version to 4.9.2
37 *
38 * Revision 1.38 2004/04/01 03:17:19 mike
39 * update version to 4.9.1
40 *
41 * Revision 1.37 2004/01/02 20:40:49 mike
42 * fix date on copyright
43 *
44 * Revision 1.36 2004/01/02 00:52:38 mike
45 * update version to 4.9
46 *
47 * Revision 1.35 2003/11/23 05:12:46 mike
48 * update version
49 *
50 * Revision 1.34 2003/07/21 20:59:54 mike
51 * update version to 4.8
52 *
53 * Revision 1.33 2003/05/14 21:19:23 mike
54 * change version string
55 *
56 * Revision 1.32 2003/05/06 21:29:11 mike
57 * add defines for lib versions (and prototypes)
58 *
59 * Revision 1.31 2002/11/04 20:46:33 mike
60 * change definition of the M_APM structure
61 *
62 * Revision 1.30 2002/11/03 23:36:24 mike
63 * added new function, m_apm_integer_pow_nr
64 *
65 * Revision 1.29 2002/02/14 21:43:00 mike
66 * add set_random_seed prototype
67 *
68 * Revision 1.28 2001/08/28 18:29:32 mike
69 * fix fixptstringexp
70 *
71 * Revision 1.27 2001/08/27 22:45:03 mike
72 * fix typo
73 *
74 * Revision 1.26 2001/08/27 22:43:06 mike
75 * add new fix pt functions to C++ wrapper
76 *
77 * Revision 1.25 2001/08/26 22:09:13 mike
78 * add new prototype
79 *
80 * Revision 1.24 2001/08/25 16:48:21 mike
81 * add new prototypes
82 *
83 * Revision 1.23 2001/07/16 18:40:27 mike
84 * add free_all_mem, trim_mem_usage prototypes
85 *
86 * Revision 1.22 2001/07/15 20:49:21 mike
87 * added is_odd, is_even, gcd, lcm functions
88 *
89 * Revision 1.21 2001/03/25 21:24:55 mike
90 * add floor and ceil functions
91 *
92 * Revision 1.20 2000/09/23 19:05:29 mike
93 * add _reciprocal prototype
94 *
95 * Revision 1.19 2000/08/21 23:30:13 mike
96 * add _is_integer function
97 *
98 * Revision 1.18 2000/07/06 00:10:15 mike
99 * redo declare for MM_cpp_min_precision
100 *
101 * Revision 1.17 2000/07/04 20:59:43 mike
102 * move MM_cpp_min_precision into cplusplus block below
103 *
104 * Revision 1.16 2000/07/04 20:49:04 mike
105 * move 'MM_cpp_min_precision' inside the extern "C"
106 * brackets
107 *
108 * Revision 1.15 2000/04/06 21:19:38 mike
109 * minor final tweaks from Orion
110 *
111 * Revision 1.14 2000/04/05 20:15:25 mike
112 * add cpp_min_precision
113 *
114 * Revision 1.13 2000/04/04 22:20:09 mike
115 * updated some comments from Orion
116 *
117 * Revision 1.12 2000/04/04 19:46:36 mike
118 * fix preincrement, postincrement operators
119 * added some comments
120 * added 'ipow' operators
121 *
122 * Revision 1.11 2000/04/03 22:08:35 mike
123 * added MAPM C++ wrapper class
124 * supplied by Orion Sky Lawlor (olawlor@acm.org)
125 *
126 * Revision 1.10 2000/04/03 18:40:28 mike
127 * add #define atan2 for alias
128 *
129 * Revision 1.9 2000/04/03 18:05:23 mike
130 * added hyperbolic functions
131 *
132 * Revision 1.8 2000/04/03 17:26:57 mike
133 * add cbrt prototype
134 *
135 * Revision 1.7 1999/09/18 03:11:23 mike
136 * add new prototype
137 *
138 * Revision 1.6 1999/09/18 03:08:25 mike
139 * add new prototypes
140 *
141 * Revision 1.5 1999/09/18 01:37:55 mike
142 * added new prototype
143 *
144 * Revision 1.4 1999/07/12 02:04:30 mike
145 * added new function prototpye (m_apm_integer_string)
146 *
147 * Revision 1.3 1999/05/15 21:04:08 mike
148 * added factorial prototype
149 *
150 * Revision 1.2 1999/05/12 20:50:12 mike
151 * added more constants
152 *
153 * Revision 1.1 1999/05/12 20:48:25 mike
154 * Initial revision
155 *
156 * $Id: m_apm.h,v 1.42 2007/12/03 02:28:25 mike Exp $
157 */
158
159 #ifndef M__APM__INCLUDED
160 #define M__APM__INCLUDED
161
162 #ifdef __cplusplus
163 /* Comment this line out if you've compiled the library as C++. */
164 #define APM_CONVERT_FROM_C
165 #endif
166
167 #ifdef APM_CONVERT_FROM_C
168 extern "C" {
169 #endif
170
171 typedef unsigned char UCHAR;
172
173 typedef struct {
174 UCHAR *m_apm_data;
175 long m_apm_id;
176 int m_apm_refcount; /* <- used only by C++ MAPM class */
177 int m_apm_malloclength;
178 int m_apm_datalength;
179 int m_apm_exponent;
180 int m_apm_sign;
181 } M_APM_struct;
182
183 typedef M_APM_struct *M_APM;
184
185
186 #define MAPM_LIB_VERSION \
187 "MAPM Library Version 4.9.5 Copyright (C) 1999-2007, Michael C. Ring"
188 #define MAPM_LIB_SHORT_VERSION "4.9.5"
189
190
191 /*
192 * convienient predefined constants
193 */
194
195 extern M_APM MM_Zero;
196 extern M_APM MM_One;
197 extern M_APM MM_Two;
198 extern M_APM MM_Three;
199 extern M_APM MM_Four;
200 extern M_APM MM_Five;
201 extern M_APM MM_Ten;
202
203 extern M_APM MM_PI;
204 extern M_APM MM_HALF_PI;
205 extern M_APM MM_2_PI;
206 extern M_APM MM_E;
207
208 extern M_APM MM_LOG_E_BASE_10;
209 extern M_APM MM_LOG_10_BASE_E;
210 extern M_APM MM_LOG_2_BASE_E;
211 extern M_APM MM_LOG_3_BASE_E;
212
213
214 /*
215 * function prototypes
216 */
217
218 extern M_APM m_apm_init(void);
219 extern void m_apm_free(M_APM);
220 extern void m_apm_free_all_mem(void);
221 extern void m_apm_trim_mem_usage(void);
222 extern char *m_apm_lib_version(char *);
223 extern char *m_apm_lib_short_version(char *);
224
225 extern void m_apm_set_string(M_APM, char *);
226 extern void m_apm_set_double(M_APM, double);
227 extern void m_apm_set_long(M_APM, long);
228
229 extern void m_apm_to_string(char *, int, M_APM);
230 extern void m_apm_to_fixpt_string(char *, int, M_APM);
231 extern void m_apm_to_fixpt_stringex(char *, int, M_APM, char, char, int);
232 extern char *m_apm_to_fixpt_stringexp(int, M_APM, char, char, int);
233 extern void m_apm_to_integer_string(char *, M_APM);
234
235 extern void m_apm_absolute_value(M_APM, M_APM);
236 extern void m_apm_negate(M_APM, M_APM);
237 extern void m_apm_copy(M_APM, M_APM);
238 extern void m_apm_round(M_APM, int, M_APM);
239 extern int m_apm_compare(M_APM, M_APM);
240 extern int m_apm_sign(M_APM);
241 extern int m_apm_exponent(M_APM);
242 extern int m_apm_significant_digits(M_APM);
243 extern int m_apm_is_integer(M_APM);
244 extern int m_apm_is_even(M_APM);
245 extern int m_apm_is_odd(M_APM);
246
247 extern void m_apm_gcd(M_APM, M_APM, M_APM);
248 extern void m_apm_lcm(M_APM, M_APM, M_APM);
249
250 extern void m_apm_add(M_APM, M_APM, M_APM);
251 extern void m_apm_subtract(M_APM, M_APM, M_APM);
252 extern void m_apm_multiply(M_APM, M_APM, M_APM);
253 extern void m_apm_divide(M_APM, int, M_APM, M_APM);
254 extern void m_apm_integer_divide(M_APM, M_APM, M_APM);
255 extern void m_apm_integer_div_rem(M_APM, M_APM, M_APM, M_APM);
256 extern void m_apm_reciprocal(M_APM, int, M_APM);
257 extern void m_apm_factorial(M_APM, M_APM);
258 extern void m_apm_floor(M_APM, M_APM);
259 extern void m_apm_ceil(M_APM, M_APM);
260 extern void m_apm_get_random(M_APM);
261 extern void m_apm_set_random_seed(char *);
262
263 extern void m_apm_sqrt(M_APM, int, M_APM);
264 extern void m_apm_cbrt(M_APM, int, M_APM);
265 extern void m_apm_log(M_APM, int, M_APM);
266 extern void m_apm_log10(M_APM, int, M_APM);
267 extern void m_apm_exp(M_APM, int, M_APM);
268 extern void m_apm_pow(M_APM, int, M_APM, M_APM);
269 extern void m_apm_integer_pow(M_APM, int, M_APM, int);
270 extern void m_apm_integer_pow_nr(M_APM, M_APM, int);
271
272 extern void m_apm_sin_cos(M_APM, M_APM, int, M_APM);
273 extern void m_apm_sin(M_APM, int, M_APM);
274 extern void m_apm_cos(M_APM, int, M_APM);
275 extern void m_apm_tan(M_APM, int, M_APM);
276 extern void m_apm_arcsin(M_APM, int, M_APM);
277 extern void m_apm_arccos(M_APM, int, M_APM);
278 extern void m_apm_arctan(M_APM, int, M_APM);
279 extern void m_apm_arctan2(M_APM, int, M_APM, M_APM);
280
281 extern void m_apm_sinh(M_APM, int, M_APM);
282 extern void m_apm_cosh(M_APM, int, M_APM);
283 extern void m_apm_tanh(M_APM, int, M_APM);
284 extern void m_apm_arcsinh(M_APM, int, M_APM);
285 extern void m_apm_arccosh(M_APM, int, M_APM);
286 extern void m_apm_arctanh(M_APM, int, M_APM);
287
288 extern void m_apm_cpp_precision(int); /* only for C++ wrapper */
289
290 /* more intuitive alternate names for the ARC functions ... */
291
292 #define m_apm_asin m_apm_arcsin
293 #define m_apm_acos m_apm_arccos
294 #define m_apm_atan m_apm_arctan
295 #define m_apm_atan2 m_apm_arctan2
296
297 #define m_apm_asinh m_apm_arcsinh
298 #define m_apm_acosh m_apm_arccosh
299 #define m_apm_atanh m_apm_arctanh
300
301 #ifdef APM_CONVERT_FROM_C
302 } /* End extern "C" bracket */
303 #endif
304
305 #ifdef __cplusplus /*<- Hides the class below from C compilers */
306
307 /*
308 This class lets you use M_APM's a bit more intuitively with
309 C++'s operator and function overloading, constructors, etc.
310
311 Added 3/24/2000 by Orion Sky Lawlor, olawlor@acm.org
312 */
313
314 extern
315 #ifdef APM_CONVERT_FROM_C
316 "C"
317 #endif
318 int MM_cpp_min_precision;
319
320
321 class MAPM {
322 protected:
323
324 /*
325 The M_APM structure here is implemented as a reference-
326 counted, copy-on-write data structure-- this makes copies
327 very fast, but that's why it's so ugly. A MAPM object is
328 basically just a wrapper around a (possibly shared)
329 M_APM_struct myVal.
330 */
331
332
333 M_APM myVal; /* My M_APM structure */
334 void create(void) {myVal=makeNew();}
335 void destroy(void) {unref(myVal);myVal=NULL;}
336 void copyFrom(M_APM Nval)
337 {
338 M_APM oldVal=myVal;
339 myVal=Nval;
340 ref(myVal);
341 unref(oldVal);
342 }
343 static M_APM makeNew(void)
344 {
345 M_APM val=m_apm_init();
346 /* refcount initialized to 1 by 'm_apm_init' */
347 return val;
348 }
349 static void ref(M_APM val)
350 {
351 val->m_apm_refcount++;
352 }
353 static void unref(M_APM val)
354 {
355 val->m_apm_refcount--;
356 if (val->m_apm_refcount==0)
357 m_apm_free(val);
358 }
359
360 /* This routine is called to get a private (mutable)
361 copy of our current value. */
362 M_APM val(void)
363 {
364 if (myVal->m_apm_refcount==1)
365 /* Return my private myVal */
366 return myVal;
367
368 /* Otherwise, our copy of myVal is shared--
369 we need to make a new private copy.
370 */
371 M_APM oldVal=myVal;
372 myVal=makeNew();
373 m_apm_copy(myVal,oldVal);
374 unref(oldVal);
375 return myVal;
376 }
377
378 /*BAD: C M_APM routines doesn't use "const" where they should--
379 hence we have to cast to a non-const type here (FIX THIS!).
380
381 (in due time.... MCR)
382 */
383 M_APM cval(void) const
384 {
385 return (M_APM)myVal;
386 }
387 /* This is the default number of digits to use for
388 1-ary functions like sin, cos, tan, etc.
389 It's the larger of my digits and cpp_min_precision.
390 */
391 int myDigits(void) const
392 {
393 int maxd=m_apm_significant_digits(cval());
394 if (maxd<MM_cpp_min_precision) maxd=MM_cpp_min_precision;
395 return maxd;
396 }
397 /* This is the default number of digits to use for
398 2-ary functions like divide, atan2, etc.
399 It's the larger of my digits, his digits, and cpp_min_precision.
400 */
401 int digits(const MAPM &otherVal) const
402 {
403 int maxd=myDigits();
404 int his=m_apm_significant_digits(otherVal.cval());
405 if (maxd<his) maxd=his;
406 return maxd;
407 }
408 public:
409 /* Constructors: */
410 MAPM(void) /* Default constructor (takes no value) */
411 {create();}
412 MAPM(const MAPM &m) /* Copy constructor */
413 {myVal=(M_APM)m.cval();ref(myVal);}
414 MAPM(M_APM m) /* M_APM constructor (refcount starts at one) */
415 {myVal=(M_APM)m;ref(myVal);}
416 MAPM(const char *s) /* Constructor from string */
417 {create();m_apm_set_string(val(),(char *)s);}
418 MAPM(double d) /* Constructor from double-precision float */
419 {create();m_apm_set_double(val(),d);}
420 MAPM(int l) /* Constructor from int */
421 {create();m_apm_set_long(val(),l);}
422 MAPM(long l) /* Constructor from long int */
423 {create();m_apm_set_long(val(),l);}
424 /* Destructor */
425 ~MAPM() {destroy();}
426
427 /* Extracting string descriptions: */
428 void toString(char *dest,int decimalPlaces) const
429 {m_apm_to_string(dest,decimalPlaces,cval());}
430 void toFixPtString(char *dest,int decimalPlaces) const
431 {m_apm_to_fixpt_string(dest,decimalPlaces,cval());}
432 void toFixPtStringEx(char *dest,int dp,char a,char b,int c) const
433 {m_apm_to_fixpt_stringex(dest,dp,cval(),a,b,c);}
434 char *toFixPtStringExp(int dp,char a,char b,int c) const
435 {return(m_apm_to_fixpt_stringexp(dp,cval(),a,b,c));}
436 void toIntegerString(char *dest) const
437 {m_apm_to_integer_string(dest,cval());}
438
439 /* Basic operators: */
440 MAPM &operator=(const MAPM &m) /* Assigment operator */
441 {copyFrom((M_APM)m.cval());return *this;}
442 MAPM &operator=(const char *s) /* Assigment operator */
443 {m_apm_set_string(val(),(char *)s);return *this;}
444 MAPM &operator=(double d) /* Assigment operator */
445 {m_apm_set_double(val(),d);return *this;}
446 MAPM &operator=(int l) /* Assigment operator */
447 {m_apm_set_long(val(),l);return *this;}
448 MAPM &operator=(long l) /* Assigment operator */
449 {m_apm_set_long(val(),l);return *this;}
450 MAPM operator++() /* Prefix increment operator */
451 {return *this = *this+MM_One;}
452 MAPM operator--() /* Prefix decrement operator */
453 {return *this = *this-MM_One;}
454 const MAPM operator++(int) /* Postfix increment operator */
455 {
456 MAPM old = *this;
457 ++(*this); /* Call prefix increment */
458 return old;
459 }
460 const MAPM operator--(int) /* Postfix decrement operator */
461 {
462 MAPM old = *this;
463 --(*this); /* Call prefix decrement */
464 return old;
465 }
466
467 /* Comparison operators */
468 int operator==(const MAPM &m) const /* Equality operator */
469 {return m_apm_compare(cval(),m.cval())==0;}
470 int operator!=(const MAPM &m) const /* Inequality operator */
471 {return m_apm_compare(cval(),m.cval())!=0;}
472 int operator<(const MAPM &m) const
473 {return m_apm_compare(cval(),m.cval())<0;}
474 int operator<=(const MAPM &m) const
475 {return m_apm_compare(cval(),m.cval())<=0;}
476 int operator>(const MAPM &m) const
477 {return m_apm_compare(cval(),m.cval())>0;}
478 int operator>=(const MAPM &m) const
479 {return m_apm_compare(cval(),m.cval())>=0;}
480
481 /* Basic arithmetic operators */
482 friend MAPM operator+(const MAPM &a,const MAPM &b)
483 {MAPM ret;m_apm_add(ret.val(),a.cval(),b.cval());return ret;}
484 friend MAPM operator-(const MAPM &a,const MAPM &b)
485 {MAPM ret;m_apm_subtract(ret.val(),a.cval(),b.cval());return ret;}
486 friend MAPM operator*(const MAPM &a,const MAPM &b)
487 {MAPM ret;m_apm_multiply(ret.val(),a.cval(),b.cval());return ret;}
488 friend MAPM operator%(const MAPM &a,const MAPM &b)
489 {MAPM quot,ret;m_apm_integer_div_rem(quot.val(),ret.val(),
490 a.cval(),b.cval());return ret;}
491
492 /* Default division keeps larger of cpp_min_precision, numerator
493 digits of precision, or denominator digits of precision. */
494 friend MAPM operator/(const MAPM &a,const MAPM &b)
495 {return a.divide(b,a.digits(b));}
496
497 MAPM divide(const MAPM &m,int toDigits) const
498 {MAPM ret;m_apm_divide(ret.val(),toDigits,cval(),
499 m.cval());return ret;}
500 MAPM divide(const MAPM &m) const {return divide(m,digits(m));}
501
502 /* Assignment arithmetic operators */
503 MAPM &operator+=(const MAPM &m) {*this = *this+m;return *this;}
504 MAPM &operator-=(const MAPM &m) {*this = *this-m;return *this;}
505 MAPM &operator*=(const MAPM &m) {*this = *this*m;return *this;}
506 MAPM &operator/=(const MAPM &m) {*this = *this/m;return *this;}
507 MAPM &operator%=(const MAPM &m) {*this = *this%m;return *this;}
508
509 /* Extracting/setting simple information: */
510 int sign(void) const
511 {return m_apm_sign(cval());}
512 int exponent(void) const
513 {return m_apm_exponent(cval());}
514 int significant_digits(void) const
515 {return m_apm_significant_digits(cval());}
516 int is_integer(void) const
517 {return m_apm_is_integer(cval());}
518 int is_even(void) const
519 {return m_apm_is_even(cval());}
520 int is_odd(void) const
521 {return m_apm_is_odd(cval());}
522
523 /* Functions: */
524 MAPM abs(void) const
525 {MAPM ret;m_apm_absolute_value(ret.val(),cval());return ret;}
526 MAPM neg(void) const
527 {MAPM ret;m_apm_negate(ret.val(),cval());return ret;}
528 MAPM round(int toDigits) const
529 {MAPM ret;m_apm_round(ret.val(),toDigits,cval());return ret;}
530 MAPM operator-(void) const {return neg();}
531
532 /* I got tired of typing the various declarations for a simple
533 1-ary real-to-real function on MAPM's; hence this define:
534 The digits-free versions return my digits of precision or
535 cpp_min_precision, whichever is bigger.
536 */
537
538 #define MAPM_1aryFunc(func) \
539 MAPM func(int toDigits) const\
540 {MAPM ret;m_apm_##func(ret.val(),toDigits,cval());return ret;}\
541 MAPM func(void) const {return func(myDigits());}
542
543 MAPM_1aryFunc(sqrt)
544 MAPM_1aryFunc(cbrt)
545 MAPM_1aryFunc(log)
546 MAPM_1aryFunc(exp)
547 MAPM_1aryFunc(log10)
548 MAPM_1aryFunc(sin)
549 MAPM_1aryFunc(asin)
550 MAPM_1aryFunc(cos)
551 MAPM_1aryFunc(acos)
552 MAPM_1aryFunc(tan)
553 MAPM_1aryFunc(atan)
554 MAPM_1aryFunc(sinh)
555 MAPM_1aryFunc(asinh)
556 MAPM_1aryFunc(cosh)
557 MAPM_1aryFunc(acosh)
558 MAPM_1aryFunc(tanh)
559 MAPM_1aryFunc(atanh)
560 #undef MAPM_1aryFunc
561
562 void sincos(MAPM &sinR,MAPM &cosR,int toDigits)
563 {m_apm_sin_cos(sinR.val(),cosR.val(),toDigits,cval());}
564 void sincos(MAPM &sinR,MAPM &cosR)
565 {sincos(sinR,cosR,myDigits());}
566 MAPM pow(const MAPM &m,int toDigits) const
567 {MAPM ret;m_apm_pow(ret.val(),toDigits,cval(),
568 m.cval());return ret;}
569 MAPM pow(const MAPM &m) const {return pow(m,digits(m));}
570 MAPM atan2(const MAPM &x,int toDigits) const
571 {MAPM ret;m_apm_arctan2(ret.val(),toDigits,cval(),
572 x.cval());return ret;}
573 MAPM atan2(const MAPM &x) const
574 {return atan2(x,digits(x));}
575
576 MAPM gcd(const MAPM &m) const
577 {MAPM ret;m_apm_gcd(ret.val(),cval(),m.cval());return ret;}
578
579 MAPM lcm(const MAPM &m) const
580 {MAPM ret;m_apm_lcm(ret.val(),cval(),m.cval());return ret;}
581
582 static MAPM random(void)
583 {MAPM ret;m_apm_get_random(ret.val());return ret;}
584
585 MAPM floor(void) const
586 {MAPM ret;m_apm_floor(ret.val(),cval());return ret;}
587 MAPM ceil(void) const
588 {MAPM ret;m_apm_ceil(ret.val(),cval());return ret;}
589
590 /* Functions defined only on integers: */
591 MAPM factorial(void) const
592 {MAPM ret;m_apm_factorial(ret.val(),cval());return ret;}
593 MAPM ipow_nr(int p) const
594 {MAPM ret;m_apm_integer_pow_nr(ret.val(),
595 cval(),p);return ret;}
596 MAPM ipow(int p,int toDigits) const
597 {MAPM ret;m_apm_integer_pow(ret.val(),
598 toDigits,cval(),p);return ret;}
599 MAPM ipow(int p) const
600 {return ipow(p,myDigits());}
601 MAPM integer_divide(const MAPM &denom) const
602 {MAPM ret;m_apm_integer_divide(ret.val(),cval(),
603 denom.cval());return ret;}
604 void integer_div_rem(const MAPM &denom,MAPM ",MAPM &rem) const
605 {m_apm_integer_div_rem(quot.val(),rem.val(),cval(),
606 denom.cval());}
607 MAPM div(const MAPM &denom) const {return integer_divide(denom);}
608 MAPM rem(const MAPM &denom) const {MAPM ret,ignored;
609 integer_div_rem(denom,ignored,ret);return ret;}
610 };
611
612 /* math.h-style functions: */
613
614 inline MAPM fabs(const MAPM &m) {return m.abs();}
615 inline MAPM factorial(const MAPM &m) {return m.factorial();}
616 inline MAPM floor(const MAPM &m) {return m.floor();}
617 inline MAPM ceil(const MAPM &m) {return m.ceil();}
618 inline MAPM get_random(void) {return MAPM::random();}
619
620 /* I got tired of typing the various declarations for a simple
621 1-ary real-to-real function on MAPM's; hence this define:
622 */
623 #define MAPM_1aryFunc(func) \
624 inline MAPM func(const MAPM &m) {return m.func();} \
625 inline MAPM func(const MAPM &m,int toDigits) {return m.func(toDigits);}
626
627 /* Define a big block of simple functions: */
628 MAPM_1aryFunc(sqrt)
629 MAPM_1aryFunc(cbrt)
630 MAPM_1aryFunc(log)
631 MAPM_1aryFunc(exp)
632 MAPM_1aryFunc(log10)
633 MAPM_1aryFunc(sin)
634 MAPM_1aryFunc(asin)
635 MAPM_1aryFunc(cos)
636 MAPM_1aryFunc(acos)
637 MAPM_1aryFunc(tan)
638 MAPM_1aryFunc(atan)
639 MAPM_1aryFunc(sinh)
640 MAPM_1aryFunc(asinh)
641 MAPM_1aryFunc(cosh)
642 MAPM_1aryFunc(acosh)
643 MAPM_1aryFunc(tanh)
644 MAPM_1aryFunc(atanh)
645 #undef MAPM_1aryFunc
646
647 /* Computes x to the power y */
648 inline MAPM pow(const MAPM &x,const MAPM &y,int toDigits)
649 {return x.pow(y,toDigits);}
650 inline MAPM pow(const MAPM &x,const MAPM &y)
651 {return x.pow(y);}
652 inline MAPM atan2(const MAPM &y,const MAPM &x,int toDigits)
653 {return y.atan2(x,toDigits);}
654 inline MAPM atan2(const MAPM &y,const MAPM &x)
655 {return y.atan2(x);}
656 inline MAPM gcd(const MAPM &u,const MAPM &v)
657 {return u.gcd(v);}
658 inline MAPM lcm(const MAPM &u,const MAPM &v)
659 {return u.lcm(v);}
660 #endif
661 #endif
662