/// <inheritdoc /> public override double ProbabilityDensity(double x) { if (x < 0.0) { return(0.0); } else { double z = x / s; // use Gamma(a) or Ln(Gamma(a)) form depending on size of a if (ga > 0.0) { return(Math.Pow(z, a - 1.0) * Math.Exp(-z) / ga / s); } else { // The standard Gamma distribution p(\alpha, x) is the same as the // Poisson distribution P(\lambda, k) with k \leftarrow \alpha - 1 // and \lambda \leftarrow x. Use this fact plus our Poisson // machinery to accurately compute probabilities for large \alpha. return(Stirling.PoissonProbability(z, a - 1.0) / s); //return (Math.Exp((a - 1.0) * Math.Log(z) - z + ga) / s); } } }
public static void stirling1_values_test() //****************************************************************************80 // // Purpose: // // STIRLING1_VALUES_TEST tests STIRLING1_VALUES. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 08 February 2007 // // Author: // // John Burkardt // { int m = 0; int n = 0; int s1 = 0; Console.WriteLine(""); Console.WriteLine("STIRLING1_VALUES_TEST:"); Console.WriteLine(" STIRLING1_VALUES returns values of"); Console.WriteLine(" the Stirling numbers of the first kind."); Console.WriteLine(""); Console.WriteLine(" N N S1"); Console.WriteLine(""); int n_data = 0; for (;;) { Stirling.stirling1_values(ref n_data, ref n, ref m, ref s1); if (n_data == 0) { break; } Console.WriteLine(" " + n.ToString().PadLeft(6) + " " + m.ToString().PadLeft(6) + " " + s1.ToString().PadLeft(12) + ""); } }
public static void stirling2_test( ) //****************************************************************************80 // // Purpose: // // STIRLING2_TEST tests STIRLING2. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 02 June 2007 // // Author: // // John Burkardt // { const int M = 8; const int N = 8; int i; Console.WriteLine(""); Console.WriteLine("STIRLING2_TEST"); Console.WriteLine(" STIRLING2: Stirling numbers of second kind."); Console.WriteLine(" Get rows 1 through " + M + ""); Console.WriteLine(""); int[] s2 = Stirling.stirling2(M, N); for (i = 0; i < M; i++) { string cout = (i + 1).ToString().PadLeft(6) + " "; int j; for (j = 0; j < N; j++) { cout += s2[i + j * M].ToString().PadLeft(6) + " "; } Console.WriteLine(cout); } }
public static void stirling1_test( ) //****************************************************************************80 // // Purpose: // // STIRLING1_TEST tests STIRLING1. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 02 June 2007 // // Author: // // John Burkardt // { int i; const int m = 8; const int n = 8; Console.WriteLine(""); Console.WriteLine("STIRLING1_TEST"); Console.WriteLine(" STIRLING1: Stirling numbers of first kind."); Console.WriteLine(" Get rows 1 through " + m + ""); Console.WriteLine(""); int[] s1 = Stirling.stirling1(m, n); for (i = 0; i < m; i++) { string cout = (i + 1).ToString().PadLeft(6) + " "; int j; for (j = 0; j < n; j++) { cout += s1[i + j * m].ToString().PadLeft(6) + " "; } Console.WriteLine(cout); } }
/// <inheritdoc /> public override double ProbabilityMass(int k) { if (k < 0) { return(0.0); } else { // These are the same expression, but the form for small arguments is faster, // while the form for large arguments avoids overflow and cancellation errors. if (k < 16) { return(Math.Exp(-mu) * MoreMath.Pow(mu, k) / AdvancedIntegerMath.Factorial(k)); } else { return(Stirling.PoissonProbability(mu, k)); } } }
/// <inheritdoc /> public override double ProbabilityMass(int k) { if ((k < 0) || (k > n)) { return(0.0); } else { int nmk = n - k; if ((k > 16) && (nmk > 16)) { // For large arguments, use cancellation-corrected Stirling series to // avoid overflow and preserve accuracy. return(Stirling.BinomialProbability(p, k, q, nmk)); } else { // Otherwise, fall back to direct evaluation. return(AdvancedIntegerMath.BinomialCoefficient(n, k) * MoreMath.Pow(p, k) * MoreMath.Pow(q, n - k)); } } }
public long howMany(int num, string[] facts) { int n = 0; long result = 0; bool[] flag = new bool[num]; for (int i = 0; i < num; i++) { if (!flag[i]) { Queue Q = new Queue(num); Q.Enqueue(i); n++; while (Q.Count > 0) { int k = (int)Q.Dequeue(); for (int j = 0; j < facts.Length; j++) { string[] x = facts[j].Split('='); int a = int.Parse(x[0]); int b = int.Parse(x[1]); if (a == k && !flag[b]) { flag[b] = true; Q.Enqueue(b); } if (b == k && !flag[a]) { flag[a] = true; Q.Enqueue(a); } } } } } for (int i = 1; i <= n; i++) { result += Stirling.calc(n, i) * Factorial.calc(i); } return(result); }
public static int poly_bernoulli(int n, int k) //****************************************************************************80 // // Purpose: // // POLY_BERNOULLI evaluates the poly-Bernolli numbers with negative index. // // Discussion: // // The poly-Bernoulli numbers B_n^k were defined by M Kaneko // formally as the coefficients of X^n/n! in a particular power // series. He also showed that, when the super-index is negative, // we have // // B_n^(-k) = Sum ( 0 <= j <= min ( n, k ) ) // (j!)^2 * S(n+1,j+1) * S(k+1,j+1) // // where S(n,k) is the Stirling number of the second kind, the number of // ways to partition a set of size n into k nonempty subset. // // B_n^(-k) is also the number of "lonesum matrices", that is, 0-1 // matrices of n rows and k columns which are uniquely reconstructable // from their row and column sums. // // The poly-Bernoulli numbers get large very quickly. // // Table: // // \ K 0 1 2 3 4 5 6 // N // 0 1 1 1 1 1 1 1 // 1 1 2 4 8 16 32 64 // 2 1 4 14 46 146 454 1394 // 3 1 8 46 230 1066 4718 20266 // 4 1 16 146 1066 6902 41506 237686 // 5 1 32 454 4718 41506 329462 2441314 // 6 1 64 1394 20266 237686 2441314 22934774 // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 15 March 2006 // // Author: // // John Burkardt // // Reference: // // Chad Brewbaker, // Lonesum (0,1) Matrices and Poly-Bernoulli Numbers of Negative Index, // MS Thesis, // Iowa State University, 2005. // // M Kaneko, // Poly-Bernoulli Numbers, // Journal Theorie des Nombres Bordeaux, // Volume 9, 1997, pages 221-228. // // Parameters: // // Input, int N, K, the indices. N and K should be nonnegative. // // Output, int POLY_BERNOULLI, the value of B_N^(-K). // { int b; int j; switch (n) { case < 0: b = 0; return(b); case 0: b = 1; return(b); } switch (k) { case <= 0: b = 0; return(b); } switch (k) { case 0: b = 1; return(b); } int jhi = Math.Min(n, k); int m = Math.Max(n, k) + 1; int[] s = Stirling.stirling2(m, m); int jfact = 1; b = 0; for (j = 0; j <= jhi; j++) { b += jfact * jfact * s[n + j * m] * s[k + j * m]; jfact *= j + 1; } return(b); }