* factorial using using iteration

* add ceil() to maths
* add combinations() to maths
* add floor() to maths

Author: realDuYuanChao

Maths/Ceil.java

@@ -0,0 +1,32 @@
+package Maths;
+
+public class Ceil {
+    public static void main(String[] args) {
+        assert ceil(10) == Math.ceil(10);
+        assert ceil(-10) == Math.ceil(-10);
+        assert ceil(10.0) == Math.ceil(10.0);
+        assert ceil(-10.0) == Math.ceil(-10.0);
+        assert ceil(10.1) == Math.ceil(10.1);
+        assert ceil(-10.1) == Math.ceil(-10.1);
+        assert ceil(0) == Math.ceil(0);
+        assert ceil(-0) == Math.ceil(-0);
+        assert ceil(0.0) == Math.ceil(0.0);
+        assert ceil(-0.0) == Math.ceil(-0.0);
+    }
+
+    /**
+     * Returns the smallest (closest to negative infinity)
+     *
+     * @param number the number
+     * @return the smallest (closest to negative infinity) of given {@code number}
+     */
+    public static double ceil(double number) {
+        if (number - (int) number == 0) {
+            return number;
+        } else if (number - (int) number > 0) {
+            return (int) (number + 1);
+        } else {
+            return (int) number;
+        }
+    }
+}

Maths/Combinations.java

@@ -0,0 +1,37 @@
+package Maths;
+
+/**
+ * @see <a href="https://en.wikipedia.org/wiki/Combination">Combination</a>
+ */
+public class Combinations {
+    public static void main(String[] args) {
+        assert combinations(1, 1) == 1;
+        assert combinations(10, 5) == 252;
+        assert combinations(6, 3) == 20;
+        assert combinations(20, 5) == 15504;
+    }
+
+    /**
+     * Calculate of factorial
+     *
+     * @param n the number
+     * @return factorial of given number
+     */
+    public static long factorial(int n) {
+        if (n < 0) {
+            throw new IllegalArgumentException("number is negative");
+        }
+        return n == 0 || n == 1 ? 1 : n * factorial(n - 1);
+    }
+
+    /**
+     * Calculate combinations
+     *
+     * @param n first number
+     * @param k second number
+     * @return combinations of given {@code n} and {@code k}
+     */
+    public static long combinations(int n, int k) {
+        return factorial(n) / (factorial(k) * factorial(n - k));
+    }
+}

Maths/Factorial.java

@@ -1,34 +1,27 @@
 package Maths;
-import java.util.*; //for importing scanner
 
 public class Factorial {
-    public static void main(String[] args) { //main method
-           int n = 1;
-           Scanner sc= new Scanner(System.in);
-           System.out.println("Enter Number");
-           n=sc.nextInt();
-           System.out.println(n + "! = " + factorial(n));
-    }
 
-    //Factorial = n! = n1 * (n-1) * (n-2)*...1
+    /* Driver Code */
+    public static void main(String[] args) {
+        assert factorial(0) == 1;
+        assert factorial(1) == 1;
+        assert factorial(5) == 120;
+        assert factorial(10) == 3628800;
+    }
 
     /**
-     * Calculate factorial N
+     * Calculate factorial N using iteration
      *
      * @param n the number
      * @return the factorial of {@code n}
      */
     public static long factorial(int n) {
-        // Using recursion
-        try {
-        	if (n == 0) {
-				return 1; // if n = 0, return factorial of n;
-			}else {
-				return n*factorial(n-1); // While N is greater than 0, call the function again, passing n-1 (Principle of factoring);
-			}
-        }catch (ArithmeticException e) {
-			System.out.println("Dont work with less than 0");
-		}
-		return n;
+        if (n < 0) {
+            throw new IllegalArgumentException("number is negative");
+        }
+        long factorial = 1;
+        for (int i = 1; i <= n; factorial *= i, ++i) ;
+        return factorial;
     }
 }

Maths/Floor.java

@@ -0,0 +1,32 @@
+package Maths;
+
+public class Floor {
+    public static void main(String[] args) {
+        assert floor(10) == Math.floor(10);
+        assert floor(-10) == Math.floor(-10);
+        assert floor(10.0) == Math.floor(10.0);
+        assert floor(-10.0) == Math.floor(-10.0);
+        assert floor(10.1) == Math.floor(10.1);
+        assert floor(-10.1) == Math.floor(-10.1);
+        assert floor(0) == Math.floor(0);
+        assert floor(-0) == Math.floor(-0);
+        assert floor(0.0) == Math.floor(0.0);
+        assert floor(-0.0) == Math.floor(-0.0);
+    }
+
+    /**
+     * Returns the largest (closest to positive infinity)
+     *
+     * @param number the number
+     * @return the largest (closest to positive infinity)  of given {@code number}
+     */
+    public static double floor(double number) {
+        if (number - (int) number == 0) {
+            return number;
+        } else if (number - (int) number > 0) {
+            return (int) number;
+        } else {
+            return (int) number - 1;
+        }
+    }
+}