dcdflib_prb.c

计算各种随机分布的密度函数

    ompr = 1.0E+00 - pr;

    f_double = ( double ) f;
    s_double = ( double ) s;

    cumnbn ( &f_double, &s_double, &pr, &ompr, &cdf_compute, &ccdf_compute );

    cout << "  "
         << setw(2)  << f           << "  "
         << setw(2)  << s           << "  "
         << setw(8)  << pr          << "  "
         << setw(12) << cdf_lookup  << "  "
         << setw(12) << cdf_compute << "\n";
  }

  cout << "\n";
  cout << "   F   S    Pr       1-CDF         CCDF\n";
  cout << "                     (Lookup)      (Computed)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    negative_binomial_cdf_values ( &n_data, &f, &s, &pr, &cdf_lookup );

    if ( n_data == 0 )
    {
      break;
    }

    ccdf_lookup = 1.0E+00 - cdf_lookup;

    ompr = 1.0E+00 - pr;

    f_double = ( double ) f;
    s_double = ( double ) s;

    cumnbn ( &f_double, &s_double, &pr, &ompr, &cdf_compute, &ccdf_compute );

    cout << "  "
         << setw(2)  << f            << "  "
         << setw(2)  << s            << "  "
         << setw(8)  << pr           << "  "
         << setw(12) << ccdf_lookup  << "  "
         << setw(12) << ccdf_compute << "\n";
  }

  return;
}
//****************************************************************************80

void test20 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST20 tests CUMNOR, NORMAL_CDF_VALUES.
//
{
  double ccdf_compute;
  double ccdf_lookup;
  double cdf_compute;
  double cdf_lookup;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST20\n";
  cout << "  CUMNOR computes the Normal CDF\n";
  cout << "    and the complementary CDF.\n";
  cout << "  NORMAL_CDF_VALUES looks up some values.\n";
  cout << "\n";
  cout << "    X         CDF           CDF\n";
  cout << "              (Lookup)      (Computed)\n";
  cout << "\n";
 
  n_data = 0;

  for ( ; ; )
  {
    normal_cdf_values ( &n_data, &x, &cdf_lookup );

    if ( n_data == 0 )
    {
      break;
    }

    cumnor ( &x, &cdf_compute, &ccdf_compute );

    cout << "  "
         << setw(8)  << x           << "  "
         << setw(12) << cdf_lookup  << "  "
         << setw(12) << cdf_compute << "\n";
  }

  cout << "\n";
  cout << "    X         1-CDF         CCDF\n";
  cout << "              (Lookup)      (Computed)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    normal_cdf_values ( &n_data, &x, &cdf_lookup );

    if ( n_data == 0 )
    {
      break;
    }

    ccdf_lookup = 1.0E+00 - cdf_lookup;

    cumnor ( &x, &cdf_compute, &ccdf_compute );

    cout << "  "
         << setw(8)  << x            << "  "
         << setw(12) << ccdf_lookup  << "  "
         << setw(12) << ccdf_compute << "\n";
  }

  return;
}
//****************************************************************************80

void test21 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST21 tests CUMPOI, POISSON_CDF_VALUES.
//
{
  double ccdf_compute;
  double ccdf_lookup;
  double cdf_compute;
  double  cdf_lookup;
  double lambda;
  int n_data;
  int x;
  double x_double;

  cout << "\n";
  cout << "TEST21\n";
  cout << "  CUMPOI computes the Poisson CDF\n";
  cout << "    and the complementary CDF.\n";
  cout << "  POISSON_CDF_VALUES looks up some values.\n";
  cout << "\n";
  cout << "     X    LAMBDA    CDF           CDF\n";
  cout << "                   (Lookup)      (Computed)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    poisson_cdf_values ( &n_data, &lambda, &x, &cdf_lookup );

    if ( n_data == 0 )
    {
      break;
    }

    x_double = ( double ) x;

    cumpoi ( &x_double, &lambda, &cdf_compute, &ccdf_compute );

    cout << "  "
         << setw(4)  << x           << "  "
         << setw(8)  << lambda      << "  "
         << setw(12) << cdf_lookup  << "  "
         << setw(12) << cdf_compute << "\n";
  }

  cout << "\n";
  cout << "     X    LAMBDA    1-CDF         CCDF\n";
  cout << "                   (Lookup)      (Computed)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    poisson_cdf_values ( &n_data, &lambda, &x, &cdf_lookup );

    if ( n_data == 0 )
    {
      break;
    }

    x_double = ( double ) x;
    ccdf_lookup = 1.0E+00 - cdf_lookup;

    cumpoi ( &x_double, &lambda, &cdf_compute, &ccdf_compute );

    cout << "  "
         << setw(4)  << x            << "  "
         << setw(8)  << lambda       << "  "
         << setw(12) << ccdf_lookup  << "  "
         << setw(12) << ccdf_compute << "\n";
  }

  return;
}
//****************************************************************************80

void test22 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST22 tests CUMT, STUDENT_CDF_VALUES.
//
{
  double ccdf_compute;
  double ccdf_lookup;
  double cdf_compute;
  double cdf_lookup;
  int df;
  double df_double;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST22\n";
  cout << "  CUMT computes the Student T CDF\n";
  cout << "    and the complementary CDF.\n";
  cout << "  STUDENT_CDF_VALUES looks up some values.\n";
  cout << "\n";
  cout << "    X       DF    CDF           CDF\n";
  cout << "                 (Lookup)      (Computed)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    student_cdf_values ( &n_data, &df, &x, &cdf_lookup );

    if ( n_data == 0 )
    {
      break;
    }
    df_double = ( double ) df;

    cumt ( &x, &df_double, &cdf_compute, &ccdf_compute );

    cout << "  "
         << setw(8)  << x           << "  "
         << setw(2)  << df          << "  "
         << setw(12) << cdf_lookup  << "  "
         << setw(12) << cdf_compute << "\n";
  }

  cout << "\n";
  cout << "    X       DF    1-CDF         CCDF\n";
  cout << "                 (Lookup)      (Computed)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    student_cdf_values ( &n_data, &df, &x, &cdf_lookup );

    if ( n_data == 0 )
    {
      break;
    }

    ccdf_lookup = 1.0E+00 - cdf_lookup;

    df_double = ( double ) df;

    cumt ( &x, &df_double, &cdf_compute, &ccdf_compute );

    cout << "  "
         << setw(8)  << x            << "  "
         << setw(2)  << df           << "  "
         << setw(12) << ccdf_lookup  << "  "
         << setw(12) << ccdf_compute << "\n";
  }

  return;
}
//****************************************************************************80

void test23 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST23 tests BETA, GAMMA_X.
//
{
  double a;
  double b;
  double apb;
  double beta1;
  double beta2;

  cout << "\n";
  cout << "TEST23\n";
  cout << "  BETA evaluates the Beta function;\n";
  cout << "  GAMMA_X evaluates the Gamma function.\n";

  a = 2.2;
  b = 3.7;
  apb = a + b;

  beta1 = beta ( a, b );
  beta2 = gamma_x ( &a ) * gamma_x ( &b ) / gamma_x ( &apb );

  cout << "\n";
  cout << "  Argument A =                   " << a << "\n";
  cout << "  Argument B =                   " << b << "\n";
  cout << "  Beta(A,B) =                    " << beta1 << "\n";
  cout << "  (Expected value = 0.0454 )\n";
  cout << "\n";
  cout << "  Gamma(A)*Gamma(B)/Gamma(A+B) = " << beta2 << "\n";

  return;
}
//****************************************************************************80

void test24 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST24 tests ERROR_F, ERROR_FC, ERF_VALUES..
//
//  Modified:
//
//    17 November 2006
//
//  Author:
//
//    John Burkardt
//
{
  double erf_compute;
  double erf_lookup;
  double erfc_compute;
  double erfc_lookup;
  int ind;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST24\n";
  cout << "  ERROR_F computes the error function ERF;\n";
  cout << "  ERROR_FC the complementary error function ERFC.\n";
  cout << "  ERF_VALUES looks up some values.\n";
  cout << "\n";
  cout << "    X         ERF           ERF\n";
  cout << "              (Lookup)      (Computed)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    erf_values ( &n_data, &x, &erf_lookup );

    if ( n_data == 0 )
    {
      break;
    }

    erf_compute = error_f ( &x );

    cout << "  "
         << setw(8)  << x           << "  "
         << setw(12) << erf_lookup  << "  "
         << setw(12) << erf_compute << "\n";
  }

  cout << "\n";
  cout << "    X         ERFC          ERFC\n";
  cout << "              (Lookup)      (Computed)\n";
  cout << "\n";

  ind = 0;
  n_data = 0;

  for ( ; ; )
  {
    erf_values ( &n_data, &x, &erf_lookup );

    if ( n_data == 0 )
    {
      break;
    }

    erfc_lookup = 1.0E+00 - erf_lookup;
    erfc_compute = error_fc ( &ind, &x );

    cout << "  "
         << setw(8)  << x            << "  "
         << setw(12) << erfc_lookup  << "  "
         << setw(12) << erfc_compute << "\n";
  }

  return;
}
//****************************************************************************80

void test25 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST25 tests XGAMM, GAMMA_VALUES.
//
{
  double gamma_compute;
  double gamma_lookup;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST25\n";
  cout << "  XGAMM computes the Gamma function;\n";
  cout << "  GAMMA_VALUES looks up some values.\n";
  cout << "\n";
  cout << "    X         GAMMA         GAMMA\n";
  cout << "              (Lookup)      (Computed)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    gamma_values ( &n_data, &x, &gamma_lookup );

    if ( n_data == 0 )
    {
      break;
    }

    gamma_compute = gamma_x ( &x );

    cout << "  "
         << setw(8)  << x             << "  "
         << setw(12) << gamma_lookup  << "  "
         << setw(12) << gamma_compute << "\n";
  }

  return;
}
//****************************************************************************80

void test26 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST26 tests GAMMA_INC, GAMMA_INC_INV.
//
{
  double a;
  int i;
  int ierror;
  int ind;
  double p;
  double q;
  int test_num = 10;
  double x;
  double x0;
  double x2;

  a = 3.0;
  ind = 1;
  x0 = 0;

  cout << "\n";
  cout << "TEST26\n";
  cout << "  GAMMA_INC evaluates the incomplete Gamma ratio;\n";
  cout << "  GAMMA_INC_INV inverts it.\n";
  cout << "\n";
  cout << "  Parameters:\n";
  cout << "\n";
  cout << "    A = " << a << "\n";
  cout << "\n";
  cout << "    X             P             Q             Inverse\n";
  cout << "\n";

  for ( i = 0; i <= test_num; i++ )
  {
    x = ( double ) i / ( double ) test_num;

    gamma_inc ( &a, &x, &p, &q, &ind );

    gamma_inc_inv ( &a, &x2, &x0, &p, &q, &ierror );

    cout << "  "
         << setw(12) << x  << "  "
         << setw(12) << p  << "  "
         << setw(12) << q  << "  "
         << setw(12) << x2 << "\n";
  }

  return;
}
//****************************************************************************80

void test27 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST27 tests PSI, PSI_VALUES.
//
{
  double psi_compute;
  double psi_lookup;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST27\n";
  cout << "  PSI computes the Psi function;\n";
  cout << "  PSI_VALUES looks up some values.\n";
  cout << "\n";
  cout << "    X         PSI           PSI\n";
  cout << "              (Lookup)      (Computed)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    psi_values ( &n_data, &x, &psi_lookup );

    if ( n_data == 0 )
    {
      break;
    }

    psi_compute = psi ( &x );

    cout << "  "
         << setw(8)  << x           << "  "
         << setw(12) << psi_lookup  << "  "
         << setw(12) << psi_compute << "\n";
  }

  return;
}