diff --git a/java-numbers-2/.idea/.gitignore b/java-numbers-2/.idea/.gitignore
new file mode 100644
index 0000000000..73f69e0958
--- /dev/null
+++ b/java-numbers-2/.idea/.gitignore
@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml
+# Editor-based HTTP Client requests
+/httpRequests/
diff --git a/java-numbers-2/.idea/compiler.xml b/java-numbers-2/.idea/compiler.xml
new file mode 100644
index 0000000000..0464686f1a
--- /dev/null
+++ b/java-numbers-2/.idea/compiler.xml
@@ -0,0 +1,13 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/java-numbers-2/.idea/encodings.xml b/java-numbers-2/.idea/encodings.xml
new file mode 100644
index 0000000000..63e9001932
--- /dev/null
+++ b/java-numbers-2/.idea/encodings.xml
@@ -0,0 +1,6 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/java-numbers-2/.idea/jarRepositories.xml b/java-numbers-2/.idea/jarRepositories.xml
new file mode 100644
index 0000000000..712ab9d985
--- /dev/null
+++ b/java-numbers-2/.idea/jarRepositories.xml
@@ -0,0 +1,20 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/java-numbers-2/.idea/misc.xml b/java-numbers-2/.idea/misc.xml
new file mode 100644
index 0000000000..d31b37ac7b
--- /dev/null
+++ b/java-numbers-2/.idea/misc.xml
@@ -0,0 +1,12 @@
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/java-numbers-2/.idea/runConfigurations.xml b/java-numbers-2/.idea/runConfigurations.xml
new file mode 100644
index 0000000000..797acea53e
--- /dev/null
+++ b/java-numbers-2/.idea/runConfigurations.xml
@@ -0,0 +1,10 @@
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/java-numbers-2/.idea/vcs.xml b/java-numbers-2/.idea/vcs.xml
new file mode 100644
index 0000000000..6c0b863585
--- /dev/null
+++ b/java-numbers-2/.idea/vcs.xml
@@ -0,0 +1,6 @@
+
+
+
+
+
+
\ No newline at end of file
diff --git a/java-numbers-2/README.md b/java-numbers-2/README.md
new file mode 100644
index 0000000000..1d996e32cc
--- /dev/null
+++ b/java-numbers-2/README.md
@@ -0,0 +1,16 @@
+## Java Number Cookbooks and Examples
+
+This module contains articles about numbers in Java.
+
+### Relevant Articles
+- [Lossy Conversion in Java](https://www.baeldung.com/java-lossy-conversion)
+- [A Guide to the Java Math Class](https://www.baeldung.com/java-lang-math)
+- [Calculate the Area of a Circle in Java](https://www.baeldung.com/java-calculate-circle-area)
+- [NaN in Java](https://www.baeldung.com/java-not-a-number)
+- [Generating Prime Numbers in Java](https://www.baeldung.com/java-generate-prime-numbers)
+- [Using Math.pow in Java](https://www.baeldung.com/java-math-pow)
+- [Check If a Number Is Prime in Java](https://www.baeldung.com/java-prime-numbers)
+- [Binary Numbers in Java](https://www.baeldung.com/java-binary-numbers)
+- [Finding the Least Common Multiple in Java](https://www.baeldung.com/java-least-common-multiple)
+- [Binary Numbers in Java](https://www.baeldung.com/java-binary-numbers)
+- More articles: [[<-- prev]](/java-numbers) [[next -->]](/java-numbers-3)
diff --git a/java-numbers-2/pom.xml b/java-numbers-2/pom.xml
new file mode 100644
index 0000000000..de25f0bb35
--- /dev/null
+++ b/java-numbers-2/pom.xml
@@ -0,0 +1,45 @@
+
+
+ 4.0.0
+ java-numbers-2
+ ${parent.version}
+ java-numbers-2
+ jar
+
+
+ com.ossez
+ parent-java
+ 0.0.2-SNAPSHOT
+ ../parent-java
+
+
+
+
+ org.openjdk.jmh
+ jmh-generator-annprocess
+ ${jmh-generator.version}
+
+
+ it.unimi.dsi
+ dsiutils
+ ${dsiutils.version}
+
+
+
+
+ java-numbers-2
+
+
+ src/main/resources
+ true
+
+
+
+
+
+ 2.6.0
+
+
+
\ No newline at end of file
diff --git a/java-numbers-2/src/main/java/com/ossez/algorithms/primechecker/BigIntegerPrimeChecker.java b/java-numbers-2/src/main/java/com/ossez/algorithms/primechecker/BigIntegerPrimeChecker.java
new file mode 100644
index 0000000000..9075b5051e
--- /dev/null
+++ b/java-numbers-2/src/main/java/com/ossez/algorithms/primechecker/BigIntegerPrimeChecker.java
@@ -0,0 +1,13 @@
+package com.ossez.algorithms.primechecker;
+
+import java.math.BigInteger;
+
+public class BigIntegerPrimeChecker implements PrimeChecker{
+
+ @Override
+ public boolean isPrime(Long number) {
+ BigInteger bigInt = BigInteger.valueOf(number);
+ return bigInt.isProbablePrime(100);
+ }
+
+}
diff --git a/java-numbers-2/src/main/java/com/ossez/algorithms/primechecker/BruteForcePrimeChecker.java b/java-numbers-2/src/main/java/com/ossez/algorithms/primechecker/BruteForcePrimeChecker.java
new file mode 100644
index 0000000000..3b1afbd1fe
--- /dev/null
+++ b/java-numbers-2/src/main/java/com/ossez/algorithms/primechecker/BruteForcePrimeChecker.java
@@ -0,0 +1,14 @@
+package com.ossez.algorithms.primechecker;
+
+import java.util.stream.IntStream;
+
+public class BruteForcePrimeChecker implements PrimeChecker {
+
+ @Override
+ public boolean isPrime(Integer number) {
+
+ return number > 1 ? IntStream.range(2, number)
+ .noneMatch(n -> (number % n == 0)) : false;
+ }
+
+}
diff --git a/java-numbers-2/src/main/java/com/ossez/algorithms/primechecker/OptimisedPrimeChecker.java b/java-numbers-2/src/main/java/com/ossez/algorithms/primechecker/OptimisedPrimeChecker.java
new file mode 100644
index 0000000000..c693ed7311
--- /dev/null
+++ b/java-numbers-2/src/main/java/com/ossez/algorithms/primechecker/OptimisedPrimeChecker.java
@@ -0,0 +1,13 @@
+package com.ossez.algorithms.primechecker;
+
+import java.util.stream.IntStream;
+
+public class OptimisedPrimeChecker implements PrimeChecker {
+
+ @Override
+ public boolean isPrime(Integer number) {
+ return number > 1 ? IntStream.rangeClosed(2, (int) Math.sqrt(number))
+ .noneMatch(n -> (number % n == 0)) : false;
+ }
+
+}
diff --git a/java-numbers-2/src/main/java/com/ossez/algorithms/primechecker/PrimeChecker.java b/java-numbers-2/src/main/java/com/ossez/algorithms/primechecker/PrimeChecker.java
new file mode 100644
index 0000000000..f571afe58c
--- /dev/null
+++ b/java-numbers-2/src/main/java/com/ossez/algorithms/primechecker/PrimeChecker.java
@@ -0,0 +1,6 @@
+package com.ossez.algorithms.primechecker;
+
+public interface PrimeChecker {
+
+ public boolean isPrime( T number );
+}
diff --git a/java-numbers-2/src/main/java/com/ossez/algorithms/primechecker/PrimesPrimeChecker.java b/java-numbers-2/src/main/java/com/ossez/algorithms/primechecker/PrimesPrimeChecker.java
new file mode 100644
index 0000000000..8fb8517d8d
--- /dev/null
+++ b/java-numbers-2/src/main/java/com/ossez/algorithms/primechecker/PrimesPrimeChecker.java
@@ -0,0 +1,12 @@
+package com.ossez.algorithms.primechecker;
+
+import org.apache.commons.math3.primes.Primes;
+
+public class PrimesPrimeChecker implements PrimeChecker{
+
+ @Override
+ public boolean isPrime(Integer number) {
+ return Primes.isPrime(number);
+ }
+
+}
diff --git a/java-numbers-2/src/main/java/com/ossez/area/circle/Circle.java b/java-numbers-2/src/main/java/com/ossez/area/circle/Circle.java
new file mode 100644
index 0000000000..4229f27353
--- /dev/null
+++ b/java-numbers-2/src/main/java/com/ossez/area/circle/Circle.java
@@ -0,0 +1,26 @@
+package com.ossez.area.circle;
+
+public class Circle {
+
+ private double radius;
+
+ public Circle(double radius) {
+ this.radius = radius;
+ }
+
+ public double getRadius() {
+ return radius;
+ }
+
+ public void setRadius(double radius) {
+ this.radius = radius;
+ }
+
+ private double calculateArea() {
+ return radius * radius * Math.PI;
+ }
+
+ public String toString() {
+ return "The area of the circle [radius = " + radius + "]: " + calculateArea();
+ }
+}
diff --git a/java-numbers-2/src/main/java/com/ossez/area/circle/CircleArea.java b/java-numbers-2/src/main/java/com/ossez/area/circle/CircleArea.java
new file mode 100644
index 0000000000..5003547b27
--- /dev/null
+++ b/java-numbers-2/src/main/java/com/ossez/area/circle/CircleArea.java
@@ -0,0 +1,36 @@
+package com.ossez.area.circle;
+
+import java.util.InputMismatchException;
+import java.util.Scanner;
+
+public class CircleArea {
+
+ public static void main(String[] args) {
+ if (args.length > 0) {
+ try {
+ double radius = Double.parseDouble(args[0]);
+ calculateArea(radius);
+ } catch (NumberFormatException nfe) {
+ System.out.println("Invalid value for radius");
+ System.exit(0);
+ }
+ }
+
+ try (Scanner scanner = new Scanner(System.in)) {
+ System.out.println("Please enter radius value: ");
+ double radius = scanner.nextDouble();
+ calculateArea(radius);
+ } catch (InputMismatchException e) {
+ System.out.println("Invalid value for radius");
+ System.exit(0);
+ }
+
+ Circle circle = new Circle(7);
+ System.out.println(circle);
+ }
+
+ private static void calculateArea(double radius) {
+ double area = radius * radius * Math.PI;
+ System.out.println("The area of the circle [radius = " + radius + "]: " + area);
+ }
+}
diff --git a/java-numbers-2/src/main/java/com/ossez/binarynumbers/BinaryNumbers.java b/java-numbers-2/src/main/java/com/ossez/binarynumbers/BinaryNumbers.java
new file mode 100644
index 0000000000..8f941bb7bd
--- /dev/null
+++ b/java-numbers-2/src/main/java/com/ossez/binarynumbers/BinaryNumbers.java
@@ -0,0 +1,140 @@
+package com.ossez.binarynumbers;
+
+public class BinaryNumbers {
+
+ /**
+ * This method takes a decimal number and convert it into a binary number.
+ * example:- input:10, output:1010
+ *
+ * @param decimalNumber
+ * @return binary number
+ */
+ public Integer convertDecimalToBinary(Integer decimalNumber) {
+
+ if (decimalNumber == 0) {
+ return decimalNumber;
+ }
+
+ StringBuilder binaryNumber = new StringBuilder();
+ Integer quotient = decimalNumber;
+
+ while (quotient > 0) {
+
+ int remainder = quotient % 2;
+ binaryNumber.append(remainder);
+ quotient /= 2;
+ }
+
+ binaryNumber = binaryNumber.reverse();
+ return Integer.valueOf(binaryNumber.toString());
+ }
+
+ /**
+ * This method takes a binary number and convert it into a decimal number.
+ * example:- input:101, output:5
+ *
+ * @param binary number
+ * @return decimal Number
+ */
+ public Integer convertBinaryToDecimal(Integer binaryNumber) {
+
+ Integer decimalNumber = 0;
+ Integer base = 1;
+
+ while (binaryNumber > 0) {
+
+ int lastDigit = binaryNumber % 10;
+ binaryNumber = binaryNumber / 10;
+
+ decimalNumber += lastDigit * base;
+ base = base * 2;
+ }
+ return decimalNumber;
+ }
+
+ /**
+ * This method accepts two binary numbers and returns sum of input numbers.
+ * Example:- firstNum: 101, secondNum: 100, output: 1001
+ *
+ * @param firstNum
+ * @param secondNum
+ * @return addition of input numbers
+ */
+ public Integer addBinaryNumber(Integer firstNum, Integer secondNum) {
+
+ StringBuilder output = new StringBuilder();
+
+ int carry = 0;
+ int temp;
+
+ while (firstNum != 0 || secondNum != 0) {
+
+ temp = (firstNum % 10 + secondNum % 10 + carry) % 2;
+ output.append(temp);
+
+ carry = (firstNum % 10 + secondNum % 10 + carry) / 2;
+
+ firstNum = firstNum / 10;
+ secondNum = secondNum / 10;
+ }
+
+ if (carry != 0) {
+ output.append(carry);
+ }
+
+ return Integer.valueOf(output.reverse()
+ .toString());
+ }
+
+ /**
+ * This method takes two binary number as input and subtract second number from the first number.
+ * example:- firstNum: 1000, secondNum: 11, output: 101
+ * @param firstNum
+ * @param secondNum
+ * @return Result of subtraction of secondNum from first
+ */
+ public Integer substractBinaryNumber(Integer firstNum, Integer secondNum) {
+
+ int onesComplement = Integer.valueOf(getOnesComplement(secondNum));
+ StringBuilder output = new StringBuilder();
+ int carry = 0;
+ int temp;
+
+ while (firstNum != 0 || onesComplement != 0) {
+
+ temp = (firstNum % 10 + onesComplement % 10 + carry) % 2;
+ output.append(temp);
+
+ carry = (firstNum % 10 + onesComplement % 10 + carry) / 2;
+
+ firstNum = firstNum / 10;
+ onesComplement = onesComplement / 10;
+ }
+
+ String additionOfFirstNumAndOnesComplement = output.reverse()
+ .toString();
+
+ if (carry == 1) {
+ return addBinaryNumber(Integer.valueOf(additionOfFirstNumAndOnesComplement), carry);
+ } else {
+ return getOnesComplement(Integer.valueOf(additionOfFirstNumAndOnesComplement));
+ }
+ }
+
+ public Integer getOnesComplement(Integer num) {
+
+ StringBuilder onesComplement = new StringBuilder();
+ while (num > 0) {
+ int lastDigit = num % 10;
+ if (lastDigit == 0) {
+ onesComplement.append(1);
+ } else {
+ onesComplement.append(0);
+ }
+ num = num / 10;
+ }
+ return Integer.valueOf(onesComplement.reverse()
+ .toString());
+ }
+
+}
\ No newline at end of file
diff --git a/java-numbers-2/src/main/java/com/ossez/lcm/BigIntegerLCM.java b/java-numbers-2/src/main/java/com/ossez/lcm/BigIntegerLCM.java
new file mode 100644
index 0000000000..5c61817ac8
--- /dev/null
+++ b/java-numbers-2/src/main/java/com/ossez/lcm/BigIntegerLCM.java
@@ -0,0 +1,13 @@
+package com.ossez.lcm;
+
+import java.math.BigInteger;
+
+public class BigIntegerLCM {
+
+ public static BigInteger lcm(BigInteger number1, BigInteger number2) {
+ BigInteger gcd = number1.gcd(number2);
+ BigInteger absProduct = number1.multiply(number2).abs();
+ return absProduct.divide(gcd);
+ }
+
+}
diff --git a/java-numbers-2/src/main/java/com/ossez/lcm/EuclideanAlgorithm.java b/java-numbers-2/src/main/java/com/ossez/lcm/EuclideanAlgorithm.java
new file mode 100644
index 0000000000..de169bf7fd
--- /dev/null
+++ b/java-numbers-2/src/main/java/com/ossez/lcm/EuclideanAlgorithm.java
@@ -0,0 +1,40 @@
+package com.ossez.lcm;
+
+import java.util.Arrays;
+
+public class EuclideanAlgorithm {
+
+ public static int gcd(int number1, int number2) {
+ if (number1 == 0 || number2 == 0) {
+ return number1 + number2;
+ } else {
+ int absNumber1 = Math.abs(number1);
+ int absNumber2 = Math.abs(number2);
+ int biggerValue = Math.max(absNumber1, absNumber2);
+ int smallerValue = Math.min(absNumber1, absNumber2);
+ return gcd(biggerValue % smallerValue, smallerValue);
+ }
+ }
+
+ public static int lcm(int number1, int number2) {
+ if (number1 == 0 || number2 == 0)
+ return 0;
+ else {
+ int gcd = gcd(number1, number2);
+ return Math.abs(number1 * number2) / gcd;
+ }
+ }
+
+ public static int lcmForArray(int[] numbers) {
+ int lcm = numbers[0];
+ for (int i = 1; i <= numbers.length - 1; i++) {
+ lcm = lcm(lcm, numbers[i]);
+ }
+ return lcm;
+ }
+
+ public static int lcmByLambda(int... numbers) {
+ return Arrays.stream(numbers).reduce(1, (lcmSoFar, currentNumber) -> Math.abs(lcmSoFar * currentNumber) / gcd(lcmSoFar, currentNumber));
+ }
+
+}
diff --git a/java-numbers-2/src/main/java/com/ossez/lcm/PrimeFactorizationAlgorithm.java b/java-numbers-2/src/main/java/com/ossez/lcm/PrimeFactorizationAlgorithm.java
new file mode 100644
index 0000000000..62872285d2
--- /dev/null
+++ b/java-numbers-2/src/main/java/com/ossez/lcm/PrimeFactorizationAlgorithm.java
@@ -0,0 +1,42 @@
+package com.ossez.lcm;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+public class PrimeFactorizationAlgorithm {
+
+ public static Map getPrimeFactors(int number) {
+ int absNumber = Math.abs(number);
+ Map primeFactorsMap = new HashMap();
+ for (int factor = 2; factor <= absNumber; factor++) {
+ while (absNumber % factor == 0) {
+ Integer power = primeFactorsMap.get(factor);
+ if (power == null) {
+ power = 0;
+ }
+ primeFactorsMap.put(factor, power + 1);
+ absNumber /= factor;
+ }
+ }
+ return primeFactorsMap;
+ }
+
+ public static int lcm(int number1, int number2) {
+ if (number1 == 0 || number2 == 0) {
+ return 0;
+ }
+ Map primeFactorsForNum1 = getPrimeFactors(number1);
+ Map primeFactorsForNum2 = getPrimeFactors(number2);
+ Set primeFactorsUnionSet = new HashSet(primeFactorsForNum1.keySet());
+ primeFactorsUnionSet.addAll(primeFactorsForNum2.keySet());
+ int lcm = 1;
+ for (Integer primeFactor : primeFactorsUnionSet) {
+ lcm *= Math.pow(primeFactor, Math.max(primeFactorsForNum1.getOrDefault(primeFactor, 0),
+ primeFactorsForNum2.getOrDefault(primeFactor, 0)));
+ }
+ return lcm;
+ }
+
+}
diff --git a/java-numbers-2/src/main/java/com/ossez/lcm/SimpleAlgorithm.java b/java-numbers-2/src/main/java/com/ossez/lcm/SimpleAlgorithm.java
new file mode 100644
index 0000000000..4e3bc550e4
--- /dev/null
+++ b/java-numbers-2/src/main/java/com/ossez/lcm/SimpleAlgorithm.java
@@ -0,0 +1,18 @@
+package com.ossez.lcm;
+
+public class SimpleAlgorithm {
+ public static int lcm(int number1, int number2) {
+ if (number1 == 0 || number2 == 0) {
+ return 0;
+ }
+ int absNumber1 = Math.abs(number1);
+ int absNumber2 = Math.abs(number2);
+ int absHigherNumber = Math.max(absNumber1, absNumber2);
+ int absLowerNumber = Math.min(absNumber1, absNumber2);
+ int lcm = absHigherNumber;
+ while (lcm % absLowerNumber != 0) {
+ lcm += absHigherNumber;
+ }
+ return lcm;
+ }
+}
diff --git a/java-numbers-2/src/main/java/com/ossez/nan/NaNExample.java b/java-numbers-2/src/main/java/com/ossez/nan/NaNExample.java
new file mode 100644
index 0000000000..3ffcdce30e
--- /dev/null
+++ b/java-numbers-2/src/main/java/com/ossez/nan/NaNExample.java
@@ -0,0 +1,81 @@
+package com.ossez.nan;
+
+/**
+ * Sample usage of NaN.
+ *
+ */
+public class NaNExample {
+
+ public static void main(String[] args) {
+ NaNExample naNExample = new NaNExample();
+ naNExample.demo();
+ }
+
+ void demo() {
+ undefined_operations_produce_NaN();
+ operations_with_no_real_results_produce_NaN();
+ operations_with_NaN_produce_NaN();
+ comparison_with_NaN();
+ check_if_a_value_is_NaN();
+ assign_NaN_to_missing_values();
+ }
+
+ void undefined_operations_produce_NaN() {
+ System.out.println("Undefined Operations Produce NaN");
+ final double ZERO = 0;
+ System.out.println("ZERO / ZERO = " + (ZERO / ZERO));
+ System.out.println("INFINITY - INFINITY = " + (Double.POSITIVE_INFINITY - Double.POSITIVE_INFINITY));
+ System.out.println("INFINITY * ZERO = " + (Double.POSITIVE_INFINITY * ZERO));
+ System.out.println();
+ }
+
+ void operations_with_no_real_results_produce_NaN() {
+ System.out.println("Operations with no real results produce NaN");
+ System.out.println("SQUARE ROOT OF -1 = " + Math.sqrt(-1));
+ System.out.println("LOG OF -1 = " + Math.log(-1));
+ System.out.println();
+ }
+
+ void operations_with_NaN_produce_NaN() {
+ System.out.println("Operations with NaN produce NaN");
+ System.out.println("2 + NaN = " + (2 + Double.NaN));
+ System.out.println("2 - NaN = " + (2 - Double.NaN));
+ System.out.println("2 * NaN = " + (2 * Double.NaN));
+ System.out.println("2 / NaN = " + (2 / Double.NaN));
+ System.out.println();
+ }
+
+ void assign_NaN_to_missing_values() {
+ System.out.println("Assign NaN to Missing values");
+ double salaryRequired = Double.NaN;
+ System.out.println(salaryRequired);
+ System.out.println();
+ }
+
+ void comparison_with_NaN() {
+ System.out.println("Comparison with NaN");
+ final double NAN = Double.NaN;
+ System.out.println("NaN == 1 = " + (NAN == 1));
+ System.out.println("NaN > 1 = " + (NAN > 1));
+ System.out.println("NaN < 1 = " + (NAN < 1));
+ System.out.println("NaN != 1 = " + (NAN != 1));
+ System.out.println("NaN == NaN = " + (NAN == NAN));
+ System.out.println("NaN > NaN = " + (NAN > NAN));
+ System.out.println("NaN < NaN = " + (NAN < NAN));
+ System.out.println("NaN != NaN = " + (NAN != NAN));
+ System.out.println();
+ }
+
+ void check_if_a_value_is_NaN() {
+ System.out.println("Check if a value is NaN");
+ double x = 1;
+ System.out.println(x + " is NaN = " + (x != x));
+ System.out.println(x + " is NaN = " + (Double.isNaN(x)));
+
+ x = Double.NaN;
+ System.out.println(x + " is NaN = " + (x != x));
+ System.out.println(x + " is NaN = " + (Double.isNaN(x)));
+ System.out.println();
+ }
+
+}
diff --git a/java-numbers-2/src/main/java/com/ossez/pow/PowerExample.java b/java-numbers-2/src/main/java/com/ossez/pow/PowerExample.java
new file mode 100644
index 0000000000..67ebbdbce0
--- /dev/null
+++ b/java-numbers-2/src/main/java/com/ossez/pow/PowerExample.java
@@ -0,0 +1,19 @@
+package com.ossez.pow;
+
+import java.text.DecimalFormat;
+
+public class PowerExample {
+
+ public static void main(String[] args) {
+
+ int intResult = (int) Math.pow(2, 3);
+ System.out.println("Math.pow(2, 3) = " + intResult);
+
+ double dblResult = Math.pow(4.2, 3);
+ System.out.println("Math.pow(4.2, 3) = " + Math.pow(4.2, 3));
+
+ DecimalFormat df = new DecimalFormat(".00");
+ System.out.println("Math.pow(4.2, 3) rounded = " + df.format(dblResult));
+
+ }
+}
diff --git a/java-numbers-2/src/main/java/com/ossez/prime/PrimeGenerator.java b/java-numbers-2/src/main/java/com/ossez/prime/PrimeGenerator.java
new file mode 100644
index 0000000000..db7b36b88e
--- /dev/null
+++ b/java-numbers-2/src/main/java/com/ossez/prime/PrimeGenerator.java
@@ -0,0 +1,59 @@
+package com.ossez.prime;
+
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class PrimeGenerator {
+ public static List sieveOfEratosthenes(int n) {
+ final boolean prime[] = new boolean[n + 1];
+ Arrays.fill(prime, true);
+
+ for (int p = 2; p * p <= n; p++) {
+ if (prime[p]) {
+ for (int i = p * 2; i <= n; i += p)
+ prime[i] = false;
+ }
+ }
+
+ final List primes = new LinkedList<>();
+ for (int i = 2; i <= n; i++) {
+ if (prime[i])
+ primes.add(i);
+ }
+ return primes;
+ }
+
+ public static List primeNumbersBruteForce(int max) {
+ final List primeNumbers = new LinkedList();
+ for (int i = 2; i <= max; i++) {
+ if (isPrimeBruteForce(i)) {
+ primeNumbers.add(i);
+ }
+ }
+ return primeNumbers;
+ }
+
+ private static boolean isPrimeBruteForce(int x) {
+ for (int i = 2; i < x; i++) {
+ if (x % i == 0) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ public static List primeNumbersTill(int max) {
+ return IntStream.rangeClosed(2, max)
+ .filter(x -> isPrime(x))
+ .boxed()
+ .collect(Collectors.toList());
+ }
+
+ private static boolean isPrime(int x) {
+ return IntStream.rangeClosed(2, (int) (Math.sqrt(x)))
+ .allMatch(n -> x % n != 0);
+ }
+}
diff --git a/java-numbers-2/src/test/java/com/ossez/algorithms/primechecker/PrimeCheckerUnitTest.java b/java-numbers-2/src/test/java/com/ossez/algorithms/primechecker/PrimeCheckerUnitTest.java
new file mode 100644
index 0000000000..f9d7a33e61
--- /dev/null
+++ b/java-numbers-2/src/test/java/com/ossez/algorithms/primechecker/PrimeCheckerUnitTest.java
@@ -0,0 +1,74 @@
+package com.ossez.algorithms.primechecker;
+
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+
+public class PrimeCheckerUnitTest {
+
+ private final BigIntegerPrimeChecker primeChecker = new BigIntegerPrimeChecker();
+
+ @Test
+ public void whenCheckIsPrime_thenTrue() {
+ assertTrue(primeChecker.isPrime(2L));
+ assertTrue(primeChecker.isPrime(13L));
+ assertTrue(primeChecker.isPrime(1009L));
+ assertTrue(primeChecker.isPrime(74207281L));
+ }
+
+ @Test
+ public void whenCheckIsPrime_thenFalse() {
+ assertFalse(primeChecker.isPrime(50L));
+ assertFalse(primeChecker.isPrime(1001L));
+ assertFalse(primeChecker.isPrime(74207282L));
+ }
+
+ private final BruteForcePrimeChecker bfPrimeChecker = new BruteForcePrimeChecker();
+
+ @Test
+ public void whenBFCheckIsPrime_thenTrue() {
+ assertTrue(bfPrimeChecker.isPrime(2));
+ assertTrue(bfPrimeChecker.isPrime(13));
+ assertTrue(bfPrimeChecker.isPrime(1009));
+ }
+
+ @Test
+ public void whenBFCheckIsPrime_thenFalse() {
+ assertFalse(bfPrimeChecker.isPrime(50));
+ assertFalse(bfPrimeChecker.isPrime(1001));
+ }
+
+ private final OptimisedPrimeChecker optimisedPrimeChecker = new OptimisedPrimeChecker();
+
+ @Test
+ public void whenOptCheckIsPrime_thenTrue() {
+ assertTrue(optimisedPrimeChecker.isPrime(2));
+ assertTrue(optimisedPrimeChecker.isPrime(13));
+ assertTrue(optimisedPrimeChecker.isPrime(1009));
+ }
+
+ @Test
+ public void whenOptCheckIsPrime_thenFalse() {
+ assertFalse(optimisedPrimeChecker.isPrime(50));
+ assertFalse(optimisedPrimeChecker.isPrime(1001));
+ }
+
+ private final PrimesPrimeChecker primesPrimeChecker = new PrimesPrimeChecker();
+
+ @Test
+ public void whenPrimesCheckIsPrime_thenTrue() {
+ assertTrue(primesPrimeChecker.isPrime(2));
+ assertTrue(primesPrimeChecker.isPrime(13));
+ assertTrue(primesPrimeChecker.isPrime(1009));
+ }
+
+ @Test
+ public void whenPrimesCheckIsPrime_thenFalse() {
+ assertFalse(primesPrimeChecker.isPrime(50));
+ assertFalse(primesPrimeChecker.isPrime(1001));
+ }
+
+}
diff --git a/java-numbers-2/src/test/java/com/ossez/binarynumbers/BinaryNumbersUnitTest.java b/java-numbers-2/src/test/java/com/ossez/binarynumbers/BinaryNumbersUnitTest.java
new file mode 100644
index 0000000000..f3c2631082
--- /dev/null
+++ b/java-numbers-2/src/test/java/com/ossez/binarynumbers/BinaryNumbersUnitTest.java
@@ -0,0 +1,73 @@
+package com.ossez.binarynumbers;
+
+import static org.junit.Assert.assertEquals;
+
+import org.junit.Test;
+
+public class BinaryNumbersUnitTest {
+
+ private BinaryNumbers binaryNumbers = new BinaryNumbers();
+
+ @Test
+ public void given_decimalNumber_then_returnBinaryNumber() {
+ assertEquals(Integer.valueOf(1000), binaryNumbers.convertDecimalToBinary(8));
+ assertEquals(Integer.valueOf(10100), binaryNumbers.convertDecimalToBinary(20));
+ }
+
+ @Test
+ public void given_decimalNumber_then_convertToBinaryNumber() {
+ assertEquals("1000", Integer.toBinaryString(8));
+ assertEquals("10100", Integer.toBinaryString(20));
+ }
+
+ @Test
+ public void given_binaryNumber_then_ConvertToDecimalNumber() {
+ assertEquals(8, Integer.parseInt("1000", 2));
+ assertEquals(20, Integer.parseInt("10100", 2));
+ }
+
+ @Test
+ public void given_binaryNumber_then_returnDecimalNumber() {
+ assertEquals(Integer.valueOf(8), binaryNumbers.convertBinaryToDecimal(1000));
+ assertEquals(Integer.valueOf(20), binaryNumbers.convertBinaryToDecimal(10100));
+ }
+
+ @Test
+ public void given_twoBinaryNumber_then_returnAddition() {
+ // adding 4 and 10
+ assertEquals(Integer.valueOf(1110), binaryNumbers.addBinaryNumber(100, 1010));
+
+ // adding 26 and 14
+ assertEquals(Integer.valueOf(101000), binaryNumbers.addBinaryNumber(11010, 1110));
+ }
+
+ @Test
+ public void given_twoBinaryNumber_then_returnSubtraction() {
+ // subtracting 16 from 25
+ assertEquals(Integer.valueOf(1001), binaryNumbers.substractBinaryNumber(11001, 10000));
+
+ // subtracting 29 from 16, the output here is negative
+ assertEquals(Integer.valueOf(1101), binaryNumbers.substractBinaryNumber(10000, 11101));
+ }
+
+ @Test
+ public void given_binaryLiteral_thenReturnDecimalValue() {
+
+ byte five = 0b101;
+ assertEquals((byte) 5, five);
+
+ short three = 0b11;
+ assertEquals((short) 3, three);
+
+ int nine = 0B1001;
+ assertEquals(9, nine);
+
+ long twentyNine = 0B11101;
+ assertEquals(29, twentyNine);
+
+ int minusThirtySeven = -0B100101;
+ assertEquals(-37, minusThirtySeven);
+
+ }
+
+}
diff --git a/java-numbers-2/src/test/java/com/ossez/java/math/MathUnitTest.java b/java-numbers-2/src/test/java/com/ossez/java/math/MathUnitTest.java
new file mode 100644
index 0000000000..86a3767048
--- /dev/null
+++ b/java-numbers-2/src/test/java/com/ossez/java/math/MathUnitTest.java
@@ -0,0 +1,175 @@
+package com.ossez.java.math;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class MathUnitTest {
+
+ @Test
+ public void whenAbsInteger_thenReturnAbsoluteValue() {
+ assertEquals(5,Math.abs(-5));
+ }
+
+ @Test
+ public void whenMaxBetweenTwoValue_thenReturnMaximum() {
+ assertEquals(10, Math.max(5,10));
+ }
+
+ @Test
+ public void whenMinBetweenTwoValue_thenReturnMinimum() {
+ assertEquals(5, Math.min(5,10));
+ }
+
+ @Test
+ public void whenSignumWithNegativeNumber_thenReturnMinusOne() {
+ assertEquals(-1, Math.signum(-5), 0);
+ }
+
+ @Test
+ public void whenCopySignWithNegativeSign_thenReturnNegativeArgument() {
+ assertEquals(-5, Math.copySign(5,-1), 0);
+ }
+
+ @Test
+ public void whenPow_thenReturnPoweredValue() {
+ assertEquals(25, Math.pow(5,2),0);
+ }
+
+ @Test
+ public void whenSqrt_thenReturnSquareRoot() {
+ assertEquals(5, Math.sqrt(25),0);
+ }
+
+ @Test
+ public void whenCbrt_thenReturnCubeRoot() {
+ assertEquals(5, Math.cbrt(125),0);
+ }
+
+ @Test
+ public void whenExp_thenReturnEulerNumberRaised() {
+ assertEquals(2.718, Math.exp(1),0.1);
+ }
+
+ @Test
+ public void whenExpm1_thenReturnEulerNumberMinusOne() {
+ assertEquals(1.718, Math.expm1(1),0.1);
+ }
+
+ @Test
+ public void whenGetExponent_thenReturnUnbiasedExponent() {
+ assertEquals(8, Math.getExponent(333.3),0);
+ assertEquals(7, Math.getExponent(222.2f),0);
+ }
+
+ @Test
+ public void whenLog_thenReturnValue() {
+ assertEquals(1, Math.log(Math.E),0);
+ }
+
+ @Test
+ public void whenLog10_thenReturnValue() {
+ assertEquals(1, Math.log10(10),0);
+ }
+
+ @Test
+ public void whenLog1p_thenReturnValue() {
+ assertEquals(1.31, Math.log1p(Math.E),0.1);
+ }
+
+ @Test
+ public void whenSin_thenReturnValue() {
+ assertEquals(1, Math.sin(Math.PI/2),0);
+ }
+
+ @Test
+ public void whenCos_thenReturnValue() {
+ assertEquals(1, Math.cos(0),0);
+ }
+
+ @Test
+ public void whenTan_thenReturnValue() {
+ assertEquals(1, Math.tan(Math.PI/4),0.1);
+ }
+
+ @Test
+ public void whenAsin_thenReturnValue() {
+ assertEquals(Math.PI/2, Math.asin(1),0);
+ }
+
+ @Test
+ public void whenAcos_thenReturnValue() {
+ assertEquals(Math.PI/2, Math.acos(0),0);
+ }
+
+ @Test
+ public void whenAtan_thenReturnValue() {
+ assertEquals(Math.PI/4, Math.atan(1),0);
+ }
+
+ @Test
+ public void whenAtan2_thenReturnValue() {
+ assertEquals(Math.PI/4, Math.atan2(1,1),0);
+ }
+
+ @Test
+ public void whenToDegrees_thenReturnValue() {
+ assertEquals(180, Math.toDegrees(Math.PI),0);
+ }
+
+ @Test
+ public void whenToRadians_thenReturnValue() {
+ assertEquals(Math.PI, Math.toRadians(180),0);
+ }
+
+ @Test
+ public void whenCeil_thenReturnValue() {
+ assertEquals(4, Math.ceil(Math.PI),0);
+ }
+
+ @Test
+ public void whenFloor_thenReturnValue() {
+ assertEquals(3, Math.floor(Math.PI),0);
+ }
+
+ @Test
+ public void whenGetExponent_thenReturnValue() {
+ assertEquals(8, Math.getExponent(333.3),0);
+ }
+
+ @Test
+ public void whenIEEERemainder_thenReturnValue() {
+ assertEquals(1.0, Math.IEEEremainder(5,2),0);
+ }
+
+ @Test
+ public void whenNextAfter_thenReturnValue() {
+ assertEquals(1.9499999284744263, Math.nextAfter(1.95f,1),0.0000001);
+ }
+
+ @Test
+ public void whenNextUp_thenReturnValue() {
+ assertEquals(1.9500002, Math.nextUp(1.95f),0.0000001);
+ }
+
+ @Test
+ public void whenRint_thenReturnValue() {
+ assertEquals(2.0, Math.rint(1.95f),0.0);
+ }
+
+ @Test
+ public void whenRound_thenReturnValue() {
+ assertEquals(2.0, Math.round(1.95f),0.0);
+ }
+
+ @Test
+ public void whenScalb_thenReturnValue() {
+ assertEquals(48, Math.scalb(3, 4),0.0);
+ }
+
+ @Test
+ public void whenHypot_thenReturnValue() {
+ assertEquals(5, Math.hypot(4, 3),0.0);
+ }
+
+}
diff --git a/java-numbers-2/src/test/java/com/ossez/lcm/BigIntegerLCMUnitTest.java b/java-numbers-2/src/test/java/com/ossez/lcm/BigIntegerLCMUnitTest.java
new file mode 100644
index 0000000000..3b3fc0f81c
--- /dev/null
+++ b/java-numbers-2/src/test/java/com/ossez/lcm/BigIntegerLCMUnitTest.java
@@ -0,0 +1,18 @@
+package com.ossez.lcm;
+
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.math.BigInteger;
+
+public class BigIntegerLCMUnitTest {
+
+ @Test
+ public void testLCM() {
+ BigInteger number1 = new BigInteger("12");
+ BigInteger number2 = new BigInteger("18");
+ BigInteger expectedLCM = new BigInteger("36");
+ Assert.assertEquals(expectedLCM, BigIntegerLCM.lcm(number1, number2));
+ }
+}
diff --git a/java-numbers-2/src/test/java/com/ossez/lcm/EuclideanAlgorithmUnitTest.java b/java-numbers-2/src/test/java/com/ossez/lcm/EuclideanAlgorithmUnitTest.java
new file mode 100644
index 0000000000..890dbb79d8
--- /dev/null
+++ b/java-numbers-2/src/test/java/com/ossez/lcm/EuclideanAlgorithmUnitTest.java
@@ -0,0 +1,27 @@
+package com.ossez.lcm;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class EuclideanAlgorithmUnitTest {
+
+ @Test
+ public void testGCD() {
+ Assert.assertEquals(6, EuclideanAlgorithm.gcd(12, 18));
+ }
+
+ @Test
+ public void testLCM() {
+ Assert.assertEquals(36, EuclideanAlgorithm.lcm(12, 18));
+ }
+
+ @Test
+ public void testLCMForArray() {
+ Assert.assertEquals(15, EuclideanAlgorithm.lcmForArray(new int[]{3, 5, 15}));
+ }
+
+ @Test
+ public void testLCMByLambdaForArray() {
+ Assert.assertEquals(15, EuclideanAlgorithm.lcmByLambda(new int[]{3, 5, 15}));
+ }
+}
diff --git a/java-numbers-2/src/test/java/com/ossez/lcm/PrimeFactorizationAlgorithmUnitTest.java b/java-numbers-2/src/test/java/com/ossez/lcm/PrimeFactorizationAlgorithmUnitTest.java
new file mode 100644
index 0000000000..7cb3bbbd92
--- /dev/null
+++ b/java-numbers-2/src/test/java/com/ossez/lcm/PrimeFactorizationAlgorithmUnitTest.java
@@ -0,0 +1,28 @@
+package com.ossez.lcm;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+
+
+public class PrimeFactorizationAlgorithmUnitTest {
+
+ @Test
+ public void testGetPrimeFactors() {
+ Map expectedPrimeFactorsMapForTwelve = new HashMap<>();
+ expectedPrimeFactorsMapForTwelve.put(2, 2);
+ expectedPrimeFactorsMapForTwelve.put(3, 1);
+ Map expectedPrimeFactorsMapForEighteen = new HashMap<>();
+ expectedPrimeFactorsMapForEighteen.put(2, 1);
+ expectedPrimeFactorsMapForEighteen.put(3, 2);
+ Assert.assertEquals(expectedPrimeFactorsMapForTwelve, getPrimeFactors(12));
+ Assert.assertEquals(expectedPrimeFactorsMapForEighteen, getPrimeFactors(18));
+ }
+
+ @Test
+ public void testLCM() {
+ Assert.assertEquals(36, PrimeFactorizationAlgorithm.lcm(12, 18));
+ }
+}
diff --git a/java-numbers-2/src/test/java/com/ossez/lcm/SimpleAlgorithmUnitTest.java b/java-numbers-2/src/test/java/com/ossez/lcm/SimpleAlgorithmUnitTest.java
new file mode 100644
index 0000000000..05df73c058
--- /dev/null
+++ b/java-numbers-2/src/test/java/com/ossez/lcm/SimpleAlgorithmUnitTest.java
@@ -0,0 +1,13 @@
+package com.ossez.lcm;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class SimpleAlgorithmUnitTest {
+
+ @Test
+ public void testLCM() {
+ Assert.assertEquals(36, lcm(12, 18));
+ }
+
+}
diff --git a/java-numbers-2/src/test/java/com/ossez/lossyconversion/ConversionTechniquesUnitTest.java b/java-numbers-2/src/test/java/com/ossez/lossyconversion/ConversionTechniquesUnitTest.java
new file mode 100644
index 0000000000..061f240ef2
--- /dev/null
+++ b/java-numbers-2/src/test/java/com/ossez/lossyconversion/ConversionTechniquesUnitTest.java
@@ -0,0 +1,68 @@
+package com.ossez.lossyconversion;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.jupiter.api.Test;
+
+public class ConversionTechniquesUnitTest {
+
+ @Test
+ public void testPrimitiveConversion() {
+
+ long longNum = 24;
+ short shortNum = (short) longNum;
+ assertEquals(24, shortNum);
+
+ double doubleNum = 15.6;
+ int integerNum = (int) doubleNum;
+ assertEquals(15, integerNum);
+
+ long largeLongNum = 32768;
+ short minShortNum = (short) largeLongNum;
+ assertEquals(-32768, minShortNum);
+
+ long smallLongNum = -32769;
+ short maxShortNum = (short) smallLongNum;
+ assertEquals(32767, maxShortNum);
+
+ long maxLong = Long.MAX_VALUE;
+ int minInt = (int) maxLong;
+ assertEquals(-1, minInt);
+
+ long minLong = Long.MIN_VALUE;
+ int maxInt = (int) minLong;
+ assertEquals(0, maxInt);
+ }
+
+ @Test
+ public void testWrapperToPrimitiveConversion() {
+
+ Float floatNum = 17.564f;
+ long longNum = floatNum.longValue();
+ assertEquals(17, longNum);
+
+ Double doubleNum = 15.9999;
+ longNum = doubleNum.longValue();
+ assertEquals(15, longNum);
+ }
+
+ @Test
+ public void testWrapperToPrimitiveConversionUsingMathRound() {
+
+ Double doubleNum = 15.9999;
+ long longNum = Math.round(doubleNum);
+ assertEquals(16, longNum);
+ }
+
+ @Test
+ public void testWrapperConversion() {
+
+ Double doubleNum = 10.3;
+ double dbl = doubleNum.doubleValue(); //unboxing
+ int intgr = (int) dbl; //downcasting
+ Integer intNum = Integer.valueOf(intgr);
+ assertEquals(Integer.valueOf(10), intNum);
+ }
+
+}
diff --git a/java-numbers-2/src/test/java/com/ossez/prime/PrimeGeneratorUnitTest.java b/java-numbers-2/src/test/java/com/ossez/prime/PrimeGeneratorUnitTest.java
new file mode 100644
index 0000000000..543aac7d88
--- /dev/null
+++ b/java-numbers-2/src/test/java/com/ossez/prime/PrimeGeneratorUnitTest.java
@@ -0,0 +1,29 @@
+package com.ossez.prime;
+
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static com.ossez.prime.PrimeGenerator.*;
+import static org.junit.Assert.*;
+
+public class PrimeGeneratorUnitTest {
+ @Test
+ public void whenBruteForced_returnsSuccessfully() {
+ final List primeNumbers = primeNumbersBruteForce(20);
+ assertEquals(Arrays.asList(new Integer[] { 2, 3, 5, 7, 11, 13, 17, 19 }), primeNumbers);
+ }
+
+ @Test
+ public void whenOptimized_returnsSuccessfully() {
+ final List primeNumbers = primeNumbersTill(20);
+ assertEquals(Arrays.asList(new Integer[] { 2, 3, 5, 7, 11, 13, 17, 19 }), primeNumbers);
+ }
+
+ @Test
+ public void whenSieveOfEratosthenes_returnsSuccessfully() {
+ final List primeNumbers = sieveOfEratosthenes(20);
+ assertEquals(Arrays.asList(new Integer[] { 2, 3, 5, 7, 11, 13, 17, 19 }), primeNumbers);
+ }
+}
diff --git a/java-numbers-2/src/test/java/com/ossez/primechecker/PrimeCheckerUnitTest.java b/java-numbers-2/src/test/java/com/ossez/primechecker/PrimeCheckerUnitTest.java
new file mode 100644
index 0000000000..9c62ceb5ba
--- /dev/null
+++ b/java-numbers-2/src/test/java/com/ossez/primechecker/PrimeCheckerUnitTest.java
@@ -0,0 +1,72 @@
+package com.ossez.primechecker;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+public class PrimeCheckerUnitTest {
+
+ private final BigIntegerPrimeChecker primeChecker = new BigIntegerPrimeChecker();
+
+ @Test
+ public void whenCheckIsPrime_thenTrue() {
+ assertTrue(primeChecker.isPrime(2L));
+ assertTrue(primeChecker.isPrime(13L));
+ assertTrue(primeChecker.isPrime(1009L));
+ assertTrue(primeChecker.isPrime(74207281L));
+ }
+
+ @Test
+ public void whenCheckIsPrime_thenFalse() {
+ assertFalse(primeChecker.isPrime(50L));
+ assertFalse(primeChecker.isPrime(1001L));
+ assertFalse(primeChecker.isPrime(74207282L));
+ }
+
+ private final BruteForcePrimeChecker bfPrimeChecker = new BruteForcePrimeChecker();
+
+ @Test
+ public void whenBFCheckIsPrime_thenTrue() {
+ assertTrue(bfPrimeChecker.isPrime(2));
+ assertTrue(bfPrimeChecker.isPrime(13));
+ assertTrue(bfPrimeChecker.isPrime(1009));
+ }
+
+ @Test
+ public void whenBFCheckIsPrime_thenFalse() {
+ assertFalse(bfPrimeChecker.isPrime(50));
+ assertFalse(bfPrimeChecker.isPrime(1001));
+ }
+
+ private final OptimisedPrimeChecker optimisedPrimeChecker = new OptimisedPrimeChecker();
+
+ @Test
+ public void whenOptCheckIsPrime_thenTrue() {
+ assertTrue(optimisedPrimeChecker.isPrime(2));
+ assertTrue(optimisedPrimeChecker.isPrime(13));
+ assertTrue(optimisedPrimeChecker.isPrime(1009));
+ }
+
+ @Test
+ public void whenOptCheckIsPrime_thenFalse() {
+ assertFalse(optimisedPrimeChecker.isPrime(50));
+ assertFalse(optimisedPrimeChecker.isPrime(1001));
+ }
+
+ private final PrimesPrimeChecker primesPrimeChecker = new PrimesPrimeChecker();
+
+ @Test
+ public void whenPrimesCheckIsPrime_thenTrue() {
+ assertTrue(primesPrimeChecker.isPrime(2));
+ assertTrue(primesPrimeChecker.isPrime(13));
+ assertTrue(primesPrimeChecker.isPrime(1009));
+ }
+
+ @Test
+ public void whenPrimesCheckIsPrime_thenFalse() {
+ assertFalse(primesPrimeChecker.isPrime(50));
+ assertFalse(primesPrimeChecker.isPrime(1001));
+ }
+
+}