def bernoulli_poly ( n, x ):
#*****************************************************************************80
#
## BERNOULLI_POLY evaluates the Bernoulli polynomial of order N at X.
#
# Discussion:
#
# Thanks to Bart Vandewoestyne for pointing out an error in the previous
# documentation, 31 January 2008.
#
# Special values of the Bernoulli polynomial include:
#
# B(N,0) = B(N,1) = B(N), the N-th Bernoulli number.
#
# B'(N,X) = N * B(N-1,X)
#
# B(N,X+1) - B(N,X) = N * X^(N-1)
# B(N,X) = (-1)^N * B(N,1-X)
#
# A formula for the Bernoulli polynomial in terms of the Bernoulli
# numbers is:
#
# B(N,X) = sum ( 0 <= K <= N ) B(K) * C(N,K) * X^(N-K)
#
# The first few polynomials include:
#
# B(0,X) = 1
# B(1,X) = X - 1/2
# B(2,X) = X^2 - X + 1/6
# B(3,X) = X^3 - 3/2*X^2 + 1/2*X
# B(4,X) = X^4 - 2*X^3 + X^2 - 1/30
# B(5,X) = X^5 - 5/2*X^4 + 5/3*X^3 - 1/6*X
# B(6,X) = X^6 - 3*X^5 + 5/2*X^4 - 1/2*X^2 + 1/42
# B(7,X) = X^7 - 7/2*X^6 + 7/2*X^5 - 7/6*X^3 + 1/6*X
# B(8,X) = X^8 - 4*X^7 + 14/3*X^6 - 7/3*X^4 + 2/3*X^2 - 1/30
#
# Licensing:
#
# This code is distributed under the GNU LGPL license.
#
# Modified:
#
# 28 December 2014
#
# Author:
#
# John Burkardt
#
# Parameters:
#
# Input, integer N, the order of the Bernoulli polynomial to
# be evaluated. N must be 0 or greater.
#
# Input, real X, the value of X at which the polynomial is to
# be evaluated.
#
# Output, real BX, the value of B(N,X).
#
import numpy as np
from bernoulli_number import bernoulli_number
from comb_row_next import comb_row_next
b = bernoulli_number ( n );
#
# Get row N of Pascal's triangle.
#
c = np.zeros ( n + 1 )
for i in range ( 0, n + 1 ):
c = comb_row_next ( i, c )
bx = 1.0
for i in range ( 1, n + 1 ):
bx = bx * x + b[i] * c[i]
return bx
def bernoulli_number ( n ):
#*****************************************************************************80
#
## BERNOULLI_NUMBER computes the value of the Bernoulli numbers B(0) through B(N).
#
# Discussion:
#
# The Bernoulli numbers are rational.
#
# If we define the sum of the M-th powers of the first N integers as:
#
# SIGMA(M,N) = sum ( 0 <= I <= N ) I**M
#
# and let C(I,J) be the combinatorial coefficient:
#
# C(I,J) = I! / ( ( I - J )! * J! )
#
# then the Bernoulli numbers B(J) satisfy:
#
# SIGMA(M,N) = 1/(M+1) * sum ( 0 <= J <= M ) C(M+1,J) B(J) * (N+1)**(M+1-J)
#
# First values:
#
# B0 1 = 1.00000000000
# B1 -1/2 = -0.50000000000
# B2 1/6 = 1.66666666666
# B3 0 = 0
# B4 -1/30 = -0.03333333333
# B5 0 = 0
# B6 1/42 = 0.02380952380
# B7 0 = 0
# B8 -1/30 = -0.03333333333
# B9 0 = 0
# B10 5/66 = 0.07575757575
# B11 0 = 0
# B12 -691/2730 = -0.25311355311
# B13 0 = 0
# B14 7/6 = 1.16666666666
# B15 0 = 0
# B16 -3617/510 = -7.09215686274
# B17 0 = 0
# B18 43867/798 = 54.97117794486
# B19 0 = 0
# B20 -174611/330 = -529.12424242424
# B21 0 = 0
# B22 854,513/138 = 6192.123
# B23 0 = 0
# B24 -236364091/2730 = -86580.257
# B25 0 = 0
# B26 8553103/6 = 1425517.16666
# B27 0 = 0
# B28 -23749461029/870 = -27298231.0678
# B29 0 = 0
# B30 8615841276005/14322 = 601580873.901
#
# Recursion:
#
# With C(N+1,K) denoting the standard binomial coefficient,
#
# B(0) = 1.0
# B(N) = - ( sum ( 0 <= K < N ) C(N+1,K) * B(K) ) / C(N+1,N)
#
# Warning:
#
# This recursion, which is used in this routine, rapidly results
# in significant errors.
#
# Special Values:
#
# Except for B(1), all Bernoulli numbers of odd index are 0.
#
# Licensing:
#
# This code is distributed under the GNU LGPL license.
#
# Modified:
#
# 22 December 2014
#
# Author:
#
# John Burkardt
#
# Parameters:
#
# Input, integer N, the order of the highest Bernoulli number to compute.
#
# Output, real B(1:N+1), B(I+1) contains the I-th Bernoulli number.
#
import numpy as np
from comb_row_next import comb_row_next
b = np.zeros ( n + 1 );
b[0] = 1.0
if ( n < 1 ):
return b
b[1] = -0.5
c = np.zeros ( n + 2 )
c[0] = 1
c[1] = 2
c[2] = 1
for i in range ( 2, n + 1 ):
c = comb_row_next ( i + 1, c )
if ( ( i % 2 ) == 1 ):
b[i] = 0.0
else:
b_sum = 0.0;
for j in range ( 0, i ):
b_sum = b_sum + b[j] * c[j]
b[i] = - b_sum / c[i]
return b
def bernoulli_number(n):
#*****************************************************************************80
#
## BERNOULLI_NUMBER computes the value of the Bernoulli numbers B(0) through B(N).
#
# Discussion:
#
# The Bernoulli numbers are rational.
#
# If we define the sum of the M-th powers of the first N integers as:
#
# SIGMA(M,N) = sum ( 0 <= I <= N ) I**M
#
# and let C(I,J) be the combinatorial coefficient:
#
# C(I,J) = I! / ( ( I - J )! * J! )
#
# then the Bernoulli numbers B(J) satisfy:
#
# SIGMA(M,N) = 1/(M+1) * sum ( 0 <= J <= M ) C(M+1,J) B(J) * (N+1)**(M+1-J)
#
# First values:
#
# B0 1 = 1.00000000000
# B1 -1/2 = -0.50000000000
# B2 1/6 = 1.66666666666
# B3 0 = 0
# B4 -1/30 = -0.03333333333
# B5 0 = 0
# B6 1/42 = 0.02380952380
# B7 0 = 0
# B8 -1/30 = -0.03333333333
# B9 0 = 0
# B10 5/66 = 0.07575757575
# B11 0 = 0
# B12 -691/2730 = -0.25311355311
# B13 0 = 0
# B14 7/6 = 1.16666666666
# B15 0 = 0
# B16 -3617/510 = -7.09215686274
# B17 0 = 0
# B18 43867/798 = 54.97117794486
# B19 0 = 0
# B20 -174611/330 = -529.12424242424
# B21 0 = 0
# B22 854,513/138 = 6192.123
# B23 0 = 0
# B24 -236364091/2730 = -86580.257
# B25 0 = 0
# B26 8553103/6 = 1425517.16666
# B27 0 = 0
# B28 -23749461029/870 = -27298231.0678
# B29 0 = 0
# B30 8615841276005/14322 = 601580873.901
#
# Recursion:
#
# With C(N+1,K) denoting the standard binomial coefficient,
#
# B(0) = 1.0
# B(N) = - ( sum ( 0 <= K < N ) C(N+1,K) * B(K) ) / C(N+1,N)
#
# Warning:
#
# This recursion, which is used in this routine, rapidly results
# in significant errors.
#
# Special Values:
#
# Except for B(1), all Bernoulli numbers of odd index are 0.
#
# Licensing:
#
# This code is distributed under the GNU LGPL license.
#
# Modified:
#
# 22 December 2014
#
# Author:
#
# John Burkardt
#
# Parameters:
#
# Input, integer N, the order of the highest Bernoulli number to compute.
#
# Output, real B(1:N+1), B(I+1) contains the I-th Bernoulli number.
#
import numpy as np
from comb_row_next import comb_row_next
b = np.zeros(n + 1)
b[0] = 1.0
if (n < 1):
return b
b[1] = -0.5
c = np.zeros(n + 2)
c[0] = 1
c[1] = 2
c[2] = 1
for i in range(2, n + 1):
c = comb_row_next(i + 1, c)
if ((i % 2) == 1):
b[i] = 0.0
else:
b_sum = 0.0
for j in range(0, i):
b_sum = b_sum + b[j] * c[j]
b[i] = -b_sum / c[i]
return b
