void mtxmul_eye_tests(float32_t eps) {
float32_t errf;
ambix_matrix_t *left, *result, *eye;
STARTTEST("");
eye=ambix_matrix_init(4, 4, NULL);
fail_if((eye!=ambix_matrix_fill(eye, AMBIX_MATRIX_IDENTITY)), __LINE__, "filling unity matrix %p did not return original matrix %p", eye);
left=ambix_matrix_init(4, 2, NULL);
fail_if(AMBIX_ERR_SUCCESS!=ambix_matrix_fill_data(left, resultdata_4_2), __LINE__,
"filling left data failed");
result=ambix_matrix_init(4, 2, NULL);
fail_if(AMBIX_ERR_SUCCESS!=ambix_matrix_fill_data(result, resultdata_4_2), __LINE__,
"filling result data failed");
fail_if((result!=ambix_matrix_multiply(eye, left, result)), __LINE__, "multiplication into matrix did not return original matrix");
#if 0
matrix_print(eye);
matrix_print(result);
matrix_print(left);
#endif
errf=matrix_diff(__LINE__, left, result, eps);
fail_if((errf>eps), __LINE__, "diffing matrix M with E*M returned %f (>%f)", errf, eps);
ambix_matrix_destroy(left);
ambix_matrix_destroy(result);
ambix_matrix_destroy(eye);
}
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 mtxmul_tests(float32_t eps) {
float32_t errf;
ambix_matrix_t *left=NULL, *right=NULL, *result, *testresult;
STARTTEST("\n");
/* fill in some test data */
left=ambix_matrix_init(4, 3, NULL);
ambix_matrix_fill_data(left, leftdata_4_3);
right=ambix_matrix_init(3, 2, NULL);
ambix_matrix_fill_data(right, rightdata_3_2);
testresult=ambix_matrix_init(4, 2, NULL);
ambix_matrix_fill_data(testresult, resultdata_4_2);
errf=matrix_diff(__LINE__, left, left, eps);
fail_if(!(errf<eps), __LINE__, "diffing matrix with itself returned %f (>%f)", errf, eps);
/* NULL multiplications */
result=ambix_matrix_multiply(NULL, NULL, NULL);
fail_if(NULL!=result, __LINE__, "multiplying NULL*NULL returned success");
result=ambix_matrix_multiply(left, NULL, result);
fail_if(NULL!=result, __LINE__, "multiplying left*NULL returned success");
result=ambix_matrix_multiply(NULL, left, result);
fail_if(NULL!=result, __LINE__, "multiplying NULL*left returned success");
/* do some matrix multiplication */
result=ambix_matrix_multiply(left, right, NULL);
fail_if((NULL==result), __LINE__, "multiply into NULL did not create matrix");
fail_if((result!=ambix_matrix_multiply(left, right, result)), __LINE__, "multiply into existing matrix returned new matrix");
#if 0
matrix_print(left);
matrix_print(right);
matrix_print(result);
printf("------------\n");
#endif
errf=matrix_diff(__LINE__, testresult, result, eps);
fail_if((errf>eps), __LINE__, "diffing two results of same multiplication returned %f (>%f)", errf, eps);
ambix_matrix_destroy(left);
ambix_matrix_destroy(right);
ambix_matrix_destroy(result);
ambix_matrix_destroy(testresult);
STOPTEST("\n");
}
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");
}
int test_datamatrix(const char*name, uint32_t rows, uint32_t cols, float32_t*data,
uint32_t xtrachannels, uint32_t chunksize, float32_t eps) {
int result=0;
ambix_matrix_t*mtx=0;
STARTTEST("%s\n", name);
mtx=ambix_matrix_init(rows,cols,mtx);
if(!mtx)return 1;
ambix_matrix_fill_data(mtx, data);
result=check_create_b2e(FILENAME_FILE, AMBIX_SAMPLEFORMAT_PCM16,
mtx,xtrachannels,
chunksize, FLOAT32, eps);
ambix_matrix_destroy(mtx);
return result;
}
static ambix_matrix_t*matrix_read(const char*path, ambix_matrix_t*matrix) {
SF_INFO info;
uint32_t rows, cols;
float*data=NULL;
ambix_matrix_t*mtx=NULL, *result=NULL;
uint32_t frames;
memset(&info, 0, sizeof(info));
SNDFILE*file=sf_open(path, SFM_READ, &info);
if(!file) {
fprintf(stderr, "ambix_interleave: matrix open failed '%s'\n", path);
return NULL;
}
rows=info.channels;
cols=info.frames;
data=(float*)malloc(rows*cols*sizeof(float));
frames=sf_readf_float(file, data, cols);
if(cols!=frames) {
fprintf(stderr, "ambix_interleave: matrix reading %d frames returned %d\n", frames, cols);
goto cleanup;
}
mtx=ambix_matrix_init(cols, rows, NULL);
if(mtx && (AMBIX_ERR_SUCCESS==ambix_matrix_fill_data(mtx, data))) {
uint32_t r, c;
matrix=ambix_matrix_init(rows, cols, matrix);
for(r=0; r<rows; r++)
for(c=0; c<cols; c++)
matrix->data[r][c]=mtx->data[c][r];
}
result=matrix;
// fprintf(stderr, "ambix_interleave: matrices not yet supported\n");
cleanup:
if(mtx)
ambix_matrix_destroy(mtx);
sf_close(file);
free(data);
return result;
}
ambix_err_t
ambix_matrix_fill_data_transposed(ambix_matrix_t*mtx, const float32_t*data, int byteswap) {
ambix_err_t err=AMBIX_ERR_SUCCESS;
ambix_matrix_t*xtm=ambix_matrix_init(mtx->cols, mtx->rows, NULL);
if(!xtm)
return AMBIX_ERR_UNKNOWN;
if(byteswap)
err=_ambix_matrix_fill_data_byteswapped(xtm, (const number32_t*)data);
else
err=ambix_matrix_fill_data(xtm, data);
if(AMBIX_ERR_SUCCESS==err) {
ambix_matrix_t*resu=ambix_matrix_transpose(mtx, xtm);
if(!resu)
err=AMBIX_ERR_UNKNOWN;
}
ambix_matrix_destroy(xtm);
return err;
}
static void ambix_write_matrix(t_ambix_write *x, t_symbol*s, int argc, t_atom*argv) {
int rows, cols;
float32_t*data=NULL;
int count;
if(x->x_matrix)
ambix_matrix_destroy(x->x_matrix);
x->x_matrix=NULL;
if(argc>=2) {
rows=atom_getint(argv+0);
cols=atom_getint(argv+1);
argc-=2;
argv+=2;
} else {
pd_error(x, "invalid matrix message");
return;
}
if(argc!=rows*cols) {
pd_error(x, "invalid matrix");
return;
}
data=(float32_t*)malloc(rows*cols*sizeof(float32_t));
for(count=0; count<argc; count++) {
data[count]=atom_getfloat(argv+count);
}
x->x_matrix=ambix_matrix_init(rows, cols, x->x_matrix);
if(AMBIX_ERR_SUCCESS!=ambix_matrix_fill_data(x->x_matrix, data)) {
pd_error(x, "invalid matrix data [%dx%d]=%p", rows, cols, data);
if(x->x_matrix)
ambix_matrix_destroy(x->x_matrix);
x->x_matrix=NULL;
}
free(data);
if(x->x_matrix)
printmatrix(x->x_matrix);
}
ambix_matrix_t*
_ambix_uuid1_to_matrix(const void*vdata, uint64_t datasize, ambix_matrix_t*orgmtx, int swap) {
const char*cdata=(const char*)vdata;
ambix_matrix_t*mtx=orgmtx;
uint32_t rows;
uint32_t cols;
uint64_t size;
uint32_t index;
if(datasize<(sizeof(rows)+sizeof(cols)))
return NULL;
index = 0;
memcpy(&rows, cdata+index, sizeof(uint32_t));
index += sizeof(uint32_t);
memcpy(&cols, cdata+index, sizeof(uint32_t));
index += sizeof(uint32_t);
if(swap) {
rows=swap4(rows);
cols=swap4(cols);
}
size=rows*cols;
if(rows<1 || cols<1 || size < 1)
goto cleanup;
if(size*sizeof(float32_t) > datasize) {
goto cleanup;
}
if(!mtx) {
mtx=(ambix_matrix_t*)calloc(1, sizeof(ambix_matrix_t));
if(!mtx)
goto cleanup;
}
if(!ambix_matrix_init(rows, cols, mtx))
goto cleanup;
if(swap) {
if(_ambix_matrix_fill_data_byteswapped(mtx, (number32_t*)(cdata+index)) != AMBIX_ERR_SUCCESS)
goto cleanup;
} else {
if(ambix_matrix_fill_data(mtx, (float32_t*)(cdata+index)) != AMBIX_ERR_SUCCESS)
goto cleanup;
}
return mtx;
cleanup:
if(mtx && mtx!=orgmtx) {
ambix_matrix_deinit(mtx);
free(mtx);
mtx=NULL;
}
return NULL;
}
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");
}
void mtxinverse_tests(float32_t eps) {
float32_t errf;
ambix_matrix_t *mtx=0, *testresult=0;
float32_t*transposedata = (float32_t*)calloc(3*4, sizeof(float32_t));
STARTTEST("\n");
/* fill in some test data 4x4 */
STARTTEST("[4x4]\n");
mtx=ambix_matrix_init(4, 4, mtx);
ambix_matrix_fill_data(mtx, leftdata_4_4);
testresult=ambix_matrix_init(4, 4, testresult);
ambix_matrix_fill_data(testresult, resultpinv_4_4);
mtxinverse_test(mtx, testresult, eps);
/* fill in some test data 4x3 */
STARTTEST("[4x3]\n");
mtx=ambix_matrix_init(4, 3, mtx);
ambix_matrix_fill_data(mtx, leftdata_4_3);
testresult=ambix_matrix_init(3, 4, testresult);
ambix_matrix_fill_data(testresult, resultpinv_4_3);
mtxinverse_test(mtx, testresult, eps);
/* fill in some test data 3x4 */
STARTTEST("[3x4]\n");
data_transpose(transposedata, leftdata_4_3, 4, 3);
mtx=ambix_matrix_init(3, 4, mtx);
ambix_matrix_fill_data(mtx, transposedata);
data_transpose(transposedata, resultpinv_4_3, 3, 4);
testresult=ambix_matrix_init(4, 3, testresult);
ambix_matrix_fill_data(testresult, transposedata);
mtxinverse_test(mtx, testresult, eps);
/* fill in some test data 4x4 */
STARTTEST("[identity:4x4]\n");
mtx=ambix_matrix_init(4, 4, mtx);
ambix_matrix_fill(mtx, AMBIX_MATRIX_IDENTITY);
testresult=ambix_matrix_init(4, 4, testresult);
ambix_matrix_fill(testresult, AMBIX_MATRIX_IDENTITY);
mtxinverse_test(mtx, testresult, eps);
STARTTEST("[one:4x4]\n");
mtx=ambix_matrix_init(4, 4, mtx);
ambix_matrix_fill(mtx, AMBIX_MATRIX_ONE);
mtxinverse_test(mtx, NULL, eps);
STARTTEST("[zero:4x4]\n");
mtx=ambix_matrix_init(4, 4, mtx);
ambix_matrix_fill(mtx, AMBIX_MATRIX_ZERO);
mtxinverse_test(mtx, NULL, eps);
STARTTEST("[SID:4x4]\n");
mtx=ambix_matrix_init(4, 4, mtx);
ambix_matrix_fill(mtx, AMBIX_MATRIX_SID);
testresult=ambix_matrix_init(4, 4, testresult);
ambix_matrix_fill(testresult, AMBIX_MATRIX_TO_SID);
mtxinverse_test(mtx, testresult, eps);
STARTTEST("[N3D:4x4]\n");
mtx=ambix_matrix_init(4, 4, mtx);
ambix_matrix_fill(mtx, AMBIX_MATRIX_N3D);
testresult=ambix_matrix_init(4, 4, testresult);
ambix_matrix_fill(testresult, AMBIX_MATRIX_TO_N3D);
mtxinverse_test(mtx, testresult, eps);
STARTTEST("[FUMA:4x4]\n");
mtx=ambix_matrix_init(4, 4, mtx);
ambix_matrix_fill(mtx, AMBIX_MATRIX_FUMA);
testresult=ambix_matrix_init(4, 4, testresult);
ambix_matrix_fill(testresult, AMBIX_MATRIX_TO_FUMA);
mtxinverse_test(mtx, testresult, eps);
ambix_matrix_destroy(mtx);
ambix_matrix_destroy(testresult);
free(transposedata);
STOPTEST("\n");
}
