File Coverage

L.xs

Criterion	Covered	Total	%
statement	955	1270	75.2
branch	501	1314	38.1
condition			n/a
subroutine			n/a
pod			n/a
total	1456	2584	56.3

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