JJSierraM/squiggle.c
1
0
Fork 0
forked from personal/squiggle.c
Code Issues Pull Requests Packages Projects Releases Wiki Activity

add tests for normal & beta.

Browse Source
This commit is contained in:
NunoSempere 2023-07-23 14:00:14 +02:00
parent f65699a688
commit 95afb7ea1a
2 changed files with 154 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
test/test
View File

Binary file not shown.

200
test/test.c
View File

@ -4,43 +4,69 @@
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#define N 1000 * 1000 #define N 1000 * 1000
#define PERCENTAGE_TOLERANCE 1.0/1000.0 #define PERCENTAGE_TOLERANCE_UNIFORM 1.0/1000.0
#define PERCENTAGE_TOLERANCE_NORMAL 5.0/1000.0
#define MAX_NAME_LENGTH 500
void test_unit_uniform(uint64_t* seed){ // Structs
double* unit_uniform_array = malloc(sizeof(double) * N);
for(int i=0; i<N; i++){
unit_uniform_array[i] = sample_unit_uniform(seed);
}
double mean = array_mean(unit_uniform_array, N);
double expected_mean = 0.5;
double delta_mean = mean - expected_mean;
double std = array_std(unit_uniform_array, N); struct array_expectations {
double expected_std = sqrt(1.0/12.0); double* array;
double delta_std = std - expected_std; int n;
char* name;
printf("Mean of unit uniform: %f, vs expected mean: %f, delta: %f\n", mean, expected_mean, delta_mean); double expected_mean;
printf("Std of unit uniform: %f, vs expected std: %f, delta: %f\n", std, expected_std, delta_std); double expected_std;
double tolerance;
};
if(fabs(delta_mean) > PERCENTAGE_TOLERANCE){ void test_array_expectations(struct array_expectations e){
printf("[-] Mean test for unit uniform NOT passed.\n"); 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;
if(fabs(delta_mean) > e.tolerance){
printf("[-] Mean test for %s NOT passed.\n", e.name);
printf("Mean of %s: %f, vs expected mean: %f, delta: %f\n", e.name, mean, e.expected_mean, delta_mean);
}else { }else {
printf("[x] Mean test for unit uniform PASSED\n"); printf("[x] Mean test for %s PASSED\n", e.name);
} }
if(fabs(delta_std) > PERCENTAGE_TOLERANCE){ if(fabs(delta_std) > e.tolerance){
printf("[-] Std test for unit uniform NOT passed.\n"); printf("[-] Std test for %s NOT passed.\n", e.name);
printf("Std of %s: %f, vs expected std: %f, delta: %f\n", e.name, std, e.expected_std, delta_std);
}else { }else {
printf("[x] Std test for unit uniform PASSED\n"); printf("[x] Std test for %s PASSED\n", e.name);
} }
printf("\n"); printf("\n");
} }
// Test unit uniform
void test_unit_uniform(uint64_t* seed){
double* unit_uniform_array = malloc(sizeof(double) * N);
for(int i=0; i<N; i++){
unit_uniform_array[i] = sample_unit_uniform(seed);
}
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_UNIFORM,
};
test_array_expectations(expectations);
}
// Test uniforms
void test_uniform(double start, double end, uint64_t* seed){ void test_uniform(double start, double end, uint64_t* seed){
double* uniform_array = malloc(sizeof(double) * N); double* uniform_array = malloc(sizeof(double) * N);
@ -48,34 +74,86 @@ void test_uniform(double start, double end, uint64_t* seed){
uniform_array[i] = sample_uniform(start, end, seed); uniform_array[i] = sample_uniform(start, end, seed);
} }
double mean = array_mean(uniform_array, N); char* name = malloc(MAX_NAME_LENGTH * sizeof(char));
double expected_mean = (start + end) / 2; snprintf(name, MAX_NAME_LENGTH, "[%f, %f] uniform", start, end);
double delta_mean = mean - expected_mean; 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_UNIFORM,
};
test_array_expectations(expectations);
free(name);
}
// Test unit normal
void test_unit_normal(uint64_t* seed){
double* unit_normal_array = malloc(sizeof(double) * N);
double std = array_std(uniform_array, N); for(int i=0; i<N; i++){
double expected_std = sqrt(1.0/12.0) * fabs(end-start); unit_normal_array[i] = sample_unit_normal(seed);
double delta_std = std - expected_std;
double width = fabs(end - start);
if(fabs(delta_mean) > width * PERCENTAGE_TOLERANCE){
printf("[-] Mean test for [%.1f, %.1f] uniform NOT passed.\n", start, end);
printf("Mean of [%.1f, %.1f] uniform: %f, vs expected mean: %f, delta: %f\n", start, end, mean, expected_mean, mean - expected_mean);
}else {
printf("[x] Mean test for [%.1f, %.1f] uniform PASSED\n", start, end);
} }
if(fabs(delta_std) > width * PERCENTAGE_TOLERANCE){ struct array_expectations expectations = {
printf("[-] Std test for [%.1f, %.1f] uniform NOT passed.\n", start, end); .array = unit_normal_array,
printf("Std of [%.1f, %.1f] uniform: %f, vs expected std: %f, delta: %f\n", start, end, std, expected_std, std - expected_std); .n = N,
for(int i=0; i<10; i++){ .name = "unit normal",
.expected_mean = 0,
.expected_std = 1,
.tolerance = 1 * PERCENTAGE_TOLERANCE_NORMAL,
};
printf("%.1f, ", uniform_array[i]); test_array_expectations(expectations);
} }
}else {
printf("[x] Std test for [%.1f, %.1f] uniform PASSED\n", start, end); // Test normal
void test_normal(double mean, double std, uint64_t* seed){
double* normal_array = malloc(sizeof(double) * N);
for(int i=0; i<N; i++){
normal_array[i] = sample_normal(mean, std, seed);
} }
printf("\n");
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_NORMAL,
};
test_array_expectations(expectations);
free(name);
}
// Test beta
void test_beta(double a, double b, uint64_t* seed){
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_UNIFORM,
};
test_array_expectations(expectations);
free(name);
} }
int main(){ int main(){
@ -104,6 +182,36 @@ int main(){
} }
} }
printf("Testing unit normal\n");
test_unit_normal(seed);
printf("Testing small normals\n");
for(int i=0; i<100; i++){
double mean = sample_normal(-10, 10, seed);
double std = sample_normal(0, 10, seed);
if ( std > 0){
test_normal(mean, std, 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 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);
}
}
free(seed); free(seed);
} }