template_inline_simulation_functors.cuh

/*
 * template_simulation_functors.cuh
 *
 *      Author: David Lawrie
 *      implementation of template and inline functions for GO Fish evolutionary models and sampling schemes
 */

#ifndef TEMPLATE_INLINE_SIMULATION_FUNCTORS_CUH_
#define TEMPLATE_INLINE_SIMULATION_FUNCTORS_CUH_

namespace Sim_Model{

/* ----- constant selection model ----- */
inline selection_constant::selection_constant() : s(0) {}
inline selection_constant::selection_constant(float s) : s(s){ }
template <typename Functor_demography, typename Functor_inbreeding>
inline selection_constant::selection_constant(float gamma, Functor_demography demography, Functor_inbreeding F, int forward_generation_shift /*= 0*/){ s = gamma/(2*demography(0,forward_generation_shift)/(1+F(0,forward_generation_shift))); }
__device__ __forceinline__ float selection_constant::operator()(const int population, const int generation, const float freq) const{ return s; }
/* ----- end constant selection model ----- */

/* ----- linear frequency dependent selection model ----- */
inline selection_linear_frequency_dependent::selection_linear_frequency_dependent() : slope(0), intercept(0) {}
inline selection_linear_frequency_dependent::selection_linear_frequency_dependent(float slope, float intercept) : slope(slope), intercept(intercept) { }
template <typename Functor_demography, typename Functor_inbreeding>
inline selection_linear_frequency_dependent::selection_linear_frequency_dependent(float gamma_slope, float gamma_intercept, Functor_demography demography, Functor_inbreeding F, int forward_generation_shift /*= 0*/){
    slope = gamma_slope/(2*demography(0,forward_generation_shift)/(1+F(0,forward_generation_shift)));
    intercept = gamma_intercept/(2*demography(0,forward_generation_shift)/(1+F(0,forward_generation_shift)));
}
__device__ __forceinline__ float selection_linear_frequency_dependent::operator()(const int population, const int generation, const float freq) const{ return slope*freq+intercept; }
/* ----- end linear frequency dependent selection model ----- */

/* ----- seasonal selection model ----- */
inline selection_sine_wave::selection_sine_wave() : A(0), pi(0), rho(0), D(0), generation_shift(0) {}
inline selection_sine_wave::selection_sine_wave(float A, float pi, float D, float rho /*= 0*/, int generation_shift /*= 0*/) : A(A), pi(pi), rho(rho), D(D), generation_shift(generation_shift) {}
template <typename Functor_demography, typename Functor_inbreeding>
inline selection_sine_wave::selection_sine_wave(float gamma_A, float pi, float gamma_D, Functor_demography demography, Functor_inbreeding F, float rho /*= 0*/, int generation_shift /*= 0*/, int forward_generation_shift /*= 0*/) : pi(pi), rho(rho), generation_shift(generation_shift) {
    A = gamma_A/(2*demography(0,forward_generation_shift)/(1+F(0,forward_generation_shift)));
    D = gamma_D/(2*demography(0,forward_generation_shift)/(1+F(0,forward_generation_shift)));
}
__device__ __forceinline__ float selection_sine_wave::operator()(const int population, const int generation, const float freq) const{ return A*sin(pi*(generation-generation_shift) + rho) + D;}
/* ----- end seasonal selection model ----- */

/* ----- population specific selection model ----- */
template <typename Functor_sel, typename Functor_sel_pop>
inline selection_population_specific<Functor_sel,Functor_sel_pop>::selection_population_specific() : pop(0), generation_shift(0) { s = Functor_sel(); s_pop = Functor_sel_pop(); }
template <typename Functor_sel, typename Functor_sel_pop>
inline selection_population_specific<Functor_sel,Functor_sel_pop>::selection_population_specific(Functor_sel s_in, Functor_sel_pop s_pop_in, int pop, int generation_shift /*= 0*/) : pop(pop), generation_shift(generation_shift){  s = s_in; s_pop = s_pop_in; }
template <typename Functor_sel, typename Functor_sel_pop>
__device__ __forceinline__ float selection_population_specific<Functor_sel,Functor_sel_pop>::operator()(const int population, const int generation, const float freq) const{
    if(pop == population) return s_pop(population, generation-generation_shift, freq);
    return s(population, generation-generation_shift, freq);
}
/* ----- end population specific selection model ----- */

/* ----- piecewise selection model ----- */
template <typename Functor_sel1, typename Functor_sel2>
inline selection_piecewise<Functor_sel1, Functor_sel2>::selection_piecewise() : inflection_point(0), generation_shift(0) { s1 = Functor_sel1(); s2 = Functor_sel2(); }
template <typename Functor_sel1, typename Functor_sel2>
inline selection_piecewise<Functor_sel1, Functor_sel2>::selection_piecewise(Functor_sel1 s1_in, Functor_sel2 s2_in, int inflection_point, int generation_shift /* = 0*/) : inflection_point(inflection_point), generation_shift(generation_shift) { s1 = s1_in; s2 = s2_in; }
template <typename Functor_sel1, typename Functor_sel2>
__device__ __forceinline__ float selection_piecewise<Functor_sel1, Functor_sel2>::operator()(const int population, const int generation, const float freq) const{
    if(generation >= inflection_point+generation_shift){ return s2(population, generation-generation_shift, freq) ; }
    return s1(population, generation-generation_shift, freq);
};
/* ----- end piecewise selection model ----- */
/* ----- end selection models ----- */

/* ----- inbreeding, mutation, & dominance models ----- */
/* ----- constant parameter model ----- */
inline F_mu_h_constant::F_mu_h_constant() : p(0) {}
inline F_mu_h_constant::F_mu_h_constant(float p) : p(p){ }
__host__ __forceinline__ float F_mu_h_constant::operator()(const int population, const int generation) const{ return p; }
/* ----- end constant parameter model ----- */

/* ----- seasonal parameter model ----- */
inline F_mu_h_sine_wave::F_mu_h_sine_wave() : A(0), pi(0), rho(0), D(0), generation_shift(0) {}
inline F_mu_h_sine_wave::F_mu_h_sine_wave(float A, float pi, float D, float rho /*= 0*/, int generation_shift /*= 0*/) : A(A), pi(pi), rho(rho), D(D), generation_shift(generation_shift) {}
__host__ __forceinline__ float F_mu_h_sine_wave::operator()(const int population, const int generation) const{ return A*sin(pi*(generation-generation_shift) + rho) + D;}
/* ----- end seasonal parameter model ----- */

/* ----- population specific parameter model ----- */
template <typename Functor_p, typename Functor_p_pop>
inline F_mu_h_population_specific<Functor_p,Functor_p_pop>::F_mu_h_population_specific() : pop(0), generation_shift(0) { p = Functor_p(); p_pop = Functor_p_pop(); }
template <typename Functor_p, typename Functor_p_pop>
inline F_mu_h_population_specific<Functor_p,Functor_p_pop>::F_mu_h_population_specific(Functor_p p_in, Functor_p_pop p_pop_in, int pop, int generation_shift /*= 0*/) : pop(pop), generation_shift(generation_shift){  p = p_in; p_pop = p_pop_in; }
template <typename Functor_p, typename Functor_p_pop>
__host__ __forceinline__ float F_mu_h_population_specific<Functor_p,Functor_p_pop>::operator()(const int population, const int generation) const{
    if(pop == population) return p_pop(population, generation-generation_shift);
    return p(population, generation-generation_shift);
}
/* ----- end population specific parameter model ----- */

/* ----- piecewise parameter model ----- */
template <typename Functor_p1, typename Functor_p2>
inline F_mu_h_piecewise<Functor_p1, Functor_p2>::F_mu_h_piecewise() : inflection_point(0), generation_shift(0) { p1 = Functor_p1(); p2 = Functor_p2(); }
template <typename Functor_p1, typename Functor_p2>
inline F_mu_h_piecewise<Functor_p1, Functor_p2>::F_mu_h_piecewise(Functor_p1 p1_in, Functor_p2 p2_in, int inflection_point, int generation_shift /* = 0*/) : inflection_point(inflection_point), generation_shift(generation_shift) { p1 = p1_in; p2 = p2_in; }
template <typename Functor_p1, typename Functor_p2>
__host__ __forceinline__ float F_mu_h_piecewise<Functor_p1, Functor_p2>::operator()(const int population, const int generation) const{
    if(generation >= inflection_point+generation_shift){ return p2(population, generation-generation_shift) ; }
    return p1(population, generation-generation_shift);
};
/* ----- end piecewise parameter model ----- */
/* ----- end of inbreeding, mutation, & dominance models models ----- */

/* ----- demography models ----- */
/* ----- constant demography model ----- */
inline demography_constant::demography_constant() : N(0) {}
inline demography_constant::demography_constant(int N) : N(N){ }
__host__ __device__  __forceinline__ int demography_constant::operator()(const int population, const int generation) const{ return N; }
/* ----- end constant demography model ----- */

/* ----- seasonal demography model ----- */
inline demography_sine_wave::demography_sine_wave() : A(0), pi(0), rho(0), D(0), generation_shift(0) {}
inline demography_sine_wave::demography_sine_wave(float A, float pi, int D, float rho /*= 0*/, int generation_shift /*= 0*/) : A(A), pi(pi), rho(rho), D(D), generation_shift(generation_shift) {}
__host__ __device__  __forceinline__ int demography_sine_wave::operator()(const int population, const int generation) const{ return (int)A*sin(pi*(generation-generation_shift) + rho) + D;}
/* ----- end seasonal parameter model ----- */

/* ----- exponential growth model ----- */
inline demography_exponential_growth::demography_exponential_growth() : rate(0), initial_population_size(0), generation_shift(0) {}
inline demography_exponential_growth::demography_exponential_growth(float rate, int initial_population_size, int generation_shift /*= 0*/) : rate(rate), initial_population_size(initial_population_size), generation_shift(generation_shift) {}
__host__ __device__  __forceinline__ int demography_exponential_growth::operator()(const int population, const int generation) const{ return (int)round(initial_population_size*exp(rate*(generation-generation_shift))); }
/* ----- end exponential growth model ----- */

/* ----- logistic growth model ----- */
inline demography_logistic_growth::demography_logistic_growth() : rate(0), initial_population_size(0), carrying_capacity(0), generation_shift(0) {}
inline demography_logistic_growth::demography_logistic_growth(float rate, int initial_population_size, int carrying_capacity, int generation_shift /*= 0*/) : rate(rate), initial_population_size(initial_population_size), carrying_capacity(carrying_capacity), generation_shift(generation_shift) {}
__host__ __device__  __forceinline__ int demography_logistic_growth::operator()(const int population, const int generation) const{
    float term = exp(rate*(generation-generation_shift));
    return (int)round(carrying_capacity*initial_population_size*term/(carrying_capacity + initial_population_size*(term-1)));
}
/* ----- end logistic growth model ----- */

/* ----- population specific demography model ----- */
template <typename Functor_d, typename Functor_d_pop>
inline demography_population_specific<Functor_d,Functor_d_pop>::demography_population_specific() : pop(0), generation_shift(0) { d = Functor_d(); d_pop = Functor_d_pop(); }
template <typename Functor_d, typename Functor_d_pop>
inline demography_population_specific<Functor_d,Functor_d_pop>::demography_population_specific(Functor_d d_in, Functor_d_pop d_pop_in, int pop, int generation_shift /*= 0*/) : pop(pop), generation_shift(generation_shift){  d = d_in; d_pop = d_pop_in; }
template <typename Functor_d, typename Functor_d_pop>
__host__ __device__  __forceinline__ int demography_population_specific<Functor_d,Functor_d_pop>::operator()(const int population, const int generation) const{
    if(pop == population) return d_pop(population, generation-generation_shift);
    return d(population, generation-generation_shift);
}
/* ----- end population specific demography model ----- */

/* ----- piecewise demography model ----- */
template <typename Functor_d1, typename Functor_d2>
inline demography_piecewise<Functor_d1, Functor_d2>::demography_piecewise() : inflection_point(0), generation_shift(0) { d1 = Functor_d1(); d2 = Functor_d2(); }
template <typename Functor_d1, typename Functor_d2>
inline demography_piecewise<Functor_d1, Functor_d2>::demography_piecewise(Functor_d1 d1_in, Functor_d2 d2_in, int inflection_point, int generation_shift /* = 0*/) : inflection_point(inflection_point), generation_shift(generation_shift) { d1 = d1_in; d2 = d2_in; }
template <typename Functor_d1, typename Functor_d2>
__host__ __device__  __forceinline__ int demography_piecewise<Functor_d1, Functor_d2>::operator()(const int population, const int generation) const{
    if(generation >= inflection_point+generation_shift){ return d2(population, generation-generation_shift) ; }
    return d1(population, generation-generation_shift);
};
/* ----- end piecewise demography model ----- */
/* ----- end of demography models ----- */

/* ----- migration models ----- */
/* ----- constant equal migration model ----- */
inline migration_constant_equal::migration_constant_equal() : m(0), num_pop(1){ }
inline migration_constant_equal::migration_constant_equal(float m, int num_pop) : m(m), num_pop(max(num_pop,1)){ }
__host__ __device__ __forceinline__ float migration_constant_equal::operator()(const int pop_FROM, const int pop_TO, const int generation) const{
        if(pop_FROM == pop_TO){ return 1-(num_pop-1)*m; }
        return (num_pop > 1) * m;
}
/* ----- end constant equal migration model ----- */

/* ----- constant directional migration model ----- */
template <typename Functor_m1>
inline migration_constant_directional<Functor_m1>::migration_constant_directional() : m(0), pop1(0), pop2(0) { rest = Functor_m1(); }
template <typename Functor_m1>
inline migration_constant_directional<Functor_m1>::migration_constant_directional(float m, int pop1, int pop2, Functor_m1 rest_in) : m(m), pop1(pop1), pop2(pop2) { rest = rest_in; }
template <typename Functor_m1>
__host__ __device__ __forceinline__ float migration_constant_directional<Functor_m1>::operator()(const int pop_FROM, const int pop_TO, const int generation) const{
    if(pop_FROM == pop1 && pop_TO == pop2) return m;
    return rest(pop_FROM, pop_TO, generation);
}
/* ----- end constant directional migration model ----- */

/* ----- piecewise migration model ----- */
template <typename Functor_m1, typename Functor_m2>
inline migration_piecewise<Functor_m1,Functor_m2>::migration_piecewise() : inflection_point(0), generation_shift(0) { m1 = Functor_m1(); m2 = Functor_m2(); }
template <typename Functor_m1, typename Functor_m2>
inline migration_piecewise<Functor_m1,Functor_m2>::migration_piecewise(Functor_m1 m1_in, Functor_m2 m2_in, int inflection_point, int generation_shift /*= 0*/) : inflection_point(inflection_point), generation_shift(generation_shift) { m1 = m1_in; m2 = m2_in; }
template <typename Functor_m1, typename Functor_m2>
__host__ __device__ __forceinline__ float migration_piecewise<Functor_m1,Functor_m2>::operator()(const int pop_FROM, const int pop_TO, const int generation) const{
    if(generation >= inflection_point+generation_shift){ return m2(pop_FROM,pop_TO,generation-generation_shift); }
    return m1(pop_FROM,pop_TO,generation-generation_shift);
}
/* ----- end piecewise migration model ----- */
/* ----- end of migration models ----- */

/* ----- preserving & sampling functions ----- */
/* ----- bool off ----- */
__host__ __forceinline__ bool bool_off::operator()(const int generation) const{ return false; }
/* ----- end bool off ----- */

/* ----- bool on ----- */
__host__ __forceinline__ bool bool_on::operator()(const int generation) const{ return true; }
/* ----- end bool on ----- */

/* ----- bool pulse_array ----- */
/* will switch to variadic templates/initializer lists when switching to C++11
bool_pulse_array::bool_pulse_array(): num_generations(0), generation_start(0) { array = NULL; }
bool_pulse_array::bool_pulse_array(const bool default_return, const int generation_start, const int num_generations, int generation_pulse...): num_generations(num_generations), generation_start(generation_start) {
    array = new bool[num_generations];
    memset(&array, default_return, num_generations*sizeof(bool));
    array[generation_pulse-generation_start] = !default_return;
}
__host__ __forceinline__ bool bool_pulse_array::operator()(const int generation) const {
    int gen = generation - generation_start;
    if((gen < 0) | (gen > num_generations)){ fprintf(stderr,"do_array functor generation error,\t generation %d\t shifted generation %d\t array length %d\n",generation,gen,num_generations); exit(1); }
    return array[gen];
}
bool_pulse_array::~bool_pulse_array(){ delete [] array; array = NULL; }*/
/* ----- end on_off_array ----- */

/* ----- bool pulse ----- */
template <typename Functor_default, typename Functor_action>
inline bool_pulse<Functor_default,Functor_action>::bool_pulse() : pulse(0), generation_shift(0) { f_default = Functor_default(); f_action = Functor_action(); }
template <typename Functor_default, typename Functor_action>
inline bool_pulse<Functor_default,Functor_action>::bool_pulse(int pulse, int generation_shift/*= 0*/) : pulse(pulse), generation_shift(generation_shift) { f_default = Functor_default(); f_action = Functor_action(); }
template <typename Functor_default, typename Functor_action>
inline bool_pulse<Functor_default,Functor_action>::bool_pulse(Functor_default f_default_in, Functor_action f_action_in, int pulse, int generation_shift/*= 0*/) : pulse(pulse), generation_shift(generation_shift) { f_default = f_default_in; f_action = f_action_in; }
template <typename Functor_default, typename Functor_action>
__host__ __forceinline__ bool bool_pulse<Functor_default,Functor_action>::operator()(const int generation) const{ if(generation == pulse + generation_shift){ return f_action(generation); } return f_default(generation); }
/* ----- end bool pulse ----- */

/* ----- bool piecewise ----- */
template <typename Functor_first, typename Functor_second>
inline bool_piecewise<Functor_first,Functor_second>::bool_piecewise() : inflection_point(0), generation_shift(0) { f1 = Functor_first(); f2 = Functor_second(); }
template <typename Functor_first, typename Functor_second>
inline bool_piecewise<Functor_first,Functor_second>::bool_piecewise(int inflection_point, int generation_shift /*= 0*/) : inflection_point(inflection_point), generation_shift(generation_shift) { f1 = Functor_first(); f2 = Functor_second(); }
template <typename Functor_first, typename Functor_second>
inline bool_piecewise<Functor_first,Functor_second>::bool_piecewise(Functor_first f1_in, Functor_second f2_in, int inflection_point, int generation_shift /*= 0*/) : inflection_point(inflection_point), generation_shift(generation_shift) { f1 = f1_in; f2 = f2_in; }
template <typename Functor_first, typename Functor_second>
__host__ __forceinline__ bool bool_piecewise<Functor_first,Functor_second>::operator()(const int generation) const{ if(generation >= inflection_point+generation_shift){ return f2(generation); } return f1(generation); }
/* ----- end bool piecewise ----- */
/* ----- end of preserving & sampling functions ----- */

}/* ----- end namespace Sim_Model ----- */

#endif /* TEMPLATE_INLINE_SIMULATION_FUNCTORS_CUH_ */