Added more algorithms to maths

DIRECTORY.md

@@ -118,21 +118,27 @@
   * [AmicableNumber](https://github.com/TheAlgorithms/Java/blob/master/Maths/AmicableNumber.java)
   * [Area](https://github.com/TheAlgorithms/Java/blob/master/Maths/Area.java)
   * [Average](https://github.com/TheAlgorithms/Java/blob/master/Maths/Average.java)
+  * [Ceil](https://github.com/TheAlgorithms/Java/blob/master/Maths/Ceil.java)
+  * [Combinations](https://github.com/TheAlgorithms/Java/blob/master/Maths/Combinations.java)
   * [Factorial](https://github.com/TheAlgorithms/Java/blob/master/Maths/Factorial.java)
   * [FactorialRecursion](https://github.com/TheAlgorithms/Java/blob/master/Maths/FactorialRecursion.java)
   * [FibonacciNumber](https://github.com/TheAlgorithms/Java/blob/master/Maths/FibonacciNumber.java)
   * [FindMax](https://github.com/TheAlgorithms/Java/blob/master/Maths/FindMax.java)
   * [FindMaxRecursion](https://github.com/TheAlgorithms/Java/blob/master/Maths/FindMaxRecursion.java)
   * [FindMin](https://github.com/TheAlgorithms/Java/blob/master/Maths/FindMin.java)
   * [FindMinRecursion](https://github.com/TheAlgorithms/Java/blob/master/Maths/FindMinRecursion.java)
+  * [Floor](https://github.com/TheAlgorithms/Java/blob/master/Maths/Floor.java)
   * [GCD](https://github.com/TheAlgorithms/Java/blob/master/Maths/GCD.java)
   * [GCDRecursion](https://github.com/TheAlgorithms/Java/blob/master/Maths/GCDRecursion.java)
+  * [LucasSeries](https://github.com/TheAlgorithms/Java/blob/master/Maths/LucasSeries.java)
   * [MaxValue](https://github.com/TheAlgorithms/Java/blob/master/Maths/MaxValue.java)
   * [MinValue](https://github.com/TheAlgorithms/Java/blob/master/Maths/MinValue.java)
   * [NumberOfDigits](https://github.com/TheAlgorithms/Java/blob/master/Maths/NumberOfDigits.java)
   * [PalindromeNumber](https://github.com/TheAlgorithms/Java/blob/master/Maths/PalindromeNumber.java)
   * [ParseInteger](https://github.com/TheAlgorithms/Java/blob/master/Maths/ParseInteger.java)
+  * [PerfectCube](https://github.com/TheAlgorithms/Java/blob/master/Maths/PerfectCube.java)
   * [PerfectNumber](https://github.com/TheAlgorithms/Java/blob/master/Maths/PerfectNumber.java)
+  * [PerfectSquare](https://github.com/TheAlgorithms/Java/blob/master/Maths/PerfectSquare.java)
   * [Pow](https://github.com/TheAlgorithms/Java/blob/master/Maths/Pow.java)
   * [PowRecursion](https://github.com/TheAlgorithms/Java/blob/master/Maths/PowRecursion.java)
   * [PrimeCheck](https://github.com/TheAlgorithms/Java/blob/master/Maths/PrimeCheck.java)

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;
+        }
+    }
+}

Maths/LucasSeries.java

@@ -0,0 +1,44 @@
+package Maths;
+
+/**
+ * https://en.wikipedia.org/wiki/Lucas_number
+ */
+public class LucasSeries {
+    public static void main(String[] args) {
+        assert lucasSeries(1) == 2 && lucasSeriesIteration(1) == 2;
+        assert lucasSeries(2) == 1 && lucasSeriesIteration(2) == 1;
+        assert lucasSeries(3) == 3 && lucasSeriesIteration(3) == 3;
+        assert lucasSeries(4) == 4 && lucasSeriesIteration(4) == 4;
+        assert lucasSeries(5) == 7 && lucasSeriesIteration(5) == 7;
+        assert lucasSeries(6) == 11 && lucasSeriesIteration(6) == 11;
+        assert lucasSeries(11) == 123 && lucasSeriesIteration(11) == 123;
+
+    }
+
+    /**
+     * Calculate nth number of lucas series(2, 1, 3, 4, 7, 11, 18, 29, 47, 76, 123, ....) using recursion
+     *
+     * @param n nth
+     * @return nth number of lucas series
+     */
+    public static int lucasSeries(int n) {
+        return n == 1 ? 2 : n == 2 ? 1 : lucasSeries(n - 1) + lucasSeries(n - 2);
+    }
+
+    /**
+     * Calculate nth number of lucas series(2, 1, 3, 4, 7, 11, 18, 29, 47, 76, 123, ....) using iteration
+     *
+     * @param n nth
+     * @return nth number of lucas series
+     */
+    public static int lucasSeriesIteration(int n) {
+        int previous = 2;
+        int current = 1;
+        for (int i = 1; i < n; i++) {
+            int next = previous + current;
+            previous = current;
+            current = next;
+        }
+        return previous;
+    }
+}

Maths/PerfectCube.java

@@ -0,0 +1,27 @@
+package Maths;
+
+/**
+ * https://en.wikipedia.org/wiki/Cube_(algebra)
+ */
+public class PerfectCube {
+    public static void main(String[] args) {
+        assert !isPerfectCube(-1);
+        assert isPerfectCube(0);
+        assert isPerfectCube(1);
+        assert !isPerfectCube(4);
+        assert isPerfectCube(8);
+        assert isPerfectCube(27);
+
+    }
+
+    /**
+     * Check if a number is perfect cube or not
+     *
+     * @param number number to check
+     * @return {@code true} if {@code number} is perfect cube, otherwise {@code false}
+     */
+    public static boolean isPerfectCube(int number) {
+        int a = (int) Math.pow(number, 1.0 / 3);
+        return a * a * a == number;
+    }
+}

Maths/PerfectSquare.java

@@ -0,0 +1,25 @@
+package Maths;
+
+/**
+ * https://en.wikipedia.org/wiki/Perfect_square
+ */
+public class PerfectSquare {
+    public static void main(String[] args) {
+        assert !isPerfectSquare(-1);
+        assert !isPerfectSquare(3);
+        assert !isPerfectSquare(5);
+        assert isPerfectSquare(9);
+        assert isPerfectSquare(100);
+    }
+
+    /**
+     * Check if a number is perfect square number
+     *
+     * @param number the number to be checked
+     * @return <tt>true</tt> if {@code number} is perfect square, otherwise <tt>false</tt>
+     */
+    public static boolean isPerfectSquare(int number) {
+        int sqrt = (int) Math.sqrt(number);
+        return sqrt * sqrt == number;
+    }
+}