[skip ci] LanguageTool 3

Author: ArnoStrouwen

docs/src/basics/compatibility_chart.md

@@ -3,7 +3,7 @@
 This chart is for documenting the compatibility of the component solver packages
 to the common interface. An `x` means that the option is implemented or the
 add-on functionality will work with the given solver. A blank means that
-the option has not been implemented or that a given add-on has not been tested
+the option has not been implemented, or that a given add-on has not been tested
 with a given package. If there are any errors in this chart, please file an
 issue or submit a pull-request.
 
@@ -46,8 +46,8 @@ issue or submit a pull-request.
 | Plotting and solution handling         | x                 | x           | x      | x               | x        | x                   | x              | x        | x          
 
 * x: Full compatibility
-* p: Partial compatibility, only in nonstiff methods unless the Jacobian is provided.
-* n: General compatibility, but not compatible with routines which.
+* p: Partial compatibility, only in nonstiff methods, unless the Jacobian is provided.
+* n: General compatibility, but not compatible with routines which
   require being able to autodifferentiate through the entire solver.
 * 0: Not possible. This is generally due to underlying inflexibility in a wrapped
   library.

docs/src/basics/faq.md

@@ -27,10 +27,10 @@ which will take one successful step. Additionally:
 step!(integrator,dt[,stop_at_tdt=false])
 ```
 
-passing a `dt` will make the integrator keep stepping until `integrator.t+dt`, and
+passing a `dt` will make the integrator continue to step until `integrator.t+dt`, and
 setting `stop_at_tdt=true` will add a `tstop` to force it to step to `integrator.t+dt`
 
-To check whether or not the integration step was successful, you can
+To check whether the integration step was successful, you can
 call `check_error(integrator)` which returns one of the
 [return codes](@ref retcodes).
 
@@ -74,10 +74,10 @@ for (u,t) in TimeChoiceIterator(integrator,ts)
 end
 ```
 
-Lastly, one can dynamically control the "endpoint". The initialization simply makes
+Lastly, one can dynamically control the “endpoint”. The initialization simply makes
 `prob.tspan[2]` the last value of `tstop`, and many of the iterators are made to stop
 at the final `tstop` value. However, `step!` will always take a step, and one
-can dynamically add new values of `tstops` by modifiying the variable in the
+can dynamically add new values of `tstops` by modifying the variable in the
 options field: `add_tstop!(integrator,new_t)`.
 
 Finally, to solve to the last `tstop`, call `solve!(integrator)`. Doing `init`
@@ -91,7 +91,7 @@ SciMLBase.check_error!
 
 ## Handing Integrators
 
-The `integrator<:DEIntegrator` type holds all of the information for the intermediate solution
+The `integrator<:DEIntegrator` type holds all the information for the intermediate solution
 of the differential equation. Useful fields are:
 
 * `t` - time of the proposed step
@@ -111,7 +111,7 @@ specific problem. For example, when solving an `ODEProblem`, `f` will be an
 creating the `ODEProblem`, please use `SciMLBase.unwrapped_f(integrator.f.f)`.
 
 The `p` is the (parameter) data which is provided by the user as a keyword arg in
-`init`. `opts` holds all of the common solver options, and can be mutated to
+`init`. `opts` holds all the common solver options, and can be mutated to
 change the solver characteristics. For example, to modify the absolute tolerance
 for the future timesteps, one can do:
 
@@ -121,8 +121,8 @@ integrator.opts.abstol = 1e-9
 
 The `sol` field holds the current solution. This current solution includes the
 interpolation function if available, and thus `integrator.sol(t)` lets one
-interpolate efficiently over the whole current solution. Additionally, a
-a "current interval interpolation function" is provided on the `integrator` type
+interpolate efficiently over the whole current solution. Additionally,
+a “current interval interpolation function” is provided on the `integrator` type
 via `integrator(t,deriv::Type=Val{0};idxs=nothing,continuity=:left)`.
 This uses only the solver information from the interval
 `[tprev,t]` to compute the interpolation, and is allowed to extrapolate beyond
@@ -132,7 +132,7 @@ that interval.
 
 Be cautious: one should not directly mutate the `t` and `u` fields of the integrator.
 Doing so will destroy the accuracy of the interpolator and can harm certain algorithms.
-Instead if one wants to introduce discontinuous changes, one should use the
+Instead, if one wants to introduce discontinuous changes, one should use the
 [callbacks](@ref callbacks). Modifications within a callback
 `affect!` surrounded by saves provides an error-free handling of the discontinuity.
 
@@ -152,20 +152,20 @@ SciMLBase.set_ut!
 The integrator and the solution have very different actions because they have
 very different meanings. The `typeof(sol) <: DESolution` type is a type with
 history: it stores
-all of the (requested) timepoints and interpolates/acts using the values closest
+all the (requested) timepoints and interpolates/acts using the values closest
 in time. On the other hand, the `typeof(integrator)<:DEIntegrator` type is a
 local object. It only knows the times of the interval it currently spans,
 the current caches and values, and the current state of the solver
 (the current options, tolerances, etc.). These serve very different purposes:
 
-* The `integrator`'s interpolation can extrapolate, both forward and backward in
+* The `integrator`'s interpolation can extrapolate, both forward and backward
   in time. This is used to estimate events and is internally used for predictions.
 * The `integrator` is fully mutable upon iteration. This means that every time
   an iterator affect is used, it will take timesteps from the current time. This
   means that `first(integrator)!=first(integrator)` since the `integrator` will
   step once to evaluate the left and then step once more (not backtracking).
   This allows the iterator to keep dynamically stepping, though one should note
-  that it may violate some immutablity assumptions commonly made about iterators.
+  that it may violate some immutability assumptions commonly made about iterators.
 
 If one wants the solution object, then one can find it in `integrator.sol`.
 
@@ -231,7 +231,7 @@ get_du!
 
 !!! warning
 
-    Note that not all of these functions will be implemented for every algorithm.
+    Note that not all these functions will be implemented for every algorithm.
     Some have hard limitations. For example, Sundials.jl cannot resize problems.
     When a function is not limited, an error will be thrown.
 
@@ -254,7 +254,7 @@ end
 ```
 
 which will only enter the loop body at the values in `tstops` (here, `prob.tspan[2]==1.0`
-and thus there are two values of `tstops` which are hit). Addtionally, one can
+and thus there are two values of `tstops` which are hit). Additionally, one can
 `solve!` only to `0.5` via:
 
 ```julia

docs/src/basics/integrator.md

@@ -32,7 +32,7 @@ will solve using `Rational{BigInt}` for the timesteps and `BigFloat` for the
 independent variables. A wide variety of number types are compatible with the
 solvers such as complex numbers, unitful numbers (via Unitful.jl),
 decimals (via DecFP), dual numbers, and many more which may not have been tested
-yet (thanks to the power of multiple dispatch!). For information on type-compatibilty,
+yet (thanks to the power of multiple dispatch!). For information on type-compatibility,
 please see the solver pages for the specific problems.
 
 ## Solving the Problems
@@ -48,12 +48,12 @@ Into the command, one passes the differential equation problem that they defined
 `prob`, optionally choose an algorithm `alg` (a default is given if not
 chosen), and change the properties of the solver using keyword arguments. The common
 arguments which are accepted by most methods is defined in [the common solver options manual page](@ref solver_options).
-The solver returns a solution object `sol` which hold all of the details for the solution.
+The solver returns a solution object `sol` which hold all the details for the solution.
 
 ## Analyzing the Solution
 
 With the solution object, you do the analysis as you please! The solution type
-has a common interface which makes handling the solution similar between the
+has a common interface, which makes handling the solution similar between the
 different types of differential equations. Tools such as interpolations
 are seamlessly built into the solution interface to make analysis easy. This
 interface is described in the [solution handling manual page](@ref solution).
@@ -62,14 +62,14 @@ Plotting functionality is provided by a recipe to Plots.jl. To
 use plot solutions, simply call the `plot(sol)` and the plotter will generate
 appropriate plots. If `save_everystep` was used, the plotters can
 generate animations of the solutions to evolution equations using the `animate(sol)`
-command. Plots can be customized using all of the keyword arguments
+command. Plots can be customized using all the keyword arguments
 provided by Plots.jl. Please see Plots.jl's documentation for more information.
 
 ## Add-on Tools
 
 One of the most compelling features of DifferentialEquations.jl is that the
-common solver interface allows one to build tools which are "algorithm and
-problem agnostic". For example, one of the provided tools allows for performing
+common solver interface allows one to build tools which are “algorithm and
+problem agnostic”. For example, one of the provided tools allows for performing
 parameter estimation on `ODEProblem`s. Since the `solve` interface is the
 same for the different algorithms, one can use any of the associated solving algorithms.
 This modular structure allows one to mix and match overarching analysis tools
@@ -90,6 +90,6 @@ which are unique and the results of recent publications! Please check out the
 for more information on using the development tools.
 
 Note that DifferentialEquations.jl allows for distributed development, meaning that
-algorithms which "plug-into ecosystem" don't have to be a part of the major packages.
+algorithms which “plug-into the ecosystem” don't have to be a part of the major packages.
 If you are interested in adding your work to the ecosystem, checkout the [developer documentation](https://devdocs.sciml.ai/dev/)
 for more information.

docs/src/basics/overview.md

@@ -15,7 +15,7 @@ plot(sol) # Plots the solution
 Many of the types defined in the DiffEq universe, such as
 `ODESolution`, `ConvergenceSimulation` `WorkPrecision`, etc. have plot recipes
 to handle the default plotting behavior. Plots can be customized using
-[all of the keyword arguments provided by Plots.jl](http://docs.juliaplots.org/dev/supported/).
+[all the keyword arguments provided by Plots.jl](http://docs.juliaplots.org/dev/supported/).
 For example, we can change the plotting backend to the GR package and put a title
 on the plot by doing:
 
@@ -40,7 +40,7 @@ of evenly-spaced points (in time) to plot. For example:
 plot(sol,denseplot=false)
 ```
 
-means "only plot the points which the solver stepped to", while:
+means “only plot the points which the solver stepped to”, while:
 
 ```julia
 plot(sol,plotdensity=1000)
@@ -67,9 +67,9 @@ and return a tuple. If no function is given, for example,
 idxs = [(0,1), (1,3), (4,5)]
 ```
 
-this would mean "plot `var₁(t)` vs `t` (*time*), `var₃(var₁)` vs `var₁`, and
+this would mean “plot `var₁(t)` vs `t` (*time*), `var₃(var₁)` vs `var₁`, and
 `var₅(var₄)` vs `var₄` all on the same graph, putting the independent variables
-(`t`, `var₁` and `var₄`) on the x-axis." While this can be used for everything,
+(`t`, `var₁` and `var₄`) on the x-axis.” While this can be used for everything,
 the following conveniences are provided:
 
 * Everywhere in a tuple position where we only find an integer, this
@@ -140,7 +140,7 @@ plot(sol,tspan=(0.0,40.0))
 ```
 
 only plots between `t=0.0` and `t=40.0`. If `denseplot=true` these bounds will be respected
-exactly. Otherwise the first point inside and last point inside the interval will be plotted,
+exactly. Otherwise, the first point inside and last point inside the interval will be plotted,
 i.e. no points outside the interval will be plotted.
 
 ### Example
@@ -218,7 +218,7 @@ Phase plots can be done similarly, for example:
 plot(sol[i,:],sol[j,:],sol[k,:])
 ```
 
-is a 3d phase plot between variables `i`, `j`, and `k`.
+is a 3D phase plot between variables `i`, `j`, and `k`.
 
 Notice that this does not use the interpolation. When not using the plot recipe,
 the interpolation must be done manually. For example:

docs/src/basics/plot.md

@@ -22,7 +22,7 @@ For example, this can be done at the problem level like:
 ODEProblem{true}(f,u0,tspan,p)
 ```
 
-which declares that `isinplace=true`. Similarly this can be done at the
+which declares that `isinplace=true`. Similarly, this can be done at the
 DEFunction level. For example:
 
 ```julia
@@ -35,7 +35,7 @@ Throughout DifferentialEquations.jl, the types that are given in a problem are
 the types used for the solution. If an initial value `u0` is needed for a problem,
 then the state variable `u` will match the type of that `u0`. Similarly, if
 time exists in a problem the type for `t` will be derived from the types of the
-`tspan`. Parameters `p` can be any type and the type will be matching how it's
+`tspan`. Parameters `p` can be any type, and the type will be matching how it's
 defined in the problem.
 
 For internal matrices, such as Jacobians and Brownian caches, these also match

docs/src/basics/problem.md

@@ -2,7 +2,7 @@
 
 ## Accessing the Values
 
-The solution type has a lot of built in functionality to help analysis. For example,
+The solution type has a lot of built-in functionality to help analysis. For example,
 it has an array interface for accessing the values. Internally, the solution type
 has two important fields:
 
@@ -27,7 +27,7 @@ to access the value at timestep `j` (if the timeseries was saved), and
 sol.t[j]
 ```
 
-to access the value of `t` at timestep `j`. For multi-dimensional systems, this
+to access the value of `t` at timestep `j`. For multidimensional systems, this
 will address first by component and lastly by time, and thus
 
 ```julia
@@ -93,7 +93,7 @@ Note that the interpolating function allows for `t` to be a vector and uses this
 sol(t,deriv=Val{0};idxs=nothing,continuity=:left)
 ```
 
-The optional argument `deriv` lets you choose the number `n` derivative to solve the interpolation for, defaulting with `n=0`. Note that most of the derivatives have not yet been implemented (though it's not hard, it just has to be done by hand for each algorithm. Open an issue if there's a specific one you need). `continuity` describes whether to satisfy left or right continuity when a discontinuity is saved. The default is `:left`, i.e. grab the value before the callback's change, but can be changed to `:right`. `idxs` allows you to choose the indices the interpolation should solve for. For example,
+The optional argument `deriv` lets you choose the number `n` derivative to solve the interpolation for, defaulting with `n=0`. Note that most of the derivatives have not yet been implemented (though it's not hard, it just has to be done manually for each algorithm. Open an issue if there's a specific one you need). `continuity` describes whether to satisfy left or right continuity when a discontinuity is saved. The default is `:left`, i.e. grab the value before the callback's change, but can be changed to `:right`. `idxs` allows you to choose the indices the interpolation should solve for. For example,
 
 ```julia
 sol(t,idxs=1:2:5)
@@ -142,7 +142,7 @@ The solution interface also includes some special fields. The problem object
 `prob` and the algorithm used to solve the problem `alg` are included in the
 solution. Additionally, the field `dense` is a boolean which states whether
 the interpolation functionality is available. Further, the field `destats`
-contains the internal statistics for the solution process such as the number
+contains the internal statistics for the solution process, such as the number
 of linear solves and convergence failures. Lastly, there is a mutable state
 `tslocation` which controls the plot recipe behavior. By default, `tslocation=0`.
 Its values have different meanings between partial and ordinary differential equations: