From 10c34deadf255ff887e3b9ad44bc379c71bfbf46 Mon Sep 17 00:00:00 2001
From: Christoph Ruegg <git@cdrnet.ch>
Date: Wed, 14 Aug 2013 18:55:24 +0200
Subject: [PATCH] Trig: sort members logically (instead of by name), no code
 changes

---
 src/Numerics/Trigonometry.cs | 748 +++++++++++++++++------------------
 1 file changed, 374 insertions(+), 374 deletions(-)

diff --git a/src/Numerics/Trigonometry.cs b/src/Numerics/Trigonometry.cs
index 99b321e7..32c93528 100644
--- a/src/Numerics/Trigonometry.cs
+++ b/src/Numerics/Trigonometry.cs
@@ -46,115 +46,6 @@ namespace MathNet.Numerics
         /// </summary>
         private const double DegreeToGradConstant = 10.0 / 9.0;
 
-        /// <summary>
-        /// Trigonometric Cosecant of an angle in radian.
-        /// </summary>
-        /// <param name="radian">
-        /// The angle in radian.
-        /// </param>
-        /// <returns>
-        /// Cosecant of an angle in radian.
-        /// </returns>
-        public static double Cosecant(double radian)
-        {
-            return 1 / Math.Sin(radian);
-        }
-
-        /// <summary>
-        /// Trigonometric Cosecant of a <c>Complex</c> number.
-        /// </summary>
-        /// <param name="value">
-        /// The complex value.
-        /// </param>
-        /// <returns>
-        /// The cosecant of a complex number.
-        /// </returns>
-        public static Complex Cosecant(this Complex value)
-        {
-            if (value.IsReal())
-            {
-                return new Complex(Cosecant(value.Real), 0d);
-            }
-
-            var sinr = Sine(value.Real);
-            var sinhi = HyperbolicSine(value.Imaginary);
-            var denom = (sinr * sinr) + (sinhi * sinhi);
-
-            return new Complex(sinr * HyperbolicCosine(value.Imaginary) / denom, -Cosine(value.Real) * sinhi / denom);
-        }
-
-        /// <summary>
-        /// Trigonometric Cosine of an angle in radian.
-        /// </summary>
-        /// <param name="radian">
-        /// The angle in radian.
-        /// </param>
-        /// <returns>
-        /// The cosine of an angle in radian.
-        /// </returns>
-        public static double Cosine(double radian)
-        {
-            return Math.Cos(radian);
-        }
-
-        /// <summary>
-        /// Trigonometric Cosine of a <c>Complex</c> number.
-        /// </summary>
-        /// <param name="value">
-        /// The complex value.
-        /// </param>
-        /// <returns>
-        /// The cosine of a complex number.
-        /// </returns>
-        public static Complex Cosine(this Complex value)
-        {
-            if (value.IsReal())
-            {
-                return new Complex(Cosine(value.Real), 0.0);
-            }
-
-            return new Complex(
-                Cosine(value.Real) * HyperbolicCosine(value.Imaginary),
-                -Sine(value.Real) * HyperbolicSine(value.Imaginary));
-        }
-
-        /// <summary>
-        /// Trigonometric Cotangent of an angle in radian.
-        /// </summary>
-        /// <param name="radian">
-        /// The angle in radian.
-        /// </param>
-        /// <returns>
-        /// The cotangent of an angle in radian.
-        /// </returns>
-        public static double Cotangent(double radian)
-        {
-            return 1 / Math.Tan(radian);
-        }
-
-        /// <summary>
-        /// Trigonometric Cotangent of a <c>Complex</c> number.
-        /// </summary>
-        /// <param name="value">
-        /// The complex value.
-        /// </param>
-        /// <returns>
-        /// The cotangent of the complex number.
-        /// </returns>
-        public static Complex Cotangent(this Complex value)
-        {
-            if (value.IsReal())
-            {
-                return new Complex(Cotangent(value.Real), 0d);
-            }
-
-            var sinr = Sine(value.Real);
-            var sinhi = HyperbolicSine(value.Imaginary);
-            var denom = (sinr * sinr) + (sinhi * sinhi);
-
-            return new Complex(sinr * Cosine(value.Real) / denom, -sinhi * HyperbolicCosine(value.Imaginary) / denom);
-        }
-
         /// <summary>
         /// Converts a degree (360-periodic) angle to a grad (400-periodic) angle.
         /// </summary>
@@ -212,295 +103,282 @@ namespace MathNet.Numerics
         }
 
         /// <summary>
-        /// Trigonometric Hyperbolic Cosecant
+        /// Converts a radian (2*Pi-periodic) angle to a degree (360-periodic) angle.
+        /// </summary>
+        /// <param name="radian">
+        /// The radian to convert.
+        /// </param>
+        /// <returns>
+        /// The converted degree.
+        /// </returns>
+        public static double RadianToDegree(double radian)
+        {
+            return radian / Constants.Degree;
+        }
+
+        /// <summary>
+        /// Converts a radian (2*Pi-periodic) angle to a grad (400-periodic) angle.
+        /// </summary>
+        /// <param name="radian">
+        /// The radian to convert.
+        /// </param>
+        /// <returns>
+        /// The converted grad.
+        /// </returns>
+        public static double RadianToGrad(double radian)
+        {
+            return radian / Constants.Grad;
+        }
+
+        /// <summary>
+        /// Trigonometric Sine of an angle in radian
         /// </summary>
         /// <param name="radian">
         /// The angle in radian.
         /// </param>
         /// <returns>
-        /// The hyperbolic cosecant of the radian angle.
+        /// The sine of the radian angle.
         /// </returns>
-        public static double HyperbolicCosecant(double radian)
+        public static double Sine(double radian)
         {
-            return 1 / HyperbolicSine(radian);
+            return Math.Sin(radian);
         }
 
         /// <summary>
-        /// Trigonometric Hyperbolic Cosecant of a <c>Complex</c> number.
+        /// Trigonometric Sine of a <c>Complex</c> number.
         /// </summary>
         /// <param name="value">
         /// The complex value.
         /// </param>
         /// <returns>
-        /// The hyperbolic cosecant of a complex number.
+        /// The sine of the complex number.
         /// </returns>
-        public static Complex HyperbolicCosecant(this Complex value)
+        public static Complex Sine(this Complex value)
         {
             if (value.IsReal())
             {
-                return new Complex(HyperbolicCosecant(value.Real), 0.0);
-            }
-
-            var exp = value.Exponential();
-
-            if (exp.IsInfinity())
-            {
-                return Complex.Zero;
+                return new Complex(Sine(value.Real), 0.0);
             }
 
-            return 2 * exp / (exp.Square() - 1);
+            return new Complex(
+                Sine(value.Real) * HyperbolicCosine(value.Imaginary),
+                Cosine(value.Real) * HyperbolicSine(value.Imaginary));
         }
 
         /// <summary>
-        /// Trigonometric Hyperbolic Cosine
+        /// Trigonometric Cosine of an angle in radian.
         /// </summary>
         /// <param name="radian">
         /// The angle in radian.
         /// </param>
         /// <returns>
-        /// The hyperbolic Cosine of the radian angle.
+        /// The cosine of an angle in radian.
         /// </returns>
-        public static double HyperbolicCosine(double radian)
+        public static double Cosine(double radian)
         {
-            return (Math.Exp(radian) + Math.Exp(-radian)) / 2;
+            return Math.Cos(radian);
         }
 
         /// <summary>
-        /// Trigonometric Hyperbolic Cosine of a <c>Complex</c> number.
+        /// Trigonometric Cosine of a <c>Complex</c> number.
         /// </summary>
         /// <param name="value">
         /// The complex value.
         /// </param>
         /// <returns>
-        /// The hyperbolic cosine of a complex number.
+        /// The cosine of a complex number.
         /// </returns>
-        public static Complex HyperbolicCosine(this Complex value)
+        public static Complex Cosine(this Complex value)
         {
             if (value.IsReal())
             {
-                return new Complex(HyperbolicCosine(value.Real), 0.0);
+                return new Complex(Cosine(value.Real), 0.0);
             }
 
             return new Complex(
-                HyperbolicCosine(value.Real) * Cosine(value.Imaginary),
-                HyperbolicSine(value.Real) * Sine(value.Imaginary));
+                Cosine(value.Real) * HyperbolicCosine(value.Imaginary),
+                -Sine(value.Real) * HyperbolicSine(value.Imaginary));
         }
 
         /// <summary>
-        /// Trigonometric Hyperbolic Cotangent
+        /// Trigonometric Tangent of an angle in radian
         /// </summary>
         /// <param name="radian">
-        /// The angle in radian angle.
+        /// The angle in radian.
         /// </param>
         /// <returns>
-        /// The hyperbolic cotangent of the radian angle.
+        /// The tangent of the radian angle.
         /// </returns>
-        public static double HyperbolicCotangent(double radian)
+        public static double Tangent(double radian)
         {
-            if (radian > 19.115)
-            {
-                return 1.0;
-            }
-
-            if (radian < -19.115)
-            {
-                return -1;
-            }
-
-            var e1 = Math.Exp(radian);
-            var e2 = Math.Exp(-radian);
-            return (e1 + e2) / (e1 - e2);
+            return Math.Tan(radian);
         }
 
         /// <summary>
-        /// Trigonometric Hyperbolic Cotangent of a <c>Complex</c> number.
+        /// Trigonometric Tangent of a <c>Complex</c> number.
         /// </summary>
         /// <param name="value">
         /// The complex value.
         /// </param>
         /// <returns>
-        /// The hyperbolic cotangent of a complex number.
+        /// The tangent of the complex number.
         /// </returns>
-        public static Complex HyperbolicCotangent(this Complex value)
+        public static Complex Tangent(this Complex value)
         {
             if (value.IsReal())
             {
-                return new Complex(HyperbolicCotangent(value.Real), 0.0);
-            }
-
-            var sini = Sine(value.Imaginary);
-            var sinhr = HyperbolicSine(value.Real);
-
-            if (double.IsInfinity(sinhr))
-            {
-                return new Complex(double.IsPositiveInfinity(sinhr) ? 1 : -1, 0.0);
+                return new Complex(Tangent(value.Real), 0.0);
             }
 
-            var denom = (sini * sini) + (sinhr * sinhr);
+            var cosr = Cosine(value.Real);
+            var sinhi = HyperbolicSine(value.Imaginary);
+            var denom = (cosr * cosr) + (sinhi * sinhi);
 
-            return new Complex(sinhr * HyperbolicCosine(value.Real) / denom, sini * Cosine(value.Imaginary) / denom);
+            return new Complex(Sine(value.Real) * cosr / denom, sinhi * HyperbolicCosine(value.Imaginary) / denom);
         }
 
         /// <summary>
-        /// Trigonometric Hyperbolic Secant
+        /// Trigonometric Cotangent of an angle in radian.
         /// </summary>
         /// <param name="radian">
-        /// The angle in radian angle.
+        /// The angle in radian.
         /// </param>
         /// <returns>
-        /// The hyperbolic secant of the radian angle.
+        /// The cotangent of an angle in radian.
         /// </returns>
-        public static double HyperbolicSecant(double radian)
+        public static double Cotangent(double radian)
         {
-            return 1 / HyperbolicCosine(radian);
+            return 1 / Math.Tan(radian);
         }
 
         /// <summary>
-        /// Trigonometric Hyperbolic Secant of a <c>Complex</c> number.
+        /// Trigonometric Cotangent of a <c>Complex</c> number.
         /// </summary>
         /// <param name="value">
         /// The complex value.
         /// </param>
         /// <returns>
-        /// The hyperbolic secant of a complex number.
+        /// The cotangent of the complex number.
         /// </returns>
-        public static Complex HyperbolicSecant(this Complex value)
+        public static Complex Cotangent(this Complex value)
         {
             if (value.IsReal())
             {
-                return new Complex(HyperbolicSecant(value.Real), 0.0);
+                return new Complex(Cotangent(value.Real), 0d);
             }
 
-            var exp = value.Exponential();
-
-            if (exp.IsInfinity())
-            {
-                return Complex.Zero;
-            }
+            var sinr = Sine(value.Real);
+            var sinhi = HyperbolicSine(value.Imaginary);
+            var denom = (sinr * sinr) + (sinhi * sinhi);
 
-            return 2 * exp / (exp.Square() + 1);
+            return new Complex(sinr * Cosine(value.Real) / denom, -sinhi * HyperbolicCosine(value.Imaginary) / denom);
         }
 
         /// <summary>
-        /// Trigonometric Hyperbolic Sine
+        /// Trigonometric Secant of an angle in radian
         /// </summary>
         /// <param name="radian">
-        /// The angle in radian angle.
+        /// The angle in radian.
         /// </param>
         /// <returns>
-        /// The hyperbolic sine of the radian angle.
+        /// The secant of the radian angle.
         /// </returns>
-        public static double HyperbolicSine(double radian)
+        public static double Secant(double radian)
         {
-            return (Math.Exp(radian) - Math.Exp(-radian)) / 2;
+            return 1 / Math.Cos(radian);
         }
 
         /// <summary>
-        /// Trigonometric Hyperbolic Sine of a <c>Complex</c> number.
+        /// Trigonometric Secant of a <c>Complex</c> number.
         /// </summary>
         /// <param name="value">
         /// The complex value.
         /// </param>
         /// <returns>
-        /// The hyperbolic sine of a complex number.
+        /// The secant of the complex number.
         /// </returns>
-        public static Complex HyperbolicSine(this Complex value)
+        public static Complex Secant(this Complex value)
         {
             if (value.IsReal())
             {
-                return new Complex(HyperbolicSine(value.Real), 0.0);
+                return new Complex(Secant(value.Real), 0d);
             }
 
-            return new Complex(
-                HyperbolicSine(value.Real) * Cosine(value.Imaginary),
-                HyperbolicCosine(value.Real) * Sine(value.Imaginary));
+            var cosr = Cosine(value.Real);
+            var sinhi = HyperbolicSine(value.Imaginary);
+            var denom = (cosr * cosr) + (sinhi * sinhi);
+
+            return new Complex(cosr * HyperbolicCosine(value.Imaginary) / denom, Sine(value.Real) * sinhi / denom);
         }
 
         /// <summary>
-        /// Trigonometric Hyperbolic Tangent in radian
+        /// Trigonometric Cosecant of an angle in radian.
         /// </summary>
         /// <param name="radian">
-        /// The angle in radian angle.
+        /// The angle in radian.
         /// </param>
         /// <returns>
-        /// The hyperbolic tangent of the radian angle.
+        /// Cosecant of an angle in radian.
         /// </returns>
-        public static double HyperbolicTangent(double radian)
+        public static double Cosecant(double radian)
         {
-            if (radian > 19.1)
-            {
-                return 1.0;
-            }
-
-            if (radian < -19.1)
-            {
-                return -1;
-            }
-
-            var e1 = Math.Exp(radian);
-            var e2 = Math.Exp(-radian);
-            return (e1 - e2) / (e1 + e2);
+            return 1 / Math.Sin(radian);
         }
 
         /// <summary>
-        /// Trigonometric Hyperbolic Tangent of a <c>Complex</c> number.
+        /// Trigonometric Cosecant of a <c>Complex</c> number.
         /// </summary>
         /// <param name="value">
         /// The complex value.
         /// </param>
         /// <returns>
-        /// The hyperbolic tangent of a complex number.
+        /// The cosecant of a complex number.
         /// </returns>
-        public static Complex HyperbolicTangent(this Complex value)
+        public static Complex Cosecant(this Complex value)
         {
             if (value.IsReal())
             {
-                return new Complex(HyperbolicTangent(value.Real), 0.0);
-            }
-
-            var cosi = Cosine(value.Imaginary);
-            var sinhr = HyperbolicSine(value.Real);
-
-            if (double.IsInfinity(sinhr))
-            {
-                return new Complex(double.IsPositiveInfinity(sinhr) ? 1 : -1, 0.0);
+                return new Complex(Cosecant(value.Real), 0d);
             }
 
-            var denom = (cosi * cosi) + (sinhr * sinhr);
+            var sinr = Sine(value.Real);
+            var sinhi = HyperbolicSine(value.Imaginary);
+            var denom = (sinr * sinr) + (sinhi * sinhi);
 
-            return new Complex(HyperbolicCosine(value.Real) * sinhr / denom, cosi * Sine(value.Imaginary) / denom);
+            return new Complex(sinr * HyperbolicCosine(value.Imaginary) / denom, -Cosine(value.Real) * sinhi / denom);
         }
 
         /// <summary>
-        /// Trigonometric Arc Cosecant in radian
+        /// Trigonometric Arc Sine in radian
         /// </summary>
         /// <param name="radian">
         /// The angle in radian angle.
         /// </param>
         /// <returns>
-        /// The inverse cosecant of the radian angle.
+        /// The inverse sine of the radian angle.
         /// </returns>
-        /// <exception cref="ArgumentOutOfRangeException">
-        /// if -1 &lt; <paramref name="radian"/> &lt; 1.
-        /// </exception>
-        public static double InverseCosecant(double radian)
+        public static double InverseSine(double radian)
         {
-            return Math.Asin(1 / radian);
+            return Math.Asin(radian);
         }
 
         /// <summary>
-        /// Trigonometric Arc Cosecant of this <c>Complex</c> number.
+        /// Trigonometric Arc Sine of this <c>Complex</c> number.
         /// </summary>
         /// <param name="value">
         /// The complex value.
         /// </param>
         /// <returns>
-        /// The arc cosecant of a complex number.
+        /// The arc sine of a complex number.
         /// </returns>
-        public static Complex InverseCosecant(this Complex value)
+        public static Complex InverseSine(this Complex value)
         {
-            var inv = 1 / value;
-            return -Complex.ImaginaryOne * ((Complex.ImaginaryOne * inv) + (1 - inv.Square()).SquareRoot()).NaturalLogarithm();
+            if (value.Imaginary > 0 || value.Imaginary == 0d && value.Real < 0)
+            {
+                return -InverseSine(-value);
+            }
+
+            return -Complex.ImaginaryOne * ((1 - value.Square()).SquareRoot() + (Complex.ImaginaryOne * value)).NaturalLogarithm();
         }
 
         /// <summary>
@@ -539,6 +417,35 @@ namespace MathNet.Numerics
             return -Complex.ImaginaryOne * (value + (Complex.ImaginaryOne * (1 - value.Square()).SquareRoot())).NaturalLogarithm();
         }
 
+        /// <summary>
+        /// Trigonometric Arc Tangent  in radian
+        /// </summary>
+        /// <param name="radian">
+        /// The angle in radian angle.
+        /// </param>
+        /// <returns>
+        /// The inverse tangent of the radian angle.
+        /// </returns>
+        public static double InverseTangent(double radian)
+        {
+            return Math.Atan(radian);
+        }
+
+        /// <summary>
+        /// Trigonometric Arc Tangent of this <c>Complex</c> number.
+        /// </summary>
+        /// <param name="value">
+        /// The complex value.
+        /// </param>
+        /// <returns>
+        /// The arc tangent of a complex number.
+        /// </returns>
+        public static Complex InverseTangent(this Complex value)
+        {
+            var iz = new Complex(-value.Imaginary, value.Real); // I*this
+            return new Complex(0, 0.5) * ((1 - iz).NaturalLogarithm() - (1 + iz).NaturalLogarithm());
+        }
+
         /// <summary>
         /// Trigonometric Arc Cotangent in radian
         /// </summary>
@@ -574,402 +481,495 @@ namespace MathNet.Numerics
         }
 
         /// <summary>
-        /// Trigonometric Hyperbolic Arc Cosecant
+        /// Trigonometric Arc Secant in radian
         /// </summary>
         /// <param name="radian">
         /// The angle in radian angle.
         /// </param>
         /// <returns>
-        /// The inverse hyperbolic cosecant of the radian angle.
+        /// The inverse secant of the radian angle.
         /// </returns>
-        public static double InverseHyperbolicCosecant(double radian)
+        public static double InverseSecant(double radian)
         {
-            return InverseHyperbolicSine(1 / radian);
+            return Math.Acos(1 / radian);
         }
 
         /// <summary>
-        /// Trigonometric Hyperbolic Arc Cosecant of this <c>Complex</c> number.
+        /// Trigonometric Arc Secant of this <c>Complex</c> number.
         /// </summary>
         /// <param name="value">
         /// The complex value.
         /// </param>
         /// <returns>
-        /// The hyperbolic arc cosecant of a complex number.
+        /// The arc secant of a complex number.
         /// </returns>
-        public static Complex InverseHyperbolicCosecant(this Complex value)
+        public static Complex InverseSecant(this Complex value)
         {
             var inv = 1 / value;
-            return (inv + (inv.Square() + 1).SquareRoot()).NaturalLogarithm();
+            return -Complex.ImaginaryOne * (inv + (Complex.ImaginaryOne * (1 - inv.Square()).SquareRoot())).NaturalLogarithm();
         }
 
         /// <summary>
-        /// Trigonometric Hyperbolic Area Cosine
+        /// Trigonometric Arc Cosecant in radian
         /// </summary>
         /// <param name="radian">
         /// The angle in radian angle.
         /// </param>
         /// <returns>
-        /// The inverse hyperbolic cosine of the radian angle.
+        /// The inverse cosecant of the radian angle.
         /// </returns>
-        public static double InverseHyperbolicCosine(double radian)
+        /// <exception cref="ArgumentOutOfRangeException">
+        /// if -1 &lt; <paramref name="radian"/> &lt; 1.
+        /// </exception>
+        public static double InverseCosecant(double radian)
         {
-            return Math.Log(radian + (Math.Sqrt(radian - 1) * Math.Sqrt(radian + 1)), Math.E);
+            return Math.Asin(1 / radian);
         }
 
         /// <summary>
-        /// Trigonometric Hyperbolic Arc Cosine of this <c>Complex</c> number.
+        /// Trigonometric Arc Cosecant of this <c>Complex</c> number.
         /// </summary>
         /// <param name="value">
         /// The complex value.
         /// </param>
         /// <returns>
-        /// The hyperbolic arc cosine of a complex number.
+        /// The arc cosecant of a complex number.
         /// </returns>
-        public static Complex InverseHyperbolicCosine(this Complex value)
+        public static Complex InverseCosecant(this Complex value)
         {
-            return (value + ((value - 1).SquareRoot() * (value + 1).SquareRoot())).NaturalLogarithm();
+            var inv = 1 / value;
+            return -Complex.ImaginaryOne * ((Complex.ImaginaryOne * inv) + (1 - inv.Square()).SquareRoot()).NaturalLogarithm();
         }
 
         /// <summary>
-        /// Trigonometric Hyperbolic Arc Cotangent
+        /// Trigonometric Hyperbolic Sine
         /// </summary>
         /// <param name="radian">
         /// The angle in radian angle.
         /// </param>
         /// <returns>
-        /// The inverse hyperbolic cotangent of the radian angle.
+        /// The hyperbolic sine of the radian angle.
         /// </returns>
-        public static double InverseHyperbolicCotangent(double radian)
+        public static double HyperbolicSine(double radian)
         {
-            return 0.5 * Math.Log((radian + 1) / (radian - 1), Math.E);
+            return (Math.Exp(radian) - Math.Exp(-radian)) / 2;
         }
 
         /// <summary>
-        /// Trigonometric Hyperbolic Arc Cotangent of this <c>Complex</c> number.
+        /// Trigonometric Hyperbolic Sine of a <c>Complex</c> number.
         /// </summary>
         /// <param name="value">
         /// The complex value.
         /// </param>
         /// <returns>
-        /// The hyperbolic arc cotangent of a complex number.
+        /// The hyperbolic sine of a complex number.
         /// </returns>
-        public static Complex InverseHyperbolicCotangent(this Complex value)
+        public static Complex HyperbolicSine(this Complex value)
         {
-            var inv = 1.0 / value;
-            return 0.5 * ((1.0 + inv).NaturalLogarithm() - (1.0 - inv).NaturalLogarithm());
+            if (value.IsReal())
+            {
+                return new Complex(HyperbolicSine(value.Real), 0.0);
+            }
+
+            return new Complex(
+                HyperbolicSine(value.Real) * Cosine(value.Imaginary),
+                HyperbolicCosine(value.Real) * Sine(value.Imaginary));
         }
 
         /// <summary>
-        /// Trigonometric Hyperbolic Area Secant
+        /// Trigonometric Hyperbolic Cosine
+        /// </summary>
+        /// <param name="radian">
+        /// The angle in radian.
+        /// </param>
+        /// <returns>
+        /// The hyperbolic Cosine of the radian angle.
+        /// </returns>
+        public static double HyperbolicCosine(double radian)
+        {
+            return (Math.Exp(radian) + Math.Exp(-radian)) / 2;
+        }
+
+        /// <summary>
+        /// Trigonometric Hyperbolic Cosine of a <c>Complex</c> number.
+        /// </summary>
+        /// <param name="value">
+        /// The complex value.
+        /// </param>
+        /// <returns>
+        /// The hyperbolic cosine of a complex number.
+        /// </returns>
+        public static Complex HyperbolicCosine(this Complex value)
+        {
+            if (value.IsReal())
+            {
+                return new Complex(HyperbolicCosine(value.Real), 0.0);
+            }
+
+            return new Complex(
+                HyperbolicCosine(value.Real) * Cosine(value.Imaginary),
+                HyperbolicSine(value.Real) * Sine(value.Imaginary));
+        }
+
+        /// <summary>
+        /// Trigonometric Hyperbolic Tangent in radian
         /// </summary>
         /// <param name="radian">
         /// The angle in radian angle.
         /// </param>
         /// <returns>
-        /// The inverse hyperbolic secant of the radian angle.
+        /// The hyperbolic tangent of the radian angle.
         /// </returns>
-        public static double InverseHyperbolicSecant(double radian)
+        public static double HyperbolicTangent(double radian)
         {
-            return InverseHyperbolicCosine(1 / radian);
+            if (radian > 19.1)
+            {
+                return 1.0;
+            }
+
+            if (radian < -19.1)
+            {
+                return -1;
+            }
+
+            var e1 = Math.Exp(radian);
+            var e2 = Math.Exp(-radian);
+            return (e1 - e2) / (e1 + e2);
         }
 
         /// <summary>
-        /// Trigonometric Hyperbolic Arc Secant of this <c>Complex</c> number.
+        /// Trigonometric Hyperbolic Tangent of a <c>Complex</c> number.
         /// </summary>
         /// <param name="value">
         /// The complex value.
         /// </param>
         /// <returns>
-        /// The hyperbolic arc secant of a complex number.
+        /// The hyperbolic tangent of a complex number.
         /// </returns>
-        public static Complex InverseHyperbolicSecant(this Complex value)
+        public static Complex HyperbolicTangent(this Complex value)
         {
-            var inv = 1 / value;
-            return (inv + ((inv - 1).SquareRoot() * (inv + 1).SquareRoot())).NaturalLogarithm();
+            if (value.IsReal())
+            {
+                return new Complex(HyperbolicTangent(value.Real), 0.0);
+            }
+
+            var cosi = Cosine(value.Imaginary);
+            var sinhr = HyperbolicSine(value.Real);
+
+            if (double.IsInfinity(sinhr))
+            {
+                return new Complex(double.IsPositiveInfinity(sinhr) ? 1 : -1, 0.0);
+            }
+
+            var denom = (cosi * cosi) + (sinhr * sinhr);
+
+            return new Complex(HyperbolicCosine(value.Real) * sinhr / denom, cosi * Sine(value.Imaginary) / denom);
         }
 
         /// <summary>
-        /// Trigonometric Hyperbolic Area Sine
+        /// Trigonometric Hyperbolic Cotangent
         /// </summary>
         /// <param name="radian">
         /// The angle in radian angle.
         /// </param>
         /// <returns>
-        /// The inverse hyperbolic sine of the radian angle.
+        /// The hyperbolic cotangent of the radian angle.
         /// </returns>
-        public static double InverseHyperbolicSine(double radian)
+        public static double HyperbolicCotangent(double radian)
         {
-            return Math.Log(radian + Math.Sqrt((radian * radian) + 1), Math.E);
+            if (radian > 19.115)
+            {
+                return 1.0;
+            }
+
+            if (radian < -19.115)
+            {
+                return -1;
+            }
+
+            var e1 = Math.Exp(radian);
+            var e2 = Math.Exp(-radian);
+            return (e1 + e2) / (e1 - e2);
         }
 
         /// <summary>
-        /// Trigonometric Hyperbolic Arc Sine of this <c>Complex</c> number.
+        /// Trigonometric Hyperbolic Cotangent of a <c>Complex</c> number.
         /// </summary>
         /// <param name="value">
         /// The complex value.
         /// </param>
         /// <returns>
-        /// The hyperbolic arc sine of a complex number.
+        /// The hyperbolic cotangent of a complex number.
         /// </returns>
-        public static Complex InverseHyperbolicSine(this Complex value)
+        public static Complex HyperbolicCotangent(this Complex value)
         {
-            return (value + (value.Square() + 1).SquareRoot()).NaturalLogarithm();
+            if (value.IsReal())
+            {
+                return new Complex(HyperbolicCotangent(value.Real), 0.0);
+            }
+
+            var sini = Sine(value.Imaginary);
+            var sinhr = HyperbolicSine(value.Real);
+
+            if (double.IsInfinity(sinhr))
+            {
+                return new Complex(double.IsPositiveInfinity(sinhr) ? 1 : -1, 0.0);
+            }
+
+            var denom = (sini * sini) + (sinhr * sinhr);
+
+            return new Complex(sinhr * HyperbolicCosine(value.Real) / denom, sini * Cosine(value.Imaginary) / denom);
         }
 
         /// <summary>
-        /// Trigonometric Hyperbolic Area Tangent
+        /// Trigonometric Hyperbolic Secant
         /// </summary>
         /// <param name="radian">
         /// The angle in radian angle.
         /// </param>
         /// <returns>
-        /// The inverse hyperbolic tangent of the radian angle.
+        /// The hyperbolic secant of the radian angle.
         /// </returns>
-        public static double InverseHyperbolicTangent(double radian)
+        public static double HyperbolicSecant(double radian)
         {
-            return 0.5 * Math.Log((1 + radian) / (1 - radian), Math.E);
+            return 1 / HyperbolicCosine(radian);
         }
 
         /// <summary>
-        /// Trigonometric Hyperbolic Arc Tangent of this <c>Complex</c> number.
+        /// Trigonometric Hyperbolic Secant of a <c>Complex</c> number.
         /// </summary>
         /// <param name="value">
         /// The complex value.
         /// </param>
         /// <returns>
-        /// The hyperbolic arc tangent of a complex number.
+        /// The hyperbolic secant of a complex number.
         /// </returns>
-        public static Complex InverseHyperbolicTangent(this Complex value)
+        public static Complex HyperbolicSecant(this Complex value)
         {
-            return 0.5 * ((1 + value).NaturalLogarithm() - (1 - value).NaturalLogarithm());
+            if (value.IsReal())
+            {
+                return new Complex(HyperbolicSecant(value.Real), 0.0);
+            }
+
+            var exp = value.Exponential();
+
+            if (exp.IsInfinity())
+            {
+                return Complex.Zero;
+            }
+
+            return 2 * exp / (exp.Square() + 1);
         }
 
         /// <summary>
-        /// Trigonometric Arc Secant in radian
+        /// Trigonometric Hyperbolic Arc Cosecant
         /// </summary>
         /// <param name="radian">
         /// The angle in radian angle.
         /// </param>
         /// <returns>
-        /// The inverse secant of the radian angle.
+        /// The inverse hyperbolic cosecant of the radian angle.
         /// </returns>
-        public static double InverseSecant(double radian)
+        public static double InverseHyperbolicCosecant(double radian)
         {
-            return Math.Acos(1 / radian);
+            return InverseHyperbolicSine(1 / radian);
         }
 
         /// <summary>
-        /// Trigonometric Arc Secant of this <c>Complex</c> number.
+        /// Trigonometric Hyperbolic Arc Cosecant of this <c>Complex</c> number.
         /// </summary>
         /// <param name="value">
         /// The complex value.
         /// </param>
         /// <returns>
-        /// The arc secant of a complex number.
+        /// The hyperbolic arc cosecant of a complex number.
         /// </returns>
-        public static Complex InverseSecant(this Complex value)
+        public static Complex InverseHyperbolicCosecant(this Complex value)
         {
             var inv = 1 / value;
-            return -Complex.ImaginaryOne * (inv + (Complex.ImaginaryOne * (1 - inv.Square()).SquareRoot())).NaturalLogarithm();
+            return (inv + (inv.Square() + 1).SquareRoot()).NaturalLogarithm();
         }
 
         /// <summary>
-        /// Trigonometric Arc Sine in radian
+        /// Trigonometric Hyperbolic Area Sine
         /// </summary>
         /// <param name="radian">
         /// The angle in radian angle.
         /// </param>
         /// <returns>
-        /// The inverse sine of the radian angle.
+        /// The inverse hyperbolic sine of the radian angle.
         /// </returns>
-        public static double InverseSine(double radian)
+        public static double InverseHyperbolicSine(double radian)
         {
-            return Math.Asin(radian);
+            return Math.Log(radian + Math.Sqrt((radian * radian) + 1), Math.E);
         }
 
         /// <summary>
-        /// Trigonometric Arc Sine of this <c>Complex</c> number.
+        /// Trigonometric Hyperbolic Arc Sine of this <c>Complex</c> number.
         /// </summary>
         /// <param name="value">
         /// The complex value.
         /// </param>
         /// <returns>
-        /// The arc sine of a complex number.
+        /// The hyperbolic arc sine of a complex number.
         /// </returns>
-        public static Complex InverseSine(this Complex value)
+        public static Complex InverseHyperbolicSine(this Complex value)
         {
-            if (value.Imaginary > 0 || value.Imaginary == 0d && value.Real < 0)
-            {
-                return -InverseSine(-value);
-            }
-
-            return -Complex.ImaginaryOne * ((1 - value.Square()).SquareRoot() + (Complex.ImaginaryOne * value)).NaturalLogarithm();
+            return (value + (value.Square() + 1).SquareRoot()).NaturalLogarithm();
         }
 
         /// <summary>
-        /// Trigonometric Arc Tangent  in radian
+        /// Trigonometric Hyperbolic Area Cosine
         /// </summary>
         /// <param name="radian">
         /// The angle in radian angle.
         /// </param>
         /// <returns>
-        /// The inverse tangent of the radian angle.
+        /// The inverse hyperbolic cosine of the radian angle.
         /// </returns>
-        public static double InverseTangent(double radian)
+        public static double InverseHyperbolicCosine(double radian)
         {
-            return Math.Atan(radian);
+            return Math.Log(radian + (Math.Sqrt(radian - 1) * Math.Sqrt(radian + 1)), Math.E);
         }
 
         /// <summary>
-        /// Trigonometric Arc Tangent of this <c>Complex</c> number.
+        /// Trigonometric Hyperbolic Arc Cosine of this <c>Complex</c> number.
         /// </summary>
         /// <param name="value">
         /// The complex value.
         /// </param>
         /// <returns>
-        /// The arc tangent of a complex number.
+        /// The hyperbolic arc cosine of a complex number.
         /// </returns>
-        public static Complex InverseTangent(this Complex value)
+        public static Complex InverseHyperbolicCosine(this Complex value)
         {
-            var iz = new Complex(-value.Imaginary, value.Real); // I*this
-            return new Complex(0, 0.5) * ((1 - iz).NaturalLogarithm() - (1 + iz).NaturalLogarithm());
+            return (value + ((value - 1).SquareRoot() * (value + 1).SquareRoot())).NaturalLogarithm();
         }
 
         /// <summary>
-        /// Converts a radian (2*Pi-periodic) angle to a degree (360-periodic) angle.
+        /// Trigonometric Hyperbolic Area Tangent
         /// </summary>
         /// <param name="radian">
-        /// The radian to convert.
+        /// The angle in radian angle.
         /// </param>
         /// <returns>
-        /// The converted degree.
+        /// The inverse hyperbolic tangent of the radian angle.
         /// </returns>
-        public static double RadianToDegree(double radian)
+        public static double InverseHyperbolicTangent(double radian)
         {
-            return radian / Constants.Degree;
+            return 0.5 * Math.Log((1 + radian) / (1 - radian), Math.E);
         }
 
         /// <summary>
-        /// Converts a radian (2*Pi-periodic) angle to a grad (400-periodic) angle.
+        /// Trigonometric Hyperbolic Arc Tangent of this <c>Complex</c> number.
         /// </summary>
-        /// <param name="radian">
-        /// The radian to convert.
+        /// <param name="value">
+        /// The complex value.
         /// </param>
         /// <returns>
-        /// The converted grad.
+        /// The hyperbolic arc tangent of a complex number.
         /// </returns>
-        public static double RadianToGrad(double radian)
+        public static Complex InverseHyperbolicTangent(this Complex value)
         {
-            return radian / Constants.Grad;
+            return 0.5 * ((1 + value).NaturalLogarithm() - (1 - value).NaturalLogarithm());
         }
 
         /// <summary>
-        /// Trigonometric Secant of an angle in radian
+        /// Trigonometric Hyperbolic Arc Cotangent
         /// </summary>
         /// <param name="radian">
-        /// The angle in radian.
+        /// The angle in radian angle.
         /// </param>
         /// <returns>
-        /// The secant of the radian angle.
+        /// The inverse hyperbolic cotangent of the radian angle.
         /// </returns>
-        public static double Secant(double radian)
+        public static double InverseHyperbolicCotangent(double radian)
         {
-            return 1 / Math.Cos(radian);
+            return 0.5 * Math.Log((radian + 1) / (radian - 1), Math.E);
         }
 
         /// <summary>
-        /// Trigonometric Secant of a <c>Complex</c> number.
+        /// Trigonometric Hyperbolic Arc Cotangent of this <c>Complex</c> number.
         /// </summary>
         /// <param name="value">
         /// The complex value.
         /// </param>
         /// <returns>
-        /// The secant of the complex number.
+        /// The hyperbolic arc cotangent of a complex number.
         /// </returns>
-        public static Complex Secant(this Complex value)
+        public static Complex InverseHyperbolicCotangent(this Complex value)
         {
-            if (value.IsReal())
-            {
-                return new Complex(Secant(value.Real), 0d);
-            }
-
-            var cosr = Cosine(value.Real);
-            var sinhi = HyperbolicSine(value.Imaginary);
-            var denom = (cosr * cosr) + (sinhi * sinhi);
-
-            return new Complex(cosr * HyperbolicCosine(value.Imaginary) / denom, Sine(value.Real) * sinhi / denom);
+            var inv = 1.0 / value;
+            return 0.5 * ((1.0 + inv).NaturalLogarithm() - (1.0 - inv).NaturalLogarithm());
         }
 
         /// <summary>
-        /// Trigonometric Sine of an angle in radian
+        /// Trigonometric Hyperbolic Area Secant
         /// </summary>
         /// <param name="radian">
-        /// The angle in radian.
+        /// The angle in radian angle.
         /// </param>
         /// <returns>
-        /// The sine of the radian angle.
+        /// The inverse hyperbolic secant of the radian angle.
         /// </returns>
-        public static double Sine(double radian)
+        public static double InverseHyperbolicSecant(double radian)
         {
-            return Math.Sin(radian);
+            return InverseHyperbolicCosine(1 / radian);
         }
 
         /// <summary>
-        /// Trigonometric Sine of a <c>Complex</c> number.
+        /// Trigonometric Hyperbolic Arc Secant of this <c>Complex</c> number.
         /// </summary>
         /// <param name="value">
         /// The complex value.
         /// </param>
         /// <returns>
-        /// The sine of the complex number.
+        /// The hyperbolic arc secant of a complex number.
         /// </returns>
-        public static Complex Sine(this Complex value)
+        public static Complex InverseHyperbolicSecant(this Complex value)
         {
-            if (value.IsReal())
-            {
-                return new Complex(Sine(value.Real), 0.0);
-            }
-
-            return new Complex(
-                Sine(value.Real) * HyperbolicCosine(value.Imaginary),
-                Cosine(value.Real) * HyperbolicSine(value.Imaginary));
+            var inv = 1 / value;
+            return (inv + ((inv - 1).SquareRoot() * (inv + 1).SquareRoot())).NaturalLogarithm();
         }
 
         /// <summary>
-        /// Trigonometric Tangent of an angle in radian
+        /// Trigonometric Hyperbolic Cosecant
         /// </summary>
         /// <param name="radian">
         /// The angle in radian.
         /// </param>
         /// <returns>
-        /// The tangent of the radian angle.
+        /// The hyperbolic cosecant of the radian angle.
         /// </returns>
-        public static double Tangent(double radian)
+        public static double HyperbolicCosecant(double radian)
         {
-            return Math.Tan(radian);
+            return 1 / HyperbolicSine(radian);
         }
 
         /// <summary>
-        /// Trigonometric Tangent of a <c>Complex</c> number.
+        /// Trigonometric Hyperbolic Cosecant of a <c>Complex</c> number.
         /// </summary>
         /// <param name="value">
         /// The complex value.
         /// </param>
         /// <returns>
-        /// The tangent of the complex number.
+        /// The hyperbolic cosecant of a complex number.
         /// </returns>
-        public static Complex Tangent(this Complex value)
+        public static Complex HyperbolicCosecant(this Complex value)
         {
             if (value.IsReal())
             {
-                return new Complex(Tangent(value.Real), 0.0);
+                return new Complex(HyperbolicCosecant(value.Real), 0.0);
             }
 
-            var cosr = Cosine(value.Real);
-            var sinhi = HyperbolicSine(value.Imaginary);
-            var denom = (cosr * cosr) + (sinhi * sinhi);
+            var exp = value.Exponential();
 
-            return new Complex(Sine(value.Real) * cosr / denom, sinhi * HyperbolicCosine(value.Imaginary) / denom);
+            if (exp.IsInfinity())
+            {
+                return Complex.Zero;
+            }
+
+            return 2 * exp / (exp.Square() - 1);
         }
     }
 }
\ No newline at end of file