public static void comb_row_next_test() //****************************************************************************80 // // Purpose: // // COMB_ROW_NEXT_TEST tests COMB_ROW_TEST. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 23 December 2014 // // Author: // // John Burkardt // { int n; const int N_MAX = 10; Console.WriteLine(""); Console.WriteLine("COMB_ROW_NEXT_TEST"); Console.WriteLine(" COMB_ROW_NEXT computes the next row of the Pascal triangle."); Console.WriteLine(""); int[] c = new int[N_MAX + 1]; for (n = 0; n <= N_MAX; n++) { Comb.comb_row_next(n, ref c); string cout = " " + n.ToString().PadLeft(2) + " "; int i; for (i = 0; i <= n; i++) { cout += c[i].ToString().PadLeft(5); } Console.WriteLine(cout); } }
public static double bernoulli_poly(int n, double x) //****************************************************************************80 // // Purpose: // // 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: // // 31 January 2008 // // Author: // // John Burkardt // // Parameters: // // Input, int N, the order of the Bernoulli polynomial to // be evaluated. N must be 0 or greater. // // Input, double X, the value of X at which the polynomial is to // be evaluated. // // Output, double BERNOULLI_POLY, the value of B(N,X). // { int i; double[] work = new double[n + 1]; Sequence.Bernoulli.bernoulli_number(n, ref work); // // Get row N of Pascal's triangle. // int[] c = new int[n + 1]; for (i = 0; i <= n; i++) { Comb.comb_row_next(n, ref c); } double value = 1.0; for (i = 1; i <= n; i++) { value = value * x + work[i] * c[i]; } return(value); }
public static void bernoulli_number(int n, ref double[] b) //****************************************************************************80 // // Purpose: // // 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: // // 09 May 2003 // // Author: // // John Burkardt // // Parameters: // // Input, int N, the order of the highest Bernoulli number to compute. // // Output, double B[N+1], B(I) contains the I-th Bernoulli number. // { int i; switch (n) { case < 0: return; } b[0] = 1.0; switch (n) { case < 1: return; } b[1] = -0.5; int[] c = new int[n + 2]; c[0] = 1; c[1] = 2; c[2] = 1; for (i = 2; i <= n; i++) { Comb.comb_row_next(i + 1, ref c); switch (i % 2) { case 1: b[i] = 0.0; break; default: { double b_sum = 0.0; int j; for (j = 0; j <= i - 1; j++) { b_sum += b[j] * c[j]; } b[i] = -b_sum / c[i]; break; } } } }