Better cauchy tests

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@104008 91177308-0d34-0410-b5e6-96231b3b80d8

test/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval.pass.cpp

@@ -15,16 +15,64 @@
 // template<class _URNG> result_type operator()(_URNG& g);
 
 #include <random>
+#include <cassert>
+#include <vector>
+#include <algorithm>
+
+double
+f(double x, double a, double b)
+{
+    return 1/3.1415926535897932 * std::atan((x - a)/b) + .5;
+}
 
 int main()
+{
     {
         typedef std::cauchy_distribution<> D;
         typedef D::param_type P;
         typedef std::mt19937 G;
         G g;
-    D d(0.5, 2);
+        const double a = 10;
-    D::result_type v = d(g);
+        const double b = .5;
-
+        D d(a, b);
-// If anyone can figure out a better test than this,
+        const int N = 1000000;
-// it would be more than welcome!
+        std::vector<D::result_type> u;
+        for (int i = 0; i < N; ++i)
+            u.push_back(d(g));
+        std::sort(u.begin(), u.end());
+        for (int i = 0; i < N; ++i)
+            assert(std::abs(f(u[i], a, b) - double(i)/N) < .001);
+    }
+    {
+        typedef std::cauchy_distribution<> D;
+        typedef D::param_type P;
+        typedef std::mt19937 G;
+        G g;
+        const double a = -1.5;
+        const double b = 1;
+        D d(a, b);
+        const int N = 1000000;
+        std::vector<D::result_type> u;
+        for (int i = 0; i < N; ++i)
+            u.push_back(d(g));
+        std::sort(u.begin(), u.end());
+        for (int i = 0; i < N; ++i)
+            assert(std::abs(f(u[i], a, b) - double(i)/N) < .001);
+    }
+    {
+        typedef std::cauchy_distribution<> D;
+        typedef D::param_type P;
+        typedef std::mt19937 G;
+        G g;
+        const double a = .5;
+        const double b = 2;
+        D d(a, b);
+        const int N = 1000000;
+        std::vector<D::result_type> u;
+        for (int i = 0; i < N; ++i)
+            u.push_back(d(g));
+        std::sort(u.begin(), u.end());
+        for (int i = 0; i < N; ++i)
+            assert(std::abs(f(u[i], a, b) - double(i)/N) < .001);
+    }
 }

test/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval_param.pass.cpp

@@ -15,17 +15,68 @@
 // template<class _URNG> result_type operator()(_URNG& g, const param_type& parm);
 
 #include <random>
+#include <cassert>
+#include <vector>
+#include <algorithm>
+
+double
+f(double x, double a, double b)
+{
+    return 1/3.1415926535897932 * std::atan((x - a)/b) + .5;
+}
+
 
 int main()
+{
     {
         typedef std::cauchy_distribution<> D;
         typedef D::param_type P;
         typedef std::mt19937 G;
         G g;
-    D d(0.5, 2);
+        const double a = 10;
-    P p(3, 4);
+        const double b = .5;
-    D::result_type v = d(g, p);
+        D d;
-
+        P p(a, b);
-// If anyone can figure out a better test than this,
+        const int N = 1000000;
-// it would be more than welcome!
+        std::vector<D::result_type> u;
+        for (int i = 0; i < N; ++i)
+            u.push_back(d(g, p));
+        std::sort(u.begin(), u.end());
+        for (int i = 0; i < N; ++i)
+            assert(std::abs(f(u[i], a, b) - double(i)/N) < .001);
+    }
+    {
+        typedef std::cauchy_distribution<> D;
+        typedef D::param_type P;
+        typedef std::mt19937 G;
+        G g;
+        const double a = -1.5;
+        const double b = 1;
+        D d;
+        P p(a, b);
+        const int N = 1000000;
+        std::vector<D::result_type> u;
+        for (int i = 0; i < N; ++i)
+            u.push_back(d(g, p));
+        std::sort(u.begin(), u.end());
+        for (int i = 0; i < N; ++i)
+            assert(std::abs(f(u[i], a, b) - double(i)/N) < .001);
+    }
+    {
+        typedef std::cauchy_distribution<> D;
+        typedef D::param_type P;
+        typedef std::mt19937 G;
+        G g;
+        const double a = .5;
+        const double b = 2;
+        D d;
+        P p(a, b);
+        const int N = 1000000;
+        std::vector<D::result_type> u;
+        for (int i = 0; i < N; ++i)
+            u.push_back(d(g, p));
+        std::sort(u.begin(), u.end());
+        for (int i = 0; i < N; ++i)
+            assert(std::abs(f(u[i], a, b) - double(i)/N) < .001);
+    }
 }