//finds the LCA of powerset of set of profiles and insert if necessary
//graph holds the final graph, table[freq ID] = ID, profileID[profileID] = profile
//sums[profileID] = binary rep, k = number of profiles
//returns beginning of linked list containing all unique LCA's found
struct hashnode_s* insert_LCAs(FILE *fp,int k) {
int count,frq,*val,bit,s=0,j,*found,size = INIT_SIZE;
unsigned long num;
unsigned int i;
char *profile;
struct hashnode_s *node = NULL,*temp = NULL;
KEY *top;
found = malloc(sizeof(int)*k);
//for every subset of minimal elements...
//checking i = 1,2 is redundant (only 1 element in bin rep), so skip
//printf("k is %d\n",k);
for (i = 3; i < (1<<k); i++) {
count = 0;
frq = 0;
j = hashtbl_numkeys(binary);
//printf("number of freq helices %d\n",j);
num = (1<<j)-1;
//printf("original num is %d with j %d\n",num,j);
//...take their LCA...
for (bit = 0, j = i; j > 0 && bit < k ; j >>= 1, bit++)
if ((1 & j) == 1) {
found[count++] = bit;
//printf("found profile %s for bit %d\n",profileID[bit],bit);
//sprintf(key,"%s",table[bit]);
if (!(val = hashtbl_get(cluster,profileID[bit])))
fprintf(stderr, "No such %s in cluster with bit %d\n",profileID[bit],bit);
frq += *val;
num &= sums[bit];
//printf("num is %d after & with %d from bit %d: %s\n",num,sums[bit],bit,profileID[bit]);
}
//printf("binary profile is %d, k is %d,frq is %d, and binary helices is %d\n",i,k,frq,num);
//...and insert
if (num != 0) {
profile = malloc(sizeof(char)*ARRAYSIZE*size);
profile = convert_binary(profile,num,&s);
find_edges(fp,profile,found,count);
temp = insert_LCA(profile,num,s,frq);
if (temp) {
//printf("LCA profile %s and i %d\n",profile,i);
temp->next = node;
node = temp;
} else
free(profile);
}
}
//add final connection from root to smallest element in graph
for (i = 0; !graph[i]; i++) ;
for (top = hashtbl_getkeys(graph[i]); top; top = top->next)
check_insert_edge(fp,"",top->data);
free(found);
return node;
}
void SPARSE::find_sep(long p, long& ap, long* S, long** fl, long** fr, long* TMP){
#else
void SPARSE::find_sep(long p, long* n, long& in, long& ap, long* S, long** fl, long** fr){
#endif
const long min_num = 6;//Jestli je v poli mene prvku nez min_num, budou vrcholy zapsany do P
const long min_nw = 6;//Jestli pri prochazeni je mene nez min_nw, tak uz pulku dal neprochazej
const long sf = 3;//Zadej kdyz najdes vlnu z druhe strany
const long ct = 2;//Jeste jsem nenarazil na zadnou vlnu
long str = 1;//Zadej pri vyhledavani stredu - zadava se pri pruchodu zprava
long stl = -1;//Zadej pri vyhledavani stredu - zadava se pri pruchodu zleva
long nvl[2];// pocet hodnot zleva
long nvr[2];// pocet hodnot zprava
long a = 0;// index fl a fr do kterych se zapisuje
long b = 1;// index fl a fr ze kterych se cte(byli ziskany v minule vlne)
long rv[2];// Do tohoto pole budou zapsany vystupni vrcholy z find_edges()
long nv;//number of vertices - pocet hodnot ktere jsou v casti, ktera zacina v iv
long nw;//number of waves - kolik vln se vytvorilo
long i;//obecny index
#ifdef RECURSIVE_PERMUTATION
long in=0;//Pocet rozpuleni
#endif
//===================================
//Najdi krajni "nejvzdalenejsi" vrcholy
//===================================
nv = find_edges(fl, TMP, p, S, rv, nw);
if(nv<=min_num || nw<= min_nw){
for(i=0; i<nv; i++){
P[TMP[i]] = ap--;
S[TMP[i]] = 3;
}
return;
}
//===================================
//Rozdeleni casti
//===================================
//Inicializace:
nvl[a] = 0;
nvl[b] = 1;
nvr[a] = 0;
nvr[b] = 1;
fl[b][0]= rv[0];//nalezene prvky
fr[b][0]= rv[1];
S[fl[b][0]] = stl;
S[fr[b][0]] = str;
//Hlavni smycka - pracuje dokud jsou ve vlne nalezeny nove vrcholy
//POSLI NAPROTI SOBE DVE VLNY
while(nvl[b]>0 || nvr[b]>0){
nvl[a] = make_wave(S, ap, fl[b], fl[a], nvl[b], stl, sf, ct);
nvr[a] = make_wave(S, ap, fr[b], fr[a], nvr[b], str, sf, ct);
//Zamen pole
swap(a,b);
nvl[a]=nvr[a]=0;
}
//ZJISTI JESTLI NEKTERA Z HODNOT NEZUSTALA VE SLEPE ULICCE, JESTLI ANO, OZNAC JI JAKO STRED
for(i=0;i<nv;i++){
if(fabs(S[TMP[i]]) == ct){
S[TMP[i]] = sf;
P[TMP[i]] = ap--;
}
}
//Po nalezeni dalsich polovin zavolej na kazdou polovinu pulici funkci
in = 2;
#ifdef RECURSIVE_PERMUTATION
for(i=in-1; i>-1; i--){
find_sep(rv[i],ap,S,fl,fr,TMP);
}
#endif
}
// ==============================================================================
/**
\brief Procedura - Zprehazi sloupce a radky podle permutace MTX::P
*/
void SPARSE::apply_permutation()
{
long i,j;
size_t s;//velikost pole pro kopirovani pomoci memcpy
long** new_col_start;
long* new_value_length;
double** new_val_start;
long* key = new long[row_number];//Klic podle ktereho se spravne seradi radek
//===================================
//Zamen sloupce
//===================================
for(i=0;i<row_number;i++){
for(j=0;j<value_length[i];j++){
key[j] = P[column_start[i][j]];
}
s = sizeof(long)*value_length[i];
memcpy(column_start[i],key,s);
}
//===================================
//Prohazej radky
//===================================
//Alokuj nove pole pointeru na zacatky radku
new_col_start = new long* [row_number];
new_val_start = new double* [row_number];
new_value_length = new long [row_number];
//zapis do nich prepermutovane zacatky radku
for(i=0; i<row_number; i++){
new_col_start[P[i]] = column_start[i];
new_val_start[P[i]] = value_start[i];
new_value_length[P[i]] = value_length[i];
}
//Smaz stare zacatky
delete[] value_start;
delete[] column_start;
delete[] value_length;
// //Prehazej nove vytvorene na spravna mista
value_start = new_val_start;
column_start = new_col_start;
value_length = new_value_length;
//===================================
//Setrid hodnoty v radku podle sloupce
//===================================
for(i=0;i<row_number;i++){
BB_sortl(value_length[i],column_start[i], key);
update_field_D_by_key(value_length[i],value_start[i],key);
for(j=0;j<value_length[i];j++)
if(column_start[i][j]==i)
diagonal[i]=&value_start[i][j];
}
delete[] key;
}
