headers/libs/mapm/m_apm.h

   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 &quot,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