void datamul_eye_tests(float32_t eps) {
float32_t errf;
uint64_t frames=4096;
uint32_t channels=16;
float32_t*inputdata;
float32_t*outputdata;
float32_t freq=500;
ambix_matrix_t eye = {0, 0, NULL};
STARTTEST("");
inputdata =data_sine(frames, channels, freq);
outputdata=(float32_t*)malloc(sizeof(float32_t)*frames*channels);
fail_if((NULL==outputdata), __LINE__, "couldn't mallocate outputdata");
ambix_matrix_init(channels, channels, &eye);
ambix_matrix_fill(&eye, AMBIX_MATRIX_IDENTITY);
fail_if(AMBIX_ERR_SUCCESS!=ambix_matrix_multiply_float32(outputdata, &eye, inputdata, frames),
__LINE__, "data multilplication failed");
errf=data_diff(__LINE__, inputdata, outputdata, frames*channels, eps);
fail_if(!(errf<eps), __LINE__, "diffing data multiplication returned %f (>%f)", errf, eps);
#if 0
printf("matrix:\n"); matrix_print(&eye);
printf("input :\n"); data_print(inputdata, frames*channels);
printf("output:\n"); data_print(outputdata,frames*channels);
#endif
free(inputdata);
free(outputdata);
ambix_matrix_deinit(&eye);
}
void datamul_tests(float32_t eps) {
float32_t errf;
float32_t*resultdata = (float32_t*)calloc(2*4, sizeof(float32_t));
float32_t*resultdataT = (float32_t*)calloc(4*2, sizeof(float32_t));
float32_t*inputdata = (float32_t*)calloc(2*3, sizeof(float32_t));
fail_if((NULL==resultdata), __LINE__, "couldn't callocate resultdata");
fail_if((NULL==resultdataT), __LINE__, "couldn't callocate resultdataT");
fail_if((NULL==inputdata), __LINE__, "couldn't callocate inputdata");
ambix_matrix_t*mtx=NULL;
STARTTEST("\n");
mtx=ambix_matrix_init(4, 3, NULL);
ambix_matrix_fill_data(mtx, leftdata_4_3);
data_transpose(inputdata, rightdata_3_2, 3, 2);
fail_if(AMBIX_ERR_SUCCESS!=ambix_matrix_multiply_float32(resultdata, mtx, inputdata, 2), __LINE__,
"data multiplication failed");
data_transpose(resultdataT, resultdata, 2, 4);
errf=data_diff(__LINE__, FLOAT32, resultdataT, resultdata_4_2, 4*2, eps);
if(errf>eps) {
printf("matrix:\n");
matrix_print(mtx);
printf("input:\n");
data_print(FLOAT32, inputdata, 3*2);
printf("expected:\n");
data_print(FLOAT32, resultdata_4_2, 4*2);
printf("calculated:\n");
data_print(FLOAT32, resultdataT , 4*2);
}
fail_if(!(errf<eps), __LINE__, "diffing data multiplication returned %f (>%f)", errf, eps);
#if 0
printf("matrix:\n");matrix_print(mtx);
printf("input :\n"); data_print(FLOAT32, rightdata_3_2, 3*2);
printf("output:\n"); data_print(FLOAT32, resultdata, 4*2);
printf("target:\n"); data_print(FLOAT32, resultdata_4_2, 4*2);
#endif
if(mtx)ambix_matrix_destroy(mtx);
free(resultdata);
free(resultdataT);
free(inputdata);
STOPTEST("\n");
}
void datamul_4_2_tests(uint32_t chunksize, float32_t eps) {
uint32_t r, c, rows, cols;
float32_t errf;
uint64_t frames=8;
uint32_t rawchannels=2;
uint32_t cokchannels=4;
float32_t*inputdata;
float32_t*outputdata;
float32_t*targetdata;
float32_t freq=500;
ambix_matrix_t eye = {0, 0, NULL};
STARTTEST("");
inputdata =data_sine(frames, rawchannels, freq);
targetdata=data_sine(frames, cokchannels, freq);
outputdata=(float32_t*)malloc(sizeof(float32_t)*frames*cokchannels);
fail_if((NULL==outputdata), __LINE__, "couldn't allocate outputdata");
ambix_matrix_init(cokchannels, rawchannels, &eye);
rows=eye.rows;
cols=eye.cols;
for(r=0; r<rows; r++) {
for(c=0; c<cols; c++) {
eye.data[r][c]=(1+r+c)%2;
}
}
#if 0
matrix_print(&eye);
printf("input\n");
data_print(inputdata, rawchannels*frames);
#endif
fail_if(AMBIX_ERR_SUCCESS!=ambix_matrix_multiply_float32(outputdata, &eye, inputdata, frames),
__LINE__, "data multilplication failed");
#if 0
printf("output\n");
data_print(outputdata, cokchannels*frames);
printf("target\n");
data_print(targetdata, cokchannels*frames);
#endif
errf=data_diff(__LINE__, targetdata, outputdata, frames*cokchannels, eps);
fail_if(!(errf<eps), __LINE__, "diffing data multiplication returned %f (>%f)", errf, eps);
#if 0
printf("matrix:\n"); matrix_print(&eye);
printf("input :\n"); data_print(inputdata, frames*channels);
printf("output:\n"); data_print(outputdata,frames*channels);
#endif
ambix_matrix_deinit(&eye);
free(inputdata);
free(outputdata);
free(targetdata);
}
