# include <cstdlib>
# include <iostream>
# include <iomanip>
# include <cmath>
# include <complex>

using namespace std;

# include "test_values.H"

int main ( void );

void test001 ( void );
void test002 ( void );
void test003 ( void );
void test0035 ( void );
void test004 ( void );
void test005 ( void );
void test006 ( void );
void test007 ( void );
void test008 ( void );
void test009 ( void );
void test0093 ( void );
void test0095 ( void );

void test010 ( void );
void test011 ( void );
void test0114 ( void );
void test01145 ( void );
void test0115 ( void );
void test01155 ( void );
void test0116 ( void );
void test012 ( void );
void test0123 ( void );
void test0127 ( void );
void test0128 ( void );
void test013 ( void );
void test0134 ( void );
void test0135 ( void );
void test014 ( void );
void test015 ( void );
void test016 ( void );
void test017 ( void );
void test018 ( void );
void test0185 ( void );
void test019 ( void );
void test0195 ( void );

void test020 ( void );
void test0205 ( void );
void test021 ( void );
void test022 ( void );
void test023 ( void );
void test024 ( void );
void test025 ( void );
void test026 ( void );
void test0265 ( void );
void test027 ( void );
void test028 ( void );
void test029 ( void );

void test030 ( void );
void test0305 ( void );
void test031 ( void );
void test032 ( void );
void test033 ( void );
void test034 ( void );
void test035 ( void );
void test036 ( void );
void test0365 ( void );
void test037 ( void );
void test038 ( void );
void test039 ( void );
void test0395 ( void );

void test040 ( void );
void test041 ( void );
void test042 ( void );
void test0425 ( void );
void test043 ( void );
void test044 ( void );
void test0445 ( void );
void test045 ( void );
void test046 ( void );
void test0465 ( void );
void test047 ( void );
void test048 ( void );
void test049 ( void );

void test050 ( void );
void test051 ( void );
void test05125 ( void );
void test0515 ( void );
void test0517 ( void );
void test0519 ( void );
void test052 ( void );
void test053 ( void );
void test054 ( void );
void test055 ( void );
void test056 ( void );
void test057 ( void );
void test058 ( void );
void test059 ( void );

void test060 ( void );
void test061 ( void );
void test062 ( void );
void test063 ( void );
void test064 ( void );
void test065 ( void );
void test066 ( void );
void test0665 ( void );
void test067 ( void );
void test068 ( void );
void test0685 ( void );
void test069 ( void );

void test070 ( void );
void test071 ( void );
void test072 ( void );
void test073 ( void );
void test074 ( void );
void test075 ( void );
void test0755 ( void );
void test0756 ( void );
void test076 ( void );
void test077 ( void );
void test078 ( void );
void test079 ( void );

void test080 ( void );
void test081 ( void );
void test082 ( void );
void test083 ( void );
void test084 ( void );
void test0845 ( void );
void test085 ( void );
void test0855 ( void );
void test086 ( void );
void test087 ( void );
void test088 ( void );
void test089 ( void );

void test090 ( void );
void test091 ( void );
void test092 ( void );
void test093 ( void );
void test094 ( void );
void test0945 ( void );
void test095 ( void );
void test096 ( void );
void test097 ( void );
void test0972 ( void );
void test0973 ( void );
void test0974 ( void );
void test0975 ( void );
void test098 ( void );
void test099 ( void );
void test0995 ( void );

void test100 ( void );
void test101 ( void );
void test102 ( void );
void test103 ( void );
void test1035 ( void );
void test1037 ( void );
void test104 ( void );
void test105 ( void );
void test106 ( void );
void test107 ( void );
void test108 ( void );
void test10875 ( void );
void test109 ( void );

void test110 ( void );
void test1105 ( void );
void test111 ( void );
void test112 ( void );
void test113 ( void );
void test1135 ( void );
void test114 ( void );
void test115 ( void );
void test116 ( void );
void test117 ( void );
void test118 ( void );
void test1185 ( void );
void test119 ( void );

void test120 ( void );
void test121 ( void );
void test122 ( void );
void test123 ( void );
void test124 ( void );
void test125 ( void );
void test1255 ( void );
void test126 ( void );
void test127 ( void );
void test1275 ( void );
void test128 ( void );
void test1283 ( void );
void test1285 ( void );
void test129 ( void );

void test131 ( void );
void test132 ( void );
void test1325 ( void );
void test130 ( void );
void test133 ( void );
void test134 ( void );
void test135 ( void );
void test136 ( void );
void test137 ( void );
void test138 ( void );
void test139 ( void );

void test140 ( void );
void test141 ( void );
void test1415 ( void );
void test142 ( void );
void test143 ( void );
void test144 ( void );
void test1445 ( void );
void test1447 ( void );
void test145 ( void );
void test146 ( void );
void test1465 ( void );
void test147 ( void );
void test148 ( void );
void test149 ( void );

void test150 ( void );
void test151 ( void );
void test152 ( void );
void test153 ( void );
void test154 ( void );
void test1545 ( void );
void test155 ( void );
void test156 ( void );
void test157 ( void );
void test1575 ( void );
void test158 ( void );
void test159 ( void );

//****************************************************************************80

int main ( void )

//****************************************************************************80
//
//  Purpose:
//
//    MAIN is the main program for TEST_VALUES_PRB.
//
//  Discussion:
//
//    TEST_VALUES_PRB calls the TEST_VALUE routines.
//
//  Modified:
//
//    25 January 2008
//
//  Author:
//
//    John Burkardt
//
{
  timestamp ( );

  cout << "\n";
  cout << "TEST_VALUES_PRB:\n";
  cout << "  C++ version,\n";
  cout << "\n";
  cout << "  Test the routines in the TEST_VALUES library.\n";

  test001 ( );
  test002 ( );
  test003 ( );
  test0035 ( );
  test004 ( );
  test005 ( );
  test006 ( );
  test007 ( );
  test008 ( );
  test009 ( );
  test0093 ( );
  test0095 ( );

  test010 ( );
  test011 ( );
  test0114 ( );
  test01145 ( );
  test0115 ( );
  test01155 ( );
  test0116 ( );
  test012 ( );
  test0123 ( );
  test0127 ( );
  test0128 ( );
  test013 ( );
  test0134 ( );
  test0135 ( );
  test014 ( );
  test015 ( );
  test016 ( );
  test017 ( );
  test018 ( );
  test0185 ( );
  test019 ( );
  test0195 ( );

  test020 ( );
  test0205 ( );
  test021 ( );
  test022 ( );
  test023 ( );
  test024 ( );
  test025 ( );
  test026 ( );
  test0265 ( );
  test027 ( );
  test028 ( );
  test029 ( );

  test030 ( );
  test0305 ( );
  test031 ( );
  test032 ( );
  test033 ( );
  test034 ( );
  test035 ( );
  test036 ( );
  test0365 ( );
  test037 ( );
  test038 ( );
  test039 ( );
  test0395 ( );

  test040 ( );
  test041 ( );
  test042 ( );
  test0425 ( );
  test043 ( );
  test044 ( );
  test0445 ( );
  test045 ( );
  test046 ( );
  test0465 ( );
  test047 ( );
  test048 ( );
  test049 ( );

  test050 ( );
  test051 ( );
  test05125 ( );
  test0515 ( );
  test0517 ( );
  test0519 ( );
  test052 ( );
  test053 ( );
  test054 ( );
  test055 ( );
  test056 ( );
  test057 ( );
  test058 ( );
  test059 ( );

  test060 ( );
  test061 ( );
  test062 ( );
  test063 ( );
  test064 ( );
  test065 ( );
  test066 ( );
  test0665 ( );
  test067 ( );
  test068 ( );
  test0685 ( );
  test069 ( );

  test070 ( );
  test071 ( );
  test072 ( );
  test073 ( );
  test074 ( );
  test075 ( );
  test0755 ( );
  test0756 ( );
  test076 ( );
  test077 ( );
  test078 ( );
  test079 ( );

  test080 ( );
  test081 ( );
  test082 ( );
  test083 ( );
  test084 ( );
  test0845 ( );
  test085 ( );
  test0855 ( );
  test086 ( );
  test087 ( );
  test088 ( );
  test089 ( );

  test090 ( );
  test091 ( );
  test092 ( );
  test093 ( );
  test094 ( );
  test0945 ( );
  test095 ( );
  test096 ( );
  test097 ( );
  test0972 ( );
  test0973 ( );
  test0974 ( );
  test0975 ( );
  test098 ( );
  test099 ( );
  test0995 ( );

  test100 ( );
  test101 ( );
  test102 ( );
  test103 ( );
  test1035 ( );
  test1037 ( );
  test104 ( );
  test105 ( );
  test106 ( );
  test107 ( );
  test108 ( );
  test10875 ( );
  test109 ( );

  test110 ( );
  test1105 ( );
  test111 ( );
  test112 ( );
  test113 ( );
  test1135 ( );
  test114 ( );
  test115 ( );
  test116 ( );
  test117 ( );
  test118 ( );
  test1185 ( );
  test119 ( );

  test120 ( );
  test121 ( );
  test122 ( );
  test123 ( );
  test124 ( );
  test125 ( );
  test1255 ( );
  test126 ( );
  test127 ( );
  test1275 ( );
  test128 ( );
  test1283 ( );
  test1285 ( );
  test129 ( );

  test131 ( );
  test132 ( );
  test1325 ( );
  test130 ( );
  test133 ( );
  test134 ( );
  test135 ( );
  test136 ( );
  test137 ( );
  test138 ( );
  test139 ( );

  test140 ( );
  test141 ( );
  test1415 ( );
  test142 ( );
  test143 ( );
  test144 ( );
  test1445 ( );
  test1447 ( );
  test145 ( );
  test146 ( );
  test1465 ( );
  test147 ( );
  test148 ( );
  test149 ( );

  test150 ( );
  test151 ( );
  test152 ( );
  test153 ( );
  test154 ( );
  test1545 ( );
  test155 ( );
  test156 ( );
  test157 ( );
  test1575 ( );
  test158 ( );
  test159 ( );

  cout << "\n";
  cout << "TEST_VALUES_PRB:\n";
  cout << "  Normal end of execution.\n";

  cout << "\n";
  timestamp ( );

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

void test001 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST001 tests ABRAM0_VALUES.
//
//  Modified:
//
//    30 June 2006
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST001:\n";
  cout << "  ABRAM0_VALUES stores values of \n";
  cout << "  the Abramowitz function of order 0.\n";
  cout << "\n";
  cout << "                X                   ABRAM0(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    abram0_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                          << "  "
         << setw(24) << setprecision ( 16 ) << x  << "  "
         << setw(24) << setprecision ( 16 ) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test002 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST002 tests ABRAM1_VALUES.
//
//  Modified:
//
//    20 January 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST002:\n";
  cout << "  ABRAM1_VALUES stores values of \n";
  cout << "  the Abramowitz function of order 1.\n";
  cout << "\n";
  cout << "                X                   ABRAM1(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    abram1_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                          << "  "
         << setw(24) << setprecision ( 16 ) << x  << "  "
         << setw(24) << setprecision ( 16 ) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test003 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST003 tests ABRAM2_VALUES.
//
//  Modified:
//
//    20 January 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST003:\n";
  cout << "  ABRAM2_VALUES stores values of \n";
  cout << "  the Abramowitz function of order 2.\n";
  cout << "\n";
  cout << "                X                   ABRAM3(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    abram2_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                          << "  "
         << setw(24) << setprecision ( 16 ) << x  << "  "
         << setw(24) << setprecision ( 16 ) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test0035 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST0035 tests AGM_VALUES.
//
//  Modified:
//
//    09 February 2008
//
//  Author:
//
//    John Burkardt
//
{
  double a;
  double b;
  double fx;
  int n_data;

  cout << "\n";
  cout << "TEST0035:\n";
  cout << "  AGM_VALUES stores values of \n";
  cout << "  the arithmetic geometric mean function.\n";
  cout << "\n";
  cout << "           A          B              AGM(A,B)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    agm_values ( &n_data, &a, &b, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                          << "  "
         << setw(14) << setprecision (  6 ) << a  << "  "
         << setw(14) << setprecision (  6 ) << b  << "  "
         << setw(24) << setprecision ( 16 ) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test004 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST004 tests AIRY_AI_VALUES.
//
//  Modified:
//
//    20 January 2007
//
//  Author:
//
//    John Burkardt
//
{
  double ai;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST004:\n";
  cout << "  AIRY_AI_VALUES stores values of \n";
  cout << "  the Airy functions Ai(X).\n";
  cout << "\n";
  cout << "                X                     Ai(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    airy_ai_values ( &n_data, &x, &ai );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                          << "  "
         << setw(24) << setprecision ( 16 ) << x  << "  "
         << setw(24) << setprecision ( 16 ) << ai << "\n";
  }
  return;
}
//****************************************************************************80

void test005 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST005 tests AIRY_AI_INT_VALUES.
//
//  Modified:
//
//    20 January 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST005:\n";
  cout << "  AIRY_AI_INT_VALUES stores values of \n";
  cout << "  the integral of the Airy Ai function.\n";
  cout << "\n";
  cout << "                X                     FX\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    airy_ai_int_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                          << "  "
         << setw(24) << setprecision ( 16 ) << x  << "  "
         << setw(24) << setprecision ( 16 ) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test006 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST006 tests AIRY_AI_PRIME_VALUES.
//
//  Modified:
//
//    20 January 2007
//
//  Author:
//
//    John Burkardt
//
{
  double aip;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST006:\n";
  cout << "  AIRY_AI_PRIME_VALUES stores values of \n";
  cout << "  the derivative of the Airy function Ai'(X).\n";
  cout << "\n";
  cout << "                X                    Ai'\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    airy_ai_prime_values ( &n_data, &x, &aip );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                           << "  "
         << setw(24) << setprecision ( 16 ) << x   << "  "
         << setw(24) << setprecision ( 16 ) << aip << "\n";
  }
  return;
}
//****************************************************************************80

void test007 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST007 tests AIRY_BI_VALUES.
//
//  Modified:
//
//    20 January 2007
//
//  Author:
//
//    John Burkardt
//
{
  double bi;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST007:\n";
  cout << "  AIRY_BI_VALUES stores values of \n";
  cout << "  the Airy function Bi.\n";
  cout << "\n";
  cout << "                X                     Bi\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    airy_bi_values ( &n_data, &x, &bi );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                          << "  "
         << setw(24) << setprecision ( 16 ) << x  << "  "
         << setw(24) << setprecision ( 16 ) << bi << "\n";
  }
  return;
}
//****************************************************************************80

void test008 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST008 tests AIRY_BI_INT_VALUES.
//
//  Modified:
//
//    20 January 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST008:\n";
  cout << "  AIRY_BI_INT_VALUES stores values of \n";
  cout << "  the integral of the Airy Bi function.\n";
  cout << "\n";
  cout << "                X                     FX\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    airy_bi_int_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                          << "  "
         << setw(24) << setprecision ( 16 ) << x  << "  "
         << setw(24) << setprecision ( 16 ) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test009 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST009 tests AIRY_BI_PRIME_VALUES.
//
//  Modified:
//
//    20 January 2007
//
//  Author:
//
//    John Burkardt
//
{
  double bip;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST009:\n";
  cout << "  AIRY_BI_PRIME_VALUES stores values of \n";
  cout << "  the derivative of Airy function Bi'(X).\n";
  cout << "\n";
  cout << "                X                     Bi'\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    airy_bi_prime_values ( &n_data, &x, &bip );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                           << "  "
         << setw(24) << setprecision ( 16 ) << x   << "  "
         << setw(24) << setprecision ( 16 ) << bip << "\n";
  }
  return;
}
//****************************************************************************80

void test0093 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST0093 tests AIRY_CAI_VALUES.
//
//  Modified:
//
//    13 April 2007
//
//  Author:
//
//    John Burkardt
//
{
  complex <double> cai;
  int n_data;
  complex <double> x;

  cout << "\n";
  cout << "TEST0093:\n";
  cout << "  AIRY_CAI_VALUES stores values of \n";
  cout << "  the Airy functions Ai(X) for complex argument.\n";
  cout << "\n";
  cout << "                X                     Ai\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    airy_cai_values ( &n_data, &x, &cai );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                                   << "  "
         << setw(14) << setprecision ( 6 ) << real ( x )   << "  "
         << setw(14) << setprecision ( 6 ) << imag ( x )   << "  "
         << setw(24) << setprecision (16 ) << real ( cai ) << "  "
         << setw(24) << setprecision (16 ) << imag ( cai ) << "\n";
  }
  return;
}
//****************************************************************************80

void test0095 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST0095 tests AIRY_CBI_VALUES.
//
//  Modified:
//
//    13 April 2007
//
//  Author:
//
//    John Burkardt
//
{
  complex <double> cbi;
  int n_data;
  complex <double> x;

  cout << "\n";
  cout << "TEST0095:\n";
  cout << "  AIRY_CBI_VALUES stores values of \n";
  cout << "  the Airy functions Bi(X) for complex argument.\n";
  cout << "\n";
  cout << "                X                     Bi\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    airy_cbi_values ( &n_data, &x, &cbi );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                                   << "  "
         << setw(14) << setprecision ( 6 ) << real ( x )   << "  "
         << setw(14) << setprecision ( 6 ) << imag ( x )   << "  "
         << setw(24) << setprecision (16 ) << real ( cbi ) << "  "
         << setw(24) << setprecision (16 ) << imag ( cbi ) << "\n";
  }
  return;
}
//****************************************************************************80

void test010 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST010 tests AIRY_GI_VALUES.
//
//  Modified:
//
//    20 January 2007
//
//  Author:
//
//    John Burkardt
//
{
  double bip;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST010:\n";
  cout << "  AIRY_GI_VALUES stores values of \n";
  cout << "  the modified Airy function Gi(X).\n";
  cout << "\n";
  cout << "                X                     Gi\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    airy_gi_values ( &n_data, &x, &bip );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                           << "  "
         << setw(24) << setprecision ( 16 ) << x   << "  "
         << setw(24) << setprecision ( 16 ) << bip << "\n";
  }
  return;
}
//****************************************************************************80

void test011 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST011 tests AIRY_HI_VALUES.
//
//  Modified:
//
//    07 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  double bip;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST011:\n";
  cout << "  AIRY_HI_VALUES stores values of \n";
  cout << "  the modified Airy function Hi(X).\n";
  cout << "\n";
  cout << "                X                     Hi\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    airy_hi_values ( &n_data, &x, &bip );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                           << "  "
         << setw(24) << setprecision ( 16 ) << x   << "  "
         << setw(24) << setprecision ( 16 ) << bip << "\n";
  }
  return;
}
//****************************************************************************80

void test0114 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST0114 tests ARCCOS_VALUES.
//
//  Modified:
//
//    12 June 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST0114:\n";
  cout << "  ARCCOS_VALUES stores values of the arc cosine function.\n";
  cout << "\n";
  cout << "                X                     FX\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    arccos_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                          << "  "
         << setw(24) << setprecision ( 16 ) << x  << "  "
         << setw(24) << setprecision ( 16 ) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test01145 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST01145 tests ARCCOSH_VALUES.
//
//  Modified:
//
//    23 June 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST01145:\n";
  cout << 
    "  ARCCOSH_VALUES stores values of the hyperbolic arc cosine function.\n";
  cout << "\n";
  cout << "                X                     FX\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    arccosh_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                          << "  "
         << setw(24) << setprecision ( 16 ) << x  << "  "
         << setw(24) << setprecision ( 16 ) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test0115 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST0115 tests ARCSIN_VALUES.
//
//  Modified:
//
//    12 June 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST0115:\n";
  cout << "  ARCSIN_VALUES stores values of the arc sine function.\n";
  cout << "\n";
  cout << "                X                     FX\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    arcsin_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                          << "  "
         << setw(24) << setprecision ( 16 ) << x  << "  "
         << setw(24) << setprecision ( 16 ) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test01155 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST01155 tests ARCSINH_VALUES.
//
//  Modified:
//
//    23 June 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST01155:\n";
  cout << 
    "  ARCSINH_VALUES stores values of the hyperbolic arc sine function.\n";
  cout << "\n";
  cout << "                X                     FX\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    arcsinh_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                          << "  "
         << setw(24) << setprecision ( 16 ) << x  << "  "
         << setw(24) << setprecision ( 16 ) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test0116 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST0116 tests ARCTAN_VALUES.
//
//  Modified:
//
//    12 June 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST0116:\n";
  cout << "  ARCTAN_VALUES stores values of the arc tangent function.\n";
  cout << "\n";
  cout << "                X                     FX\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    arctan_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                          << "  "
         << setw(24) << setprecision ( 16 ) << x  << "  "
         << setw(24) << setprecision ( 16 ) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test012 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST012 tests ARCTAN_INT_VALUES.
//
//  Modified:
//
//    07 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  double bip;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST012:\n";
  cout << "  ARCTAN_INT_VALUES stores values of \n";
  cout << "  the arctangent integral.\n";
  cout << "\n";
  cout << "                X                     FX\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    arctan_int_values ( &n_data, &x, &bip );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                           << "  "
         << setw(24) << setprecision ( 16 ) << x   << "  "
         << setw(24) << setprecision ( 16 ) << bip << "\n";
  }
  return;
}
//****************************************************************************80

void test0123 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST01235 tests ARCTANH_VALUES.
//
//  Modified:
//
//    23 June 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST0123:\n";
  cout << 
    "  ARCTANH_VALUES stores values of the hyperbolic arc tangent function.\n";
  cout << "\n";
  cout << "                X                     FX\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    arctanh_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                          << "  "
         << setw(24) << setprecision ( 16 ) << x  << "  "
         << setw(24) << setprecision ( 16 ) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test0127 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST0127 tests BEI0_VALUES.
//
//  Modified:
//
//    30 June 2006
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST0127:\n";
  cout << "  BEI0_VALUES stores values of \n";
  cout << "  the Kelvin function BEI of order 0.\n";
  cout << "\n";
  cout << "                X                     FX\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    bei0_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                          << "  "
         << setw(24) << setprecision ( 16 ) << x  << "  "
         << setw(24) << setprecision ( 16 ) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test0128 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST0128 tests BEI1_VALUES.
//
//  Modified:
//
//    30 June 2006
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST0128:\n";
  cout << "  BEI1_VALUES stores values of \n";
  cout << "  the Kelvin function BEI of order 1.\n";
  cout << "\n";
  cout << "                X                     FX\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    bei1_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                          << "  "
         << setw(24) << setprecision ( 16 ) << x  << "  "
         << setw(24) << setprecision ( 16 ) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test013 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST013 tests BELL_VALUES.
//
//  Modified:
//
//    07 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  int c;
  int n;
  int n_data;

  cout << "\n";
  cout << "TEST013:\n";
  cout << "  BELL_VALUES returns values of \n";
  cout << "  the Bell numbers.\n";
  cout << "\n";
  cout << "     N        BELL(N)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    bell_values ( &n_data, &n, &c );

    if ( n_data == 0 )
    {
      break;
    }
    cout                  << "  "
         << setw(6)  << n << "  "
         << setw(10) << c << "\n";
  }
  return;
}
//****************************************************************************80

void test0134 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST0134 tests BER0_VALUES.
//
//  Modified:
//
//    30 June 2006
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST0134:\n";
  cout << "  BER0_VALUES stores values of \n";
  cout << "  the Kelvin function BER of order 0.\n";
  cout << "\n";
  cout << "                X                     FX\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    ber0_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                          << "  "
         << setw(24) << setprecision ( 16 ) << x  << "  "
         << setw(24) << setprecision ( 16 ) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test0135 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST0135 tests BER1_VALUES.
//
//  Modified:
//
//    30 June 2006
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST0135:\n";
  cout << "  BER1_VALUES stores values of \n";
  cout << "  the Kelvin function BER of order 1.\n";
  cout << "\n";
  cout << "                X                     FX\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    ber1_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                          << "  "
         << setw(24) << setprecision ( 16 ) << x  << "  "
         << setw(24) << setprecision ( 16 ) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test014 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST014 tests BERNOULLI_NUMBER_VALUES.
//
//  Modified:
//
//    07 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  double c;
  int n;
  int n_data;

  cout << "\n";
  cout << "TEST014:\n";
  cout << "  BERNOULLI_NUMBER_VALUES returns values of \n";
  cout << "  the Bernoulli numbers.\n";
  cout << "\n";
  cout << "     N              B(N)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    bernoulli_number_values ( &n_data, &n, &c );

    if ( n_data == 0 )
    {
      break;
    }
    cout                  << "  "
         << setw(6)  << n << "  "
         << setw(12) << c << "\n";
  }
  return;
}
//****************************************************************************80

void test015 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST015 tests BERNOULLI_POLY_VALUES.
//
//  Modified:
//
//    07 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  double b;
  int n;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST015:\n";
  cout << "  BERNOULLI_POLY_VALUES returns values of \n";
  cout << "  the Bernoulli Polynomials.\n";
  cout << "\n";
  cout << "     N     X      BERNOULLI(N)(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    bernoulli_poly_values ( &n_data, &n, &x, &b );

    if ( n_data == 0 )
    {
      break;
    }
    cout                  << "  "
         << setw(6)  << n << "  "
         << setw(12) << x << "  "
         << setw(12) << b << "\n";
  }
  return;
}
//****************************************************************************80

void test016 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST016 tests BERNSTEIN_POLY_VALUES.
//
//  Modified:
//
//    07 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  double b;
  int k;
  int n;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST016:\n";
  cout << "  BERNSTEIN_POLY_VALUES returns values of \n";
  cout << "  the Bernstein Polynomials.\n";
  cout << "\n";
  cout << "     N     K       X      BERNSTEIN(N,K)(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    bernstein_poly_values ( &n_data, &n, &k, &x, &b );

    if ( n_data == 0 )
    {
      break;
    }
    cout                  << "  "
         << setw(6)  << n << "  "
         << setw(6)  << k << "  "
         << setw(12) << x << "  "
         << setw(12) << b << "\n";
  }
  return;
}
//****************************************************************************80

void test017 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST017 tests BESSEL_I0_VALUES.
//
//  Modified:
//
//    07 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST017:\n";
  cout << "  BESSEL_I0_VALUES stores values of \n";
  cout << "  the Bessel I0 function.\n";
  cout << "\n";
  cout << "      X         I0(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    bessel_i0_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(12) << x  << "  "
         << setw(12) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test018 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST018 tests BESSEL_I0_INT_VALUES.
//
//  Modified:
//
//    07 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  double bip;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST018:\n";
  cout << "  BESSEL_I0_INT_VALUES stores values of \n";
  cout << "  the integral of the Bessel I0 function.\n";
  cout << "\n";
  cout << "                X                     FX\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    bessel_i0_int_values ( &n_data, &x, &bip );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                           << "  "
         << setw(24) << setprecision ( 16 ) << x   << "  "
         << setw(24) << setprecision ( 16 ) << bip << "\n";
  }
  return;
}
//****************************************************************************80

void test0185 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST0185 tests BESSEL_I0_SPHERICAL_VALUES.
//
//  Modified:
//
//    06 January 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST0185:\n";
  cout << "  BESSEL_I0_SPHERICAL_VALUES stores values of\n";
  cout << "  the spherical Bessel i0 function.\n";
  cout << "\n";
  cout << "      X            i0(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
   bessel_i0_spherical_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(12) << x  << "  "
         << setw(12) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test019 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST019 tests BESSEL_I1_VALUES.
//
//  Modified:
//
//    07 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST019:\n";
  cout << "  BESSEL_I1_VALUES stores values of \n";
  cout << "  the Bessel I1 function.\n";
  cout << "\n";
  cout << "      X         I1(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    bessel_i1_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(12) << x  << "  "
         << setw(12) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test0195 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST0195 tests BESSEL_I1_SPHERICAL_VALUES.
//
//  Modified:
//
//    06 January 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST0195:\n";
  cout << "  BESSEL_I1_SPHERICAL_VALUES stores values of\n";
  cout << "  the spherical Bessel i1 function.\n";
  cout << "\n";
  cout << "      X            i1(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
   bessel_i1_spherical_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(12) << x  << "  "
         << setw(12) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test020 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST020 tests BESSEL_IN_VALUES.
//
//  Modified:
//
//    07 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST020:\n";
  cout << "  BESSEL_IN_VALUES stores values of \n";
  cout << "  the Bessel In function.\n";
  cout << "\n";
  cout << "      X         IN(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    bessel_in_values ( &n_data, &n, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(6)  << n  << "  "
         << setw(12) << x  << "  "
         << setw(12) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test0205 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST0205 tests BESSEL_IX_VALUES.
//
//  Modified:
//
//    07 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  double n;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST0205:\n";
  cout << "  BESSEL_IX_VALUES stores values of \n";
  cout << "  the Bessel In function for NONINTEGER order.\n";
  cout << "\n";
  cout << "      X         IN(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    bessel_ix_values ( &n_data, &n, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(12) << n  << "  "
         << setw(12) << x  << "  "
         << setw(12) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test021 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST021 tests BESSEL_J0_VALUES.
//
//  Modified:
//
//    07 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST021:\n";
  cout << "  BESSEL_J0_VALUES stores values of \n";
  cout << "  the Bessel J0 function.\n";
  cout << "\n";
  cout << "      X         J0(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    bessel_j0_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(12) << x  << "  "
         << setw(12) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test022 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST022 tests BESSEL_J0_INT_VALUES.
//
//  Modified:
//
//    07 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  double bip;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST022:\n";
  cout << "  BESSEL_J0_INT_VALUES stores values of \n";
  cout << "  the integral of the Bessel J0 function.\n";
  cout << "\n";
  cout << "                X                     FX\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    bessel_j0_int_values ( &n_data, &x, &bip );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                           << "  "
         << setw(24) << setprecision ( 16 ) << x   << "  "
         << setw(24) << setprecision ( 16 ) << bip << "\n";
  }
  return;
}
//****************************************************************************80

void test023 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST023 tests BESSEL_J0_SPHERICAL_VALUES.
//
//  Modified:
//
//    06 January 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST023:\n";
  cout << "  BESSEL_J0_SPHERICAL_VALUES stores values of\n";
  cout << "  the spherical Bessel j0 function.\n";
  cout << "\n";
  cout << "      X            j0(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
   bessel_j0_spherical_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(12) << x  << "  "
         << setw(12) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test024 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST024 tests BESSEL_J1_VALUES.
//
//  Modified:
//
//    07 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST024:\n";
  cout << "  BESSEL_J1_VALUES stores values of \n";
  cout << "  the Bessel J1 function.\n";
  cout << "\n";
  cout << "      X         J1(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    bessel_j1_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(12) << x  << "  "
         << setw(12) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test025 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST025 tests BESSEL_J1_SPHERICAL_VALUES.
//
//  Modified:
//
//    06 January 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST025:\n";
  cout << "  BESSEL_J1_SPHERICAL_VALUES stores values of\n";
  cout << "  the spherical Bessel j1 function.\n";
  cout << "\n";
  cout << "      X            j1(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
   bessel_j1_spherical_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(12) << x  << "  "
         << setw(12) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test026 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST026 tests BESSEL_JN_VALUES.
//
//  Modified:
//
//    07 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST026:\n";
  cout << "  BESSEL_JN_VALUES stores values of \n";
  cout << "  the Bessel Jn function.\n";
  cout << "\n";
  cout << "      X         JN(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    bessel_jn_values ( &n_data, &n, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(6)  << n  << "  "
         << setw(12) << x  << "  "
         << setw(12) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test0265 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST0265 tests BESSEL_JX_VALUES.
//
//  Modified:
//
//    01 April 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  double n;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST0265:\n";
  cout << "  BESSEL_JX_VALUES stores values of \n";
  cout << "  the Bessel Jn function for NONINTEGER order.\n";
  cout << "\n";
  cout << "      X         JN(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    bessel_jx_values ( &n_data, &n, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(12) << n  << "  "
         << setw(12) << x  << "  "
         << setw(12) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test027 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST027 tests BESSEL_K0_VALUES.
//
//  Modified:
//
//    07 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST027:\n";
  cout << "  BESSEL_K0_VALUES stores values of \n";
  cout << "  the Bessel K0 function.\n";
  cout << "\n";
  cout << "      X         K0(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    bessel_k0_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(12) << x  << "  "
         << setw(12) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test028 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST028 tests BESSEL_K0_INT_VALUES.
//
//  Modified:
//
//    07 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  double bip;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST028:\n";
  cout << "  BESSEL_K0_INT_VALUES stores values of \n";
  cout << "  the integral of the Bessel K0 function.\n";
  cout << "\n";
  cout << "                X                     FX\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    bessel_k0_int_values ( &n_data, &x, &bip );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                           << "  "
         << setw(24) << setprecision ( 16 ) << x   << "  "
         << setw(24) << setprecision ( 16 ) << bip << "\n";
  }
  return;
}
//****************************************************************************80

void test029 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST029 tests BESSEL_K1_VALUES.
//
//  Modified:
//
//    07 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST029:\n";
  cout << "  BESSEL_K1_VALUES stores values of \n";
  cout << "  the Bessel K1 function.\n";
  cout << "\n";
  cout << "      X         K1(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    bessel_k1_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(12) << x  << "  "
         << setw(12) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test030 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST030 tests BESSEL_KN_VALUES.
//
//  Modified:
//
//    07 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST030:\n";
  cout << "  BESSEL_KN_VALUES stores values of \n";
  cout << "  the Bessel Kn function.\n";
  cout << "\n";
  cout << "      X         KN(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    bessel_kn_values ( &n_data, &n, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(6)  << n  << "  "
         << setw(12) << x  << "  "
         << setw(12) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test0305 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST0305 tests BESSEL_KX_VALUES.
//
//  Modified:
//
//    01 April 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  double n;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST0305:\n";
  cout << "  BESSEL_KX_VALUES stores values of \n";
  cout << "  the Bessel Kn function for NONINTEGER order.\n";
  cout << "\n";
  cout << "      X         KN(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    bessel_kx_values ( &n_data, &n, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(12) << n  << "  "
         << setw(12) << x  << "  "
         << setw(12) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test031 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST031 tests BESSEL_Y0_VALUES.
//
//  Modified:
//
//    02 March 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST031:\n";
  cout << "  BESSEL_Y0_VALUES stores values of \n";
  cout << "  the Bessel Y0 function.\n";
  cout << "\n";
  cout << "      X         Y0(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    bessel_y0_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(12) << x  << "  "
         << setw(12) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test032 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST032 tests BESSEL_Y0_INT_VALUES.
//
//  Modified:
//
//    02 March 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST032:\n";
  cout << "  BESSEL_Y0_INT_VALUES stores values of \n";
  cout << "  the integral of the Bessel Y0 function.\n";
  cout << "\n";
  cout << "                X                     FX\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    bessel_y0_int_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                          << "  "
         << setw(24) << setprecision ( 16 ) << x  << "  "
         << setw(24) << setprecision ( 16 ) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test033 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST033 tests BESSEL_Y0_SPHERICAL_VALUES.
//
//  Modified:
//
//    02 March 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST033:\n";
  cout << "  BESSEL_Y0_SPHERICAL_VALUES stores values of\n";
  cout << "  the spherical Bessel y0 function.\n";
  cout << "\n";
  cout << "                X                      y0(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
   bessel_y0_spherical_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                          << "  "
         << setw(24) << setprecision ( 16 ) << x  << "  "
         << setw(24) << setprecision ( 16 ) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test034 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST034 tests BESSEL_Y1_VALUES.
//
//  Modified:
//
//    02 March 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST034:\n";
  cout << "  BESSEL_Y1_VALUES stores values of \n";
  cout << "  the Bessel Y1 function.\n";
  cout << "\n";
  cout << "                X                   Y1(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    bessel_y1_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                          << "  "
         << setw(24) << setprecision ( 16 ) << x  << "  "
         << setw(24) << setprecision ( 16 ) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test035 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST035 tests BESSEL_Y1_SPHERICAL_VALUES.
//
//  Modified:
//
//    02 March 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST035:\n";
  cout << "  BESSEL_Y1_SPHERICAL_VALUES stores values of\n";
  cout << "  the spherical Bessel y1 function.\n";
  cout << "\n";
  cout << "                X                      y1(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
   bessel_y1_spherical_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                          << "  "
         << setw(24) << setprecision ( 16 ) << x  << "  "
         << setw(24) << setprecision ( 16 ) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test036 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST036 tests BESSEL_YN_VALUES.
//
//  Modified:
//
//    02 March 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST036:\n";
  cout << "  BESSEL_YN_VALUES stores values of \n";
  cout << "  the Bessel Yn function.\n";
  cout << "\n";
  cout << "      X         YN(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    bessel_yn_values ( &n_data, &n, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(6)  << n  << "  "
         << setw(12) << x  << "  "
         << setw(12) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test0365 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST0365 tests BESSEL_YX_VALUES.
//
//  Modified:
//
//    01 April 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  double n;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST0365:\n";
  cout << "  BESSEL_YX_VALUES stores values of \n";
  cout << "  the Bessel Yn function for NONINTEGER order.\n";
  cout << "\n";
  cout << "      X         YN(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    bessel_yx_values ( &n_data, &n, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(12) << n  << "  "
         << setw(12) << x  << "  "
         << setw(12) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test037 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST037 tests BETA_CDF_VALUES.
//
//  Modified:
//
//    02 March 2007
//
//  Author:
//
//    John Burkardt
//
{
  double a;
  double b;
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST037:\n";
  cout << "  BETA_CDF_VALUES stores values of\n";
  cout << "  the Beta CDF.\n";
  cout << "\n";
  cout << "      A            B            X            CDF(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    beta_cdf_values ( &n_data, &a, &b, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                 << "  "
         << setw(12)                     << a  << "  "
         << setw(12)                     << b  << "  "
         << setw(12)                     << x  << "  "
         << setw(24) << setprecision(16) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test038 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST038 tests BETA_INC_VALUES.
//
//  Modified:
//
//    02 March 2007
//
//  Author:
//
//    John Burkardt
//
{
  double a;
  double b;
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST038:\n";
  cout << "  BETA_INC_VALUES stores values of\n";
  cout << "  the incomplete Beta function.\n";
  cout << "\n";
  cout << "      A            B            X            BETA_INC(A,B)(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    beta_inc_values ( &n_data, &a, &b, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                 << "  "
         << setw(12)                     << a  << "  "
         << setw(12)                     << b  << "  "
         << setw(12)                     << x  << "  "
         << setw(24) << setprecision(16) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test039 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST039 tests BETA_LOG_VALUES.
//
//  Modified:
//
//    02 March 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fxy;
  int n_data;
  double x;
  double y;

  cout << "\n";
  cout << "TEST039:\n";
  cout << "  BETA_LOG_VALUES stores values of\n";
  cout << "  the logarithm of the Beta function.\n";
  cout << "\n";
  cout << "      X              Y         BETA_LOG(X,Y)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    beta_log_values ( &n_data, &x, &y, &fxy );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                 << "  "
         << setw(12)                     << x   << "  "
         << setw(12)                     << y   << "  "
         << setw(24) << setprecision(16) << fxy << "\n";
  }
  return;
}
//****************************************************************************80

void test0395 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST0395 tests BETA_NONCENTRAL_CDF_VALUES.
//
//  Modified:
//
//    25 January 2008
//
//  Author:
//
//    John Burkardt
//
{
  double a;
  double b;
  double fx;
  double lambda;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST0395:\n";
  cout << "  BETA_NONCENTRAL_CDF_VALUES stores values of\n";
  cout << "  the noncentral Beta CDF.\n";
  cout << "\n";
  cout << "      A            B       LAMBDA             X            CDF(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    beta_noncentral_cdf_values ( &n_data, &a, &b, &lambda, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                 << "  "
         << setw(12)                     << a  << "  "
         << setw(12)                     << b  << "  "
         << setw(12)                     << lambda << "  "
         << setw(12)                     << x  << "  "
         << setw(24) << setprecision(16) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test040 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST040 tests BETA_VALUES.
//
//  Modified:
//
//    02 March 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fxy;
  int n_data;
  double x;
  double y;

  cout << "\n";
  cout << "TEST040:\n";
  cout << "  BETA_VALUES stores values of\n";
  cout << "  the Beta function.\n";
  cout << "\n";
  cout << "      X              Y         BETA(X,Y)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    beta_values ( &n_data, &x, &y, &fxy );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                 << "  "
         << setw(12)                     << x   << "  "
         << setw(12)                     << y   << "  "
         << setw(24) << setprecision(16) << fxy << "\n";
  }
  return;
}
//****************************************************************************80

void test041 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST041 tests BINOMIAL_VALUES.
//
//  Modified:
//
//    02 March 2007
//
//  Author:
//
//    John Burkardt
//
{
  int a;
  int b;
  int c;
  int n_data;

  cout << "\n";
  cout << "TEST041:\n";
  cout << "  BINOMIAL_VALUES returns values of\n";
  cout << "  the binomial numbers.\n";
  cout << "\n";
  cout << "     A     B        C(A,B)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    binomial_values ( &n_data, &a, &b, &c );

    if ( n_data == 0 )
    {
      break;
    }
    cout                  << "  "
         << setw(6)  << a << "  "
         << setw(6)  << b << "  "
         << setw(12) << c << "\n";
  }
  return;
}
//****************************************************************************80

void test042 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST042 tests BINOMIAL_CDF_VALUES.
//
//  Modified:
//
//    02 March 2007
//
//  Author:
//
//    John Burkardt
//
{
  int a;
  double b;
  double fx;
  int n_data;
  int x;

  cout << "\n";
  cout << "TEST042:\n";
  cout << "  BINOMIAL_CDF_VALUES returns values of \n";
  cout << "  the Binomial Cumulative Density Function.\n";
  cout << "\n";
  cout << "     A      B        X   CDF(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    binomial_cdf_values ( &n_data, &a, &b, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                  << "  "
         << setw(6)                      << a  << "  "
         << setw(8)                      << b  << "  "
         << setw(4)                      << x  << "  "
         << setw(24) << setprecision(16) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test0425 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST0425 tests BETA_INC_VALUES.
//
//  Modified:
//
//    06 December 2005
//
//  Author:
//
//    John Burkardt
//
{
  double fxy;
  int n_data;
  double r;
  double x;
  double y;

  cout << "\n";
  cout << "TEST0425:\n";
  cout << "  BIVARIATE_NORMAL_CDF_VALUES stores values of\n";
  cout << "  the bivariate normal CDF.\n";
  cout << "\n";
  cout << "      R            X            Y            F(R)(X,Y)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    bivariate_normal_cdf_values ( &n_data, &r, &x, &y, &fxy );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                 << "  "
         << setw(12)                     << r   << "  "
         << setw(12)                     << x   << "  "
         << setw(12)                     << y   << "  "
         << setw(24) << setprecision(16) << fxy << "\n";
  }
  return;
}
//****************************************************************************80

void test043 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST043 tests CATALAN_VALUES.
//
//  Modified:
//
//    02 March 2007
//
//  Author:
//
//    John Burkardt
//
{
  int c;
  int n;
  int n_data;

  cout << "\n";
  cout << "TEST043:\n";
  cout << "  CATALAN_VALUES returns values of \n";
  cout << "  the Catalan numbers.\n";
  cout << "\n";
  cout << "     N        C(N)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    catalan_values ( &n_data, &n, &c );

    if ( n_data == 0 )
    {
      break;
    }
    cout                  << "  "
         << setw(6)  << n << "  "
         << setw(10) << c << "\n";
  }
  return;
}
//****************************************************************************80

void test044 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST044 tests CAUCHY_CDF_VALUES.
//
//  Modified:
//
//    02 March 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  double mu;
  int n_data;
  double sigma;
  double x;

  cout << "\n";
  cout << "TEST044:\n";
  cout << "  CAUCHY_CDF_VALUES returns values of \n";
  cout << "  the Cauchy Cumulative Density Function.\n";
  cout << "\n";
  cout << "     Mu      Sigma        X   CDF(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    cauchy_cdf_values ( &n_data, &mu, &sigma, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                 << "  "
         << setw(8)                      << mu    << "  "
         << setw(8)                      << sigma << "  "
         << setw(8)                      << x     << "  "
         << setw(24) << setprecision(16) << fx    << "\n";
  }
  return;
}
//****************************************************************************80

void test0445 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST0445 tests CBRT_VALUES.
//
//  Modified:
//
//    22 June 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST0445:\n";
  cout << "  CBRT_VALUES stores values of the cube root function.\n";
  cout << "\n";
  cout << "      X            CBRT(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    cbrt_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(12) << x  << "  "
         << setw(12) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test045 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST045 tests CHEBYSHEV_T_VALUES.
//
//  Modified:
//
//    02 March 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST045:\n";
  cout << "  CHEBYSHEV_T_VALUES returns values of\n";
  cout << "  the Chebyshev T polynomials.\n";
  cout << "\n";
  cout << "     N       X      T(N)(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    chebyshev_t_values ( &n_data, &n, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(6)  << n  << "  "
         << setw(8)  << x  << "  "
         << setw(12) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test046 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST046 tests CHEBYSHEV_U_VALUES.
//
//  Modified:
//
//    09 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST046:\n";
  cout << "  CHEBYSHEV_U_VALUES returns values of\n";
  cout << "  the Chebyshev U polynomials.\n";
  cout << "\n";
  cout << "     N       X      U(N)(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    chebyshev_u_values ( &n_data, &n, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(6)  << n  << "  "
         << setw(8)  << x  << "  "
         << setw(12) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test0465 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST0465 tests CHI_VALUES.
//
//  Modified:
//
//    11 June 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST0465:\n";
  cout << "  CHI_VALUES stores values of\n";
  cout << "  the Hyperbolic Cosine Integral function CHI(X).\n";
  cout << "\n";
  cout << "      X            CHI(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    chi_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(12) << x  << "  "
         << setw(12) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test047 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST047 tests CHI_SQUARE_CDF_VALUES.
//
//  Modified:
//
//    09 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  int a;
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST047:\n";
  cout << "  CHI_SQUARE_CDF_VALUES returns values of \n";
  cout << "  the Chi-Squared Cumulative Density Function.\n";
  cout << "\n";
  cout << "     N       X    CDF(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    chi_square_cdf_values ( &n_data, &a, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(6)  << a  << "  "
         << setw(8)  << x  << "  "
         << setw(12) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test048 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST048 tests CHI_SQUARE_NONCENTRAL_CDF_VALUES.
//
//  Modified:
//
//    09 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  int df;
  double fx;
  double lambda;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST048:\n";
  cout << "  CHI_SQUARE_NONCENTRAL_CDF_VALUES returns values of\n";
  cout << "  the noncentral Chi-Squared Cumulative Density Function.\n";
  cout << "\n";
  cout << "      X      LAMBDA     DF     CDF\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    chi_square_noncentral_cdf_values ( &n_data, &df, &lambda, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                       << "  "
         << setw(10) << x      << "  "
         << setw(8)  << lambda << "  "
         << setw(4)  << df     << "  "
         << setw(12) << fx     << "\n";
  }
  return;
}
//****************************************************************************80

void test049 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST049 tests CI_VALUES.
//
//  Modified:
//
//    09 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST049:\n";
  cout << "  CI_VALUES stores values of\n";
  cout << "  the Cosine Integral function CI(X).\n";
  cout << "\n";
  cout << "      X            CI(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    ci_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(12) << x  << "  "
         << setw(12) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test050 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST050 tests CIN_VALUES.
//
//  Modified:
//
//    09 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST050:\n";
  cout << "  CIN_VALUES stores values of\n";
  cout << "  the Cosine Integral function CIN(X).\n";
  cout << "\n";
  cout << "      X            CIN(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    cin_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(12) << x  << "  "
         << setw(12) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test051 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST051 tests BESSEL_Y0_INT_VALUES.
//
//  Modified:
//
//    09 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST051:\n";
  cout << "  CLAUSEN_VALUES stores values of \n";
  cout << "  Clausen's integral function.\n";
  cout << "\n";
  cout << "                X                     FX\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    clausen_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                          << "  "
         << setw(24) << setprecision ( 16 ) << x  << "  "
         << setw(24) << setprecision ( 16 ) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test05125 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST05125 tests CLEBSCH_GORDAN_VALUES.
//
//  Modified:
//
//    09 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  double j1;
  double j2;
  double j3;
  double m1;
  double m2;
  double m3;
  int n_data;

  cout << "\n";
  cout << "TEST05125:\n";
  cout << "  CLEBSCH_GORDAN_VALUES returns values of\n";
  cout << "  the Clebsch Gordan coefficient.\n";
  cout << "\n";
  cout << "      J1      J2      J3      M1      M2      M3        CG\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    clebsch_gordan_values ( &n_data, &j1, &j2, &j3, &m1, &m2, &m3, &fx );

    if ( n_data == 0 )
    {
      break;
    }

    cout << "  " << setw(6) << j1
         << "  " << setw(6) << j2
         << "  " << setw(6) << j3
         << "  " << setw(6) << m1
         << "  " << setw(6) << m2
         << "  " << setw(6) << m3
         << "  " << setprecision(16) << setw(24) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test0515 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST0515 tests COLLATZ_COUNT_VALUES.
//
//  Modified:
//
//    07 March 2006
//
//  Author:
//
//    John Burkardt
//
{
  int count;
  int n;
  int n_data;

  cout << "\n";
  cout << "TEST0515:\n";
  cout << "  COLLATZ_COUNT_VALUES returns values of\n";
  cout << "  the length of the Collatz sequence that\n";
  cout << "  starts at N.\n";
  cout << "\n";
  cout << "         N      COLLATZ_COUNT(N)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    collatz_count_values ( &n_data, &n, &count );

    if ( n_data == 0 )
    {
      break;
    }
    cout << "  " << setw(8)  << n
         << "  " << setw(12) << count << "\n";
  }

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

void test0517 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST0517 tests COS_VALUES.
//
//  Modified:
//
//    12 June 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST0517:\n";
  cout << "   COS_VALUES stores values of the cosine function.\n";
  cout << "\n";
  cout << "                X                     FX\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    cos_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                          << "  "
         << setw(24) << setprecision ( 16 ) << x  << "  "
         << setw(24) << setprecision ( 16 ) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test0519 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST0519 tests COSH_VALUES.
//
//  Modified:
//
//    23 June 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST0519:\n";
  cout << "   COSH_VALUES stores values of the hyperbolic cosine function.\n";
  cout << "\n";
  cout << "                X                     FX\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    cosh_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                          << "  "
         << setw(24) << setprecision ( 16 ) << x  << "  "
         << setw(24) << setprecision ( 16 ) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test052 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST052 tests CP_VALUES.
//
//  Modified:
//
//    09 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  double cp;
  int n_data;
  double p;
  double tc;

  cout << "\n";
  cout << "TEST052:\n";
  cout << "  CP_VALUES stores values of\n";
  cout << "  the specific heat CP\n";
  cout << "  as a function of temperature and pressure.\n";
  cout << "\n";
  cout << "      T            P            CP(T,P)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    cp_values ( &n_data, &tc, &p, &cp );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(12) << tc << "  "
         << setw(12) << p  << "  "
         << setw(12) << cp << "\n";
  }
  return;
}
//****************************************************************************80

void test053 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST053 tests DAWSON_VALUES.
//
//  Modified:
//
//    09 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST053:\n";
  cout << "  DAWSON_VALUES stores values of\n";
  cout << "  Dawson's integral function.\n";
  cout << "\n";
  cout << "      X          DAWSON(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    dawson_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(12) << x  << "  "
         << setw(12) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test054 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST054 tests DEBYE1_VALUES.
//
//  Modified:
//
//    09 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST054:\n";
  cout << "  DEBYE1_VALUES stores values of \n";
  cout << "  the Debye function of order 1.\n";
  cout << "\n";
  cout << "                X                     FX\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    debye1_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                          << "  "
         << setw(24) << setprecision ( 16 ) << x  << "  "
         << setw(24) << setprecision ( 16 ) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test055 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST055 tests DEBYE2_VALUES.
//
//  Modified:
//
//    09 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST055:\n";
  cout << "  DEBYE2_VALUES stores values of \n";
  cout << "  the Debye function of order 2.\n";
  cout << "\n";
  cout << "                X                     FX\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    debye2_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                          << "  "
         << setw(24) << setprecision ( 16 ) << x  << "  "
         << setw(24) << setprecision ( 16 ) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test056 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST056 tests DEBYE3_VALUES.
//
//  Modified:
//
//    09 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST056:\n";
  cout << "  DEBYE3_VALUES stores values of \n";
  cout << "  the Debye function of order 3.\n";
  cout << "\n";
  cout << "                X                     FX\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    debye3_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                          << "  "
         << setw(24) << setprecision ( 16 ) << x  << "  "
         << setw(24) << setprecision ( 16 ) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test057 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST057 tests DEBYE4_VALUES.
//
//  Modified:
//
//    09 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST057:\n";
  cout << "  DEBYE4_VALUES stores values of \n";
  cout << "  the Debye function of order 4.\n";
  cout << "\n";
  cout << "                X                     FX\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    debye4_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                          << "  "
         << setw(24) << setprecision ( 16 ) << x  << "  "
         << setw(24) << setprecision ( 16 ) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test058 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST058 tests DIELECTRIC_VALUES.
//
//  Modified:
//
//    09 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  double eps;
  int n_data;
  double p;
  double tc;

  cout << "\n";
  cout << "TEST058:\n";
  cout << "  DIELECTRIC_VALUES stores values of\n";
  cout << "  the dielectric function.\n";
  cout << "\n";
  cout << "      T           P            EPS(T,P)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    dielectric_values ( &n_data, &tc, &p, &eps );

    if ( n_data == 0 )
    {
      break;
    }
    cout                    << "  "
         << setw(12) << tc  << "  "
         << setw(12) << p   << "  "
         << setw(12) << eps << "\n";
  }
  return;
}
//****************************************************************************80

void test059 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST059 tests DILOGARITHM_VALUES.
//
//  Modified:
//
//    09 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST059:\n";
  cout << "  DILOGARITHM_VALUES stores values of\n";
  cout << "  the dilogarithm function.\n";
  cout << "\n";
  cout << "      X          DILOGARITHM(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    dilogarithm_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(12) << x  << "  "
         << setw(12) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test060 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST060 tests E1_VALUES.
//
//  Modified:
//
//    09 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST060:\n";
  cout << "  E1_VALUES stores values of\n";
  cout << "  the exponential integral function E1(X).\n";
  cout << "\n";
  cout << "      X          E1(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    e1_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(12) << x  << "  "
         << setw(12) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test061 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST061 tests EI_VALUES.
//
//  Modified:
//
//    09 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST061:\n";
  cout << "  EI_VALUES stores values of\n";
  cout << "  the exponential integral function EI(X).\n";
  cout << "\n";
  cout << "      X          EI(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    ei_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(12) << x  << "  "
         << setw(12) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test062 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST062 tests ELLIPTIC_EA_VALUES.
//
//  Modified:
//
//    09 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST062:\n";
  cout << "  ELLIPTIC_EA_VALUES stores values of\n";
  cout << "  the complete elliptic integral of the second\n";
  cout << "  kind, with parameter angle ALPHA in degrees.\n";
  cout << "\n";
  cout << "    ALPHA        EA(ALPHA)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    elliptic_ea_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(12) << x  << "  "
         << setw(12) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test063 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST063 tests ELLIPTIC_EM_VALUES.
//
//  Modified:
//
//    09 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST063:\n";
  cout << "  ELLIPTIC_EM_VALUES stores values of\n";
  cout << "  the complete elliptic integral of the second\n";
  cout << "  kind, with parameter modulus M.\n";
  cout << "\n";
  cout << "      M            EM(M)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    elliptic_em_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(12) << x  << "  "
         << setw(12) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test064 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST064 tests ELLIPTIC_KA_VALUES.
//
//  Modified:
//
//    09 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST064:\n";
  cout << "  ELLIPTIC_KA_VALUES stores values of\n";
  cout << "  the complete elliptic integral of the first\n";
  cout << "  kind, with parameter angle ALPHA in degrees.\n";
  cout << "\n";
  cout << "    ALPHA        KA(ALPHA)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    elliptic_ka_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(12) << x  << "  "
         << setw(12) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test065 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST065 tests ELLIPTIC_KM_VALUES.
//
//  Modified:
//
//    09 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST065:\n";
  cout << "  ELLIPTIC_KM_VALUES stores values of\n";
  cout << "  the complete elliptic integral of the first\n";
  cout << "  kind, with parameter modulus M.\n";
  cout << "\n";
  cout << "      M            KM(M)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    elliptic_km_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(12) << x  << "  "
         << setw(12) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test066 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST066 tests ERF_VALUES.
//
//  Modified:
//
//    09 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST066:\n";
  cout << "  ERF_VALUES stores values of\n";
  cout << "  the error function ERF(X).\n";
  cout << "\n";
  cout << "      X          ERF(X)\n";
  cout << "\n";

  n_data = 0;

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

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(12) << x  << "  "
         << setw(12) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test0665 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST0665 tests ERFC_VALUES.
//
//  Modified:
//
//    20 May 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST0665:\n";
  cout << "  ERFC_VALUES stores values of\n";
  cout << "  the complementary error function ERFC(X).\n";
  cout << "\n";
  cout << "      X          ERFC(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    erfc_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(12) << x  << "  "
         << setw(12) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test067 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST067 tests EULER_NUMBER_VALUES.
//
//  Modified:
//
//    09 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  int c;
  int n;
  int n_data;

  cout << "\n";
  cout << "TEST067:\n";
  cout << "  EULER_NUMBER_VALUES returns values of\n";
  cout << "  the Euler numbers.\n";
  cout << "\n";
  cout << "     N        EULER_NUMBER(N)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    euler_number_values ( &n_data, &n, &c );

    if ( n_data == 0 )
    {
      break;
    }
    cout                  << "  "
         << setw(6)  << n << "  "
         << setw(10) << c << "\n";
  }
  return;
}
//****************************************************************************80

void test068 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST068 tests EULER_POLY_VALUES.
//
//  Modified:
//
//    09 February 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST068:\n";
  cout << "  EULER_POLY_VALUES returns values of\n";
  cout << "  the Euler numbers.\n";
  cout << "\n";
  cout << "     N     X       EULER_POLY(N)(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    euler_poly_values ( &n_data, &n, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(6)  << n  << "  "
         << setw(8)  << x  << "  "
         << setw(16) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test0685 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST0685 tests EXP_VALUES.
//
//  Modified:
//
//    19 June 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST0685:\n";
  cout << "   EXP_VALUES stores values of the exponential function.\n";
  cout << "\n";
  cout << "                X                     FX\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    exp_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                          << "  "
         << setw(24) << setprecision ( 16 ) << x  << "  "
         << setw(24) << setprecision ( 16 ) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test069 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST069 tests EXP3_INT_VALUES.
//
//  Modified:
//
//    12 June 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST069:\n";
  cout << "  EXP3_INT_VALUES stores values of \n";
  cout << "  the exponential integral function.\n";
  cout << "\n";
  cout << "                X                     FX\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    exp3_int_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                          << "  "
         << setw(24) << setprecision ( 16 ) << x  << "  "
         << setw(24) << setprecision ( 16 ) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test070 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST070 tests EXPONENTIAL_CDF_VALUES.
//
//  Modified:
//
//    12 June 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  double lambda;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST070:\n";
  cout << "  EXPONENTIAL_CDF_VALUES stores values of \n";
  cout << "  the exponential CDF.\n";
  cout << "\n";
  cout << "                X                     FX\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    exponential_cdf_values ( &n_data, &lambda, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                              << "  "
         << setw(24) << setprecision ( 8 )  << lambda << "  "
         << setw(24) << setprecision ( 8 )  << x      << "  "
         << setw(24) << setprecision ( 16 ) << fx     << "\n";
  }
  return;
}
//****************************************************************************80

void test071 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST071 tests EXTREME_VALUES_CDF_VALUES.
//
//  Modified:
//
//    12 June 2007
//
//  Author:
//
//    John Burkardt
//
{
  double alpha;
  double beta;
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST071:\n";
  cout << "  EXTREME_VALUES_CDF_VALUES stores values of \n";
  cout << "  the extreme values CDF.\n";
  cout << "\n";
  cout << "        Alpha    Beta        X                     FX\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    extreme_values_cdf_values ( &n_data, &alpha, &beta, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                              << "  "
         << setw(12)                        << alpha  << "  "
         << setw(12)                        << beta   << "  "
         << setw(12)                        << x      << "  "
         << setw(24) << setprecision ( 16 ) << fx     << "\n";
  }
  return;
}
//****************************************************************************80

void test072 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST072 tests F_CDF_VALUES.
//
//  Modified:
//
//    12 June 2007
//
//  Author:
//
//    John Burkardt
//
{
  int a;
  int b;
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << " TEST072:\n";
  cout << "   F_CDF_VALUES stores values of\n";
  cout << "   the F cumulative density function.\n";
  cout << "\n";
  cout << "     A       B            X            CDF(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    f_cdf_values ( &n_data, &a, &b, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(6)  << a  << "  "
         << setw(6)  << b  << "  "
         << setw(12) << x  << "  "
         << setw(12) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test073 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST073 tests F_NONCENTRAL_CDF_VALUES.
//
//  Modified:
//
//    12 June 2007
//
//  Author:
//
//    John Burkardt
//
{
  int a;
  int b;
  double fx;
  double lambda;
  int n_data;
  double x;

  cout << "\n";
  cout << " TEST073:\n";
  cout << "   F_NONCENTRAL_CDF_VALUES stores values of\n";
  cout << "   the F cumulative density function.\n";
  cout << "\n";
  cout << "     A       B            LAMBDA    X            CDF\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    f_noncentral_cdf_values ( &n_data, &a, &b, &lambda, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                       << "  "
         << setw(6)  << a      << "  "
         << setw(6)  << b      << "  "
         << setw(8)  << lambda << "  "
         << setw(12) << x      << "  "
         << setw(12) << fx     << "\n";
  }
  return;
}
//****************************************************************************80

void test074 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST074 tests FRESNEL_COS_VALUES.
//
//  Modified:
//
//    12 June 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << " TEST074:\n";
  cout << "   FRESNEL_COS_VALUES stores values of\n";
  cout << "   the Fresnel cosine integral C(X).\n";
  cout << "\n";
  cout << "      X           C(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    fresnel_cos_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                       << "  "
         << setw(12)                     << x  << "  "
         << setw(24) << setprecision(16) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test075 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST075 tests FRESNEL_SIN_VALUES.
//
//  Modified:
//
//    12 June 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << " TEST075:\n";
  cout << "   FRESNEL_SIN_VALUES stores values of\n";
  cout << "   the Fresnel sine integral S(X).\n";
  cout << "\n";
  cout << "      X           S(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    fresnel_sin_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                       << "  "
         << setw(12)                     << x  << "  "
         << setw(24) << setprecision(16) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test0755 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST0755 tests FROBENIUS_NUMBER_ORDER2_VALUES.
//
//  Modified:
//
//    20 January 2007
//
//  Author:
//
//    John Burkardt
//
{
  int c1;
  int c2;
  int f;
  int n_data;

  cout << "\n";
  cout << "TEST0755:\n";
  cout << "  FROBENIUS_NUMBER_ORDER2_VALUES returns values of \n";
  cout << "  the Frobenius number of order 2.\n";
  cout << "\n";
  cout << "         C1        C2          F(C1,C2)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    frobenius_number_order2_values ( &n_data, &c1, &c2, &f );

    if ( n_data == 0 )
    {
      break;
    }

    cout << "  " << setw(8) << c1
         << "  " << setw(8) << c2
         << "  " << setw(8) << f << "\n";
  }

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

void test0756 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST0756 tests FROBENIUS_NUMBER_ORDER_VALUES, FROBENIUS_NUMBER_DATA_VALUES.
//
//  Modified:
//
//    23 November 2007
//
//  Author:
//
//    John Burkardt
//
{
  int *c;
  int f;
  int i;
  int n_data;
  int order;

  cout << "\n";
  cout << "TEST0756:\n";
  cout << "  FROBENIUS_NUMBER_ORDER_VALUES returns the order for\n";
  cout << "  a Frobenius problem;\n";
  cout << "  FROBENIUS_NUMBER_DATA_VALUES returns the corresponding\n";
  cout << "  coin denominations.\n";

  n_data = 0;

  for ( ; ; )
  {
    frobenius_number_order_values ( &n_data, &order );

    if ( n_data == 0 )
    {
      break;
    }

    c = new int[order];

    frobenius_number_data_values ( &n_data, order, c, &f );

    cout << "\n";
    cout << "  Order = " << order << "\n";
    for ( i = 0; i < order; i++ )
    {
      cout << "  " << setw(8) << c[i];
    }
    cout << "\n";
    cout << "  Frobenius number = " << f << "\n";

    delete [] c;
  }
  return;
}
//****************************************************************************80

void test076 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST076 tests GAMMA_VALUES.
//
//  Modified:
//
//    20 January 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << " TEST076:\n";
  cout << "   GAMMA_VALUES stores values of the Gamma function.\n";
  cout << "\n";
  cout << "      X            GAMMA(X)\n";
  cout << "\n";

  n_data = 0;

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

    if ( n_data == 0 )
    {
      break;
    }
    cout                                       << "  "
         << setw(12)                     << x  << "  "
         << setw(24) << setprecision(16) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test077 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST077 tests GAMMA_CDF_VALUES.
//
//  Modified:
//
//    20 January 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  double mu;
  int n_data;
  double sigma;
  double x;

  cout << "\n";
  cout << " TEST077:\n";
  cout << "   GAMMA_CDF_VALUES stores values of\n";
  cout << "   the Gamma CDF.\n";
  cout << "\n";
  cout << "      M    Sigma      X            CDF((X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    gamma_cdf_values ( &n_data, &mu, &sigma, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                           << "  "
         << setw(12)                     << mu     << "  "
         << setw(12)                     << sigma  << "  "
         << setw(12)                     << x      << "  "
         << setw(24) << setprecision(16) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test078 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST078 tests GAMMA_INC_VALUES.
//
//  Modified:
//
//    20 January 2007
//
//  Author:
//
//    John Burkardt
//
{
  double a;
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << " TEST078:\n";
  cout << "   GAMMA_INC_VALUES stores values of\n";
  cout << "   the incomplete Gamma function.\n";
  cout << "\n";
  cout << "      A            X            GAMMA_INC(A)(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    gamma_inc_values ( &n_data, &a, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                       << "  "
         << setw(12)                     << a  << "  "
         << setw(12)                     << x  << "  "
         << setw(24) << setprecision(16) << fx << "\n";
  }
  return;
}

//****************************************************************************80

void test079 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST079 tests GAMMA_LOG_VALUES.
//
//  Modified:
//
//    20 January 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << " TEST079:\n";
  cout << "   GAMMA_LOG_VALUES stores values of\n";
  cout << "   the logarithm of the Gamma function.\n";
  cout << "\n";
  cout << "      X            GAMMA_LOG(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    gamma_log_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                       << "  "
         << setw(12)                     << x  << "  "
         << setw(24) << setprecision(16) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test080 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST080 tests GEGENBAUER_POLY_VALUES.
//
//  Modified:
//
//    20 January 2007
//
//  Author:
//
//    John Burkardt
//
{
  double a;
  double fx;
  int n;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST080:\n";
  cout << "  GEGENBAUER_POLY_VALUES returns values of\n";
  cout << "  the Gegenbauer polynomials.\n";
  cout << "\n";
  cout << "       N       A       X       G(N,A)(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    gegenbauer_poly_values ( &n_data, &n, &a, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                       << "  "
         << setw(6)                      << n  << "  "
         << setw(10)                     << a  << "  "
         << setw(10)                     << x  << "  "
         << setw(24) << setprecision(16) << fx << "\n";
  }

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

void test081 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST081 tests GEOMETRIC_CDF_VALUES.
//
//  Modified:
//
//    20 January 2007
//
//  Author:
//
//    John Burkardt
//
{
  double cdf;
  int n_data;
  double p;
  int x;

  cout << "\n";
  cout << " TEST081:\n";
  cout << "   GEOMETRIC_CDF_VALUES stores values of\n";
  cout << "   the Geometric Probability Cumulative Density Function.\n";
  cout << "\n";
  cout << "      X      P       CDF\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    geometric_cdf_values ( &n_data, &x, &p, &cdf );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                        << "  "
         << setw(6)                      << x   << "  "
         << setw(8)                      << p   << "  "
         << setw(24) << setprecision(16) << cdf << "\n";
  }
  return;
}
//****************************************************************************80

void test082 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST082 tests GOODWIN_VALUES.
//
//  Modified:
//
//    20 January 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST082:\n";
  cout << "  GOODWIN_VALUES stores values of \n";
  cout << "  the Goodwin function.\n";
  cout << "\n";
  cout << "                X                     FX\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    goodwin_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                          << "  "
         << setw(24) << setprecision ( 16 ) << x  << "  "
         << setw(24) << setprecision ( 16 ) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test083 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST083 tests GUD_VALUES.
//
//  Modified:
//
//    20 January 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << " TEST083:\n";
  cout << "   GUD_VALUES stores values of\n";
  cout << "   the Gudermannian function.\n";
  cout << "\n";
  cout << "      X            GUD(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    gud_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                       << "  "
         << setw(12)                     << x  << "  "
         << setw(24) << setprecision(16) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test084 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST084 tests HERMITE_POLY_VALUES.
//
//  Modified:
//
//    20 January 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n;
  int n_data;
  double x;

  cout << "\n";
  cout << " TEST084\n";
  cout << "   HERMITE_POLY_VALUES stores values of\n";
  cout << "   the Hermite polynomials.\n";
  cout << "\n";
  cout << "     N      X            H(N)(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    hermite_poly_values ( &n_data, &n, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                       << "  "
         << setw(6)                      << n  << "  "
         << setw(12)                     << x  << "  "
         << setw(24) << setprecision(16) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test0845 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST0845 tests HYPER_2F1_VALUES.
//
//  Modified:
//
//    09 September 2007
//
//  Author:
//
//    John Burkardt
//
{
  double a;
  double b;
  double c;
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << " TEST0845:\n";
  cout << "   HYPER_2F1_VALUES stores values of\n";
  cout << "   the hypergeometric function 2F1.\n";
  cout << "\n";
  cout << "      A      B     C      X   Hyper_2F1(A,B,C,X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    hyper_2f1_values ( &n_data, &a, &b, &c, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                       << "  "
         << setw(8)                      << a  << "  "
         << setw(8)                      << b  << "  "
         << setw(8)                      << c  << "  "
         << setw(8)                      << x  << "  "
         << setw(24) << setprecision(16) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test085 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST085 tests HYPERGEOMETRIC_CDF_VALUES.
//
//  Modified:
//
//    20 January 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  int pop;
  int sam;
  int succ;
  int x;

  cout << "\n";
  cout << " TEST085:\n";
  cout << "   HYPERGEOMETRIC_CDF_VALUES stores values of\n";
  cout << "   the Hypergeometric CDF.\n";
  cout << "\n";
  cout << "     SAM    SUC   POP     X   HyperCDF(S,S,P)(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    hypergeometric_cdf_values ( &n_data, &sam, &succ, &pop, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                         << "  "
         << setw(8)                      << sam  << "  "
         << setw(8)                      << succ << "  "
         << setw(8)                      << pop  << "  "
         << setw(8)                      << x    << "  "
         << setw(24) << setprecision(16) << fx   << "\n";
  }
  return;
}
//****************************************************************************80

void test0855 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST0855 tests HYPERGEOMETRIC_PDF_VALUES.
//
//  Modified:
//
//    28 January 2008
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  int pop;
  int sam;
  int succ;
  int x;

  cout << "\n";
  cout << " TEST0855:\n";
  cout << "   HYPERGEOMETRIC_PDF_VALUES stores values of\n";
  cout << "   the Hypergeometric PDF.\n";
  cout << "\n";
  cout << "     SAM    SUC   POP     X   HyperPDF(S,S,P)(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    hypergeometric_pdf_values ( &n_data, &sam, &succ, &pop, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                         << "  "
         << setw(8)                      << sam  << "  "
         << setw(8)                      << succ << "  "
         << setw(8)                      << pop  << "  "
         << setw(8)                      << x    << "  "
         << setw(24) << setprecision(16) << fx   << "\n";
  }
  return;
}
//****************************************************************************80

void test086 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST086 tests I4_FACTORIAL_VALUES.
//
//  Modified:
//
//    21 March 2007
//
//  Author:
//
//    John Burkardt
//
{
  int fn;
  int n;
  int n_data;

  cout << "\n";
  cout << " TEST086:\n";
  cout << "   I4_FACTORIAL_VALUES return;s values of\n";
  cout << "   the factorial function.\n";
  cout << "\n";
  cout << "      N         N!\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    i4_factorial_values ( &n_data, &n, &fn );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(6)  << n  << "  "
         << setw(12) << fn << "\n";
  }
  return;
}
//****************************************************************************80

void test087 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST087 tests I4_FACTORIAL2_VALUES.
//
//  Modified:
//
//    12 June 2007
//
//  Author:
//
//    John Burkardt
//
{
  int fn;
  int n;
  int n_data;

  cout << "\n";
  cout << " TEST087:\n";
  cout << "   I4_FACTORIAL2_VALUES return;s values of\n";
  cout << "   the double factorial function.\n";
  cout << "\n";
  cout << "      N         N!!\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    i4_factorial2_values ( &n_data, &n, &fn );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(6)  << n  << "  "
         << setw(12) << fn << "\n";
  }
  return;
}
//****************************************************************************80

void test088 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST088 tests I4_POCHHAMMER_VALUES.
//
//  Modified:
//
//    12 June 2007
//
//  Author:
//
//    John Burkardt
//
{
  int fmn;
  int m;
  int n;
  int n_data;

  cout << "\n";
  cout << "TEST088:\n";
  cout << "  I4_POCHHAMMER_VALUES returns some exact values\n";
  cout << "  of the Pochhammer symbol:\n";
  cout << "\n";
  cout << "     M     N      Pochhammer(M,N)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    i4_pochhammer_values ( &n_data, &m, &n, &fmn );

    if ( n_data == 0 )
    {
      break;
    }
    cout                   << "  "
         << setw(6)  << m   << "  "
         << setw(6)  << n   << "  "
         << setw(12) << fmn << "\n";
  }
  return;
}
//****************************************************************************80

void test089 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST089 tests I0ML0_VALUES.
//
//  Modified:
//
//    12 June 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST089:\n";
  cout << "  I0ML0_VALUES stores values of \n";
  cout << "  the I0-L0 function.\n";
  cout << "\n";
  cout << "                X                     FX\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    i0ml0_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                          << "  "
         << setw(24) << setprecision ( 16 ) << x  << "  "
         << setw(24) << setprecision ( 16 ) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test090 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST090 tests I1ML1_VALUES.
//
//  Modified:
//
//    12 June 2007
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST090:\n";
  cout << "  I1ML1_VALUES stores values of \n";
  cout << "  the I1-L1 function.\n";
  cout << "\n";
  cout << "                X                     FX\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    i1ml1_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                          << "  "
         << setw(24) << setprecision ( 16 ) << x  << "  "
         << setw(24) << setprecision ( 16 ) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test091 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST091 tests JACOBI_CN_VALUES.
//
//  Modified:
//
//    12 June 2007
//
//  Author:
//
//    John Burkardt
//
{
  double a;
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST091:\n";
  cout << "  JACOBI_CN_VALUES returns values of \n";
  cout << "  the Jacobi elliptic CN function.\n";
  cout << "\n";
  cout << "      A         X       CN(A,X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    jacobi_cn_values ( &n_data, &a, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                       << "  "
         << setw(10)                     << a  << "  "
         << setw(10)                     << x  << "  "
         << setw(24) << setprecision(16) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test092 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST092 tests JACOBI_DN_VALUES.
//
//  Modified:
//
//    12 June 2007
//
//  Author:
//
//    John Burkardt
//
{
  double a;
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST092:\n";
  cout << "  JACOBI_DN_VALUES returns values of \n";
  cout << "  the Jacobi elliptic DN function.\n";
  cout << "\n";
  cout << "      A         X       DN(A,X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    jacobi_dn_values ( &n_data, &a, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                 << "  "
         << setw(10)                     << a  << "  "
         << setw(10)                     << x  << "  "
         << setw(24) << setprecision(16) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test093 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST093 tests JACOBI_POLY_VALUES.
//
//  Modified:
//
//    12 June 2007
//
//  Author:
//
//    John Burkardt
//
{
  int a;
  int b;
  double fx;
  int n;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST093:\n";
  cout << "  JACOBI_POLY_VALUES returns values of\n";
  cout << "  the Jacobi polynomial.\n";
  cout << "\n";
  cout << "       N       A       B      X       J(N,A,B)(X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    jacobi_poly_values ( &n_data, &n, &a, &b, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                       << "  "
         << setw(6)                      << n  << "  "
         << setw(6)                      << a  << "  "
         << setw(6)                      << b  << "  "
         << setw(10)                     << x  << "  "
         << setw(24) << setprecision(16) << fx << "\n";
  }

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

void test094 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST094 tests JACOBI_SN_VALUES.
//
//  Modified:
//
//    12 June 2007
//
//  Author:
//
//    John Burkardt
//
{
  double a;
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST094:\n";
  cout << "  JACOBI_SN_VALUES returns values of \n";
  cout << "  the Jacobi elliptic SN function.\n";
  cout << "\n";
  cout << "      A         X       SN(A,X)\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    jacobi_sn_values ( &n_data, &a, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                       << "  "
         << setw(10)                     << a  << "  "
         << setw(10)                     << x  << "  "
         << setw(24) << setprecision(16) << fx << "\n";
  }
  return;
}
//****************************************************************************80

void test0945 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST0945 tests JED_CE_VALUES.
//
//  Modified:
//
//    04 May 2006
//
//  Author:
//
//    John Burkardt
//
{
  int d;
  double f;
  double jed;
  int n_data;
  int m;
  int y;

  cout << "\n";
  cout << "TEST0945:\n";
  cout << "  JED_CE_VALUES returns:\n";
  cout << "  JED, a Julian Ephemeris Date, and\n";
  cout << "  YMDF, the corresponding year, month, day, fraction.\n";
  cout << "\n";
  cout << "        JED          Y   M   D    F\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    jed_ce_values ( &n_data, &jed, &y, &m, &d, &f );

    if ( n_data == 0 )
    {
      break;
    }
    cout << "  " << setw(12) << jed
         << "  " << setw(6)  << y
         << "  " << setw(2)  << m
         << "  " << setw(2)  << d
         << "  " << setw(6)  << f << "\n";
  }
  return;
}
//****************************************************************************80

void test095 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST095 tests JED_MJD_VALUES.
//
//  Modified:
//
//    12 June 2007
//
//  Author:
//
//    John Burkardt
//
{
  double jed;
  int n_data;
  double mjd;

  cout << "\n";
  cout << "TEST095:\n";
  cout << "  JED_MJD_VALUES returns:\n";
  cout << "  JED, a Julian Ephemeris Date, and\n";
  cout << "  MJD, the corresponding Modified Julian Day count.\n";
  cout << "\n";
  cout << "   JED      MJD\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    jed_mjd_values ( &n_data, &jed, &mjd );

    if ( n_data == 0 )
    {
      break;
    }
    cout                    << "  "
         << setw(12) << jed << "  "
         << setw(12) << mjd << "\n";
  }
  return;
}
//****************************************************************************80

void test096 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST096 tests JED_RD_VALUES.
//
//  Modified:
//
//    12 June 2007
//
//  Author:
//
//    John Burkardt
//
{
  double jed;
  int n_data;
  double rd;

  cout << "\n";
  cout << "TEST096:\n";
  cout << "  JED_RD_VALUES returns:\n";
  cout << "  JED, a Julian Ephemeris Date, and\n";
  cout << "  RD, the corresponding Reingold Dershowitz Day count.\n";
  cout << "\n";
  cout << "   JED      RD\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    jed_rd_values ( &n_data, &jed, &rd );

    if ( n_data == 0 )
    {
      break;
    }
    cout                    << "  "
         << setw(12) << jed << "  "
         << setw(12) << rd  << "\n";
  }
  return;
}
//****************************************************************************80

void test097 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST097 tests JED_WEEKDAY_VALUES.
//
//  Modified:
//
//    12 June 2007
//
//  Author:
//
//    John Burkardt
//
{
  double jed;
  int n_data;
  int weekday;
  char *weekday_name[7] = {
    "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", 
    "Friday", "Saturday" };

  cout << "\n";
  cout << "TEST097:\n";
  cout << "  JED_WEEKDAY_VALUES returns Julian Ephemeris Dates \n";
  cout << "  (JED) and the corresponding weekday\n";
  cout << "\n";
  cout << "   JED      #  Weekday\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    jed_weekday_values ( &n_data, &jed, &weekday );

    if ( n_data == 0 )
    {
      break;
    }
    cout                            << "  "
         << setw(12) << jed         << "  "
         << setw(1)  << weekday     << "  "
         << weekday_name[weekday-1] << "\n";
  }
  return;
}
//****************************************************************************80

void test0972 ( void )

//****************************************************************************80
//
//  Purpose:
//
//    TEST0972 tests KEI0_VALUES.
//
//  Modified:
//
//    30 June 2006
//
//  Author:
//
//    John Burkardt
//
{
  double fx;
  int n_data;
  double x;

  cout << "\n";
  cout << "TEST0972:\n";
  cout << "  KEI0_VALUES stores values of \n";
  cout << "  the Kelvin function KEI of order 0.\n";
  cout << "\n";
  cout << "                X                     FX\n";
  cout << "\n";

  n_data = 0;

  for ( ; ; )
  {
    kei0_values ( &n_data, &x, &fx );

    if ( n_data == 0 )
    {
      break;
    }
    cout                                          << "  "
         << setw(24) << setprecision ( 16 ) << x  << "  "
         << setw(24) << setprecision ( 16 ) << fx << "\n";
  }
  return;