Fermat Number in Java

In this section, we will discuss what is Fermat number and also create Java programs to check if the given number is a Fermat number or not. The Fermat number program frequently asked in Java coding interviews and academics.

Fermat Number

Fermat number first studied by Pierre de Fermat. A non-negative odd integer that is in the form of 2²^k +1 (where k>=0) is known as a Fermat number. It is denoted by F_n. It is OEIS integer sequence A000215.

It is difficult to generate Fermat numbers. Since they are used in cryptography and pseudo-random number generation. It also has some powerful mathematical properties.

Fermat Number Example

First few Fermat numbers are 3, 5, 17, 257, 65537, 4294967297, 18446744073709551617.

First 10 Fermat numbers:

F₀ = 2²⁰ +1 = 3

F₁ = 2²¹ +1 = 5

F₂ = 2²² +1 = 17

F₃ = 2²³ +1 = 257

F₄ = 2²⁴ +1 = 65537

F⁵ = 2²⁵ +1=4294967297

F⁶ = 2²⁶ +1=18446744073709551617

F₇ = 2²⁷ +1 = 340282366920938463463374607431768211457

F₈ = 2²⁸ +1 = 115792089237316195423570985008687907853269984665640564039457584007913129639937

F₉ = 2²⁹ +1 =

134078079299425970995740249982058461274793658205923933777235614437217640300
73546976801874298166903427690031858186486050853753882811946569946433649006084097
It is conjectured that just the first 5 numbers in this sequence are primes. It is OEIS sequence A019434.

F₀ = 2²⁰ +1 = 3

F₁ = 2²¹ +1 = 5

F₂ = 2²² +1 = 17

F₃ = 2²³ +1 = 257

F₄ = 2²⁴ +1 = 65537

Steps to Find Fermat Number

Read or initialize an integer n.
Calculate 2ⁿby using the Math.pow() method and store the result in a variable (p).
Now, calculate 2^p and store the result in a variable (res).
Add 1 in the variable (res) store the result in a variable (f). It is a Fermat number.

Let's implement the above steps in a Java program.

Fermat Number Java Program

FermatNumberExample1.java

import java.util.Scanner;
public class FermatNumberExample1
{
public static void main(String args[])
{ 
int n = 0;        
double result;
//executes until the condition becomes false
while (n <= 10) 
{
//logic to find Fermat number 
result = Math.pow (2, Math.pow(2, n)) + 1;
n++;
//prints the result
System.out.println (result);
} //end of while
}  
}

Output:

3.0
5.0
17.0
257.0
65537.0
4.294967297E9
1.8446744073709552E19
3.4028236692093846E38
1.157920892373162E77
1.3407807929942597E154
Infinity

FermatNumberExample.java

import java.math.BigInteger;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class FermatNumbers 
{
public static void main(String[] args) 
{
System.out.println("First 10 Fermat numbers:");
for ( int i = 0 ; i < 10 ; i++ ) 
{
System.out.printf("F[%d] = %s\n", i, fermat(i));
}
System.out.printf("%nFirst 12 Fermat numbers factored:%n");
for ( int i = 0 ; i < 13 ; i++ ) 
{
System.out.printf("F[%d] = %s\n", i, getString(getFactors(i, fermat(i))));
}
}
private static String getString(List<BigInteger> factors) 
{
if ( factors.size() == 1 ) 
{
return factors.get(0) + " (PRIME)";
}
return factors.stream().map(v -> v.toString()).map(v -> v.startsWith("-") ? "(C" + v.replace("-", "") + ")" : v).collect(Collectors.joining(" * "));
}
private static Map<Integer, String> COMPOSITE = new HashMap<>();
static 
{
COMPOSITE.put(9, "5529");
COMPOSITE.put(10, "6078");
COMPOSITE.put(11, "1037");
COMPOSITE.put(12, "5488");
COMPOSITE.put(13, "2884");
}
private static List<BigInteger> getFactors(int fermatIndex, BigInteger n) 
{
List<BigInteger> factors = new ArrayList<>();
BigInteger factor = BigInteger.ONE;
while (true) 
{
if (n.isProbablePrime(100)) 
{
factors.add(n);
break;
}
else 
{
if ( COMPOSITE.containsKey(fermatIndex) ) 
{
String stop = COMPOSITE.get(fermatIndex);
if ( n.toString().startsWith(stop) ) 
{
factors.add(new BigInteger("-" + n.toString().length()));
break;
}
}
factor = pollardRhoFast(n);
if (factor.compareTo(BigInteger.ZERO) == 0 ) 
{
factors.add(n);
break;
}
else 
{
factors.add(factor);
n = n.divide(factor);
}
}
}
return factors;
}
private static final BigInteger TWO = BigInteger.valueOf(2);
private static BigInteger fermat(int n) 
{
return TWO.pow((int)Math.pow(2, n)).add(BigInteger.ONE);
}
//  See:  https://en.wikipedia.org/wiki/Pollard%27s_rho_algorithm
@SuppressWarnings("unused")
private static BigInteger pollardRho(BigInteger n) 
{
BigInteger x = BigInteger.valueOf(2);
BigInteger y = BigInteger.valueOf(2);
BigInteger d = BigInteger.ONE;
while ( d.compareTo(BigInteger.ONE) == 0 ) 
{
x = pollardRhoG(x, n);
y = pollardRhoG(pollardRhoG(y, n), n);
d = x.subtract(y).abs().gcd(n);
}
if (d.compareTo(n) == 0) 
{
return BigInteger.ZERO;
}
return d;
}
//Includes Speed Up of 100 multiples and 1 GCD, instead of 100 multiples and 100 GCDs.
//See Variants section of Wikipedia article.
//Testing F[8] = 1238926361552897 * Prime 
//This variant = 32 sec.
//Standard algorithm = 107 sec.
private static BigInteger pollardRhoFast(BigInteger n) 
{
long start = System.currentTimeMillis();
BigInteger x = BigInteger.valueOf(2);
BigInteger y = BigInteger.valueOf(2);
BigInteger d = BigInteger.ONE;
int count = 0;
BigInteger z = BigInteger.ONE;
while ( true ) 
{
x = pollardRhoG(x, n);
y = pollardRhoG(pollardRhoG(y, n), n);
d = x.subtract(y).abs();
z = z.multiply(d).mod(n);
count++;
if ( count == 100 ) 
{
d = z.gcd(n);
if ( d.compareTo(BigInteger.ONE) != 0 ) 
{
break;
}
z = BigInteger.ONE;
count = 0;
}
}
long end = System.currentTimeMillis();
System.out.printf("    Pollard rho try factor %s elapsed time = %d ms (factor = %s).%n", n, (end-start), d);
if ( d.compareTo(n) == 0 ) 
{
return BigInteger.ZERO;
}
return d;
}
private static BigInteger pollardRhoG(BigInteger x, BigInteger n) 
{
return x.multiply(x).add(BigInteger.ONE).mod(n);
}
}

Output:

First 10 Fermat numbers:
F[0] = 3
F[1] = 5
F[2] = 17
F[3] = 257
F[4] = 65537
F[5] = 4294967297
F[6] = 18446744073709551617
F[7] = 340282366920938463463374607431768211457
F[8] = 115792089237316195423570985008687907853269984665640564039457584007913129639937
F[9] = 13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084097

First 12 Fermat numbers factored:
F[0] = 3 (PRIME)
F[1] = 5 (PRIME)
F[2] = 17 (PRIME)
F[3] = 257 (PRIME)
F[4] = 65537 (PRIME)
    Pollard rho try factor 4294967297 elapsed time = 8 ms (factor = 641).
F[5] = 641 * 6700417
    Pollard rho try factor 18446744073709551617 elapsed time = 33 ms (factor = 274177).
F[6] = 274177 * 67280421310721

Next TopicInstantiation in Java

← prev next →