float
CRebuildGraph::compareMatrix(gsl_matrix* matrixA, gsl_matrix*matrixB){
float delta;
gsl_vector *work ,*s;
if (matrixA->size1 != matrixB->size1)
throw runtime_error(" size 1 and size 2 are different");
gsl_matrix *U1, *U2,*V1,*V2;
InitMatrix((int)matrixA->size1,&work,&s,&U1,&U2,&V1,&V2);
gsl_matrix_memcpy (U1, matrixA);
//gsl_linalg_SV_decomp (gsl_matrix * A, gsl_matrix * V, gsl_vector * S, gsl_vector * work)
//La matriu A es substitueix per U a la sortida
gsl_linalg_SV_decomp(U1,V1,s,work);
gsl_matrix_memcpy (U2, matrixB);
gsl_linalg_SV_decomp(U2,V2,s,work);
//F = U1 VS2 V1^T = U1 U2^T A2 V2 V1^T
gsl_matrix *F=gsl_matrix_alloc(matrixA->size1,matrixA->size1);
gsl_matrix_transpose(U2);
multiplica(F,U1,U2);
multiplica(F,F,matrixB);
multiplica(F,F,V2);
gsl_matrix_transpose(V1);
multiplica(F,F,V1);
//F ja esta calculada. Calculem la norma.
delta=0;
for(int i=0; i<matrixA->size1; i++){
for(int j=0; j<matrixA->size1; j++){
delta+=pow(gsl_matrix_get(matrixA,i,j)-gsl_matrix_get(F,i,j),2);
}
}
delta=std::pow(delta,0.5f);
delta/=matrixA->size1;
printingCompareMatrixResults(delta,F,matrixA);
FreeMatrix(&work,
&s,
&U1,
&U2,
&V1,
&V2,
&F );
return delta;
}
void xmi_inverse_matrix(double x[3], double y[3], double z[3], double **inverseF) {
gsl_matrix *m = gsl_matrix_alloc(3,3);
gsl_matrix *inverse = gsl_matrix_alloc(3,3);
gsl_permutation *p = gsl_permutation_calloc(3);
int signum;
double *rv;
int i,j,k;
gsl_matrix_set(m,0,0, x[0]);
gsl_matrix_set(m,1,0, x[1]);
gsl_matrix_set(m,2,0, x[2]);
gsl_matrix_set(m,0,1, y[0]);
gsl_matrix_set(m,1,1, y[1]);
gsl_matrix_set(m,2,1, y[2]);
gsl_matrix_set(m,0,2, z[0]);
gsl_matrix_set(m,1,2, z[1]);
gsl_matrix_set(m,2,2, z[2]);
#if DEBUG == 2
fprintf(stdout,"input matrix\n");
gsl_matrix_fprintf(stdout,m , "%g");
#endif
//invert the sucker
gsl_linalg_LU_decomp(m,p,&signum);
gsl_linalg_LU_invert(m,p,inverse);
#if DEBUG == 2
fprintf(stdout,"inverted matrix\n");
gsl_matrix_fprintf(stdout,inverse , "%g");
#endif
gsl_matrix_transpose(inverse);
#if DEBUG == 2
fprintf(stdout,"transposed inverted matrix\n");
gsl_matrix_fprintf(stdout,inverse , "%g");
#endif
rv = (double *) malloc(9*sizeof(double));
k = 0;
for (i = 0 ; i < 3 ; i++)
for (j = 0 ; j < 3 ; j++)
rv[k++] = gsl_matrix_get(inverse, i,j);
gsl_matrix_free(m);
gsl_matrix_free(inverse);
gsl_permutation_free(p);
*inverseF = rv;
}
int ComputeHermitianMatrix(const gsl_matrix *const M,
gsl_matrix_complex * const E,
gsl_matrix *const S,
gsl_matrix *const N)
{
unsigned int i, j;
gsl_complex z;
// S = (M + M^T)/2
gsl_matrix_memcpy(S, M);
gsl_matrix_transpose(S);
gsl_matrix_add(S, M);
gsl_matrix_scale(S, 0.5);
// N = (M - M^T)/2
gsl_matrix_memcpy(N, M);
gsl_matrix_transpose(N);
gsl_matrix_scale(N, -1);
gsl_matrix_add(N, M);
gsl_matrix_scale(N, 0.5);
for(i = 0; i < M->size1; i++)
{
for(j = 0 ; j < M->size2; j++)
{
GSL_SET_COMPLEX(&z,
gsl_matrix_get(S, i, j),
gsl_matrix_get(N, i, j));
gsl_matrix_complex_set(E, i, j, z);
}
}
return GSL_SUCCESS;
}
void VarproFunction::computeDefaultRTheta( gsl_matrix *RTheta ) {
size_t c_size1 = getN(), c_size2 = getNrow();
size_t status = 0;
size_t minus1 = -1;
double tmp;
gsl_matrix * tempc = gsl_matrix_alloc(c_size1, c_size2);
if (myPhi == NULL) {
gsl_matrix_memcpy(tempc, myMatr);
} else {
gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, 1, myMatr, myPhi, 0, tempc);
}
gsl_matrix * tempu = gsl_matrix_alloc(c_size2, c_size2);
double *s = new double[mymin(c_size1, c_size2)];
/* Determine optimal work */
size_t lwork;
dgesvd_("A", "N", &tempc->size2, &tempc->size1, tempc->data, &tempc->tda, s,
tempu->data, &tempu->size2, NULL, &tempc->size1, &tmp, &minus1, &status);
double *work = new double[(lwork = tmp)];
/* Compute low-rank approximation */
dgesvd_("A", "N", &tempc->size2, &tempc->size1, tempc->data, &tempc->tda, s,
tempu->data, &tempu->size2, NULL, &tempc->size1, work, &lwork, &status);
if (status) {
delete [] s;
delete [] work;
gsl_matrix_free(tempc);
gsl_matrix_free(tempu);
throw new Exception("Error computing initial approximation: "
"DGESVD didn't converge\n");
}
gsl_matrix_transpose(tempu);
gsl_matrix_view RlraT;
RlraT = gsl_matrix_submatrix(tempu, 0, tempu->size2 - RTheta->size2,
tempu->size1, RTheta->size2);
gsl_matrix_memcpy(RTheta, &(RlraT.matrix));
delete [] s;
delete [] work;
gsl_matrix_free(tempc);
gsl_matrix_free(tempu);
}
/*!
Computes permutation matrix.
*/
int ComputePermMatrix(gsl_matrix * const UA,
gsl_matrix * const UB,
gsl_matrix * const P)
{
gsl_matrix_transpose(UA);
#ifdef VERBOSE
PrintGSLMatrix(UA, "WA");
PrintGSLMatrix(UB, "WB");
#endif
MulGSLMatrices(UB, UA, P);
#ifdef VERBOSE
PrintGSLMatrix(P, "Permutation Matrix");
#endif
return GSL_SUCCESS;
}
bool Matrix_Transpose(gsl_matrix *A){
gsl_matrix_transpose(A);
return true;
}
/** \brief Principal Components analysis.
\ingroup grplinalg
This implementation uses SVD to calculate the PCA.
Example:
\code
Array *X = get_data_from_somewhere();
Array *var, *X_pca;
matrix_pca( X, &var, FALSE ); // overwrite X
X_pca = matrix_pca( X, &var, TRUE ); // do not touch X
\endcode
\param X a 2D array observations x variables containing the data
\param var output: vector of eigenvalues of XX^T in decreasing order; if you
pass NULL, it is ignored;
\param alloc if true, new memory is allocated and returned. Else
X is overwritten.
\return pointer to the PCA'd matrix
*/
Array* matrix_pca( Array *X, Array **var, bool alloc ){
Array *out=NULL;
int i,j;
bool ismatrix;
matrix_CHECK( ismatrix, X );
if( !ismatrix ) return NULL;
int N,K; /* N observations, K variables */
N = X->size[0];
K = X->size[1];
Array *tmp = array_copy( X, TRUE );
/* subtract mean from observations */
Array *mean=matrix_mean( X, 0 );
for( i=0; i<N; i++ ){
for( j=0; j<K; j++ ){
array_INDEX2( tmp, double, i, j ) -=
array_INDEX1( mean, double, j );
}
}
array_scale( tmp, 1.0/sqrt((double) N-1 ) );
gsl_matrix *A=matrix_to_gsl( tmp, TRUE ); /* copy */
gsl_matrix *V=gsl_matrix_alloc( K, K );
gsl_vector *S=gsl_vector_alloc( K );
gsl_vector *workspace=gsl_vector_alloc( K );
/* A->U, V->V, S->S */
gsl_linalg_SV_decomp( A, V, S, workspace);
gsl_matrix_transpose( V );
if( var ){
(*var)=array_fromptr2( DOUBLE, 1, S->data, S->size );
S->owner=0; /* transfer ownership to array */
(*var)->free_data=1;
for( i=0; i<array_NUMEL( *var ); i++ ){
array_INDEX1( *var, double, i ) = SQR( array_INDEX1( *var, double, i ) );
}
}
Array *Vp=array_fromptr2( DOUBLE, 2, V->data, V->size1, V->size2 );
matrix_transpose( tmp, FALSE );
out=matrix_mult( Vp, tmp ); /* PCA'd data */
matrix_transpose( out, FALSE );
if( out->size[0]!=X->size[0] || out->size[1]!=X->size[1] ){
errprintf("Input/Output dimension mismatch: (%i,%i) vs. (%i,%i)\n",
X->size[0], X->size[1], out->size[0], out->size[1] );
}
if( !alloc ){ /* write back out->X */
memcpy( X->data, out->data, out->nbytes );
array_free( out );
out = X;
}
/* clean up */
gsl_matrix_free( A );
gsl_matrix_free( V );
gsl_vector_free( S );
gsl_vector_free( workspace );
array_free( mean );
array_free( Vp );
array_free( tmp );
return out;
}
int chol(gsl_matrix *A, gsl_vector *b, gsl_vector *x,
gsl_vector **x_bar, gsl_vector **x_error, double *max_error)
{
gsl_matrix *ML, *MU, *L;
gsl_vector *vec, *y_bar;
size_t j;
int status;
if (b->size != A->size1) {
return MATRIX_VECTOR_UNEQUAL_ROW_DIM;
}
/* if ((status = isPositiveDefinite(A))) { */
/* return status; */
/* } */
if ((status = cholcrout(A, &L))) {
return status;
}
/* prepare the (L|b) matrix */
ML = gsl_matrix_alloc(L->size1, L->size2 + 1);
vec = gsl_vector_alloc(L->size2);
for (j = 0; j < L->size2; ++j) {
gsl_matrix_get_col(vec, L, j);
gsl_matrix_set_col(ML, j, vec);
}
gsl_matrix_set_col(ML, ML->size2 - 1, b);
/* solve the (L|b) matrix using forwards substitution */
if ((status = subst_forwards(ML, &y_bar))) {
return status;
}
/* prepare the (L'|b) matrix */
gsl_matrix_transpose(L);
MU = gsl_matrix_alloc(L->size1, L->size2 + 1);
for (j = 0; j < L->size2; ++j) {
gsl_matrix_get_col(vec, L, j);
gsl_matrix_set_col(MU, j, vec);
}
gsl_vector_free(vec);
gsl_matrix_set_col(MU, MU->size2 - 1, y_bar);
/* solve the (U|b) matrix using backwards substitution */
if ((status = subst_backwards(MU, x_bar))) {
return status;
}
gsl_vector_free(y_bar);
gsl_matrix_free(ML);
gsl_matrix_free(MU);
gsl_matrix_free(L);
/* get the error statistics */
gatherErrors(*x_bar, x, x_error, max_error);
return 0;
}
int dietens(gsl_matrix * ep, double eav, double dem, double S, double stheta, double ctheta, double sphi, double cphi)
{
gsl_matrix * A = gsl_matrix_alloc(3,3);
gsl_matrix * epsilon = gsl_matrix_alloc(3,3);
gsl_matrix * ea = gsl_matrix_alloc(3,3);
gsl_matrix_set_zero(epsilon);
gsl_matrix_set(A,0,0,cphi*ctheta);
gsl_matrix_set(A,0,1,sphi);
gsl_matrix_set(A,0,2,-cphi*stheta);
gsl_matrix_set(A,1,0,-sphi*ctheta);
gsl_matrix_set(A,1,1,cphi);
gsl_matrix_set(A,1,2,sphi*stheta);
gsl_matrix_set(A,2,0,stheta);
gsl_matrix_set(A,2,1,0.0);
gsl_matrix_set(A,2,2,ctheta);
gsl_matrix_set(epsilon,0,0,eav-(1/3)*S*dem);
gsl_matrix_set(epsilon,1,1,eav-(1/3)*S*dem);
gsl_matrix_set(epsilon,2,2,eav+(2/3)*S*dem);
gsl_blas_dgemm(CblasTrans, CblasTrans, 1.0, epsilon, A, 0.0, ea);
gsl_matrix_transpose(A);//transpose A but dont need if eij=eji
//LU solve here, could use a symmetrical eg Cholesky
{
gsl_matrix *K = gsl_matrix_alloc(4, 4);
gsl_permutation *p = gsl_permutation_alloc(4);
gsl_vector *x = gsl_vector_alloc(4);
gsl_vector_view bp;
double z;
int i,j,s;
gsl_matrix_memcpy(K,A);
for (i = 0; i < 4; i++)
{
bp = gsl_matrix_column(ea, i);
gsl_linalg_LU_decomp(A, p, &s);
gsl_linalg_LU_solve(A, p, &bp.vector, x);
for (j = 0; j < 4; j++)
{
z = gsl_vector_get(x, j);
gsl_matrix_set(ep,i,j,z); //'through the looking glass' transpose
}
gsl_matrix_memcpy(A,K);
}
gsl_matrix_free(A);
gsl_matrix_free(epsilon);
gsl_matrix_free(ea);
gsl_matrix_free(K);
gsl_permutation_free(p);
gsl_vector_free(x);
}
return 1;
}
match_result algorithm_umeyama::match(graph& g, graph& h,gsl_matrix* gm_P_i,gsl_matrix* gm_ldh,double dalpha_ldh)
{
if (bverbose)
*gout<<"Umeyama algorithm"<<std::endl;
bool bblast_match_end=(get_param_i("blast_match_proj")==1);
//some duplicate variables
gsl_matrix* gm_Ag_d=g.get_descmatrix(cdesc_matrix);
gsl_matrix* gm_Ah_d=h.get_descmatrix(cdesc_matrix);
if (pdebug.ivalue) gsl_matrix_printout(gm_Ag_d,"Ag",pdebug.strvalue);
if (pdebug.ivalue) gsl_matrix_printout(gm_Ah_d,"Ah",pdebug.strvalue);
//memory allocation
gsl_eigen_symmv_workspace * gesw= gsl_eigen_symmv_alloc (N);
gsl_vector* eval_g=gsl_vector_alloc(N);
gsl_vector* eval_h=gsl_vector_alloc(N);
gsl_matrix* evec_g=gsl_matrix_alloc(N,N);
gsl_matrix* evec_h=gsl_matrix_alloc(N,N);
if (bverbose) *gout<<"Memory allocation finished"<<std::endl;
//eigenvalues and eigenvectors for both matrices
gsl_eigen_symmv (gm_Ag_d, eval_g,evec_g,gesw);
if (bverbose) *gout<<"Ag eigen vectors"<<std::endl;
gsl_eigen_symmv (gm_Ah_d, eval_h,evec_h,gesw);
gsl_matrix_free(gm_Ag_d);
gsl_matrix_free(gm_Ah_d);
if (bverbose) *gout<<"Ah eigen vectors"<<std::endl;
gsl_eigen_symmv_sort (eval_g, evec_g, GSL_EIGEN_SORT_VAL_DESC);
gsl_eigen_symmv_sort (eval_h, evec_h, GSL_EIGEN_SORT_VAL_DESC);
if (pdebug.ivalue){ gsl_matrix_printout(eval_g,"eval_g",pdebug.strvalue);
gsl_matrix_printout(eval_h,"eval_h",pdebug.strvalue);
gsl_matrix_printout(evec_g,"evec_g",pdebug.strvalue);
gsl_matrix_printout(evec_h,"evec_h",pdebug.strvalue);};
gsl_matrix_abs(evec_g);
gsl_matrix_abs(evec_h);
if (pdebug.ivalue) gsl_matrix_printout(evec_g,"abs(evec_g)",pdebug.strvalue);
if (pdebug.ivalue) gsl_matrix_printout(evec_h,"abs(evec_h)",pdebug.strvalue);
//loss matrix construction
gsl_matrix* C=gsl_matrix_alloc(N,N);
if (bverbose) *gout<<"Loss function matrix allocation"<<std::endl;
gsl_blas_dgemm(CblasNoTrans,CblasTrans,1,evec_g,evec_h,0,C);
if (pdebug.ivalue) gsl_matrix_printout(C,"C=abs(evec_g)*abs(evec_h')",pdebug.strvalue);
//label cost matrix
update_C_hungarian(C,-1);
//scaling for hungarian
double dscale_factor =gsl_matrix_max_abs(C);
dscale_factor=(dscale_factor>EPSILON)?dscale_factor:EPSILON;
dscale_factor=10000/dscale_factor;
gsl_matrix_scale(C,-dscale_factor);
gsl_matrix_transpose(C);
if (pdebug.ivalue) gsl_matrix_printout(C,"scale(C)",pdebug.strvalue);
gsl_matrix* gm_P=gsl_matrix_alloc(N,N);
gsl_matrix_hungarian(C,gm_P,NULL,NULL,false,(bblast_match_end?gm_ldh:NULL),false);
if (pdebug.ivalue) gsl_matrix_printout(gm_P,"gm_P",pdebug.strvalue);
if (bverbose) *gout<<"Hungarian solved"<<std::endl;
match_result mres;
mres.gm_P=gm_P;
//initial score
mres.vd_trace.push_back(graph_dist(g,h,cscore_matrix));
//final score
mres.vd_trace.push_back(graph_dist(g,h,gm_P,cscore_matrix));
//other output parameters
mres.dres=mres.vd_trace.at(1);
mres.inum_iteration=2;
//transpose matrix save
mres.gm_P=gm_P;
mres.gm_P_exact=NULL;
return mres;
}
/*
in matlab or octave
orig = [2.580000 -3.100000 4.250000
> 3.821000 4.440000 5.656000
> 1.820000 7.410000 3.330000]
orig =
2.5800 -3.1000 4.2500
3.8210 4.4400 5.6560
1.8200 7.4100 3.3300
octave:4> trans = orig'
trans =
2.5800 3.8210 1.8200
-3.1000 4.4400 7.4100
4.2500 5.6560 3.3300
*/
int main (void) {
int i, j;
FILE *opointer;
opointer = fopen("initial.txt","w");
FILE *tpointer;
tpointer = fopen("transpose.txt","w");
char *ofmt;
ofmt = "%f";
printf("The output file format ofmt %s \n",ofmt);
printf("will be used in gsl_matrix_fprintf (opointer, m, ofmt)\n");
gsl_matrix * m = gsl_matrix_alloc (3, 3);
gsl_matrix_set (m, 0, 0, 2.58);
gsl_matrix_set (m, 0, 1, -3.1);
gsl_matrix_set (m, 0, 2, 4.25);
gsl_matrix_set (m, 1, 0, 3.821);
gsl_matrix_set (m, 1, 1, 4.44);
gsl_matrix_set (m, 1, 2, 5.656);
gsl_matrix_set (m, 2, 0, 1.82);
gsl_matrix_set (m, 2, 1, 7.41);
gsl_matrix_set (m, 2, 2, 3.33);
/*
Function: int gsl_matrix_fprintf (FILE * stream, const gsl_matrix * m, const char * format)
This function writes the elements of the matrix m line-by-line to the stream stream using the format specifier format, which should be one of the %g, %e or %f formats for floating point numbers and %d for integers. The function returns 0 for success and GSL_EFAILED if there was a problem writing to the file.
*/
gsl_matrix_fprintf (opointer, m, ofmt);
printf ("Initial test matrice \n");
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
printf ("m(%d,%d) = %g\n", i, j,
gsl_matrix_get (m, i, j));
}
}
printf ("transpose of initial matrice \n");
printf ("the matrice needs to be square\n");
printf ("%x\n",*m);
printf ("sizeof of struct m %d \n",sizeof(*m));
printf("num of rows %d\n",m->size1);
printf("num of cols %d\n",m->size2);
if (m->size1 == m->size2) {
gsl_matrix_transpose (m);
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
printf ("m(%d,%d) = %g\n", i, j,
gsl_matrix_get (m, i, j));
}
}
gsl_matrix_fprintf (tpointer, m, ofmt);
}
else printf("the matrice is not square can not transpose\n");
gsl_matrix_set_identity (m);
printf ("The identity matrice \n");
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
printf ("m(%d,%d) = %g\n", i, j,
gsl_matrix_get (m, i, j));
}
}
gsl_matrix_free (m);
return 0;
}
int
ssc_inverse (double X_ji[6], double J_minus[6*6], const double X_ij[6])
{
GSLU_MATRIX_VIEW (R_ij, 3, 3);
so3_rotxyz (R_ij.data, SSC_RPH (X_ij));
// X_ji
const double h_ji = atan2 (R_ij(0,1), R_ij(0,0));
#ifdef _GNU_SOURCE
double sh_ji, ch_ji;
sincos (h_ji, &sh_ji, &ch_ji);
#else
double sh_ji = sin (h_ji), ch_ji = cos(h_ji);
#endif
const double x_ji = -(R_ij(0,0)*X_ij(0) + R_ij(1,0)*X_ij(1) + R_ij(2,0)*X_ij(2));
const double y_ji = -(R_ij(0,1)*X_ij(0) + R_ij(1,1)*X_ij(1) + R_ij(2,1)*X_ij(2));
const double z_ji = -(R_ij(0,2)*X_ij(0) + R_ij(1,2)*X_ij(1) + R_ij(2,2)*X_ij(2));
const double r_ji = atan2 (R_ij(2,0)*sh_ji - R_ij(2,1)*ch_ji, -R_ij(1,0)*sh_ji + R_ij(1,1)*ch_ji);
const double p_ji = atan2 (-R_ij(0,2), R_ij(0,0)*ch_ji + R_ij(0,1)*sh_ji);
X_ji(SSC_DOF_X) = x_ji;
X_ji(SSC_DOF_Y) = y_ji;
X_ji(SSC_DOF_Z) = z_ji;
X_ji(SSC_DOF_R) = r_ji;
X_ji(SSC_DOF_P) = p_ji;
X_ji(SSC_DOF_H) = h_ji;
if (J_minus != NULL) {
const double x_ij=X_ij(SSC_DOF_X), y_ij=X_ij(SSC_DOF_Y), z_ij=X_ij(SSC_DOF_Z);
const double r_ij=X_ij(SSC_DOF_R), p_ij=X_ij(SSC_DOF_P), h_ij=X_ij(SSC_DOF_H);
#ifdef _GNU_SOURCE
double sr_ij, cr_ij, sp_ij, cp_ij, sh_ij, ch_ij;
sincos (r_ij, &sr_ij, &cr_ij);
sincos (p_ij, &sp_ij, &cp_ij);
sincos (h_ij, &sh_ij, &ch_ij);
#else
double sr_ij = sin (r_ij), cr_ij = cos (r_ij);
double sp_ij = sin (p_ij), cp_ij = cos (p_ij);
double sh_ij = sin (h_ij), ch_ij = cos (h_ij);
#endif
// N
double tmp = x_ij*ch_ij + y_ij*sh_ij;
const double N_data[] = {
0, -R_ij(2,0)*tmp + z_ij*cp_ij, R_ij(1,0)*x_ij - R_ij(0,0)*y_ij,
z_ji, -R_ij(2,1)*tmp + z_ij*sp_ij*sr_ij, R_ij(1,1)*x_ij - R_ij(0,1)*y_ij,
-y_ji, -R_ij(2,2)*tmp + z_ij*sp_ij*cr_ij, R_ij(1,2)*x_ij - R_ij(0,2)*y_ij
};
gsl_matrix_const_view N = gsl_matrix_const_view_array (N_data, 3, 3);
// Q
tmp = sqrt (1-R_ij(0,2)*R_ij(0,2));
double Q_data[] = {
-R_ij(0,0), -R_ij(0,1)*cr_ij, R_ij(0,2)*R_ij(2,2),
R_ij(0,1)*tmp, -R_ij(2,2)*ch_ij*tmp, R_ij(1,2)*tmp,
R_ij(0,2)*R_ij(0,0), -R_ij(1,2)*ch_ij, -R_ij(2,2)
};
gsl_matrix_view Q = gsl_matrix_view_array (Q_data, 3, 3);
gsl_matrix_scale (&Q.matrix, 1./(tmp*tmp));
// J_minus
gsl_matrix_view J = gsl_matrix_view_array (J_minus, 6, 6);
gsl_matrix_set_zero (&J.matrix);
gsl_matrix_transpose (&R_ij.matrix);
gsl_matrix_scale (&R_ij.matrix, -1.0);
gslu_matrix_set_submatrix (&J.matrix, 0, 0, &R_ij.matrix); // -R_ij'
gslu_matrix_set_submatrix (&J.matrix, 0, 3, &N.matrix);
gslu_matrix_set_submatrix (&J.matrix, 3, 3, &Q.matrix);
}
return GSL_SUCCESS;
}
void gsl_matrix_hungarian(gsl_matrix* gm_C,gsl_matrix* gm_P,gsl_vector* gv_col_inc, gsl_permutation* gp_sol, int _bprev_init, gsl_matrix *gm_C_denied, bool bgreedy)
{
// mexPrintf("VV\n");
long dim, startdim, enddim, n1,n2;
double *C;
int i,j;
int **m;
double *z;
hungarian_problem_t p, *q;
int matrix_size;
double C_min=gsl_matrix_min(gm_C)-1;
n1 = gm_C->size1; /* first dimension of the cost matrix */
n2 = gm_C->size2; /* second dimension of the cost matrix */
C = gm_C->data;
//greedy solution
if (bgreedy)
{
int ind,ind1,ind2;
size_t *C_ind=new size_t[n1*n2];
gsl_heapsort_index(C_ind,C,n1*n2,sizeof(double),compare_doubles);
bool* bperm_fix_1=new bool[n1]; bool* bperm_fix_2=new bool[n2]; int inummatch=0;
for (i=0;i<n1;i++) {bperm_fix_1[i]=false;bperm_fix_2[i]=false;};
gsl_matrix_set_zero(gm_P);
for (long l=0;l<n1*n2;l++)
{
ind=C_ind[l];
ind1=floor(ind/n1);
ind2=ind%n2;
if (!bperm_fix_1[ind1] and !bperm_fix_2[ind2])
{
bperm_fix_1[ind1]=true; bperm_fix_2[ind2]=true;
gm_P->data[ind]=1;inummatch++;
};
if (inummatch==n1) break;
};
delete[] bperm_fix_1;delete[] bperm_fix_2;
//because C is a transpose matrix
gsl_matrix_transpose(gm_P);
return;
};
double C_max=((gsl_matrix_max(gm_C)-C_min>1)?(gsl_matrix_max(gm_C)-C_min):1)*(n1>n2?n1:n2);
m = (int**)calloc(n1,sizeof(int*));
// mexPrintf("C[2] = %f \n",C[2]);
for (i=0;i<n1;i++)
{
m[i] = (int*)calloc(n2,sizeof(int));
for (j=0;j<n2;j++)
m[i][j] = (int) (C[i+n1*j] - C_min);
// mexPrintf("m[%d][%d] = %f %f\n",i,j,m[i][j],C[i+n1*j] - C_min);
if (gm_C_denied!=NULL)
for (j=0;j<n2;j++){
if (j==30)
int dbg=1;
bool bden=(gm_C_denied->data[n2*i+j]<1e-10);
if (bden) m[i][j] =C_max;
else
int dbg=1;
};
};
//normalization: rows and columns
// mexPrintf("C[2] = %f \n",C[2]);
double dmin;
for (i=0;i<n1;i++)
{
dmin=m[i][0];
for (j=1;j<n2;j++)
dmin= (m[i][j]<dmin)? m[i][j]:dmin;
for (j=0;j<n2;j++)
m[i][j]-=dmin;
};
for (j=0;j<n2;j++)
{
dmin=m[0][j];
for (i=1;i<n1;i++)
dmin= (m[i][j]<dmin)? m[i][j]:dmin;
for (i=0;i<n1;i++)
m[i][j]-=dmin;
};
if ((_bprev_init) &&(gv_col_inc !=NULL))
{
//dual solution v substraction
for (j=0;j<n2;j++)
for (i=0;i<n1;i++)
m[i][j]-=gv_col_inc->data[j];
//permutation of m columns
int *mt = new int[n2];
for (i=0;i<n1;i++)
{
for (j=0;j<n2;j++) mt[j]=m[i][j];
for (j=0;j<n2;j++) m[i][j]=mt[gsl_permutation_get(gp_sol,j)];
};
delete[] mt;
};
/* initialize the hungarian_problem using the cost matrix*/
matrix_size = hungarian_init(&p, m , n1,n2, HUNGARIAN_MODE_MINIMIZE_COST) ;
/* solve the assignement problem */
hungarian_solve(&p);
q = &p;
//gsl_matrix* gm_P=gsl_matrix_alloc(n1,n2);
gsl_permutation* gp_sol_inv=gsl_permutation_alloc(n2);
if (gp_sol!=NULL)
gsl_permutation_inverse(gp_sol_inv,gp_sol);
else
gsl_permutation_init(gp_sol_inv);
for (i=0;i<n1;i++)
for (j=0;j<n2;j++)
gsl_matrix_set(gm_P,i,j,q->assignment[i][gp_sol_inv->data[j]]);
//initialization by the previous solution
if ((_bprev_init) &&(gv_col_inc !=NULL))
for (j=0;j<n2;j++)
gv_col_inc->data[j]=q->col_inc[gp_sol_inv->data[j]];
if ((_bprev_init) && (gp_sol!=NULL))
{
for (i=0;i<n1;i++)
for (j=0;j<n2;j++)
if (gsl_matrix_get(gm_P,i,j)==HUNGARIAN_ASSIGNED)
gp_sol->data[i]=j;
};
/* free used memory */
gsl_permutation_free(gp_sol_inv);
hungarian_free(&p);
for (i=0;i<n1;i++)
free(m[i]);
free(m);
/* for (int i=0;i<gm_C->size1;i++)
{
for (int j=0;j<gm_C->size1;j++)
{
mexPrintf("G[%d][%d] = %f %f \n",i,j,gsl_matrix_get(gm_P,i,j),gsl_matrix_get(gm_C,i,j));
}
}*/
// mexPrintf("AAA");
//return gm_P;
}
match_result algorithm_ca::match(graph& g, graph& h,gsl_matrix* gm_P_i,gsl_matrix* _gm_ldh,double dalpha_ldh)
{
double dhung_max=get_param_d("hungarian_max");
bool bblast_match_end=(get_param_i("blast_match_proj")==1);
bool bblast_match=(get_param_i("blast_match")==1);
double dfw_xeps=get_param_d("algo_fw_xeps");
double bgreedy=(get_param_i("hungarian_greedy")==1);
double dfvalue;
if (bverbose)
*gout<<"C-adaptation strategy"<<std::endl;
//some duplicate variables
gsl_matrix* gm_Ag_d=g.get_descmatrix(cdesc_matrix);
gsl_matrix* gm_Ah_d=h.get_descmatrix(cdesc_matrix);
gsl_matrix * gm_C_a=gsl_matrix_alloc(N,N);
gsl_matrix * gm_C_up=gsl_matrix_alloc(N,N);
gsl_matrix * gm_P=gsl_matrix_alloc(N,N);
gsl_matrix * gm_temp=gsl_matrix_alloc(N,N);
//initialization
gsl_matrix_memcpy(gm_C_a,gm_P_i);
//cycle over linear combination of linear and non linear terms
double astep=1e-30;bool bcont=true;
if (dalpha_ldh>0)
gsl_matrix_scale(gm_ldh,dalpha_ldh);
while (bcont){
bcont=(astep<1);
//optimal permutation
gsl_matrix_scale(gm_C_a,-dhung_max);
gsl_matrix_transpose(gm_C_a);
gsl_matrix_hungarian(gm_C_a,gm_P,NULL,NULL,false,(bblast_match?gm_ldh:NULL),bgreedy);
gsl_matrix_transpose(gm_C_a);
gsl_matrix_scale(gm_C_a,-1.0/dhung_max);
//C-matrix update
gsl_blas_dgemm(CblasNoTrans,CblasNoTrans,1,gm_Ag_d,gm_P,0,gm_temp);
gsl_blas_dgemm(CblasNoTrans,CblasNoTrans,1,gm_temp,gm_Ah_d,0,gm_C_up);
gsl_matrix_scale(gm_C_up,1-dalpha_ldh);
if (dalpha_ldh>0) gsl_matrix_add(gm_C_up,gm_ldh);
gsl_matrix_scale(gm_C_a,1-astep);
gsl_matrix_scale(gm_C_up,astep);
gsl_matrix_add(gm_C_a,gm_C_up);
dfvalue=f_qcv(gm_Ag_d,gm_Ah_d,gm_P,gm_temp,true);
if (bverbose) *gout<<"astep="<<astep<<", f="<<dfvalue<<std::endl;
astep+=0.01;//0.01*astep;
astep=(astep<1)?astep:1;
};
gsl_matrix_free(gm_Ag_d);
gsl_matrix_free(gm_Ah_d);
gsl_matrix_free(gm_temp);
gsl_matrix_free(gm_C_up);
gsl_matrix_free(gm_C_a);
if (dalpha_ldh>0)
gsl_matrix_scale(gm_ldh,1.0/dalpha_ldh);
match_result mres;
mres.gm_P=gm_P;
//initial score
mres.vd_trace.push_back(graph_dist(g,h,cscore_matrix));
//final score
mres.vd_trace.push_back(graph_dist(g,h,gm_P,cscore_matrix));
//other output parameters
mres.dres=mres.vd_trace.at(1);
mres.inum_iteration=2;
//transpose matrix save
mres.gm_P=gm_P;
mres.gm_P_exact=NULL;
return mres;
}
int main() {
int i,j,k;
double s;
std::vector< std::vector< std::vector<double> > > patients(count);
for(i = 0; i<count; ++i) {
std::cout << files[i] << std::endl;
patients[i] = Patient(files[i]).data;
}
gsl_matrix* A_avg = gsl_matrix_alloc(3, 64);
for(i = 0; i<3; ++i) {
for(j = 0; j<64; ++j) {
s = 0;
for(k = 0; k < count; ++k) {
s+=patients[k][i][j];
}
gsl_matrix_set(A_avg, i, j, s/count);
}
}
//std::cout << "A_avg" << std::endl;
//gsl_matrix_print(A_avg, 3, 64);
gsl_matrix* S = gsl_matrix_alloc(3, 64);
for(i = 0; i<3; ++i) {
for(j = 0; j<64; ++j) {
s = 0;
for(k = 0; k < count; ++k) {
s += pow((patients[k][i][j] - gsl_matrix_get(A_avg, i, j)), 2);
}
gsl_matrix_set(S, i, j, sqrt(s/count));
}
}
// std::cout << "S" << std::endl;
gsl_matrix_print(S, 3, 64);
gsl_matrix *T[count];
for(k = 0; k < count; ++k) {
T[k] = gsl_matrix_alloc(3, 64);
for(i = 0; i<3; ++i) {
for(j = 0; j<64; ++j) {
s = (patients[k][i][j] - gsl_matrix_get(A_avg, i, j)) / gsl_matrix_get(S, i, j);
gsl_matrix_set(T[k], i, j, s);
}
}
}
size_t cube_sizes[3] = {3, 64, count};
Tensor<3> cube(cube_sizes);
size_t matrix_sizes[3] = {cube.size(), 1};
Tensor<2> matrix(matrix_sizes);
int M, N;
std::cout << cube.size() << std::endl;
for (size_t offset = 0; offset < cube.size(); ++offset) {
i = offset/(3*64); //0...20
j = (offset%(3*64))/64; //0...3
k = (offset%(3*64))%64; //0...64
cube.data[offset] = gsl_matrix_get(T[i], j, k); // patients[i][j][k];
}
// start calculating, flatten
std::cout << "HOSVD 3x(64*20)" << std::endl;
cube.flatten(matrix, 0);
gsl_matrix* Ax = TensorToGSLMatrix(matrix);
gsl_matrix* Ux;
gsl_matrix* Vx;
gsl_vector* Sx;
gsl_vector* workx;
//gsl_matrix_print(Ax, 1536, 3);
N = Ax->size2;
workx = gsl_vector_alloc(N);
Sx = gsl_vector_alloc(N);
Vx = gsl_matrix_alloc(N, N);
gsl_linalg_SV_decomp(Ax, Vx, Sx, workx);
//gsl_matrix_transpose (Vx);
std::cout << "S1" << std::endl;
gsl_vector_print(Sx, N);
std::cout << "V" << std::endl;
gsl_matrix_print(Vx, N , N);
//std::cout << "work" << std::endl;
//gsl_vector_print(workx, N);
//Нам нужен Vx, это наше U; V(3x3)
/* FLATTEN HOSVD 64x(3*20) */
std::cout << "HOSVD 64x(3*24)" << std::endl;
cube.flatten(matrix, 1);
//print(matrix);
gsl_matrix* Ay = TensorToGSLMatrix(matrix);
gsl_matrix* Uy;
gsl_matrix* Vy;
gsl_vector* Sy;
gsl_vector* worky;
N = Ay->size2;
//gsl_matrix_print(Ay, Ay->size1, Ay->size2);
worky = gsl_vector_alloc(N);
Sy = gsl_vector_alloc(N);
Vy = gsl_matrix_alloc(N, N);
gsl_linalg_SV_decomp(Ay, Vy, Sy, worky);
//gsl_matrix_transpose(Vy);
std::cout << "S2" << std::endl;
gsl_vector_print(Sy, N);
//std::cout << "V" << std::endl;
//gsl_matrix_print(Vy, Vy->size1, Vy->size2);
//Нам нужен Vy, это наше V; V(3x3)
/* FLATTEN HOSVD 20x(3*64) */
std::cout << "HOSVD 20x(3*64)" << std::endl;
cube.flatten(matrix, 2);
//print(matrix);
gsl_matrix* Az = TensorToGSLMatrix(matrix);
gsl_matrix* Uz;
gsl_matrix* Vz;
gsl_vector* Sz;
gsl_vector* workz;
N = Az->size2;
//gsl_matrix_print(Ay, Ay->size1, Ay->size2);
workz = gsl_vector_alloc(N);
Sz = gsl_vector_alloc(N);
Vz = gsl_matrix_alloc(N, N);
gsl_linalg_SV_decomp(Az, Vz, Sz, workz);
// gsl_matrix_transpose(Vz);
std::cout << "S3" << std::endl;
gsl_vector_print(Sz, Az->size2);
//std::cout << "V" << std::endl;
//gsl_matrix_print(Vz, Vz->size1, Vz->size2);
//Нам нужен Vz, это наше W; W(20x20)
gsl_matrix *Vx_t, *tmp[count], *Z[count], *Z_avg;
Vx_t = gsl_matrix_alloc(Vx->size2, Vx->size1);
gsl_matrix_transpose (Vz);
for(i =0; i<count; ++i) {
Z[i] = gsl_matrix_alloc(3,64);
tmp[i] = gsl_matrix_alloc(3,64);
gsl_blas_dgemm (CblasNoTrans, CblasNoTrans, 1.0, Vx_t, T[i], 0.0, tmp[i]);
gsl_blas_dgemm (CblasNoTrans, CblasNoTrans, 1.0, tmp[i], Vy, 0.0, Z[i]);
}
std::cout << "qqq111" <<std::endl;
for(i = 0; i<1; ++i) {
for(k =0; k<10; ++k) {
for(j =0; j<3; ++j) {
std::cout << gsl_matrix_get(Z[i], j, k) << " ";
}
std::cout << std::endl;
}
// if(i == 11)
std::cout << std::endl;
}
return 0;
}
void add_signal(
Search_settings *sett,
Command_line_opts *opts,
Aux_arrays *aux_arr,
Search_range *s_range) {
int i, j, n, gsize, reffr, k;
double snr, sum = 0., h0, cof, thsnr = 0;
double sigma_noise = 1.0;
double sinaadd, cosaadd, sindadd, cosdadd, phaseadd, shiftadd, signadd;
double nSource[3], sgnlo[10], sgnlol[4];
double **sigaa, **sigbb; // aa[nifo][N]
sigaa = (double **)malloc(sett->nifo*sizeof(double *));
for (k=0; k < sett->nifo; k++) sigaa[k] = (double *)calloc(sett->N, sizeof(double));
sigbb = (double **)malloc(sett->nifo*sizeof(double *));
for (k=0; k < sett->nifo; k++) sigbb[k] = (double *)calloc(sett->N, sizeof(double));
FILE *data;
// Signal parameters are read
if ((data=fopen (opts->addsig, "r")) != NULL) {
// Fscanning for the GW amplitude, grid size, hemisphere
// and the reference frame (for which the signal freq. is not spun-down/up)
fscanf (data, "%le %d %d %d", &snr, &gsize, s_range->pmr, &reffr);
// Fscanning signal parameters: f, fdot, delta, alpha (sgnlo[0], ..., sgnlo[3])
// four amplitudes sgnlo[4], ..., sgnlo[7]
// (see sigen.c and Phys. Rev. D 82, 022005 2010, Eqs. 2.13a-d)
// be1, be2 (sgnlo[8], sgnlo[9] to translate the sky position into grid position)
for(i=0; i<10; i++)
fscanf(data, "%le",i+sgnlo);
fclose (data);
} else {
perror (opts->addsig);
}
// Search-specific parametrization of freq.
// for the software injections
// sgnlo[0]: frequency, sgnlo[1]: frequency. derivative
//#mb For VSR1 reffr=67
sgnlo[0] += -2.*sgnlo[1]*(sett->N)*(reffr - opts->ident);
// Check if the signal is in band
if(sgnlo[0]<0) exit(171); // «
else if (sgnlo[0]>M_PI) exit(187); // »
cof = sett->oms + sgnlo[0];
for(i=0; i<2; i++) sgnlol[i] = sgnlo[i];
sgnlol[2] = sgnlo[8]*cof;
sgnlol[3] = sgnlo[9]*cof;
// solving a linear system in order to translate
// sky position, frequency and spindown (sgnlo parameters)
// into the position in the grid
double *MM ;
MM = (double *) calloc (16, sizeof (double));
for(i=0; i<16; i++) MM[i] = sett->M[i] ;
gsl_vector *x = gsl_vector_alloc (4);
int s;
gsl_matrix_view m = gsl_matrix_view_array (MM, 4, 4);
gsl_matrix_transpose (&m.matrix) ;
gsl_vector_view b = gsl_vector_view_array (sgnlol, 4);
gsl_permutation *p = gsl_permutation_alloc (4);
gsl_linalg_LU_decomp (&m.matrix, p, &s);
gsl_linalg_LU_solve (&m.matrix, p, &b.vector, x);
s_range->spndr[0] = round(gsl_vector_get(x,1));
s_range->nr[0] = round(gsl_vector_get(x,2));
s_range->mr[0] = round(gsl_vector_get(x,3));
gsl_permutation_free (p);
gsl_vector_free (x);
free (MM);
// Define the grid range in which the signal will be looked for
s_range->spndr[1] = s_range->spndr[0] + gsize;
s_range->spndr[0] -= gsize;
s_range->nr[1] = s_range->nr[0] + gsize;
s_range->nr[0] -= gsize;
s_range->mr[1] = s_range->mr[0] + gsize;
s_range->mr[0] -= gsize;
s_range->pmr[1] = s_range->pmr[0];
printf("add_signal() - the following grid range is used\n");
printf("(spndr, nr, mr, pmr pairs): %d %d %d %d %d %d %d %d\n", \
s_range->spndr[0], s_range->spndr[1], s_range->nr[0], s_range->nr[1],
s_range->mr[0], s_range->mr[1], s_range->pmr[0], s_range->pmr[1]);
// sgnlo[2]: declination, sgnlo[3]: right ascension
sindadd = sin(sgnlo[2]);
cosdadd = cos(sgnlo[2]);
sinaadd = sin(sgnlo[3]);
cosaadd = cos(sgnlo[3]);
// To keep coherent phase between time segments
double phaseshift = sgnlo[0]*sett->N*(reffr - opts->ident)
+ sgnlo[1]*pow(sett->N*(reffr - opts->ident), 2);
// Loop for each detector
for(n=0; n<sett->nifo; n++) {
modvir(sinaadd, cosaadd, sindadd, cosdadd,
sett->N, &ifo[n], aux_arr, sigaa[n], sigbb[n]);
nSource[0] = cosaadd*cosdadd;
nSource[1] = sinaadd*cosdadd;
nSource[2] = sindadd;
// adding signal to data (point by point)
for (i=0; i<sett->N; i++) {
shiftadd = 0.;
for (j=0; j<3; j++)
shiftadd += nSource[j]*ifo[n].sig.DetSSB[i*3+j];
// Phase
phaseadd = sgnlo[0]*i + sgnlo[1]*aux_arr->t2[i]
+ (cof + 2.*sgnlo[1]*i)*shiftadd
- phaseshift;
// The whole signal with 4 amplitudes and modulations
signadd = sgnlo[4]*(sigaa[n][i])*cos(phaseadd)
+ sgnlo[6]*(sigaa[n][i])*sin(phaseadd)
+ sgnlo[5]*(sigbb[n][i])*cos(phaseadd)
+ sgnlo[7]*(sigbb[n][i])*sin(phaseadd);
//#mb test printout
//printf("%d %le\n", i + sett->N*(opts->ident-1), phaseadd);
// Adding the signal to the data vector
if(ifo[n].sig.xDat[i]) {
ifo[n].sig.xDat[i] += signadd;
sum += pow(signadd, 2.);
// thsnr += pow(h0*signadd, 2.);
}
}
// Write the data+signal to file
/* FILE *dataout;
char xxx[512];
sprintf(xxx, "%s/%03d/%s/xdatc_%03d_%04d%s.bin",
opts->dtaprefix, opts->ident, ifo[n].name,
opts->ident, opts->band, opts->label);
printf("Flag 1: try to write xDat to fole %s\n", xxx);
if((dataout = fopen(xxx, "wb")) != NULL) {
fwrite(ifo[n].sig.xDat, sizeof(*ifo[n].sig.xDat), sett->N, dataout);
}
else{
printf("Problem with %s file!\n", xxx);
}
fclose(dataout); */
}
h0 = (snr*sigma_noise)/(sqrt(sum));
for(n=0; n<sett->nifo; n++) {
for (i=0; i<sett->N; i++) {
ifo[n].sig.xDat[i] = ifo[n].sig.xDat[i]*h0;
}
}
printf("%le %le\n", snr, h0);
for (i = 0; i < sett->nifo; i++) free(sigaa[i]);
free(sigaa);
for (i = 0; i < sett->nifo; i++) free(sigbb[i]);
free(sigbb);
//exit(0);
}
int Umeyama(const gsl_matrix * const A,
const gsl_matrix * const B,
gsl_matrix * const Assignment,
float *score)
{
int res = 0;
gsl_matrix_complex *AE = NULL, *BE = NULL;
gsl_matrix *P = NULL,
*AS = NULL,
*BS = NULL,
*AN = NULL,
*BN = NULL,
*AssignmentT = NULL;
#ifdef USE_ASP
long *col_mate;
long *row_mate;
cost **pTempCost;
int i, j;
#endif
struct timeval start, end;
long mtime, seconds, useconds;
#ifdef VERBOSE
PrintGSLMatrix(A, "Umeyama A");
PrintGSLMatrix(B, "Umeyama B");
#endif
AE = gsl_matrix_complex_alloc(A->size1, A->size2); if(AE == NULL) goto _exit;
AS = gsl_matrix_alloc(A->size1, A->size2); if(AS == NULL) goto _exit;
AN = gsl_matrix_alloc(A->size1, A->size2); if(AN == NULL) goto _exit;
ComputeHermitianMatrix(A, AE, AS, AN);
#ifdef VERBOSE
PrintGSLMatrix(AS, "AS");
PrintGSLMatrix(AN, "AN");
#endif
if( IsHermitian(AE) == false )
{
fprintf(stderr, "FATAL: AE is not Hermitian!\n");
exit(0);
}
#ifdef VERBOSE
fprintf(stderr, "Verified AE is Hermitian.\n");
#endif
BE = gsl_matrix_complex_alloc(B->size1, B->size2); if(BE == NULL) goto _exit;
BS = gsl_matrix_alloc(B->size1, B->size2); if(BS == NULL) goto _exit;
BN = gsl_matrix_alloc(B->size1, B->size2); if(BN == NULL) goto _exit;
ComputeHermitianMatrix(B, BE, BS, BN);
#ifdef VERBOSE
PrintGSLMatrix(BS, "BS");
PrintGSLMatrix(BN, "BN");
#endif
if( IsHermitian(BE) == false )
{
fprintf(stderr, "FATAL: BE is not Hermitian!\n");
exit(0);
}
#ifdef VERBOSE
fprintf(stderr, "Verified BE is Hermitian.\n");
WriteComplexMatrixToFile(BE);
PrintGSLMatrixComplex(AE, "AE");
PrintGSLMatrixComplex(BE, "BE");
#endif
P = gsl_matrix_alloc(A->size1, A->size2); if(P == NULL) goto _exit;
res = EigenDecomp(AE, BE, P);
if( res == -1 ) goto _exit;
#ifdef VERBOSE
PrintGSLMatrix(P, "P");
PrintGSLMatrix(P, "Computing Hungarian");
#endif
// Begin timing Hungarian
gettimeofday(&start, NULL);
#ifdef USE_ASP
col_mate = new long[P->size1];
row_mate = new long[P->size1];
pTempCost = new cost*[P->size1];
for(i = 0; i < P->size1; ++i)
pTempCost[i] = new cost[P->size2];
for(i = 0; i < P->size1; ++i)
for(j = 0; j < P->size2; ++j)
pTempCost[i][j] = gsl_matrix_get(P, i, j);
asp(P->size1, pTempCost, col_mate, row_mate);
for(i = 0; i < P->size1; ++i)
delete[] pTempCost[i];
delete[] pTempCost;
// Update assignment matrix
for(i = 0; i < P->size1; ++i)
gsl_matrix_set(Assignment, i, col_mate[i], 1);
delete[] col_mate;
delete[] row_mate;
#else
Hungarian(P, true, Assignment);
#endif
// End timing Hungarian
gettimeofday(&end, NULL);
seconds = end.tv_sec - start.tv_sec;
useconds = end.tv_usec - start.tv_usec;
mtime = ((seconds) * 1000 + useconds/1000.0) + 0.5;
fprintf(stderr, "%ld ms\t", mtime);
// PrintGSLMatrixUint(Assignment, "Assignment");
// Allocate and initialize AssgtT
AssignmentT = gsl_matrix_alloc(Assignment->size1, Assignment->size2);
if(AssignmentT == NULL) goto _exit;
gsl_matrix_memcpy(AssignmentT, Assignment);
gsl_matrix_transpose(AssignmentT);
/*
PrintGSLMatrix(AS, "AS");
PrintGSLMatrix(AN, "AN");
PrintGSLMatrix(BS, "BS");
PrintGSLMatrix(BN, "BN");
*/
*score = CalcScore(AS, AN, BS, BN, Assignment, AssignmentT);
_exit:
if(P != NULL) gsl_matrix_free(P);
if(AS != NULL) gsl_matrix_free(AS);
if(AN != NULL) gsl_matrix_free(AN);
if(BS != NULL) gsl_matrix_free(BS);
if(BN != NULL) gsl_matrix_free(BN);
if(AE != NULL) gsl_matrix_complex_free(AE);
if(BE != NULL) gsl_matrix_complex_free(BE);
if(AssignmentT != NULL) gsl_matrix_free(AssignmentT);
return res;
}
int
main(int argc, char *argv[])
{
gen_workspace *gen_workspace_p;
lapack_workspace *lapack_workspace_p;
size_t N;
int c;
int lower;
int upper;
int incremental;
size_t nmat;
gsl_matrix *A, *B;
gsl_rng *r;
int s;
int compute_schur;
size_t i;
gsl_ieee_env_setup();
gsl_rng_env_setup();
N = 30;
lower = -10;
upper = 10;
incremental = 0;
nmat = 0;
compute_schur = 0;
while ((c = getopt(argc, argv, "ic:n:l:u:z")) != (-1))
{
switch (c)
{
case 'i':
incremental = 1;
break;
case 'n':
N = strtol(optarg, NULL, 0);
break;
case 'l':
lower = strtol(optarg, NULL, 0);
break;
case 'u':
upper = strtol(optarg, NULL, 0);
break;
case 'c':
nmat = strtoul(optarg, NULL, 0);
break;
case 'z':
compute_schur = 1;
break;
case '?':
default:
printf("usage: %s [-i] [-z] [-n size] [-l lower-bound] [-u upper-bound] [-c num]\n", argv[0]);
exit(1);
break;
} /* switch (c) */
}
A = gsl_matrix_alloc(N, N);
B = gsl_matrix_alloc(N, N);
gen_workspace_p = gen_alloc(N, compute_schur);
lapack_workspace_p = lapack_alloc(N);
r = gsl_rng_alloc(gsl_rng_default);
if (incremental)
{
make_start_matrix(A, lower);
/* we need B to be non-singular */
make_random_integer_matrix(B, r, lower, upper);
}
fprintf(stderr, "testing N = %d", N);
if (incremental)
fprintf(stderr, " incrementally");
else
fprintf(stderr, " randomly");
fprintf(stderr, " on element range [%d, %d]", lower, upper);
if (compute_schur)
fprintf(stderr, ", with Schur vectors");
fprintf(stderr, "\n");
while (1)
{
if (nmat && (count >= nmat))
break;
++count;
if (!incremental)
{
make_random_matrix(A, r, lower, upper);
make_random_matrix(B, r, lower, upper);
}
else
{
s = inc_matrix(A, lower, upper);
if (s)
break; /* all done */
make_random_integer_matrix(B, r, lower, upper);
}
/*if (count != 89120)
continue;*/
/* make copies of matrices */
gsl_matrix_memcpy(gen_workspace_p->A, A);
gsl_matrix_memcpy(gen_workspace_p->B, B);
gsl_matrix_transpose_memcpy(lapack_workspace_p->A, A);
gsl_matrix_transpose_memcpy(lapack_workspace_p->B, B);
/* compute eigenvalues with LAPACK */
s = lapack_proc(lapack_workspace_p);
if (s != GSL_SUCCESS)
{
printf("LAPACK failed, case %lu\n", count);
exit(1);
}
#if 0
print_matrix(A, "A");
print_matrix(B, "B");
gsl_matrix_transpose(lapack_workspace_p->A);
gsl_matrix_transpose(lapack_workspace_p->B);
print_matrix(lapack_workspace_p->A, "S_lapack");
print_matrix(lapack_workspace_p->B, "T_lapack");
#endif
/* compute eigenvalues with GSL */
s = gen_proc(gen_workspace_p);
if (s != GSL_SUCCESS)
{
printf("=========== CASE %lu ============\n", count);
printf("Failed to converge: found %u eigenvalues\n",
gen_workspace_p->n_evals);
print_matrix(A, "A");
print_matrix(B, "B");
print_matrix(gen_workspace_p->A, "Af");
print_matrix(gen_workspace_p->B, "Bf");
print_matrix(lapack_workspace_p->A, "Ae");
print_matrix(lapack_workspace_p->B, "Be");
exit(1);
}
#if 0
print_matrix(gen_workspace_p->A, "S_gsl");
print_matrix(gen_workspace_p->B, "T_gsl");
#endif
/* compute alpha / beta vectors */
for (i = 0; i < N; ++i)
{
double beta;
gsl_complex alpha, z;
beta = gsl_vector_get(gen_workspace_p->beta, i);
if (beta == 0.0)
GSL_SET_COMPLEX(&z, GSL_POSINF, GSL_POSINF);
else
{
alpha = gsl_vector_complex_get(gen_workspace_p->alpha, i);
z = gsl_complex_div_real(alpha, beta);
}
gsl_vector_complex_set(gen_workspace_p->evals, i, z);
beta = gsl_vector_get(lapack_workspace_p->beta, i);
GSL_SET_COMPLEX(&alpha,
lapack_workspace_p->alphar[i],
lapack_workspace_p->alphai[i]);
if (beta == 0.0)
GSL_SET_COMPLEX(&z, GSL_POSINF, GSL_POSINF);
else
z = gsl_complex_div_real(alpha, beta);
gsl_vector_complex_set(lapack_workspace_p->evals, i, z);
gsl_vector_complex_set(lapack_workspace_p->alpha, i, alpha);
}
#if 0
gsl_sort_vector(gen_workspace_p->beta);
gsl_sort_vector(lapack_workspace_p->beta);
sort_complex_vector(gen_workspace_p->alpha);
sort_complex_vector(lapack_workspace_p->alpha);
s = test_alpha(gen_workspace_p->alpha,
lapack_workspace_p->alpha,
A,
B,
"gen",
"lapack");
s = test_beta(gen_workspace_p->beta,
lapack_workspace_p->beta,
A,
B,
"gen",
"lapack");
#endif
#if 1
sort_complex_vector(gen_workspace_p->evals);
sort_complex_vector(lapack_workspace_p->evals);
s = test_evals(gen_workspace_p->evals,
lapack_workspace_p->evals,
A,
B,
"gen",
"lapack");
#endif
if (compute_schur)
{
test_schur(A,
gen_workspace_p->A,
gen_workspace_p->Q,
gen_workspace_p->Z);
test_schur(B,
gen_workspace_p->B,
gen_workspace_p->Q,
gen_workspace_p->Z);
}
}
gsl_matrix_free(A);
gsl_matrix_free(B);
gen_free(gen_workspace_p);
lapack_free(lapack_workspace_p);
if (r)
gsl_rng_free(r);
return 0;
} /* main() */
