Merge pull request #637 from ArnoStrouwen/LT

[skip ci] LanguageTool 4

Author: ChrisRackauckas

docs/src/getting_started.md

@@ -6,7 +6,7 @@ this material.
 
 ## Example 1 : Solving Scalar Equations
 
-In this example we will solve the equation
+In this example, we will solve the equation
 
 ```math
 \frac{du}{dt} = f(u,p,t)
@@ -111,12 +111,12 @@ which will only save the final time point.
 
 #### Choosing a Solver Algorithm
 
-DifferentialEquations.jl has a method for choosing the default solver algorithm
+DifferentialEquations.jl has a method for choosing the default solver algorithm,
 which will find an efficient method to solve your problem. To help users receive
 the right algorithm, DifferentialEquations.jl offers a method for choosing
-algorithms through hints. This default chooser utilizes the precisions of the
+algorithms through hints. This default chooser utilizes the precision of the
 number types and the keyword arguments (such as the tolerances) to select an
-algorithm. Additionally one can provide `alg_hints` to help choose good defaults
+algorithm. Additionally, one can provide `alg_hints` to help choose good defaults
 using properties of the problem and necessary features for the solution.
 For example, if we have a stiff problem where we need high accuracy,
 but don't know the best stiff algorithm for this problem, we can use:
@@ -128,7 +128,7 @@ sol = solve(prob,alg_hints=[:stiff],reltol=1e-8,abstol=1e-8)
 You can also explicitly choose the algorithm to use. DifferentialEquations.jl
 offers a much wider variety of solver algorithms than traditional differential
 equations libraries. Many of these algorithms are from recent research and have
-been shown to be more efficient than the "standard" algorithms.
+been shown to be more efficient than the “standard” algorithms.
 For example, we can choose a 5th order Tsitouras method:
 
 ```@example ODE2
@@ -143,7 +143,7 @@ via:
 sol = solve(prob,Tsit5(),reltol=1e-8,abstol=1e-8)
 ```
 
-In DifferentialEquations.jl, some good "go-to" choices for ODEs are:
+In DifferentialEquations.jl, some good “go-to” choices for ODEs are:
 
 - `AutoTsit5(Rosenbrock23())` handles both stiff and non-stiff equations. This
   is a good algorithm to use if you know nothing about the equation.
@@ -154,13 +154,13 @@ In DifferentialEquations.jl, some good "go-to" choices for ODEs are:
 - `BS3()` for fast low accuracy non-stiff.
 - `Vern7()` for high accuracy non-stiff.
 - `Rodas4()` or `Rodas5()` for small stiff equations with Julia-defined types, events, etc.
-- `KenCarp4()` or `TRBDF2()` for medium sized (100-2000 ODEs) stiff equations
+- `KenCarp4()` or `TRBDF2()` for medium-sized (100-2000 ODEs) stiff equations
 - `RadauIIA5()` for really high accuracy stiff equations
 - `QNDF()` for large stiff equations
 
 For a comprehensive list of the available algorithms and detailed recommendations,
-[Please see the solver documentation](@ref ode_solve). Every problem
-type has an associated page detailing all of the solvers associated with the problem.
+[please see the solver documentation](@ref ode_solve). Every problem
+type has an associated page detailing all the solvers associated with the problem.
 
 ### Step 3: Analyzing the Solution
 
@@ -228,11 +228,11 @@ plot(sol)
 The plot function can be formatted using [the attributes available in Plots.jl](https://juliaplots.github.io/).
 Additional DiffEq-specific controls are documented [at the plotting page](@ref plot).
 
-For example, from the Plots.jl attribute page we see that the line width can be
+For example, from the Plots.jl attribute page, we see that the line width can be
 set via the argument `linewidth`. Additionally, a title can be set with `title`.
 Thus we add these to our plot command to get the correct output, fix up some
 axis labels, and change the legend (note we can disable the legend with
-`legend=false`) to get a nice looking plot:
+`legend=false`) to get a nice-looking plot:
 
 ```@example ODE2
 plot(sol,linewidth=5,title="Solution to the linear ODE with a thick line",
@@ -247,7 +247,7 @@ plot!(sol.t,t->0.5*exp(1.01t),lw=3,ls=:dash,label="True Solution!")
 
 ## Example 2: Solving Systems of Equations
 
-In this example we will solve the Lorenz equations:
+In this example, we will solve the Lorenz equations:
 
 ```math
 \begin{aligned}
@@ -293,19 +293,19 @@ using Plots
 plot(sol,idxs=(1,2,3))
 ```
 
-Note that the default plot for multi-dimensional systems is an overlay of
+Note that the default plot for multidimensional systems is an overlay of
 each timeseries. We can plot the timeseries of just the second component using
 the variable choices interface once more:
 
 ```@example ODE3
 plot(sol,idxs=(0,2))
 ```
 
-Note that here "variable 0" corresponds to the independent variable ("time").
+Note that here “variable 0” corresponds to the independent variable (“time”).
 
 ## Defining Parameterized Functions
 
-In many cases you may want to explicitly have parameters associated with your
+Often, you want to explicitly have parameters associated with your
 differential equations. This can be used by things like
 [parameter estimation routines](https://docs.sciml.ai/Overview/stable/highlevels/inverse_problems/).
 In this case, you use the `p` values via the syntax:
@@ -467,7 +467,7 @@ is the value of the 5th component (by linear indexing) at the 3rd timepoint, or
 sol[2,1,:]
 ```
 
-is the timeseries for the component which is the 2nd row and 1 column.
+is the timeseries for the component, which is the 2nd row and 1 column.
 
 ## Going Beyond ODEs: How to Use the Documentation
 

docs/src/index.md

@@ -24,7 +24,7 @@ include:
 
 The well-optimized DifferentialEquations solvers benchmark as some of the fastest
 implementations, using classic algorithms and ones from recent research which
-routinely outperform the "standard" C/Fortran methods, and include algorithms
+routinely outperform the “standard” C/Fortran methods, and include algorithms
 optimized for high-precision and HPC applications. At the same time, it wraps
 the classic C/Fortran methods, making it easy to switch over to them whenever
 necessary. Solving differential equations with different methods from
@@ -75,7 +75,7 @@ Additionally, DifferentialEquations.jl comes with built-in analysis features, in
 ## Supporting and Citing
 
 The software in this ecosystem was developed as part of academic research.
-If you would like to help support it, please star the repository as such
+If you would like to help support it, please star the repository, as such
 metrics may help us secure funding in the future. If you use SciML
 software as part of your research, teaching, or other activities, we would
 be grateful if you could cite our work.
@@ -95,7 +95,7 @@ be grateful if you could cite our work.
 is necessary for any use of DifferentialEquations.jl or the packages that are
 maintained as part of its suite (OrdinaryDiffEq.jl, Sundials.jl, DiffEqDevTools.jl, etc.).
 Additionally, many of the solvers utilize novel algorithms, and if these algorithms
-are used we asked that you cite the methods. [Please see our citation page for guidelines](http://sciml.ai/citing.html).
+are used, we ask that you cite the methods. [Please see our citation page for guidelines](http://sciml.ai/citing.html).
 
 ## Getting Started: Installation And First Steps
 
@@ -116,7 +116,7 @@ using DifferentialEquations
 This will add solvers and dependencies
 for all kinds of Differential Equations (e.g. ODEs or SDEs etc., see the Supported
 Equations section below). If you are interested in only one type of equation
-solvers of `DifferentialEquations.jl` or simply want a more lightweight
+solver of `DifferentialEquations.jl` or simply want a more lightweight
 version, see the
 [Reduced Compile Time and Low Dependency Usage](@ref low_dep)
 page.
@@ -125,9 +125,9 @@ To understand the package in more detail, check out the following tutorials in
 this manual. **It is highly recommended that new users start with the
 [ODE tutorial](@ref ode_example)**. Example IJulia notebooks
 [can also be found in DiffEqTutorials.jl](https://github.com/SciML/DiffEqTutorials.jl).
-If you find any example where there seems to be an error, please open an issue.
+If you find any example where there appears to be an error, please open an issue.
 
-For the most up to date information on using the package, please join [the Gitter channel](https://gitter.im/JuliaDiffEq/Lobby).
+For the most up-to-date information on using the package, please join [the Gitter channel](https://gitter.im/JuliaDiffEq/Lobby).
 
 Using the bleeding edge for the latest features and development is only recommended
 for power users. Information on how to get to the bleeding edge is found in the
@@ -154,7 +154,7 @@ interpreter then run:
 >>> diffeqpy.install()
 ```
 
-and you're good! In addition, to improve the performance of your code it is
+and you're good! In addition, to improve the performance of your code, it is
 recommended that you use Numba to JIT compile your derivative functions. To
 install Numba, use:
 
@@ -220,13 +220,13 @@ Depth = 2
 
 ### Removing and Reducing Compile Times
 
-In some situations one may wish to decrease the compile time associated with DifferentialEquations.jl
-usage. If that's the case, there's two strategies to employ. One strategy is to use the
+In some situations, one may wish to decrease the compile time associated with DifferentialEquations.jl
+usage. If that's the case, there are two strategies to employ. One strategy is to use the
 [low dependency usage](https://diffeq.sciml.ai/stable/features/low_dep/). DifferentialEquations.jl
 is a metapackage composed of many smaller packages, and thus one could directly use a single component,
 such as `OrdinaryDiffEq.jl` for the pure Julia ODE solvers, and decrease the compile times by ignoring
-the rest (note: the interface is exactly the same, except using a solver other than those in OrdinaryDiffEq.jl
-will error). We recommend that downstream packages only rely on exactly the packages they need.
+the rest (note: the interface is exactly the same, except using a solver apart from those in OrdinaryDiffEq.jl
+will error). We recommend that downstream packages rely solely on the packages they need.
 
 The other strategy is to use [PackageCompiler.jl](https://julialang.github.io/PackageCompiler.jl/dev/) to create
 a system image that precompiles the whole package. To do this, one simply does:
@@ -236,10 +236,10 @@ using PackageCompiler
 PackageCompiler.create_sysimage([:DifferentialEquations,:Plots];replace_default=true)
 ```
 
-Note that there are some drawbacks to adding a package in your system image, for example
+Note that there are some drawbacks to adding a package in your system image. For example,
 the package will never update until you manually rebuild the system image again. For more
 information on the consequences,
-[see this portion of the PackageCompiler manual](https://julialang.github.io/PackageCompiler.jl/dev/sysimages/#Drawbacks-to-custom-sysimages-1)
+[see this portion of the PackageCompiler manual](https://julialang.github.io/PackageCompiler.jl/dev/sysimages/#Drawbacks-to-custom-sysimages-1).
 
 ### Basics
 

docs/src/tutorials/advanced_ode_example.md

@@ -1,7 +1,7 @@
 # [Solving Large Stiff Equations](@id stiff)
 
 This tutorial is for getting into the extra features for solving large stiff ordinary
-differential equations in an efficient manner. Solving stiff ordinary
+differential equations efficiently. Solving stiff ordinary
 differential equations requires specializing the linear solver on properties of
 the Jacobian in order to cut down on the ``\mathcal{O}(n^3)`` linear solve and
 the ``\mathcal{O}(n^2)`` back-solves. Note that these same functions and
@@ -110,7 +110,7 @@ prob_ode_brusselator_2d = ODEProblem(brusselator_2d_loop,u0,(0.,11.5),p)
 ## Choosing Jacobian Types
 
 When one is using an implicit or semi-implicit differential equation solver,
-the Jacobian must be built at many iterations and this can be one of the most
+the Jacobian must be built at many iterations, and this can be one of the most
 expensive steps. There are two pieces that must be optimized in order to reach
 maximal efficiency when solving stiff equations: the sparsity pattern and the
 construction of the Jacobian. The construction is filling the matrix
@@ -142,7 +142,7 @@ One of the useful companion tools for DifferentialEquations.jl is
 [Symbolics.jl](https://github.com/JuliaSymbolics/Symbolics.jl).
 This allows for automatic declaration of Jacobian sparsity types. To see this
 in action, we can give an example `du` and `u` and call `jacobian_sparsity`
-on our function with the example arguments and it will kick out a sparse matrix
+on our function with the example arguments, and it will kick out a sparse matrix
 with our pattern, that we can turn into our `jac_prototype`.
 
 ```@example stiff1
@@ -151,7 +151,7 @@ du0 = copy(u0)
 jac_sparsity = Symbolics.jacobian_sparsity((du,u)->brusselator_2d_loop(du,u,p,0.0),du0,u0)
 ```
 
-Notice Julia gives a nice print out of the sparsity pattern. That's neat, and
+Notice that Julia gives a nice print out of the sparsity pattern. That's neat, and
 would be tedious to build by hand! Now we just pass it to the `ODEFunction`
 like as before:
 
@@ -182,7 +182,7 @@ or `TRBDF2(linsolve = UMFPACKFactorization())`.
 ## Using Jacobian-Free Newton-Krylov
 
 A completely different way to optimize the linear solvers for large sparse
-matrices is to use a Krylov subpsace method. This requires choosing a linear
+matrices is to use a Krylov subspace method. This requires choosing a linear
 solver for changing to a Krylov method. To swap the linear solver out, we use
 the `linsolve` command and choose the GMRES linear solver.
 
@@ -192,7 +192,7 @@ nothing # hide
 ```
 
 Notice that this acceleration does not require the definition of a sparsity
-pattern and can thus be an easier way to scale for large problems. For more
+pattern, and can thus be an easier way to scale for large problems. For more
 information on linear solver choices, see the
 [linear solver documentation](@ref linear_nonlinear). `linsolve` choices are any
 valid [LinearSolve.jl](http://linearsolve.sciml.ai/dev/) solver.
@@ -235,8 +235,8 @@ Notice a few things about this preconditioner. This preconditioner uses the
 sparse Jacobian, and thus we set `concrete_jac=true` to tell the algorithm to
 generate the Jacobian (otherwise, a Jacobian-free algorithm is used with GMRES
 by default). Then `newW = true` whenever a new `W` matrix is computed, and
-`newW=nothing` during the startup phase of the solver. Thus we do a check
-`newW === nothing || newW` and when true, it's only at these points when we
+`newW=nothing` during the startup phase of the solver. Thus, we do a check
+`newW === nothing || newW` and when true, it's only at these points when
 we update the preconditioner, otherwise we just pass on the previous version.
 We use `convert(AbstractMatrix,W)` to get the concrete `W` matrix (matching
 `jac_prototype`, thus `SpraseMatrixCSC`) which we can use in the preconditioner's
@@ -299,7 +299,7 @@ the linear solver choice is done with a Symbol in the `linear_solver` from a
 preset list. Particular choices of note are `:Band` for a banded matrix and
 `:GMRES` for using GMRES. If you are using Sundials, `:GMRES` will not require
 defining the JacVecOperator, and instead will always make use of a Jacobian-Free
-Newton Krylov (with numerical differentiation). Thus on this problem we could do:
+Newton Krylov (with numerical differentiation). Thus, on this problem we could do:
 
 ```@example stiff1
 using Sundials
@@ -368,7 +368,7 @@ function precilu(z,r,p,t,y,fy,gamma,delta,lr)
 end
 ```
 
-We then simply pass these functions to the Sundials solver with a choice of
+We then simply pass these functions to the Sundials solver, with a choice of
 `prec_side=1` to indicate that it is a left-preconditioner:
 
 ```julia

docs/src/tutorials/bvp_example.md

@@ -7,7 +7,7 @@ introductions can be found by [checking out SciMLTutorials.jl](https://docs.scim
 
     This tutorial assumes you have read the [Ordinary Differential Equations tutorial](@ref ode_example).
 
-In this example we will solve the ODE that satisfies the boundary condition in the form of
+In this example, we will solve the ODE that satisfies the boundary condition in the form of
 
 ```math
 \begin{aligned}
@@ -37,7 +37,7 @@ end
 ### Boundary Condition
 
 There are two problem types available:
- - A problem type for general boundary conditions `BVProblem` ( including conditions that may be anywhere/ everywhere on the integration interval ).
+ - A problem type for general boundary conditions `BVProblem` (including conditions that may be anywhere/ everywhere on the integration interval).
  - A problem type for boundaries that are specified at the beginning and the end of the integration interval `TwoPointBVProblem`
 
 #### `BVProblem`
@@ -68,16 +68,16 @@ end
 bvp3 = BVProblem(simplependulum!, bc3!, u₀_2, tspan)
 sol3 = solve(bvp3, Shooting(Vern7()))
 ```
-The initial guess can also be supplied via a function of `t` or a previous solution type, this is espacially handy for parameter analysis.
-We changed `u` to `sol` to emphasize the fact that in this case the boundary condition can be written on the solution object. Thus all of the features on the solution type such as interpolations are available when using the `Shooting` method (i.e. you can have a boundary condition saying that the maximum over the interval is `1` using an optimization function on the continuous output). Note that user has to import the IVP solver before it can be used. Any common interface ODE solver is acceptable.
+The initial guess can also be supplied via a function of `t` or a previous solution type, this is especially handy for parameter analysis.
+We changed `u` to `sol` to emphasize the fact that in this case, the boundary condition can be written on the solution object. Thus, all the features on the solution type such as interpolations are available when using the `Shooting` method. (i.e. you can have a boundary condition saying that the maximum over the interval is `1` using an optimization function on the continuous output). Note that user has to import the IVP solver before it can be used. Any common interface ODE solver is acceptable.
 
 ```@example bvp
 plot(sol3)
 ```
 
 #### `TwoPointBVProblem`
 
-Defining a similar problem as `TwoPointBVProblem` is shown in the following example. At the moment `MIRK4` is the only solver for `TwoPointBVProblem`s.
+Defining a similar problem as `TwoPointBVProblem` is shown in the following example. Currently, `MIRK4` is the only solver for `TwoPointBVProblem`s.
 
 ```@example bvp
 function bc2!(residual, u, p, t) # u[1] is the beginning of the time span, and u[end] is the ending

docs/src/tutorials/dae_example.md

@@ -20,7 +20,7 @@ Mu' = f(u,p,t)
 ```
 
 where ``M`` is known as the mass matrix. Let's solve the Robertson equation.
-In previous tutorials we wrote this equation as:
+In previous tutorials, we wrote this equation as:
 
 ```math
 \begin{aligned}
@@ -72,7 +72,7 @@ plot(sol, xscale=:log10, tspan=(1e-6, 1e5), layout=(3,1))
 
 ## Implicitly-Defined Differential-Algebraic Equations (DAEs)
 
-In this example we will solve the Robertson equation in its implicit form:
+In this example, we will solve the Robertson equation in its implicit form:
 
 ```math
 f(du,u,p,t) = 0
@@ -104,7 +104,7 @@ with initial conditions ``y_1(0) = 1``, ``y_2(0) = 0``, ``y_3(0) = 0``,
 The workflow for DAEs is the same as for the other types of equations, where all
 you need to know is how to define the problem. A `DAEProblem` is specified by defining
 an in-place update `f(out,du,u,p,t)` which uses the values to mutate `out` as the
-output. To makes this into a DAE, we move all of the variables to one side.
+output. To makes this into a DAE, we move all the variables to one side.
 Thus, we can define the function:
 
 ```@example dae