changes for complex numbers

Python/bltinmodule.c

@@ -281,6 +281,51 @@ builtin_compile(self, args)
 	return compile_string(str, filename, start);
 }
 
+#ifndef WITHOUT_COMPLEX
+
+static object *
+builtin_complex(self, args)
+	object *self;
+	object *args;
+{
+	object *r, *i;
+	number_methods *nbr, *nbi;
+	complex cr, ci;
+
+	i = NULL;
+	if (!newgetargs(args, "O|O:complex", &r, &i))
+		return NULL;
+	if ((nbr = r->ob_type->tp_as_number) == NULL ||
+	     nbr->nb_float == NULL || (i != NULL &&
+	   ((nbi = i->ob_type->tp_as_number) == NULL ||
+	     nbi->nb_float == NULL))) {
+		err_setstr(TypeError,
+			   "complex() argument can't be converted to complex");
+		return NULL;
+	}
+	if (is_complexobject(r))
+		cr = ((complexobject*)r)->cval;
+	else {
+		cr.real = getfloatvalue((*nbr->nb_float)(r));
+		cr.imag = 0.;
+	}
+	if (i == NULL) {
+		ci.real = 0.;
+		ci.imag = 0.;
+	}
+	else if (is_complexobject(i))
+		ci = ((complexobject*)i)->cval;
+	else {
+		ci.real = getfloatvalue((*nbi->nb_float)(i));
+		ci.imag = 0.;
+	}
+	cr.real -= ci.imag;
+	cr.imag += ci.real;
+	return newcomplexobject(cr);
+}
+
+#endif
+
 static object *
 builtin_dir(self, args)
 	object *self;
@@ -954,7 +999,11 @@ do_pow(v, w)
 		err_setstr(TypeError, "pow() requires numeric arguments");
 		return NULL;
 	}
-	if (is_floatobject(w) && getfloatvalue(v) < 0.0) {
+	if (
+#ifndef WITHOUT_COMPLEX
+            !is_complexobject(v) && 
+#endif
+            is_floatobject(w) && getfloatvalue(v) < 0.0) {
 		if (!err_occurred())
 		    err_setstr(ValueError, "negative number to float power");
 		return NULL;
@@ -1394,6 +1443,9 @@ static struct methodlist builtin_methods[] = {
 	{"cmp",		builtin_cmp, 1},
 	{"coerce",	builtin_coerce, 1},
 	{"compile",	builtin_compile, 1},
+#ifndef WITHOUT_COMPLEX
+	{"complex",	builtin_complex, 1},
+#endif
 	{"delattr",	builtin_delattr, 1},
 	{"dir",		builtin_dir, 1},
 	{"divmod",	builtin_divmod, 1},

Python/getargs.c

@@ -498,6 +498,17 @@ convertsimple1(arg, p_format, p_va)
 			break;
 		}
 	
+	case 'D': /* complex double */
+		{
+			complex *p = va_arg(*p_va, complex *);
+			complex cval = PyComplex_AsCComplex(arg);
+			if (err_occurred())
+				return "complex<D>";
+			else
+				*p = cval;
+			break;
+		}
+	
 	case 'c': /* char */
 		{
 			char *p = va_arg(*p_va, char *);

Python/marshal.c

@@ -39,6 +39,7 @@ OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 #define TYPE_NONE	'N'
 #define TYPE_INT	'i'
 #define TYPE_FLOAT	'f'
+#define TYPE_COMPLEX	'x'
 #define TYPE_LONG	'l'
 #define TYPE_STRING	's'
 #define TYPE_TUPLE	'('
@@ -150,6 +151,26 @@ w_object(v, p)
 		w_byte(n, p);
 		w_string(buf, n, p);
 	}
+#ifndef WITHOUT_COMPLEX
+	else if (is_complexobject(v)) {
+		extern void float_buf_repr PROTO((char *, floatobject *));
+		char buf[256]; /* Plenty to format any double */
+		floatobject *temp;
+		w_byte(TYPE_COMPLEX, p);
+		temp = (floatobject*)newfloatobject(PyComplex_RealAsDouble(v));
+		float_buf_repr(buf, temp);
+		DECREF(temp);
+		n = strlen(buf);
+		w_byte(n, p);
+		w_string(buf, n, p);
+		temp = (floatobject*)newfloatobject(PyComplex_ImagAsDouble(v));
+		float_buf_repr(buf, temp);
+		DECREF(temp);
+		n = strlen(buf);
+		w_byte(n, p);
+		w_string(buf, n, p);
+	}
+#endif
 	else if (is_stringobject(v)) {
 		w_byte(TYPE_STRING, p);
 		n = getstringsize(v);
@@ -329,6 +350,32 @@ r_object(p)
 			return newfloatobject(atof(buf));
 		}
 	
+#ifndef WITHOUT_COMPLEX
+	case TYPE_COMPLEX:
+		{
+			extern double atof PROTO((const char *));
+			char buf[256];
+			complex c;
+			n = r_byte(p);
+			if (r_string(buf, (int)n, p) != n) {
+				err_setstr(EOFError,
+					"EOF read where object expected");
+				return NULL;
+			}
+			buf[n] = '\0';
+			c.real = atof(buf);
+			n = r_byte(p);
+			if (r_string(buf, (int)n, p) != n) {
+				err_setstr(EOFError,
+					"EOF read where object expected");
+				return NULL;
+			}
+			buf[n] = '\0';
+			c.imag = atof(buf);
+			return newcomplexobject(c);
+		}
+#endif
+	
 	case TYPE_STRING:
 		n = r_long(p);
 		v = newsizedstringobject((char *)NULL, n);