     /// init(t:(r, i))
     public init(t:(T, T)) {
         (re, im) = t
+    }
+    /// Complex<U> -> Complex<T>
+    public init<U:ArithmeticType>(_ z:Complex<U>) {
+        (re, im) = (T(z.re)!, T(z.im)!)
     }
     /// self * i
     public var i:Complex { return Complex(-im, re) }

        set(t){ (re, im) = t }
    }
    /// converts to Complex<Int>
    public var asComplexInt:Complex<Int> {
        return Complex<Int>(Int(re)!, Int(im)!)
    }
    /// converts to Complex<Double>
    public var asComplexDouble:Complex<Double> {
        return Complex<Double>(Double(re)!, Double(im)!)
    }
    /// converts to Complex<Float>
    public var asComplexFloat:Complex<Float> {
        return Complex<Float>(Float(re)!, Float(im)!)
    }
}
/// real part of z
public func real<T>(z:Complex<T>) -> T { return z.re }

    public init?<U:ArithmeticType>(_ x:U) {
        switch x {
        case let s as CGFloat:  self.init(s)
        case let d as Double:   self.init(d)
        case let f as Float:    self.init(f)
        case let i as Int:      self.init(i)
        default:
            return nil
        }
