diff --git a/base/docs/helpdb/Base.jl b/base/docs/helpdb/Base.jl index bf42c1bdd1f96..4e3688afacdf7 100644 --- a/base/docs/helpdb/Base.jl +++ b/base/docs/helpdb/Base.jl @@ -4360,7 +4360,7 @@ position """ selectperm(v, k, [alg=,] [by=,] [lt=,] [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 diff --git a/base/linalg/schur.jl b/base/linalg/schur.jl index 445b444db2455..45d679011102b 100644 --- a/base/linalg/schur.jl +++ b/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`. diff --git a/base/linalg/triangular.jl b/base/linalg/triangular.jl index 30110711cd6d7..c5ec031b2c973 100644 --- a/base/linalg/triangular.jl +++ b/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 diff --git a/base/managers.jl b/base/managers.jl index b53503e03898b..7164bee7f0721 100644 --- a/base/managers.jl +++ b/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` diff --git a/doc/manual/conversion-and-promotion.rst b/doc/manual/conversion-and-promotion.rst index 7d37fc18d843b..8e3a06c2a2198 100644 --- a/doc/manual/conversion-and-promotion.rst +++ b/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 `_:: +(x::Number, y::Number) = +(promote(x,y)...) diff --git a/doc/stdlib/arrays.rst b/doc/stdlib/arrays.rst index 9a4a5d203bb53..ccad51321734d 100644 --- a/doc/stdlib/arrays.rst +++ b/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!`\ . + diff --git a/doc/stdlib/linalg.rst b/doc/stdlib/linalg.rst index 4763985c80596..00e05696f5b32 100644 --- a/doc/stdlib/linalg.rst +++ b/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 diff --git a/doc/stdlib/sort.rst b/doc/stdlib/sort.rst index 60ab3e1aa15be..671284119b9bc 100644 --- a/doc/stdlib/sort.rst +++ b/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=,] [by=,] [lt=,] [rev=false,] [initialized=false]) diff --git a/src/builtins.c b/src/builtins.c index abe9de5a79c76..4c25cd8562ed6 100644 --- a/src/builtins.c +++ b/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 diff --git a/test/perf/kernel/go_benchmark.c b/test/perf/kernel/go_benchmark.c index dfe12b8b09d2b..a1b2a93dfb52d 100644 --- a/test/perf/kernel/go_benchmark.c +++ b/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]; diff --git a/test/perf/kernel/go_benchmark.jl b/test/perf/kernel/go_benchmark.jl index 8c8ab39e47489..2f31b52a7bf0b 100644 --- a/test/perf/kernel/go_benchmark.jl +++ b/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