Spell check

docs/src/developers/extensions.md

@@ -54,7 +54,7 @@ model = Model()
 Just as `Bin` and `Int` create binary and integer variables, you can extend
 the [`@variable`](@ref) macro to create new types of variables. Here is an
 explanation by example, where we create a `AddTwice` type, that creates a tuple
-of two JuMP variables instead of a single varaible.
+of two JuMP variables instead of a single variable.
 
 First, create a new struct. This can be anything. Our struct holds a
 [`VariableInfo`](@ref) object that stores bound information, and whether the

docs/src/developers/roadmap.md

@@ -11,22 +11,22 @@ JuMP 1.0 will be ready to release roughly when all of these tasks are completed.
 Some but not all of these tasks are summarized in the
 [JuMP 1.0 milestone](https://github.com/jump-dev/JuMP.jl/milestone/12).
 
-- Create a website for JuMP. (**Done**: [jump.dev](https://jump.dev))
+- Create a website for JuMP (**Done**: [jump.dev](https://jump.dev))
 - Deprecate the JuliaOpt organization and move repositories to the
-  [JuMP-dev](https://github.com/JuMP-dev) organization. (**Done**)
-- Address major regressions from JuMP 0.18.
+  [JuMP-dev](https://github.com/JuMP-dev) organization (**Done**)
+- Address major regressions from JuMP 0.18
   - Performance ([#1403](https://github.com/jump-dev/JuMP.jl/issues/1403),
                  [#1654](https://github.com/jump-dev/JuMP.jl/issues/1654),
                  [#1607](https://github.com/jump-dev/JuMP.jl/issues/1607))
   - Callbacks (**Done**: see `examples/callbacks.jl`)
   - Column generation syntax (**Done**: see `examples/cutting_stock_column_generation.jl`)
   - Support for second-order cones in Gurobi, CPLEX, and Xpress (**Done**)
-- Fix issues that we promised MOI would fix.
+- Fix issues that we promised MOI would fix
   - Checking feasibility of solutions (**Done**: [#2466](https://github.com/jump-dev/JuMP.jl/pull/2466))
   - Accessing IIS (**Done**: see [Conflicts](@ref))
   - Accessing multiple results from solvers (**Done**: [Gurobi#392](https://github.com/jump-dev/Gurobi.jl/pull/392))
   - Dual warm-starts (**Done**: [#2214](https://github.com/jump-dev/JuMP.jl/pull/2214))
-- Address “easy” usability issues
+- Address "easy" usability issues
   - Line numbers in error messages (**Done**: [#2276](https://github.com/jump-dev/JuMP.jl/pull/2276))
   - LP sensitivity summary (**Done**: see [Sensitivity analysis for LP](@ref))
   - Inferred element types for collections in macros (**Done**: [#2070](https://github.com/jump-dev/JuMP.jl/pull/2070))
@@ -35,11 +35,11 @@ Some but not all of these tasks are summarized in the
   - Separate how-to, concept explanation, and technical reference following the
     [Divio recommendations](https://www.divio.com/blog/documentation/) (**Done**)
   - Fully integrate [JuMPTutorials](https://github.com/jump-dev/JuMPTutorials.jl)
-    with JuMP's documentation. (**Done**)
+    with JuMP's documentation (**Done**)
 - Developer experience
-  - Get JuMP’s unit tests running faster. See [#1745](https://github.com/jump-dev/JuMP.jl/pull/1745). (**Done**)
-- All solvers should complete the transition to MOI. (**Done**)
-- Provide packages for installing Bonmin and Couenne.
+  - Get JuMP's unit tests running faster. See [#1745](https://github.com/jump-dev/JuMP.jl/pull/1745). (**Done**)
+- All solvers should complete the transition to MOI (**Done**)
+- Provide packages for installing Bonmin and Couenne
 - [MathOptFormat](https://github.com/odow/MathOptFormat.jl) 1.0 (**Done**)
 
 ## MOI 1.0

docs/src/developers/style.md

@@ -382,7 +382,7 @@ points more specific to Julia and documentation that use [Documenter](https://gi
 - Every exported object needs a docstring
 - All examples in docstrings should be [`jldoctests`](https://juliadocs.github.io/Documenter.jl/stable/man/doctests/)
 - Always use complete English sentences with proper punctuation
-- Do not terminate lists swith punctuation (e.g., as in this doc)
+- Do not terminate lists with punctuation (e.g., as in this doc)
 
 Here is an example:
 ````julia

docs/src/tutorials/Conic programs/tips_and_tricks.jl

@@ -221,4 +221,4 @@ objective_value(model)
 # ## Other Cones and Functions
 
 # For other cones supported by JuMP, check out the
-# [MathOptInterface Manual](http://jump.dev/MathOptInterface.jl/stable).
+# [MathOptInterface Manual](https://jump.dev/MathOptInterface.jl/stable).

docs/src/tutorials/Getting started/an_introduction_to_julia.jl

@@ -54,7 +54,7 @@ nothing #hide
 #     typed (e.g., `1 - 2`), as well as the evaluation of the expression (`-1`).
 
 # Did you notice how Julia didn't print `.0` after some of the numbers? Julia is
-# a dynamic language, which means you never have to explictly declare the type
+# a dynamic language, which means you never have to explicitly declare the type
 # of a variable. However, in the background, Julia is giving each variable a
 # type. Check the type of something using the `typeof` function:
 
@@ -91,12 +91,12 @@ nothing #hide
 π
 
 # !!! tip
-#     To make π (and most other greek letters), type `\pi` and then press
+#     To make π (and most other Greek letters), type `\pi` and then press
 #     `[TAB]`.
 
 typeof(π)
 
-# Athough if we do math with irrational numbers, they get converted to
+# Although if we do math with irrational numbers, they get converted to
 # `Float64`:
 
 typeof(2π / 3)
@@ -134,7 +134,7 @@ sin(2π / 3) - √3 / 2
 
 # One way of explaining this difference is to consider how we would write
 # `1 / 3` and `2 / 3` using only four digits after the decimal point. We would
-# write `1 / 3` as `0.3333`, and `2 / 3` as `0.6667`. So, depiste the fact that
+# write `1 / 3` as `0.3333`, and `2 / 3` as `0.6667`. So, despite the fact that
 # `2 * (1 / 3) == 2 / 3`, `2 * 0.3333 == 0.6666 != 0.6667`.
 
 # Let's try that again using ≈ (`\approx + [TAB]`) instead of `==`:
@@ -189,7 +189,7 @@ b = [5, 6]
 A = [1.0 2.0; 3.0 4.0]
 
 # Note how this time the type is `Array{Float64, 2}`; the elements are `Float64`
-# and there are `2` dimenions.
+# and there are `2` dimensions.
 
 # We can do linear algebra:
 
@@ -378,7 +378,7 @@ end
 # ## Comprehensions
 
 # Similar to languages like Haskell and Python, Julia supports the use of simple
-# loops in the construction of arrays and dictionaries, called comprehenions.
+# loops in the construction of arrays and dictionaries, called comprehensions.
 #
 # A list of increasing integers:
 
@@ -487,7 +487,7 @@ catch err; showerror(stdout, err) end  #hide
 # ### Broadcasting
 
 # In the example above, we didn't define what to do if `f` was passed an
-# `Array`. Luckily, Julia provides a convienient syntax for mapping `f`
+# `Array`. Luckily, Julia provides a convenient syntax for mapping `f`
 # element-wise over arrays! Just add a `.` between the name of the function and
 # the opening `(`. This works for _any_ function, including functions with
 # multiple arguments. For example:
@@ -525,7 +525,7 @@ println("mutable_type: $(mutable_type)")
 println("immutable_type: $(immutable_type)")
 
 # Because `Vector{Int}` is a mutable type, modifying the variable inside the
-# function changed the value outside of the function. In constrast, the change
+# function changed the value outside of the function. In contrast, the change
 # to `immutable_type` didn't modify the value outside the function.
 
 # You can check mutability with the `isimmutable` function:
@@ -561,7 +561,7 @@ Random.seed!(33)
 # Pkg.add("JuMP")
 # ```
 
-# For a complete list of registed Julia packages see the package listing at
+# For a complete list of registered Julia packages see the package listing at
 # [JuliaHub](https://juliahub.com).
 
 # From time to you may wish to use a Julia package that is not registered.  In

docs/src/tutorials/Getting started/variables_constraints_objective.jl

@@ -124,8 +124,8 @@ u = [10; 11; 12; 13; 14; 15; 16; 17; 18; 19]
 
 # ### Variable types
 
-# The last arguement to the `@variable` macro is usually the variable type. Here
-# we'll look at how to specifiy the variable type.
+# The last argument to the `@variable` macro is usually the variable type. Here
+# we'll look at how to specify the variable type.
 
 # #### Integer variables
 
@@ -169,7 +169,7 @@ model = Model()
 # ### Constraint references
 
 # While calling the `@constraint` macro, we can also set up a constraint
-# reference. Such a referrence is useful for obtaining additional information
+# reference. Such a reference is useful for obtaining additional information
 # about the constraint, such as its dual solution.
 
 @constraint(model, con, x <= 4)

docs/src/tutorials/Getting started/working_with_data_files.jl

@@ -75,8 +75,8 @@ import DataFrames
 import XLSX
 
 # To read a Excel file into a DataFrame, we use the following julia code. The
-# first arguement to the `readtable` function is the file to be read and the
-# second arguement is the name of the sheet.
+# first argument to the `readtable` function is the file to be read and the
+# second argument is the name of the sheet.
 
 excel_df = DataFrames.DataFrame(
     XLSX.readtable(joinpath(DATA_DIR, "SalesData.xlsx"), "SalesOrders")...
@@ -111,14 +111,14 @@ csv_df = CSV.read(joinpath(DATA_DIR, "StarWars.csv"), DataFrames.DataFrame)
 
 ss_df = CSV.read(joinpath(DATA_DIR, "Cereal.txt"), DataFrames.DataFrame)
 
-# We can also specify the delimiter by passing the `delim` arguement.
+# We can also specify the delimiter by passing the `delim` argument.
 
 delim_df = CSV.read(
     joinpath(DATA_DIR, "Soccer.txt"), DataFrames.DataFrame, delim = "::"
 )
 
 # Note that by default, are read-only. If we wish to make changes to the data
-# read, we pass the `copycols = true` arguement in the function call.
+# read, we pass the `copycols = true` argument in the function call.
 
 ss_df = CSV.read(
     joinpath(DATA_DIR, "Cereal.txt"), DataFrames.DataFrame, copycols = true
@@ -253,8 +253,8 @@ end
 # * 1 = no visa required for travel
 # * 0 = visa required for travel
 
-# Let us assossciate each passport with a decision variable $pass_{cntr}$ for
-# each country. We want to minize the sum $\sum pass_{cntr}$ over all countries.
+# Let us associate each passport with a decision variable $pass_{cntr}$ for
+# each country. We want to minimize the sum $\sum pass_{cntr}$ over all countries.
 
 # Since we wish to visit all the countries, for every country, we should own at
 # least one passport that lets us travel to that country visa free. For one
@@ -280,7 +280,7 @@ import GLPK
 
 World = names(passport_data)[2:end]
 
-# Then, create the model and intialize the decision variables:
+# Then, create the model and initialize the decision variables:
 model = Model(GLPK.Optimizer)
 @variable(model, pass[cntr in World], Bin)