[cfe-commits] [libcxx] r104008 - in /libcxx/trunk/test/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy: eval.pass.cpp eval_param.pass.cpp

[Howard Hinnant]

Author: hhinnant
Date: Mon May 17 19:34:49 2010
New Revision: 104008

URL: http://llvm.org/viewvc/llvm-project?rev=104008&view=rev
Log:
Better cauchy tests

Modified:
    libcxx/trunk/test/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval.pass.cpp
    libcxx/trunk/test/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval_param.pass.cpp

Modified: libcxx/trunk/test/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval.pass.cpp?rev=104008&r1=104007&r2=104008&view=diff
==============================================================================
--- libcxx/trunk/test/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval.pass.cpp (original)
+++ libcxx/trunk/test/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval.pass.cpp Mon May 17 19:34:49 2010
@@ -15,16 +15,64 @@
 // template<class _URNG> result_type operator()(_URNG& g);
 
 #include <random>
+#include <cassert>
+#include <vector>
+#include <algorithm>
 
-int main()
+double
+f(double x, double a, double b)
 {
-    typedef std::cauchy_distribution<> D;
-    typedef D::param_type P;
-    typedef std::mt19937 G;
-    G g;
-    D d(0.5, 2);
-    D::result_type v = d(g);
+    return 1/3.1415926535897932 * std::atan((x - a)/b) + .5;
+}
 
-// If anyone can figure out a better test than this,
-// it would be more than welcome!
+int main()
+{
+    {
+        typedef std::cauchy_distribution<> D;
+        typedef D::param_type P;
+        typedef std::mt19937 G;
+        G g;
+        const double a = 10;
+        const double b = .5;
+        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 = -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);
+    }
 }

Modified: libcxx/trunk/test/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval_param.pass.cpp
URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval_param.pass.cpp?rev=104008&r1=104007&r2=104008&view=diff
==============================================================================
--- libcxx/trunk/test/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval_param.pass.cpp (original)
+++ libcxx/trunk/test/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval_param.pass.cpp Mon May 17 19:34:49 2010
@@ -15,17 +15,68 @@
 // template<class _URNG> result_type operator()(_URNG& g, const param_type& parm);
 
 #include <random>
+#include <cassert>
+#include <vector>
+#include <algorithm>
 
-int main()
+double
+f(double x, double a, double b)
 {
-    typedef std::cauchy_distribution<> D;
-    typedef D::param_type P;
-    typedef std::mt19937 G;
-    G g;
-    D d(0.5, 2);
-    P p(3, 4);
-    D::result_type v = d(g, p);
+    return 1/3.1415926535897932 * std::atan((x - a)/b) + .5;
+}
+
 
-// If anyone can figure out a better test than this,
-// it would be more than welcome!
+int main()
+{
+    {
+        typedef std::cauchy_distribution<> D;
+        typedef D::param_type P;
+        typedef std::mt19937 G;
+        G g;
+        const double a = 10;
+        const double b = .5;
+        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 = -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);
+    }
 }