     public static var SQRT1_2 = Float(Double.SQRT1_2)
     public static var EPSILON:Float = 0x1p-23
 }
-// el corazon
+/// Complex number of `RealType`
+///
 public struct Complex<T:RealType> : Equatable, CustomStringConvertible, Hashable {
     public var (re, im): (T, T)
     public init(_ re:T, _ im:T) {

        self.re = abs * T.cos(arg)
        self.im = abs * T.sin(arg)
    }
    /// real part of self
    public var real:T { get{ return re } set(r){ re = r } }
    /// imaginary part of self
    public var imag:T { get{ return im } set(i){ im = i } }
    /// absolute value of self
    public var abs:T {
        get { return T.hypot(re, im) }
        set(r){ let f = r / abs; re *= f; im *= f }
    }
    /// argument of self
    public var arg:T  {
        get { return T.atan2(im, re) }
        set(t){ let m = abs; re = m * T.cos(t); im = m * T.sin(t) }
    }
    /// norm of self
    public var norm:T { return T.hypot(re, im) }
    /// conjugate of self
    public var conj:Complex { return Complex(re, -im) }
    /// projection of self
    public var proj:Complex {
        if re.isFinite && im.isFinite {
            return self

/*
 * for the compatibility's sake w/ C++11
 */
/// absolute value of z in T:RealType
public func abs<T>(z:Complex<T>) -> T { return z.abs }
/// argument of z in T:RealType
public func arg<T>(z:Complex<T>) -> T { return z.arg }
/// real part of z in T:RealType
public func real<T>(z:Complex<T>) -> T { return z.real }
/// imaginary part of z in T:RealType
public func imag<T>(z:Complex<T>) -> T { return z.imag }
/// norm of z in T:RealType
public func norm<T>(z:Complex<T>) -> T { return z.norm }
/// conjugate of z in Complex
public func conj<T>(z:Complex<T>) -> Complex<T> { return z.conj }
/// projection of z in Complex
public func proj<T>(z:Complex<T>) -> Complex<T> { return z.proj }
//
// approximate comparisons
