static D hypoth(D u,D v){D p,q,t; MMM(u,v); R INF(p)?inf:p?(t=q/p,p*sqrt(1+t*t)):0;}
int main(int argc, char **argv) {
///******************************************************
///********************** INPUT *************************
///******************************************************
if (argc != 4) {
std::cout << "Invalid number of arguments!" << std::endl;
std::cout << "./compare A.out B.out" << std::endl;
exit(EXIT_FAILURE);
}
//matrix dimensions
int dimM = 0;
int dimN = 0;
int dimO = 0;
//get dimensions
std::ifstream fIn(argv[1]);
if (!fIn) {
std::cout << "Error opening file: " << argv[1] << std::endl;
exit(EXIT_FAILURE);
}
if(!(fIn >> dimM >> dimN))
{
std::cout << "Error in reading matrix entries!" << std::endl;
exit(EXIT_FAILURE);
}
fIn.close();
fIn.open(argv[2]);
if (!fIn) {
std::cout << "Error opening file: " << argv[2] << std::endl;
exit(EXIT_FAILURE);
}
if(!(fIn >> dimN >> dimO))
{
std::cout << "Error in reading matrix entries!" << std::endl;
exit(EXIT_FAILURE);
}
fIn.close();
//calculate minimal matrix size
//all matrices are padded with 0s to this size
//should be power of 2 for efficient block division
//dirty hack...
LD = 64;
if (LD<dimM) LD = dimM;
if (LD<dimN) LD = dimN;
if (LD<dimO) LD = dimO;
LD--;
LD |= LD >> 1;
LD |= LD >> 2;
LD |= LD >> 4;
LD |= LD >> 8;
LD |= LD >> 16;
LD++;
//add useless padding
LD += PADDING;
double* a = (double*) aligned_alloc(ALIGNMENT, sizeof(double) * LD * LD);
double* b = (double*) aligned_alloc(ALIGNMENT, sizeof(double) * LD * LD);
double* c = (double*) aligned_alloc(ALIGNMENT, sizeof(double) * LD * LD);
Matrix A = loadMatrix(argv[1], &a[0]);
Matrix B = loadMatrix(argv[2], &b[0]);
Matrix C(&c[0], nullptr, A.getDimM(), B.getDimN(), 0, 0);
///******************************************************
///********************** CALCULATION *******************
///******************************************************
double time = 0;
#ifdef USE_LIKWID
likwid_markerInit();
likwid_markerStartRegion("dummy");
#endif
siwir::Timer timer;
MMM(A, B, C);
time = timer.elapsed();
std::cout << dimM << "\t" << dimN << "\t" << dimO << "\t" << time << std::endl;
#ifdef USE_LIKWID
likwid_markerStopRegion("dummy");
likwid_markerClose();
#endif
///******************************************************
///********************** OUTPUT ************************
///******************************************************
saveMatrix(argv[3], C);
free(a);
free(b);
free(c);
};
void
quat_mat2quat(register fastf_t *quat, register const fastf_t *mat)
{
fastf_t tr;
fastf_t s;
#define XX 0
#define YY 5
#define ZZ 10
#define MMM(a, b) mat[4*(a)+(b)]
tr = mat[XX] + mat[YY] + mat[ZZ];
if ( tr > 0.0 ) {
s = sqrt( tr + 1.0 );
quat[W] = s * 0.5;
s = 0.5 / s;
quat[X] = ( mat[6] - mat[9] ) * s;
quat[Y] = ( mat[8] - mat[2] ) * s;
quat[Z] = ( mat[1] - mat[4] ) * s;
return;
}
/* Find dominant element of primary diagonal */
if ( mat[YY] > mat[XX] ) {
if ( mat[ZZ] > mat[YY] ) {
s = sqrt( MMM(Z, Z) - (MMM(X, X)+MMM(Y, Y)) + 1.0 );
quat[Z] = s * 0.5;
s = 0.5 / s;
quat[W] = (MMM(X, Y) - MMM(Y, X)) * s;
quat[X] = (MMM(Z, X) + MMM(X, Z)) * s;
quat[Y] = (MMM(Z, Y) + MMM(Y, Z)) * s;
} else {
s = sqrt( MMM(Y, Y) - (MMM(Z, Z)+MMM(X, X)) + 1.0 );
quat[Y] = s * 0.5;
s = 0.5 / s;
quat[W] = (MMM(Z, X) - MMM(X, Z)) * s;
quat[Z] = (MMM(Y, Z) + MMM(Z, Y)) * s;
quat[X] = (MMM(Y, X) + MMM(X, Y)) * s;
}
} else {
if ( mat[ZZ] > mat[XX] ) {
s = sqrt( MMM(Z, Z) - (MMM(X, X)+MMM(Y, Y)) + 1.0 );
quat[Z] = s * 0.5;
s = 0.5 / s;
quat[W] = (MMM(X, Y) - MMM(Y, X)) * s;
quat[X] = (MMM(Z, X) + MMM(X, Z)) * s;
quat[Y] = (MMM(Z, Y) + MMM(Y, Z)) * s;
} else {
s = sqrt( MMM(X, X) - (MMM(Y, Y)+MMM(Z, Z)) + 1.0 );
quat[X] = s * 0.5;
s = 0.5 / s;
quat[W] = (MMM(Y, Z) - MMM(Z, Y)) * s;
quat[Y] = (MMM(X, Y) + MMM(Y, X)) * s;
quat[Z] = (MMM(X, Z) + MMM(Z, X)) * s;
}
}
#undef MMM
}
