void quantile_d(
CintCP len,
double V[*len],
CintCP n,
Cdouble P[*n],
double Q[*n])
{
register int i;
int j, k;
double g;
sort_d(V, *len, FALSE, FALSE); // sort vector
for (k = 0; k < *len; k++) if ( !ISNAN(V[k]) ) break; // find first NaN or NA
for (i = 0; i < *n; i++) {
g = P[i]*(*len-k-1);
j = g;
if (j == *len-k-1) Q[i] = V[*len-1]; // compute quantile
else {
g -= j;
Q[i] = (1-g)*V[j+k]+g*V[j+k+1]; // compute quantile
}
}
return;
} // quantile_d
int prep_profile(double *ordinate,
int n_data,
int n_bin,
double first_bin_min_size,
int min_number,
double ordinate_max_max,
int bin_type,
int **bin_id,
double **ordinate_min,
double **ordinate_max,
double **ordinate_avg,
int *n_bin_out){
int *ordinate_id;
int i,j,k;
double next_ordinate;
double ordinate_next;
double ordinate_step;
int accumulator;
double ordinate_stop;
int status=ERROR_NONE;
fprintf(stderr," Preparing profile bins...");
sort_d(ordinate,n_data,&ordinate_id,FALSE);
ordinate_stop=MIN(ordinate_max_max,ordinate[ordinate_id[n_data-1]]);
if(bin_type==LOG_BIN){
ordinate_next=MAX(first_bin_min_size,ordinate[ordinate_id[MIN(1,n_data-1)]]);
ordinate_step=
pow(ordinate_stop/ordinate_next,1.0/(double)(n_bin-1));
}
else{
ordinate_step=
(ordinate_stop/(double)(n_bin));
ordinate_next=ordinate_step;
if(ordinate_next<first_bin_min_size ||
ordinate_step<ordinate[ordinate_id[MIN(1,n_data-1)]]){
ordinate_next=MAX(first_bin_min_size,ordinate[ordinate_id[MIN(1,n_data-1)]]);
ordinate_step=
((ordinate_stop-ordinate_next)/(double)(n_bin-1));
}
}
(*bin_id)=(int *)malloc(sizeof(int)*n_data);
for(i=0;i<n_data;i++)
(*bin_id)[i]=-1;
(*ordinate_min) =(double *)malloc(sizeof(double)*n_bin);
(*ordinate_max) =(double *)malloc(sizeof(double)*n_bin);
(*ordinate_avg) =(double *)malloc(sizeof(double)*n_bin);
for(i=0;i<n_bin;i++)
(*ordinate_avg)[i]=0.0;
for(i=0,j=0,(*ordinate_min)[0]=0.0,accumulator=0;
i<n_data && j<n_bin && ordinate[ordinate_id[i]]<=ordinate_stop;
i++){
next_ordinate=ordinate[ordinate_id[MIN(i+1,n_data-1)]];
if(ordinate[ordinate_id[i]]>=ordinate_next &&
next_ordinate>ordinate[ordinate_id[i]]){
if(accumulator>min_number){
if(bin_type==LOG_BIN) ordinate_next*=ordinate_step;
else ordinate_next+=ordinate_step;
(*ordinate_avg)[j]/=(double)accumulator;
j++;
if(j<n_bin)
(*ordinate_min)[j]=(*ordinate_max)[j-1];
accumulator=0;
}
else {
ordinate_next=next_ordinate;
if(bin_type==LOG_BIN){
ordinate_step=
pow(ordinate_stop/ordinate_next,1.0/(double)MAX(1,n_bin-j-1));
}
else if(bin_type==LINEAR_BIN){
ordinate_step=
((ordinate_stop-ordinate_next)/(double)(n_bin-j));
}
}
}
(*ordinate_avg)[j]+=ordinate[ordinate_id[i]];
(*bin_id)[ordinate_id[i]]=j;
(*ordinate_max)[j] =ordinate[ordinate_id[i]];
accumulator++;
}
for(i=0;i<n_data;i++)
if((*bin_id)[i]==j)
(*bin_id)[i]=-1;
*n_bin_out=MIN(n_bin,j);
fprintf(stderr,"%d bins created...Done.\n",(*n_bin_out));
free(ordinate_id);
return(status);
}
void prep_profile_image(double *image,
int n_x,
int n_y,
double x_cen,
double y_cen,
int n_bin,
double first_bin_min_size,
double min_amount,
double r_max_max,
int bin_type,
int **bin_image,
double **r_min,
double **r_max,
int *n_bin_out){
int n_pix;
double *r_pix;
int *order;
int i,j,k;
double R_next;
double R_step;
double r_pix_next;
double accumulator;
double R_max;
fprintf(stderr," Creating profile bins...");
n_pix=n_x*n_y;
r_pix=(double *)malloc(sizeof(double)*n_pix);
for(j=0,k=0;j<n_y;j++){
for(i=0;i<n_x;i++){
r_pix[k]=pow(((double)i-x_cen)*((double)i-x_cen)+
((double)j-y_cen)*((double)j-y_cen),0.5);
k++;
}
}
sort_d(r_pix,n_pix,&order,TRUE);
R_max=MIN(r_max_max,r_pix[n_pix-1]);
if(bin_type==LOG_BIN){
R_next=MAX(first_bin_min_size,r_pix[MIN(1,n_pix-1)]);
R_step=
pow(R_max/R_next,1.0/(double)(n_bin-1));
}
else{
R_step=
(R_max/(double)(n_bin));
R_next=R_step;
if(R_next<first_bin_min_size ||
R_step<r_pix[MIN(1,n_pix-1)]){
R_next=MAX(first_bin_min_size,r_pix[MIN(1,n_pix-1)]);
R_step=
((R_max-R_next)/(double)(n_bin-1));
}
}
(*bin_image)=(int *)malloc(sizeof(int)*n_pix);
for(i=0;i<n_pix;i++)
(*bin_image)[i]=-1;
(*r_min) =(double *)malloc(sizeof(double)*n_bin);
(*r_max) =(double *)malloc(sizeof(double)*n_bin);
for(i=0,j=0,(*r_min)[0]=0.0,accumulator=0.0;
i<n_pix && j<n_bin && r_pix[i]<=R_max;
i++){
r_pix_next=r_pix[MIN(i+1,n_pix-1)];
if(r_pix[i]>=R_next &&
r_pix_next>r_pix[i]){
if(accumulator>min_amount){
if(bin_type==LOG_BIN) R_next*=R_step;
else R_next+=R_step;
j++;
if(j<n_bin)
(*r_min)[j]=(*r_max)[j-1];
accumulator=0.0;
}
else {
R_next=r_pix_next;
if(bin_type==LOG_BIN){
R_step=
pow(R_max/R_next,1.0/(double)MAX(1,n_bin-j-1));
}
else if(bin_type==LINEAR_BIN){
R_step=
((R_max-R_next)/(double)(n_bin-j));
}
}
}
(*bin_image)[order[i]]=j;
(*r_max)[j] =r_pix[i];
accumulator+=image[order[i]];
}
*n_bin_out=MIN(n_bin,j+1);
fprintf(stderr,"%d bins created...Done.\n",(*n_bin_out));
free(r_pix);
free(order);
}
float mapper(struct preprocessing *preproc,
struct mapping_algorithm *algorithm,
struct cost_function *cfunction,
struct platform_resources *platform,
struct waveform_resources *waveform,
struct mapping_result *result)
{
int i, j; // loop indices
float cost; // mapping cost
float m[Mmax];
// t-mapping: trellis organization
int nodes[Nmax][Mmax]; // 2D-array of N*M nodes that can be traspassed in the trellis
//int (*ptr_nodes)[Mmax];
int count; // integer counter
/* primero compruebas que las variables de entrada sean correctas */
/*if (...)
return -1;
*/
// COPIES
/* number of processors and tasks */
N = platform->nof_processors; // number of platform's processors
M = waveform->nof_tasks; // number of application's tasks/SDR functions/processes
// INITIALIZATIONS
//ptr_nodes = nodes;
// trellis organization: 'trellis nodes' (2D-array) numbered to be accessible by a single number or dimension
count = 0;
for (i=0; i<M; i++)
for (j=0; j<N; j++)
nodes[j][i] = count++;
/* cost function parameters */
q1 = cfunction->q;
q2 = (float)1-q1;
mhop = cfunction->mhop;
/* application and platform resources and parameters */
for (i=0; i<M; i++)
m[i] = waveform->c[i];
/** IGM: fill force idx vector */
for (i=0; i<M; i++)
force_idx[i] = waveform->force[i];
for (i=0; i<M; i++)
for (j=0; j<M; j++)
b[i][j] = waveform->b[i][j];
for (i=0; i<N; i++)
P[i] = platform->C[i];
for (i=0; i<N; i++)
for (j=0; j<N; j++)
L[i][j] = platform->B[i][j];
arch = platform->arch;
resource_trans();
/* preprocessing */
switch (preproc->ord) {
case no_ord:
for (i=0; i<M; i++)
m_sort[i] = m[i];
break;
case c_ord:
sort_d(m);
break;
case b_ord:
sort_b(m);
break;
default:
for (i=0; i<M; i++)
m_sort[i] = m[i];
}
cost = tw_mapping(nodes, algorithm->w);
for (i=0;i<M;i++) {
result->P_m[i]=final_map[i];
}
return cost;
}
