static int nhash_insert(int hashval, int *set, int setsize) {
struct nhash_list *tableptr;
int i, fs = 0;
current_setnum++;
tableptr = table+hashval;
nhash_load++;
for (i = 0; i < setsize; i++) {
if (finals[*(set+i)])
fs = 1;
}
if (tableptr->size == 0) {
tableptr->set_offset = move_set(set, setsize);
tableptr->size = setsize;
tableptr->setnum = current_setnum;
add_T_ptr(current_setnum, setsize, tableptr->set_offset, fs);
return(current_setnum);
}
tableptr = xxmalloc(sizeof(struct nhash_list));
tableptr->next = (table+hashval)->next;
(table+hashval)->next = tableptr;
tableptr->setnum = current_setnum;
tableptr->size = setsize;
tableptr->set_offset = move_set(set, setsize);
add_T_ptr(current_setnum, setsize, tableptr->set_offset, fs);
return(current_setnum);
}
PUBLIC int
move_first( char *string,
short *ptable,
short *s,
short *s1,
int verbosity_level,
int shifts,
int noLP){
cnt_move = 0;
Encoded enc;
enc.seq = string;
enc.s0 = s;
enc.s1 = s1;
/* moves*/
enc.bp_left=0;
enc.bp_right=0;
enc.bp_left2=0;
enc.bp_right2=0;
/* options*/
enc.noLP=noLP;
enc.verbose_lvl=verbosity_level;
enc.first=1;
enc.shift=shifts;
/* degeneracy*/
enc.begin_unpr=0;
enc.begin_pr=0;
enc.end_unpr=0;
enc.end_pr=0;
enc.current_en=0;
/* function */
enc.funct=NULL;
int i;
for (i=0; i<MAX_DEGEN; i++) enc.processed[i]=enc.unprocessed[i]=NULL;
struct_en str;
str.structure = allocopy(ptable);
str.energy = energy_of_structure_pt(enc.seq, str.structure, enc.s0, enc.s1, 0);
while (move_set(&enc, &str)!=0) {
free_degen(&enc);
}
free_degen(&enc);
copy_arr(ptable, str.structure);
free(str.structure);
return str.energy;
}
/* move to deepest (or first) neighbour*/
PRIVATE int
move_set(Encoded *Enc, struct_en *str){
/* count how many times called*/
cnt_move++;
/* count better neighbours*/
int cnt = 0;
/* deepest descent*/
struct_en min;
min.structure = allocopy(str->structure);
min.energy = str->energy;
Enc->current_en = str->energy;
if (Enc->verbose_lvl>0) { fprintf(stderr, " start of MS:\n "); print_str(stderr, str->structure); fprintf(stderr, " %d\n\n", str->energy); }
/* if using first dont do all of them*/
bool end = false;
/* insertions*/
if (!end) cnt += insertions(Enc, str, &min);
if (Enc->first && cnt>0) end = true;
if (Enc->verbose_lvl>1) fprintf(stderr, "\n");
/* deletions*/
if (!end) cnt += deletions(Enc, str, &min);
if (Enc->first && cnt>0) end = true;
/* shifts (only if enabled + noLP disabled)*/
if (!end && Enc->shift && !Enc->noLP) {
cnt += shifts(Enc, str, &min);
if (Enc->first && cnt>0) end = true;
}
/* if degeneracy occurs, solve it!*/
if (!end && (Enc->end_unpr - Enc->begin_unpr)>0) {
Enc->processed[Enc->end_pr] = str->structure;
Enc->end_pr++;
str->structure = Enc->unprocessed[Enc->begin_unpr];
Enc->unprocessed[Enc->begin_unpr]=NULL;
Enc->begin_unpr++;
cnt += move_set(Enc, str);
} else {
/* write output to str*/
copy_arr(str->structure, min.structure);
str->energy = min.energy;
}
/* release minimal*/
free(min.structure);
/* resolve degeneracy in local minima*/
if ((Enc->end_pr - Enc->begin_pr)>0) {
Enc->processed[Enc->end_pr]=str->structure;
Enc->end_pr++;
int min = find_min(Enc->processed, Enc->begin_pr, Enc->end_pr);
short *tmp = Enc->processed[min];
Enc->processed[min] = Enc->processed[Enc->begin_pr];
Enc->processed[Enc->begin_pr] = tmp;
str->structure = Enc->processed[Enc->begin_pr];
Enc->begin_pr++;
free_degen(Enc);
}
if (Enc->verbose_lvl>1 && !(Enc->first)) { fprintf(stderr, "\n end of MS:\n "); print_str(stderr, str->structure); fprintf(stderr, " %d\n\n", str->energy); }
return cnt;
}
// move to deepest (or first) neighbour
int move_set(encoded &enc, int &deepest, degen °)
{
// count how many times called
cnt_move++;
// count better neighbours
int cnt = 0;
// deepest descent
deg.current = deepest;
short *min_pt = allocopy(enc.pt);
if (deg.opt->verbose_lvl>3) fprintf(stderr, "\n start of MS:\n %s %d\n\n", pt_to_str(enc.pt).c_str(), deepest);
// if using first dont do all of them
bool end = false;
// insertions
if (!end) cnt += insertions(enc, deepest, min_pt, deg, deg.opt->verbose_lvl>3);
if (deg.opt->first && cnt>0) end = true;
fprintf(stderr, "\n");
// deletions
if (!end) cnt += deletions(enc, deepest, min_pt, deg, deg.opt->verbose_lvl>3);
if (deg.opt->first && cnt>0) end = true;
fprintf(stderr, "\n");
// shifts (only if enabled + noLP disabled)
if (!end && deg.opt->shift && !deg.opt->noLP) {
cnt += shifts(enc, deepest, min_pt, deg, deg.opt->verbose_lvl>3);
if (deg.opt->first && cnt>0) end = true;
}
if (deg.opt->verbose_lvl>3) fprintf(stderr, "\n %s\n %s\n", enc.seq, pt_to_str(min_pt).c_str());
// if degeneracy occurs, solve it!
if (!end && deg.unprocessed.size()>0) {
deg.processed.insert(allocopy(enc.pt));
// take first
if (enc.pt) free(enc.pt);
enc.pt = (*deg.unprocessed.begin());
deg.unprocessed.erase(deg.unprocessed.begin());
if (deg.opt->minh>0.1001) {
deepest = energy_of_structure_pt(enc.seq, enc.pt, enc.s0, enc.s1, 0);
}
cnt += move_set(enc, deepest, deg);
} else {
copy_arr(enc.pt, min_pt);
}
free(min_pt);
// resolve degeneracy in local minima
if (deg.processed.size()>0) {
deg.processed.insert(enc.pt);
enc.pt = *deg.processed.begin();
deg.processed.erase(deg.processed.begin());
erase_set(deg.processed);
}
return cnt;
}
