Merge pull request #914 from yixuan/bugfix

Various documentation fixes for Stan User's Guide

Author: WardBrian

src/stan-users-guide/complex-numbers.qmd

@@ -61,7 +61,7 @@ numbers, with the corresponding imaginary component set to zero.
 
 ```stan
 complex z1 = 3;  // int promoted to 3 + 0i
-complex z2 = 3.2;  // real promoted to 3.2 + 0.i
+complex z2 = 3.2;  // real promoted to 3.2 + 0.0i
 ```
 
 
@@ -149,7 +149,7 @@ vector.
 rv =  [2 + 3i, 1.9 - 2.3i];
 ```
 
-Complex matrices and vectors support all of the standard arithetmic
+Complex matrices and vectors support all of the standard arithmetic
 operations including negation, addition, subtraction, and
 multiplication (division involves a solve, and isn't a simple
 arithmetic operation for matrices).  They also support transposition.

src/stan-users-guide/dae.qmd

@@ -113,14 +113,13 @@ in Stan (see the [user-defined functions chapter](user-functions.qmd) for
 more information on coding user-defined functions).
 
 ```stan
- vector chem(real t, vector yy, vector yp,
-                 real alpha, real beta, real gamma) {
-    vector[3] res;
-    res[1] = yp[1] + alpha * yy[1] - beta * yy[2] * yy[3];
-    res[2] = yp[2] - alpha * yy[1] + beta * yy[2] * yy[3] + gamma * yy[2] * yy[2];
-    res[3] = yy[1] + yy[2] + yy[3] - 1.0;
-    return res;
-  }
+vector chem(real t, vector yy, vector yp,
+            real alpha, real beta, real gamma) {
+  vector[3] res;
+  res[1] = yp[1] + alpha * yy[1] - beta * yy[2] * yy[3];
+  res[2] = yp[2] - alpha * yy[1] + beta * yy[2] * yy[3] + gamma * yy[2] * yy[2];
+  res[3] = yy[1] + yy[2] + yy[3] - 1.0;
+  return res;
 }
 ```
 

src/stan-users-guide/floating-point.qmd

@@ -116,7 +116,7 @@ There are value functions `positive_infinity()` and
 `negative_infinity()` as well as a test function `is_inf()`.
 
 Positive and negative infinity have the expected comparison behavior,
-so that `negative_infinty() < 0` evaluates to true (represented with 1
+so that `negative_infinity() < 0` evaluates to true (represented with 1
 in Stan).  Also, negating positive infinity leads to negative infinity
 and vice-versa.
 

src/stan-users-guide/gaussian-processes.qmd

@@ -890,7 +890,7 @@ is the matrix of covariances between inputs $x$ and $\tilde{x}$, which
 in the case of the exponentiated quadratic covariance function
 would be
 $$
-K(x \mid \alpha, \rho)_{i, j} = \eta^2 \exp\left(-\dfrac{1}{2 \rho^2}
+K(x \mid \alpha, \rho)_{i, j} = \alpha^2 \exp\left(-\dfrac{1}{2 \rho^2}
 \sum_{d=1}^D \left(x_{i,d} - \tilde{x}_{j,d}\right)^2\right).
 $$
 

src/stan-users-guide/measurement-error.qmd

@@ -262,10 +262,10 @@ y_j &= \log \left( \frac{r^t_j / (n^t_j - r^t_j)}
 and corresponding standard errors
 $$
 \sigma_j = \sqrt{
-  \frac{1}{r^T_i}
-+ \frac{1}{n^T_i - r^T_i}
-+ \frac{1}{r^C_i}
-+ \frac{1}{n^C_i - r^C_i}
+  \frac{1}{r^T_j}
++ \frac{1}{n^T_j - r^T_j}
++ \frac{1}{r^C_j}
++ \frac{1}{n^C_j - r^C_j}
 }.
 $$
 

src/stan-users-guide/multi-indexing.qmd

@@ -77,7 +77,7 @@ example, consider the following.
 
 ```stan
 array[2, 3] int c;
-// ... define: c = ((1, 3, 5), ((7, 11, 13))
+// ... define: c = ((1, 3, 5), (7, 11, 13))
 array[4] int idxs;
 // ... define: idxs = (2, 2, 1, 2)
 array[4, 3] int d

src/stan-users-guide/parallelization.qmd

@@ -16,9 +16,9 @@ be used with multi-processing.
 The advantages of reduce with summation are:
 
 1. More flexible argument interface, avoiding the packing and
-   unpacking that is necessary with rectanguar map.
+   unpacking that is necessary with rectangular map.
 2. Partitions data for parallelization automatically (this is done manually
-   in rectanguar map).
+   in rectangular map).
 3. Is easier to use.
 
 The advantages of rectangular map are:
@@ -92,7 +92,7 @@ See details [below](#reduce-sum-grainsize).
 
 For efficiency and convenience additional
 shared arguments can be passed to every term in the sum. So for the
-array ```{ x1, x2, ... }``` and the shared arguments ```s1, s2, ...```stan
+array ```{ x1, x2, ... }``` and the shared arguments ```s1, s2, ...```
 the effective sum (with individual terms) looks like: 
 
 ```stan
@@ -137,7 +137,7 @@ without modification from the ```reduce_sum``` / `reduce_sum_static` call)
 The user-provided function ```f``` is expected to compute the partial
 sum with the terms ```start``` through ```end``` of the overall
 sum. The user function is passed the subset ```x[start:end]``` as
-```x_slice```. ```start``` and  ```end``` are passed so that ```f```stan
+```x_slice```. ```start``` and  ```end``` are passed so that ```f```
 can index any of the tailing ```sM``` arguments as necessary. The
 trailing ```sM``` arguments are passed without modification to every
 call of ```f```.
@@ -452,8 +452,8 @@ data {
 }
 transformed data {
   // K = 3 shards
-  array[3, 4] = { y[1:4], y[5:8], y[9:12] int ys };
-  array[3, 4] = { x[1:4], x[5:8], x[9:12] real xs };
+  array[3, 4] int ys = { y[1:4], y[5:8], y[9:12] };
+  array[3, 4] real xs = { x[1:4], x[5:8], x[9:12] };
   array[3] vector[0] theta;
 }
 parameters {

src/stan-users-guide/problematic-posteriors.qmd

@@ -467,7 +467,7 @@ p(\phi \mid y)
 \end{align*}
 
 If $N = 9$ and each $y_n = 1$, the posterior is
-$\textsf{beta}(\phi \mid 9.5,0,5)$.  This posterior is unbounded as $\phi
+$\textsf{beta}(\phi \mid 9.5,0.5)$.  This posterior is unbounded as $\phi
 \rightarrow 1$.  Nevertheless, the posterior is proper, and although
 there is no posterior mode, the posterior mean is well-defined with a
 value of exactly 0.95.

src/stan-users-guide/proportionality-constants.qmd

@@ -84,7 +84,7 @@ parameters {
   real x;
 }
 model {
-  target += normal_lupdf(x | mu, sigma)
+  target += normal_lupdf(x | mu, sigma);
 }
 ```
 
@@ -135,10 +135,10 @@ The following code demonstrates the different behaviors:
 ```stan
 functions {
   real custom1_lpdf(x) {
-    return normal_lupdf(x | 0.0, 1.0)
+    return normal_lupdf(x | 0.0, 1.0);
   }
   real custom2_lpdf(x) {
-    return normal_lpdf(x | 0.0, 1.0)
+    return normal_lpdf(x | 0.0, 1.0);
   }
 }
 parameters {

src/stan-users-guide/reparameterization.qmd

@@ -102,13 +102,13 @@ model {
 The new parameters, `phi` and `lambda`, are declared in the
 parameters block and the parameters for the Beta distribution,
 `alpha` and `beta`, are declared and defined in the
-transformed parameters block.  And If their values are not of interest,
+transformed parameters block.  And if their values are not of interest,
 they could instead be defined as local variables in the model as
 follows.
 
 ```stan
 model {
-  real alpha = lambda * phi
+  real alpha = lambda * phi;
   real beta = lambda * (1 - phi);
   // ...
   for (n in 1:N) {