 public func /= <T>(inout lhs:Complex<T>, rhs:T) {
     lhs = lhs / rhs
 }
-/// exp(z)
+/// - returns: e ** z in Complex
 public func exp<T>(z:Complex<T>) -> Complex<T> {
     let r = T.exp(z.re)
     let a = z.im
     return Complex(r * T.cos(a), r * T.sin(a))
 }
-/// log(z)
+/// - returns: natural log of z in Complex
 public func log<T>(z:Complex<T>) -> Complex<T> {
     return Complex(T.log(z.abs), z.arg)
 }
-/// log10(z)
+/// - returns: log 10 of z in Complex
 public func log10<T>(z:Complex<T>) -> Complex<T> { return log(z) / T(M_LN10) }
 public func log10<T:RealType>(r:T) -> T { return T.log(r) / T(M_LN10) }
 /// pow(zb, zx)

#else
import Foundation
#endif
public protocol RealType : FloatingPointType, AbsoluteValuable, Equatable, Comparable, Hashable {
    // Initializers (predefined)
    init(_ value: UInt8)

/*
 * 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
