FFInterface::~FFInterface (void)
{
Disconnect ();
ClearTasks ();
pthread_mutex_destroy (&mtx_TaskList);
ITERATE (GoalToPrerequisites_hmp_t, hmp_GoalToPrerequisites, ite)
delete ite->second;
ITERATE (GoalToPlan_hmp_t, hmp_GoalToPlan, ite)
delete ite->second;
}
void self_statement_Or(Or *v2548,OID v1741,OID v332)
{ GC_BIND;
{ char * v1743 = GC_STRING(check_var_string(copy_string("v_or"),v1741,v332));
new_block_void();
interface_I_class(Kernel._boolean);
princ_string(v1743);
princ_string(copy_string(";"));
breakline_void();
{ OID gc_local;
ITERATE(v1744);
bag *v1744_support;
v1744_support = GC_OBJECT(list,v2548->args);
for (START(v1744_support); NEXT(v1744);)
{ new_block_void();
statement_any(v1744,_string_(v1743),v332);
princ_string(copy_string("if ("));
princ_string(v1743);
princ_string(copy_string(" == "));
(*Generate.produce)(Generate.PRODUCER->value,
Kernel.ctrue);
princ_string(copy_string(") "));
if (Kernel._string == OWNER(v1741))
{ c_princ_string(string_v(v1741));
princ_string(copy_string(" ="));
}
expression_boolean(CTRUE,v332);
princ_string(copy_string("; "));
breakline_void();
princ_string(copy_string("else "));
}
}
if (Kernel._string == OWNER(v1741))
{ c_princ_string(string_v(v1741));
princ_string(copy_string(" = "));
expression_boolean(CFALSE,v332);
princ_string(copy_string(";"));
}
else { expression_boolean(CFALSE,v332);
princ_string(copy_string(";"));
}
{ OID gc_local;
ITERATE(v1744);
bag *v1744_support;
v1744_support = GC_OBJECT(list,v2548->args);
for (START(v1744_support); NEXT(v1744);)
close_block_void();
}
close_block_void();
}
GC_UNBIND;}
kadm5_ret_t
k5_kadm5_hook_remove(krb5_context context, kadm5_hook_handle *handles,
int stage, krb5_principal princ)
{
ITERATE(remove, (context, h->data, stage, princ));
return 0;
}
kadm5_ret_t
k5_kadm5_hook_modify(krb5_context context, kadm5_hook_handle *handles,
int stage, kadm5_principal_ent_t princ, long mask)
{
ITERATE(modify, (context, h->data, stage, princ, mask));
return 0;
}
static const CBioseq::TId &s_GetSeqIds(const vector<CSeq_id_Handle> &handles){
static CBioseq::TId ids;
ids.clear();
ITERATE(vector<CSeq_id_Handle>, it, handles)
ids.push_back(CRef<CSeq_id>(const_cast<CSeq_id*>(it->GetSeqId().GetNonNullPointer())));
return ids;
}
void FFInterface::ClearTasks (void)
{
pthread_mutex_lock (&mtx_TaskList);
ITERATE (TaskIdToFFResponse_hmp_t, hmp_TaskIdToFFResponse, ite)
delete ite->second;
hmp_TaskIdToFFResponse.clear ();
pthread_mutex_unlock (&mtx_TaskList);
}
kadm5_ret_t
k5_kadm5_hook_create(krb5_context context, kadm5_hook_handle *handles,
int stage, kadm5_principal_ent_t princ, long mask,
int n_ks_tuple, krb5_key_salt_tuple *ks_tuple,
const char *newpass)
{
ITERATE(create, (context, h->data,
stage, princ, mask, n_ks_tuple, ks_tuple, newpass));
return 0;
}
kadm5_ret_t
k5_kadm5_hook_chpass(krb5_context context, kadm5_hook_handle *handles,
int stage, krb5_principal princ, krb5_boolean keepold,
int n_ks_tuple, krb5_key_salt_tuple *ks_tuple,
const char *newpass)
{
ITERATE(chpass, (context, h->data,
stage, princ, keepold,
n_ks_tuple, ks_tuple, newpass));
return 0;
}
bool FeatureSpace::SaveFeatureMapping (String _sName)
{
File file;
if (false == file.Open((config)(_sName + ":feature_mapping_file"), ios_base::out))
return false;
ITERATE (FeatureValueToIndex_map_t, map_FeatureValueToIndex, ite)
file << ite->second << '\x01' << ite->first << endl;
file.Close ();
return true;
}
void defile(vector<string> &options)
{ bool changed;
do {
changed=false;
vector<string> reoptions=options;
options.clear();
ITERATE(vector<string>, oi, reoptions) {
if ((*oi)[0]=='@') {
string::iterator be((*oi).end());
do --be; while ((*be!=':') && (*be!='@'));
if (*be=='@') {
ifstream pstr(string(be+1, (*oi).end()).c_str());
if (!pstr.is_open() || pstr.fail() || pstr.eof())
raiseError("invalid parameter file");
while (!pstr.fail() && !pstr.eof()) {
string nl=getSLine(pstr);
if (nl.length()) options.push_back(string(nl.begin(), nl.end()));
}
}
else {
string filename((*oi).begin()+1, be), lineNos(be+1, (*oi).end());
int lineNo=atoi(lineNos.c_str());
if (!lineNo)
raiseError("Invalid line number (%s) for parameter file %s.", lineNos.c_str(), filename.c_str());
ifstream pstr(filename.c_str());
if (!pstr.is_open() || pstr.fail() || pstr.eof())
raiseError("Invalid parameter file (%s).", (*oi).c_str());
while(--lineNo) {
getSLine(pstr);
if (pstr.fail() || pstr.eof())
raiseError("can't read parameter file %s to line %s", filename.c_str(), lineNos.c_str());
}
string nl=getSLine(pstr);
if (nl[0]=='=') options.push_back(string(nl.begin()+1, nl.end()));
else {
vector<string> ns;
string2atoms(nl, ns);
ITERATE(vector<string>, ni, ns) options.push_back(*ni);
}
}
changed=true;
}
else options.push_back(*oi);
}
} while (changed);
}
float TEFMDataDescription::getExampleMatch(const TExample &ex1, const TExample &ex2)
{
if ((ex1.domain != domain) && (ex2.domain != domain))
raiseError("example's domain doesn't match the data descriptor's");
float weight=1.0;
TExample::iterator e1i(ex1.begin()), e2i(ex2.end());
if (domainDistributions) {
if (matchProbabilities.size() != domainDistributions->size())
matchProbabilities = vector<float>(domainDistributions->size(), -1);
vector<float>::iterator mi(matchProbabilities.begin());
TDomainDistributions::const_iterator di(domainDistributions->begin()), de(domainDistributions->end());
for(; di!=de; e1i++, e2i++, di++, mi++) {
if ((*e1i).varType == TValue::INTVAR) {
if ((*e1i).isDK()) {
if ((*e2i).isDK()) {
if (*mi == -1) {
float mp = 0.0;
ITERATE(TDiscDistribution, ddi, ((TDiscDistribution &)((*di).getReference())))
mp += *ddi * *ddi;
*mi = mp;
}
weight *= *mi;
}
else if (!(*e2i).isSpecial())
weight *= (*di)->p(*e2i);
}
else if ((*e2i).isDK() && !(*e1i).isSpecial())
weight *= (*di)->p(*e1i);
}
}
}
else {
TVarList::const_iterator vi(domain->attributes->begin()), vie(domain->attributes->end());
for(; vi!=vie; e1i++, e2i++, vi++)
if (((*e1i).varType == TValue::INTVAR) && ((*e1i).isDK() && !(*e2i).isSpecial() || (*e2i).isDK() && !(*e1i).isSpecial()))
weight /= (*vi)->noOfValues();
}
return weight;
}
void inner_statement_any(OID v2548,OID v1741,OID v332)
{ GC_BIND;
if (INHERIT(OWNER(v2548),Language._Do))
{ list * v1732 = GC_OBJECT(list,OBJECT(Do,v2548)->args);
int v1733 = v1732->length;
ClaireBoolean * v1722 = Optimize.OPT->alloc_stack;
int v1734 = 0;
(Optimize.OPT->alloc_stack = CFALSE);
{ ITERATE(v1744);
for (START(v1732); NEXT(v1744);)
{ ++v1734;
if (v1734 == v1733)
{ (Optimize.OPT->alloc_stack = v1722);
inner_statement_any(v1744,v1741,v332);
}
else if (boolean_I_any(v1744) == CTRUE)
inner_statement_any(v1744,_oid_(Kernel.emptySet),v332);
}
}
}
else statement_any(v2548,v1741,v332);
GC_UNBIND;}
void Main::PauseAllMainLoopThreads(bool paused)
{
ITERATE(i, mMainLoopThreads)
i->second.mainLoopThread->SetPaused(paused);
}
PClassifier TTreeSplitConstructor_ExhaustiveBinary::operator()(
PStringList &descriptions, PDiscDistribution &subsetSizes, float &quality, int &spentAttribute,
PExampleGenerator gen, const int &weightID ,
PDomainContingency dcont, PDistribution apriorClass,
const vector<bool> &candidates,
PClassifier
)
{
checkProperty(measure);
measure->checkClassTypeExc(gen->domain->classVar->varType);
PIntList bestMapping;
int wins, bestAttr;
PVariable bvar;
if (measure->needs==TMeasureAttribute::Generator) {
bool cse = candidates.size()==0;
bool haveCandidates = false;
vector<bool> myCandidates;
myCandidates.reserve(gen->domain->attributes->size());
vector<bool>::const_iterator ci(candidates.begin()), ce(candidates.end());
TVarList::const_iterator vi, ve(gen->domain->attributes->end());
for(vi = gen->domain->attributes->begin(); vi != ve; vi++) {
bool co = (*vi)->varType == TValue::INTVAR && (!cse || (ci!=ce) && *ci);
myCandidates.push_back(co);
haveCandidates = haveCandidates || co;
}
if (!haveCandidates)
return returnNothing(descriptions, subsetSizes, quality, spentAttribute);
PDistribution thisSubsets;
float thisQuality;
wins = 0;
int thisAttr = 0;
int N = gen->numberOfExamples();
TSimpleRandomGenerator rgen(N);
ci = myCandidates.begin();
for(vi = gen->domain->attributes->begin(); vi != ve; ci++, vi++, thisAttr++) {
if (*ci) {
thisSubsets = NULL;
PIntList thisMapping =
/*throughCont ? measure->bestBinarization(thisSubsets, thisQuality, *dci, dcont->classes, apriorClass, minSubset)
: */measure->bestBinarization(thisSubsets, thisQuality, *vi, gen, apriorClass, weightID, minSubset);
if (thisMapping
&& ( (!wins || (thisQuality>quality)) && ((wins=1)==1)
|| (thisQuality==quality) && rgen.randbool(++wins))) {
bestAttr = thisAttr;
quality = thisQuality;
subsetSizes = thisSubsets;
bestMapping = thisMapping;
}
}
/*if (thoughCont)
dci++; */
}
if (!wins)
return returnNothing(descriptions, subsetSizes, quality, spentAttribute);
if (quality<worstAcceptable)
return returnNothing(descriptions, subsetSizes, spentAttribute);
if (subsetSizes && subsetSizes->variable)
bvar = subsetSizes->variable;
else {
TEnumVariable *evar = mlnew TEnumVariable("");
evar->addValue("0");
evar->addValue("1");
bvar = evar;
}
}
else {
bool cse = candidates.size()==0;
if (!cse && noCandidates(candidates))
return returnNothing(descriptions, subsetSizes, quality, spentAttribute);
if (!dcont || dcont->classIsOuter) {
dcont = PDomainContingency(mlnew TDomainContingency(gen, weightID));
// raiseWarningWho("TreeSplitConstructor_ExhaustiveBinary", "this class is not optimized for 'candidates' list and can be very slow");
}
int N = gen ? gen->numberOfExamples() : -1;
if (N<0)
N = dcont->classes->cases;
TSimpleRandomGenerator rgen(N);
PDistribution classDistribution = dcont->classes;
vector<bool>::const_iterator ci(candidates.begin()), ce(candidates.end());
TDiscDistribution *dis0, *dis1;
TContDistribution *con0, *con1;
int thisAttr = 0;
bestAttr = -1;
wins = 0;
quality = 0.0;
float leftExamples, rightExamples;
TDomainContingency::iterator dci(dcont->begin()), dce(dcont->end());
for(; (cse || (ci!=ce)) && (dci!=dce); dci++, thisAttr++) {
// We consider the attribute only if it is a candidate, discrete and has at least two values
if ((cse || *(ci++)) && ((*dci)->outerVariable->varType==TValue::INTVAR) && ((*dci)->discrete->size()>=2)) {
const TDistributionVector &distr = *(*dci)->discrete;
if (distr.size()>16)
raiseError("'%s' has more than 16 values, cannot exhaustively binarize", gen->domain->attributes->at(thisAttr)->get_name().c_str());
// If the attribute is binary, we check subsetSizes and assess the quality if they are OK
if (distr.size()==2) {
if ((distr.front()->abs<minSubset) || (distr.back()->abs<minSubset))
continue; // next attribute
else {
float thisMeas = measure->call(thisAttr, dcont, apriorClass);
if ( ((!wins || (thisMeas>quality)) && ((wins=1)==1))
|| ((thisMeas==quality) && rgen.randbool(++wins))) {
bestAttr = thisAttr;
quality = thisMeas;
leftExamples = distr.front()->abs;
rightExamples = distr.back()->abs;
bestMapping = mlnew TIntList(2, 0);
bestMapping->at(1) = 1;
}
continue;
}
}
vector<int> valueIndices;
int ind = 0;
for(TDistributionVector::const_iterator dvi(distr.begin()), dve(distr.end()); (dvi!=dve); dvi++, ind++)
if ((*dvi)->abs>0)
valueIndices.push_back(ind);
if (valueIndices.size()<2)
continue;
PContingency cont = prepareBinaryCheat(classDistribution, *dci, bvar, dis0, dis1, con0, con1);
// A real job: go through all splits
int binWins = 0;
float binQuality = -1.0;
float binLeftExamples = -1.0, binRightExamples = -1.0;
// Selection: each element correspons to a value of the original attribute and is 1, if the value goes right
// The first value always goes left (and has no corresponding bit in selection.
TBoolCount selection(valueIndices.size()-1), bestSelection(0);
// First for discrete classes
if (dis0) {
do {
*dis0 = CAST_TO_DISCDISTRIBUTION(distr[valueIndices[0]]);
*dis1 *= 0;
vector<int>::const_iterator ii(valueIndices.begin());
ii++;
for(TBoolCount::const_iterator bi(selection.begin()), be(selection.end()); bi!=be; bi++, ii++)
*(*bi ? dis1 : dis0) += distr[*ii];
cont->outerDistribution->setint(0, dis0->abs);
cont->outerDistribution->setint(1, dis1->abs);
if ((dis0->abs < minSubset) || (dis1->abs < minSubset))
continue; // cannot split like that, to few examples in one of the branches
float thisMeas = measure->operator()(cont, classDistribution, apriorClass);
if ( ((!binWins) || (thisMeas>binQuality)) && ((binWins=1) ==1)
|| (thisMeas==binQuality) && rgen.randbool(++binWins)) {
bestSelection = selection;
binQuality = thisMeas;
binLeftExamples = dis0->abs;
binRightExamples = dis1->abs;
}
} while (selection.next());
}
// And then exactly the same for continuous classes
else {
do {
*con0 = CAST_TO_CONTDISTRIBUTION(distr[0]);
*con1 = TContDistribution();
vector<int>::const_iterator ii(valueIndices.begin());
for(TBoolCount::const_iterator bi(selection.begin()), be(selection.end()); bi!=be; bi++, ii++)
*(*bi ? con1 : con0) += distr[*ii];
if ((con0->abs<minSubset) || (con1->abs<minSubset))
continue; // cannot split like that, to few examples in one of the branches
float thisMeas = measure->operator()(cont, classDistribution, apriorClass);
if ( ((!binWins) || (thisMeas>binQuality)) && ((binWins=1) ==1)
|| (thisMeas==binQuality) && rgen.randbool(++binWins)) {
bestSelection = selection;
binQuality = thisMeas;
binLeftExamples = con0->abs;
binRightExamples = con1->abs;
}
} while (selection.next());
}
if ( binWins
&& ( (!wins || (binQuality>quality)) && ((wins=1)==1)
|| (binQuality==quality) && rgen.randbool(++wins))) {
bestAttr = thisAttr;
quality = binQuality;
leftExamples = binLeftExamples;
rightExamples = binRightExamples;
bestMapping = mlnew TIntList(distr.size(), -1);
vector<int>::const_iterator ii = valueIndices.begin();
bestMapping->at(*(ii++)) = 0;
ITERATE(TBoolCount, bi, bestSelection)
bestMapping->at(*(ii++)) = *bi ? 1 : 0;
}
}
}
if (!wins)
return returnNothing(descriptions, subsetSizes, quality, spentAttribute);
subsetSizes = mlnew TDiscDistribution();
subsetSizes->addint(0, leftExamples);
subsetSizes->addint(1, rightExamples);
}
PVariable attribute = gen->domain->attributes->at(bestAttr);
if (attribute->noOfValues() == 2) {
spentAttribute = bestAttr;
descriptions = mlnew TStringList(attribute.AS(TEnumVariable)->values.getReference());
TClassifierFromVarFD *cfv = mlnew TClassifierFromVarFD(attribute, gen->domain, bestAttr, subsetSizes);
cfv->transformUnknowns = false;
return cfv;
}
string s0, s1;
int ns0 = 0, ns1 = 0;
TValue ev;
attribute->firstValue(ev);
PITERATE(TIntList, mi, bestMapping) {
string str;
attribute->val2str(ev, str);
if (*mi==1) {
s1 += string(ns1 ? ", " : "") + str;
ns1++;
}
else if (*mi==0) {
s0 += string(ns0 ? ", " : "") + str;
ns0++;
}
attribute->nextValue(ev);
}
int CLocalFinderApp::Run(void)
{
CArgs myargs = GetArgs();
int left = myargs["from"].AsInteger();
int right = myargs["to"].AsInteger();
bool repeats = myargs["rep"];
//
// read our sequence data
//
CFastaReader fastareader(myargs["input"].AsString());
CRef<CSeq_loc> masked_regions;
masked_regions = fastareader.SaveMask();
CRef<CSeq_entry> se = fastareader.ReadOneSeq();
if(masked_regions) {
CBioseq& bioseq = se->SetSeq(); // assumes that reader gets only one sequence per fasta id (no [] in file)
CRef<CSeq_annot> seq_annot(new CSeq_annot);
seq_annot->SetNameDesc("NCBI-FASTA-Lowercase");
bioseq.SetAnnot().push_back(seq_annot);
CSeq_annot::C_Data::TFtable* feature_table = &seq_annot->SetData().SetFtable();
for(CSeq_loc_CI i(*masked_regions); i; ++i) {
CRef<CSeq_feat> repeat(new CSeq_feat);
CRef<CSeq_id> id(new CSeq_id);
id->Assign(i.GetSeq_id());
CRef<CSeq_loc> loc(new CSeq_loc(*id, i.GetRange().GetFrom(), i.GetRange().GetTo()));
repeat->SetLocation(*loc);
repeat->SetData().SetImp().SetKey("repeat_region");
feature_table->push_back(repeat);
}
}
CRef<CObjectManager> objmgr = CObjectManager::GetInstance();
CScope scope(*objmgr);
scope.AddTopLevelSeqEntry(*se);
CRef<CSeq_id> cntg(new CSeq_id);
cntg->Assign(*se->GetSeq().GetFirstId());
CSeq_loc loc;
loc.SetWhole(*cntg);
CSeqVector vec(loc, scope);
vec.SetIupacCoding();
CResidueVec seq;
ITERATE(CSeqVector,i,vec)
seq.push_back(*i);
// read the alignment information
TGeneModelList alignments;
if(myargs["align"]) {
CNcbiIstream& alignmentfile = myargs["align"].AsInputFile();
string our_contig = cntg->GetSeqIdString(true);
string cur_contig;
CAlignModel algn;
while(alignmentfile >> algn >> getcontig(cur_contig)) {
if (cur_contig==our_contig)
alignments.push_back(algn);
}
}
// create engine
CRef<CHMMParameters> hmm_params(new CHMMParameters(myargs["model"].AsInputFile()));
CGnomonEngine gnomon(hmm_params, seq, TSignedSeqRange(left, right));
// run!
gnomon.Run(alignments, repeats, true, true, false, false, 10.0);
// dump the annotation
CRef<CSeq_annot> annot = gnomon.GetAnnot(*cntg);
auto_ptr<CObjectOStream> os(CObjectOStream::Open(eSerial_AsnText, cout));
*os << *annot;
return 0;
}
bool TTabDelimExampleGenerator::readExample(TFileExampleIteratorData &fei, TExample &exam)
{
vector<string> atoms;
// read lines until eof or a non-empty line
while(!feof(fei.file) && ((readTabAtom(fei, atoms, true, csv)>0) || atomsEmpty(atoms))) {
vector<string>::iterator ii(atoms.begin()), ie(atoms.end());
while ((ii!=ie) && !(*ii).length())
ii++;
if (ii==ie)
atoms.clear();
else
break;
}
if (!atoms.size())
return false;
// Add an appropriate number of empty atoms, if needed
while (atoms.size()<attributeTypes->size())
atoms.push_back(string(""));
_ASSERT(exam.domain==domain);
exam.removeMetas();
TExample::iterator ei(exam.begin());
TVarList::iterator vi(domain->attributes->begin());
vector<string>::iterator ai(atoms.begin());
TIntList::iterator si(attributeTypes->begin()), se(attributeTypes->end());
TIntList::iterator cb, cp, ce;
if (classPoses) {
cb = cp = classPoses->begin();
ce = classPoses->end();
}
int pos=0;
for (; (si!=se); pos++, si++, ai++) {
if (*si) { // if attribute is not to be skipped and is not a basket
string valstr;
// Check for don't care
valstr = *ai;
if (!valstr.length() || (valstr == "NA") || (valstr == ".") || (DC && (valstr == DC)))
valstr = "?";
else if ((valstr == "*") || (DK && (valstr == DK)))
valstr = "~";
try {
if (*si==-1)
if (pos==classPos) { // if this is class value
TValue cval;
domain->classVar->filestr2val(valstr, cval, exam);
exam.setClass(cval);
}
else if (classPoses && (cp != ce) && (pos == *cp)) {
const int ind = cp - cb;
domain->classVars->at(ind)->filestr2val(valstr, exam.values_end[ind], exam);
cp++;
}
else { // if this is a normal value
(*vi++)->filestr2val(valstr, *ei++, exam);
}
else { // if this is a meta value
TMetaDescriptor *md = domain->metas[*si];
_ASSERT(md!=NULL);
TValue mval;
md->variable->filestr2val(valstr, mval, exam);
exam.setMeta(*si, mval);
}
}
catch (mlexception &err) {
raiseError("file '%s', line '%i': %s", fei.filename.c_str(), fei.line, err.what());
}
}
// the attribute is marked to be skipped, but may also be a basket
else {
if (pos == basketPos) {
TSplits splits;
split(*ai, splits);
ITERATE(TSplits, si, splits)
basketFeeder->addItem(exam, string(si->first, si->second), fei.line);
}
}
}
if (pos==classPos) // if class is the last value in the line, it is set here
domain->classVar->filestr2val(ai==atoms.end() ? "?" : *(ai++), exam[domain->variables->size()-1], exam);
/* I'm not sure that this is needed; this code is a mess but I don't wish to
waste time studying it since we are moving to 3.0 */
else if (classPoses && (cp != ce) && (pos == *cp)) {
const int ind = cp - cb;
domain->classVars->at(ind)->filestr2val(ai==atoms.end() ? "?" : *(ai++), exam.values_end[ind], exam);
}
while ((ai!=atoms.end()) && !(*ai).length()) ai++; // line must be empty from now on
if (ai!=atoms.end()) {
vector<string>::iterator ii=atoms.begin();
string s=*ii;
while(++ii!=atoms.end()) s+=" "+*ii;
raiseError("example of invalid length (%s)", s.c_str());
}
return true;
}
PProbabilityEstimator TProbabilityEstimatorConstructor_kernel::operator()(PDistribution frequencies, PDistribution apriori, PExampleGenerator, const long &weightID, const int &) const
{ TContDistribution *cdist = frequencies.AS(TContDistribution);
if (!cdist)
raiseError("continuous distribution expected");
if (!cdist->size())
raiseError("empty distribution");
if ((minImpact<0.0) || (minImpact>1.0))
raiseError("'minImpact' should be between 0.0 and 1.0 (not %5.3f)", minImpact);
vector<float> points;
distributePoints(cdist->distribution, nPoints, points);
TContDistribution *curve = mlnew TContDistribution(frequencies->variable);
PDistribution wcurve = curve;
/* Bandwidth suggested by Chad Shaw. Also found in http://www.stat.lsa.umich.edu/~kshedden/Courses/Stat606/Notes/interpolate.pdf */
const float h = smoothing * sqrt(cdist->error()) * exp(- 1.0/5.0 * log(cdist->abs)); // 1.144
const float hsqrt2pi = h * 2.5066282746310002;
float t;
if (minImpact>0) {
t = -2 * log(minImpact*hsqrt2pi); // 2.5066... == sqrt(2*pi)
if (t<=0) {
// minImpact too high, but that's user's problem...
ITERATE(vector<float>, pi, points)
curve->setfloat(*pi, 0.0);
return wcurve;
}
else
t = h * sqrt(t);
}
ITERATE(vector<float>, pi, points) {
const float &x = *pi;
TContDistribution::const_iterator from, to;
if (minImpact>0) {
from = cdist->lower_bound(x-t);
to = cdist->lower_bound(x+t);
if ((from==cdist->end()) || (to==cdist->begin()) || (from==to)) {
curve->setfloat(x, 0.0);
continue;
}
}
else {
from = cdist->begin();
to = cdist->end();
}
float p = 0.0, n = 0.0;
for(; from != to; from++) {
n += (*from).second;
p += (*from).second * exp( - 0.5 * sqr( (x - (*from).first)/h ) );
}
curve->setfloat(x, p/hsqrt2pi/(n*h)); // hsqrt2pi is from the inside (errf), n*h is for the sum average
}
return mlnew TProbabilityEstimator_FromDistribution(curve);
}
CNcbiOstream& CNamespace::PrintFullName(CNcbiOstream& out) const
{
ITERATE ( TNamespaces, i, GetNamespaces() )
out << *i << "::";
return out;
}
