int main(int argc, char **argv){
float **shake_dim_min_to_max_matrix = NULL; /* N*dim */
FILE *ifp = NULL;
FILE *ofp = NULL;
int with_sample_ID = 1;
int arg_stat = 0;
int i = 0;
int j = 0;
char dim_string[TMP_STRING_LEN];
int grid_tensor_elms = 1;
int grid_tensor_rank = 1;
int *grid_tensor_dim = NULL;
int **tensor_position_matrix = NULL;
float **tensor_vars = NULL;
/* temporary vars */
int tmp_ptr_arr = 0;
int tmp_ptr_word = 0;
char *tmp_word;
tmp_word = c_alloc_vec(SHORT_STRING_LEN);
if(argc == 2){
if(strcmp(argv[1],"-h") == 0){
message();
usage();
options();
}else{
message();
usage();
}
}else if(argc >= 4){
arg_stat = get_options(1,argc,argv);
if((arg_stat&22) != 22){
usage();
exit(1);
}
/* (* check file format */
int max_col = 0;
int min_col = 0;
int lines = 0;
if((ifp = fopen(sample_file,"r")) == NULL){
perror(sample_file);
exit(1);
}
read_ilist_from_stream(1,ifp,&dim_data);
read_ilist_from_stream(1,ifp,&num_data);
fgetc(ifp);
count_column_from_stream(ifp,&lines,&max_col,&min_col);
fclose(ifp);
fprintf(stderr,"1st line information: dim:%d: num:%d:\n",dim_data,num_data);
fprintf(stderr,"count: max:%d: min:%d: lines:%d:\n",max_col,min_col,lines);
if(max_col != min_col){
fprintf(stderr,"[EROOR] something wrong: max_col not min_col.\n");
exit(1);
}
if(dim_data == max_col){
fprintf(stderr,"dim_data == num of columns: with_sample_ID = 0.\n");
with_sample_ID = 0;
}else if((dim_data + 1) == max_col){
fprintf(stderr,"dim_data + 1 == num of columns: with_sample_ID = 1.\n");
with_sample_ID = 1;
}
/* *) */
/* (* scan data, allocate mem, read data */
if((ifp = fopen(sample_file,"r")) == NULL){
perror(sample_file);
exit(1);
}
read_ilist_from_stream(1,ifp,&dim_data);
read_ilist_from_stream(1,ifp,&num_data);
data_matrix = f_alloc_mat(num_data,dim_data);
sample_id = c_alloc_mat(num_data,ID_LEN);
if(with_sample_ID == 1){
read_ID_ftable_from_stream(num_data,dim_data,ifp,data_matrix,sample_id);
}else if(with_sample_ID == 0){
read_ftable_from_stream(num_data,dim_data,ifp,data_matrix);
}
fclose(ifp);
dim_clst = dim_data;
dim_min_and_max_table = f_alloc_mat(2,dim_data);
/* *) */
/* (* set min_dim_list to dim_min_and_max_table[0] */
min_list_from_matrix(dim_data,num_data,data_matrix,dim_min_and_max_table[0],0);
/* *) */
/* (* set max_dim_list to dim_min_and_max_table[1] */
max_list_from_matrix(dim_data,num_data,data_matrix,dim_min_and_max_table[1],0);
/* *) */
/* (* set ticks to dim_min_to_max_matrix */
dim_min_to_max_matrix = f_alloc_mat(num_clst,dim_data);
make_min_to_max_table(num_clst,dim_data,dim_min_and_max_table,dim_min_to_max_matrix);
/* *) */
/* (* change operation by coordinate_option */
if((strcmp(coordinate_option,"Diagonal") == 0)||(strcmp(coordinate_option,"-D") == 0)){
/* (* copy pointer for write to file */
out_matrix = dim_min_to_max_matrix;
/* *) */
}else if(strcmp(coordinate_option,"random=Order") == 0){
/* (* generate random order */
int_rand_order_matrix = i_alloc_mat(dim_data,num_clst);
t = time(NULL);
for(i=0;i<dim_data;i++){
srand(t+33*i);
mk_int_rand_order_list(0,num_clst-1,int_rand_order_matrix[i],t+pow(5,i)+(13*i)+seed);
}
/* *) */
/* (* set shake_dim_min_to_max_matrix from random_order & min_max_matrix */
shake_dim_min_to_max_matrix = f_alloc_mat(num_clst,dim_data);
for(j=0;j<num_clst;j++){
for(i=0;i<dim_data;i++){
shake_dim_min_to_max_matrix[j][i] = dim_min_to_max_matrix[int_rand_order_matrix[i][j]][i];
}
}
/* *) */
/* (* copy pointer for write to file */
out_matrix = shake_dim_min_to_max_matrix;
/* *) */
}else if(strcmp(coordinate_option,"random=Value") == 0){
t = time(NULL);
dim_min_to_max_matrix = f_alloc_mat(num_clst,dim_data);
mk_rand_coordinate(num_clst,dim_data,dim_min_and_max_table,dim_min_to_max_matrix,t+seed);
out_matrix = dim_min_to_max_matrix;
}else if(strcmp(coordinate_option,"node=Central") == 0){
/* check num */
if(num_data < num_clst){
printf("%d,%d\n",num_data,num_clst);
fprintf(stderr,"Warn : number of clusters exceeded number of samples.\n");
exit(1);
}
/* init id_distance */
id_distance = status_alloc_list(num_data);
for(i=0;i<num_data;i++){
id_distance[i].pos = i;
id_distance[i].value = 0;
}
/* set centroid */
centroid = f_calloc_vec(dim_data);
for(i=0;i<num_data;i++){
for(j=0;j<dim_data;j++){
centroid[j] += data_matrix[i][j];
}
}
for(j=0;j<dim_data;j++){
centroid[j] = centroid[j]/num_data;
}
/* set id_distance */
for(i=0;i<num_data;i++){
id_distance[i].value = euc_dist(dim_data,centroid,data_matrix[i]);
}
/* sort id_distance by distance */
qsort(id_distance,num_data,sizeof(struct status),(int(*)(const void*, const void*))cmp_dist);
out_matrix = data_matrix;
}else if(strcmp(coordinate_option,"node=diStant") == 0){
if(num_data < num_clst){
fprintf(stderr,"Warn : number of clusters exceeded number of samples.\n");
exit(1);
}
origin = f_calloc_vec(dim_data);
origin_data_dist_list = f_alloc_vec(num_data);
for(i=0;i<num_data;i++){
origin_data_dist_list[i] = euc_dist(dim_data,origin,data_matrix[i]);
}
id_distance = status_alloc_list(num_data);
for(i=0;i<num_data;i++){
id_distance[i].pos = i;
id_distance[i].value = origin_data_dist_list[i];
}
qsort(id_distance,num_data,sizeof(struct status),(int(*)(const void*, const void*))alt_cmp_dist);
out_matrix = data_matrix;
}else if(strcmp(coordinate_option,"node=Power") == 0){
if(num_data < num_clst){
fprintf(stderr,"Warn : number of clusters exceeded number of samples.\n");
exit(1);
}
id_distance = status_alloc_list(num_data);
for(i=0;i<num_data;i++){
id_distance[i].pos = i;
id_distance[i].value = 0;
}
for(i=0;i<num_data;i++){
for(j=0;j<dim_data;j++){
id_distance[i].value = id_distance[i].value + data_matrix[i][j];
}
}
qsort(id_distance,num_data,sizeof(struct status),(int(*)(const void*, const void*))alt_cmp_dist);
out_matrix = data_matrix;
}else if(strcmp(coordinate_option,"node=outLying") == 0){
if(num_data < num_clst){
fprintf(stderr,"Warn : number of clusters exceeded number of samples.\n");
exit(1);
}
id_distance = status_alloc_list(num_data);
for(i=0;i<num_data;i++){
id_distance[i].pos = i;
id_distance[i].value = 0;
}
centroid = f_calloc_vec(dim_data);
for(i=0;i<num_data;i++){
for(j=0;j<dim_data;j++){
centroid[j] += data_matrix[i][j];
}
}
for(j=0;j<dim_data;j++){
centroid[j] = centroid[j]/num_data;
}
for(i=0;i<num_data;i++){
id_distance[i].value = euc_dist(dim_data,centroid,data_matrix[i]);
}
qsort(id_distance,num_data,sizeof(struct status),(int(*)(const void*, const void*))alt_cmp_dist);
out_matrix = data_matrix;
}else if(strcmp(coordinate_option,"node=Intensive") == 0){
if(num_data < num_clst){
fprintf(stderr,"Warn : number of cluster exceeded number of samples.\n");
exit(1);
}
id_distance = status_alloc_list(num_data);
for(i=0;i<num_data;i++){
id_distance[i].pos = i;
id_distance[i].value = 0;
}
for(i=0;i<num_data;i++){
for(j=0;j<=i;j++){
id_distance[i].value += euc_dist(dim_data,data_matrix[i],data_matrix[j]);
}
}
for(i=0;i<num_data;i++){
for(j=num_data-1;j>i;j--){
id_distance[i].value += euc_dist(dim_data,data_matrix[j],data_matrix[i]);
}
}
qsort(id_distance,num_data,sizeof(struct status),(int(*)(const void*, const void*))cmp_dist);
out_matrix = data_matrix;
}else if(strncmp(coordinate_option,"node=Median",11) == 0){
//fprintf(stderr,"HOGE!!\n");
double delta = 0;
int data_ptr = 0;
int bin_ptr = 0;
int total_bin_count = 0;
//int tmp = 0;
/* check num */
if(num_data < num_clst){
printf("%d,%d\n",num_data,num_clst);
fprintf(stderr,"Warn : number of clusters exceeded number of samples.\n");
exit(1);
}
/* init id_distance */
id_distance = status_alloc_list(num_data);
for(i=0;i<num_data;i++){
id_distance[i].pos = i;
id_distance[i].value = 0;
}
/* set centroid */
centroid = f_calloc_vec(dim_data);
for(i=0;i<num_data;i++){
for(j=0;j<dim_data;j++){
centroid[j] += data_matrix[i][j];
}
}
for(j=0;j<dim_data;j++){
centroid[j] = centroid[j]/num_data;
}
/* set id_distance */
for(i=0;i<num_data;i++){
id_distance[i].value = euc_dist(dim_data,centroid,data_matrix[i]);
}
/* sort id_distance by distance */
qsort(id_distance,num_data,sizeof(struct status),(int(*)(const void*, const void*))cmp_dist);
max_dist = id_distance[num_data-1].value;
min_dist = id_distance[0].value;
fprintf(stderr,"max_dist:%f:\n",max_dist);
fprintf(stderr,"min_dist:%f:\n",min_dist);
out_matrix = data_matrix;
/* set partition */
partition = (int)num_data/num_clst;
fprintf(stderr,"partition:%d:\n",partition);
parted_values = f_calloc_vec(partition);
delta = (max_dist - min_dist)/partition;
fprintf(stderr,"delta:%f:\n",delta);
for(i=0;i<partition;i++){
parted_values[i] = min_dist + (i * delta);
//fprintf(stderr,"%f\n",parted_values[i]);
}
/* (* UNDER CHECK */
bins = i_calloc_vec(partition);
data_ptr = 0;
bin_ptr = 0;
total_bin_count = 0;
//median_range = 0;
median_count = 0;
median_value = 0;
ordered_start = 0;
for(i=0;i<num_data;i++){
if(bin_ptr >= partition){
break;
}
if(id_distance[i].value <= parted_values[bin_ptr+1]){
total_bin_count++;
bins[bin_ptr]++;
}else{
if(bins[bin_ptr] > median_count){
median_count = bins[bin_ptr];
median_value = parted_values[bin_ptr];
ordered_start = total_bin_count - bins[bin_ptr];
}
bin_ptr++;
}
}
//printf(":::%d:::\n",num_data);
//printf(":::%d:::\n",num_data - total_bin_count);
bins[bin_ptr-1] = (num_data - total_bin_count);
/* test
for(i=0;i<partition;i++){
fprintf(stderr,"%f\n",parted_values[i]);
fprintf(stderr," %d\n",bins[i]);
tmp = tmp + bins[i];
fprintf(stderr," %d\n",tmp);
}
fprintf(stderr,"start:%d:\n",ordered_start);
*/
/* *) */
}else if(strcmp(coordinate_option,"Through") == 0){
num_clst = num_data;
out_matrix = data_matrix;
}else if(strncmp(coordinate_option,"Grid=",5) == 0){
sscanf(coordinate_option,"Grid=%s",dim_string);
grid_tensor_rank = dim_data;
grid_tensor_dim = get_tensor_dimANDrank(grid_tensor_rank,dim_string);
tensor_position_matrix = make_outer_tensor_position_matrix(dim_data,&grid_tensor_elms,grid_tensor_dim);
num_clst = grid_tensor_elms;
if((tensor_vars = malloc((size_t)sizeof(float*)*grid_tensor_rank)) == NULL){
printf("failed : malloc() at %ld byte.\n",(long int)sizeof(float*)*grid_tensor_rank);
exit(1);
}
for(i=0;i<grid_tensor_rank;i++){
tensor_vars[i] = make_min_to_max_list(grid_tensor_dim[i],dim_min_and_max_table[0][i],dim_min_and_max_table[1][i]);
}
out_matrix = f_alloc_mat(grid_tensor_elms,grid_tensor_rank);
for(i=0;i<grid_tensor_elms;i++){
for(j=0;j<dim_data;j++){
out_matrix[i][j] = tensor_vars[j][tensor_position_matrix[i][j]];
}
}
}else if(strncmp(coordinate_option,"Axis-mean=",10) == 0){
int axis_str_len = 0;
int axis_list_len = 0;
int *axis_list = NULL;
double *axis_v_list = NULL;
sscanf(coordinate_option,"Axis-mean=%s",axis_str);
axis_str_len = strlen(axis_str);
for(i=0;i<axis_str_len;i++){
if(axis_str[i] == ','){
axis_list_len++;
}
}
axis_list_len++;
axis_list = i_alloc_vec(axis_list_len);
axis_v_list = d_calloc_vec(axis_list_len);
for(i=0;i<axis_str_len;i++){
if(axis_str[i] == ','){
tmp_word[tmp_ptr_word] = '\0';
sscanf(tmp_word,"%d",&axis_list[tmp_ptr_arr]);
tmp_ptr_arr++;
tmp_ptr_word = 0;
}else{
tmp_word[tmp_ptr_word] = axis_str[i];
tmp_ptr_word++;
}
}
tmp_word[tmp_ptr_word] = '\0';
sscanf(tmp_word,"%d",&axis_list[tmp_ptr_arr]);
tmp_ptr_arr++;
tmp_ptr_word = 0;
/* num_clst */
num_clst = axis_list_len;
/* out_matrix alloc */
out_matrix = f_calloc_mat(num_clst,dim_data);
/* calculation */
for(i=0;i<num_data;i++){
for(j=0;j<axis_list_len;j++){
axis_v_list[j] += data_matrix[i][axis_list[j]];
}
}
for(j=0;j<axis_list_len;j++){
axis_v_list[j] = axis_v_list[j]/num_data;
out_matrix[j][axis_list[j]] = (float)axis_v_list[j];
}
}else if(strncmp(coordinate_option,"aXis-intensive=",15) == 0){
/* declear and allocation */
float axis_ratio = 1;
struct st_ax_and_mean *ax_mean;
if(((ax_mean = malloc(sizeof(struct st_ax_and_mean) * dim_data)) == NULL)){ fprintf(stderr, "[E] failed: malloc().\n"); exit(0); }
out_matrix = f_calloc_mat(dim_data,dim_data);
/* ratio */
sscanf(coordinate_option,"aXis-intensive=%f",&axis_ratio);
mat_TO_st_ax_and_mean(dim_data, num_data, data_matrix, ax_mean);
qsort(ax_mean,dim_data,sizeof(struct st_ax_and_mean),(int(*)(const void*, const void*))cmp_ax_and_mean);
for(j=0;j<dim_data;j++){
out_matrix[j][ax_mean[j].ax] = axis_ratio * ax_mean[j].mean;
}
}else{
options();
exit(1);
}
/* *) */
/* (* open file and write shake_dim_min_to_max_matrix */
ofp = fopen(cluster_file,"w");
if(ofp == NULL){
perror(cluster_file);
exit(1);
}
if(ordered_output == 0){
fprintf(ofp,"%d %d\n",dim_data,num_clst);
for(j=0;j<num_clst;j++){
for(i=0;i<dim_data;i++){
fprintf(ofp,"%f ",out_matrix[j][i]);
}
fprintf(ofp,"\n");
}
fclose(ofp);
}else{
fprintf(ofp,"%d %d\n",dim_data,num_clst);
for(j=ordered_start;j<num_clst+ordered_start;j++){
for(i=0;i<dim_data;i++){
fprintf(ofp,"%f ",out_matrix[id_distance[j].pos][i]);
}
fprintf(ofp,"\n");
}
fclose(ofp);
}
/* *) */
}else{
message();
usage();
}
return(0);
}
int main(int argc, char **argv){
struct options *opt;
int ie=0;
FILE *fp;
char *line;
int c;
int num_RNG_edge = 0;
struct edge_d RNG_edge_d;
//struct edge_table RNG_tbl;
//float **dmat;
float **RNG_d_tbl;
float *min_stack;
int min_stack_len;
float maxmin = 0;
int i,j,k,l;
/* (* check options */
opt = alloc_options();
init_options(opt);
get_options(argc-1, argv+1, opt);
if((*opt).loop == 0){
(*opt).loop = (*opt).dsize;
}
if(argc == 1){
(*opt).help = 1;
}
if((*opt).help == 1){
help();
ie = 1;
}
if((*opt).stat == 1){
status();
ie = 1;
}
if((*opt).check == 1){
check_options(opt);
ie = 1;
}
if(ie == 1){
exit(0);
}
/* *) */
/* (* read RNG_d */
//must be rewrite
line = c_alloc_vec(LEN);
if((fp = fopen((*opt).ef,"r")) == NULL){
perror((*opt).ef);
exit(1);
}
num_RNG_edge = 0;
while((c=fgetc(fp)) != EOF){
if((char)c == '\n'){
num_RNG_edge++;
}
}
//printf("num_RNG_edge:%d:\n",num_RNG_edge);
fseek(fp,0U,SEEK_SET);
RNG_edge_d.p = i_alloc_vec(num_RNG_edge);
RNG_edge_d.t = i_alloc_vec(num_RNG_edge);
RNG_edge_d.d = f_alloc_vec(num_RNG_edge);
i = 0;
while((fgets(line,LEN,fp)) != NULL){
sscanf(line,"%d %d %f",RNG_edge_d.p+i,RNG_edge_d.t+i,RNG_edge_d.d+i);
i++;
}
fclose(fp);
//check
/*
for(i=0;i<num_RNG_edge;i++){
printf("%d %d %f\n",RNG_edge_d.p[i],RNG_edge_d.t[i],RNG_edge_d.d[i]);
}
*/
/* *) */
/* (* create RNG_d_tbl */
//must be rewite
RNG_d_tbl = f_calloc_mat((*opt).dsize,(*opt).dsize);
for(i=0;i<(*opt).dsize;i++){
for(j=0;j<(*opt).dsize;j++){
RNG_d_tbl[i][j] = -1;
}
}
for(i=0;i<num_RNG_edge;i++){
RNG_d_tbl[RNG_edge_d.p[i]][RNG_edge_d.t[i]] = RNG_edge_d.d[i];
RNG_d_tbl[RNG_edge_d.t[i]][RNG_edge_d.p[i]] = RNG_edge_d.d[i];
}
//check
/*
printf("dsize:%d:\n",(*opt).dsize);
for(i=0;i<(*opt).dsize;i++){
for(j=0;j<(*opt).dsize;j++){
printf(" %f",RNG_d_tbl[i][j]);
}
printf("\n");
}
*/
/* *) */
/* (* refine RNG_d_tbl */
min_stack = f_alloc_vec((*opt).dsize);
//for l in loop
for(l=0;l<(*opt).loop;l++){
//for i in row
for(i=0;i<(*opt).dsize;i++){
//for j in row
for(j=0;j<(*opt).dsize;j++){
//for k in column
//min_stack_len = 0;
maxmin = 0;
min_stack_len = 0;
for(k=0;k<(*opt).dsize;k++){
//comp(dmat[i] dmat[j])
//if dmat[i][k]!=0, dmat[j][k]!=0
//Func1
//if((RNG_d_tbl[i][k] != -1) && (RNG_d_tbl[j][k] != -1)){
if((RNG_d_tbl[i][k] >= 0) && (RNG_d_tbl[j][k] >= 0)){
//add max(pair) to min_stack; nim_stack_len++;
min_stack[min_stack_len] = max(RNG_d_tbl[i][k],RNG_d_tbl[j][k]);
min_stack_len++;
}
//end for k
}
//min of nim_stack
//Func2
maxmin = f_min_list(min_stack_len,min_stack); // ?? can rewrite maxmin ??
if((*opt).diag==1 && i==j){ maxmin = -1; } // ?? needs ??
//printf("maxmin:%f:\n",maxmin);
//rewrite RNG_d_tbl[i][j] <- nim(nin_stack);
if(min_stack_len > 0){
// must be replaced!!
//Func3
if(RNG_d_tbl[i][j] >= 0){
maxmin = min(maxmin,RNG_d_tbl[i][j]);
}
RNG_d_tbl[i][j] = maxmin;
}
//end for j
}
//end for i
}
//end for l
}
/* *) */
/* (* print results */
//printf("result after %d times loop:\n",l);
if((*opt).zeroself == 1){
for(i=0;i<(*opt).dsize;i++){
RNG_d_tbl[i][i] = 0;
}
}
for(i=0;i<(*opt).dsize;i++){
printf("%f",RNG_d_tbl[i][0]);
for(j=1;j<(*opt).dsize;j++){
printf(" %f",RNG_d_tbl[i][j]);
}
printf("\n");
}
/* *) */
return(0);
}
int main(int argc, char **argv){
int i,j;
int mpi_rank;
int mpi_size;
char *file_name_head;
char *mpi_target_file_name;
char *mpi_rank_str;
int mpi_c;
int mpi_sample_dim = 0;
int mpi_sample_num = 0;
int *mpi_sample_num_list;
float *mpi_sample_ave_vec;
float **mpi_sample_ave_mat;
double *total_sample_ave_vec;
double total_sample_num;
char **mpi_sample_head;
float **mpi_sample_mat;
int *mpi_reccount_list;
int *mpi_displs;
FILE *mpi_target_fp;
file_name_head = c_alloc_vec(STRSIZE_LARGE);
sscanf(argv[1],"%s",file_name_head);
MPI_Status status;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
mpi_rank_str = c_calloc_vec(STRSIZE);
mpi_target_file_name = c_calloc_vec(STRSIZE_LARGE);
mpi_sample_num_list = i_alloc_vec(mpi_size);
mpi_reccount_list = i_alloc_vec(mpi_size);
mpi_displs = i_alloc_vec(mpi_size);
sprintf(mpi_rank_str,"%d",mpi_rank);
sprintf(mpi_target_file_name,"%s",file_name_head);
strcat(mpi_target_file_name,".");
strcat(mpi_target_file_name,mpi_rank_str);
/* (* file: open */
printf("[%d/%d] file: open\n",mpi_rank,mpi_size);
if((mpi_target_fp = fopen(mpi_target_file_name,"r")) == NULL){
perror(mpi_target_file_name);
exit(0);
}
read_ilist_from_stream(1,mpi_target_fp,&mpi_sample_dim);
read_ilist_from_stream(1,mpi_target_fp,&mpi_sample_num);
mpi_sample_head = c_alloc_mat(mpi_sample_num,STRSIZE);
mpi_sample_mat = f_alloc_mat(mpi_sample_num,mpi_sample_dim);
mpi_sample_ave_vec = f_calloc_vec(mpi_sample_dim);
mpi_sample_ave_mat = f_calloc_mat(mpi_size,mpi_sample_dim);
total_sample_ave_vec = d_calloc_vec(mpi_sample_dim);
read_ID_ftable_from_stream(mpi_sample_num,mpi_sample_dim,mpi_target_fp,mpi_sample_mat,mpi_sample_head);
fclose(mpi_target_fp);
printf("[%d/%d] file: close\n",mpi_rank,mpi_size);
/* *) */
/* (* check */
printf("[%d/%d] ave:start:",mpi_rank,mpi_size);
for(j=0;j<mpi_sample_dim;j++){
printf(" %lf",mpi_sample_ave_vec[j]);
}
printf("\n");
/* *) */
/* (* rank vec mean */
for(i=0;i<mpi_sample_num;i++){
for(j=0;j<mpi_sample_dim;j++){
mpi_sample_ave_vec[j] += mpi_sample_mat[i][j];
}
}
for(j=0;j<mpi_sample_dim;j++){
mpi_sample_ave_vec[j] = mpi_sample_ave_vec[j]/mpi_sample_num;
}
/* *) */
/* (* check */
for(i=0;i<mpi_sample_num;i++){
printf("%s",mpi_sample_head[i]);
for(j=0;j<mpi_sample_dim;j++){
printf(" %lf",mpi_sample_mat[i][j]);
}
printf("\n");
}
printf("[%d/%d] ave:end:",mpi_rank,mpi_size);
for(j=0;j<mpi_sample_dim;j++){
printf(" %lf",mpi_sample_ave_vec[j]);
}
printf("\n");
/* *) */
/* (* allgather num */
for(i=0;i<mpi_size;i++){
mpi_reccount_list[i] = 1; //recieve from size:1 each rank
}
for(i=0;i<mpi_size;i++){
mpi_displs[i] = i;
}
MPI_Allgatherv(&mpi_sample_num, 1, MPI_INT, mpi_sample_num_list, mpi_reccount_list, mpi_displs, MPI_INT, MPI_COMM_WORLD );
fprintf(stdout,"[%d/%d] sample dimensions:%d:\n",mpi_rank,mpi_size,mpi_sample_dim);
fprintf(stdout,"[%d/%d] num samples:%d:\n",mpi_rank,mpi_size,mpi_sample_num);
for(i=0;i<mpi_size;i++){
fprintf(stdout,"[%d/%d]mpi_sample_num_list[%d]:%d:\n",mpi_rank,mpi_size,i,mpi_sample_num_list[i]);
}
/* *) */
/* (* allgather ave_mat */
for(i=0;i<mpi_size;i++){
mpi_reccount_list[i] = mpi_sample_dim; //recieve sizes:mpi_sample_dim from each rank
}
for(i=0;i<mpi_size;i++){
mpi_displs[i] = i*mpi_sample_dim; //recieve pointers for each rank
}
MPI_Allgatherv(mpi_sample_ave_vec,mpi_sample_dim,MPI_FLOAT,mpi_sample_ave_mat[0],mpi_reccount_list,mpi_displs,MPI_FLOAT,MPI_COMM_WORLD); //????
//MPI_Allgatherv(mpi_sample_ave_vec,mpi_sample_dim,MPI_FLOAT,&mpi_sample_ave_mat[0][0],mpi_reccount_list,mpi_displs,MPI_FLOAT,MPI_COMM_WORLD); //????
for(i=0;i<mpi_size;i++){
for(j=0;j<mpi_sample_dim;j++){
printf(" [%d/%d:%d:%d]:%f",mpi_rank,mpi_size,i,j,mpi_sample_ave_mat[i][j]);
}
printf("\n");
}
/* *) */
/* (* total mean */
total_sample_num = 0;
for(i=0;i<mpi_size;i++){
total_sample_num += mpi_sample_num_list[i];
}
printf("[%d/%d] total_sample_num:%d:\n",mpi_rank,mpi_size,total_sample_num);
for(i=0;i<mpi_size;i++){
for(j=0;j<mpi_sample_dim;j++){
total_sample_ave_vec[j] += (double)(mpi_sample_ave_mat[i][j] * mpi_sample_num_list[i]);
}
}
for(j=0;j<mpi_sample_dim;j++){
total_sample_ave_vec[j] = total_sample_ave_vec[j]/total_sample_num;
}
for(j=0;j<mpi_sample_dim;j++){
printf(" [%d/%d]total_sample_ave_vec[%d]:%lf",mpi_rank,mpi_size,j,total_sample_ave_vec[j]);
}
printf("\n");
/* *) */
MPI_Finalize();
fprintf(stdout,"\n[%d/%d] END\n",mpi_rank,mpi_size);
}
