changes for complex numbers

diff --git a/Python/bltinmodule.c b/Python/bltinmodule.c
index 944525591ba9b4ec4bd6ba10c0ad8eef925f3f5c..dca31acd39c1c4103a35743d12ea13b22e38d896 100644 (file)
--- a/Python/bltinmodule.c
+++ b/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},

diff --git a/Python/getargs.c b/Python/getargs.c
index cd3ff6d4d8c1f2cd037f20b7c38213fd1c95f2b9..7ec31c353569f1c41599e457718112a5d4fbe4f8 100644 (file)
--- a/Python/getargs.c
+++ b/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 *);

diff --git a/Python/marshal.c b/Python/marshal.c
index 15c02c3c653a63f8a4bc057ffed155140d900613..f3d7b5cb4d4f6f77413812f2970e68e6a58b873c 100644 (file)
--- a/Python/marshal.c
+++ b/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);