Merge pull request #134 from ArnoStrouwen/lt

[skip ci] LanguageTool

Author: ChrisRackauckas

docs/src/basics/IntegralProblem.md

@@ -21,4 +21,4 @@ depends on whether batching is used.
 | **vector valued `f`** | `u` is a vector, `y` is a matrix | `u` is a matrix, `y` is a matrix |
 
 The last dimension is always used as the batching dimension,
-e.g. if `u` is a matrix, then `u[:,i]` is the `i`th point where the integrand will be evaluated.
+e.g., if `u` is a matrix, then `u[:,i]` is the `i`th point where the integrand will be evaluated.

docs/src/basics/solve.md

@@ -5,5 +5,5 @@ solve(prob::IntegralProblem, alg::SciMLBase.AbstractIntegralAlgorithm)
 ```
 
 Additionally, the extra keyword arguments are splatted to the library calls, so
-see the documentation of the integrator library for all of the extra details.
+see the documentation of the integrator library for all the extra details.
 These extra keyword arguments are not guaranteed to act uniformly.

docs/src/tutorials/numerical_integrals.md

@@ -1,6 +1,6 @@
 # Numerically Solving Integrals
 
-For basic multidimensional quadrature we can construct and solve a `IntegralProblem`.
+For basic multidimensional quadrature, we can construct and solve a `IntegralProblem`.
 The integral we want to evaluate is:
 ```math
 \int_1^3\int_1^3\int_1^3 \sum_1^3 \sin(u_i) du_1du_2du_3.
@@ -15,7 +15,7 @@ sol.u
 ```
 where the first argument of `IntegralProblem` is the integrand,
 the second argument is the lower bound, and the third argument is the upper bound.
-`p` are the parameters of the integrand. In this case there are no parameters,
+`p` are the parameters of the integrand. In this case, there are no parameters,
 but still `f` must be defined as `f(x,p)` and **not** `f(x)`.
 For an example with parameters, see the next tutorial.
 The first argument of `solve` is the problem we are solving,
@@ -25,8 +25,8 @@ in this case tolerances how precise the numerical approximation should be.
 
 We can also evaluate multiple integrals at once.
 We could create two `IntegralProblem`s for this,
-but that is wasteful if the integrands share alot of computation.
-We also want to evaluate:
+but that is wasteful if the integrands share a lot of computation.
+For example, we also want to evaluate:
 ```math
 \int_1^3\int_1^3\int_1^3 \sum_1^3 \cos(u_i) du_1du_2du_3.
 ```
@@ -40,10 +40,10 @@ sol.u
 The keyword `nout` now has to be specified equal to the number of integrals ware are calculating, 2.
 Another way to think about this is that the integrand is now a vector valued function.
 The default value for the keyword `nout` is 1,
-thus is does not need to be specified for scalar valued functions.
-In the above example the integrand was defined out-of-position.
+and thus it does not need to be specified for scalar valued functions.
+In the above example, the integrand was defined out-of-position.
 This means that a new output vector is created every time the function `f` is called.
-If we do not  want these allocations we can also define `f` in-position.
+If we do not  want these allocations, we can also define `f` in-position.
 ``` @example integrate3
 using Integrals, IntegralsCubature
 function f(y,u,p)
@@ -79,7 +79,7 @@ Both `u` and `y` changed from vectors to matrices,
 where each column is respectively a point the integrand is evaluated at or
 the evaluation of the integrand at the corresponding point.
 Try to create yourself an out-of-position version of the above problem.
-For the full details of the batching interface, see the [problem page](@ref prob)
+For the full details of the batching interface, see the [problem page](@ref prob).
 
 If we would like to compare the results against Cuba.jl's `Cuhre` method, then
 the change is a one-argument change:
@@ -93,12 +93,12 @@ sol = solve(prob,CubaCuhre();reltol=1e-3,abstol=1e-3)
 sol.u
 ```
 However, `Cuhre` does not support vector valued integrands.
-The [solvers page](@ref solvers) gives an overview which arguments each algorithm can handle.
+The [solvers page](@ref solvers) gives an overview of which arguments each algorithm can handle.
 
 ## One-dimensional integrals
 
 Integrals.jl also has specific solvers for integrals in a single dimension, such as `QuadGKLJ`.
-For example we can create our own sine function by integrating the cosine function from 0 to x.
+For example, we can create our own sine function by integrating the cosine function from 0 to x.
 
 ``` @example integrate6
 using Integrals
@@ -116,13 +116,13 @@ and the integral is thus transformed to:
 \int_a^\infty f(u)du = \int_0^1 f\left(a+\frac{t}{1-t}\right)\frac{1}{(1-t)^2}dt
 ```
 Integrals with an infinite lower bound are handled in the same way.
-If both upper and lower bound are infinite $u$ is substituted with $\frac{t}{1-t^2}$,
+If both upper and lower bound are infinite, $u$ is substituted with $\frac{t}{1-t^2}$,
 ```math
 \int_{-\infty}^\infty f(u)du = \int_{-1}^1 f\left(\frac{t}{1-t^2}\right)\frac{1+t^2}{(1-t^2)^2}dt
 ```
 For multidimensional integrals, each variable with infinite bounds is substituted the same way.
 The details of the math behind these transforms can be found
-[here.](https://en.wikipedia.org/wiki/Integration_by_substitution#Substitution_for_multiple_variables).
+[here](https://en.wikipedia.org/wiki/Integration_by_substitution#Substitution_for_multiple_variables).
 
 As an example, let us integrate the standard bivariate normal probability distribution
 over the area above the horizontal axis, which should be equal to $0.5$.