Converting between integer types

base/math.jl

@@ -41,9 +41,11 @@ end
 
 """
     clamp(x, lo, hi)
+    clamp(x, T)
 
 Return `x` if `lo <= x <= hi`. If `x < lo`, return `lo`. If `x > hi`, return `hi`. Arguments
-are promoted to a common type.
+are promoted to a common type. If the type `T` is given `lo` and `hi` are typemin(T)
+and typemax(T) respectively and the result is converted to `T`
 
 ```jldoctest
 julia> clamp.([pi, 1.0, big(10.)], 2., 9.)
@@ -59,10 +61,13 @@ clamp(x::X, lo::L, hi::H) where {X,L,H} =
                   convert(promote_type(X,L,H), lo),
                   convert(promote_type(X,L,H), x)))
 
+clamp( x, ::Type{T} ) where {T} = clamp( x, typemin(T), typemax(T) ) % T
 """
     clamp!(array::AbstractArray, lo, hi)
+    clamp!(array::AbstractArray, T)
 
-Restrict values in `array` to the specified range, in-place.
+Restrict values in `array` to the specified range, in-place.  If the type `T` is
+given `lo` and `hi` are typemin(T) and typemax(T) respectively
 See also [`clamp`](@ref).
 """
 function clamp!(x::AbstractArray, lo, hi)
@@ -72,6 +77,13 @@ function clamp!(x::AbstractArray, lo, hi)
     x
 end
 
+function clamp!(x::AbstractArray, ::Type{T}) where {T}
+    @inbounds for i in eachindex(x)
+        x[i] = clamp(x[i], T )
+    end
+    x
+end
+
 # evaluate p[1] + x * (p[2] + x * (....)), i.e. a polynomial via Horner's rule
 macro horner(x, p...)
     ex = esc(p[end])

test/math.jl

@@ -15,11 +15,22 @@
 
     @test clamp.([0, 1, 2, 3, 4], 1.0, 3.0) == [1.0, 1.0, 2.0, 3.0, 3.0]
     @test clamp.([0 1; 2 3], 1.0, 3.0) == [1.0 1.0; 2.0 3.0]
+
+    @test clamp(-200,Int8) === typemin(Int8)
+    @test clamp(100,Int8) === Int8(100)
+    @test clamp(200,Int8) === typemax(Int8)
+
     begin
         x = [0.0, 1.0, 2.0, 3.0, 4.0]
         clamp!(x, 1, 3)
         @test x == [1.0, 1.0, 2.0, 3.0, 3.0]
     end
+    begin
+        x = [-1000,0,1000]
+        clamp!(x, UInt8)
+        @test x == UInt8[0, 0, 255]
+    end
+
 end
 
 @testset "constants" begin