Beispiel #1
0
        /// <summary>
        /// This function returns the complex hyperbolic arccosine of
        /// the real number a, arccosh(a).
        /// </summary>
        /// <param name="a">Function argument.</param>
        /// <returns>The complex hyperbolic arccosine of
        /// the real number a.</returns>
        public static Complex Acosh(double a)
        {
            Complex z;

            if (a >= 1)
            {
                z = new Complex(RMath.Acosh(a), 0);
            }
            else
            {
                if (a >= -1.0)
                {
                    z = new Complex(0, Math.Acos(a));
                }
                else
                {
                    z = new Complex(RMath.Acosh(-a), M_PI);
                }
            }

            return(z);
        }
Beispiel #2
0
        /// <summary>
        /// This function returns the complex arcsecant of the real number a,
        /// arcsec(a) = arccos(1/a).
        /// </summary>
        /// <param name="a">Function argument.</param>
        /// <returns>The complex arcsecant of the real number a.</returns>
        public static Complex Asec(double a)
        {
            Complex z;

            if (a <= -1.0 || a >= 1.0)
            {
                z = new Complex(Math.Acos(1 / a), 0.0);
            }
            else
            {
                if (a >= 0.0)
                {
                    z = new Complex(0, RMath.Acosh(1 / a));
                }
                else
                {
                    z = new Complex(M_PI, -RMath.Acosh(-1 / a));
                }
            }

            return(z);
        }
Beispiel #3
0
        /// <summary>
        /// This function returns the complex arccosine of the real number a, arccos(a).
        /// </summary>
        /// <param name="a">The function argument.</param>
        /// <returns>The complex arccosine of the real number a.</returns>
        /// <remarks>
        /// For a between -1 and 1, the
        /// function returns a real value in the range [0,pi]. For a
        /// less than -1 the result has a real part of pi/2 and a
        /// negative imaginary part.  For a greater than 1 the result
        /// is purely imaginary and positive.
        /// </remarks>
        public static Complex Acos(double a)
        {
            Complex z;

            if (Math.Abs(a) <= 1.0)
            {
                z = new Complex(Math.Acos(a), 0);
            }
            else
            {
                if (a < 0.0)
                {
                    z = new Complex(Math.PI, -RMath.Acosh(-a));
                }
                else
                {
                    z = new Complex(0, RMath.Acosh(a));
                }
            }

            return(z);
        }
Beispiel #4
0
        //-----------------------------------------------------------------------------------
        //-----------------------------------------------------------------------------------

        /// <summary>
        /// The modulus (length) of the complex number
        /// </summary>
        /// <returns></returns>
        public double GetModulus()
        {
            return(RMath.Hypot(Re, Im));
        }
Beispiel #5
0
        /// <summary>
        /// This function returns the complex arcsine of the complex number a,
        /// arcsin(a)}. The branch cuts are on the real axis, less than -1
        /// and greater than 1.
        /// </summary>
        /// <param name="a">The function argument.</param>
        /// <returns>the complex arcsine of the complex number a.</returns>
        public static Complex Asin(Complex a)
        {
            double  R = a.Re, I = a.Im;
            Complex z;

            if (I == 0)
            {
                z = Asin(R);
            }
            else
            {
                double x = Math.Abs(R), y = Math.Abs(I);
                double r = hypot(x + 1, y), s = hypot(x - 1, y);
                double A  = 0.5 * (r + s);
                double B  = x / A;
                double y2 = y * y;

                double real, imag;

                const double A_crossover = 1.5, B_crossover = 0.6417;

                if (B <= B_crossover)
                {
                    real = Math.Asin(B);
                }
                else
                {
                    if (x <= 1)
                    {
                        double D = 0.5 * (A + x) * (y2 / (r + x + 1) + (s + (1 - x)));
                        real = Math.Atan(x / Math.Sqrt(D));
                    }
                    else
                    {
                        double Apx = A + x;
                        double D   = 0.5 * (Apx / (r + x + 1) + Apx / (s + (x - 1)));
                        real = Math.Atan(x / (y * Math.Sqrt(D)));
                    }
                }

                if (A <= A_crossover)
                {
                    double Am1;

                    if (x < 1)
                    {
                        Am1 = 0.5 * (y2 / (r + (x + 1)) + y2 / (s + (1 - x)));
                    }
                    else
                    {
                        Am1 = 0.5 * (y2 / (r + (x + 1)) + (s + (x - 1)));
                    }

                    imag = RMath.Log1p(Am1 + Math.Sqrt(Am1 * (A + 1)));
                }
                else
                {
                    imag = Math.Log(A + Math.Sqrt(A * A - 1));
                }

                z = new Complex((R >= 0) ? real : -real, (I >= 0) ? imag : -imag);
            }

            return(z);
        }