Fix a bunch of 'the the' typos

base/docs/helpdb/Base.jl

@@ -4360,7 +4360,7 @@ position
 """
     selectperm(v, k, [alg=<algorithm>,] [by=<transform>,] [lt=<comparison>,] [rev=false])
 
-Return a partial permutation of the the vector `v`, according to the order specified by
+Return a partial permutation of the vector `v`, according to the order specified by
 `by`, `lt` and `rev`, so that `v[output]` returns the first `k` (or range of adjacent values
 if `k` is a range) values of a fully sorted version of `v`. If `k` is a single index
 (Integer), an array of the first `k` indices is returned; if `k` is a range, an array of

base/linalg/schur.jl

@@ -72,7 +72,7 @@ end
 
 Reorders the Schur factorization `F` of a matrix `A = Z*T*Z'` according to the logical array
 `select` returning the reordered factorization `F` object. The selected eigenvalues appear
-in the leading diagonal of `F[:Schur]` and the the corresponding leading columns of
+in the leading diagonal of `F[:Schur]` and the corresponding leading columns of
 `F[:vectors]` form an orthogonal/unitary basis of the corresponding right invariant
 subspace. In the real case, a complex conjugate pair of eigenvalues must be either both
 included or both excluded via `select`.
@@ -91,7 +91,7 @@ ordschur!{Ty<:BlasFloat}(T::StridedMatrix{Ty}, Z::StridedMatrix{Ty}, select::Uni
 
 Reorders the Schur factorization of a real matrix `A = Z*T*Z'` according to the logical
 array `select` returning the reordered matrices `T` and `Z` as well as the vector of
-eigenvalues `λ`. The selected eigenvalues appear in the leading diagonal of `T` and the the
+eigenvalues `λ`. The selected eigenvalues appear in the leading diagonal of `T` and the
 corresponding leading columns of `Z` form an orthogonal/unitary basis of the corresponding
 right invariant subspace. In the real case, a complex conjugate pair of eigenvalues must be
 either both included or both excluded via `select`.

base/linalg/triangular.jl

@@ -1557,7 +1557,7 @@ for (f, g) in ((:/, :A_rdiv_B!), (:A_rdiv_Bc, :A_rdiv_Bc!), (:A_rdiv_Bt, :A_rdiv
 end
 end
 
-# If these are not defined, the they will fallback to the versions in matmul.jl
+# If these are not defined, they will fallback to the versions in matmul.jl
 # and dispatch to generic_matmatmul! which is very costly to compile. The methods
 # below might compute an unnecessary copy. Eliminating the copy requires adding
 # all the promotion logic here once again. Since these methods are probably relatively

base/managers.jl

@@ -201,7 +201,7 @@ function ssh_tunnel(user, host, bind_addr, port, sshflags)
     # the connection is forwarded to `port` on the remote server over the local port `localport`
     # the -f option backgrounds the ssh session
     # `sleep 60` command specifies that an alloted time of 60 seconds is allowed to start the
-    # remote julia process and estabilish the network connections specified the the process topology.
+    # remote julia process and establish the network connections specified by the process topology.
     # If no connections are made within 60 seconds, ssh will exit and an error will be printed on the
     # process that launched the remote process.
     ssh = `ssh -T -a -x -o ExitOnForwardFailure=yes`

doc/manual/conversion-and-promotion.rst

@@ -268,7 +268,7 @@ That is really all there is to using promotions. The rest is just a
 matter of clever application, the most typical "clever" application
 being the definition of catch-all methods for numeric operations like
 the arithmetic operators ``+``, ``-``, ``*`` and ``/``. Here are some of
-the the catch-all method definitions given in
+the catch-all method definitions given in
 `promotion.jl <https://github.com/JuliaLang/julia/blob/master/base/promotion.jl>`_::
 
     +(x::Number, y::Number) = +(promote(x,y)...)

doc/stdlib/arrays.rst

@@ -1067,3 +1067,4 @@ dense counterparts. The following functions are specific to sparse arrays.
    Generates a copy of ``x`` and removes numerical zeros from that copy, optionally trimming excess space from the result's ``nzind`` and ``nzval`` arrays when ``trim`` is ``true``\ .
 
    For an in-place version and algorithmic information, see :func:`Base.SparseArrays.dropzeros!`\ .
+

doc/stdlib/linalg.rst

@@ -614,7 +614,7 @@ Linear algebra functions in Julia are largely implemented by calling functions f
 
    .. Docstring generated from Julia source
 
-   Reorders the Schur factorization ``F`` of a matrix ``A = Z*T*Z'`` according to the logical array ``select`` returning the reordered factorization ``F`` object. The selected eigenvalues appear in the leading diagonal of ``F[:Schur]`` and the the corresponding leading columns of ``F[:vectors]`` form an orthogonal/unitary basis of the corresponding right invariant subspace. In the real case, a complex conjugate pair of eigenvalues must be either both included or both excluded via ``select``\ .
+   Reorders the Schur factorization ``F`` of a matrix ``A = Z*T*Z'`` according to the logical array ``select`` returning the reordered factorization ``F`` object. The selected eigenvalues appear in the leading diagonal of ``F[:Schur]`` and the corresponding leading columns of ``F[:vectors]`` form an orthogonal/unitary basis of the corresponding right invariant subspace. In the real case, a complex conjugate pair of eigenvalues must be either both included or both excluded via ``select``\ .
 
 .. function:: ordschur!(F::Schur, select::Union{Vector{Bool},BitVector}) -> F::Schur
 
@@ -626,7 +626,7 @@ Linear algebra functions in Julia are largely implemented by calling functions f
 
    .. Docstring generated from Julia source
 
-   Reorders the Schur factorization of a real matrix ``A = Z*T*Z'`` according to the logical array ``select`` returning the reordered matrices ``T`` and ``Z`` as well as the vector of eigenvalues ``λ``\ . The selected eigenvalues appear in the leading diagonal of ``T`` and the the corresponding leading columns of ``Z`` form an orthogonal/unitary basis of the corresponding right invariant subspace. In the real case, a complex conjugate pair of eigenvalues must be either both included or both excluded via ``select``\ .
+   Reorders the Schur factorization of a real matrix ``A = Z*T*Z'`` according to the logical array ``select`` returning the reordered matrices ``T`` and ``Z`` as well as the vector of eigenvalues ``λ``\ . The selected eigenvalues appear in the leading diagonal of ``T`` and the corresponding leading columns of ``Z`` form an orthogonal/unitary basis of the corresponding right invariant subspace. In the real case, a complex conjugate pair of eigenvalues must be either both included or both excluded via ``select``\ .
 
 .. function:: ordschur!(T::StridedMatrix, Z::StridedMatrix, select::Union{Vector{Bool},BitVector}) -> T::StridedMatrix, Z::StridedMatrix, λ::Vector
 

doc/stdlib/sort.rst

@@ -205,7 +205,7 @@ Order-Related Functions
 
    .. Docstring generated from Julia source
 
-   Return a partial permutation of the the vector ``v``\ , according to the order specified by ``by``\ , ``lt`` and ``rev``\ , so that ``v[output]`` returns the first ``k`` (or range of adjacent values if ``k`` is a range) values of a fully sorted version of ``v``\ . If ``k`` is a single index (Integer), an array of the first ``k`` indices is returned; if ``k`` is a range, an array of those indices is returned. Note that the handling of integer values for ``k`` is different from ``select`` in that it returns a vector of ``k`` elements instead of just the ``k`` th element. Also note that this is equivalent to, but more efficient than, calling ``sortperm(...)[k]``
+   Return a partial permutation of the vector ``v``\ , according to the order specified by ``by``\ , ``lt`` and ``rev``\ , so that ``v[output]`` returns the first ``k`` (or range of adjacent values if ``k`` is a range) values of a fully sorted version of ``v``\ . If ``k`` is a single index (Integer), an array of the first ``k`` indices is returned; if ``k`` is a range, an array of those indices is returned. Note that the handling of integer values for ``k`` is different from ``select`` in that it returns a vector of ``k`` elements instead of just the ``k`` th element. Also note that this is equivalent to, but more efficient than, calling ``sortperm(...)[k]``
 
 .. function:: selectperm!(ix, v, k, [alg=<algorithm>,] [by=<transform>,] [lt=<comparison>,] [rev=false,] [initialized=false])
 

src/builtins.c

@@ -480,7 +480,7 @@ JL_CALLABLE(jl_f__apply)
         newargs[0] = (jl_value_t*)arg_heap;
         newargs = jl_svec_data(arg_heap);
     }
-    // GC Note: here we assume that the the return value of `jl_svecref`,
+    // GC Note: here we assume that the return value of `jl_svecref`,
     //          `jl_array_ptr_ref` will not be young if `arg_heap` becomes old
     //          since they are allocated before `arg_heap`. Otherwise,
     //          we need to add write barrier for !onstack

test/perf/kernel/go_benchmark.c

@@ -284,7 +284,7 @@ play_move(int i, int j, int color)
      * than one direction.
      */
     if (on_board(ai, aj) && board[pos2] == color && !same_string(pos, pos2)) {
-      /* The strings are linked together simply by swapping the the
+      /* The strings are linked together simply by swapping the
        * next_stone pointers.
        */
       int tmp = next_stone[pos2];

test/perf/kernel/go_benchmark.jl

@@ -269,7 +269,7 @@ function play_move(board::Board, i::Int, j::Int, color::Int)
     # may happen if the same string neighbors the new stone in more
     # than one direction.
     if on_board(board, ai, aj) && board[pos2] == color && !same_string(board, pos, pos2)
-      # The strings are linked together simply by swapping the the
+      # The strings are linked together simply by swapping the
       # next_stone pointers.
       (board.next_stone[pos], board.next_stone[pos2]) = (board.next_stone[pos2], board.next_stone[pos])
     end