double
get_hapscore(hap_set_t& hap_set) {
std::sort(hap_set.begin(),hap_set.end());
std::vector<hinfo> haps;
typedef hap_set_t::const_iterator hiter;
{
hiter i(hap_set.begin()), i_end(hap_set.end());
for (; i!=i_end; ++i) {
// 1: check if we match any types; add new type if not
bool is_match(false);
const unsigned hs(haps.size());
for (unsigned j(0); j<hs; ++j) {
if (is_hap_match(*i,haps[j])) {
is_match=true;
break;
}
}
if (! is_match) haps.push_back(hinfo(*i));
}
}
const bool is_2hap(haps.size()>1);
// 2: get two most likely haplotypes:
if (is_2hap) {
std::partial_sort(haps.begin(),haps.begin()+2,haps.end());
}
// 3: calculate average read alignment score restricted to two best haplotypes:
//static const double neginf(std::log(0));
double ln2hapratio(0);
{
hiter i(hap_set.begin()), i_end(hap_set.end());
for (; i!=i_end; ++i) {
double als(get_align_score(*i,haps[0]));
if (is_2hap) {
als=std::max(als,get_align_score(*i,haps[1]));
}
//ln2hapratio = log_sum(ln2hapratio,als);
ln2hapratio += als;
}
// target is log(avg(read_prob_ratio)), not avg(log(read_prob_ratio)):
//
//ln2hapratio -= std::log(static_cast<double>(hap_set.size()));
ln2hapratio /= static_cast<double>(hap_set.size());
}
return ln2hapratio;
}
//-------------------------------------------------------------------------------
// General dumping methods -- dumping relevant parts of ontology
//-------------------------------------------------------------------------------
void TBox :: dump ( dumpInterface* dump ) const
{
dump->prologue();
// dump all (relevant) roles
dumpAllRoles(dump);
// dump all (relevant) concepts
for ( c_const_iterator pc = c_begin(); pc != c_end(); ++pc )
if ( isRelevant(*pc) )
dumpConcept( dump, *pc );
for ( i_const_iterator pi = i_begin(); pi != i_end(); ++pi )
if ( isRelevant(*pi) )
dumpConcept( dump, *pi );
// dump GCIs
if ( getTG() != bpTOP )
{
dump->startAx (diImpliesC);
dump->dumpTop();
dump->contAx (diImpliesC);
dumpExpression ( dump, getTG() );
dump->finishAx (diImpliesC);
}
dump->epilogue();
}
std::ostream&
operator<<(std::ostream& os,
const indel_data& id) {
os << "seq: " << id.get_insert_seq() << "\n";
report_indel_evidence_set(id.all_read_ids,"all_read",os);
report_indel_evidence_set(id.contig_ids,"contig",os);
// report_indel_evidence_set(id.tier1_map_read_ids,"tier1_map_read",os);
report_indel_evidence_set(id.tier2_map_read_ids,"tier2_map_read",os);
report_indel_evidence_set(id.submap_read_ids,"submap_read",os);
report_indel_evidence_set(id.noise_read_ids,"noise_read",os);
{
typedef indel_data::score_t::const_iterator siter;
siter i(id.read_path_lnp.begin()), i_end(id.read_path_lnp.end());
for(unsigned n(0); i!=i_end; ++i) {
os << "read_path_lnp no: " << ++n
<< " id: " << i->first
<< " " << i->second
<< "\n";
}
}
report_indel_evidence_set(id.suboverlap_tier1_read_ids,"suboverlap_tier1_read",os);
report_indel_evidence_set(id.suboverlap_tier2_read_ids,"suboverlap_tier2_read",os);
os << "is_external_candidate: " << id.is_external_candidate << "\n";
return os;
}
std::ostream&
operator<<(std::ostream& os,
const read_path_scores& rps) {
os << "ref: " << rps.ref
<< " indel: " << rps.indel
<< " nsite: " << rps.nsite;
#if 0
if(rps.is_alt) {
os << " alt: " << rps.alt;
}
#else
typedef read_path_scores::alt_indel_t::const_iterator aiter;
aiter i(rps.alt_indel.begin()), i_end(rps.alt_indel.end());
for(; i!=i_end; ++i) {
const indel_key& ik(i->first);
os << " alt-" << ik.pos << "-" << INDEL::get_index_label(ik.type) << ik.length << ": " << i->second;
}
#endif
os << " ist1?: " << rps.is_tier1_read;
return os;
}
int
main(int, char*[])
{
// This is a simple example of using the transform_iterators class to
// generate iterators that multiply the value returned by dereferencing
// the iterator. In this case we are multiplying by 2.
// Would be cooler to use lambda library in this example.
int x[] = { 1, 2, 3, 4, 5, 6, 7, 8 };
const int N = sizeof(x)/sizeof(int);
typedef boost::binder1st< std::multiplies<int> > Function;
typedef boost::transform_iterator_generator<Function, int*>::type doubling_iterator;
doubling_iterator i(x, boost::bind1st(std::multiplies<int>(), 2)),
i_end(x + N, boost::bind1st(std::multiplies<int>(), 2));
std::cout << "multiplying the array by 2:" << std::endl;
while (i != i_end)
std::cout << *i++ << " ";
std::cout << std::endl;
std::cout << "adding 4 to each element in the array:" << std::endl;
std::copy(boost::make_transform_iterator(x, boost::bind1st(std::plus<int>(), 4)),
boost::make_transform_iterator(x + N, boost::bind1st(std::plus<int>(), 4)),
std::ostream_iterator<int>(std::cout, " "));
std::cout << std::endl;
return 0;
}
void
dump_indel_set(const indel_set_t& is,
std::ostream& os) {
indel_set_t::const_iterator i(is.begin()), i_end(is.end());
for (; i!=i_end; ++i) os << *i;
}
// debug dumpers:
void
pos_basecall_buffer::
dump(std::ostream& os) const {
pciter i(_pdata.begin()), i_end(_pdata.end());
for(; i!=i_end; ++i) {
os << "pc_buff pos: " << i->first << "\n";
}
}
void
stage_data::
dump(std::ostream& os) const {
typedef stage_pos_t::const_iterator siter;
os << "stage_pos:\n";
siter i(_stage_pos.begin()), i_end(_stage_pos.end());
for (; i!=i_end; ++i) {
os << "pos: " << i->first << " id: " << i->second << "\n";
}
}
static
void
report_indel_evidence_set(const indel_data::evidence_t& e,
const char* label,
std::ostream& os) {
typedef indel_data::evidence_t::const_iterator viter;
viter i(e.begin()),i_end(e.end());
for(unsigned n(0); i!=i_end; ++i) {
os << label << " no: " << ++n << " id: " << *i << "\n";
}
}
void
htype_buffer::
dump(std::ostream& os) const {
os << "Haplotype buffer dump ON\n";
const_iterator i(_hdata.begin()),i_end(_hdata.end());
for (; i!=i_end; ++i) {
os << i->first << " count: " << i->second << "\n";
}
os << "Haplotype buffer dump OFF\n";
}
uint8_t BayGPRSInterface::changeIPR(long baud) {
_baud = baud;
long t_baud[] = { baud, 9600, 38400, 57600 };
for (uint8_t i = 0; i < 4; i++) {
i_begin(t_baud[i]);
skipChars();
printP("AT"); //Will autoconfigure BAUD-Rate - Auto BAUD-Rate did not work with Sleep-Mode!
delay(100);
println();
printP("AT+IPR=");
println(_baud);
if (!wait_forOK(200)) {
i_end();
i_begin(_baud);
return 0;
}
i_end();
}
return 1;
}
void
TBox :: answerQuery ( const std::vector<DLTree*>& Cs )
{
DLHeap.removeQuery();
std::cout << "Transforming concepts...";
// create BPs for all the concepts
concepts.clear();
for ( std::vector<DLTree*>::const_iterator q = Cs.begin(), q_end = Cs.end(); q != q_end; ++q )
concepts.push_back(tree2dag(*q));
std::cout << " done" << std::endl << "Filling all individuals...";
// all individuals to go thru
std::vector<TIndividual*> AllInd;
for ( i_iterator i = i_begin(), i_e = i_end(); i != i_e; i++ )
AllInd.push_back(*i);
std::cout << " done with " << AllInd.size() << " individuals" << std::endl;
size_t size = Cs.size();
std::cout << "Creating iterables...";
IV.clear();
for ( size_t j = 0; j < size; j++ )
IV.add(new Iterable<TIndividual*>(AllInd));
std::cout << " done\n";
std::cout << "Run consistency checks...";
size_t n = 0, nAns = 0;
TsProcTimer timer;
timer.Start();
do
{
if ( n++ % 100 == 0 )
{
float time = timer;
std::cout << n << " tries, " << nAns << " answers, " << time << " total time, " << time/n << " avg time" << std::endl;
}
if ( static_cast<NominalReasoner*>(nomReasoner)->checkExtraCond() )
{
for ( size_t k = 0; k < size; k++ )
std::cout << IV.get(k)->getName() << " ";
std::cout << "\n";
}
} while ( !IV.next() );
timer.Stop();
std::cout << "Total " << n << " tries, " << nAns << " answers, " << timer << " total time, " << timer/n << " avg time" << std::endl;
}
ordinal_type
Stokhos::Sparse3Tensor<ordinal_type, value_type>::
num_entries() const
{
#ifdef STOKHOS_DEBUG
TEUCHOS_TEST_FOR_EXCEPTION(fill_completed == false, std::logic_error,
"You must call fillComplete() before calling num_entries()!");
#endif
ordinal_type num = 0;
for (k_iterator k = k_begin(); k != k_end(); ++k)
for (kj_iterator j = j_begin(k); j != j_end(k); ++j)
for (kji_iterator i = i_begin(j); i != i_end(j); ++i)
++num;
return num;
}
void
Stokhos::Sparse3Tensor<ordinal_type, value_type>::
print(std::ostream& os) const
{
#ifdef STOKHOS_DEBUG
TEUCHOS_TEST_FOR_EXCEPTION(fill_completed == false, std::logic_error,
"You must call fillComplete() before calling print()!");
#endif
for (k_iterator k=k_begin(); k!=k_end(); ++k)
for (kj_iterator j=j_begin(k); j!=j_end(k); ++j)
for (kji_iterator i=i_begin(j); i!=i_end(j); ++i)
os << "k = " << index(k)
<< ", j = " << index(j)
<< ", i = " << index(i)
<< ", Cijk = " << value(i) << std::endl;
}
void e () {
i_local_t a,b,c,d,e,f,g,h,i,j,k,l;
int (*ip)(int (*)(int,int),int,int,int,int,int,int,int,int,int);
i_init(100);
a = i_paramk(I_I,1);
b = i_paramk(I_I,2);
c = i_param(I_I);
d = i_param(I_I);
e = i_param(I_I);
g = i_param(I_I);
h = i_param(I_I);
i = i_param(I_I);
j = i_param(I_I);
k = i_local(0,I_I);
l = i_local(0,I_I);
f = i_paramk(I_P,0);
i_argi(a);
i_argi(b);
i_calli(k, f);
i_argi(c);
i_argi(d);
i_calli(d, f);
i_addi(k,k,d);
i_argi(e);
i_argi(g);
i_calli(g, f);
i_addi(k,k,g);
i_argi(h);
i_argi(i);
i_calli(i, f);
i_addi(k,k,i);
i_addi(k,k,j);
i_addii(l,k,3);
i_reti(l);
i_end();
i_unparse();
ip = (int (*)(int (*)(int,int),int,int,int,int,int,int,int,int,int))
i_emit().i;
v_dump((void*)ip);
printf("**48=%d\n", (*ip)(gg,1,2,3,4,5,6,7,8,9));
}
void
insert_seq_manager::
finalize() {
obs_t::const_iterator i(_obs.begin()), i_end(_obs.end());
unsigned count(0);
std::string& candidate(_consensus_seq);
for(; i!=i_end; ++i) {
if((i->first.size() > candidate.size()) ||
( i->second > count)) {
candidate = i->first;
count = i->second;
}
}
_consensus_seq = candidate;
_obs.clear();
_is_consensus=true;
}
void
BlockerVcfHeaderHandler::
process_final_header_line() {
_os << "##INFO=<ID=END,Number=1,Type=Integer,Description=\"End position of the region described in this record\">\n";
_os << "##INFO=<ID=" << _opt.nvopt.BlockavgLabel
<< ",Number=0,Type=Flag,Description=\"Non-variant site block."
<< " All sites in a block are constrained to be non-variant, have the same filter value,"
<< " and have all sample values in range [x,y] , y <= max(x+3,(x*(1+" << _opt.nvopt.BlockFracTol << ")))."
<< " All printed site block sample values are the minimum observed in the region spanned by the block\">\n";
// new format tags:
_os << "##FORMAT=<ID=MQ,Number=1,Type=Integer,Description=\"RMS Mapping Quality\">\n";
_os << "##FORMAT=<ID=GQX,Number=1,Type=Integer,Description=\"Minimum of {Genotype quality assuming variant position,Genotype quality assuming non-variant position}\">\n";
// overlap tags:
_os << "##FILTER=<ID=" << _opt.indel_conflict_label
<< ",Description=\"Locus is in region with conflicting indel calls.\">\n";
_os << "##FILTER=<ID=" << _opt.site_conflict_label
<< ",Description=\"Site genotype conflicts with proximal indel call. This is typically a heterozygous SNV call made inside of a heterozygous deletion.\">\n";
// special chrom-depth filter tag:
if(_opt.is_chrom_depth()){
_os << "##FILTER=<ID=" << _opt.max_chrom_depth_filter_tag
<< ",Description=\"Site depth is greater than " << _opt.max_chrom_depth_filter_factor.strval()
<< "x the mean chromosome depth\">\n";
BlockerOptions::cdmap_t::const_iterator i(_opt.ChromDepth.begin()), i_end(_opt.ChromDepth.end());
for(;i!=i_end;++i) {
const std::string& chrom(i->first);
const double chrom_thresh(i->second*_opt.max_chrom_depth_filter_factor.numval());
_os << "##" << _opt.max_chrom_depth_filter_tag << "_" << chrom << "=" << chrom_thresh << "\n";
}
}
// print the rest of the standard filter tags:
if(NULL != _opt.GQX_filter.get()) {
print_filter_header(*_opt.GQX_filter,"Locus",_os);
}
print_filter_header_set(_opt.filters,_os);
}
static
void
get_htypes_for_indel(const starling_deriv_options& dopt,
const starling_read_buffer& rbuff,
const reference_contig_segment& ref,
const indel_key& ik,
const indel_data& id,
htype_buffer& hdata) {
static const bool is_tier2_pass(false);
static const bool is_use_alt_indel(true);
static const double include_thresh(0.999);
typedef indel_data::score_t::const_iterator siter;
htype_element he;
siter i(id.read_path_lnp.begin()), i_end(id.read_path_lnp.end());
for (; i!=i_end; ++i) {
const align_id_t read_id(i->first);
const read_path_scores& path_lnp(i->second);
const read_path_scores pprob(indel_lnp_to_pprob(dopt,path_lnp,is_tier2_pass,is_use_alt_indel));
if (pprob.indel >= include_thresh) {
// convert indel to htype_element and insert:
const starling_read* srptr(rbuff.get_read(read_id));
/// TODO - add segmented read support
if (srptr->is_segmented()) {
log_os << "ERROR: haplotype model does not work for spliced reads\n";
exit(EXIT_FAILURE);
}
const read_segment& rseg(srptr->get_full_segment());
if (! convert_indel_to_htype(ik,id,rseg,ref,he)) continue;
hdata.insert_element(he);
}
}
}
void b () {
i_local_t f;
i_label_t L1;
v_pptr pp;
i_init(100);
L1 = i_mklabel();
f = i_local(0, I_P);
i_setp(f, gg);
i_nop();
i_nop();
i_nop();
i_nop();
i_retp(f);
i_end();
i_unparse();
pp = i_emit().p;
v_dump((void*)pp);
printf("**3=%d\n", (*(int (*)(int, int))((*pp)()))(1,2));
}
void d () {
i_local_t a,b;
v_iptr ip;
i_init(100);
a = i_local(0, I_I);
b = i_local(0, I_I);
i_seti(a, 1);
i_seti(b, 2);
i_argi(a);
i_argi(b);
i_callii(a, gg);
i_reti(a);
i_end();
i_unparse();
ip = i_emit().i;
v_dump((void*)ip);
printf("**3=%d\n", (*ip)());
}
void a () {
i_local_t a, b, c,d;
i_init(20);
a = i_local(0, I_I);
b = i_local(0, I_I);
c = i_local(0, I_I);
d = i_local(0, I_I);
i_seti(a, 5);
i_seti(b, 7);
i_seti(c, 8);
i_movi(d, c);
i_addi(c, a, b);
i_addi(d, d, c);
i_reti(d);
i_end();
i_unparse();
i_emitc();
}
value_type
Stokhos::Sparse3Tensor<ordinal_type, value_type>::
getValue(ordinal_type i, ordinal_type j, ordinal_type k) const
{
#ifdef STOKHOS_DEBUG
TEUCHOS_TEST_FOR_EXCEPTION(fill_completed == false, std::logic_error,
"You must call fillComplete() before calling getValue()!");
#endif
k_iterator k_it = find_k(k);
if (k_it == k_end())
return value_type(0);
kj_iterator j_it = find_j(k_it, j);
if (j_it == j_end(k_it))
return value_type(0);
kji_iterator i_it = find_i(j_it, i);
if (i_it == i_end(j_it))
return value_type(0);
return i_it.value();
}
void TBox :: buildDAG ( void )
{
nNominalReferences = 0;
// init concept indexing
nC = 1; // start with 1 to make index 0 an indicator of "not processed"
ConceptMap.push_back(NULL);
// make fresh concept and datatype
concept2dag(pTemp);
DLTree* freshDT = DTCenter.getFreshDataType();
addDataExprToHeap ( static_cast<TDataEntry*>(freshDT->Element().getNE()) );
deleteTree(freshDT);
for ( c_const_iterator pc = c_begin(); pc != c_end(); ++pc )
concept2dag(*pc);
for ( i_const_iterator pi = i_begin(); pi != i_end(); ++pi )
concept2dag(*pi);
// init heads of simple rules
for ( TSimpleRules::iterator q = SimpleRules.begin(), q_end = SimpleRules.end(); q < q_end; ++q )
(*q)->bpHead = tree2dag((*q)->tHead);
// builds Roles range and domain
initRangeDomain(ORM);
initRangeDomain(DRM);
// build all splits
for ( TSplitVars::iterator s = getSplits()->begin(), s_end = getSplits()->end(); s != s_end; ++s )
split2dag(*s);
RoleMaster::iterator p, p_end;
// build all GCIs
DLTree* GCI = Axioms.getGCI();
// add special domains to the GCIs
if ( likely(useSpecialDomains) )
for ( p = ORM.begin(), p_end = ORM.end(); p < p_end; ++p )
if ( !(*p)->isSynonym() && (*p)->hasSpecialDomain() )
GCI = createSNFAnd ( GCI, clone((*p)->getTSpecialDomain()) );
// take chains that lead to Bot role into account
if ( !ORM.getBotRole()->isSimple() )
GCI = createSNFAnd ( GCI,
new DLTree ( TLexeme(FORALL), createRole(ORM.getBotRole()), createBottom() ) );
T_G = tree2dag(GCI);
deleteTree(GCI);
// mark GCI flags
GCIs.setGCI(T_G != bpTOP);
GCIs.setReflexive(ORM.hasReflexiveRoles());
// builds functional labels for roles
for ( p = ORM.begin(), p_end = ORM.end(); p < p_end; ++p )
if ( !(*p)->isSynonym() && (*p)->isTopFunc() )
(*p)->setFunctional ( atmost2dag ( 1, *p, bpTOP ) );
for ( p = DRM.begin(), p_end = DRM.end(); p < p_end; ++p )
if ( !(*p)->isSynonym() && (*p)->isTopFunc() )
(*p)->setFunctional ( atmost2dag ( 1, *p, bpTOP ) );
// check the type of the ontology
if ( nNominalReferences > 0 )
{
unsigned int nInd = i_end() - i_begin();
if ( nInd > 100 && nNominalReferences > nInd )
isLikeWINE = true;
}
// here DAG is complete; set its final size
DLHeap.setFinalSize();
}
void
get_starling_indel_sample_report_info(const starling_deriv_options& dopt,
const indel_key& ik,
const indel_data& id,
const pos_basecall_buffer& bc_buff,
const bool is_tier2_pass,
const bool is_use_alt_indel,
starling_indel_sample_report_info& isri) {
// get read info:
{
static const double path_pprob_thresh(0.999);
unsigned n_subscore_reads(0);
typedef indel_data::score_t::const_iterator siter;
siter i(id.read_path_lnp.begin()), i_end(id.read_path_lnp.end());
for(; i!=i_end; ++i) {
const read_path_scores& path_lnp(i->second);
// optionally skip tier2 data:
if((! is_tier2_pass) && (! path_lnp.is_tier1_read)) continue;
const read_path_scores pprob(indel_lnp_to_pprob(dopt,path_lnp,is_tier2_pass,is_use_alt_indel));
if (pprob.ref >= path_pprob_thresh) {
isri.n_q30_ref_reads++;
} else if(pprob.indel >= path_pprob_thresh) {
isri.n_q30_indel_reads++;
} else {
typedef read_path_scores::alt_indel_t::const_iterator aciter;
bool is_alt_found(false);
#if 0
if(pprob.is_alt && (pprob.alt >= path_pprob_thresh)) {
isri.n_q30_alt_reads++;
is_alt_found=true;
}
#else
aciter j(pprob.alt_indel.begin()), j_end(pprob.alt_indel.end());
for(; j!=j_end; ++j) {
if(j->second >= path_pprob_thresh) {
isri.n_q30_alt_reads++;
is_alt_found=true;
break;
}
}
#endif
if(! is_alt_found) { n_subscore_reads++; }
}
}
// total number of reads with non-zero, yet insufficient indel
// breakpoint overlap
const unsigned n_suboverlap_tier1_reads(id.suboverlap_tier1_read_ids.size());
isri.n_other_reads = (n_subscore_reads+n_suboverlap_tier1_reads);
if(is_tier2_pass) {
const unsigned n_suboverlap_tier2_reads(id.suboverlap_tier2_read_ids.size());
isri.n_other_reads += n_suboverlap_tier2_reads;
}
}
{
// get depth of indel:
pos_t depth_pos(ik.pos-1);
if(ik.type==INDEL::BP_RIGHT) depth_pos=ik.pos;
const snp_pos_info* spi_ptr(bc_buff.get_pos(depth_pos));
if(NULL==spi_ptr) {
isri.depth=0;
} else {
isri.depth=spi_ptr->calls.size();
}
}
}
void
indel_digt_caller::
get_high_low_het_ratio_lhood(const starling_options& /*opt*/,
const starling_deriv_options& dopt,
const starling_sample_options& sample_opt,
const double indel_error_lnp,
const double indel_real_lnp,
const double ref_error_lnp,
const double ref_real_lnp,
const indel_key& ik,
const indel_data& id,
const double het_ratio,
const bool is_tier2_pass,
const bool is_use_alt_indel,
double& het_lhood_high,
double& het_lhood_low) {
// handle het ratio and its complement in one step:
const double chet_ratio(1.-het_ratio);
const double log_het_ratio(std::log(het_ratio));
const double log_chet_ratio(std::log(chet_ratio));
const bool is_breakpoint(ik.is_breakpoint());
het_lhood_high=0;
het_lhood_low=0;
// typedef read_path_scores::alt_indel_t::const_iterator aiter;
typedef indel_data::score_t::const_iterator siter;
siter i(id.read_path_lnp.begin()), i_end(id.read_path_lnp.end());
for (; i!=i_end; ++i) {
const read_path_scores& path_lnp(i->second);
// optionally skip tier2 data:
if ((! is_tier2_pass) && (! path_lnp.is_tier1_read)) continue;
// get alt path lnp:
double alt_path_lnp(path_lnp.ref);
#if 0
if (is_use_alt_indel && path_lnp.is_alt &&
(path_lnp.alt > alt_path_lnp)) {
alt_path_lnp=path_lnp.alt;
}
#else
if (is_use_alt_indel && (! path_lnp.alt_indel.empty()) ) {
typedef read_path_scores::alt_indel_t::const_iterator aiter;
aiter j(path_lnp.alt_indel.begin()), j_end(path_lnp.alt_indel.end());
for (; j!=j_end; ++j) {
if (j->second>alt_path_lnp) alt_path_lnp=j->second;
}
}
#endif
const double noindel_lnp(log_sum(alt_path_lnp+ref_real_lnp,path_lnp.indel+indel_error_lnp));
const double hom_lnp(log_sum(alt_path_lnp+ref_error_lnp,path_lnp.indel+indel_real_lnp));
// allele ratio convention is that the indel occurs at the
// het_allele ratio and the alternate allele occurs at
// (1-het_allele_ratio):
{
double log_ref_prob(log_chet_ratio);
double log_indel_prob(log_het_ratio);
if (! is_breakpoint) {
get_het_observed_allele_ratio(path_lnp.read_length,sample_opt.min_read_bp_flank,
ik,het_ratio,log_ref_prob,log_indel_prob);
}
const double het_lnp(log_sum(noindel_lnp+log_ref_prob,hom_lnp+log_indel_prob));
het_lhood_low += integrate_out_sites(dopt,path_lnp.nsite,het_lnp,is_tier2_pass);
}
{
double log_ref_prob(log_het_ratio);
double log_indel_prob(log_chet_ratio);
if (! is_breakpoint) {
get_het_observed_allele_ratio(path_lnp.read_length,sample_opt.min_read_bp_flank,
ik,chet_ratio,log_ref_prob,log_indel_prob);
}
const double het_lnp(log_sum(noindel_lnp+log_ref_prob,hom_lnp+log_indel_prob));
het_lhood_high += integrate_out_sites(dopt,path_lnp.nsite,het_lnp,is_tier2_pass);
}
}
}
void a () {
i_local_t a,b,c,d,e,f,g,h,i,j,w,z,func,cnt;
i_label_t L1;
v_iptr ip;
i_init(100);
L1 = i_mklabel();
/* func = i_local(0, I_P);*/
cnt = i_local(0, I_P);
a = i_local(0, I_I);
b = i_local(0, I_I);
c = i_local(0, I_I);
d = i_local(0, I_I);
e = i_local(0, I_I);
f = i_local(0, I_I);
g = i_local(0, I_I);
h = i_local(0, I_I);
i = i_local(0, I_I);
j = i_local(0, I_I);
z = i_local(0, I_I);
w = i_local(0, I_I);
/* i_setp(func, ff);*/
i_seti(a, 1);
i_seti(b, 2);
i_seti(c, 3);
i_seti(d, 4);
i_seti(e, 5);
i_seti(f, 6);
i_seti(g, 7);
i_seti(h, 8);
i_seti(i, 9);
i_seti(j, 0);
i_seti(z, 0);
i_seti(cnt, 0);
i_label(L1);
i_argi(a);
i_argi(b);
i_argi(c);
i_argi(d);
i_argi(e);
i_argi(f);
i_argi(g);
i_argi(h);
i_argi(i);
i_argi(j);
i_callii(w, ff);
i_addi(z,z,w);
i_addii(cnt,cnt,1);
i_bltii(cnt,2,L1);
i_addi(z, z, a);
i_addi(z, z, b);
i_addi(z, z, c);
i_addi(z, z, d);
i_addi(z, z, e);
i_addi(z, z, f);
i_addi(z, z, g);
i_addi(z, z, h);
i_addi(z, z, i);
i_addi(z, z, j);
i_reti(z); /* (9*10/2)*3 = 135 */
i_end();
i_unparse();
ip = i_emit().i;
v_dump((void*)ip);
printf("**135=%d\n", (*ip)());
}
void TBox :: gatherRelevanceInfo ( void )
{
nRelevantCCalls = 0;
nRelevantBCalls = 0;
// gather GCIs features
curFeature = &GCIFeatures;
markGCIsRelevant();
clearRelevanceInfo();
KBFeatures |= GCIFeatures;
// fills in nominal cloud relevance info
NCFeatures = GCIFeatures;
// set up relevance info
for ( i_iterator pi = i_begin(); pi != i_end(); ++pi )
{
setConceptRelevant(*pi);
NCFeatures |= (*pi)->posFeatures;
}
// correct NC inverse role information
if ( NCFeatures.hasSomeAll() && !RelatedI.empty() )
NCFeatures.setInverseRoles();
for ( c_iterator pc = c_begin(); pc != c_end(); ++pc )
setConceptRelevant(*pc);
long cSize = ( c_end() - c_begin() ) + ( i_end() - i_begin() );
size_t bSize = DLHeap.size()-2;
curFeature = nullptr;
float cRatio, bRatio = 0, logCSize = 1, logBSize = 1, sqCSize = 1, sqBSize = 1;
if ( cSize > 10 )
{
cRatio = ((float)nRelevantCCalls)/cSize;
sqCSize = sqrtf((float)cSize);
if ( cSize > 1 )
logCSize = logf((float)cSize);
}
if ( bSize > 20 )
{
bRatio = ((float)nRelevantBCalls)/bSize;
sqBSize = sqrtf((float)bSize);
if ( bSize > 1 )
logBSize = logf((float)bSize);
}
if (0) // relevance stat
{
if ( LLM.isWritable(llAlways) && cSize > 10 )
LL << "There were made " << nRelevantCCalls << " relevance C calls for "
<< cSize << " concepts\nRC ratio=" << cRatio << ", ratio/logSize="
<< cRatio/logCSize << ", ratio/sqSize=" << cRatio/sqCSize << ", ratio/size="
<< cRatio/cSize<< "\n";
if ( LLM.isWritable(llAlways) && bSize > 20 )
LL << "There were made " << nRelevantBCalls << " relevance B calls for "
<< bSize << " nodes\nRB ratio=" << bRatio << ", ratio/logSize="
<< bRatio/logBSize << ", ratio/sqSize=" << bRatio/sqBSize << ", ratio/size="
<< bRatio/bSize << "\n";
}
// set up GALEN-like flag; based on r/n^{3/2}, add r/n^2<1
isLikeGALEN = (bRatio > sqBSize*20) && (bRatio < bSize);
// switch off sorted reasoning iff top role appears
if ( KBFeatures.hasTopRole() )
useSortedReasoning = false;
}
