TTDeletMutations_bitstring Class Reference

Bitstring implementation of TTDeletMutations with recombination. More...

#include <ttdeletmutations_bitstring.h>

Inheritance diagram for TTDeletMutations_bitstring:

Collaboration diagram for TTDeletMutations_bitstring:

Public Member Functions
	TTDeletMutations_bitstring ()
	TTDeletMutations_bitstring (const TTDeletMutations_bitstring &T)
virtual	~TTDeletMutations_bitstring ()
double	viability_multi ()
double	viability_epist ()
double	viability_multi_continuous ()
double	viability_epist_continuous ()
void	mutate_redraw ()
void	mutate_noredraw ()
void	mutate_noredraw_noBackMutation ()
void	set_sequence (bitstring **seq)
Getters:
unsigned int	get_nb_mutations () const
unsigned int	get_nb_mut_atLocus (unsigned int loc) const
unsigned int	get_nb_htz_mutations () const
unsigned int	get_nb_hmz_mutations () const
bool	get_hmz_atLocus (unsigned int loc) const
bool	get_htz_atLocus (unsigned int loc) const
Setters:
void	set_proto (TProtoDeletMutations_bitstring *proto)
void	set_nb_locus (int val)
void	set_mut_rate (double val, int nloc)
void	set_is_continuous (bool val)
void	set_viability_func_ptr (unsigned int f_model, bool is_cont)
void	set_inherit_func_ptr (void(TProtoDeletMutations_bitstring::*theFunc)(sex_t, bitstring *, bitstring **))
void	set_mutation_func_ptr (unsigned int m_model)
Implementations
virtual void	init ()
virtual void	init_sequence ()
virtual void	reset ()
virtual void *	set_trait (void *value)
virtual void **	get_sequence () const
virtual unsigned int	get_allele (int loc, int all) const
virtual double	get_allele_value (int loc, int all) const
virtual void	set_allele_value (unsigned int locus, unsigned int allele, double value)
virtual void	set_sequence (void **seq)
virtual trait_t	get_type () const
virtual void	inherit (const TTrait *mother, const TTrait *father)
virtual void	mutate ()
virtual void	set_value ()
virtual void *	getValue () const
virtual void	show_up ()
virtual TTDeletMutations_bitstring *	clone ()
virtual TTDeletMutations_bitstring &	operator= (const TTrait &T)
virtual bool	operator== (const TTrait &T)
virtual bool	operator!= (const TTrait &T)
virtual void	store_data (BinaryStorageBuffer *saver)
virtual bool	retrieve_data (BinaryStorageBuffer *reader)
Public Member Functions inherited from TTrait
virtual	~TTrait ()
Public Member Functions inherited from StorableComponent
virtual	~StorableComponent ()

Static Public Member Functions
static void	set_effects (float **fx)
static void	set_recomb_template (unsigned int size)

Private Member Functions
void	set_nb_mutations ()
void	set_nb_htz_mutations ()
void	set_nb_hmz_mutations ()
void	set_counts_and_bitstrings ()

Private Attributes
TProtoDeletMutations_bitstring *	_myProto
bool	_is_continuous
unsigned int	_nb_mutations
unsigned int	_nb_hmz_mutations
unsigned int	_nb_htz_mutations
bitstring *	sequence [2]
bitstring *	_htz
bitstring *	_hmz
double	_phenotype
trait_t	_type
Parameters
unsigned int	_nb_locus
double	_genomic_mut_rate
double(TTDeletMutations_bitstring::*	_viability_func_ptr )(void)
void(TProtoDeletMutations_bitstring::*	_inherit_func_ptr )(sex_t, bitstring *, bitstring **)
void(TTDeletMutations_bitstring::*	_mutation_func_ptr )(void)

Detailed Description

Bitstring implementation of TTDeletMutations with recombination.

Constructor & Destructor Documentation

TTDeletMutations_bitstring() [1/2]

TTDeletMutations_bitstring::TTDeletMutations_bitstring ( )

inline

  : _myProto(0), _nb_locus(0), _genomic_mut_rate(0),
     _viability_func_ptr(0), _inherit_func_ptr(0),_mutation_func_ptr(0), _is_continuous(false),
     _nb_mutations(0), _nb_hmz_mutations(0),_nb_htz_mutations(0), _htz(0), _hmz(0),
     _phenotype(0), _type(DELE)
  {sequence[0] = sequence[1] = NULL;}

References sequence.

Referenced by clone().

TTDeletMutations_bitstring() [2/2]

TTDeletMutations_bitstring::TTDeletMutations_bitstring ( const TTDeletMutations_bitstring &  T )

inline

  : _myProto(T._myProto), _nb_locus(T._nb_locus),
  _genomic_mut_rate(T._genomic_mut_rate),
  _viability_func_ptr(T._viability_func_ptr),_inherit_func_ptr(T._inherit_func_ptr),
  _mutation_func_ptr(T._mutation_func_ptr), _is_continuous(T._is_continuous),
  _nb_mutations(0), _nb_hmz_mutations(0),
  _nb_htz_mutations(0), _htz(0), _hmz(0), _phenotype(0), _type(DELE)
  {sequence[0] = sequence[1] = NULL;}

References sequence.

~TTDeletMutations_bitstring()

virtual TTDeletMutations_bitstring::~TTDeletMutations_bitstring ( )

inlinevirtual

{reset();}

References reset().

Member Function Documentation

clone()

virtual TTDeletMutations_bitstring* TTDeletMutations_bitstring::clone ( )

inlinevirtual

Implements TTrait.

{return new TTDeletMutations_bitstring(*this);}

References TTDeletMutations_bitstring().

get_allele()

unsigned int TTDeletMutations_bitstring::get_allele ( int  loc, int  all  ) const

virtual

Implements TTrait.

{
  return (*sequence[all])[loc];
}

References sequence.

get_allele_value()

double TTDeletMutations_bitstring::get_allele_value ( int  loc, int  all  ) const

virtual

Implements TTrait.

{
  if((*sequence[all])[loc]) {
    if(get_hmz_atLocus(loc)) return _myProto->get_effect(1, loc);
    else return _myProto->get_effect(0, loc);
  } else {
    if(get_hmz_atLocus(loc)) return 0;
    else return _myProto->get_effect(0, loc);
  }
}

References _myProto, TProtoDeletMutations_bitstring::get_effect(), get_hmz_atLocus(), and sequence.

get_hmz_atLocus()

bool TTDeletMutations_bitstring::get_hmz_atLocus ( unsigned int  loc ) const

inline

{return (*sequence[0])[loc] & (*sequence[1])[loc];}

References sequence.

Referenced by get_allele_value().

get_htz_atLocus()

bool TTDeletMutations_bitstring::get_htz_atLocus ( unsigned int  loc ) const

inline

{return (*sequence[0])[loc] ^ (*sequence[1])[loc];}

References sequence.

get_nb_hmz_mutations()

unsigned int TTDeletMutations_bitstring::get_nb_hmz_mutations ( ) const

inline

{return _nb_hmz_mutations;}

References _nb_hmz_mutations.

Referenced by TTDeletMutBitstrSH::setDeletStats(), and show_up().

get_nb_htz_mutations()

unsigned int TTDeletMutations_bitstring::get_nb_htz_mutations ( ) const

inline

{return _nb_htz_mutations;}

References _nb_htz_mutations.

Referenced by TTDeletMutBitstrSH::setDeletStats(), and show_up().

get_nb_mut_atLocus()

unsigned int TTDeletMutations_bitstring::get_nb_mut_atLocus ( unsigned int  loc ) const

inline

{return (*sequence[0])[loc] + (*sequence[1])[loc];}

References sequence.

get_nb_mutations()

unsigned int TTDeletMutations_bitstring::get_nb_mutations ( ) const

inline

{return _nb_mutations;}

References _nb_mutations.

Referenced by show_up().

get_sequence()

virtual void** TTDeletMutations_bitstring::get_sequence ( ) const

inlinevirtual

Implements TTrait.

{return (void**)&sequence[0];}

References sequence.

Referenced by TTDeletMutBitstrSH::setDeletStats().

get_type()

virtual trait_t TTDeletMutations_bitstring::get_type ( ) const

inlinevirtual

Implements TTrait.

{return _type;}

References _type.

getValue()

virtual void* TTDeletMutations_bitstring::getValue ( ) const

inlinevirtual

Implements TTrait.

{return (void*)&_phenotype;}

References _phenotype.

Referenced by show_up().

inherit()

void TTDeletMutations_bitstring::inherit ( const TTrait *  mother, const TTrait *  father  )

virtual

Implements TTrait.

{
  bitstring** mother_seq = (bitstring**)mother->get_sequence();
  bitstring** father_seq = (bitstring**)father->get_sequence();
  
  (_myProto->* _inherit_func_ptr) (FEM, sequence[FEM], mother_seq);
  
  (_myProto->* _inherit_func_ptr) (MAL, sequence[MAL], father_seq);
}

References _inherit_func_ptr, _myProto, FEM, TTrait::get_sequence(), MAL, and sequence.

init()

void TTDeletMutations_bitstring::init ( )

virtual

Implements TTrait.

{  
  if(sequence[0] != NULL)
    fatal("TTDeletMutations_bitstring::init::sequence[0] is not NULL !\n");
  
  if(sequence[1] != NULL)
    fatal("TTDeletMutations_bitstring::init::sequence[1] is not NULL !\n");
  
  sequence[0] = new bitstring(_nb_locus);
  sequence[1] = new bitstring(_nb_locus);
  
  _htz = new bitstring(_nb_locus);
  _hmz = new bitstring(_nb_locus);
}

References _hmz, _htz, _nb_locus, fatal(), and sequence.

Referenced by operator=(), and set_sequence().

init_sequence()

void TTDeletMutations_bitstring::init_sequence ( )

virtual

Implements TTrait.

{
  if(sequence[0] == NULL) sequence[0] = new bitstring(_nb_locus);
  
  if(sequence[1] == NULL) sequence[1] = new bitstring(_nb_locus);
  
  unsigned int nb_mut, locus;
  
  sequence[0]->reset();
  sequence[1]->reset();
  
  if(_myProto->get_init_freq() != 0) {
    
    nb_mut = (unsigned int)(_myProto->get_init_freq()*_nb_locus*2);
    
    for(unsigned int i = 0; i < nb_mut; i++) {
      
      do {
        locus = RAND::Uniform( _nb_locus );
        //check if the locus is not already homozygote:
      } while( (*sequence[0])[ locus ] && (*sequence[1])[ locus ] );
      
      if((*sequence[0])[ locus ])
        sequence[1]->set(locus);
      else
        sequence[0]->set(locus);
    }
    
  }
}

References _myProto, _nb_locus, TProtoDeletMutations_bitstring::get_init_freq(), bitstring::reset(), sequence, bitstring::set(), and RAND::Uniform().

mutate()

virtual void TTDeletMutations_bitstring::mutate ( )

inlinevirtual

Implements TTrait.

{(this->*_mutation_func_ptr)();}

References _mutation_func_ptr.

mutate_noredraw()

void TTDeletMutations_bitstring::mutate_noredraw

(

)

{
  unsigned int NbMut, mut_locus, mut_chrom;
  
  NbMut = (unsigned int)RAND::Poisson(_genomic_mut_rate);
 
  while(NbMut != 0) {  
 
    mut_locus = RAND::Uniform( _nb_locus ); // choose the locus that is going to mutate
    mut_chrom = RAND::RandBool();     // which chromosome of the two will we mutate
 
    // has it already mutated in the past?
    if( (*sequence[mut_chrom])[mut_locus] ) {
 
      // true if there is already a mutation there because that would =1
      // maybe backmutate (this has a reduced prob)
      // draw a new rand num and if of some value, proceed with backmutation
 
      if(RAND::Uniform() < _myProto->get_backmutation_rate() )
      { // by default, 1% of the time do a backmutation once we get here
 
        //backmutate:
        sequence[mut_chrom]->flip(mut_locus); // change to the other number at that locus (0 to 1 or vice versa)
 
      }
 
    } else {
      // or forward mutate
      sequence[mut_chrom]->set(mut_locus);
    }
 
    NbMut--;
  }
}

References _genomic_mut_rate, _myProto, _nb_locus, bitstring::flip(), TProtoDeletMutations_bitstring::get_backmutation_rate(), RAND::Poisson(), RAND::RandBool(), sequence, bitstring::set(), and RAND::Uniform().

Referenced by set_mutation_func_ptr().

mutate_noredraw_noBackMutation()

void TTDeletMutations_bitstring::mutate_noredraw_noBackMutation

(

)

{
  unsigned int NbMut = (unsigned int)RAND::Poisson(_genomic_mut_rate);
 
  while(NbMut != 0) {
 
    sequence[RAND::RandBool()]->set( RAND::Uniform( _nb_locus ) );
 
    NbMut--;
  }
 
}

References _genomic_mut_rate, _nb_locus, RAND::Poisson(), RAND::RandBool(), sequence, bitstring::set(), and RAND::Uniform().

Referenced by set_mutation_func_ptr().

mutate_redraw()

void TTDeletMutations_bitstring::mutate_redraw

(

)

{
  unsigned int NbMut, mutLocus;
  
  NbMut = (unsigned int)RAND::Poisson(_genomic_mut_rate);
  
  if( (int)_nb_hmz_mutations - (int)NbMut < 0 ) NbMut -= _nb_hmz_mutations;
  
  while(NbMut != 0) {  
    
    do { 
      mutLocus = RAND::Uniform( _nb_locus );
      //check if the locus is not already homozygote:
    } while( (*sequence[0])[mutLocus] && (*sequence[1])[mutLocus] );
    
    if ( !( (*sequence[0])[mutLocus] || (*sequence[1])[mutLocus] ) )
      sequence[RAND::RandBool()]->set(mutLocus);
    else if((*sequence[0])[mutLocus])
      sequence[1]->set(mutLocus);
    else
      sequence[0]->set(mutLocus);
    
    NbMut--;
  }
}

References _genomic_mut_rate, _nb_hmz_mutations, _nb_locus, RAND::Poisson(), RAND::RandBool(), sequence, bitstring::set(), and RAND::Uniform().

Referenced by set_mutation_func_ptr().

operator!=()

bool TTDeletMutations_bitstring::operator!= ( const TTrait &  T )

virtual

Implements TTrait.

{
  if(!((*this) == T))
    return true;
  else
    return false;
}

operator=()

TTDeletMutations_bitstring & TTDeletMutations_bitstring::operator= ( const TTrait &  T )

virtual

Implements TTrait.

{
  const TTDeletMutations_bitstring& TD = dynamic_cast<const TTDeletMutations_bitstring&> (T);
 
  if(this != &TD) {
    
    _nb_locus = TD._nb_locus;
 
    //deallocate any previous sequence memory:
    reset();
 
    //allocate sequence memory:
    init();
 
    //copy sequence:
    sequence[0]->copy(*TD.sequence[0]);
    sequence[1]->copy(*TD.sequence[1]);
    
    set_value();
  }
  return *this;
}

References _nb_locus, bitstring::copy(), init(), reset(), sequence, and set_value().

operator==()

bool TTDeletMutations_bitstring::operator== ( const TTrait &  T )

virtual

Implements TTrait.

{
  if( _type != T.get_type() ) return false;
  
  const TTDeletMutations_bitstring& TD = dynamic_cast<const TTDeletMutations_bitstring&> (T);
  if(this != &TD) {
    if(_nb_locus != TD._nb_locus) return false;
  }
  return true;
}

References _nb_locus, _type, and TTrait::get_type().

reset()

void TTDeletMutations_bitstring::reset ( )

virtual

Implements TTrait.

{
  if(sequence[0] != NULL) delete sequence[0];
  if(sequence[1] != NULL) delete sequence[1];
  
  sequence[0] = NULL;
  sequence[1] = NULL; 
  
  if(_htz != NULL) delete _htz;
  _htz = 0;
  
  if(_hmz != NULL) delete _hmz;
  _hmz = 0;
}

References _hmz, _htz, and sequence.

Referenced by operator=(), set_sequence(), and ~TTDeletMutations_bitstring().

retrieve_data()

bool TTDeletMutations_bitstring::retrieve_data ( BinaryStorageBuffer *  reader )

virtual

Implements StorableComponent.

{
  size_t wnb = sequence[0]->nb_words();
  size_t bytes = wnb * sizeof(bitstring::_ul);
  bitstring::_ul *srce = new bitstring::_ul [wnb];
  
  reader->read(srce, bytes); 
  sequence[0]->set_data(srce,wnb);
  
  reader->read(srce, bytes);
  sequence[1]->set_data(srce,wnb);
  
  delete [] srce;
 
  return true;
}

References bitstring::nb_words(), BinaryStorageBuffer::read(), sequence, and bitstring::set_data().

set_allele_value()

void TTDeletMutations_bitstring::set_allele_value ( unsigned int  locus, unsigned int  allele, double  value  )

virtual

Implements TTrait.

{
  assert(locus < _nb_locus && allele < 2); 
  
  sequence[allele]->set(locus); 
 
  _myProto->set_effect(1, locus, (float)value);
  
  double dom;
  
  if(_myProto->get_dominance_model() == 1)
    dom = exp(-1.0*_myProto->get_effect(1, locus)*(-1.0*log(2*_myProto->get_dominance()) / _myProto->get_strength()))/2.0; //scaling of h on s
  else dom = _myProto->get_dominance();
  
   //heterozygote effect: hs
  _myProto->set_effect(0, locus, (float)(dom * _myProto->get_effect(1, locus)) );
  
}

References _myProto, _nb_locus, TProtoDeletMutations_bitstring::get_dominance(), TProtoDeletMutations_bitstring::get_dominance_model(), TProtoDeletMutations_bitstring::get_effect(), TProtoDeletMutations_bitstring::get_strength(), sequence, bitstring::set(), and TProtoDeletMutations_bitstring::set_effect().

set_counts_and_bitstrings()

void TTDeletMutations_bitstring::set_counts_and_bitstrings ( )

private

{
  unsigned int hmz_cnt = 0, htz_cnt = 0;
  size_t nw = sequence[0]->nb_words();
  for (size_t w = 0; w < nw; ++w) {
    auto w0 = *sequence[0]->getword_atIdx(w);
    auto w1 = *sequence[1]->getword_atIdx(w);
    auto hmz_word = w0 & w1;
    auto htz_word = w0 ^ w1;
    *_hmz->getword_atIdx(w) = hmz_word;
    *_htz->getword_atIdx(w) = htz_word;
    hmz_cnt += __builtin_popcountl(hmz_word);
    htz_cnt += __builtin_popcountl(htz_word);
  }
  _nb_hmz_mutations = hmz_cnt;
  _nb_htz_mutations = htz_cnt;
  _nb_mutations = 2 * hmz_cnt + htz_cnt;
}

References _hmz, _htz, _nb_hmz_mutations, _nb_htz_mutations, _nb_mutations, bitstring::getword_atIdx(), bitstring::nb_words(), and sequence.

Referenced by set_value().

set_effects()

static void TTDeletMutations_bitstring::set_effects ( float **  fx )

static

set_inherit_func_ptr()

void TTDeletMutations_bitstring::set_inherit_func_ptr ( void(TProtoDeletMutations_bitstring::*)(sex_t, bitstring *, bitstring **)  theFunc )

inline

                                                                        {_inherit_func_ptr = theFunc;}

References _inherit_func_ptr.

Referenced by TProtoDeletMutations_bitstring::hatch().

set_is_continuous()

void TTDeletMutations_bitstring::set_is_continuous ( bool  val )

inline

{_is_continuous = val;}

References _is_continuous.

Referenced by TProtoDeletMutations_bitstring::hatch().

set_mut_rate()

void TTDeletMutations_bitstring::set_mut_rate ( double  val, int  nloc  )

inline

{_genomic_mut_rate = 2*nloc*val;}

References _genomic_mut_rate.

Referenced by TProtoDeletMutations_bitstring::hatch().

set_mutation_func_ptr()

void TTDeletMutations_bitstring::set_mutation_func_ptr

(

unsigned int

m_model

)

{  
  switch(m_model) {
    case 1:
    {
      if(_myProto->get_backmutation_rate() != 0)
        _mutation_func_ptr = &TTDeletMutations_bitstring::mutate_noredraw;
      else
        _mutation_func_ptr = &TTDeletMutations_bitstring::mutate_noredraw_noBackMutation;
      break;
    }
    case 2:
      _mutation_func_ptr = &TTDeletMutations_bitstring::mutate_redraw;
      break;
  }
}

References _mutation_func_ptr, _myProto, TProtoDeletMutations_bitstring::get_backmutation_rate(), mutate_noredraw(), mutate_noredraw_noBackMutation(), and mutate_redraw().

Referenced by TProtoDeletMutations_bitstring::hatch().

set_nb_hmz_mutations()

void TTDeletMutations_bitstring::set_nb_hmz_mutations ( )

private

{
  (*_hmz) = *sequence[0] & *sequence[1];
  _nb_hmz_mutations = _hmz->count();
}

References _hmz, _nb_hmz_mutations, bitstring::count(), and sequence.

set_nb_htz_mutations()

void TTDeletMutations_bitstring::set_nb_htz_mutations ( )

private

{
  (*_htz) = *sequence[0] ^ *sequence[1];
  _nb_htz_mutations = _htz->count();
}

References _htz, _nb_htz_mutations, bitstring::count(), and sequence.

set_nb_locus()

void TTDeletMutations_bitstring::set_nb_locus ( int  val )

inline

{_nb_locus = val;}

References _nb_locus.

Referenced by TProtoDeletMutations_bitstring::hatch().

set_nb_mutations()

void TTDeletMutations_bitstring::set_nb_mutations ( )

private

{
  _nb_mutations = sequence[0]->count() + sequence[1]->count();
}

References _nb_mutations, bitstring::count(), and sequence.

set_proto()

void TTDeletMutations_bitstring::set_proto ( TProtoDeletMutations_bitstring *  proto )

inline

{_myProto = proto;}

References _myProto.

Referenced by TProtoDeletMutations_bitstring::hatch().

set_recomb_template()

static void TTDeletMutations_bitstring::set_recomb_template ( unsigned int  size )

static

set_sequence() [1/2]

void TTDeletMutations_bitstring::set_sequence

(

bitstring **

seq

)

{
  reset();
  init();
  sequence[0]->copy(*seq[0]);
  sequence[1]->copy(*seq[1]);
}

References bitstring::copy(), init(), reset(), and sequence.

Referenced by TTDeletMutBitstrFH::FHread().

set_sequence() [2/2]

virtual void TTDeletMutations_bitstring::set_sequence ( void **  seq )

inlinevirtual

Implements TTrait.

{}

set_trait()

virtual void* TTDeletMutations_bitstring::set_trait ( void *  value )

inlinevirtual

Implements TTrait.

{return NULL;}

set_value()

void TTDeletMutations_bitstring::set_value ( )

virtual

Implements TTrait.

{
  if (_is_continuous) {
    set_counts_and_bitstrings();
  } else {
    _nb_hmz_mutations = sequence[0]->count_and(*sequence[1]);
    _nb_htz_mutations = sequence[0]->count_xor(*sequence[1]);
    _nb_mutations = 2 * _nb_hmz_mutations + _nb_htz_mutations;
  }
  _phenotype = (this->*_viability_func_ptr)();
}

References _is_continuous, _nb_hmz_mutations, _nb_htz_mutations, _nb_mutations, _phenotype, _viability_func_ptr, bitstring::count_and(), bitstring::count_xor(), sequence, and set_counts_and_bitstrings().

Referenced by TTDeletMutBitstrFH::FHread(), operator=(), and show_up().

set_viability_func_ptr()

void TTDeletMutations_bitstring::set_viability_func_ptr	(	unsigned int	f_model,
		bool	is_cont
	)

                                                                                            {  
  switch(f_model) {
    case 1:
    {
      if(is_cont)
        _viability_func_ptr = &TTDeletMutations_bitstring::viability_multi_continuous;
      else
        _viability_func_ptr = &TTDeletMutations_bitstring::viability_multi;
      break;
    }
    case 2:
    {
      if(is_cont)
        _viability_func_ptr = &TTDeletMutations_bitstring::viability_epist_continuous;
      else
        _viability_func_ptr = &TTDeletMutations_bitstring::viability_epist;
      break;
    }
  }
}

References _viability_func_ptr, viability_epist(), viability_epist_continuous(), viability_multi(), and viability_multi_continuous().

Referenced by TProtoDeletMutations_bitstring::hatch().

show_up()

void TTDeletMutations_bitstring::show_up ( )

virtual

Implements TTrait.

{
  set_value();
  std::cout<<"\n  Trait type: delet"
  <<"\n       value: "<<*(double*)getValue()
  <<"\nnb mutations: "<<get_nb_mutations()
  <<"\n  nb hmz mut: "<<get_nb_hmz_mutations()
  <<"\n  nb htz mut: "<<get_nb_htz_mutations()
  <<"\n    sequence: "<<std::endl;
  cout<<"0: ";
  for(unsigned int i = 0; i < _nb_locus && i < 64; i++)
    cout<<(*sequence[0])[i];
  cout<<"\n1: ";
  for(unsigned int i = 0; i < _nb_locus && i < 64; i++)
    cout<<(*sequence[1])[i];
  cout<<endl;
}

References _nb_locus, get_nb_hmz_mutations(), get_nb_htz_mutations(), get_nb_mutations(), getValue(), sequence, and set_value().

store_data()

void TTDeletMutations_bitstring::store_data ( BinaryStorageBuffer *  saver )

virtual

Implements StorableComponent.

{
  size_t wnb = sequence[0]->nb_words();
  size_t bytes = sizeof(bitstring::_ul);
  
  for(size_t i = 0; i < wnb; i++) 
    saver->store(sequence[0]->getword_atIdx(i), bytes);
  
  for(size_t i = 0; i < wnb; i++) 
    saver->store(sequence[1]->getword_atIdx(i), bytes);
}

References bitstring::getword_atIdx(), bitstring::nb_words(), sequence, and BinaryStorageBuffer::store().

viability_epist()

double TTDeletMutations_bitstring::viability_epist

(

)

{
  //w = 1 - s(hmz + h*htz)
  return 1.0 - _myProto->get_strength() * (_nb_hmz_mutations + _myProto->get_dominance() * _nb_htz_mutations) * _myProto->get_fitness_scaling_factor();
}

References _myProto, _nb_hmz_mutations, _nb_htz_mutations, TProtoDeletMutations_bitstring::get_dominance(), TProtoDeletMutations_bitstring::get_fitness_scaling_factor(), and TProtoDeletMutations_bitstring::get_strength().

Referenced by set_viability_func_ptr().

viability_epist_continuous()

double TTDeletMutations_bitstring::viability_epist_continuous

(

)

{
  //w = 1 - sum_i(s_i*hmz_i + hs_i*htz_i)
  //sparse iteration: only visit set bits (mutated loci) using ctz
  double fitness = 1.0;
  float** effects = _myProto->get_effects();
 
  for (size_t w = 0; w < _hmz->nb_words(); ++w) {
    auto word = *_hmz->getword_atIdx(w);
    while (word) {
      unsigned int bit = __builtin_ctzl(word);
      unsigned int locus = w * BITS_PER_WORD + bit;
      fitness -= effects[1][locus];
      word &= word - 1;
    }
  }
 
  for (size_t w = 0; w < _htz->nb_words(); ++w) {
    auto word = *_htz->getword_atIdx(w);
    while (word) {
      unsigned int bit = __builtin_ctzl(word);
      unsigned int locus = w * BITS_PER_WORD + bit;
      fitness -= effects[0][locus];
      word &= word - 1;
    }
  }
 
  return fitness * _myProto->get_fitness_scaling_factor();
}

References _hmz, _htz, _myProto, BITS_PER_WORD, TProtoDeletMutations_bitstring::get_effects(), TProtoDeletMutations_bitstring::get_fitness_scaling_factor(), bitstring::getword_atIdx(), and bitstring::nb_words().

Referenced by set_viability_func_ptr().

viability_multi()

double TTDeletMutations_bitstring::viability_multi

(

)

{
  //w = (1-s)^hmz * (1-hs)^htz
  return ( pow( 1.0 - _myProto->get_strength(), (double)_nb_hmz_mutations ) *
           pow( 1.0 - (_myProto->get_dominance() * _myProto->get_strength()), (double)_nb_htz_mutations) *
           _myProto->get_fitness_scaling_factor() );
}

References _myProto, _nb_hmz_mutations, _nb_htz_mutations, TProtoDeletMutations_bitstring::get_dominance(), TProtoDeletMutations_bitstring::get_fitness_scaling_factor(), and TProtoDeletMutations_bitstring::get_strength().

Referenced by set_viability_func_ptr().

viability_multi_continuous()

double TTDeletMutations_bitstring::viability_multi_continuous

(

)

{
  //w = prod_i (1-s_i)^hmz_i * (1-hs_i)^htz_i
  //sparse iteration: only visit set bits (mutated loci) using ctz
  double fitness = 1.0;
  float** effects = _myProto->get_effects();
 
  for (size_t w = 0; w < _hmz->nb_words(); ++w) {
    auto word = *_hmz->getword_atIdx(w);
    while (word) {
      unsigned int bit = __builtin_ctzl(word);
      unsigned int locus = w * BITS_PER_WORD + bit;
      fitness *= (1.0f - effects[1][locus]);
      word &= word - 1;
    }
  }
 
  for (size_t w = 0; w < _htz->nb_words(); ++w) {
    auto word = *_htz->getword_atIdx(w);
    while (word) {
      unsigned int bit = __builtin_ctzl(word);
      unsigned int locus = w * BITS_PER_WORD + bit;
      fitness *= (1.0f - effects[0][locus]);
      word &= word - 1;
    }
  }
 
  return fitness * _myProto->get_fitness_scaling_factor();
}

References _hmz, _htz, _myProto, BITS_PER_WORD, TProtoDeletMutations_bitstring::get_effects(), TProtoDeletMutations_bitstring::get_fitness_scaling_factor(), bitstring::getword_atIdx(), and bitstring::nb_words().

Referenced by set_viability_func_ptr().

Member Data Documentation

_genomic_mut_rate

double TTDeletMutations_bitstring::_genomic_mut_rate

private

Referenced by mutate_noredraw(), mutate_noredraw_noBackMutation(), mutate_redraw(), and set_mut_rate().

_hmz

bitstring * TTDeletMutations_bitstring::_hmz

private

Referenced by init(), reset(), set_counts_and_bitstrings(), set_nb_hmz_mutations(), viability_epist_continuous(), and viability_multi_continuous().

_htz

bitstring* TTDeletMutations_bitstring::_htz

private

Referenced by init(), reset(), set_counts_and_bitstrings(), set_nb_htz_mutations(), viability_epist_continuous(), and viability_multi_continuous().

_inherit_func_ptr

void(TProtoDeletMutations_bitstring::* TTDeletMutations_bitstring::_inherit_func_ptr) (sex_t, bitstring *, bitstring **)

private

Referenced by inherit(), and set_inherit_func_ptr().

_is_continuous

bool TTDeletMutations_bitstring::_is_continuous

private

Referenced by set_is_continuous(), and set_value().

_mutation_func_ptr

void(TTDeletMutations_bitstring::* TTDeletMutations_bitstring::_mutation_func_ptr) (void)

private

Referenced by mutate(), and set_mutation_func_ptr().

_myProto

TProtoDeletMutations_bitstring* TTDeletMutations_bitstring::_myProto

private

Referenced by get_allele_value(), inherit(), init_sequence(), mutate_noredraw(), set_allele_value(), set_mutation_func_ptr(), set_proto(), viability_epist(), viability_epist_continuous(), viability_multi(), and viability_multi_continuous().

_nb_hmz_mutations

unsigned int TTDeletMutations_bitstring::_nb_hmz_mutations

private

Referenced by get_nb_hmz_mutations(), mutate_redraw(), set_counts_and_bitstrings(), set_nb_hmz_mutations(), set_value(), viability_epist(), and viability_multi().

_nb_htz_mutations

unsigned int TTDeletMutations_bitstring::_nb_htz_mutations

private

Referenced by get_nb_htz_mutations(), set_counts_and_bitstrings(), set_nb_htz_mutations(), set_value(), viability_epist(), and viability_multi().

_nb_locus

unsigned int TTDeletMutations_bitstring::_nb_locus

private

Referenced by init(), init_sequence(), mutate_noredraw(), mutate_noredraw_noBackMutation(), mutate_redraw(), operator=(), operator==(), set_allele_value(), set_nb_locus(), and show_up().

_nb_mutations

unsigned int TTDeletMutations_bitstring::_nb_mutations

private

Referenced by get_nb_mutations(), set_counts_and_bitstrings(), set_nb_mutations(), and set_value().

_phenotype

double TTDeletMutations_bitstring::_phenotype

private

Referenced by getValue(), and set_value().

_type

trait_t TTDeletMutations_bitstring::_type

private

Referenced by get_type(), and operator==().

_viability_func_ptr

double(TTDeletMutations_bitstring::* TTDeletMutations_bitstring::_viability_func_ptr) (void)

private

Referenced by set_value(), and set_viability_func_ptr().

sequence

bitstring* TTDeletMutations_bitstring::sequence[2]

private

Referenced by get_allele(), get_allele_value(), get_hmz_atLocus(), get_htz_atLocus(), get_nb_mut_atLocus(), get_sequence(), inherit(), init(), init_sequence(), mutate_noredraw(), mutate_noredraw_noBackMutation(), mutate_redraw(), operator=(), reset(), retrieve_data(), set_allele_value(), set_counts_and_bitstrings(), set_nb_hmz_mutations(), set_nb_htz_mutations(), set_nb_mutations(), set_sequence(), set_value(), show_up(), store_data(), and TTDeletMutations_bitstring().

---

The documentation for this class was generated from the following files:

• ttdeletmutations_bitstring.h
• ttdeletmutations_bitstring.cc