nysol-take 3.0.0
Sign up to get free protection for your applications and to get access to all the features.
- checksums.yaml +7 -0
- data/bin/mbiclique.rb +317 -0
- data/bin/mbipolish.rb +362 -0
- data/bin/mccomp.rb +235 -0
- data/bin/mclique.rb +295 -0
- data/bin/mclique2g.rb +105 -0
- data/bin/mcliqueInfo.rb +203 -0
- data/bin/mfriends.rb +202 -0
- data/bin/mgdiff.rb +252 -0
- data/bin/mhifriend.rb +456 -0
- data/bin/mhipolish.rb +465 -0
- data/bin/mitemset.rb +168 -0
- data/bin/mpal.rb +410 -0
- data/bin/mpolishing.rb +399 -0
- data/bin/msequence.rb +165 -0
- data/bin/mtra2g.rb +476 -0
- data/bin/mtra2gc.rb +360 -0
- data/ext/grhfilrun/extconf.rb +12 -0
- data/ext/grhfilrun/grhfilrun.c +85 -0
- data/ext/grhfilrun/src/_sspc.c +358 -0
- data/ext/grhfilrun/src/aheap.c +545 -0
- data/ext/grhfilrun/src/aheap.h +251 -0
- data/ext/grhfilrun/src/base.c +92 -0
- data/ext/grhfilrun/src/base.h +59 -0
- data/ext/grhfilrun/src/fstar.c +497 -0
- data/ext/grhfilrun/src/fstar.h +80 -0
- data/ext/grhfilrun/src/grhfil.c +214 -0
- data/ext/grhfilrun/src/itemset.c +713 -0
- data/ext/grhfilrun/src/itemset.h +170 -0
- data/ext/grhfilrun/src/problem.c +415 -0
- data/ext/grhfilrun/src/problem.h +179 -0
- data/ext/grhfilrun/src/queue.c +533 -0
- data/ext/grhfilrun/src/queue.h +182 -0
- data/ext/grhfilrun/src/sample.c +19 -0
- data/ext/grhfilrun/src/sspc.c +597 -0
- data/ext/grhfilrun/src/sspc2.c +491 -0
- data/ext/grhfilrun/src/stdlib2.c +1482 -0
- data/ext/grhfilrun/src/stdlib2.h +892 -0
- data/ext/grhfilrun/src/trsact.c +817 -0
- data/ext/grhfilrun/src/trsact.h +160 -0
- data/ext/grhfilrun/src/vec.c +745 -0
- data/ext/grhfilrun/src/vec.h +172 -0
- data/ext/lcmrun/extconf.rb +20 -0
- data/ext/lcmrun/lcmrun.cpp +99 -0
- data/ext/lcmrun/src/aheap.c +216 -0
- data/ext/lcmrun/src/aheap.h +111 -0
- data/ext/lcmrun/src/base.c +92 -0
- data/ext/lcmrun/src/base.h +59 -0
- data/ext/lcmrun/src/itemset.c +496 -0
- data/ext/lcmrun/src/itemset.h +157 -0
- data/ext/lcmrun/src/lcm.c +427 -0
- data/ext/lcmrun/src/problem.c +349 -0
- data/ext/lcmrun/src/problem.h +177 -0
- data/ext/lcmrun/src/queue.c +528 -0
- data/ext/lcmrun/src/queue.h +176 -0
- data/ext/lcmrun/src/sgraph.c +359 -0
- data/ext/lcmrun/src/sgraph.h +173 -0
- data/ext/lcmrun/src/stdlib2.c +1282 -0
- data/ext/lcmrun/src/stdlib2.h +823 -0
- data/ext/lcmrun/src/trsact.c +747 -0
- data/ext/lcmrun/src/trsact.h +159 -0
- data/ext/lcmrun/src/vec.c +731 -0
- data/ext/lcmrun/src/vec.h +171 -0
- data/ext/lcmseq0run/extconf.rb +20 -0
- data/ext/lcmseq0run/lcmseq0run.cpp +59 -0
- data/ext/lcmseq0run/src/aheap.c +216 -0
- data/ext/lcmseq0run/src/aheap.h +111 -0
- data/ext/lcmseq0run/src/base.c +92 -0
- data/ext/lcmseq0run/src/base.h +59 -0
- data/ext/lcmseq0run/src/itemset.c +518 -0
- data/ext/lcmseq0run/src/itemset.h +157 -0
- data/ext/lcmseq0run/src/itemset_zero.c +522 -0
- data/ext/lcmseq0run/src/lcm_seq.c +446 -0
- data/ext/lcmseq0run/src/lcm_seq_zero.c +446 -0
- data/ext/lcmseq0run/src/problem.c +439 -0
- data/ext/lcmseq0run/src/problem.h +179 -0
- data/ext/lcmseq0run/src/problem_zero.c +439 -0
- data/ext/lcmseq0run/src/queue.c +533 -0
- data/ext/lcmseq0run/src/queue.h +182 -0
- data/ext/lcmseq0run/src/stdlib2.c +1350 -0
- data/ext/lcmseq0run/src/stdlib2.h +864 -0
- data/ext/lcmseq0run/src/trsact.c +747 -0
- data/ext/lcmseq0run/src/trsact.h +159 -0
- data/ext/lcmseq0run/src/vec.c +779 -0
- data/ext/lcmseq0run/src/vec.h +172 -0
- data/ext/lcmseqrun/extconf.rb +20 -0
- data/ext/lcmseqrun/lcmseqrun.cpp +101 -0
- data/ext/lcmseqrun/src/aheap.c +216 -0
- data/ext/lcmseqrun/src/aheap.h +111 -0
- data/ext/lcmseqrun/src/base.c +92 -0
- data/ext/lcmseqrun/src/base.h +59 -0
- data/ext/lcmseqrun/src/itemset.c +518 -0
- data/ext/lcmseqrun/src/itemset.h +157 -0
- data/ext/lcmseqrun/src/itemset_zero.c +522 -0
- data/ext/lcmseqrun/src/lcm_seq.c +447 -0
- data/ext/lcmseqrun/src/lcm_seq_zero.c +446 -0
- data/ext/lcmseqrun/src/problem.c +439 -0
- data/ext/lcmseqrun/src/problem.h +179 -0
- data/ext/lcmseqrun/src/problem_zero.c +439 -0
- data/ext/lcmseqrun/src/queue.c +533 -0
- data/ext/lcmseqrun/src/queue.h +182 -0
- data/ext/lcmseqrun/src/stdlib2.c +1350 -0
- data/ext/lcmseqrun/src/stdlib2.h +864 -0
- data/ext/lcmseqrun/src/trsact.c +747 -0
- data/ext/lcmseqrun/src/trsact.h +159 -0
- data/ext/lcmseqrun/src/vec.c +779 -0
- data/ext/lcmseqrun/src/vec.h +172 -0
- data/ext/lcmtransrun/extconf.rb +18 -0
- data/ext/lcmtransrun/lcmtransrun.cpp +264 -0
- data/ext/macerun/extconf.rb +20 -0
- data/ext/macerun/macerun.cpp +57 -0
- data/ext/macerun/src/aheap.c +217 -0
- data/ext/macerun/src/aheap.h +112 -0
- data/ext/macerun/src/itemset.c +491 -0
- data/ext/macerun/src/itemset.h +158 -0
- data/ext/macerun/src/mace.c +503 -0
- data/ext/macerun/src/problem.c +346 -0
- data/ext/macerun/src/problem.h +174 -0
- data/ext/macerun/src/queue.c +529 -0
- data/ext/macerun/src/queue.h +177 -0
- data/ext/macerun/src/sgraph.c +360 -0
- data/ext/macerun/src/sgraph.h +174 -0
- data/ext/macerun/src/stdlib2.c +993 -0
- data/ext/macerun/src/stdlib2.h +811 -0
- data/ext/macerun/src/vec.c +634 -0
- data/ext/macerun/src/vec.h +170 -0
- data/ext/sspcrun/extconf.rb +20 -0
- data/ext/sspcrun/src/_sspc.c +358 -0
- data/ext/sspcrun/src/aheap.c +545 -0
- data/ext/sspcrun/src/aheap.h +251 -0
- data/ext/sspcrun/src/base.c +92 -0
- data/ext/sspcrun/src/base.h +59 -0
- data/ext/sspcrun/src/fstar.c +496 -0
- data/ext/sspcrun/src/fstar.h +80 -0
- data/ext/sspcrun/src/grhfil.c +213 -0
- data/ext/sspcrun/src/itemset.c +713 -0
- data/ext/sspcrun/src/itemset.h +170 -0
- data/ext/sspcrun/src/problem.c +415 -0
- data/ext/sspcrun/src/problem.h +179 -0
- data/ext/sspcrun/src/queue.c +533 -0
- data/ext/sspcrun/src/queue.h +182 -0
- data/ext/sspcrun/src/sample.c +19 -0
- data/ext/sspcrun/src/sspc.c +598 -0
- data/ext/sspcrun/src/sspc2.c +491 -0
- data/ext/sspcrun/src/stdlib2.c +1482 -0
- data/ext/sspcrun/src/stdlib2.h +892 -0
- data/ext/sspcrun/src/trsact.c +817 -0
- data/ext/sspcrun/src/trsact.h +160 -0
- data/ext/sspcrun/src/vec.c +745 -0
- data/ext/sspcrun/src/vec.h +172 -0
- data/ext/sspcrun/sspcrun.cpp +54 -0
- data/lib/nysol/enumLcmEp.rb +338 -0
- data/lib/nysol/enumLcmEsp.rb +284 -0
- data/lib/nysol/enumLcmIs.rb +275 -0
- data/lib/nysol/enumLcmSeq.rb +143 -0
- data/lib/nysol/items.rb +201 -0
- data/lib/nysol/seqDB.rb +256 -0
- data/lib/nysol/take.rb +39 -0
- data/lib/nysol/taxonomy.rb +113 -0
- data/lib/nysol/traDB.rb +257 -0
- metadata +239 -0
@@ -0,0 +1,731 @@
|
|
1
|
+
/* library for vector and sparse vector, and matrix */
|
2
|
+
/* Takeaki Uno 27/Dec/2008 */
|
3
|
+
|
4
|
+
#ifndef _vec_c_
|
5
|
+
#define _vec_c_
|
6
|
+
|
7
|
+
#include"vec.h"
|
8
|
+
#include"stdlib2.c"
|
9
|
+
#include"queue.c"
|
10
|
+
|
11
|
+
MAT INIT_MAT = {TYPE_MAT,NULL,0,NULL,0,0,NULL,NULL,0,0,NULL,NULL};
|
12
|
+
SVEC INIT_SVEC_ELE = {0,0};
|
13
|
+
SVEC INIT_SVEC = {TYPE_SVEC,NULL,0,0};
|
14
|
+
SMAT INIT_SMAT = {TYPE_SMAT,NULL,0,NULL,0,0,NULL,NULL,0,0,0};
|
15
|
+
SETFAMILY INIT_SETFAMILY = INIT_SETFAMILY_;
|
16
|
+
|
17
|
+
QSORT_TYPE (SVEC_VAL, SVEC_VAL)
|
18
|
+
QSORT_TYPE (SVEC_VAL2, SVEC_VAL2)
|
19
|
+
|
20
|
+
/* allocate memory according to rows and rowt */
|
21
|
+
void VEC_alloc (VEC *V, VEC_ID clms){
|
22
|
+
*V = INIT_VEC;
|
23
|
+
V->end = clms;
|
24
|
+
calloc2 (V->v, clms+1, EXIT);
|
25
|
+
}
|
26
|
+
|
27
|
+
/* terminate routine for VEC */
|
28
|
+
void VEC_end (VEC *V){
|
29
|
+
free2 (V->v);
|
30
|
+
*V = INIT_VEC;
|
31
|
+
}
|
32
|
+
|
33
|
+
/* allocate memory according to rows and rowt */
|
34
|
+
void MAT_alloc (MAT *M, VEC_ID rows, VEC_ID clms){
|
35
|
+
VEC_ID i, clms2 = clms+(clms%2?1:2);
|
36
|
+
calloc2 (M->v, rows+1, EXIT);
|
37
|
+
calloc2 (M->buf_org, clms2 * (rows+1)+4, {free(M->v);EXIT;});
|
38
|
+
M->buf = M->buf_org; ADDR_FLOOR16(M->buf);
|
39
|
+
M->end = rows;
|
40
|
+
M->clms = clms;
|
41
|
+
FLOOP (i, 0, rows){
|
42
|
+
M->v[i].end = M->v[i].t = clms;
|
43
|
+
M->v[i].v = M->buf + i*(clms2);
|
44
|
+
// printf ("%p %p\n", M->buf, M->v[i].v);
|
45
|
+
}
|
46
|
+
}
|
47
|
+
|
48
|
+
/* terminate routine for MAT */
|
49
|
+
void MAT_end (MAT *M){
|
50
|
+
free2 (M->buf_org);
|
51
|
+
free2 (M->buf2_org);
|
52
|
+
free2 (M->v);
|
53
|
+
*M = INIT_MAT;
|
54
|
+
}
|
55
|
+
|
56
|
+
/* allocate memory */
|
57
|
+
void SVEC_alloc (SVEC *V, VEC_ID end){
|
58
|
+
*V = INIT_SVEC;
|
59
|
+
calloc2 (V->v, end+1, EXIT);
|
60
|
+
V->end = end;
|
61
|
+
V->t = 0;
|
62
|
+
}
|
63
|
+
|
64
|
+
/* terminate routine for SVEC */
|
65
|
+
void SVEC_end (SVEC *V){
|
66
|
+
free2 (V->v);
|
67
|
+
*V = INIT_SVEC;
|
68
|
+
}
|
69
|
+
|
70
|
+
/* allocate memory according to rows and rowt */
|
71
|
+
void SMAT_alloc (SMAT *M, VEC_ID rows, VEC_ID *rowt, VEC_ID clms, size_t eles){
|
72
|
+
VEC_ID i;
|
73
|
+
if ( eles == 0 ) ARY_SUM (M->ele_end, rowt, 0, rows); else M->ele_end = eles;
|
74
|
+
calloc2 (M->buf, M->ele_end*((M->flag&LOAD_DBLBUF)?2:1) +rows +2, EXIT);
|
75
|
+
malloc2 (M->v, rows+1, {free(M->buf);EXIT;});
|
76
|
+
ARY_FILL (M->v, 0, rows, INIT_SVEC);
|
77
|
+
M->end = rows;
|
78
|
+
M->clms = clms;
|
79
|
+
if ( rowt ){
|
80
|
+
FLOOP (i, 0, rows){
|
81
|
+
M->v[i].v = i? M->v[i-1].v + rowt[i-1] +1: M->buf;
|
82
|
+
M->v[i].end = rowt[i];
|
83
|
+
}
|
84
|
+
}
|
85
|
+
}
|
86
|
+
|
87
|
+
/* terminate routine for MAT */
|
88
|
+
void SMAT_end (SMAT *M){
|
89
|
+
free2 (M->buf);
|
90
|
+
free2 (M->buf2);
|
91
|
+
free2 (M->v);
|
92
|
+
*M = INIT_SMAT;
|
93
|
+
}
|
94
|
+
|
95
|
+
|
96
|
+
|
97
|
+
/* allocate memory according to rows and rowt */
|
98
|
+
/* if eles == 0, compute eles from rowt and rows */
|
99
|
+
void SETFAMILY_alloc (SETFAMILY *M, VEC_ID rows, VEC_ID *rowt, VEC_ID clms, size_t eles){
|
100
|
+
VEC_ID i;
|
101
|
+
char *buf;
|
102
|
+
if ( eles == 0 ) ARY_SUM (M->ele_end, rowt, 0, rows); else M->ele_end = eles;
|
103
|
+
calloc2 (buf, (M->ele_end*((M->flag&LOAD_DBLBUF)?2:1) +((M->flag&LOAD_DBLBUF)?MAX(rows,clms):rows)+2)*M->unit, EXIT);
|
104
|
+
M->buf = (QUEUE_INT *)buf;
|
105
|
+
malloc2 (M->v, rows+1, {free(M->buf);EXIT;});
|
106
|
+
ARY_FILL (M->v, 0, rows, INIT_QUEUE);
|
107
|
+
M->end = rows;
|
108
|
+
M->clms = clms;
|
109
|
+
if ( rowt ){
|
110
|
+
FLOOP (i, 0, rows){
|
111
|
+
M->v[i].v = (QUEUE_INT *)buf;
|
112
|
+
buf += (rowt[i] +1)*M->unit;
|
113
|
+
M->v[i].end = rowt[i]+1;
|
114
|
+
}
|
115
|
+
}
|
116
|
+
}
|
117
|
+
|
118
|
+
/* allocate memory according to rows and rowt */
|
119
|
+
/* if eles == 0, compute eles from rowt and rows */
|
120
|
+
void SETFAMILY_alloc_weight (SETFAMILY *M){
|
121
|
+
VEC_ID i;
|
122
|
+
calloc2 (M->w, M->end +1, EXIT);
|
123
|
+
calloc2 (M->wbuf, M->ele_end*((M->flag&LOAD_DBLBUF)?2:1)+1, {free(M->w);EXIT;});
|
124
|
+
FLOOP (i, 1, M->t) M->w[i] = i? M->w[i-1] + M->v[i-1].t: M->wbuf;
|
125
|
+
}
|
126
|
+
|
127
|
+
/* terminate routine for MAT */
|
128
|
+
void SETFAMILY_end (SETFAMILY *M){
|
129
|
+
mfree (M->buf, M->buf2, M->v, M->rw, M->cw, M->wbuf, M->w);
|
130
|
+
*M = INIT_SETFAMILY;
|
131
|
+
}
|
132
|
+
|
133
|
+
/****************************************************************/
|
134
|
+
/****************************************************************/
|
135
|
+
/****************************************************************/
|
136
|
+
|
137
|
+
/* read binary file for MAT */
|
138
|
+
/* each unit-byte will be one number. if unit<0, the sign of unit is flipped, and each value is minesed the half of the maximum */
|
139
|
+
void MAT_load_bin (MAT *M, FILE2 *fp, int unit){
|
140
|
+
VEC_ID flag=0, i, j, jj;
|
141
|
+
size_t siz=0;
|
142
|
+
VEC_VAL z, neg=0;
|
143
|
+
|
144
|
+
if ( unit < 0 ){
|
145
|
+
unit = -unit; flag = 1; neg=128;
|
146
|
+
FLOOP (jj, 0, unit-1) neg *= 256;
|
147
|
+
}
|
148
|
+
if ( M->t == 0 ){ // determine #rows if M->t is 0 (not specified)
|
149
|
+
fseek(fp->fp, 0, SEEK_END);
|
150
|
+
siz = ftell(fp->fp);
|
151
|
+
fseek(fp->fp, 0, SEEK_SET);
|
152
|
+
M->t = (VEC_ID)(siz / unit / M->clms);
|
153
|
+
if ( M->flag & LOAD_TPOSE ) SWAP_VEC_ID (M->t, M->clms);
|
154
|
+
}
|
155
|
+
MAT_alloc (M, M->t, M->clms); if (ERROR_MES) return;
|
156
|
+
M->end = M->t;
|
157
|
+
FLOOP (i, 0, M->t){
|
158
|
+
FLOOP (j, 0, M->clms){
|
159
|
+
z=0; FLOOP (jj, 0, unit){ z *= 256; z += FILE2_getc (fp); }
|
160
|
+
if ( flag ) z -= neg;
|
161
|
+
if ( M->flag & LOAD_TPOSE ) M->v[j].v[i] = z;
|
162
|
+
else M->v[i].v[j] = z;
|
163
|
+
}
|
164
|
+
}
|
165
|
+
}
|
166
|
+
|
167
|
+
/* segmentation fault for illegal files */
|
168
|
+
/* count/read the number in file for MAT */
|
169
|
+
/* if *rows>0, only read count the numbers in a row, for the first scan. */
|
170
|
+
void MAT_file_load (MAT *M, FILE2 *fp){
|
171
|
+
QUEUE_ID c;
|
172
|
+
VEC_ID t=0;
|
173
|
+
double p;
|
174
|
+
|
175
|
+
for (t=0 ; (FILE_err&2)==0 ; t++){
|
176
|
+
ARY_SCAN (c, double, *fp, 0);
|
177
|
+
if ( M->flag & LOAD_TPOSE ){
|
178
|
+
if ( M->t == 0 ){ M->t = c; if ( M->clms>0 ) break; }
|
179
|
+
} else if ( M->clms == 0 ){ M->clms = c; if ( M->t>0 ) break; }
|
180
|
+
if ( c == 0 ) t--;
|
181
|
+
}
|
182
|
+
if ( M->flag & LOAD_TPOSE ){ if ( M->clms==0 ) M->clms = t;} else if ( M->t==0 ) M->t = t;
|
183
|
+
FILE2_reset (fp);
|
184
|
+
M->end = M->t;
|
185
|
+
MAT_alloc (M, M->t, M->clms); if (ERROR_MES) return;
|
186
|
+
FLOOP (t, 0, (M->flag&LOAD_TPOSE)? M->clms: M->t){
|
187
|
+
FLOOP (c, 0, (M->flag&LOAD_TPOSE)? M->t: M->clms){
|
188
|
+
p = FILE2_read_double(fp);
|
189
|
+
if ( FILE_err==1 || FILE_err==2 ) break;
|
190
|
+
if ( M->flag&LOAD_TPOSE ) M->v[c].v[t] = p;
|
191
|
+
else M->v[t].v[c] = p;
|
192
|
+
if ( FILE_err==5 || FILE_err==6 ) break;
|
193
|
+
}
|
194
|
+
FLOOP (c, c, (M->flag&LOAD_TPOSE)? M->t: M->clms){
|
195
|
+
if ( M->flag&LOAD_TPOSE ) M->v[c].v[t] = 0;
|
196
|
+
else M->v[t].v[c] = 0;
|
197
|
+
}
|
198
|
+
if ( !FILE_err ) FILE2_read_until_newline (fp);
|
199
|
+
}
|
200
|
+
}
|
201
|
+
|
202
|
+
/* load file with switching the format according to the flag */
|
203
|
+
void MAT_load (MAT *M){
|
204
|
+
FILE2 fp = INIT_FILE2;
|
205
|
+
int unit=0;
|
206
|
+
#ifdef USE_MATH
|
207
|
+
VEC_ID i;
|
208
|
+
#endif
|
209
|
+
if ( M->flag & VEC_LOAD_BIN ) unit = 1;
|
210
|
+
else if ( M->flag & VEC_LOAD_BIN2 ) unit = 2;
|
211
|
+
else if ( M->flag & VEC_LOAD_BIN4 ) unit = 4;
|
212
|
+
if ( M->flag & VEC_LOAD_CENTERIZE ) unit = -unit;
|
213
|
+
|
214
|
+
FILE2_open (fp, M->fname, "rb", EXIT);
|
215
|
+
if ( unit ) MAT_load_bin (M, &fp, unit);
|
216
|
+
else MAT_file_load (M, &fp);
|
217
|
+
|
218
|
+
FILE2_close (&fp); if (ERROR_MES) EXIT;
|
219
|
+
#ifdef USE_MATH
|
220
|
+
if ( M->flag&VEC_NORMALIZE ) FLOOP (i, 0, M->t) ARY_NORMALIZE (M->v[i].v,M->v[i].t);
|
221
|
+
#endif
|
222
|
+
print_mes (M, "mat: %s ,#rows %d ,#clms %d\n", M->fname, M->t, M->clms);
|
223
|
+
}
|
224
|
+
|
225
|
+
|
226
|
+
/* scan file and read the numbers for SMAT */
|
227
|
+
/* flag&1? SMAT, SETFAMILY, flag&2? tuple list format: array list :*/
|
228
|
+
void SMAT_file_load (SMAT *M, FILE2 *fp){
|
229
|
+
SVEC_VAL z=0;
|
230
|
+
VEC_ID flag= (M->type==TYPE_SMAT), t, x, y;
|
231
|
+
FILE_COUNT C;
|
232
|
+
|
233
|
+
C = FILE2_count (fp, (M->flag&(LOAD_ELE+LOAD_TPOSE)) | FILE_COUNT_ROWT, 0, 0, 0, 0, 0);
|
234
|
+
if ( M->clms == 0 ) M->clms = C.clms;
|
235
|
+
if ( M->t == 0 ) M->t = C.rows;
|
236
|
+
if ( flag ) SMAT_alloc (M, M->t, C.rowt, M->clms, 0);
|
237
|
+
else SETFAMILY_alloc ((SETFAMILY *)M, M->t, C.rowt, M->clms, 0);
|
238
|
+
free2 (C.rowt);
|
239
|
+
if ( ERROR_MES ) return;
|
240
|
+
FILE2_reset (fp);
|
241
|
+
t=0;
|
242
|
+
do {
|
243
|
+
if ( M->flag&LOAD_ELE ){
|
244
|
+
x = (VEC_ID)FILE2_read_int (fp);
|
245
|
+
y = (VEC_ID)FILE2_read_int (fp);
|
246
|
+
if ( flag ) z = FILE2_read_double (fp);
|
247
|
+
if ( FILE_err&4 ) goto LOOP_END2;
|
248
|
+
FILE2_read_until_newline (fp);
|
249
|
+
} else {
|
250
|
+
x = t;
|
251
|
+
y = (VEC_ID)FILE2_read_int (fp);
|
252
|
+
if ( FILE_err&4 ) goto LOOP_END2;
|
253
|
+
if ( flag ) z = FILE2_read_double (fp);
|
254
|
+
}
|
255
|
+
if ( M->flag&LOAD_TPOSE ) SWAP_VEC_ID (x, y);
|
256
|
+
// printf ("%d %d %d %d\n", x, M->t, y, M->clms);
|
257
|
+
if ( y >= M->clms || x >= M->t ) goto LOOP_END2;
|
258
|
+
// printf ("## %d %d\n", x, y);
|
259
|
+
if ( flag ){
|
260
|
+
M->v[x].v[M->v[x].t].i = y;
|
261
|
+
M->v[x].v[M->v[x].t].a = z;
|
262
|
+
M->v[x].t++;
|
263
|
+
} else QUE_INS (((SETFAMILY *)M)->v[x], y);
|
264
|
+
LOOP_END2:;
|
265
|
+
if ( !(M->flag&LOAD_ELE) && (FILE_err&3) ){ t++; if ( t >= M->t ) break; }
|
266
|
+
} while ( (FILE_err&2)==0 );
|
267
|
+
}
|
268
|
+
|
269
|
+
/* scan file and read the numbers for SMAT */
|
270
|
+
/* flag&1? SMAT, SETFAMILY, flag&2? tuple list format: array list :*/
|
271
|
+
void SETFAMILY_load_weight (SETFAMILY *M){
|
272
|
+
FILE2 fp = INIT_FILE2;
|
273
|
+
VEC_ID i;
|
274
|
+
QUEUE_ID j;
|
275
|
+
if ( M->flag&LOAD_TPOSE ) error ("transope and weight can't be specified simultaneously", EXIT);
|
276
|
+
FILE2_open (fp, M->wfname, "r", EXIT);
|
277
|
+
SETFAMILY_alloc_weight (M);
|
278
|
+
FLOOP (i, 0, M->t){
|
279
|
+
FLOOP (j, 0, M->v[i].t)
|
280
|
+
M->w[i][j] = (WEIGHT)FILE2_read_double (&fp);
|
281
|
+
FILE2_read_until_newline (&fp);
|
282
|
+
}
|
283
|
+
}
|
284
|
+
|
285
|
+
void SETFAMILY_load_column_weight (SETFAMILY *M){
|
286
|
+
int i;
|
287
|
+
#ifdef WEIGHT_DOUBLE
|
288
|
+
ARY_LOAD (M->cw, double, i, M->cwfname, 1, EXIT);
|
289
|
+
#else
|
290
|
+
ARY_LOAD (M->cw, int, i, M->cwfname, 1, EXIT);
|
291
|
+
#endif
|
292
|
+
if ( i < M->clms ){ realloc2 (M->cw, M->clms+1, EXIT); ARY_FILL (M->cw, i, M->clms+1, 0); }
|
293
|
+
}
|
294
|
+
|
295
|
+
void SETFAMILY_load_row_weight (SETFAMILY *M){
|
296
|
+
int i;
|
297
|
+
#ifdef WEIGHT_DOUBLE
|
298
|
+
ARY_LOAD (M->rw, double, i, M->rwfname, 1, EXIT);
|
299
|
+
#else
|
300
|
+
ARY_LOAD (M->rw, int, i, M->rwfname, 1, EXIT);
|
301
|
+
#endif
|
302
|
+
if ( i < M->t ){ realloc2 (M->rw, M->t+1, EXIT); ARY_FILL (M->rw, i, M->t+1, 0); }
|
303
|
+
}
|
304
|
+
|
305
|
+
|
306
|
+
/* load file with switching the format according to the flag */
|
307
|
+
void SMAT_load (SMAT *M){
|
308
|
+
FILE2 fp = INIT_FILE2;
|
309
|
+
VEC_ID i;
|
310
|
+
M->type = TYPE_SMAT;
|
311
|
+
FILE2_open (fp, M->fname, "r", EXIT);
|
312
|
+
SMAT_file_load (M, &fp);
|
313
|
+
FILE2_close (&fp); if (ERROR_MES) EXIT;
|
314
|
+
FLOOP (i, 0, M->t) M->v[i].v[M->v[i].t].i = M->clms; // end mark
|
315
|
+
|
316
|
+
#ifdef USE_MATH
|
317
|
+
if ( M->flag&VEC_NORMALIZE ) FLOOP (i, 0, M->t) SVEC_normalize (&M->v[i]); // normalize
|
318
|
+
#endif
|
319
|
+
if (M->flag&LOAD_INCSORT)
|
320
|
+
FLOOP (i, 0, M->t) qsort_VEC_ID ((VEC_ID *)(M->v[i].v), M->v[i].t, sizeof(SVEC_ELE));
|
321
|
+
if (M->flag&LOAD_DECSORT)
|
322
|
+
FLOOP (i, 0, M->t) qsort_VEC_ID ((VEC_ID *)(M->v[i].v), M->v[i].t, -(int)sizeof(SVEC_ELE));
|
323
|
+
if (M->flag&LOAD_RM_DUP)
|
324
|
+
FLOOP (i, 0, M->t) MQUE_UNIFY (M->v[i], SVEC_VAL);
|
325
|
+
M->eles = M->ele_end;
|
326
|
+
print_mes (M, "smat: %s ,#rows %d ,#clms %d ,#eles %zd\n", M->fname, M->t, M->clms, M->eles);
|
327
|
+
|
328
|
+
}
|
329
|
+
|
330
|
+
/* sort and duplication check */
|
331
|
+
void SETFAMILY_sort (SETFAMILY *M){
|
332
|
+
VEC_ID i;
|
333
|
+
PERM *p;
|
334
|
+
WEIGHT *ww;
|
335
|
+
QUEUE Q;
|
336
|
+
int flag = (M->flag&LOAD_INCSORT)? 1: ((M->flag&LOAD_DECSORT)? -1: 0);
|
337
|
+
if ( flag ){ // sort items in each row
|
338
|
+
malloc2 (p, M->clms, EXIT);
|
339
|
+
FLOOP (i, 0, M->t)
|
340
|
+
QUEUE_perm_WEIGHT (&M->v[i], M->w?M->w[i]:NULL, p, flag);
|
341
|
+
free (p);
|
342
|
+
}
|
343
|
+
flag = ((M->flag&LOAD_SIZSORT)? ((M->flag&LOAD_DECROWSORT)? -1: 1): 0) *sizeof(QUEUE);
|
344
|
+
if ( flag ){ // sort the rows
|
345
|
+
p = qsort_perm_VECt ((VEC *)M->v, M->t, flag);
|
346
|
+
if ( M->w ) ARY_INVPERMUTE_ (M->w, p, ww, M->t);
|
347
|
+
ARY_INVPERMUTE (M->v, p, Q, M->t, EXIT);
|
348
|
+
free (p);
|
349
|
+
}
|
350
|
+
if (M->flag&LOAD_RM_DUP){ // unify the duplicated edges
|
351
|
+
FLOOP (i, 0, M->t)
|
352
|
+
QUEUE_rm_dup_WEIGHT (&M->v[i], M->w?M->w[i]:NULL);
|
353
|
+
}
|
354
|
+
}
|
355
|
+
|
356
|
+
/* scan file and load the data from file to SMAT structure */
|
357
|
+
void SETFAMILY_load (SETFAMILY *M){
|
358
|
+
FILE2 fp = INIT_FILE2;
|
359
|
+
VEC_ID i;
|
360
|
+
M->type = TYPE_SETFAMILY;
|
361
|
+
FILE2_open (fp, M->fname, "r", EXIT);
|
362
|
+
SMAT_file_load ((SMAT *)M, &fp);
|
363
|
+
FILE2_close (&fp); if(ERROR_MES) EXIT;
|
364
|
+
print_mes (M, "setfamily: %s ,#rows %d ,#clms %d ,#eles %zd", M->fname, M->t, M->clms, M->eles);
|
365
|
+
if ( !(M->flag&LOAD_ELE) && M->wfname ){
|
366
|
+
SETFAMILY_load_weight (M); if ( ERROR_MES ){ SETFAMILY_end (M); EXIT; }
|
367
|
+
print_mes (M, " ,weightfile %s", M->wfname);
|
368
|
+
}
|
369
|
+
print_mes (M, "\n");
|
370
|
+
|
371
|
+
SETFAMILY_sort (M);
|
372
|
+
FLOOP (i, 0, M->t) M->v[i].v[M->v[i].t] = M->clms; // end mark
|
373
|
+
M->eles = M->ele_end;
|
374
|
+
|
375
|
+
}
|
376
|
+
|
377
|
+
/* print routines */
|
378
|
+
void MAT_print (FILE *fp, MAT *M){
|
379
|
+
VEC *V;
|
380
|
+
MQUE_FLOOP (*M, V) ARY_FPRINT (fp, V->v, 0, V->t, VEC_VALF" ");
|
381
|
+
}
|
382
|
+
void SVEC_print (FILE *fp, SVEC *V){
|
383
|
+
SVEC_ELE *x;
|
384
|
+
MQUE_FLOOP (*V, x) fprintf (fp, "("QUEUE_IDF","SVEC_VALF") ", (*x).i, (*x).a);
|
385
|
+
fputc ('\n', fp);
|
386
|
+
}
|
387
|
+
void SMAT_print (FILE *fp, SMAT *M){
|
388
|
+
SVEC *V;
|
389
|
+
MQUE_FLOOP (*M, V) SVEC_print (fp, V);
|
390
|
+
}
|
391
|
+
void SETFAMILY_print (FILE *fp, SETFAMILY *M){
|
392
|
+
QUEUE *V;
|
393
|
+
MQUE_FLOOP (*M, V) ARY_FPRINT (fp, V->v, 0, V->t, QUEUE_INTF" ");
|
394
|
+
}
|
395
|
+
|
396
|
+
/*
|
397
|
+
void SETFAMILY_print_WEIGHT (FILE *fp, SETFAMILY *M){
|
398
|
+
if ( M->w ){
|
399
|
+
printf (","); fprint_WEIGHT (stdout, M->w[i][j]); }
|
400
|
+
printf ("\n");
|
401
|
+
}
|
402
|
+
*/
|
403
|
+
|
404
|
+
/****************************************************************/
|
405
|
+
/** Inner product routines **************************************/
|
406
|
+
/****************************************************************/
|
407
|
+
SVEC_VAL2 SVEC_inpro (SVEC *V1, SVEC *V2){
|
408
|
+
VEC_ID i1, i2=0;
|
409
|
+
SVEC_VAL2 sum=0;
|
410
|
+
FLOOP (i1, 0, V1->t){
|
411
|
+
while (V2->v[i2].i < V1->v[i1].i) i2++;
|
412
|
+
if (V2->v[i2].i == V1->v[i1].i) sum += ((SVEC_VAL2)V2->v[i2].a)*V1->v[i1].a;
|
413
|
+
}
|
414
|
+
return (sum);
|
415
|
+
}
|
416
|
+
|
417
|
+
|
418
|
+
/* get ith vector */
|
419
|
+
void *MVEC_getvec (void *M, int i, int flag){
|
420
|
+
MAT *MM = (MAT *)M;
|
421
|
+
if (MM->type==TYPE_MAT) return (&MM->v[i]);
|
422
|
+
if (MM->type==TYPE_SMAT) return (&((SVEC *)M)->v[i]);
|
423
|
+
if (MM->type==TYPE_SETFAMILY) return (&((QUEUE *)M)->v[i]);
|
424
|
+
return (NULL);
|
425
|
+
}
|
426
|
+
|
427
|
+
/* compute the inner product of two vectors */
|
428
|
+
double VEC_inpro (VEC *V1, VEC *V2){
|
429
|
+
VEC_VAL sum=0;
|
430
|
+
VEC_VAL *v1 = V1->v, *v2 = V2->v, *v_end = v1 + MIN (V1->end, V2->end), *vv=v_end-1;
|
431
|
+
#ifdef USE_SIMD
|
432
|
+
__m128d u1, u2, u3;
|
433
|
+
double r[2];
|
434
|
+
if ( v1 < vv ){
|
435
|
+
u3 = _mm_load_pd (v1); v1 += 2;
|
436
|
+
u2 = _mm_load_pd (v2); v2 += 2;
|
437
|
+
u3 = _mm_mul_pd (u3, u2);
|
438
|
+
while ( v1 < vv ){
|
439
|
+
u1 = _mm_load_pd (v1); v1 += 2;
|
440
|
+
u2 = _mm_load_pd (v2); v2 += 2;
|
441
|
+
u1 = _mm_mul_pd (u1, u2);
|
442
|
+
u3 = _mm_add_pd (u3, u1);
|
443
|
+
}
|
444
|
+
_mm_storeu_pd (r, u3);
|
445
|
+
sum = r[0]+r[1];
|
446
|
+
_mm_empty();
|
447
|
+
}
|
448
|
+
#else
|
449
|
+
VEC_VAL a0, a1;
|
450
|
+
while ( v1 < vv ){
|
451
|
+
a0 = *v1 * *v2; v1++; v2++;
|
452
|
+
a1 = *v1 * *v2; v1++; v2++;
|
453
|
+
sum += a0 + a1;
|
454
|
+
}
|
455
|
+
#endif
|
456
|
+
if ( v1 < v_end ){ sum += *v1 * *v2; }
|
457
|
+
return (sum);
|
458
|
+
}
|
459
|
+
|
460
|
+
/* compute the l1-norm of two vectors */
|
461
|
+
double VEC_l1dist (VEC *V1, VEC *V2){
|
462
|
+
VEC_ID i, end=MIN(V1->end,V2->end);
|
463
|
+
double sum=0;
|
464
|
+
FLOOP (i, 0, end) sum += abs (((double)V1->v[i])- ((double)V2->v[i]));
|
465
|
+
return (sum);
|
466
|
+
}
|
467
|
+
|
468
|
+
/* compute the l-infinity-norm of two vectors */
|
469
|
+
double VEC_linfdist (VEC *V1, VEC *V2){
|
470
|
+
VEC_ID i, end=MIN(V1->end,V2->end);
|
471
|
+
double m=0;
|
472
|
+
FLOOP (i, 0, end) ENMAX (m, abs (((double)V1->v[i])- ((double)V2->v[i])));
|
473
|
+
return (m);
|
474
|
+
}
|
475
|
+
|
476
|
+
double SETFAMILY_resemblance (QUEUE *Q1, QUEUE *Q2){
|
477
|
+
int *x, *y=Q2->v, *yy = y+Q2->t, s=0;
|
478
|
+
MQUE_FLOOP (*Q1, x){
|
479
|
+
while ( *y < *x ){ if ( ++y == yy ) goto END; }
|
480
|
+
if ( *y == *x ){ s++; if ( ++y == yy ) goto END; }
|
481
|
+
}
|
482
|
+
END:;
|
483
|
+
return ( ((double)s) / ((double)(Q1->t + Q2->t)));
|
484
|
+
}
|
485
|
+
|
486
|
+
|
487
|
+
#ifdef USE_MATH
|
488
|
+
|
489
|
+
/****************************************************************/
|
490
|
+
/** Norm computation and normalization ************************/
|
491
|
+
/****************************************************************/
|
492
|
+
double SVEC_norm (SVEC *V){
|
493
|
+
SVEC_ELE *v;
|
494
|
+
double sum=0;
|
495
|
+
MQUE_FLOOP (*V, v) sum += ((double)(v->a)) * (v->a);
|
496
|
+
return (sqrt(sum));
|
497
|
+
}
|
498
|
+
void SVEC_normalize (SVEC *V){
|
499
|
+
SVEC_ELE *v;
|
500
|
+
double norm = SVEC_norm (V);
|
501
|
+
MQUE_FLOOP (*V, v) v->a /= norm;
|
502
|
+
}
|
503
|
+
|
504
|
+
double VEC_norm (VEC *V){
|
505
|
+
return (sqrt (VEC_inpro (V, V)));
|
506
|
+
}
|
507
|
+
|
508
|
+
void VEC_normalize (VEC *V){
|
509
|
+
double norm = VEC_norm (V);
|
510
|
+
VEC_VAL *v = V->v, *v_end = v + V->end;
|
511
|
+
#ifdef USE_SIMD
|
512
|
+
__m128d u1, u2;
|
513
|
+
while ( v < v_end ){
|
514
|
+
u1 = _mm_load_pd (v);
|
515
|
+
u2 = _mm_load1_pd (&norm);
|
516
|
+
u1 = _mm_div_pd (u1, u2);
|
517
|
+
_mm_storeu_pd (v, u1);
|
518
|
+
}
|
519
|
+
_mm_empty();
|
520
|
+
if ( v < v_end ) *v /= norm;
|
521
|
+
#else
|
522
|
+
while ( v < v_end ) *v /= norm;
|
523
|
+
#endif
|
524
|
+
}
|
525
|
+
|
526
|
+
/****************************************************************/
|
527
|
+
/** Euclidean distance routines *********************************/
|
528
|
+
/****************************************************************/
|
529
|
+
|
530
|
+
/* compute the Euclidean distance of two vectors (VEC) */
|
531
|
+
double VEC_eucdist_ (VEC *V1, VEC *V2){
|
532
|
+
double sum=0, a0;
|
533
|
+
VEC_VAL *v1 = V1->v, *v2 = V2->v, *v_end = v1 + MIN (V1->end, V2->end), *vv=v_end-1;
|
534
|
+
#ifdef USE_SIMD
|
535
|
+
__m128d u1, u2, u3;
|
536
|
+
double r[2];
|
537
|
+
if ( v1 < vv ){
|
538
|
+
u3 = _mm_load_pd (v1); v1 += 2;
|
539
|
+
u2 = _mm_load_pd (v2); v2 += 2;
|
540
|
+
u3 = _mm_sub_pd (u3, u2);
|
541
|
+
u3 = _mm_mul_pd (u3, u3);
|
542
|
+
while ( v1 < vv ){
|
543
|
+
u1 = _mm_load_pd (v1); v1 += 2;
|
544
|
+
u2 = _mm_load_pd (v2); v2 += 2;
|
545
|
+
u1 = _mm_sub_pd (u1, u2);
|
546
|
+
u1 = _mm_mul_pd (u1, u1);
|
547
|
+
u3 = _mm_add_pd (u3, u1);
|
548
|
+
}
|
549
|
+
_mm_storeu_pd (r, u3);
|
550
|
+
sum = r[0]+r[1];
|
551
|
+
_mm_empty();
|
552
|
+
}
|
553
|
+
#else
|
554
|
+
double a1;
|
555
|
+
while ( v1 < vv ){
|
556
|
+
a0 = *v1 - *v2; v1++; v2++;
|
557
|
+
a1 = *v1 - *v2; v1++; v2++;
|
558
|
+
sum += a0*a0 + a1*a1;
|
559
|
+
}
|
560
|
+
#endif
|
561
|
+
if ( v1 < v_end ){ a0 = *v1 - *v2; sum += a0*a0; }
|
562
|
+
return (sum);
|
563
|
+
}
|
564
|
+
|
565
|
+
double VEC_eucdist (VEC *V1, VEC *V2){
|
566
|
+
double p = SQRT (VEC_eucdist_ (V1, V2));
|
567
|
+
#ifdef USE_SIMD
|
568
|
+
_mm_empty ();
|
569
|
+
#endif
|
570
|
+
return (p);
|
571
|
+
}
|
572
|
+
|
573
|
+
/* compute the Euclidean distance of two vectors (SVEC)*/
|
574
|
+
double SVEC_eucdist_ (SVEC *V1, SVEC *V2){
|
575
|
+
VEC_ID i1, i2;
|
576
|
+
double sum=0, a;
|
577
|
+
for ( i1=i2=0 ; i1<V1->t && i2<V2->t ; ){
|
578
|
+
if (V2->v[i2].i > V1->v[i1].i) a = V1->v[i1].a;
|
579
|
+
else if (V2->v[i2].i < V1->v[i1].i) a = V2->v[i2].a;
|
580
|
+
else a = ((double)V2->v[i2].a) - ((double)V1->v[i1].a);
|
581
|
+
sum += a*a;
|
582
|
+
}
|
583
|
+
return (sum);
|
584
|
+
}
|
585
|
+
|
586
|
+
double SVEC_eucdist (SVEC *V1, SVEC *V2){
|
587
|
+
return (sqrt (SVEC_eucdist (V1, V2)));
|
588
|
+
}
|
589
|
+
|
590
|
+
/* compute the Euclidean distance of two vectors (VEC * SVEC)*/
|
591
|
+
double VEC_SVEC_eucdist (VEC *V1, SVEC *V2){
|
592
|
+
VEC_ID i, i2=0;
|
593
|
+
double sum=0, a;
|
594
|
+
FLOOP (i, 0, V1->end){
|
595
|
+
if ( i < V2->v[i2].i ) a = V1->v[i];
|
596
|
+
else { a = ((double)V1->v[i]) - ((double)V2->v[i2].a); i2++; }
|
597
|
+
sum += a*a;
|
598
|
+
}
|
599
|
+
return (sqrt(sum));
|
600
|
+
}
|
601
|
+
|
602
|
+
/**********************************************************/
|
603
|
+
/* Euclidean distance of vector and set */
|
604
|
+
double VEC_QUEUE_eucdist (VEC *V, QUEUE *Q){
|
605
|
+
VEC_ID i;
|
606
|
+
QUEUE_ID i2=0;
|
607
|
+
double sum=0, a;
|
608
|
+
FLOOP (i, 0, V->end){
|
609
|
+
if ( i < Q->v[i2] ) a = V->v[i];
|
610
|
+
else { a = ((double)V->v[i]) - 1.0; i2++; }
|
611
|
+
sum += a*a;
|
612
|
+
}
|
613
|
+
return (sqrt(sum));
|
614
|
+
}
|
615
|
+
|
616
|
+
/* compute Euclidean distance of two sets */
|
617
|
+
double QUEUE_eucdist (QUEUE *Q1, QUEUE *Q2){
|
618
|
+
double f;
|
619
|
+
MQUE_UNION(f, *Q1, *Q2);
|
620
|
+
return (sqrt(f));
|
621
|
+
}
|
622
|
+
|
623
|
+
double MVEC_norm (void *V){
|
624
|
+
VEC *VV = (VEC *)V;
|
625
|
+
double p;
|
626
|
+
if (VV->type==TYPE_VEC){ ARY_NORM (p, VV->v, VV->t); return (p); }
|
627
|
+
if (VV->type==TYPE_SVEC) return (SVEC_norm ((SVEC *)V));
|
628
|
+
if (VV->type==TYPE_QUEUE) return (sqrt(((QUEUE*)V)->t));
|
629
|
+
return (0.0);
|
630
|
+
}
|
631
|
+
|
632
|
+
double MMAT_norm_i (void *M, int i){
|
633
|
+
MAT *MM = (MAT *)M;
|
634
|
+
double p;
|
635
|
+
if (MM->type==TYPE_MAT){ ARY_NORM (p, MM->v[i].v, MM->v[i].t); return (p); }
|
636
|
+
if (MM->type==TYPE_SMAT) return (SVEC_norm (&((SMAT *)M)->v[i]));
|
637
|
+
if (MM->type==TYPE_SETFAMILY) return (sqrt (((SETFAMILY *)M)->v[i].t));
|
638
|
+
return (0.0);
|
639
|
+
}
|
640
|
+
|
641
|
+
double MVEC_eucdist (void *V, void *U){
|
642
|
+
VEC *VV = (VEC *)V;
|
643
|
+
double p;
|
644
|
+
if (VV->type==TYPE_VEC) return (VEC_eucdist ((VEC *)V, (VEC *)U));
|
645
|
+
if (VV->type==TYPE_SVEC) return (SVEC_eucdist ((SVEC *)V, (SVEC *)U));
|
646
|
+
if (VV->type==TYPE_QUEUE){ MQUE_DIF (p, *((QUEUE *)V), *((QUEUE *)U)); return (sqrt(p));}
|
647
|
+
return (0.0);
|
648
|
+
}
|
649
|
+
|
650
|
+
double MMAT_eucdist_ij (void *M, int i, int j){
|
651
|
+
MAT *MM=(MAT *)M;
|
652
|
+
double p;
|
653
|
+
if (MM->type==TYPE_MAT) return (VEC_eucdist ( &MM->v[i], &MM->v[j] ));
|
654
|
+
if (MM->type==TYPE_SMAT) return (SVEC_eucdist ( &((SMAT *)M)->v[i], &((SMAT *)M)->v[j]));
|
655
|
+
if (MM->type==TYPE_SETFAMILY){ MQUE_DIF (p, ((SETFAMILY *)M)->v[i], ((SETFAMILY *)M)->v[j]); return (sqrt(p)); }
|
656
|
+
return (0.0);
|
657
|
+
}
|
658
|
+
|
659
|
+
|
660
|
+
#endif
|
661
|
+
|
662
|
+
/**********************************************************/
|
663
|
+
/** multi-vector routines ******************************/
|
664
|
+
/**********************************************************/
|
665
|
+
|
666
|
+
/* compute the inner product, Euclidean distance for multi vector */
|
667
|
+
double MVEC_inpro (void *V, void *U){
|
668
|
+
VEC *VV = (VEC *)V, *UU = (VEC *)U;
|
669
|
+
double p;
|
670
|
+
if (VV->type==TYPE_VEC){
|
671
|
+
if (UU->type==TYPE_VEC){ ARY_INPRO (p, VV->v, UU->v, VV->t); return (p); }
|
672
|
+
if (UU->type==TYPE_SVEC){ ARY_SVEC_INPRO (p, *((SVEC *)U), VV->v); return (p); }
|
673
|
+
if (UU->type==TYPE_QUEUE){ ARY_QUEUE_INPRO (p, *((QUEUE *)U), VV->v); return (p); }
|
674
|
+
}
|
675
|
+
if (VV->type==TYPE_SVEC){
|
676
|
+
if (UU->type==TYPE_VEC){ ARY_SVEC_INPRO (p, *((SVEC *)V), UU->v); return (p);}
|
677
|
+
if (UU->type==TYPE_SVEC) return (SVEC_inpro ((SVEC *)V, (SVEC *)U));
|
678
|
+
// if (UU->type==TYPE_QUEUE) return (VEC_QUEUE_inpro (V, U));
|
679
|
+
}
|
680
|
+
if (VV->type==TYPE_QUEUE){
|
681
|
+
if (UU->type==TYPE_VEC){ ARY_QUEUE_INPRO (p, *((QUEUE *)V), UU->v); return (p); }
|
682
|
+
// else if (UU->type==TYPE_SVEC) return (SVEC_inpro (V, U));
|
683
|
+
if (UU->type==TYPE_QUEUE){ MQUE_INTSEC (p, *((QUEUE *)V), *((QUEUE *)U)); return (p);}
|
684
|
+
}
|
685
|
+
return (0.0);
|
686
|
+
}
|
687
|
+
|
688
|
+
double MVEC_double_inpro (void *V, double *w){
|
689
|
+
VEC *VV = (VEC *)V;
|
690
|
+
double p;
|
691
|
+
if (VV->type==TYPE_VEC){ ARY_INPRO (p, VV->v, w, VV->t); return (p); }
|
692
|
+
if (VV->type==TYPE_SVEC){ ARY_SVEC_INPRO (p, *((SVEC *)V), w); return (p); }
|
693
|
+
if (VV->type==TYPE_QUEUE){ ARY_QUEUE_INPRO (p, *((QUEUE *)V), w); return (p); }
|
694
|
+
return (0.0);
|
695
|
+
}
|
696
|
+
|
697
|
+
/* compute the inner product, euclidean distance for i,jth vector */
|
698
|
+
double MMAT_inpro_ij (void *M, int i, int j){
|
699
|
+
MAT *MM = (MAT *)M;
|
700
|
+
double p;
|
701
|
+
if (MM->type==TYPE_MAT){ ARY_INPRO (p, MM->v[i].v, MM->v[j].v, MM->v[j].t); return (p); }
|
702
|
+
if (MM->type==TYPE_SMAT) return (SVEC_inpro (&((SMAT *)M)->v[i], &((SMAT *)M)->v[j]));
|
703
|
+
if (MM->type==TYPE_SETFAMILY){
|
704
|
+
p = QUEUE_intsec_ (&((SETFAMILY *)M)->v[i], &((SETFAMILY *)M)->v[j]); return (p); }
|
705
|
+
return (0.0);
|
706
|
+
}
|
707
|
+
|
708
|
+
double MMAT_double_inpro_i (void *M, int i, double *w){
|
709
|
+
MAT *MM = (MAT *)M;
|
710
|
+
double p;
|
711
|
+
if (MM->type==TYPE_MAT){ ARY_INPRO (p, MM->v[i].v, w, MM->v[i].t); return (p); }
|
712
|
+
if (MM->type==TYPE_SMAT){ ARY_SVEC_INPRO (p, ((SMAT *)M)->v[i], w); return (p); }
|
713
|
+
if (MM->type==TYPE_SETFAMILY){ ARY_QUEUE_INPRO (p, ((SETFAMILY *)M)->v[i], w); return (p); }
|
714
|
+
return (0.0);
|
715
|
+
}
|
716
|
+
|
717
|
+
#ifdef _barray_h_
|
718
|
+
void SETFAMILY_to_BARRAY (BARRAY *A, SETFAMILY *F){
|
719
|
+
VEC_ID t;
|
720
|
+
size_t i=0;
|
721
|
+
BARRAY_init (A, F->clms, F->t);
|
722
|
+
FLOOP (t, 0, F->t){
|
723
|
+
BARRAY_set_subset (&A->v[i], &F->v[t]);
|
724
|
+
i += A->xend;
|
725
|
+
}
|
726
|
+
}
|
727
|
+
#endif
|
728
|
+
|
729
|
+
#endif
|
730
|
+
|
731
|
+
|