<div>
<p> </p>
<h1> Converting to NIMBLE from JAGS, OpenBUGS or WinBUGS </h1>
<p> NIMBLE is a hierarchical modeling package that uses nearly the same modeling language as the popular MCMC packages WinBUGS, OpenBUGS and JAGS. NIMBLE makes the modeling language extensible — you can add distributions and functions — and also allows customization of MCMC or other algorithms that use models. Here is a quick summary of steps to convert existing code from WinBUGS, OpenBUGS or JAGS to NIMBLE. For more information, see examples on <a rel="nofollow" href="http://r-nimble.org/" target="_blank">r-nimble.org</a> or the <a rel="nofollow" href="https://r-nimble.org/manuals/NimbleUserManual.pdf" target="_blank">NIMBLE User Manual</a>. </p>
<h2> Main steps for converting existing code </h2>
<p> These steps assume you are familiar with running WinBUGS, OpenBUGS or JAGS through an R package such as R2WinBUGS, R2jags, rjags, or jagsUI. </p>
<ol>
<li>Wrap your model code in <tt>nimbleCode({})</tt>, directly in R.</li>
<ul>
<li>This replaces the step of writing or generating a separate file containing the model code.</li>
<li>Alternatively, you can read standard JAGS- and BUGS-formatted code and data files using<br>
<tt>readBUGSmodel</tt>.</li>
</ul>
<li> Provide information about missing or empty indices </li>
<ul>
<li> Example: If <tt>x</tt> is a matrix, you must write at least <tt>x[,]</tt> to show it has two dimensions.</li>
<li> If other declarations make the size of <tt>x</tt> clear, <tt>x[,]</tt> will work in some circumstances.</li>
<li> If not, either provide index ranges (e.g. <tt>x[1:n, 1:m]</tt>) or use the <tt>dimensions</tt> argument to <tt>nimbleModel</tt> to provide the sizes in each dimension.</li>
</ul>
<li> Choose how you want to run MCMC. </li>
<ul>
<li> Use <tt>nimbleMCMC()</tt> as the just-do-it way to run an MCMC. This will take all steps to<br>
set up and run an MCMC using NIMBLE’s default configuration.</li>
<li> To use NIMBLE’s full flexibility: build the model, configure and build the MCMC, and compile both the model and MCMC. Then run the MCMC via <tt>runMCMC</tt> or by calling the <tt>run</tt> function of the compiled MCMC. See the NIMBLE User Manual to learn more about what you can do.</li>
</ul>
</ol>
<p> See below for a list of some more nitty-gritty additional steps you may need to consider for some models. </p>
<h2> Example: An animal abundance model </h2>
<p> This example is adapted from Chapter 6, Section 6.4 of <a rel="nofollow" href="https://www.elsevier.com/books/applied-hierarchical-modeling-in-ecology-analysis-of-distribution-abundance-and-species-richness-in-r-and-bugs/kery/978-0-12-801378-6" target="_blank">Applied Hierarchical Modeling in Ecology: Analysis of distribution, abundance and species richness in R and BUGS. Volume I: Prelude and Static Models</a> by Marc Kéry and J. Andrew Royle (2015, Academic Press). The <a rel="nofollow" href="https://www.mbr-pwrc.usgs.gov/pubanalysis/keryroylebook/" target="_blank">book’s web site</a> provides code for its examples. </p>
<h3> Original code </h3>
<p> The original model code looks like this: </p>
<pre><tt>
cat(file = &quot;model2.txt&quot;,&quot;
model {
# Priors
for(k in 1:3){ # Loop over 3 levels of hab or time factors
alpha0[k] ~ dunif(-10, 10) # Detection intercepts
alpha1[k] ~ dunif(-10, 10) # Detection slopes
beta0[k] ~ dunif(-10, 10) # Abundance intercepts
beta1[k] ~ dunif(-10, 10) # Abundance slopes
}
# Likelihood
# Ecological model for true abundance
for (i in 1:M){
N[i] ~ dpois(lambda[i])
log(lambda[i]) &lt;-beta0[hab[i]] + beta1[hab[i]] * vegHt[i]
# Some intermediate derived quantities
critical[i] &lt;-step(2-N[i])# yields 1 whenever N is 2 or less
z[i] &lt;-step(N[i]-0.5) # Indicator for occupied site
# Observation model for replicated counts
for (j in 1:J){
C[i,j] ~ dbin(p[i,j], N[i])
logit(p[i,j]) &lt;-alpha0[j] + alpha1[j] * wind[i,j]
}
}
# Derived quantities
Nocc &lt;-sum(z[]) # Number of occupied sites among sample of M
Ntotal &lt;-sum(N[]) # Total population size at M sites combined
Nhab[1] &lt;-sum(N[1:33]) # Total abundance for sites in hab A
Nhab[2] &lt;-sum(N[34:66]) # Total abundance for sites in hab B
Nhab[3] &lt;-sum(N[67:100])# Total abundance for sites in hab C
for(k in 1:100){ # Predictions of lambda and p ...
for(level in 1:3){ # ... for each level of hab and time factors
lam.pred[k, level] &lt;-exp(beta0[level] + beta1[level] * XvegHt[k])
logit(p.pred[k, level]) &lt;-alpha0[level] + alpha1[level] * Xwind[k]
}
}
N.critical &lt;-sum(critical[]) # Number of populations with critical size
}&quot;)
</tt></pre>
<h3>Brief summary of the model</h3>
<p> This is known as an &quot;N-mixture&quot; model in ecology. The details aren't really important for illustrating the mechanics of converting this model to NIMBLE, but here is a brief summary anyway. The latent abundances <tt>N[i]</tt> at sites <tt>i = 1...M</tt> are assumed to follow a Poisson. The j-th count at the i-th site, <tt>C[i, j]</tt>, is assumed to follow a binomial with detection probability <tt>p[i, j]</tt>. The abundance at each site depends on a habitat-specific intercept and coefficient for vegetation height, with a log link. The detection probability for each sampling occasion depends on a date-specific intercept and coefficient for wind speed. Kéry and Royle concocted this as a simulated example to illustrate the hierarchical modeling approaches for estimating abundance from count data on repeated visits to multiple sites. </p>
<h2>NIMBLE version of the model code</h2>
<p>Here is the model converted for use in NIMBLE. In this case, the only changes to the code are to insert some missing index ranges (see comments).</p>
<div>
<div>
<div>
<pre><span>library</span><span>(nimble)</span>
<span>Section6p4_code</span> <span>&lt;-</span> <span>nimbleCode</span><span>( {</span>
    <span># Priors</span>
    <span>for</span><span>(k</span> <span>in</span> <span>1</span><span>:</span><span>3</span><span>) {</span>                <span># Loop over 3 levels of hab or time factors</span>
      <span>alpha0[k]</span> <span>~</span> <span>dunif</span><span>(</span><span>-</span><span>10</span><span>,</span> <span>10</span><span>)</span> <span># Detection intercepts</span>
      <span>alpha1[k]</span> <span>~</span> <span>dunif</span><span>(</span><span>-</span><span>10</span><span>,</span> <span>10</span><span>)</span> <span># Detection slopes</span>
      <span>beta0[k]</span> <span>~</span> <span>dunif</span><span>(</span><span>-</span><span>10</span><span>,</span> <span>10</span><span>)</span>  <span># Abundance intercepts</span>
      <span>beta1[k]</span> <span>~</span> <span>dunif</span><span>(</span><span>-</span><span>10</span><span>,</span> <span>10</span><span>)</span>  <span># Abundance slopes</span>
    <span>}</span>

    <span># Likelihood</span>
    <span># Ecological model for true abundance</span>
    <span>for</span> <span>(i</span> <span>in</span> <span>1</span><span>:</span><span>M){</span>
      <span>N[i]</span> <span>~</span> <span>dpois</span><span>(lambda[i])</span>
      <span>log</span><span>(lambda[i])</span> <span>&lt;-</span> <span>beta0[hab[i]]</span> <span>+</span> <span>beta1[hab[i]]</span> <span>*</span> <span>vegHt[i]</span>
      <span># Some intermediate derived quantities</span>
      <span>critical[i]</span> <span>&lt;-</span> <span>step</span><span>(</span><span>2</span><span>-</span><span>N[i])</span><span># yields 1 whenever N is 2 or less</span>
      <span>z[i]</span> <span>&lt;-</span> <span>step</span><span>(N[i]</span><span>-</span><span>0.5</span><span>)</span>     <span># Indicator for occupied site</span>
      <span># Observation model for replicated counts</span>
      <span>for</span> <span>(j</span> <span>in</span> <span>1</span><span>:</span><span>J){</span>
        <span>C[i,j]</span> <span>~</span> <span>dbin</span><span>(p[i,j], N[i])</span>
        <span>logit</span><span>(p[i,j])</span> <span>&lt;-</span> <span>alpha0[j]</span> <span>+</span> <span>alpha1[j]</span> <span>*</span> <span>wind[i,j]</span>
        <span>}</span>
    <span>}</span>

    <span># Derived quantities; unnececssary when running for inference purpose</span>
    <span># NIMBLE: We have filled in indices in the next two lines.</span>
    <span>Nocc</span> <span>&lt;-</span> <span>sum</span><span>(z[</span><span>1</span><span>:</span><span>100</span><span>])</span>         <span># Number of occupied sites among sample of M</span>
    <span>Ntotal</span> <span>&lt;-</span> <span>sum</span><span>(N[</span><span>1</span><span>:</span><span>100</span><span>])</span>       <span># Total population size at M sites combined</span>
    <span>Nhab[</span><span>1</span><span>]</span> <span>&lt;-</span> <span>sum</span><span>(N[</span><span>1</span><span>:</span><span>33</span><span>])</span>  <span># Total abundance for sites in hab A</span>
    <span>Nhab[</span><span>2</span><span>]</span> <span>&lt;-</span> <span>sum</span><span>(N[</span><span>34</span><span>:</span><span>66</span><span>])</span> <span># Total abundance for sites in hab B</span>
    <span>Nhab[</span><span>3</span><span>]</span> <span>&lt;-</span> <span>sum</span><span>(N[</span><span>67</span><span>:</span><span>100</span><span>])</span><span># Total abundance for sites in hab C</span>
    <span>for</span><span>(k</span> <span>in</span> <span>1</span><span>:</span><span>100</span><span>){</span>         <span># Predictions of lambda and p ...</span>
      <span>for</span><span>(level</span> <span>in</span> <span>1</span><span>:</span><span>3</span><span>){</span>    <span># ... for each level of hab and time factors</span>
        <span>lam.pred[k, level]</span> <span>&lt;-</span> <span>exp</span><span>(beta0[level]</span> <span>+</span> <span>beta1[level]</span> <span>*</span> <span>XvegHt[k])</span>
        <span>logit</span><span>(p.pred[k, level])</span> <span>&lt;-</span> <span>alpha0[level]</span> <span>+</span> <span>alpha1[level]</span> <span>*</span> <span>Xwind[k]</span>
        <span>}</span>
      <span>}</span>
    <span># NIMBLE: We have filled in indices in the next line. </span>
    <span>N.critical</span> <span>&lt;-</span> <span>sum</span><span>(critical[</span><span>1</span><span>:</span><span>100</span><span>])</span> <span># Number of populations with critical size</span>
  <span>})</span>
</pre>
</div>
</div>
</div>
<h2> Simulated data </h2>
<p> To carry this example further, we need some simulated data. Kéry and Royle provide separate code to do this. With NIMBLE we could use the model itself to simulate data rather than writing separate simulation code. But for our goals here, we simply copy Kéry and Royle's simulation code, and we compact it somewhat: </p>
<div>
<div>
<div>
<pre><span># Code from Kery and Royle (2015)</span>
<span># Choose sample sizes and prepare obs. data array y</span>
<span>set.seed</span><span>(</span><span>1</span><span>)</span>                   <span># So we all get same data set</span>
<span>M</span> <span>&lt;-</span> <span>100</span>                      <span># Number of sites</span>
<span>J</span> <span>&lt;-</span> <span>3</span>                        <span># Number of repeated abundance measurements</span>
<span>C</span> <span>&lt;-</span> <span>matrix</span><span>(</span><span>NA</span><span>,</span> <span>nrow</span> <span>= M,</span> <span>ncol</span> <span>= J)</span> <span># to contain the observed data</span>

<span># Create a covariate called vegHt</span>
<span>vegHt</span> <span>&lt;-</span> <span>sort</span><span>(</span><span>runif</span><span>(M,</span> <span>-</span><span>1</span><span>,</span> <span>1</span><span>))</span> <span># sort for graphical convenience</span>

<span># Choose parameter values for abundance model and compute lambda</span>
<span>beta0</span> <span>&lt;-</span> <span>0</span>                    <span># Log-scale intercept</span>
<span>beta1</span> <span>&lt;-</span> <span>2</span>                    <span># Log-scale slope for vegHt</span>
<span>lambda</span> <span>&lt;-</span> <span>exp</span><span>(beta0</span> <span>+</span> <span>beta1</span> <span>*</span> <span>vegHt)</span> <span># Expected abundance</span>

<span># Draw local abundance</span>
<span>N</span> <span>&lt;-</span> <span>rpois</span><span>(M, lambda)</span>

<span># Create a covariate called wind</span>
<span>wind</span> <span>&lt;-</span> <span>array</span><span>(</span><span>runif</span><span>(M</span> <span>*</span> <span>J,</span> <span>-</span><span>1</span><span>,</span> <span>1</span><span>),</span> <span>dim</span> <span>=</span> <span>c</span><span>(M, J))</span>

<span># Choose parameter values for measurement error model and compute detectability</span>
<span>alpha0</span> <span>&lt;-</span> <span>-</span><span>2</span>                        <span># Logit-scale intercept</span>
<span>alpha1</span> <span>&lt;-</span> <span>-</span><span>3</span>                        <span># Logit-scale slope for wind</span>
<span>p</span> <span>&lt;-</span> <span>plogis</span><span>(alpha0</span> <span>+</span> <span>alpha1</span> <span>*</span> <span>wind)</span> <span># Detection probability</span>

<span># Take J = 3 abundance measurements at each site</span>
<span>for</span><span>(j</span> <span>in</span> <span>1</span><span>:</span><span>J) {</span>
  <span>C[,j]</span> <span>&lt;-</span> <span>rbinom</span><span>(M, N, p[,j])</span>
<span>}</span>

<span># Create factors</span>
<span>time</span> <span>&lt;-</span> <span>matrix</span><span>(</span><span>rep</span><span>(</span><span>as.character</span><span>(</span><span>1</span><span>:</span><span>J), M),</span> <span>ncol</span> <span>= J,</span> <span>byrow</span> <span>=</span> <span>TRUE</span><span>)</span>
<span>hab</span> <span>&lt;-</span> <span>c</span><span>(</span><span>rep</span><span>(</span><span>&quot;A&quot;</span><span>,</span> <span>33</span><span>),</span> <span>rep</span><span>(</span><span>&quot;B&quot;</span><span>,</span> <span>33</span><span>),</span> <span>rep</span><span>(</span><span>&quot;C&quot;</span><span>,</span> <span>34</span><span>))</span>  <span># assumes M = 100</span>

<span># Bundle data</span>
<span># NIMBLE: For full flexibility, we could separate this list</span>
<span># into constants and data lists. For simplicity we will keep</span>
<span># it as one list to be provided as the &quot;constants&quot; argument.</span>
<span># See comments about how we would split it if desired.</span>
<span>win.data</span> <span>&lt;-</span> <span>list</span><span>(</span>
    <span>## NIMBLE: C is the actual data</span>
    <span>C</span> <span>= C,</span>
    <span>## NIMBLE: Covariates can be data or constants</span>
    <span>## If they are data, you could modify them after the model is built</span>
    <span>wind</span> <span>= wind,</span>
    <span>vegHt</span> <span>= vegHt,</span>
    <span>XvegHt</span> <span>=</span> <span>seq</span><span>(</span><span>-</span><span>1</span><span>,</span> <span>1</span><span>,,</span> <span>100</span><span>),</span> <span># Used only for derived quantities</span>
    <span>Xwind</span> <span>=</span> <span>seq</span><span>(</span><span>-</span><span>1</span><span>,</span> <span>1</span><span>,,</span><span>100</span><span>),</span>   <span># Used only for derived quantities</span>
    <span>## NIMBLE: The rest of these are constants, needed for model definition</span>
    <span>## We can provide them in the same list and NIMBLE will figure it out.</span>
    <span>M</span> <span>=</span> <span>nrow</span><span>(C),</span>
    <span>J</span> <span>=</span> <span>ncol</span><span>(C),</span>
    <span>hab</span> <span>=</span> <span>as.numeric</span><span>(</span><span>factor</span><span>(hab))</span>
<span>)</span>
</pre>
</div>
</div>
</div>
<h2> Initial values </h2>
<p> Next we need to set up initial values and choose parameters to monitor in the MCMC output. To do so we will again directly use Kéry and Royle's code.</p>
<div>
<div>
<div>
<pre><span>Nst</span> <span>&lt;-</span> <span>apply</span><span>(C,</span> <span>1</span><span>, max)</span><span>+</span><span>1</span>   <span># Important to give good inits for latent N</span>
<span>inits</span> <span>&lt;-</span> <span>function</span><span>()</span> <span>list</span><span>(</span><span>N</span> <span>= Nst,</span>
                         <span>alpha0</span> <span>=</span> <span>rnorm</span><span>(</span><span>3</span><span>),</span>
                         <span>alpha1</span> <span>=</span> <span>rnorm</span><span>(</span><span>3</span><span>),</span>
                         <span>beta0</span> <span>=</span> <span>rnorm</span><span>(</span><span>3</span><span>),</span>
                         <span>beta1</span> <span>=</span> <span>rnorm</span><span>(</span><span>3</span><span>))</span>

<span># Parameters monitored</span>
<span># could also estimate N, bayesian counterpart to BUPs before: simply add &quot;N&quot; to the list</span>
<span>params</span> <span>&lt;-</span> <span>c</span><span>(</span><span>&quot;alpha0&quot;</span><span>,</span> <span>&quot;alpha1&quot;</span><span>,</span> <span>&quot;beta0&quot;</span><span>,</span> <span>&quot;beta1&quot;</span><span>,</span> <span>&quot;Nocc&quot;</span><span>,</span> <span>&quot;Ntotal&quot;</span><span>,</span> <span>&quot;Nhab&quot;</span><span>,</span> <span>&quot;N.critical&quot;</span><span>,</span> <span>&quot;lam.pred&quot;</span><span>,</span> <span>&quot;p.pred&quot;</span><span>)</span>
</pre>
</div>
</div>
</div>
<h2> Run MCMC with <tt>nimbleMCMC</tt> </h2>
<p> Now we are ready to run an MCMC in nimble. We will run only one chain, using the same settings as Kéry and Royle. </p>
<div>
<div>
<div>
<pre><span>samples</span> <span>&lt;-</span> <span>nimbleMCMC</span><span>(</span>
    <span>code</span> <span>= Section6p4_code,</span>
    <span>constants</span> <span>= win.data,</span> <span>## provide the combined data &amp; constants as constants</span>
    <span>inits</span> <span>= inits,</span>
    <span>monitors</span> <span>= params,</span>
    <span>niter</span> <span>=</span> <span>22000</span><span>,</span>
    <span>nburnin</span> <span>=</span> <span>2000</span><span>,</span>
    <span>thin</span> <span>=</span> <span>10</span><span>)</span>
</pre>
</div>
<div>
<pre>## defining model...
</pre>
</div>
<div>
<pre>## Detected C as data within 'constants'.
</pre>
</div>
<div>
<pre>## Adding C as data for building model.
</pre>
</div>
<div>
<pre>## building model...
</pre>
</div>
<div>
<pre>## setting data and initial values...
</pre>
</div>
<div>
<pre>## running calculate on model (any error reports that follow may simply reflect missing values in model variables) ... 
## checking model sizes and dimensions...
## checking model calculations...
## model building finished.
## compiling... this may take a minute. Use 'showCompilerOutput = TRUE' to see C++ compiler details.
## compilation finished.
## runMCMC's handling of nburnin changed in nimble version 0.6-11. Previously, nburnin samples were discarded *post-thinning*.  Now nburnin samples are discarded *pre-thinning*.  The number of samples returned will be floor((niter-nburnin)/thin).
## running chain 1...
</pre>
</div>
<div>
<pre>## |-------------|-------------|-------------|-------------|
## |-------------------------------------------------------|
</pre>
</div>
</div>
</div>
<h2> Work with the samples </h2>
<p> Finally we want to look at our samples. NIMBLE returns samples as a simple matrix with named columns. There are numerous packages for processing MCMC output. If you want to use the <tt>coda</tt> package, you can convert a matrix to a coda mcmc object like this: </p>
<div>
<div>
<div>
<pre><span>library</span><span>(coda)</span>
<span>coda.samples</span> <span>&lt;-</span> <span>as.mcmc</span><span>(samples)</span>
</pre>
</div>
</div>
</div>
<p>Alternatively, if you call <tt>nimbleMCMC</tt> with the argument <tt>samplesAsCodaMCMC = TRUE</tt>, the samples will be returned as a coda object.</p>
<p>To show that MCMC really happened, here is a plot of <tt>N.critical</tt>:</p>
<div>
<div>
<div>
<pre><span>plot</span><span>(</span><span>jitter</span><span>(samples[,</span> <span>&quot;N.critical&quot;</span><span>]),</span> <span>xlab</span> <span>=</span> <span>&quot;iteration&quot;</span><span>,</span> <span>ylab</span> <span>=</span> <span>&quot;N.critical&quot;</span><span>,</span>
     <span>main</span> <span>=</span> <span>&quot;Number of populations with critical size&quot;</span><span>,</span>
     <span>type</span> <span>=</span> <span>&quot;l&quot;</span><span>)</span>
</pre>
</div>
</div>
<p><a rel="nofollow" href="https://i1.wp.com/r-nimble.org/wp-content/uploads/2018/05/converting-to-nimble-plot-1.png?ssl=1" target="_blank"><img sizes="(max-width: 300px) 100vw, 300px" src="https://i2.wp.com/r-nimble.org/wp-content/uploads/2018/05/converting-to-nimble-plot-1-300x200.png?resize=300%2C200&ssl=1" alt="" width="300" class="wp-image-839" data-recalc-dims="1" height="200"></a></div>
<h1> Next steps </h1>
<p> NIMBLE allows users to customize MCMC and other algorithms in many ways. See the NIMBLE User Manual and web site for more ideas. </p>
<h2> Smaller steps you may need for converting existing code</h2>
<p>If the main steps above aren't sufficient, consider these additional steps when converting from JAGS, WinBUGS or OpenBUGS to NIMBLE.</p>
<ol start="4">
<li> Convert any use of truncation syntax
<ul>
<li> e.g. <tt>x ~ dnorm(0, tau) T(a, b)</tt> should be re-written as <tt>x ~ T(dnorm(0, tau), a, b)</tt>.</li>
<li> If reading model code from a file using <tt>readBUGSmodel</tt>, the <tt>x ~ dnorm(0, tau) T(a, b)</tt> syntax will work.</li>
</ul>
</li>
<li> Possibly split the <tt>data</tt> into <tt>data</tt> and <tt>constants</tt> for NIMBLE.
<ul>
<li> NIMBLE has a more general concept of data, so NIMBLE makes a distinction between data and constants. </li>
<li> Constants are necessary to define the model, such as <tt>nsite</tt> in <tt>for(i in 1:nsite) {...}</tt> and constant vectors of factor indices (e.g. <tt>block</tt> in <tt>mu[block[i]]</tt>). </li>
<li> Data are observed values of some variables.</li>
<li> Alternatively, one can provide a list of both constants and data for the <tt>constants</tt> argument to <tt>nimbleModel</tt>, and NIMBLE will try to determine which is which. Usually this will work, but when in doubt, try separating them. </li>
</ul>
</li>
<li> Possibly update initial values (<tt>inits</tt>).
<ul>
<li> In some cases, NIMBLE likes to have more complete <tt>inits</tt> than the other packages.</li>
<li> In a model with stochastic indices, those indices should have <tt>inits</tt> values.</li>
<li> When using <tt>nimbleMCMC</tt> or <tt>runMCMC</tt>, <tt>inits</tt> can be a function, as in R packages for calling WinBUGS, OpenBUGS or JAGS. Alternatively, it can be a list.</li>
<li> When you build a model with <tt>nimbleModel</tt> for more control than <tt>nimbleMCMC</tt>, you can provide <tt>inits</tt> as a list. This sets defaults that can be over-ridden with the <tt>inits</tt> argument to <tt>runMCMC</tt>.</li>
</ul>
</li>
</ol>
<p><br>
</p>
<p> <img width="1" src="https://r-nimble.org/?feed-stats-post-id=829" height="1"></p>
	<p>
<div>
<div>To <strong>leave a comment</strong> for the author, please follow the link and comment on their blog: <strong><a href="https://r-nimble.org/quick-guide-for-converting-from-jags-or-bugs-to-nimble"> R – NIMBLE</a></strong>.</div>
<hr>
<a rel="nofollow" href="https://www.r-bloggers.com/">R-bloggers.com</a> offers <strong><a rel="nofollow" href="https://feedburner.google.com/fb/a/mailverify?uri=RBloggers">daily e-mail updates</a></strong> about <a rel="nofollow" href="https://www.r-project.org/" title="The R Project for Statistical Computing">R</a> news and <a rel="nofollow" href="https://www.r-bloggers.com/search/tutorial" title="R tutorials">tutorials</a> on topics such as: <a rel="nofollow" href="https://www.r-bloggers.com/search/data%20science" title="Data science">Data science</a>, <a rel="nofollow" href="https://www.r-bloggers.com/search/Big%20Data" title="Big Data">Big Data, <a rel="nofollow" href="https://www.r-users.com/" title="R jobs">R jobs</a>, visualization (<a rel="nofollow" href="https://www.r-bloggers.com/search/ggplot2" title="ggplot and ggplot2 tutorials">ggplot2</a>, <a rel="nofollow" href="https://www.r-bloggers.com/search/boxplot" title="Boxplots using lattice and ggplot2 tutorials">Boxplots</a>, <a rel="nofollow" href="https://www.r-bloggers.com/search/map" title="Maps and gis">maps</a>, <a rel="nofollow" href="https://www.r-bloggers.com/search/animation" title="Animation in R">animation</a>), programming (<a rel="nofollow" href="https://www.r-bloggers.com/search/RStudio" title="RStudio IDE for R">RStudio</a>, <a rel="nofollow" href="https://www.r-bloggers.com/search/sweave" title="Sweave and literate programming">Sweave</a>, <a rel="nofollow" href="https://www.r-bloggers.com/search/LaTeX" title="LaTeX in R">LaTeX</a>, <a rel="nofollow" href="https://www.r-bloggers.com/search/SQL" title="SQL and databases">SQL</a>, <a rel="nofollow" href="https://www.r-bloggers.com/search/eclipse" title="Eclipse IDE for R">Eclipse</a>, <a rel="nofollow" href="https://www.r-bloggers.com/search/git" title="git and github, Version Control System">git</a>, <a rel="nofollow" href="https://www.r-bloggers.com/search/hadoop" title="Large data in R using Hadoop">hadoop</a>, <a rel="nofollow" href="https://www.r-bloggers.com/search/Web+Scraping" title="Web Scraping of google, facebook, yahoo, twitter and more using R">Web Scraping</a>) statistics (<a rel="nofollow" href="https://www.r-bloggers.com/search/regression" title="Regressions and ANOVA analysis tutorials">regression</a>, <a rel="nofollow" href="https://www.r-bloggers.com/search/PCA" title="principal component analysis tutorial">PCA</a>, <a rel="nofollow" href="https://www.r-bloggers.com/search/time+series" title="Time series">time series</a>, <a rel="nofollow" href="https://www.r-bloggers.com/search/trading" title="finance trading">trading</a>) and more...
<img width="1" alt="" src="http://feeds.feedburner.com/~r/RBloggers/~4/KK0tYAAOLWc" height="1"></a></div></div>