Return the contangent of a double.

Description

Demo Code

/**   Basic numeric operations not included in standard Java run-time library.
 *
 *   <p>//w  ww . j a  v  a 2  s . c o  m
 *   The binomial methods are modified from those in the Colt library.
 *   </p>
 *
 *   <p>
 *   The following methods for trigonometric functions come from the
 *   Sfun class written by Visual Numerics.
 *   </p>
 *
 *   <ul>
 *   <li>acosh</li>
 *   <li>asinh</li>
 *   <li>atanh</li>
 *   <li>cot</li>
 *   <li>cosh</li>
 *   <li>sinh</li>
 *   <li>tanh</li>
 *   </ul>
 *
 *   <p>
 *   These methods are covered by the following license.
 *   </p>
 *
 * -------------------------------------------------------------------------
 *   $Id: Sfun.java,v 1.1.1.1 1999/03/05 21:43:39 brophy Exp $
 * -------------------------------------------------------------------------
 * Copyright (c) 1997 - 1998 by Visual Numerics, Inc. All rights reserved.
 *
 * Permission to use, copy, modify, and distribute this software is freely
 * granted by Visual Numerics, Inc., provided that the copyright notice
 * above and the following warranty disclaimer are preserved in human
 * readable form.
 *
 * Because this software is licensed free of charge, it is provided
 * "AS IS", with NO WARRANTY.  TO THE EXTENT PERMITTED BY LAW, VNI
 * DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
 * TO ITS PERFORMANCE, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 * VNI WILL NOT BE LIABLE FOR ANY DAMAGES WHATSOEVER ARISING OUT OF THE USE
 * OF OR INABILITY TO USE THIS SOFTWARE, INCLUDING BUT NOT LIMITED TO DIRECT,
 * INDIRECT, SPECIAL, CONSEQUENTIAL, PUNITIVE, AND EXEMPLARY DAMAGES, EVEN
 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
 *
 * -------------------------------------------------------------------------
 */

public class Main{
    public static void main(String[] argv) throws Exception{
        double x = 2.45678;
        System.out.println(cot(x));
    }
    private static final double COT_COEF[] = {
            .240259160982956302509553617744970e+0,
            -.165330316015002278454746025255758e-1,
            -.429983919317240189356476228239895e-4,
            -.159283223327541046023490851122445e-6,
            -.619109313512934872588620579343187e-9,
            -.243019741507264604331702590579575e-11,
            -.956093675880008098427062083100000e-14,
            -.376353798194580580416291539706666e-16,
            -.148166574646746578852176794666666e-18 };
    /**   Return the contangent of a double.
     *
     *   @param   x   The number whose cotangent is desired.
     *
     *   @return      The cotangent.
     *
     *   <p>
     *   This method is a modified version of the one in the
     *   Visual Numerics Sfun class.
     *   </p>
     */

    public static double cot(double x) {
        double ans, ainty, ainty2, prodbg, y, yrem;
        double pi2rec = 0.011619772367581343075535053490057; //  2/PI - 0.625

        y = Math.abs(x);

        // 4.5036e+15 = 1.0/EPSILON_LARGE

        if (y > 4.5036e+15) {
            return Double.NaN;
        }

        // Carefully compute
        // Y * (2/PI) = (AINT(Y) + REM(Y)) * (.625 + PI2REC)
        //      = AINT(.625*Y) + REM(.625*Y) + Y*PI2REC  =  AINT(.625*Y) + Z
        //      = AINT(.625*Y) + AINT(Z) + REM(Z)

        ainty = (int) y;
        yrem = y - ainty;
        prodbg = 0.625D * ainty;
        ainty = (int) prodbg;
        y = (prodbg - ainty) + 0.625D * yrem + y * pi2rec;
        ainty2 = (int) y;
        ainty = ainty + ainty2;
        y = y - ainty2;

        int ifn = (int) (ainty % 2.0);

        if (ifn == 1)
            y = 1.0D - y;

        if (y == 0.0D) {
            ans = Double.POSITIVE_INFINITY;
        }
        // 1.82501e-08 = Math.sqrt(3.0*EPSILON_SMALL)

        else if (y <= 1.82501e-08) {
            ans = 1.0D / y;
        }

        else if (y <= 0.25D) {
            ans = (0.5D + Polynomial.evaluateChebyschev(COT_COEF, 32.0D * y
                    * y - 1.0D))
                    / y;
        }

        else if (y <= 0.5D) {
            ans = (0.5D + Polynomial.evaluateChebyschev(COT_COEF, 8.0D * y
                    * y - 1.0D))
                    / (0.5D * y);

            ans = (ans * ans - 1.0D) * 0.5D / ans;
        }

        else {
            ans = (0.5D + Polynomial.evaluateChebyschev(COT_COEF, 2.0D * y
                    * y - 1.0D))
                    / (0.25D * y);

            //$$$PIB$$$ Is one of the following two lines bogus?

            ans = (ans * ans - 1.0D) * 0.5D / ans;
            ans = (ans * ans - 1.0D) * 0.5D / ans;
        }

        if (x != 0.0D)
            ans = sign(ans, x);

        if (ifn == 1)
            ans = -ans;

        return ans;
    }
    /**   Return sign of an integer.
     *
     *   @param   n   Number whose sign is desired.
     *
     *   @return      -1 if n < 0, 0 if n isn 0, 1 if n > 0.
     */

    public static int sign(int n) {
        if (n > 0) {
            return 1;
        } else if (n < 0) {
            return -1;
        }

        return 0;
    }
    /**   Return sign of a double.
     *
     *   @param   d   double whose sign is desired.
     *
     *   @return      -1 if d < 0, 0 if d is 0, 1 if d > 0.
     */

    public static int sign(double d) {
        if (d > 0.0D) {
            return 1;
        } else if (d < 0.0D) {
            return -1;
        }

        return 0;
    }
    /**   Return the value of a double with the sign of another double.
     *
     *   @param   x   First double.
     *   @param   y   Second double.
     *
     *   @return      x with the sign of y.
     */

    public static double sign(double x, double y) {
        double abs_x = ((x < 0) ? -x : x);

        return (y < 0.0) ? -abs_x : abs_x;
    }
}
Return the contangent of a double. - Java java.lang

Description

Demo Code

Related Tutorials
