Add tests for all those complex functions (and a bunch of real ones)

Author: PhilipVinc

src/device/cuda/math.jl

@@ -36,10 +36,10 @@
 @inline atan2(x::Float64, y::Float64) = @wrap __nv_atan2(x::double, y::double)::double
 @inline atan2(x::Float32, y::Float32) = @wrap __nv_atan2f(x::float, y::float)::float
 
-@inline angle(x::ComplexF64) = atan2(x.re, y.im)
-@inline angle(x::ComplexF32) = atan2(x.re, y.im)
-@inline angle(x::Float64) = 0.0
-@inline angle(x::Float32) = 0.0
+@inline angle(x::ComplexF64) = atan2(x.im, x.re)
+@inline angle(x::ComplexF32) = atan2(x.im, x.re)
+@inline angle(x::Float64) = signbit(x) * -3.141592653589793
+@inline angle(x::Float32) = signbit(x) * -3.1415927f0
 
 ## hyperbolic
 

test/device/cuda.jl

@@ -99,9 +99,129 @@ end
         val = Array(buf)
         @test val[] ≈ x^y
     end
-end
 
 
+    @testset "angle" begin
+        buf  = CuTestArray(zeros(Float32))
+        cbuf = CuTestArray(zeros(Float32))
+
+        function cuda_kernel(a, x)
+            a[] = CUDAnative.angle(x)
+            return
+        end
+
+        #op(::Float32)
+        x   = rand(Float32)
+        @cuda cuda_kernel(buf, x)
+        val = Array(buf)
+        @test val[] ≈ angle(x)
+        @cuda cuda_kernel(buf, -x)
+        val = Array(buf)
+        @test val[] ≈ angle(-x)
+
+        #op(::ComplexF32)
+        x   = rand(ComplexF32)
+        @cuda cuda_kernel(cbuf, x)
+        val = Array(cbuf)
+        @test val[] ≈ angle(x)
+        @cuda cuda_kernel(cbuf, -x)
+        val = Array(cbuf)
+        @test val[] ≈ angle(-x)
+
+        #op(::Float64)
+        x   = rand(Float64)
+        @cuda cuda_kernel(buf, x)
+        val = Array(buf)
+        @test val[] ≈ angle(x)
+        @cuda cuda_kernel(buf, -x)
+        val = Array(buf)
+        @test val[] ≈ angle(-x)
+
+        #op(::ComplexF64)
+        x   = rand(ComplexF64)
+        @cuda cuda_kernel(cbuf, x)
+        val = Array(cbuf)
+        @test val[] ≈ angle(x)
+        @cuda cuda_kernel(cbuf, -x)
+        val = Array(cbuf)
+        @test val[] ≈ angle(-x)
+    end
+
+    # dictionary of key=>tuple, where the tuple should
+    # contain the cpu command and the cuda function to test.
+    ops = Dict("exp"=>(exp, CUDAnative.exp),
+               "angle"=>(angle, CUDAnative.angle),
+               "exp2"=>(exp2, CUDAnative.exp2),
+               "exp10"=>(exp10, CUDAnative.exp10),
+               "expm1"=>(expm1, CUDAnative.expm1))
+
+    @testset "$key" for key=keys(ops)
+        cpu_op, cuda_op = ops[key]
+
+        buf = CuTestArray(zeros(Float32))
+
+        function cuda_kernel(a, x)
+            a[] = cuda_op(x)
+            return
+        end
+
+        #op(::Float32)
+        x   = rand(Float32)
+        @cuda cuda_kernel(buf, x)
+        val = Array(buf)
+        @test val[] ≈ cpu_op(x)
+        @cuda cuda_kernel(buf, -x)
+        val = Array(buf)
+        @test val[] ≈ cpu_op(-x)
+
+        #op(::Float64)
+        x   = rand(Float64)
+        @cuda cuda_kernel(buf, x)
+        val = Array(buf)
+        @test val[] ≈ cpu_op(x)
+        @cuda cuda_kernel(buf, -x)
+        val = Array(buf)
+        @test val[] ≈ cpu_op(-x)
+    end
+
+    # dictionary of key=>tuple, where the tuple should
+    # contain the cpu command and the cuda function to test.
+    ops = Dict("exp"=>(exp, CUDAnative.exp),
+               "abs"=>(abs, CUDAnative.abs),
+               "abs2"=>(abs2, CUDAnative.abs2),
+               "angle"=>(angle, CUDAnative.angle),
+               "log"=>(log, CUDAnative.log))
+
+    @testset "Complex - $key" for key=keys(ops)
+        cpu_op, cuda_op = ops[key]
+
+        buf = CuTestArray(zeros(Complex{Float32}))
+
+        function cuda_kernel(a, x)
+            a[] = cuda_op(x)
+            return
+        end
+
+        #op(::ComplexF32, ::ComplexF32)
+        x   = rand(ComplexF32)
+        @cuda cuda_kernel(buf, x)
+        val = Array(buf)
+        @test val[] ≈ cpu_op(x)
+        @cuda cuda_kernel(buf, -x)
+        val = Array(buf)
+        @test val[] ≈ cpu_op(-x)
+
+        #op(::ComplexF64, ::ComplexF64)
+        x   = rand(ComplexF64)
+        @cuda cuda_kernel(buf, x)
+        val = Array(buf)
+        @test val[] ≈ cpu_op(x)
+        @cuda cuda_kernel(buf, -x)
+        val = Array(buf)
+        @test val[] ≈ cpu_op(-x)
+    end
+end
+
 
 ############################################################################################