generics.h

Go to the documentation of this file.

#ifndef _GENERICS_H_
#define _GENERICS_H_
 
#include "internal.h"
 
template <class TYPE>
SEXP ndeme (TYPE& X) {
  return ScalarInteger(X.ndeme());
}
SEXP ndeme (TYPE& X) {…}
 
template <class TYPE>
SEXP nsample (TYPE& X) {
  return ScalarInteger(X.nsample());
}
SEXP nsample (TYPE& X) {…}
 
template <class TYPE>
SEXP timezero (TYPE& X) {
  return ScalarReal(X.timezero());
}
SEXP timezero (TYPE& X) {…}
 
template <class TYPE>
SEXP time (TYPE& X) {
  return ScalarReal(X.time());
}
SEXP time (TYPE& X) {…}

template <class TYPE>
SEXP serial (const TYPE& X) {
  SEXP out;
  PROTECT(out = NEW_RAW(X.bytesize()));
  X >> RAW(out);
  UNPROTECT(1);
  return out;
}
SEXP serial (const TYPE& X) {…}

template <class TYPE>
SEXP yaml (const TYPE& X) {
  return mkString(X.yaml().c_str());
}
SEXP yaml (const TYPE& X) {…}

template <class TYPE>
SEXP describe (const TYPE& X) {
  return mkString(X.describe().c_str());
}
SEXP describe (const TYPE& X) {…}

template <class TYPE>
SEXP structure (const TYPE& X) {
  return X.structure();
}
SEXP structure (const TYPE& X) {…}

template <class TYPE>
SEXP newick (const TYPE& X) {
  return mkString(X.newick().c_str());
}
SEXP newick (const TYPE& X) {…}

template <class TYPE>
SEXP lineage_count (const TYPE& G) {
  return G.lineage_count();
}
SEXP lineage_count (const TYPE& G) {…}

template <class TYPE>
SEXP gendat (const TYPE& G) {
  return G.gendat();
}
SEXP gendat (const TYPE& G) {…}

template<class TYPE>
SEXP make (SEXP Params, SEXP IVPs, SEXP T0) {
  SEXP o;
  PROTECT(Params = AS_NUMERIC(Params));
  PROTECT(IVPs = AS_NUMERIC(IVPs));
  PROTECT(T0 = AS_NUMERIC(T0));
  GetRNGstate();
  TYPE X = *REAL(T0);
  X.update_params(REAL(Params),LENGTH(Params));
  X.update_IVPs(REAL(IVPs),LENGTH(IVPs));
  X.rinit();
  X.update_clocks();
  PutRNGstate();
  PROTECT(o = serial(X));
  UNPROTECT(4);
  return o;
}
SEXP make (SEXP Params, SEXP IVPs, SEXP T0) {…}

template<class TYPE>
SEXP revive (SEXP State, SEXP Params) {
  SEXP o;
  TYPE X = State;
  PROTECT(Params = AS_NUMERIC(Params));
  X.update_params(REAL(Params),LENGTH(Params));
  PROTECT(o = serial(X));
  UNPROTECT(2);
  return o;
}
SEXP revive (SEXP State, SEXP Params) {…}

template<class TYPE>
SEXP run (SEXP State, SEXP Tout) {
  SEXP out;
  TYPE X = State;
  PROTECT(Tout = AS_NUMERIC(Tout));
  GetRNGstate();
  X.valid();
  X.play(*REAL(Tout));
  PutRNGstate();
  PROTECT(out = serial(X));
  UNPROTECT(2);
  return out;
}
SEXP run (SEXP State, SEXP Tout) {…}

template <class TYPE>
SEXP genealogy (SEXP State) {
  TYPE A = State;
  SEXP out;
  PROTECT(out = serial(A.geneal));
  SET_ATTR(out,install("class"),mkString("gpgen"));
  UNPROTECT(1);
  return out;
}
SEXP genealogy (SEXP State) {…}
 
#define MAKEFN(X,TYPE) SEXP make ## X (SEXP Params, SEXP IVPs, SEXP T0) { \
    return make<TYPE>(Params,IVPs,T0);                                  \
  }                                                                     \
 
#define MAKEFN(X,TYPE) SEXP make ## X (SEXP Params, SEXP IVPs, SEXP T0) { \ …
#define REVIVEFN(X,TYPE) SEXP revive ## X (SEXP State, SEXP Params) {   \
    return revive<TYPE>(State,Params);                                  \
  }                                                                     \
 
#define REVIVEFN(X,TYPE) SEXP revive ## X (SEXP State, SEXP Params) {   \ …
#define RUNFN(X,TYPE) SEXP run ## X (SEXP State, SEXP Times) {  \
    return run<TYPE>(State,Times);                              \
  }                                                             \
 
#define RUNFN(X,TYPE) SEXP run ## X (SEXP State, SEXP Times) {  \ …
#define GENEALFN(X,TYPE) SEXP geneal ## X (SEXP State) {        \
    return genealogy<TYPE>(State);                              \
  }                                                             \
 
#define GENEALFN(X,TYPE) SEXP geneal ## X (SEXP State) {        \ …
#define YAMLFN(X,TYPE) SEXP yaml ## X (SEXP State) {    \
    return yaml<TYPE>(State);                           \
  }                                                     \
 
#define YAMLFN(X,TYPE) SEXP yaml ## X (SEXP State) {    \ …
#define GENERICS(X,TYPE)                        \
  extern "C" {                                  \
                                                \
    MAKEFN(X,TYPE)                              \
                                                \
    REVIVEFN(X,TYPE)                            \
                                                \
    RUNFN(X,TYPE)                               \
                                                \
    GENEALFN(X,TYPE)                            \
                                                \
    YAMLFN(X,TYPE)                              \
                                                \
  }                                             \
 
#define GENERICS(X,TYPE)                        \ …
#endif