void create_tests(float32_t eps) {
int rows=4;
int cols=3;
int cols2=2;
ambix_matrix_t matrix, *left, *right;
STARTTEST("");
memset(&matrix, 0, sizeof(matrix));
left=ambix_matrix_create();
fail_if((left==NULL), __LINE__, "failed to create left matrix");
fail_if((left->rows || left->cols), __LINE__, "created empty matrix has non-zero size");
fail_if((left!=ambix_matrix_init(rows, cols, left)), __LINE__, "initializing existing matrix* returned new matrix");
fail_if((left->rows!=rows || left->cols!=cols), __LINE__, "created matrix [%dx%d] does not match [%dx%d]", left->rows, left->cols, cols, cols2);
right=ambix_matrix_init(cols, cols2, NULL);
fail_if((right==NULL), __LINE__, "failed to create right matrix");
fail_if((right->rows!=cols || right->cols!=cols2), __LINE__, "created matrix [%dx%d] does not match [%dx%d]", right->rows, right->cols, cols, cols2);
fail_if((&matrix!=ambix_matrix_init(rows, cols2, &matrix)), __LINE__, "initializing existing matrix returned new matrix");
fail_if((matrix.rows!=rows || matrix.cols!=cols2), __LINE__, "initialized matrix [%dx%d] does not match [%dx%d]", matrix.rows, matrix.cols, rows, cols2);
ambix_matrix_deinit(&matrix);
fail_if((matrix.rows || matrix.cols), __LINE__, "deinitialized matrix is non-zero");
ambix_matrix_deinit(left);
fail_if((left->rows || left->cols), __LINE__, "deinitialized matrix is non-zero");
ambix_matrix_destroy(left);
ambix_matrix_destroy(right);
}
void mtx_copy(float32_t eps) {
float32_t errf;
ambix_matrix_t *left=NULL, *right=NULL;
unsigned int i;
float32_t maxeps=eps;
STARTTEST("\n");
right=ambix_matrix_copy(left, NULL);
fail_if((NULL!=right), __LINE__, "copying from NULL matrix erroneously succeeded");
left=ambix_matrix_create();
fail_if((left !=ambix_matrix_init(4, 3, left )), __LINE__, "initializing left matrix failed");
ambix_matrix_fill_data(left, leftdata_4_3);
right=ambix_matrix_copy(left, NULL);
fail_if((NULL==right), __LINE__, "copying to NULL matrix failed");
errf=matrix_diff(__LINE__, left, right, eps);
fail_if(errf>0.f, __LINE__, "diffing mtx with copy0 returned %g (>%g)", errf, 0.f);
right=ambix_matrix_copy(left, right);
fail_if((NULL==right), __LINE__, "copying to right matrix failed");
errf=matrix_diff(__LINE__, left, right, eps);
fail_if(errf>0.f, __LINE__, "diffing mtx with copy returned %g (>%g)", errf, 0.f);
ambix_matrix_destroy(left);
ambix_matrix_destroy(right);
STOPTEST("\n");
}
void mtx_diff(float32_t eps) {
float32_t errf;
ambix_matrix_t *left=NULL, *right=NULL;
unsigned int i;
const unsigned int rows=4;
const unsigned int cols=3;
float32_t*leftdata=leftdata_4_3;
float32_t*rightdata=malloc(sizeof(leftdata_4_3));
float32_t maxeps=eps;
STARTTEST("\n");
left=ambix_matrix_create();
right=ambix_matrix_create();
/* comparisons:
- failing tests:
- different dimensions
- left/right matrix is NULL
- non-failing tests:
- all values diff==0
- all values diff<eps
- few values diff<eps
- many values diff<eps
*/
fail_if((left !=ambix_matrix_init(3, 4, left )), __LINE__, "initializing left matrix failed");
fail_if((right!=ambix_matrix_init(3, 4, right)), __LINE__, "initializing right matrix failed");
/* compare equal matrices */
STARTTEST("ident\n");
ambix_matrix_fill_data(left, leftdata);
errf=matrix_diff(__LINE__, left, left, eps);
fail_if(errf>0.f, __LINE__, "diffing mtx with itself returned %g (>%g)", errf, 0.f);
/* compare equal matrices */
STARTTEST("equal\n");
for(i=0; i<rows*cols; i++) {
rightdata[i]=leftdata[i];
}
ambix_matrix_fill_data(left , leftdata);
ambix_matrix_fill_data(right, rightdata);
errf=matrix_diff(__LINE__, left, right, eps);
fail_if(errf>0.f, __LINE__, "diffing mtx with copy returned %g (>%g)", errf, 0.f);
/* compare matrices where all values differ, but <eps */
STARTTEST("all<eps\n");
for(i=0; i<rows*cols; i++) {
rightdata[i]=leftdata[i]+eps*0.5;
}
ambix_matrix_fill_data(left , leftdata);
ambix_matrix_fill_data(right, rightdata);
errf=matrix_diff(__LINE__, left, right, eps);
fail_if(errf>eps, __LINE__, "diffing mtx with mtx+eps/2 returned %g (>%g)", errf, eps);
for(i=0; i<rows*cols; i++) {
rightdata[i]=leftdata[i]-eps*0.5;
}
ambix_matrix_fill_data(left , leftdata);
ambix_matrix_fill_data(right, rightdata);
errf=matrix_diff(__LINE__, left, right, eps);
fail_if(errf>eps, __LINE__, "diffing mtx with mtx-eps/2 returned %g (>%g)", errf, eps);
/* compare matrices where many values differ with <eps; but one with >eps */
STARTTEST("most<eps;one>eps\n");
for(i=0; i<rows*cols; i++) {
rightdata[i]=leftdata[i];
}
for(i=0; i<rows; i++) {
rightdata[i]=leftdata[i]+eps*0.5;
}
rightdata[0]=leftdata[0]+eps*1.5;
ambix_matrix_fill_data(left , leftdata);
ambix_matrix_fill_data(right, rightdata);
errf=matrix_diff(__LINE__, left, right, eps);
fail_if(errf>(eps*2.0), __LINE__, "diffing mtx with one value>eps returned %g (>%g)", errf, eps);
fail_if(errf<(eps*1.0), __LINE__, "diffing mtx with one value>eps returned %g (>%g)", errf, eps);
/* compare matrices where most values differ with >eps */
STARTTEST("most>eps\n");
for(i=0; i<rows*cols; i++) {
rightdata[i]=leftdata[i];
}
maxeps=eps*1.5;
for(i=0; i<(rows*cols)-1; i++) {
rightdata[i]=leftdata[i]-maxeps;
}
ambix_matrix_fill_data(left , leftdata);
ambix_matrix_fill_data(right, rightdata);
errf=matrix_diff(__LINE__, left, right, eps);
fail_if(errf<eps*1.0, __LINE__, "diffing mtx with one value>eps returned %g (<%g)", errf, eps*1.0);
fail_if(errf>eps*2.0, __LINE__, "diffing mtx with one value>eps returned %g (<%g)", errf, eps*2.0);
ambix_matrix_destroy(left);
ambix_matrix_destroy(right);
free(rightdata);
STOPTEST("\n");
}
