cgit.sxemacs.org Git - sxemacs/blob - src/ent/ent-gmp.h

   1 /*
   2   ent-gmp.h -- Numeric types for SXEmacs
   3   Copyright (C) 2004, 2005, 2006 Sebastian Freundt
   4
   5   Author:  Jerry James
   6   Backport:  Sebastian Freundt
   7
   8 This file is part of SXEmacs
   9
  10 SXEmacs is free software: you can redistribute it and/or modify
  11 it under the terms of the GNU General Public License as published by
  12 the Free Software Foundation, either version 3 of the License, or
  13 (at your option) any later version.
  14
  15 SXEmacs is distributed in the hope that it will be useful,
  16 but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 GNU General Public License for more details.
  19
  20 You should have received a copy of the GNU General Public License
  21 along with this program.  If not, see <http://www.gnu.org/licenses/>. */
  22
  23
  24 #ifndef INCLUDED_number_gmp_h_
  25 #define INCLUDED_number_gmp_h_
  26
  27 #ifdef UNO
  28 /* Uno complains about several inline functions that include conditions with
  29    assignments and side effects if we don't do this */
  30 #undef __GNUC__
  31 #endif
  32
  33 #include <gmp.h>
  34
  35 typedef mpz_t bigz;
  36 typedef mpq_t bigq;
  37 typedef mpf_t bigf;
  38
  39 extern bigz ent_scratch_bigz;
  40 extern bigq ent_scratch_bigq;
  41 extern bigf ent_scratch_bigf;
  42
  43 \f
  44 /********************************* Bigzs **********************************/
  45 struct Lisp_Bigz {
  46         struct lrecord_header lheader;
  47         bigz data;
  48 };
  49 typedef struct Lisp_Bigz Lisp_Bigz;
  50
  51 DECLARE_LRECORD (bigz, Lisp_Bigz);
  52 #define XBIGZ(x) XRECORD (x, bigz, Lisp_Bigz)
  53 #define wrap_bigz(p) wrap_object (p)
  54 #define BIGZP(x) RECORDP (x, bigz)
  55 #define CHECK_BIGZ(x) CHECK_RECORD (x, bigz)
  56 #define CONCHECK_BIGZ(x) CONCHECK_RECORD (x, bigz)
  57
  58 #define bigz_data(b) (b)->data
  59 #define XBIGZ_DATA(x) bigz_data (XBIGZ (x))
  60
  61 extern Lisp_Object make_bigz(long);
  62 extern Lisp_Object make_bigz_bz(bigz);
  63
  64 \f
  65 extern gmp_randstate_t random_state;
  66
  67 /***** Bigz: basic functions *****/
  68 #define bigz_init(b)                    mpz_init (b)
  69 #define bigz_fini(b)                    mpz_clear (b)
  70 #define bigz_hashcode(b)                mpz_get_ui (b)
  71 #define bigz_sign(b)                    mpz_sgn (b)
  72 #define bigz_evenp(b)                   mpz_even_p (b)
  73 #define bigz_oddp(b)                    mpz_odd_p (b)
  74
  75 /***** Bigz: size *****/
  76 #define bigz_fits_int_p(b)              mpz_fits_sint_p (b)
  77 #define bigz_fits_uint_p(b)             mpz_fits_uint_p (b)
  78 #define bigz_fits_long_p(b)             mpz_fits_slong_p (b)
  79 #define bigz_fits_ulong_p(b)            mpz_fits_ulong_p (b)
  80
  81 /***** Bigz: conversions *****/
  82 #define bigz_to_string(b, base)         mpz_get_str (NULL, base, b)
  83 #define bigz_to_string2(t, b, base)     mpz_get_str(t, base, b)
  84 #define bigz_to_int(b)                  ((EMACS_INT) mpz_get_si (b))
  85 #define bigz_to_uint(b)                 ((EMACS_UINT) mpz_get_ui (b))
  86 #define bigz_to_long(b)                 mpz_get_si (b)
  87 #define bigz_to_ulong(b)                mpz_get_ui (b)
  88 #if fpfloat_double_p
  89 #define bigz_to_fpfloat(b)              mpz_get_d(b)
  90 #elif fpfloat_long_double_p
  91 #define bigz_to_fpfloat(b)              (fpfloat)mpz_get_d(b)
  92 #endif
  93
  94 /***** Bigz: converting assignments *****/
  95 #define bigz_set(b1, b2)                mpz_set(b1, b2)
  96 #define bigz_set_string(b, s, base)     mpz_set_str(b, s, base)
  97 #define bigz_set_long(b, l)             mpz_set_si(b, l)
  98 #define bigz_set_ulong(b, l)            mpz_set_ui(b, l)
  99 #if fpfloat_double_p
 100 #define bigz_set_fpfloat(b, f)          mpz_set_d(b, f)
 101 #elif fpfloat_long_double_p
 102 #define bigz_set_fpfloat(b, f)          mpz_set_d(b, (double)f)
 103 #endif
 104 #define bigz_set_bigq(b, r)             mpz_set_q(b, r)
 105 #define bigz_set_bigf(b, f)             mpz_set_f(b, f)
 106
 107 /***** Bigz: comparisons *****/
 108 #define bigz_cmp(b1,b2)               mpz_cmp (b1, b2)
 109 #define bigz_lt(b1,b2)                (mpz_cmp (b1, b2) < 0)
 110 #define bigz_le(b1,b2)                (mpz_cmp (b1, b2) <= 0)
 111 #define bigz_eql(b1,b2)               (mpz_cmp (b1, b2) == 0)
 112 #define bigz_ge(b1,b2)                (mpz_cmp (b1, b2) >= 0)
 113 #define bigz_gt(b1,b2)                (mpz_cmp (b1, b2) > 0)
 114
 115 /***** Bigz: arithmetic *****/
 116 #define bigz_neg(b,b2)                  mpz_neg(b, b2)
 117 #define bigz_abs(b,b2)                  mpz_abs(b, b2)
 118 #define bigz_add(b,b1,b2)               mpz_add(b, b1, b2)
 119 #define bigz_sub(b,b1,b2)               mpz_sub(b, b1, b2)
 120 #define bigz_mul(b,b1,b2)               mpz_mul(b, b1, b2)
 121 #define bigz_divisible_p(b1,b2)         mpz_divisible_p(b1, b2)
 122 #define bigz_div(b,b1,b2)               mpz_tdiv_q(b, b1, b2)
 123 #define bigz_div_ui(b,b1,b2)            mpz_tdiv_q_ui(b, b1, b2)
 124 #define bigz_ceil(b,b1,b2)              mpz_cdiv_q(b, b1, b2)
 125 #define bigz_floor(b,b1,b2)             mpz_fdiv_q(b, b1, b2)
 126 #define bigz_mod(b,b1,b2)               mpz_mod(b, b1, b2)
 127 #define bigz_pow(res,b,pow)             mpz_pow_ui(res, b, pow)
 128 #define bigz_gcd(res,b1,b2)             mpz_gcd(res, b1, b2)
 129 #define bigz_lcm(res,b1,b2)             mpz_lcm(res, b1, b2)
 130
 131 /***** Bigz: bit manipulations *****/
 132 #define bigz_and(res,b1,b2)           mpz_and (res, b1, b2)
 133 #define bigz_ior(res,b1,b2)           mpz_ior (res, b1, b2)
 134 #define bigz_xor(res,b1,b2)           mpz_xor (res, b1, b2)
 135 #define bigz_not(res,b)               mpz_com (res, b)
 136 #define bigz_setbit(b,bit)            mpz_setbit (b, bit)
 137 #define bigz_clrbit(b,bit)            mpz_clrbit (b, bit)
 138 #define bigz_testbit(b,bit)           mpz_tstbit (b, bit)
 139 #define bigz_lshift(res,b,bits)       mpz_mul_2exp (res, b, bits)
 140 #define bigz_rshift(res,b,bits)       mpz_fdiv_q_2exp (res, b, bits)
 141
 142 /***** Bigz: random numbers *****/
 143 #define bigz_random_seed(seed)        gmp_randseed_ui (random_state, seed)
 144 #define bigz_random(res,limit)        mpz_urandomm (res, random_state, limit)
 145
 146 extern Lisp_Object read_bigz_string(const char *cp, int base);
 147 extern_inline Lisp_Object ent_mpz_downgrade_maybe(bigz);
 148
 149 extern_inline Lisp_Object
 150 ent_mpz_downgrade_maybe(bigz n)
 151 {
 152         if (!bigz_fits_int_p(n))
 153                 return make_bigz_bz(n);
 154         else {
 155                 EMACS_INT i = bigz_to_int(n);
 156                 if (NUMBER_FITS_IN_AN_EMACS_INT(i))
 157                         return make_int(i);
 158                 else
 159                         return make_bigz_bz(n);
 160         }
 161 }
 162
 163 \f
 164 /************************** Rational Integer Fractions **********************/
 165 struct Lisp_Bigq
 166 {
 167         struct lrecord_header lheader;
 168         bigq data;
 169 };
 170 typedef struct Lisp_Bigq Lisp_Bigq;
 171
 172 DECLARE_LRECORD(bigq, Lisp_Bigq);
 173 #define XBIGQ(x) XRECORD(x, bigq, Lisp_Bigq)
 174 #define wrap_bigq(p) wrap_object (p)
 175 #define BIGQP(x) RECORDP(x, bigq)
 176 #define CHECK_BIGQ(x) CHECK_RECORD(x, bigq)
 177 #define CONCHECK_BIGQ(x) CONCHECK_RECORD(x, bigq)
 178
 179 #define bigq_data(r) (r)->data
 180
 181 #define XBIGQ_DATA(r) bigq_data(XBIGQ(r))
 182 #define XBIGQ_NUMERATOR(r) bigq_numerator(XBIGQ_DATA(r))
 183 #define XBIGQ_DENOMINATOR(r) bigq_denominator(XBIGQ_DATA(r))
 184
 185 extern Lisp_Object make_bigq(long, unsigned long);
 186 extern Lisp_Object make_bigq_bz(bigz, bigz);
 187 extern Lisp_Object make_bigq_bq(bigq);
 188
 189 \f
 190 /***** Bigq: basic functions *****/
 191 #define bigq_init(r)                   mpq_init (r)
 192 #define bigq_fini(r)                   mpq_clear (r)
 193 #define bigq_hashcode(r) \
 194   (mpz_get_ui (mpq_denref (r)) * mpz_get_ui (mpq_numref (r)))
 195 #define bigq_sign(r)                   mpq_sgn (r)
 196 #define bigq_numerator(r)              mpq_numref (r)
 197 #define bigq_denominator(r)            mpq_denref (r)
 198 #define bigq_canonicalize(r)           mpq_canonicalize (r)
 199
 200 /***** Bigq: conversions *****/
 201 #define bigq_to_string(r,base)          mpq_get_str (NULL, base, r)
 202 #define bigq_to_string2(t, b, base)     mpq_get_str(t, base, b)
 203 #define bigq_to_int(r)                 ((EMACS_INT) (mpq_get_d (r)))
 204 #define bigq_to_uint(r)                ((EMACS_UINT) (mpq_get_d (r)))
 205 #define bigq_to_long(r)                ((long) (mpq_get_d (r)))
 206 #define bigq_to_ulong(r)               ((unsigned long) (mpq_get_d (r)))
 207 #if fpfloat_double_p
 208 #define bigq_to_fpfloat(r)              mpq_get_d(r)
 209 #elif fpfloat_long_double_p
 210 #define bigq_to_fpfloat(r)              (fpfloat)mpq_get_d(r)
 211 #endif
 212
 213 /***** Bigq: converting assignments *****/
 214 #define bigq_set(r1, r2)                mpq_set(r1, r2)
 215 #define bigq_set_string(r, s, base)     mpq_set_str(r, s, base)
 216 #define bigq_set_long(r, l)             mpq_set_si(r, l, 1UL)
 217 #define bigq_set_ulong(r, l)            mpq_set_ui(r, l, 1UL)
 218 #if fpfloat_double_p
 219 #define bigq_set_fpfloat(r, f)          mpq_set_d(r, f)
 220 #elif fpfloat_long_double_p
 221 #define bigq_set_fpfloat(r, f)          mpq_set_d(r, (double)f)
 222 #endif
 223 #define bigq_set_bigz(r, b)             mpq_set_z(r, b)
 224 #define bigq_set_bigf(r, f)             mpq_set_f(r, f)
 225 #define bigq_set_long_ulong(r,num,den)  mpq_set_si(r, num, den)
 226 #define bigq_set_ulong_ulong(r,num,den) mpq_set_ui(r, num, den)
 227 /* FIXME: Why does this canonicalize, but the previous 2 don't? */
 228 #define bigq_set_bigz_bigz(r,num,den) do {      \
 229     mpz_set (mpq_numref (r), num);              \
 230     mpz_set (mpq_denref (r), den);              \
 231     mpq_canonicalize (r);                       \
 232   } while (0)
 233
 234 /***** Bigq: comparisons *****/
 235 #define bigq_cmp(r1,r2)                mpq_cmp (r1, r2)
 236 #define bigq_lt(r1,r2)                 (mpq_cmp (r1, r2) < 0)
 237 #define bigq_le(r1,r2)                 (mpq_cmp (r1, r2) <= 0)
 238 #define bigq_eql(r1,r2)                mpq_equal (r1, r2)
 239 #define bigq_ge(r1,r2)                 (mpq_cmp (r1, r2) >= 0)
 240 #define bigq_gt(r1,r2)                 (mpq_cmp (r1, r2) > 0)
 241 #define bigq_ne(r1,r2)                 (!mpq_equal (r1, r2))
 242
 243 /***** Bigq: arithmetic *****/
 244 #define bigq_neg(q,q2)                 mpq_neg (q, q2)
 245 #define bigq_abs(q,q2)                 mpq_abs (q, q2)
 246 #define bigq_inv(q,q2)                 mpq_inv (q, q2)
 247 #define bigq_add(res,q1,q2)            mpq_add (res, q1, q2)
 248 #define bigq_sub(res,q1,q2)            mpq_sub (res, q1, q2)
 249 #define bigq_mul(res,q1,q2)            mpq_mul (res, q1, q2)
 250 #define bigq_div(res,q1,q2)            mpq_div (res, q1, q2)
 251
 252 extern Lisp_Object read_bigq_string(char *cp);
 253 extern_inline Lisp_Object ent_mpq_downgrade_maybe(bigq);
 254
 255 extern_inline Lisp_Object
 256 ent_mpq_downgrade_maybe(bigq n)
 257 {
 258         bigq_canonicalize(n);
 259         if (!bigz_fits_long_p(bigq_denominator(n)) ||
 260             bigz_to_long(bigq_denominator(n)) != 1L) {
 261                 return make_bigq_bq(n);
 262         } else {
 263                 return ent_mpz_downgrade_maybe(bigq_numerator(n));
 264         }
 265 }
 266
 267 \f
 268 /******************************** Bigfs *********************************/
 269 struct Lisp_Bigf
 270 {
 271         struct lrecord_header lheader;
 272         bigf data;
 273 };
 274 typedef struct Lisp_Bigf Lisp_Bigf;
 275
 276 DECLARE_LRECORD(bigf, Lisp_Bigf);
 277 #define XBIGF(x) XRECORD(x, bigf, Lisp_Bigf)
 278 #define wrap_bigf(p) wrap_object(p)
 279 #define BIGFP(x) RECORDP(x, bigf)
 280 #define CHECK_BIGF(x) CHECK_RECORD(x, bigf)
 281 #define CONCHECK_BIGF(x) CONCHECK_RECORD(x, bigf)
 282
 283 #define bigf_data(f) ((f)->data)
 284 #define XBIGF_DATA(x) bigf_data(XBIGF(x))
 285 #define XBIGF_GET_PREC(x) bigf_get_prec(XBIGF_DATA(x))
 286 #define XBIGF_SET_PREC(x,p) bigf_set_prec(XBIGF_DATA(x), p)
 287
 288 extern Lisp_Object make_bigf(fpfloat, unsigned long);
 289 extern Lisp_Object make_bigf_bf(bigf);
 290
 291 \f
 292 /***** Bigf: basic functions *****/
 293 #define bigf_init(f)                mpf_init (f)
 294 #define bigf_init_prec(f,prec)      mpf_init2 (f, prec)
 295 #define bigf_fini(f)                mpf_clear (f)
 296 #define bigf_hashcode(f)            mpf_get_ui (f)
 297 #define bigf_sign(f)                mpf_sgn (f)
 298 #define bigf_get_prec(f)            mpf_get_prec (f)
 299 #define bigf_set_prec(f, prec)      mpf_set_prec (f, prec)
 300 #define bigf_set_default_prec(prec) mpf_set_default_prec(prec)
 301 #define bigf_get_default_prec()     mpf_get_default_prec()
 302
 303 /***** Bigf: conversions *****/
 304 extern Bufbyte *bigf_to_string (bigf f, int base);
 305 #define bigf_to_int(f)              ((EMACS_INT) mpf_get_si (f))
 306 #define bigf_to_uint(f)             ((EMACS_UINT) mpf_get_ui (f))
 307 #define bigf_to_long(f)             mpf_get_si (f)
 308 #define bigf_to_ulong(f)            mpf_get_ui (f)
 309 #if fpfloat_double_p
 310 #define bigf_to_fpfloat(f)              mpf_get_d(f)
 311 #elif fpfloat_long_double_p
 312 #define bigf_to_fpfloat(f)              (fpfloat)mpf_get_d(f)
 313 #endif
 314
 315 /***** Bigf: converting assignments *****/
 316 #define bigf_set(f1,f2)             mpf_set (f1, f2)
 317 #define bigf_set_string(f,str,base) mpf_set_str (f, str, base)
 318 #define bigf_set_long(f,l)          mpf_set_si (f, l)
 319 #define bigf_set_ulong(f,l)         mpf_set_ui (f, l)
 320 #if fpfloat_double_p
 321 #define bigf_set_fpfloat(d, f)          mpf_set_d(d, f)
 322 #elif fpfloat_long_double_p
 323 #define bigf_set_fpfloat(d, f)          mpf_set_d(d, (double)f)
 324 #endif
 325 #define bigf_set_bigz(f, b)             mpf_set_z (f, b)
 326 #define bigf_set_bigq(f, r)             mpf_set_q (f, r)
 327
 328 /***** Bigf: comparisons *****/
 329 #define bigf_cmp(f1,f2)             mpf_cmp (f1, f2)
 330 #define bigf_lt(f1,f2)              (mpf_cmp (f1, f2) < 0)
 331 #define bigf_le(f1,f2)              (mpf_cmp (f1, f2) <= 0)
 332 #define bigf_eq(f1,f2)                  (mpf_cmp (f1, f2) == 0)
 333 #define bigf_eq_bits(f1,f2,bits)        mpf_eq (f1, f2, bits)
 334 #define bigf_ge(f1,f2)              (mpf_cmp (f1, f2) >= 0)
 335 #define bigf_gt(f1,f2)              (mpf_cmp (f1, f2) > 0)
 336
 337 /***** Bigf: arithmetic *****/
 338 #define bigf_neg(f,f2)              mpf_neg (f, f2)
 339 #define bigf_abs(f,f2)              mpf_abs (f, f2)
 340 #define bigf_add(res,f1,f2)         mpf_add (res, f1, f2)
 341 #define bigf_sub(res,f1,f2)         mpf_sub (res, f1, f2)
 342 #define bigf_mul(res,f1,f2)         mpf_mul (res, f1, f2)
 343 #define bigf_div(res,f1,f2)         mpf_div (res, f1, f2)
 344 #define bigf_ceil(res,f)            mpf_ceil (res, f)
 345 #define bigf_floor(res,f)           mpf_floor (res, f)
 346 #define bigf_trunc(res,f)           mpf_trunc (res, f)
 347 #define bigf_sqrt(res,f)            mpf_sqrt (res, f)
 348 #define bigf_pow(res,f,exp)         mpf_pow_ui (res, f, exp)
 349
 350 extern Lisp_Object read_bigf_string(char *cp);
 351
 352 extern void init_optables_BIGZ_T(void);
 353 extern void init_optables_BIGQ_T(void);
 354 extern void init_optables_BIGF_T(void);
 355 extern void init_ent_mpz(void);
 356 extern void init_ent_mpq(void);
 357 extern void init_ent_mpf(void);
 358 extern void syms_of_ent_mpz(void);
 359 extern void syms_of_ent_mpq(void);
 360 extern void syms_of_ent_mpf(void);
 361 extern void vars_of_ent_mpz(void);
 362 extern void vars_of_ent_mpq(void);
 363 extern void vars_of_ent_mpf(void);
 364
 365 #endif /* INCLUDED_number_gmp_h_ */