TTQuanti_diallelic_bitstring_no_pleio Class Reference

TTQuanti_diallelic_bitstring_no_pleio : single or multiple non-pleiotropic traits, di-allelic. More...

#include <ttquanti_bitstring.h>

Inheritance diagram for TTQuanti_diallelic_bitstring_no_pleio:

Collaboration diagram for TTQuanti_diallelic_bitstring_no_pleio:

Public Member Functions
	TTQuanti_diallelic_bitstring_no_pleio ()
	TTQuanti_diallelic_bitstring_no_pleio (const TTQuanti_diallelic_bitstring_no_pleio &TT)
virtual	~TTQuanti_diallelic_bitstring_no_pleio ()
virtual void	init ()
virtual void	init_sequence ()
virtual TTQuanti_diallelic_bitstring_no_pleio *	clone ()
virtual void	show_up ()
virtual double	get_additive_genotype (const unsigned int trait) const
virtual double	get_dominant_genotype (const unsigned int trait) const
virtual void	copy_sequence_block (sex_t SEX, unsigned int chromosome, unsigned int from_locus, unsigned int to_locus, const TTQuanti *parent)
virtual void	copy_sequence_1locus (sex_t SEX, unsigned int chromosome, unsigned int at, const TTQuanti *parent)
double	get_additive_genotype_equal_effects (const unsigned int trait) const
Public Member Functions inherited from TTQuanti_diallelic_bitstring
	TTQuanti_diallelic_bitstring ()
	TTQuanti_diallelic_bitstring (const TTQuanti &T)
virtual	~TTQuanti_diallelic_bitstring ()
virtual bool	get_allele_bit (unsigned int position, unsigned int allele) const
virtual void	set_allele_bit (unsigned int position, unsigned int allele, bool value)
void	set_bit_sequence (const bitstring *inseq)
const bitstring &	get_bit_sequence (bool chromosome) const
void	inherit_free (const TTrait *mother, const TTrait *father)
virtual void	reset ()
virtual void	set_sequence (void **seq)
virtual void **	get_sequence () const
virtual unsigned int	get_allele (int loc, int all) const
virtual double	get_allele_value (int locus, int allele) const
virtual void	set_allele_value (unsigned int locus, unsigned int allele, double value)
virtual TTQuanti_diallelic_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)
virtual double	get_full_genotype (unsigned int trait)
virtual void	mutate_add (unsigned int position, unsigned int allele, double value)
virtual void	mutate_inplace (unsigned int position, unsigned int allele, double value)
Public Member Functions inherited from TTQuanti
	TTQuanti ()
	TTQuanti (const TTQuanti &T)
virtual	~TTQuanti ()
virtual trait_t	get_type () const
virtual void	mutate ()
virtual void	inherit (const TTrait *mother, const TTrait *father)
virtual void *	set_trait (void *value)
virtual void	set_value ()
virtual void *	getValue () const
void	set_proto (TProtoQuanti *proto)
TProtoQuanti *	get_proto ()
double	get_phenotype (unsigned int trai)
void	set_phenotype (unsigned int trait, double value)
void	reset_phenotype_to_genotypic_value ()
Public Member Functions inherited from TTrait
virtual	~TTrait ()
Public Member Functions inherited from StorableComponent
virtual	~StorableComponent ()

Additional Inherited Members
Protected Attributes inherited from TTQuanti_diallelic_bitstring
bitstring *	_sequence
Protected Attributes inherited from TTQuanti
double *	_phenotypes
double *	_genotypic_values
TProtoQuanti *	_myProto

Detailed Description

TTQuanti_diallelic_bitstring_no_pleio : single or multiple non-pleiotropic traits, di-allelic.

Constructor & Destructor Documentation

TTQuanti_diallelic_bitstring_no_pleio() [1/2]

TTQuanti_diallelic_bitstring_no_pleio::TTQuanti_diallelic_bitstring_no_pleio ( )

inline

                                          : TTQuanti_diallelic_bitstring()
  {}

Referenced by clone().

Here is the caller graph for this function:

TTQuanti_diallelic_bitstring_no_pleio() [2/2]

TTQuanti_diallelic_bitstring_no_pleio::TTQuanti_diallelic_bitstring_no_pleio ( const TTQuanti_diallelic_bitstring_no_pleio &  TT )

inline

                                                                                         : TTQuanti_diallelic_bitstring(TT)
  {}

~TTQuanti_diallelic_bitstring_no_pleio()

virtual TTQuanti_diallelic_bitstring_no_pleio::~TTQuanti_diallelic_bitstring_no_pleio ( )

inlinevirtual

{}

Member Function Documentation

clone()

virtual TTQuanti_diallelic_bitstring_no_pleio* TTQuanti_diallelic_bitstring_no_pleio::clone ( )

inlinevirtual

Implements TTrait.

{return new TTQuanti_diallelic_bitstring_no_pleio(*this);}

References TTQuanti_diallelic_bitstring_no_pleio().

copy_sequence_1locus()

void TTQuanti_diallelic_bitstring_no_pleio::copy_sequence_1locus ( sex_t  SEX, unsigned int  chromosome, unsigned int  at, const TTQuanti *  parent  )

inlinevirtual

Implements TTQuanti.

{
  const bitstring& orig = dynamic_cast<const TTQuanti_diallelic_bitstring*>(parent)->get_bit_sequence((bool)chromosome);
 
  _sequence[SEX][at] = orig[at];
}

References TTQuanti_diallelic_bitstring::_sequence, and TTQuanti_diallelic_bitstring::get_bit_sequence().

copy_sequence_block()

void TTQuanti_diallelic_bitstring_no_pleio::copy_sequence_block ( sex_t  SEX, unsigned int  chromosome, unsigned int  from_locus, unsigned int  to_locus, const TTQuanti *  parent  )

inlinevirtual

Implements TTQuanti.

{
  assert(to_locus > from_locus);
 
  const bitstring& orig = dynamic_cast<const TTQuanti_diallelic_bitstring*>(parent)->get_bit_sequence((bool)chromosome);
 
  _sequence[SEX].copy(orig, from_locus, to_locus);
 
}

References TTQuanti_diallelic_bitstring::_sequence, bitstring::copy(), and TTQuanti_diallelic_bitstring::get_bit_sequence().

get_additive_genotype()

double TTQuanti_diallelic_bitstring_no_pleio::get_additive_genotype ( const unsigned int  trait ) const

inlinevirtual

Implements TTQuanti.

{
  unsigned int L   = _myProto->get_num_locus(trait);          //number of loci affecting this trait
  unsigned int pos = _myProto->get_locus_seq_pos(0, trait); //starting position, all loci contiguous on the map
  double genotype = 0;
 
  if(_myProto->has_equal_effects() ) {
 
    const bitstring& mask = _myProto->get_trait_mask(trait);
    unsigned int n0 = _sequence[0].count_and(mask);
    unsigned int n1 = _sequence[1].count_and(mask);
    return 2.0 * L * _myProto->get_equal_val_0()
        + (n0 + n1) * _myProto->get_equal_val_diff();
  }
 
  for(unsigned int j = 0; j < L; ++j, ++pos) {
    genotype += _myProto->get_seq_diallele_value( pos, _sequence[0][pos] );
    genotype += _myProto->get_seq_diallele_value( pos, _sequence[1][pos] );
  }
 
  return genotype;
}

References TTQuanti::_myProto, TTQuanti_diallelic_bitstring::_sequence, bitstring::count_and(), TProtoQuanti::get_equal_val_0(), TProtoQuanti::get_equal_val_diff(), TProtoQuanti::get_locus_seq_pos(), TProtoQuanti::get_num_locus(), TProtoQuanti::get_seq_diallele_value(), TProtoQuanti::get_trait_mask(), and TProtoQuanti::has_equal_effects().

get_additive_genotype_equal_effects()

double TTQuanti_diallelic_bitstring_no_pleio::get_additive_genotype_equal_effects ( const unsigned int  trait ) const

inline

{
  unsigned int L   = _myProto->get_num_locus(trait);          //number of loci affecting this trait
  unsigned int pos = _myProto->get_locus_seq_pos(0, trait); //starting position, all loci contiguous on the map
 
  // bulk path: replace O(L) per-bit loop with two popcount calls over [pos, pos+L)
  unsigned int n0 = _sequence[0].count(pos, pos + L);
  unsigned int n1 = _sequence[1].count(pos, pos + L);
  return 2.0 * L * _myProto->get_equal_val_0()
      + (n0 + n1) * _myProto->get_equal_val_diff();
}

References TTQuanti::_myProto, TTQuanti_diallelic_bitstring::_sequence, bitstring::count(), TProtoQuanti::get_equal_val_0(), TProtoQuanti::get_equal_val_diff(), TProtoQuanti::get_locus_seq_pos(), and TProtoQuanti::get_num_locus().

Referenced by get_dominant_genotype().

Here is the caller graph for this function:

get_dominant_genotype()

double TTQuanti_diallelic_bitstring_no_pleio::get_dominant_genotype ( const unsigned int  trait ) const

inlinevirtual

Implements TTQuanti.

{
  unsigned int L = _myProto->get_num_locus(trait);          //number of loci affecting this trait
  unsigned int pos = _myProto->get_locus_seq_pos(0, trait); //starting position, all loci contiguous on the map
 
  if(_myProto->has_equal_effects() && _myProto->has_equal_domCoeff()) {
 
    const bitstring& mask = _myProto->get_trait_mask(trait);
    unsigned int n_htz  = _sequence[0].count_xor_and(_sequence[1], mask);
    unsigned int n_hmz1 = _sequence[0].count_and_and(_sequence[1], mask);
    unsigned int n_hmz0 = L - n_htz - n_hmz1;  // remainder are homozygous ancestral
 
    double val_0 = _myProto->get_equal_val_0();
    double val_1 = _myProto->get_equal_val_1();
    double k     = _myProto->get_dominance(0, trait);  // uniform k
 
    return n_hmz0 * 2.0 * val_0
        + n_htz  * (val_0 + val_1 + k * fabs(val_1 - val_0))
        + n_hmz1 * 2.0 * val_1;
 
  }//END_has_equal_effect && has_equal_domCoeff
 
  if(_myProto->has_equal_effects() ) {
    unsigned long word;
 
    // additive effects are equal across loci, only dominance varies
    double het_val = fabs(_myProto->get_equal_val_1() - _myProto->get_equal_val_0());
    double genotype = get_additive_genotype_equal_effects(trait); // includes add efx of all loci
 
    bitstring htz(_sequence[0]);
    htz ^= _sequence[1];              // XOR: heterozygous loci have bit=1
 
    // Per-locus part (only heterozygous loci — iterate over set bits in htz)
    for (size_t w = pos/BITS_PER_WORD; w <= (pos+L-1)/BITS_PER_WORD; ++w) {
      word = *htz.getword_atIdx(w);  // only heterozygous bits
      while (word) {
        unsigned int bit = __builtin_ctzl(word);   // find lowest set bit
        unsigned int locus = w * BITS_PER_WORD + bit;
        double k = _myProto->get_dominance(locus, trait);
        genotype += k * het_val;       // add dominance deviation at that locus
        word &= word - 1;  // clear lowest set bit
      }
    }
 
    return genotype;
  } //END_has_equal_effect
 
 
  // non-optimized case:
  double genotype = 0;
  unsigned int locID;
 
  for(unsigned int j = 0; j < L; ++j, ++pos) {
    locID = _myProto->get_locus_ID(j, trait);
    genotype += _myProto->get_genotype_with_dominance(
        _myProto->get_seq_diallele_value( pos, _sequence[0][pos] ) ,
        _myProto->get_seq_diallele_value( pos, _sequence[1][pos] ),
        locID,
        trait);
  }
 
  return genotype;
 
}

References TTQuanti::_myProto, TTQuanti_diallelic_bitstring::_sequence, BITS_PER_WORD, bitstring::count_and_and(), bitstring::count_xor_and(), get_additive_genotype_equal_effects(), TProtoQuanti::get_dominance(), TProtoQuanti::get_equal_val_0(), TProtoQuanti::get_equal_val_1(), TProtoQuanti::get_genotype_with_dominance(), TProtoQuanti::get_locus_ID(), TProtoQuanti::get_locus_seq_pos(), TProtoQuanti::get_num_locus(), TProtoQuanti::get_seq_diallele_value(), TProtoQuanti::get_trait_mask(), bitstring::getword_atIdx(), TProtoQuanti::has_equal_domCoeff(), and TProtoQuanti::has_equal_effects().

init()

void TTQuanti_diallelic_bitstring_no_pleio::init ( )

inlinevirtual

Reimplemented from TTQuanti_diallelic_bitstring.

{
  TTQuanti_diallelic_bitstring::init();
}

References TTQuanti_diallelic_bitstring::init().

init_sequence()

void TTQuanti_diallelic_bitstring_no_pleio::init_sequence ( )

inlinevirtual

Implements TTrait.

{
  //options:
  //0: no variation, all alleles set to 0
  //1: max variation, randomly set alleles at each locus
  //2: no variation and initialize with opposite effect alleles at alternating loci.
 
  // initialize with 0 bit
  _sequence[0].reset();
  _sequence[1].reset();
 
  if (_myProto->get_doInitMutation() == 1) {
 
    for(unsigned int i = 0; i < _myProto->get_num_locus(); ++i) {
 
      // randomly set the allelic values
      _sequence[0][ i ] = RAND::RandBool();
      _sequence[1][ i ] = RAND::RandBool();
 
    }
 
  } else if (_myProto->get_doInitMutation() == 2) {
    //option 2; polarized di-allelic values; even locus set to +a, odd locus set to -a
 
    for(unsigned int i = 0; i < _myProto->get_num_locus(); i++) { // process trait-wise
      // no need to set alleles to 0 since it was initialized that way
 
      if(i%2) { // odd locus
        _sequence[1][ i ].flip(); //set with the alternate/negative allele value
        _sequence[0][ i ].flip();
      }
    }
  }
 
}

References TTQuanti::_myProto, TTQuanti_diallelic_bitstring::_sequence, bitstring::flip(), TProtoQuanti::get_doInitMutation(), TProtoQuanti::get_num_locus(), RAND::RandBool(), and bitstring::reset().

show_up()

void TTQuanti_diallelic_bitstring_no_pleio::show_up ( )

virtual

Implements TTrait.

{
  message("\
          Trait's type: QUANTI (diallelic, no pleiotropy)\n\
          traits: %i\n\
          loci: %i\n\
          seq length: %i\n",_myProto->get_num_traits(),_myProto->get_num_locus()
          ,_myProto->get_seq_length());
 
  for(unsigned int i = 0; i < _myProto->get_num_traits(); i++)
    message("phenotype %i: %f\n",i+1,_phenotypes[i]);
 
  message("genotype:");
 
  for(unsigned int i = 0; i < _myProto->get_num_traits(); ++i) {
 
    message("\ntrait %i (%i loci):\nloci: ",i+1, _myProto->get_num_locus(i));
 
    for(unsigned int j = 0; j < _myProto->get_num_locus(i); ++j) {
          message("%i, ", _myProto->get_locus_ID(j, i));
    }
 
    message("\n[0]: ");
 
    for(unsigned int j = 0; j < _myProto->get_num_locus(i); ++j) {
      message("%.3f,", (double)_sequence[0][ _myProto->get_locus_seq_pos(j, i) ]);
    }
 
    message("\n[1]: ");
 
    for(unsigned int j = 0; j < _myProto->get_num_locus(i); ++j) {
      message("%.3f,", (double)_sequence[1][ _myProto->get_locus_seq_pos(j, i) ]);
    }
  }
 
  message("\n");
 
}

References TTQuanti::_myProto, TTQuanti::_phenotypes, TTQuanti_diallelic_bitstring::_sequence, TProtoQuanti::get_locus_ID(), TProtoQuanti::get_locus_seq_pos(), TProtoQuanti::get_num_locus(), TProtoQuanti::get_num_traits(), TProtoQuanti::get_seq_length(), and message().

---

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

• ttquanti_bitstring.h
• ttquanti_bitstring.cc