Magic-Mirror/llvm-capstone
1
0
Fork 0
mirror of https://github.com/capstone-engine/llvm-capstone.git synced 2024-12-13 19:24:21 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Better cauchy tests

Browse Source 
llvm-svn: 104008
This commit is contained in:
Howard Hinnant 2010-05-18 00:34:49 +00:00
parent b013b0bc04
commit 34c3b52a2c
2 changed files with 118 additions and 19 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
libcxx/test/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval.pass.cpp
View File

@ -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);
}
}

71
libcxx/test/numerics/rand/rand.dis/rand.dist.norm/rand.dist.norm.cauchy/eval_param.pass.cpp
View File

@ -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);
}
}