void CRebuildGraph::printingCompareMatrixResults(float delta,
gsl_matrix *F,
gsl_matrix* matrixA
){
CFuncTrace lFuncTrace(false,"CRebuildGraph::printingCompareMatrixResults");
lFuncTrace.trace(CTrace::TRACE_DEBUG,"DIFERENCIA (delta) -> %f",delta);
//Per presentar-la, definim positiva i normalitzem la matriu F
if(gsl_matrix_min(F)<0)
gsl_matrix_add_constant (F, -gsl_matrix_min(F));
if(gsl_matrix_max(F)>0)
gsl_matrix_scale (F, 1/gsl_matrix_max(F));
FILE *out;
out=fopen("sortida.txt","w");
lFuncTrace.trace(CTrace::TRACE_DEBUG,"Resultats en sortida.txt");
fprintf(out, "DIFERENCIA (delta) -> %f\n\n",delta);
for(int i=0; i<matrixA->size1; i++){
for(int j=0; j<matrixA->size1; j++){
if(gsl_matrix_get(matrixA,i,j)==0){
fprintf(out," ");
}else if(gsl_matrix_get(matrixA,i,j)==1){
fprintf(out,"#");
}else{
printf("\nERROR-Matriu no valida %f",gsl_matrix_get(matrixA,i,j));
exit(1);
}
}
fprintf(out,"\t|\t");
for(int j=0; j<matrixA->size1; j++){
if(gsl_matrix_get(F,i,j)<0.2)
fprintf(out," ");
else if(gsl_matrix_get(F,i,j)<0.4)
fprintf(out,"∑");
else if(gsl_matrix_get(F,i,j)<0.6)
fprintf(out,"^");
else if(gsl_matrix_get(F,i,j)<0.8)
fprintf(out,"-");
else if(gsl_matrix_get(F,i,j)<0.95)
fprintf(out,"/");
else
fprintf(out,"#");
}
fprintf(out,"\n");
}
fclose(out);
}
int
main (void)
{
size_t i, j, n = 100;
double min, max, min_out, max_out, k = 0.0, l = 0.0;
gsl_matrix * m = gsl_matrix_alloc (n, n);
for (i = 0; i < n; i++)
for (j = 0; j < n; j++)
gsl_matrix_set (m, i, j, sin(i) + cos(j));
min = gsl_matrix_min (m);
max = gsl_matrix_max (m);
gsl_matrix_minmax (m, &min_out, &max_out);
// Minimum is -1.99995, and min and min_out are equal.
k += min - min_out;
// Maximum is 1.99991, and max and max_out are equal.
l += max - max_out;
gsl_matrix_free (m);
printf ("difference k = %g (should be zero)\n", k);
printf ("difference l = %g (should be zero)\n", l);
return 0;
}
/* pseudo graphical display of sample chunk statistical properties,
only useful with one MPI worker as it prints to terminal.
*/
void print_chunk_graph(gsl_matrix *X,/*sub-sample of CHUNK rows*/ gsl_vector *lP)/*log-Posterior values, unnormalized*/{
int width=100; // we assume that the display can show $width characters
int i,j,k,n,nc;
int tmp;
double *x;
gsl_vector_view x_view;
double Q[5];
int q[5];
double max,min,range;
char s[32],c[32];
n=X->size2;
max=gsl_matrix_max(X);
min=gsl_matrix_min(X);
range=max-min;
printf("range: [%g,%g] (%g)\n",min,max,range);
for (i=0;i<X->size1;i++){
//sort each row:
x_view=gsl_matrix_row(X,i);
gsl_sort_vector(&(x_view.vector));
//determine eachquantile
x=gsl_matrix_ptr(X,i,0);
Q[0]=gsl_stats_quantile_from_sorted_data(x,1,n,0.01);
Q[1]=gsl_stats_quantile_from_sorted_data(x,1,n,0.25);
Q[2]=gsl_stats_quantile_from_sorted_data(x,1,n,0.50);
Q[3]=gsl_stats_quantile_from_sorted_data(x,1,n,0.75);
Q[4]=gsl_stats_quantile_from_sorted_data(x,1,n,0.99);
//printf("quantiles: %g\t%g\t%g\t%g\t%g\n",Q[0],Q[1],Q[2],Q[3],Q[4]);
for (j=0;j<5;j++) {
q[j]=(int) ((Q[j]-min)*width/range);
}
sprintf(s," -LU- ");
sprintf(c,"+{|}+ ");
tmp=0;
for (k=0;k<5;k++){
nc=q[k]-tmp;
for (j=0;j<nc;j++) {
printf("%c",s[k]);
}
tmp=q[k];
printf("%c",c[k]);
}
printf("\n\n");
}
printf("|");
for (j=0;j<width-2;j++) printf("-");
printf("|\n");
printf("%+4.4g",min);
for (j=0;j<width-8;j++) printf(" ");
printf("%+4.4g\n",max);
}
//Make matrix non negative by making all elements less than zero
//as zero
int
Matrix::makePositive()
{
double minValue=gsl_matrix_min(matrix);
if(minValue>=0)
{
//This means matrix is positive
return 0;
}
minValue=minValue*-1;
for(int i=0;i<row;i++)
{
for(int j=0;j<col;j++)
{
double value=getValue(i,j);
value=value+minValue;
setValue(value,i,j);
}
}
return 0;
}
//graph size synhronization by dummy nodes adding
void experiment::synchronize(graph& g, graph& h, gsl_matrix** pgm_ldh)
{
int iadd_r=0,iadd_c=0;
if (g.get_adjmatrix()->size1>h.get_adjmatrix()->size1)
{
iadd_c=g.get_adjmatrix()->size1-h.get_adjmatrix()->size1;
};
if (g.get_adjmatrix()->size1<h.get_adjmatrix()->size1)
{
iadd_r=-g.get_adjmatrix()->size1+h.get_adjmatrix()->size1;
};
int idummy_nodes= get_param_i("dummy_nodes");
switch(idummy_nodes){
case 0://just complete the smallest graph
break;
case 1://double the matrix size
iadd_r=h.get_adjmatrix()->size1;
iadd_c=g.get_adjmatrix()->size1;
break;
};
h.add_dummy_nodes(iadd_c);
g.add_dummy_nodes(iadd_r);
if (pgm_ldh!=NULL){
gsl_matrix* gm_C_new=gsl_matrix_alloc((*pgm_ldh)->size1+iadd_r,(*pgm_ldh)->size2+iadd_c);
gsl_matrix_view gmv_C_new=gsl_matrix_submatrix(gm_C_new,0,0,(*pgm_ldh)->size1,(*pgm_ldh)->size2);
double dmin_C_blast=gsl_matrix_min((*pgm_ldh));
double dmax_C_blast=gsl_matrix_max((*pgm_ldh));
double dccoef= get_param_d("dummy_nodes_c_coef");
dmin_C_blast=(1-dccoef)*dmin_C_blast+dccoef*dmax_C_blast;
gsl_matrix_set_all(gm_C_new,dmin_C_blast);
gsl_matrix_memcpy(&gmv_C_new.matrix,(*pgm_ldh));
gsl_matrix_free((*pgm_ldh));
*pgm_ldh=gm_C_new;
};
}
int
Matrix::normalizeVector()
{
if(col>1)
{
return 0;
}
double minValue=gsl_matrix_min(matrix);
if(minValue<0)
{
minValue=-1*minValue;
for(int i=0;i<row;i++)
{
double val=getValue(i,0);
if(val<0)
{
val=val+minValue;
setValue(val,i,0);
}
}
}
double total=0;
for(int i=0;i<row;i++)
{
total=total+getValue(i,0);
}
for(int i=0;i<row;i++)
{
double val=getValue(i,0)/total;
setValue(val,i,0);
}
return 0;
}
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;
}
