Script Programming(스크립트 프로그래밍)

public class Hello {
    public static void main(String[] args) {
        System.out.println("Hello, world!");
        System.out.println("안녕하세요?");
    }
}

// Filename: TestHexView03.java
//
// Compile: javac TestHexView03.java
// Execute: java TestHexView03 [filename]
//
// Date: 2013. 7. 28.

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

public class TestHexView03 {

    public static void printUsage() {
        System.out.println("java TestHexView03 [filename]");
    }
    
    public static String toHex(byte b) {
        String s = "";
        int x1, x2;
        x1 = (b & 0xF0) >> 4;
        x2 = b & 0x0F;
        if (x1 < 10)
            s += (char)('0' + x1);
        else
            s += (char)((x1 - 10) + 'A');
        if (x2 < 10)
            s += (char)('0' + x2);
        else
            s += (char)((x2 - 10) + 'A');
        return s;
    }

    public static String toHex8(int n) {
        String s = "";
        int x1, x2, x3, x4, x5, x6, x7, x8;
        x1 = (n & 0xF0000000) >> 28;
        x2 = (n & 0xF000000) >> 24;
        x3 = (n & 0xF00000) >> 20;
        x4 = (n & 0xF0000) >> 16;
        x5 = (n & 0xF000) >> 12;
        x6 = (n & 0xF00) >> 8;
        x7 = (n & 0xF0) >> 4;
        x8 = n & 0x0F;
        if (x1 < 10)
            s += (char)(x1 + '0');
        else
            s += (char)((x1 - 10) + 'A');
        if (x2 < 10)
            s += (char)(x2 + '0');
        else
            s += (char)((x2 - 10) + 'A');
        if (x3 < 10)
            s += (char)(x3 + '0');
        else
            s += (char)((x3 - 10) + 'A');
        if (x4 < 10)
            s += (char)(x4 + '0');
        else
            s += (char)((x4 - 10) + 'A');
        s += " ";
        if (x5 < 10)
            s += (char)(x5 + '0');
        else
            s += (char)((x5 - 10) + 'A');
        if (x6 < 10)
            s += (char)(x6 + '0');
        else
            s += (char)((x6 - 10) + 'A');
        if (x7 < 10)
            s += (char)(x7 + '0');
        else
            s += (char)((x7 - 10) + 'A');
        if (x8 < 10)
            s += (char)(x8 + '0');
        else
            s += (char)((x8 - 10) + 'A');
  
        return s;
    }

    public static void main(String[] args) {
     
        if (args.length < 1) {
      printUsage();
      System.exit(1);
        }
     
        String filename = args[0];
     
        File infile = null;
        FileInputStream fileInput = null;

        try { 

            infile = new File(filename);
            if  (!infile.exists()) {
                 System.out.println("The file \"" + filename + "\" does not exist.");
                 System.exit(1);
            }

            if (!infile.canRead()) {
                 System.out.println("The file \"" + filename + "\" is not allowed to be read.");
                 System.exit(1);
            }   

            if  (infile.isDirectory()) {
                 System.out.println("The file \"" + filename + "\" is a directory.");
                 System.exit(1);
            }

            long fileSize = new File(args[0]).length();
            if  (fileSize < 1L) {
                 System.out.println("The file size is zero.");
                 System.exit(1);
            }

            System.out.println("The size of the file \"" + filename + "\" is " + fileSize + ".\n");
             
            fileInput = new FileInputStream(infile);

            long n = 0L;

            int data;
            String dum = "";

            while (n < fileSize  && (data = fileInput.read()) != -1) {
                if (n % 16 == 0L) {
                    System.out.print(toHex8((int) (n & 0xFFFFFFFF)) + ": ");
                }
             
                if (n % 16 != 8L) {
                    System.out.print(" ");
                }
                else {
                    System.out.print("-");
                }
                System.out.print( toHex((byte) (data & 0xFF)) );
                
                if ((data & 0xFF) >= 0x20 && (data & 0xFF) <= 0x7E) {
                    dum += (char)  (data & 0xFF);
                }
                else {
                    dum += ".";
                }
                
                if (n > 0 && n % 16 == 15L) {
                    System.out.print("  |");
                    System.out.print(dum);
                    System.out.print("|");
                    System.out.println();
                    dum = "";
                }
             
                n++;
            }

            if (n > 0 && n % 16 > 0) {
                for (int i = (int)(n % 16); i < 16; i++) {
                    System.out.print("   ");
                }
                System.out.print("  |");
                System.out.print(dum);
                for (int i = (int)(n % 16); i < 16; i++) {
                    System.out.print(" ");
                }
                System.out.print("|");
                System.out.println();
                dum = "";
            }

            fileInput.close();
            
            System.out.println();
            System.out.println("Read " + n + " bytes");
        }
        catch (IOException e) {
            System.out.println("Error message: " + e.getMessage());
        }   
    }
}

// Filename: MakeFibonacciTable_01.java
//
//        1) Show a simple table of Fibonacci numbers.
//        2) Use a linear recursion whose time complexity is o(N).
//
//   Compile: javac MakeFibonacciTable_01.java
//   Execute: java MakeFibonacciTable_01
//
//   Date: 2013. 3. 14.
//  Author: pkim __AT__ scripts ((DOT)) pe ((DOT)) kr

import java.math.*;

public class MakeFibonacciTable_01 {

    private static String toCurrencyString(BigInteger x) {
     String s = x.toString();
     int n = s.length();
     int i = 0;
     if (n <= 3) {
      return s;
     }
     String t = "";
     i = n % 3;
     if (i > 0 && n > 3) {
         t = s.substring(0, n % 3) + ",";
     }
     while (i < n - 3) {
          t += s.substring(i, i + 3) + ",";
          i += 3;
        }
       t += s.substring(i, n);
     return t;
    }

    private static BigInteger fib_aux(int n, int i, BigInteger a, BigInteger b) {
        if (i == 0) {
            return a;
        }
        else {
            BigInteger t = a.add(b);
            a = b;
            b = t;
            return fib_aux(n, i - 1, a, b);
        }
    }

    public static BigInteger fibo1(int n) {
        return fib_aux(n, n, new BigInteger("0"), new BigInteger("1"));
    }
   

     public static void main(String[] args) {
         BigInteger value;
         int i;

         System.out.printf("---------------------------------------------------------\n");
         System.out.printf("   n                                               F(n)    \n");
         System.out.printf("---------------------------------------------------------\n");
         for (i = 0; i <= 150; i++) {
             value = fibo1(i);
             if ((i % 10) == 0) {
                 System.out.printf("%5d   %47s\n", i, toCurrencyString(value));
             }
         }
         System.out.printf("----------------------------------------------------------\n");
         System.out.printf("\n");
    }
}

// Filename: TestNthRootApp.java
//
//            Approximate square roots, cubic roots and n-th roots of a given number.
//
// Compile: javac -d . TestNthRootApp.java
// Execute: java TestNthRootApp
//
// Date: 2013. 1. 6.
// Copyright (c) 2013 PH Kim  (pkim __AT__ scripts.pe.kr)

public class TestNthRootApp {

    final private static int MAX_ITER = 20000;
    final private static double M_EPSILON = 1.0e-15;

    /**
     * Compute the n-th root of x to a given scale, x > 0.
     */
    public static double nPow(double a, int n) {
        if (n > 0) {
            if (n == 1)
                return a;
            else {
                if (a == 0.0 || a == 1.0) {
                    return a;
                }
                else if (a == -1.0) {
                    if (n % 2 == 1)
                        return -1.0;
                    else
                        return 1.0;
                }
                else if (a < 0.0) {
                    if (n % 2 == 1)
                        return -nPow(-a, n);
                    else
                        return nPow(-a, n);
                }
                else {
                    double y = 1.0;
                    for (int i = 0; i < n; i++) {
                        y *= a;
                    }
                    return y;
                }
            }
        }
        else if (n == 0) {
            return 1.0;
        }
        else {      //  when n < 0
            if (a == 0.0)
                throw new RuntimeException("Negative powering exception of zero.");
            else {
                if (n == -1)
                    return 1.0/a;
                else
                    return 1.0/nPow(a, -n);
            }
        }
    }

    /**
     * Compute the n-th root of x to a given scale, x > 0.
     */
    public static double gPow(double a, int n) {
        if (n > 0) {
            if (n == 1)
                return a;
            else {
                if (a == 0.0 || a == 1.0) {
                    return a;
                }
                else if (a == -1.0) {
                    if (n % 2 == 1)
                        return -1.0;
                    else
                        return 1.0;
                }
                else if (a < 0.0) {
                    if (n % 2 == 1)
                        return -gPow(-a, n);
                    else
                        return gPow(-a, n);
                }
                else {

                    double y = 1.0;
                    double r = a;
                    int m = 8*4 - 1;            ///  8*sizeof(int) - 1;
                    int one = 1;
                    for (int i = 0; i < m; i++) {
                        if ((n & one) == 0) {
                            y *= 1.0;
                        }
                        else {
                            y *= r;
                        }
                        r = r*r;
                        one <<= 1;
                        if (one > n)
                            break;
                    }
                    return y;
                }
            }
        }
        else if (n == 0) {
            return 1.0;
        }
        else {      //  when n < 0
            if (a == 0.0)
                throw new RuntimeException("Negative powering exception of zero.");
            else {
                if (n == -1)
                    return 1.0/a;
                else
                    return 1.0/gPow(a, -n);
            }
        }
    }

    /**
     * Compute the n-th root of x to a given scale, x > 0.
     */
    public static double mPow(double a, int n) {
        if (n > 0) {
            if (n == 1)
                return a;
            else {
                if (a == 0.0 || a == 1.0) {
                    return a;
                }
                else if (a == -1.0) {
                    if (n % 2 == 1)
                        return -1.0;
                    else
                        return 1.0;
                }
                else if (a < 0.0) {
                    if (n % 2 == 1)
                        return -mPow(-a, n);
                    else
                        return mPow(-a, n);
                }
                else {

                    double y = 1.0;
                    double r = a;
                    int m = n;
                    while (m > 0) {
                        if ((m & 0x1) == 1) {
                            y *= r;
                        }
                        r = r*r;
                        m >>= 1;
                    }
                    return y;
                }
            }
        }
        else if (n == 0) {
            return 1.0;
        }
        else {      //  when n < 0
            if (a == 0.0)
                throw new RuntimeException("Negative powering exception of zero.");
            else {
                if (n == -1)
                    return 1.0/a;
                else
                    return 1.0/mPow(a, -n);
            }
        }
    }

    /**
     * Compute the square root of x to a given scale, x > 0.
     */
    public static double heronSqrt(double a) {
        if (a < 0.0) {
            throw new RuntimeException("Cannot find the sqrt of a negative number.");
        }
        else if (a == 0.0 || a == 1.0) {
            return a;
        }
        else {
            double x1 = a;
            double x2 = (x1 + a/x1)/2.0;
            double er = x1 - x2;
            int counter = 0;
            while (x1 + er != x1) {
                x1 = x2;
                x2 = (x1 + a/x1)/2.0;
                er = x1 - x2;
                if (Math.abs(er) < Math.abs(M_EPSILON*x1))
                    break;
                counter++;
                if (counter > MAX_ITER)
                    break;
            }
            if (counter >= MAX_ITER)
                throw new RuntimeException("Inaccurate sqrt exception by too many iterations.");
            return x2;
        }
    }

    /**
     * Compute the cubic root of x to a given scale, x > 0.
     */
    public static double newtonCbrt(double a) {
        if (a == 0.0 || a == 1.0 || a == -1.0) {
            return a;
        }
        else if (a < 0.0) {
            return -newtonCbrt(-a);
        }
        else {
            double x1 = a;
            double x2 = (2.0*x1 + a/(x1*x1))/3.0;
            double er = x1 - x2;
            int counter = 0;
            while (x1 + er != x1) {
                x1 = x2;
                x2 = (2.0*x1 + a/(x1*x1))/3.0;
                er = x1 - x2;
                if (Math.abs(er) < Math.abs(M_EPSILON*x1))
                    break;
                counter++;
                if (counter > MAX_ITER)
                    break;
            }
            if (counter >= MAX_ITER)
                throw new RuntimeException("Inaccurate cbrt exception by too many iterations.");
            return x2;
        }
    }

    /**
     * Compute the n-th root of x to a given scale, x > 0.
     */
    public static double newtonNthRoot(int n, double a) {
        if (n == 0) {
            return 1.0;
        }
        else if (n == 1) {
            return a;
        }
        else if (n > 0) {
            if (a == 0.0 || a == 1.0) {
                return a;
            }
            else if (a == -1.0) {
                if (n % 2 == 1)
                    return a;
                else
                    throw new RuntimeException("Cannot find the even n-th root of a negative number.");
            }
            else if (a < 0.0) {
                if (n % 2 == 1)
                    return -newtonNthRoot(n, -a);
                else
                    throw new RuntimeException("Cannot find the even n-th root of a negative number.");
            }
            else if (a < 1.0) {
                return 1.0/newtonNthRoot(n, 1.0/a);
            }
            else {
                double x1 = a;
                double xn = mPow(x1, n - 1);
                double x2 = ((n - 1)*x1 + a/xn)/n;
                double er = x1 - x2;
                int counter = 0;
                while (x1 + er != x1) {
                    x1 = x2;
                    xn = mPow(x1, n - 1);
                    x2 = ((n - 1)*x1 + a/xn)/n;
                    er = x1 - x2;
                    if (Math.abs(er) < Math.abs(M_EPSILON*x1))
                        break;
                    counter++;
                    if (counter > MAX_ITER)
                        break;
                }
                if (counter >= MAX_ITER)
                    throw new RuntimeException("Inaccurate n-th root exception by too many iterations.");
                return x2;
            }
        }
        else {
            if (a == 0.0) {
                throw new RuntimeException("Cannot find the negative n-th root of zero.");
            }
            else {
                return 1.0/newtonNthRoot(-n, a);
            }
        }
    }

    public static void main(String[] args) {

        double x = 16.0;
        double u = Math.sqrt(x);

        System.out.println("[ Testing heronSqrt(double) ]--------------------");
        System.out.println("x = " + x );
        System.out.println("u = sqrt(" + x + ") = " + u );
        double y = heronSqrt(x);
        System.out.println("y = heronSqrt(" + x + ") = " + y );
        System.out.println("y*y = " + y*y );
        System.out.println();

        System.out.println("[ Testing newtonCbrt(double) ]--------------------" );
        x = -216.0;
        System.out.println("x = " + x );
        System.out.println("-exp(log(-x)/3.0) = " + -Math.exp(Math.log(-x)/3.0) );
        double w = newtonCbrt(x);
        System.out.println("w = newtonCbrt(" + x + ") = " + w );
        System.out.println("w*w*w = " + w*w*w );
        System.out.println();

        x = 729000000000.0;
        System.out.println("x = " + x );
        System.out.println("exp(log(x)/3.0) = " + Math.exp(Math.log(x)/3.0) );
        w = newtonCbrt(x);
        System.out.println("w = newtonCbrt(" + x + ") = " + w );
        System.out.println("w*w*w = " + w*w*w );
        System.out.println();

        System.out.println("[ Testing newtonNthRoot(int, double) ]--------------------" );
        double z = newtonNthRoot(3, x);
        System.out.println("x = " + x );
        System.out.println("z = newtonNthRoot(3, " + x + ") = " + z );
        System.out.println("z*z*z = " + z*z*z );
        System.out.println();

        x = 12960000000000000000.0;
        z = newtonNthRoot(4, x);
        System.out.println("x = " + x );
        System.out.println("z = newtonNthRoot(4, x) = newtonNthRoot(4, " + x + ") = " + z );
        System.out.println("z*z*z*z = " + z*z*z*z );
        System.out.println();

        x = 1.0/12960000000000000000.0;
        z = newtonNthRoot(4, x);
        System.out.println("x = " + x );
        System.out.println("exp(log(x)/4.0) = " + Math.exp(Math.log(x)/4.0) );
        System.out.println("z = newtonNthRoot(4, x) = newtonNthRoot(4, " + x + ") = " + z );
        System.out.println("z*z*z*z = " + z*z*z*z );
        System.out.println();

        try {
            x = -4.0;
            System.out.println("[ Test Exception heronSqrt(double) ]--------------------" );
            System.out.println("x = " + x );
            System.out.println("Calculating heronSqrt(" + x + ")" );
            y = heronSqrt(x);
            System.out.println("y = heronSqrt(" + x + ") = " + y );
            System.out.println("y*y = " + y*y );
            System.out.println();
        }
        catch (Exception ex) {
            System.out.println(ex.getMessage() + "\n" + "Caught some exception in calculating heronSqrt(" + x + ")" );
            System.out.println();
        }

        try {
            x = -4.0;
            System.out.println("[ Test Exception in newtonCbrt(double) ]--------------------" );
            System.out.println("x = " + x );
            System.out.println("Calculating newtonCbrt(" + x + ")" );
             = newtonCbrt(x);
            System.out.println("y = newtonCbrt(" + x + ") = " + y );
            System.out.println("y*y*y = " + y*y*y );
            System.out.println();
        }
        catch (Exception ex) {
            System.out.println(ex.getMessage() + "\n" + "Caught some exception in calculating newtonCbrt(" + x + ")");
            System.out.println();
        }

        System.out.println("[ Test calculations by powering ]-----------------------------" );
        x = 200.0;
        z = newtonNthRoot(10, x);
        System.out.println("x = " + x );
        System.out.println("exp(log(x)/10.0) = " + Math.exp(Math.log(x)/10.0) );
        System.out.println("z = newtonNthRoot(10, x) = newtonNthRoot(10, " + x + ") = " + z );
        System.out.println("pow(z, 10) = " + Math.pow(z, 10) );
        System.out.println();

        x = 3001.0;
        z = newtonNthRoot(99, x);
        System.out.println("x = " + x );
        System.out.println("exp(log(x)/99.0) = " + Math.exp(Math.log(x)/99.0) );
        System.out.println("z = newtonNthRoot(99, x) = newtonNthRoot(99, " + x + ") = " + z );
        System.out.println("pow(z, 99) = " + Math.pow(z, 99) );
        System.out.println();

        x = 3001.0;
        z = newtonNthRoot(-99, x);
        System.out.println("x = " + x );
        System.out.println("exp(log(x)/-99.0) = " + Math.exp(Math.log(x)/-99.0) );
        System.out.println("z = newtonNthRoot(-99, x) = newtonNthRoot(-99, " + x + ") = " + z );
        System.out.println("1.0/pow(z, 99) = " + 1.0/Math.pow(z, 99) );
        System.out.println();

        System.out.println("2.1**2.1 = pow(2.1, 2.1) = "  + Math.pow(2.1, 2.1) );
        System.out.println("2.1**(-2.1) = pow(2.1, -2.1) = "  + Math.pow(2.1, -2.1) );
        System.out.println("2.1**2.1 * 2.1**(-2.1) = pow(2.1, 2.1) * pow(2.1, -2.1) = "  + Math.pow(2.1, 2.1)*Math.pow(2.1, -2.1) );
        System.out.println("2.1**2.1 = exp(2.1*log(2.1)) = "  + Math.exp(2.1*Math.log(2.1)) );
        System.out.println("2.1**(-2.1) = exp(-2.1*log(2.1)) = " + Math.exp(-2.1*Math.log(2.1)) );
        System.out.println("2.1**2.1 * 2.1**(-2.1) = exp(2.1*log(2.1)) * exp(-2.1*log(2.1)) = "  + Math.exp(2.1*Math.log(2.1)) * Math.exp(-2.1*Math.log(2.1)) );
        System.out.println();

        int k = 301;
        x = -1.029;
        double t1 = nPow(x, k);
        double t2 = gPow(x, k);
        double t3 = mPow(x, k);
        System.out.println("t1 = nPow(" + x + ", " + k + ") = " + t1 );
        System.out.println("t2 = gPow(" + x + ", " + k + ") = " + t2 );
        System.out.println("t3 = mPow(" + x + ", " + k + ") = " + t3 );
        System.out.println("t1 / t2 = " + (t1 / t2) );
        System.out.println("t1 - t2 = " + (t1 - t2) );
        System.out.println("t1 == t2 ? " + ((t1 == t2) ? "yes" : "no") );
        System.out.println("t1 / t3 = " + (t1 / t3) );
        System.out.println("t1 - t3 = " + (t1 - t3) );
        System.out.println("t1 == t3 ? " + ((t1 == t3) ? "yes" : "no") );
        System.out.println("t2 / t3 = " + (t2 / t3) );
        System.out.println("t2 - t3 = " + (t2 - t3) );
        System.out.println("t2 == t3 ? " + ((t2 == t3) ? "yes" : "no") );
        System.out.println();

        System.out.println("Done.");
    }
}

/*
[ Testing heronSqrt(double) ]--------------------
x = 16.0
u = sqrt(16.0) = 4.0
y = heronSqrt(16.0) = 4.0
y*y = 16.0

[ Testing newtonCbrt(double) ]--------------------
x = -216.0
-exp(log(-x)/3.0) = -6.000000000000001
w = newtonCbrt(-216.0) = -6.0
w*w*w = -216.0

x = 7.29E11
exp(log(x)/3.0) = 9000.000000000004
w = newtonCbrt(7.29E11) = 9000.0
w*w*w = 7.29E11

[ Testing newtonNthRoot(int, double) ]--------------------
x = 7.29E11
z = newtonNthRoot(3, 7.29E11) = 9000.0
z*z*z = 7.29E11

x = 1.296E19
z = newtonNthRoot(4, x) = newtonNthRoot(4, 1.296E19) = 60000.0
z*z*z*z = 1.296E19

x = 7.716049382716049E-20
exp(log(x)/4.0) = 1.666666666666666E-5
z = newtonNthRoot(4, x) = newtonNthRoot(4, 7.716049382716049E-20) = 1.6666666666
666667E-5
z*z*z*z = 7.716049382716051E-20

[ Test Exception heronSqrt(double) ]--------------------
x = -4.0
Calculating heronSqrt(-4.0)
Cannot find the sqrt of a negative number.
Caught some exception in calculating heronSqrt(-4.0)

[ Test Exception in newtonCbrt(double) ]--------------------
x = -4.0
Calculating newtonCbrt(-4.0)
y = newtonCbrt(-4.0) = -1.5874010519681994
y*y*y = -3.999999999999999

[ Test calculations by powering ]-----------------------------
x = 200.0
exp(log(x)/10.0) = 1.6986464646342472
z = newtonNthRoot(10, x) = newtonNthRoot(10, 200.0) = 1.6986464646342472
pow(z, 10) = 199.9999999999999

x = 3001.0
exp(log(x)/99.0) = 1.0842361893258805
z = newtonNthRoot(99, x) = newtonNthRoot(99, 3001.0) = 1.0842361893258805
pow(z, 99) = 3000.9999999999955

x = 3001.0
exp(log(x)/-99.0) = 0.9223082662659932
z = newtonNthRoot(-99, x) = newtonNthRoot(-99, 3001.0) = 0.9223082662659932
1.0/pow(z, 99) = 3001.000000000004

2.1**2.1 = pow(2.1, 2.1) = 4.749638091742242
2.1**(-2.1) = pow(2.1, -2.1) = 0.21054235726688475
2.1**2.1 * 2.1**(-2.1) = pow(2.1, 2.1) * pow(2.1, -2.1) = 0.9999999999999999
2.1**2.1 = exp(2.1*log(2.1)) = 4.749638091742242
2.1**(-2.1) = exp(-2.1*log(2.1)) = 0.21054235726688478
2.1**2.1 * 2.1**(-2.1) = exp(2.1*log(2.1)) * exp(-2.1*log(2.1)) = 1.0

t1 = nPow(-1.029, 301) = -5457.92801577163
t2 = gPow(-1.029, 301) = -5457.928015771692
t3 = mPow(-1.029, 301) = -5457.928015771692
t1 / t2 = 0.9999999999999887
t1 - t2 = 6.184563972055912E-11
t1 == t2 ? no
t1 / t3 = 0.9999999999999887
t1 - t3 = 6.184563972055912E-11
t1 == t3 ? no
t2 / t3 = 1.0
t2 - t3 = 0.0
t2 == t3 ? yes

Done.
*/

public class TestArcSine {
        public static double sin(double x)  {
            double y = Math.sin(x);
            return y;
        }

        public static double asin(double x) {
            double y = Math.asin(x);
            return y;
        }

        public static double sinh(double x) {
            double y = Math.sinh(x);
            return y;
        }

        public static double cosh(double x) {
            double y = Math.cosh(x);
            return y;
        }

        public static double asinh(double x)
        {
            double y = Math.log(x + Math.sqrt(x*x + 1));
            return y;
        }

        public static double acosh(double x)
        {
            double y = Math.log(x + Math.sqrt(x*x - 1));
            return y;
        }

        public static void main(String[] args)
        {
            double x = -0.9;
            double y = asin(x);
            System.out.printf("y = asin(%.1g) = %.9f\n", x,  y);
            System.out.printf("sin(y) = sin(%.9f) = %.1g\n",  y, sin(y));
            System.out.printf("\n");

            x = 1.1;
            double u = acosh(x);
            System.out.printf("u = acosh(%3.2g) = %.10f\n", x,  u);

            double v = asinh(x);
            System.out.printf("v = asinh(%3.2g) = %.10f\n", x,  v);

            System.out.printf("cosh(u) = cosh(%.10f) = %3.2g\n", u,  cosh(u));
            System.out.printf("sinh(v) = sinh(%.10f) = %3.2g\n", v,  sinh(v));
        }
}

/*
Output:
y = asin(-0.9) = -1.119769515
sin(y) = sin(-1.119769515) = -0.9

u = acosh(1.1) = 0.4435682544
v = asinh(1.1) = 0.9503469298
cosh(u) = cosh(0.4435682544) = 1.1
sinh(v) = sinh(0.9503469298) = 1.1
*/

/**
 * Filename: TestLanczos_02.java
 *
 * Compile: javac -d . -cp .:commons-math3-3.0.jar TestLanczos_02.java
 * Execute: java -classpath .:commons-math3-3.0.jar TestLanczos_02
 *
 * Note: You can download commons-math3-3.0-bin.tar.gz or commons-math3-3.0-bin.zip
 *         at http://commons.apache.org/math/download_math.cgi
 *
 * ----------------------------------------------------------------------------
 * See: http://www.thinbasic.com/community/showthread.php?11279-Gamma-function
 * See: http://en.wikipedia.org/wiki/Gamma_function
 * See: http://http://jany.tistory.com/53
 * See: http://support.realsoftware.com/listarchives/realbasic-nug/2003-08/msg03123.html
 * ----------------------------------------------------------------------------
 * Date: 2012. 12. 12.
 * Copyright (C) Pil Ho, Kim  (pkim (AT) scripts.pe.kr)
 */

import java.io.*;
import org.apache.commons.math3.special.Gamma;

public class TestLanczos_02 {

     private static double frac(double x) {
         double result;
         if (x >= 0.0)
             result = Math.abs(x) - Math.floor(Math.abs(x));
         else
             result = -(Math.abs(x) - Math.floor(Math.abs(x)));
        return result;
    }

    public static double gamma2(double y)  {
        double pi = 3.1415926535897932385;
        double sq2pi = 2.50662827463100050241577;  // sqrt(2Pi)
        double g = 607./128;   // best resu'ts when 4<=g<=5
        double t, w, gam, x = y - 1.0;
        int i, cg = 14;
        double[] c = new double[16];
        
        // Lanczos approximation for the complex plane
        // calculated using vpa digits(256)
        // the best set of coeffs was selected from
        // a solution space of g=0 to 32 with 1 to 32 terms
        // these coeffs really give superb performance
        // of 15 sig. digits for 0<=real(z)<=171
        // coeffs should sum to about g*g/2+23/24
        
        // http://www.numericana.com/answer/info/godfrey.htm
        
          c[ 1] =        0.99999999999999709182;   // thiBasic arrays start at 1 ?
          c[ 2] =       57.156235665862923517;
          c[ 3] =      -59.597960355475491248;
          c[ 4] =       14.136097974741747174;
          c[ 5] =       -0.49191381609762019978;
          c[ 6] =        0.33994649984811888699/10000;
          c[ 7] =        0.46523628927048575665/10000;
          c[ 8] =       -0.98374475304879564677/10000;
          c[ 9] =        0.15808870322491248884/1000;
          c[10] =       -0.21026444172410488319/1000;
          c[11] =        0.21743961811521264320/1000;
          c[12] =       -0.16431810653676389022/1000;
          c[13] =        0.84418223983852743293/10000;
          c[14] =       -0.26190838401581408670/10000;
          c[15] =        0.36899182659531622704/100000;
          
        if ( x < 0.0 ) {
            x = -x;
            if (frac(x) == 0.0) {
                gam = Math.pow(10.0, 4932);
            }
            else {
                t = c[1];
                for (i = 1; i <= cg; i++) {
                    t = t + c[i+1]/(x+i);
                }
                w = x + g + 0.5;
                gam = Math.pow(w, x+0.5)*Math.exp(-w)*sq2pi*t;
                gam = pi*x/(gam*Math.sin(pi*x));
            }
        }
        else {
            t = c[1];
            for (i = 1; i <= cg; i++) {
                t = t + c[i+1]/(x+i);
            }
            w = x + g + 0.5;
            gam = Math.pow(w, x+0.5)*Math.exp(-w)*sq2pi*t;
        }
        return gam;
    }

    public static void main(String[] args) {
        double y, x = 1.0;

        while (x > 0.0) {
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            String line = null;

            try {
                System.out.printf("Input x(0 to exit): ");
                line = br.readLine();
                x = Double.parseDouble((line));
            }
            catch (IOException ioe) {
                System.err.println("IO error trying to read your input number!");
                System.err.println("Try to input again.");
            }

            if (x == 0.0) {
                break;
            }
            y = gamma2(x);
            System.out.printf(" Gamma(%f) = (%f)! = %30f\n", x, x - 1, y);

            System.out.printf(" Gamma.logGamma(%f) = log((%f)!) = %f\n", x, x - 1, Gamma.logGamma(x));
            System.out.printf(" Math.exp(Gamm.logGamma(%f)) = (%f)! = %30f\n", x, x - 1, Math.exp(Gamma.logGamma(x)));
        }
    }
}

/*
100! =  93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000

Execute: java -classpath .:commons-math3-3.0.jar TestLanczos_02
Result:
Input x(0 to exit): 101
 Gamma(101.000000) = (100.000000)! = 93326215443944150000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.000000
 Gamma.logGamma(101.000000) = log((100.000000)!) = 363.739376
 Math.exp(Gamm.logGamma(101.000000)) = (100.000000)! = 93326215443942250000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.000000
Input x(0 to exit): 0
*/