// test_chi_squared.cpp

// Copyright Paul A. Bristow 2006.
// Copyright John Maddock 2007.

// Use, modification and distribution are subject to the
// Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt
// or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <boost/math/concepts/real_concept.hpp> // for real_concept
using ::boost::math::concepts::real_concept;

#include <boost/math/distributions/chi_squared.hpp> // for chi_squared_distribution
using boost::math::chi_squared_distribution;
using boost::math::chi_squared;

#include <boost/test/test_exec_monitor.hpp> // for test_main
#include <boost/test/floating_point_comparison.hpp> // for BOOST_CHECK_CLOSE

#include <iostream>
using std::cout;
using std::endl;
#include <limits>
using std::numeric_limits;

template <class RealType>
RealType naive_pdf(RealType df, RealType x)
{
   using namespace std; // For ADL of std functions.
   RealType e = log(x) * ((df / 2) - 1) - (x / 2) - boost::math::lgamma(df/2);
   e -= log(static_cast<RealType>(2)) * df / 2;
   return exp(e);
}

template <class RealType>
void test_spot(
     RealType df,    // Degrees of freedom
     RealType cs,    // Chi Square statistic
     RealType P,     // CDF
     RealType Q,     // Complement of CDF
     RealType tol)   // Test tolerance
{
   boost::math::chi_squared_distribution<RealType> dist(df);
   BOOST_CHECK_CLOSE(
      cdf(dist, cs), P, tol);
   BOOST_CHECK_CLOSE(
      pdf(dist, cs), naive_pdf(dist.degrees_of_freedom(), cs), tol);
   if((P < 0.99) && (Q < 0.99))
   {
      //
      // We can only check this if P is not too close to 1,
      // so that we can guarentee Q is free of error:
      //
      BOOST_CHECK_CLOSE(
         cdf(complement(dist, cs)), Q, tol);
      BOOST_CHECK_CLOSE(
            quantile(dist, P), cs, tol);
      BOOST_CHECK_CLOSE(
            quantile(complement(dist, Q)), cs, tol);
   }
}

//
// This test data is taken from the tables of upper and lower
// critical values of the Chi Squared distribution available
// at http://www.itl.nist.gov/div898/handbook/eda/section3/eda3674.htm
//
double q[] = { 0.10, 0.05, 0.025, 0.01, 0.001 };
double upper_critical_values[][6] = {
  { 1,         2.706,    3.841,    5.024,    6.635,   10.828 },
  { 2,         4.605,    5.991,    7.378,    9.210,   13.816 },
  { 3,         6.251,    7.815,    9.348,   11.345,   16.266 },
  { 4,         7.779,    9.488,   11.143,   13.277,   18.467 },
  { 5,         9.236,   11.070,   12.833,   15.086,   20.515 },
  { 6,        10.645,   12.592,   14.449,   16.812,   22.458 },
  { 7,        12.017,   14.067,   16.013,   18.475,   24.322 },
  { 8,        13.362,   15.507,   17.535,   20.090,   26.125 },
  { 9,        14.684,   16.919,   19.023,   21.666,   27.877 },
 { 10,        15.987,   18.307,   20.483,   23.209,   29.588 },
 { 11,        17.275,   19.675,   21.920,   24.725,   31.264 },
 { 12,        18.549,   21.026,   23.337,   26.217,   32.910 },
 { 13,        19.812,   22.362,   24.736,   27.688,   34.528 },
 { 14,        21.064,   23.685,   26.119,   29.141,   36.123 },
 { 15,        22.307,   24.996,   27.488,   30.578,   37.697 },
 { 16,        23.542,   26.296,   28.845,   32.000,   39.252 },
 { 17,        24.769,   27.587,   30.191,   33.409,   40.790 },
 { 18,        25.989,   28.869,   31.526,   34.805,   42.312 },
 { 19,        27.204,   30.144,   32.852,   36.191,   43.820 },
 { 20,        28.412,   31.410,   34.170,   37.566,   45.315 },
 { 21,        29.615,   32.671,   35.479,   38.932,   46.797 },
 { 22,        30.813,   33.924,   36.781,   40.289,   48.268 },
 { 23,        32.007,   35.172,   38.076,   41.638,   49.728 },
 { 24,        33.196,   36.415,   39.364,   42.980,   51.179 },
 { 25,        34.382,   37.652,   40.646,   44.314,   52.620 },
 { 26,        35.563,   38.885,   41.923,   45.642,   54.052 },
 { 27,        36.741,   40.113,   43.195,   46.963,   55.476 },
 { 28,        37.916,   41.337,   44.461,   48.278,   56.892 },
 { 29,        39.087,   42.557,   45.722,   49.588,   58.301 },
 { 30,        40.256,   43.773,   46.979,   50.892,   59.703 },
 { 31,        41.422,   44.985,   48.232,   52.191,   61.098 },
 { 32,        42.585,   46.194,   49.480,   53.486,   62.487 },
 { 33,        43.745,   47.400,   50.725,   54.776,   63.870 },
 { 34,        44.903,   48.602,   51.966,   56.061,   65.247 },
 { 35,        46.059,   49.802,   53.203,   57.342,   66.619 },
 { 36,        47.212,   50.998,   54.437,   58.619,   67.985 },
 { 37,        48.363,   52.192,   55.668,   59.893,   69.347 },
 { 38,        49.513,   53.384,   56.896,   61.162,   70.703 },
 { 39,        50.660,   54.572,   58.120,   62.428,   72.055 },
 { 40,        51.805,   55.758,   59.342,   63.691,   73.402 },
 { 41,        52.949,   56.942,   60.561,   64.950,   74.745 },
 { 42,        54.090,   58.124,   61.777,   66.206,   76.084 },
 { 43,        55.230,   59.304,   62.990,   67.459,   77.419 },
 { 44,        56.369,   60.481,   64.201,   68.710,   78.750 },
 { 45,        57.505,   61.656,   65.410,   69.957,   80.077 },
 { 46,        58.641,   62.830,   66.617,   71.201,   81.400 },
 { 47,        59.774,   64.001,   67.821,   72.443,   82.720 },
 { 48,        60.907,   65.171,   69.023,   73.683,   84.037 },
 { 49,        62.038,   66.339,   70.222,   74.919,   85.351 },
 { 50,        63.167,   67.505,   71.420,   76.154,   86.661 },
 { 51,        64.295,   68.669,   72.616,   77.386,   87.968 },
 { 52,        65.422,   69.832,   73.810,   78.616,   89.272 },
 { 53,        66.548,   70.993,   75.002,   79.843,   90.573 },
 { 54,        67.673,   72.153,   76.192,   81.069,   91.872 },
 { 55,        68.796,   73.311,   77.380,   82.292,   93.168 },
 { 56,        69.919,   74.468,   78.567,   83.513,   94.461 },
 { 57,        71.040,   75.624,   79.752,   84.733,   95.751 },
 { 58,        72.160,   76.778,   80.936,   85.950,   97.039 },
 { 59,        73.279,   77.931,   82.117,   87.166,   98.324 },
 { 60,        74.397,   79.082,   83.298,   88.379,   99.607 },
 { 61,        75.514,   80.232,   84.476,   89.591,  100.888 },
 { 62,        76.630,   81.381,   85.654,   90.802,  102.166 },
 { 63,        77.745,   82.529,   86.830,   92.010,  103.442 },
 { 64,        78.860,   83.675,   88.004,   93.217,  104.716 },
 { 65,        79.973,   84.821,   89.177,   94.422,  105.988 },
 { 66,        81.085,   85.965,   90.349,   95.626,  107.258 },
 { 67,        82.197,   87.108,   91.519,   96.828,  108.526 },
 { 68,        83.308,   88.250,   92.689,   98.028,  109.791 },
 { 69,        84.418,   89.391,   93.856,   99.228,  111.055 },
 { 70,        85.527,   90.531,   95.023,  100.425,  112.317 },
 { 71,        86.635,   91.670,   96.189,  101.621,  113.577 },
 { 72,        87.743,   92.808,   97.353,  102.816,  114.835 },
 { 73,        88.850,   93.945,   98.516,  104.010,  116.092 },
 { 74,        89.956,   95.081,   99.678,  105.202,  117.346 },
 { 75,        91.061,   96.217,  100.839,  106.393,  118.599 },
 { 76,        92.166,   97.351,  101.999,  107.583,  119.850 },
 { 77,        93.270,   98.484,  103.158,  108.771,  121.100 },
 { 78,        94.374,   99.617,  104.316,  109.958,  122.348 },
 { 79,        95.476,  100.749,  105.473,  111.144,  123.594 },
 { 80,        96.578,  101.879,  106.629,  112.329,  124.839 },
 { 81,        97.680,  103.010,  107.783,  113.512,  126.083 },
 { 82,        98.780,  104.139,  108.937,  114.695,  127.324 },
 { 83,        99.880,  105.267,  110.090,  115.876,  128.565 },
 { 84,       100.980,  106.395,  111.242,  117.057,  129.804 },
 { 85,       102.079,  107.522,  112.393,  118.236,  131.041 },
 { 86,       103.177,  108.648,  113.544,  119.414,  132.277 },
 { 87,       104.275,  109.773,  114.693,  120.591,  133.512 },
 { 88,       105.372,  110.898,  115.841,  121.767,  134.746 },
 { 89,       106.469,  112.022,  116.989,  122.942,  135.978 },
 { 90,       107.565,  113.145,  118.136,  124.116,  137.208 },
 { 91,       108.661,  114.268,  119.282,  125.289,  138.438 },
 { 92,       109.756,  115.390,  120.427,  126.462,  139.666 },
 { 93,       110.850,  116.511,  121.571,  127.633,  140.893 },
 { 94,       111.944,  117.632,  122.715,  128.803,  142.119 },
 { 95,       113.038,  118.752,  123.858,  129.973,  143.344 },
 { 96,       114.131,  119.871,  125.000,  131.141,  144.567 },
 { 97,       115.223,  120.990,  126.141,  132.309,  145.789 },
 { 98,       116.315,  122.108,  127.282,  133.476,  147.010 },
 { 99,       117.407,  123.225,  128.422,  134.642,  148.230 },
 { 100,       118.498,  124.342,  129.561,  135.807,  149.449 },
 {100,       118.498,  124.342,  129.561,  135.807,  149.449 }
};

double lower_critical_values[][6] = {
   /*
   These have fewer than 4 significant digits, leave them out
   of the tests for now:
     1.,         .016,     .004,     .001,     .000,     .000,
     2.,         .211,     .103,     .051,     .020,     .002,
     3.,         .584,     .352,     .216,     .115,     .024,
     4.,        1.064,     .711,     .484,     .297,     .091,
     5.,        1.610,    1.145,     .831,     .554,     .210,
     6.,        2.204,    1.635,    1.237,     .872,     .381,
     7.,        2.833,    2.167,    1.690,    1.239,     .598,
     8.,        3.490,    2.733,    2.180,    1.646,     .857,
     */
     { 9.,        4.168,    3.325,    2.700,    2.088,    1.152 },
    { 10.,        4.865,    3.940,    3.247,    2.558,    1.479 },
    { 11.,        5.578,    4.575,    3.816,    3.053,    1.834 },
    { 12.,        6.304,    5.226,    4.404,    3.571,    2.214 },
    { 13.,        7.042,    5.892,    5.009,    4.107,    2.617 },
    { 14.,        7.790,    6.571,    5.629,    4.660,    3.041 },
    { 15.,        8.547,    7.261,    6.262,    5.229,    3.483 },
    { 16.,        9.312,    7.962,    6.908,    5.812,    3.942 },
    { 17.,       10.085,    8.672,    7.564,    6.408,    4.416 },
    { 18.,       10.865,    9.390,    8.231,    7.015,    4.905 },
    { 19.,       11.651,   10.117,    8.907,    7.633,    5.407 },
    { 20.,       12.443,   10.851,    9.591,    8.260,    5.921 },
    { 21.,       13.240,   11.591,   10.283,    8.897,    6.447 },
    { 22.,       14.041,   12.338,   10.982,    9.542,    6.983 },
    { 23.,       14.848,   13.091,   11.689,   10.196,    7.529 },
    { 24.,       15.659,   13.848,   12.401,   10.856,    8.085 },
    { 25.,       16.473,   14.611,   13.120,   11.524,    8.649 },
    { 26.,       17.292,   15.379,   13.844,   12.198,    9.222 },
    { 27.,       18.114,   16.151,   14.573,   12.879,    9.803 },
    { 28.,       18.939,   16.928,   15.308,   13.565,   10.391 },
    { 29.,       19.768,   17.708,   16.047,   14.256,   10.986 },
    { 30.,       20.599,   18.493,   16.791,   14.953,   11.588 },
    { 31.,       21.434,   19.281,   17.539,   15.655,   12.196 },
    { 32.,       22.271,   20.072,   18.291,   16.362,   12.811 },
    { 33.,       23.110,   20.867,   19.047,   17.074,   13.431 },
    { 34.,       23.952,   21.664,   19.806,   17.789,   14.057 },
    { 35.,       24.797,   22.465,   20.569,   18.509,   14.688 },
    { 36.,       25.643,   23.269,   21.336,   19.233,   15.324 },
    { 37.,       26.492,   24.075,   22.106,   19.960,   15.965 },
    { 38.,       27.343,   24.884,   22.878,   20.691,   16.611 },
    { 39.,       28.196,   25.695,   23.654,   21.426,   17.262 },
    { 40.,       29.051,   26.509,   24.433,   22.164,   17.916 },
    { 41.,       29.907,   27.326,   25.215,   22.906,   18.575 },
    { 42.,       30.765,   28.144,   25.999,   23.650,   19.239 },
    { 43.,       31.625,   28.965,   26.785,   24.398,   19.906 },
    { 44.,       32.487,   29.787,   27.575,   25.148,   20.576 },
    { 45.,       33.350,   30.612,   28.366,   25.901,   21.251 },
    { 46.,       34.215,   31.439,   29.160,   26.657,   21.929 },
    { 47.,       35.081,   32.268,   29.956,   27.416,   22.610 },
    { 48.,       35.949,   33.098,   30.755,   28.177,   23.295 },
    { 49.,       36.818,   33.930,   31.555,   28.941,   23.983 },
    { 50.,       37.689,   34.764,   32.357,   29.707,   24.674 },
    { 51.,       38.560,   35.600,   33.162,   30.475,   25.368 },
    { 52.,       39.433,   36.437,   33.968,   31.246,   26.065 },
    { 53.,       40.308,   37.276,   34.776,   32.018,   26.765 },
    { 54.,       41.183,   38.116,   35.586,   32.793,   27.468 },
    { 55.,       42.060,   38.958,   36.398,   33.570,   28.173 },
    { 56.,       42.937,   39.801,   37.212,   34.350,   28.881 },
    { 57.,       43.816,   40.646,   38.027,   35.131,   29.592 },
    { 58.,       44.696,   41.492,   38.844,   35.913,   30.305 },
    { 59.,       45.577,   42.339,   39.662,   36.698,   31.020 },
    { 60.,       46.459,   43.188,   40.482,   37.485,   31.738 },
    { 61.,       47.342,   44.038,   41.303,   38.273,   32.459 },
    { 62.,       48.226,   44.889,   42.126,   39.063,   33.181 },
    { 63.,       49.111,   45.741,   42.950,   39.855,   33.906 },
    { 64.,       49.996,   46.595,   43.776,   40.649,   34.633 },
    { 65.,       50.883,   47.450,   44.603,   41.444,   35.362 },
    { 66.,       51.770,   48.305,   45.431,   42.240,   36.093 },
    { 67.,       52.659,   49.162,   46.261,   43.038,   36.826 },
    { 68.,       53.548,   50.020,   47.092,   43.838,   37.561 },
    { 69.,       54.438,   50.879,   47.924,   44.639,   38.298 },
    { 70.,       55.329,   51.739,   48.758,   45.442,   39.036 },
    { 71.,       56.221,   52.600,   49.592,   46.246,   39.777 },
    { 72.,       57.113,   53.462,   50.428,   47.051,   40.519 },
    { 73.,       58.006,   54.325,   51.265,   47.858,   41.264 },
    { 74.,       58.900,   55.189,   52.103,   48.666,   42.010 },
    { 75.,       59.795,   56.054,   52.942,   49.475,   42.757 },
    { 76.,       60.690,   56.920,   53.782,   50.286,   43.507 },
    { 77.,       61.586,   57.786,   54.623,   51.097,   44.258 },
    { 78.,       62.483,   58.654,   55.466,   51.910,   45.010 },
    { 79.,       63.380,   59.522,   56.309,   52.725,   45.764 },
    { 80.,       64.278,   60.391,   57.153,   53.540,   46.520 },
    { 81.,       65.176,   61.261,   57.998,   54.357,   47.277 },
    { 82.,       66.076,   62.132,   58.845,   55.174,   48.036 },
    { 83.,       66.976,   63.004,   59.692,   55.993,   48.796 },
    { 84.,       67.876,   63.876,   60.540,   56.813,   49.557 },
    { 85.,       68.777,   64.749,   61.389,   57.634,   50.320 },
    { 86.,       69.679,   65.623,   62.239,   58.456,   51.085 },
    { 87.,       70.581,   66.498,   63.089,   59.279,   51.850 },
    { 88.,       71.484,   67.373,   63.941,   60.103,   52.617 },
    { 89.,       72.387,   68.249,   64.793,   60.928,   53.386 },
    { 90.,       73.291,   69.126,   65.647,   61.754,   54.155 },
    { 91.,       74.196,   70.003,   66.501,   62.581,   54.926 },
    { 92.,       75.100,   70.882,   67.356,   63.409,   55.698 },
    { 93.,       76.006,   71.760,   68.211,   64.238,   56.472 },
    { 94.,       76.912,   72.640,   69.068,   65.068,   57.246 },
    { 95.,       77.818,   73.520,   69.925,   65.898,   58.022 },
    { 96.,       78.725,   74.401,   70.783,   66.730,   58.799 },
    { 97.,       79.633,   75.282,   71.642,   67.562,   59.577 },
    { 98.,       80.541,   76.164,   72.501,   68.396,   60.356 },
    { 99.,       81.449,   77.046,   73.361,   69.230,   61.137 },
    {100.,       82.358,   77.929,   74.222,   70.065,   61.918 }
};

template <class RealType> // Any floating-point type RealType.
void test_spots(RealType)
{
  // Basic sanity checks, test data is to three decimal places only
  // so set tolerance to 0.001 expressed as a persentage.

  RealType tolerance = 0.001f * 100;

  cout << "Tolerance = " << tolerance << "%." << endl;

  using boost::math::chi_squared_distribution;
  using  ::boost::math::chi_squared;
  using  ::boost::math::cdf;
  using  ::boost::math::pdf;

  for(unsigned i = 0; i < sizeof(upper_critical_values) / sizeof(upper_critical_values[0]); ++i)
  {
     test_spot(
        static_cast<RealType>(upper_critical_values[i][0]),   // degrees of freedom
        static_cast<RealType>(upper_critical_values[i][1]),   // Chi Squared statistic
        static_cast<RealType>(1 - q[0]),       // Probability of result (CDF), P
        static_cast<RealType>(q[0]),           // Q = 1 - P
        tolerance);
     test_spot(
        static_cast<RealType>(upper_critical_values[i][0]),   // degrees of freedom
        static_cast<RealType>(upper_critical_values[i][2]),   // Chi Squared statistic
        static_cast<RealType>(1 - q[1]),       // Probability of result (CDF), P
        static_cast<RealType>(q[1]),           // Q = 1 - P
        tolerance);
     test_spot(
        static_cast<RealType>(upper_critical_values[i][0]),   // degrees of freedom
        static_cast<RealType>(upper_critical_values[i][3]),   // Chi Squared statistic
        static_cast<RealType>(1 - q[2]),       // Probability of result (CDF), P
        static_cast<RealType>(q[2]),           // Q = 1 - P
        tolerance);
     test_spot(
        static_cast<RealType>(upper_critical_values[i][0]),   // degrees of freedom
        static_cast<RealType>(upper_critical_values[i][4]),   // Chi Squared statistic
        static_cast<RealType>(1 - q[3]),       // Probability of result (CDF), P
        static_cast<RealType>(q[3]),           // Q = 1 - P
        tolerance);
     test_spot(
        static_cast<RealType>(upper_critical_values[i][0]),   // degrees of freedom
        static_cast<RealType>(upper_critical_values[i][5]),   // Chi Squared statistic
        static_cast<RealType>(1 - q[4]),       // Probability of result (CDF), P
        static_cast<RealType>(q[4]),           // Q = 1 - P
        tolerance);
  }

  for(unsigned i = 0; i < sizeof(lower_critical_values) / sizeof(lower_critical_values[0]); ++i)
  {
     test_spot(
        static_cast<RealType>(lower_critical_values[i][0]),   // degrees of freedom
        static_cast<RealType>(lower_critical_values[i][1]),   // Chi Squared statistic
        static_cast<RealType>(q[0]),       // Probability of result (CDF), P
        static_cast<RealType>(1 - q[0]),           // Q = 1 - P
        tolerance);
     test_spot(
        static_cast<RealType>(lower_critical_values[i][0]),   // degrees of freedom
        static_cast<RealType>(lower_critical_values[i][2]),   // Chi Squared statistic
        static_cast<RealType>(q[1]),       // Probability of result (CDF), P
        static_cast<RealType>(1 - q[1]),           // Q = 1 - P
        tolerance);
     test_spot(
        static_cast<RealType>(lower_critical_values[i][0]),   // degrees of freedom
        static_cast<RealType>(lower_critical_values[i][3]),   // Chi Squared statistic
        static_cast<RealType>(q[2]),       // Probability of result (CDF), P
        static_cast<RealType>(1 - q[2]),           // Q = 1 - P
        tolerance);
     test_spot(
        static_cast<RealType>(lower_critical_values[i][0]),   // degrees of freedom
        static_cast<RealType>(lower_critical_values[i][4]),   // Chi Squared statistic
        static_cast<RealType>(q[3]),       // Probability of result (CDF), P
        static_cast<RealType>(1 - q[3]),           // Q = 1 - P
        tolerance);
     test_spot(
        static_cast<RealType>(lower_critical_values[i][0]),   // degrees of freedom
        static_cast<RealType>(lower_critical_values[i][5]),   // Chi Squared statistic
        static_cast<RealType>(q[4]),       // Probability of result (CDF), P
        static_cast<RealType>(1 - q[4]),           // Q = 1 - P
        tolerance);
  }

    RealType tol2 = boost::math::tools::epsilon<RealType>() * 5 * 100; // 5 eps as a percentage
    chi_squared_distribution<RealType> dist(static_cast<RealType>(8));
    RealType x = 7;
    using namespace std; // ADL of std names.
    // mean:
    BOOST_CHECK_CLOSE(
       mean(dist)
       , static_cast<RealType>(8), tol2);
    // variance:
    BOOST_CHECK_CLOSE(
       variance(dist)
       , static_cast<RealType>(16), tol2);
    // std deviation:
    BOOST_CHECK_CLOSE(
       standard_deviation(dist)
       , static_cast<RealType>(4), tol2);
    // hazard:
    BOOST_CHECK_CLOSE(
       hazard(dist, x)
       , pdf(dist, x) / cdf(complement(dist, x)), tol2);
    // cumulative hazard:
    BOOST_CHECK_CLOSE(
       chf(dist, x)
       , -log(cdf(complement(dist, x))), tol2);
    // coefficient_of_variation:
    BOOST_CHECK_CLOSE(
       coefficient_of_variation(dist)
       , standard_deviation(dist) / mean(dist), tol2);
    // mode:
    BOOST_CHECK_CLOSE(
       mode(dist)
       , static_cast<RealType>(6), tol2);

    BOOST_CHECK_CLOSE(
       median(dist), 
       quantile(
          chi_squared_distribution<RealType>(static_cast<RealType>(8)),
          static_cast<RealType>(0.5)), static_cast<RealType>(tol2));
    // skewness:
    BOOST_CHECK_CLOSE(
       skewness(dist)
       , static_cast<RealType>(1), tol2);
    // kurtosis:
    BOOST_CHECK_CLOSE(
       kurtosis(dist)
       , static_cast<RealType>(4.5), tol2);
    // kurtosis excess:
    BOOST_CHECK_CLOSE(
       kurtosis_excess(dist)
       , static_cast<RealType>(1.5), tol2);
    // special cases:
    BOOST_CHECK_THROW(
       pdf(
          chi_squared_distribution<RealType>(static_cast<RealType>(1)),
          static_cast<RealType>(0)), std::overflow_error
       );
    BOOST_CHECK_EQUAL(
       pdf(chi_squared_distribution<RealType>(2), static_cast<RealType>(0))
       , static_cast<RealType>(0.5f));
    BOOST_CHECK_EQUAL(
       pdf(chi_squared_distribution<RealType>(3), static_cast<RealType>(0))
       , static_cast<RealType>(0.0f));
    BOOST_CHECK_EQUAL(
       cdf(chi_squared_distribution<RealType>(1), static_cast<RealType>(0))
       , static_cast<RealType>(0.0f));
    BOOST_CHECK_EQUAL(
       cdf(chi_squared_distribution<RealType>(2), static_cast<RealType>(0))
       , static_cast<RealType>(0.0f));
    BOOST_CHECK_EQUAL(
       cdf(chi_squared_distribution<RealType>(3), static_cast<RealType>(0))
       , static_cast<RealType>(0.0f));
    BOOST_CHECK_EQUAL(
       cdf(complement(chi_squared_distribution<RealType>(1), static_cast<RealType>(0)))
       , static_cast<RealType>(1));
    BOOST_CHECK_EQUAL(
       cdf(complement(chi_squared_distribution<RealType>(2), static_cast<RealType>(0)))
       , static_cast<RealType>(1));
    BOOST_CHECK_EQUAL(
       cdf(complement(chi_squared_distribution<RealType>(3), static_cast<RealType>(0)))
       , static_cast<RealType>(1));

    BOOST_CHECK_THROW(
       pdf(
          chi_squared_distribution<RealType>(static_cast<RealType>(-1)),
          static_cast<RealType>(1)), std::domain_error
       );
    BOOST_CHECK_THROW(
       pdf(
          chi_squared_distribution<RealType>(static_cast<RealType>(8)),
          static_cast<RealType>(-1)), std::domain_error
       );
    BOOST_CHECK_THROW(
       cdf(
          chi_squared_distribution<RealType>(static_cast<RealType>(-1)),
          static_cast<RealType>(1)), std::domain_error
       );
    BOOST_CHECK_THROW(
       cdf(
          chi_squared_distribution<RealType>(static_cast<RealType>(8)),
          static_cast<RealType>(-1)), std::domain_error
       );
    BOOST_CHECK_THROW(
       cdf(complement(
          chi_squared_distribution<RealType>(static_cast<RealType>(-1)),
          static_cast<RealType>(1))), std::domain_error
       );
    BOOST_CHECK_THROW(
       cdf(complement(
          chi_squared_distribution<RealType>(static_cast<RealType>(8)),
          static_cast<RealType>(-1))), std::domain_error
       );
    BOOST_CHECK_THROW(
       quantile(
          chi_squared_distribution<RealType>(static_cast<RealType>(-1)),
          static_cast<RealType>(0.5)), std::domain_error
       );
    BOOST_CHECK_THROW(
       quantile(
          chi_squared_distribution<RealType>(static_cast<RealType>(8)),
          static_cast<RealType>(-1)), std::domain_error
       );
    BOOST_CHECK_THROW(
       quantile(
          chi_squared_distribution<RealType>(static_cast<RealType>(8)),
          static_cast<RealType>(1.1)), std::domain_error
       );
    BOOST_CHECK_THROW(
       quantile(complement(
          chi_squared_distribution<RealType>(static_cast<RealType>(-1)),
          static_cast<RealType>(0.5))), std::domain_error
       );
    BOOST_CHECK_THROW(
       quantile(complement(
          chi_squared_distribution<RealType>(static_cast<RealType>(8)),
          static_cast<RealType>(-1))), std::domain_error
       );
    BOOST_CHECK_THROW(
       quantile(complement(
          chi_squared_distribution<RealType>(static_cast<RealType>(8)),
          static_cast<RealType>(1.1))), std::domain_error
       );

    // This first test value is taken from an example here:
    // http://www.itl.nist.gov/div898/handbook/prc/section2/prc232.htm
    // Subsequent tests just test our empirically generated values, they
    // catch regressions, but otherwise aren't worth much.
    BOOST_CHECK_EQUAL(
       ceil(chi_squared_distribution<RealType>::find_degrees_of_freedom(
         55, 0.05f, 0.01f, 100)), static_cast<RealType>(170));
    BOOST_CHECK_EQUAL(
       ceil(chi_squared_distribution<RealType>::find_degrees_of_freedom(
         10, 0.05f, 0.01f, 100)), static_cast<RealType>(3493));
    BOOST_CHECK_EQUAL(
       ceil(chi_squared_distribution<RealType>::find_degrees_of_freedom(
         -55, 0.05f, 0.01f, 100)), static_cast<RealType>(49));
    BOOST_CHECK_EQUAL(
       ceil(chi_squared_distribution<RealType>::find_degrees_of_freedom(
         -10, 0.05f, 0.01f, 100)), static_cast<RealType>(2826));
} // template <class RealType>void test_spots(RealType)

int test_main(int, char* [])
{
  BOOST_MATH_CONTROL_FP;
  // Check that can generate chi_squared distribution using the two convenience methods:
  chi_squared_distribution<> mychisqr(8);
  chi_squared mychisqr2(8);

  // Basic sanity-check spot values.

  // (Parameter value, arbitrarily zero, only communicates the floating point type).
  test_spots(0.0F); // Test float.
  test_spots(0.0); // Test double.
#ifndef BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS
  test_spots(0.0L); // Test long double.
#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582))
  test_spots(boost::math::concepts::real_concept(0.)); // Test real concept.
#endif
#endif
  return 0;
} // int test_main(int, char* [])

/*

Output:

Autorun "i:\boost-06-05-03-1300\libs\math\test\Math_test\debug\test_chi_squared.exe"
Running 1 test case...
Tolerance = 0.1%.
Tolerance = 0.1%.
Tolerance = 0.1%.
Tolerance = 0.1%.
*** No errors detected

*/