popul_proc_t< STATE, PARAMETERS, NEVENT > Class Template Reference

Population process class. More...

#include <popul_proc.h>

Public Member Functions
size_t	bytesize (void) const
	size of serialized binary form
	popul_proc_t (double t0=0)
	popul_proc_t (raw_t *o)
	constructor from serialized binary form
	popul_proc_t (const popul_proc_t &X)
	copy constructor
popul_proc_t &	operator= (const popul_proc_t &X)
	copy assignment operator
	popul_proc_t (popul_proc_t &&)=delete
	move constructor
popul_proc_t &	operator= (popul_proc_t &&)=delete
	move assignment operator
	~popul_proc_t (void)
	destructor
slate_t	time (void) const
	get current time.
virtual void	valid (void) const
virtual void	rinit (void)=0
	initialize the state
virtual void	jump (int e)=0
	makes a jump
void	update_params (double *, int)
	set parameters
void	update_IVPs (double *, int)
	set initial-value parameters
double	event_rates (double *rate, int n) const
	compute event rates
string_t	yaml (string_t tab) const
	machine/human readable info
void	update_clocks (void)
	updates clock and next event
int	play (double tfin)

Protected Types
typedef STATE	state_t
typedef PARAMETERS	parameters_t

Protected Attributes
slate_t	next
size_t	event
slate_t	current
state_t	state
parameters_t	params

Static Protected Attributes
static const size_t	nevent = NEVENT

Private Member Functions
void	clean (void)

Friends
raw_t *	operator>> (const popul_proc_t &X, raw_t *o)
	binary serialization
raw_t *	operator>> (raw_t *o, popul_proc_t &X)
	binary deserialization

Detailed Description

template<class STATE, class PARAMETERS, size_t NEVENT>
class popul_proc_t< STATE, PARAMETERS, NEVENT >

Population process class.

The class for the simulation of the Markov process.

• STATE is a datatype that holds the state of the Markov process.
• PARAMETERS is a datatype for the model parameters
• NEVENT is the number of event-types

Definition at line 16 of file popul_proc.h.

Member Typedef Documentation

parameters_t

template<class STATE, class PARAMETERS, size_t NEVENT>

typedef PARAMETERS popul_proc_t< STATE, PARAMETERS, NEVENT >::parameters_t

protected

Definition at line 21 of file popul_proc.h.

state_t

template<class STATE, class PARAMETERS, size_t NEVENT>

typedef STATE popul_proc_t< STATE, PARAMETERS, NEVENT >::state_t

protected

Definition at line 20 of file popul_proc.h.

Constructor & Destructor Documentation

popul_proc_t() [1/4]

template<class STATE, class PARAMETERS, size_t NEVENT>

popul_proc_t< STATE, PARAMETERS, NEVENT >::popul_proc_t ( double t0 = 0 )

inline

basic constructor for popul_proc class t0 = initial time

Definition at line 69 of file popul_proc.h.

                               {
    clean();
    next = current = slate_t(t0);
    event = 0;
  };

popul_proc_t() [2/4]

template<class STATE, class PARAMETERS, size_t NEVENT>

popul_proc_t< STATE, PARAMETERS, NEVENT >::popul_proc_t ( raw_t * o )

inline

constructor from serialized binary form

Definition at line 75 of file popul_proc.h.

                          {
    o >> *this;
  };

popul_proc_t() [3/4]

template<class STATE, class PARAMETERS, size_t NEVENT>

popul_proc_t< STATE, PARAMETERS, NEVENT >::popul_proc_t ( const popul_proc_t< STATE, PARAMETERS, NEVENT > & X )

inline

copy constructor

Definition at line 79 of file popul_proc.h.

                                        {
    raw_t *o = new raw_t[X.bytesize()];
    X >> o;
    o >> *this;
    delete[] o;
  };

popul_proc_t() [4/4]

template<class STATE, class PARAMETERS, size_t NEVENT>

popul_proc_t< STATE, PARAMETERS, NEVENT >::popul_proc_t ( popul_proc_t< STATE, PARAMETERS, NEVENT > && )

delete

move constructor

~popul_proc_t()

template<class STATE, class PARAMETERS, size_t NEVENT>

popul_proc_t< STATE, PARAMETERS, NEVENT >::~popul_proc_t ( void )

inline

destructor

Definition at line 99 of file popul_proc.h.

                       {
    clean();
  };

Member Function Documentation

bytesize()

template<class STATE, class PARAMETERS, size_t NEVENT>

size_t popul_proc_t< STATE, PARAMETERS, NEVENT >::bytesize ( void ) const

inline

size of serialized binary form

Definition at line 40 of file popul_proc.h.

                               {
    return 2*sizeof(slate_t) + sizeof(size_t)
      + sizeof(state_t) + sizeof(parameters_t);
  };

Here is the caller graph for this function:

clean()

template<class STATE, class PARAMETERS, size_t NEVENT>

void popul_proc_t< STATE, PARAMETERS, NEVENT >::clean ( void )

inlineprivate

Definition at line 34 of file popul_proc.h.

{};         // memory cleanup

Here is the caller graph for this function:

event_rates()

template<class STATE, class PARAMETERS, size_t NEVENT>

double popul_proc_t< STATE, PARAMETERS, NEVENT >::event_rates	(	double *	rate,
		int	n ) const

compute event rates

jump()

template<class STATE, class PARAMETERS, size_t NEVENT>

virtual void popul_proc_t< STATE, PARAMETERS, NEVENT >::jump ( int e )

pure virtual

makes a jump

Implemented in master_t< lbdp_proc_t, 1 >, master_t< lbdp_proc_t, 1 >, master_t< moran_proc_t, 1 >, master_t< moran_proc_t, 1 >, master_t< s2i2r2_proc_t, 3 >, master_t< s2i2r2_proc_t, 3 >, master_t< seir_proc_t, 2 >, master_t< seir_proc_t, 2 >, master_t< si2r_proc_t, 2 >, master_t< si2r_proc_t, 2 >, master_t< siir_proc_t, 2 >, master_t< siir_proc_t, 2 >, master_t< sir_proc_t, 1 >, master_t< sir_proc_t, 1 >, master_t< strains_proc_t, 3 >, master_t< strains_proc_t, 3 >, master_t< twospecies_proc_t, 3 >, master_t< twospecies_proc_t, 3 >, master_t< twoundead_proc_t, 5 >, and master_t< twoundead_proc_t, 5 >.

Here is the caller graph for this function:

operator=() [1/2]

template<class STATE, class PARAMETERS, size_t NEVENT>

popul_proc_t & popul_proc_t< STATE, PARAMETERS, NEVENT >::operator= ( const popul_proc_t< STATE, PARAMETERS, NEVENT > & X )

inline

copy assignment operator

Definition at line 86 of file popul_proc.h.

                                                    {
    clean();
    raw_t *o = new raw_t[X.bytesize()];
    X >> o;
    o >> *this;
    delete[] o;
    return *this;
  };

operator=() [2/2]

template<class STATE, class PARAMETERS, size_t NEVENT>

popul_proc_t & popul_proc_t< STATE, PARAMETERS, NEVENT >::operator= ( popul_proc_t< STATE, PARAMETERS, NEVENT > && )

delete

move assignment operator

play()

template<class STATE, class PARAMETERS, size_t NEVENT>

int popul_proc_t< STATE, PARAMETERS, NEVENT >::play

(

double

tfin

)

run process to a specified time. return number of events that have occurred.

Definition at line 172 of file popul_proc.h.

{
  int count = 0;
  if (current > tfin)
    err("cannot simulate backward! (current t=%lg, requested t=%lg)",current,tfin);
  while (next < tfin) {
    current = next;
    jump(event);
    update_clocks();
    count++;
    R_CheckUserInterrupt();
  }
  if (next > tfin) current = tfin; // relies on Markov property
  return count;
}

Here is the call graph for this function:

rinit()

template<class STATE, class PARAMETERS, size_t NEVENT>

virtual void popul_proc_t< STATE, PARAMETERS, NEVENT >::rinit ( void )

pure virtual

initialize the state

Implemented in master_t< lbdp_proc_t, 1 >, master_t< lbdp_proc_t, 1 >, master_t< moran_proc_t, 1 >, master_t< moran_proc_t, 1 >, master_t< s2i2r2_proc_t, 3 >, master_t< s2i2r2_proc_t, 3 >, master_t< seir_proc_t, 2 >, master_t< seir_proc_t, 2 >, master_t< si2r_proc_t, 2 >, master_t< si2r_proc_t, 2 >, master_t< siir_proc_t, 2 >, master_t< siir_proc_t, 2 >, master_t< sir_proc_t, 1 >, master_t< sir_proc_t, 1 >, master_t< strains_proc_t, 3 >, master_t< strains_proc_t, 3 >, master_t< twospecies_proc_t, 3 >, master_t< twospecies_proc_t, 3 >, master_t< twoundead_proc_t, 5 >, and master_t< twoundead_proc_t, 5 >.

time()

template<class STATE, class PARAMETERS, size_t NEVENT>

slate_t popul_proc_t< STATE, PARAMETERS, NEVENT >::time ( void ) const

inline

get current time.

Definition at line 107 of file popul_proc.h.

                            {
    return current;
  };

update_clocks()

template<class STATE, class PARAMETERS, size_t NEVENT>

void popul_proc_t< STATE, PARAMETERS, NEVENT >::update_clocks

(

void

)

updates clock and next event

Definition at line 141 of file popul_proc.h.

{
  double rate[nevent];
  double total_rate = event_rates(rate,nevent);
  if (R_FINITE(total_rate)) {
    if (total_rate > 0) {
      next = current+rexp(1/total_rate);
    } else {
      next = R_PosInf;
    }
  } else {
    for (event = 0; event < nevent; event++) {
      if (!R_FINITE(rate[event]))
        Rprintf("in '%s': invalid event rate[%zd]=%lg\n",__func__,event,rate[event]);
    }
    err("in '%s': invalid total event rate=%lg", __func__,total_rate);
  }
  double u = runif(0,total_rate);
  event = 0;
  while (u > rate[event] && event < nevent) {
    if (rate[event] < 0)
      err("in '%s': negative rate[%zd]=%lg",__func__,event,rate[event]); // #nocov
    u -= rate[event];
    event++;
  }
  assert(event < nevent);
}

Here is the call graph for this function:

Here is the caller graph for this function:

update_IVPs()

template<class STATE, class PARAMETERS, size_t NEVENT>

void popul_proc_t< STATE, PARAMETERS, NEVENT >::update_IVPs	(	double *	,
		int	)

set initial-value parameters

update_params()

template<class STATE, class PARAMETERS, size_t NEVENT>

void popul_proc_t< STATE, PARAMETERS, NEVENT >::update_params	(	double *	,
		int	)

set parameters

valid()

template<class STATE, class PARAMETERS, size_t NEVENT>

virtual void popul_proc_t< STATE, PARAMETERS, NEVENT >::valid ( void ) const

inlinevirtual

Definition at line 111 of file popul_proc.h.

{};

yaml()

template<class STATE, class PARAMETERS, size_t NEVENT>

string_t popul_proc_t< STATE, PARAMETERS, NEVENT >::yaml

(

string_t

tab

)

const

machine/human readable info

Friends And Related Symbol Documentation

operator>> [1/2]

template<class STATE, class PARAMETERS, size_t NEVENT>

raw_t * operator>> ( const popul_proc_t< STATE, PARAMETERS, NEVENT > & X, raw_t * o )

friend

binary serialization

Definition at line 45 of file popul_proc.h.

                                                             {
    slate_t A[2]; A[0] = X.current; A[1] = X.next;
    memcpy(o,A,sizeof(A)); o += sizeof(A);
    memcpy(o,&X.event,sizeof(size_t)); o += sizeof(size_t);
    memcpy(o,&X.state,sizeof(state_t)); o += sizeof(state_t);
    memcpy(o,&X.params,sizeof(parameters_t)); o += sizeof(parameters_t);
    return o;
  };

operator>> [2/2]

template<class STATE, class PARAMETERS, size_t NEVENT>

raw_t * operator>> ( raw_t * o, popul_proc_t< STATE, PARAMETERS, NEVENT > & X )

friend

binary deserialization

Definition at line 54 of file popul_proc.h.

                                                       {
    X.clean();
    slate_t A[2];
    memcpy(A,o,sizeof(A)); o += sizeof(A);
    X.current = A[0]; X.next = A[1];
    memcpy(&X.event,o,sizeof(size_t)); o += sizeof(size_t);
    memcpy(&X.state,o,sizeof(state_t)); o += sizeof(state_t);
    memcpy(&X.params,o,sizeof(parameters_t)); o += sizeof(parameters_t);
    return o;
  };

Field Documentation

current

template<class STATE, class PARAMETERS, size_t NEVENT>

slate_t popul_proc_t< STATE, PARAMETERS, NEVENT >::current

protected

Definition at line 28 of file popul_proc.h.

event

template<class STATE, class PARAMETERS, size_t NEVENT>

size_t popul_proc_t< STATE, PARAMETERS, NEVENT >::event

protected

Definition at line 27 of file popul_proc.h.

nevent

template<class STATE, class PARAMETERS, size_t NEVENT>

const size_t popul_proc_t< STATE, PARAMETERS, NEVENT >::nevent = NEVENT

staticprotected

Definition at line 22 of file popul_proc.h.

next

template<class STATE, class PARAMETERS, size_t NEVENT>

slate_t popul_proc_t< STATE, PARAMETERS, NEVENT >::next

protected

Definition at line 26 of file popul_proc.h.

params

template<class STATE, class PARAMETERS, size_t NEVENT>

parameters_t popul_proc_t< STATE, PARAMETERS, NEVENT >::params

protected

Definition at line 30 of file popul_proc.h.

state

template<class STATE, class PARAMETERS, size_t NEVENT>

state_t popul_proc_t< STATE, PARAMETERS, NEVENT >::state

protected

Definition at line 29 of file popul_proc.h.

---

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

• src/popul_proc.h