int tputs (char *string, int nlines, int (*outfun) (int)) { while (*string) outfun (*string++); return 0; }
void Layer::step(vec inp) { double h = m_DT/m_TAU; m_u += h*( - m_u + m_BL + inp ); m_v = outfun(m_u, m_TH, m_AMP); m_output = m_v; }
void Reservoir::step(vec inp) { // unit integration m_u += (m_DT/m_TAU)*( -m_u + inp + m_w*m_v); if (m_NOISE ==true) m_u += (m_DT/m_TAU)*(m_NOISE_STD*randn(m_N) ); m_v = outfun( m_u, m_TH, m_AMP); // truncated activation function if (m_TRUNK == true) m_v = m_v%(m_v>0); m_output = m_v; }
/** @ingroup alignmentGroup @brief Dump the alignment to a file of format \a fileFormat Dumps the alignment contained in \a alignmentData to file \a filename of type \a fileFormat. @note If \a filename exists, all contents will be erased @param alignmentData Alignment data structure @param fileFormat Format of output file. Can take the value \b PLL_FORMAT_PHYLIP or \b PLL_FORMAT_FASTA @param filename Output filename @return Returns \b PLL_TRUE on success, otherwise \b PLL_FALSE. */ int pllAlignmentDataDumpFile (pllAlignmentData * alignmentData, int fileFormat, const char * filename) { FILE * fp; void (*outfun)(FILE *, pllAlignmentData *); if (fileFormat != PLL_FORMAT_PHYLIP && fileFormat != PLL_FORMAT_FASTA) return (PLL_FALSE); outfun = (fileFormat == PLL_FORMAT_PHYLIP) ? dump_phylip_content : dump_fasta_content; fp = fopen (filename, "w"); if (!fp) return (PLL_FALSE); /* if PHYLIP print the silly header at the beginning */ if (fileFormat == PLL_FORMAT_PHYLIP) { fprintf (fp, "%d %d\n", alignmentData->sequenceCount, alignmentData->sequenceLength); } outfun(fp, alignmentData); fclose (fp); return (PLL_TRUE); }
SEXP hitrun(SEXP alpha, SEXP initial, SEXP nbatch, SEXP blen, SEXP nspac, SEXP origin, SEXP basis, SEXP amat, SEXP bvec, SEXP outmat, SEXP debug) { if (! isReal(alpha)) error("argument \"alpha\" must be type double"); if (! isReal(initial)) error("argument \"initial\" must be type double"); if (! isInteger(nbatch)) error("argument \"nbatch\" must be type integer"); if (! isInteger(blen)) error("argument \"blen\" must be type integer"); if (! isInteger(nspac)) error("argument \"nspac\" must be type integer"); if (! isReal(origin)) error("argument \"origin\" must be type double"); if (! isReal(basis)) error("argument \"basis\" must be type double"); if (! isReal(amat)) error("argument \"amat\" must be type double"); if (! isReal(bvec)) error("argument \"bvec\" must be type double"); if (! (isNull(outmat) | isReal(outmat))) error("argument \"outmat\" must be type double or NULL"); if (! isLogical(debug)) error("argument \"debug\" must be logical"); if (! isMatrix(basis)) error("argument \"basis\" must be matrix"); if (! isMatrix(amat)) error("argument \"amat\" must be matrix"); if (! (isNull(outmat) | isMatrix(outmat))) error("argument \"outmat\" must be matrix or NULL"); int dim_oc = LENGTH(alpha); int dim_nc = LENGTH(initial); int ncons = nrows(amat); if (LENGTH(nbatch) != 1) error("argument \"nbatch\" must be scalar"); if (LENGTH(blen) != 1) error("argument \"blen\" must be scalar"); if (LENGTH(nspac) != 1) error("argument \"nspac\" must be scalar"); if (LENGTH(origin) != dim_oc) error("length(origin) != length(alpha)"); if (nrows(basis) != dim_oc) error("nrow(basis) != length(alpha)"); if (ncols(basis) != dim_nc) error("ncol(basis) != length(initial)"); if (ncols(amat) != dim_nc) error("ncol(amat) != length(initial)"); if (LENGTH(bvec) != ncons) error("length(bvec) != nrow(amat)"); if (LENGTH(debug) != 1) error("argument \"debug\" must be scalar"); int dim_out = dim_oc; if (! isNull(outmat)) { dim_out = nrows(outmat); if (ncols(outmat) != dim_oc) error("ncol(outmat) != length(alpha)"); } int int_nbatch = INTEGER(nbatch)[0]; int int_blen = INTEGER(blen)[0]; int int_nspac = INTEGER(nspac)[0]; int int_debug = LOGICAL(debug)[0]; double *dbl_star_alpha = REAL(alpha); double *dbl_star_initial = REAL(initial); double *dbl_star_origin = REAL(origin); double *dbl_star_basis = REAL(basis); double *dbl_star_amat = REAL(amat); double *dbl_star_bvec = REAL(bvec); int has_outmat = isMatrix(outmat); double *dbl_star_outmat = 0; if (has_outmat) dbl_star_outmat = REAL(outmat); if (int_nbatch <= 0) error("argument \"nbatch\" must be positive"); if (int_blen <= 0) error("argument \"blen\" must be positive"); if (int_nspac <= 0) error("argument \"nspac\" must be positive"); check_finite(dbl_star_alpha, dim_oc, "alpha"); check_positive(dbl_star_alpha, dim_oc, "alpha"); check_finite(dbl_star_initial, dim_nc, "initial"); check_finite(dbl_star_origin, dim_oc, "origin"); check_finite(dbl_star_basis, dim_oc * dim_nc, "basis"); check_finite(dbl_star_amat, ncons * dim_nc, "amat"); check_finite(dbl_star_bvec, ncons, "bvec"); if (has_outmat) check_finite(dbl_star_outmat, dim_out * dim_oc, "outmat"); double *state = (double *) R_alloc(dim_nc, sizeof(double)); double *proposal = (double *) R_alloc(dim_nc, sizeof(double)); double *batch_buffer = (double *) R_alloc(dim_out, sizeof(double)); double *out_buffer = (double *) R_alloc(dim_out, sizeof(double)); memcpy(state, dbl_star_initial, dim_nc * sizeof(double)); logh_setup(dbl_star_alpha, dbl_star_origin, dbl_star_basis, dim_oc, dim_nc); double current_log_dens = logh(state); out_setup(dbl_star_origin, dbl_star_basis, dbl_star_outmat, dim_oc, dim_nc, dim_out, has_outmat); SEXP result, resultnames, path, save_initial, save_final; if (! int_debug) { PROTECT(result = allocVector(VECSXP, 3)); PROTECT(resultnames = allocVector(STRSXP, 3)); } else { PROTECT(result = allocVector(VECSXP, 11)); PROTECT(resultnames = allocVector(STRSXP, 11)); } PROTECT(path = allocMatrix(REALSXP, dim_out, int_nbatch)); SET_VECTOR_ELT(result, 0, path); PROTECT(save_initial = duplicate(initial)); SET_VECTOR_ELT(result, 1, save_initial); UNPROTECT(2); SET_STRING_ELT(resultnames, 0, mkChar("batch")); SET_STRING_ELT(resultnames, 1, mkChar("initial")); SET_STRING_ELT(resultnames, 2, mkChar("final")); if (int_debug) { SEXP spath, ppath, zpath, u1path, u2path, s1path, s2path, gpath; int nn = int_nbatch * int_blen * int_nspac; PROTECT(spath = allocMatrix(REALSXP, dim_nc, nn)); SET_VECTOR_ELT(result, 3, spath); PROTECT(ppath = allocMatrix(REALSXP, dim_nc, nn)); SET_VECTOR_ELT(result, 4, ppath); PROTECT(zpath = allocMatrix(REALSXP, dim_nc, nn)); SET_VECTOR_ELT(result, 5, zpath); PROTECT(u1path = allocVector(REALSXP, nn)); SET_VECTOR_ELT(result, 6, u1path); PROTECT(u2path = allocVector(REALSXP, nn)); SET_VECTOR_ELT(result, 7, u2path); PROTECT(s1path = allocVector(REALSXP, nn)); SET_VECTOR_ELT(result, 8, s1path); PROTECT(s2path = allocVector(REALSXP, nn)); SET_VECTOR_ELT(result, 9, s2path); PROTECT(gpath = allocVector(REALSXP, nn)); SET_VECTOR_ELT(result, 10, gpath); UNPROTECT(8); SET_STRING_ELT(resultnames, 3, mkChar("current")); SET_STRING_ELT(resultnames, 4, mkChar("proposal")); SET_STRING_ELT(resultnames, 5, mkChar("z")); SET_STRING_ELT(resultnames, 6, mkChar("u1")); SET_STRING_ELT(resultnames, 7, mkChar("u2")); SET_STRING_ELT(resultnames, 8, mkChar("s1")); SET_STRING_ELT(resultnames, 9, mkChar("s2")); SET_STRING_ELT(resultnames, 10, mkChar("log.green")); } namesgets(result, resultnames); UNPROTECT(1); GetRNGstate(); if (current_log_dens == R_NegInf) error("log unnormalized density -Inf at initial state"); for (int ibatch = 0, k = 0; ibatch < int_nbatch; ibatch++) { for (int i = 0; i < dim_out; i++) batch_buffer[i] = 0.0; for (int jbatch = 0; jbatch < int_blen; jbatch++) { double proposal_log_dens; for (int ispac = 0; ispac < int_nspac; ispac++) { /* Note: should never happen! */ if (current_log_dens == R_NegInf) error("log density -Inf at current state"); double u1 = R_NaReal; double u2 = R_NaReal; double smax = R_NaReal; double smin = R_NaReal; double z[dim_nc]; propose(state, proposal, dbl_star_amat, dbl_star_bvec, dim_nc, ncons, z, &smax, &smin, &u1); proposal_log_dens = logh(proposal); int accept = FALSE; if (proposal_log_dens != R_NegInf) { if (proposal_log_dens >= current_log_dens) { accept = TRUE; } else { double green = exp(proposal_log_dens - current_log_dens); u2 = unif_rand(); accept = u2 < green; } } if (int_debug) { int l = ispac + int_nspac * (jbatch + int_blen * ibatch); int lbase = l * dim_nc; SEXP spath = VECTOR_ELT(result, 3); SEXP ppath = VECTOR_ELT(result, 4); SEXP zpath = VECTOR_ELT(result, 5); SEXP u1path = VECTOR_ELT(result, 6); SEXP u2path = VECTOR_ELT(result, 7); SEXP s1path = VECTOR_ELT(result, 8); SEXP s2path = VECTOR_ELT(result, 9); SEXP gpath = VECTOR_ELT(result, 10); for (int lj = 0; lj < dim_nc; lj++) { REAL(spath)[lbase + lj] = state[lj]; REAL(ppath)[lbase + lj] = proposal[lj]; REAL(zpath)[lbase + lj] = z[lj]; } REAL(u1path)[l] = u1; REAL(u2path)[l] = u2; REAL(s1path)[l] = smin; REAL(s2path)[l] = smax; REAL(gpath)[l] = proposal_log_dens - current_log_dens; } if (accept) { memcpy(state, proposal, dim_nc * sizeof(double)); current_log_dens = proposal_log_dens; } } /* end of inner loop (one iteration) */ outfun(state, out_buffer); for (int j = 0; j < dim_out; j++) batch_buffer[j] += out_buffer[j]; } /* end of middle loop (one batch) */ for (int j = 0; j < dim_out; j++, k++) REAL(path)[k] = batch_buffer[j] / int_blen; } /* end of outer loop */ PutRNGstate(); PROTECT(save_final = allocVector(REALSXP, dim_nc)); memcpy(REAL(save_final), state, dim_nc * sizeof(double)); SET_VECTOR_ELT(result, 2, save_final); UNPROTECT(5); return result; }