Bernoulli number in Java

Bernoulli numbers are the special type of numbers that plays an important role in number theory and analysis. These numbers are mainly used in series expansions of several trigonometric, gamma, hyperbolic functions, etc.

Nth Bernoulli number is denoted by B_n that can be defined by the following exponential generating function:

Bernoulli numbers arise in the expansion of the series of trigonometric functions. We have two different definitions for the Bernoulli numbers.

The Bernoulli numbers are written as , as defined in the modern usage or the National Institute of Standards and Technology convention. It is also referred to as "even-index" Bernoulli numbers. The Bernoulli numbers are written as , as per the definition defined in the old literature.

In both of the cases, each Bernoulli number is a special case of the Bernoulli polynomials:

B_n (x) OR B_n^* (x) with B_n=B_n (0) AND B_n^* (0)

We also denote the Bell number and Bell polynomial as B_n and B_n (x), respectively. So, we should not be confused with both of them.

We can define the Bernoulli number B_n by using the following contour integral:

Algorithm

The algorithm to find the "second Bernoulli numbers" is as follows:

for m from 0 by 1 to n do
    A[m] → 1/(m+1)
    for j from m by -1 to 1 do
      A[j-1] → j×(A[j-1] - A[j])
  return A[0] (which is Bn)

Let's implement the code to get N Bernoulli numbers in Java. Before writing the logic to get Bernoulli numbers, we create BigRational.java class that performs the necessary operations for BigDecimal and BigInteger and return the result.

BigRational.java

import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.util.Objects;
// create BigRational class that implements comparable interface
publicclass BigRational implements Comparable<BigRational> {
	// declare and initialization of ZERO, ONE, and TWO variables of type BigRational
publicfinalstatic BigRational ZERO = new BigRational(0);
publicfinalstatic BigRational ONE  = new BigRational(1);
publicfinalstatic BigRational TWO  = new BigRational(2);
    // declare numerator and denominator variables
    // denominator will always be a positive number
private BigInteger num;
private BigInteger den;
    // initialization of BigRational object
public BigRational(int num, int den) {
	this.num = BigInteger.valueOf(num);
	this.den = BigInteger.valueOf(den);
    }
    // create and initialize a new BigRational object
public BigRational(int numerator) {
this(numerator, 1);
    }
    // initialization of BigRational object from a string, e.g., "-343/1273"
public BigRational(String str) {
        // use split() method to break it into sub-string and store them in the array
	String[] tokens = str.split("/");
	// check whether the size of the tokens is equal to 2 or not
if (tokens.length == 2) {
	BigInteger num1 = new BigInteger(tokens[0]);
	BigInteger num2 = new BigInteger(tokens[1]);
            init(num1, num2);
        }
        // check whether the size of the tokens is equal to 1 or not
elseif (tokens.length == 1) {
	BigInteger num1 = new BigInteger(tokens[0]);
            init(num1, BigInteger.ONE);
        }
        // else throw IllegalArgumentException
else
thrownew IllegalArgumentException("For input string: \"" + str + "\"");
    }
    // creation and initialization of BigRational object from a BigInteger
public BigRational(BigInteger num, BigInteger den) {
        // use init() method for initialization object 
	init(num, den);
    }
    // create init() method for initializing object
privatevoid init(BigInteger num, BigInteger den) {
        // check whether the denominator is positive or not
if (den.equals(BigInteger.ZERO)) {
thrownew ArithmeticException("Denominator is zero");
        }
        // reduce fraction (if numerator is 0, it will always yield denominator 0)
        BigInteger g = num.gcd(den);
this.num = num.divide(g);
this.den = den.divide(g);
        // ensure whether the denominator is positive or not
if (this.den.compareTo(BigInteger.ZERO) < 0) {
this.den = den.negate();
this.num = num.negate();
        }
    }
    // return string representation of denominator and numerator
public String toString() { 
        // if numerator is one, return denominator
	if (den.equals(BigInteger.ONE)) 
	return num + "";
	// else return numerator and denominator
	else
	return num + "/" + den;
    }
    // if x < y, return -1
    // if x = y, return 0
    // if x > y, return +1
publicint compareTo(BigRational y) {
	BigRational x = this;
int res = x.num.multiply(y.den).compareTo(x.den.multiply(y.num));

return res;
    }
    // check whether the current BigRational is zero, negative or positive
publicboolean isZero() {
	boolean res = num.signum() == 0;
	return res;
    }
publicboolean isPositive() {
	boolean res = num.signum() >  0;
	return res;
    }
publicboolean isNegative() {
	boolean res = num.signum() <  0;
	return res;
    }
    // check whether the current rational object equal to y or not
publicboolean equals(Object y) {
if (y == this) 
	returntrue;
if (y == null) 
	returnfalse;  
if (y.getClass() != this.getClass()) 
	returnfalse;
        BigRational newBegRational = (BigRational) y;
return compareTo(newBegRational) == 0;
    }
    // hashCode consistent with equals() and compareTo()
publicint hashCode() {
return Objects.hash(num, den);
    }
    // return a * b
public BigRational times(BigRational b) {
        BigRational a = this;
returnnew BigRational(a.num.multiply(b.num), a.den.multiply(b.den));
    }
    // return a + b
public BigRational plus(BigRational b) {
        BigRational a = this;
        BigInteger numerator   = a.num.multiply(b.den).add(b.num.multiply(a.den));
        BigInteger denominator = a.den.multiply(b.den);
returnnew BigRational(numerator, denominator);
    }
    // return -a
public BigRational negate() {
returnnew BigRational(num.negate(), den);
    }
    // return |a|
public BigRational abs() {
if (isNegative()) return negate();
elsereturnthis;
    }
    // return a - b
public BigRational minus(BigRational b) {
        BigRational a = this;
return a.plus(b.negate());
    }
    // return 1 / a
public BigRational reciprocal() {
returnnew BigRational(den, num);
    }
    // return a / b
publicBigRational divides(BigRational b) {
        BigRational a = this;
return a.times(b.reciprocal());
    }
    // return double reprentation (within given precision)
publicdouble doubleValue() {
int SCALE = 32;        // number of digits after the decimal place
        BigDecimal numerator   = new BigDecimal(num);
        BigDecimal denominator = new BigDecimal(den);
        BigDecimal quotient    = numerator.divide(denominator, SCALE, RoundingMode.HALF_EVEN);
return quotient.doubleValue();
    }
}

BernoulliNumber.java

import java.math.BigInteger;
import java.util.Scanner;
// create BernoulliNumber class to get N Bernoulli numbers
public class BernoulliNumber {
	// main() method start
    public static void main(String[] args) {

	int N;
	
	// create scanner class object to get input from user
	Scanner sc = new Scanner(System.in);
	
	System.out.println("How many Bernoulli number you want to get.");
	// initialization N
	N = sc.nextInt();
	sc.close();
        // precompute binomial coefficients
        BigInteger[][] bin = new BigInteger[N+1][N+1];

        for (int i = 1; i <= N; i++) { 
	bin[0][i] = BigInteger.ZERO;
        }
        for (int i = 0; i <= N; i++) { 
	bin[i][0] = BigInteger.ONE;
        }
        // bottom-up dynamic programming
        for (int i = 1; i <= N; i++) {
            for (int j = 1; j <= N; j++) {
                bin[i][j] = bin[i - 1][j - 1].add(bin[i - 1][j]);
            }
        }


        // get Bernoulli numbers using BigRational class
        BigRational[] bernoulliNumbers = new BigRational[N + 1];
        bernoulliNumbers[0] = new BigRational(1, 1);
        bernoulliNumbers[1] = new BigRational(-1, 2);
        for (int i = 2; i < N; i++) {
	bernoulliNumbers[i] = new BigRational(0, 1);
            for (int j = 0; j < i; j++) {
                BigRational coef = new BigRational(bin[i + 1][i + 1 - j], BigInteger.ONE);
                bernoulliNumbers[i] = bernoulliNumbers[i].minus(coef.times(bernoulliNumbers[j]));
            }
            bernoulliNumbers[i] = bernoulliNumbers[i].divides(new BigRational(i + 1, 1));
        }

        // print out the first N Bernoulli numbers
        for (int i = 0; i < N; i++)
	System.out.println(bernoulliNumbers[i]);

    }
}

Output: