Improved test cases

trthatcher · May 5, 2016 · 0a1c92e · 0a1c92e
1 parent cb0b85a
commit 0a1c92e
Show file tree

Hide file tree

Showing 2 changed files with 40 additions and 76 deletions.
diff --git a/src/pairwisefunction.jl b/src/pairwisefunction.jl
@@ -131,8 +131,8 @@ for (scheme, dimension) in ((:(:row), 1), (:(:col), 2))
 
         function dotvectors!{T<:AbstractFloat}(
                  ::Type{Val{$scheme}},
-                X::AbstractMatrix{T}, 
-                xᵀx::Vector{T}
+                xᵀx::Vector{T},
+                X::AbstractMatrix{T}
             )
             if !(size(X,$dimension) == length(xᵀx))
                 errorstring = string("Dimension mismatch on dimension ", $dimension)
@@ -146,7 +146,7 @@ for (scheme, dimension) in ((:(:row), 1), (:(:col), 2))
         end
 
         @inline function dotvectors{T<:AbstractFloat}(::Type{Val{$scheme}}, X::AbstractMatrix{T})
-            dotvectors!(Val{$scheme}, X, Array(T, size(X,$dimension)))
+            dotvectors!(Val{$scheme}, Array(T, size(X,$dimension)), X)
         end
 
         @inline function gramian!{T<:AbstractFloat}(

diff --git a/test/pairwise.jl b/test/pairwise.jl
@@ -1,52 +1,59 @@
+n = 200
+m = 100
+p = 25
+
 info("Testing ", MOD.pairwise)
 for kernelobj in additive_kernels
     for T in (Float64,)
-        x1 = T[1; 2]
-        x2 = T[2; 0]
-        x3 = T[3; 2]
-        X = [x1'; x2'; x3']
 
-        y1 = T[1; 1]
-        y2 = T[1; 1]
-        Y = [y1'; y2']
+        Set_X = [rand(T, p) for i = 1:n]
+        Set_Y = [rand(T, p) for i = 1:m]
+
+        X = transpose(hcat(Set_X...))
+        Y = transpose(hcat(Set_Y...))
 
-        Set_x = (x1,x2,x3)
-        Set_y = (y1,y2)
         k = (kernelobj)()
 
-        @test MOD.pairwise(k, x1[1], y1[1])  == MOD.phi(k, x1[1], y1[1])
-        @test MOD.pairwise(k, x1, y1) == MOD.phi(k, x1[1], y1[1]) + MOD.phi(k, x1[2], y1[2])
+        @test MOD.pairwise(k, Set_X[1][1], Set_Y[1][1])     == MOD.phi(k, Set_X[1][1], Set_Y[1][1])
+        @test MOD.pairwise(k, Set_X[1][1:2], Set_Y[1][1:2]) == MOD.phi(k, Set_X[1][1], Set_Y[1][1]) + MOD.phi(k, Set_X[1][2], Set_Y[1][2])
 
-        P = [MOD.pairwise(k,x,y) for x in Set_x, y in Set_x]
+        P = [MOD.pairwise(k,x,y) for x in Set_X, y in Set_X]
         @test_approx_eq MOD.pairwise(Val{:row}, k, X)  P
         @test_approx_eq MOD.pairwise(Val{:col}, k, X') P
+        @test_approx_eq MOD.pairwise!(Val{:row}, Array(T,n,n), k, X)  P
+        @test_approx_eq MOD.pairwise!(Val{:col}, Array(T,n,n), k, X') P
 
-        P = [MOD.pairwise(k,x,y) for x in Set_x, y in Set_y]
-        @test_approx_eq MOD.pairwise(Val{:row}, k, X, Y)   P
+        P = [MOD.pairwise(k,x,y) for x in Set_X, y in Set_Y]
+        @test_approx_eq MOD.pairwise(Val{:row}, k, X,  Y)  P
         @test_approx_eq MOD.pairwise(Val{:col}, k, X', Y') P
+        @test_approx_eq MOD.pairwise!(Val{:row}, Array(T,n,m), k, X,  Y)  P
+        @test_approx_eq MOD.pairwise!(Val{:col}, Array(T,n,m), k, X', Y') P
 
-        @test_throws DimensionMismatch MOD.pairwise!(Val{:row}, Array(T,1,4), k, X)
-        @test_throws DimensionMismatch MOD.pairwise!(Val{:row}, Array(T,4,1), k, X)
-        @test_throws DimensionMismatch MOD.pairwise!(Val{:col}, Array(T,1,4), k, X')
-        @test_throws DimensionMismatch MOD.pairwise!(Val{:col}, Array(T,4,1), k, X')
+        @test_throws DimensionMismatch MOD.pairwise!(Val{:row}, Array(T,n+1,n), k, X)
+        @test_throws DimensionMismatch MOD.pairwise!(Val{:row}, Array(T,n,n+1), k, X)
+        @test_throws DimensionMismatch MOD.pairwise!(Val{:col}, Array(T,n+1,n), k, X')
+        @test_throws DimensionMismatch MOD.pairwise!(Val{:col}, Array(T,n,n+1), k, X')
 
-        @test_throws DimensionMismatch MOD.pairwise!(Val{:row}, Array(T,2,2), k, X, Y)
-        @test_throws DimensionMismatch MOD.pairwise!(Val{:row}, Array(T,4,2), k, X, Y)
-        @test_throws DimensionMismatch MOD.pairwise!(Val{:col}, Array(T,2,2), k, X', Y')
-        @test_throws DimensionMismatch MOD.pairwise!(Val{:col}, Array(T,4,2), k, X', Y')
+        @test_throws DimensionMismatch MOD.pairwise!(Val{:row}, Array(T,n+1,m), k, X,  Y)
+        @test_throws DimensionMismatch MOD.pairwise!(Val{:row}, Array(T,n,m+1), k, X,  Y)
+        @test_throws DimensionMismatch MOD.pairwise!(Val{:col}, Array(T,n+1,m), k, X', Y')
+        @test_throws DimensionMismatch MOD.pairwise!(Val{:col}, Array(T,n,m+1), k, X', Y')
 
-        @test_throws DimensionMismatch MOD.pairwise!(Val{:row}, Array(T,2,2), k, Y, X)
-        @test_throws DimensionMismatch MOD.pairwise!(Val{:row}, Array(T,2,4), k, Y, X)
-        @test_throws DimensionMismatch MOD.pairwise!(Val{:col}, Array(T,2,2), k, Y', X')
-        @test_throws DimensionMismatch MOD.pairwise!(Val{:col}, Array(T,2,4), k, Y', X')
+        @test_throws DimensionMismatch MOD.pairwise!(Val{:row}, Array(T,m+1,n), k, Y,  X)
+        @test_throws DimensionMismatch MOD.pairwise!(Val{:row}, Array(T,m,n+1), k, Y,  X)
+        @test_throws DimensionMismatch MOD.pairwise!(Val{:col}, Array(T,m+1,n), k, Y', X')
+        @test_throws DimensionMismatch MOD.pairwise!(Val{:col}, Array(T,m,n+1), k, Y', X')
 
         @test_approx_eq MOD.dotvectors(Val{:row}, X) sum((X.*X),2)
         @test_approx_eq MOD.dotvectors(Val{:col}, X) sum((X.*X),1)
 
-        @test_throws DimensionMismatch MOD.dotvectors!(Val{:row}, Array(T,3,2), Array(T,2))
-        @test_throws DimensionMismatch MOD.dotvectors!(Val{:row}, Array(T,3,4), Array(T,4))
-        @test_throws DimensionMismatch MOD.dotvectors!(Val{:col}, Array(T,2,3), Array(T,2))
-        @test_throws DimensionMismatch MOD.dotvectors!(Val{:col}, Array(T,4,3), Array(T,4))
+        @test_approx_eq MOD.dotvectors!(Val{:row}, Array(T,n), X) sum((X.*X),2)
+        @test_approx_eq MOD.dotvectors!(Val{:col}, Array(T,p), X) sum((X.*X),1)
+
+        @test_throws DimensionMismatch MOD.dotvectors!(Val{:row}, Array(T,2), Array(T,3,2))
+        @test_throws DimensionMismatch MOD.dotvectors!(Val{:row}, Array(T,4), Array(T,3,4))
+        @test_throws DimensionMismatch MOD.dotvectors!(Val{:col}, Array(T,2), Array(T,2,3))
+        @test_throws DimensionMismatch MOD.dotvectors!(Val{:col}, Array(T,4), Array(T,4,3))
 
         @test_throws DimensionMismatch MOD.squared_distance!(Array(T,3,4), Array(T,3))
         @test_throws DimensionMismatch MOD.squared_distance!(Array(T,4,3), Array(T,3))
@@ -57,46 +64,3 @@ for kernelobj in additive_kernels
         @test_throws DimensionMismatch MOD.squared_distance!(Array(T,3,4), Array(T,3), Array(T,5))
     end
 end
-
-#=
-immutable TestKernel{T<:AbstractFloat} <: BaseKernel{T}
-    a::T
-end
-
-MOD.phi{T<:AbstractFloat}(κ::TestKernel, x::AbstractVector{T}, y::AbstractVector{T}) = sum(x) + sum(y) + κ.a
-
-function MOD.description_string{T<:AbstractFloat}(κ::TestKernel{T}, eltype::Bool = true)
-    "Test" * (eltype ? "{$(T)}" : "") * "(a=$(κ.a))"
-end
-
-p = 10
-for T in (Float32, Float64)
-    x1 = rand(T,p)
-    x2 = rand(T,p)
-    x3 = rand(T,p)
-    X = [x1'; x2'; x3']
-
-    y1 = rand(T,p)
-    y2 = rand(T,p)
-    Y = [y1'; y2']
-
-    Set_x = (x1, x2, x3)
-    Set_y = (y1, y2)
-
-    k = TestKernel(100*one(T))
-
-    P = [MOD.pairwise(k,x,y) for x in Set_x, y in Set_x]
-
-    @test_approx_eq MOD.syml!(MOD.pairwise(k, X,false,true))  P
-    @test_approx_eq MOD.symu!(MOD.pairwise(k, X,false,false)) P
-
-    @test_approx_eq MOD.syml!(MOD.pairwise(k, X',true,true))  P
-    @test_approx_eq MOD.symu!(MOD.pairwise(k, X',true,false)) P
-
-    P = [MOD.pairwise(k,x,y) for x in Set_x, y in Set_y]
-
-    @test_approx_eq MOD.pairwise(k, X,  Y,  false)  P
-    @test_approx_eq MOD.pairwise(k, X', Y', true)   P
-
-end
-=#