random: remove useless @inline

Author: rfourquet

base/random/RNGs.jl

@@ -49,7 +49,7 @@ srand(rng::RandomDevice) = rng
 
 ### generation of floats
 
-@inline rand(r::RandomDevice, I::FloatInterval) = rand_generic(r, I)
+rand(r::RandomDevice, I::FloatInterval) = rand_generic(r, I)
 
 
 ## MersenneTwister
@@ -130,21 +130,21 @@ hash(r::MersenneTwister, h::UInt) = foldr(hash, h, (r.seed, r.state, r.vals, r.i
 
 ### low level API
 
-@inline mt_avail(r::MersenneTwister) = MTCacheLength - r.idx
-@inline mt_empty(r::MersenneTwister) = r.idx == MTCacheLength
-@inline mt_setfull!(r::MersenneTwister) = r.idx = 0
-@inline mt_setempty!(r::MersenneTwister) = r.idx = MTCacheLength
-@inline mt_pop!(r::MersenneTwister) = @inbounds return r.vals[r.idx+=1]
+mt_avail(r::MersenneTwister) = MTCacheLength - r.idx
+mt_empty(r::MersenneTwister) = r.idx == MTCacheLength
+mt_setfull!(r::MersenneTwister) = r.idx = 0
+mt_setempty!(r::MersenneTwister) = r.idx = MTCacheLength
+mt_pop!(r::MersenneTwister) = @inbounds return r.vals[r.idx+=1]
 
 function gen_rand(r::MersenneTwister)
     dsfmt_fill_array_close1_open2!(r.state, pointer(r.vals), length(r.vals))
     mt_setfull!(r)
 end
 
-@inline reserve_1(r::MersenneTwister) = (mt_empty(r) && gen_rand(r); nothing)
+reserve_1(r::MersenneTwister) = (mt_empty(r) && gen_rand(r); nothing)
 # `reserve` allows one to call `rand_inbounds` n times
 # precondition: n <= MTCacheLength
-@inline reserve(r::MersenneTwister, n::Int) = (mt_avail(r) < n && gen_rand(r); nothing)
+reserve(r::MersenneTwister, n::Int) = (mt_avail(r) < n && gen_rand(r); nothing)
 
 
 ### seeding
@@ -205,21 +205,21 @@ const GLOBAL_RNG = MersenneTwister(0)
 #### helper functions
 
 # precondition: !mt_empty(r)
-@inline rand_inbounds(r::MersenneTwister, ::Close1Open2_64) = mt_pop!(r)
-@inline rand_inbounds(r::MersenneTwister, ::CloseOpen_64) =
+rand_inbounds(r::MersenneTwister, ::Close1Open2_64) = mt_pop!(r)
+rand_inbounds(r::MersenneTwister, ::CloseOpen_64) =
     rand_inbounds(r, Close1Open2()) - 1.0
-@inline rand_inbounds(r::MersenneTwister) = rand_inbounds(r, CloseOpen())
+rand_inbounds(r::MersenneTwister) = rand_inbounds(r, CloseOpen())
 
-@inline rand_ui52_raw_inbounds(r::MersenneTwister) =
+rand_ui52_raw_inbounds(r::MersenneTwister) =
     reinterpret(UInt64, rand_inbounds(r, Close1Open2()))
-@inline rand_ui52_raw(r::MersenneTwister) = (reserve_1(r); rand_ui52_raw_inbounds(r))
+rand_ui52_raw(r::MersenneTwister) = (reserve_1(r); rand_ui52_raw_inbounds(r))
 
-@inline function rand_ui2x52_raw(r::MersenneTwister)
+function rand_ui2x52_raw(r::MersenneTwister)
     reserve(r, 2)
     rand_ui52_raw_inbounds(r) % UInt128 << 64 | rand_ui52_raw_inbounds(r)
 end
 
-@inline function rand_ui104_raw(r::MersenneTwister)
+function rand_ui104_raw(r::MersenneTwister)
     reserve(r, 2)
     rand_ui52_raw_inbounds(r) % UInt128 << 52 ⊻ rand_ui52_raw_inbounds(r)
 end
@@ -229,13 +229,13 @@ rand_ui23_raw(r::MersenneTwister) = rand_ui52_raw(r)
 
 #### floats
 
-@inline rand(r::MersenneTwister, I::FloatInterval_64) = (reserve_1(r); rand_inbounds(r, I))
+rand(r::MersenneTwister, I::FloatInterval_64) = (reserve_1(r); rand_inbounds(r, I))
 
-@inline rand(r::MersenneTwister, I::FloatInterval) = rand_generic(r, I)
+rand(r::MersenneTwister, I::FloatInterval) = rand_generic(r, I)
 
 #### integers
 
-@inline rand(r::MersenneTwister,
+rand(r::MersenneTwister,
              ::Type{T}) where {T<:Union{Bool,Int8,UInt8,Int16,UInt16,Int32,UInt32}} =
                  rand_ui52_raw(r) % T
 
@@ -317,10 +317,10 @@ function rand!(r::MersenneTwister, A::Array{Float64}, n::Int=length(A),
     A
 end
 
-@inline mask128(u::UInt128, ::Type{Float16}) =
+mask128(u::UInt128, ::Type{Float16}) =
     (u & 0x03ff03ff03ff03ff03ff03ff03ff03ff) | 0x3c003c003c003c003c003c003c003c00
 
-@inline mask128(u::UInt128, ::Type{Float32}) =
+mask128(u::UInt128, ::Type{Float32}) =
     (u & 0x007fffff007fffff007fffff007fffff) | 0x3f8000003f8000003f8000003f800000
 
 function rand!(r::MersenneTwister, A::Union{Array{Float16},Array{Float32}},
@@ -408,7 +408,7 @@ end
 
 #### from a range
 
-@inline function rand_lteq(r::AbstractRNG, randfun, u::U, mask::U) where U<:Integer
+function rand_lteq(r::AbstractRNG, randfun, u::U, mask::U) where U<:Integer
     while true
         x = randfun(r) & mask
         x <= u && return x

base/random/generation.jl

@@ -6,12 +6,12 @@
 
 ### GLOBAL_RNG fallback for all types
 
-@inline rand(T::Type) = rand(GLOBAL_RNG, T)
+rand(::Type{T}) where {T} = rand(GLOBAL_RNG, T)
 
 ### random floats
 
 # CloseOpen(T) is the fallback for an AbstractFloat T
-@inline rand(r::AbstractRNG=GLOBAL_RNG, ::Type{T}=Float64) where {T<:AbstractFloat} =
+rand(r::AbstractRNG=GLOBAL_RNG, ::Type{T}=Float64) where {T<:AbstractFloat} =
     rand(r, CloseOpen(T))
 
 # generic random generation function which can be used by RNG implementors
@@ -95,8 +95,8 @@ rand_generic(rng::AbstractRNG, I::FloatInterval{BigFloat}) =
 rand_ui10_raw(r::AbstractRNG) = rand(r, UInt16)
 rand_ui23_raw(r::AbstractRNG) = rand(r, UInt32)
 
-@inline rand_ui52_raw(r::AbstractRNG) = reinterpret(UInt64, rand(r, Close1Open2()))
-@inline rand_ui52(r::AbstractRNG) = rand_ui52_raw(r) & 0x000fffffffffffff
+rand_ui52_raw(r::AbstractRNG) = reinterpret(UInt64, rand(r, Close1Open2()))
+rand_ui52(r::AbstractRNG) = rand_ui52_raw(r) & 0x000fffffffffffff
 
 ### random complex numbers
 
@@ -131,10 +131,14 @@ rand(                dims::Dims)       = rand(GLOBAL_RNG, dims)
 rand(r::AbstractRNG, dims::Integer...) = rand(r, Dims(dims))
 rand(                dims::Integer...) = rand(Dims(dims))
 
-rand(r::AbstractRNG, T::Type, dims::Dims)                   = rand!(r, Array{T}(dims))
-rand(                T::Type, dims::Dims)                   = rand(GLOBAL_RNG, T, dims)
-rand(r::AbstractRNG, T::Type, d::Integer, dims::Integer...) = rand(r, T, Dims((d, dims...)))
-rand(                T::Type, d::Integer, dims::Integer...) = rand(T, Dims((d, dims...)))
+rand(r::AbstractRNG, ::Type{T}, dims::Dims) where {T} = rand!(r, Array{T}(dims))
+rand(                ::Type{T}, dims::Dims) where {T} = rand(GLOBAL_RNG, T, dims)
+
+rand(r::AbstractRNG, ::Type{T}, d::Integer, dims::Integer...) where {T} =
+    rand(r, T, Dims((d, dims...)))
+
+rand(                ::Type{T}, d::Integer, dims::Integer...) where {T} =
+    rand(T, Dims((d, dims...)))
 # note: the above methods would trigger an ambiguity warning if d was not separated out:
 # rand(r, ()) would match both this method and rand(r, dims::Dims)
 # moreover, a call like rand(r, NotImplementedType()) would be an infinite loop

base/random/normal.jl

@@ -45,7 +45,7 @@ julia> randn(rng, Complex64, (2, 3))
 end
 
 # this unlikely branch is put in a separate function for better efficiency
-function randn_unlikely(rng, idx, rabs, x)
+@noinline function randn_unlikely(rng, idx, rabs, x)
     @inbounds if idx == 0
         while true
             xx = -ziggurat_nor_inv_r*log(rand(rng))
@@ -93,7 +93,7 @@ julia> randexp(rng, 3, 3)
  0.695867  0.693292  0.643644
 ```
 """
-@inline function randexp(rng::AbstractRNG=GLOBAL_RNG)
+function randexp(rng::AbstractRNG=GLOBAL_RNG)
     @inbounds begin
         ri = rand_ui52(rng)
         idx = ri & 0xFF
@@ -103,7 +103,7 @@ julia> randexp(rng, 3, 3)
     end
 end
 
-function randexp_unlikely(rng, idx, x)
+@noinline function randexp_unlikely(rng, idx, x)
     @inbounds if idx == 0
         return ziggurat_exp_r - log(rand(rng))
     elseif (fe[idx] - fe[idx+1])*rand(rng) + fe[idx+1] < exp(-x)