1
2 #ifdef __MINGW32__
3 #ifndef __USE_MINGW_ANSI_STDIO
4 #define __USE_MINGW_ANSI_STDIO 1
5 #endif
6 #endif
7
8 #define PERL_NO_GET_CONTEXT 1
9
10 #include "EXTERN.h"
11 #include "perl.h"
12 #include "XSUB.h"
13
14
15 #include "math_mpc_include.h"
16
17 #define MY_CXT_KEY "Math::MPC::_guts" XS_VERSION
18
19 typedef struct {
20 mp_prec_t _perl_default_prec_re;
21 mp_prec_t _perl_default_prec_im;
22 mpc_rnd_t _perl_default_rounding_mode;
23 } my_cxt_t;
24
25 START_MY_CXT
26
27 #define DEFAULT_PREC MY_CXT._perl_default_prec_re,MY_CXT._perl_default_prec_im
28 #define DEFAULT_PREC_RE MY_CXT._perl_default_prec_re
29 #define DEFAULT_PREC_IM MY_CXT._perl_default_prec_im
30 #define DEFAULT_ROUNDING_MODE MY_CXT._perl_default_rounding_mode
31
32 /* These (CXT) values set at boot ... MPC_RNDNN == 0 */
33 /*
34 mpc_rnd_t _perl_default_rounding_mode = MPC_RNDNN;
35 mp_prec_t _perl_default_prec_re = 53;
36 mp_prec_t _perl_default_prec_im = 53;
37 */
38
39 int nok_pok = 0; /* flag that is incremented whenever a scalar that is both
40 NOK and POK is passed to new or an overloaded operator */
41
NOK_POK_val(pTHX)42 int NOK_POK_val(pTHX) {
43 /* return the numeric value of $Math::MPC::NOK_POK */
44 return SvIV(get_sv("Math::MPC::NOK_POK", 0));
45 }
46
_win32_infnanstring(char * s)47 int _win32_infnanstring(char * s) { /* MS Windows only - detect 1.#INF and 1.#IND
48 * Need to do this to correctly handle an inf/nan
49 * scalar that is both NOK and POK on older win32 perls */
50
51 /*************************************
52 * if input string =~ /^\-1\.#INF$/ return -1
53 * elsif input string =~ /^\+?1\.#INF$/i return 1
54 * elsif input string =~ /^(\-|\+)?1\.#IND$/i return 2
55 * else return 0
56 **************************************/
57 #ifdef _WIN32_BIZARRE_INFNAN
58 int sign = 1;
59 int factor = 1;
60
61 if(s[0] == '-') {
62 sign = -1;
63 s++;
64 }
65 else {
66 if(s[0] == '+') s++;
67 }
68
69 if(!strcmp(s, "1.#INF")) return sign;
70 if(!strcmp(s, "1.#IND")) return 2;
71
72 return 0;
73 #else
74 croak("Math::MPC::_win32_infnanstring not implemented for this build of perl");
75 #endif
76 }
77
78 /* This function is based on some code posted by Philippe Theveny. */
79
Rmpc_mul_sj(mpc_ptr rop,mpc_ptr op,intmax_t i,mpc_rnd_t rnd)80 int Rmpc_mul_sj (mpc_ptr rop, mpc_ptr op, intmax_t i, mpc_rnd_t rnd) {
81
82 #ifdef MATH_MPC_NEED_LONG_LONG_INT
83
84 mpfr_t x;
85 int inex;
86
87 mpfr_init2 (x, sizeof(intmax_t) * CHAR_BIT);
88 mpfr_set_sj (x, i, GMP_RNDN);
89
90 inex = mpc_mul_fr (rop, op, x, rnd);
91
92 mpfr_clear (x);
93 return inex;
94 }
95
96 #else
97
98 croak("Rmpc_mul_sj not implememnted on this build of perl");
99 }
100
101 #endif
102
103
104 /* This function is based on some code posted by Philippe Theveny. */
105
Rmpc_mul_ld(mpc_ptr rop,mpc_ptr op,long double i,mpc_rnd_t rnd)106 int Rmpc_mul_ld (mpc_ptr rop, mpc_ptr op, long double i, mpc_rnd_t rnd) {
107
108 #if defined(NV_IS_LONG_DOUBLE) || defined(NV_IS_FLOAT128)
109
110 mpfr_t x;
111 int inex;
112
113 mpfr_init2 (x, sizeof(long double) * CHAR_BIT);
114 mpfr_set_ld (x, i, GMP_RNDN);
115
116 inex = mpc_mul_fr (rop, op, x, rnd);
117
118 mpfr_clear (x);
119 return inex;
120 }
121
122 #else
123
124 croak("Rmpc_mul_ld not implememnted on this build of perl");
125 }
126
127 #endif
128
129
130 /* This function is based on some code posted by Philippe Theveny. */
131
Rmpc_mul_d(mpc_ptr rop,mpc_ptr op,double i,mpc_rnd_t rnd)132 int Rmpc_mul_d (mpc_ptr rop, mpc_ptr op, double i, mpc_rnd_t rnd) {
133 mpfr_t x;
134 int inex;
135
136 mpfr_init2 (x, sizeof(double) * CHAR_BIT);
137 mpfr_set_d (x, i, GMP_RNDN);
138
139 inex = mpc_mul_fr (rop, op, x, rnd);
140
141 mpfr_clear (x);
142 return inex;
143 }
144
145
146 /* This function is based on some code posted by Philippe Theveny. */
147
Rmpc_div_sj(mpc_ptr rop,mpc_ptr op,intmax_t i,mpc_rnd_t rnd)148 int Rmpc_div_sj (mpc_ptr rop, mpc_ptr op, intmax_t i, mpc_rnd_t rnd) {
149
150 #ifdef MATH_MPC_NEED_LONG_LONG_INT
151
152 mpfr_t x;
153 int inex;
154
155 mpfr_init2 (x, sizeof(intmax_t) * CHAR_BIT);
156 mpfr_set_sj (x, i, GMP_RNDN);
157
158 inex = mpc_div_fr (rop, op, x, rnd);
159
160 mpfr_clear (x);
161 return inex;
162 }
163
164 #else
165
166 croak("Rmpc_div_sj not implememnted on this build of perl");
167 }
168
169 #endif
170
171
172 /* This function is based on some code posted by Philippe Theveny. */
173
Rmpc_sj_div(mpc_ptr rop,intmax_t i,mpc_ptr op,mpc_rnd_t rnd)174 int Rmpc_sj_div (mpc_ptr rop, intmax_t i, mpc_ptr op, mpc_rnd_t rnd) {
175
176 #ifdef MATH_MPC_NEED_LONG_LONG_INT
177
178 mpfr_t x;
179 int inex;
180
181 mpfr_init2 (x, sizeof(intmax_t) * CHAR_BIT);
182 mpfr_set_sj (x, i, GMP_RNDN);
183
184 inex = mpc_fr_div (rop, x, op, rnd);
185
186 mpfr_clear (x);
187 return inex;
188 }
189
190 #else
191
192 croak("Rmpc_sj_div not implememnted on this build of perl");
193 }
194
195 #endif
196
197
198 /* This function is based on some code posted by Philippe Theveny. */
199
Rmpc_div_ld(mpc_ptr rop,mpc_ptr op,long double i,mpc_rnd_t rnd)200 int Rmpc_div_ld (mpc_ptr rop, mpc_ptr op, long double i, mpc_rnd_t rnd) {
201
202 #if defined(NV_IS_LONG_DOUBLE) || defined(NV_IS_FLOAT128)
203
204 mpfr_t x;
205 int inex;
206
207 mpfr_init2 (x, sizeof(long double) * CHAR_BIT);
208 mpfr_set_ld (x, i, GMP_RNDN);
209
210 inex = mpc_div_fr (rop, op, x, rnd);
211
212 mpfr_clear (x);
213 return inex;
214 }
215
216 #else
217
218 croak("Rmpc_div_ld not implememnted on this build of perl");
219 }
220
221 #endif
222
223
224 /* This function is based on some code posted by Philippe Theveny. */
225
Rmpc_ld_div(mpc_ptr rop,long double i,mpc_ptr op,mpc_rnd_t rnd)226 int Rmpc_ld_div (mpc_ptr rop, long double i, mpc_ptr op, mpc_rnd_t rnd) {
227
228 #if defined(NV_IS_LONG_DOUBLE) || defined(NV_IS_FLOAT128)
229
230 mpfr_t x;
231 int inex;
232
233 mpfr_init2 (x, sizeof(long double) * CHAR_BIT);
234 mpfr_set_ld (x, i, GMP_RNDN);
235
236 inex = mpc_fr_div (rop, x, op, rnd);
237
238 mpfr_clear (x);
239 return inex;
240 }
241
242 #else
243
244 croak("Rmpc_ld_div not implememnted on this build of perl");
245 }
246
247 #endif
248
249 /* This function is based on some code posted by Philippe Theveny. */
250
Rmpc_div_d(mpc_ptr rop,mpc_ptr op,double i,mpc_rnd_t rnd)251 int Rmpc_div_d (mpc_ptr rop, mpc_ptr op, double i, mpc_rnd_t rnd) {
252 mpfr_t x;
253 int inex;
254
255 mpfr_init2 (x, sizeof(double) * CHAR_BIT);
256 mpfr_set_d (x, i, GMP_RNDN);
257
258 inex = mpc_div_fr (rop, op, x, rnd);
259
260 mpfr_clear (x);
261 return inex;
262 }
263
264
265 /* This function is based on some code posted by Philippe Theveny. */
266
Rmpc_d_div(mpc_ptr rop,double i,mpc_ptr op,mpc_rnd_t rnd)267 int Rmpc_d_div (mpc_ptr rop, double i, mpc_ptr op, mpc_rnd_t rnd) {
268 mpfr_t x;
269 int inex;
270
271 mpfr_init2 (x, sizeof(double) * CHAR_BIT);
272 mpfr_set_d (x, i, GMP_RNDN);
273
274 inex = mpc_fr_div (rop, x, op, rnd);
275
276 mpfr_clear (x);
277 return inex;
278 }
279
280
_mpfr_set_NV(pTHX_ mpfr_t * p,SV * q,unsigned int round)281 SV * _mpfr_set_NV(pTHX_ mpfr_t * p, SV * q, unsigned int round) {
282
283 #if defined(MPC_CAN_PASS_FLOAT128)
284
285 if(!SV_IS_NOK(q)) croak("Second arg given to Rmpfr_set_NV is not an NV");
286
287 return newSViv(mpfr_set_float128(*p, (float128)SvNVX(q), (mp_rnd_t)round));
288
289 #elif defined(NV_IS_FLOAT128)
290
291 char * buffer;
292 int exp, exp2 = 0;
293 float128 ld, buffer_size;
294 int returned;
295
296 if(!SV_IS_NOK(q)) croak("Second arg given to Math::MPC::_mpfr_set_NV is not an NV");
297
298
299 ld = (float128)SvNVX(q);
300
301 if(ld != ld) {
302 mpfr_set_nan(*p);
303 return newSViv(0);
304 }
305
306 if(ld != 0.0Q && (ld / ld != 1)) {
307 returned = ld > 0.0Q ? 1 : -1;
308 mpfr_set_inf(*p, returned);
309 return newSViv(0);
310 }
311
312 ld = frexpq((float128)SvNVX(q), &exp);
313
314 while(ld != floorq(ld)) {
315 ld *= 2;
316 exp2 += 1;
317 }
318
319 buffer_size = ld < 0.0Q ? ld * -1.0Q : ld;
320 buffer_size = ceilq(logq(buffer_size + 1) / 2.30258509299404568401799145468436418Q);
321
322 Newxz(buffer, buffer_size + 5, char);
323
324 returned = quadmath_snprintf(buffer, (size_t)buffer_size + 5, "%.0Qf", ld);
325 if(returned < 0) croak("In Math::MPC::_mpfr_set_NV, encoding error in quadmath_snprintf function");
326 if(returned >= buffer_size + 5) croak("In Math::MPC::_mpfr_set_NV, buffer given to quadmath_snprintf function was too small");
327 returned = mpfr_set_str(*p, buffer, 10, (mp_rnd_t)round);
328 Safefree(buffer);
329
330 if (exp2 > exp) mpfr_div_2ui(*p, *p, exp2 - exp, GMP_RNDN);
331 else mpfr_mul_2ui(*p, *p, exp - exp2, GMP_RNDN);
332 return newSViv(returned);
333
334 #elif defined(NV_IS_LONG_DOUBLE) && !defined(_MSC_VER)
335
336 if(!SV_IS_NOK(q)) croak("Second arg given to Math::MPC::_mpfr_set_NV is not an NV");
337
338 return newSViv(mpfr_set_ld(*p, (long double)SvNVX(q), (mp_rnd_t)round));
339
340 #else
341
342 if(!SV_IS_NOK(q)) croak("Second arg given to Math::MPC::_mpfr_set_NV is not an NV");
343
344 return newSViv(mpfr_set_d (*p, (double)SvNVX(q), (mp_rnd_t)round));
345 #endif
346 }
347
Rmpc_set_default_rounding_mode(pTHX_ SV * round)348 void Rmpc_set_default_rounding_mode(pTHX_ SV * round) {
349 dMY_CXT;
350 DEFAULT_ROUNDING_MODE = (mpc_rnd_t)SvUV(round);
351 }
352
Rmpc_get_default_rounding_mode(pTHX)353 SV * Rmpc_get_default_rounding_mode(pTHX) {
354 dMY_CXT;
355 return newSVuv(DEFAULT_ROUNDING_MODE);
356 }
357
Rmpc_set_default_prec(pTHX_ SV * prec)358 void Rmpc_set_default_prec(pTHX_ SV * prec) {
359 dMY_CXT;
360 DEFAULT_PREC_RE = (mp_prec_t)SvUV(prec);
361 DEFAULT_PREC_IM = (mp_prec_t)SvUV(prec);
362 }
363
Rmpc_set_default_prec2(pTHX_ SV * prec_re,SV * prec_im)364 void Rmpc_set_default_prec2(pTHX_ SV * prec_re, SV * prec_im) {
365 dMY_CXT;
366 DEFAULT_PREC_RE = (mp_prec_t)SvUV(prec_re);
367 DEFAULT_PREC_IM = (mp_prec_t)SvUV(prec_im);
368 }
369
Rmpc_get_default_prec(pTHX)370 SV * Rmpc_get_default_prec(pTHX) {
371 dMY_CXT;
372 if(DEFAULT_PREC_RE == DEFAULT_PREC_IM)
373 return newSVuv(DEFAULT_PREC_RE);
374 return newSVuv(0);
375 }
376
Rmpc_get_default_prec2(void)377 void Rmpc_get_default_prec2(void) {
378 dTHX;
379 dXSARGS;
380 dMY_CXT;
381 EXTEND(SP, 2);
382 ST(0) = sv_2mortal(newSVuv(DEFAULT_PREC_RE));
383 ST(1) = sv_2mortal(newSVuv(DEFAULT_PREC_IM));
384 XSRETURN(2);
385 }
386
Rmpc_set_prec(pTHX_ mpc_t * p,SV * prec)387 void Rmpc_set_prec(pTHX_ mpc_t * p, SV * prec) {
388 mpc_set_prec(*p, SvUV(prec));
389 }
390
Rmpc_set_re_prec(pTHX_ mpc_t * p,SV * prec)391 void Rmpc_set_re_prec(pTHX_ mpc_t * p, SV * prec) {
392 mpfr_set_prec(MPC_RE(*p), SvUV(prec));
393 }
394
Rmpc_set_im_prec(pTHX_ mpc_t * p,SV * prec)395 void Rmpc_set_im_prec(pTHX_ mpc_t * p, SV * prec) {
396 mpfr_set_prec(MPC_IM(*p), SvUV(prec));
397 }
398
Rmpc_get_prec(pTHX_ mpc_t * x)399 SV * Rmpc_get_prec(pTHX_ mpc_t * x) {
400 return newSVuv(mpc_get_prec(*x));
401 }
402
Rmpc_get_prec2(pTHX_ mpc_t * x)403 void Rmpc_get_prec2(pTHX_ mpc_t * x) {
404 dXSARGS;
405 mp_prec_t re, im;
406 mpc_get_prec2(&re, &im, *x);
407 /* sp = mark; *//* not needed */
408 EXTEND(SP, 2);
409 ST(0) = sv_2mortal(newSVuv(re));
410 ST(1) = sv_2mortal(newSVuv(im));
411 /* PUTBACK; *//* not needed */
412 XSRETURN(2);
413 }
414
Rmpc_get_im_prec(pTHX_ mpc_t * x)415 SV * Rmpc_get_im_prec(pTHX_ mpc_t * x) {
416 return newSVuv(mpfr_get_prec(MPC_IM(*x)));
417 }
418
Rmpc_get_re_prec(pTHX_ mpc_t * x)419 SV * Rmpc_get_re_prec(pTHX_ mpc_t * x) {
420 return newSVuv(mpfr_get_prec(MPC_RE(*x)));
421 }
422
RMPC_RE(mpfr_t * fr,mpc_t * x)423 void RMPC_RE(mpfr_t * fr, mpc_t * x) {
424 mp_prec_t precision = mpfr_get_prec(MPC_RE(*x));
425 mpfr_set_prec(*fr, precision);
426 mpfr_set(*fr, MPC_RE(*x), GMP_RNDN); /* No rounding will be done, anyway */
427 }
428
RMPC_IM(mpfr_t * fr,mpc_t * x)429 void RMPC_IM(mpfr_t * fr, mpc_t * x) {
430 mp_prec_t precision = mpfr_get_prec(MPC_IM(*x));
431 mpfr_set_prec(*fr, precision);
432 mpfr_set(*fr, MPC_IM(*x), GMP_RNDN); /* No rounding will be done, anyway */
433 }
434
RMPC_INEX_RE(pTHX_ SV * x)435 SV * RMPC_INEX_RE(pTHX_ SV * x) {
436 return newSViv(MPC_INEX_RE(SvIV(x)));
437 }
438
RMPC_INEX_IM(pTHX_ SV * x)439 SV * RMPC_INEX_IM(pTHX_ SV * x) {
440 return newSViv(MPC_INEX_IM(SvIV(x)));
441 }
442
DESTROY(pTHX_ mpc_t * p)443 void DESTROY(pTHX_ mpc_t * p) {
444 mpc_clear(*p);
445 Safefree(p);
446 }
447
Rmpc_clear(pTHX_ mpc_t * p)448 void Rmpc_clear(pTHX_ mpc_t * p) {
449 mpc_clear(*p);
450 Safefree(p);
451 }
452
Rmpc_clear_mpc(mpc_t * p)453 void Rmpc_clear_mpc(mpc_t * p) {
454 mpc_clear(*p);
455 }
456
Rmpc_clear_ptr(pTHX_ mpc_t * p)457 void Rmpc_clear_ptr(pTHX_ mpc_t * p) {
458 Safefree(p);
459 }
460
Rmpc_init2(pTHX_ SV * prec)461 SV * Rmpc_init2(pTHX_ SV * prec) {
462 mpc_t * mpc_t_obj;
463 SV * obj_ref, * obj;
464
465 New(1, mpc_t_obj, 1, mpc_t);
466 if(mpc_t_obj == NULL) croak("Failed to allocate memory in Rmpc_init2 function");
467 obj_ref = newSV(0);
468 obj = newSVrv(obj_ref, "Math::MPC");
469 mpc_init2 (*mpc_t_obj, SvUV(prec));
470
471 sv_setiv(obj, INT2PTR(IV,mpc_t_obj));
472 SvREADONLY_on(obj);
473 return obj_ref;
474 }
475
Rmpc_init3(pTHX_ SV * prec_r,SV * prec_i)476 SV * Rmpc_init3(pTHX_ SV * prec_r, SV * prec_i) {
477 mpc_t * mpc_t_obj;
478 SV * obj_ref, * obj;
479
480 New(1, mpc_t_obj, 1, mpc_t);
481 if(mpc_t_obj == NULL) croak("Failed to allocate memory in Rmpc_init3 function");
482 obj_ref = newSV(0);
483 obj = newSVrv(obj_ref, "Math::MPC");
484 mpc_init3 (*mpc_t_obj, SvUV(prec_r), SvUV(prec_i));
485
486 sv_setiv(obj, INT2PTR(IV,mpc_t_obj));
487 SvREADONLY_on(obj);
488 return obj_ref;
489 }
490
Rmpc_init2_nobless(pTHX_ SV * prec)491 SV * Rmpc_init2_nobless(pTHX_ SV * prec) {
492 mpc_t * mpc_t_obj;
493 SV * obj_ref, * obj;
494
495 New(1, mpc_t_obj, 1, mpc_t);
496 if(mpc_t_obj == NULL) croak("Failed to allocate memory in Rmpc_init2_nobless function");
497 obj_ref = newSV(0);
498 obj = newSVrv(obj_ref, NULL);
499 mpc_init2 (*mpc_t_obj, SvUV(prec));
500
501 sv_setiv(obj, INT2PTR(IV,mpc_t_obj));
502 SvREADONLY_on(obj);
503 return obj_ref;
504 }
505
Rmpc_init3_nobless(pTHX_ SV * prec_r,SV * prec_i)506 SV * Rmpc_init3_nobless(pTHX_ SV * prec_r, SV * prec_i) {
507 mpc_t * mpc_t_obj;
508 SV * obj_ref, * obj;
509
510 New(1, mpc_t_obj, 1, mpc_t);
511 if(mpc_t_obj == NULL) croak("Failed to allocate memory in Rmpc_init3_nobless function");
512 obj_ref = newSV(0);
513 obj = newSVrv(obj_ref, NULL);
514 mpc_init3 (*mpc_t_obj, SvUV(prec_r), SvUV(prec_i));
515
516 sv_setiv(obj, INT2PTR(IV,mpc_t_obj));
517 SvREADONLY_on(obj);
518 return obj_ref;
519 }
520
Rmpc_set(pTHX_ mpc_t * p,mpc_t * q,SV * round)521 SV * Rmpc_set(pTHX_ mpc_t * p, mpc_t * q, SV * round) {
522 return newSViv(mpc_set(*p, *q, (mpc_rnd_t)SvUV(round)));
523 }
524
Rmpc_set_ui(pTHX_ mpc_t * p,SV * q,SV * round)525 SV * Rmpc_set_ui(pTHX_ mpc_t * p, SV * q, SV * round) {
526 return newSViv(mpc_set_ui(*p, SvUV(q), (mpc_rnd_t)SvUV(round)));
527 }
528
Rmpc_set_si(pTHX_ mpc_t * p,SV * q,SV * round)529 SV * Rmpc_set_si(pTHX_ mpc_t * p, SV * q, SV * round) {
530 return newSViv(mpc_set_si(*p, SvIV(q), (mpc_rnd_t)SvUV(round)));
531 }
532
Rmpc_set_ld(pTHX_ mpc_t * p,SV * q,SV * round)533 SV * Rmpc_set_ld(pTHX_ mpc_t * p, SV * q, SV * round) {
534 #if defined(NV_IS_LONG_DOUBLE) || defined(NV_IS_FLOAT128)
535 return newSViv(mpc_set_ld(*p, SvNV(q), (mpc_rnd_t)SvUV(round)));
536 #else
537 croak("Rmpc_set_ld not implemented for this build of perl");
538 #endif
539 }
540
Rmpc_set_NV(pTHX_ mpc_t * p,SV * q,unsigned int round)541 SV * Rmpc_set_NV(pTHX_ mpc_t * p, SV * q, unsigned int round) {
542 #if defined(MPC_CAN_PASS_FLOAT128)
543 int ret;
544 mpfr_t f128;
545
546 if(!SV_IS_NOK(q)) croak("Second arg given to Rmpc_set_NV is not an NV");
547
548 mpfr_init2(f128, FLT128_MANT_DIG);
549 mpfr_set_float128(f128, SvNVX(q), MPC_RNDNN);
550 ret = mpc_set_fr(*p, f128, (mpc_rnd_t)round);
551 mpfr_clear(f128);
552 return newSViv(ret);
553
554 #elif defined(NV_IS_FLOAT128)
555
556 char * buffer;
557 int exp, exp2 = 0;
558 float128 ld, buffer_size;
559 mpfr_t t;
560 int returned;
561
562 if(!SV_IS_NOK(q)) croak("Second arg given to Rmpc_set_NV is not an NV");
563
564 ld = (float128)SvNVX(q);
565 mpfr_init2(t, FLT128_MANT_DIG);
566 if(ld != ld) {
567 mpc_set_fr(*p, t, MPC_RNDNN);
568 mpfr_clear(t);
569 return newSViv(0);
570 }
571
572 if(ld != 0.0Q && (ld / ld != 1)) {
573 returned = ld > 0.0Q ? 1 : -1;
574 mpfr_set_inf(t, returned);
575 mpc_set_fr(*p, t, MPC_RNDNN);
576 mpfr_clear(t);
577 return newSViv(0);
578 }
579
580 ld = frexpq((float128)SvNVX(q), &exp);
581
582 while(ld != floorq(ld)) {
583 ld *= 2;
584 exp2 += 1;
585 }
586
587 buffer_size = ld < 0.0Q ? ld * -1.0Q : ld;
588 buffer_size = ceilq(logq(buffer_size + 1) / 2.30258509299404568401799145468436418Q);
589
590 Newxz(buffer, buffer_size + 5, char);
591 if(buffer == NULL) croak("Failed to allocate memory in Rmpc_set_NV");
592
593 returned = quadmath_snprintf(buffer, (size_t)buffer_size + 5, "%.0Qf", ld);
594 if(returned < 0) croak("In Rmpc_set_NV, encoding error in quadmath_snprintf function");
595 if(returned >= buffer_size + 5) croak("In Rmpc_set_NV, buffer given to quadmath_snprintf function was too small");
596 mpfr_set_str(t, buffer, 10, MPC_RNDNN); /* exact */
597 Safefree(buffer);
598
599 if (exp2 > exp) mpfr_div_2ui(t, t, exp2 - exp, GMP_RNDN);
600 else mpfr_mul_2ui(t, t, exp - exp2, GMP_RNDN);
601 returned = mpc_set_fr(*p, t, (mpc_rnd_t)round);
602 mpfr_clear(t);
603 return newSViv(returned);
604
605
606 #elif defined(NV_IS_LONG_DOUBLE)
607
608 if(!SV_IS_NOK(q)) croak("Second arg given to Rmpc_set_NV is not an NV");
609 return newSViv(mpc_set_ld(*p, SvNVX(q), (mpc_rnd_t)round));
610
611 #else
612
613 if(!SV_IS_NOK(q)) croak("Second arg given to Rmpc_set_NV is not an NV");
614 return newSViv(mpc_set_d(*p, SvNVX(q), (mpc_rnd_t)round));
615
616 #endif
617 }
618
Rmpc_set_NV_NV(pTHX_ mpc_t * p,SV * re_q,SV * im_q,SV * round)619 SV * Rmpc_set_NV_NV(pTHX_ mpc_t * p, SV * re_q, SV * im_q, SV * round) {
620 #if defined(MPC_CAN_PASS_FLOAT128)
621
622 int ret;
623 mpfr_t re_f128, im_f128;
624
625 if(!SV_IS_NOK(re_q) || !SV_IS_NOK(im_q)) croak("Second and/or third arg given to Rmpc_set_NV_NV is not an NV");
626
627 mpfr_init2(re_f128, FLT128_MANT_DIG);
628 mpfr_init2(im_f128, FLT128_MANT_DIG);
629 mpfr_set_float128(re_f128, SvNVX(re_q), ((mpc_rnd_t)SvUV(round)) & 3);
630 mpfr_set_float128(im_f128, SvNVX(im_q), ((mpc_rnd_t)SvUV(round)) / 16);
631 ret = mpc_set_fr_fr(*p, re_f128, im_f128, (mpc_rnd_t)SvUV(round));
632 mpfr_clear(re_f128);
633 mpfr_clear(im_f128);
634 return newSViv(ret);
635
636 #elif defined(NV_IS_FLOAT128)
637
638 char * buffer;
639 int exp, exp2 = 0, done_re = 0, done_im = 0;
640 float128 re_ld, im_ld, buffer_size;
641 mpfr_t re_fr, im_fr;
642 int returned;
643
644 if(!SV_IS_NOK(re_q) || !SV_IS_NOK(im_q)) croak("Second and/or third arg given to Rmpc_set_NV_NV is not an NV");
645
646 re_ld = (float128)SvNVX(re_q);
647 im_ld = (float128)SvNVX(im_q);
648 mpfr_init2(re_fr, FLT128_MANT_DIG);
649 mpfr_init2(im_fr, FLT128_MANT_DIG);
650
651 /************** real part ****************/
652
653 if(re_ld != re_ld) {
654 mpfr_set_nan(re_fr);
655 done_re = 1;
656 }
657
658 if(!done_re) {
659 if(re_ld != 0.0Q && (re_ld / re_ld != 1)) {
660 returned = re_ld > 0.0Q ? 1 : -1;
661 mpfr_set_inf(re_fr, returned);
662 done_re = 1;
663 }
664
665 if(!done_re) {
666 re_ld = frexpq(re_ld, &exp);
667
668 while(re_ld != floorq(re_ld)) {
669 re_ld *= 2;
670 exp2 += 1;
671 }
672
673 buffer_size = re_ld < 0.0Q ? re_ld * -1.0Q : re_ld;
674 buffer_size = ceilq(logq(buffer_size + 1) / 2.30258509299404568401799145468436418Q);
675
676 Newxz(buffer, buffer_size + 5, char);
677 if(buffer == NULL) croak("Failed to allocate memory in Rmpc_set_NV_NV");
678
679 returned = quadmath_snprintf(buffer, (size_t)buffer_size + 5, "%.0Qf", re_ld);
680 if(returned < 0) croak("In Rmpc_set_NV_NV, encoding error in quadmath_snprintf function");
681 if(returned >= buffer_size + 5) croak("In Rmpc_set_NV_NV, buffer given to quadmath_snprintf function was too small");
682 mpfr_set_str(re_fr, buffer, 10, (mp_rnd_t)round); /* exact */
683 Safefree(buffer);
684
685 if (exp2 > exp) mpfr_div_2ui(re_fr, re_fr, exp2 - exp, GMP_RNDN);
686 else mpfr_mul_2ui(re_fr, re_fr, exp - exp2, GMP_RNDN);
687 }
688 }
689
690 /************** imag part ****************/
691
692 if(im_ld != im_ld) {
693 mpfr_set_nan(im_fr);
694 done_im = 1;
695 }
696
697 if(!done_im) {
698 if(im_ld != 0.0Q && (im_ld / im_ld != 1)) {
699 returned = im_ld > 0.0Q ? 1 : -1;
700 mpfr_set_inf(im_fr, returned);
701 done_im = 1;
702 }
703
704 if(!done_im) {
705 im_ld = frexpq(im_ld, &exp);
706
707 while(im_ld != floorq(im_ld)) {
708 im_ld *= 2;
709 exp2 += 1;
710 }
711
712 buffer_size = im_ld < 0.0Q ? im_ld * -1.0Q : im_ld;
713 buffer_size = ceilq(logq(buffer_size + 1) / 2.30258509299404568401799145468436418Q);
714
715 Newxz(buffer, buffer_size + 5, char);
716 if(buffer == NULL) croak("Failed to allocate memory in Rmpc_set_NV_NV");
717
718 returned = quadmath_snprintf(buffer, (size_t)buffer_size + 5, "%.0Qf", im_ld);
719 if(returned < 0) croak("In Rmpc_set_NV_NV, encoding error in quadmath_snprintf function");
720 if(returned >= buffer_size + 5) croak("In Rmpc_set_NV_NV, buffer given to quadmath_snprintf function was too small");
721 mpfr_set_str(im_fr, buffer, 10, (mp_rnd_t)round); /* exact */
722 Safefree(buffer);
723
724 if (exp2 > exp) mpfr_div_2ui(im_fr, im_fr, exp2 - exp, GMP_RNDN);
725 else mpfr_mul_2ui(im_fr, im_fr, exp - exp2, GMP_RNDN);
726 }
727 }
728
729 returned = mpc_set_fr_fr(*p, re_fr, im_fr, MPC_RNDNN);
730 mpfr_clear(re_fr);
731 mpfr_clear(im_fr);
732 return newSViv(returned);
733
734 #elif defined(NV_IS_LONG_DOUBLE)
735
736 if(!SV_IS_NOK(re_q) || !SV_IS_NOK(im_q)) croak("Second and/or third arg given to Rmpc_set_NV_NV is not an NV");
737 return newSViv(mpc_set_ld_ld(*p, SvNVX(re_q), SvNVX(im_q), (mpc_rnd_t)SvUV(round)));
738
739 #else
740
741 if(!SV_IS_NOK(re_q) || !SV_IS_NOK(im_q)) croak("Second and/or third arg given to Rmpc_set_NV_NV is not an NV");
742 return newSViv(mpc_set_d_d(*p, SvNVX(re_q), SvNVX(im_q), (mpc_rnd_t)SvUV(round)));
743 #endif
744 }
745
Rmpc_set_uj(pTHX_ mpc_t * p,SV * q,SV * round)746 SV * Rmpc_set_uj(pTHX_ mpc_t * p, SV * q, SV * round) {
747 #ifdef MATH_MPC_NEED_LONG_LONG_INT
748 return newSViv(mpc_set_uj(*p, SvUV(q), (mpc_rnd_t)SvUV(round)));
749 #else
750 croak("Rmpc_set_uj not implemented for this build of perl");
751 #endif
752 }
753
Rmpc_set_sj(pTHX_ mpc_t * p,SV * q,SV * round)754 SV * Rmpc_set_sj(pTHX_ mpc_t * p, SV * q, SV * round) {
755 #ifdef MATH_MPC_NEED_LONG_LONG_INT
756 return newSViv(mpc_set_sj(*p, SvIV(q), (mpc_rnd_t)SvUV(round)));
757 #else
758 croak("Rmpc_set_sj not implemented for this build of perl");
759 #endif
760 }
761
Rmpc_set_z(pTHX_ mpc_t * p,mpz_t * q,SV * round)762 SV * Rmpc_set_z(pTHX_ mpc_t * p, mpz_t * q, SV * round) {
763 return newSViv(mpc_set_z(*p, *q, (mpc_rnd_t)SvUV(round)));
764 }
765
Rmpc_set_f(pTHX_ mpc_t * p,mpf_t * q,SV * round)766 SV * Rmpc_set_f(pTHX_ mpc_t * p, mpf_t * q, SV * round) {
767 return newSViv(mpc_set_f(*p, *q, (mpc_rnd_t)SvUV(round)));
768 }
769
Rmpc_set_q(pTHX_ mpc_t * p,mpq_t * q,SV * round)770 SV * Rmpc_set_q(pTHX_ mpc_t * p, mpq_t * q, SV * round) {
771 return newSViv(mpc_set_q(*p, *q, (mpc_rnd_t)SvUV(round)));
772 }
773
Rmpc_set_d(pTHX_ mpc_t * p,SV * q,SV * round)774 SV * Rmpc_set_d(pTHX_ mpc_t * p, SV * q, SV * round) {
775 return newSViv(mpc_set_d(*p, SvNV(q), (mpc_rnd_t)SvUV(round)));
776 }
777
Rmpc_set_fr(pTHX_ mpc_t * p,mpfr_t * q,SV * round)778 SV * Rmpc_set_fr(pTHX_ mpc_t * p, mpfr_t * q, SV * round) {
779 return newSViv(mpc_set_fr(*p, *q, (mpc_rnd_t)SvUV(round)));
780 }
781
Rmpc_set_ui_ui(pTHX_ mpc_t * p,SV * q_r,SV * q_i,SV * round)782 SV * Rmpc_set_ui_ui(pTHX_ mpc_t * p, SV * q_r, SV * q_i, SV * round) {
783 return newSViv(mpc_set_ui_ui(*p, (unsigned long)SvUV(q_r), (unsigned long)SvUV(q_i), (mpc_rnd_t)SvUV(round)));
784 }
785
Rmpc_set_si_si(pTHX_ mpc_t * p,SV * q_r,SV * q_i,SV * round)786 SV * Rmpc_set_si_si(pTHX_ mpc_t * p, SV * q_r, SV * q_i, SV * round) {
787 return newSViv(mpc_set_si_si(*p, (long)SvIV(q_r), (long)SvIV(q_i), (mpc_rnd_t)SvUV(round)));
788 }
789
Rmpc_set_d_d(pTHX_ mpc_t * p,SV * q_r,SV * q_i,SV * round)790 SV * Rmpc_set_d_d(pTHX_ mpc_t * p, SV * q_r, SV * q_i, SV * round) {
791 return newSViv(mpc_set_d_d(*p, (double)SvNV(q_r), (double)SvNV(q_i), (mpc_rnd_t)SvUV(round)));
792 }
793
Rmpc_set_ld_ld(pTHX_ mpc_t * mpc,SV * ld1,SV * ld2,SV * round)794 SV * Rmpc_set_ld_ld(pTHX_ mpc_t * mpc, SV * ld1, SV * ld2, SV * round) {
795 #if defined(NV_IS_LONG_DOUBLE) || defined(NV_IS_FLOAT128)
796 return newSViv(mpc_set_ld_ld(*mpc, SvNV(ld1), SvNV(ld2), (mpc_rnd_t) SvUV(round)));
797 #else
798 croak("Rmpc_set_ld_ld not implemented for this build of perl");
799 #endif
800 }
801
Rmpc_set_z_z(pTHX_ mpc_t * p,mpz_t * q_r,mpz_t * q_i,SV * round)802 SV * Rmpc_set_z_z(pTHX_ mpc_t * p, mpz_t * q_r, mpz_t * q_i, SV * round) {
803 return newSViv(mpc_set_z_z(*p, *q_r, *q_i, (mpc_rnd_t)SvUV(round)));
804 }
805
Rmpc_set_q_q(pTHX_ mpc_t * p,mpq_t * q_r,mpq_t * q_i,SV * round)806 SV * Rmpc_set_q_q(pTHX_ mpc_t * p, mpq_t * q_r, mpq_t * q_i, SV * round) {
807 return newSViv(mpc_set_q_q(*p, *q_r, *q_i, (mpc_rnd_t)SvUV(round)));
808 }
809
Rmpc_set_f_f(pTHX_ mpc_t * p,mpf_t * q_r,mpf_t * q_i,SV * round)810 SV * Rmpc_set_f_f(pTHX_ mpc_t * p, mpf_t * q_r, mpf_t * q_i, SV * round) {
811 return newSViv(mpc_set_f_f(*p, *q_r, *q_i, (mpc_rnd_t)SvUV(round)));
812 }
813
Rmpc_set_fr_fr(pTHX_ mpc_t * p,mpfr_t * q_r,mpfr_t * q_i,SV * round)814 SV * Rmpc_set_fr_fr(pTHX_ mpc_t * p, mpfr_t * q_r, mpfr_t * q_i, SV * round) {
815 return newSViv(mpc_set_fr_fr(*p, *q_r, *q_i, (mpc_rnd_t)SvUV(round)));
816 }
817
Rmpc_set_d_ui(pTHX_ mpc_t * mpc,SV * d,SV * ui,SV * round)818 SV * Rmpc_set_d_ui(pTHX_ mpc_t * mpc, SV * d, SV * ui, SV * round) {
819 SV_MPC_SET_X_Y(d, ui, *mpc, (double)SvNV(d), (unsigned long int)SvUV(ui), (mpc_rnd_t)SvUV(round));
820 }
821
Rmpc_set_d_si(pTHX_ mpc_t * mpc,SV * d,SV * si,SV * round)822 SV * Rmpc_set_d_si(pTHX_ mpc_t * mpc, SV * d, SV * si, SV * round) {
823 SV_MPC_SET_X_Y(d, si, *mpc, (double)SvNV(d), (signed long int)SvIV(si), (mpc_rnd_t) SvUV(round));
824 }
825
Rmpc_set_d_fr(pTHX_ mpc_t * mpc,SV * d,mpfr_t * mpfr,SV * round)826 SV * Rmpc_set_d_fr(pTHX_ mpc_t * mpc, SV * d, mpfr_t * mpfr, SV * round) {
827 SV_MPC_SET_X_Y(d, fr, *mpc, (double)SvNV(d), *mpfr, (mpc_rnd_t) SvUV(round));
828 }
829
Rmpc_set_ui_d(pTHX_ mpc_t * mpc,SV * ui,SV * d,SV * round)830 SV * Rmpc_set_ui_d(pTHX_ mpc_t * mpc, SV * ui, SV * d, SV * round) {
831 SV_MPC_SET_X_Y(ui, d, *mpc, (unsigned long)SvUV(ui), (double)SvNV(d), (mpc_rnd_t) SvUV(round));
832 }
833
Rmpc_set_ui_si(pTHX_ mpc_t * mpc,SV * ui,SV * si,SV * round)834 SV * Rmpc_set_ui_si(pTHX_ mpc_t * mpc, SV * ui, SV * si, SV * round) {
835 SV_MPC_SET_X_Y(ui, si, *mpc, (unsigned long)SvUV(ui), (signed long int)SvIV(si), (mpc_rnd_t) SvUV(round));
836 }
837
Rmpc_set_ui_fr(pTHX_ mpc_t * mpc,SV * ui,mpfr_t * mpfr,SV * round)838 SV * Rmpc_set_ui_fr(pTHX_ mpc_t * mpc, SV * ui, mpfr_t * mpfr, SV * round) {
839 SV_MPC_SET_X_Y(ui, fr, *mpc, (unsigned long)SvUV(ui), *mpfr, (mpc_rnd_t) SvUV(round));
840 }
841
Rmpc_set_si_d(pTHX_ mpc_t * mpc,SV * si,SV * d,SV * round)842 SV * Rmpc_set_si_d(pTHX_ mpc_t * mpc, SV * si, SV * d, SV * round) {
843 SV_MPC_SET_X_Y(si, d, *mpc, (signed long int)SvIV(si), (double)SvNV(d), (mpc_rnd_t) SvUV(round));
844 }
845
Rmpc_set_si_ui(pTHX_ mpc_t * mpc,SV * si,SV * ui,SV * round)846 SV * Rmpc_set_si_ui(pTHX_ mpc_t * mpc, SV * si, SV * ui, SV * round) {
847 SV_MPC_SET_X_Y(si, ui, *mpc, (signed long int)SvIV(si), (unsigned long)SvUV(ui), (mpc_rnd_t) SvUV(round));
848 }
849
Rmpc_set_si_fr(pTHX_ mpc_t * mpc,SV * si,mpfr_t * mpfr,SV * round)850 SV * Rmpc_set_si_fr(pTHX_ mpc_t * mpc, SV * si, mpfr_t * mpfr, SV * round) {
851 SV_MPC_SET_X_Y(si, fr, *mpc, (signed long int)SvIV(si), *mpfr, (mpc_rnd_t) SvUV(round));
852 }
853
Rmpc_set_fr_d(pTHX_ mpc_t * mpc,mpfr_t * mpfr,SV * d,SV * round)854 SV * Rmpc_set_fr_d(pTHX_ mpc_t * mpc, mpfr_t * mpfr, SV * d, SV * round) {
855 SV_MPC_SET_X_Y(fr, d, *mpc, *mpfr, (double)SvNV(d), (mpc_rnd_t) SvUV(round));
856 }
857
Rmpc_set_fr_ui(pTHX_ mpc_t * mpc,mpfr_t * mpfr,SV * ui,SV * round)858 SV * Rmpc_set_fr_ui(pTHX_ mpc_t * mpc, mpfr_t * mpfr, SV * ui, SV * round) {
859 SV_MPC_SET_X_Y(fr, ui, *mpc, *mpfr, (unsigned long)SvUV(ui), (mpc_rnd_t) SvUV(round));
860 }
861
Rmpc_set_fr_si(pTHX_ mpc_t * mpc,mpfr_t * mpfr,SV * si,SV * round)862 SV * Rmpc_set_fr_si(pTHX_ mpc_t * mpc, mpfr_t * mpfr, SV * si, SV * round) {
863 SV_MPC_SET_X_Y(fr, si, *mpc, *mpfr , (signed long int)SvIV(si), (mpc_rnd_t) SvUV(round));
864 }
865
Rmpc_set_ld_ui(pTHX_ mpc_t * mpc,SV * d,SV * ui,SV * round)866 SV * Rmpc_set_ld_ui(pTHX_ mpc_t * mpc, SV * d, SV * ui, SV * round) {
867 #if defined(NV_IS_LONG_DOUBLE) || defined(NV_IS_FLOAT128)
868 SV_MPC_SET_X_Y(ld, ui, *mpc, SvNV(d), (unsigned long)SvUV(ui), (mpc_rnd_t) SvUV(round));
869 #else
870 croak("Rmpc_set_ld_ui not implemented for this build of perl");
871 #endif
872 }
873
Rmpc_set_ld_si(pTHX_ mpc_t * mpc,SV * d,SV * si,SV * round)874 SV * Rmpc_set_ld_si(pTHX_ mpc_t * mpc, SV * d, SV * si, SV * round) {
875 #if defined(NV_IS_LONG_DOUBLE) || defined(NV_IS_FLOAT128)
876 SV_MPC_SET_X_Y(ld, si, *mpc, SvNV(d), (signed long int)SvIV(si), (mpc_rnd_t) SvUV(round));
877 #else
878 croak("Rmpc_set_ld_si not implemented for this build of perl");
879 #endif
880 }
881
Rmpc_set_ld_fr(pTHX_ mpc_t * mpc,SV * d,mpfr_t * mpfr,SV * round)882 SV * Rmpc_set_ld_fr(pTHX_ mpc_t * mpc, SV * d, mpfr_t * mpfr, SV * round) {
883 #if defined(NV_IS_LONG_DOUBLE) || defined(NV_IS_FLOAT128)
884 SV_MPC_SET_X_Y(ld, fr, *mpc, SvNV(d), *mpfr, (mpc_rnd_t) SvUV(round));
885 #else
886 croak("Rmpc_set_ld_fr not implemented for this build of perl");
887 #endif
888 }
889
Rmpc_set_ui_ld(pTHX_ mpc_t * mpc,SV * ui,SV * d,SV * round)890 SV * Rmpc_set_ui_ld(pTHX_ mpc_t * mpc, SV * ui, SV * d, SV * round) {
891 #if defined(NV_IS_LONG_DOUBLE) || defined(NV_IS_FLOAT128)
892 SV_MPC_SET_X_Y(ui, ld, *mpc, (unsigned long)SvUV(ui), SvNV(d), (mpc_rnd_t) SvUV(round));
893 #else
894 croak("Rmpc_set_ui_ld not implemented for this build of perl");
895 #endif
896 }
897
Rmpc_set_si_ld(pTHX_ mpc_t * mpc,SV * si,SV * d,SV * round)898 SV * Rmpc_set_si_ld(pTHX_ mpc_t * mpc, SV * si, SV * d, SV * round) {
899 #if defined(NV_IS_LONG_DOUBLE) || defined(NV_IS_FLOAT128)
900 SV_MPC_SET_X_Y(si, ld, *mpc, (signed long int)SvIV(si), SvNV(d), (mpc_rnd_t) SvUV(round));
901 #else
902 croak("Rmpc_set_si_ld not implemented for this build of perl");
903 #endif
904 }
905
Rmpc_set_fr_ld(pTHX_ mpc_t * mpc,mpfr_t * mpfr,SV * d,SV * round)906 SV * Rmpc_set_fr_ld(pTHX_ mpc_t * mpc, mpfr_t * mpfr, SV * d, SV * round) {
907 #if defined(NV_IS_LONG_DOUBLE) || defined(NV_IS_FLOAT128)
908 SV_MPC_SET_X_Y(fr, ld, *mpc, *mpfr, SvNV(d), (mpc_rnd_t) SvUV(round));
909 #else
910 croak("Rmpc_set_fr_ld not implemented for this build of perl");
911 #endif
912 }
913
Rmpc_set_d_uj(pTHX_ mpc_t * mpc,SV * d,SV * ui,SV * round)914 SV * Rmpc_set_d_uj(pTHX_ mpc_t * mpc, SV * d, SV * ui, SV * round) {
915 #ifdef MATH_MPC_NEED_LONG_LONG_INT
916 SV_MPC_SET_X_Y(d, uj, *mpc, (double)SvNV(d), SvUV(ui), (mpc_rnd_t) SvUV(round));
917 #else
918 croak("Rmpc_set_d_uj not implemented for this build of perl");
919 #endif
920 }
921
Rmpc_set_d_sj(pTHX_ mpc_t * mpc,SV * d,SV * si,SV * round)922 SV * Rmpc_set_d_sj(pTHX_ mpc_t * mpc, SV * d, SV * si, SV * round) {
923 #ifdef MATH_MPC_NEED_LONG_LONG_INT
924 SV_MPC_SET_X_Y(d, sj, *mpc, (double)SvNV(d), SvIV(si), (mpc_rnd_t) SvUV(round));
925 #else
926 croak("Rmpc_set_d_sj not implemented for this build of perl");
927 #endif
928 }
929
Rmpc_set_sj_d(pTHX_ mpc_t * mpc,SV * si,SV * d,SV * round)930 SV * Rmpc_set_sj_d(pTHX_ mpc_t * mpc, SV * si, SV * d, SV * round) {
931 #ifdef MATH_MPC_NEED_LONG_LONG_INT
932 SV_MPC_SET_X_Y(sj, d, *mpc, SvIV(si), (double)SvNV(d), (mpc_rnd_t) SvUV(round));
933 #else
934 croak("Rmpc_set_sj_d not implemented for this build of perl");
935 #endif
936 }
937
Rmpc_set_uj_d(pTHX_ mpc_t * mpc,SV * ui,SV * d,SV * round)938 SV * Rmpc_set_uj_d(pTHX_ mpc_t * mpc, SV * ui, SV * d, SV * round) {
939 #ifdef MATH_MPC_NEED_LONG_LONG_INT
940 SV_MPC_SET_X_Y(uj, d, *mpc, SvUV(ui), (double)SvNV(d), (mpc_rnd_t) SvUV(round));
941 #else
942 croak("Rmpc_set_uj_d not implemented for this build of perl");
943 #endif
944 }
945
Rmpc_set_uj_fr(pTHX_ mpc_t * mpc,SV * ui,mpfr_t * mpfr,SV * round)946 SV * Rmpc_set_uj_fr(pTHX_ mpc_t * mpc, SV * ui, mpfr_t * mpfr, SV * round) {
947 #ifdef MATH_MPC_NEED_LONG_LONG_INT
948 SV_MPC_SET_X_Y(uj, fr, *mpc, SvUV(ui), *mpfr, (mpc_rnd_t) SvUV(round));
949 #else
950 croak("Rmpc_set_uj_fr not implemented for this build of perl");
951 #endif
952 }
953
Rmpc_set_sj_fr(pTHX_ mpc_t * mpc,SV * si,mpfr_t * mpfr,SV * round)954 SV * Rmpc_set_sj_fr(pTHX_ mpc_t * mpc, SV * si, mpfr_t * mpfr, SV * round) {
955 #ifdef MATH_MPC_NEED_LONG_LONG_INT
956 SV_MPC_SET_X_Y(sj, fr, *mpc, SvIV(si), *mpfr, (mpc_rnd_t) SvUV(round));
957 #else
958 croak("Rmpc_set_sj_fr not implemented for this build of perl");
959 #endif
960 }
961
Rmpc_set_fr_uj(pTHX_ mpc_t * mpc,mpfr_t * mpfr,SV * ui,SV * round)962 SV * Rmpc_set_fr_uj(pTHX_ mpc_t * mpc, mpfr_t * mpfr, SV * ui, SV * round) {
963 #ifdef MATH_MPC_NEED_LONG_LONG_INT
964 SV_MPC_SET_X_Y(fr, uj, *mpc, *mpfr, SvUV(ui), (mpc_rnd_t) SvUV(round));
965 #else
966 croak("Rmpc_set_fr_uj not implemented for this build of perl");
967 #endif
968 }
969
Rmpc_set_fr_sj(pTHX_ mpc_t * mpc,mpfr_t * mpfr,SV * si,SV * round)970 SV * Rmpc_set_fr_sj(pTHX_ mpc_t * mpc, mpfr_t * mpfr, SV * si, SV * round) {
971 #ifdef MATH_MPC_NEED_LONG_LONG_INT
972 SV_MPC_SET_X_Y(fr, sj, *mpc, *mpfr , SvIV(si), (mpc_rnd_t) SvUV(round));
973 #else
974 croak("Rmpc_set_fr_sj not implemented for this build of perl");
975 #endif
976 }
977
Rmpc_set_uj_sj(pTHX_ mpc_t * mpc,SV * ui,SV * si,SV * round)978 SV * Rmpc_set_uj_sj(pTHX_ mpc_t * mpc, SV * ui, SV * si, SV * round) {
979 #ifdef MATH_MPC_NEED_LONG_LONG_INT
980 SV_MPC_SET_X_Y(uj, sj, *mpc, SvUV(ui), SvIV(si), (mpc_rnd_t) SvUV(round));
981 #else
982 croak("Rmpc_set_uj_si, Rmpc_set_ui_sj and Rmpc_set_uj_sj not implemented for this build of perl");
983 #endif
984 }
985
Rmpc_set_sj_uj(pTHX_ mpc_t * mpc,SV * si,SV * ui,SV * round)986 SV * Rmpc_set_sj_uj(pTHX_ mpc_t * mpc, SV * si, SV * ui, SV * round) {
987 #ifdef MATH_MPC_NEED_LONG_LONG_INT
988 SV_MPC_SET_X_Y(sj, uj, *mpc, SvIV(si), SvUV(ui), (mpc_rnd_t) SvUV(round));
989 #else
990 croak("Rmpc_set_sj_ui, Rmpc_set_si_uj and Rmpc_set_sj_uj not implemented for this build of perl");
991 #endif
992 }
993
994
Rmpc_set_ld_uj(pTHX_ mpc_t * mpc,SV * d,SV * ui,SV * round)995 SV * Rmpc_set_ld_uj(pTHX_ mpc_t * mpc, SV * d, SV * ui, SV * round) {
996 #ifdef MATH_MPC_NEED_LONG_LONG_INT
997 #if defined(NV_IS_LONG_DOUBLE) || defined(NV_IS_FLOAT128)
998 SV_MPC_SET_X_Y(ld, uj, *mpc, SvNV(d), SvUV(ui), (mpc_rnd_t) SvUV(round));
999 #else
1000 croak("Rmpc_set_ld_uj not implemented for this build of perl");
1001 #endif
1002 #else
1003 croak("Rmpc_set_ld_uj not implemented for this build of perl");
1004 #endif
1005 }
1006
Rmpc_set_ld_sj(pTHX_ mpc_t * mpc,SV * d,SV * si,SV * round)1007 SV * Rmpc_set_ld_sj(pTHX_ mpc_t * mpc, SV * d, SV * si, SV * round) {
1008 #ifdef MATH_MPC_NEED_LONG_LONG_INT
1009 #if defined(NV_IS_LONG_DOUBLE) || defined(NV_IS_FLOAT128)
1010 SV_MPC_SET_X_Y(ld, sj, *mpc, SvNV(d), SvIV(si), (mpc_rnd_t) SvUV(round));
1011 #else
1012 croak("Rmpc_set_ld_sj not implemented for this build of perl");
1013 #endif
1014 #else
1015 croak("Rmpc_set_ld_sj not implemented for this build of perl");
1016 #endif
1017 }
1018
Rmpc_set_uj_ld(pTHX_ mpc_t * mpc,SV * ui,SV * d,SV * round)1019 SV * Rmpc_set_uj_ld(pTHX_ mpc_t * mpc, SV * ui, SV * d, SV * round) {
1020 #ifdef MATH_MPC_NEED_LONG_LONG_INT
1021 #if defined(NV_IS_LONG_DOUBLE) || defined(NV_IS_FLOAT128)
1022 SV_MPC_SET_X_Y(uj, ld, *mpc, SvUV(ui), SvNV(d), (mpc_rnd_t) SvUV(round));
1023 #else
1024 croak("Rmpc_set_uj_ld not implemented for this build of perl");
1025 #endif
1026 #else
1027 croak("Rmpc_set_uj_ld not implemented for this build of perl");
1028 #endif
1029 }
1030
Rmpc_set_sj_ld(pTHX_ mpc_t * mpc,SV * si,SV * d,SV * round)1031 SV * Rmpc_set_sj_ld(pTHX_ mpc_t * mpc, SV * si, SV * d, SV * round) {
1032 #ifdef MATH_MPC_NEED_LONG_LONG_INT
1033 #if defined(NV_IS_LONG_DOUBLE) || defined(NV_IS_FLOAT128)
1034 SV_MPC_SET_X_Y(sj, ld, *mpc, SvIV(si), SvNV(d), (mpc_rnd_t) SvUV(round));
1035 #else
1036 croak("Rmpc_set_sj_ld not implemented for this build of perl");
1037 #endif
1038 #else
1039 croak("Rmpc_set_sj_ld not implemented for this build of perl");
1040 #endif
1041 }
1042
Rmpc_set_f_ui(pTHX_ mpc_t * mpc,mpf_t * mpf,SV * ui,SV * round)1043 SV * Rmpc_set_f_ui(pTHX_ mpc_t * mpc, mpf_t * mpf, SV * ui, SV * round) {
1044 SV_MPC_SET_X_Y(f, ui, *mpc, *mpf, (unsigned long int)SvUV(ui), (mpc_rnd_t) SvUV(round));
1045 }
1046
Rmpc_set_q_ui(pTHX_ mpc_t * mpc,mpq_t * mpq,SV * ui,SV * round)1047 SV * Rmpc_set_q_ui(pTHX_ mpc_t * mpc, mpq_t * mpq, SV * ui, SV * round) {
1048 SV_MPC_SET_X_Y(q, ui, *mpc, *mpq, (unsigned long int)SvUV(ui), (mpc_rnd_t) SvUV(round));
1049 }
1050
Rmpc_set_z_ui(pTHX_ mpc_t * mpc,mpz_t * mpz,SV * ui,SV * round)1051 SV * Rmpc_set_z_ui(pTHX_ mpc_t * mpc, mpz_t * mpz, SV * ui, SV * round) {
1052 SV_MPC_SET_X_Y(z, ui, *mpc, *mpz, (unsigned long int)SvUV(ui), (mpc_rnd_t) SvUV(round));
1053 }
1054
Rmpc_set_f_si(pTHX_ mpc_t * mpc,mpf_t * mpf,SV * si,SV * round)1055 SV * Rmpc_set_f_si(pTHX_ mpc_t * mpc, mpf_t * mpf, SV * si, SV * round) {
1056 SV_MPC_SET_X_Y(f, si, *mpc, *mpf, (signed long int)SvIV(si), (mpc_rnd_t) SvUV(round));
1057 }
1058
Rmpc_set_q_si(pTHX_ mpc_t * mpc,mpq_t * mpq,SV * si,SV * round)1059 SV * Rmpc_set_q_si(pTHX_ mpc_t * mpc, mpq_t * mpq, SV * si, SV * round) {
1060 SV_MPC_SET_X_Y(q, si, *mpc, *mpq, (signed long int)SvIV(si), (mpc_rnd_t) SvUV(round));
1061 }
1062
Rmpc_set_z_si(pTHX_ mpc_t * mpc,mpz_t * mpz,SV * si,SV * round)1063 SV * Rmpc_set_z_si(pTHX_ mpc_t * mpc, mpz_t * mpz, SV * si, SV * round) {
1064 SV_MPC_SET_X_Y(z, si, *mpc, *mpz, (signed long int)SvIV(si), (mpc_rnd_t) SvUV(round));
1065 }
1066
Rmpc_set_f_d(pTHX_ mpc_t * mpc,mpf_t * mpf,SV * d,SV * round)1067 SV * Rmpc_set_f_d(pTHX_ mpc_t * mpc, mpf_t * mpf, SV * d, SV * round) {
1068 SV_MPC_SET_X_Y(f, d, *mpc, *mpf, (double)SvNV(d), (mpc_rnd_t) SvUV(round));
1069 }
1070
Rmpc_set_q_d(pTHX_ mpc_t * mpc,mpq_t * mpq,SV * d,SV * round)1071 SV * Rmpc_set_q_d(pTHX_ mpc_t * mpc, mpq_t * mpq, SV * d, SV * round) {
1072 SV_MPC_SET_X_Y(q, d, *mpc, *mpq, (double)SvNV(d), (mpc_rnd_t) SvUV(round));
1073 }
1074
Rmpc_set_z_d(pTHX_ mpc_t * mpc,mpz_t * mpz,SV * d,SV * round)1075 SV * Rmpc_set_z_d(pTHX_ mpc_t * mpc, mpz_t * mpz, SV * d, SV * round) {
1076 SV_MPC_SET_X_Y(z, d, *mpc, *mpz, (double)SvNV(d), (mpc_rnd_t) SvUV(round));
1077 }
1078
Rmpc_set_f_uj(pTHX_ mpc_t * mpc,mpf_t * mpf,SV * uj,SV * round)1079 SV * Rmpc_set_f_uj(pTHX_ mpc_t * mpc, mpf_t * mpf, SV * uj, SV * round) {
1080 #ifdef MATH_MPC_NEED_LONG_LONG_INT
1081 SV_MPC_SET_X_Y(f, uj, *mpc, *mpf, (unsigned long long)SvUV(uj), (mpc_rnd_t) SvUV(round));
1082 #else
1083 croak("Rmpc_set_f_uj not implemented for this build of perl");
1084 #endif
1085 }
1086
Rmpc_set_q_uj(pTHX_ mpc_t * mpc,mpq_t * mpq,SV * uj,SV * round)1087 SV * Rmpc_set_q_uj(pTHX_ mpc_t * mpc, mpq_t * mpq, SV * uj, SV * round) {
1088 #ifdef MATH_MPC_NEED_LONG_LONG_INT
1089 SV_MPC_SET_X_Y(q, uj, *mpc, *mpq, (unsigned long long)SvUV(uj), (mpc_rnd_t) SvUV(round));
1090 #else
1091 croak("Rmpc_set_q_uj not implemented for this build of perl");
1092 #endif
1093 }
1094
Rmpc_set_z_uj(pTHX_ mpc_t * mpc,mpz_t * mpz,SV * uj,SV * round)1095 SV * Rmpc_set_z_uj(pTHX_ mpc_t * mpc, mpz_t * mpz, SV * uj, SV * round) {
1096 #ifdef MATH_MPC_NEED_LONG_LONG_INT
1097 SV_MPC_SET_X_Y(z, uj, *mpc, *mpz, (unsigned long long)SvUV(uj), (mpc_rnd_t) SvUV(round));
1098 #else
1099 croak("Rmpc_set_z_uj not implemented for this build of perl");
1100 #endif
1101 }
1102
Rmpc_set_f_sj(pTHX_ mpc_t * mpc,mpf_t * mpf,SV * sj,SV * round)1103 SV * Rmpc_set_f_sj(pTHX_ mpc_t * mpc, mpf_t * mpf, SV * sj, SV * round) {
1104 #ifdef MATH_MPC_NEED_LONG_LONG_INT
1105 SV_MPC_SET_X_Y(f, sj, *mpc, *mpf, (signed long long)SvIV(sj), (mpc_rnd_t) SvUV(round));
1106 #else
1107 croak("Rmpc_set_f_sj not implemented for this build of perl");
1108 #endif
1109 }
1110
Rmpc_set_q_sj(pTHX_ mpc_t * mpc,mpq_t * mpq,SV * sj,SV * round)1111 SV * Rmpc_set_q_sj(pTHX_ mpc_t * mpc, mpq_t * mpq, SV * sj, SV * round) {
1112 #ifdef MATH_MPC_NEED_LONG_LONG_INT
1113 SV_MPC_SET_X_Y(q, sj, *mpc, *mpq, (signed long long)SvIV(sj), (mpc_rnd_t) SvUV(round));
1114 #else
1115 croak("Rmpc_set_q_sj not implemented for this build of perl");
1116 #endif
1117 }
1118
Rmpc_set_z_sj(pTHX_ mpc_t * mpc,mpz_t * mpz,SV * sj,SV * round)1119 SV * Rmpc_set_z_sj(pTHX_ mpc_t * mpc, mpz_t * mpz, SV * sj, SV * round) {
1120 #ifdef MATH_MPC_NEED_LONG_LONG_INT
1121 SV_MPC_SET_X_Y(z, sj, *mpc, *mpz, (signed long long)SvIV(sj), (mpc_rnd_t) SvUV(round));
1122 #else
1123 croak("Rmpc_set_z_sj not implemented for this build of perl");
1124 #endif
1125 }
1126
Rmpc_set_f_ld(pTHX_ mpc_t * mpc,mpf_t * mpf,SV * ld,SV * round)1127 SV * Rmpc_set_f_ld(pTHX_ mpc_t * mpc, mpf_t * mpf, SV * ld, SV * round) {
1128 #if defined(NV_IS_LONG_DOUBLE) || defined(NV_IS_FLOAT128)
1129 SV_MPC_SET_X_Y(f, ld, *mpc, *mpf, (long double)SvNV(ld), (mpc_rnd_t) SvUV(round));
1130 #else
1131 croak("Rmpc_set_f_ld not implemented for this build of perl");
1132 #endif
1133 }
1134
Rmpc_set_q_ld(pTHX_ mpc_t * mpc,mpq_t * mpq,SV * ld,SV * round)1135 SV * Rmpc_set_q_ld(pTHX_ mpc_t * mpc, mpq_t * mpq, SV * ld, SV * round) {
1136 #if defined(NV_IS_LONG_DOUBLE) || defined(NV_IS_FLOAT128)
1137 SV_MPC_SET_X_Y(q, ld, *mpc, *mpq, (long double)SvNV(ld), (mpc_rnd_t) SvUV(round));
1138 #else
1139 croak("Rmpc_set_q_ld not implemented for this build of perl");
1140 #endif
1141 }
1142
Rmpc_set_z_ld(pTHX_ mpc_t * mpc,mpz_t * mpz,SV * ld,SV * round)1143 SV * Rmpc_set_z_ld(pTHX_ mpc_t * mpc, mpz_t * mpz, SV * ld, SV * round) {
1144 #if defined(NV_IS_LONG_DOUBLE) || defined(NV_IS_FLOAT128)
1145 SV_MPC_SET_X_Y(z, ld, *mpc, *mpz, (long double)SvNV(ld), (mpc_rnd_t) SvUV(round));
1146 #else
1147 croak("Rmpc_set_z_ld not implemented for this build of perl");
1148 #endif
1149 }
1150
1151 /*
1152 ##############################
1153 ##############################
1154 */
1155
Rmpc_set_ui_f(pTHX_ mpc_t * mpc,SV * ui,mpf_t * mpf,SV * round)1156 SV * Rmpc_set_ui_f(pTHX_ mpc_t * mpc, SV * ui, mpf_t * mpf, SV * round) {
1157 SV_MPC_SET_X_Y(ui, f, *mpc, (unsigned long int)SvUV(ui), *mpf, (mpc_rnd_t) SvUV(round));
1158 }
1159
Rmpc_set_ui_q(pTHX_ mpc_t * mpc,SV * ui,mpq_t * mpq,SV * round)1160 SV * Rmpc_set_ui_q(pTHX_ mpc_t * mpc, SV * ui, mpq_t * mpq, SV * round) {
1161 SV_MPC_SET_X_Y(ui, q, *mpc, (unsigned long int)SvUV(ui), *mpq, (mpc_rnd_t) SvUV(round));
1162 }
1163
Rmpc_set_ui_z(pTHX_ mpc_t * mpc,SV * ui,mpz_t * mpz,SV * round)1164 SV * Rmpc_set_ui_z(pTHX_ mpc_t * mpc, SV * ui, mpz_t * mpz, SV * round) {
1165 SV_MPC_SET_X_Y(ui, z, *mpc, (unsigned long int)SvUV(ui), *mpz, (mpc_rnd_t) SvUV(round));
1166 }
1167
Rmpc_set_si_f(pTHX_ mpc_t * mpc,SV * si,mpf_t * mpf,SV * round)1168 SV * Rmpc_set_si_f(pTHX_ mpc_t * mpc, SV * si, mpf_t * mpf, SV * round) {
1169 SV_MPC_SET_X_Y(si, f, *mpc, (signed long int)SvIV(si), *mpf, (mpc_rnd_t) SvUV(round));
1170 }
1171
Rmpc_set_si_q(pTHX_ mpc_t * mpc,SV * si,mpq_t * mpq,SV * round)1172 SV * Rmpc_set_si_q(pTHX_ mpc_t * mpc, SV * si, mpq_t * mpq, SV * round) {
1173 SV_MPC_SET_X_Y(si, q, *mpc, (signed long int)SvIV(si), *mpq, (mpc_rnd_t) SvUV(round));
1174 }
1175
Rmpc_set_si_z(pTHX_ mpc_t * mpc,SV * si,mpz_t * mpz,SV * round)1176 SV * Rmpc_set_si_z(pTHX_ mpc_t * mpc, SV * si, mpz_t * mpz, SV * round) {
1177 SV_MPC_SET_X_Y(si, z, *mpc, (signed long int)SvIV(si), *mpz, (mpc_rnd_t) SvUV(round));
1178 }
1179
Rmpc_set_d_f(pTHX_ mpc_t * mpc,SV * d,mpf_t * mpf,SV * round)1180 SV * Rmpc_set_d_f(pTHX_ mpc_t * mpc, SV * d, mpf_t * mpf, SV * round) {
1181 SV_MPC_SET_X_Y(d, f, *mpc, (double)SvNV(d), *mpf, (mpc_rnd_t) SvUV(round));
1182 }
1183
Rmpc_set_d_q(pTHX_ mpc_t * mpc,SV * d,mpq_t * mpq,SV * round)1184 SV * Rmpc_set_d_q(pTHX_ mpc_t * mpc, SV * d, mpq_t * mpq, SV * round) {
1185 SV_MPC_SET_X_Y(d, q, *mpc, (double)SvNV(d), *mpq, (mpc_rnd_t) SvUV(round));
1186 }
1187
Rmpc_set_d_z(pTHX_ mpc_t * mpc,SV * d,mpz_t * mpz,SV * round)1188 SV * Rmpc_set_d_z(pTHX_ mpc_t * mpc, SV * d, mpz_t * mpz, SV * round) {
1189 SV_MPC_SET_X_Y(d, z, *mpc, (double)SvNV(d), *mpz, (mpc_rnd_t) SvUV(round));
1190 }
1191
Rmpc_set_uj_f(pTHX_ mpc_t * mpc,SV * uj,mpf_t * mpf,SV * round)1192 SV * Rmpc_set_uj_f(pTHX_ mpc_t * mpc, SV * uj, mpf_t * mpf, SV * round) {
1193 #ifdef MATH_MPC_NEED_LONG_LONG_INT
1194 SV_MPC_SET_X_Y(uj, f, *mpc, (unsigned long long)SvUV(uj), *mpf, (mpc_rnd_t) SvUV(round));
1195 #else
1196 croak("Rmpc_set_uj_f not implemented for this build of perl");
1197 #endif
1198 }
1199
Rmpc_set_uj_q(pTHX_ mpc_t * mpc,SV * uj,mpq_t * mpq,SV * round)1200 SV * Rmpc_set_uj_q(pTHX_ mpc_t * mpc, SV * uj, mpq_t * mpq, SV * round) {
1201 #ifdef MATH_MPC_NEED_LONG_LONG_INT
1202 SV_MPC_SET_X_Y(uj, q, *mpc, (unsigned long long)SvUV(uj), *mpq, (mpc_rnd_t) SvUV(round));
1203 #else
1204 croak("Rmpc_set_uj_q not implemented for this build of perl");
1205 #endif
1206 }
1207
Rmpc_set_uj_z(pTHX_ mpc_t * mpc,SV * uj,mpz_t * mpz,SV * round)1208 SV * Rmpc_set_uj_z(pTHX_ mpc_t * mpc, SV * uj, mpz_t * mpz, SV * round) {
1209 #ifdef MATH_MPC_NEED_LONG_LONG_INT
1210 SV_MPC_SET_X_Y(uj, z, *mpc, (unsigned long long)SvUV(uj), *mpz, (mpc_rnd_t) SvUV(round));
1211 #else
1212 croak("Rmpc_set_uj_z not implemented for this build of perl");
1213 #endif
1214 }
1215
Rmpc_set_sj_f(pTHX_ mpc_t * mpc,SV * sj,mpf_t * mpf,SV * round)1216 SV * Rmpc_set_sj_f(pTHX_ mpc_t * mpc, SV * sj, mpf_t * mpf, SV * round) {
1217 #ifdef MATH_MPC_NEED_LONG_LONG_INT
1218 SV_MPC_SET_X_Y(sj, f, *mpc, (signed long long)SvIV(sj), *mpf, (mpc_rnd_t) SvUV(round));
1219 #else
1220 croak("Rmpc_set_sj_f not implemented for this build of perl");
1221 #endif
1222 }
1223
Rmpc_set_sj_q(pTHX_ mpc_t * mpc,SV * sj,mpq_t * mpq,SV * round)1224 SV * Rmpc_set_sj_q(pTHX_ mpc_t * mpc, SV * sj, mpq_t * mpq, SV * round) {
1225 #ifdef MATH_MPC_NEED_LONG_LONG_INT
1226 SV_MPC_SET_X_Y(sj, q, *mpc, (signed long long)SvIV(sj), *mpq, (mpc_rnd_t) SvUV(round));
1227 #else
1228 croak("Rmpc_set_sj_q not implemented for this build of perl");
1229 #endif
1230 }
1231
Rmpc_set_sj_z(pTHX_ mpc_t * mpc,SV * sj,mpz_t * mpz,SV * round)1232 SV * Rmpc_set_sj_z(pTHX_ mpc_t * mpc, SV * sj, mpz_t * mpz, SV * round) {
1233 #ifdef MATH_MPC_NEED_LONG_LONG_INT
1234 SV_MPC_SET_X_Y(sj, z, *mpc, (signed long long)SvIV(sj), *mpz, (mpc_rnd_t) SvUV(round));
1235 #else
1236 croak("Rmpc_set_sj_z not implemented for this build of perl");
1237 #endif
1238 }
1239
Rmpc_set_ld_f(pTHX_ mpc_t * mpc,SV * ld,mpf_t * mpf,SV * round)1240 SV * Rmpc_set_ld_f(pTHX_ mpc_t * mpc, SV * ld, mpf_t * mpf, SV * round) {
1241 #if defined(NV_IS_LONG_DOUBLE) || defined(NV_IS_FLOAT128)
1242 SV_MPC_SET_X_Y(ld, f, *mpc, (long double)SvNV(ld), *mpf, (mpc_rnd_t) SvUV(round));
1243 #else
1244 croak("Rmpc_set_ld_f not implemented for this build of perl");
1245 #endif
1246 }
1247
Rmpc_set_ld_q(pTHX_ mpc_t * mpc,SV * ld,mpq_t * mpq,SV * round)1248 SV * Rmpc_set_ld_q(pTHX_ mpc_t * mpc, SV * ld, mpq_t * mpq, SV * round) {
1249 #if defined(NV_IS_LONG_DOUBLE) || defined(NV_IS_FLOAT128)
1250 SV_MPC_SET_X_Y(ld, q, *mpc, (long double)SvNV(ld), *mpq, (mpc_rnd_t) SvUV(round));
1251 #else
1252 croak("Rmpc_set_ld_q not implemented for this build of perl");
1253 #endif
1254 }
1255
Rmpc_set_ld_z(pTHX_ mpc_t * mpc,SV * ld,mpz_t * mpz,SV * round)1256 SV * Rmpc_set_ld_z(pTHX_ mpc_t * mpc, SV * ld, mpz_t * mpz, SV * round) {
1257 #if defined(NV_IS_LONG_DOUBLE) || defined(NV_IS_FLOAT128)
1258 SV_MPC_SET_X_Y(ld, z, *mpc, (long double)SvNV(ld), *mpz, (mpc_rnd_t) SvUV(round));
1259 #else
1260 croak("Rmpc_set_ld_z not implemented for this build of perl");
1261 #endif
1262 }
1263
1264 /*
1265 ##############################
1266 ##############################
1267 */
1268
Rmpc_set_f_q(pTHX_ mpc_t * mpc,mpf_t * mpf,mpq_t * mpq,SV * round)1269 SV * Rmpc_set_f_q(pTHX_ mpc_t * mpc, mpf_t * mpf, mpq_t * mpq, SV * round) {
1270 SV_MPC_SET_X_Y(f, q, *mpc, *mpf, *mpq, (mpc_rnd_t) SvUV(round));
1271 }
1272
Rmpc_set_q_f(pTHX_ mpc_t * mpc,mpq_t * mpq,mpf_t * mpf,SV * round)1273 SV * Rmpc_set_q_f(pTHX_ mpc_t * mpc, mpq_t * mpq, mpf_t * mpf, SV * round) {
1274 SV_MPC_SET_X_Y(q, f, *mpc, *mpq, *mpf, (mpc_rnd_t) SvUV(round));
1275 }
1276
Rmpc_set_f_z(pTHX_ mpc_t * mpc,mpf_t * mpf,mpz_t * mpz,SV * round)1277 SV * Rmpc_set_f_z(pTHX_ mpc_t * mpc, mpf_t * mpf, mpz_t * mpz, SV * round) {
1278 SV_MPC_SET_X_Y(f, z, *mpc, *mpf, *mpz, (mpc_rnd_t) SvUV(round));
1279 }
1280
Rmpc_set_z_f(pTHX_ mpc_t * mpc,mpz_t * mpz,mpf_t * mpf,SV * round)1281 SV * Rmpc_set_z_f(pTHX_ mpc_t * mpc, mpz_t * mpz, mpf_t * mpf, SV * round) {
1282 SV_MPC_SET_X_Y(z, f, *mpc, *mpz, *mpf, (mpc_rnd_t) SvUV(round));
1283 }
1284
Rmpc_set_q_z(pTHX_ mpc_t * mpc,mpq_t * mpq,mpz_t * mpz,SV * round)1285 SV * Rmpc_set_q_z(pTHX_ mpc_t * mpc, mpq_t * mpq, mpz_t * mpz, SV * round) {
1286 SV_MPC_SET_X_Y(q, z, *mpc, *mpq, *mpz, (mpc_rnd_t) SvUV(round));
1287 }
1288
Rmpc_set_z_q(pTHX_ mpc_t * mpc,mpz_t * mpz,mpq_t * mpq,SV * round)1289 SV * Rmpc_set_z_q(pTHX_ mpc_t * mpc, mpz_t * mpz, mpq_t * mpq, SV * round) {
1290 SV_MPC_SET_X_Y(z, q, *mpc, *mpz, *mpq, (mpc_rnd_t) SvUV(round));
1291 }
1292
Rmpc_set_f_fr(pTHX_ mpc_t * mpc,mpf_t * mpf,mpfr_t * mpfr,SV * round)1293 SV * Rmpc_set_f_fr(pTHX_ mpc_t * mpc, mpf_t * mpf, mpfr_t * mpfr, SV * round) {
1294 SV_MPC_SET_X_Y(f, fr, *mpc, *mpf, *mpfr, (mpc_rnd_t) SvUV(round));
1295 }
1296
Rmpc_set_fr_f(pTHX_ mpc_t * mpc,mpfr_t * mpfr,mpf_t * mpf,SV * round)1297 SV * Rmpc_set_fr_f(pTHX_ mpc_t * mpc, mpfr_t * mpfr, mpf_t * mpf, SV * round) {
1298 SV_MPC_SET_X_Y(fr, f, *mpc, *mpfr, *mpf, (mpc_rnd_t) SvUV(round));
1299 }
1300
Rmpc_set_q_fr(pTHX_ mpc_t * mpc,mpq_t * mpq,mpfr_t * mpfr,SV * round)1301 SV * Rmpc_set_q_fr(pTHX_ mpc_t * mpc, mpq_t * mpq, mpfr_t * mpfr, SV * round) {
1302 SV_MPC_SET_X_Y(q, fr, *mpc, *mpq, *mpfr, (mpc_rnd_t) SvUV(round));
1303 }
1304
Rmpc_set_fr_q(pTHX_ mpc_t * mpc,mpfr_t * mpfr,mpq_t * mpq,SV * round)1305 SV * Rmpc_set_fr_q(pTHX_ mpc_t * mpc, mpfr_t * mpfr, mpq_t * mpq, SV * round) {
1306 SV_MPC_SET_X_Y(fr, q, *mpc, *mpfr, *mpq, (mpc_rnd_t) SvUV(round));
1307 }
1308
Rmpc_set_z_fr(pTHX_ mpc_t * mpc,mpz_t * mpz,mpfr_t * mpfr,SV * round)1309 SV * Rmpc_set_z_fr(pTHX_ mpc_t * mpc, mpz_t * mpz, mpfr_t * mpfr, SV * round) {
1310 SV_MPC_SET_X_Y(z, fr, *mpc, *mpz, *mpfr, (mpc_rnd_t) SvUV(round));
1311 }
1312
Rmpc_set_fr_z(pTHX_ mpc_t * mpc,mpfr_t * mpfr,mpz_t * mpz,SV * round)1313 SV * Rmpc_set_fr_z(pTHX_ mpc_t * mpc, mpfr_t * mpfr, mpz_t * mpz, SV * round) {
1314 SV_MPC_SET_X_Y(fr, z, *mpc, *mpfr, *mpz, (mpc_rnd_t) SvUV(round));
1315 }
1316
1317
1318 /*
1319 ##############################
1320 ##############################
1321 */
1322
Rmpc_set_uj_uj(pTHX_ mpc_t * mpc,SV * uj1,SV * uj2,SV * round)1323 SV * Rmpc_set_uj_uj(pTHX_ mpc_t * mpc, SV * uj1, SV * uj2, SV * round) {
1324 #ifdef MATH_MPC_NEED_LONG_LONG_INT
1325 return newSViv(mpc_set_uj_uj(*mpc, (unsigned long long)SvUV(uj1),
1326 (unsigned long long)SvUV(uj2), (mpc_rnd_t)SvUV(round)));
1327 #else
1328 croak("Rmpc_set_ui_uj, Rmpc_set_uj_ui and Rmpc_set_uj_uj not implemented for this build of perl");
1329 #endif
1330 }
1331
Rmpc_set_sj_sj(pTHX_ mpc_t * mpc,SV * sj1,SV * sj2,SV * round)1332 SV * Rmpc_set_sj_sj(pTHX_ mpc_t * mpc, SV * sj1, SV * sj2, SV * round) {
1333 #ifdef MATH_MPC_NEED_LONG_LONG_INT
1334 return newSViv(mpc_set_sj_sj(*mpc, (signed long long)SvIV(sj1),
1335 (signed long long)SvIV(sj2), (mpc_rnd_t)SvUV(round)));
1336 #else
1337 croak("Rmpc_set_si_sj, Rmpc_set_sj_si and Rmpc_set_sj_sj not implemented for this build of perl");
1338 #endif
1339 }
1340
Rmpc_add(pTHX_ mpc_t * a,mpc_t * b,mpc_t * c,SV * round)1341 SV * Rmpc_add(pTHX_ mpc_t * a, mpc_t * b, mpc_t * c, SV * round) {
1342 return newSViv(mpc_add(*a, *b, *c, (mpc_rnd_t)SvUV(round)));
1343 }
1344
Rmpc_add_ui(pTHX_ mpc_t * a,mpc_t * b,SV * c,SV * round)1345 SV * Rmpc_add_ui(pTHX_ mpc_t * a, mpc_t * b, SV * c, SV * round){
1346 return newSViv(mpc_add_ui(*a, *b, SvUV(c), (mpc_rnd_t)SvUV(round)));
1347 }
1348
Rmpc_add_fr(pTHX_ mpc_t * a,mpc_t * b,mpfr_t * c,SV * round)1349 SV * Rmpc_add_fr(pTHX_ mpc_t * a, mpc_t * b, mpfr_t * c, SV * round){
1350 return newSViv(mpc_add_fr(*a, *b, *c, (mpc_rnd_t)SvUV(round)));
1351 }
1352
Rmpc_sub(pTHX_ mpc_t * a,mpc_t * b,mpc_t * c,SV * round)1353 SV * Rmpc_sub(pTHX_ mpc_t * a, mpc_t * b, mpc_t * c, SV * round) {
1354 return newSViv(mpc_sub(*a, *b, *c, (mpc_rnd_t)SvUV(round)));
1355 }
1356
Rmpc_sub_ui(pTHX_ mpc_t * a,mpc_t * b,SV * c,SV * round)1357 SV * Rmpc_sub_ui(pTHX_ mpc_t * a, mpc_t * b, SV * c, SV * round) {
1358 return newSViv(mpc_sub_ui(*a, *b, SvUV(c), (mpc_rnd_t)SvUV(round)));
1359 }
1360
Rmpc_ui_sub(pTHX_ mpc_t * a,SV * b,mpc_t * c,SV * round)1361 SV * Rmpc_ui_sub(pTHX_ mpc_t * a, SV * b, mpc_t * c, SV * round) {
1362 return newSViv(mpc_ui_sub(*a, SvUV(b), *c, (mpc_rnd_t)SvUV(round)));
1363 }
1364
Rmpc_ui_ui_sub(pTHX_ mpc_t * a,SV * b_r,SV * b_i,mpc_t * c,SV * round)1365 SV * Rmpc_ui_ui_sub(pTHX_ mpc_t * a, SV * b_r, SV * b_i, mpc_t * c, SV * round) {
1366 return newSViv(mpc_ui_ui_sub(*a, SvUV(b_r), SvUV(b_i), *c, (mpc_rnd_t)SvUV(round)));
1367 }
1368
Rmpc_mul(pTHX_ mpc_t * a,mpc_t * b,mpc_t * c,SV * round)1369 SV * Rmpc_mul(pTHX_ mpc_t * a, mpc_t * b, mpc_t * c, SV * round) {
1370 return newSViv(mpc_mul(*a, *b, *c, (mpc_rnd_t)SvUV(round)));
1371 }
1372
Rmpc_mul_ui(pTHX_ mpc_t * a,mpc_t * b,SV * c,SV * round)1373 SV * Rmpc_mul_ui(pTHX_ mpc_t * a, mpc_t * b, SV * c, SV * round){
1374 return newSViv(mpc_mul_ui(*a, *b, SvUV(c), (mpc_rnd_t)SvUV(round)));
1375 }
1376
Rmpc_mul_si(pTHX_ mpc_t * a,mpc_t * b,SV * c,SV * round)1377 SV * Rmpc_mul_si(pTHX_ mpc_t * a, mpc_t * b, SV * c, SV * round){
1378 return newSViv(mpc_mul_si(*a, *b, SvIV(c), (mpc_rnd_t)SvUV(round)));
1379 }
1380
Rmpc_mul_fr(pTHX_ mpc_t * a,mpc_t * b,mpfr_t * c,SV * round)1381 SV * Rmpc_mul_fr(pTHX_ mpc_t * a, mpc_t * b, mpfr_t * c, SV * round){
1382 return newSViv(mpc_mul_fr(*a, *b, *c, (mpc_rnd_t)SvUV(round)));
1383 }
1384
Rmpc_mul_i(pTHX_ mpc_t * a,mpc_t * b,SV * sign,SV * round)1385 SV * Rmpc_mul_i(pTHX_ mpc_t * a, mpc_t * b, SV * sign, SV * round){
1386 return newSViv(mpc_mul_i(*a, *b, SvIV(sign), (mpc_rnd_t)SvUV(round)));
1387 }
1388
Rmpc_sqr(pTHX_ mpc_t * a,mpc_t * b,SV * round)1389 SV * Rmpc_sqr(pTHX_ mpc_t * a, mpc_t * b, SV * round) {
1390 return newSViv(mpc_sqr(*a, *b, (mpc_rnd_t)SvUV(round)));
1391 }
1392
Rmpc_div(pTHX_ mpc_t * a,mpc_t * b,mpc_t * c,SV * round)1393 SV * Rmpc_div(pTHX_ mpc_t * a, mpc_t * b, mpc_t * c, SV * round) {
1394 return newSViv(mpc_div(*a, *b, *c, (mpc_rnd_t)SvUV(round)));
1395 }
1396
Rmpc_div_ui(pTHX_ mpc_t * a,mpc_t * b,SV * c,SV * round)1397 SV * Rmpc_div_ui(pTHX_ mpc_t * a, mpc_t * b, SV * c, SV * round){
1398 return newSViv(mpc_div_ui(*a, *b, SvUV(c), (mpc_rnd_t)SvUV(round)));
1399 }
1400
Rmpc_ui_div(pTHX_ mpc_t * a,SV * b,mpc_t * c,SV * round)1401 SV * Rmpc_ui_div(pTHX_ mpc_t * a, SV * b, mpc_t * c, SV * round) {
1402 return newSViv(mpc_ui_div(*a, SvUV(b), *c, (mpc_rnd_t)SvUV(round)));
1403 }
1404
Rmpc_div_fr(pTHX_ mpc_t * a,mpc_t * b,mpfr_t * c,SV * round)1405 SV * Rmpc_div_fr(pTHX_ mpc_t * a, mpc_t * b, mpfr_t * c, SV * round){
1406 return newSViv(mpc_div_fr(*a, *b, *c, (mpc_rnd_t)SvUV(round)));
1407 }
1408
Rmpc_sqrt(pTHX_ mpc_t * a,mpc_t * b,SV * round)1409 SV * Rmpc_sqrt(pTHX_ mpc_t * a, mpc_t * b, SV * round) {
1410 return newSViv(mpc_sqrt(*a, *b, (mpc_rnd_t)SvUV(round)));
1411 }
1412
Rmpc_pow(pTHX_ mpc_t * a,mpc_t * b,mpc_t * pow,SV * round)1413 SV * Rmpc_pow(pTHX_ mpc_t * a, mpc_t * b, mpc_t * pow, SV * round) {
1414 return newSViv(mpc_pow(*a, *b, *pow, (mpc_rnd_t)SvUV(round)));
1415 }
1416
Rmpc_pow_d(pTHX_ mpc_t * a,mpc_t * b,SV * pow,SV * round)1417 SV * Rmpc_pow_d(pTHX_ mpc_t * a, mpc_t * b, SV * pow, SV * round) {
1418 return newSViv(mpc_pow_d(*a, *b, SvNV(pow), (mpc_rnd_t)SvUV(round)));
1419 }
1420
Rmpc_pow_ld(pTHX_ mpc_t * a,mpc_t * b,SV * pow,SV * round)1421 SV * Rmpc_pow_ld(pTHX_ mpc_t * a, mpc_t * b, SV * pow, SV * round) {
1422 #if defined(NV_IS_LONG_DOUBLE) || defined(NV_IS_FLOAT128)
1423 return newSViv(mpc_pow_ld(*a, *b, SvNV(pow), (mpc_rnd_t)SvUV(round)));
1424 #else
1425 croak("Rmpc_pow_ld not implemented on this build of perl");
1426 #endif
1427 }
1428
Rmpc_pow_si(pTHX_ mpc_t * a,mpc_t * b,SV * pow,SV * round)1429 SV * Rmpc_pow_si(pTHX_ mpc_t * a, mpc_t * b, SV * pow, SV * round) {
1430 return newSViv(mpc_pow_si(*a, *b, SvIV(pow), (mpc_rnd_t)SvUV(round)));
1431 }
1432
Rmpc_pow_ui(pTHX_ mpc_t * a,mpc_t * b,SV * pow,SV * round)1433 SV * Rmpc_pow_ui(pTHX_ mpc_t * a, mpc_t * b, SV * pow, SV * round) {
1434 return newSViv(mpc_pow_ui(*a, *b, SvUV(pow), (mpc_rnd_t)SvUV(round)));
1435 }
1436
Rmpc_pow_z(pTHX_ mpc_t * a,mpc_t * b,mpz_t * pow,SV * round)1437 SV * Rmpc_pow_z(pTHX_ mpc_t * a, mpc_t * b, mpz_t * pow, SV * round) {
1438 return newSViv(mpc_pow_z(*a, *b, *pow, (mpc_rnd_t)SvUV(round)));
1439 }
1440
Rmpc_pow_fr(pTHX_ mpc_t * a,mpc_t * b,mpfr_t * pow,SV * round)1441 SV * Rmpc_pow_fr(pTHX_ mpc_t * a, mpc_t * b, mpfr_t * pow, SV * round) {
1442 return newSViv(mpc_pow_fr(*a, *b, *pow, (mpc_rnd_t)SvUV(round)));
1443 }
1444
Rmpc_neg(pTHX_ mpc_t * a,mpc_t * b,SV * round)1445 SV * Rmpc_neg(pTHX_ mpc_t * a, mpc_t * b, SV * round) {
1446 return newSViv(mpc_neg(*a, *b, (mpc_rnd_t)SvUV(round)));
1447 }
1448
Rmpc_abs(pTHX_ mpfr_t * a,mpc_t * b,SV * round)1449 SV * Rmpc_abs(pTHX_ mpfr_t * a, mpc_t * b, SV * round) {
1450 return newSViv(mpc_abs(*a, *b, (mpc_rnd_t)SvUV(round)));
1451 }
1452
Rmpc_conj(pTHX_ mpc_t * a,mpc_t * b,SV * round)1453 SV * Rmpc_conj(pTHX_ mpc_t * a, mpc_t * b, SV * round) {
1454 return newSViv(mpc_conj(*a, *b, (mpc_rnd_t)SvUV(round)));
1455 }
1456
Rmpc_norm(pTHX_ mpfr_t * a,mpc_t * b,SV * round)1457 SV * Rmpc_norm(pTHX_ mpfr_t * a, mpc_t * b, SV * round) {
1458 return newSViv(mpc_norm(*a, *b, (mpc_rnd_t)SvUV(round)));
1459 }
1460
1461 /* Beginning mpc-1.0, mpc_mul_2exp and mpc_div_2exp were
1462 * renamed mpc_mul_2ui and mpc_div_2ui
1463 */
1464
Rmpc_mul_2ui(pTHX_ mpc_t * a,mpc_t * b,SV * c,SV * round)1465 SV * Rmpc_mul_2ui(pTHX_ mpc_t * a, mpc_t * b, SV * c, SV * round) {
1466 #if MPC_VERSION < 65536
1467 return newSViv(mpc_mul_2exp(*a, *b, SvUV(c), (mpc_rnd_t)SvUV(round)));
1468 #else
1469 return newSViv(mpc_mul_2ui(*a, *b, SvUV(c), (mpc_rnd_t)SvUV(round)));
1470 #endif
1471 }
1472
Rmpc_div_2ui(pTHX_ mpc_t * a,mpc_t * b,SV * c,SV * round)1473 SV * Rmpc_div_2ui(pTHX_ mpc_t * a, mpc_t * b, SV * c, SV * round) {
1474 #if MPC_VERSION < 65536
1475 return newSViv(mpc_div_2exp(*a, *b, SvUV(c), (mpc_rnd_t)SvUV(round)));
1476 #else
1477 return newSViv(mpc_div_2ui(*a, *b, SvUV(c), (mpc_rnd_t)SvUV(round)));
1478 #endif
1479 }
1480
Rmpc_cmp(pTHX_ mpc_t * a,mpc_t * b)1481 SV * Rmpc_cmp(pTHX_ mpc_t * a, mpc_t * b) {
1482 return newSViv(mpc_cmp(*a, *b));
1483 }
1484
Rmpc_cmp_si(pTHX_ mpc_t * a,SV * b)1485 SV * Rmpc_cmp_si(pTHX_ mpc_t * a, SV * b) {
1486 return newSViv(mpc_cmp_si(*a, SvIV(b)));
1487 }
1488
Rmpc_cmp_si_si(pTHX_ mpc_t * a,SV * b,SV * c)1489 SV * Rmpc_cmp_si_si(pTHX_ mpc_t * a, SV * b, SV * c) {
1490 return newSViv(mpc_cmp_si_si(*a, SvIV(b), SvIV(c)));
1491 }
1492
Rmpc_exp(pTHX_ mpc_t * a,mpc_t * b,SV * round)1493 SV * Rmpc_exp(pTHX_ mpc_t * a, mpc_t * b, SV * round) {
1494 return newSViv(mpc_exp(*a, *b, (mpc_rnd_t)SvUV(round)));
1495 }
1496
Rmpc_log(pTHX_ mpc_t * rop,mpc_t * op,SV * round)1497 SV * Rmpc_log(pTHX_ mpc_t * rop, mpc_t * op, SV * round) {
1498 return newSViv(mpc_log(*rop, *op, (mpc_rnd_t)SvUV(round)));
1499 }
1500
_Rmpc_out_str(pTHX_ FILE * stream,SV * base,SV * dig,mpc_t * p,SV * round)1501 SV * _Rmpc_out_str(pTHX_ FILE * stream, SV * base, SV * dig, mpc_t * p, SV * round) {
1502 size_t ret;
1503 if(SvIV(base) < 2 || SvIV(base) > 36) croak("2nd argument supplied to Rmpc_out_str is out of allowable range (must be between 2 and 36 inclusive)");
1504 ret = mpc_out_str(stream, (int)SvIV(base), (size_t)SvUV(dig), *p, (mpc_rnd_t)SvUV(round));
1505 fflush(stream);
1506 return newSVuv(ret);
1507 }
1508
_Rmpc_out_strS(pTHX_ FILE * stream,SV * base,SV * dig,mpc_t * p,SV * round,SV * suff)1509 SV * _Rmpc_out_strS(pTHX_ FILE * stream, SV * base, SV * dig, mpc_t * p, SV * round, SV * suff) {
1510 size_t ret;
1511 if(SvIV(base) < 2 || SvIV(base) > 36) croak("2nd argument supplied to Rmpc_out_str is out of allowable range (must be between 2 and 36 inclusive)");
1512 ret = mpc_out_str(stream, (int)SvIV(base), (size_t)SvUV(dig), *p, (mpc_rnd_t)SvUV(round));
1513 fflush(stream);
1514 fprintf(stream, "%s", SvPV_nolen(suff));
1515 fflush(stream);
1516 return newSVuv(ret);
1517 }
1518
_Rmpc_out_strP(pTHX_ SV * pre,FILE * stream,SV * base,SV * dig,mpc_t * p,SV * round)1519 SV * _Rmpc_out_strP(pTHX_ SV * pre, FILE * stream, SV * base, SV * dig, mpc_t * p, SV * round) {
1520 size_t ret;
1521 if(SvIV(base) < 2 || SvIV(base) > 36) croak("3rd argument supplied to Rmpc_out_str is out of allowable range (must be between 2 and 36 inclusive)");
1522 fprintf(stream, "%s", SvPV_nolen(pre));
1523 fflush(stream);
1524 ret = mpc_out_str(stream, (int)SvIV(base), (size_t)SvUV(dig), *p, (mpc_rnd_t)SvUV(round));
1525 fflush(stream);
1526 return newSVuv(ret);
1527 }
1528
_Rmpc_out_strPS(pTHX_ SV * pre,FILE * stream,SV * base,SV * dig,mpc_t * p,SV * round,SV * suff)1529 SV * _Rmpc_out_strPS(pTHX_ SV * pre, FILE * stream, SV * base, SV * dig, mpc_t * p, SV * round, SV * suff) {
1530 size_t ret;
1531 if(SvIV(base) < 2 || SvIV(base) > 36) croak("3rd argument supplied to Rmpc_out_str is out of allowable range (must be between 2 and 36 inclusive)");
1532 fprintf(stream, "%s", SvPV_nolen(pre));
1533 fflush(stream);
1534 ret = mpc_out_str(stream, (int)SvIV(base), (size_t)SvUV(dig), *p, (mpc_rnd_t)SvUV(round));
1535 fflush(stream);
1536 fprintf(stream, "%s", SvPV_nolen(suff));
1537 fflush(stream);
1538 return newSVuv(ret);
1539 }
1540
1541
Rmpc_inp_str(pTHX_ mpc_t * p,FILE * stream,SV * base,SV * round)1542 int Rmpc_inp_str(pTHX_ mpc_t * p, FILE * stream, SV * base, SV * round) {
1543 int ret;
1544 if(SvIV(base) < 2 || SvIV(base) > 36) croak("3rd argument supplied to Rmpc_inp_str is out of allowable range (must be between 2 and 36 inclusive)");
1545 ret = mpc_inp_str(*p, stream, NULL, (int)SvIV(base), (mpc_rnd_t)SvUV(round));
1546 if(ret == -1) croak("Invalid string given to Rmpc_inp_str");
1547 return ret;
1548 }
1549
1550 /* Removed in mpc-0.7
1551 void Rmpc_random(mpc_t * p) {
1552 mpc_random(*p);
1553 }
1554 */
1555
1556 /* Removed in mpc-0.7
1557 void Rmpc_random2(mpc_t * p, SV * s, SV * exp) {
1558 mpc_random2(*p, SvIV(s), SvUV(exp));
1559 }
1560 */
1561
Rmpc_sin(pTHX_ mpc_t * rop,mpc_t * op,SV * round)1562 SV * Rmpc_sin(pTHX_ mpc_t * rop, mpc_t * op, SV * round) {
1563 return newSViv(mpc_sin(*rop, *op, (mpc_rnd_t)SvUV(round)));
1564 }
1565
Rmpc_cos(pTHX_ mpc_t * rop,mpc_t * op,SV * round)1566 SV * Rmpc_cos(pTHX_ mpc_t * rop, mpc_t * op, SV * round) {
1567 return newSViv(mpc_cos(*rop, *op, (mpc_rnd_t)SvUV(round)));
1568 }
1569
Rmpc_tan(pTHX_ mpc_t * rop,mpc_t * op,SV * round)1570 SV * Rmpc_tan(pTHX_ mpc_t * rop, mpc_t * op, SV * round) {
1571 return newSViv(mpc_tan(*rop, *op, (mpc_rnd_t)SvUV(round)));
1572 }
1573
Rmpc_sinh(pTHX_ mpc_t * rop,mpc_t * op,SV * round)1574 SV * Rmpc_sinh(pTHX_ mpc_t * rop, mpc_t * op, SV * round) {
1575 return newSViv(mpc_sinh(*rop, *op, (mpc_rnd_t)SvUV(round)));
1576 }
1577
Rmpc_cosh(pTHX_ mpc_t * rop,mpc_t * op,SV * round)1578 SV * Rmpc_cosh(pTHX_ mpc_t * rop, mpc_t * op, SV * round) {
1579 return newSViv(mpc_cosh(*rop, *op, (mpc_rnd_t)SvUV(round)));
1580 }
1581
Rmpc_tanh(pTHX_ mpc_t * rop,mpc_t * op,SV * round)1582 SV * Rmpc_tanh(pTHX_ mpc_t * rop, mpc_t * op, SV * round) {
1583 return newSViv(mpc_tanh(*rop, *op, (mpc_rnd_t)SvUV(round)));
1584 }
1585
Rmpc_asin(pTHX_ mpc_t * rop,mpc_t * op,SV * round)1586 SV * Rmpc_asin(pTHX_ mpc_t * rop, mpc_t * op, SV * round) {
1587 return newSViv(mpc_asin(*rop, *op, (mpc_rnd_t)SvUV(round)));
1588 }
1589
Rmpc_acos(pTHX_ mpc_t * rop,mpc_t * op,SV * round)1590 SV * Rmpc_acos(pTHX_ mpc_t * rop, mpc_t * op, SV * round) {
1591 return newSViv(mpc_acos(*rop, *op, (mpc_rnd_t)SvUV(round)));
1592 }
1593
Rmpc_atan(pTHX_ mpc_t * rop,mpc_t * op,SV * round)1594 SV * Rmpc_atan(pTHX_ mpc_t * rop, mpc_t * op, SV * round) {
1595 return newSViv(mpc_atan(*rop, *op, (mpc_rnd_t)SvUV(round)));
1596 }
1597
Rmpc_asinh(pTHX_ mpc_t * rop,mpc_t * op,SV * round)1598 SV * Rmpc_asinh(pTHX_ mpc_t * rop, mpc_t * op, SV * round) {
1599 return newSViv(mpc_asinh(*rop, *op, (mpc_rnd_t)SvUV(round)));
1600 }
1601
Rmpc_acosh(pTHX_ mpc_t * rop,mpc_t * op,SV * round)1602 SV * Rmpc_acosh(pTHX_ mpc_t * rop, mpc_t * op, SV * round) {
1603 return newSViv(mpc_acosh(*rop, *op, (mpc_rnd_t)SvUV(round)));
1604 }
1605
Rmpc_atanh(pTHX_ mpc_t * rop,mpc_t * op,SV * round)1606 SV * Rmpc_atanh(pTHX_ mpc_t * rop, mpc_t * op, SV * round) {
1607 return newSViv(mpc_atanh(*rop, *op, (mpc_rnd_t)SvUV(round)));
1608 }
1609
overload_true(pTHX_ mpc_t * a,SV * second,SV * third)1610 SV * overload_true(pTHX_ mpc_t *a, SV *second, SV * third) {
1611 if(
1612 ( mpfr_nan_p(MPC_RE(*a)) || !mpfr_cmp_ui(MPC_RE(*a), 0) ) &&
1613 ( mpfr_nan_p(MPC_IM(*a)) || !mpfr_cmp_ui(MPC_IM(*a), 0) )
1614 ) return newSVuv(0);
1615 return newSVuv(1);
1616 }
1617
1618 /********************************/
1619 /********************************/
1620 /********************************/
1621 /********************************/
1622 /********************************/
1623 /********************************/
1624 /********************************/
1625 /********************************/
1626
overload_mul(pTHX_ mpc_t * a,SV * b,SV * third)1627 SV * overload_mul(pTHX_ mpc_t * a, SV * b, SV * third) {
1628 dMY_CXT;
1629 mpc_t * mpc_t_obj;
1630 SV * obj_ref, * obj;
1631 mpfr_t t;
1632 int ret;
1633
1634 New(1, mpc_t_obj, 1, mpc_t);
1635 if(mpc_t_obj == NULL) croak("Failed to allocate memory in overload_mul function");
1636 obj_ref = newSV(0);
1637 obj = newSVrv(obj_ref, "Math::MPC");
1638 mpc_init3(*mpc_t_obj, DEFAULT_PREC);
1639 sv_setiv(obj, INT2PTR(IV,mpc_t_obj));
1640 SvREADONLY_on(obj);
1641
1642 #ifdef MATH_MPC_NEED_LONG_LONG_INT
1643
1644 if(SV_IS_IOK(b)) {
1645 mpfr_init2(t, sizeof(IV) * CHAR_BIT);
1646 #ifdef _MSC_VER
1647 mpfr_set_str(t, SvPV_nolen(b), 10, GMP_RNDN);
1648 #else
1649 if(SvUOK(b)) mpfr_set_uj(t, SvUVX(b), GMP_RNDN);
1650 else mpfr_set_sj(t, SvIVX(b), GMP_RNDN);
1651 #endif
1652 mpc_mul_fr(*mpc_t_obj, *a, t, DEFAULT_ROUNDING_MODE);
1653 mpfr_clear(t);
1654 return obj_ref;
1655 }
1656
1657 #else
1658 if(SV_IS_IOK(b)) {
1659 if(SvUOK(b)) {
1660 mpc_mul_ui(*mpc_t_obj, *a, SvUVX(b), DEFAULT_ROUNDING_MODE);
1661 return obj_ref;
1662 }
1663
1664 mpc_mul_si(*mpc_t_obj, *a, SvIVX(b), DEFAULT_ROUNDING_MODE);
1665 return obj_ref;
1666 }
1667 #endif
1668
1669 if(SV_IS_POK(b)) { /* assign the string with default precision */
1670
1671 NOK_POK_DUALVAR_CHECK , "Math::MPC::overload_mul");}
1672
1673 #ifdef _WIN32_BIZARRE_INFNAN
1674 ret = _win32_infnanstring(SvPV_nolen(b));
1675 if(ret) {
1676 mpfr_init(t);
1677 if(ret == 2) {
1678 mpfr_set_nan(t);
1679 mpc_set_fr(*mpc_t_obj, t, MPC_RNDNN);
1680 }
1681 else {
1682 mpfr_set_inf(t, ret);
1683 mpc_set_fr(*mpc_t_obj, t, MPC_RNDNN);
1684 }
1685 mpfr_clear(t);
1686 }
1687 else {
1688 if(mpc_set_str(*mpc_t_obj, SvPV_nolen(b), 0, DEFAULT_ROUNDING_MODE) == -1)
1689 croak("Invalid string (%s) supplied to Math::MPC::overload_mul", SvPV_nolen(b));
1690 }
1691 #else
1692 if(mpc_set_str(*mpc_t_obj, SvPV_nolen(b), 0, DEFAULT_ROUNDING_MODE) == -1)
1693 croak("Invalid string (%s) supplied to Math::MPC::overload_mul", SvPV_nolen(b));
1694 #endif
1695 mpc_mul(*mpc_t_obj, *a, *mpc_t_obj, DEFAULT_ROUNDING_MODE);
1696 return obj_ref;
1697 }
1698
1699 if(SV_IS_NOK(b)) {
1700 #if defined(NV_IS_FLOAT128)
1701 mpfr_init2(t, FLT128_MANT_DIG);
1702 _mpfr_set_NV(aTHX_ &t, b, GMP_RNDN);
1703
1704 #elif defined(NV_IS_LONG_DOUBLE)
1705 mpfr_init2(t, REQUIRED_LDBL_MANT_DIG);
1706 mpfr_set_ld(t, (long double)SvNVX(b), GMP_RNDN);
1707 #else
1708 mpfr_init2(t, DBL_MANT_DIG);
1709 mpfr_set_d(t, (double)SvNVX(b), GMP_RNDN);
1710 #endif
1711 mpc_mul_fr(*mpc_t_obj, *a, t, DEFAULT_ROUNDING_MODE);
1712 mpfr_clear(t);
1713 return obj_ref;
1714 }
1715
1716 if(sv_isobject(b)) {
1717 const char *h = HvNAME(SvSTASH(SvRV(b)));
1718 if(strEQ(h, "Math::MPC")) {
1719 mpc_mul(*mpc_t_obj, *a, *(INT2PTR(mpc_t *, SvIVX(SvRV(b)))), DEFAULT_ROUNDING_MODE);
1720 return obj_ref;
1721 }
1722 }
1723
1724 croak("Invalid argument supplied to Math::MPC::overload_mul");
1725 }
1726
1727 SV * overload_add(pTHX_ mpc_t* a, SV * b, SV * third) {
1728 dMY_CXT;
1729 mpc_t * mpc_t_obj;
1730 SV * obj_ref, * obj;
1731 mpfr_t t;
1732 int ret;
1733
1734 New(1, mpc_t_obj, 1, mpc_t);
1735 if(mpc_t_obj == NULL) croak("Failed to allocate memory in overload_add function");
1736 obj_ref = newSV(0);
1737 obj = newSVrv(obj_ref, "Math::MPC");
1738 mpc_init3(*mpc_t_obj, DEFAULT_PREC);
1739 sv_setiv(obj, INT2PTR(IV,mpc_t_obj));
1740 SvREADONLY_on(obj);
1741
1742 #ifdef MATH_MPC_NEED_LONG_LONG_INT
1743
1744 if(SV_IS_IOK(b)) {
1745 mpfr_init2(t, sizeof(IV) * CHAR_BIT);
1746 #ifdef _MSC_VER
1747 mpfr_set_str(t, SvPV_nolen(b), 10, GMP_RNDN);
1748 #else
1749 if(SvUOK(b)) mpfr_set_uj(t, SvUVX(b), GMP_RNDN);
1750 else mpfr_set_sj(t, SvIVX(b), GMP_RNDN);
1751 #endif
1752 mpc_add_fr(*mpc_t_obj, *a, t, DEFAULT_ROUNDING_MODE);
1753 mpfr_clear(t);
1754 return obj_ref;
1755 }
1756
1757 #else
1758
1759 if(SV_IS_IOK(b)) {
1760 if(SvUOK(b)) {
1761 mpc_add_ui(*mpc_t_obj, *a, SvUVX(b), DEFAULT_ROUNDING_MODE);
1762 return obj_ref;
1763 }
1764
1765 if(SvIVX(b) >= 0)
1766 mpc_add_ui(*mpc_t_obj, *a, SvUVX(b) , DEFAULT_ROUNDING_MODE);
1767 else
1768 mpc_sub_ui(*mpc_t_obj, *a, SvIVX(b) * -1, DEFAULT_ROUNDING_MODE);
1769 return obj_ref;
1770 }
1771 #endif
1772
1773 if(SV_IS_POK(b)) { /* assign string with default precision */
1774
1775 NOK_POK_DUALVAR_CHECK , "Math::MPC::overload_add");}
1776
1777 #ifdef _WIN32_BIZARRE_INFNAN
1778 ret = _win32_infnanstring(SvPV_nolen(b));
1779 if(ret) {
1780 mpfr_init(t);
1781 if(ret == 2) {
1782 mpfr_set_nan(t);
1783 mpc_set_fr(*mpc_t_obj, t, MPC_RNDNN);
1784 }
1785 else {
1786 mpfr_set_inf(t, ret);
1787 mpc_set_fr(*mpc_t_obj, t, MPC_RNDNN);
1788 }
1789 mpfr_clear(t);
1790 }
1791 else {
1792 if(mpc_set_str(*mpc_t_obj, SvPV_nolen(b), 0, DEFAULT_ROUNDING_MODE) == -1)
1793 croak("Invalid string (%s) supplied to Math::MPC::overload_add", SvPV_nolen(b));
1794 }
1795 #else
1796 if(mpc_set_str(*mpc_t_obj, SvPV_nolen(b), 0, DEFAULT_ROUNDING_MODE) == -1)
1797 croak("Invalid string (%s) supplied to Math::MPC::overload_add", SvPV_nolen(b));
1798 #endif
1799 mpc_add(*mpc_t_obj, *a, *mpc_t_obj, DEFAULT_ROUNDING_MODE);
1800 return obj_ref;
1801 }
1802
1803 if(SV_IS_NOK(b)) {
1804 #if defined(NV_IS_FLOAT128)
1805 mpfr_init2(t, FLT128_MANT_DIG);
1806 _mpfr_set_NV(aTHX_ &t, b, GMP_RNDN);
1807
1808 #elif defined(NV_IS_LONG_DOUBLE)
1809 mpfr_init2(t, REQUIRED_LDBL_MANT_DIG);
1810 mpfr_set_ld(t, (long double)SvNVX(b), GMP_RNDN);
1811 #else
1812 mpfr_init2(t, DBL_MANT_DIG);
1813 mpfr_set_d(t, (double)SvNVX(b), GMP_RNDN);
1814 #endif
1815 mpc_add_fr(*mpc_t_obj, *a, t, DEFAULT_ROUNDING_MODE);
1816 mpfr_clear(t);
1817 return obj_ref;
1818 }
1819
1820 if(sv_isobject(b)) {
1821 const char *h = HvNAME(SvSTASH(SvRV(b)));
1822 if(strEQ(h, "Math::MPC")) {
1823 mpc_add(*mpc_t_obj, *a, *(INT2PTR(mpc_t *, SvIVX(SvRV(b)))), DEFAULT_ROUNDING_MODE);
1824 return obj_ref;
1825 }
1826 }
1827
1828 croak("Invalid argument supplied to Math::MPC::overload_add");
1829 }
1830
1831 SV * overload_sub(pTHX_ mpc_t * a, SV * b, SV * third) {
1832 dMY_CXT;
1833 mpc_t * mpc_t_obj;
1834 SV * obj_ref, * obj;
1835 mpfr_t t;
1836 int ret;
1837
1838 New(1, mpc_t_obj, 1, mpc_t);
1839 if(mpc_t_obj == NULL) croak("Failed to allocate memory in overload_sub function");
1840 obj_ref = newSV(0);
1841 obj = newSVrv(obj_ref, "Math::MPC");
1842 mpc_init3(*mpc_t_obj, DEFAULT_PREC);
1843 sv_setiv(obj, INT2PTR(IV,mpc_t_obj));
1844 SvREADONLY_on(obj);
1845
1846 #ifdef MATH_MPC_NEED_LONG_LONG_INT
1847
1848 if(SV_IS_IOK(b)) {
1849 mpfr_init2(t, sizeof(IV) * CHAR_BIT);
1850
1851 #ifdef _MSC_VER
1852
1853 mpfr_set_str(t, SvPV_nolen(b), 10, GMP_RNDN);
1854 #else
1855 if(SvUOK(b)) mpfr_set_uj(t, SvUVX(b), GMP_RNDN);
1856 else mpfr_set_sj(t, SvIVX(b), GMP_RNDN);
1857 #endif
1858 if(third == &PL_sv_yes) mpc_fr_sub(*mpc_t_obj, t, *a, DEFAULT_ROUNDING_MODE);
1859 else mpc_sub_fr(*mpc_t_obj, *a, t, DEFAULT_ROUNDING_MODE);
1860 mpfr_clear(t);
1861 return obj_ref;
1862 }
1863
1864 #else
1865
1866 if(SV_IS_IOK(b)) {
1867 if(SvUOK(b)) {
1868 if(third == &PL_sv_yes) mpc_ui_sub(*mpc_t_obj, SvUVX(b), *a, DEFAULT_ROUNDING_MODE);
1869 else mpc_sub_ui(*mpc_t_obj, *a, SvUVX(b), DEFAULT_ROUNDING_MODE);
1870 return obj_ref;
1871 }
1872
1873 if(third == &PL_sv_yes) {
1874 if(SvIVX(b) >=0) {
1875 mpc_ui_sub(*mpc_t_obj, SvUVX(b), *a, DEFAULT_ROUNDING_MODE);
1876 }
1877 else {
1878 mpc_add_ui(*mpc_t_obj, *a, SvIVX(b) * -1, DEFAULT_ROUNDING_MODE);
1879 mpc_neg(*mpc_t_obj, *mpc_t_obj, DEFAULT_ROUNDING_MODE);
1880 }
1881 }
1882 else {
1883 if(SvIVX(b) >=0)
1884 mpc_sub_ui(*mpc_t_obj, *a, SvUVX(b), DEFAULT_ROUNDING_MODE);
1885 else
1886 mpc_add_ui(*mpc_t_obj, *a, SvIVX(b) * -1, DEFAULT_ROUNDING_MODE);
1887 }
1888 return obj_ref;
1889 }
1890 #endif
1891
1892 if(SV_IS_POK(b)) { /* assign with default precision */
1893
1894 NOK_POK_DUALVAR_CHECK , "Math::MPC::overload_sub");}
1895
1896 #ifdef _WIN32_BIZARRE_INFNAN
1897 ret = _win32_infnanstring(SvPV_nolen(b));
1898 if(ret) {
1899 mpfr_init(t);
1900 if(ret == 2) {
1901 mpfr_set_nan(t);
1902 mpc_set_fr(*mpc_t_obj, t, MPC_RNDNN);
1903 }
1904 else {
1905 mpfr_set_inf(t, ret);
1906 mpc_set_fr(*mpc_t_obj, t, MPC_RNDNN);
1907 }
1908 mpfr_clear(t);
1909 }
1910 else {
1911 if(mpc_set_str(*mpc_t_obj, SvPV_nolen(b), 0, DEFAULT_ROUNDING_MODE) == -1)
1912 croak("Invalid string (%s) supplied to Math::MPC::overload_sub", SvPV_nolen(b));
1913 }
1914 #else
1915 if(mpc_set_str(*mpc_t_obj, SvPV_nolen(b), 0, DEFAULT_ROUNDING_MODE) == -1)
1916 croak("Invalid string (%s) supplied to Math::MPC::overload_sub", SvPV_nolen(b));
1917 #endif
1918 if(third == &PL_sv_yes) mpc_sub(*mpc_t_obj, *mpc_t_obj, *a, DEFAULT_ROUNDING_MODE);
1919 else mpc_sub(*mpc_t_obj, *a, *mpc_t_obj, DEFAULT_ROUNDING_MODE);
1920 return obj_ref;
1921 }
1922
1923 if(SV_IS_NOK(b)) {
1924 #if defined(NV_IS_FLOAT128)
1925 mpfr_init2(t, FLT128_MANT_DIG);
1926 _mpfr_set_NV(aTHX_ &t, b, GMP_RNDN);
1927
1928 #elif defined(NV_IS_LONG_DOUBLE)
1929 mpfr_init2(t, REQUIRED_LDBL_MANT_DIG);
1930 mpfr_set_ld(t, (long double)SvNVX(b), GMP_RNDN);
1931 #else
1932 mpfr_init2(t, DBL_MANT_DIG);
1933 mpfr_set_d(t, (double)SvNVX(b), GMP_RNDN);
1934 #endif
1935 if(third == &PL_sv_yes) mpc_fr_sub(*mpc_t_obj, t, *a, DEFAULT_ROUNDING_MODE);
1936 else mpc_sub_fr(*mpc_t_obj, *a, t, DEFAULT_ROUNDING_MODE);
1937 mpfr_clear(t);
1938 return obj_ref;
1939 }
1940
1941 if(sv_isobject(b)) {
1942 const char *h = HvNAME(SvSTASH(SvRV(b)));
1943 if(strEQ(h, "Math::MPC")) {
1944 mpc_sub(*mpc_t_obj, *a, *(INT2PTR(mpc_t *, SvIVX(SvRV(b)))), DEFAULT_ROUNDING_MODE);
1945 return obj_ref;
1946 }
1947 }
1948
1949 croak("Invalid argument supplied to Math::MPC::overload_sub function");
1950 }
1951
1952 SV * overload_div(pTHX_ mpc_t * a, SV * b, SV * third) {
1953 dMY_CXT;
1954 mpc_t * mpc_t_obj;
1955 SV * obj_ref, * obj;
1956 mpfr_t t;
1957 int ret;
1958
1959
1960 New(1, mpc_t_obj, 1, mpc_t);
1961 if(mpc_t_obj == NULL) croak("Failed to allocate memory in overload_div function");
1962 obj_ref = newSV(0);
1963 obj = newSVrv(obj_ref, "Math::MPC");
1964 mpc_init3(*mpc_t_obj, DEFAULT_PREC);
1965 sv_setiv(obj, INT2PTR(IV,mpc_t_obj));
1966 SvREADONLY_on(obj);
1967
1968 #ifdef MATH_MPC_NEED_LONG_LONG_INT
1969
1970 if(SV_IS_IOK(b)) {
1971 mpfr_init2(t, sizeof(IV) * CHAR_BIT);
1972 #ifdef _MSC_VER
1973 mpfr_set_str(t, SvPV_nolen(b), 10, GMP_RNDN);
1974 #else
1975 if(SvUOK(b)) mpfr_set_uj(t, SvUVX(b), GMP_RNDN);
1976 else mpfr_set_sj(t, SvIVX(b), GMP_RNDN);
1977 #endif
1978 if(third == &PL_sv_yes) mpc_fr_div(*mpc_t_obj, t, *a, DEFAULT_ROUNDING_MODE);
1979 else mpc_div_fr(*mpc_t_obj, *a, t, DEFAULT_ROUNDING_MODE);
1980 mpfr_clear(t);
1981 return obj_ref;
1982 }
1983
1984 #else
1985
1986 if(SV_IS_IOK(b)) {
1987 if(SvUOK(b)) {
1988 if(third == &PL_sv_yes) mpc_ui_div(*mpc_t_obj, SvUVX(b), *a, DEFAULT_ROUNDING_MODE);
1989 else mpc_div_ui(*mpc_t_obj, *a, SvUVX(b), DEFAULT_ROUNDING_MODE);
1990 return obj_ref;
1991 }
1992
1993 if(third == &PL_sv_yes) {
1994 if(SvIVX(b) >=0) {
1995 mpc_ui_div(*mpc_t_obj, SvUVX(b), *a, DEFAULT_ROUNDING_MODE);
1996 }
1997 else {
1998 mpc_ui_div(*mpc_t_obj, SvIVX(b) * -1, *a, DEFAULT_ROUNDING_MODE);
1999 mpc_neg(*mpc_t_obj, *mpc_t_obj, DEFAULT_ROUNDING_MODE);
2000 }
2001 }
2002 else {
2003 if(SvIVX(b) >=0) {
2004 mpc_div_ui(*mpc_t_obj, *a, SvUVX(b), DEFAULT_ROUNDING_MODE);
2005 }
2006 else {
2007 mpc_div_ui(*mpc_t_obj, *a, SvIVX(b) * -1, DEFAULT_ROUNDING_MODE);
2008 mpc_neg(*mpc_t_obj, *mpc_t_obj, DEFAULT_ROUNDING_MODE);
2009 }
2010 }
2011 return obj_ref;
2012 }
2013 #endif
2014
2015 if(SV_IS_POK(b)) { /* assign with default precision */
2016
2017 NOK_POK_DUALVAR_CHECK , "Math::MPC::overload_div");}
2018
2019 #ifdef _WIN32_BIZARRE_INFNAN
2020 ret = _win32_infnanstring(SvPV_nolen(b));
2021 if(ret) {
2022 mpfr_init(t);
2023 if(ret == 2) {
2024 mpfr_set_nan(t);
2025 mpc_set_fr(*mpc_t_obj, t, MPC_RNDNN);
2026 }
2027 else {
2028 mpfr_set_inf(t, ret);
2029 mpc_set_fr(*mpc_t_obj, t, MPC_RNDNN);
2030 }
2031 mpfr_clear(t);
2032 }
2033 else {
2034 if(mpc_set_str(*mpc_t_obj, SvPV_nolen(b), 0, DEFAULT_ROUNDING_MODE) == -1)
2035 croak("Invalid string (%s) supplied to Math::MPC::overload_div", SvPV_nolen(b));
2036 }
2037 #else
2038 if(mpc_set_str(*mpc_t_obj, SvPV_nolen(b), 0, DEFAULT_ROUNDING_MODE) == -1)
2039 croak("Invalid string (%s) supplied to Math::MPC::overload_div", SvPV_nolen(b));
2040 #endif
2041 if(third == &PL_sv_yes) mpc_div(*mpc_t_obj, *mpc_t_obj, *a, DEFAULT_ROUNDING_MODE);
2042 else mpc_div(*mpc_t_obj, *a, *mpc_t_obj, DEFAULT_ROUNDING_MODE);
2043 return obj_ref;
2044 }
2045
2046 if(SV_IS_NOK(b)) {
2047 #if defined(NV_IS_FLOAT128)
2048 mpfr_init2(t, FLT128_MANT_DIG);
2049 _mpfr_set_NV(aTHX_ &t, b, GMP_RNDN);
2050
2051 #elif defined(NV_IS_LONG_DOUBLE)
2052 mpfr_init2(t, REQUIRED_LDBL_MANT_DIG);
2053 mpfr_set_ld(t, (long double)SvNVX(b), GMP_RNDN);
2054 #else
2055 mpfr_init2(t, DBL_MANT_DIG);
2056 mpfr_set_d(t, (double)SvNVX(b), GMP_RNDN);
2057 #endif
2058 if(third == &PL_sv_yes) mpc_fr_div(*mpc_t_obj, t, *a, DEFAULT_ROUNDING_MODE);
2059 else mpc_div_fr(*mpc_t_obj, *a, t, DEFAULT_ROUNDING_MODE);
2060 mpfr_clear(t);
2061 return obj_ref;
2062 }
2063
2064 if(sv_isobject(b)) {
2065 const char *h = HvNAME(SvSTASH(SvRV(b)));
2066 if(strEQ(h, "Math::MPC")) {
2067 mpc_div(*mpc_t_obj, *a, *(INT2PTR(mpc_t *, SvIVX(SvRV(b)))), DEFAULT_ROUNDING_MODE);
2068 return obj_ref;
2069 }
2070 }
2071
2072 croak("Invalid argument supplied to Math::MPC::overload_div function");
2073
2074 }
2075
2076
2077 SV * overload_div_eq(pTHX_ SV * a, SV * b, SV * third) {
2078 dMY_CXT;
2079 mpfr_t t;
2080 mpc_t temp;
2081 int ret;
2082
2083 SvREFCNT_inc(a);
2084
2085 #ifdef MATH_MPC_NEED_LONG_LONG_INT
2086
2087 if(SV_IS_IOK(b)) {
2088 mpfr_init2(t, sizeof(UV) * CHAR_BIT);
2089 #ifdef _MSC_VER
2090 mpfr_set_str(t, SvPV_nolen(b), 10, GMP_RNDN);
2091 #else
2092 if(SvUOK(b)) mpfr_set_uj(t, SvUVX(b), GMP_RNDN);
2093 else mpfr_set_sj(t, SvIVX(b), GMP_RNDN);
2094 #endif
2095 mpc_div_fr(*(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), *(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), t, DEFAULT_ROUNDING_MODE);
2096 mpfr_clear(t);
2097 return a;
2098 }
2099
2100 #else
2101
2102 if(SV_IS_IOK(b)) {
2103 if(SvUOK(b)) {
2104 mpc_div_ui(*(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), *(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), SvUVX(b), DEFAULT_ROUNDING_MODE);
2105 return a;
2106 }
2107
2108 if(SvIV(b) >= 0) {
2109 mpc_div_ui(*(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), *(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), SvUVX(b), DEFAULT_ROUNDING_MODE);
2110 return a;
2111 }
2112 mpc_div_ui(*(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), *(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), SvIVX(b) * -1, DEFAULT_ROUNDING_MODE);
2113 mpc_neg(*(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), *(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), DEFAULT_ROUNDING_MODE);
2114 return a;
2115 }
2116 #endif
2117
2118 if(SV_IS_POK(b)) {
2119
2120 NOK_POK_DUALVAR_CHECK , "Math::MPC::overload_div_eq");}
2121
2122 mpc_init3(temp, DEFAULT_PREC); /* cannot assign to an mpfr_t - may have an imaginary component */
2123
2124 #ifdef _WIN32_BIZARRE_INFNAN
2125 ret = _win32_infnanstring(SvPV_nolen(b));
2126 if(ret) {
2127 mpfr_init(t);
2128 if(ret == 2) {
2129 mpfr_set_nan(t);
2130 mpc_set_fr(temp, t, MPC_RNDNN);
2131 }
2132 else {
2133 mpfr_set_inf(t, ret);
2134 mpc_set_fr(temp, t, MPC_RNDNN);
2135 }
2136 mpfr_clear(t);
2137 }
2138 else {
2139 if(mpc_set_str(temp, SvPV_nolen(b), 0, DEFAULT_ROUNDING_MODE) == -1) {
2140 SvREFCNT_dec(a);
2141 croak("Invalid string (%s) supplied to Math::MPC::overload_div_eq", SvPV_nolen(b));
2142 }
2143 }
2144 #else
2145 if(mpc_set_str(temp, SvPV_nolen(b), 0, DEFAULT_ROUNDING_MODE) == -1) {
2146 SvREFCNT_dec(a);
2147 croak("Invalid string (%s) supplied to Math::MPC::overload_div_eq", SvPV_nolen(b));
2148 }
2149 #endif
2150 mpc_div(*(INT2PTR(mpc_t *, SvIV(SvRV(a)))), *(INT2PTR(mpc_t *, SvIV(SvRV(a)))), temp, DEFAULT_ROUNDING_MODE);
2151 mpc_clear(temp);
2152 return a;
2153 }
2154
2155 if(SV_IS_NOK(b)) {
2156 #if defined(NV_IS_FLOAT128)
2157 mpfr_init2(t, FLT128_MANT_DIG);
2158 _mpfr_set_NV(aTHX_ &t, b, GMP_RNDN);
2159
2160 #elif defined(NV_IS_LONG_DOUBLE)
2161 mpfr_init2(t, REQUIRED_LDBL_MANT_DIG);
2162 mpfr_set_ld(t, (long double)SvNVX(b), GMP_RNDN);
2163 #else
2164 mpfr_init2(t, DBL_MANT_DIG);
2165 mpfr_set_d(t, (double)SvNVX(b), GMP_RNDN);
2166 #endif
2167 mpc_div_fr(*(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), *(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), t, DEFAULT_ROUNDING_MODE);
2168 mpfr_clear(t);
2169 return a;
2170 }
2171
2172 if(sv_isobject(b)) {
2173 const char *h = HvNAME(SvSTASH(SvRV(b)));
2174 if(strEQ(h, "Math::MPC")) {
2175 mpc_div(*(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), *(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), *(INT2PTR(mpc_t *, SvIVX(SvRV(b)))), DEFAULT_ROUNDING_MODE);
2176 return a;
2177 }
2178 }
2179
2180 SvREFCNT_dec(a);
2181 croak("Invalid argument supplied to Math::MPC::overload_div_eq function");
2182
2183 }
2184
2185 SV * overload_sub_eq(pTHX_ SV * a, SV * b, SV * third) {
2186 dMY_CXT;
2187 mpfr_t t;
2188 mpc_t temp;
2189 int ret;
2190
2191 SvREFCNT_inc(a);
2192
2193 #ifdef MATH_MPC_NEED_LONG_LONG_INT
2194
2195 if(SV_IS_IOK(b)) {
2196 mpfr_init2(t, sizeof(IV) * CHAR_BIT);
2197 #ifdef _MSC_VER
2198 mpfr_set_str(t, SvPV_nolen(b), 10, GMP_RNDN);
2199 #else
2200 if(SvUOK(b)) mpfr_set_uj(t, SvUVX(b), GMP_RNDN);
2201 else mpfr_set_sj(t, SvIVX(b), GMP_RNDN);
2202 #endif
2203 mpc_sub_fr(*(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), *(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), t, DEFAULT_ROUNDING_MODE);
2204 mpfr_clear(t);
2205 return a;
2206 }
2207
2208 #else
2209
2210 if(SV_IS_IOK(b)) {
2211 if(SvUOK(b)) {
2212 mpc_sub_ui(*(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), *(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), SvUVX(b), DEFAULT_ROUNDING_MODE);
2213 return a;
2214 }
2215
2216 if(SvIV(b) >= 0) {
2217 mpc_sub_ui(*(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), *(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), SvUVX(b), DEFAULT_ROUNDING_MODE);
2218 return a;
2219 }
2220 mpc_add_ui(*(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), *(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), SvIVX(b) * -1, DEFAULT_ROUNDING_MODE);
2221 return a;
2222 }
2223 #endif
2224
2225 if(SV_IS_POK(b)) {
2226
2227 NOK_POK_DUALVAR_CHECK , "Math::MPC::overload_sub_eq");}
2228
2229 mpc_init3(temp, DEFAULT_PREC); /* cannot assign to an mpfr_t - may have an imaginary component */
2230
2231 #ifdef _WIN32_BIZARRE_INFNAN
2232 ret = _win32_infnanstring(SvPV_nolen(b));
2233 if(ret) {
2234 mpfr_init(t);
2235 if(ret == 2) {
2236 mpfr_set_nan(t);
2237 mpc_set_fr(temp, t, MPC_RNDNN);
2238 }
2239 else {
2240 mpfr_set_inf(t, ret);
2241 mpc_set_fr(temp, t, MPC_RNDNN);
2242 }
2243 mpfr_clear(t);
2244 }
2245 else {
2246 if(mpc_set_str(temp, SvPV_nolen(b), 0, DEFAULT_ROUNDING_MODE) == -1) {
2247 SvREFCNT_dec(a);
2248 croak("Invalid string (%s) supplied to Math::MPC::overload_sub_eq", SvPV_nolen(b));
2249 }
2250 }
2251 #else
2252
2253 if(mpc_set_str(temp, SvPV_nolen(b), 0, DEFAULT_ROUNDING_MODE) == -1) {
2254 SvREFCNT_dec(a);
2255 croak("Invalid string (%s) supplied to Math::MPC::overload_sub_eq", SvPV_nolen(b));
2256 }
2257 #endif
2258 mpc_sub(*(INT2PTR(mpc_t *, SvIV(SvRV(a)))), *(INT2PTR(mpc_t *, SvIV(SvRV(a)))), temp, DEFAULT_ROUNDING_MODE);
2259 mpc_clear(temp);
2260 return a;
2261 }
2262
2263 if(SV_IS_NOK(b)) {
2264 #if defined(NV_IS_FLOAT128)
2265 mpfr_init2(t, FLT128_MANT_DIG);
2266 _mpfr_set_NV(aTHX_ &t, b, GMP_RNDN);
2267
2268 #elif defined(NV_IS_LONG_DOUBLE)
2269 mpfr_init2(t, REQUIRED_LDBL_MANT_DIG);
2270 mpfr_set_ld(t, (long double)SvNVX(b), GMP_RNDN);
2271 #else
2272 mpfr_init2(t, DBL_MANT_DIG);
2273 mpfr_set_d(t, (double)SvNVX(b), GMP_RNDN);
2274 #endif
2275 mpc_sub_fr(*(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), *(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), t, DEFAULT_ROUNDING_MODE);
2276 mpfr_clear(t);
2277 return a;
2278 }
2279
2280 if(sv_isobject(b)) {
2281 const char *h = HvNAME(SvSTASH(SvRV(b)));
2282 if(strEQ(h, "Math::MPC")) {
2283 mpc_sub(*(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), *(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), *(INT2PTR(mpc_t *, SvIVX(SvRV(b)))), DEFAULT_ROUNDING_MODE);
2284 return a;
2285 }
2286 }
2287
2288 SvREFCNT_dec(a);
2289 croak("Invalid argument supplied to Math::MPC::overload_sub_eq function");
2290
2291 }
2292
2293 SV * overload_add_eq(pTHX_ SV * a, SV * b, SV * third) {
2294 dMY_CXT;
2295 SvREFCNT_inc(a);
2296 mpfr_t t;
2297 mpc_t temp;
2298 int ret;
2299
2300 #ifdef MATH_MPC_NEED_LONG_LONG_INT
2301 if(SV_IS_IOK(b)) {
2302 mpfr_init2(t, sizeof(UV) * CHAR_BIT);
2303 #ifdef _MSC_VER
2304 mpfr_set_str(t, SvPV_nolen(b), 10, GMP_RNDN);
2305 #else
2306 if(SvUOK(b)) mpfr_set_uj(t, SvUV(b), GMP_RNDN);
2307 else mpfr_set_sj(t, SvIV(b), GMP_RNDN);
2308 #endif
2309 mpc_add_fr(*(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), *(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), t, DEFAULT_ROUNDING_MODE);
2310 mpfr_clear(t);
2311 return a;
2312 }
2313
2314 #else
2315
2316 if(SV_IS_IOK(b)) {
2317 if(SvUOK(b)) {
2318 mpc_add_ui(*(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), *(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), SvUVX(b), DEFAULT_ROUNDING_MODE);
2319 return a;
2320 }
2321
2322
2323 if(SvIV(b) >= 0) {
2324 mpc_add_ui(*(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), *(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), SvUVX(b), DEFAULT_ROUNDING_MODE);
2325 return a;
2326 }
2327 mpc_sub_ui(*(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), *(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), SvIVX(b) * -1, DEFAULT_ROUNDING_MODE);
2328 return a;
2329 }
2330 #endif
2331
2332 if(SV_IS_POK(b)) {
2333
2334 NOK_POK_DUALVAR_CHECK , "Math::MPC::overload_add_eq");}
2335
2336 mpc_init3(temp, DEFAULT_PREC); /* cannot assign to an mpfr_t - may contain an imaginary part */
2337
2338 #ifdef _WIN32_BIZARRE_INFNAN
2339 ret = _win32_infnanstring(SvPV_nolen(b));
2340 if(ret) {
2341 mpfr_init(t);
2342 if(ret == 2) {
2343 mpfr_set_nan(t);
2344 mpc_set_fr(temp, t, MPC_RNDNN);
2345 }
2346 else {
2347 mpfr_set_inf(t, ret);
2348 mpc_set_fr(temp, t, MPC_RNDNN);
2349 }
2350 mpfr_clear(t);
2351 }
2352 else {
2353 if(mpc_set_str(temp, SvPV_nolen(b), 0, DEFAULT_ROUNDING_MODE) == -1) {
2354 SvREFCNT_dec(a);
2355 croak("Invalid string (1: %s) supplied to Math::MPC::overload_add_eq", SvPV_nolen(b));
2356 }
2357 }
2358 #else
2359 if(mpc_set_str(temp, SvPV_nolen(b), 0, DEFAULT_ROUNDING_MODE) == -1) {
2360 SvREFCNT_dec(a);
2361 croak("Invalid string (2: %s) supplied to Math::MPC::overload_add_eq", SvPV_nolen(b));
2362 }
2363 #endif
2364 mpc_add(*(INT2PTR(mpc_t *, SvIV(SvRV(a)))), *(INT2PTR(mpc_t *, SvIV(SvRV(a)))), temp, DEFAULT_ROUNDING_MODE);
2365 mpc_clear(temp);
2366 return a;
2367 }
2368
2369 if(SV_IS_NOK(b)) {
2370 #if defined(NV_IS_FLOAT128)
2371 mpfr_init2(t, FLT128_MANT_DIG);
2372 _mpfr_set_NV(aTHX_ &t, b, GMP_RNDN);
2373
2374 #elif defined(NV_IS_LONG_DOUBLE)
2375 mpfr_init2(t, REQUIRED_LDBL_MANT_DIG);
2376 mpfr_set_ld(t, (long double)SvNVX(b), GMP_RNDN);
2377 #else
2378 mpfr_init2(t, DBL_MANT_DIG);
2379 mpfr_set_d(t, (double)SvNVX(b), GMP_RNDN);
2380 #endif
2381 mpc_add_fr(*(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), *(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), t, DEFAULT_ROUNDING_MODE);
2382 mpfr_clear(t);
2383 return a;
2384 }
2385
2386 if(sv_isobject(b)) {
2387 const char *h = HvNAME(SvSTASH(SvRV(b)));
2388 if(strEQ(h, "Math::MPC")) {
2389 mpc_add(*(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), *(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), *(INT2PTR(mpc_t *, SvIVX(SvRV(b)))), DEFAULT_ROUNDING_MODE);
2390 return a;
2391 }
2392 }
2393
2394 SvREFCNT_dec(a);
2395 croak("Invalid argument supplied to Math::MPC::overload_add_eq");
2396 }
2397
2398 SV * overload_mul_eq(pTHX_ SV * a, SV * b, SV * third) {
2399 dMY_CXT;
2400 mpfr_t t;
2401 mpc_t temp;
2402 int ret;
2403
2404 SvREFCNT_inc(a);
2405
2406 #ifdef MATH_MPC_NEED_LONG_LONG_INT
2407
2408 if(SV_IS_IOK(b)) {
2409 mpfr_init2(t, sizeof(IV) * CHAR_BIT);
2410
2411 #ifdef _MSC_VER
2412 mpfr_set_str(t, SvPV_nolen(b), 10, GMP_RNDN);
2413 #else
2414 if(SvUOK(b)) mpfr_set_uj(t, SvUVX(b), GMP_RNDN);
2415 else mpfr_set_sj(t, SvIVX(b), GMP_RNDN);
2416 #endif
2417 mpc_mul_fr(*(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), *(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), t, DEFAULT_ROUNDING_MODE);
2418 mpfr_clear(t);
2419 return a;
2420 }
2421
2422 #else
2423
2424 if(SV_IS_IOK(b)) {
2425 if(SvUOK(b)) {
2426 mpc_mul_ui(*(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), *(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), SvUVX(b), DEFAULT_ROUNDING_MODE);
2427 return a;
2428 }
2429
2430 mpc_mul_si(*(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), *(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), SvIVX(b), DEFAULT_ROUNDING_MODE);
2431 return a;
2432 }
2433
2434 #endif
2435
2436 if(SV_IS_POK(b)) {
2437
2438 NOK_POK_DUALVAR_CHECK , "Math::MPC::overload_mul_eq");}
2439
2440 mpc_init3(temp, DEFAULT_PREC); /* cannot assign to an mpfr_t - may contain an imaginary part */
2441
2442 #ifdef _WIN32_BIZARRE_INFNAN
2443 ret = _win32_infnanstring(SvPV_nolen(b));
2444 if(ret) {
2445 mpfr_init(t);
2446 if(ret == 2) {
2447 mpfr_set_nan(t);
2448 mpc_set_fr(temp, t, MPC_RNDNN);
2449 }
2450 else {
2451 mpfr_set_inf(t, ret);
2452 mpc_set_fr(temp, t, MPC_RNDNN);
2453 }
2454 mpfr_clear(t);
2455 }
2456 else {
2457 if(mpc_set_str(temp, SvPV_nolen(b), 0, DEFAULT_ROUNDING_MODE) == -1) {
2458 SvREFCNT_dec(a);
2459 croak("Invalid string (%s) supplied to Math::MPC::overload_mul_eq", SvPV_nolen(b));
2460 }
2461 }
2462 #else
2463 if(mpc_set_str(temp, SvPV_nolen(b), 0, DEFAULT_ROUNDING_MODE) == -1) {
2464 SvREFCNT_dec(a);
2465 croak("Invalid string (%s) supplied to Math::MPC::overload_mul_eq", SvPV_nolen(b));
2466 }
2467 #endif
2468 mpc_mul(*(INT2PTR(mpc_t *, SvIV(SvRV(a)))), *(INT2PTR(mpc_t *, SvIV(SvRV(a)))), temp, DEFAULT_ROUNDING_MODE);
2469 mpc_clear(temp);
2470 return a;
2471 }
2472
2473 if(SV_IS_NOK(b)) {
2474 #if defined(NV_IS_FLOAT128)
2475 mpfr_init2(t, FLT128_MANT_DIG);
2476 _mpfr_set_NV(aTHX_ &t, b, GMP_RNDN);
2477
2478 #elif defined(NV_IS_LONG_DOUBLE)
2479 mpfr_init2(t, REQUIRED_LDBL_MANT_DIG);
2480 mpfr_set_ld(t, (long double)SvNVX(b), GMP_RNDN);
2481 #else
2482 mpfr_init2(t, DBL_MANT_DIG);
2483 mpfr_set_d(t, (double)SvNVX(b), GMP_RNDN);
2484 #endif
2485 mpc_mul_fr(*(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), *(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), t, DEFAULT_ROUNDING_MODE);
2486 mpfr_clear(t);
2487 return a;
2488 }
2489
2490 if(sv_isobject(b)) {
2491 const char *h = HvNAME(SvSTASH(SvRV(b)));
2492 if(strEQ(h, "Math::MPC")) {
2493 mpc_mul(*(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), *(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), *(INT2PTR(mpc_t *, SvIVX(SvRV(b)))), DEFAULT_ROUNDING_MODE);
2494 return a;
2495 }
2496 }
2497
2498 SvREFCNT_dec(a);
2499 croak("Invalid argument supplied to Math::MPC::overload_mul_eq");
2500 }
2501
2502 SV * overload_pow(pTHX_ mpc_t * a, SV * b, SV * third) {
2503 dMY_CXT;
2504 mpc_t * mpc_t_obj, t;
2505 SV * obj_ref, * obj;
2506 mpfr_t temp;
2507 int ret;
2508
2509 New(1, mpc_t_obj, 1, mpc_t);
2510 if(mpc_t_obj == NULL) croak("Failed to allocate memory in overload_pow function");
2511 obj_ref = newSV(0);
2512 obj = newSVrv(obj_ref, "Math::MPC");
2513 mpc_init3(*mpc_t_obj, DEFAULT_PREC);
2514 sv_setiv(obj, INT2PTR(IV,mpc_t_obj));
2515 SvREADONLY_on(obj);
2516
2517 #ifdef MATH_MPC_NEED_LONG_LONG_INT
2518
2519 if(SV_IS_IOK(b)) {
2520 mpc_init2(t, sizeof(UV) * CHAR_BIT);
2521 #ifdef _MSC_VER
2522 mpc_set_str(t, SvPV_nolen(b), 10, MPC_RNDNN);
2523 #else
2524 if(SvUOK(b)) mpc_set_uj(t, SvUVX(b), MPC_RNDNN);
2525 else mpc_set_sj(t, SvIV(b), MPC_RNDNN);
2526 #endif
2527 if(third == &PL_sv_yes)
2528 mpc_pow(*mpc_t_obj, t, *a, DEFAULT_ROUNDING_MODE);
2529 else
2530 mpc_pow(*mpc_t_obj, *a, t, DEFAULT_ROUNDING_MODE);
2531 mpc_clear(t);
2532 return obj_ref;
2533 }
2534
2535 #else
2536
2537 if(SV_IS_IOK(b)) {
2538 if(SvUOK(b)) {
2539 mpc_init2(t, sizeof(UV) * CHAR_BIT);
2540 mpc_set_ui(t, SvUVX(b), MPC_RNDNN);
2541 if(third == &PL_sv_yes)
2542 mpc_pow(*mpc_t_obj, t, *a, DEFAULT_ROUNDING_MODE);
2543 else
2544 mpc_pow(*mpc_t_obj, *a, t, DEFAULT_ROUNDING_MODE);
2545 mpc_clear(t);
2546 return obj_ref;
2547 }
2548
2549 mpc_init2(t, sizeof(IV) * CHAR_BIT);
2550 mpc_set_si(t, SvIVX(b), MPC_RNDNN);
2551 if(third == &PL_sv_yes)
2552 mpc_pow(*mpc_t_obj, t, *a, DEFAULT_ROUNDING_MODE);
2553 else
2554 mpc_pow(*mpc_t_obj, *a, t, DEFAULT_ROUNDING_MODE);
2555 mpc_clear(t);
2556 return obj_ref;
2557 }
2558 #endif
2559
2560 if(SV_IS_POK(b)) {
2561
2562 NOK_POK_DUALVAR_CHECK , "Math::MPC::overload_pow");}
2563
2564 #ifdef _WIN32_BIZARRE_INFNAN
2565 ret = _win32_infnanstring(SvPV_nolen(b));
2566 if(ret) {
2567 mpfr_init(temp);
2568 if(ret == 2) {
2569 mpfr_set_nan(temp);
2570 mpc_set_fr(*mpc_t_obj, temp, MPC_RNDNN);
2571 }
2572 else {
2573 mpfr_set_inf(temp, ret);
2574 mpc_set_fr(*mpc_t_obj, temp, MPC_RNDNN);
2575 }
2576 mpfr_clear(temp);
2577 }
2578 else {
2579 if(mpc_set_str(*mpc_t_obj, SvPV_nolen(b), 0, DEFAULT_ROUNDING_MODE) == -1)
2580 croak("Invalid string (%s) supplied to Math::MPC::overload_pow", SvPV_nolen(b));
2581 }
2582 #else
2583 if(mpc_set_str(*mpc_t_obj, SvPV_nolen(b), 0, DEFAULT_ROUNDING_MODE) == -1)
2584 croak("Invalid string (%s) supplied to Math::MPC::overload_pow", SvPV_nolen(b));
2585 #endif
2586 if(third == &PL_sv_yes)
2587 mpc_pow(*mpc_t_obj, *mpc_t_obj, *a, DEFAULT_ROUNDING_MODE);
2588 else
2589 mpc_pow(*mpc_t_obj, *a, *mpc_t_obj, DEFAULT_ROUNDING_MODE);
2590 return obj_ref;
2591 }
2592
2593 if(SV_IS_NOK(b)) {
2594 #if defined(NV_IS_FLOAT128)
2595 mpc_init2(t, FLT128_MANT_DIG);
2596 Rmpc_set_NV(aTHX_ &t, b, MPC_RNDNN);
2597
2598 #elif defined(NV_IS_LONG_DOUBLE)
2599 mpc_init2(t, REQUIRED_LDBL_MANT_DIG);
2600 mpc_set_ld(t, (long double)SvNVX(b), MPC_RNDNN);
2601 #else
2602 mpc_init2(t, DBL_MANT_DIG);
2603 mpc_set_d(t, (double)SvNVX(b), MPC_RNDNN);
2604 #endif
2605 if(third == &PL_sv_yes)
2606 mpc_pow(*mpc_t_obj, t, *a, DEFAULT_ROUNDING_MODE);
2607 else
2608 mpc_pow(*mpc_t_obj, *a, t, DEFAULT_ROUNDING_MODE);
2609 mpc_clear(t);
2610 return obj_ref;
2611 }
2612
2613 if(sv_isobject(b)) {
2614 const char *h = HvNAME(SvSTASH(SvRV(b)));
2615 if(strEQ(h, "Math::MPC")) {
2616 mpc_pow(*mpc_t_obj, *a, *(INT2PTR(mpc_t *, SvIVX(SvRV(b)))), DEFAULT_ROUNDING_MODE);
2617 return obj_ref;
2618 }
2619 }
2620
2621 croak("Invalid argument supplied to Math::MPC::overload_pow");
2622 }
2623
2624 SV * overload_pow_eq(pTHX_ SV * a, SV * b, SV * third) {
2625 dMY_CXT;
2626 mpfr_t t;
2627 mpc_t temp;
2628 int ret;
2629
2630
2631 SvREFCNT_inc(a);
2632
2633 #ifdef MATH_MPC_NEED_LONG_LONG_INT
2634
2635 if(SV_IS_IOK(b)) {
2636 mpfr_init2(t, sizeof(IV) * CHAR_BIT);
2637 #ifdef _MSC_VER
2638 mpfr_set_str(t, SvPV_nolen(b), 10, GMP_RNDN);
2639 #else
2640 if(SvUOK(b)) mpfr_set_uj(t, SvUVX(b), GMP_RNDN);
2641 else mpfr_set_sj(t, SvIVX(b), GMP_RNDN);
2642 #endif
2643 mpc_pow_fr(*(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), *(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), t, DEFAULT_ROUNDING_MODE);
2644 mpfr_clear(t);
2645 return a;
2646 }
2647
2648 #else
2649
2650 if(SV_IS_IOK(b)) {
2651 if(SvUOK(b)) {
2652 mpc_pow_ui(*(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), *(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), SvUVX(b), DEFAULT_ROUNDING_MODE);
2653 return a;
2654 }
2655
2656 mpc_pow_si(*(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), *(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), SvIVX(b), DEFAULT_ROUNDING_MODE);
2657 return a;
2658 }
2659
2660 #endif
2661
2662 if(SV_IS_POK(b)) {
2663
2664 NOK_POK_DUALVAR_CHECK , "Math::MPC::overload_pow_eq");}
2665
2666 mpc_init3(temp, DEFAULT_PREC); /* cannot assign to an mpfr_t - may contain an imaginary part */
2667
2668 #ifdef _WIN32_BIZARRE_INFNAN
2669 ret = _win32_infnanstring(SvPV_nolen(b));
2670 if(ret) {
2671 mpfr_init(t);
2672 if(ret == 2) {
2673 mpfr_set_nan(t);
2674 mpc_set_fr(temp, t, MPC_RNDNN);
2675 }
2676 else {
2677 mpfr_set_inf(t, ret);
2678 mpc_set_fr(temp, t, MPC_RNDNN);
2679 }
2680 mpfr_clear(t);
2681 }
2682 else {
2683 if(mpc_set_str(temp, SvPV_nolen(b), 0, DEFAULT_ROUNDING_MODE) == -1) {
2684 SvREFCNT_dec(a);
2685 croak("Invalid string (%s) supplied to Math::MPC::overload_mul_eq", SvPV_nolen(b));
2686 }
2687 }
2688 #else
2689 if(mpc_set_str(temp, SvPV_nolen(b), 0, DEFAULT_ROUNDING_MODE) == -1) {
2690 SvREFCNT_dec(a);
2691 croak("Invalid string (%s) supplied to Math::MPC::overload_pow_eq", SvPV_nolen(b));
2692 }
2693 #endif
2694 mpc_pow(*(INT2PTR(mpc_t *, SvIV(SvRV(a)))), *(INT2PTR(mpc_t *, SvIV(SvRV(a)))), temp, DEFAULT_ROUNDING_MODE);
2695 mpc_clear(temp);
2696 return a;
2697 }
2698
2699 if(SV_IS_NOK(b)) {
2700 #if defined(NV_IS_FLOAT128)
2701 mpfr_init2(t, FLT128_MANT_DIG);
2702 _mpfr_set_NV(aTHX_ &t, b, GMP_RNDN);
2703
2704 #elif defined(NV_IS_LONG_DOUBLE)
2705 mpfr_init2(t, REQUIRED_LDBL_MANT_DIG);
2706 mpfr_set_ld(t, (long double)SvNVX(b), GMP_RNDN);
2707 #else
2708 mpfr_init2(t, DBL_MANT_DIG);
2709 mpfr_set_d(t, (double)SvNVX(b), GMP_RNDN);
2710 #endif
2711 mpc_pow_fr(*(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), *(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), t, DEFAULT_ROUNDING_MODE);
2712 mpfr_clear(t);
2713 return a;
2714 }
2715
2716 if(sv_isobject(b)) {
2717 const char *h = HvNAME(SvSTASH(SvRV(b)));
2718 if(strEQ(h, "Math::MPC")) {
2719 mpc_pow(*(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), *(INT2PTR(mpc_t *, SvIVX(SvRV(a)))), *(INT2PTR(mpc_t *, SvIVX(SvRV(b)))), DEFAULT_ROUNDING_MODE);
2720 return a;
2721 }
2722 }
2723
2724 SvREFCNT_dec(a);
2725 croak("Invalid argument supplied to Math::MPC::overload_pow_eq");
2726 }
2727
2728 SV * overload_equiv(pTHX_ mpc_t * a, SV * b, SV * third) {
2729 dMY_CXT;
2730 mpfr_t temp;
2731 mpc_t t;
2732 int ret;
2733
2734 if(mpfr_nan_p(MPC_RE(*a)) || mpfr_nan_p(MPC_IM(*a))) return newSViv(0);
2735
2736 #ifdef MATH_MPC_NEED_LONG_LONG_INT
2737
2738 if(SV_IS_IOK(b)) {
2739 mpc_init2(t, sizeof(IV) * CHAR_BIT);
2740 #ifdef _MSC_VER
2741 mpc_set_str(t, SvPV_nolen(b), 10, MPC_RNDNN);
2742 #else
2743 if(SvUOK(b)) mpc_set_uj(t, SvUVX(b), MPC_RNDNN);
2744 else mpc_set_sj(t, SvIVX(b), MPC_RNDNN);
2745 #endif
2746 ret = mpc_cmp(*a, t);
2747 mpc_clear(t);
2748 if(ret == 0) return newSViv(1);
2749 return newSViv(0);
2750 }
2751
2752 #else
2753
2754 if(SV_IS_IOK(b)) {
2755 if(SvUOK(b)) {
2756 mpc_init2(t, sizeof(UV) * CHAR_BIT);
2757 mpc_set_ui(t, SvUVX(b), MPC_RNDNN);
2758 ret = mpc_cmp(*a, t);
2759 mpc_clear(t);
2760 if(ret == 0) return newSViv(1);
2761 return newSViv(0);
2762 }
2763
2764 ret = mpc_cmp_si(*a, SvIVX(b));
2765 if(ret == 0) return newSViv(1);
2766 return newSViv(0);
2767 }
2768 #endif
2769
2770 if(SV_IS_POK(b)) {
2771
2772 NOK_POK_DUALVAR_CHECK , "Math::MPC::overload_equiv");}
2773
2774 #ifdef _WIN32_BIZARRE_INFNAN
2775 ret = _win32_infnanstring(SvPV_nolen(b));
2776 if(ret) {
2777 if(ret == 2) return newSViv(0);
2778 else {
2779 mpc_init3(t, DEFAULT_PREC);
2780 mpfr_init(temp);
2781 mpfr_set_inf(temp, ret);
2782 mpc_set_fr(t, temp, MPC_RNDNN);
2783 mpfr_clear(temp);
2784 }
2785 }
2786 else {
2787 mpc_init3(t, DEFAULT_PREC);
2788 if(mpc_set_str(t, (char *)SvPV_nolen(b), 0, DEFAULT_ROUNDING_MODE) == -1)
2789 croak("Invalid string (%s) supplied to Math::MPC::overload_equiv", SvPV_nolen(b));
2790 }
2791 #else
2792 mpc_init3(t, DEFAULT_PREC);
2793 if(mpc_set_str(t, (char *)SvPV_nolen(b), 0, DEFAULT_ROUNDING_MODE) == -1)
2794 croak("Invalid string (%s) supplied to Math::MPC::overload_equiv", SvPV_nolen(b));
2795 #endif
2796 if(mpfr_nan_p(MPC_RE(t)) || mpfr_nan_p(MPC_IM(t))) {
2797 mpc_clear(t);
2798 return newSViv(0);
2799 }
2800 ret = mpc_cmp(*a, t);
2801 mpc_clear(t);
2802 if(ret == 0) return newSViv(1);
2803 return newSViv(0);
2804 }
2805
2806 if(SV_IS_NOK(b)) {
2807 #if defined(NV_IS_FLOAT128)
2808 mpc_init2(t, FLT128_MANT_DIG);
2809 Rmpc_set_NV(aTHX_ &t, b, MPC_RNDNN);
2810
2811 #elif defined(NV_IS_LONG_DOUBLE)
2812 mpc_init2(t, REQUIRED_LDBL_MANT_DIG);
2813 mpc_set_ld(t, (long double)SvNVX(b), MPC_RNDNN);
2814 #else
2815 mpc_init2(t, DBL_MANT_DIG);
2816 mpc_set_d(t, (double)SvNVX(b), MPC_RNDNN);
2817 #endif
2818 if(mpfr_nan_p(MPC_RE(t)) || mpfr_nan_p(MPC_IM(t))) {
2819 mpc_clear(t);
2820 return newSViv(0);
2821 }
2822 ret = mpc_cmp(*a, t);
2823 mpc_clear(t);
2824 if(ret == 0) return newSViv(1);
2825 return newSViv(0);
2826 }
2827
2828 if(sv_isobject(b)) {
2829 const char *h = HvNAME(SvSTASH(SvRV(b)));
2830 if(strEQ(h, "Math::MPC")) {
2831 if(mpfr_nan_p(MPC_RE(*(INT2PTR(mpc_t *, SvIVX(SvRV(b)))))) ||
2832 mpfr_nan_p(MPC_IM(*(INT2PTR(mpc_t *, SvIVX(SvRV(b))))))) return newSViv(0);
2833 ret = mpc_cmp(*a, *(INT2PTR(mpc_t *, SvIVX(SvRV(b)))));
2834 if(ret == 0) return newSViv(1);
2835 return newSViv(0);
2836 }
2837 }
2838
2839 croak("Invalid argument supplied to Math::MPC::overload_equiv");
2840 }
2841
2842 SV * overload_not(pTHX_ mpc_t * a, SV * second, SV * third) {
2843 if(mpfr_nan_p(MPC_RE(*a)) || mpfr_nan_p(MPC_IM(*a))) return newSViv(1); /* Thanks Jean-Louis Morel */
2844 if(mpc_cmp_si_si(*a, 0, 0)) return newSViv(0);
2845 return newSViv(1);
2846 }
2847
2848 SV * overload_sqrt(pTHX_ mpc_t * p, SV * second, SV * third) {
2849 dMY_CXT;
2850 mpc_t * mpc_t_obj;
2851 SV * obj_ref, * obj;
2852
2853 New(1, mpc_t_obj, 1, mpc_t);
2854 if(mpc_t_obj == NULL) croak("Failed to allocate memory in overload_sqrt function");
2855 obj_ref = newSV(0);
2856 obj = newSVrv(obj_ref, "Math::MPC");
2857 mpc_init3(*mpc_t_obj, DEFAULT_PREC);
2858
2859 mpc_sqrt(*mpc_t_obj, *p, DEFAULT_ROUNDING_MODE);
2860 sv_setiv(obj, INT2PTR(IV,mpc_t_obj));
2861 SvREADONLY_on(obj);
2862 return obj_ref;
2863 }
2864
2865 void overload_copy(pTHX_ mpc_t * p, SV * second, SV * third) {
2866 dXSARGS;
2867 dMY_CXT;
2868 mpc_t * mpc_t_obj;
2869 SV * obj_ref, * obj;
2870 mp_prec_t re, im;
2871
2872 New(1, mpc_t_obj, 1, mpc_t);
2873 if(mpc_t_obj == NULL) croak("Failed to allocate memory in overload_copy function");
2874 obj_ref = newSV(0);
2875 obj = newSVrv(obj_ref, "Math::MPC");
2876
2877 mpc_get_prec2(&re, &im, *p);
2878 mpc_init3(*mpc_t_obj, re, im);
2879 mpc_set(*mpc_t_obj, *p, DEFAULT_ROUNDING_MODE);
2880 sv_setiv(obj, INT2PTR(IV,mpc_t_obj));
2881 SvREADONLY_on(obj);
2882 ST(0) = sv_2mortal(obj_ref);
2883 /* PUTBACK; *//* not needed */
2884 XSRETURN(1);
2885 }
2886
2887 SV * overload_abs(pTHX_ mpc_t * p, SV * second, SV * third) {
2888 dMY_CXT;
2889 mpfr_t * mpfr_t_obj;
2890 SV * obj_ref, * obj;
2891
2892 New(1, mpfr_t_obj, 1, mpfr_t);
2893 if(mpfr_t_obj == NULL) croak("Failed to allocate memory in overload_abs function");
2894 obj_ref = newSV(0);
2895 obj = newSVrv(obj_ref, "Math::MPFR");
2896 mpfr_init(*mpfr_t_obj);
2897
2898 mpc_abs(*mpfr_t_obj, *p, DEFAULT_ROUNDING_MODE);
2899 sv_setiv(obj, INT2PTR(IV,mpfr_t_obj));
2900 SvREADONLY_on(obj);
2901 return obj_ref;
2902 }
2903
2904 SV * overload_exp(pTHX_ mpc_t * p, SV * second, SV * third) {
2905 dMY_CXT;
2906 mpc_t * mpc_t_obj;
2907 SV * obj_ref, * obj;
2908
2909 New(1, mpc_t_obj, 1, mpc_t);
2910 if(mpc_t_obj == NULL) croak("Failed to allocate memory in overload_exp function");
2911 obj_ref = newSV(0);
2912 obj = newSVrv(obj_ref, "Math::MPC");
2913 mpc_init3(*mpc_t_obj, DEFAULT_PREC);
2914
2915 mpc_exp(*mpc_t_obj, *p, DEFAULT_ROUNDING_MODE);
2916 sv_setiv(obj, INT2PTR(IV,mpc_t_obj));
2917 SvREADONLY_on(obj);
2918 return obj_ref;
2919 }
2920
2921 SV * overload_log(pTHX_ mpc_t * p, SV * second, SV * third) {
2922 dMY_CXT;
2923 mpc_t * mpc_t_obj;
2924 SV * obj_ref, * obj;
2925
2926 New(1, mpc_t_obj, 1, mpc_t);
2927 if(mpc_t_obj == NULL) croak("Failed to allocate memory in overload_exp function");
2928 obj_ref = newSV(0);
2929 obj = newSVrv(obj_ref, "Math::MPC");
2930 mpc_init3(*mpc_t_obj, DEFAULT_PREC);
2931
2932 mpc_log(*mpc_t_obj, *p, DEFAULT_ROUNDING_MODE);
2933 sv_setiv(obj, INT2PTR(IV,mpc_t_obj));
2934 SvREADONLY_on(obj);
2935 return obj_ref;
2936 }
2937
2938 SV * overload_sin(pTHX_ mpc_t * p, SV * second, SV * third) {
2939 dMY_CXT;
2940 mpc_t * mpc_t_obj;
2941 SV * obj_ref, * obj;
2942
2943 New(1, mpc_t_obj, 1, mpc_t);
2944 if(mpc_t_obj == NULL) croak("Failed to allocate memory in overload_sin function");
2945 obj_ref = newSV(0);
2946 obj = newSVrv(obj_ref, "Math::MPC");
2947 mpc_init3(*mpc_t_obj, DEFAULT_PREC);
2948
2949 mpc_sin(*mpc_t_obj, *p, DEFAULT_ROUNDING_MODE);
2950 sv_setiv(obj, INT2PTR(IV,mpc_t_obj));
2951 SvREADONLY_on(obj);
2952 return obj_ref;
2953 }
2954
2955 SV * overload_cos(pTHX_ mpc_t * p, SV * second, SV * third) {
2956 dMY_CXT;
2957 mpc_t * mpc_t_obj;
2958 SV * obj_ref, * obj;
2959
2960 New(1, mpc_t_obj, 1, mpc_t);
2961 if(mpc_t_obj == NULL) croak("Failed to allocate memory in overload_sin function");
2962 obj_ref = newSV(0);
2963 obj = newSVrv(obj_ref, "Math::MPC");
2964 mpc_init3(*mpc_t_obj, DEFAULT_PREC);
2965
2966 mpc_cos(*mpc_t_obj, *p, DEFAULT_ROUNDING_MODE);
2967 sv_setiv(obj, INT2PTR(IV,mpc_t_obj));
2968 SvREADONLY_on(obj);
2969 return obj_ref;
2970 }
2971
2972 void _get_r_string(pTHX_ mpc_t * p, SV * base, SV * n_digits, SV * round) {
2973 dXSARGS;
2974 char * out;
2975 mp_exp_t ptr;
2976 unsigned long b = SvUV(base);
2977
2978 if(b < 2 || b > 36) croak("Second argument supplied to r_string is not in acceptable range");
2979
2980 out = mpfr_get_str(0, &ptr, b, SvUV(n_digits), MPC_RE(*p), (mpc_rnd_t)SvUV(round) & 3);
2981
2982 if(out == NULL) croak("An error occurred in _get_r_string");
2983
2984 /* sp = mark; *//* not needed */
2985 ST(0) = sv_2mortal(newSVpv(out, 0));
2986 mpfr_free_str(out);
2987 ST(1) = sv_2mortal(newSViv(ptr));
2988 /* PUTBACK; *//* not needed */
2989 XSRETURN(2);
2990 }
2991
2992 void _get_i_string(pTHX_ mpc_t * p, SV * base, SV * n_digits, SV * round) {
2993 dXSARGS;
2994 char * out;
2995 mp_exp_t ptr;
2996 unsigned long b = SvUV(base);
2997
2998 if(b < 2 || b > 36) croak("Second argument supplied to i_string is not in acceptable range");
2999
3000 out = mpfr_get_str(0, &ptr, b, SvUV(n_digits), MPC_IM(*p), (mpc_rnd_t)SvUV(round) & 3);
3001
3002 if(out == NULL) croak("An error occurred in _get_i_string");
3003
3004 /* sp = mark; *//* not needed */
3005 ST(0) = sv_2mortal(newSVpv(out, 0));
3006 mpfr_free_str(out);
3007 ST(1) = sv_2mortal(newSViv(ptr));
3008 /* PUTBACK; *//* not needed */
3009 XSRETURN(2);
3010 }
3011
3012
3013 /* ########################################
3014 ########################################
3015 ########################################
3016 ########################################
3017 ########################################
3018 ######################################## */
3019
3020
3021
3022 SV * _itsa(pTHX_ SV * a) {
3023 if(SV_IS_IOK(a)) {
3024 if(SvUOK(a)) return newSVuv(1);
3025 return newSVuv(2);
3026 }
3027 if(SV_IS_POK(a)) return newSVuv(4);
3028 if(SV_IS_NOK(a)) return newSVuv(3);
3029 if(sv_isobject(a)) {
3030 const char *h = HvNAME(SvSTASH(SvRV(a)));
3031 if(strEQ(h, "Math::MPFR")) return newSVuv(5);
3032 if(strEQ(h, "Math::GMPf")) return newSVuv(6);
3033 if(strEQ(h, "Math::GMPq")) return newSVuv(7);
3034 if(strEQ(h, "Math::GMPz")) return newSVuv(8);
3035 if(strEQ(h, "Math::GMP")) return newSVuv(9);
3036 if(strEQ(h, "Math::MPC")) return newSVuv(10);
3037 }
3038 return newSVuv(0);
3039 }
3040
3041 SV * _new_real_im(pTHX_ SV * b, SV * d) {
3042 dMY_CXT;
3043 mpc_t * mpc_t_obj;
3044 mpfr_t temp_re, temp_im;
3045 int done_re = 0, done_im = 0;
3046 SV * obj_ref, * obj;
3047
3048 New(1, mpc_t_obj, 1, mpc_t);
3049 if(mpc_t_obj == NULL) croak("Failed to allocate memory in _new_real_im function");
3050 obj_ref = newSV(0);
3051 obj = newSVrv(obj_ref, "Math::MPC");
3052 mpc_init3(*mpc_t_obj, DEFAULT_PREC);
3053
3054 sv_setiv(obj, INT2PTR(IV,mpc_t_obj));
3055 SvREADONLY_on(obj);
3056
3057 mpfr_init2(temp_re, DEFAULT_PREC_RE);
3058 mpfr_init2(temp_im, DEFAULT_PREC_IM);
3059
3060 #ifdef MATH_MPC_NEED_LONG_LONG_INT
3061
3062 if(SV_IS_IOK(b) && !done_re) {
3063 #ifdef _MSC_VER
3064 mpfr_set_str(temp_re, SvPV_nolen(b), 10, DEFAULT_ROUNDING_MODE & 3);
3065 #else
3066 if(SvUOK(b)) mpfr_set_uj(temp_re, SvUVX(b), DEFAULT_ROUNDING_MODE & 3);
3067 else mpfr_set_sj(temp_re, SvIVX(b), DEFAULT_ROUNDING_MODE & 3);
3068 #endif
3069 done_re = 1;
3070 }
3071
3072 #else
3073
3074 if(SV_IS_IOK(b) && !done_re) {
3075 if(SvUOK(b)) mpfr_set_ui(temp_re, SvUVX(b), DEFAULT_ROUNDING_MODE & 3);
3076 else mpfr_set_si(temp_re, SvIVX(b), DEFAULT_ROUNDING_MODE & 3);
3077 done_re = 1;
3078 }
3079 #endif
3080
3081 if(SV_IS_POK(b) && !done_re) {
3082
3083 NOK_POK_DUALVAR_CHECK , "Math::MPC::new");}
3084
3085 #ifdef _WIN32_BIZARRE_INFNAN
3086 done_re = _win32_infnanstring(SvPV_nolen(b));
3087 if(done_re) {
3088 if(done_re == 2) mpfr_set_nan(temp_re);
3089 else mpfr_set_inf(temp_re, done_re);
3090 }
3091 else {
3092 if(mpfr_set_str(temp_re, SvPV_nolen(b), 0, DEFAULT_ROUNDING_MODE & 3) == -1)
3093 croak("Invalid real string (%s) supplied to Math::MPC::new", SvPV_nolen(b));
3094 }
3095 #else
3096 if(mpfr_set_str(temp_re, SvPV_nolen(b), 0, DEFAULT_ROUNDING_MODE & 3) == -1)
3097 croak("Invalid real string (%s) supplied to Math::MPC::new", SvPV_nolen(b));
3098 #endif
3099 done_re = 1;
3100 }
3101
3102 if(SV_IS_NOK(b) && !done_re) {
3103 #if defined(MPC_CAN_PASS_FLOAT128)
3104 mpfr_set_float128(temp_re, SvNVX(b), DEFAULT_ROUNDING_MODE & 3);
3105 #elif defined(NV_IS_FLOAT128)
3106 _mpfr_set_NV(aTHX_ &temp_re, b, GMP_RNDN);
3107 #elif defined(NV_IS_LONG_DOUBLE)
3108 mpfr_set_ld(temp_re, SvNVX(b), DEFAULT_ROUNDING_MODE & 3);
3109 #else
3110 mpfr_set_d(temp_re, SvNVX(b), DEFAULT_ROUNDING_MODE & 3);
3111 #endif
3112 done_re = 1;
3113 }
3114
3115 if(sv_isobject(b) && !done_re) {
3116 const char *h = HvNAME(SvSTASH(SvRV(b)));
3117 if(strEQ(h, "Math::MPFR")) {
3118 mpfr_set(temp_re, *(INT2PTR(mpfr_t *, SvIVX(SvRV(b)))), DEFAULT_ROUNDING_MODE & 3);
3119 done_re = 1;
3120 }
3121 if(strEQ(h, "Math::GMPf")) {
3122 mpfr_set_f(temp_re, *(INT2PTR(mpf_t *, SvIVX(SvRV(b)))), DEFAULT_ROUNDING_MODE & 3);
3123 done_re = 1;
3124 }
3125 if(strEQ(h, "Math::GMPq")) {
3126 mpfr_set_q(temp_re, *(INT2PTR(mpq_t *, SvIVX(SvRV(b)))), DEFAULT_ROUNDING_MODE & 3);
3127 done_re = 1;
3128 }
3129 if(strEQ(h, "Math::GMP") ||
3130 strEQ(h, "Math::GMPz")) {
3131 mpfr_set_z(temp_re, *(INT2PTR(mpz_t *, SvIVX(SvRV(b)))), DEFAULT_ROUNDING_MODE & 3);
3132 done_re = 1;
3133 }
3134 }
3135
3136 if(!done_re)
3137 croak("Invalid real argument supplied to Math::MPC::new");
3138
3139 /****************************************************************/
3140
3141 #ifdef MATH_MPC_NEED_LONG_LONG_INT
3142
3143 if(SV_IS_IOK(d) && !done_im) {
3144 #ifdef _MSC_VER
3145 mpfr_set_str(temp_im, SvPV_nolen(d), 10, DEFAULT_ROUNDING_MODE / 16);
3146 #else
3147 if(SvUOK(d)) mpfr_set_uj(temp_im, SvUVX(d), DEFAULT_ROUNDING_MODE / 16);
3148 else mpfr_set_sj(temp_im, SvIVX(d), DEFAULT_ROUNDING_MODE / 16);
3149 #endif
3150 done_im = 1;
3151 }
3152
3153 #else
3154 if(SV_IS_IOK(d) && !done_im) {
3155 if(SvUOK(d)) mpfr_set_ui(temp_im, SvUVX(d), DEFAULT_ROUNDING_MODE / 16);
3156 else mpfr_set_si(temp_im, SvIVX(d), DEFAULT_ROUNDING_MODE / 16);
3157 done_im = 1;
3158 }
3159 #endif
3160
3161 if(SV_IS_POK(d) && !done_im) {
3162
3163 if(SV_IS_NOK(d)) {
3164 nok_pok++;
3165 if(SvIV(get_sv("Math::MPC::NOK_POK", 0)))
3166 warn("Scalar passed to %s is both NV and PV. Using PV (string) value", "Math::MPC::new");}
3167
3168 #ifdef _WIN32_BIZARRE_INFNAN
3169 done_im = _win32_infnanstring(SvPV_nolen(d));
3170 if(done_im) {
3171 if(done_im == 2) mpfr_set_nan(temp_im);
3172 else mpfr_set_inf(temp_im, done_im);
3173 }
3174 else {
3175 if(mpfr_set_str(temp_im, SvPV_nolen(d), 0, DEFAULT_ROUNDING_MODE & 3) == -1)
3176 croak("Invalid imaginary string (%s) supplied to Math::MPC::new", SvPV_nolen(d));
3177 }
3178 #else
3179 if(mpfr_set_str(temp_im, SvPV_nolen(d), 0, DEFAULT_ROUNDING_MODE & 3) == -1)
3180 croak("Invalid imaginary string (%s) supplied to Math::MPC::new", SvPV_nolen(d));
3181 #endif
3182 done_im = 1;
3183 }
3184
3185 if(SV_IS_NOK(d) && !done_im) {
3186
3187 #if defined(MPC_CAN_PASS_FLOAT128)
3188 mpfr_set_float128(temp_im, SvNVX(d), DEFAULT_ROUNDING_MODE / 16);
3189 #elif defined(NV_IS_FLOAT128)
3190 _mpfr_set_NV(aTHX_ &temp_im, d, GMP_RNDN);
3191 #elif defined(NV_IS_LONG_DOUBLE)
3192 mpfr_set_ld(temp_im, SvNVX(d), DEFAULT_ROUNDING_MODE / 16);
3193 #else
3194 mpfr_set_d(temp_im, SvNVX(d), DEFAULT_ROUNDING_MODE / 16);
3195 #endif
3196 done_im = 1;
3197 }
3198
3199 if(sv_isobject(d) && !done_im) {
3200 const char *h = HvNAME(SvSTASH(SvRV(d)));
3201 if(strEQ(h, "Math::MPFR")) {
3202 mpfr_set(temp_im, *(INT2PTR(mpfr_t *, SvIVX(SvRV(d)))), DEFAULT_ROUNDING_MODE / 16);
3203 done_im = 1;
3204 }
3205 if(strEQ(h, "Math::GMPf")) {
3206 mpfr_set_f(temp_im, *(INT2PTR(mpf_t *, SvIVX(SvRV(d)))), DEFAULT_ROUNDING_MODE / 16);
3207 done_im = 1;
3208 }
3209 if(strEQ(h, "Math::GMPq")) {
3210 mpfr_set_q(temp_im, *(INT2PTR(mpq_t *, SvIVX(SvRV(d)))), DEFAULT_ROUNDING_MODE / 16);
3211 done_im = 1;
3212 }
3213 if(strEQ(h, "Math::GMP") ||
3214 strEQ(h, "Math::GMPz")) {
3215 mpfr_set_z(temp_im, *(INT2PTR(mpz_t *, SvIVX(SvRV(d)))), DEFAULT_ROUNDING_MODE / 16);
3216 done_im = 1;
3217 }
3218 }
3219
3220 if(!done_im)
3221 croak("Invalid imaginary argument supplied to Math::MPC::new");
3222
3223 /****************************************************************/
3224
3225 mpc_set_fr_fr(*mpc_t_obj, temp_re, temp_im, DEFAULT_ROUNDING_MODE);
3226 mpfr_clear(temp_re);
3227 mpfr_clear(temp_im);
3228 return obj_ref;
3229 }
3230
3231 int _has_longlong(void) {
3232 #ifdef MATH_MPC_NEED_LONG_LONG_INT
3233 return 1;
3234 #else
3235 return 0;
3236 #endif
3237 }
3238
3239 int _has_longdouble(void) {
3240 #if defined(NV_IS_LONG_DOUBLE) || defined(NV_IS_FLOAT128)
3241 return 1;
3242 #else
3243 return 0;
3244 #endif
3245 }
3246
3247 /* Has inttypes.h been included ?
3248 &&
3249 Do we have MATH_MPC_NEED_LONG_LONG_INT ? */
3250
3251 int _has_inttypes() {
3252 #ifdef _MSC_VER
3253 return 0;
3254 #else
3255 #if defined MATH_MPC_NEED_LONG_LONG_INT
3256 return 1;
3257 #else
3258 return 0;
3259 #endif
3260 #endif
3261 }
3262
3263 SV * gmp_v(pTHX) {
3264 #if __GNU_MP_VERSION >= 4
3265 return newSVpv(gmp_version, 0);
3266 #else
3267 warn("From Math::MPC::gmp_v: 'gmp_version' is not implemented - returning '0'");
3268 return newSVpv("0", 0);
3269 #endif
3270 }
3271
3272 SV * mpfr_v(pTHX) {
3273 return newSVpv(mpfr_get_version(), 0);
3274 }
3275
3276 /* Not yet available
3277 SV * RMPC_MAX_PREC(mpc_t * a) {
3278 return newSVuv(MPC_MAX_PREC(*a));
3279 }
3280 */
3281
3282 SV * _MPC_VERSION_MAJOR(pTHX) {
3283 return newSVuv(MPC_VERSION_MAJOR);
3284 }
3285
3286 SV * _MPC_VERSION_MINOR(pTHX) {
3287 return newSVuv(MPC_VERSION_MINOR);
3288 }
3289
3290 SV * _MPC_VERSION_PATCHLEVEL(pTHX) {
3291 return newSVuv(MPC_VERSION_PATCHLEVEL);
3292 }
3293
3294 SV * _MPC_VERSION(pTHX) {
3295 return newSVuv(MPC_VERSION);
3296 }
3297
3298 SV * _MPFR_VERSION(pTHX) {
3299 return newSVuv(MPFR_VERSION);
3300 }
3301
3302 SV * _MPC_VERSION_NUM(pTHX_ SV * x, SV * y, SV * z) {
3303 return newSVuv(MPC_VERSION_NUM((unsigned long)SvUV(x), (unsigned long)SvUV(y), (unsigned long)SvUV(z)));
3304 }
3305
3306 SV * _MPC_VERSION_STRING(pTHX) {
3307 return newSVpv(MPC_VERSION_STRING, 0);
3308 }
3309
3310 SV * Rmpc_get_version(pTHX) {
3311 return newSVpv(mpc_get_version(), 0);
3312 }
3313
3314 SV * Rmpc_real(pTHX_ mpfr_t * rop, mpc_t * op, SV * round) {
3315 return newSViv(mpc_real(*rop, *op, (mpc_rnd_t)SvUV(round)));
3316 }
3317
3318 SV * Rmpc_imag(pTHX_ mpfr_t * rop, mpc_t * op, SV * round) {
3319 return newSViv(mpc_imag(*rop, *op, (mpc_rnd_t)SvUV(round)));
3320 }
3321
3322 SV * Rmpc_arg(pTHX_ mpfr_t * rop, mpc_t * op, SV * round) {
3323 return newSViv(mpc_arg(*rop, *op, (mpc_rnd_t)SvUV(round)));
3324 }
3325
3326 SV * Rmpc_proj(pTHX_ mpc_t * rop, mpc_t * op, SV * round) {
3327 return newSViv(mpc_proj(*rop, *op, (mpc_rnd_t)SvUV(round)));
3328 }
3329
3330 SV * Rmpc_get_str(pTHX_ SV * base, SV * dig, mpc_t * op, SV * round) {
3331 char * out;
3332 SV * outsv;
3333 out = mpc_get_str((int)SvIV(base), (size_t)SvUV(dig), *op, (mpc_rnd_t)SvUV(round));
3334 outsv = newSVpv(out, 0);
3335 mpc_free_str(out);
3336 return outsv;
3337 }
3338
3339 int Rmpc_set_str(pTHX_ mpc_t * rop, SV * str, SV * base, SV * round) {
3340 int ret;
3341 ret = mpc_set_str(*rop, SvPV_nolen(str), (int)SvIV(base), (mpc_rnd_t)SvUV(round));
3342 if(ret == -1)croak("Invalid string given to Rmpc_set_str");
3343 return ret;
3344 }
3345
3346 int Rmpc_strtoc(pTHX_ mpc_t * rop, SV * str, SV * base, SV * round) {
3347 int ret;
3348 ret = mpc_strtoc(*rop, SvPV_nolen(str), NULL, (int)SvIV(base), (mpc_rnd_t)SvUV(round));
3349 if(ret == -1) croak("Invalid string given to Rmpc_strtoc");
3350 return ret;
3351 }
3352
3353 void Rmpc_set_nan(mpc_t * a) {
3354 mpc_set_nan(*a);
3355 }
3356
3357 void Rmpc_swap(mpc_t * a, mpc_t * b) {
3358 mpc_swap(*a, *b);
3359 }
3360
3361 /* atan2(x, y) = atan(x / y) */
3362 SV * overload_atan2(pTHX_ mpc_t * p, mpc_t * q, SV * third) {
3363 dMY_CXT;
3364 mpc_t * mpc_t_obj;
3365 SV * obj_ref, * obj;
3366
3367 New(1, mpc_t_obj, 1, mpc_t);
3368 if(mpc_t_obj == NULL) croak("Failed to allocate memory in overload_atan2 function");
3369 obj_ref = newSV(0);
3370 obj = newSVrv(obj_ref, "Math::MPC");
3371 mpc_init3(*mpc_t_obj, DEFAULT_PREC);
3372
3373 mpc_div(*mpc_t_obj, *p, *q, DEFAULT_ROUNDING_MODE);
3374
3375 mpc_atan(*mpc_t_obj, *mpc_t_obj, DEFAULT_ROUNDING_MODE);
3376 sv_setiv(obj, INT2PTR(IV,mpc_t_obj));
3377 SvREADONLY_on(obj);
3378 return obj_ref;
3379 }
3380
3381 SV * Rmpc_sin_cos(pTHX_ mpc_t * rop_sin, mpc_t * rop_cos, mpc_t * op, SV * rnd_sin, SV * rnd_cos) {
3382 #ifdef SIN_COS_AVAILABLE
3383 return newSViv(mpc_sin_cos(*rop_sin, *rop_cos, *op, (mpc_rnd_t)SvUV(rnd_sin), (mpc_rnd_t)SvUV(rnd_cos)));
3384 #else
3385 croak("Rmpc_�sin_cos not supported by your version (%s) of the mpc library", MPC_VERSION_STRING);
3386 #endif
3387 }
3388
3389 void Rmpc_get_dc(pTHX_ SV * crop, mpc_t * op, SV * round) {
3390 #ifdef _DO_COMPLEX_H
3391 warn("Rmpc_get_dc is deprecated - use Rmpc_get_DC instead\n");
3392 if(sv_isobject(crop)) {
3393 const char *h = HvNAME(SvSTASH(SvRV(crop)));
3394 if(strNE(h, "Math::Complex_C"))
3395 croak("1st arg to Rmpc_get_dc is a %s object - needs to be a Math::Complex_C object", h);
3396 }
3397 else croak("1st arg to Rmpc_get_dc needs to be a Math::Complex_C object");
3398 *(INT2PTR(double _Complex *, SvIVX(SvRV(crop)))) = mpc_get_dc(*op, (mpc_rnd_t)SvUV(round));
3399 #else
3400 croak("Rmpc_get_dc not implemented");
3401 #endif
3402 }
3403
3404 void Rmpc_get_ldc(pTHX_ SV * crop, mpc_t * op, SV * round) {
3405 #ifdef _DO_COMPLEX_H
3406 warn("Rmpc_get_ldc is deprecated - use Rmpc_get_LDC instead\n");
3407 if(sv_isobject(crop)) {
3408 const char *h = HvNAME(SvSTASH(SvRV(crop)));
3409 if(strNE(h, "Math::Complex_C::L"))
3410 croak("1st arg to Rmpc_get_ldc is a %s object - needs to be a Math::Complex_C::L object", h);
3411 }
3412 else croak("1st arg to Rmpc_get_ldc needs to be a Math::Complex_C::L object");
3413 *(INT2PTR(long double _Complex *, SvIVX(SvRV(crop)))) = mpc_get_ldc(*op, (mpc_rnd_t)SvUV(round));
3414 #else
3415 croak("Rmpc_get_ldc not implemented");
3416 #endif
3417 }
3418
3419 SV * Rmpc_set_dc(pTHX_ mpc_t * op, SV * crop, SV * round) {
3420 #ifdef _DO_COMPLEX_H
3421 warn("Rmpc_set_dc is deprecated - use Rmpc_set_DC instead\n");
3422 if(sv_isobject(crop)) {
3423 const char *h = HvNAME(SvSTASH(SvRV(crop)));
3424 if(strNE(h, "Math::Complex_C"))
3425 croak("2nd arg to Rmpc_set_dc is a %s object - needs to be a Math::Complex_C object", h);
3426 }
3427 else croak("2nd arg to Rmpc_set_dc needs to be a Math::Complex_C object");
3428 return newSViv(mpc_set_dc(*op, *(INT2PTR(double _Complex *, SvIVX(SvRV(crop)))), (mpc_rnd_t)SvUV(round)));
3429 #else
3430 croak("Rmpc_set_dc not implemented");
3431 #endif
3432 }
3433
3434 SV * Rmpc_set_ldc(pTHX_ mpc_t * op, SV * crop, SV * round) {
3435 #ifdef _DO_COMPLEX_H
3436 warn("Rmpc_set_ldc is deprecated - use Rmpc_set_LDC instead\n");
3437 if(sv_isobject(crop)) {
3438 const char *h = HvNAME(SvSTASH(SvRV(crop)));
3439 if(strNE(h, "Math::Complex_C::L"))
3440 croak("2nd arg to Rmpc_set_ldc is a %s object - needs to be a Math::Complex_C::L object", h);
3441 }
3442 else croak("2nd arg to Rmpc_set_ldc needs to be a Math::Complex_C::L object");
3443 return newSViv(mpc_set_ldc(*op, *(INT2PTR(long double _Complex *, SvIVX(SvRV(crop)))), (mpc_rnd_t)SvUV(round)));
3444 #else
3445 croak("Rmpc_set_ldc not implemented");
3446 #endif
3447 }
3448
3449 /**********************************
3450 **********************************/
3451
3452 void Rmpc_get_DC(pTHX_ SV * crop, mpc_t * op, SV * round) {
3453 #ifdef _DO_COMPLEX_H
3454 if(sv_isobject(crop)) {
3455 const char *h = HvNAME(SvSTASH(SvRV(crop)));
3456 if(strNE(h, "Math::Complex_C"))
3457 croak("1st arg to Rmpc_get_DC is a %s object - needs to be a Math::Complex_C object", h);
3458 }
3459 else croak("1st arg to Rmpc_get_DC needs to be a Math::Complex_C object");
3460 *(INT2PTR(double _Complex *, SvIVX(SvRV(crop)))) = mpc_get_dc(*op, (mpc_rnd_t)SvUV(round));
3461 #else
3462 croak("Rmpc_get_DC not implemented");
3463 #endif
3464 }
3465
3466 void Rmpc_get_LDC(pTHX_ SV * crop, mpc_t * op, SV * round) {
3467 #ifdef _DO_COMPLEX_H
3468 if(sv_isobject(crop)) {
3469 const char *h = HvNAME(SvSTASH(SvRV(crop)));
3470 if(strNE(h, "Math::Complex_C::L"))
3471 croak("1st arg to Rmpc_get_LDC is a %s object - needs to be a Math::Complex_C::L object", h);
3472 }
3473 else croak("1st arg to Rmpc_get_LDC needs to be a Math::Complex_C::L object");
3474 *(INT2PTR(long double _Complex *, SvIVX(SvRV(crop)))) = mpc_get_ldc(*op, (mpc_rnd_t)SvUV(round));
3475 #else
3476 croak("Rmpc_get_LDC not implemented");
3477 #endif
3478 }
3479
3480 SV * Rmpc_set_DC(pTHX_ mpc_t * op, SV * crop, SV * round) {
3481 #ifdef _DO_COMPLEX_H
3482 if(sv_isobject(crop)) {
3483 const char *h = HvNAME(SvSTASH(SvRV(crop)));
3484 if(strNE(h, "Math::Complex_C"))
3485 croak("2nd arg to Rmpc_set_DC is a %s object - needs to be a Math::Complex_C object", h);
3486 }
3487 else croak("2nd arg to Rmpc_set_DC needs to be a Math::Complex_C object");
3488 return newSViv(mpc_set_dc(*op, *(INT2PTR(double _Complex *, SvIVX(SvRV(crop)))), (mpc_rnd_t)SvUV(round)));
3489 #else
3490 croak("Rmpc_set_DC not implemented");
3491 #endif
3492 }
3493
3494 SV * Rmpc_set_LDC(pTHX_ mpc_t * op, SV * crop, SV * round) {
3495 #ifdef _DO_COMPLEX_H
3496 if(sv_isobject(crop)) {
3497 const char *h = HvNAME(SvSTASH(SvRV(crop)));
3498 if(strNE(h, "Math::Complex_C::L"))
3499 croak("2nd arg to Rmpc_set_LDC is a %s object - needs to be a Math::Complex_C::L object", h);
3500 }
3501 else croak("2nd arg to Rmpc_set_LDC needs to be a Math::Complex_C::L object");
3502 return newSViv(mpc_set_ldc(*op, *(INT2PTR(long double _Complex *, SvIVX(SvRV(crop)))), (mpc_rnd_t)SvUV(round)));
3503 #else
3504 croak("Rmpc_set_LDC not implemented");
3505 #endif
3506 }
3507
3508 /**********************************
3509 **********************************/
3510
3511
3512 /**********************************
3513 **********************************/
3514
3515 int _have_Complex_h(void) {
3516 #ifdef _DO_COMPLEX_H
3517 return 1;
3518 #else
3519 return 0;
3520 #endif
3521 }
3522
3523 SV * _mpfr_buildopt_tls_p(pTHX) {
3524 #if MPFR_VERSION_MAJOR >= 3
3525 return newSViv(mpfr_buildopt_tls_p());
3526 #else
3527 croak("Math::MPC::_mpfr_buildopt_tls_p not implemented with this version of the mpfr library - we have %s but need at least 3.0.0", MPFR_VERSION_STRING);
3528 #endif
3529 }
3530
3531 SV * _get_xs_version(pTHX) {
3532 return newSVpv(XS_VERSION, 0);
3533 }
3534
3535 SV * _wrap_count(pTHX) {
3536 return newSVuv(PL_sv_count);
3537 }
3538
3539 /* Beginning mpc-1.0, mpc_mul_2si and mpc_div_2si were added */
3540
3541 SV * Rmpc_mul_2si(pTHX_ mpc_t * a, mpc_t * b, SV * c, SV * round) {
3542 #if MPC_VERSION >= 65536
3543 return newSViv(mpc_mul_2si(*a, *b, SvUV(c), (mpc_rnd_t)SvUV(round)));
3544 # else
3545 croak("mpc_mul_2si not implemented until mpc-1.0. We have version %d", MPC_VERSION);
3546 #endif
3547 }
3548
3549 SV * Rmpc_div_2si(pTHX_ mpc_t * a, mpc_t * b, SV * c, SV * round) {
3550 #if MPC_VERSION >= 65536
3551 return newSViv(mpc_div_2si(*a, *b, SvUV(c), (mpc_rnd_t)SvUV(round)));
3552 # else
3553 croak("mpc_div_2si not implemented until mpc-1.0. We have version %d", MPC_VERSION);
3554 #endif
3555 }
3556
3557 SV * Rmpc_log10(pTHX_ mpc_t * rop, mpc_t *op, SV * round) {
3558 #if MPC_VERSION >= 65536
3559 return newSViv(mpc_log10(*rop, *op, (mpc_rnd_t)SvUV(round)));
3560 # else
3561 croak("mpc_log10 not implemented until mpc-1.0. We have version %d", MPC_VERSION);
3562 #endif
3563 }
3564
3565 int Rmpc_cmp_abs(mpc_t * op1, mpc_t * op2) {
3566 #if (!defined(MPC_VERSION) || (MPC_VERSION<MPC_VERSION_NUM(1,1,0)))
3567 croak("Rmpc_cmp_abs not available - need mpc-1.1.0 or later");
3568 #else
3569 return mpc_cmp_abs(*op1, *op2);
3570 #endif
3571 }
3572
3573 int Rmpc_rootofunity(pTHX_ mpc_t * rop, unsigned long n, unsigned long k, SV * round) {
3574 #if (!defined(MPC_VERSION) || (MPC_VERSION<MPC_VERSION_NUM(1,1,0)))
3575 croak("Rmpc_rootofunity not available - need mpc-1.1.0 or later");
3576 #else
3577 return mpc_rootofunity(*rop, n, k, (mpc_rnd_t)SvUV(round));
3578 #endif
3579 }
3580
3581 int _can_pass_float128(void) {
3582
3583 #ifdef MPC_CAN_PASS_FLOAT128
3584 return 1;
3585 #else
3586 return 0;
3587 #endif
3588
3589 }
3590
3591 int _get_nv_precision(void) {
3592 #if defined(NV_IS_FLOAT128)
3593 return 113;
3594 #elif defined(NV_IS_LONG_DOUBLE)
3595 return (int) REQUIRED_LDBL_MANT_DIG;
3596 #else
3597 return 53;
3598 #endif
3599 }
3600
3601
3602 int nok_pokflag(void) {
3603 return nok_pok;
3604 }
3605
3606 void clear_nok_pok(void){
3607 nok_pok = 0;
3608 }
3609
3610 void set_nok_pok(int x) {
3611 nok_pok = x;
3612 }
3613
3614 int _SvNOK(pTHX_ SV * in) {
3615 if(SV_IS_NOK(in)) return 1;
3616 return 0;
3617 }
3618
3619 int _SvPOK(pTHX_ SV * in) {
3620 if(SV_IS_POK(in)) return 1;
3621 return 0;
3622 }
3623
3624 SV * Rmpc_fma(pTHX_ mpc_t * a, mpc_t * b, mpc_t * c, mpc_t * d, SV * round) {
3625 return newSViv(mpc_fma(*a, *b, *c, *d, (mpc_rnd_t)SvUV(round)));
3626 }
3627
3628 SV * Rmpc_dot(pTHX_ mpc_t * rop, SV * avref_A, SV * avref_B, SV * len, SV * round) {
3629 #if defined(MPC_VERSION) && MPC_VERSION >= 65793 /* version 1.1.1 */
3630 mpc_ptr *p_A, *p_B;
3631 SV ** elem;
3632 int ret, i;
3633 unsigned long s = (unsigned long)SvUV(len);
3634
3635 if(s > av_len((AV*)SvRV(avref_A)) + 1 || s > av_len((AV*)SvRV(avref_B)) + 1)
3636 croak("2nd last arg to Rmpc_dot is too large");
3637
3638 Newx(p_A, s, mpc_ptr);
3639 if(p_A == NULL) croak("Unable to allocate memory for first pointer array in Rmpc_dot");
3640
3641 Newx(p_B, s, mpc_ptr);
3642 if(p_B == NULL) croak("Unable to allocate memory for second pointer array in Rmpc_dot");
3643
3644 for(i = 0; i < s; ++i) {
3645 elem = av_fetch((AV*)SvRV(avref_A), i, 0);
3646 p_A[i] = *(INT2PTR(mpc_t *, SvIVX(SvRV(*elem))));
3647 elem = av_fetch((AV*)SvRV(avref_B), i, 0);
3648 p_B[i] = *(INT2PTR(mpc_t *, SvIVX(SvRV(*elem))));
3649 }
3650
3651 ret = mpc_dot(*rop, p_A, p_B, s, (mpc_rnd_t)SvUV(round));
3652
3653 Safefree(p_A);
3654 Safefree(p_B);
3655 return newSViv(ret);
3656 #else
3657 croak("The Rmpc_dot function requires mpc-1.1.1 or later");
3658 #endif
3659 }
3660
3661 SV * Rmpc_sum(pTHX_ mpc_t * rop, SV * avref, SV * len, SV * round) {
3662 #if defined(MPC_VERSION) && MPC_VERSION >= 65793 /* version 1.1.1 */
3663 mpc_ptr *p;
3664 SV ** elem;
3665 int ret, i;
3666 unsigned long s = (unsigned long)SvUV(len);
3667
3668 if(s > av_len((AV*)SvRV(avref)) + 1)croak("2nd last arg to Rmpc_sum is greater than the size of the array");
3669
3670 Newx(p, s, mpc_ptr);
3671 if(p == NULL) croak("Unable to allocate memory in Rmpc_sum");
3672
3673 for(i = 0; i < s; ++i) {
3674 elem = av_fetch((AV*)SvRV(avref), i, 0);
3675 p[i] = *(INT2PTR(mpc_t *, SvIVX(SvRV(*elem))));
3676 }
3677
3678 ret = mpc_sum(*rop, p, s, (mpc_rnd_t)SvUV(round));
3679
3680 Safefree(p);
3681 return newSViv(ret);
3682 #else
3683 croak("The Rmpc_sum function requires mpc-1.1.1 or later");
3684 #endif
3685 }
3686
3687 /* I think the CLONE function needs to come at the very end ... not sure */
3688
3689 void CLONE(pTHX_ SV * x, ...) {
3690 MY_CXT_CLONE;
3691 }
3692
3693
3694
3695 MODULE = Math::MPC PACKAGE = Math::MPC
3696
3697 PROTOTYPES: DISABLE
3698
3699
3700 int
3701 NOK_POK_val ()
3702 CODE:
3703 RETVAL = NOK_POK_val (aTHX);
3704 OUTPUT: RETVAL
3705
3706
3707 int
3708 _win32_infnanstring (s)
3709 char * s
3710
3711 int
3712 Rmpc_mul_sj (rop, op, i, rnd)
3713 mpc_ptr rop
3714 mpc_ptr op
3715 intmax_t i
3716 mpc_rnd_t rnd
3717
3718 int
3719 Rmpc_mul_ld (rop, op, i, rnd)
3720 mpc_ptr rop
3721 mpc_ptr op
3722 long double i
3723 mpc_rnd_t rnd
3724
3725 int
3726 Rmpc_mul_d (rop, op, i, rnd)
3727 mpc_ptr rop
3728 mpc_ptr op
3729 double i
3730 mpc_rnd_t rnd
3731
3732 int
3733 Rmpc_div_sj (rop, op, i, rnd)
3734 mpc_ptr rop
3735 mpc_ptr op
3736 intmax_t i
3737 mpc_rnd_t rnd
3738
3739 int
3740 Rmpc_sj_div (rop, i, op, rnd)
3741 mpc_ptr rop
3742 intmax_t i
3743 mpc_ptr op
3744 mpc_rnd_t rnd
3745
3746 int
3747 Rmpc_div_ld (rop, op, i, rnd)
3748 mpc_ptr rop
3749 mpc_ptr op
3750 long double i
3751 mpc_rnd_t rnd
3752
3753 int
3754 Rmpc_ld_div (rop, i, op, rnd)
3755 mpc_ptr rop
3756 long double i
3757 mpc_ptr op
3758 mpc_rnd_t rnd
3759
3760 int
3761 Rmpc_div_d (rop, op, i, rnd)
3762 mpc_ptr rop
3763 mpc_ptr op
3764 double i
3765 mpc_rnd_t rnd
3766
3767 int
3768 Rmpc_d_div (rop, i, op, rnd)
3769 mpc_ptr rop
3770 double i
3771 mpc_ptr op
3772 mpc_rnd_t rnd
3773
3774 SV *
3775 _mpfr_set_NV (p, q, round)
3776 mpfr_t * p
3777 SV * q
3778 unsigned int round
3779 CODE:
3780 RETVAL = _mpfr_set_NV (aTHX_ p, q, round);
3781 OUTPUT: RETVAL
3782
3783 void
3784 Rmpc_set_default_rounding_mode (round)
3785 SV * round
3786 PREINIT:
3787 I32* temp;
3788 PPCODE:
3789 temp = PL_markstack_ptr++;
3790 Rmpc_set_default_rounding_mode(aTHX_ round);
3791 if (PL_markstack_ptr != temp) {
3792 /* truly void, because dXSARGS not invoked */
3793 PL_markstack_ptr = temp;
3794 XSRETURN_EMPTY; /* return empty stack */
3795 }
3796 /* must have used dXSARGS; list context implied */
3797 return; /* assume stack size is correct */
3798
3799 SV *
3800 Rmpc_get_default_rounding_mode ()
3801 CODE:
3802 RETVAL = Rmpc_get_default_rounding_mode (aTHX);
3803 OUTPUT: RETVAL
3804
3805
3806 void
3807 Rmpc_set_default_prec (prec)
3808 SV * prec
3809 PREINIT:
3810 I32* temp;
3811 PPCODE:
3812 temp = PL_markstack_ptr++;
3813 Rmpc_set_default_prec(aTHX_ prec);
3814 if (PL_markstack_ptr != temp) {
3815 /* truly void, because dXSARGS not invoked */
3816 PL_markstack_ptr = temp;
3817 XSRETURN_EMPTY; /* return empty stack */
3818 }
3819 /* must have used dXSARGS; list context implied */
3820 return; /* assume stack size is correct */
3821
3822 void
3823 Rmpc_set_default_prec2 (prec_re, prec_im)
3824 SV * prec_re
3825 SV * prec_im
3826 PREINIT:
3827 I32* temp;
3828 PPCODE:
3829 temp = PL_markstack_ptr++;
3830 Rmpc_set_default_prec2(aTHX_ prec_re, prec_im);
3831 if (PL_markstack_ptr != temp) {
3832 /* truly void, because dXSARGS not invoked */
3833 PL_markstack_ptr = temp;
3834 XSRETURN_EMPTY; /* return empty stack */
3835 }
3836 /* must have used dXSARGS; list context implied */
3837 return; /* assume stack size is correct */
3838
3839 SV *
3840 Rmpc_get_default_prec ()
3841 CODE:
3842 RETVAL = Rmpc_get_default_prec (aTHX);
3843 OUTPUT: RETVAL
3844
3845
3846 void
3847 Rmpc_get_default_prec2 ()
3848
3849 PREINIT:
3850 I32* temp;
3851 PPCODE:
3852 temp = PL_markstack_ptr++;
3853 Rmpc_get_default_prec2();
3854 if (PL_markstack_ptr != temp) {
3855 /* truly void, because dXSARGS not invoked */
3856 PL_markstack_ptr = temp;
3857 XSRETURN_EMPTY; /* return empty stack */
3858 }
3859 /* must have used dXSARGS; list context implied */
3860 return; /* assume stack size is correct */
3861
3862 void
3863 Rmpc_set_prec (p, prec)
3864 mpc_t * p
3865 SV * prec
3866 PREINIT:
3867 I32* temp;
3868 PPCODE:
3869 temp = PL_markstack_ptr++;
3870 Rmpc_set_prec(aTHX_ p, prec);
3871 if (PL_markstack_ptr != temp) {
3872 /* truly void, because dXSARGS not invoked */
3873 PL_markstack_ptr = temp;
3874 XSRETURN_EMPTY; /* return empty stack */
3875 }
3876 /* must have used dXSARGS; list context implied */
3877 return; /* assume stack size is correct */
3878
3879 void
3880 Rmpc_set_re_prec (p, prec)
3881 mpc_t * p
3882 SV * prec
3883 PREINIT:
3884 I32* temp;
3885 PPCODE:
3886 temp = PL_markstack_ptr++;
3887 Rmpc_set_re_prec(aTHX_ p, prec);
3888 if (PL_markstack_ptr != temp) {
3889 /* truly void, because dXSARGS not invoked */
3890 PL_markstack_ptr = temp;
3891 XSRETURN_EMPTY; /* return empty stack */
3892 }
3893 /* must have used dXSARGS; list context implied */
3894 return; /* assume stack size is correct */
3895
3896 void
3897 Rmpc_set_im_prec (p, prec)
3898 mpc_t * p
3899 SV * prec
3900 PREINIT:
3901 I32* temp;
3902 PPCODE:
3903 temp = PL_markstack_ptr++;
3904 Rmpc_set_im_prec(aTHX_ p, prec);
3905 if (PL_markstack_ptr != temp) {
3906 /* truly void, because dXSARGS not invoked */
3907 PL_markstack_ptr = temp;
3908 XSRETURN_EMPTY; /* return empty stack */
3909 }
3910 /* must have used dXSARGS; list context implied */
3911 return; /* assume stack size is correct */
3912
3913 SV *
3914 Rmpc_get_prec (x)
3915 mpc_t * x
3916 CODE:
3917 RETVAL = Rmpc_get_prec (aTHX_ x);
3918 OUTPUT: RETVAL
3919
3920 void
3921 Rmpc_get_prec2 (x)
3922 mpc_t * x
3923 PREINIT:
3924 I32* temp;
3925 PPCODE:
3926 temp = PL_markstack_ptr++;
3927 Rmpc_get_prec2(aTHX_ x);
3928 if (PL_markstack_ptr != temp) {
3929 /* truly void, because dXSARGS not invoked */
3930 PL_markstack_ptr = temp;
3931 XSRETURN_EMPTY; /* return empty stack */
3932 }
3933 /* must have used dXSARGS; list context implied */
3934 return; /* assume stack size is correct */
3935
3936 SV *
3937 Rmpc_get_im_prec (x)
3938 mpc_t * x
3939 CODE:
3940 RETVAL = Rmpc_get_im_prec (aTHX_ x);
3941 OUTPUT: RETVAL
3942
3943 SV *
3944 Rmpc_get_re_prec (x)
3945 mpc_t * x
3946 CODE:
3947 RETVAL = Rmpc_get_re_prec (aTHX_ x);
3948 OUTPUT: RETVAL
3949
3950 void
3951 RMPC_RE (fr, x)
3952 mpfr_t * fr
3953 mpc_t * x
3954 PREINIT:
3955 I32* temp;
3956 PPCODE:
3957 temp = PL_markstack_ptr++;
3958 RMPC_RE(fr, x);
3959 if (PL_markstack_ptr != temp) {
3960 /* truly void, because dXSARGS not invoked */
3961 PL_markstack_ptr = temp;
3962 XSRETURN_EMPTY; /* return empty stack */
3963 }
3964 /* must have used dXSARGS; list context implied */
3965 return; /* assume stack size is correct */
3966
3967 void
3968 RMPC_IM (fr, x)
3969 mpfr_t * fr
3970 mpc_t * x
3971 PREINIT:
3972 I32* temp;
3973 PPCODE:
3974 temp = PL_markstack_ptr++;
3975 RMPC_IM(fr, x);
3976 if (PL_markstack_ptr != temp) {
3977 /* truly void, because dXSARGS not invoked */
3978 PL_markstack_ptr = temp;
3979 XSRETURN_EMPTY; /* return empty stack */
3980 }
3981 /* must have used dXSARGS; list context implied */
3982 return; /* assume stack size is correct */
3983
3984 SV *
3985 RMPC_INEX_RE (x)
3986 SV * x
3987 CODE:
3988 RETVAL = RMPC_INEX_RE (aTHX_ x);
3989 OUTPUT: RETVAL
3990
3991 SV *
3992 RMPC_INEX_IM (x)
3993 SV * x
3994 CODE:
3995 RETVAL = RMPC_INEX_IM (aTHX_ x);
3996 OUTPUT: RETVAL
3997
3998 void
3999 DESTROY (p)
4000 mpc_t * p
4001 PREINIT:
4002 I32* temp;
4003 PPCODE:
4004 temp = PL_markstack_ptr++;
4005 DESTROY(aTHX_ p);
4006 if (PL_markstack_ptr != temp) {
4007 /* truly void, because dXSARGS not invoked */
4008 PL_markstack_ptr = temp;
4009 XSRETURN_EMPTY; /* return empty stack */
4010 }
4011 /* must have used dXSARGS; list context implied */
4012 return; /* assume stack size is correct */
4013
4014 void
4015 Rmpc_clear (p)
4016 mpc_t * p
4017 PREINIT:
4018 I32* temp;
4019 PPCODE:
4020 temp = PL_markstack_ptr++;
4021 Rmpc_clear(aTHX_ p);
4022 if (PL_markstack_ptr != temp) {
4023 /* truly void, because dXSARGS not invoked */
4024 PL_markstack_ptr = temp;
4025 XSRETURN_EMPTY; /* return empty stack */
4026 }
4027 /* must have used dXSARGS; list context implied */
4028 return; /* assume stack size is correct */
4029
4030 void
4031 Rmpc_clear_mpc (p)
4032 mpc_t * p
4033 PREINIT:
4034 I32* temp;
4035 PPCODE:
4036 temp = PL_markstack_ptr++;
4037 Rmpc_clear_mpc(p);
4038 if (PL_markstack_ptr != temp) {
4039 /* truly void, because dXSARGS not invoked */
4040 PL_markstack_ptr = temp;
4041 XSRETURN_EMPTY; /* return empty stack */
4042 }
4043 /* must have used dXSARGS; list context implied */
4044 return; /* assume stack size is correct */
4045
4046 void
4047 Rmpc_clear_ptr (p)
4048 mpc_t * p
4049 PREINIT:
4050 I32* temp;
4051 PPCODE:
4052 temp = PL_markstack_ptr++;
4053 Rmpc_clear_ptr(aTHX_ p);
4054 if (PL_markstack_ptr != temp) {
4055 /* truly void, because dXSARGS not invoked */
4056 PL_markstack_ptr = temp;
4057 XSRETURN_EMPTY; /* return empty stack */
4058 }
4059 /* must have used dXSARGS; list context implied */
4060 return; /* assume stack size is correct */
4061
4062 SV *
4063 Rmpc_init2 (prec)
4064 SV * prec
4065 CODE:
4066 RETVAL = Rmpc_init2 (aTHX_ prec);
4067 OUTPUT: RETVAL
4068
4069 SV *
4070 Rmpc_init3 (prec_r, prec_i)
4071 SV * prec_r
4072 SV * prec_i
4073 CODE:
4074 RETVAL = Rmpc_init3 (aTHX_ prec_r, prec_i);
4075 OUTPUT: RETVAL
4076
4077 SV *
4078 Rmpc_init2_nobless (prec)
4079 SV * prec
4080 CODE:
4081 RETVAL = Rmpc_init2_nobless (aTHX_ prec);
4082 OUTPUT: RETVAL
4083
4084 SV *
4085 Rmpc_init3_nobless (prec_r, prec_i)
4086 SV * prec_r
4087 SV * prec_i
4088 CODE:
4089 RETVAL = Rmpc_init3_nobless (aTHX_ prec_r, prec_i);
4090 OUTPUT: RETVAL
4091
4092 SV *
4093 Rmpc_set (p, q, round)
4094 mpc_t * p
4095 mpc_t * q
4096 SV * round
4097 CODE:
4098 RETVAL = Rmpc_set (aTHX_ p, q, round);
4099 OUTPUT: RETVAL
4100
4101 SV *
4102 Rmpc_set_ui (p, q, round)
4103 mpc_t * p
4104 SV * q
4105 SV * round
4106 CODE:
4107 RETVAL = Rmpc_set_ui (aTHX_ p, q, round);
4108 OUTPUT: RETVAL
4109
4110 SV *
4111 Rmpc_set_si (p, q, round)
4112 mpc_t * p
4113 SV * q
4114 SV * round
4115 CODE:
4116 RETVAL = Rmpc_set_si (aTHX_ p, q, round);
4117 OUTPUT: RETVAL
4118
4119 SV *
4120 Rmpc_set_ld (p, q, round)
4121 mpc_t * p
4122 SV * q
4123 SV * round
4124 CODE:
4125 RETVAL = Rmpc_set_ld (aTHX_ p, q, round);
4126 OUTPUT: RETVAL
4127
4128 SV *
4129 Rmpc_set_NV (p, q, round)
4130 mpc_t * p
4131 SV * q
4132 unsigned int round
4133 CODE:
4134 RETVAL = Rmpc_set_NV (aTHX_ p, q, round);
4135 OUTPUT: RETVAL
4136
4137 SV *
4138 Rmpc_set_NV_NV (p, re_q, im_q, round)
4139 mpc_t * p
4140 SV * re_q
4141 SV * im_q
4142 SV * round
4143 CODE:
4144 RETVAL = Rmpc_set_NV_NV (aTHX_ p, re_q, im_q, round);
4145 OUTPUT: RETVAL
4146
4147 SV *
4148 Rmpc_set_uj (p, q, round)
4149 mpc_t * p
4150 SV * q
4151 SV * round
4152 CODE:
4153 RETVAL = Rmpc_set_uj (aTHX_ p, q, round);
4154 OUTPUT: RETVAL
4155
4156 SV *
4157 Rmpc_set_sj (p, q, round)
4158 mpc_t * p
4159 SV * q
4160 SV * round
4161 CODE:
4162 RETVAL = Rmpc_set_sj (aTHX_ p, q, round);
4163 OUTPUT: RETVAL
4164
4165 SV *
4166 Rmpc_set_z (p, q, round)
4167 mpc_t * p
4168 mpz_t * q
4169 SV * round
4170 CODE:
4171 RETVAL = Rmpc_set_z (aTHX_ p, q, round);
4172 OUTPUT: RETVAL
4173
4174 SV *
4175 Rmpc_set_f (p, q, round)
4176 mpc_t * p
4177 mpf_t * q
4178 SV * round
4179 CODE:
4180 RETVAL = Rmpc_set_f (aTHX_ p, q, round);
4181 OUTPUT: RETVAL
4182
4183 SV *
4184 Rmpc_set_q (p, q, round)
4185 mpc_t * p
4186 mpq_t * q
4187 SV * round
4188 CODE:
4189 RETVAL = Rmpc_set_q (aTHX_ p, q, round);
4190 OUTPUT: RETVAL
4191
4192 SV *
4193 Rmpc_set_d (p, q, round)
4194 mpc_t * p
4195 SV * q
4196 SV * round
4197 CODE:
4198 RETVAL = Rmpc_set_d (aTHX_ p, q, round);
4199 OUTPUT: RETVAL
4200
4201 SV *
4202 Rmpc_set_fr (p, q, round)
4203 mpc_t * p
4204 mpfr_t * q
4205 SV * round
4206 CODE:
4207 RETVAL = Rmpc_set_fr (aTHX_ p, q, round);
4208 OUTPUT: RETVAL
4209
4210 SV *
4211 Rmpc_set_ui_ui (p, q_r, q_i, round)
4212 mpc_t * p
4213 SV * q_r
4214 SV * q_i
4215 SV * round
4216 CODE:
4217 RETVAL = Rmpc_set_ui_ui (aTHX_ p, q_r, q_i, round);
4218 OUTPUT: RETVAL
4219
4220 SV *
4221 Rmpc_set_si_si (p, q_r, q_i, round)
4222 mpc_t * p
4223 SV * q_r
4224 SV * q_i
4225 SV * round
4226 CODE:
4227 RETVAL = Rmpc_set_si_si (aTHX_ p, q_r, q_i, round);
4228 OUTPUT: RETVAL
4229
4230 SV *
4231 Rmpc_set_d_d (p, q_r, q_i, round)
4232 mpc_t * p
4233 SV * q_r
4234 SV * q_i
4235 SV * round
4236 CODE:
4237 RETVAL = Rmpc_set_d_d (aTHX_ p, q_r, q_i, round);
4238 OUTPUT: RETVAL
4239
4240 SV *
4241 Rmpc_set_ld_ld (mpc, ld1, ld2, round)
4242 mpc_t * mpc
4243 SV * ld1
4244 SV * ld2
4245 SV * round
4246 CODE:
4247 RETVAL = Rmpc_set_ld_ld (aTHX_ mpc, ld1, ld2, round);
4248 OUTPUT: RETVAL
4249
4250 SV *
4251 Rmpc_set_z_z (p, q_r, q_i, round)
4252 mpc_t * p
4253 mpz_t * q_r
4254 mpz_t * q_i
4255 SV * round
4256 CODE:
4257 RETVAL = Rmpc_set_z_z (aTHX_ p, q_r, q_i, round);
4258 OUTPUT: RETVAL
4259
4260 SV *
4261 Rmpc_set_q_q (p, q_r, q_i, round)
4262 mpc_t * p
4263 mpq_t * q_r
4264 mpq_t * q_i
4265 SV * round
4266 CODE:
4267 RETVAL = Rmpc_set_q_q (aTHX_ p, q_r, q_i, round);
4268 OUTPUT: RETVAL
4269
4270 SV *
4271 Rmpc_set_f_f (p, q_r, q_i, round)
4272 mpc_t * p
4273 mpf_t * q_r
4274 mpf_t * q_i
4275 SV * round
4276 CODE:
4277 RETVAL = Rmpc_set_f_f (aTHX_ p, q_r, q_i, round);
4278 OUTPUT: RETVAL
4279
4280 SV *
4281 Rmpc_set_fr_fr (p, q_r, q_i, round)
4282 mpc_t * p
4283 mpfr_t * q_r
4284 mpfr_t * q_i
4285 SV * round
4286 CODE:
4287 RETVAL = Rmpc_set_fr_fr (aTHX_ p, q_r, q_i, round);
4288 OUTPUT: RETVAL
4289
4290 SV *
4291 Rmpc_set_d_ui (mpc, d, ui, round)
4292 mpc_t * mpc
4293 SV * d
4294 SV * ui
4295 SV * round
4296 CODE:
4297 RETVAL = Rmpc_set_d_ui (aTHX_ mpc, d, ui, round);
4298 OUTPUT: RETVAL
4299
4300 SV *
4301 Rmpc_set_d_si (mpc, d, si, round)
4302 mpc_t * mpc
4303 SV * d
4304 SV * si
4305 SV * round
4306 CODE:
4307 RETVAL = Rmpc_set_d_si (aTHX_ mpc, d, si, round);
4308 OUTPUT: RETVAL
4309
4310 SV *
4311 Rmpc_set_d_fr (mpc, d, mpfr, round)
4312 mpc_t * mpc
4313 SV * d
4314 mpfr_t * mpfr
4315 SV * round
4316 CODE:
4317 RETVAL = Rmpc_set_d_fr (aTHX_ mpc, d, mpfr, round);
4318 OUTPUT: RETVAL
4319
4320 SV *
4321 Rmpc_set_ui_d (mpc, ui, d, round)
4322 mpc_t * mpc
4323 SV * ui
4324 SV * d
4325 SV * round
4326 CODE:
4327 RETVAL = Rmpc_set_ui_d (aTHX_ mpc, ui, d, round);
4328 OUTPUT: RETVAL
4329
4330 SV *
4331 Rmpc_set_ui_si (mpc, ui, si, round)
4332 mpc_t * mpc
4333 SV * ui
4334 SV * si
4335 SV * round
4336 CODE:
4337 RETVAL = Rmpc_set_ui_si (aTHX_ mpc, ui, si, round);
4338 OUTPUT: RETVAL
4339
4340 SV *
4341 Rmpc_set_ui_fr (mpc, ui, mpfr, round)
4342 mpc_t * mpc
4343 SV * ui
4344 mpfr_t * mpfr
4345 SV * round
4346 CODE:
4347 RETVAL = Rmpc_set_ui_fr (aTHX_ mpc, ui, mpfr, round);
4348 OUTPUT: RETVAL
4349
4350 SV *
4351 Rmpc_set_si_d (mpc, si, d, round)
4352 mpc_t * mpc
4353 SV * si
4354 SV * d
4355 SV * round
4356 CODE:
4357 RETVAL = Rmpc_set_si_d (aTHX_ mpc, si, d, round);
4358 OUTPUT: RETVAL
4359
4360 SV *
4361 Rmpc_set_si_ui (mpc, si, ui, round)
4362 mpc_t * mpc
4363 SV * si
4364 SV * ui
4365 SV * round
4366 CODE:
4367 RETVAL = Rmpc_set_si_ui (aTHX_ mpc, si, ui, round);
4368 OUTPUT: RETVAL
4369
4370 SV *
4371 Rmpc_set_si_fr (mpc, si, mpfr, round)
4372 mpc_t * mpc
4373 SV * si
4374 mpfr_t * mpfr
4375 SV * round
4376 CODE:
4377 RETVAL = Rmpc_set_si_fr (aTHX_ mpc, si, mpfr, round);
4378 OUTPUT: RETVAL
4379
4380 SV *
4381 Rmpc_set_fr_d (mpc, mpfr, d, round)
4382 mpc_t * mpc
4383 mpfr_t * mpfr
4384 SV * d
4385 SV * round
4386 CODE:
4387 RETVAL = Rmpc_set_fr_d (aTHX_ mpc, mpfr, d, round);
4388 OUTPUT: RETVAL
4389
4390 SV *
4391 Rmpc_set_fr_ui (mpc, mpfr, ui, round)
4392 mpc_t * mpc
4393 mpfr_t * mpfr
4394 SV * ui
4395 SV * round
4396 CODE:
4397 RETVAL = Rmpc_set_fr_ui (aTHX_ mpc, mpfr, ui, round);
4398 OUTPUT: RETVAL
4399
4400 SV *
4401 Rmpc_set_fr_si (mpc, mpfr, si, round)
4402 mpc_t * mpc
4403 mpfr_t * mpfr
4404 SV * si
4405 SV * round
4406 CODE:
4407 RETVAL = Rmpc_set_fr_si (aTHX_ mpc, mpfr, si, round);
4408 OUTPUT: RETVAL
4409
4410 SV *
4411 Rmpc_set_ld_ui (mpc, d, ui, round)
4412 mpc_t * mpc
4413 SV * d
4414 SV * ui
4415 SV * round
4416 CODE:
4417 RETVAL = Rmpc_set_ld_ui (aTHX_ mpc, d, ui, round);
4418 OUTPUT: RETVAL
4419
4420 SV *
4421 Rmpc_set_ld_si (mpc, d, si, round)
4422 mpc_t * mpc
4423 SV * d
4424 SV * si
4425 SV * round
4426 CODE:
4427 RETVAL = Rmpc_set_ld_si (aTHX_ mpc, d, si, round);
4428 OUTPUT: RETVAL
4429
4430 SV *
4431 Rmpc_set_ld_fr (mpc, d, mpfr, round)
4432 mpc_t * mpc
4433 SV * d
4434 mpfr_t * mpfr
4435 SV * round
4436 CODE:
4437 RETVAL = Rmpc_set_ld_fr (aTHX_ mpc, d, mpfr, round);
4438 OUTPUT: RETVAL
4439
4440 SV *
4441 Rmpc_set_ui_ld (mpc, ui, d, round)
4442 mpc_t * mpc
4443 SV * ui
4444 SV * d
4445 SV * round
4446 CODE:
4447 RETVAL = Rmpc_set_ui_ld (aTHX_ mpc, ui, d, round);
4448 OUTPUT: RETVAL
4449
4450 SV *
4451 Rmpc_set_si_ld (mpc, si, d, round)
4452 mpc_t * mpc
4453 SV * si
4454 SV * d
4455 SV * round
4456 CODE:
4457 RETVAL = Rmpc_set_si_ld (aTHX_ mpc, si, d, round);
4458 OUTPUT: RETVAL
4459
4460 SV *
4461 Rmpc_set_fr_ld (mpc, mpfr, d, round)
4462 mpc_t * mpc
4463 mpfr_t * mpfr
4464 SV * d
4465 SV * round
4466 CODE:
4467 RETVAL = Rmpc_set_fr_ld (aTHX_ mpc, mpfr, d, round);
4468 OUTPUT: RETVAL
4469
4470 SV *
4471 Rmpc_set_d_uj (mpc, d, ui, round)
4472 mpc_t * mpc
4473 SV * d
4474 SV * ui
4475 SV * round
4476 CODE:
4477 RETVAL = Rmpc_set_d_uj (aTHX_ mpc, d, ui, round);
4478 OUTPUT: RETVAL
4479
4480 SV *
4481 Rmpc_set_d_sj (mpc, d, si, round)
4482 mpc_t * mpc
4483 SV * d
4484 SV * si
4485 SV * round
4486 CODE:
4487 RETVAL = Rmpc_set_d_sj (aTHX_ mpc, d, si, round);
4488 OUTPUT: RETVAL
4489
4490 SV *
4491 Rmpc_set_sj_d (mpc, si, d, round)
4492 mpc_t * mpc
4493 SV * si
4494 SV * d
4495 SV * round
4496 CODE:
4497 RETVAL = Rmpc_set_sj_d (aTHX_ mpc, si, d, round);
4498 OUTPUT: RETVAL
4499
4500 SV *
4501 Rmpc_set_uj_d (mpc, ui, d, round)
4502 mpc_t * mpc
4503 SV * ui
4504 SV * d
4505 SV * round
4506 CODE:
4507 RETVAL = Rmpc_set_uj_d (aTHX_ mpc, ui, d, round);
4508 OUTPUT: RETVAL
4509
4510 SV *
4511 Rmpc_set_uj_fr (mpc, ui, mpfr, round)
4512 mpc_t * mpc
4513 SV * ui
4514 mpfr_t * mpfr
4515 SV * round
4516 CODE:
4517 RETVAL = Rmpc_set_uj_fr (aTHX_ mpc, ui, mpfr, round);
4518 OUTPUT: RETVAL
4519
4520 SV *
4521 Rmpc_set_sj_fr (mpc, si, mpfr, round)
4522 mpc_t * mpc
4523 SV * si
4524 mpfr_t * mpfr
4525 SV * round
4526 CODE:
4527 RETVAL = Rmpc_set_sj_fr (aTHX_ mpc, si, mpfr, round);
4528 OUTPUT: RETVAL
4529
4530 SV *
4531 Rmpc_set_fr_uj (mpc, mpfr, ui, round)
4532 mpc_t * mpc
4533 mpfr_t * mpfr
4534 SV * ui
4535 SV * round
4536 CODE:
4537 RETVAL = Rmpc_set_fr_uj (aTHX_ mpc, mpfr, ui, round);
4538 OUTPUT: RETVAL
4539
4540 SV *
4541 Rmpc_set_fr_sj (mpc, mpfr, si, round)
4542 mpc_t * mpc
4543 mpfr_t * mpfr
4544 SV * si
4545 SV * round
4546 CODE:
4547 RETVAL = Rmpc_set_fr_sj (aTHX_ mpc, mpfr, si, round);
4548 OUTPUT: RETVAL
4549
4550 SV *
4551 Rmpc_set_uj_sj (mpc, ui, si, round)
4552 mpc_t * mpc
4553 SV * ui
4554 SV * si
4555 SV * round
4556 CODE:
4557 RETVAL = Rmpc_set_uj_sj (aTHX_ mpc, ui, si, round);
4558 OUTPUT: RETVAL
4559
4560 SV *
4561 Rmpc_set_sj_uj (mpc, si, ui, round)
4562 mpc_t * mpc
4563 SV * si
4564 SV * ui
4565 SV * round
4566 CODE:
4567 RETVAL = Rmpc_set_sj_uj (aTHX_ mpc, si, ui, round);
4568 OUTPUT: RETVAL
4569
4570 SV *
4571 Rmpc_set_ld_uj (mpc, d, ui, round)
4572 mpc_t * mpc
4573 SV * d
4574 SV * ui
4575 SV * round
4576 CODE:
4577 RETVAL = Rmpc_set_ld_uj (aTHX_ mpc, d, ui, round);
4578 OUTPUT: RETVAL
4579
4580 SV *
4581 Rmpc_set_ld_sj (mpc, d, si, round)
4582 mpc_t * mpc
4583 SV * d
4584 SV * si
4585 SV * round
4586 CODE:
4587 RETVAL = Rmpc_set_ld_sj (aTHX_ mpc, d, si, round);
4588 OUTPUT: RETVAL
4589
4590 SV *
4591 Rmpc_set_uj_ld (mpc, ui, d, round)
4592 mpc_t * mpc
4593 SV * ui
4594 SV * d
4595 SV * round
4596 CODE:
4597 RETVAL = Rmpc_set_uj_ld (aTHX_ mpc, ui, d, round);
4598 OUTPUT: RETVAL
4599
4600 SV *
4601 Rmpc_set_sj_ld (mpc, si, d, round)
4602 mpc_t * mpc
4603 SV * si
4604 SV * d
4605 SV * round
4606 CODE:
4607 RETVAL = Rmpc_set_sj_ld (aTHX_ mpc, si, d, round);
4608 OUTPUT: RETVAL
4609
4610 SV *
4611 Rmpc_set_f_ui (mpc, mpf, ui, round)
4612 mpc_t * mpc
4613 mpf_t * mpf
4614 SV * ui
4615 SV * round
4616 CODE:
4617 RETVAL = Rmpc_set_f_ui (aTHX_ mpc, mpf, ui, round);
4618 OUTPUT: RETVAL
4619
4620 SV *
4621 Rmpc_set_q_ui (mpc, mpq, ui, round)
4622 mpc_t * mpc
4623 mpq_t * mpq
4624 SV * ui
4625 SV * round
4626 CODE:
4627 RETVAL = Rmpc_set_q_ui (aTHX_ mpc, mpq, ui, round);
4628 OUTPUT: RETVAL
4629
4630 SV *
4631 Rmpc_set_z_ui (mpc, mpz, ui, round)
4632 mpc_t * mpc
4633 mpz_t * mpz
4634 SV * ui
4635 SV * round
4636 CODE:
4637 RETVAL = Rmpc_set_z_ui (aTHX_ mpc, mpz, ui, round);
4638 OUTPUT: RETVAL
4639
4640 SV *
4641 Rmpc_set_f_si (mpc, mpf, si, round)
4642 mpc_t * mpc
4643 mpf_t * mpf
4644 SV * si
4645 SV * round
4646 CODE:
4647 RETVAL = Rmpc_set_f_si (aTHX_ mpc, mpf, si, round);
4648 OUTPUT: RETVAL
4649
4650 SV *
4651 Rmpc_set_q_si (mpc, mpq, si, round)
4652 mpc_t * mpc
4653 mpq_t * mpq
4654 SV * si
4655 SV * round
4656 CODE:
4657 RETVAL = Rmpc_set_q_si (aTHX_ mpc, mpq, si, round);
4658 OUTPUT: RETVAL
4659
4660 SV *
4661 Rmpc_set_z_si (mpc, mpz, si, round)
4662 mpc_t * mpc
4663 mpz_t * mpz
4664 SV * si
4665 SV * round
4666 CODE:
4667 RETVAL = Rmpc_set_z_si (aTHX_ mpc, mpz, si, round);
4668 OUTPUT: RETVAL
4669
4670 SV *
4671 Rmpc_set_f_d (mpc, mpf, d, round)
4672 mpc_t * mpc
4673 mpf_t * mpf
4674 SV * d
4675 SV * round
4676 CODE:
4677 RETVAL = Rmpc_set_f_d (aTHX_ mpc, mpf, d, round);
4678 OUTPUT: RETVAL
4679
4680 SV *
4681 Rmpc_set_q_d (mpc, mpq, d, round)
4682 mpc_t * mpc
4683 mpq_t * mpq
4684 SV * d
4685 SV * round
4686 CODE:
4687 RETVAL = Rmpc_set_q_d (aTHX_ mpc, mpq, d, round);
4688 OUTPUT: RETVAL
4689
4690 SV *
4691 Rmpc_set_z_d (mpc, mpz, d, round)
4692 mpc_t * mpc
4693 mpz_t * mpz
4694 SV * d
4695 SV * round
4696 CODE:
4697 RETVAL = Rmpc_set_z_d (aTHX_ mpc, mpz, d, round);
4698 OUTPUT: RETVAL
4699
4700 SV *
4701 Rmpc_set_f_uj (mpc, mpf, uj, round)
4702 mpc_t * mpc
4703 mpf_t * mpf
4704 SV * uj
4705 SV * round
4706 CODE:
4707 RETVAL = Rmpc_set_f_uj (aTHX_ mpc, mpf, uj, round);
4708 OUTPUT: RETVAL
4709
4710 SV *
4711 Rmpc_set_q_uj (mpc, mpq, uj, round)
4712 mpc_t * mpc
4713 mpq_t * mpq
4714 SV * uj
4715 SV * round
4716 CODE:
4717 RETVAL = Rmpc_set_q_uj (aTHX_ mpc, mpq, uj, round);
4718 OUTPUT: RETVAL
4719
4720 SV *
4721 Rmpc_set_z_uj (mpc, mpz, uj, round)
4722 mpc_t * mpc
4723 mpz_t * mpz
4724 SV * uj
4725 SV * round
4726 CODE:
4727 RETVAL = Rmpc_set_z_uj (aTHX_ mpc, mpz, uj, round);
4728 OUTPUT: RETVAL
4729
4730 SV *
4731 Rmpc_set_f_sj (mpc, mpf, sj, round)
4732 mpc_t * mpc
4733 mpf_t * mpf
4734 SV * sj
4735 SV * round
4736 CODE:
4737 RETVAL = Rmpc_set_f_sj (aTHX_ mpc, mpf, sj, round);
4738 OUTPUT: RETVAL
4739
4740 SV *
4741 Rmpc_set_q_sj (mpc, mpq, sj, round)
4742 mpc_t * mpc
4743 mpq_t * mpq
4744 SV * sj
4745 SV * round
4746 CODE:
4747 RETVAL = Rmpc_set_q_sj (aTHX_ mpc, mpq, sj, round);
4748 OUTPUT: RETVAL
4749
4750 SV *
4751 Rmpc_set_z_sj (mpc, mpz, sj, round)
4752 mpc_t * mpc
4753 mpz_t * mpz
4754 SV * sj
4755 SV * round
4756 CODE:
4757 RETVAL = Rmpc_set_z_sj (aTHX_ mpc, mpz, sj, round);
4758 OUTPUT: RETVAL
4759
4760 SV *
4761 Rmpc_set_f_ld (mpc, mpf, ld, round)
4762 mpc_t * mpc
4763 mpf_t * mpf
4764 SV * ld
4765 SV * round
4766 CODE:
4767 RETVAL = Rmpc_set_f_ld (aTHX_ mpc, mpf, ld, round);
4768 OUTPUT: RETVAL
4769
4770 SV *
4771 Rmpc_set_q_ld (mpc, mpq, ld, round)
4772 mpc_t * mpc
4773 mpq_t * mpq
4774 SV * ld
4775 SV * round
4776 CODE:
4777 RETVAL = Rmpc_set_q_ld (aTHX_ mpc, mpq, ld, round);
4778 OUTPUT: RETVAL
4779
4780 SV *
4781 Rmpc_set_z_ld (mpc, mpz, ld, round)
4782 mpc_t * mpc
4783 mpz_t * mpz
4784 SV * ld
4785 SV * round
4786 CODE:
4787 RETVAL = Rmpc_set_z_ld (aTHX_ mpc, mpz, ld, round);
4788 OUTPUT: RETVAL
4789
4790 SV *
4791 Rmpc_set_ui_f (mpc, ui, mpf, round)
4792 mpc_t * mpc
4793 SV * ui
4794 mpf_t * mpf
4795 SV * round
4796 CODE:
4797 RETVAL = Rmpc_set_ui_f (aTHX_ mpc, ui, mpf, round);
4798 OUTPUT: RETVAL
4799
4800 SV *
4801 Rmpc_set_ui_q (mpc, ui, mpq, round)
4802 mpc_t * mpc
4803 SV * ui
4804 mpq_t * mpq
4805 SV * round
4806 CODE:
4807 RETVAL = Rmpc_set_ui_q (aTHX_ mpc, ui, mpq, round);
4808 OUTPUT: RETVAL
4809
4810 SV *
4811 Rmpc_set_ui_z (mpc, ui, mpz, round)
4812 mpc_t * mpc
4813 SV * ui
4814 mpz_t * mpz
4815 SV * round
4816 CODE:
4817 RETVAL = Rmpc_set_ui_z (aTHX_ mpc, ui, mpz, round);
4818 OUTPUT: RETVAL
4819
4820 SV *
4821 Rmpc_set_si_f (mpc, si, mpf, round)
4822 mpc_t * mpc
4823 SV * si
4824 mpf_t * mpf
4825 SV * round
4826 CODE:
4827 RETVAL = Rmpc_set_si_f (aTHX_ mpc, si, mpf, round);
4828 OUTPUT: RETVAL
4829
4830 SV *
4831 Rmpc_set_si_q (mpc, si, mpq, round)
4832 mpc_t * mpc
4833 SV * si
4834 mpq_t * mpq
4835 SV * round
4836 CODE:
4837 RETVAL = Rmpc_set_si_q (aTHX_ mpc, si, mpq, round);
4838 OUTPUT: RETVAL
4839
4840 SV *
4841 Rmpc_set_si_z (mpc, si, mpz, round)
4842 mpc_t * mpc
4843 SV * si
4844 mpz_t * mpz
4845 SV * round
4846 CODE:
4847 RETVAL = Rmpc_set_si_z (aTHX_ mpc, si, mpz, round);
4848 OUTPUT: RETVAL
4849
4850 SV *
4851 Rmpc_set_d_f (mpc, d, mpf, round)
4852 mpc_t * mpc
4853 SV * d
4854 mpf_t * mpf
4855 SV * round
4856 CODE:
4857 RETVAL = Rmpc_set_d_f (aTHX_ mpc, d, mpf, round);
4858 OUTPUT: RETVAL
4859
4860 SV *
4861 Rmpc_set_d_q (mpc, d, mpq, round)
4862 mpc_t * mpc
4863 SV * d
4864 mpq_t * mpq
4865 SV * round
4866 CODE:
4867 RETVAL = Rmpc_set_d_q (aTHX_ mpc, d, mpq, round);
4868 OUTPUT: RETVAL
4869
4870 SV *
4871 Rmpc_set_d_z (mpc, d, mpz, round)
4872 mpc_t * mpc
4873 SV * d
4874 mpz_t * mpz
4875 SV * round
4876 CODE:
4877 RETVAL = Rmpc_set_d_z (aTHX_ mpc, d, mpz, round);
4878 OUTPUT: RETVAL
4879
4880 SV *
4881 Rmpc_set_uj_f (mpc, uj, mpf, round)
4882 mpc_t * mpc
4883 SV * uj
4884 mpf_t * mpf
4885 SV * round
4886 CODE:
4887 RETVAL = Rmpc_set_uj_f (aTHX_ mpc, uj, mpf, round);
4888 OUTPUT: RETVAL
4889
4890 SV *
4891 Rmpc_set_uj_q (mpc, uj, mpq, round)
4892 mpc_t * mpc
4893 SV * uj
4894 mpq_t * mpq
4895 SV * round
4896 CODE:
4897 RETVAL = Rmpc_set_uj_q (aTHX_ mpc, uj, mpq, round);
4898 OUTPUT: RETVAL
4899
4900 SV *
4901 Rmpc_set_uj_z (mpc, uj, mpz, round)
4902 mpc_t * mpc
4903 SV * uj
4904 mpz_t * mpz
4905 SV * round
4906 CODE:
4907 RETVAL = Rmpc_set_uj_z (aTHX_ mpc, uj, mpz, round);
4908 OUTPUT: RETVAL
4909
4910 SV *
4911 Rmpc_set_sj_f (mpc, sj, mpf, round)
4912 mpc_t * mpc
4913 SV * sj
4914 mpf_t * mpf
4915 SV * round
4916 CODE:
4917 RETVAL = Rmpc_set_sj_f (aTHX_ mpc, sj, mpf, round);
4918 OUTPUT: RETVAL
4919
4920 SV *
4921 Rmpc_set_sj_q (mpc, sj, mpq, round)
4922 mpc_t * mpc
4923 SV * sj
4924 mpq_t * mpq
4925 SV * round
4926 CODE:
4927 RETVAL = Rmpc_set_sj_q (aTHX_ mpc, sj, mpq, round);
4928 OUTPUT: RETVAL
4929
4930 SV *
4931 Rmpc_set_sj_z (mpc, sj, mpz, round)
4932 mpc_t * mpc
4933 SV * sj
4934 mpz_t * mpz
4935 SV * round
4936 CODE:
4937 RETVAL = Rmpc_set_sj_z (aTHX_ mpc, sj, mpz, round);
4938 OUTPUT: RETVAL
4939
4940 SV *
4941 Rmpc_set_ld_f (mpc, ld, mpf, round)
4942 mpc_t * mpc
4943 SV * ld
4944 mpf_t * mpf
4945 SV * round
4946 CODE:
4947 RETVAL = Rmpc_set_ld_f (aTHX_ mpc, ld, mpf, round);
4948 OUTPUT: RETVAL
4949
4950 SV *
4951 Rmpc_set_ld_q (mpc, ld, mpq, round)
4952 mpc_t * mpc
4953 SV * ld
4954 mpq_t * mpq
4955 SV * round
4956 CODE:
4957 RETVAL = Rmpc_set_ld_q (aTHX_ mpc, ld, mpq, round);
4958 OUTPUT: RETVAL
4959
4960 SV *
4961 Rmpc_set_ld_z (mpc, ld, mpz, round)
4962 mpc_t * mpc
4963 SV * ld
4964 mpz_t * mpz
4965 SV * round
4966 CODE:
4967 RETVAL = Rmpc_set_ld_z (aTHX_ mpc, ld, mpz, round);
4968 OUTPUT: RETVAL
4969
4970 SV *
4971 Rmpc_set_f_q (mpc, mpf, mpq, round)
4972 mpc_t * mpc
4973 mpf_t * mpf
4974 mpq_t * mpq
4975 SV * round
4976 CODE:
4977 RETVAL = Rmpc_set_f_q (aTHX_ mpc, mpf, mpq, round);
4978 OUTPUT: RETVAL
4979
4980 SV *
4981 Rmpc_set_q_f (mpc, mpq, mpf, round)
4982 mpc_t * mpc
4983 mpq_t * mpq
4984 mpf_t * mpf
4985 SV * round
4986 CODE:
4987 RETVAL = Rmpc_set_q_f (aTHX_ mpc, mpq, mpf, round);
4988 OUTPUT: RETVAL
4989
4990 SV *
4991 Rmpc_set_f_z (mpc, mpf, mpz, round)
4992 mpc_t * mpc
4993 mpf_t * mpf
4994 mpz_t * mpz
4995 SV * round
4996 CODE:
4997 RETVAL = Rmpc_set_f_z (aTHX_ mpc, mpf, mpz, round);
4998 OUTPUT: RETVAL
4999
5000 SV *
5001 Rmpc_set_z_f (mpc, mpz, mpf, round)
5002 mpc_t * mpc
5003 mpz_t * mpz
5004 mpf_t * mpf
5005 SV * round
5006 CODE:
5007 RETVAL = Rmpc_set_z_f (aTHX_ mpc, mpz, mpf, round);
5008 OUTPUT: RETVAL
5009
5010 SV *
5011 Rmpc_set_q_z (mpc, mpq, mpz, round)
5012 mpc_t * mpc
5013 mpq_t * mpq
5014 mpz_t * mpz
5015 SV * round
5016 CODE:
5017 RETVAL = Rmpc_set_q_z (aTHX_ mpc, mpq, mpz, round);
5018 OUTPUT: RETVAL
5019
5020 SV *
5021 Rmpc_set_z_q (mpc, mpz, mpq, round)
5022 mpc_t * mpc
5023 mpz_t * mpz
5024 mpq_t * mpq
5025 SV * round
5026 CODE:
5027 RETVAL = Rmpc_set_z_q (aTHX_ mpc, mpz, mpq, round);
5028 OUTPUT: RETVAL
5029
5030 SV *
5031 Rmpc_set_f_fr (mpc, mpf, mpfr, round)
5032 mpc_t * mpc
5033 mpf_t * mpf
5034 mpfr_t * mpfr
5035 SV * round
5036 CODE:
5037 RETVAL = Rmpc_set_f_fr (aTHX_ mpc, mpf, mpfr, round);
5038 OUTPUT: RETVAL
5039
5040 SV *
5041 Rmpc_set_fr_f (mpc, mpfr, mpf, round)
5042 mpc_t * mpc
5043 mpfr_t * mpfr
5044 mpf_t * mpf
5045 SV * round
5046 CODE:
5047 RETVAL = Rmpc_set_fr_f (aTHX_ mpc, mpfr, mpf, round);
5048 OUTPUT: RETVAL
5049
5050 SV *
5051 Rmpc_set_q_fr (mpc, mpq, mpfr, round)
5052 mpc_t * mpc
5053 mpq_t * mpq
5054 mpfr_t * mpfr
5055 SV * round
5056 CODE:
5057 RETVAL = Rmpc_set_q_fr (aTHX_ mpc, mpq, mpfr, round);
5058 OUTPUT: RETVAL
5059
5060 SV *
5061 Rmpc_set_fr_q (mpc, mpfr, mpq, round)
5062 mpc_t * mpc
5063 mpfr_t * mpfr
5064 mpq_t * mpq
5065 SV * round
5066 CODE:
5067 RETVAL = Rmpc_set_fr_q (aTHX_ mpc, mpfr, mpq, round);
5068 OUTPUT: RETVAL
5069
5070 SV *
5071 Rmpc_set_z_fr (mpc, mpz, mpfr, round)
5072 mpc_t * mpc
5073 mpz_t * mpz
5074 mpfr_t * mpfr
5075 SV * round
5076 CODE:
5077 RETVAL = Rmpc_set_z_fr (aTHX_ mpc, mpz, mpfr, round);
5078 OUTPUT: RETVAL
5079
5080 SV *
5081 Rmpc_set_fr_z (mpc, mpfr, mpz, round)
5082 mpc_t * mpc
5083 mpfr_t * mpfr
5084 mpz_t * mpz
5085 SV * round
5086 CODE:
5087 RETVAL = Rmpc_set_fr_z (aTHX_ mpc, mpfr, mpz, round);
5088 OUTPUT: RETVAL
5089
5090 SV *
5091 Rmpc_set_uj_uj (mpc, uj1, uj2, round)
5092 mpc_t * mpc
5093 SV * uj1
5094 SV * uj2
5095 SV * round
5096 CODE:
5097 RETVAL = Rmpc_set_uj_uj (aTHX_ mpc, uj1, uj2, round);
5098 OUTPUT: RETVAL
5099
5100 SV *
5101 Rmpc_set_sj_sj (mpc, sj1, sj2, round)
5102 mpc_t * mpc
5103 SV * sj1
5104 SV * sj2
5105 SV * round
5106 CODE:
5107 RETVAL = Rmpc_set_sj_sj (aTHX_ mpc, sj1, sj2, round);
5108 OUTPUT: RETVAL
5109
5110 SV *
5111 Rmpc_add (a, b, c, round)
5112 mpc_t * a
5113 mpc_t * b
5114 mpc_t * c
5115 SV * round
5116 CODE:
5117 RETVAL = Rmpc_add (aTHX_ a, b, c, round);
5118 OUTPUT: RETVAL
5119
5120 SV *
5121 Rmpc_add_ui (a, b, c, round)
5122 mpc_t * a
5123 mpc_t * b
5124 SV * c
5125 SV * round
5126 CODE:
5127 RETVAL = Rmpc_add_ui (aTHX_ a, b, c, round);
5128 OUTPUT: RETVAL
5129
5130 SV *
5131 Rmpc_add_fr (a, b, c, round)
5132 mpc_t * a
5133 mpc_t * b
5134 mpfr_t * c
5135 SV * round
5136 CODE:
5137 RETVAL = Rmpc_add_fr (aTHX_ a, b, c, round);
5138 OUTPUT: RETVAL
5139
5140 SV *
5141 Rmpc_sub (a, b, c, round)
5142 mpc_t * a
5143 mpc_t * b
5144 mpc_t * c
5145 SV * round
5146 CODE:
5147 RETVAL = Rmpc_sub (aTHX_ a, b, c, round);
5148 OUTPUT: RETVAL
5149
5150 SV *
5151 Rmpc_sub_ui (a, b, c, round)
5152 mpc_t * a
5153 mpc_t * b
5154 SV * c
5155 SV * round
5156 CODE:
5157 RETVAL = Rmpc_sub_ui (aTHX_ a, b, c, round);
5158 OUTPUT: RETVAL
5159
5160 SV *
5161 Rmpc_ui_sub (a, b, c, round)
5162 mpc_t * a
5163 SV * b
5164 mpc_t * c
5165 SV * round
5166 CODE:
5167 RETVAL = Rmpc_ui_sub (aTHX_ a, b, c, round);
5168 OUTPUT: RETVAL
5169
5170 SV *
5171 Rmpc_ui_ui_sub (a, b_r, b_i, c, round)
5172 mpc_t * a
5173 SV * b_r
5174 SV * b_i
5175 mpc_t * c
5176 SV * round
5177 CODE:
5178 RETVAL = Rmpc_ui_ui_sub (aTHX_ a, b_r, b_i, c, round);
5179 OUTPUT: RETVAL
5180
5181 SV *
5182 Rmpc_mul (a, b, c, round)
5183 mpc_t * a
5184 mpc_t * b
5185 mpc_t * c
5186 SV * round
5187 CODE:
5188 RETVAL = Rmpc_mul (aTHX_ a, b, c, round);
5189 OUTPUT: RETVAL
5190
5191 SV *
5192 Rmpc_mul_ui (a, b, c, round)
5193 mpc_t * a
5194 mpc_t * b
5195 SV * c
5196 SV * round
5197 CODE:
5198 RETVAL = Rmpc_mul_ui (aTHX_ a, b, c, round);
5199 OUTPUT: RETVAL
5200
5201 SV *
5202 Rmpc_mul_si (a, b, c, round)
5203 mpc_t * a
5204 mpc_t * b
5205 SV * c
5206 SV * round
5207 CODE:
5208 RETVAL = Rmpc_mul_si (aTHX_ a, b, c, round);
5209 OUTPUT: RETVAL
5210
5211 SV *
5212 Rmpc_mul_fr (a, b, c, round)
5213 mpc_t * a
5214 mpc_t * b
5215 mpfr_t * c
5216 SV * round
5217 CODE:
5218 RETVAL = Rmpc_mul_fr (aTHX_ a, b, c, round);
5219 OUTPUT: RETVAL
5220
5221 SV *
5222 Rmpc_mul_i (a, b, sign, round)
5223 mpc_t * a
5224 mpc_t * b
5225 SV * sign
5226 SV * round
5227 CODE:
5228 RETVAL = Rmpc_mul_i (aTHX_ a, b, sign, round);
5229 OUTPUT: RETVAL
5230
5231 SV *
5232 Rmpc_sqr (a, b, round)
5233 mpc_t * a
5234 mpc_t * b
5235 SV * round
5236 CODE:
5237 RETVAL = Rmpc_sqr (aTHX_ a, b, round);
5238 OUTPUT: RETVAL
5239
5240 SV *
5241 Rmpc_div (a, b, c, round)
5242 mpc_t * a
5243 mpc_t * b
5244 mpc_t * c
5245 SV * round
5246 CODE:
5247 RETVAL = Rmpc_div (aTHX_ a, b, c, round);
5248 OUTPUT: RETVAL
5249
5250 SV *
5251 Rmpc_div_ui (a, b, c, round)
5252 mpc_t * a
5253 mpc_t * b
5254 SV * c
5255 SV * round
5256 CODE:
5257 RETVAL = Rmpc_div_ui (aTHX_ a, b, c, round);
5258 OUTPUT: RETVAL
5259
5260 SV *
5261 Rmpc_ui_div (a, b, c, round)
5262 mpc_t * a
5263 SV * b
5264 mpc_t * c
5265 SV * round
5266 CODE:
5267 RETVAL = Rmpc_ui_div (aTHX_ a, b, c, round);
5268 OUTPUT: RETVAL
5269
5270 SV *
5271 Rmpc_div_fr (a, b, c, round)
5272 mpc_t * a
5273 mpc_t * b
5274 mpfr_t * c
5275 SV * round
5276 CODE:
5277 RETVAL = Rmpc_div_fr (aTHX_ a, b, c, round);
5278 OUTPUT: RETVAL
5279
5280 SV *
5281 Rmpc_sqrt (a, b, round)
5282 mpc_t * a
5283 mpc_t * b
5284 SV * round
5285 CODE:
5286 RETVAL = Rmpc_sqrt (aTHX_ a, b, round);
5287 OUTPUT: RETVAL
5288
5289 SV *
5290 Rmpc_pow (a, b, pow, round)
5291 mpc_t * a
5292 mpc_t * b
5293 mpc_t * pow
5294 SV * round
5295 CODE:
5296 RETVAL = Rmpc_pow (aTHX_ a, b, pow, round);
5297 OUTPUT: RETVAL
5298
5299 SV *
5300 Rmpc_pow_d (a, b, pow, round)
5301 mpc_t * a
5302 mpc_t * b
5303 SV * pow
5304 SV * round
5305 CODE:
5306 RETVAL = Rmpc_pow_d (aTHX_ a, b, pow, round);
5307 OUTPUT: RETVAL
5308
5309 SV *
5310 Rmpc_pow_ld (a, b, pow, round)
5311 mpc_t * a
5312 mpc_t * b
5313 SV * pow
5314 SV * round
5315 CODE:
5316 RETVAL = Rmpc_pow_ld (aTHX_ a, b, pow, round);
5317 OUTPUT: RETVAL
5318
5319 SV *
5320 Rmpc_pow_si (a, b, pow, round)
5321 mpc_t * a
5322 mpc_t * b
5323 SV * pow
5324 SV * round
5325 CODE:
5326 RETVAL = Rmpc_pow_si (aTHX_ a, b, pow, round);
5327 OUTPUT: RETVAL
5328
5329 SV *
5330 Rmpc_pow_ui (a, b, pow, round)
5331 mpc_t * a
5332 mpc_t * b
5333 SV * pow
5334 SV * round
5335 CODE:
5336 RETVAL = Rmpc_pow_ui (aTHX_ a, b, pow, round);
5337 OUTPUT: RETVAL
5338
5339 SV *
5340 Rmpc_pow_z (a, b, pow, round)
5341 mpc_t * a
5342 mpc_t * b
5343 mpz_t * pow
5344 SV * round
5345 CODE:
5346 RETVAL = Rmpc_pow_z (aTHX_ a, b, pow, round);
5347 OUTPUT: RETVAL
5348
5349 SV *
5350 Rmpc_pow_fr (a, b, pow, round)
5351 mpc_t * a
5352 mpc_t * b
5353 mpfr_t * pow
5354 SV * round
5355 CODE:
5356 RETVAL = Rmpc_pow_fr (aTHX_ a, b, pow, round);
5357 OUTPUT: RETVAL
5358
5359 SV *
5360 Rmpc_neg (a, b, round)
5361 mpc_t * a
5362 mpc_t * b
5363 SV * round
5364 CODE:
5365 RETVAL = Rmpc_neg (aTHX_ a, b, round);
5366 OUTPUT: RETVAL
5367
5368 SV *
5369 Rmpc_abs (a, b, round)
5370 mpfr_t * a
5371 mpc_t * b
5372 SV * round
5373 CODE:
5374 RETVAL = Rmpc_abs (aTHX_ a, b, round);
5375 OUTPUT: RETVAL
5376
5377 SV *
5378 Rmpc_conj (a, b, round)
5379 mpc_t * a
5380 mpc_t * b
5381 SV * round
5382 CODE:
5383 RETVAL = Rmpc_conj (aTHX_ a, b, round);
5384 OUTPUT: RETVAL
5385
5386 SV *
5387 Rmpc_norm (a, b, round)
5388 mpfr_t * a
5389 mpc_t * b
5390 SV * round
5391 CODE:
5392 RETVAL = Rmpc_norm (aTHX_ a, b, round);
5393 OUTPUT: RETVAL
5394
5395 SV *
5396 Rmpc_mul_2ui (a, b, c, round)
5397 mpc_t * a
5398 mpc_t * b
5399 SV * c
5400 SV * round
5401 CODE:
5402 RETVAL = Rmpc_mul_2ui (aTHX_ a, b, c, round);
5403 OUTPUT: RETVAL
5404
5405 SV *
5406 Rmpc_div_2ui (a, b, c, round)
5407 mpc_t * a
5408 mpc_t * b
5409 SV * c
5410 SV * round
5411 CODE:
5412 RETVAL = Rmpc_div_2ui (aTHX_ a, b, c, round);
5413 OUTPUT: RETVAL
5414
5415 SV *
5416 Rmpc_cmp (a, b)
5417 mpc_t * a
5418 mpc_t * b
5419 CODE:
5420 RETVAL = Rmpc_cmp (aTHX_ a, b);
5421 OUTPUT: RETVAL
5422
5423 SV *
5424 Rmpc_cmp_si (a, b)
5425 mpc_t * a
5426 SV * b
5427 CODE:
5428 RETVAL = Rmpc_cmp_si (aTHX_ a, b);
5429 OUTPUT: RETVAL
5430
5431 SV *
5432 Rmpc_cmp_si_si (a, b, c)
5433 mpc_t * a
5434 SV * b
5435 SV * c
5436 CODE:
5437 RETVAL = Rmpc_cmp_si_si (aTHX_ a, b, c);
5438 OUTPUT: RETVAL
5439
5440 SV *
5441 Rmpc_exp (a, b, round)
5442 mpc_t * a
5443 mpc_t * b
5444 SV * round
5445 CODE:
5446 RETVAL = Rmpc_exp (aTHX_ a, b, round);
5447 OUTPUT: RETVAL
5448
5449 SV *
5450 Rmpc_log (rop, op, round)
5451 mpc_t * rop
5452 mpc_t * op
5453 SV * round
5454 CODE:
5455 RETVAL = Rmpc_log (aTHX_ rop, op, round);
5456 OUTPUT: RETVAL
5457
5458 SV *
5459 _Rmpc_out_str (stream, base, dig, p, round)
5460 FILE * stream
5461 SV * base
5462 SV * dig
5463 mpc_t * p
5464 SV * round
5465 CODE:
5466 RETVAL = _Rmpc_out_str (aTHX_ stream, base, dig, p, round);
5467 OUTPUT: RETVAL
5468
5469 SV *
5470 _Rmpc_out_strS (stream, base, dig, p, round, suff)
5471 FILE * stream
5472 SV * base
5473 SV * dig
5474 mpc_t * p
5475 SV * round
5476 SV * suff
5477 CODE:
5478 RETVAL = _Rmpc_out_strS (aTHX_ stream, base, dig, p, round, suff);
5479 OUTPUT: RETVAL
5480
5481 SV *
5482 _Rmpc_out_strP (pre, stream, base, dig, p, round)
5483 SV * pre
5484 FILE * stream
5485 SV * base
5486 SV * dig
5487 mpc_t * p
5488 SV * round
5489 CODE:
5490 RETVAL = _Rmpc_out_strP (aTHX_ pre, stream, base, dig, p, round);
5491 OUTPUT: RETVAL
5492
5493 SV *
5494 _Rmpc_out_strPS (pre, stream, base, dig, p, round, suff)
5495 SV * pre
5496 FILE * stream
5497 SV * base
5498 SV * dig
5499 mpc_t * p
5500 SV * round
5501 SV * suff
5502 CODE:
5503 RETVAL = _Rmpc_out_strPS (aTHX_ pre, stream, base, dig, p, round, suff);
5504 OUTPUT: RETVAL
5505
5506 int
5507 Rmpc_inp_str (p, stream, base, round)
5508 mpc_t * p
5509 FILE * stream
5510 SV * base
5511 SV * round
5512 CODE:
5513 RETVAL = Rmpc_inp_str (aTHX_ p, stream, base, round);
5514 OUTPUT: RETVAL
5515
5516 SV *
5517 Rmpc_sin (rop, op, round)
5518 mpc_t * rop
5519 mpc_t * op
5520 SV * round
5521 CODE:
5522 RETVAL = Rmpc_sin (aTHX_ rop, op, round);
5523 OUTPUT: RETVAL
5524
5525 SV *
5526 Rmpc_cos (rop, op, round)
5527 mpc_t * rop
5528 mpc_t * op
5529 SV * round
5530 CODE:
5531 RETVAL = Rmpc_cos (aTHX_ rop, op, round);
5532 OUTPUT: RETVAL
5533
5534 SV *
5535 Rmpc_tan (rop, op, round)
5536 mpc_t * rop
5537 mpc_t * op
5538 SV * round
5539 CODE:
5540 RETVAL = Rmpc_tan (aTHX_ rop, op, round);
5541 OUTPUT: RETVAL
5542
5543 SV *
5544 Rmpc_sinh (rop, op, round)
5545 mpc_t * rop
5546 mpc_t * op
5547 SV * round
5548 CODE:
5549 RETVAL = Rmpc_sinh (aTHX_ rop, op, round);
5550 OUTPUT: RETVAL
5551
5552 SV *
5553 Rmpc_cosh (rop, op, round)
5554 mpc_t * rop
5555 mpc_t * op
5556 SV * round
5557 CODE:
5558 RETVAL = Rmpc_cosh (aTHX_ rop, op, round);
5559 OUTPUT: RETVAL
5560
5561 SV *
5562 Rmpc_tanh (rop, op, round)
5563 mpc_t * rop
5564 mpc_t * op
5565 SV * round
5566 CODE:
5567 RETVAL = Rmpc_tanh (aTHX_ rop, op, round);
5568 OUTPUT: RETVAL
5569
5570 SV *
5571 Rmpc_asin (rop, op, round)
5572 mpc_t * rop
5573 mpc_t * op
5574 SV * round
5575 CODE:
5576 RETVAL = Rmpc_asin (aTHX_ rop, op, round);
5577 OUTPUT: RETVAL
5578
5579 SV *
5580 Rmpc_acos (rop, op, round)
5581 mpc_t * rop
5582 mpc_t * op
5583 SV * round
5584 CODE:
5585 RETVAL = Rmpc_acos (aTHX_ rop, op, round);
5586 OUTPUT: RETVAL
5587
5588 SV *
5589 Rmpc_atan (rop, op, round)
5590 mpc_t * rop
5591 mpc_t * op
5592 SV * round
5593 CODE:
5594 RETVAL = Rmpc_atan (aTHX_ rop, op, round);
5595 OUTPUT: RETVAL
5596
5597 SV *
5598 Rmpc_asinh (rop, op, round)
5599 mpc_t * rop
5600 mpc_t * op
5601 SV * round
5602 CODE:
5603 RETVAL = Rmpc_asinh (aTHX_ rop, op, round);
5604 OUTPUT: RETVAL
5605
5606 SV *
5607 Rmpc_acosh (rop, op, round)
5608 mpc_t * rop
5609 mpc_t * op
5610 SV * round
5611 CODE:
5612 RETVAL = Rmpc_acosh (aTHX_ rop, op, round);
5613 OUTPUT: RETVAL
5614
5615 SV *
5616 Rmpc_atanh (rop, op, round)
5617 mpc_t * rop
5618 mpc_t * op
5619 SV * round
5620 CODE:
5621 RETVAL = Rmpc_atanh (aTHX_ rop, op, round);
5622 OUTPUT: RETVAL
5623
5624 SV *
5625 overload_true (a, second, third)
5626 mpc_t * a
5627 SV * second
5628 SV * third
5629 CODE:
5630 RETVAL = overload_true (aTHX_ a, second, third);
5631 OUTPUT: RETVAL
5632
5633 SV *
5634 overload_mul (a, b, third)
5635 mpc_t * a
5636 SV * b
5637 SV * third
5638 CODE:
5639 RETVAL = overload_mul (aTHX_ a, b, third);
5640 OUTPUT: RETVAL
5641
5642 SV *
5643 overload_add (a, b, third)
5644 mpc_t * a
5645 SV * b
5646 SV * third
5647 CODE:
5648 RETVAL = overload_add (aTHX_ a, b, third);
5649 OUTPUT: RETVAL
5650
5651 SV *
5652 overload_sub (a, b, third)
5653 mpc_t * a
5654 SV * b
5655 SV * third
5656 CODE:
5657 RETVAL = overload_sub (aTHX_ a, b, third);
5658 OUTPUT: RETVAL
5659
5660 SV *
5661 overload_div (a, b, third)
5662 mpc_t * a
5663 SV * b
5664 SV * third
5665 CODE:
5666 RETVAL = overload_div (aTHX_ a, b, third);
5667 OUTPUT: RETVAL
5668
5669 SV *
5670 overload_div_eq (a, b, third)
5671 SV * a
5672 SV * b
5673 SV * third
5674 CODE:
5675 RETVAL = overload_div_eq (aTHX_ a, b, third);
5676 OUTPUT: RETVAL
5677
5678 SV *
5679 overload_sub_eq (a, b, third)
5680 SV * a
5681 SV * b
5682 SV * third
5683 CODE:
5684 RETVAL = overload_sub_eq (aTHX_ a, b, third);
5685 OUTPUT: RETVAL
5686
5687 SV *
5688 overload_add_eq (a, b, third)
5689 SV * a
5690 SV * b
5691 SV * third
5692 CODE:
5693 RETVAL = overload_add_eq (aTHX_ a, b, third);
5694 OUTPUT: RETVAL
5695
5696 SV *
5697 overload_mul_eq (a, b, third)
5698 SV * a
5699 SV * b
5700 SV * third
5701 CODE:
5702 RETVAL = overload_mul_eq (aTHX_ a, b, third);
5703 OUTPUT: RETVAL
5704
5705 SV *
5706 overload_pow (a, b, third)
5707 mpc_t * a
5708 SV * b
5709 SV * third
5710 CODE:
5711 RETVAL = overload_pow (aTHX_ a, b, third);
5712 OUTPUT: RETVAL
5713
5714 SV *
5715 overload_pow_eq (a, b, third)
5716 SV * a
5717 SV * b
5718 SV * third
5719 CODE:
5720 RETVAL = overload_pow_eq (aTHX_ a, b, third);
5721 OUTPUT: RETVAL
5722
5723 SV *
5724 overload_equiv (a, b, third)
5725 mpc_t * a
5726 SV * b
5727 SV * third
5728 CODE:
5729 RETVAL = overload_equiv (aTHX_ a, b, third);
5730 OUTPUT: RETVAL
5731
5732 SV *
5733 overload_not (a, second, third)
5734 mpc_t * a
5735 SV * second
5736 SV * third
5737 CODE:
5738 RETVAL = overload_not (aTHX_ a, second, third);
5739 OUTPUT: RETVAL
5740
5741 SV *
5742 overload_sqrt (p, second, third)
5743 mpc_t * p
5744 SV * second
5745 SV * third
5746 CODE:
5747 RETVAL = overload_sqrt (aTHX_ p, second, third);
5748 OUTPUT: RETVAL
5749
5750 void
5751 overload_copy (p, second, third)
5752 mpc_t * p
5753 SV * second
5754 SV * third
5755 PREINIT:
5756 I32* temp;
5757 PPCODE:
5758 temp = PL_markstack_ptr++;
5759 overload_copy(aTHX_ p, second, third);
5760 if (PL_markstack_ptr != temp) {
5761 /* truly void, because dXSARGS not invoked */
5762 PL_markstack_ptr = temp;
5763 XSRETURN_EMPTY; /* return empty stack */
5764 }
5765 /* must have used dXSARGS; list context implied */
5766 return; /* assume stack size is correct */
5767
5768 SV *
5769 overload_abs (p, second, third)
5770 mpc_t * p
5771 SV * second
5772 SV * third
5773 CODE:
5774 RETVAL = overload_abs (aTHX_ p, second, third);
5775 OUTPUT: RETVAL
5776
5777 SV *
5778 overload_exp (p, second, third)
5779 mpc_t * p
5780 SV * second
5781 SV * third
5782 CODE:
5783 RETVAL = overload_exp (aTHX_ p, second, third);
5784 OUTPUT: RETVAL
5785
5786 SV *
5787 overload_log (p, second, third)
5788 mpc_t * p
5789 SV * second
5790 SV * third
5791 CODE:
5792 RETVAL = overload_log (aTHX_ p, second, third);
5793 OUTPUT: RETVAL
5794
5795 SV *
5796 overload_sin (p, second, third)
5797 mpc_t * p
5798 SV * second
5799 SV * third
5800 CODE:
5801 RETVAL = overload_sin (aTHX_ p, second, third);
5802 OUTPUT: RETVAL
5803
5804 SV *
5805 overload_cos (p, second, third)
5806 mpc_t * p
5807 SV * second
5808 SV * third
5809 CODE:
5810 RETVAL = overload_cos (aTHX_ p, second, third);
5811 OUTPUT: RETVAL
5812
5813 void
5814 _get_r_string (p, base, n_digits, round)
5815 mpc_t * p
5816 SV * base
5817 SV * n_digits
5818 SV * round
5819 PREINIT:
5820 I32* temp;
5821 PPCODE:
5822 temp = PL_markstack_ptr++;
5823 _get_r_string(aTHX_ p, base, n_digits, round);
5824 if (PL_markstack_ptr != temp) {
5825 /* truly void, because dXSARGS not invoked */
5826 PL_markstack_ptr = temp;
5827 XSRETURN_EMPTY; /* return empty stack */
5828 }
5829 /* must have used dXSARGS; list context implied */
5830 return; /* assume stack size is correct */
5831
5832 void
5833 _get_i_string (p, base, n_digits, round)
5834 mpc_t * p
5835 SV * base
5836 SV * n_digits
5837 SV * round
5838 PREINIT:
5839 I32* temp;
5840 PPCODE:
5841 temp = PL_markstack_ptr++;
5842 _get_i_string(aTHX_ p, base, n_digits, round);
5843 if (PL_markstack_ptr != temp) {
5844 /* truly void, because dXSARGS not invoked */
5845 PL_markstack_ptr = temp;
5846 XSRETURN_EMPTY; /* return empty stack */
5847 }
5848 /* must have used dXSARGS; list context implied */
5849 return; /* assume stack size is correct */
5850
5851 SV *
5852 _itsa (a)
5853 SV * a
5854 CODE:
5855 RETVAL = _itsa (aTHX_ a);
5856 OUTPUT: RETVAL
5857
5858 SV *
5859 _new_real_im (b, d)
5860 SV * b
5861 SV * d
5862 CODE:
5863 RETVAL = _new_real_im (aTHX_ b, d);
5864 OUTPUT: RETVAL
5865
5866 int
5867 _has_longlong ()
5868
5869
5870 int
5871 _has_longdouble ()
5872
5873
5874 int
5875 _has_inttypes ()
5876
5877 SV *
5878 gmp_v ()
5879 CODE:
5880 RETVAL = gmp_v (aTHX);
5881 OUTPUT: RETVAL
5882
5883
5884 SV *
5885 mpfr_v ()
5886 CODE:
5887 RETVAL = mpfr_v (aTHX);
5888 OUTPUT: RETVAL
5889
5890
5891 SV *
5892 _MPC_VERSION_MAJOR ()
5893 CODE:
5894 RETVAL = _MPC_VERSION_MAJOR (aTHX);
5895 OUTPUT: RETVAL
5896
5897
5898 SV *
5899 _MPC_VERSION_MINOR ()
5900 CODE:
5901 RETVAL = _MPC_VERSION_MINOR (aTHX);
5902 OUTPUT: RETVAL
5903
5904
5905 SV *
5906 _MPC_VERSION_PATCHLEVEL ()
5907 CODE:
5908 RETVAL = _MPC_VERSION_PATCHLEVEL (aTHX);
5909 OUTPUT: RETVAL
5910
5911
5912 SV *
5913 _MPC_VERSION ()
5914 CODE:
5915 RETVAL = _MPC_VERSION (aTHX);
5916 OUTPUT: RETVAL
5917
5918
5919 SV *
5920 _MPFR_VERSION ()
5921 CODE:
5922 RETVAL = _MPFR_VERSION (aTHX);
5923 OUTPUT: RETVAL
5924
5925
5926 SV *
5927 _MPC_VERSION_NUM (x, y, z)
5928 SV * x
5929 SV * y
5930 SV * z
5931 CODE:
5932 RETVAL = _MPC_VERSION_NUM (aTHX_ x, y, z);
5933 OUTPUT: RETVAL
5934
5935 SV *
5936 _MPC_VERSION_STRING ()
5937 CODE:
5938 RETVAL = _MPC_VERSION_STRING (aTHX);
5939 OUTPUT: RETVAL
5940
5941
5942 SV *
5943 Rmpc_get_version ()
5944 CODE:
5945 RETVAL = Rmpc_get_version (aTHX);
5946 OUTPUT: RETVAL
5947
5948
5949 SV *
5950 Rmpc_real (rop, op, round)
5951 mpfr_t * rop
5952 mpc_t * op
5953 SV * round
5954 CODE:
5955 RETVAL = Rmpc_real (aTHX_ rop, op, round);
5956 OUTPUT: RETVAL
5957
5958 SV *
5959 Rmpc_imag (rop, op, round)
5960 mpfr_t * rop
5961 mpc_t * op
5962 SV * round
5963 CODE:
5964 RETVAL = Rmpc_imag (aTHX_ rop, op, round);
5965 OUTPUT: RETVAL
5966
5967 SV *
5968 Rmpc_arg (rop, op, round)
5969 mpfr_t * rop
5970 mpc_t * op
5971 SV * round
5972 CODE:
5973 RETVAL = Rmpc_arg (aTHX_ rop, op, round);
5974 OUTPUT: RETVAL
5975
5976 SV *
5977 Rmpc_proj (rop, op, round)
5978 mpc_t * rop
5979 mpc_t * op
5980 SV * round
5981 CODE:
5982 RETVAL = Rmpc_proj (aTHX_ rop, op, round);
5983 OUTPUT: RETVAL
5984
5985 SV *
5986 Rmpc_get_str (base, dig, op, round)
5987 SV * base
5988 SV * dig
5989 mpc_t * op
5990 SV * round
5991 CODE:
5992 RETVAL = Rmpc_get_str (aTHX_ base, dig, op, round);
5993 OUTPUT: RETVAL
5994
5995 int
5996 Rmpc_set_str (rop, str, base, round)
5997 mpc_t * rop
5998 SV * str
5999 SV * base
6000 SV * round
6001 CODE:
6002 RETVAL = Rmpc_set_str (aTHX_ rop, str, base, round);
6003 OUTPUT: RETVAL
6004
6005 int
6006 Rmpc_strtoc (rop, str, base, round)
6007 mpc_t * rop
6008 SV * str
6009 SV * base
6010 SV * round
6011 CODE:
6012 RETVAL = Rmpc_strtoc (aTHX_ rop, str, base, round);
6013 OUTPUT: RETVAL
6014
6015 void
6016 Rmpc_set_nan (a)
6017 mpc_t * a
6018 PREINIT:
6019 I32* temp;
6020 PPCODE:
6021 temp = PL_markstack_ptr++;
6022 Rmpc_set_nan(a);
6023 if (PL_markstack_ptr != temp) {
6024 /* truly void, because dXSARGS not invoked */
6025 PL_markstack_ptr = temp;
6026 XSRETURN_EMPTY; /* return empty stack */
6027 }
6028 /* must have used dXSARGS; list context implied */
6029 return; /* assume stack size is correct */
6030
6031 void
6032 Rmpc_swap (a, b)
6033 mpc_t * a
6034 mpc_t * b
6035 PREINIT:
6036 I32* temp;
6037 PPCODE:
6038 temp = PL_markstack_ptr++;
6039 Rmpc_swap(a, b);
6040 if (PL_markstack_ptr != temp) {
6041 /* truly void, because dXSARGS not invoked */
6042 PL_markstack_ptr = temp;
6043 XSRETURN_EMPTY; /* return empty stack */
6044 }
6045 /* must have used dXSARGS; list context implied */
6046 return; /* assume stack size is correct */
6047
6048 SV *
6049 overload_atan2 (p, q, third)
6050 mpc_t * p
6051 mpc_t * q
6052 SV * third
6053 CODE:
6054 RETVAL = overload_atan2 (aTHX_ p, q, third);
6055 OUTPUT: RETVAL
6056
6057 SV *
6058 Rmpc_sin_cos (rop_sin, rop_cos, op, rnd_sin, rnd_cos)
6059 mpc_t * rop_sin
6060 mpc_t * rop_cos
6061 mpc_t * op
6062 SV * rnd_sin
6063 SV * rnd_cos
6064 CODE:
6065 RETVAL = Rmpc_sin_cos (aTHX_ rop_sin, rop_cos, op, rnd_sin, rnd_cos);
6066 OUTPUT: RETVAL
6067
6068 void
6069 Rmpc_get_dc (crop, op, round)
6070 SV * crop
6071 mpc_t * op
6072 SV * round
6073 PREINIT:
6074 I32* temp;
6075 PPCODE:
6076 temp = PL_markstack_ptr++;
6077 Rmpc_get_dc(aTHX_ crop, op, round);
6078 if (PL_markstack_ptr != temp) {
6079 /* truly void, because dXSARGS not invoked */
6080 PL_markstack_ptr = temp;
6081 XSRETURN_EMPTY; /* return empty stack */
6082 }
6083 /* must have used dXSARGS; list context implied */
6084 return; /* assume stack size is correct */
6085
6086 void
6087 Rmpc_get_ldc (crop, op, round)
6088 SV * crop
6089 mpc_t * op
6090 SV * round
6091 PREINIT:
6092 I32* temp;
6093 PPCODE:
6094 temp = PL_markstack_ptr++;
6095 Rmpc_get_ldc(aTHX_ crop, op, round);
6096 if (PL_markstack_ptr != temp) {
6097 /* truly void, because dXSARGS not invoked */
6098 PL_markstack_ptr = temp;
6099 XSRETURN_EMPTY; /* return empty stack */
6100 }
6101 /* must have used dXSARGS; list context implied */
6102 return; /* assume stack size is correct */
6103
6104 SV *
6105 Rmpc_set_dc (op, crop, round)
6106 mpc_t * op
6107 SV * crop
6108 SV * round
6109 CODE:
6110 RETVAL = Rmpc_set_dc (aTHX_ op, crop, round);
6111 OUTPUT: RETVAL
6112
6113 SV *
6114 Rmpc_set_ldc (op, crop, round)
6115 mpc_t * op
6116 SV * crop
6117 SV * round
6118 CODE:
6119 RETVAL = Rmpc_set_ldc (aTHX_ op, crop, round);
6120 OUTPUT: RETVAL
6121
6122 void
6123 Rmpc_get_DC (crop, op, round)
6124 SV * crop
6125 mpc_t * op
6126 SV * round
6127 PREINIT:
6128 I32* temp;
6129 PPCODE:
6130 temp = PL_markstack_ptr++;
6131 Rmpc_get_DC(aTHX_ crop, op, round);
6132 if (PL_markstack_ptr != temp) {
6133 /* truly void, because dXSARGS not invoked */
6134 PL_markstack_ptr = temp;
6135 XSRETURN_EMPTY; /* return empty stack */
6136 }
6137 /* must have used dXSARGS; list context implied */
6138 return; /* assume stack size is correct */
6139
6140 void
6141 Rmpc_get_LDC (crop, op, round)
6142 SV * crop
6143 mpc_t * op
6144 SV * round
6145 PREINIT:
6146 I32* temp;
6147 PPCODE:
6148 temp = PL_markstack_ptr++;
6149 Rmpc_get_LDC(aTHX_ crop, op, round);
6150 if (PL_markstack_ptr != temp) {
6151 /* truly void, because dXSARGS not invoked */
6152 PL_markstack_ptr = temp;
6153 XSRETURN_EMPTY; /* return empty stack */
6154 }
6155 /* must have used dXSARGS; list context implied */
6156 return; /* assume stack size is correct */
6157
6158 SV *
6159 Rmpc_set_DC (op, crop, round)
6160 mpc_t * op
6161 SV * crop
6162 SV * round
6163 CODE:
6164 RETVAL = Rmpc_set_DC (aTHX_ op, crop, round);
6165 OUTPUT: RETVAL
6166
6167 SV *
6168 Rmpc_set_LDC (op, crop, round)
6169 mpc_t * op
6170 SV * crop
6171 SV * round
6172 CODE:
6173 RETVAL = Rmpc_set_LDC (aTHX_ op, crop, round);
6174 OUTPUT: RETVAL
6175
6176 int
6177 _have_Complex_h ()
6178
6179
6180 SV *
6181 _mpfr_buildopt_tls_p ()
6182 CODE:
6183 RETVAL = _mpfr_buildopt_tls_p (aTHX);
6184 OUTPUT: RETVAL
6185
6186
6187 SV *
6188 _get_xs_version ()
6189 CODE:
6190 RETVAL = _get_xs_version (aTHX);
6191 OUTPUT: RETVAL
6192
6193
6194 SV *
6195 _wrap_count ()
6196 CODE:
6197 RETVAL = _wrap_count (aTHX);
6198 OUTPUT: RETVAL
6199
6200
6201 SV *
6202 Rmpc_mul_2si (a, b, c, round)
6203 mpc_t * a
6204 mpc_t * b
6205 SV * c
6206 SV * round
6207 CODE:
6208 RETVAL = Rmpc_mul_2si (aTHX_ a, b, c, round);
6209 OUTPUT: RETVAL
6210
6211 SV *
6212 Rmpc_div_2si (a, b, c, round)
6213 mpc_t * a
6214 mpc_t * b
6215 SV * c
6216 SV * round
6217 CODE:
6218 RETVAL = Rmpc_div_2si (aTHX_ a, b, c, round);
6219 OUTPUT: RETVAL
6220
6221 SV *
6222 Rmpc_log10 (rop, op, round)
6223 mpc_t * rop
6224 mpc_t * op
6225 SV * round
6226 CODE:
6227 RETVAL = Rmpc_log10 (aTHX_ rop, op, round);
6228 OUTPUT: RETVAL
6229
6230 int
6231 Rmpc_cmp_abs (op1, op2)
6232 mpc_t * op1
6233 mpc_t * op2
6234
6235 int
6236 Rmpc_rootofunity (rop, n, k, round)
6237 mpc_t * rop
6238 unsigned long n
6239 unsigned long k
6240 SV * round
6241 CODE:
6242 RETVAL = Rmpc_rootofunity (aTHX_ rop, n, k, round);
6243 OUTPUT: RETVAL
6244
6245 int
6246 _can_pass_float128 ()
6247
6248
6249 int
6250 _get_nv_precision ()
6251
6252
6253 int
6254 nok_pokflag ()
6255
6256
6257 void
6258 clear_nok_pok ()
6259
6260 PREINIT:
6261 I32* temp;
6262 PPCODE:
6263 temp = PL_markstack_ptr++;
6264 clear_nok_pok();
6265 if (PL_markstack_ptr != temp) {
6266 /* truly void, because dXSARGS not invoked */
6267 PL_markstack_ptr = temp;
6268 XSRETURN_EMPTY; /* return empty stack */
6269 }
6270 /* must have used dXSARGS; list context implied */
6271 return; /* assume stack size is correct */
6272
6273 void
6274 set_nok_pok (x)
6275 int x
6276 PREINIT:
6277 I32* temp;
6278 PPCODE:
6279 temp = PL_markstack_ptr++;
6280 set_nok_pok(x);
6281 if (PL_markstack_ptr != temp) {
6282 /* truly void, because dXSARGS not invoked */
6283 PL_markstack_ptr = temp;
6284 XSRETURN_EMPTY; /* return empty stack */
6285 }
6286 /* must have used dXSARGS; list context implied */
6287 return; /* assume stack size is correct */
6288
6289 int
6290 _SvNOK (in)
6291 SV * in
6292 CODE:
6293 RETVAL = _SvNOK (aTHX_ in);
6294 OUTPUT: RETVAL
6295
6296 int
6297 _SvPOK (in)
6298 SV * in
6299 CODE:
6300 RETVAL = _SvPOK (aTHX_ in);
6301 OUTPUT: RETVAL
6302
6303 SV *
6304 Rmpc_fma (a, b, c, d, round)
6305 mpc_t * a
6306 mpc_t * b
6307 mpc_t * c
6308 mpc_t * d
6309 SV * round
6310 CODE:
6311 RETVAL = Rmpc_fma (aTHX_ a, b, c, d, round);
6312 OUTPUT: RETVAL
6313
6314 SV *
6315 Rmpc_dot (rop, avref_A, avref_B, len, round)
6316 mpc_t * rop
6317 SV * avref_A
6318 SV * avref_B
6319 SV * len
6320 SV * round
6321 CODE:
6322 RETVAL = Rmpc_dot (aTHX_ rop, avref_A, avref_B, len, round);
6323 OUTPUT: RETVAL
6324
6325 SV *
6326 Rmpc_sum (rop, avref, len, round)
6327 mpc_t * rop
6328 SV * avref
6329 SV * len
6330 SV * round
6331 CODE:
6332 RETVAL = Rmpc_sum (aTHX_ rop, avref, len, round);
6333 OUTPUT: RETVAL
6334
6335 void
6336 CLONE (x, ...)
6337 SV * x
6338 PREINIT:
6339 I32* temp;
6340 PPCODE:
6341 temp = PL_markstack_ptr++;
6342 CLONE(aTHX_ x);
6343 if (PL_markstack_ptr != temp) {
6344 /* truly void, because dXSARGS not invoked */
6345 PL_markstack_ptr = temp;
6346 XSRETURN_EMPTY; /* return empty stack */
6347 }
6348 /* must have used dXSARGS; list context implied */
6349 return; /* assume stack size is correct */
6350
6351 BOOT:
6352
6353 {
6354 MY_CXT_INIT;
6355 MY_CXT._perl_default_prec_re = 53;
6356 MY_CXT._perl_default_prec_im = 53;
6357 MY_CXT._perl_default_rounding_mode = 0;
6358 }
6359
6360