PUBLIC int
move_adaptive(char *string,
short *ptable,
short *s,
short *s1,
int verbosity_level){
srand(time(NULL));
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=0;
enc.verbose_lvl=verbosity_level;
enc.first=1;
enc.shift=0;
/* 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;
// allocate memory for moves
enc.moves_from = (int*) space(ptable[0]*ptable[0]*sizeof(int));
enc.moves_to = (int*) space(ptable[0]*ptable[0]*sizeof(int));
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_rset(&enc, &str)!=0) {
free_degen(&enc);
}
free_degen(&enc);
copy_arr(ptable, str.structure);
free(str.structure);
free(enc.moves_from);
free(enc.moves_to);
return str.energy;
}
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;
}
PRIVATE int try_moves(intermediate_t c, int maxE, intermediate_t *next, int dist) {
int *loopidx, len, num_next=0, en, oldE;
move_t *mv;
short *pt;
len = c.pt[0];
loopidx = pair_table_to_loop_index(c.pt);
oldE = c.Sen;
for (mv=c.moves; mv->i!=0; mv++) {
int i,j;
if (mv->when>0) continue;
i = mv->i; j = mv->j;
pt = (short *) space(sizeof(short)*(len+1));
memcpy(pt, c.pt,(len+1)*sizeof(short));
if (j<0) { /*it's a delete move */
pt[-i]=0;
pt[-j]=0;
} else { /* insert move */
if ((loopidx[i] == loopidx[j]) && /* i and j belong to same loop */
(pt[i] == 0) && (pt[j]==0) /* ... and are unpaired */
) {
pt[i]=j;
pt[j]=i;
} else {
free(pt);
continue; /* llegal move, try next; */
}
}
#ifdef LOOP_EN
en = c.curr_en + energy_of_move_pt(c.pt, S, S1, i, j);
#else
en = energy_of_structure_pt(seq, pt, S, S1, 0);
#endif
if (en<maxE) {
next[num_next].Sen = (en>oldE)?en:oldE;
next[num_next].curr_en = en;
next[num_next].pt = pt;
mv->when=dist;
mv->E = en;
next[num_next++].moves = copy_moves(c.moves);
mv->when=0;
}
else free(pt);
}
free(loopidx);
return num_next;
}
// done with all structures along the way to deepest
int update_deepest(encoded &enc, int &deepest, short *min_pt, degen °, bool verbose)
{
// debug
/*if (deg.opt->f_point) {
fprintf(stderr, "UD: %s %.2f (%d, %d) (%d, %d)\n", pt_to_str(enc.pt).c_str(), deepest/100.0, enc.bp_left, enc.bp_right, enc.bp_left2, enc.bp_right2);
}*/
int tmp_en;
if (deg.opt->EOM) {
tmp_en = deg.current + energy_of_move_pt(enc.pt, enc.s0, enc.s1, enc.bp_left, enc.bp_right);
do_moves(enc, true, false);
if (enc.bp_left2 != 0) {
tmp_en += energy_of_move_pt(enc.pt, enc.s0, enc.s1, enc.bp_left2, enc.bp_right2);
do_moves(enc, false, true);
}
} else {
do_moves(enc);
tmp_en = energy_of_structure_pt(enc.seq, enc.pt, enc.s0, enc.s1, 0);
}
// our function
bool res = 0;
if (deg.opt->f_point) {
res = deg.opt->f_point(enc.pt, tmp_en);
undo_moves(enc);
return res;
}
// default behaviour
if (tmp_en <= deepest) {
deepest = tmp_en;
copy_arr(min_pt, enc.pt);
}
//printf("%s %7.2f\n", pt_to_str(enc.pt).c_str(), tmp_en/100.0);
undo_moves(enc);
return res;
}
PRIVATE int find_path_once(const char *struc1, const char *struc2, int maxE, int maxl) {
short *pt1, *pt2;
move_t *mlist;
int i, len, d, dist=0, result;
intermediate_t *current, *next;
pt1 = make_pair_table(struc1);
pt2 = make_pair_table(struc2);
len = (int) strlen(struc1);
mlist = (move_t *) space(sizeof(move_t)*len); /* bp_dist < n */
for (i=1; i<=len; i++) {
if (pt1[i] != pt2[i]) {
if (i<pt1[i]) { /* need to delete this pair */
mlist[dist].i = -i;
mlist[dist].j = -pt1[i];
mlist[dist++].when = 0;
}
if (i<pt2[i]) { /* need to insert this pair */
mlist[dist].i = i;
mlist[dist].j = pt2[i];
mlist[dist++].when = 0;
}
}
}
free(pt2);
BP_dist = dist;
current = (intermediate_t *) space(sizeof(intermediate_t)*(maxl+1));
current[0].pt = pt1;
current[0].Sen = current[0].curr_en = energy_of_structure_pt(seq, pt1, S, S1, 0);
current[0].moves = mlist;
next = (intermediate_t *) space(sizeof(intermediate_t)*(dist*maxl+1));
for (d=1; d<=dist; d++) { /* go through the distance classes */
int c, u, num_next=0;
intermediate_t *cc;
for (c=0; current[c].pt != NULL; c++) {
num_next += try_moves(current[c], maxE, next+num_next, d);
}
if (num_next==0) {
for (cc=current; cc->pt != NULL; cc++) free_intermediate(cc);
current[0].Sen=INT_MAX;
break;
}
/* remove duplicates via sort|uniq
if this becomes a bottleneck we can use a hash instead */
qsort(next, num_next, sizeof(intermediate_t),compare_ptable);
for (u=0,c=1; c<num_next; c++) {
if (memcmp(next[u].pt,next[c].pt,sizeof(short)*len)!=0) {
next[++u] = next[c];
} else {
free_intermediate(next+c);
}
}
num_next = u+1;
qsort(next, num_next, sizeof(intermediate_t),compare_energy);
/* free the old stuff */
for (cc=current; cc->pt != NULL; cc++) free_intermediate(cc);
for (u=0; u<maxl && u<num_next; u++) {
current[u] = next[u];
}
for (; u<num_next; u++)
free_intermediate(next+u);
num_next=0;
}
free(next);
path = current[0].moves;
result = current[0].Sen;
free(current[0].pt); free(current);
return(result);
}
// 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;
}
