add hg and python

cinap_lenrek committed 15 years ago

Commit 4bb9e221 parent 987265c3706 files · +1228772 −-233Browse files

Showing the changes to sys/src/cmd/python/Objects/complexobject.c (1 of 3706 files). Show all

Unified · Split

sys/src/cmd/python/Objects/complexobject.c+1031−0

@@ -0,0 +1,1031 @@
	1	+
	2	+/* Complex object implementation */
	3	+
	4	+/* Borrows heavily from floatobject.c */
	5	+
	6	+/* Submitted by Jim Hugunin */
	7	+
	8	+#include "Python.h"
	9	+#include "structmember.h"
	10	+
	11	+#ifndef WITHOUT_COMPLEX
	12	+
	13	+/* Precisions used by repr() and str(), respectively.
	14	+
	15	+ The repr() precision (17 significant decimal digits) is the minimal number
	16	+ that is guaranteed to have enough precision so that if the number is read
	17	+ back in the exact same binary value is recreated. This is true for IEEE
	18	+ floating point by design, and also happens to work for all other modern
	19	+ hardware.
	20	+
	21	+ The str() precision is chosen so that in most cases, the rounding noise
	22	+ created by various operations is suppressed, while giving plenty of
	23	+ precision for practical use.
	24	+*/
	25	+
	26	+#define PREC_REPR 17
	27	+#define PREC_STR 12
	28	+
	29	+/* elementary operations on complex numbers */
	30	+
	31	+static Py_complex c_1 = {1., 0.};
	32	+
	33	+Py_complex
	34	+c_sum(Py_complex a, Py_complex b)
	35	+{
	36	+ Py_complex r;
	37	+ r.real = a.real + b.real;
	38	+ r.imag = a.imag + b.imag;
	39	+ return r;
	40	+}
	41	+
	42	+Py_complex
	43	+c_diff(Py_complex a, Py_complex b)
	44	+{
	45	+ Py_complex r;
	46	+ r.real = a.real - b.real;
	47	+ r.imag = a.imag - b.imag;
	48	+ return r;
	49	+}
	50	+
	51	+Py_complex
	52	+c_neg(Py_complex a)
	53	+{
	54	+ Py_complex r;
	55	+ r.real = -a.real;
	56	+ r.imag = -a.imag;
	57	+ return r;
	58	+}
	59	+
	60	+Py_complex
	61	+c_prod(Py_complex a, Py_complex b)
	62	+{
	63	+ Py_complex r;
	64	+ r.real = a.realb.real - a.imagb.imag;
	65	+ r.imag = a.realb.imag + a.imagb.real;
	66	+ return r;
	67	+}
	68	+
	69	+Py_complex
	70	+c_quot(Py_complex a, Py_complex b)
	71	+{
	72	+ /******************************************************************
	73	+ This was the original algorithm. It's grossly prone to spurious
	74	+ overflow and underflow errors. It also merrily divides by 0 despite
	75	+ checking for that(!). The code still serves a doc purpose here, as
	76	+ the algorithm following is a simple by-cases transformation of this
	77	+ one:
	78	+
	79	+ Py_complex r;
	80	+ double d = b.realb.real + b.imagb.imag;
	81	+ if (d == 0.)
	82	+ errno = EDOM;
	83	+ r.real = (a.realb.real + a.imagb.imag)/d;
	84	+ r.imag = (a.imagb.real - a.realb.imag)/d;
	85	+ return r;
	86	+ ******************************************************************/
	87	+
	88	+ /* This algorithm is better, and is pretty obvious: first divide the
	89	+ * numerators and denominator by whichever of {b.real, b.imag} has
	90	+ * larger magnitude. The earliest reference I found was to CACM
	91	+ * Algorithm 116 (Complex Division, Robert L. Smith, Stanford
	92	+ * University). As usual, though, we're still ignoring all IEEE
	93	+ * endcases.
	94	+ */
	95	+ Py_complex r; /* the result */
	96	+ const double abs_breal = b.real < 0 ? -b.real : b.real;
	97	+ const double abs_bimag = b.imag < 0 ? -b.imag : b.imag;
	98	+
	99	+ if (abs_breal >= abs_bimag) {
	100	+ /* divide tops and bottom by b.real */
	101	+ if (abs_breal == 0.0) {
	102	+ errno = EDOM;
	103	+ r.real = r.imag = 0.0;
	104	+ }
	105	+ else {
	106	+ const double ratio = b.imag / b.real;
	107	+ const double denom = b.real + b.imag * ratio;
	108	+ r.real = (a.real + a.imag * ratio) / denom;
	109	+ r.imag = (a.imag - a.real * ratio) / denom;
	110	+ }
	111	+ }
	112	+ else {
	113	+ /* divide tops and bottom by b.imag */
	114	+ const double ratio = b.real / b.imag;
	115	+ const double denom = b.real * ratio + b.imag;
	116	+ assert(b.imag != 0.0);
	117	+ r.real = (a.real * ratio + a.imag) / denom;
	118	+ r.imag = (a.imag * ratio - a.real) / denom;
	119	+ }
	120	+ return r;
	121	+}
	122	+
	123	+Py_complex
	124	+c_pow(Py_complex a, Py_complex b)
	125	+{
	126	+ Py_complex r;
	127	+ double vabs,len,at,phase;
	128	+ if (b.real == 0. && b.imag == 0.) {
	129	+ r.real = 1.;
	130	+ r.imag = 0.;
	131	+ }
	132	+ else if (a.real == 0. && a.imag == 0.) {
	133	+ if (b.imag != 0. \|\| b.real < 0.)
	134	+ errno = EDOM;
	135	+ r.real = 0.;
	136	+ r.imag = 0.;
	137	+ }
	138	+ else {
	139	+ vabs = hypot(a.real,a.imag);
	140	+ len = pow(vabs,b.real);
	141	+ at = atan2(a.imag, a.real);
	142	+ phase = at*b.real;
	143	+ if (b.imag != 0.0) {
	144	+ len /= exp(at*b.imag);
	145	+ phase += b.imag*log(vabs);
	146	+ }
	147	+ r.real = len*cos(phase);
	148	+ r.imag = len*sin(phase);
	149	+ }
	150	+ return r;
	151	+}
	152	+
	153	+static Py_complex
	154	+c_powu(Py_complex x, long n)
	155	+{
	156	+ Py_complex r, p;
	157	+ long mask = 1;
	158	+ r = c_1;
	159	+ p = x;
	160	+ while (mask > 0 && n >= mask) {
	161	+ if (n & mask)
	162	+ r = c_prod(r,p);
	163	+ mask <<= 1;
	164	+ p = c_prod(p,p);
	165	+ }
	166	+ return r;
	167	+}
	168	+
	169	+static Py_complex
	170	+c_powi(Py_complex x, long n)
	171	+{
	172	+ Py_complex cn;
	173	+
	174	+ if (n > 100 \|\| n < -100) {
	175	+ cn.real = (double) n;
	176	+ cn.imag = 0.;
	177	+ return c_pow(x,cn);
	178	+ }
	179	+ else if (n > 0)
	180	+ return c_powu(x,n);
	181	+ else
	182	+ return c_quot(c_1,c_powu(x,-n));
	183	+
	184	+}
	185	+
	186	+static PyObject *
	187	+complex_subtype_from_c_complex(PyTypeObject *type, Py_complex cval)
	188	+{
	189	+ PyObject *op;
	190	+
	191	+ op = type->tp_alloc(type, 0);
	192	+ if (op != NULL)
	193	+ ((PyComplexObject *)op)->cval = cval;
	194	+ return op;
	195	+}
	196	+
	197	+PyObject *
	198	+PyComplex_FromCComplex(Py_complex cval)
	199	+{
	200	+ register PyComplexObject *op;
	201	+
	202	+ /* Inline PyObject_New */
	203	+ op = (PyComplexObject *) PyObject_MALLOC(sizeof(PyComplexObject));
	204	+ if (op == NULL)
	205	+ return PyErr_NoMemory();
	206	+ PyObject_INIT(op, &PyComplex_Type);
	207	+ op->cval = cval;
	208	+ return (PyObject *) op;
	209	+}
	210	+
	211	+static PyObject *
	212	+complex_subtype_from_doubles(PyTypeObject *type, double real, double imag)
	213	+{
	214	+ Py_complex c;
	215	+ c.real = real;
	216	+ c.imag = imag;
	217	+ return complex_subtype_from_c_complex(type, c);
	218	+}
	219	+
	220	+PyObject *
	221	+PyComplex_FromDoubles(double real, double imag)
	222	+{
	223	+ Py_complex c;
	224	+ c.real = real;
	225	+ c.imag = imag;
	226	+ return PyComplex_FromCComplex(c);
	227	+}
	228	+
	229	+double
	230	+PyComplex_RealAsDouble(PyObject *op)
	231	+{
	232	+ if (PyComplex_Check(op)) {
	233	+ return ((PyComplexObject *)op)->cval.real;
	234	+ }
	235	+ else {
	236	+ return PyFloat_AsDouble(op);
	237	+ }
	238	+}
	239	+
	240	+double
	241	+PyComplex_ImagAsDouble(PyObject *op)
	242	+{
	243	+ if (PyComplex_Check(op)) {
	244	+ return ((PyComplexObject *)op)->cval.imag;
	245	+ }
	246	+ else {
	247	+ return 0.0;
	248	+ }
	249	+}
	250	+
	251	+Py_complex
	252	+PyComplex_AsCComplex(PyObject *op)
	253	+{
	254	+ Py_complex cv;
	255	+ if (PyComplex_Check(op)) {
	256	+ return ((PyComplexObject *)op)->cval;
	257	+ }
	258	+ else {
	259	+ cv.real = PyFloat_AsDouble(op);
	260	+ cv.imag = 0.;
	261	+ return cv;
	262	+ }
	263	+}
	264	+
	265	+static void
	266	+complex_dealloc(PyObject *op)
	267	+{
	268	+ op->ob_type->tp_free(op);
	269	+}
	270	+
	271	+
	272	+static void
	273	+complex_to_buf(char buf, int bufsz, PyComplexObject v, int precision)
	274	+{
	275	+ char format[32];
	276	+ if (v->cval.real == 0.) {
	277	+ PyOS_snprintf(format, sizeof(format), "%%.%ig", precision);
	278	+ PyOS_ascii_formatd(buf, bufsz - 1, format, v->cval.imag);
	279	+ strncat(buf, "j", 1);
	280	+ } else {
	281	+ char re[64], im[64];
	282	+ /* Format imaginary part with sign, real part without */
	283	+ PyOS_snprintf(format, sizeof(format), "%%.%ig", precision);
	284	+ PyOS_ascii_formatd(re, sizeof(re), format, v->cval.real);
	285	+ PyOS_snprintf(format, sizeof(format), "%%+.%ig", precision);
	286	+ PyOS_ascii_formatd(im, sizeof(im), format, v->cval.imag);
	287	+ PyOS_snprintf(buf, bufsz, "(%s%sj)", re, im);
	288	+ }
	289	+}
	290	+
	291	+static int
	292	+complex_print(PyComplexObject v, FILE fp, int flags)
	293	+{
	294	+ char buf[100];
	295	+ complex_to_buf(buf, sizeof(buf), v,
	296	+ (flags & Py_PRINT_RAW) ? PREC_STR : PREC_REPR);
	297	+ fputs(buf, fp);
	298	+ return 0;
	299	+}
	300	+
	301	+static PyObject *
	302	+complex_repr(PyComplexObject *v)
	303	+{
	304	+ char buf[100];
	305	+ complex_to_buf(buf, sizeof(buf), v, PREC_REPR);
	306	+ return PyString_FromString(buf);
	307	+}
	308	+
	309	+static PyObject *
	310	+complex_str(PyComplexObject *v)
	311	+{
	312	+ char buf[100];
	313	+ complex_to_buf(buf, sizeof(buf), v, PREC_STR);
	314	+ return PyString_FromString(buf);
	315	+}
	316	+
	317	+static long
	318	+complex_hash(PyComplexObject *v)
	319	+{
	320	+ long hashreal, hashimag, combined;
	321	+ hashreal = _Py_HashDouble(v->cval.real);
	322	+ if (hashreal == -1)
	323	+ return -1;
	324	+ hashimag = _Py_HashDouble(v->cval.imag);
	325	+ if (hashimag == -1)
	326	+ return -1;
	327	+ /* Note: if the imaginary part is 0, hashimag is 0 now,
	328	+ * so the following returns hashreal unchanged. This is
	329	+ * important because numbers of different types that
	330	+ * compare equal must have the same hash value, so that
	331	+ * hash(x + 0*j) must equal hash(x).
	332	+ */
	333	+ combined = hashreal + 1000003 * hashimag;
	334	+ if (combined == -1)
	335	+ combined = -2;
	336	+ return combined;
	337	+}
	338	+
	339	+static PyObject *
	340	+complex_add(PyComplexObject v, PyComplexObject w)
	341	+{
	342	+ Py_complex result;
	343	+ PyFPE_START_PROTECT("complex_add", return 0)
	344	+ result = c_sum(v->cval,w->cval);
	345	+ PyFPE_END_PROTECT(result)
	346	+ return PyComplex_FromCComplex(result);
	347	+}
	348	+
	349	+static PyObject *
	350	+complex_sub(PyComplexObject v, PyComplexObject w)
	351	+{
	352	+ Py_complex result;
	353	+ PyFPE_START_PROTECT("complex_sub", return 0)
	354	+ result = c_diff(v->cval,w->cval);
	355	+ PyFPE_END_PROTECT(result)
	356	+ return PyComplex_FromCComplex(result);
	357	+}
	358	+
	359	+static PyObject *
	360	+complex_mul(PyComplexObject v, PyComplexObject w)
	361	+{
	362	+ Py_complex result;
	363	+ PyFPE_START_PROTECT("complex_mul", return 0)
	364	+ result = c_prod(v->cval,w->cval);
	365	+ PyFPE_END_PROTECT(result)
	366	+ return PyComplex_FromCComplex(result);
	367	+}
	368	+
	369	+static PyObject *
	370	+complex_div(PyComplexObject v, PyComplexObject w)
	371	+{
	372	+ Py_complex quot;
	373	+ PyFPE_START_PROTECT("complex_div", return 0)
	374	+ errno = 0;
	375	+ quot = c_quot(v->cval,w->cval);
	376	+ PyFPE_END_PROTECT(quot)
	377	+ if (errno == EDOM) {
	378	+ PyErr_SetString(PyExc_ZeroDivisionError, "complex division");
	379	+ return NULL;
	380	+ }
	381	+ return PyComplex_FromCComplex(quot);
	382	+}
	383	+
	384	+static PyObject *
	385	+complex_classic_div(PyComplexObject v, PyComplexObject w)
	386	+{
	387	+ Py_complex quot;
	388	+
	389	+ if (Py_DivisionWarningFlag >= 2 &&
	390	+ PyErr_Warn(PyExc_DeprecationWarning,
	391	+ "classic complex division") < 0)
	392	+ return NULL;
	393	+
	394	+ PyFPE_START_PROTECT("complex_classic_div", return 0)
	395	+ errno = 0;
	396	+ quot = c_quot(v->cval,w->cval);
	397	+ PyFPE_END_PROTECT(quot)
	398	+ if (errno == EDOM) {
	399	+ PyErr_SetString(PyExc_ZeroDivisionError, "complex division");
	400	+ return NULL;
	401	+ }
	402	+ return PyComplex_FromCComplex(quot);
	403	+}
	404	+
	405	+static PyObject *
	406	+complex_remainder(PyComplexObject v, PyComplexObject w)
	407	+{
	408	+ Py_complex div, mod;
	409	+
	410	+ if (PyErr_Warn(PyExc_DeprecationWarning,
	411	+ "complex divmod(), // and % are deprecated") < 0)
	412	+ return NULL;
	413	+
	414	+ errno = 0;
	415	+ div = c_quot(v->cval,w->cval); /* The raw divisor value. */
	416	+ if (errno == EDOM) {
	417	+ PyErr_SetString(PyExc_ZeroDivisionError, "complex remainder");
	418	+ return NULL;
	419	+ }
	420	+ div.real = floor(div.real); /* Use the floor of the real part. */
	421	+ div.imag = 0.0;
	422	+ mod = c_diff(v->cval, c_prod(w->cval, div));
	423	+
	424	+ return PyComplex_FromCComplex(mod);
	425	+}
	426	+
	427	+
	428	+static PyObject *
	429	+complex_divmod(PyComplexObject v, PyComplexObject w)
	430	+{
	431	+ Py_complex div, mod;
	432	+ PyObject d, m, *z;
	433	+
	434	+ if (PyErr_Warn(PyExc_DeprecationWarning,
	435	+ "complex divmod(), // and % are deprecated") < 0)
	436	+ return NULL;
	437	+
	438	+ errno = 0;
	439	+ div = c_quot(v->cval,w->cval); /* The raw divisor value. */
	440	+ if (errno == EDOM) {
	441	+ PyErr_SetString(PyExc_ZeroDivisionError, "complex divmod()");
	442	+ return NULL;
	443	+ }
	444	+ div.real = floor(div.real); /* Use the floor of the real part. */
	445	+ div.imag = 0.0;
	446	+ mod = c_diff(v->cval, c_prod(w->cval, div));
	447	+ d = PyComplex_FromCComplex(div);
	448	+ m = PyComplex_FromCComplex(mod);
	449	+ z = PyTuple_Pack(2, d, m);
	450	+ Py_XDECREF(d);
	451	+ Py_XDECREF(m);
	452	+ return z;
	453	+}
	454	+
	455	+static PyObject *
	456	+complex_pow(PyComplexObject v, PyObject w, PyComplexObject *z)
	457	+{
	458	+ Py_complex p;
	459	+ Py_complex exponent;
	460	+ long int_exponent;
	461	+
	462	+ if ((PyObject *)z!=Py_None) {
	463	+ PyErr_SetString(PyExc_ValueError, "complex modulo");
	464	+ return NULL;
	465	+ }
	466	+ PyFPE_START_PROTECT("complex_pow", return 0)
	467	+ errno = 0;
	468	+ exponent = ((PyComplexObject*)w)->cval;
	469	+ int_exponent = (long)exponent.real;
	470	+ if (exponent.imag == 0. && exponent.real == int_exponent)
	471	+ p = c_powi(v->cval,int_exponent);
	472	+ else
	473	+ p = c_pow(v->cval,exponent);
	474	+
	475	+ PyFPE_END_PROTECT(p)
	476	+ Py_ADJUST_ERANGE2(p.real, p.imag);
	477	+ if (errno == EDOM) {
	478	+ PyErr_SetString(PyExc_ZeroDivisionError,
	479	+ "0.0 to a negative or complex power");
	480	+ return NULL;
	481	+ }
	482	+ else if (errno == ERANGE) {
	483	+ PyErr_SetString(PyExc_OverflowError,
	484	+ "complex exponentiation");
	485	+ return NULL;
	486	+ }
	487	+ return PyComplex_FromCComplex(p);
	488	+}
	489	+
	490	+static PyObject *
	491	+complex_int_div(PyComplexObject v, PyComplexObject w)
	492	+{
	493	+ PyObject t, r;
	494	+
	495	+ t = complex_divmod(v, w);
	496	+ if (t != NULL) {
	497	+ r = PyTuple_GET_ITEM(t, 0);
	498	+ Py_INCREF(r);
	499	+ Py_DECREF(t);
	500	+ return r;
	501	+ }
	502	+ return NULL;
	503	+}
	504	+
	505	+static PyObject *
	506	+complex_neg(PyComplexObject *v)
	507	+{
	508	+ Py_complex neg;
	509	+ neg.real = -v->cval.real;
	510	+ neg.imag = -v->cval.imag;
	511	+ return PyComplex_FromCComplex(neg);
	512	+}
	513	+
	514	+static PyObject *
	515	+complex_pos(PyComplexObject *v)
	516	+{
	517	+ if (PyComplex_CheckExact(v)) {
	518	+ Py_INCREF(v);
	519	+ return (PyObject *)v;
	520	+ }
	521	+ else
	522	+ return PyComplex_FromCComplex(v->cval);
	523	+}
	524	+
	525	+static PyObject *
	526	+complex_abs(PyComplexObject *v)
	527	+{
	528	+ double result;
	529	+ PyFPE_START_PROTECT("complex_abs", return 0)
	530	+ result = hypot(v->cval.real,v->cval.imag);
	531	+ PyFPE_END_PROTECT(result)
	532	+ return PyFloat_FromDouble(result);
	533	+}
	534	+
	535	+static int
	536	+complex_nonzero(PyComplexObject *v)
	537	+{
	538	+ return v->cval.real != 0.0 \|\| v->cval.imag != 0.0;
	539	+}
	540	+
	541	+static int
	542	+complex_coerce(PyObject pv, PyObject pw)
	543	+{
	544	+ Py_complex cval;
	545	+ cval.imag = 0.;
	546	+ if (PyInt_Check(*pw)) {
	547	+ cval.real = (double)PyInt_AsLong(*pw);
	548	+ *pw = PyComplex_FromCComplex(cval);
	549	+ Py_INCREF(*pv);
	550	+ return 0;
	551	+ }
	552	+ else if (PyLong_Check(*pw)) {
	553	+ cval.real = PyLong_AsDouble(*pw);
	554	+ if (cval.real == -1.0 && PyErr_Occurred())
	555	+ return -1;
	556	+ *pw = PyComplex_FromCComplex(cval);
	557	+ Py_INCREF(*pv);
	558	+ return 0;
	559	+ }
	560	+ else if (PyFloat_Check(*pw)) {
	561	+ cval.real = PyFloat_AsDouble(*pw);
	562	+ *pw = PyComplex_FromCComplex(cval);
	563	+ Py_INCREF(*pv);
	564	+ return 0;
	565	+ }
	566	+ else if (PyComplex_Check(*pw)) {
	567	+ Py_INCREF(*pv);
	568	+ Py_INCREF(*pw);
	569	+ return 0;
	570	+ }
	571	+ return 1; /* Can't do it */
	572	+}
	573	+
	574	+static PyObject *
	575	+complex_richcompare(PyObject v, PyObject w, int op)
	576	+{
	577	+ int c;
	578	+ Py_complex i, j;
	579	+ PyObject *res;
	580	+
	581	+ c = PyNumber_CoerceEx(&v, &w);
	582	+ if (c < 0)
	583	+ return NULL;
	584	+ if (c > 0) {
	585	+ Py_INCREF(Py_NotImplemented);
	586	+ return Py_NotImplemented;
	587	+ }
	588	+ /* Make sure both arguments are complex. */
	589	+ if (!(PyComplex_Check(v) && PyComplex_Check(w))) {
	590	+ Py_DECREF(v);
	591	+ Py_DECREF(w);
	592	+ Py_INCREF(Py_NotImplemented);
	593	+ return Py_NotImplemented;
	594	+ }
	595	+
	596	+ i = ((PyComplexObject *)v)->cval;
	597	+ j = ((PyComplexObject *)w)->cval;
	598	+ Py_DECREF(v);
	599	+ Py_DECREF(w);
	600	+
	601	+ if (op != Py_EQ && op != Py_NE) {
	602	+ PyErr_SetString(PyExc_TypeError,
	603	+ "no ordering relation is defined for complex numbers");
	604	+ return NULL;
	605	+ }
	606	+
	607	+ if ((i.real == j.real && i.imag == j.imag) == (op == Py_EQ))
	608	+ res = Py_True;
	609	+ else
	610	+ res = Py_False;
	611	+
	612	+ Py_INCREF(res);
	613	+ return res;
	614	+}
	615	+
	616	+static PyObject *
	617	+complex_int(PyObject *v)
	618	+{
	619	+ PyErr_SetString(PyExc_TypeError,
	620	+ "can't convert complex to int; use int(abs(z))");
	621	+ return NULL;
	622	+}
	623	+
	624	+static PyObject *
	625	+complex_long(PyObject *v)
	626	+{
	627	+ PyErr_SetString(PyExc_TypeError,
	628	+ "can't convert complex to long; use long(abs(z))");
	629	+ return NULL;
	630	+}
	631	+
	632	+static PyObject *
	633	+complex_float(PyObject *v)
	634	+{
	635	+ PyErr_SetString(PyExc_TypeError,
	636	+ "can't convert complex to float; use abs(z)");
	637	+ return NULL;
	638	+}
	639	+
	640	+static PyObject *
	641	+complex_conjugate(PyObject *self)
	642	+{
	643	+ Py_complex c;
	644	+ c = ((PyComplexObject *)self)->cval;
	645	+ c.imag = -c.imag;
	646	+ return PyComplex_FromCComplex(c);
	647	+}
	648	+
	649	+static PyObject *
	650	+complex_getnewargs(PyComplexObject *v)
	651	+{
	652	+ return Py_BuildValue("(D)", &v->cval);
	653	+}
	654	+
	655	+static PyMethodDef complex_methods[] = {
	656	+ {"conjugate", (PyCFunction)complex_conjugate, METH_NOARGS},
	657	+ {"__getnewargs__", (PyCFunction)complex_getnewargs, METH_NOARGS},
	658	+ {NULL, NULL} /* sentinel */
	659	+};
	660	+
	661	+static PyMemberDef complex_members[] = {
	662	+ {"real", T_DOUBLE, offsetof(PyComplexObject, cval.real), READONLY,
	663	+ "the real part of a complex number"},
	664	+ {"imag", T_DOUBLE, offsetof(PyComplexObject, cval.imag), READONLY,
	665	+ "the imaginary part of a complex number"},
	666	+ {0},
	667	+};
	668	+
	669	+static PyObject *
	670	+complex_subtype_from_string(PyTypeObject type, PyObject v)
	671	+{
	672	+ const char s, start;
	673	+ char *end;
	674	+ double x=0.0, y=0.0, z;
	675	+ int got_re=0, got_im=0, done=0;
	676	+ int digit_or_dot;
	677	+ int sw_error=0;
	678	+ int sign;
	679	+ char buffer[256]; /* For errors */
	680	+#ifdef Py_USING_UNICODE
	681	+ char s_buffer[256];
	682	+#endif
	683	+ Py_ssize_t len;
	684	+
	685	+ if (PyString_Check(v)) {
	686	+ s = PyString_AS_STRING(v);
	687	+ len = PyString_GET_SIZE(v);
	688	+ }
	689	+#ifdef Py_USING_UNICODE
	690	+ else if (PyUnicode_Check(v)) {
	691	+ if (PyUnicode_GET_SIZE(v) >= (Py_ssize_t)sizeof(s_buffer)) {
	692	+ PyErr_SetString(PyExc_ValueError,
	693	+ "complex() literal too large to convert");
	694	+ return NULL;
	695	+ }
	696	+ if (PyUnicode_EncodeDecimal(PyUnicode_AS_UNICODE(v),
	697	+ PyUnicode_GET_SIZE(v),
	698	+ s_buffer,
	699	+ NULL))
	700	+ return NULL;
	701	+ s = s_buffer;
	702	+ len = strlen(s);
	703	+ }
	704	+#endif
	705	+ else if (PyObject_AsCharBuffer(v, &s, &len)) {
	706	+ PyErr_SetString(PyExc_TypeError,
	707	+ "complex() arg is not a string");
	708	+ return NULL;
	709	+ }
	710	+
	711	+ /* position on first nonblank */
	712	+ start = s;
	713	+ while (s && isspace(Py_CHARMASK(s)))
	714	+ s++;
	715	+ if (s[0] == '\0') {
	716	+ PyErr_SetString(PyExc_ValueError,
	717	+ "complex() arg is an empty string");
	718	+ return NULL;
	719	+ }
	720	+
	721	+ z = -1.0;
	722	+ sign = 1;
	723	+ do {
	724	+
	725	+ switch (*s) {
	726	+
	727	+ case '\0':
	728	+ if (s-start != len) {
	729	+ PyErr_SetString(
	730	+ PyExc_ValueError,
	731	+ "complex() arg contains a null byte");
	732	+ return NULL;
	733	+ }
	734	+ if(!done) sw_error=1;
	735	+ break;
	736	+
	737	+ case '-':
	738	+ sign = -1;
	739	+ /* Fallthrough */
	740	+ case '+':
	741	+ if (done) sw_error=1;
	742	+ s++;
	743	+ if ( s=='\0'\|\|s=='+'\|\|*s=='-' \|\|
	744	+ isspace(Py_CHARMASK(*s)) ) sw_error=1;
	745	+ break;
	746	+
	747	+ case 'J':
	748	+ case 'j':
	749	+ if (got_im \|\| done) {
	750	+ sw_error = 1;
	751	+ break;
	752	+ }
	753	+ if (z<0.0) {
	754	+ y=sign;
	755	+ }
	756	+ else{
	757	+ y=sign*z;
	758	+ }
	759	+ got_im=1;
	760	+ s++;
	761	+ if (s!='+' && s!='-' )
	762	+ done=1;
	763	+ break;
	764	+
	765	+ default:
	766	+ if (isspace(Py_CHARMASK(*s))) {
	767	+ while (s && isspace(Py_CHARMASK(s)))
	768	+ s++;
	769	+ if (s[0] != '\0')
	770	+ sw_error=1;
	771	+ else
	772	+ done = 1;
	773	+ break;
	774	+ }
	775	+ digit_or_dot =
	776	+ (s=='.' \|\| isdigit(Py_CHARMASK(s)));
	777	+ if (done\|\|!digit_or_dot) {
	778	+ sw_error=1;
	779	+ break;
	780	+ }
	781	+ errno = 0;
	782	+ PyFPE_START_PROTECT("strtod", return 0)
	783	+ z = PyOS_ascii_strtod(s, &end) ;
	784	+ PyFPE_END_PROTECT(z)
	785	+ if (errno != 0) {
	786	+ PyOS_snprintf(buffer, sizeof(buffer),
	787	+ "float() out of range: %.150s", s);
	788	+ PyErr_SetString(
	789	+ PyExc_ValueError,
	790	+ buffer);
	791	+ return NULL;
	792	+ }
	793	+ s=end;
	794	+ if (s=='J' \|\| s=='j') {
	795	+
	796	+ break;
	797	+ }
	798	+ if (got_re) {
	799	+ sw_error=1;
	800	+ break;
	801	+ }
	802	+
	803	+ /* accept a real part */
	804	+ x=sign*z;
	805	+ got_re=1;
	806	+ if (got_im) done=1;
	807	+ z = -1.0;
	808	+ sign = 1;
	809	+ break;
	810	+
	811	+ } /* end of switch */
	812	+
	813	+ } while (s - start < len && !sw_error);
	814	+
	815	+ if (sw_error) {
	816	+ PyErr_SetString(PyExc_ValueError,
	817	+ "complex() arg is a malformed string");
	818	+ return NULL;
	819	+ }
	820	+
	821	+ return complex_subtype_from_doubles(type, x, y);
	822	+}
	823	+
	824	+static PyObject *
	825	+complex_new(PyTypeObject type, PyObject args, PyObject *kwds)
	826	+{
	827	+ PyObject r, i, tmp, f;
	828	+ PyNumberMethods nbr, nbi = NULL;
	829	+ Py_complex cr, ci;
	830	+ int own_r = 0;
	831	+ static PyObject *complexstr;
	832	+ static char *kwlist[] = {"real", "imag", 0};
	833	+
	834	+ r = Py_False;
	835	+ i = NULL;
	836	+ if (!PyArg_ParseTupleAndKeywords(args, kwds, "\|OO:complex", kwlist,
	837	+ &r, &i))
	838	+ return NULL;
	839	+
	840	+ /* Special-case for single argument that is already complex */
	841	+ if (PyComplex_CheckExact(r) && i == NULL &&
	842	+ type == &PyComplex_Type) {
	843	+ /* Note that we can't know whether it's safe to return
	844	+ a complex subclass instance as-is, hence the restriction
	845	+ to exact complexes here. */
	846	+ Py_INCREF(r);
	847	+ return r;
	848	+ }
	849	+ if (PyString_Check(r) \|\| PyUnicode_Check(r)) {
	850	+ if (i != NULL) {
	851	+ PyErr_SetString(PyExc_TypeError,
	852	+ "complex() can't take second arg"
	853	+ " if first is a string");
	854	+ return NULL;
	855	+ }
	856	+ return complex_subtype_from_string(type, r);
	857	+ }
	858	+ if (i != NULL && (PyString_Check(i) \|\| PyUnicode_Check(i))) {
	859	+ PyErr_SetString(PyExc_TypeError,
	860	+ "complex() second arg can't be a string");
	861	+ return NULL;
	862	+ }
	863	+
	864	+ /* XXX Hack to support classes with __complex__ method */
	865	+ if (complexstr == NULL) {
	866	+ complexstr = PyString_InternFromString("__complex__");
	867	+ if (complexstr == NULL)
	868	+ return NULL;
	869	+ }
	870	+ f = PyObject_GetAttr(r, complexstr);
	871	+ if (f == NULL)
	872	+ PyErr_Clear();
	873	+ else {
	874	+ PyObject *args = PyTuple_New(0);
	875	+ if (args == NULL)
	876	+ return NULL;
	877	+ r = PyEval_CallObject(f, args);
	878	+ Py_DECREF(args);
	879	+ Py_DECREF(f);
	880	+ if (r == NULL)
	881	+ return NULL;
	882	+ own_r = 1;
	883	+ }
	884	+ nbr = r->ob_type->tp_as_number;
	885	+ if (i != NULL)
	886	+ nbi = i->ob_type->tp_as_number;
	887	+ if (nbr == NULL \|\| nbr->nb_float == NULL \|\|
	888	+ ((i != NULL) && (nbi == NULL \|\| nbi->nb_float == NULL))) {
	889	+ PyErr_SetString(PyExc_TypeError,
	890	+ "complex() argument must be a string or a number");
	891	+ if (own_r) {
	892	+ Py_DECREF(r);
	893	+ }
	894	+ return NULL;
	895	+ }
	896	+ if (PyComplex_Check(r)) {
	897	+ /* Note that if r is of a complex subtype, we're only
	898	+ retaining its real & imag parts here, and the return
	899	+ value is (properly) of the builtin complex type. */
	900	+ cr = ((PyComplexObject*)r)->cval;
	901	+ if (own_r) {
	902	+ Py_DECREF(r);
	903	+ }
	904	+ }
	905	+ else {
	906	+ tmp = PyNumber_Float(r);
	907	+ if (own_r) {
	908	+ Py_DECREF(r);
	909	+ }
	910	+ if (tmp == NULL)
	911	+ return NULL;
	912	+ if (!PyFloat_Check(tmp)) {
	913	+ PyErr_SetString(PyExc_TypeError,
	914	+ "float(r) didn't return a float");
	915	+ Py_DECREF(tmp);
	916	+ return NULL;
	917	+ }
	918	+ cr.real = PyFloat_AsDouble(tmp);
	919	+ Py_DECREF(tmp);
	920	+ cr.imag = 0.0;
	921	+ }
	922	+ if (i == NULL) {
	923	+ ci.real = 0.0;
	924	+ ci.imag = 0.0;
	925	+ }
	926	+ else if (PyComplex_Check(i))
	927	+ ci = ((PyComplexObject*)i)->cval;
	928	+ else {
	929	+ tmp = (*nbi->nb_float)(i);
	930	+ if (tmp == NULL)
	931	+ return NULL;
	932	+ ci.real = PyFloat_AsDouble(tmp);
	933	+ Py_DECREF(tmp);
	934	+ ci.imag = 0.;
	935	+ }
	936	+ cr.real -= ci.imag;
	937	+ cr.imag += ci.real;
	938	+ return complex_subtype_from_c_complex(type, cr);
	939	+}
	940	+
	941	+PyDoc_STRVAR(complex_doc,
	942	+"complex(real[, imag]) -> complex number\n"
	943	+"\n"
	944	+"Create a complex number from a real part and an optional imaginary part.\n"
	945	+"This is equivalent to (real + imag*1j) where imag defaults to 0.");
	946	+
	947	+static PyNumberMethods complex_as_number = {
	948	+ (binaryfunc)complex_add, /* nb_add */
	949	+ (binaryfunc)complex_sub, /* nb_subtract */
	950	+ (binaryfunc)complex_mul, /* nb_multiply */
	951	+ (binaryfunc)complex_classic_div, /* nb_divide */
	952	+ (binaryfunc)complex_remainder, /* nb_remainder */
	953	+ (binaryfunc)complex_divmod, /* nb_divmod */
	954	+ (ternaryfunc)complex_pow, /* nb_power */
	955	+ (unaryfunc)complex_neg, /* nb_negative */
	956	+ (unaryfunc)complex_pos, /* nb_positive */
	957	+ (unaryfunc)complex_abs, /* nb_absolute */
	958	+ (inquiry)complex_nonzero, /* nb_nonzero */
	959	+ 0, /* nb_invert */
	960	+ 0, /* nb_lshift */
	961	+ 0, /* nb_rshift */
	962	+ 0, /* nb_and */
	963	+ 0, /* nb_xor */
	964	+ 0, /* nb_or */
	965	+ complex_coerce, /* nb_coerce */
	966	+ complex_int, /* nb_int */
	967	+ complex_long, /* nb_long */
	968	+ complex_float, /* nb_float */
	969	+ 0, /* nb_oct */
	970	+ 0, /* nb_hex */
	971	+ 0, /* nb_inplace_add */
	972	+ 0, /* nb_inplace_subtract */
	973	+ 0, /* nb_inplace_multiply*/
	974	+ 0, /* nb_inplace_divide */
	975	+ 0, /* nb_inplace_remainder */
	976	+ 0, /* nb_inplace_power */
	977	+ 0, /* nb_inplace_lshift */
	978	+ 0, /* nb_inplace_rshift */
	979	+ 0, /* nb_inplace_and */
	980	+ 0, /* nb_inplace_xor */
	981	+ 0, /* nb_inplace_or */
	982	+ (binaryfunc)complex_int_div, /* nb_floor_divide */
	983	+ (binaryfunc)complex_div, /* nb_true_divide */
	984	+ 0, /* nb_inplace_floor_divide */
	985	+ 0, /* nb_inplace_true_divide */
	986	+};
	987	+
	988	+PyTypeObject PyComplex_Type = {
	989	+ PyObject_HEAD_INIT(&PyType_Type)
	990	+ 0,
	991	+ "complex",
	992	+ sizeof(PyComplexObject),
	993	+ 0,
	994	+ complex_dealloc, /* tp_dealloc */
	995	+ (printfunc)complex_print, /* tp_print */
	996	+ 0, /* tp_getattr */
	997	+ 0, /* tp_setattr */
	998	+ 0, /* tp_compare */
	999	+ (reprfunc)complex_repr, /* tp_repr */
	1000	+ &complex_as_number, /* tp_as_number */
	1001	+ 0, /* tp_as_sequence */
	1002	+ 0, /* tp_as_mapping */
	1003	+ (hashfunc)complex_hash, /* tp_hash */
	1004	+ 0, /* tp_call */
	1005	+ (reprfunc)complex_str, /* tp_str */
	1006	+ PyObject_GenericGetAttr, /* tp_getattro */
	1007	+ 0, /* tp_setattro */
	1008	+ 0, /* tp_as_buffer */
	1009	+ Py_TPFLAGS_DEFAULT \| Py_TPFLAGS_BASETYPE, /* tp_flags */
	1010	+ complex_doc, /* tp_doc */
	1011	+ 0, /* tp_traverse */
	1012	+ 0, /* tp_clear */
	1013	+ complex_richcompare, /* tp_richcompare */
	1014	+ 0, /* tp_weaklistoffset */
	1015	+ 0, /* tp_iter */
	1016	+ 0, /* tp_iternext */
	1017	+ complex_methods, /* tp_methods */
	1018	+ complex_members, /* tp_members */
	1019	+ 0, /* tp_getset */
	1020	+ 0, /* tp_base */
	1021	+ 0, /* tp_dict */
	1022	+ 0, /* tp_descr_get */
	1023	+ 0, /* tp_descr_set */
	1024	+ 0, /* tp_dictoffset */
	1025	+ 0, /* tp_init */
	1026	+ PyType_GenericAlloc, /* tp_alloc */
	1027	+ complex_new, /* tp_new */
	1028	+ PyObject_Del, /* tp_free */
	1029	+};
	1030	+
	1031	+#endif