File Coverage

L.xs

Criterion	Covered	Total	%
statement	939	1258	74.6
branch	427	994	42.9
condition			n/a
subroutine			n/a
pod			n/a
total	1366	2252	60.6

line	stmt	bran	code
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			#include
15			#include
16			#include
17
18			#ifdef OLDPERL
19			#define SvUOK SvIsUV
20			#endif
21
22			#ifndef Newx
23			# define Newx(v,n,t) New(0,v,n,t)
24			#endif
25
26			#ifndef Newxz
27			# define Newxz(v,n,t) Newz(0,v,n,t)
28			#endif
29
30			#if defined(LDBL_MANT_DIG)
31			#if LDBL_MANT_DIG == 53
32			#define _DIGITS 17
33			#endif
34			#if LDBL_MANT_DIG == 64
35			#define _DIGITS 21
36			#endif
37			#if LDBL_MANT_DIG == 106
38			#define _DIGITS 33
39			#endif
40			#if LDBL_MANT_DIG == 113
41			#define _DIGITS 36
42			#endif
43			#elif defined(DBL_MANT_DIG)
44			#if DBL_MANT_DIG == 53
45			#define _DIGITS 17
46			#endif
47			#else
48			#define _DIGITS 21
49			#endif
50
51			#ifndef _DIGITS
52			#define _DIGITS 21
53			#endif
54
55			int _MATH_COMPLEX_C_L_DIGITS = _DIGITS;
56
57			int nnum = 0;
58
59			#define MATH_COMPLEX long double _Complex
60
61	2		void l_set_prec(int x) {
62	2	50	if(x < 1)croak("1st arg (precision) to l_set_prec must be at least 1");
63	2		_MATH_COMPLEX_C_L_DIGITS = x;
64	2		}
65
66	8		int l_get_prec(void) {
67	8		return _MATH_COMPLEX_C_L_DIGITS;
68			}
69
70	70		int _is_nan(long double x) {
71	70	100	if(x == x) return 0;
72	36		return 1;
73			}
74
75	30		int _is_inf(long double x) {
76	30	50	if(x == 0) return 0;
77	30	100	if(_is_nan(x)) return 0;
78	18	100	if(x / x == x / x) return 0;
79	8	100	if(x < 0) return -1;
80	4		return 1;
81			}
82
83	128		long double _get_nan(void) {
84	128		float nanval = 0.0L / 0.0L;
85	128		return nanval;
86			}
87
88	2		long double _get_inf(void) {
89	2		long double infval = 1.0L / 0.0L;
90	2		return infval;
91			}
92
93	0		long double _get_neg_inf(void) {
94	0		long double inf = -1.0L / 0.0L;
95	0		return inf;
96			}
97
98	62		SV * create_cl(pTHX) {
99
100			MATH_COMPLEX *pc;
101			SV * obj_ref, * obj;
102
103	62		New(42, pc, 1, MATH_COMPLEX);
104	62	50	if(pc == NULL) croak("Failed to allocate memory in create_cl function");
105
106	62		obj_ref = newSV(0);
107	62		obj = newSVrv(obj_ref, "Math::Complex_C::L");
108
109	62		__real__ *pc = _get_nan();
110	62		__imag__ *pc = _get_nan();
111
112	62		sv_setiv(obj, INT2PTR(IV,pc));
113	62		SvREADONLY_on(obj);
114	62		return obj_ref;
115
116			}
117
118	65		void assign_cl(pTHX_ SV * rop, SV * d1, SV * d2) {
119			long double _d1, _d2;
120
121	65	50	if(SvUOK(d1)) {
122	0		_d1 = (long double)SvUVX(d1);
123			}
124			else {
125	65	100	if(SvIOK(d1)) {
126	35		_d1 = (long double)SvIVX(d1);
127			}
128			else {
129	30	100	if(SvNOK(d1)) {
130	18		_d1 = (long double)SvNVX(d1);
131			}
132			else {
133	12	50	if(SvPOK(d1)) {
134	12	100	if(!looks_like_number(d1)) nnum++;
135	12	50	_d1 = strtold(SvPV_nolen(d1), NULL);
136			}
137			else {
138	0	0	if(sv_isobject(d1)) {
139	0	0	const char *h = HvNAME(SvSTASH(SvRV(d1)));
		0
		0
		0
		0
		0
140	0	0	if(strEQ(h, "Math::LongDouble"))
141	0		_d1 = (INT2PTR(long double , SvIVX(SvRV(d1))));
142	0		else croak("Invalid object given as 2nd arg to assign_cl function");
143			}
144			else {
145	0		croak("Invalid 2nd arg supplied to assign_cl function");
146			}
147			}
148			}
149			}
150			}
151
152	65	50	if(SvUOK(d2)) {
153	0		_d2 = (long double)SvUVX(d2);
154			}
155			else {
156	65	100	if(SvIOK(d2)) {
157	31		_d2 = (long double)SvIVX(d2);
158			}
159			else {
160	34	100	if(SvNOK(d2)) {
161	23		_d2 = (long double)SvNVX(d2);
162			}
163			else {
164	11	50	if(SvPOK(d2)) {
165	11	100	if(!looks_like_number(d2)) nnum++;
166	11	50	_d2 = strtold(SvPV_nolen(d2), NULL) ;
167			}
168			else {
169	0	0	if(sv_isobject(d2)) {
170	0	0	const char *h = HvNAME(SvSTASH(SvRV(d2)));
		0
		0
		0
		0
		0
171	0	0	if(strEQ(h, "Math::LongDouble"))
172	0		_d2 = (INT2PTR(long double , SvIVX(SvRV(d2))));
173	0		else croak("Invalid object given as 3rd arg to assign_cl function");
174			}
175			else {
176	0		croak("Invalid 3rd arg supplied to assign_cl function");
177			}
178			}
179			}
180			}
181			}
182
183	65		__real__ (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = _d1;
184	65		__imag__ (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = _d2;
185	65		}
186
187	4		void set_real_cl(pTHX_ SV * rop, SV * d1) {
188			long double _d1;
189
190	4	100	if(SvUOK(d1)) {
191	1		_d1 = (long double)SvUVX(d1);
192			}
193			else {
194	3	50	if(SvIOK(d1)) {
195	0		_d1 = (long double)SvIVX(d1);
196			}
197			else {
198	3	100	if(SvNOK(d1)) {
199	2		_d1 = (long double)SvNVX(d1);
200			}
201			else {
202	1	50	if(SvPOK(d1)) {
203	1	50	if(!looks_like_number(d1)) nnum++;
204	1	50	_d1 = strtold(SvPV_nolen(d1), NULL) ;
205			}
206			else {
207	0	0	if(sv_isobject(d1)) {
208	0	0	const char *h = HvNAME(SvSTASH(SvRV(d1)));
		0
		0
		0
		0
		0
209	0	0	if(strEQ(h, "Math::LongDouble"))
210	0		_d1 = (INT2PTR(long double , SvIVX(SvRV(d1))));
211	0		else croak("Invalid object given as 2nd arg to set_real_cl function");
212			}
213			else {
214	0		croak("Invalid 2nd arg supplied to set_real_cl function");
215			}
216			}
217			}
218			}
219			}
220
221	4		__real__ (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = _d1;
222	4		}
223
224	4		void set_imag_cl(pTHX_ SV * rop, SV * d2) {
225			long double _d2;
226
227	4	50	if(SvUOK(d2)) {
228	0		_d2 = (long double)SvUVX(d2);
229			}
230			else {
231	4	100	if(SvIOK(d2)) {
232	3		_d2 = (long double)SvIVX(d2);
233			}
234			else {
235	1	50	if(SvNOK(d2)) {
236	0		_d2 = (long double)SvNVX(d2);
237			}
238			else {
239	1	50	if(SvPOK(d2)) {
240	1	50	if(!looks_like_number(d2)) nnum++;
241	1	50	_d2 = strtold(SvPV_nolen(d2), NULL) ;
242			}
243			else {
244	0	0	if(sv_isobject(d2)) {
245	0	0	const char *h = HvNAME(SvSTASH(SvRV(d2)));
		0
		0
		0
		0
		0
246	0	0	if(strEQ(h, "Math::LongDouble"))
247	0		_d2 = (INT2PTR(long double , SvIVX(SvRV(d2))));
248	0		else croak("Invalid object given as 2nd arg to set_imag_cl function");
249			}
250			else {
251	0		croak("Invalid 2nd arg supplied to set_imag_cl function");
252			}
253			}
254			}
255			}
256			}
257
258	4		__imag__ (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = _d2;
259	4		}
260
261
262	0		void LD2cl(pTHX_ SV * rop, SV * d1, SV * d2) {
263			long double _d1, _d2;
264
265	0	0	if(sv_isobject(d1) && sv_isobject(d2)) {
		0
266	0	0	const char *h1 = HvNAME(SvSTASH(SvRV(d1)));
		0
		0
		0
		0
		0
267	0	0	const char *h2 = HvNAME(SvSTASH(SvRV(d2)));
		0
		0
		0
		0
		0
268	0	0	if(strEQ(h1, "Math::LongDouble") &&
		0
269	0		strEQ(h2, "Math::LongDouble")) {
270
271	0		_d1 = (INT2PTR(long double , SvIVX(SvRV(d1))));
272	0		_d2 = (INT2PTR(long double , SvIVX(SvRV(d2))));
273
274	0		__real__ (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = _d1;
275	0		__imag__ (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = _d2;
276			}
277	0		else croak("Both 2nd and 3rd args supplied to LD2cl need to be Math::LongDouble objects");
278			}
279	0		else croak("Both 2nd and 3rd args supplied to LD2cl need to be Math::LongDouble objects");
280	0		}
281
282	0		void cl2LD(pTHX_ SV * rop1, SV * rop2, SV * op) {
283	0	0	if(sv_isobject(rop1)) {
284	0	0	const char *h = HvNAME(SvSTASH(SvRV(rop1)));
		0
		0
		0
		0
		0
285	0	0	if(strEQ(h, "Math::LongDouble")) {
286	0		(INT2PTR(long double , SvIVX(SvRV(rop1)))) = creall((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op)))));
287			}
288	0		else croak("1st arg (a %s object) supplied to cl2LD needs to be a Math::LongDouble object", h);
289			}
290	0		else croak("1st arg (which needs to be a Math::LongDouble object) supplied to cl2LD is not an object");
291
292	0	0	if(sv_isobject(rop2)) {
293	0	0	const char *h = HvNAME(SvSTASH(SvRV(rop2)));
		0
		0
		0
		0
		0
294	0	0	if(strEQ(h, "Math::LongDouble")) {
295	0		(INT2PTR(long double , SvIVX(SvRV(rop2)))) = cimagl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op)))));
296			}
297	0		else croak("2nd arg (a %s object) supplied to cl2LD needs to be a Math::LongDouble object", h);
298			}
299	0		else croak("2nd arg (which needs to be a Math::LongDouble object) supplied to cl2LD is not an object");
300	0		}
301
302	1		void mul_cl(pTHX_ SV * rop, SV * op1, SV * op2) {
303	2		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op1)))) *
304	1		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op2))));
305	1		}
306
307	1		void mul_c_nvl(pTHX_ SV * rop, SV * op1, SV * op2) {
308	2		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op1)))) *
309	1	50	(long double)SvNV(op2);
310	1		}
311
312	1		void mul_c_ivl(pTHX_ SV * rop, SV * op1, SV * op2) {
313	2		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op1)))) *
314	1	50	(long double)SvIV(op2);
315	1		}
316
317	1		void mul_c_uvl(pTHX_ SV * rop, SV * op1, SV * op2) {
318	2		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op1)))) *
319	1	50	(long double)SvUV(op2);
320	1		}
321
322	1		void mul_c_pvl(pTHX_ SV * rop, SV * op1, SV * op2) {
323	2		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op1)))) *
324	1	50	strtold(SvPV_nolen(op2), NULL);
325	1		}
326
327	1		void div_cl(pTHX_ SV * rop, SV * op1, SV * op2) {
328	2		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op1)))) /
329	1		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op2))));
330	1		}
331
332	1		void div_c_nvl(pTHX_ SV * rop, SV * op1, SV * op2) {
333	2		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op1)))) /
334	1	50	(long double)SvNV(op2);
335	1		}
336
337	1		void div_c_ivl(pTHX_ SV * rop, SV * op1, SV * op2) {
338	2		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op1)))) /
339	1	50	(long double)SvIV(op2);
340	1		}
341
342	1		void div_c_uvl(pTHX_ SV * rop, SV * op1, SV * op2) {
343	2		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op1)))) /
344	1	50	(long double)SvUV(op2);
345	1		}
346
347	1		void div_c_pvl(pTHX_ SV * rop, SV * op1, SV * op2) {
348	2		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op1)))) /
349	1	50	strtold(SvPV_nolen(op2), NULL);
350	1		}
351
352	1		void add_cl(pTHX_ SV * rop, SV * op1, SV * op2) {
353	2		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op1)))) +
354	1		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op2))));
355	1		}
356
357	1		void add_c_nvl(pTHX_ SV * rop, SV * op1, SV * op2) {
358	2		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op1)))) +
359	1	50	(long double)SvNV(op2);
360	1		}
361
362	1		void add_c_ivl(pTHX_ SV * rop, SV * op1, SV * op2) {
363	2		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op1)))) +
364	1	50	(long double)SvIV(op2);
365	1		}
366
367	1		void add_c_uvl(pTHX_ SV * rop, SV * op1, SV * op2) {
368	2		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op1)))) +
369	1	50	(long double)SvUV(op2);
370	1		}
371
372	1		void add_c_pvl(pTHX_ SV * rop, SV * op1, SV * op2) {
373	2		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op1)))) +
374	1	50	strtold(SvPV_nolen(op2), NULL);
375	1		}
376
377	1		void sub_cl(pTHX_ SV * rop, SV * op1, SV * op2) {
378	2		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op1)))) -
379	1		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op2))));
380	1		}
381
382	1		void sub_c_nvl(pTHX_ SV * rop, SV * op1, SV * op2) {
383	2		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op1)))) -
384	1	50	(long double)SvNV(op2);
385	1		}
386
387	1		void sub_c_ivl(pTHX_ SV * rop, SV * op1, SV * op2) {
388	2		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op1)))) -
389	1	50	(long double)SvIV(op2);
390	1		}
391
392	1		void sub_c_uvl(pTHX_ SV * rop, SV * op1, SV * op2) {
393	2		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op1)))) -
394	1	50	(long double)SvUV(op2);
395	1		}
396
397	1		void sub_c_pvl(pTHX_ SV * rop, SV * op1, SV * op2) {
398	2		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op1)))) -
399	1	50	strtold(SvPV_nolen(op2), NULL);
400	1		}
401
402	100		void DESTROY(pTHX_ SV * op) {
403	100		Safefree(INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(op))));
404	100		}
405
406	68		SV * real_cl(pTHX_ SV * op) {
407			#if defined(NO_INF_CAST_TO_NV) && defined(__GNUC__) && ((__GNUC__ > 4 && __GNUC__ < 7) \|\| (__GNUC__ == 4 && __GNUC_MINOR__ >= 9))
408			int t;
409			long double temp = creall((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op)))));
410			t = _is_inf(temp);
411			if(t) {
412			if(t < 0) return newSVnv((NV)strtod("-inf", NULL));
413			return newSVnv((NV)strtod( "inf", NULL));
414			}
415
416			#endif
417	68		return newSVnv(creall((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op))))));
418			}
419
420	0		SV * real_cl2LD(pTHX_ SV * op) {
421			long double * f;
422			SV * obj_ref, * obj;
423
424	0		Newx(f, 1, long double);
425	0	0	if(f == NULL) croak("Failed to allocate memory in real_cl2LD function");
426
427	0		obj_ref = newSV(0);
428	0		obj = newSVrv(obj_ref, "Math::LongDouble");
429
430	0		f = creall((INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(op)))));
431
432	0		sv_setiv(obj, INT2PTR(IV,f));
433	0		SvREADONLY_on(obj);
434	0		return obj_ref;
435			}
436
437	1		void real_cl2str(pTHX_ SV * op) {
438	1		dXSARGS;
439			long double t;
440			char * buffer;
441
442	1	50	if(sv_isobject(op)) {
443	1	50	const char *h = HvNAME(SvSTASH(SvRV(op)));
		50
		50
		0
		50
		50
444	1	50	if(strEQ(h, "Math::Complex_C::L")) {
445	1	50	EXTEND(SP, 1);
446	1		t = creall((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op)))));
447
448	1		Newx(buffer, 8 + _MATH_COMPLEX_C_L_DIGITS, char);
449	1	50	if(buffer == NULL) croak("Failed to allocate memory in real_cl2str");
450	1		sprintf(buffer, "%.*Le", _MATH_COMPLEX_C_L_DIGITS - 1, t);
451	1		ST(0) = sv_2mortal(newSVpv(buffer, 0));
452	1		Safefree(buffer);
453	1		XSRETURN(1);
454			}
455	0		else croak("Invalid object supplied to Math::Complex_C::L::real_cl2str function");
456			}
457	0		else croak("Invalid argument supplied to Math::Complex_C::L::real_cl2str function");
458			}
459
460	60		SV * imag_cl(pTHX_ SV * op) {
461			#if defined(NO_INF_CAST_TO_NV) && defined(__GNUC__) && ((__GNUC__ > 4 && __GNUC__ < 7) \|\| (__GNUC__ == 4 && __GNUC_MINOR__ >= 9))
462			int t;
463			long double temp = cimagl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op)))));
464			t = _is_inf(temp);
465			if(t) {
466			if(t < 0) return newSVnv((NV)strtod("-inf", NULL));
467			return newSVnv((NV)strtod( "inf", NULL));
468			}
469
470			#endif
471	60		return newSVnv(cimagl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op))))));
472			}
473
474	0		SV * imag_cl2LD(pTHX_ SV * op) {
475			long double * f;
476			SV * obj_ref, * obj;
477
478	0		Newx(f, 1, long double);
479	0	0	if(f == NULL) croak("Failed to allocate memory in imag_cl2LD function");
480
481	0		obj_ref = newSV(0);
482	0		obj = newSVrv(obj_ref, "Math::LongDouble");
483
484	0		f = cimagl((INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(op)))));
485
486	0		sv_setiv(obj, INT2PTR(IV,f));
487	0		SvREADONLY_on(obj);
488	0		return obj_ref;
489			}
490
491	1		void imag_cl2str(pTHX_ SV * op) {
492	1		dXSARGS;
493			long double t;
494			char * buffer;
495
496	1	50	if(sv_isobject(op)) {
497	1	50	const char *h = HvNAME(SvSTASH(SvRV(op)));
		50
		50
		0
		50
		50
498	1	50	if(strEQ(h, "Math::Complex_C::L")) {
499	1	50	EXTEND(SP, 1);
500	1		t = cimagl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op)))));
501
502	1		Newx(buffer, 8 + _MATH_COMPLEX_C_L_DIGITS, char);
503	1	50	if(buffer == NULL) croak("Failed to allocate memory in imag_cl2str");
504	1		sprintf(buffer, "%.*Le", _MATH_COMPLEX_C_L_DIGITS - 1, t);
505	1		ST(0) = sv_2mortal(newSVpv(buffer, 0));
506	1		Safefree(buffer);
507	1		XSRETURN(1);
508			}
509	0		else croak("Invalid object supplied to Math::Complex_C::L::imag_cl2str function");
510			}
511	0		else croak("Invalid argument supplied to Math::Complex_C::L::imag_cl2str function");
512			}
513
514	1		SV * arg_cl(pTHX_ SV * op) {
515	1		return newSVnv(cargl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op))))));
516			}
517
518	0		SV * arg_cl2LD(pTHX_ SV * op) {
519			long double * f;
520			SV * obj_ref, * obj;
521
522	0		Newx(f, 1, long double);
523	0	0	if(f == NULL) croak("Failed to allocate memory in arg_cl2LD function");
524
525	0		obj_ref = newSV(0);
526	0		obj = newSVrv(obj_ref, "Math::LongDouble");
527
528	0		f = cargl((INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(op)))));
529
530	0		sv_setiv(obj, INT2PTR(IV,f));
531	0		SvREADONLY_on(obj);
532	0		return obj_ref;
533			}
534
535	1		void arg_cl2str(pTHX_ SV * op) {
536	1		dXSARGS;
537			long double t;
538			char * buffer;
539
540	1	50	if(sv_isobject(op)) {
541	1	50	const char *h = HvNAME(SvSTASH(SvRV(op)));
		50
		50
		0
		50
		50
542	1	50	if(strEQ(h, "Math::Complex_C::L")) {
543	1	50	EXTEND(SP, 1);
544	1		t = cargl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op)))));
545
546	1		Newx(buffer, 8 + _MATH_COMPLEX_C_L_DIGITS, char);
547	1	50	if(buffer == NULL) croak("Failed to allocate memory in arg_cl2str");
548	1		sprintf(buffer, "%.*Le", _MATH_COMPLEX_C_L_DIGITS - 1, t);
549	1		ST(0) = sv_2mortal(newSVpv(buffer, 0));
550	1		Safefree(buffer);
551	1		XSRETURN(1);
552			}
553	0		else croak("Invalid object supplied to Math::Complex_C::L::arg_cl2str function");
554			}
555	0		else croak("Invalid argument supplied to Math::Complex_C::L::arg_cl2str function");
556			}
557
558	1		SV * abs_cl(pTHX_ SV * op) {
559	1		return newSVnv(cabsl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op))))));
560			}
561
562	0		SV * abs_cl2LD(pTHX_ SV * op) {
563			long double * f;
564			SV * obj_ref, * obj;
565
566	0		Newx(f, 1, long double);
567	0	0	if(f == NULL) croak("Failed to allocate memory in cabs_cl2LD function");
568
569	0		obj_ref = newSV(0);
570	0		obj = newSVrv(obj_ref, "Math::LongDouble");
571
572	0		f = cabsl((INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(op)))));
573
574	0		sv_setiv(obj, INT2PTR(IV,f));
575	0		SvREADONLY_on(obj);
576	0		return obj_ref;
577			}
578
579	1		void abs_cl2str(pTHX_ SV * op) {
580	1		dXSARGS;
581			long double t;
582			char * buffer;
583
584	1	50	if(sv_isobject(op)) {
585	1	50	const char *h = HvNAME(SvSTASH(SvRV(op)));
		50
		50
		0
		50
		50
586	1	50	if(strEQ(h, "Math::Complex_C::L")) {
587	1	50	EXTEND(SP, 1);
588	1		t = cabsl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op)))));
589
590	1		Newx(buffer, 8 + _MATH_COMPLEX_C_L_DIGITS, char);
591	1	50	if(buffer == NULL) croak("Failed to allocate memory in arg_cl2str");
592	1		sprintf(buffer, "%.*Le", _MATH_COMPLEX_C_L_DIGITS - 1, t);
593	1		ST(0) = sv_2mortal(newSVpv(buffer, 0));
594	1		Safefree(buffer);
595	1		XSRETURN(1);
596			}
597	0		else croak("Invalid object supplied to Math::Complex_C::L::abs_cl2str function");
598			}
599	0		else croak("Invalid argument supplied to Math::Complex_C::L::abs_cl2str function");
600			}
601
602	1		void conj_cl(pTHX_ SV * rop, SV * op) {
603	1		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = conjl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op)))));
604	1		}
605
606	1		void acos_cl(pTHX_ SV * rop, SV * op) {
607	1		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = cacosl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op)))));
608	1		}
609
610	1		void asin_cl(pTHX_ SV * rop, SV * op) {
611	1		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = casinl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op)))));
612	1		}
613
614	1		void atan_cl(pTHX_ SV * rop, SV * op) {
615	1		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = catanl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op)))));
616	1		}
617
618	1		void cos_cl(pTHX_ SV * rop, SV * op) {
619	1		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = ccosl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op)))));
620	1		}
621
622	1		void sin_cl(pTHX_ SV * rop, SV * op) {
623	1		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = csinl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op)))));
624	1		}
625
626	1		void tan_cl(pTHX_ SV * rop, SV * op) {
627	1		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = ctanl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op)))));
628	1		}
629
630	1		void acosh_cl(pTHX_ SV * rop, SV * op) {
631	1		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = cacoshl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op)))));
632	1		}
633
634	1		void asinh_cl(pTHX_ SV * rop, SV * op) {
635	1		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = casinhl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op)))));
636	1		}
637
638	1		void atanh_cl(pTHX_ SV * rop, SV * op) {
639	1		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = catanhl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op)))));
640	1		}
641
642	1		void cosh_cl(pTHX_ SV * rop, SV * op) {
643	1		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = ccoshl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op)))));
644	1		}
645
646	1		void sinh_cl(pTHX_ SV * rop, SV * op) {
647	1		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = csinhl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op)))));
648	1		}
649
650	1		void tanh_cl(pTHX_ SV * rop, SV * op) {
651	1		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = ctanhl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op)))));
652	1		}
653
654	1		void exp_cl(pTHX_ SV * rop, SV * op) {
655	1		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = cexpl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op)))));
656	1		}
657
658	1		void log_cl(pTHX_ SV * rop, SV * op) {
659	1		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = clogl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op)))));
660	1		}
661
662	1		void sqrt_cl(pTHX_ SV * rop, SV * op) {
663	1		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = csqrtl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op)))));
664	1		}
665
666	6		void proj_cl(pTHX_ SV * rop, SV * op) {
667	6		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = cprojl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op)))));
668	6		}
669
670	1		void pow_cl(pTHX_ SV * rop, SV * op, SV * exp) {
671	2		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))) = cpowl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(op)))),
672	1		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(exp)))));
673	1		}
674
675	4		SV * _overload_true(pTHX_ SV * rop, SV * second, SV * third) {
676	6		if (_is_nan(creall((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))))) &&
677	4		_is_nan(cimagl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop))))))) return newSVuv(0);
678	2	50	if(creall((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop))))) \|\|
		0
679	2		cimagl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))))) return newSVuv(1);
680	0		return newSVuv(0);
681			}
682
683	8		SV * _overload_not(pTHX_ SV * rop, SV * second, SV * third) {
684	12		if (_is_nan(creall((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))))) &&
685	8		_is_nan(cimagl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop))))))) return newSVuv(1);
686	4	50	if(creall((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop))))) \|\|
		0
687	4		cimagl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop)))))) return newSVuv(0);
688	0		return newSVuv(1);
689			}
690
691	37		SV * _overload_equiv(pTHX_ SV * a, SV * b, SV * third) {
692	37	100	if(SvUOK(b)) {
693	1	50	if((long double)SvUVX(b) == creall((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a))))) &&
		50
694	1		0.0L == cimagl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))))) return newSVuv(1);
695	0		return newSVuv(0);
696			}
697	36	50	if(SvIOK(b)) {
698	0	0	if((long double)SvIVX(b) == creall((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a))))) &&
		0
699	0		0.0L == cimagl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))))) return newSVuv(1);
700	0		return newSVuv(0);
701			}
702	36	50	if(SvNOK(b)) {
703	0	0	if((long double)SvNVX(b) == creall((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a))))) &&
		0
704	0		0.0L == cimagl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))))) return newSVuv(1);
705	0		return newSVuv(0);
706			}
707
708	36	100	if(SvPOK(b)) {
709	2	50	if(!looks_like_number(b)) nnum++;
710	2	50	if(strtold(SvPV_nolen(b), NULL) == creall((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a))))) &&
		100
		50
711	1		0.0L == cimagl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))))) return newSVuv(1);
712	1		return newSVuv(0);
713			}
714
715	34	50	if(sv_isobject(b)) {
716	34	50	const char *h = HvNAME(SvSTASH(SvRV(b)));
		50
		50
		0
		50
		50
717	34	50	if(strEQ(h, "Math::Complex_C::L")) {
718	34	100	if(creall((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a))))) == creall((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(b))))) &&
		50
719	33		cimagl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a))))) == cimagl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(b))))))
720	33		return newSVuv(1);
721	1		return newSVuv(0);
722			}
723			}
724
725	0		croak("Invalid argument supplied to Math::Complex_C::L::_overload_equiv function");
726			}
727
728	7		SV * _overload_not_equiv(pTHX_ SV * a, SV * b, SV * third) {
729	7	50	if(SvUOK(b)) {
730	0	0	if((long double)SvUVX(b) == creall((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a))))) &&
		0
731	0		0.0L == cimagl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))))) return newSVuv(0);
732	0		return newSVuv(1);
733			}
734	7	50	if(SvIOK(b)) {
735	0	0	if((long double)SvIVX(b) == creall((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a))))) &&
		0
736	0		0.0L == cimagl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))))) return newSVuv(0);
737	0		return newSVuv(1);
738			}
739	7	50	if(SvNOK(b)) {
740	0	0	if((long double)SvNVX(b) == creall((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a))))) &&
		0
741	0		0.0L == cimagl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))))) return newSVuv(0);
742	0		return newSVuv(1);
743			}
744	7	100	if(SvPOK(b)) {
745	2	50	if(!looks_like_number(b)) nnum++;
746	2	50	if(strtold(SvPV_nolen(b), NULL) == creall((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a))))) &&
		100
		50
747	1		0.0L == cimagl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))))) return newSVuv(0);
748	1		return newSVuv(1);
749			}
750	5	50	if(sv_isobject(b)) {
751	5	50	const char *h = HvNAME(SvSTASH(SvRV(b)));
		50
		50
		0
		50
		50
752	5	50	if(strEQ(h, "Math::Complex_C::L")) {
753	5	50	if(creall((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a))))) == creall((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(b))))) &&
		0
754	0		cimagl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a))))) == cimagl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(b))))))
755	0		return newSVuv(0);
756	5		return newSVuv(1);
757			}
758			}
759
760	0		croak("Invalid argument supplied to Math::Complex_C::L::_overload_not_equiv function");
761			}
762
763
764	5		SV * _overload_pow(pTHX_ SV * a, SV * b, SV * third) {
765			MATH_COMPLEX *pc, t;
766			SV * obj_ref, * obj;
767
768	5		New(42, pc, 1, MATH_COMPLEX);
769	5	50	if(pc == NULL) croak("Failed to allocate memory in _overload_pow function");
770
771	5		obj_ref = newSV(0);
772	5		obj = newSVrv(obj_ref, "Math::Complex_C::L");
773
774	5		sv_setiv(obj, INT2PTR(IV,pc));
775	5		SvREADONLY_on(obj);
776	5	50	if(SvUOK(b)) {
777	0		__real__ t = (long double)SvUVX(b);
778	0		__imag__ t = 0.0L;
779	0		pc = cpowl((INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(a)))), t);
780	0		return obj_ref;
781			}
782	5	100	if(SvIOK(b)) {
783	3		__real__ t = (long double)SvIVX(b);
784	3		__imag__ t = 0.0L;
785	3		pc = cpowl((INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(a)))), t);
786	3		return obj_ref;
787			}
788	2	100	if(SvNOK(b)) {
789	1		__real__ t = (long double)SvNVX(b);
790	1		__imag__ t = 0.0L;
791	1		pc = cpowl((INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(a)))), t);
792	1		return obj_ref;
793			}
794	1	50	if(SvPOK(b)) {
795	0	0	if(!looks_like_number(b)) nnum++;
796	0	0	__real__ t = strtold(SvPV_nolen(b), NULL);
797	0		__imag__ t = 0.0L;
798	0		pc = cpowl((INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(a)))), t);
799	0		return obj_ref;
800			}
801	1	50	else if(sv_isobject(b)) {
802	1	50	const char *h = HvNAME(SvSTASH(SvRV(b)));
		50
		50
		0
		50
		50
803	1	50	if(strEQ(h, "Math::Complex_C::L")) {
804	1		pc = cpowl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))), (INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(b)))));
805	1		return obj_ref;
806			}
807			}
808	0		else croak("Invalid argument supplied to Math::Complex_C::L::_overload_pow function");
809	0		}
810
811	5		SV * _overload_mul(pTHX_ SV * a, SV * b, SV * third) {
812			MATH_COMPLEX *pc;
813			SV * obj_ref, * obj;
814
815	5		New(42, pc, 1, MATH_COMPLEX);
816	5	50	if(pc == NULL) croak("Failed to allocate memory in _overload_mul function");
817
818	5		obj_ref = newSV(0);
819	5		obj = newSVrv(obj_ref, "Math::Complex_C::L");
820
821	5		sv_setiv(obj, INT2PTR(IV,pc));
822	5		SvREADONLY_on(obj);
823
824	5	50	if(SvUOK(b)) {
825	0		pc = (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))) (long double)SvUVX(b);
826	0		return obj_ref;
827			}
828
829	5	100	if(SvIOK(b)) {
830	2		pc = (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))) (long double)SvIVX(b);
831	2		return obj_ref;
832			}
833
834	3	100	if(SvNOK(b)) {
835	1		pc = (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))) (long double)SvNVX(b);
836	1		return obj_ref;
837			}
838	2	100	if(SvPOK(b)) {
839	1	50	if(!looks_like_number(b)) nnum++;
840	1	50	pc = (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))) strtold(SvPV_nolen(b), NULL);
841	1		return obj_ref;
842			}
843	1	50	if(sv_isobject(b)) {
844	1	50	const char *h = HvNAME(SvSTASH(SvRV(b)));
		50
		50
		0
		50
		50
845	1	50	if(strEQ(h, "Math::Complex_C::L")) {
846	1		pc = (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))) (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(b))));
847	1		return obj_ref;
848			}
849			}
850
851	0		croak("Invalid argument supplied to Math::Complex_C::L::_overload_mul function");
852			}
853
854	5		SV * _overload_add(pTHX_ SV * a, SV * b, SV * third) {
855			MATH_COMPLEX *pc;
856			SV * obj_ref, * obj;
857
858	5		New(42, pc, 1, MATH_COMPLEX);
859	5	50	if(pc == NULL) croak("Failed to allocate memory in _overload_add function");
860
861	5		obj_ref = newSV(0);
862	5		obj = newSVrv(obj_ref, "Math::Complex_C::L");
863
864	5		sv_setiv(obj, INT2PTR(IV,pc));
865	5		SvREADONLY_on(obj);
866
867	5	50	if(SvUOK(b)) {
868	0		pc = (INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(a)))) + (long double)SvUVX(b);
869	0		return obj_ref;
870			}
871
872	5	100	if(SvIOK(b)) {
873	2		pc = (INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(a)))) + (long double)SvIVX(b);
874	2		return obj_ref;
875			}
876
877	3	100	if(SvNOK(b)) {
878	1		pc = (INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(a)))) + (long double)SvNVX(b);
879	1		return obj_ref;
880			}
881	2	100	if(SvPOK(b)) {
882	1	50	if(!looks_like_number(b)) nnum++;
883	1	50	pc = (INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(a)))) + strtold(SvPV_nolen(b), NULL);
884	1		return obj_ref;
885			}
886	1	50	if(sv_isobject(b)) {
887	1	50	const char *h = HvNAME(SvSTASH(SvRV(b)));
		50
		50
		0
		50
		50
888	1	50	if(strEQ(h, "Math::Complex_C::L")) {
889	1		pc = (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))) + (INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(b))));
890	1		return obj_ref;
891			}
892			}
893
894	0		croak("Invalid argument supplied to Math::Complex_C::L::_overload_add function");
895			}
896
897	7		SV * _overload_div(pTHX_ SV * a, SV * b, SV * third) {
898			MATH_COMPLEX *pc;
899			SV * obj_ref, * obj;
900
901	7		New(42, pc, 1, MATH_COMPLEX);
902	7	50	if(pc == NULL) croak("Failed to allocate memory in _overload_div function");
903
904	7		obj_ref = newSV(0);
905	7		obj = newSVrv(obj_ref, "Math::Complex_C::L");
906
907	7		sv_setiv(obj, INT2PTR(IV,pc));
908	7		SvREADONLY_on(obj);
909
910	7	50	if(SvUOK(b)) {
911	0	0	if(third == &PL_sv_yes) pc = (long double)SvUVX(b) / (INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(a))));
912	0		else pc = (INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(a)))) / (long double)SvUVX(b);
913	0		return obj_ref;
914			}
915
916	7	100	if(SvIOK(b)) {
917	2	50	if(third == &PL_sv_yes) pc = (long double)SvIVX(b) / (INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(a))));
918	2		else pc = (INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(a)))) / (long double)SvIVX(b);
919	2		return obj_ref;
920			}
921
922	5	100	if(SvNOK(b)) {
923	1	50	if(third == &PL_sv_yes) pc = (long double)SvNVX(b) / (INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(a))));
924	1		else pc = (INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(a)))) / (long double)SvNVX(b);
925	1		return obj_ref;
926			}
927	4	100	if(SvPOK(b)) {
928	2	50	if(!looks_like_number(b)) nnum++;
929	2	100	if(third == &PL_sv_yes) pc = strtold(SvPV_nolen(b), NULL) / (INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(a))));
		50
930	1	50	else pc = (INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(a)))) / strtold(SvPV_nolen(b), NULL);
931	2		return obj_ref;
932			}
933	2	50	if(sv_isobject(b)) {
934	2	50	const char *h = HvNAME(SvSTASH(SvRV(b)));
		50
		50
		0
		50
		50
935	2	50	if(strEQ(h, "Math::Complex_C::L")) {
936	2		pc = (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))) / (INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(b))));
937	2		return obj_ref;
938			}
939			}
940
941	0		croak("Invalid argument supplied to Math::Complex_C::L::_overload_div function");
942			}
943
944	6		SV * _overload_sub(pTHX_ SV * a, SV * b, SV * third) {
945			MATH_COMPLEX *pc;
946			SV * obj_ref, * obj;
947
948	6		New(42, pc, 1, MATH_COMPLEX);
949	6	50	if(pc == NULL) croak("Failed to allocate memory in _overload_sub function");
950
951	6		obj_ref = newSV(0);
952	6		obj = newSVrv(obj_ref, "Math::Complex_C::L");
953
954	6		sv_setiv(obj, INT2PTR(IV,pc));
955	6		SvREADONLY_on(obj);
956
957	6	50	if(SvUOK(b)) {
958	0	0	if(third == &PL_sv_yes) pc = (long double)SvUVX(b) - (INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(a))));
959	0		else pc = (INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(a)))) - (long double)SvUVX(b);
960	0		return obj_ref;
961			}
962
963	6	100	if(SvIOK(b)) {
964	2	50	if(third == &PL_sv_yes) pc = (long double)SvIVX(b) - (INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(a))));
965	2		else pc = (INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(a)))) - (long double)SvIVX(b);
966	2		return obj_ref;
967			}
968
969	4	100	if(SvNOK(b)) {
970	1	50	if(third == &PL_sv_yes) pc = (long double)SvNVX(b) - (INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(a))));
971	1		else pc = (INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(a)))) - (long double)SvNVX(b);
972	1		return obj_ref;
973			}
974	3	100	if(SvPOK(b)) {
975	2	50	if(!looks_like_number(b)) nnum++;
976	2	100	if(third == &PL_sv_yes) pc = strtold(SvPV_nolen(b), NULL) - (INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(a))));
		50
977	1	50	else pc = (INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(a)))) - strtold(SvPV_nolen(b), NULL);
978	2		return obj_ref;
979			}
980	1	50	if(sv_isobject(b)) {
981	1	50	const char *h = HvNAME(SvSTASH(SvRV(b)));
		50
		50
		0
		50
		50
982	1	50	if(strEQ(h, "Math::Complex_C::L")) {
983	1		pc = (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))) - (INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(b))));
984	1		return obj_ref;
985			}
986			}
987
988	0		croak("Invalid argument supplied to Math::Complex_C::L::_overload_sub function");
989			}
990
991	1		SV * _overload_sqrt(pTHX_ SV * a, SV * b, SV * third) {
992			MATH_COMPLEX *pc;
993			SV * obj_ref, * obj;
994
995	1		New(42, pc, 1, MATH_COMPLEX);
996	1	50	if(pc == NULL) croak("Failed to allocate memory in _overload_sqrt function");
997
998	1		obj_ref = newSV(0);
999	1		obj = newSVrv(obj_ref, "Math::Complex_C::L");
1000
1001	1		pc = csqrtl((INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(a)))));
1002
1003	1		sv_setiv(obj, INT2PTR(IV,pc));
1004	1		SvREADONLY_on(obj);
1005	1		return obj_ref;
1006			}
1007
1008	4		SV * _overload_pow_eq(pTHX_ SV * a, SV * b, SV * third) {
1009			MATH_COMPLEX t;
1010	4		SvREFCNT_inc(a);
1011
1012	4	50	if(SvUOK(b)) {
1013	0		__real__ t = (long double)SvUVX(b);
1014	0		__imag__ t = 0.0L;
1015	0		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))) = cpowl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))), t);
1016	0		return a;
1017			}
1018	4	100	if(SvIOK(b)) {
1019	3		__real__ t = (long double)SvIVX(b);
1020	3		__imag__ t = 0.0L;
1021	3		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))) = cpowl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))), t);
1022	3		return a;
1023			}
1024	1	50	if(SvNOK(b)) {
1025	1		__real__ t = (long double)SvNVX(b);
1026	1		__imag__ t = 0.0L;
1027	1		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))) = cpowl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))), t);
1028	1		return a;
1029			}
1030	0	0	if(SvPOK(b)) {
1031	0	0	if(!looks_like_number(b)) nnum++;
1032	0	0	__real__ t = strtold(SvPV_nolen(b), NULL);
1033	0		__imag__ t = 0.0L;
1034	0		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))) = cpowl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))), t);
1035	0		return a;
1036			}
1037	0	0	if(sv_isobject(b)) {
1038	0	0	const char *h = HvNAME(SvSTASH(SvRV(b)));
		0
		0
		0
		0
		0
1039	0	0	if(strEQ(h, "Math::Complex_C::L")) {
1040	0		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))) = cpowl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))),
1041	0		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(b)))));
1042	0		return a;
1043			}
1044			}
1045	0		SvREFCNT_dec(a);
1046	0		croak("Invalid argument supplied to Math::Complex_C::L::_overload_pow_eq function");
1047			}
1048
1049	7		SV * _overload_mul_eq(pTHX_ SV * a, SV * b, SV * third) {
1050	7		SvREFCNT_inc(a);
1051
1052	7	50	if(SvUOK(b)) {
1053	0		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))) *= (long double)SvUVX(b);
1054	0		return a;
1055			}
1056
1057	7	100	if(SvIOK(b)) {
1058	2		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))) *= (long double)SvIVX(b);
1059	2		return a;
1060			}
1061
1062	5	100	if(SvNOK(b)) {
1063	1		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))) *= (long double)SvNVX(b);
1064	1		return a;
1065			}
1066
1067	4	100	if(SvPOK(b)) {
1068	2	100	if(!looks_like_number(b)) nnum++;
1069	2	50	(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))) *= strtold(SvPV_nolen(b), NULL);
1070	2		return a;
1071			}
1072
1073	2	50	if(sv_isobject(b)) {
1074	2	50	const char *h = HvNAME(SvSTASH(SvRV(b)));
		50
		50
		0
		50
		50
1075	2	50	if(strEQ(h, "Math::Complex_C::L")) {
1076	2		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))) = (INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(b))));
1077	2		return a;
1078			}
1079			}
1080
1081	0		SvREFCNT_dec(a);
1082	0		croak("Invalid argument supplied to Math::Complex_C::L::_overload_mul_eq function");
1083			}
1084
1085	6		SV * _overload_add_eq(pTHX_ SV * a, SV * b, SV * third) {
1086	6		SvREFCNT_inc(a);
1087
1088	6	50	if(SvUOK(b)) {
1089	0		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))) += (long double)SvUVX(b);
1090	0		return a;
1091			}
1092
1093	6	100	if(SvIOK(b)) {
1094	2		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))) += (long double)SvIVX(b);
1095	2		return a;
1096			}
1097
1098	4	100	if(SvNOK(b)) {
1099	1		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))) += (long double)SvNVX(b);
1100	1		return a;
1101			}
1102
1103	3	100	if(SvPOK(b)) {
1104	1	50	if(!looks_like_number(b)) nnum++;
1105	1	50	(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))) += strtold(SvPV_nolen(b), NULL);
1106	1		return a;
1107			}
1108
1109	2	50	if(sv_isobject(b)) {
1110	2	50	const char *h = HvNAME(SvSTASH(SvRV(b)));
		50
		50
		0
		50
		50
1111	2	50	if(strEQ(h, "Math::Complex_C::L")) {
1112	2		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))) += (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(b))));
1113	2		return a;
1114			}
1115			}
1116
1117	0		SvREFCNT_dec(a);
1118	0		croak("Invalid argument supplied to Math::Complex_C::L::_overload_add_eq function");
1119			}
1120
1121	5		SV * _overload_div_eq(pTHX_ SV * a, SV * b, SV * third) {
1122	5		SvREFCNT_inc(a);
1123
1124	5	50	if(SvUOK(b)) {
1125	0		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))) /= (long double)SvUVX(b);
1126	0		return a;
1127			}
1128
1129	5	100	if(SvIOK(b)) {
1130	2		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))) /= (long double)SvIVX(b);
1131	2		return a;
1132			}
1133
1134	3	100	if(SvNOK(b)) {
1135	1		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))) /= (long double)SvNVX(b);
1136	1		return a;
1137			}
1138
1139	2	100	if(SvPOK(b)) {
1140	1	50	if(!looks_like_number(b)) nnum++;
1141	1	50	(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))) /= strtold(SvPV_nolen(b), NULL);
1142	1		return a;
1143			}
1144
1145	1	50	if(sv_isobject(b)) {
1146	1	50	const char *h = HvNAME(SvSTASH(SvRV(b)));
		50
		50
		0
		50
		50
1147	1	50	if(strEQ(h, "Math::Complex_C::L")) {
1148	1		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))) /= (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(b))));
1149	1		return a;
1150			}
1151			}
1152
1153	0		SvREFCNT_dec(a);
1154	0		croak("Invalid argument supplied to Math::Complex_C::L::_overload_div_eq function");
1155			}
1156
1157	5		SV * _overload_sub_eq(pTHX_ SV * a, SV * b, SV * third) {
1158	5		SvREFCNT_inc(a);
1159
1160	5	50	if(SvUOK(b)) {
1161	0		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))) -= (long double)SvUVX(b);
1162	0		return a;
1163			}
1164
1165	5	100	if(SvIOK(b)) {
1166	2		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))) -= (long double)SvIVX(b);
1167	2		return a;
1168			}
1169
1170	3	100	if(SvNOK(b)) {
1171	1		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))) -= (long double)SvNVX(b);
1172	1		return a;
1173			}
1174
1175	2	100	if(SvPOK(b)) {
1176	1	50	if(!looks_like_number(b)) nnum++;
1177	1	50	(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))) -= strtold(SvPV_nolen(b), NULL);
1178	1		return a;
1179			}
1180
1181	1	50	if(sv_isobject(b)) {
1182	1	50	const char *h = HvNAME(SvSTASH(SvRV(b)));
		50
		50
		0
		50
		50
1183	1	50	if(strEQ(h, "Math::Complex_C::L")) {
1184	1		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(a)))) -= (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(b))));
1185	1		return a;
1186			}
1187			}
1188
1189	0		SvREFCNT_dec(a);
1190	0		croak("Invalid argument supplied to Math::Complex_C::L::_overload_sub_eq function");
1191			}
1192
1193	4		SV * _overload_copy(pTHX_ SV * a, SV * second, SV * third) {
1194
1195			MATH_COMPLEX *pc;
1196			SV * obj_ref, * obj;
1197
1198	4		New(42, pc, 1, MATH_COMPLEX);
1199	4	50	if(pc == NULL) croak("Failed to allocate memory in _overload_copy function");
1200
1201	4		obj_ref = newSV(0);
1202	4		obj = newSVrv(obj_ref, "Math::Complex_C::L");
1203
1204	4		__real__ pc = __real__ (INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(a))));
1205	4		__imag__ pc = __imag__ (INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(a))));
1206
1207	4		sv_setiv(obj, INT2PTR(IV,pc));
1208	4		SvREADONLY_on(obj);
1209	4		return obj_ref;
1210
1211			}
1212
1213	1		SV * _overload_abs(pTHX_ SV * rop, SV * second, SV * third) {
1214	1		return newSVnv(cabsl((INT2PTR(MATH_COMPLEX , SvIVX(SvRV(rop))))));
1215			}
1216
1217	1		SV * _overload_exp(pTHX_ SV * a, SV * b, SV * third) {
1218			MATH_COMPLEX *pc;
1219			SV * obj_ref, * obj;
1220
1221	1		New(42, pc, 1, MATH_COMPLEX);
1222	1	50	if(pc == NULL) croak("Failed to allocate memory in _overload_exp function");
1223
1224	1		obj_ref = newSV(0);
1225	1		obj = newSVrv(obj_ref, "Math::Complex_C::L");
1226
1227	1		pc = cexpl((INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(a)))));
1228
1229	1		sv_setiv(obj, INT2PTR(IV,pc));
1230	1		SvREADONLY_on(obj);
1231	1		return obj_ref;
1232			}
1233
1234	1		SV * _overload_log(pTHX_ SV * a, SV * b, SV * third) {
1235			MATH_COMPLEX *pc;
1236			SV * obj_ref, * obj;
1237
1238	1		New(42, pc, 1, MATH_COMPLEX);
1239	1	50	if(pc == NULL) croak("Failed to allocate memory in _overload_log function");
1240
1241	1		obj_ref = newSV(0);
1242	1		obj = newSVrv(obj_ref, "Math::Complex_C::L");
1243
1244	1		pc = clogl((INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(a)))));
1245
1246	1		sv_setiv(obj, INT2PTR(IV,pc));
1247	1		SvREADONLY_on(obj);
1248	1		return obj_ref;
1249			}
1250
1251	1		SV * _overload_sin(pTHX_ SV * a, SV * b, SV * third) {
1252			MATH_COMPLEX *pc;
1253			SV * obj_ref, * obj;
1254
1255	1		New(42, pc, 1, MATH_COMPLEX);
1256	1	50	if(pc == NULL) croak("Failed to allocate memory in _overload_sin function");
1257
1258	1		obj_ref = newSV(0);
1259	1		obj = newSVrv(obj_ref, "Math::Complex_C::L");
1260
1261	1		pc = csinl((INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(a)))));
1262
1263	1		sv_setiv(obj, INT2PTR(IV,pc));
1264	1		SvREADONLY_on(obj);
1265	1		return obj_ref;
1266			}
1267
1268	1		SV * _overload_cos(pTHX_ SV * a, SV * b, SV * third) {
1269			MATH_COMPLEX *pc;
1270			SV * obj_ref, * obj;
1271
1272	1		New(42, pc, 1, MATH_COMPLEX);
1273	1	50	if(pc == NULL) croak("Failed to allocate memory in _overload_cos function");
1274
1275	1		obj_ref = newSV(0);
1276	1		obj = newSVrv(obj_ref, "Math::Complex_C::L");
1277
1278	1		pc = ccosl((INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(a)))));
1279
1280	1		sv_setiv(obj, INT2PTR(IV,pc));
1281	1		SvREADONLY_on(obj);
1282	1		return obj_ref;
1283			}
1284
1285	1		SV * _overload_atan2(pTHX_ SV * a, SV * b, SV * third) {
1286			MATH_COMPLEX *pc;
1287			SV * obj_ref, * obj;
1288
1289	1		New(42, pc, 1, MATH_COMPLEX);
1290	1	50	if(pc == NULL) croak("Failed to allocate memory in _overload_atan2 function");
1291
1292	1		obj_ref = newSV(0);
1293	1		obj = newSVrv(obj_ref, "Math::Complex_C::L");
1294
1295	2		pc = (INT2PTR(MATH_COMPLEX *, SvIVX(SvRV(a)))) /
1296	1		(INT2PTR(MATH_COMPLEX , SvIVX(SvRV(b)))) ;
1297
1298	1		pc = catanl(pc);
1299
1300	1		sv_setiv(obj, INT2PTR(IV,pc));
1301	1		SvREADONLY_on(obj);
1302	1		return obj_ref;
1303			}
1304
1305	4		SV * get_nanl(pTHX) {
1306	4		return newSVnv(_get_nan());
1307			}
1308
1309	2		SV * get_infl(pTHX) {
1310			#if defined(NO_INF_CAST_TO_NV) && defined(__GNUC__) && ((__GNUC__ > 4 && __GNUC__ < 7) \|\| (__GNUC__ == 4 && __GNUC_MINOR__ >= 9))
1311			return newSVnv((NV)strtod("inf", NULL));
1312			#else
1313	2		return newSVnv(_get_inf());
1314			#endif
1315			}
1316
1317	0		SV * get_neg_infl(pTHX) {
1318			#if defined(NO_INF_CAST_TO_NV) && defined(__GNUC__) && ((__GNUC__ > 4 && __GNUC__ < 7) \|\| (__GNUC__ == 4 && __GNUC_MINOR__ >= 9))
1319			return newSVnv((NV)strtod("-inf", NULL));
1320			#else
1321	0		return newSVnv(_get_neg_inf());
1322			#endif
1323			}
1324
1325	1		SV * is_nanl(pTHX_ SV * a) {
1326	1	50	if(SvNV(a) == SvNV(a)) return newSVuv(0);
		50
		50
1327	1		return newSVuv(1);
1328			}
1329
1330	6		SV * is_infl(pTHX_ SV * a) {
1331	6	50	if(SvNV(a) == 0) return newSVuv(0);
		50
1332	6	50	if(SvNV(a) != SvNV(a)) return newSVuv(0);
		50
		50
1333	6	50	if(SvNV(a) / SvNV(a) == SvNV(a) / SvNV(a)) return newSVuv(0);
		50
		50
		50
		50
1334	6	50	if(SvNV(a) < 0) return newSViv(-1);
		50
1335	6		return newSViv(1);
1336			}
1337
1338	0		SV * _complex_type(pTHX) {
1339	0		return newSVpv("__complex128", 0);
1340			}
1341
1342	0		SV * _double_type(pTHX) {
1343	0		return newSVpv("__long double", 0);
1344			}
1345
1346	0		SV * _get_nv(pTHX_ SV * x) {
1347	0	0	return newSVnv(SvNV(x));
1348			}
1349
1350	0		SV * _which_package(pTHX_ SV * b) {
1351	0	0	if(sv_isobject(b)) return newSVpv(HvNAME(SvSTASH(SvRV(b))), 0);
		0
		0
		0
		0
		0
		0
1352	0		return newSVpv("Not an object", 0);
1353			}
1354
1355	0		SV * _wrap_count(pTHX) {
1356	0		return newSVuv(PL_sv_count);
1357			}
1358
1359	0		SV * _ivsize(pTHX) {
1360	0		return newSViv(sizeof(IV));
1361			}
1362
1363	0		SV * _nvsize(pTHX) {
1364	0		return newSViv(sizeof(NV));
1365			}
1366
1367	0		SV * _doublesize(pTHX) {
1368	0		return newSViv(sizeof(double));
1369			}
1370
1371	0		SV * _longdoublesize(pTHX) {
1372	0		return newSViv(sizeof(long double));
1373			}
1374
1375	0		SV * _double_Complexsize(pTHX) {
1376	0		return newSViv(sizeof(double _Complex));
1377			}
1378
1379	0		SV * _longdouble_Complexsize(pTHX) {
1380	0		return newSViv(sizeof(long double _Complex));
1381			}
1382
1383
1384	12		void _l_to_str(pTHX_ SV * ld) {
1385	12		dXSARGS;
1386			MATH_COMPLEX t;
1387			char *rbuffer;
1388			int query;
1389
1390	12	50	if(sv_isobject(ld)) {
1391	12	50	const char *h = HvNAME(SvSTASH(SvRV(ld)));
		50
		50
		0
		50
		50
1392	12	50	if(strEQ(h, "Math::Complex_C::L")) {
1393	12	50	EXTEND(SP, 2);
1394
1395	12		t = (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(ld))));
1396			/**/
1397	12		Newx(rbuffer, 8 + _MATH_COMPLEX_C_L_DIGITS, char);
1398	12	50	if(rbuffer == NULL) croak("Failed to allocate memory in l_to_str");
1399
1400	12		query = _is_inf(__real__ t);
1401	12	100	if(query \|\| _is_nan(__real__ t))
		100
1402	9	100	sprintf(rbuffer, "%s", query ? query > 0 ? "inf"
1403	2	100	: "-inf"
1404			: "nan");
1405			else
1406	5		sprintf(rbuffer, "%.*Le", _MATH_COMPLEX_C_L_DIGITS - 1, __real__ t);
1407
1408	12		ST(0) = sv_2mortal(newSVpv(rbuffer, 0));
1409
1410	12		query = _is_inf(__imag__ t);
1411	12	100	if(query \|\| _is_nan(__imag__ t))
		100
1412	9	100	sprintf(rbuffer, "%s", query ? query > 0 ? "inf"
1413	2	100	: "-inf"
1414			: "nan");
1415			else
1416	5		sprintf(rbuffer, "%.*Le", _MATH_COMPLEX_C_L_DIGITS - 1, __imag__ t);
1417
1418	12		ST(1) = sv_2mortal(newSVpv(rbuffer, 0));
1419			/**/
1420	12		Safefree(rbuffer);
1421	12		XSRETURN(2);
1422			}
1423	0		else croak("l_to_str function needs a Math::Complex_C::L arg but was supplied with a %s arg", h);
1424			}
1425	0		else croak("Invalid argument supplied to Math::Complex_C::L::l_to_str function");
1426			}
1427
1428	3		void _l_to_strp(pTHX_ SV * ld, int decimal_prec) {
1429	3		dXSARGS;
1430			MATH_COMPLEX t;
1431			char *rbuffer;
1432			int query;
1433
1434	3	50	if(decimal_prec < 1)croak("2nd arg (precision) to _l_to_strp must be at least 1");
1435
1436	3	50	if(sv_isobject(ld)) {
1437	3	50	const char *h = HvNAME(SvSTASH(SvRV(ld)));
		50
		50
		0
		50
		50
1438	3	50	if(strEQ(h, "Math::Complex_C::L")) {
1439	3	50	EXTEND(SP, 2);
1440	3		t = (INT2PTR(MATH_COMPLEX , SvIVX(SvRV(ld))));
1441			/* new */
1442	3		Newx(rbuffer, 8 + decimal_prec, char);
1443	3	50	if(rbuffer == NULL) croak("Failed to allocate memory in l_to_strp");
1444
1445	3		query = _is_inf(__real__ t);
1446	3	100	if(query \|\| _is_nan(__real__ t))
		50
1447	5	100	sprintf(rbuffer, "%s", query ? query > 0 ? "inf"
1448	2	100	: "-inf"
1449			: "nan");
1450			else
1451	0		sprintf(rbuffer, "%.*Le", decimal_prec - 1, __real__ t);
1452
1453	3		ST(0) = sv_2mortal(newSVpv(rbuffer, 0));
1454
1455	3		query = _is_inf(__imag__ t);
1456	3	100	if(query \|\| _is_nan(__imag__ t))
		50
1457	5	100	sprintf(rbuffer, "%s", query ? query > 0 ? "inf"
1458	2	100	: "-inf"
1459			: "nan");
1460			else
1461	0		sprintf(rbuffer, "%.*Le", decimal_prec - 1, __imag__ t);
1462
1463	3		ST(1) = sv_2mortal(newSVpv(rbuffer, 0));
1464			/**/
1465	3		Safefree(rbuffer);
1466	3		XSRETURN(2);
1467			}
1468	0		else croak("l_to_strp function needs a Math::Complex_C::L arg but was supplied with a %s arg", h);
1469			}
1470	0		else croak("Invalid argument supplied to Math::Complex_C::L::l_to_strp function");
1471			}
1472
1473	0		SV * _LDBL_DIG(pTHX) {
1474			#ifdef LDBL_DIG
1475	0		return newSViv(LDBL_DIG);
1476			#else
1477			return 0;
1478			#endif
1479			}
1480
1481	0		SV * _DBL_DIG(pTHX) {
1482			#ifdef DBL_DIG
1483	0		return newSViv(DBL_DIG);
1484			#else
1485			return 0;
1486			#endif
1487			}
1488
1489	0		SV * _get_xs_version(pTHX) {
1490	0		return newSVpv(XS_VERSION, 0);
1491			}
1492
1493	9		SV * _itsa(pTHX_ SV * a) {
1494	9	50	if(SvUOK(a)) return newSVuv(1);
1495	9	50	if(SvIOK(a)) return newSVuv(2);
1496	9	100	if(SvNOK(a)) return newSVuv(3);
1497	4	50	if(SvPOK(a)) return newSVuv(4);
1498	0	0	if(sv_isobject(a)) {
1499	0	0	const char *h = HvNAME(SvSTASH(SvRV(a)));
		0
		0
		0
		0
		0
1500	0	0	if(strEQ(h, "Math::LongDouble")) return newSVuv(96);
1501	0	0	if(strEQ(h, "Math::Float128")) return newSVuv(113);
1502	0	0	if(strEQ(h, "Math::Complex_C::L")) return newSVuv(226);
1503			}
1504	0		return newSVuv(0);
1505			}
1506
1507	4		int nnumflag(void) {
1508	4		return nnum;
1509			}
1510
1511	1		void clear_nnum(void) {
1512	1		nnum = 0;
1513	1		}
1514
1515	1		void set_nnum(int x) {
1516	1		nnum = x;
1517	1		}
1518
1519	0		int _lln(pTHX_ SV * x) {
1520	0	0	if(looks_like_number(x)) return 1;
1521	0		return 0;
1522			}
1523
1524
1525
1526			MODULE = Math::Complex_C::L PACKAGE = Math::Complex_C::L
1527
1528			PROTOTYPES: DISABLE
1529
1530
1531			void
1532			l_set_prec (x)
1533			int x
1534			PREINIT:
1535			I32* temp;
1536			PPCODE:
1537	2		temp = PL_markstack_ptr++;
1538	2		l_set_prec(x);
1539	2	50	if (PL_markstack_ptr != temp) {
1540			/* truly void, because dXSARGS not invoked */
1541	2		PL_markstack_ptr = temp;
1542	2		XSRETURN_EMPTY; /* return empty stack */
1543			}
1544			/* must have used dXSARGS; list context implied */
1545	0		return; /* assume stack size is correct */
1546
1547			int
1548			l_get_prec ()
1549
1550
1551			SV *
1552			create_cl ()
1553			CODE:
1554	62		RETVAL = create_cl (aTHX);
1555			OUTPUT: RETVAL
1556
1557
1558			void
1559			assign_cl (rop, d1, d2)
1560			SV * rop
1561			SV * d1
1562			SV * d2
1563			PREINIT:
1564			I32* temp;
1565			PPCODE:
1566	65		temp = PL_markstack_ptr++;
1567	65		assign_cl(aTHX_ rop, d1, d2);
1568	65	50	if (PL_markstack_ptr != temp) {
1569			/* truly void, because dXSARGS not invoked */
1570	65		PL_markstack_ptr = temp;
1571	65		XSRETURN_EMPTY; /* return empty stack */
1572			}
1573			/* must have used dXSARGS; list context implied */
1574	0		return; /* assume stack size is correct */
1575
1576			void
1577			set_real_cl (rop, d1)
1578			SV * rop
1579			SV * d1
1580			PREINIT:
1581			I32* temp;
1582			PPCODE:
1583	4		temp = PL_markstack_ptr++;
1584	4		set_real_cl(aTHX_ rop, d1);
1585	4	50	if (PL_markstack_ptr != temp) {
1586			/* truly void, because dXSARGS not invoked */
1587	4		PL_markstack_ptr = temp;
1588	4		XSRETURN_EMPTY; /* return empty stack */
1589			}
1590			/* must have used dXSARGS; list context implied */
1591	0		return; /* assume stack size is correct */
1592
1593			void
1594			set_imag_cl (rop, d2)
1595			SV * rop
1596			SV * d2
1597			PREINIT:
1598			I32* temp;
1599			PPCODE:
1600	4		temp = PL_markstack_ptr++;
1601	4		set_imag_cl(aTHX_ rop, d2);
1602	4	50	if (PL_markstack_ptr != temp) {
1603			/* truly void, because dXSARGS not invoked */
1604	4		PL_markstack_ptr = temp;
1605	4		XSRETURN_EMPTY; /* return empty stack */
1606			}
1607			/* must have used dXSARGS; list context implied */
1608	0		return; /* assume stack size is correct */
1609
1610			void
1611			LD2cl (rop, d1, d2)
1612			SV * rop
1613			SV * d1
1614			SV * d2
1615			PREINIT:
1616			I32* temp;
1617			PPCODE:
1618	0		temp = PL_markstack_ptr++;
1619	0		LD2cl(aTHX_ rop, d1, d2);
1620	0	0	if (PL_markstack_ptr != temp) {
1621			/* truly void, because dXSARGS not invoked */
1622	0		PL_markstack_ptr = temp;
1623	0		XSRETURN_EMPTY; /* return empty stack */
1624			}
1625			/* must have used dXSARGS; list context implied */
1626	0		return; /* assume stack size is correct */
1627
1628			void
1629			cl2LD (rop1, rop2, op)
1630			SV * rop1
1631			SV * rop2
1632			SV * op
1633			PREINIT:
1634			I32* temp;
1635			PPCODE:
1636	0		temp = PL_markstack_ptr++;
1637	0		cl2LD(aTHX_ rop1, rop2, op);
1638	0	0	if (PL_markstack_ptr != temp) {
1639			/* truly void, because dXSARGS not invoked */
1640	0		PL_markstack_ptr = temp;
1641	0		XSRETURN_EMPTY; /* return empty stack */
1642			}
1643			/* must have used dXSARGS; list context implied */
1644	0		return; /* assume stack size is correct */
1645
1646			void
1647			mul_cl (rop, op1, op2)
1648			SV * rop
1649			SV * op1
1650			SV * op2
1651			PREINIT:
1652			I32* temp;
1653			PPCODE:
1654	1		temp = PL_markstack_ptr++;
1655	1		mul_cl(aTHX_ rop, op1, op2);
1656	1	50	if (PL_markstack_ptr != temp) {
1657			/* truly void, because dXSARGS not invoked */
1658	1		PL_markstack_ptr = temp;
1659	1		XSRETURN_EMPTY; /* return empty stack */
1660			}
1661			/* must have used dXSARGS; list context implied */
1662	0		return; /* assume stack size is correct */
1663
1664			void
1665			mul_c_nvl (rop, op1, op2)
1666			SV * rop
1667			SV * op1
1668			SV * op2
1669			PREINIT:
1670			I32* temp;
1671			PPCODE:
1672	1		temp = PL_markstack_ptr++;
1673	1		mul_c_nvl(aTHX_ rop, op1, op2);
1674	1	50	if (PL_markstack_ptr != temp) {
1675			/* truly void, because dXSARGS not invoked */
1676	1		PL_markstack_ptr = temp;
1677	1		XSRETURN_EMPTY; /* return empty stack */
1678			}
1679			/* must have used dXSARGS; list context implied */
1680	0		return; /* assume stack size is correct */
1681
1682			void
1683			mul_c_ivl (rop, op1, op2)
1684			SV * rop
1685			SV * op1
1686			SV * op2
1687			PREINIT:
1688			I32* temp;
1689			PPCODE:
1690	1		temp = PL_markstack_ptr++;
1691	1		mul_c_ivl(aTHX_ rop, op1, op2);
1692	1	50	if (PL_markstack_ptr != temp) {
1693			/* truly void, because dXSARGS not invoked */
1694	1		PL_markstack_ptr = temp;
1695	1		XSRETURN_EMPTY; /* return empty stack */
1696			}
1697			/* must have used dXSARGS; list context implied */
1698	0		return; /* assume stack size is correct */
1699
1700			void
1701			mul_c_uvl (rop, op1, op2)
1702			SV * rop
1703			SV * op1
1704			SV * op2
1705			PREINIT:
1706			I32* temp;
1707			PPCODE:
1708	1		temp = PL_markstack_ptr++;
1709	1		mul_c_uvl(aTHX_ rop, op1, op2);
1710	1	50	if (PL_markstack_ptr != temp) {
1711			/* truly void, because dXSARGS not invoked */
1712	1		PL_markstack_ptr = temp;
1713	1		XSRETURN_EMPTY; /* return empty stack */
1714			}
1715			/* must have used dXSARGS; list context implied */
1716	0		return; /* assume stack size is correct */
1717
1718			void
1719			mul_c_pvl (rop, op1, op2)
1720			SV * rop
1721			SV * op1
1722			SV * op2
1723			PREINIT:
1724			I32* temp;
1725			PPCODE:
1726	1		temp = PL_markstack_ptr++;
1727	1		mul_c_pvl(aTHX_ rop, op1, op2);
1728	1	50	if (PL_markstack_ptr != temp) {
1729			/* truly void, because dXSARGS not invoked */
1730	1		PL_markstack_ptr = temp;
1731	1		XSRETURN_EMPTY; /* return empty stack */
1732			}
1733			/* must have used dXSARGS; list context implied */
1734	0		return; /* assume stack size is correct */
1735
1736			void
1737			div_cl (rop, op1, op2)
1738			SV * rop
1739			SV * op1
1740			SV * op2
1741			PREINIT:
1742			I32* temp;
1743			PPCODE:
1744	1		temp = PL_markstack_ptr++;
1745	1		div_cl(aTHX_ rop, op1, op2);
1746	1	50	if (PL_markstack_ptr != temp) {
1747			/* truly void, because dXSARGS not invoked */
1748	1		PL_markstack_ptr = temp;
1749	1		XSRETURN_EMPTY; /* return empty stack */
1750			}
1751			/* must have used dXSARGS; list context implied */
1752	0		return; /* assume stack size is correct */
1753
1754			void
1755			div_c_nvl (rop, op1, op2)
1756			SV * rop
1757			SV * op1
1758			SV * op2
1759			PREINIT:
1760			I32* temp;
1761			PPCODE:
1762	1		temp = PL_markstack_ptr++;
1763	1		div_c_nvl(aTHX_ rop, op1, op2);
1764	1	50	if (PL_markstack_ptr != temp) {
1765			/* truly void, because dXSARGS not invoked */
1766	1		PL_markstack_ptr = temp;
1767	1		XSRETURN_EMPTY; /* return empty stack */
1768			}
1769			/* must have used dXSARGS; list context implied */
1770	0		return; /* assume stack size is correct */
1771
1772			void
1773			div_c_ivl (rop, op1, op2)
1774			SV * rop
1775			SV * op1
1776			SV * op2
1777			PREINIT:
1778			I32* temp;
1779			PPCODE:
1780	1		temp = PL_markstack_ptr++;
1781	1		div_c_ivl(aTHX_ rop, op1, op2);
1782	1	50	if (PL_markstack_ptr != temp) {
1783			/* truly void, because dXSARGS not invoked */
1784	1		PL_markstack_ptr = temp;
1785	1		XSRETURN_EMPTY; /* return empty stack */
1786			}
1787			/* must have used dXSARGS; list context implied */
1788	0		return; /* assume stack size is correct */
1789
1790			void
1791			div_c_uvl (rop, op1, op2)
1792			SV * rop
1793			SV * op1
1794			SV * op2
1795			PREINIT:
1796			I32* temp;
1797			PPCODE:
1798	1		temp = PL_markstack_ptr++;
1799	1		div_c_uvl(aTHX_ rop, op1, op2);
1800	1	50	if (PL_markstack_ptr != temp) {
1801			/* truly void, because dXSARGS not invoked */
1802	1		PL_markstack_ptr = temp;
1803	1		XSRETURN_EMPTY; /* return empty stack */
1804			}
1805			/* must have used dXSARGS; list context implied */
1806	0		return; /* assume stack size is correct */
1807
1808			void
1809			div_c_pvl (rop, op1, op2)
1810			SV * rop
1811			SV * op1
1812			SV * op2
1813			PREINIT:
1814			I32* temp;
1815			PPCODE:
1816	1		temp = PL_markstack_ptr++;
1817	1		div_c_pvl(aTHX_ rop, op1, op2);
1818	1	50	if (PL_markstack_ptr != temp) {
1819			/* truly void, because dXSARGS not invoked */
1820	1		PL_markstack_ptr = temp;
1821	1		XSRETURN_EMPTY; /* return empty stack */
1822			}
1823			/* must have used dXSARGS; list context implied */
1824	0		return; /* assume stack size is correct */
1825
1826			void
1827			add_cl (rop, op1, op2)
1828			SV * rop
1829			SV * op1
1830			SV * op2
1831			PREINIT:
1832			I32* temp;
1833			PPCODE:
1834	1		temp = PL_markstack_ptr++;
1835	1		add_cl(aTHX_ rop, op1, op2);
1836	1	50	if (PL_markstack_ptr != temp) {
1837			/* truly void, because dXSARGS not invoked */
1838	1		PL_markstack_ptr = temp;
1839	1		XSRETURN_EMPTY; /* return empty stack */
1840			}
1841			/* must have used dXSARGS; list context implied */
1842	0		return; /* assume stack size is correct */
1843
1844			void
1845			add_c_nvl (rop, op1, op2)
1846			SV * rop
1847			SV * op1
1848			SV * op2
1849			PREINIT:
1850			I32* temp;
1851			PPCODE:
1852	1		temp = PL_markstack_ptr++;
1853	1		add_c_nvl(aTHX_ rop, op1, op2);
1854	1	50	if (PL_markstack_ptr != temp) {
1855			/* truly void, because dXSARGS not invoked */
1856	1		PL_markstack_ptr = temp;
1857	1		XSRETURN_EMPTY; /* return empty stack */
1858			}
1859			/* must have used dXSARGS; list context implied */
1860	0		return; /* assume stack size is correct */
1861
1862			void
1863			add_c_ivl (rop, op1, op2)
1864			SV * rop
1865			SV * op1
1866			SV * op2
1867			PREINIT:
1868			I32* temp;
1869			PPCODE:
1870	1		temp = PL_markstack_ptr++;
1871	1		add_c_ivl(aTHX_ rop, op1, op2);
1872	1	50	if (PL_markstack_ptr != temp) {
1873			/* truly void, because dXSARGS not invoked */
1874	1		PL_markstack_ptr = temp;
1875	1		XSRETURN_EMPTY; /* return empty stack */
1876			}
1877			/* must have used dXSARGS; list context implied */
1878	0		return; /* assume stack size is correct */
1879
1880			void
1881			add_c_uvl (rop, op1, op2)
1882			SV * rop
1883			SV * op1
1884			SV * op2
1885			PREINIT:
1886			I32* temp;
1887			PPCODE:
1888	1		temp = PL_markstack_ptr++;
1889	1		add_c_uvl(aTHX_ rop, op1, op2);
1890	1	50	if (PL_markstack_ptr != temp) {
1891			/* truly void, because dXSARGS not invoked */
1892	1		PL_markstack_ptr = temp;
1893	1		XSRETURN_EMPTY; /* return empty stack */
1894			}
1895			/* must have used dXSARGS; list context implied */
1896	0		return; /* assume stack size is correct */
1897
1898			void
1899			add_c_pvl (rop, op1, op2)
1900			SV * rop
1901			SV * op1
1902			SV * op2
1903			PREINIT:
1904			I32* temp;
1905			PPCODE:
1906	1		temp = PL_markstack_ptr++;
1907	1		add_c_pvl(aTHX_ rop, op1, op2);
1908	1	50	if (PL_markstack_ptr != temp) {
1909			/* truly void, because dXSARGS not invoked */
1910	1		PL_markstack_ptr = temp;
1911	1		XSRETURN_EMPTY; /* return empty stack */
1912			}
1913			/* must have used dXSARGS; list context implied */
1914	0		return; /* assume stack size is correct */
1915
1916			void
1917			sub_cl (rop, op1, op2)
1918			SV * rop
1919			SV * op1
1920			SV * op2
1921			PREINIT:
1922			I32* temp;
1923			PPCODE:
1924	1		temp = PL_markstack_ptr++;
1925	1		sub_cl(aTHX_ rop, op1, op2);
1926	1	50	if (PL_markstack_ptr != temp) {
1927			/* truly void, because dXSARGS not invoked */
1928	1		PL_markstack_ptr = temp;
1929	1		XSRETURN_EMPTY; /* return empty stack */
1930			}
1931			/* must have used dXSARGS; list context implied */
1932	0		return; /* assume stack size is correct */
1933
1934			void
1935			sub_c_nvl (rop, op1, op2)
1936			SV * rop
1937			SV * op1
1938			SV * op2
1939			PREINIT:
1940			I32* temp;
1941			PPCODE:
1942	1		temp = PL_markstack_ptr++;
1943	1		sub_c_nvl(aTHX_ rop, op1, op2);
1944	1	50	if (PL_markstack_ptr != temp) {
1945			/* truly void, because dXSARGS not invoked */
1946	1		PL_markstack_ptr = temp;
1947	1		XSRETURN_EMPTY; /* return empty stack */
1948			}
1949			/* must have used dXSARGS; list context implied */
1950	0		return; /* assume stack size is correct */
1951
1952			void
1953			sub_c_ivl (rop, op1, op2)
1954			SV * rop
1955			SV * op1
1956			SV * op2
1957			PREINIT:
1958			I32* temp;
1959			PPCODE:
1960	1		temp = PL_markstack_ptr++;
1961	1		sub_c_ivl(aTHX_ rop, op1, op2);
1962	1	50	if (PL_markstack_ptr != temp) {
1963			/* truly void, because dXSARGS not invoked */
1964	1		PL_markstack_ptr = temp;
1965	1		XSRETURN_EMPTY; /* return empty stack */
1966			}
1967			/* must have used dXSARGS; list context implied */
1968	0		return; /* assume stack size is correct */
1969
1970			void
1971			sub_c_uvl (rop, op1, op2)
1972			SV * rop
1973			SV * op1
1974			SV * op2
1975			PREINIT:
1976			I32* temp;
1977			PPCODE:
1978	1		temp = PL_markstack_ptr++;
1979	1		sub_c_uvl(aTHX_ rop, op1, op2);
1980	1	50	if (PL_markstack_ptr != temp) {
1981			/* truly void, because dXSARGS not invoked */
1982	1		PL_markstack_ptr = temp;
1983	1		XSRETURN_EMPTY; /* return empty stack */
1984			}
1985			/* must have used dXSARGS; list context implied */
1986	0		return; /* assume stack size is correct */
1987
1988			void
1989			sub_c_pvl (rop, op1, op2)
1990			SV * rop
1991			SV * op1
1992			SV * op2
1993			PREINIT:
1994			I32* temp;
1995			PPCODE:
1996	1		temp = PL_markstack_ptr++;
1997	1		sub_c_pvl(aTHX_ rop, op1, op2);
1998	1	50	if (PL_markstack_ptr != temp) {
1999			/* truly void, because dXSARGS not invoked */
2000	1		PL_markstack_ptr = temp;
2001	1		XSRETURN_EMPTY; /* return empty stack */
2002			}
2003			/* must have used dXSARGS; list context implied */
2004	0		return; /* assume stack size is correct */
2005
2006			void
2007			DESTROY (op)
2008			SV * op
2009			PREINIT:
2010			I32* temp;
2011			PPCODE:
2012	100		temp = PL_markstack_ptr++;
2013	100		DESTROY(aTHX_ op);
2014	100	50	if (PL_markstack_ptr != temp) {
2015			/* truly void, because dXSARGS not invoked */
2016	100		PL_markstack_ptr = temp;
2017	100		XSRETURN_EMPTY; /* return empty stack */
2018			}
2019			/* must have used dXSARGS; list context implied */
2020	0		return; /* assume stack size is correct */
2021
2022			SV *
2023			real_cl (op)
2024			SV * op
2025			CODE:
2026	68		RETVAL = real_cl (aTHX_ op);
2027			OUTPUT: RETVAL
2028
2029			SV *
2030			real_cl2LD (op)
2031			SV * op
2032			CODE:
2033	0		RETVAL = real_cl2LD (aTHX_ op);
2034			OUTPUT: RETVAL
2035
2036			void
2037			real_cl2str (op)
2038			SV * op
2039			PREINIT:
2040			I32* temp;
2041			PPCODE:
2042	1		temp = PL_markstack_ptr++;
2043	1		real_cl2str(aTHX_ op);
2044	1	50	if (PL_markstack_ptr != temp) {
2045			/* truly void, because dXSARGS not invoked */
2046	0		PL_markstack_ptr = temp;
2047	0		XSRETURN_EMPTY; /* return empty stack */
2048			}
2049			/* must have used dXSARGS; list context implied */
2050	1		return; /* assume stack size is correct */
2051
2052			SV *
2053			imag_cl (op)
2054			SV * op
2055			CODE:
2056	60		RETVAL = imag_cl (aTHX_ op);
2057			OUTPUT: RETVAL
2058
2059			SV *
2060			imag_cl2LD (op)
2061			SV * op
2062			CODE:
2063	0		RETVAL = imag_cl2LD (aTHX_ op);
2064			OUTPUT: RETVAL
2065
2066			void
2067			imag_cl2str (op)
2068			SV * op
2069			PREINIT:
2070			I32* temp;
2071			PPCODE:
2072	1		temp = PL_markstack_ptr++;
2073	1		imag_cl2str(aTHX_ op);
2074	1	50	if (PL_markstack_ptr != temp) {
2075			/* truly void, because dXSARGS not invoked */
2076	0		PL_markstack_ptr = temp;
2077	0		XSRETURN_EMPTY; /* return empty stack */
2078			}
2079			/* must have used dXSARGS; list context implied */
2080	1		return; /* assume stack size is correct */
2081
2082			SV *
2083			arg_cl (op)
2084			SV * op
2085			CODE:
2086	1		RETVAL = arg_cl (aTHX_ op);
2087			OUTPUT: RETVAL
2088
2089			SV *
2090			arg_cl2LD (op)
2091			SV * op
2092			CODE:
2093	0		RETVAL = arg_cl2LD (aTHX_ op);
2094			OUTPUT: RETVAL
2095
2096			void
2097			arg_cl2str (op)
2098			SV * op
2099			PREINIT:
2100			I32* temp;
2101			PPCODE:
2102	1		temp = PL_markstack_ptr++;
2103	1		arg_cl2str(aTHX_ op);
2104	1	50	if (PL_markstack_ptr != temp) {
2105			/* truly void, because dXSARGS not invoked */
2106	0		PL_markstack_ptr = temp;
2107	0		XSRETURN_EMPTY; /* return empty stack */
2108			}
2109			/* must have used dXSARGS; list context implied */
2110	1		return; /* assume stack size is correct */
2111
2112			SV *
2113			abs_cl (op)
2114			SV * op
2115			CODE:
2116	1		RETVAL = abs_cl (aTHX_ op);
2117			OUTPUT: RETVAL
2118
2119			SV *
2120			abs_cl2LD (op)
2121			SV * op
2122			CODE:
2123	0		RETVAL = abs_cl2LD (aTHX_ op);
2124			OUTPUT: RETVAL
2125
2126			void
2127			abs_cl2str (op)
2128			SV * op
2129			PREINIT:
2130			I32* temp;
2131			PPCODE:
2132	1		temp = PL_markstack_ptr++;
2133	1		abs_cl2str(aTHX_ op);
2134	1	50	if (PL_markstack_ptr != temp) {
2135			/* truly void, because dXSARGS not invoked */
2136	0		PL_markstack_ptr = temp;
2137	0		XSRETURN_EMPTY; /* return empty stack */
2138			}
2139			/* must have used dXSARGS; list context implied */
2140	1		return; /* assume stack size is correct */
2141
2142			void
2143			conj_cl (rop, op)
2144			SV * rop
2145			SV * op
2146			PREINIT:
2147			I32* temp;
2148			PPCODE:
2149	1		temp = PL_markstack_ptr++;
2150	1		conj_cl(aTHX_ rop, op);
2151	1	50	if (PL_markstack_ptr != temp) {
2152			/* truly void, because dXSARGS not invoked */
2153	1		PL_markstack_ptr = temp;
2154	1		XSRETURN_EMPTY; /* return empty stack */
2155			}
2156			/* must have used dXSARGS; list context implied */
2157	0		return; /* assume stack size is correct */
2158
2159			void
2160			acos_cl (rop, op)
2161			SV * rop
2162			SV * op
2163			PREINIT:
2164			I32* temp;
2165			PPCODE:
2166	1		temp = PL_markstack_ptr++;
2167	1		acos_cl(aTHX_ rop, op);
2168	1	50	if (PL_markstack_ptr != temp) {
2169			/* truly void, because dXSARGS not invoked */
2170	1		PL_markstack_ptr = temp;
2171	1		XSRETURN_EMPTY; /* return empty stack */
2172			}
2173			/* must have used dXSARGS; list context implied */
2174	0		return; /* assume stack size is correct */
2175
2176			void
2177			asin_cl (rop, op)
2178			SV * rop
2179			SV * op
2180			PREINIT:
2181			I32* temp;
2182			PPCODE:
2183	1		temp = PL_markstack_ptr++;
2184	1		asin_cl(aTHX_ rop, op);
2185	1	50	if (PL_markstack_ptr != temp) {
2186			/* truly void, because dXSARGS not invoked */
2187	1		PL_markstack_ptr = temp;
2188	1		XSRETURN_EMPTY; /* return empty stack */
2189			}
2190			/* must have used dXSARGS; list context implied */
2191	0		return; /* assume stack size is correct */
2192
2193			void
2194			atan_cl (rop, op)
2195			SV * rop
2196			SV * op
2197			PREINIT:
2198			I32* temp;
2199			PPCODE:
2200	1		temp = PL_markstack_ptr++;
2201	1		atan_cl(aTHX_ rop, op);
2202	1	50	if (PL_markstack_ptr != temp) {
2203			/* truly void, because dXSARGS not invoked */
2204	1		PL_markstack_ptr = temp;
2205	1		XSRETURN_EMPTY; /* return empty stack */
2206			}
2207			/* must have used dXSARGS; list context implied */
2208	0		return; /* assume stack size is correct */
2209
2210			void
2211			cos_cl (rop, op)
2212			SV * rop
2213			SV * op
2214			PREINIT:
2215			I32* temp;
2216			PPCODE:
2217	1		temp = PL_markstack_ptr++;
2218	1		cos_cl(aTHX_ rop, op);
2219	1	50	if (PL_markstack_ptr != temp) {
2220			/* truly void, because dXSARGS not invoked */
2221	1		PL_markstack_ptr = temp;
2222	1		XSRETURN_EMPTY; /* return empty stack */
2223			}
2224			/* must have used dXSARGS; list context implied */
2225	0		return; /* assume stack size is correct */
2226
2227			void
2228			sin_cl (rop, op)
2229			SV * rop
2230			SV * op
2231			PREINIT:
2232			I32* temp;
2233			PPCODE:
2234	1		temp = PL_markstack_ptr++;
2235	1		sin_cl(aTHX_ rop, op);
2236	1	50	if (PL_markstack_ptr != temp) {
2237			/* truly void, because dXSARGS not invoked */
2238	1		PL_markstack_ptr = temp;
2239	1		XSRETURN_EMPTY; /* return empty stack */
2240			}
2241			/* must have used dXSARGS; list context implied */
2242	0		return; /* assume stack size is correct */
2243
2244			void
2245			tan_cl (rop, op)
2246			SV * rop
2247			SV * op
2248			PREINIT:
2249			I32* temp;
2250			PPCODE:
2251	1		temp = PL_markstack_ptr++;
2252	1		tan_cl(aTHX_ rop, op);
2253	1	50	if (PL_markstack_ptr != temp) {
2254			/* truly void, because dXSARGS not invoked */
2255	1		PL_markstack_ptr = temp;
2256	1		XSRETURN_EMPTY; /* return empty stack */
2257			}
2258			/* must have used dXSARGS; list context implied */
2259	0		return; /* assume stack size is correct */
2260
2261			void
2262			acosh_cl (rop, op)
2263			SV * rop
2264			SV * op
2265			PREINIT:
2266			I32* temp;
2267			PPCODE:
2268	1		temp = PL_markstack_ptr++;
2269	1		acosh_cl(aTHX_ rop, op);
2270	1	50	if (PL_markstack_ptr != temp) {
2271			/* truly void, because dXSARGS not invoked */
2272	1		PL_markstack_ptr = temp;
2273	1		XSRETURN_EMPTY; /* return empty stack */
2274			}
2275			/* must have used dXSARGS; list context implied */
2276	0		return; /* assume stack size is correct */
2277
2278			void
2279			asinh_cl (rop, op)
2280			SV * rop
2281			SV * op
2282			PREINIT:
2283			I32* temp;
2284			PPCODE:
2285	1		temp = PL_markstack_ptr++;
2286	1		asinh_cl(aTHX_ rop, op);
2287	1	50	if (PL_markstack_ptr != temp) {
2288			/* truly void, because dXSARGS not invoked */
2289	1		PL_markstack_ptr = temp;
2290	1		XSRETURN_EMPTY; /* return empty stack */
2291			}
2292			/* must have used dXSARGS; list context implied */
2293	0		return; /* assume stack size is correct */
2294
2295			void
2296			atanh_cl (rop, op)
2297			SV * rop
2298			SV * op
2299			PREINIT:
2300			I32* temp;
2301			PPCODE:
2302	1		temp = PL_markstack_ptr++;
2303	1		atanh_cl(aTHX_ rop, op);
2304	1	50	if (PL_markstack_ptr != temp) {
2305			/* truly void, because dXSARGS not invoked */
2306	1		PL_markstack_ptr = temp;
2307	1		XSRETURN_EMPTY; /* return empty stack */
2308			}
2309			/* must have used dXSARGS; list context implied */
2310	0		return; /* assume stack size is correct */
2311
2312			void
2313			cosh_cl (rop, op)
2314			SV * rop
2315			SV * op
2316			PREINIT:
2317			I32* temp;
2318			PPCODE:
2319	1		temp = PL_markstack_ptr++;
2320	1		cosh_cl(aTHX_ rop, op);
2321	1	50	if (PL_markstack_ptr != temp) {
2322			/* truly void, because dXSARGS not invoked */
2323	1		PL_markstack_ptr = temp;
2324	1		XSRETURN_EMPTY; /* return empty stack */
2325			}
2326			/* must have used dXSARGS; list context implied */
2327	0		return; /* assume stack size is correct */
2328
2329			void
2330			sinh_cl (rop, op)
2331			SV * rop
2332			SV * op
2333			PREINIT:
2334			I32* temp;
2335			PPCODE:
2336	1		temp = PL_markstack_ptr++;
2337	1		sinh_cl(aTHX_ rop, op);
2338	1	50	if (PL_markstack_ptr != temp) {
2339			/* truly void, because dXSARGS not invoked */
2340	1		PL_markstack_ptr = temp;
2341	1		XSRETURN_EMPTY; /* return empty stack */
2342			}
2343			/* must have used dXSARGS; list context implied */
2344	0		return; /* assume stack size is correct */
2345
2346			void
2347			tanh_cl (rop, op)
2348			SV * rop
2349			SV * op
2350			PREINIT:
2351			I32* temp;
2352			PPCODE:
2353	1		temp = PL_markstack_ptr++;
2354	1		tanh_cl(aTHX_ rop, op);
2355	1	50	if (PL_markstack_ptr != temp) {
2356			/* truly void, because dXSARGS not invoked */
2357	1		PL_markstack_ptr = temp;
2358	1		XSRETURN_EMPTY; /* return empty stack */
2359			}
2360			/* must have used dXSARGS; list context implied */
2361	0		return; /* assume stack size is correct */
2362
2363			void
2364			exp_cl (rop, op)
2365			SV * rop
2366			SV * op
2367			PREINIT:
2368			I32* temp;
2369			PPCODE:
2370	1		temp = PL_markstack_ptr++;
2371	1		exp_cl(aTHX_ rop, op);
2372	1	50	if (PL_markstack_ptr != temp) {
2373			/* truly void, because dXSARGS not invoked */
2374	1		PL_markstack_ptr = temp;
2375	1		XSRETURN_EMPTY; /* return empty stack */
2376			}
2377			/* must have used dXSARGS; list context implied */
2378	0		return; /* assume stack size is correct */
2379
2380			void
2381			log_cl (rop, op)
2382			SV * rop
2383			SV * op
2384			PREINIT:
2385			I32* temp;
2386			PPCODE:
2387	1		temp = PL_markstack_ptr++;
2388	1		log_cl(aTHX_ rop, op);
2389	1	50	if (PL_markstack_ptr != temp) {
2390			/* truly void, because dXSARGS not invoked */
2391	1		PL_markstack_ptr = temp;
2392	1		XSRETURN_EMPTY; /* return empty stack */
2393			}
2394			/* must have used dXSARGS; list context implied */
2395	0		return; /* assume stack size is correct */
2396
2397			void
2398			sqrt_cl (rop, op)
2399			SV * rop
2400			SV * op
2401			PREINIT:
2402			I32* temp;
2403			PPCODE:
2404	1		temp = PL_markstack_ptr++;
2405	1		sqrt_cl(aTHX_ rop, op);
2406	1	50	if (PL_markstack_ptr != temp) {
2407			/* truly void, because dXSARGS not invoked */
2408	1		PL_markstack_ptr = temp;
2409	1		XSRETURN_EMPTY; /* return empty stack */
2410			}
2411			/* must have used dXSARGS; list context implied */
2412	0		return; /* assume stack size is correct */
2413
2414			void
2415			proj_cl (rop, op)
2416			SV * rop
2417			SV * op
2418			PREINIT:
2419			I32* temp;
2420			PPCODE:
2421	6		temp = PL_markstack_ptr++;
2422	6		proj_cl(aTHX_ rop, op);
2423	6	50	if (PL_markstack_ptr != temp) {
2424			/* truly void, because dXSARGS not invoked */
2425	6		PL_markstack_ptr = temp;
2426	6		XSRETURN_EMPTY; /* return empty stack */
2427			}
2428			/* must have used dXSARGS; list context implied */
2429	0		return; /* assume stack size is correct */
2430
2431			void
2432			pow_cl (rop, op, exp)
2433			SV * rop
2434			SV * op
2435			SV * exp
2436			PREINIT:
2437			I32* temp;
2438			PPCODE:
2439	1		temp = PL_markstack_ptr++;
2440	1		pow_cl(aTHX_ rop, op, exp);
2441	1	50	if (PL_markstack_ptr != temp) {
2442			/* truly void, because dXSARGS not invoked */
2443	1		PL_markstack_ptr = temp;
2444	1		XSRETURN_EMPTY; /* return empty stack */
2445			}
2446			/* must have used dXSARGS; list context implied */
2447	0		return; /* assume stack size is correct */
2448
2449			SV *
2450			_overload_true (rop, second, third)
2451			SV * rop
2452			SV * second
2453			SV * third
2454			CODE:
2455	4		RETVAL = _overload_true (aTHX_ rop, second, third);
2456			OUTPUT: RETVAL
2457
2458			SV *
2459			_overload_not (rop, second, third)
2460			SV * rop
2461			SV * second
2462			SV * third
2463			CODE:
2464	8		RETVAL = _overload_not (aTHX_ rop, second, third);
2465			OUTPUT: RETVAL
2466
2467			SV *
2468			_overload_equiv (a, b, third)
2469			SV * a
2470			SV * b
2471			SV * third
2472			CODE:
2473	37		RETVAL = _overload_equiv (aTHX_ a, b, third);
2474			OUTPUT: RETVAL
2475
2476			SV *
2477			_overload_not_equiv (a, b, third)
2478			SV * a
2479			SV * b
2480			SV * third
2481			CODE:
2482	7		RETVAL = _overload_not_equiv (aTHX_ a, b, third);
2483			OUTPUT: RETVAL
2484
2485			SV *
2486			_overload_pow (a, b, third)
2487			SV * a
2488			SV * b
2489			SV * third
2490			CODE:
2491	5		RETVAL = _overload_pow (aTHX_ a, b, third);
2492			OUTPUT: RETVAL
2493
2494			SV *
2495			_overload_mul (a, b, third)
2496			SV * a
2497			SV * b
2498			SV * third
2499			CODE:
2500	5		RETVAL = _overload_mul (aTHX_ a, b, third);
2501			OUTPUT: RETVAL
2502
2503			SV *
2504			_overload_add (a, b, third)
2505			SV * a
2506			SV * b
2507			SV * third
2508			CODE:
2509	5		RETVAL = _overload_add (aTHX_ a, b, third);
2510			OUTPUT: RETVAL
2511
2512			SV *
2513			_overload_div (a, b, third)
2514			SV * a
2515			SV * b
2516			SV * third
2517			CODE:
2518	7		RETVAL = _overload_div (aTHX_ a, b, third);
2519			OUTPUT: RETVAL
2520
2521			SV *
2522			_overload_sub (a, b, third)
2523			SV * a
2524			SV * b
2525			SV * third
2526			CODE:
2527	6		RETVAL = _overload_sub (aTHX_ a, b, third);
2528			OUTPUT: RETVAL
2529
2530			SV *
2531			_overload_sqrt (a, b, third)
2532			SV * a
2533			SV * b
2534			SV * third
2535			CODE:
2536	1		RETVAL = _overload_sqrt (aTHX_ a, b, third);
2537			OUTPUT: RETVAL
2538
2539			SV *
2540			_overload_pow_eq (a, b, third)
2541			SV * a
2542			SV * b
2543			SV * third
2544			CODE:
2545	4		RETVAL = _overload_pow_eq (aTHX_ a, b, third);
2546			OUTPUT: RETVAL
2547
2548			SV *
2549			_overload_mul_eq (a, b, third)
2550			SV * a
2551			SV * b
2552			SV * third
2553			CODE:
2554	7		RETVAL = _overload_mul_eq (aTHX_ a, b, third);
2555			OUTPUT: RETVAL
2556
2557			SV *
2558			_overload_add_eq (a, b, third)
2559			SV * a
2560			SV * b
2561			SV * third
2562			CODE:
2563	6		RETVAL = _overload_add_eq (aTHX_ a, b, third);
2564			OUTPUT: RETVAL
2565
2566			SV *
2567			_overload_div_eq (a, b, third)
2568			SV * a
2569			SV * b
2570			SV * third
2571			CODE:
2572	5		RETVAL = _overload_div_eq (aTHX_ a, b, third);
2573			OUTPUT: RETVAL
2574
2575			SV *
2576			_overload_sub_eq (a, b, third)
2577			SV * a
2578			SV * b
2579			SV * third
2580			CODE:
2581	5		RETVAL = _overload_sub_eq (aTHX_ a, b, third);
2582			OUTPUT: RETVAL
2583
2584			SV *
2585			_overload_copy (a, second, third)
2586			SV * a
2587			SV * second
2588			SV * third
2589			CODE:
2590	4		RETVAL = _overload_copy (aTHX_ a, second, third);
2591			OUTPUT: RETVAL
2592
2593			SV *
2594			_overload_abs (rop, second, third)
2595			SV * rop
2596			SV * second
2597			SV * third
2598			CODE:
2599	1		RETVAL = _overload_abs (aTHX_ rop, second, third);
2600			OUTPUT: RETVAL
2601
2602			SV *
2603			_overload_exp (a, b, third)
2604			SV * a
2605			SV * b
2606			SV * third
2607			CODE:
2608	1		RETVAL = _overload_exp (aTHX_ a, b, third);
2609			OUTPUT: RETVAL
2610
2611			SV *
2612			_overload_log (a, b, third)
2613			SV * a
2614			SV * b
2615			SV * third
2616			CODE:
2617	1		RETVAL = _overload_log (aTHX_ a, b, third);
2618			OUTPUT: RETVAL
2619
2620			SV *
2621			_overload_sin (a, b, third)
2622			SV * a
2623			SV * b
2624			SV * third
2625			CODE:
2626	1		RETVAL = _overload_sin (aTHX_ a, b, third);
2627			OUTPUT: RETVAL
2628
2629			SV *
2630			_overload_cos (a, b, third)
2631			SV * a
2632			SV * b
2633			SV * third
2634			CODE:
2635	1		RETVAL = _overload_cos (aTHX_ a, b, third);
2636			OUTPUT: RETVAL
2637
2638			SV *
2639			_overload_atan2 (a, b, third)
2640			SV * a
2641			SV * b
2642			SV * third
2643			CODE:
2644	1		RETVAL = _overload_atan2 (aTHX_ a, b, third);
2645			OUTPUT: RETVAL
2646
2647			SV *
2648			get_nanl ()
2649			CODE:
2650	4		RETVAL = get_nanl (aTHX);
2651			OUTPUT: RETVAL
2652
2653
2654			SV *
2655			get_infl ()
2656			CODE:
2657	2		RETVAL = get_infl (aTHX);
2658			OUTPUT: RETVAL
2659
2660
2661			SV *
2662			get_neg_infl ()
2663			CODE:
2664	0		RETVAL = get_neg_infl (aTHX);
2665			OUTPUT: RETVAL
2666
2667
2668			SV *
2669			is_nanl (a)
2670			SV * a
2671			CODE:
2672	1		RETVAL = is_nanl (aTHX_ a);
2673			OUTPUT: RETVAL
2674
2675			SV *
2676			is_infl (a)
2677			SV * a
2678			CODE:
2679	6		RETVAL = is_infl (aTHX_ a);
2680			OUTPUT: RETVAL
2681
2682			SV *
2683			_complex_type ()
2684			CODE:
2685	0		RETVAL = _complex_type (aTHX);
2686			OUTPUT: RETVAL
2687
2688
2689			SV *
2690			_double_type ()
2691			CODE:
2692	0		RETVAL = _double_type (aTHX);
2693			OUTPUT: RETVAL
2694
2695
2696			SV *
2697			_get_nv (x)
2698			SV * x
2699			CODE:
2700	0		RETVAL = _get_nv (aTHX_ x);
2701			OUTPUT: RETVAL
2702
2703			SV *
2704			_which_package (b)
2705			SV * b
2706			CODE:
2707	0		RETVAL = _which_package (aTHX_ b);
2708			OUTPUT: RETVAL
2709
2710			SV *
2711			_wrap_count ()
2712			CODE:
2713	0		RETVAL = _wrap_count (aTHX);
2714			OUTPUT: RETVAL
2715
2716
2717			SV *
2718			_ivsize ()
2719			CODE:
2720	0		RETVAL = _ivsize (aTHX);
2721			OUTPUT: RETVAL
2722
2723
2724			SV *
2725			_nvsize ()
2726			CODE:
2727	0		RETVAL = _nvsize (aTHX);
2728			OUTPUT: RETVAL
2729
2730
2731			SV *
2732			_doublesize ()
2733			CODE:
2734	0		RETVAL = _doublesize (aTHX);
2735			OUTPUT: RETVAL
2736
2737
2738			SV *
2739			_longdoublesize ()
2740			CODE:
2741	0		RETVAL = _longdoublesize (aTHX);
2742			OUTPUT: RETVAL
2743
2744
2745			SV *
2746			_double_Complexsize ()
2747			CODE:
2748	0		RETVAL = _double_Complexsize (aTHX);
2749			OUTPUT: RETVAL
2750
2751
2752			SV *
2753			_longdouble_Complexsize ()
2754			CODE:
2755	0		RETVAL = _longdouble_Complexsize (aTHX);
2756			OUTPUT: RETVAL
2757
2758
2759			void
2760			_l_to_str (ld)
2761			SV * ld
2762			PREINIT:
2763			I32* temp;
2764			PPCODE:
2765	12		temp = PL_markstack_ptr++;
2766	12		_l_to_str(aTHX_ ld);
2767	12	50	if (PL_markstack_ptr != temp) {
2768			/* truly void, because dXSARGS not invoked */
2769	0		PL_markstack_ptr = temp;
2770	0		XSRETURN_EMPTY; /* return empty stack */
2771			}
2772			/* must have used dXSARGS; list context implied */
2773	12		return; /* assume stack size is correct */
2774
2775			void
2776			_l_to_strp (ld, decimal_prec)
2777			SV * ld
2778			int decimal_prec
2779			PREINIT:
2780			I32* temp;
2781			PPCODE:
2782	3		temp = PL_markstack_ptr++;
2783	3		_l_to_strp(aTHX_ ld, decimal_prec);
2784	3	50	if (PL_markstack_ptr != temp) {
2785			/* truly void, because dXSARGS not invoked */
2786	0		PL_markstack_ptr = temp;
2787	0		XSRETURN_EMPTY; /* return empty stack */
2788			}
2789			/* must have used dXSARGS; list context implied */
2790	3		return; /* assume stack size is correct */
2791
2792			SV *
2793			_LDBL_DIG ()
2794			CODE:
2795	0		RETVAL = _LDBL_DIG (aTHX);
2796			OUTPUT: RETVAL
2797
2798
2799			SV *
2800			_DBL_DIG ()
2801			CODE:
2802	0		RETVAL = _DBL_DIG (aTHX);
2803			OUTPUT: RETVAL
2804
2805
2806			SV *
2807			_get_xs_version ()
2808			CODE:
2809	0		RETVAL = _get_xs_version (aTHX);
2810			OUTPUT: RETVAL
2811
2812
2813			SV *
2814			_itsa (a)
2815			SV * a
2816			CODE:
2817	9		RETVAL = _itsa (aTHX_ a);
2818			OUTPUT: RETVAL
2819
2820			int
2821			nnumflag ()
2822
2823
2824			void
2825			clear_nnum ()
2826
2827			PREINIT:
2828			I32* temp;
2829			PPCODE:
2830	1		temp = PL_markstack_ptr++;
2831	1		clear_nnum();
2832	1	50	if (PL_markstack_ptr != temp) {
2833			/* truly void, because dXSARGS not invoked */
2834	1		PL_markstack_ptr = temp;
2835	1		XSRETURN_EMPTY; /* return empty stack */
2836			}
2837			/* must have used dXSARGS; list context implied */
2838	0		return; /* assume stack size is correct */
2839
2840			void
2841			set_nnum (x)
2842			int x
2843			PREINIT:
2844			I32* temp;
2845			PPCODE:
2846	1		temp = PL_markstack_ptr++;
2847	1		set_nnum(x);
2848	1	50	if (PL_markstack_ptr != temp) {
2849			/* truly void, because dXSARGS not invoked */
2850	1		PL_markstack_ptr = temp;
2851	1		XSRETURN_EMPTY; /* return empty stack */
2852			}
2853			/* must have used dXSARGS; list context implied */
2854	0		return; /* assume stack size is correct */
2855
2856			int
2857			_lln (x)
2858			SV * x
2859			CODE:
2860	0		RETVAL = _lln (aTHX_ x);
2861			OUTPUT: RETVAL
2862