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);
}
/*!
If necessary, convert the problem from a maximum assignment into a minimum
assignment. We do this by letting C = maximum value in the assignment matrix.
Replace each c_{i,j} with C - c_{i,j}.
*/
int ConvertToMinAsg(gsl_matrix * const M)
{
float max;
if(M == NULL) return GSL_EINVAL;
// Find maximum value in matrix
max = gsl_matrix_max(M);
for(int i = 0; i < M->size1; ++i)
for(int j = 0; j < M->size2; ++j)
// Subtract element values from C
gsl_matrix_set(M, i, j, max - gsl_matrix_get(M, 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;
};
}
void
gslu_matrix_printfc (const gsl_matrix *A, const char *name, const char *fmt, CBLAS_TRANSPOSE_t Trans)
{
// figure out our terminal window size
int ncols = 0;
struct winsize w;
if (ioctl (0, TIOCGWINSZ, &w))
ncols = 80;
else
ncols = round (w.ws_col / 12.0);
if (ncols == 0)
ncols = 80;
if (name != NULL && Trans==CblasNoTrans)
printf ("%s =\n", name);
else
printf ("%s' =\n", name);
// default printf format
int __default__ = 1;
if (fmt == NULL)
fmt = "%10.4f";
else
__default__ = 0;
size_t size1, size2;
if (Trans == CblasNoTrans) {
size1 = A->size1;
size2 = A->size2;
} else {
size1 = A->size2;
size2 = A->size1;
}
// emulate matlab scientific format
bool scifmt = 0;
const int scimin = -3;
const int scimax = 4;
const double ZERO = DBL_EPSILON;
double fabsmax = fabs (gsl_matrix_max (A));
int sci;
if (fabsmax > ZERO)
sci = floor (log10 (fabsmax));
else
sci = 0;
if (sci < scimin) {
sci++;
scifmt = 1;
}
else if (sci > scimax) {
sci--;
scifmt = 1;
}
const double tens = pow (10, sci);
if (scifmt)
printf (" 1.0e%+03d *\n", sci);
// print matrix
for (size_t n=0; n < size2; n+=ncols) {
if (ncols < size2) {
if (n == (size2 - 1))
printf (" Column %zd\n", n);
else
printf (" Columns %zd through %zd\n", n, GSL_MIN(n+ncols, size2)-1);
}
for (size_t i=0; i<size1; i++) {
for (size_t j=GSL_MIN(n, size2); j<GSL_MIN(n+ncols, size2); j++) {
double v;
if (Trans == CblasNoTrans)
v = gsl_matrix_get (A, i, j);
else
v = gsl_matrix_get (A, j, i);
if (scifmt)
v /= tens;
if (__default__ && fabs (v) < ZERO)
printf ("%10.4g", 0.0);
else
printf (fmt, v);
printf (" ");
}
printf ("\n");
}
}
}
double
Matrix::getMax()
{
double val=gsl_matrix_max(matrix);
return val;
}
int w_update(
gsl_matrix *weights,
gsl_matrix *x_white,
gsl_matrix *bias,
gsl_matrix *shuffled_x_white, //work space for shuffled x_white
gsl_permutation *p, // random permutation
gsl_rng *r, // random stream from gsl
double lrate){
int error = 0;
size_t i;
const size_t NVOX = x_white->size2;
const size_t NCOMP = x_white->size1;
size_t block = (size_t)floor(sqrt(NVOX/3.0));
gsl_matrix *ib = gsl_matrix_alloc(1,block);
gsl_matrix_set_all( ib, 1.0);
gsl_ran_shuffle (r, p->data, NVOX, sizeof(size_t));
// gsl_matrix *shuffled_x_white = gsl_matrix_alloc(NCOMP,NVOX);
// gsl_matrix_memcpy(shuffled_x_white, x_white);
gsl_vector_view arow;
#pragma omp parallel for private(i,arow)
for (i = 0; i < x_white->size1; i++) {
arow = gsl_matrix_row(shuffled_x_white,i);
gsl_permute_vector (p, &arow.vector);
}
size_t start;
gsl_matrix *unmixed = gsl_matrix_alloc(NCOMP,block);
gsl_matrix *unm_logit = gsl_matrix_alloc(NCOMP,block);
gsl_matrix *temp_I = gsl_matrix_alloc(NCOMP,NCOMP);
gsl_matrix *ones = gsl_matrix_alloc(block,1);
gsl_matrix_set_all(ones, 1.0);
double max;
gsl_matrix_view sub_x_white_view;
// gsl_matrix *d_unmixer = gsl_matrix_alloc(NCOMP,NCOMP);
for (start = 0; start < NVOX; start = start + block) {
if (start + block > NVOX-1){
block = NVOX-start;
gsl_matrix_free(ib);
ib = gsl_matrix_alloc(1,block);
gsl_matrix_set_all( ib, 1.0);
gsl_matrix_free(unmixed);
unmixed = gsl_matrix_alloc(NCOMP,block);
gsl_matrix_free(unm_logit);
unm_logit = gsl_matrix_alloc(NCOMP,block);
gsl_matrix_free(ones);
ones = gsl_matrix_alloc(block,1);
gsl_matrix_set_all(ones, 1.0);
}
// sub_x_white = xwhite[:, permute[start:start+block]]
sub_x_white_view = gsl_matrix_submatrix(shuffled_x_white, 0,start, NCOMP, block );
// Compute unmixed = weights . sub_x_white + bias . ib
matrix_mmul(weights, &sub_x_white_view.matrix, unmixed);
gsl_blas_dgemm(CblasNoTrans, CblasNoTrans,
1.0, bias, ib, 1.0, unmixed);
// Compute 1-2*logit
gsl_matrix_memcpy(unm_logit, unmixed);
matrix_apply_all(unm_logit, logit);
// weights = weights + lrate*(block*I+(unm_logit*unmixed.T))*weights
gsl_matrix_set_identity(temp_I); // temp_I = I
// (1) temp_I = block*temp_I +unm_logit*unmixed.T
gsl_blas_dgemm( CblasNoTrans,CblasTrans,
1.0, unm_logit, unmixed,
(double)block , temp_I);
// BE CAREFUL with aliasing here! use d_unmixer if problems arise
// gsl_matrix_memcpy(d_unmixer, weights);
// (2) weights = weights + lrate*temp_I*weights
gsl_blas_dgemm( CblasNoTrans,CblasNoTrans,
lrate, temp_I, weights,
1.0, weights);
// Update the bias
gsl_blas_dgemm( CblasNoTrans, CblasNoTrans,
lrate, unm_logit, ones,
1.0, bias);
// check if blows up
max = gsl_matrix_max(weights);
if (max > MAX_W){
if (lrate<1e-6) {
printf("\nERROR: Weight matrix may not be invertible\n");
error = 2;
break;
}
error = 1;
break;
}
}
// set number of threads back to normal
// openblas_set_num _threads(MAX_THREAD);
//clean up
// gsl_rng_free (r);
// gsl_permutation_free (p);
// gsl_matrix_free(d_unmixer);
gsl_matrix_free(ib);
gsl_matrix_free(unmixed);
gsl_matrix_free(temp_I);
gsl_matrix_free(ones);
gsl_matrix_free(unm_logit);
// gsl_matrix_free(shuffled_x_white);
return(error);
}
int Holling2(double t, const double y[], double ydot[], void *params){
double alpha = 0.3; // respiration
double lambda = 0.65; // ecologic efficiency
double hand = 0.35; // handling time
double beta = 0.5; // intraspecific competition
double aij = 6.0; // attack rate
//double migratingPop = 0.01;
int i, j,l = 0; // Hilfsvariablen
double rowsum = 0;
//double colsum = 0;
// int test = 0;
//
// if(test<5)
// {
// printf("Richtiges Holling");
// }
// test++;
//-- Struktur zerlegen-------------------------------------------------------------------------------------------------------------------------------
struct foodweb *nicheweb = (struct foodweb *)params; // pointer cast from (void*) to (struct foodweb*)
//printf("t in Holling 2=%f\n", t);
gsl_vector *network = (nicheweb->network); // Inhalt: A+linksA+Y+linksY+Massen+Trophische_Level = (Rnum+S)²+1+Y²+1+(Rnum+S)+S
int S = nicheweb->S;
int Y = nicheweb->Y;
int Rnum = nicheweb->Rnum;
//double d = nicheweb->d;
int Z = nicheweb->Z;
//double dij = pow(10, d);
double Bmigr = gsl_vector_get(network, (Rnum+S)*(S+Rnum)+1+Y*Y+1+(Rnum+S)+S);
//printf("Bmigr ist %f\n", Bmigr);
double nu,mu, tau;
int SpeciesNumber;
tau = gsl_vector_get(nicheweb->migrPara,0);
mu = gsl_vector_get(nicheweb->migrPara,1);
// if((int)nu!=0)
// {
// printf("nu ist nicht null sondern %f\n",nu);
// }
nu = gsl_vector_get(nicheweb->migrPara,2);
SpeciesNumber = gsl_vector_get(nicheweb->migrPara,3);
double tlast = gsl_vector_get(nicheweb->migrPara,4);
// if(SpeciesNumber!= 0)
// {
// //printf("SpeciesNumber %i\n", SpeciesNumber);
// }
//printf("t oben %f\n",t);
//int len = (Rnum+S)*(Rnum+S)+2+Y*Y+(Rnum+S)+S;
gsl_vector_view A_view = gsl_vector_subvector(network, 0, (Rnum+S)*(Rnum+S)); // Fressmatrix A als Vektor
gsl_matrix_view EA_mat = gsl_matrix_view_vector(&A_view.vector, (Rnum+S), (Rnum+S)); // A als Matrix_view
gsl_matrix *EAmat = &EA_mat.matrix; // A als Matrix
gsl_vector_view D_view = gsl_vector_subvector(network, (Rnum+S)*(Rnum+S)+1, Y*Y); // Migrationsmatrix D als Vektor
gsl_matrix_view ED_mat = gsl_matrix_view_vector(&D_view.vector, Y, Y); // D als Matrixview
gsl_matrix *EDmat = &ED_mat.matrix; // D als Matrix
gsl_vector_view M_vec = gsl_vector_subvector(network, ((Rnum+S)*(Rnum+S))+1+(Y*Y)+1, (Rnum+S)); // Massenvektor
gsl_vector *Mvec = &M_vec.vector;
//-- verändere zu dem gewünschten Zeitpunkt Migrationsmatrix
if( (t > tau) && (tlast < tau))
{
//printf("mu ist %f\n", gsl_vector_get(nicheweb->migrPara,1));
//printf("nu ist %f\n", nu);
gsl_vector_set(nicheweb->migrPara,4,t);
//printf("Setze Link für gewünschte Migration\n");
// printf("t oben %f\n",t);
// printf("tlast oben %f\n",tlast);
gsl_matrix_set(EDmat, nu, mu, 1.);
//int m;
// for(l = 0; l< Y;l++)
// {
// for(m=0;m<Y;m++)
// {
// printf("%f\t",gsl_matrix_get(EDmat,l,m));
// }
// printf("\n");
// }
}
else
{
gsl_matrix_set_zero(EDmat);
}
// printf("\ncheckpoint Holling2 I\n");
// printf("\nS = %i\n", S);
// printf("\nS + Rnum = %i\n", S+Rnum);
//
// printf("\nSize A_view = %i\n", (int)A_view.vector.size);
// printf("\nSize D_view = %i\n", (int)D_view.vector.size);
// printf("\nSize M_vec = %i\n", (int)M_vec.vector.size);
// for(i=0; i<(Rnum+S)*Y; i++){
// printf("\ny = %f\n", y[i]);
// }
// for(i=0; i<(Rnum+S)*Y; i++){
// printf("\nydot = %f\n", ydot[i]);
// }
//--zusätzliche Variablen anlegen-------------------------------------------------------------------------------------------------------------
double ytemp[(Rnum+S)*Y];
for(i=0; i<(Rnum+S)*Y; i++) ytemp[i] = y[i]; // temp array mit Kopie der Startwerte
for(i=0; i<(Rnum+S)*Y; i++) ydot[i] = 0; // Ergebnis, in das evolve_apply schreibt
gsl_vector_view yfddot_vec = gsl_vector_view_array(ydot, (Rnum+S)*Y); //Notiz: vector_view_array etc. arbeiten auf den original Daten der ihnen zugeordneten Arrays/Vektoren!
gsl_vector *yfddotvec = &yfddot_vec.vector; // zum einfacheren Rechnen ydot über vector_view_array ansprechen
gsl_vector_view yfd_vec = gsl_vector_view_array(ytemp, (Rnum+S)*Y);
gsl_vector *yfdvec = &yfd_vec.vector; // Startwerte der Populationen
//-- neue Objekte zum Rechnen anlegen--------------------------------------------------------------------------------------------------------
gsl_matrix *AFgsl = gsl_matrix_calloc(Rnum+S, Rnum+S); // matrix of foraging efforts
// gsl_matrix *ADgsl = gsl_matrix_calloc(Y,Y); // matrix of migration efforts
gsl_matrix *Emat = gsl_matrix_calloc(Rnum+S, Rnum+S); // gsl objects for calculations of populations
gsl_vector *tvec = gsl_vector_calloc(Rnum+S);
gsl_vector *rvec = gsl_vector_calloc(Rnum+S);
gsl_vector *svec = gsl_vector_calloc(Rnum+S);
// gsl_matrix *Dmat = gsl_matrix_calloc(Y,Y); // gsl objects for calculations of migration
// gsl_vector *d1vec = gsl_vector_calloc(Y);
gsl_vector *d2vec = gsl_vector_calloc(Y);
gsl_vector *d3vec = gsl_vector_calloc(Y);
// printf("\ncheckpoint Holling2 III\n");
//-- Einzelne Patches lösen------------------------------------------------------------------------------------------------------------
for(l=0; l<Y; l++) // start of patch solving
{
gsl_matrix_set_zero(AFgsl); // Objekte zum Rechnen vor jedem Patch nullen
gsl_matrix_set_zero(Emat);
gsl_vector_set_zero(tvec);
gsl_vector_set_zero(rvec);
gsl_vector_set_zero(svec);
gsl_vector_view ydot_vec = gsl_vector_subvector(yfddotvec, (Rnum+S)*l, (Rnum+S)); // enthält ydot von Patch l
gsl_vector *ydotvec = &ydot_vec.vector;
gsl_vector_view y_vec = gsl_vector_subvector(yfdvec, (Rnum+S)*l, (Rnum+S)); // enthält Startwerte der Population in l
gsl_vector *yvec = &y_vec.vector;
gsl_matrix_memcpy(AFgsl, EAmat);
for(i=0; i<Rnum+S; i++)
{
gsl_vector_view rowA = gsl_matrix_row(AFgsl,i);
rowsum = gsl_blas_dasum(&rowA.vector);
if(rowsum !=0 )
{
for(j=0; j<Rnum+S; j++)
gsl_matrix_set(AFgsl, i, j, (gsl_matrix_get(AFgsl,i,j)/rowsum)); // normiere Beute Afgsl = A(Beutelinks auf 1 normiert) = f(i,j)
}
}
gsl_matrix_memcpy(Emat, EAmat); // Emat = A
gsl_matrix_scale(Emat, aij); // Emat(i,j) = a(i,j)
gsl_matrix_mul_elements(Emat, AFgsl); // Emat(i,j) = a(i,j)*f(i,j)
gsl_vector_memcpy(svec, yvec); // s(i) = y(i)
gsl_vector_scale(svec, hand); // s(i) = y(i)*h
gsl_blas_dgemv(CblasNoTrans, 1, Emat, svec, 0, rvec); // r(i) = Sum_k h*a(i,k)*f(i,k)*y(k)
gsl_vector_add_constant(rvec, 1); // r(i) = 1+Sum_k h*a(i,k)*f(i,k)*y(k)
gsl_vector_memcpy(tvec, Mvec); // t(i) = masse(i)^(-0.25)
gsl_vector_div(tvec, rvec); // t(i) = masse(i)^(-0.25)/(1+Sum_k h*a(i,k)*f(i,k)*y(k))
gsl_vector_mul(tvec, yvec); // t(i) = masse(i)^(-0.25)*y(i)/(1+Sum_k h*a(i,k)*f(i,k)*y(k))
gsl_blas_dgemv(CblasTrans, 1, Emat, tvec, 0, rvec); // r(i) = Sum_j a(j,i)*f(j,i)*t(j)
gsl_vector_mul(rvec, yvec); // r(i) = Sum_j a(j,i)*f(j,i)*t(j)*y(i) [rvec: Praedation]
gsl_blas_dgemv(CblasNoTrans, lambda, Emat, yvec, 0, ydotvec); // ydot(i) = Sum_j lambda*a(i,j)*f(i,j)*y(j)
gsl_vector_mul(ydotvec, tvec); // ydot(i) = Sum_j lambda*a(i,j)*f(i,j)*y(j)*t(i)
gsl_vector_memcpy(svec, Mvec);
gsl_vector_scale(svec, alpha); // s(i) = alpha*masse^(-0.25) [svec=Respiration bzw. Mortalitaet]
gsl_vector_memcpy(tvec, Mvec);
gsl_vector_scale(tvec, beta); // t(i) = beta*masse^(-0.25)
gsl_vector_mul(tvec, yvec); // t(i) = beta*y(i)
gsl_vector_add(svec, tvec); // s(i) = alpha*masse^(-0.25)+beta*y(i)
gsl_vector_mul(svec, yvec); // s(i) = alpha*masse^(-0.25)*y(i)+beta*y(i)*y(i)
gsl_vector_add(svec, rvec); // [svec: Respiration, competition und Praedation]
gsl_vector_sub(ydotvec, svec); // ydot(i) = Fressen-Respiration-Competition-Praedation
for(i=0; i<Rnum; i++)
gsl_vector_set(ydotvec, i, 0.0); // konstante Ressourcen
}// Ende Einzelpatch, Ergebnis steht in ydotvec
// printf("\ncheckpoint Holling2 IV\n");
//-- Migration lösen---------------------------------------------------------------------------------------------------------
gsl_vector *ydottest = gsl_vector_calloc(Y);
double ydotmigr = gsl_vector_get(nicheweb->migrPara, 5);
// int count=0,m;
// for(l = 0; l< Y;l++)
// {
// for(m=0;m<Y;m++)
// {
// count += gsl_matrix_get(EDmat,l,m);
// }
// }
// if(count!=0)
// {
// //printf("count %i\n",count);
// //printf("t unten %f\n",t);
// //printf("tau %f\n",tau);
// for(l = 0; l< Y;l++)
// {
// for(m=0;m<Y;m++)
// {
// printf("%f\t",gsl_matrix_get(EDmat,l,m));
// }
// printf("\n");
// }
// }
double max = gsl_matrix_max(EDmat);
for(l = Rnum; l< Rnum+S; l++) // start of migration solving
{
if(l == SpeciesNumber+Rnum && max !=0 )
{
//printf("max ist %f\n",max);
//printf("l ist %i\n",l);
// gsl_matrix_set_zero(ADgsl); // reset gsl objects for every patch
// gsl_matrix_set_zero(Dmat);
// gsl_vector_set_zero(d1vec);
gsl_vector_set_zero(d2vec);
gsl_vector_set_zero(d3vec);
gsl_vector_set_zero(ydottest);
// Untervektor von yfddot (enthält ydot[]) mit offset l (Rnum...Rnum+S) und Abstand zwischen den Elementen (stride) von Rnum+S.
// Dies ergibt gerade die Größe einer Spezies in jedem Patch in einem Vektor
gsl_vector_view dydot_vec = gsl_vector_subvector_with_stride(yfddotvec, l, (Rnum+S), Y); // ydot[]
gsl_vector *dydotvec = &dydot_vec.vector;
/*
gsl_vector_view dy_vec = gsl_vector_subvector_with_stride(yfdvec, l, (Rnum+S), Y); // Startgrößen der Spezies pro Patch
gsl_vector *dyvec = &dy_vec.vector;
*/
// gsl_matrix_memcpy(ADgsl, EDmat); // ADgsl = D
//
// if(nicheweb->M == 1) // umschalten w: patchwise (Abwanderung aus jedem Patch gleich), sonst linkwise (Abwanderung pro link gleich)
// {
// for(i=0; i<Y; i++)
// {
// gsl_vector_view colD = gsl_matrix_column(ADgsl, i); // Spalte i aus Migrationsmatrix
// colsum = gsl_blas_dasum(&colD.vector);
// if(colsum!=0)
// {
// for(j=0;j<Y;j++)
// gsl_matrix_set(ADgsl,j,i,(gsl_matrix_get(ADgsl,j,i)/colsum)); // ADgsl: D mit normierten Links
// }
// }
// }
//
// gsl_matrix_memcpy(Dmat, EDmat); // Dmat = D
// gsl_matrix_scale(Dmat, dij); // Dmat(i,j) = d(i,j) (Migrationsstärke)
// gsl_matrix_mul_elements(Dmat, ADgsl); // Dmat(i,j) = d(i,j)*xi(i,j) (skalierte und normierte Migrationsmatrix)
//
// gsl_vector_set_all(d1vec, 1/gsl_vector_get(Mvec, l)); // d1(i)= m(l)^0.25
// gsl_vector_mul(d1vec, dyvec); // d1(i)= m(l)^0.25*y(i)
// gsl_blas_dgemv(CblasNoTrans, 1, Dmat, d1vec, 0, d2vec); // d2(i)= Sum_j d(i,j)*xi(i,j)*m(l)^0.25*y(j)
//
// gsl_vector_set_all(d1vec, 1); // d1(i)= 1
// gsl_blas_dgemv(CblasTrans, 1, Dmat, d1vec, 0, d3vec); // d3(i)= Sum_j d(i,j)*xi(i,j)
// gsl_vector_scale(d3vec, 1/gsl_vector_get(Mvec,l)); // d3(i)= Sum_j d(i,j)*xi(i,j)*m(l)^0.25
// gsl_vector_mul(d3vec, dyvec); // d3(i)= Sum_j d(i,j)*xi(i,j)*m(l)^0.25*y(i)
//
gsl_vector_set(d2vec,nu,Bmigr);
gsl_vector_set(d3vec,mu,Bmigr);
gsl_vector_add(ydottest,d2vec);
gsl_vector_sub(ydottest,d3vec);
//printf("d2vec ist %f\n",gsl_vector_get(d2vec,0));
//printf("d3vec ist %f\n",gsl_vector_get(d3vec,0));
//if(gsl_vector_get(ydottest,mu)!=0)
//{
ydotmigr += gsl_vector_get(ydottest,nu);
// printf("ydotmigr ist %f\n",ydotmigr);
gsl_vector_set(nicheweb->migrPara,5,ydotmigr);
// if(ydotmigr !=0)
// {
// printf("ydottest aufaddiert ist %f\n",ydotmigr);
// printf("ydottest aufaddiert ist %f\n",gsl_vector_get(nicheweb->migrPara,5));
// }
gsl_vector_add(dydotvec, d2vec); //
gsl_vector_sub(dydotvec, d3vec); // Ergebnis in dydotvec (also ydot[]) = Sum_j d(i,j)*xi(i,j)*m(l)^0.25*y(j) - Sum_j d(i,j)*xi(i,j)*m(l)^0.25*y(i)
}
}// Patch i gewinnt das was aus allen j Patches zuwandert und verliert was von i auswandert
//printf("ydot ist %f\n",gsl_vector_get(ydottest,0));
//printf("\ncheckpoint Holling2 V\n");
/*
for(i=0; i<(Rnum+S)*Y; i++){
printf("\ny = %f\tydot=%f\n", y[i], ydot[i]);
}
*/
//--check for fixed point attractor-----------------------------------------------------------------------------------
if(t>7800){
gsl_vector_set(nicheweb->fixpunkte, 0, 0);
gsl_vector_set(nicheweb->fixpunkte, 1, 0);
gsl_vector_set(nicheweb->fixpunkte, 2, 0);
int fix0 = (int)gsl_vector_get(nicheweb->fixpunkte, 0);
int fix1 = (int)gsl_vector_get(nicheweb->fixpunkte, 1);
int fix2 = (int)gsl_vector_get(nicheweb->fixpunkte, 2);
//printf("t unten = %f\n", t);
for(i=0; i<(Rnum+S)*Y; i++)
{
if(y[i] <= 0)
{
fix0++;
fix1++;
fix2++;
}
else
{
if((ydot[i]/y[i]<0.0001) || (ydot[i]<0.0001)) fix0++;
if(ydot[i]/y[i]<0.0001) fix1++;
if(ydot[i]<0.0001) fix2++;
}
}
if(fix0==(Rnum+S)*Y) gsl_vector_set(nicheweb->fixpunkte, 3, 1);
if(fix1==(Rnum+S)*Y) gsl_vector_set(nicheweb->fixpunkte, 4, 1);
if(fix2==(Rnum+S)*Y) gsl_vector_set(nicheweb->fixpunkte, 5, 1);
}
//--Speicher leeren-----------------------------------------------------------------------------------------------------
gsl_matrix_free(Emat);
// gsl_matrix_free(Dmat);
gsl_matrix_free(AFgsl);
// gsl_matrix_free(ADgsl);
gsl_vector_free(tvec);
gsl_vector_free(rvec);
gsl_vector_free(svec);
// gsl_vector_free(d1vec);
gsl_vector_free(d2vec);
gsl_vector_free(d3vec);
gsl_vector_free(ydottest);
// printf("\nCheckpoint Holling2 VI\n");
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;
}
