Rename logspace to logrange

While the accuracy of terminology argument doesn't apply as strongly to
this function as it does for `linspace`, it still makes sense to make
this name match its `lin*` counterpart.

Author: ararslan

NEWS.md

@@ -978,6 +978,8 @@ Deprecated or removed
   * `linspace` and `LinSpace` have been renamed to `linrange` and `LinRange`, respectively
     ([#TODO]).
 
+  * `logspace` has been renamed to `logrange` ([#TODO]).
+
   * `similar(::Associative)` has been deprecated in favor of `empty(::Associative)`, and
     `similar(::Associative, ::Pair{K, V})` has been deprecated in favour of
     `empty(::Associative, K, V)` ([#24390]).

base/deprecated.jl

@@ -897,10 +897,11 @@ end
 
 # issue #24794
 @deprecate linspace(start, stop)     linrange(start, stop, 50)
-@deprecate logspace(start, stop)     logspace(start, stop, 50)
+@deprecate logspace(start, stop)     logrange(start, stop, 50)
 
 @deprecate linspace linrange
 @deprecate_binding LinSpace LinRange
+@deprecate logspace logrange
 
 @deprecate merge!(repo::LibGit2.GitRepo, args...; kwargs...) LibGit2.merge!(repo, args...; kwargs...)
 @deprecate push!(w::LibGit2.GitRevWalker, arg) LibGit2.push!(w, arg)

base/exports.jl

@@ -401,7 +401,7 @@ export
     last,
     linearindices,
     linrange,
-    logspace,
+    logrange,
     mapslices,
     max,
     maximum!,

base/range.jl

@@ -211,7 +211,7 @@ StepRangeLen(ref::R, step::S, len::Integer, offset::Integer = 1) where {R,S} =
 StepRangeLen{T}(ref::R, step::S, len::Integer, offset::Integer = 1) where {T,R,S} =
     StepRangeLen{T,R,S}(ref, step, len, offset)
 
-## linrange and logspace
+## linrange and logrange
 
 struct LinRange{T} <: AbstractRange{T}
     start::T
@@ -321,20 +321,20 @@ function print_range(io::IO, r::AbstractRange,
 end
 
 """
-    logspace(start::Real, stop::Real, n::Integer; base=10)
+    logrange(start::Real, stop::Real, n::Integer; base=10)
 
 Construct a vector of `n` logarithmically spaced numbers from `base^start` to `base^stop`.
 
 ```jldoctest
-julia> logspace(1.,10.,5)
+julia> logrange(1.,10.,5)
 5-element Array{Float64,1}:
      10.0
    1778.2794100389228
  316227.7660168379
       5.623413251903491e7
       1.0e10
 
-julia> logspace(1.,10.,5,base=2)
+julia> logrange(1.,10.,5,base=2)
 5-element Array{Float64,1}:
     2.0
     9.513656920021768
@@ -343,7 +343,7 @@ julia> logspace(1.,10.,5,base=2)
  1024.0
 ```
 """
-logspace(start::Real, stop::Real, n::Integer; base=10) = base.^linrange(start, stop, n)
+logrange(start::Real, stop::Real, n::Integer; base=10) = base.^linrange(start, stop, n)
 
 ## interface implementations
 

doc/src/base/arrays.md

@@ -33,7 +33,7 @@ Base.fill!
 Base.similar(::AbstractArray)
 Base.similar(::Any, ::Tuple)
 Base.linrange
-Base.logspace
+Base.logrange
 ```
 
 ## Basic functions

examples/lru_test.jl

@@ -10,7 +10,7 @@ get_str(i) = String(vcat(map(x->[x>>4; x&0x0F], reinterpret(UInt8, [Int32(i)])).
 isbounded(::Type{L}) where {L<:LRUExample.LRU} = any(map(n->n==:maxsize, fieldnames(L)))
 isbounded(l::L) where {L<:LRUExample.LRU} = isbounded(L)
 
-nmax = round.(Int, logspace(2, 5, 4))
+nmax = round.(Int, logrange(2, 5, 4))
 
 function lrutest()
     #println("LRU consistency tests")

test/compiler/compiler.jl

@@ -585,7 +585,7 @@ tpara18457(::Type{A}) where {A<:AbstractMyType18457} = tpara18457(supertype(A))
 
     function FOO_19322(Y::AbstractMatrix; frac::Float64=0.3, nbins::Int=100, n_sims::Int=100)
         num_iters, num_chains = size(Y)
-        start_iters = unique([1; [round(Int64, s) for s in logspace(log(10,100),
+        start_iters = unique([1; [round(Int64, s) for s in logrange(log(10,100),
                                                                     log(10,num_iters/2),nbins-1)]])
         result = zeros(Float64, 10, length(start_iters) * num_chains)
         j=1

test/ranges.jl

@@ -1210,14 +1210,14 @@ end
     @test Float32(linsp.ref) ≈ linsp.ref.hi + linsp.ref.lo
 end
 
-@testset "logspace" begin
+@testset "logrange" begin
     n = 10; a = 2; b = 4
     # test default values; base = 10
-    @test logspace(a, b, 50) == 10 .^ linrange(a, b, 50)
-    @test logspace(a, b, n) == 10 .^ linrange(a, b, n)
+    @test logrange(a, b, 50) == 10 .^ linrange(a, b, 50)
+    @test logrange(a, b, n) == 10 .^ linrange(a, b, n)
     for base in (10, 2, ℯ)
-        @test logspace(a, b, 50, base=base) == base.^linrange(a, b, 50)
-        @test logspace(a, b, n, base=base) == base.^linrange(a, b, n)
+        @test logrange(a, b, 50, base=base) == base.^linrange(a, b, 50)
+        @test logrange(a, b, n, base=base) == base.^linrange(a, b, n)
     end
 end