void mu_test_sort()
{
my_t n1 = {{{2}, {3}}, 1};
my_t n2 = {{{10}, {6}}, 2};
my_t n3 = {{{11}, {34}}, 2};
my_t n4 = {{{1}, {33}}, 3};
list_t list;
list_init(&list);
// 2 -> 1 -> 3 -> 2
list_push_back(&n2.link, &list);
list_push_back(&n1.link, &list);
list_push_back(&n4.link, &list);
list_push_back(&n3.link, &list);
mu_check(list_front(&list) == &n2.link);
mu_check(list_next(&n2.link) == &n1.link);
mu_check(list_next(&n1.link) == &n4.link);
mu_check(list_next(&n4.link) == &n3.link);
mu_check(list_back(&list) == &n3.link);
puts("pre sort:");
print(list_first(&n1.link));
list_sort(&list, my_cmp);
mu_check(list_front(&list) == &n1.link);
mu_check(list_next(&n1.link) == &n2.link);
mu_check(list_next(&n2.link) == &n3.link);
mu_check(list_next(&n3.link) == &n4.link);
mu_check(list_back(&list) == &n4.link);
puts("post sort:");
print(list_first(&n1.link));
}
inline void check_bitbuffer_invariants(bitbuffer b) {
// check the position in the buffer plus the remaining bytes
// is the end of the buffer
mu_check(b.buffer_origin + (b.buflen_max - b.remaining_bytes) == b.buffer);
// check that the head_offset is between 0 and 7
mu_check(b.head_offset >= 0);
mu_check(b.head_offset <= 7);
}
int test_crossover_config_new_and_destroy(void)
{
float uninit = -1.0f;
struct crossover_config *cc = crossover_config_new(0);
mu_check(cc->method == 0);
mu_check(fltcmp(&cc->probability, &uninit) == 0);
crossover_config_destroy(cc);
return 0;
}
int test_stack_new_and_destroy(void)
{
struct stack *s = stack_new();
mu_check(s->size == 0);
mu_check(s->root == NULL);
mu_check(s->end == NULL);
stack_destroy(s, free);
return 0;
}
void mu_test_bitbuffer_init_free_heap() {
size_t size = sizeof(char) * 100;
bitbuffer b;
bitbuffer_init(&b, size);
mu_check(b.buflen_max == size);
check_bitbuffer_invariants(b);
mu_check(b.buffer_controlled);
bitbuffer_free(&b);
}
void mu_test_bitbuffer_init_free_stack() {
size_t size = sizeof(char) * 100;
char buff[size];
bitbuffer b;
bitbuffer_init_from_buffer(&b, buff, size);
mu_check(b.buflen_max == size);
mu_check(b.buffer == buff);
mu_check(!b.buffer_controlled);
check_bitbuffer_invariants(b);
bitbuffer_free(&b);
}
void mu_test_sml_queue()
{
sml_queue_t head;
sml_queue_init(&head);
sml_queue_t *q;
for(int i=0; i < 40; i++) {
node *val= (node *)malloc(sizeof(node));
val->data = i;
if(i & 1) {
sml_queue_insert_tail(&head, &(val->q));
}
else {
sml_queue_insert_head(&head, &(val->q));
}
}
q = sml_queue_first(&head);
int j = 38, k = 1;
while(q != sml_queue_head(&head)) {
node *val = sml_queue_data(q, node, q);
mu_check(val->data == j);
//printf("%d ", val->data);
if(j == 0) break;
j -= 2;
q = sml_queue_next(q);
}
q = sml_queue_next(q);
while(q != sml_queue_head(&head)) {
node *val = sml_queue_data(q, node, q);
mu_check(val->data == k);
//printf("%d ", val->data);
k += 2;
q = sml_queue_next(q);
}
sml_queue_sort(&head, cmp);
q = sml_queue_first(&head);
j = 0;
while(q != sml_queue_head(&head)) {
node *val = sml_queue_data(q, node, q);
mu_check(val->data == j);
j++;
//printf("%d ", val->data);
q = sml_queue_next(q);
}
q = sml_queue_first(&head);
while(q != sml_queue_head(&head)) {
node *val = sml_queue_data(q, node, q);
free(val);
q = sml_queue_next(q);
}
}
int test_crossover_config_new_and_destroy(void)
{
float uninit = -1.0f;
struct crossover_config *cc;
/* setup */
cc = crossover_config_new();
/* assert */
mu_check(cc->methods == NULL);
mu_check(fltcmp(cc->probability, uninit) == 0);
/* clean up */
crossover_config_destroy(cc);
return 0;
}
void mu_test_bitbuffer_advance_sequential() {
size_t numchars = 10;
bitbuffer b;
for (size_t step = 1; step < numchars; step++) {
bitbuffer_init(&b, sizeof(char) * numchars);
int i;
for (i = 0; i < (int)numchars; i += step) {
mu_check(b.buffer - b.buffer_origin == i / 8);
bitbuffer_advance(&b, step);
check_bitbuffer_invariants(b);
}
mu_check(b.buffer - b.buffer_origin == i / 8);
bitbuffer_free(&b);
}
}
int test_regression_evaluate(void)
{
int i;
int res;
float f = 100.0;
float **func_input;
float solution_score = 5.0;
struct tree *t;
struct node **chromosome = malloc(sizeof(struct node *) * 5);
struct data *d = csv_load_data(TEST_DATA, 1, ",");
/* initialize func_input */
func_input = malloc(sizeof(float *) * 2);
for (i = 0; i < 2; i++) {
func_input[i] = malloc(sizeof(float) * (unsigned long) d->rows);
}
/* build chromosome */
chromosome[0] = node_new_constant(FLOAT, &f);
chromosome[1] = node_new_input((char *) "x");
chromosome[2] = node_new_func(MUL, 2);
chromosome[3] = node_new_func(RAD, 1);
chromosome[4] = node_new_func(SIN, 1);
/* build tree */
t = malloc(sizeof(struct tree));
t->root = NULL;
t->size = 5;
t->depth = -1;
t->score = NULL;
t->chromosome = chromosome;
/* evaluate tree */
res = regression_evaluate(t, func_input, d, (char *) "y");
mu_check(res == 0);
mu_check(fltcmp(t->score, &solution_score) == 0);
mu_check(t->hits == 361);
/* clean up */
free_chromosome(chromosome, 5);
tree_destroy(t);
data_destroy(d);
free_mem_arr(func_input, 2, free);
return 0;
}
void mu_test_sml_random_combined() {
sml_combined_random_init((unsigned int)time(NULL));
int cas = 30, n = 2000;
while(cas--) {
double v = x2cal(n, sml_combined_random_int);
mu_check(v < 15.09 && v > 0.5543);
n += 2000;
}
}
int test_function_max_arity(void)
{
int max_arity;
setup_function_set();
max_arity = function_max_arity(fs);
mu_check(max_arity == 2);
teardown_function_set();
return 0;
}
int test_function_arity(void)
{
int arity;
setup_function_set();
arity = function_arity(0, fs);
mu_check(arity == 2);
teardown_function_set();
return 0;
}
void
mu_test_options ()
{
struct balloon_options opts;
opts.m_cost = 0;
opts.t_cost = 10000llu;
opts.n_neighbors = 1;
opts.comp_opts.comp = 0;
opts.comp_opts.comb = 0;
opts.mix = 0;
opts.n_threads = 1;
opts.m_cost = 1024;
mu_check ( !options_validate (&opts) );
opts.t_cost = 0;
mu_check ( !options_validate (&opts) );
opts.t_cost = 3;
opts.n_neighbors = 0;
mu_check ( options_validate (&opts) );
}
int test_function_set_new_and_destroy(void)
{
int i;
setup_function_set();
mu_check(fs != NULL);
for (i = 0; i < 9; i++) {
mu_print("function number: %d\t", fs->functions[i]->function);
mu_print("arity: %d\n", fs->functions[i]->arity);
}
teardown_function_set();
return 0;
}
void
mu_test_validate_parameters__saltlen ()
{
size_t outlen;
size_t inlen;
size_t saltlen;
outlen = 32;
inlen = 1024;
saltlen = 32;
mu_check ( validate_parameters (outlen, inlen, saltlen) == 0 );
saltlen = 0;
mu_check ( validate_parameters (outlen, inlen, saltlen) == ERROR_SALTLEN_TOO_SMALL );
saltlen = SALTLEN_MIN - 1;
mu_check ( validate_parameters (outlen, inlen, saltlen) == ERROR_SALTLEN_TOO_SMALL );
saltlen = 1 << 24;
mu_check ( validate_parameters (outlen, inlen, saltlen) == ERROR_SALTLEN_TOO_BIG);
saltlen = SALTLEN_MAX;
mu_check ( validate_parameters (outlen, inlen, saltlen) == ERROR_SALTLEN_TOO_BIG);
}
int test_evolve_new_and_destroy(void)
{
struct config *c = config_new();
float solution = -1.0f;
mu_check(c->max_generations == -1);
mu_check(c->population_size == -1);
mu_check(c->population_generator == NULL);
mu_check(c->stale_limit == -1);
mu_check(fltcmp(&c->target_score, &solution) == 0);
mu_check(c->data_struct == NULL);
mu_check(c->selection == NULL);
mu_check(c->crossover == NULL);
mu_check(c->mutation == NULL);
config_destroy(c);
return 0;
}
int test_function_new_and_destroy(void)
{
f = function_new(DEFAULT, 0, 2);
mu_check(f->type == DEFAULT);
mu_check(f->function == 0);
mu_check(f->arity == 2);
function_destroy(f);
/* default function */
f = function_new_func(0, 2);
mu_check(f->type == DEFAULT);
mu_check(f->function == 0);
mu_check(f->arity == 2);
function_destroy(f);
/* classification function */
f = function_new_cfunc(0, 2);
mu_check(f->type == CLASSIFICATION);
mu_check(f->function == 0);
mu_check(f->arity == 2);
function_destroy(f);
return 0;
}
void mu_test_bitbuffer_writeblock() {
bitbuffer b;
#define WRITEBLOCK_BUFLEN_BYTES 21
char buff[WRITEBLOCK_BUFLEN_BYTES] = "this is a test array";
for (size_t i = 1; i <= WRITEBLOCK_BUFLEN_BYTES * 8; i++) {
bitbuffer_init(&b, WRITEBLOCK_BUFLEN_BYTES);
memset(b.buffer_origin, 1, WRITEBIT_BUFLEN_BYTES);
bitbuffer_writeblock(&b, buff, i);
mu_check(0 == memcmp_bits(buff, b.buffer_origin, i));
bitbuffer_free(&b);
check_bitbuffer_location(b, i);
check_bitbuffer_invariants(b);
}
}
void mu_test_bitbuffer_pop() {
bitbuffer b;
#define POP_BUFLEN_BYTES 21
// initialize the destination buffers to prevent valgrind
// from complaining becase it doesn't understand bitshifts
char buff[POP_BUFLEN_BYTES] = "this is a test array";
char dest[POP_BUFLEN_BYTES] = " ";
for (size_t c = 0; c < POP_BUFLEN_BYTES * 8; c++) {
bitbuffer_init_from_buffer(&b, (char *)&buff, POP_BUFLEN_BYTES);
bitbuffer_pop(&dest, &b, c);
mu_check(0 == memcmp_bits(buff, dest, c + 1));
check_bitbuffer_invariants(b);
check_bitbuffer_location(b, c);
bitbuffer_free(&b);
};
}
void mu_test_bitbuffer_writebit() {
bitbuffer b;
#define WRITEBIT_BUFLEN_BYTES 21
// initialize the destination buffers to prevent valgrind
// from complaining becase it doesn't understand bitshifts
char buff[WRITEBIT_BUFLEN_BYTES] = "this is a test array";
char dest[WRITEBIT_BUFLEN_BYTES] = " ";
bitbuffer_init_from_buffer(&b, dest, WRITEBIT_BUFLEN_BYTES);
for (size_t i = 0; i < WRITEBIT_BUFLEN_BYTES * 8; i++) {
bitbuffer_writebit(&b, (buff[i / 8] >> (7 - i % 8)) & 1);
mu_check(0 == memcmp_bits(buff, dest, i + 1));
check_bitbuffer_invariants(b);
check_bitbuffer_location(b, i + 1);
}
bitbuffer_free(&b);
}
void mu_test_bitbuffer_next() {
bitbuffer b;
char buff[] = "this is a test array";
bitbuffer_init_from_buffer(&b, (char *)&buff, strlen(buff));
for (int c = 0; c < (int)strlen(buff); c++) {
for (int i = 7; i >= 0; i--) {
bool next = bitbuffer_next(&b);
bool expected_next = ((buff[c] >> i) & 1);
// mu_print(MU_SUITE, "%d %d : %d == %d\n",
// c, i, next, expected_next);
mu_check(next == expected_next);
// one greater than current because we already advanced
// past current
check_bitbuffer_location(b, c * 8 + (8 - i));
check_bitbuffer_invariants(b);
}
}
bitbuffer_free(&b);
}
int test_regression_func_input(void)
{
int i;
int res;
float f = 100.0;
float *f_arr;
float **func_input;
struct data *d = csv_load_data(TEST_DATA, 1, ",");
struct node **stack = malloc(sizeof(struct node *) * 4);
/* malloc func_input */
func_input = malloc(sizeof(float *) * 2);
for (i = 0; i < 2; i++) {
func_input[i] = malloc(sizeof(float) * (unsigned long) d->rows);
}
/* initialize float array */
f_arr = malloc(sizeof(float) * (unsigned long) d->rows);
for (i = 0; i < d->rows; i++) {
f_arr[i] = (float) i;
}
/* create stack */
stack[0] = node_new_input((char *) "x");
stack[1] = node_new_input((char *) "y");
stack[2] = node_new_constant(FLOAT, &f);
stack[3] = node_new_eval(FLOAT, (void *) f_arr, d->rows);
/* input node - x */
regression_func_input(stack[0], d, func_input, 0);
for (i = 0; i < d->rows; i++) {
res = fltcmp(&func_input[0][i], d->data[data_field_index(d, "x")][i]);
mu_check(res == 0);
}
/* input node - y */
regression_func_input(stack[1], d, func_input, 1);
for (i = 0; i < d->rows; i++) {
res = fltcmp(&func_input[1][i], d->data[data_field_index(d, "y")][i]);
mu_check(res == 0);
}
/* constant node */
regression_func_input(stack[2], d, func_input, 0);
for (i = 0; i < d->rows; i++) {
res = fltcmp(&func_input[0][i], &f);
mu_check(res == 0);
}
/* eval node */
regression_func_input(stack[3], d, func_input, 0);
for (i = 0; i < d->rows; i++) {
f = (float) i;
res = fltcmp(&func_input[0][i], &f);
mu_check(res == 0);
}
/* clean up */
node_destroy(stack[0]);
node_destroy(stack[1]);
node_destroy(stack[2]);
node_destroy(stack[3]);
data_destroy(d);
free_mem_arr(func_input, 2, free);
free(stack);
return 0;
}
int test_stack_pop(void)
{
struct stack *s = stack_new();
float *f1 = malloc_float(2.0);
float *f2 = malloc_float(4.0);
float *f3 = malloc_float(8.0);
float *flt_ptr;
/* push float 1 */
stack_push(s, f1);
mu_check(fltcmp(s->end->value, f1) == 0);
mu_check(s->size == 1);
mu_check(s->root->value == f1);
mu_check(s->end->prev == NULL);
/* push float 2 */
stack_push(s, f2);
mu_check(fltcmp(s->end->value, f2) == 0);
mu_check(s->size == 2);
mu_check(s->root->value == f1);
mu_check(s->end->prev->value == f1);
mu_check(fltcmp(s->end->prev->value, f1) == 0);
/* push float 3 */
stack_push(s, f3);
mu_check(fltcmp(s->end->value, f3) == 0);
mu_check(s->size == 3);
mu_check(s->root->value == f1);
mu_check(s->end->prev->value == f2);
mu_check(fltcmp(s->end->prev->value, f2) == 0);
/* pop float 3 */
flt_ptr = stack_pop(s);
mu_check(fltcmp(flt_ptr, f3) == 0);
mu_check(s->size == 2);
mu_check(s->root->value == f1);
mu_check(fltcmp(s->root->value, f1) == 0);
free(flt_ptr);
/* pop float 2 */
flt_ptr = stack_pop(s);
mu_check(fltcmp(flt_ptr, f2) == 0);
mu_check(s->size == 1);
mu_check(s->root->value == f1);
mu_check(fltcmp(s->root->value, f1) == 0);
free(flt_ptr);
/* pop float 1 */
flt_ptr = stack_pop(s);
mu_check(fltcmp(flt_ptr, f1) == 0);
mu_check(s->size == 0);
mu_check(s->root == NULL);
mu_check(s->end == NULL);
free(flt_ptr);
stack_destroy(s, free);
return 0;
}
inline void check_bitbuffer_location(bitbuffer b, size_t bits) {
mu_check(bits == (size_t)(b.buffer - b.buffer_origin) * 8 + b.head_offset);
}
void mu_test_list()
{
my_t n1 = {{{0}, {0}}, 1};
my_t n2 = {{{0}, {0}}, 2};
my_t n3 = {{{0}, {0}}, 3};
my_t n4 = {{{0}, {0}}, 4};
my_t n5 = {{{0}, {0}}, 5};
my_t n6 = {{{0}, {0}}, 6};
list_t list;
list_init(&list);
// 5 -> 1
list_push_back(&n5.link, &list);
list_insert_after(&n5.link, &n1.link, &list);
mu_check( list_next(&n5.link) == &n1.link);
mu_check( list_last(&n5.link) == &n1.link);
mu_check( list_last(&n1.link) == &n1.link);
mu_check( list_first(&n1.link) == &n5.link);
// 5 -> 3 -> 1
list_insert_befor(&n1.link, &n3.link, &list);
mu_check( list_next(&n5.link) == &n3.link);
mu_check( list_last(&n5.link) == &n1.link);
mu_check( list_prev(&n1.link) == &n3.link);
mu_check( list_first(&n3.link) == &n5.link);
// 1 -> 3 -> 5
list_swap(&n5.link, &n1.link, &list);
mu_check( list_next(&n1.link) == &n3.link);
mu_check( list_last(&n1.link) == &n5.link);
mu_check( list_prev(&n5.link) == &n3.link);
mu_check( list_first(&n3.link) == &n1.link);
// 5 -> 3 -> 1
list_swap(&n5.link, &n1.link, &list);
mu_check( list_next(&n5.link) == &n3.link);
mu_check( list_last(&n5.link) == &n1.link);
mu_check( list_prev(&n1.link) == &n3.link);
mu_check( list_first(&n3.link) == &n5.link);
// 2 -> 5 -> 3 -> 1
list_push_front(&n2.link, &list);
mu_check( !list_prev(&n2.link));
mu_check( list_last(&n2.link) == &n1.link);
mu_check( list_prev(&n5.link) == &n2.link);
mu_check( list_first(&n3.link) == &n2.link);
// 2 -> 5 -> 3 -> 1 -> 4
list_push_back(&n4.link, &list);
print(list_first(&n2.link));
mu_check( !list_next(&n4.link));
mu_check( list_last(&n2.link) == &n4.link);
mu_check( list_prev(&n4.link) == &n1.link);
mu_check( list_next(&n1.link) == &n4.link);
mu_check( list_first(&n4.link) == &n2.link);
// 2 -> 5 -> 1 -> 4
list_remove(&n3.link, &list);
mu_check( list_next(&n5.link) == &n1.link);
mu_check( list_prev(&n1.link) == &n5.link);
// 2 -> 6 -> 1 -> 4
list_replace(&n5.link, &n6.link, &list);
mu_check( list_next(&n6.link) == &n1.link);
mu_check( list_prev(&n1.link) == &n6.link);
mu_check( list_prev(&n6.link) == &n2.link);
// 2 -> 1 -> 6 -> 4
list_swap(&n6.link, &n1.link, &list);
mu_check( list_next(&n1.link) == &n6.link);
mu_check( list_prev(&n6.link) == &n1.link);
mu_check( list_next(&n6.link) == &n4.link);
// 2 -> 6 -> 1 -> 4
list_swap(&n6.link, &n1.link, &list);
mu_check( list_next(&n6.link) == &n1.link);
mu_check( list_prev(&n1.link) == &n6.link);
mu_check( list_next(&n1.link) == &n4.link);
mu_check( list_prev(&n6.link) == &n2.link);
mu_check( list_front(&list) == &n2.link);
mu_check( list_back(&list) == &n4.link);
puts("pre sort:");
print(list_first(&n1.link));
list_sort(&list, my_cmp);
puts("post sort:");
print(list_first(&n1.link));
}
int test_regression_traverse(void)
{
int i;
int res;
float f1 = 1.0;
float f2 = 2.0;
float f3;
float *flt_ptr;
float zero = 0.0;
float **func_input;
struct node *result_node;
struct node **chromosome = malloc(sizeof(struct node *) * 3);
struct stack *stack = stack_new();
struct data *d = csv_load_data(TEST_DATA, 1, ",");
/* initialize func_input */
func_input = malloc(sizeof(float *) * 2);
for (i = 0; i < 2; i++) {
func_input[i] = malloc(sizeof(float) * (unsigned long) d->rows);
}
/* ADD */
chromosome[0] = node_new_constant(FLOAT, &f1);
chromosome[1] = node_new_constant(FLOAT, &f2);
chromosome[2] = node_new_func(ADD, 2);
res = regression_traverse(0, 2, chromosome, stack, func_input, d);
result_node = stack_pop(stack);
for (i = 0; i < d->rows; i++) {
f3 = f1 + f2;
flt_ptr = &((float *) result_node->values)[i];
mu_check(fltcmp(flt_ptr, &f3) == 0);
}
node_destroy(result_node);
free_chromosome(chromosome, 3);
/* SUB */
chromosome[0] = node_new_constant(FLOAT, &f1);
chromosome[1] = node_new_constant(FLOAT, &f2);
chromosome[2] = node_new_func(SUB, 2);
res = regression_traverse(0, 2, chromosome, stack, func_input, d);
result_node = stack_pop(stack);
for (i = 0; i < d->rows; i++) {
f3 = f1 - f2;
flt_ptr = &((float *) result_node->values)[i];
mu_check(fltcmp(flt_ptr, &f3) == 0);
}
node_destroy(result_node);
free_chromosome(chromosome, 3);
/* MUL */
chromosome[0] = node_new_constant(FLOAT, &f1);
chromosome[1] = node_new_constant(FLOAT, &f2);
chromosome[2] = node_new_func(MUL, 2);
res = regression_traverse(0, 2, chromosome, stack, func_input, d);
result_node = stack_pop(stack);
for (i = 0; i < d->rows; i++) {
f3 = f1 * f2;
flt_ptr = &((float *) result_node->values)[i];
mu_check(fltcmp(flt_ptr, &f3) == 0);
}
node_destroy(result_node);
free_chromosome(chromosome, 3);
/* DIV */
chromosome[0] = node_new_constant(FLOAT, &f1);
chromosome[1] = node_new_constant(FLOAT, &f2);
chromosome[2] = node_new_func(DIV, 2);
res = regression_traverse(0, 2, chromosome, stack, func_input, d);
result_node = stack_pop(stack);
for (i = 0; i < d->rows; i++) {
f3 = f1 / f2;
flt_ptr = &((float *) result_node->values)[i];
mu_check(fltcmp(flt_ptr, &f3) == 0);
}
node_destroy(result_node);
free_chromosome(chromosome, 3);
/* DIV - FAIL TEST - DIVIDE BY ZERO */
chromosome[0] = node_new_constant(FLOAT, &f1);
chromosome[1] = node_new_constant(FLOAT, &zero);
chromosome[2] = node_new_func(DIV, 2);
res = regression_traverse(0, 2, chromosome, stack, func_input, d);
mu_check(res == -1);
free_chromosome(chromosome, 3);
/* POW */
chromosome[0] = node_new_constant(FLOAT, &f1);
chromosome[1] = node_new_constant(FLOAT, &f2);
chromosome[2] = node_new_func(POW, 2);
res = regression_traverse(0, 2, chromosome, stack, func_input, d);
result_node = stack_pop(stack);
for (i = 0; i < d->rows; i++) {
f3 = (float) pow(f1, f2);
flt_ptr = &((float *) result_node->values)[i];
mu_check(fltcmp(flt_ptr, &f3) == 0);
}
node_destroy(result_node);
free_chromosome(chromosome, 3);
/* LOG */
chromosome[0] = node_new_constant(FLOAT, &f1);
chromosome[1] = node_new_func(LOG, 1);
res = regression_traverse(0, 1, chromosome, stack, func_input, d);
result_node = stack_pop(stack);
for (i = 0; i < d->rows; i++) {
f3 = (float) log(f1);
flt_ptr = &((float *) result_node->values)[i];
mu_check(fltcmp(flt_ptr, &f3) == 0);
}
node_destroy(result_node);
free_chromosome(chromosome, 2);
/* EXP */
chromosome[0] = node_new_constant(FLOAT, &f1);
chromosome[1] = node_new_func(EXP, 1);
res = regression_traverse(0, 1, chromosome, stack, func_input, d);
result_node = stack_pop(stack);
for (i = 0; i < d->rows; i++) {
f3 = (float) exp(f1);
flt_ptr = &((float *) result_node->values)[i];
mu_check(fltcmp(flt_ptr, &f3) == 0);
}
node_destroy(result_node);
free_chromosome(chromosome, 2);
/* RAD */
chromosome[0] = node_new_constant(FLOAT, &f1);
chromosome[1] = node_new_func(RAD, 1);
res = regression_traverse(0, 1, chromosome, stack, func_input, d);
result_node = stack_pop(stack);
for (i = 0; i < d->rows; i++) {
f3 = (float) f1 * (float) (PI / 180.0);
flt_ptr = &((float *) result_node->values)[i];
mu_check(fltcmp(flt_ptr, &f3) == 0);
}
node_destroy(result_node);
free_chromosome(chromosome, 2);
/* SIN */
chromosome[0] = node_new_constant(FLOAT, &f1);
chromosome[1] = node_new_func(SIN, 1);
res = regression_traverse(0, 1, chromosome, stack, func_input, d);
result_node = stack_pop(stack);
for (i = 0; i < d->rows; i++) {
f3 = (float) sin(f1);
flt_ptr = &((float *) result_node->values)[i];
mu_check(fltcmp(flt_ptr, &f3) == 0);
}
node_destroy(result_node);
free_chromosome(chromosome, 2);
/* COS */
chromosome[0] = node_new_constant(FLOAT, &f1);
chromosome[1] = node_new_func(COS, 1);
res = regression_traverse(0, 1, chromosome, stack, func_input, d);
result_node = stack_pop(stack);
for (i = 0; i < d->rows; i++) {
f3 = (float) cos(f1);
flt_ptr = &((float *) result_node->values)[i];
mu_check(fltcmp(flt_ptr, &f3) == 0);
}
node_destroy(result_node);
free_chromosome(chromosome, 2);
/* FAIL TEST - UNKNOWN FUNCTION */
chromosome[0] = node_new_constant(FLOAT, &f1);
chromosome[1] = node_new_func(99, 1);
res = regression_traverse(0, 1, chromosome, stack, func_input, d);
mu_check(res == -2);
free_chromosome(chromosome, 2);
/* clean up */
stack_destroy(stack, free);
free(chromosome);
data_destroy(d);
free_mem_arr(func_input, 2, free);
return 0;
}
