forked from personal/squiggle.c
formatting pass.
This commit is contained in:
parent
6b2349132b
commit
88e998edce
454
test/test.c
454
test/test.c
|
|
@ -1,280 +1,284 @@
|
|||
#include "../squiggle.h"
|
||||
#include <stdint.h>
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#define PERCENTAGE_TOLERANCE 1.0/1000.0
|
||||
#define PERCENTAGE_TOLERANCE_LOGNORMAL 5.0/1000.0
|
||||
#define PERCENTAGE_TOLERANCE 1.0 / 1000.0
|
||||
#define PERCENTAGE_TOLERANCE_LOGNORMAL 5.0 / 1000.0
|
||||
#define MAX_NAME_LENGTH 500
|
||||
|
||||
// Structs
|
||||
|
||||
struct array_expectations {
|
||||
double* array;
|
||||
int n;
|
||||
char* name;
|
||||
double expected_mean;
|
||||
double expected_std;
|
||||
double tolerance;
|
||||
double* array;
|
||||
int n;
|
||||
char* name;
|
||||
double expected_mean;
|
||||
double expected_std;
|
||||
double tolerance;
|
||||
};
|
||||
|
||||
void test_array_expectations(struct array_expectations e){
|
||||
double mean = array_mean(e.array, e.n);
|
||||
double delta_mean = mean - e.expected_mean;
|
||||
void test_array_expectations(struct array_expectations e)
|
||||
{
|
||||
double mean = array_mean(e.array, e.n);
|
||||
double delta_mean = mean - e.expected_mean;
|
||||
|
||||
double std = array_std(e.array, e.n);
|
||||
double delta_std = std - e.expected_std;
|
||||
|
||||
double std = array_std(e.array, e.n);
|
||||
double delta_std = std - e.expected_std;
|
||||
|
||||
if(fabs(delta_mean)/fabs(mean) > e.tolerance){
|
||||
printf("[-] Mean test for %s NOT passed.\n", e.name);
|
||||
printf("Mean of %s: %f, vs expected mean: %f\n", e.name, mean, e.expected_mean);
|
||||
printf("delta: %f, relative delta: %f\n", delta_mean, delta_mean/fabs(mean));
|
||||
}else {
|
||||
printf("[x] Mean test for %s PASSED\n", e.name);
|
||||
}
|
||||
if (fabs(delta_mean) / fabs(mean) > e.tolerance) {
|
||||
printf("[-] Mean test for %s NOT passed.\n", e.name);
|
||||
printf("Mean of %s: %f, vs expected mean: %f\n", e.name, mean, e.expected_mean);
|
||||
printf("delta: %f, relative delta: %f\n", delta_mean, delta_mean / fabs(mean));
|
||||
} else {
|
||||
printf("[x] Mean test for %s PASSED\n", e.name);
|
||||
}
|
||||
|
||||
if(fabs(delta_std)/fabs(std) > e.tolerance){
|
||||
printf("[-] Std test for %s NOT passed.\n", e.name);
|
||||
printf("Std of %s: %f, vs expected std: %f\n", e.name, std, e.expected_std);
|
||||
printf("delta: %f, relative delta: %f\n", delta_std, delta_std/fabs(std));
|
||||
}else {
|
||||
printf("[x] Std test for %s PASSED\n", e.name);
|
||||
}
|
||||
|
||||
printf("\n");
|
||||
if (fabs(delta_std) / fabs(std) > e.tolerance) {
|
||||
printf("[-] Std test for %s NOT passed.\n", e.name);
|
||||
printf("Std of %s: %f, vs expected std: %f\n", e.name, std, e.expected_std);
|
||||
printf("delta: %f, relative delta: %f\n", delta_std, delta_std / fabs(std));
|
||||
} else {
|
||||
printf("[x] Std test for %s PASSED\n", e.name);
|
||||
}
|
||||
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
// Test unit uniform
|
||||
void test_unit_uniform(uint64_t* seed){
|
||||
int n = 1000 * 1000;
|
||||
double* unit_uniform_array = malloc(sizeof(double) * n);
|
||||
|
||||
for(int i=0; i<n; i++){
|
||||
unit_uniform_array[i] = sample_unit_uniform(seed);
|
||||
}
|
||||
void test_unit_uniform(uint64_t* seed)
|
||||
{
|
||||
int n = 1000 * 1000;
|
||||
double* unit_uniform_array = malloc(sizeof(double) * n);
|
||||
|
||||
struct array_expectations expectations = {
|
||||
.array = unit_uniform_array,
|
||||
.n = n,
|
||||
.name = "unit uniform",
|
||||
.expected_mean = 0.5,
|
||||
.expected_std = sqrt(1.0/12.0),
|
||||
.tolerance = 1 * PERCENTAGE_TOLERANCE,
|
||||
};
|
||||
for (int i = 0; i < n; i++) {
|
||||
unit_uniform_array[i] = sample_unit_uniform(seed);
|
||||
}
|
||||
|
||||
test_array_expectations(expectations);
|
||||
free(unit_uniform_array);
|
||||
struct array_expectations expectations = {
|
||||
.array = unit_uniform_array,
|
||||
.n = n,
|
||||
.name = "unit uniform",
|
||||
.expected_mean = 0.5,
|
||||
.expected_std = sqrt(1.0 / 12.0),
|
||||
.tolerance = 1 * PERCENTAGE_TOLERANCE,
|
||||
};
|
||||
|
||||
test_array_expectations(expectations);
|
||||
free(unit_uniform_array);
|
||||
}
|
||||
|
||||
// Test uniforms
|
||||
void test_uniform(double start, double end, uint64_t* seed){
|
||||
int n = 1000 * 1000;
|
||||
double* uniform_array = malloc(sizeof(double) * n);
|
||||
|
||||
for(int i=0; i<n; i++){
|
||||
uniform_array[i] = sample_uniform(start, end, seed);
|
||||
}
|
||||
|
||||
char* name = malloc(MAX_NAME_LENGTH * sizeof(char));
|
||||
snprintf(name, MAX_NAME_LENGTH, "[%f, %f] uniform", start, end);
|
||||
struct array_expectations expectations = {
|
||||
.array = uniform_array,
|
||||
.n = n,
|
||||
.name = name,
|
||||
.expected_mean = (start + end)/2,
|
||||
.expected_std = sqrt(1.0/12.0) * fabs(end-start),
|
||||
.tolerance = fabs(end -start) * PERCENTAGE_TOLERANCE,
|
||||
};
|
||||
void test_uniform(double start, double end, uint64_t* seed)
|
||||
{
|
||||
int n = 1000 * 1000;
|
||||
double* uniform_array = malloc(sizeof(double) * n);
|
||||
|
||||
test_array_expectations(expectations);
|
||||
free(name);
|
||||
free(uniform_array);
|
||||
for (int i = 0; i < n; i++) {
|
||||
uniform_array[i] = sample_uniform(start, end, seed);
|
||||
}
|
||||
|
||||
char* name = malloc(MAX_NAME_LENGTH * sizeof(char));
|
||||
snprintf(name, MAX_NAME_LENGTH, "[%f, %f] uniform", start, end);
|
||||
struct array_expectations expectations = {
|
||||
.array = uniform_array,
|
||||
.n = n,
|
||||
.name = name,
|
||||
.expected_mean = (start + end) / 2,
|
||||
.expected_std = sqrt(1.0 / 12.0) * fabs(end - start),
|
||||
.tolerance = fabs(end - start) * PERCENTAGE_TOLERANCE,
|
||||
};
|
||||
|
||||
test_array_expectations(expectations);
|
||||
free(name);
|
||||
free(uniform_array);
|
||||
}
|
||||
|
||||
// Test unit normal
|
||||
void test_unit_normal(uint64_t* seed){
|
||||
int n = 1000 * 1000;
|
||||
double* unit_normal_array = malloc(sizeof(double) * n);
|
||||
|
||||
for(int i=0; i<n; i++){
|
||||
unit_normal_array[i] = sample_unit_normal(seed);
|
||||
}
|
||||
void test_unit_normal(uint64_t* seed)
|
||||
{
|
||||
int n = 1000 * 1000;
|
||||
double* unit_normal_array = malloc(sizeof(double) * n);
|
||||
|
||||
struct array_expectations expectations = {
|
||||
.array = unit_normal_array,
|
||||
.n = n,
|
||||
.name = "unit normal",
|
||||
.expected_mean = 0,
|
||||
.expected_std = 1,
|
||||
.tolerance = 1 * PERCENTAGE_TOLERANCE,
|
||||
};
|
||||
for (int i = 0; i < n; i++) {
|
||||
unit_normal_array[i] = sample_unit_normal(seed);
|
||||
}
|
||||
|
||||
test_array_expectations(expectations);
|
||||
free(unit_normal_array);
|
||||
struct array_expectations expectations = {
|
||||
.array = unit_normal_array,
|
||||
.n = n,
|
||||
.name = "unit normal",
|
||||
.expected_mean = 0,
|
||||
.expected_std = 1,
|
||||
.tolerance = 1 * PERCENTAGE_TOLERANCE,
|
||||
};
|
||||
|
||||
test_array_expectations(expectations);
|
||||
free(unit_normal_array);
|
||||
}
|
||||
|
||||
// Test normal
|
||||
void test_normal(double mean, double std, uint64_t* seed){
|
||||
int n = 10 * 1000 * 1000;
|
||||
double* normal_array = malloc(sizeof(double) * n);
|
||||
|
||||
for(int i=0; i<n; i++){
|
||||
normal_array[i] = sample_normal(mean, std, seed);
|
||||
}
|
||||
|
||||
char* name = malloc(MAX_NAME_LENGTH * sizeof(char));
|
||||
snprintf(name, MAX_NAME_LENGTH, "normal(%f, %f)", mean, std);
|
||||
struct array_expectations expectations = {
|
||||
.array = normal_array,
|
||||
.n = n,
|
||||
.name = name,
|
||||
.expected_mean = mean,
|
||||
.expected_std = std,
|
||||
.tolerance = std * PERCENTAGE_TOLERANCE,
|
||||
};
|
||||
void test_normal(double mean, double std, uint64_t* seed)
|
||||
{
|
||||
int n = 10 * 1000 * 1000;
|
||||
double* normal_array = malloc(sizeof(double) * n);
|
||||
|
||||
test_array_expectations(expectations);
|
||||
free(name);
|
||||
free(normal_array);
|
||||
for (int i = 0; i < n; i++) {
|
||||
normal_array[i] = sample_normal(mean, std, seed);
|
||||
}
|
||||
|
||||
char* name = malloc(MAX_NAME_LENGTH * sizeof(char));
|
||||
snprintf(name, MAX_NAME_LENGTH, "normal(%f, %f)", mean, std);
|
||||
struct array_expectations expectations = {
|
||||
.array = normal_array,
|
||||
.n = n,
|
||||
.name = name,
|
||||
.expected_mean = mean,
|
||||
.expected_std = std,
|
||||
.tolerance = std * PERCENTAGE_TOLERANCE,
|
||||
};
|
||||
|
||||
test_array_expectations(expectations);
|
||||
free(name);
|
||||
free(normal_array);
|
||||
}
|
||||
|
||||
// Test lognormal
|
||||
void test_lognormal(double logmean, double logstd, uint64_t* seed){
|
||||
int n = 10 * 1000 * 1000;
|
||||
double* lognormal_array = malloc(sizeof(double) * n);
|
||||
|
||||
for(int i=0; i<n; i++){
|
||||
lognormal_array[i] = sample_lognormal(logmean, logstd, seed);
|
||||
}
|
||||
|
||||
char* name = malloc(MAX_NAME_LENGTH * sizeof(char));
|
||||
snprintf(name, MAX_NAME_LENGTH, "lognormal(%f, %f)", logmean, logstd);
|
||||
struct array_expectations expectations = {
|
||||
.array = lognormal_array,
|
||||
.n = n,
|
||||
.name = name,
|
||||
.expected_mean = exp(logmean + pow(logstd, 2)/2),
|
||||
.expected_std = sqrt((exp(pow(logstd, 2)) - 1) * exp(2*logmean + pow(logstd, 2))),
|
||||
.tolerance = exp(logstd) * PERCENTAGE_TOLERANCE_LOGNORMAL,
|
||||
};
|
||||
void test_lognormal(double logmean, double logstd, uint64_t* seed)
|
||||
{
|
||||
int n = 10 * 1000 * 1000;
|
||||
double* lognormal_array = malloc(sizeof(double) * n);
|
||||
|
||||
test_array_expectations(expectations);
|
||||
free(name);
|
||||
free(lognormal_array);
|
||||
for (int i = 0; i < n; i++) {
|
||||
lognormal_array[i] = sample_lognormal(logmean, logstd, seed);
|
||||
}
|
||||
|
||||
char* name = malloc(MAX_NAME_LENGTH * sizeof(char));
|
||||
snprintf(name, MAX_NAME_LENGTH, "lognormal(%f, %f)", logmean, logstd);
|
||||
struct array_expectations expectations = {
|
||||
.array = lognormal_array,
|
||||
.n = n,
|
||||
.name = name,
|
||||
.expected_mean = exp(logmean + pow(logstd, 2) / 2),
|
||||
.expected_std = sqrt((exp(pow(logstd, 2)) - 1) * exp(2 * logmean + pow(logstd, 2))),
|
||||
.tolerance = exp(logstd) * PERCENTAGE_TOLERANCE_LOGNORMAL,
|
||||
};
|
||||
|
||||
test_array_expectations(expectations);
|
||||
free(name);
|
||||
free(lognormal_array);
|
||||
}
|
||||
|
||||
// Test beta
|
||||
|
||||
void test_beta(double a, double b, uint64_t* seed){
|
||||
int n = 10 * 1000 * 1000;
|
||||
double* beta_array = malloc(sizeof(double) * n);
|
||||
|
||||
for(int i=0; i<n; i++){
|
||||
beta_array[i] = sample_beta(a, b, seed);
|
||||
}
|
||||
|
||||
char* name = malloc(MAX_NAME_LENGTH * sizeof(char));
|
||||
snprintf(name, MAX_NAME_LENGTH, "beta(%f, %f)", a, b);
|
||||
struct array_expectations expectations = {
|
||||
.array = beta_array,
|
||||
.n = n,
|
||||
.name = name,
|
||||
.expected_mean = a/(a+b),
|
||||
.expected_std = sqrt((a*b)/(pow(a+b, 2) * (a + b + 1))),
|
||||
.tolerance = PERCENTAGE_TOLERANCE,
|
||||
};
|
||||
void test_beta(double a, double b, uint64_t* seed)
|
||||
{
|
||||
int n = 10 * 1000 * 1000;
|
||||
double* beta_array = malloc(sizeof(double) * n);
|
||||
|
||||
test_array_expectations(expectations);
|
||||
free(name);
|
||||
for (int i = 0; i < n; i++) {
|
||||
beta_array[i] = sample_beta(a, b, seed);
|
||||
}
|
||||
|
||||
char* name = malloc(MAX_NAME_LENGTH * sizeof(char));
|
||||
snprintf(name, MAX_NAME_LENGTH, "beta(%f, %f)", a, b);
|
||||
struct array_expectations expectations = {
|
||||
.array = beta_array,
|
||||
.n = n,
|
||||
.name = name,
|
||||
.expected_mean = a / (a + b),
|
||||
.expected_std = sqrt((a * b) / (pow(a + b, 2) * (a + b + 1))),
|
||||
.tolerance = PERCENTAGE_TOLERANCE,
|
||||
};
|
||||
|
||||
test_array_expectations(expectations);
|
||||
free(name);
|
||||
}
|
||||
|
||||
int main(){
|
||||
int main()
|
||||
{
|
||||
// set randomness seed
|
||||
uint64_t* seed = malloc(sizeof(uint64_t));
|
||||
*seed = 1000; // xorshift can't start with a seed of 0
|
||||
/*
|
||||
printf("Testing unit uniform\n");
|
||||
test_unit_uniform(seed);
|
||||
|
||||
printf("Testing small uniforms\n");
|
||||
for(int i=0; i<100; i++){
|
||||
double start = sample_uniform(-10, 10, seed);
|
||||
double end = sample_uniform(-10, 10, seed);
|
||||
if ( end > start){
|
||||
test_uniform(start, end, seed);
|
||||
}
|
||||
}
|
||||
printf("Testing unit uniform\n");
|
||||
test_unit_uniform(seed);
|
||||
|
||||
printf("Testing wide uniforms\n");
|
||||
for(int i=0; i<100; i++){
|
||||
double start = sample_uniform(-1000 * 1000, 1000 * 1000, seed);
|
||||
double end = sample_uniform(-1000 * 1000, 1000 * 1000, seed);
|
||||
if ( end > start){
|
||||
test_uniform(start, end, seed);
|
||||
}
|
||||
}
|
||||
printf("Testing small uniforms\n");
|
||||
for (int i = 0; i < 100; i++) {
|
||||
double start = sample_uniform(-10, 10, seed);
|
||||
double end = sample_uniform(-10, 10, seed);
|
||||
if (end > start) {
|
||||
test_uniform(start, end, seed);
|
||||
}
|
||||
}
|
||||
|
||||
printf("Testing unit normal\n");
|
||||
test_unit_normal(seed);
|
||||
|
||||
printf("Testing small normals\n");
|
||||
for(int i=0; i<100; i++){
|
||||
double mean = sample_uniform(-10, 10, seed);
|
||||
double std = sample_uniform(0, 10, seed);
|
||||
if ( std > 0){
|
||||
test_normal(mean, std, seed);
|
||||
}
|
||||
}
|
||||
printf("Testing wide uniforms\n");
|
||||
for (int i = 0; i < 100; i++) {
|
||||
double start = sample_uniform(-1000 * 1000, 1000 * 1000, seed);
|
||||
double end = sample_uniform(-1000 * 1000, 1000 * 1000, seed);
|
||||
if (end > start) {
|
||||
test_uniform(start, end, seed);
|
||||
}
|
||||
}
|
||||
|
||||
printf("Testing larger normals\n");
|
||||
for(int i=0; i<100; i++){
|
||||
double mean = sample_uniform(-1000 * 1000, 1000 * 1000, seed);
|
||||
double std = sample_uniform(0, 1000 * 1000, seed);
|
||||
if ( std > 0){
|
||||
test_normal(mean, std, seed);
|
||||
}
|
||||
}
|
||||
*/
|
||||
printf("Testing very small lognormals\n");
|
||||
for(int i=0; i<10; i++){
|
||||
double mean = sample_uniform(-1, 1, seed);
|
||||
double std = sample_uniform(0, 1, seed);
|
||||
if ( std > 0){
|
||||
test_lognormal(mean, std, seed);
|
||||
}
|
||||
}
|
||||
printf("Testing unit normal\n");
|
||||
test_unit_normal(seed);
|
||||
|
||||
printf("Testing small lognormals\n");
|
||||
for(int i=0; i<10; i++){
|
||||
double mean = sample_uniform(-1, 5, seed);
|
||||
double std = sample_uniform(0, 5, seed);
|
||||
if ( std > 0){
|
||||
test_lognormal(mean, std, seed);
|
||||
}
|
||||
}
|
||||
/*
|
||||
printf("Testing beta distribution\n");
|
||||
for(int i=0; i<100; i++){
|
||||
double a = sample_uniform(0, 1000, seed);
|
||||
double b = sample_uniform(0, 1000, seed);
|
||||
if ( (a > 0) && ( b >0)){
|
||||
test_beta(a, b, seed);
|
||||
}
|
||||
}
|
||||
printf("Testing small normals\n");
|
||||
for (int i = 0; i < 100; i++) {
|
||||
double mean = sample_uniform(-10, 10, seed);
|
||||
double std = sample_uniform(0, 10, seed);
|
||||
if (std > 0) {
|
||||
test_normal(mean, std, seed);
|
||||
}
|
||||
}
|
||||
|
||||
printf("Testing larger beta distributions\n");
|
||||
for(int i=0; i<100; i++){
|
||||
double a = sample_uniform(0, 1000 * 1000, seed);
|
||||
double b = sample_uniform(0, 1000 * 1000, seed);
|
||||
if ( (a > 0) && ( b >0)){
|
||||
test_beta(a, b, seed);
|
||||
}
|
||||
}
|
||||
printf("Testing larger normals\n");
|
||||
for (int i = 0; i < 100; i++) {
|
||||
double mean = sample_uniform(-1000 * 1000, 1000 * 1000, seed);
|
||||
double std = sample_uniform(0, 1000 * 1000, seed);
|
||||
if (std > 0) {
|
||||
test_normal(mean, std, seed);
|
||||
}
|
||||
}
|
||||
|
||||
free(seed);
|
||||
*/
|
||||
printf("Testing very small lognormals\n");
|
||||
for (int i = 0; i < 10; i++) {
|
||||
double mean = sample_uniform(-1, 1, seed);
|
||||
double std = sample_uniform(0, 1, seed);
|
||||
if (std > 0) {
|
||||
test_lognormal(mean, std, seed);
|
||||
}
|
||||
}
|
||||
|
||||
printf("Testing small lognormals\n");
|
||||
for (int i = 0; i < 10; i++) {
|
||||
double mean = sample_uniform(-1, 5, seed);
|
||||
double std = sample_uniform(0, 5, seed);
|
||||
if (std > 0) {
|
||||
test_lognormal(mean, std, seed);
|
||||
}
|
||||
}
|
||||
|
||||
printf("Testing beta distribution\n");
|
||||
for (int i = 0; i < 100; i++) {
|
||||
double a = sample_uniform(0, 1000, seed);
|
||||
double b = sample_uniform(0, 1000, seed);
|
||||
if ((a > 0) && (b > 0)) {
|
||||
test_beta(a, b, seed);
|
||||
}
|
||||
}
|
||||
|
||||
printf("Testing larger beta distributions\n");
|
||||
for (int i = 0; i < 100; i++) {
|
||||
double a = sample_uniform(0, 1000 * 1000, seed);
|
||||
double b = sample_uniform(0, 1000 * 1000, seed);
|
||||
if ((a > 0) && (b > 0)) {
|
||||
test_beta(a, b, seed);
|
||||
}
|
||||
}
|
||||
|
||||
free(seed);
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user