void add_new_mutation( const std::size_t idx,
const mcont_t & mutations,
gamete_type & new_gamete )
{
assert(idx<mutations.size());
if(mutations[idx].neutral)
{
assert(std::find(new_gamete.mutations.begin(),
new_gamete.mutations.end(),idx)==new_gamete.mutations.end());
new_gamete.mutations.emplace(std::upper_bound(new_gamete.mutations.begin(),
new_gamete.mutations.end(),mutations[idx].pos,
[&mutations](const double & __value,const std::size_t __mut) noexcept {
assert(__mut<mutations.size());
return __value < mutations[__mut].pos;}),
idx );
assert(gamete_is_sorted_n(new_gamete,mutations));
}
else
{
assert(std::find(new_gamete.smutations.begin(),
new_gamete.smutations.end(),idx)==new_gamete.smutations.end());
new_gamete.smutations.emplace(std::upper_bound(new_gamete.smutations.begin(),
new_gamete.smutations.end(),mutations[idx].pos,
[&mutations](const double & __value,const std::size_t __mut) noexcept {
assert(__mut<mutations.size());
return __value < mutations[__mut].pos;}),
idx );
assert(gamete_is_sorted_s(new_gamete,mutations));
}
}
void add_N_mutations_recycle( queue_type & recycling_bin,
const mutation_model & mmodel,
const unsigned & n,
mlist_type & mutations,
gamete_type & g)
{
assert(gamete_is_sorted_n(g,mutations));
assert(gamete_is_sorted_s(g,mutations));
for( unsigned i = 0 ; i < n ; ++i )
{
add_new_mutation(mmodel_dispatcher(mmodel,g,mutations,recycling_bin),mutations,g);
}
}
void recombine_gametes( const double_vec_type & pos,
const std::size_t ibeg,
const std::size_t jbeg,
gcont_t & gametes,
const mcont_t & mutations,
typename gcont_t::value_type::mutation_container & neutral,
typename gcont_t::value_type::mutation_container & selected)
{
assert( std::is_sorted(pos.cbegin(),pos.cend()) );
auto itr = gametes[ibeg].mutations.cbegin();
auto jtr = gametes[jbeg].mutations.cbegin();
auto itr_s = gametes[ibeg].smutations.cbegin();
auto jtr_s = gametes[jbeg].smutations.cbegin();
auto itr_e = gametes[ibeg].mutations.cend();
auto itr_s_e = gametes[ibeg].smutations.cend();
auto jtr_e = gametes[jbeg].mutations.cend();
auto jtr_s_e = gametes[jbeg].smutations.cend();
auto pend = (pos.size()%2==0) ? pos.cend() : pos.cend()-1;
auto i = pos.cbegin();
const double * p = pos.data();
for( ; i < pend ; i+=2,p+=2 )
{
itr = fwdpp_internal::rec_gam_updater(itr,itr_e,mutations,
neutral,*p);
itr_s = fwdpp_internal::rec_gam_updater(itr_s,itr_s_e,mutations,
selected,*p);
jtr = fwdpp_internal::rec_update_itr(jtr,jtr_e,mutations,*p);
jtr_s = fwdpp_internal::rec_update_itr(jtr_s,jtr_s_e,mutations,*p);
jtr = fwdpp_internal::rec_gam_updater(jtr,jtr_e,mutations,
neutral,*(p+1));
jtr_s = fwdpp_internal::rec_gam_updater(jtr_s,jtr_s_e,mutations,
selected,*(p+1));
itr = fwdpp_internal::rec_update_itr(itr,itr_e,mutations,*(p+1));
itr_s = fwdpp_internal::rec_update_itr(itr_s,itr_s_e,mutations,*(p+1));
}
assert(std::distance(i,pos.cend())<=1);
for( ; i<pos.cend();++i)
{
itr = fwdpp_internal::rec_gam_updater(itr,itr_e,mutations,
neutral,*p);
itr_s = fwdpp_internal::rec_gam_updater(itr_s,itr_s_e,mutations,
selected,*p);
}
assert(gamete_is_sorted_n(gametes[ibeg],mutations));
assert(gamete_is_sorted_s(gametes[ibeg],mutations));
}
