Development Java Tutorial

import java.io.File;
/* 
 * Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 */
public class Main {
  /**
   * Returns n!. Shorthand for n    * href="http://mathworld.wolfram.com/Factorial.html"> Factorial, the
   * product of the numbers 1,...,n.
   * 
   * Preconditions:
   * 

   * 
•  n >= 0 (otherwise
     * IllegalArgumentException is thrown)

   * 
•  The result is small enough to fit into a long. The
   * largest value of n for which n! <
   * Long.MAX_VALUE is 20. If the computed value exceeds Long.MAX_VALUE
     * an ArithMeticException  is thrown.

   * 

   * 
   * @param n argument
   * @return n!
   * @throws ArithmeticException if the result is too large to be represented
   *         by a long integer.
   * @throws IllegalArgumentException if n < 0
   */
  public static long factorial(final int n) {
      long result = Math.round(factorialDouble(n));
      if (result == Long.MAX_VALUE) {
          throw new ArithmeticException(
              "result too large to represent in a long integer");
      }
      return result;
  }
  /**
   * Returns n!. Shorthand for n    * href="http://mathworld.wolfram.com/Factorial.html"> Factorial, the
   * product of the numbers 1,...,n as a double.
   * 
   * Preconditions:
   * 

   * 
•  n >= 0 (otherwise
     * IllegalArgumentException is thrown)

   * 
•  The result is small enough to fit into a double. The
     * largest value of n for which n! <
     * Double.MAX_VALUE is 170. If the computed value exceeds
     * Double.MAX_VALUE, Double.POSITIVE_INFINITY is returned

   * 

   * 
   * @param n argument
   * @return n!
   * @throws IllegalArgumentException if n < 0
   */
  public static double factorialDouble(final int n) {
      if (n < 0) {
          throw new IllegalArgumentException("must have n >= 0 for n!");
      }
      return Math.floor(Math.exp(factorialLog(n)) + 0.5);
  }
  /**
   * Returns the natural logarithm of n!.
   * 
   * Preconditions:
   * 

   * 
•  n >= 0 (otherwise
     * IllegalArgumentException is thrown)

   * 

   * 
   * @param n argument
   * @return n!
   * @throws IllegalArgumentException if preconditions are not met.
   */
  public static double factorialLog(final int n) {
      if (n < 0) {
          throw new IllegalArgumentException("must have n > 0 for n!");
      }
      double logSum = 0;
      for (int i = 2; i <= n; i++) {
          logSum += Math.log((double)i);
      }
      return logSum;
  }
}