Adding upstream version 14.2.21.upstream/14.2.21upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 594 insertions, 0 deletions

diff --git a/src/boost/libs/math/test/test_chi_squared.cpp b/src/boost/libs/math/test/test_chi_squared.cpp
new file mode 100644
index 00000000..8f79b93a
--- /dev/null
+++ b/src/boost/libs/math/test/test_chi_squared.cpp
@@ -0,0 +1,594 @@
+// 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)
+
+#ifdef _MSC_VER
+#  pragma warning(disable: 4100) // unreferenced formal parameter.
+// Seems an entirely spurious warning - formal parameter T IS used - get error if /* T */
+//#  pragma warning(disable: 4535) // calling _set_se_translator() requires /EHa (in Boost.test)
+// Enable C++ Exceptions Yes With SEH Exceptions (/EHa) prevents warning 4535.
+#  pragma warning(disable: 4127) // conditional expression is constant
+#endif
+
+#include <boost/math/tools/test.hpp> // for real_concept
+#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
+#include <boost/math/distributions/non_central_chi_squared.hpp> // for chi_squared_distribution
+using boost::math::chi_squared_distribution;
+using boost::math::chi_squared;
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp> // for test_main
+#include <boost/test/tools/floating_point_comparison.hpp> // for BOOST_CHECK_CLOSE
+
+#include "test_out_of_range.hpp"
+
+#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 guarantee 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);
+   }
+
+   boost::math::non_central_chi_squared_distribution<RealType> dist2(df, 0);
+   BOOST_CHECK_CLOSE(
+      cdf(dist2, cs), P, tol);
+   BOOST_CHECK_CLOSE(
+      pdf(dist2, cs), naive_pdf(dist2.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 guarantee Q is free of error:
+      //
+      BOOST_CHECK_CLOSE(
+         cdf(complement(dist2, cs)), Q, tol);
+      BOOST_CHECK_CLOSE(
+         quantile(dist2, P), cs, tol);
+      BOOST_CHECK_CLOSE(
+         quantile(complement(dist2, 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 T)
+{
+  // 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 for type " << typeid(T).name()  << " is " << 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_MATH_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_MATH_CHECK_THROW(
+       pdf(
+          chi_squared_distribution<RealType>(static_cast<RealType>(-1)),
+          static_cast<RealType>(1)), std::domain_error
+       );
+    BOOST_MATH_CHECK_THROW(
+       pdf(
+          chi_squared_distribution<RealType>(static_cast<RealType>(8)),
+          static_cast<RealType>(-1)), std::domain_error
+       );
+    BOOST_MATH_CHECK_THROW(
+       cdf(
+          chi_squared_distribution<RealType>(static_cast<RealType>(-1)),
+          static_cast<RealType>(1)), std::domain_error
+       );
+    BOOST_MATH_CHECK_THROW(
+       cdf(
+          chi_squared_distribution<RealType>(static_cast<RealType>(8)),
+          static_cast<RealType>(-1)), std::domain_error
+       );
+    BOOST_MATH_CHECK_THROW(
+       cdf(complement(
+          chi_squared_distribution<RealType>(static_cast<RealType>(-1)),
+          static_cast<RealType>(1))), std::domain_error
+       );
+    BOOST_MATH_CHECK_THROW(
+       cdf(complement(
+          chi_squared_distribution<RealType>(static_cast<RealType>(8)),
+          static_cast<RealType>(-1))), std::domain_error
+       );
+    BOOST_MATH_CHECK_THROW(
+       quantile(
+          chi_squared_distribution<RealType>(static_cast<RealType>(-1)),
+          static_cast<RealType>(0.5)), std::domain_error
+       );
+    BOOST_MATH_CHECK_THROW(
+       quantile(
+          chi_squared_distribution<RealType>(static_cast<RealType>(8)),
+          static_cast<RealType>(-1)), std::domain_error
+       );
+    BOOST_MATH_CHECK_THROW(
+       quantile(
+          chi_squared_distribution<RealType>(static_cast<RealType>(8)),
+          static_cast<RealType>(1.1)), std::domain_error
+       );
+    BOOST_MATH_CHECK_THROW(
+       quantile(complement(
+          chi_squared_distribution<RealType>(static_cast<RealType>(-1)),
+          static_cast<RealType>(0.5))), std::domain_error
+       );
+    BOOST_MATH_CHECK_THROW(
+       quantile(complement(
+          chi_squared_distribution<RealType>(static_cast<RealType>(8)),
+          static_cast<RealType>(-1))), std::domain_error
+       );
+    BOOST_MATH_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));
+
+    check_out_of_range<boost::math::chi_squared_distribution<RealType> >(1); // (All) valid constructor parameter values.
+
+} // template <class RealType>void test_spots(RealType)
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+  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 !defined(BOOST_MATH_NO_REAL_CONCEPT_TESTS)
+  test_spots(boost::math::concepts::real_concept(0.)); // Test real concept.
+#endif
+#endif
+} // BOOST_AUTO_TEST_CASE( test_main )
+
+/*
+
+Output:
+
+Description: Autorun "J:\Cpp\MathToolkit\test\Math_test\Debug\test_chi_squared.exe"
+  Running 1 test case...
+  Tolerance for type float is 0.1 %
+  Tolerance for type double is 0.1 %
+  Tolerance for type long double is 0.1 %
+  Tolerance for type class boost::math::concepts::real_concept is 0.1 %
+
+
+*/
+
+
+