*** complexobject.c.orig 
--- complexobject.c 
***************
*** 837,848 ****
  					 &r, &i))
  		return NULL;
  
! 	/* Special-case for single argument that is already complex */
  	if (PyComplex_CheckExact(r) && i == NULL &&
  	    type == &PyComplex_Type) {
  		/* Note that we can't know whether it's safe to return
  		   a complex *subclass* instance as-is, hence the restriction
! 		   to exact complexes here.  */
  		Py_INCREF(r);
  		return r;
  	}
--- 837,850 ----
  					 &r, &i))
  		return NULL;
  
! 	/* Special-case for a single argument when type(arg) is complex. */
  	if (PyComplex_CheckExact(r) && i == NULL &&
  	    type == &PyComplex_Type) {
  		/* Note that we can't know whether it's safe to return
  		   a complex *subclass* instance as-is, hence the restriction
! 		   to exact complexes here.  If either the input or the
! 		   output is a complex subclass, it will be handled below 
! 		   as a non-orthogonal vector.  */
  		Py_INCREF(r);
  		return r;
  	}
***************
*** 893,898 ****
--- 895,908 ----
  		}
  		return NULL;
  	}
+ 
+ 	/* If we get this far, then the "real" and "imag" parts should
+ 	   both be treated as numbers, and the constructor should return a
+ 	   complex number equal to (real + imag*1j).
+ 
+  	   Note that we do NOT assume the input to already be in canonical
+ 	   form; the "real" and "imag" parts might themselves be complex
+ 	   numbers, which slightly complicates the code below. */
  	if (PyComplex_Check(r)) {
  		/* Note that if r is of a complex subtype, we're only
  		   retaining its real & imag parts here, and the return
***************
*** 903,910 ****
--- 913,926 ----
  		}
  	}
  	else {
+ 		/* The "real" part really is entirely real, and contributes
+ 		   nothing in the imaginary direction.  
+ 		   Just treat it as a double. */
+ 		cr.imag = 0.0;  
  		tmp = PyNumber_Float(r);
  		if (own_r) {
+ 			/* r was a newly created complex number, rather
+ 			   than the original "real" argument. */
  			Py_DECREF(r);
  		}
  		if (tmp == NULL)
***************
*** 917,923 ****
  		}
  		cr.real = PyFloat_AsDouble(tmp);
  		Py_DECREF(tmp);
- 		cr.imag = 0.0;
  	}
  	if (i == NULL) {
  		ci.real = 0.0;
--- 933,938 ----
***************
*** 926,938 ****
  	else if (PyComplex_Check(i))
  		ci = ((PyComplexObject*)i)->cval;
  	else {
  		tmp = (*nbi->nb_float)(i);
  		if (tmp == NULL)
  			return NULL;
  		ci.real = PyFloat_AsDouble(tmp);
  		Py_DECREF(tmp);
! 		ci.imag = 0.;
! 	}
  	cr.real -= ci.imag;
  	cr.imag += ci.real;
  	return complex_subtype_from_c_complex(type, cr);
--- 941,959 ----
  	else if (PyComplex_Check(i))
  		ci = ((PyComplexObject*)i)->cval;
  	else {
+ 		/* The "imag" part really is entirely imaginary, and
+ 		   contributes nothing in the real direction.
+ 		   Just treat it as a double. */
+ 		ci.imag = 0.0;
  		tmp = (*nbi->nb_float)(i);
  		if (tmp == NULL)
  			return NULL;
  		ci.real = PyFloat_AsDouble(tmp);
  		Py_DECREF(tmp);
! 	}
! 	/*  If the input was in canonical form, then the "real" and "imag"
! 	    parts are real numbers, so that ci.imag and cr.image are zero.
! 	    We need this correction in case they were not real numbers. */
  	cr.real -= ci.imag;
  	cr.imag += ci.real;
  	return complex_subtype_from_c_complex(type, cr);