Merge pull request #450 from ArnoStrouwen/LT

[skip ci] LanguageTool

Author: ChrisRackauckas

docs/pages.jl

@@ -20,10 +20,10 @@ pages = ["index.md",
         "Flux.jl" => "optimization_packages/flux.md",
         "GCMAES.jl" => "optimization_packages/gcmaes.md",
         "MathOptInterface.jl" => "optimization_packages/mathoptinterface.md",
-        "MultistartOptimization.jl" => "optimization_packages/multistartoptimization.md",
         "Metaheuristics.jl" => "optimization_packages/metaheuristics.md",
-        "NOMAD.jl" => "optimization_packages/nomad.md",
+        "MultistartOptimization.jl" => "optimization_packages/multistartoptimization.md",
         "NLopt.jl" => "optimization_packages/nlopt.md",
+        "NOMAD.jl" => "optimization_packages/nomad.md",
         "Nonconvex.jl" => "optimization_packages/nonconvex.md",
         "Optim.jl" => "optimization_packages/optim.md",
         "Optimisers.jl" => "optimization_packages/optimisers.md",

docs/src/API/modelingtoolkit.md

@@ -14,6 +14,6 @@ details.
 
 Secondly, one can generate `OptimizationProblem`s for use in
 Optimization.jl from purely a symbolic front-end. This is the form
-users will encounter when using ModelingToolkit.jl directly, and its
+users will encounter when using ModelingToolkit.jl directly, and it is
 also the form supplied by domain-specific languages. For more information,
 see the [OptimizationSystem documentation](https://docs.sciml.ai/ModelingToolkit/stable/systems/OptimizationSystem/).

docs/src/index.md

@@ -1,11 +1,11 @@
 # Optimization.jl: A Unified Optimization Package
 
 Optimization.jl is a package with a scope that is beyond your normal global optimization
-package. Optimization.jl seeks to bring together all of the optimization packages
+package. Optimization.jl seeks to bring together all the optimization packages
 it can find, local and global, into one unified Julia interface. This means, you
-learn one package and you learn them all! Optimization.jl adds a few high-level
+learn one package, and you learn them all! Optimization.jl adds a few high-level
 features, such as integrating with automatic differentiation, to make its usage
-fairly simple for most cases, while allowing all of the options in a single
+fairly simple for most cases, while allowing all the options in a single
 unified interface.
 
 ## Installation

docs/src/optimization_packages/blackboxoptim.md

@@ -1,5 +1,5 @@
 # BlackBoxOptim.jl
-[`BlackBoxOptim`](https://github.com/robertfeldt/BlackBoxOptim.jl) is a is a Julia package implementing **(Meta-)heuristic/stochastic algorithms** that do not require for the optimized function to be differentiable.
+[`BlackBoxOptim`](https://github.com/robertfeldt/BlackBoxOptim.jl) is a Julia package implementing **(Meta-)heuristic/stochastic algorithms** that do not require for the optimized function to be differentiable.
 
 ## Installation: OptimizationBBO.jl
 
@@ -46,7 +46,7 @@ The currently available algorithms are listed [here](https://github.com/robertfe
 
 ## Example
 
-The Rosenbrock function can optimized using the `BBO_adaptive_de_rand_1_bin_radiuslimited()` as follows:
+The Rosenbrock function can be optimized using the `BBO_adaptive_de_rand_1_bin_radiuslimited()` as follows:
 
 ```@example BBO
 using Optimization, OptimizationBBO

docs/src/optimization_packages/cmaevolutionstrategy.md

@@ -19,7 +19,7 @@ constraint equations. However, lower and upper constraints set by `lb` and `ub`
 
 ## Example
 
-The Rosenbrock function can optimized using the `CMAEvolutionStrategyOpt()` as follows:
+The Rosenbrock function can be optimized using the `CMAEvolutionStrategyOpt()` as follows:
 
 ```@example CMAEvolutionStrategy
 using Optimization, OptimizationCMAEvolutionStrategy

docs/src/optimization_packages/evolutionary.md

@@ -25,11 +25,11 @@ A `Evolutionary` algorithm is called by one of the following:
 
 - [`Evolutionary.CMAES()`](https://wildart.github.io/Evolutionary.jl/stable/cmaes/): **Covariance Matrix Adaptation Evolution Strategy algorithm**
 
-Algorithm specific options are defined as `kwargs`. See the respective documentation for more detail.
+Algorithm-specific options are defined as `kwargs`. See the respective documentation for more detail.
 
 ## Example
 
-The Rosenbrock function can optimized using the `Evolutionary.CMAES()` as follows:
+The Rosenbrock function can be optimized using the `Evolutionary.CMAES()` as follows:
 
 ```@example Evolutionary
 using Optimization, OptimizationEvolutionary

docs/src/optimization_packages/gcmaes.md

@@ -1,5 +1,5 @@
 # GCMAES.jl
-[`GCMAES`](https://github.com/AStupidBear/GCMAES.jl) is a Julia package implementing the **Gradient-based Covariance Matrix Adaptation Evolutionary Strategy** which can utilize the gradient information to speed up the optimization process.
+[`GCMAES`](https://github.com/AStupidBear/GCMAES.jl) is a Julia package implementing the **Gradient-based Covariance Matrix Adaptation Evolutionary Strategy**, which can utilize the gradient information to speed up the optimization process.
 
 ## Installation: OptimizationGCMAES.jl
 
@@ -19,7 +19,7 @@ constraint equations. However, lower and upper constraints set by `lb` and `ub`
 
 ## Example
 
-The Rosenbrock function can optimized using the `GCMAESOpt()` without utilizing the gradient information as follows:
+The Rosenbrock function can be optimized using the `GCMAESOpt()` without utilizing the gradient information as follows:
 
 ```@example GCMAES
 using Optimization, OptimizationGCMAES
@@ -31,7 +31,7 @@ prob = Optimization.OptimizationProblem(f, x0, p, lb = [-1.0,-1.0], ub = [1.0,1.
 sol = solve(prob, GCMAESOpt())
 ```
 
-We can also utilise the gradient information of the optimization problem to aid the optimization as follows:
+We can also utilize the gradient information of the optimization problem to aid the optimization as follows:
 
 ```@example GCMAES
 f = OptimizationFunction(rosenbrock, Optimization.AutoForwardDiff())

docs/src/optimization_packages/mathoptinterface.md

@@ -1,7 +1,7 @@
 # MathOptInterface.jl
 
-[MathOptInterface](https://github.com/jump-dev/MathOptInterface.jl) is Julia
-abstration layer to interface with variety of mathematical optimization solvers.
+[MathOptInterface](https://github.com/jump-dev/MathOptInterface.jl) is a Julia
+abstraction layer to interface with a variety of mathematical optimization solvers.
 
 ## Installation: OptimizationMOI.jl
 
@@ -16,10 +16,10 @@ import Pkg; Pkg.add("OptimizationMOI")
 As of now, the `Optimization` interface to `MathOptInterface` implements only
 the `maxtime` common keyword argument. 
 
-An optimizer which supports the `MathOptInterface` API can be called be called
+An optimizer which supports the `MathOptInterface` API can be called
 directly if no optimizer options have to be defined. 
 
-For example using the [`Ipopt.jl`](https://github.com/jump-dev/Ipopt.jl)
+For example, using the [`Ipopt.jl`](https://github.com/jump-dev/Ipopt.jl)
 optimizer:
 
 
@@ -29,9 +29,9 @@ sol = solve(prob, Ipopt.Optimizer())
 ```
 
 The optimizer options are handled in one of two ways. They can either be set via
-`OptimizationMOI.MOI.OptimizerWithAttributes()` or as keyword argument to `solve`. 
+`OptimizationMOI.MOI.OptimizerWithAttributes()` or as keyword arguments to `solve`. 
 
-For example using the `Ipopt.jl` optimizer:
+For example, using the `Ipopt.jl` optimizer:
 
 ```julia
 using OptimizationMOI, Ipopt

docs/src/optimization_packages/metaheuristics.md

@@ -1,5 +1,5 @@
 # Metaheuristics.jl
-[`Metaheuristics`](https://github.com/jmejia8/Metaheuristics.jl) is a is a Julia package implementing **metaheuristic algorithms** for global optiimization that do not require for the optimized function to be differentiable.
+[`Metaheuristics`](https://github.com/jmejia8/Metaheuristics.jl) is a Julia package implementing **metaheuristic algorithms** for global optimization that does not require for the optimized function to be differentiable.
 
 ## Installation: OptimizationMetaheuristics.jl
 
@@ -15,7 +15,7 @@ import Pkg; Pkg.add("OptimizationMetaheuristics")
 A `Metaheuristics` Single-Objective algorithm is called using one of the following:
 
 * Evolutionary Centers Algorithm: `ECA()`
-* Differential Evolution: `DE()` with 5 different stratgies
+* Differential Evolution: `DE()` with 5 different strategies
   - `DE(strategy=:rand1)` - default strategy
   - `DE(strategy=:rand2)`
   - `DE(strategy=:best1)`
@@ -27,13 +27,13 @@ A `Metaheuristics` Single-Objective algorithm is called using one of the followi
 * Simulated Annealing: `SA()`
 * Whale Optimization Algorithm: `WOA()`
 
-`Metaheuristics` also performs [`Multiobjective optimization`](https://jmejia8.github.io/Metaheuristics.jl/stable/examples/#Multiobjective-Optimization) but this is not yet supported by `Optimization`.
+`Metaheuristics` also performs [`Multiobjective optimization`](https://jmejia8.github.io/Metaheuristics.jl/stable/examples/#Multiobjective-Optimization), but this is not yet supported by `Optimization`.
 
-Each optimizer sets default settings based on the optimization problem but specific parameters can be set as shown in the original [`Documentation`](https://jmejia8.github.io/Metaheuristics.jl/stable/algorithms/) 
+Each optimizer sets default settings based on the optimization problem, but specific parameters can be set as shown in the original [`Documentation`](https://jmejia8.github.io/Metaheuristics.jl/stable/algorithms/) 
 
-Additionally, `Metaheuristics` common settings which would be defined by [`Metaheuristics.Options`](https://jmejia8.github.io/Metaheuristics.jl/stable/api/#Metaheuristics.Options) can be simply passed as special keywoard arguments to `solve` without the need to use the `Metaheuristics.Options` struct.
+Additionally, `Metaheuristics` common settings which would be defined by [`Metaheuristics.Options`](https://jmejia8.github.io/Metaheuristics.jl/stable/api/#Metaheuristics.Options) can be simply passed as special keyword arguments to `solve` without the need to use the `Metaheuristics.Options` struct.
 
-Lastly, information about the optimization problem such as the true optimum is set via [`Metaheuristics.Information`](https://jmejia8.github.io/Metaheuristics.jl/stable/api/#Metaheuristics.Information) and passed as part of the optimizer struct to `solve` e.g. `solve(prob, ECA(information=Metaheuristics.Inoformation(f_optimum = 0.0)))`
+Lastly, information about the optimization problem such as the true optimum is set via [`Metaheuristics.Information`](https://jmejia8.github.io/Metaheuristics.jl/stable/api/#Metaheuristics.Information) and passed as part of the optimizer struct to `solve` e.g., `solve(prob, ECA(information=Metaheuristics.Inoformation(f_optimum = 0.0)))`
 
 
 
@@ -46,7 +46,7 @@ constraint equations. However, lower and upper constraints set by `lb` and `ub`
 
 ## Examples
 
-The Rosenbrock function can optimized using the Evolutionary Centers Algorithm `ECA()` as follows:
+The Rosenbrock function can be optimized using the Evolutionary Centers Algorithm `ECA()` as follows:
 
 ```@example Metaheuristics
 using Optimization, OptimizationMetaheuristics

docs/src/optimization_packages/multistartoptimization.md

@@ -1,5 +1,5 @@
 # MultiStartOptimization.jl
-[`MultistartOptimization`](https://github.com/tpapp/MultistartOptimization.jl) is a is a Julia package implementing a global optimization multistart method which performs local optimization after choosing multiple starting points.
+[`MultistartOptimization`](https://github.com/tpapp/MultistartOptimization.jl) is a Julia package implementing a global optimization multistart method which performs local optimization after choosing multiple starting points.
 
 `MultistartOptimization` requires both a global and local method to be defined. The global multistart method chooses a set of initial starting points from where local the local method starts from.
 
@@ -14,7 +14,7 @@ import Pkg; Pkg.add("OptimizationMultistartOptimization")
 ```
 !!! note
 
-  You also need to load the relevant subpackage for the local method of you choice, for example if you plan to use one of the NLopt.jl's optimizers, you'd install and load OptimizationNLopt as described in the [NLopt.jl](@ref)'s section.
+  You also need to load the relevant subpackage for the local method of your choice, for example if you plan to use one of the NLopt.jl's optimizers, you'd install and load OptimizationNLopt as described in the [NLopt.jl](@ref)'s section.
 
 ## Global Optimizer
 ### Without Constraint Equations
@@ -24,7 +24,7 @@ constraint equations. However, lower and upper constraints set by `lb` and `ub`
 
 ## Examples 
 
-The Rosenbrock function can optimized using `MultistartOptimization.TikTak()` with 100 initial points and the local method `NLopt.LD_LBFGS()` as follows:
+The Rosenbrock function can be optimized using `MultistartOptimization.TikTak()` with 100 initial points and the local method `NLopt.LD_LBFGS()` as follows:
 
 ```@example MultiStart
 using Optimization, OptimizationMultistartOptimization, OptimizationNLopt
@@ -36,7 +36,7 @@ prob = Optimization.OptimizationProblem(f, x0, p, lb = [-1.0,-1.0], ub = [1.0,1.
 sol = solve(prob, MultistartOptimization.TikTak(100), NLopt.LD_LBFGS())
 ```
 
-You can use any `Optimization` optimizers you like. The global method of the `MultistartOptimization` is a positional argument and followed by the local method. This for example means we can perform a multistartoptimization with LBFGS as the optimizer using either the `NLopt.jl` or `Optim.jl` implementation as follows. Moreover, this interface allows you access and adjust all the optimizer settings as you normally would:
+You can use any `Optimization` optimizers you like. The global method of the `MultistartOptimization` is a positional argument and followed by the local method. For example, we can perform a multistartoptimization with LBFGS as the optimizer using either the `NLopt.jl` or `Optim.jl` implementation as follows. Moreover, this interface allows you to access and adjust all the optimizer settings as you normally would:
 
 ```@example MultiStart
 using OptimizationOptimJL