void gt_makeitmthresholds(Profilematrix *prof,
ProfScore minscore)
{
unsigned long d, a;
long ddown;
ProfScore partsum,
score,
*maxscore;
ALLOCASSIGNSPACE(maxscore,NULL,ProfScore,prof->dimension);
for (d=0; d<prof->dimension; d++)
{
for (a=0; a<prof->numofcharacters; a++)
{
score = GETPROFSCORE(prof,a,d);
if (a == 0 || maxscore[d] < score)
{
maxscore[d] = score;
}
}
}
partsum = (ProfScore) 0;
gt_assert(prof->itmthreshold != NULL);
for (ddown = (long) (prof->dimension-1); ddown>=0; ddown--)
{
prof->itmthreshold[ddown] = minscore - partsum;
partsum += maxscore[ddown];
}
FREESPACE(maxscore);
}
static void gt_tyrsearchinfo_init(Tyrsearchinfo *tyrsearchinfo,
const Tyrindex *tyrindex,
unsigned int showmode,
unsigned int searchstrand)
{
unsigned long merbytes;
merbytes = gt_tyrindex_merbytes(tyrindex);
tyrsearchinfo->mersize = gt_tyrindex_mersize(tyrindex);
tyrsearchinfo->mertable = gt_tyrindex_mertable(tyrindex);
tyrsearchinfo->lastmer = gt_tyrindex_lastmer(tyrindex);
tyrsearchinfo->showmode = showmode;
tyrsearchinfo->searchstrand = searchstrand;
tyrsearchinfo->dnaalpha = gt_alphabet_new_dna();
ALLOCASSIGNSPACE(tyrsearchinfo->bytecode,NULL,GtUchar,merbytes);
ALLOCASSIGNSPACE(tyrsearchinfo->rcbuf,NULL,GtUchar,tyrsearchinfo->mersize);
}
Substriter *gt_substriter_new(const GtAlphabet *alphabet,unsigned int qvalue)
{
Substriter *substriter;
ALLOCASSIGNSPACE(substriter,NULL,Substriter,1);
substriter->qvalue = qvalue;
substriter->numofchars = gt_alphabet_num_of_chars(alphabet);
substriter->multimappower = gt_initmultimappower(substriter->numofchars,
qvalue);
return substriter;
}
int test_trieins(bool onlyins,const GtStr *indexname,GtError *err)
{
Suffixarray suffixarray;
bool haserr = false;
Seqpos totallength = 0;
gt_error_check(err);
if (streamsuffixarray(&suffixarray,
SARR_ESQTAB,
indexname,
NULL,
err) != 0)
{
haserr = true;
} else
{
totallength = getencseqtotallength(suffixarray.encseq);
}
if (!haserr)
{
Mergertrierep trierep;
const GtUchar *characters;
ALLOCASSIGNSPACE(trierep.encseqreadinfo,NULL,Encseqreadinfo,1);
trierep.encseqreadinfo[0].encseqptr = suffixarray.encseq;
trierep.encseqreadinfo[0].readmode = suffixarray.readmode;
characters = getencseqAlphabetcharacters(suffixarray.encseq);
mergertrie_initnodetable(&trierep,totallength,1U);
maketrie(&trierep,characters,totallength);
if (onlyins)
{
#ifdef WITHTRIEIDENT
#ifdef WITHTRIESHOW
showtrie(&trierep,characters);
#endif
checktrie(&trierep,totallength+1,totallength,err);
#endif
} else
{
#ifdef WITHTRIEIDENT
#ifdef WITHTRIESHOW
showallnoderelations(trierep.root);
#endif
#endif
successivelydeletesmallest(&trierep,totallength,characters,err);
}
mergertrie_delete(&trierep);
}
freesuffixarray(&suffixarray);
return haserr ? -1 : 0;
}
GtCodetype *gt_initfilltable(unsigned int numofchars,unsigned int prefixlength)
{
unsigned int i;
GtCodetype *filltable, *basepower;
basepower = gt_initbasepower(numofchars,prefixlength);
ALLOCASSIGNSPACE(filltable,NULL,GtCodetype,prefixlength);
for (i=0; i<prefixlength; i++)
{
filltable[i] = basepower[prefixlength-i]-1;
}
FREESPACE(basepower);
return filltable;
}
GtCodetype *gt_initbasepower(unsigned int numofchars,unsigned int prefixlength)
{
GtCodetype thepower = (GtCodetype) 1, *basepower;
unsigned int i;
ALLOCASSIGNSPACE(basepower,NULL,GtCodetype,prefixlength+1);
for (i=0; /* Nothing */; i++)
{
basepower[i] = thepower;
if (i == prefixlength)
{
break;
}
gt_assert(thepower < ((~(GtCodetype) 0)/(GtCodetype) numofchars));
thepower *= numofchars;
}
return basepower;
}
Turningwheel *newTurningwheel(unsigned int numofwheels,
unsigned int asize)
{
unsigned int i;
Turningwheel *tw;
ALLOCASSIGNSPACE(tw,NULL,Turningwheel,1);
gt_assert(numofwheels < (unsigned int) MAXNUMOFWHEELS);
gt_assert(numofwheels > 0);
gt_assert(asize > 0);
for (i=0; i<numofwheels; i++)
{
tw->wheelspace[i] = 0;
}
tw->numofwheels = numofwheels;
tw->asize = asize;
tw->idx = numofwheels - 1;
tw->minchanged = 0;
return tw;
}
void gt_lookaheadsearchPSSM(const GtEncseq *encseq,
const Profilematrix *prof)
{
unsigned long firstpos, bufsize;
GtUchar currentchar;
unsigned long pos;
GtEncseqReader *esr;
unsigned long totallength = gt_encseq_total_length(encseq);
GtUchar *buffer;
esr = gt_encseq_create_reader_with_readmode(encseq,GT_READMODE_FORWARD,0);
ALLOCASSIGNSPACE(buffer,NULL,GtUchar,prof->dimension);
firstpos = bufsize = 0;
for (pos=0; pos < totallength; pos++)
{
currentchar = gt_encseq_reader_next_encoded_char(esr);
if (ISSPECIAL(currentchar))
{
bufsize = firstpos = 0;
} else
{
if (bufsize < prof->dimension)
{
buffer[bufsize++] = currentchar;
} else
{
buffer[firstpos++] = currentchar;
if (firstpos == prof->dimension)
{
firstpos = 0;
}
}
}
}
gt_encseq_reader_delete(esr);
FREESPACE(buffer);
}
static GtOPrval parse_options(int *parsed_args,
Cmppairwiseopt *pw,
int argc, const char **argv, GtError *err)
{
GtOptionParser *op;
GtOption *optionstrings,
*optionfiles,
*optioncharlistlen,
*optiontext;
GtStrArray *charlistlen;
GtOPrval oprval;
gt_error_check(err);
charlistlen = gt_str_array_new();
pw->strings = gt_str_array_new();
pw->files = gt_str_array_new();
pw->text = gt_str_new();
pw->charlistlen = NULL;
op = gt_option_parser_new("options","Apply function to pairs of strings.");
gt_option_parser_set_mail_address(op,"<*****@*****.**>");
optionstrings = gt_option_new_string_array("ss","use two strings",
pw->strings);
gt_option_parser_add_option(op, optionstrings);
optionfiles = gt_option_new_filename_array("ff","use two files",
pw->files);
gt_option_parser_add_option(op, optionfiles);
optioncharlistlen = gt_option_new_string_array("a",
"use character list and length",
charlistlen);
gt_option_parser_add_option(op, optioncharlistlen);
optiontext = gt_option_new_string("t","use text",pw->text, NULL);
gt_option_parser_add_option(op, optiontext);
gt_option_exclude(optionstrings, optionfiles);
gt_option_exclude(optionstrings, optioncharlistlen);
gt_option_exclude(optionstrings, optiontext);
gt_option_exclude(optionfiles, optioncharlistlen);
gt_option_exclude(optionfiles, optiontext);
gt_option_exclude(optioncharlistlen, optiontext);
oprval = gt_option_parser_parse(op, parsed_args, argc, argv, gt_versionfunc,
err);
if (oprval == GT_OPTION_PARSER_OK)
{
if (gt_option_is_set(optionstrings))
{
if (gt_str_array_size(pw->strings) != 2UL)
{
gt_error_set(err, "option -ss requires two string arguments");
oprval = GT_OPTION_PARSER_ERROR;
}
} else
{
if (gt_option_is_set(optionfiles))
{
if (gt_str_array_size(pw->files) != 2UL)
{
gt_error_set(err, "option -ff requires two filename arguments");
oprval = GT_OPTION_PARSER_ERROR;
}
} else
{
if (gt_option_is_set(optioncharlistlen))
{
long readint;
if (gt_str_array_size(charlistlen) != 2UL)
{
gt_error_set(err,
"option -a requires charlist and length argument");
oprval = GT_OPTION_PARSER_ERROR;
}
ALLOCASSIGNSPACE(pw->charlistlen,NULL,Charlistlen,1);
pw->charlistlen->charlist =
gt_str_ref(gt_str_array_get_str(charlistlen,
0));
if (sscanf(gt_str_array_get(charlistlen,1UL),"%ld",&readint) != 1 ||
readint < 1L)
{
gt_error_set(err,
"option -a requires charlist and length argument");
oprval = GT_OPTION_PARSER_ERROR;
}
pw->charlistlen->len = (unsigned long) readint;
} else
{
if (!gt_option_is_set(optiontext))
{
gt_error_set(err,
"use exactly one of the options -ss, -ff, -a, -t");
oprval = GT_OPTION_PARSER_ERROR;
}
}
}
}
}
gt_option_parser_delete(op);
if (oprval == GT_OPTION_PARSER_OK && *parsed_args != argc)
{
gt_error_set(err, "superfluous program parameters");
oprval = GT_OPTION_PARSER_ERROR;
}
gt_str_array_delete(charlistlen);
return oprval;
}
unsigned long greedyunitedist(const GtUchar *useq,
unsigned long ulenvalue,
const GtUchar *vseq,
unsigned long vlenvalue)
{
unsigned long currentallocated, realdistance;
FrontResource gl;
Frontspec frontspecspace[2],
*fspec,
*prevfspec;
Frontvalue *fptr;
unsigned long kval;
long r;
#ifdef SKDEBUG
printf("unitedistcheckSEPgeneric(ulen=%lu,vlen=%lu)\n",ulenvalue,vlenvalue);
#endif
gt_assert(ulenvalue < (unsigned long) LONG_MAX);
gt_assert(vlenvalue < (unsigned long) LONG_MAX);
currentallocated = 1UL;
ALLOCASSIGNSPACE(gl.frontspace,NULL,Frontvalue,currentallocated);
gl.useq = useq;
gl.vseq = vseq;
gl.ubound = useq + ulenvalue;
gl.vbound = vseq + vlenvalue;
gl.ulen = (long) ulenvalue;
gl.vlen = (long) vlenvalue;
gl.integermin = -MAX(gl.ulen,gl.vlen);
prevfspec = &frontspecspace[0];
firstfrontforward(&gl,prevfspec);
if (gl.ulen == gl.vlen && ROWVALUE(&gl.frontspace[0]) == gl.vlen)
{
realdistance = 0;
} else
{
for (kval=1UL, r=1-MIN(gl.ulen,gl.vlen); /* Nothing */ ; kval++, r++)
{
if (prevfspec == &frontspecspace[0])
{
fspec = &frontspecspace[1];
} else
{
fspec = &frontspecspace[0];
}
fspec->offset = prevfspec->offset + prevfspec->width;
frontspecparms(&gl,fspec,(long) kval,r);
while ((unsigned long) (fspec->offset + fspec->width)
>= currentallocated)
{
currentallocated += (kval+1);
ALLOCASSIGNSPACE(gl.frontspace,gl.frontspace,
Frontvalue,currentallocated);
}
(void) evalfrontforward(&gl,prevfspec,fspec,r);
fptr = gl.frontspace + fspec->offset - fspec->left;
if (accessfront(&gl,fptr,fspec,gl.vlen - gl.ulen) == gl.ulen)
{
realdistance = kval;
break;
}
if (prevfspec == &frontspecspace[0])
{
prevfspec = &frontspecspace[1];
} else
{
prevfspec = &frontspecspace[0];
}
}
}
#ifdef SKDEBUG
printf("unitedistfrontSEP returns %ld\n",realdistance);
#endif
FREESPACE(gl.frontspace);
return realdistance;
}
