void
free_param(Spec *spc, Data *dat, KNN *knn)
{
/* 配列の解放 */
free_int_vector(spc->tr_sample);
free_int_vector(spc->te_sample);
free_double_matrix(dat->x_tr);
free_double_matrix(dat->x_te);
free_int_vector(dat->label_tr);
free_int_vector(dat->label_te);
free_double_vector(knn->dist_queue);
free_int_vector(knn->index);
free_int_matrix(knn->count);
}
int main(int argc, char **argv)
{
int i;
int dim, line;
int dflag = 0;
double extract;
int *index, *fi;
double *item, max;
FILE *fp;
if(argc != 4){
fprintf(stderr, "\n[使用法] : detect_fi <file> [-d (num) / -r (ratio)]\n");
exit(1);
}
/* 取り出す要素数の方法を引数から確認 */
if(is_opt(argc, argv, "-d")){
dflag = 1;
extract = get_double_arg(argc, argv, "-d");
}
else if(is_opt(argc, argv, "-r"))
extract = get_double_arg(argc, argv, "-r");
else{
fprintf(stderr, "\n[エラー] : 不明な引数が含まれています\n");
exit(1);
}
/* データの大きさを調べる */
get_size(argv[1], &dim, &line);
/* 準備 */
index = new_int_vector(line);
item = new_double_vector(line);
/* データを読み込む */
if((fp = fopen(argv[1], "r")) == NULL){
fprintf(stderr, "\n[エラー] : ファイル %s が開けません\n", argv[1]);
exit(1);
}
for(i = 0; i < line; i++)
fscanf(fp, "%d %lf", &index[i], &item[i]);
fclose(fp);
/* 要素数を決定し、結果を出力 */
if(dflag){
dim = (int)extract;
fi = new_int_vector(dim);
for(i = 0; i < dim; i++)
fi[i] = index[i];
if(dim > 1)
quicksort(fi, 0, dim - 1);
if((fp = fopen("Subset.dat", "w")) == NULL){
fprintf(stderr, "\n[エラー] : ファイル Subset.dat が開けません\n");
exit(1);
}
for(i = 0; i < dim; i++){
fprintf(fp, "%d", fi[i]);
if(i < dim - 1)
fprintf(fp, " ");
}
fprintf(fp, "\n");
fclose(fp);
}
else{
/* 評価関数の最大値を判定する */
max = item[line - 1];
extract = max * (1.0 - extract / 100.0);
for(i = 0; i < line; i++){
if(item[i] - extract > 0.0){
dim = i;
break;
}
}
dim++; /* 特徴の番号を合わせる. C言語では0番から始まるけど、特徴は1
番からカウントするのでfor文を抜けた後のdimは特徴数が1だけ
小さい。 */
fi = new_int_vector(dim);
for(i = 0; i < dim; i++)
fi[i] = index[i];
if(dim > 1)
quicksort(fi, 0, dim - 1);
if((fp = fopen("Subset.dat", "w")) == NULL){
fprintf(stderr, "\n[エラー] : ファイル Subset.dat が開けません\n");
exit(1);
}
for(i = 0; i < dim; i++){
fprintf(fp, "%d", fi[i]);
if(i < dim - 1)
fprintf(fp, " ");
}
fprintf(fp, "\n");
fclose(fp);
}
/* 終了処理 */
free_int_vector(index);
free_double_vector(item);
free_int_vector(fi);
exit(0);
}
int main(int argc, char **argv)
{
int i, j, k;
int line, dim, max_byte;
int split, *num = NULL;
char **buffer;
char ofname[NAME_LEN] = {'\0'}, str[NAME_LEN] = {'\0'};
FILE *fp = NULL;
/* 引数の確認 */
if(argc < 4){
fprintf(stderr, "\n[使用法] : file_split <file> [-q (num) / -s (M) (n1)...(nM)] (-o (str))\n");
exit(1);
}
strcpy(ofname, argv[1]);
if(is_opt(argc, argv, "-o"))
strcpy(ofname, get_char_arg(argc, argv, "-o"));
/* 1行当たりのバイト数の最大値とデータの行の総数を調べる */
get_max_byte(argv[1], &max_byte);
get_size(argv[1], &dim, &line);
/* データの分割数を設定する */
if(is_opt(argc, argv, "-q")){
split = get_int_arg(argc, argv, "-q");
num = new_int_vector(split);
for(i = 0; i < split; i++)
num[i] = line / split;
for(i = 0; i < (line % split); i++)
num[i]++;
}
else if(is_opt(argc, argv, "-s")){
num = get_int_arg_list(argc, argv, "-s", &split);
j = 0;
for(i = 0; i < split; i++)
j += num[i];
if(j != line){
fprintf(stderr, "\n[エラー] : 指定された分割方法は正しくありません\n");
exit(1);
}
}
else{
fprintf(stderr, "\n[エラー] : 分割方法を必ず指定して下さい\n");
exit(1);
}
/* データを確保するための配列を準備する */
buffer = new_char_matrix(line, sizeof(char)*(max_byte + 2));
for(i = 0; i < line; i++)
for(j = 0; j <= sizeof(char)*max_byte + 1; j++)
buffer[i][j] = '\0';
/* ファイルからデータを読み込む */
if((fp = fopen(argv[1], "r")) == NULL){
fprintf(stderr, "\n[エラー] : ファイル %s が開けません\n", argv[1]);
exit(1);
}
for(i = 0; i < line; i++){
for(j = 0; j <= max_byte*sizeof(char); j++){
fscanf(fp, "%c", &buffer[i][j]);
if(buffer[i][j] == '\n')
break;
}
}
fclose(fp);
/* 指定された方法によりデータを分割する */
line = 0;
for(i = 0; i < split; i++){
sprintf(str, "%s_%d", ofname, i+1);
if((fp = fopen(str, "w")) == NULL){
fprintf(stderr, "\n[エラー] : ファイル %s が開けません\n", str);
exit(1);
}
for(j = 0; j < num[i]; j++){
for(k = 0; k <= max_byte*sizeof(char); k++){
fprintf(fp, "%c", buffer[line + j][k]);
if(buffer[line + j][k] == '\n')
break;
}
}
fclose(fp);
line += num[i];
}
/* 作業用の配列を解放 */
free_char_matrix(buffer);
free_int_vector(num);
exit(0);
}
n_division* algorithm3 (sparse_matrix_arr *adj_matrix, double precision, int use_improve){
int n_groups = 0; /* counts number of groups in P */
int i, j;
int n = adj_matrix->n; /* number of vertices */
int_vector *is_divisable; /* indicated whether a group is divisable */
int_vector *vgroup;
int next_divisable_group;
int group_size;
two_division* division;
int n_div1; /* Marks the size of the +1 group in a two-division */
int_vector* p_groups;
n_division* res;
/* Allocate and Init res */
if ((p_groups = allocate_int_vector(n)) == NULL){
/* allocation failed */
return NULL;
}
if ((res = allocate_n_division(p_groups)) == NULL) {
/* allocation failed */
return NULL;
}
res->quality = 0.0;
for (i = 0; i < n; i++){
res->p_groups->values[i] = -1;
}
/* Allocate and Init is_divisable */
if ((is_divisable = allocate_int_vector(n+1)) == NULL){
/* allocation failed */
free_n_division(res);
return NULL;
}
/* First we want to remove singletons */
for (i = 0; i < n; ++i){
if (adj_matrix->rowptr[i] == adj_matrix->rowptr[i+1]){
res->p_groups->values[i] = n_groups;
is_divisable->values[n_groups] = 0;
++n_groups;
}
}
if (n_groups == n) {
next_divisable_group = -1;
}
else {
/* Now fill in the "last" group which is the group with every node
which isn't a singleton */
for (i = 0; i < n; i++) {
if (res->p_groups->values[i] == -1)
res->p_groups->values[i] = n_groups;
}
++n_groups;
is_divisable->values[n_groups-1] = 1;
next_divisable_group = n_groups-1;
}
while (next_divisable_group >= 0){
group_size = 0;
for (i = 0; i < n; i ++){
if (res->p_groups->values[i] == next_divisable_group){
group_size++;
}
}
if ((vgroup = allocate_int_vector(group_size)) == NULL){
/* allocation failed */
free_n_division(res);
free_int_vector(is_divisable);
return NULL;
}
/* filling vgroup with its relevant vertices */
j = 0;
for (i = 0; j < group_size; ++i){
if (res->p_groups->values[i] == next_divisable_group){
vgroup->values[j++] = i;
}
}
if ((division = algorithm2(adj_matrix, vgroup, precision, use_improve)) == NULL) {
/* Error in algorithm2! */
free_n_division(res);
free_int_vector(is_divisable);
free_int_vector(vgroup);
return NULL;
}
else {
/* Now we count how big is the +1 group */
n_div1 = 0;
for (i = 0; i < group_size; i++) {
n_div1 += (division->s_vector->values[i] > 0) ? 1 : 0;
}
if ((n_div1 == 0) || (n_div1 == group_size)) {
/* No division found... */
is_divisable->values[next_divisable_group] = 0;
}
else {
/* Woohoo! New division!
The division is a two-division, i.e. +1 / -1, and so we need
to screen the new groups using vgroup and the division we got */
res->quality += division->quality;
for (i = 0; i < group_size; i++) {
if (division->s_vector->values[i] > 0) {
res->p_groups->values[vgroup->values[i]] = n_groups;
}
}
n_groups++;
is_divisable->values[n_groups-1] = (n_div1 > 1) ? 1 : 0;
is_divisable->values[next_divisable_group] =
((group_size-n_div1) > 1) ? 1 : 0;
}
free_two_division(division);
}
/* Free the vgroup, there is no use of it anymore */
free_int_vector(vgroup);
/* Check if there are more divisable groups */
while ((next_divisable_group < n_groups) &&
(!is_divisable->values[next_divisable_group])) {
next_divisable_group++;
}
if (next_divisable_group == n_groups) next_divisable_group = -1;
}
free_int_vector(is_divisable);
return res;
}
rational scale(int dimdiff, T_LassInt *fvTree, T_LassInt * fvNew)
{ int i, j, k, l, m, n;
int *pcol, /* pivot columns */
*dcol, /* determinant columns */
*frow; /* fixed constraints (rows) */
rational **Ascale; /* contains complete rows of scaling matrix */
rational **Adet; /* contains square scaling matrix */
rational r1;
pcol = create_int_vector (dimdiff);
dcol = create_int_vector (dimdiff);
frow = create_int_vector (dimdiff);
Ascale = create_matrix (dimdiff, G_d);
Adet = create_matrix (dimdiff, dimdiff);
/* extract index sets where projection on differing subspaces happened */
j=l=m=n=0;
for (i=0; i<G_d; i++){
while (fvTree[j]<i) j++;
if (fvTree[j]>i) { /* i is not in fvTree */
for (k=0; k<dimdiff; k++){
if (i==p2c[k][0]){
pcol[l]=i;
frow[l]=k; /* =p2c[k][1]; */
l++;
break;
}
}
}
else { /* i is in fvTree */
while (fvNew[m]<i) m++;
if (fvNew[m]>i) { /* i is not in fvNew */
dcol[n]=i;
n++;
}
}
}
/* test consistent dimensionality; can be omitted */
if (n!=l) {
fprintf(stderr, "\n***** ERROR: Non-square scaling matrix in 'scale'\n");
exit(1);
};
if (n==0) return 1; /* projection was done on the same subspace */
/* Build Ascale and inverte right half by left half */
for (i=0; i<dimdiff; i++)
for (j=0; j<G_d; j++) Ascale[i][j] = G_Hyperplanes[p2c[i][1]][j];
for (i=0; i<dimdiff; i++){
r1=1/Ascale[i][p2c[i][0]];
for (j=0; j<G_d; j++) Ascale[i][j]*=r1; /* divide pivot-row by pivot-element */
for (j=0; j<dimdiff; j++){
if (i==j) continue;
for (k=0; k<G_d; k++){
if (k!=p2c[i][0])
Ascale[j][k] -= Ascale[i][k]*Ascale[j][p2c[i][0]];
}
}
}
/* extract determinant submatrix Adet */
for (i=0; i<n; i++)
for (j=0; j<n; j++)
Adet[i][j]=Ascale[frow[i]][dcol[j]];
if (n==1) { /* here the determinant is trivial */
return 1/fabs(Adet[0][0]);
}
/* compute determinant of Adet (modulo sign due to permutation) */
for (i=0; i<n; i++) pcol[i]=-1;
for (i=0; i<n-1; i++){
j=0; /* search for pivot column */
while (pcol[j]>=0) j++;
for (k=j+1; k<n; k++) {
if (pcol[k]>=0) continue;
if (fabs(Adet[i][k])>fabs(Adet[i][j])) j=k;
};
pcol[j]=i;
for (k=i+1; k<n; k++)
for (l=0; l<n; l++){
if (l!=j)
Adet[k][l] -= Adet[i][l]/Adet[i][j]*Adet[k][j];
}
};
r1=1;
for (i=0; i<n; i++) {
if (pcol[i]>=0) r1*=Adet[pcol[i]][i];
else r1*=Adet[n-1][i];
}
free_int_vector (pcol, dimdiff);
free_int_vector (dcol, dimdiff);
free_int_vector (frow, dimdiff);
free_matrix (Ascale, dimdiff, G_d);
free_matrix (Adet, dimdiff, dimdiff);
return 1/fabs(r1);
}
int main(int argc, char **argv) {
sparse_matrix_arr* adj_matrix;
int_vector *vgroup, *subgroup;
elem_vector *s_vector;
mod_matrix *Bijtag;
two_division *division;
int i,j;
if (argc < 4) {
fprintf(stderr, "Invalid Arguments, Aborting.\n");
fprintf(stderr, "Usage: %s <adjacency-mat-file> <group-file> <first-subgroup-file>\n", argv[0]);
return EXIT_FAILURE;
}
if ((adj_matrix = read_adjacency_matrix_file(argv[1])) == NULL) {
/*Problem reading adjacency matrix data */
return EXIT_FAILURE;
}
if ((vgroup = read_vertices_group_file(argv[2], adj_matrix->n)) == NULL) {
/*Problem reading adjacency matrix data */
free_sparse_matrix_arr(adj_matrix);
return EXIT_FAILURE;
}
if ((subgroup = read_vertices_group_file(argv[3], adj_matrix->n)) == NULL) {
/*Problem reading adjacency matrix data */
free_int_vector(vgroup);
free_sparse_matrix_arr(adj_matrix);
return EXIT_FAILURE;
}
if ((Bijtag = allocate_partial_modularity_matrix(adj_matrix, vgroup)) == NULL) {
free_int_vector(vgroup);
free_sparse_matrix_arr(adj_matrix);
return EXIT_FAILURE;
}
free_sparse_matrix_arr(adj_matrix);
if ((s_vector = allocate_elem_vector(vgroup->n)) == NULL) {
free_mod_matrix(Bijtag);
free_int_vector(vgroup);
return EXIT_FAILURE;
}
if ((division = allocate_two_division(s_vector)) == NULL) {
free_elem_vector(s_vector);
free_mod_matrix(Bijtag);
free_int_vector(vgroup);
return EXIT_FAILURE;
}
/*align subgroup indices to be a subgroup of vgroup indices*/
for(i=0, j=0; i<subgroup->n; i++) {
while(j<vgroup->n && vgroup->values[j]!=subgroup->values[i])
j++;
if (j==vgroup->n) {
fprintf(stderr, "vertex %d not found in main group file.\n", subgroup->values[i]);
}
if (vgroup->values[j]==subgroup->values[i]) {
subgroup->values[i] = j;
}
}
for(i=0; i<s_vector->n; i++) {
s_vector->values[i] = 1;
}
for(i=0; i<subgroup->n; i++) {
s_vector->values[subgroup->values[i]] = -1;
}
division->quality = 0;
if(improve_network_division(Bijtag, division) == 0) {
free_int_vector(vgroup);
free_int_vector(subgroup);
free_two_division(division);
free_mod_matrix(Bijtag);
return EXIT_FAILURE;
}
printf("%f\n", division->quality);
for(i=0; i<division->s_vector->n; i++) {
if (division->s_vector->values[i] == division->s_vector->values[0]) {
printf("%d ", vgroup->values[i]);
}
}
printf("\n");
for(i=0; i<division->s_vector->n; i++) {
if (division->s_vector->values[i] != division->s_vector->values[0]) {
printf("%d ", vgroup->values[i]);
}
}
printf("\n");
free_int_vector(subgroup);
free_int_vector(vgroup);
free_two_division(division);
free_mod_matrix(Bijtag);
return EXIT_SUCCESS;
}
