Better cauchy tests
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@104008 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/test/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval.pass.cpp b/test/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval.pass.cpp
index 3ab9d54..f889837 100644
--- a/test/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval.pass.cpp
+++ b/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);
- D::result_type v = d(g);
-
-// If anyone can figure out a better test than this,
-// it would be more than welcome!
+ {
+ 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);
+ }
}
diff --git a/test/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval_param.pass.cpp b/test/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval_param.pass.cpp
index c9cdad4..c4cfaef 100644
--- a/test/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval_param.pass.cpp
+++ b/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);
- P p(3, 4);
- D::result_type v = d(g, p);
-
-// If anyone can figure out a better test than this,
-// it would be more than welcome!
+ {
+ 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);
+ }
}