         )
     }
     public static func sin(_ x:Element)->Self { return sin(Self(x)) }
-    /// - returns: tangent of z in Complex
+    /// tangent of z in Complex
     public static func tan(_ z:Self) -> Self {
         return sin(z) / cos(z)
     }
     public static func tan(_ x:Element) -> Self { return tan(Self(x)) }
-    /// - returns: arc cosine of z in Complex
+    /// arc cosine of z in Complex
     public static func acos(_ z:Self) -> Self {
         return log(z - sqrt(1 - z*z).i).i
     }
     public static func acos(_ x:Element) -> Self { return acos(Self(x)) }
-    /// - returns: arc sine of z in Complex
+    /// arc sine of z in Complex
     public static func asin(_ z:Self) -> Self {
         return -log(z.i + sqrt(1 - z*z)).i
     }
     public static func asin(_ x:Element) -> Self { return asin(Self(x)) }
-    /// - returns: arc tangent of z in Complex
+    /// arc tangent of z in Complex
     public static func atan(_ z:Self) -> Self {
         let lp = log(1 - z.i)
         let lm = log(1 + z.i)
         return (lp - lm).i / 2
     }
     public static func atan(_ x:Element) -> Self { return atan(Self(x)) }
-    /// - returns: hyperbolic cosine of z in Complex
+    /// hyperbolic cosine of z in Complex
     public static func cosh(_ z:Self) -> Self {
         // return (exp(z) + exp(-z)) / T(2)
         return cos(z.i)
     }
     public static func cosh(_ x:Element) -> Self { return cosh(Self(x)) }
-    /// - returns: hyperbolic sine of z in Complex
+    /// hyperbolic sine of z in Complex
     public static func sinh(_ z:Self) -> Self {
         // return (exp(z) - exp(-z)) / T(2)
         return -sin(z.i).i;
     }
     public static func sinh(_ x:Element) -> Self { return sinh(Self(x)) }
-    /// - returns: hyperbolic tangent of z in Complex
+    /// hyperbolic tangent of z in Complex
     public static func tanh(_ z:Self) -> Self {
         // let ez = exp(z), e_z = exp(-z)
         // return (ez - e_z) / (ez + e_z)
         return sinh(z) / cosh(z)
     }
     public static func tanh(_ x:Element) -> Self { return tanh(Self(x)) }
-    /// - returns: inverse hyperbolic cosine of z in Complex
+    /// inverse hyperbolic cosine of z in Complex
     public static func acosh(_ z:Self) -> Self {
         return log(z + sqrt(z+1)*sqrt(z-1))
     }
     public static func acosh(_ x:Element) -> Self { return acosh(Self(x)) }
-    /// - returns: inverse hyperbolic cosine of z in Complex
+    /// inverse hyperbolic cosine of z in Complex
     public static func asinh(_ z:Self) -> Self {
         return log(z + sqrt(z*z+1))
     }
     public static func asinh(_ x:Element) -> Self { return asinh(Self(x)) }
-    /// - returns: inverse hyperbolic tangent of z in Complex
+    /// inverse hyperbolic tangent of z in Complex
     public static func atanh(_ z:Self) -> Self {
         return (log(1 + z) - log(1 - z)) / 2
     }
     public static func atanh(_ x:Element) -> Self { return atanh(Self(x)) }
-    /// - returns: hypot
+    /// hypotenuse. defined as √(lhs**2 + rhs**2) though its need for Complex is moot.
     public static func hypot(_ lhs:Self, _ rhs:Self) -> Self {
-        fatalError("Not applicable for Complex")
+        return sqrt(lhs*lhs + rhs*rhs)
     }
     public static func hypot(_ lhs:Self, _ rhs:Element)->Self { return hypot(lhs, Self(rhs)) }
     public static func hypot(_ lhs:Element, _ rhs:Self)->Self { return hypot(Self(lhs), rhs) }
     public static func hypot(_ lhs:Element, _ rhs:Element)->Self { return Self(Element.hypot(lhs, rhs)) }
-    /// - returns: atan2
+    /// atan2 = atan(lhs/rhs)
     public static func atan2(_ lhs:Self, _ rhs:Self) -> Self {
         return atan(lhs/rhs)
     }

            (real, imag) = (real * r, imag * r)
        }
    }
    /// argument
    public var arg:Element  {
        get { return Element.atan2(imag, real) }

            return Self(.infinity, imag.sign == .minus ? -Element(0): +Element(0))
        }
    }
    /// description -- conforms to CustomStringConvertible
    public var description:String {
        let sig = imag.sign == .minus ? "-" : "+"
        return "(\(real)\(sig)\(imag.magnitude).i)"
