diff --git a/lib/complex.rb b/lib/complex.rb
index 85ceb44..22311f9 100644
--- a/lib/complex.rb
+++ b/lib/complex.rb
@@ -431,162 +431,157 @@ module Math
   alias asinh! asinh
   alias atanh! atanh  
 
-  # Redefined to handle a Complex argument.
-  def sqrt(z)
-    if Complex.generic?(z)
-      if z >= 0
-	sqrt!(z)
+  def sqrt(value)
+    if value.kind_of? Complex
+      if value.image < 0
+        sqrt(value.conjugate).conjugate
       else
-	Complex(0,sqrt!(-z))
+        Complex(sqrt!((value.abs + value.real) / 2),
+                sqrt!((value.abs - value.real) / 2))
       end
     else
-      if z.image < 0
-	sqrt(z.conjugate).conjugate
+      value = Float(value)
+      if value >= 0
+        sqrt!(value)
       else
-	r = z.abs
-	x = z.real
-	Complex( sqrt!((r+x)/2), sqrt!((r-x)/2) )
+        Complex(0, sqrt!(value.abs))
       end
     end
   end
   
-  # Redefined to handle a Complex argument.
-  def exp(z)
-    if Complex.generic?(z)
-      exp!(z)
+  def exp(value)
+    if value.kind_of? Complex
+      Complex(exp!(value.real) * cos!(value.image),
+              exp!(value.real) * sin!(value.image))
     else
-      Complex(exp!(z.real) * cos!(z.image), exp!(z.real) * sin!(z.image))
+      exp!(value)
     end
   end
-  
-  # Redefined to handle a Complex argument.
-  def cos(z)
-    if Complex.generic?(z)
-      cos!(z)
+
+  def cos(value)
+    if value.kind_of? Complex
+      Complex(cos!(value.real) * cosh!(value.image),
+              -sin!(value.real) * sinh!(value.image))
     else
-      Complex(cos!(z.real)*cosh!(z.image),
-	      -sin!(z.real)*sinh!(z.image))
+      cos!(value)
     end
   end
-    
-  # Redefined to handle a Complex argument.
-  def sin(z)
-    if Complex.generic?(z)
-      sin!(z)
+  
+  def sin(value)
+    if value.kind_of? Complex
+      Complex(sin!(value.real) * cosh!(value.image),
+              cos!(value.real) * sinh!(value.image))
     else
-      Complex(sin!(z.real)*cosh!(z.image),
-	      cos!(z.real)*sinh!(z.image))
+      sin!(value)
     end
   end
-  
-  # Redefined to handle a Complex argument.
-  def tan(z)
-    if Complex.generic?(z)
-      tan!(z)
+
+  def tan(value)
+    if value.kind_of? Complex
+      sin(value) / cos(value)
     else
-      sin(z)/cos(z)
+      tan!(value)
     end
   end
-
-  def sinh(z)
-    if Complex.generic?(z)
-      sinh!(z)
+  
+  def sinh(value)
+    if value.kind_of? Complex
+      Complex(sinh!(value.real) * cos!(value.image),
+              cosh!(value.real) * sin!(value.image))
     else
-      Complex( sinh!(z.real)*cos!(z.image), cosh!(z.real)*sin!(z.image) )
+      sinh!(value)
     end
   end
 
-  def cosh(z)
-    if Complex.generic?(z)
-      cosh!(z)
+  def cosh(value)
+    if value.kind_of? Complex
+      Complex(cosh!(value.real) * cos!(value.image),
+              sinh!(value.real) * sin!(value.image))
     else
-      Complex( cosh!(z.real)*cos!(z.image), sinh!(z.real)*sin!(z.image) )
+      cosh!(value)
     end
   end
 
-  def tanh(z)
-    if Complex.generic?(z)
-      tanh!(z)
+  def tanh(value)
+    if value.kind_of? Complex
+      sinh(value) / cosh(value)
     else
-      sinh(z)/cosh(z)
+      tanh!(value)
     end
   end
   
-  # Redefined to handle a Complex argument.
-  def log(z)
-    if Complex.generic?(z) and z >= 0
-      log!(z)
+  def log(value)
+    if value.kind_of?(Complex) || (value = Float(value)) < 0
+      Complex(log!(value.abs), value.arg)
     else
-      r, theta = z.polar
-      Complex(log!(r.abs), theta)
+      log!(value)
     end
   end
   
-  # Redefined to handle a Complex argument.
-  def log10(z)
-    if Complex.generic?(z)
-      log10!(z)
+  def log10(value)
+    if value.kind_of?(Complex) || (value = Float(value)) < 0
+      log(value) / log!(10)
     else
-      log(z)/log!(10)
+      log10!(value)
     end
   end
-
-  def acos(z)
-    if Complex.generic?(z) and z >= -1 and z <= 1
-      acos!(z)
+  
+  def acos(value)
+    if value.kind_of?(Complex) || (value = Float(value)).abs > 1
+      -1.0.im * log(value + 1.0.im * sqrt(1.0-value*value))
     else
-      -1.0.im * log( z + 1.0.im * sqrt(1.0-z*z) )
+      acos!(value)
     end
   end
-
-  def asin(z)
-    if Complex.generic?(z) and z >= -1 and z <= 1
-      asin!(z)
+  
+  def asin(value)
+    if value.kind_of?(Complex) || (value = Float(value)).abs > 1
+      -1.0.im * log(1.0.im * value + sqrt(1.0-value*value))
     else
-      -1.0.im * log( 1.0.im * z + sqrt(1.0-z*z) )
+      asin!(value)
     end
   end
-
-  def atan(z)
-    if Complex.generic?(z)
-      atan!(z)
+  
+  def atan(value)
+    if value.kind_of? Complex
+      1.0.im * log((1.0.im + value) / (1.0.im - value)) / 2.0
     else
-      1.0.im * log( (1.0.im+z) / (1.0.im-z) ) / 2.0
+      atan!(value)
     end
   end
-
-  def atan2(y,x)
-    if Complex.generic?(y) and Complex.generic?(x)
-      atan2!(y,x)
+  
+  def atan2(x, y)
+    if x.kind_of?(Complex) || y.kind_of?(Complex)
+      -1.0.im * log( (y+1.0.im*x) / sqrt(y*y+x*x) )
     else
-      -1.0.im * log( (x+1.0.im*y) / sqrt(x*x+y*y) )
+      atan2!(x, y)
     end
   end
-
-  def acosh(z)
-    if Complex.generic?(z) and z >= 1
-      acosh!(z)
+  
+  def acosh(value)
+    if value.kind_of?(Complex) || (value = Float(value)) < 1
+      log(value + sqrt(value * value - 1.0))
     else
-      log( z + sqrt(z*z-1.0) )
+      acosh!(value)
     end
   end
-
-  def asinh(z)
-    if Complex.generic?(z)
-      asinh!(z)
+  
+  def asinh(value)
+    if value.kind_of? Complex
+      log(value + sqrt(1.0 + value * value))
     else
-      log( z + sqrt(1.0+z*z) )
+      asinh!(value)
     end
   end
-
-  def atanh(z)
-    if Complex.generic?(z) and z >= -1 and z <= 1
-      atanh!(z)
+  
+  def atanh(value)
+    if value.kind_of?(Complex) || (value = Float(value)).abs > 1
+      log((1.0 + value) / (1.0 - value)) / 2.0
     else
-      log( (1.0+z) / (1.0-z) ) / 2.0
+      atanh!(value)
     end
   end
-
+  
   module_function :sqrt!
   module_function :sqrt
   module_function :exp!
@@ -621,7 +616,6 @@ module Math
   module_function :asinh
   module_function :atanh!
   module_function :atanh
-  
 end
 
 # Documentation comments: