Merge pull request #422 from tkoolen/tk/pass-tests

Another round of fixes

Author: andyferris

src/lyap.jl

@@ -8,5 +8,4 @@ _lyap(::Size{(1,1)}, ::Size{(1,1)}, a::StaticMatrix,  c::StaticMatrix) = -c/(2a[
      -(d*c  + (a - t*I)*c*(a-t*I)')/(2*d*t) # http://www.nber.org/papers/w8956.pdf
 end
 
-@inline _lyap(sa::Size, sc::Size, a::StaticMatrix, c::StaticMatrix) = sc(Base.lyap(Array(a),Array(c)))
- 
+@inline _lyap(sa::Size, sc::Size, a::StaticMatrix, c::StaticMatrix) = sc(lyap(Array(a),Array(c)))

src/mapreduce.jl

@@ -4,16 +4,24 @@
 ## map / map! ##
 ################
 
-# The following type signature for map() matches any list of AbstractArrays,
-# provided at least one is a static array.
 if VERSION < v"0.7.0-"
+    # The following type signature for map() matches any list of AbstractArrays,
+    # provided at least one is a static array.
     @inline function map(f, as::Union{SA,AbstractArray}...) where {SA<:StaticArray}
         _map(f, same_size(as...), as...)
     end
 else
+    # In 0.7, the above construction can no longer be used due to https://github.com/JuliaLang/julia/pull/23117.
+    # Instead, only dispatch to StaticArrays._map if one of the first two arguments is a StaticArray.
     @inline function map(f, a1::StaticArray, as::AbstractArray...)
         _map(f, same_size(a1, as...), a1, as...)
     end
+    @inline function map(f, a1::AbstractArray, a2::StaticArray, as::AbstractArray...)
+        _map(f, same_size(a1, a2, as...), a1, a2, as...)
+    end
+    @inline function map(f, a1::StaticArray, a2::StaticArray, as::AbstractArray...)
+        _map(f, same_size(a1, a2, as...), a1, a2, as...)
+    end
 end
 
 @generated function _map(f, ::Size{S}, a::AbstractArray...) where {S}

test/linalg.jl

@@ -110,22 +110,23 @@ using StaticArrays, Compat.Test
         @test @inferred(conj(SVector(1+im, 2+im))) === SVector(1-im, 2-im)
 
         if VERSION < v"0.7-"
-            @test @inferred(transpose(@SVector([1, 2, 3]))) === Adjoint(@SVector([1, 2, 3]))
+            @test @inferred(transpose(@SVector([1, 2, 3]))) === RowVector(@SVector([1, 2, 3]))
+            @test @inferred(adjoint(@SVector([1, 2, 3]))) === RowVector(@SVector([1, 2, 3]))
         else
             @test @inferred(transpose(@SVector([1, 2, 3]))) === Transpose(@SVector([1, 2, 3]))
+            @test @inferred(adjoint(@SVector([1, 2, 3]))) === Adjoint(@SVector([1, 2, 3]))
         end
         @test @inferred(transpose(@SMatrix([1 2; 0 3]))) === @SMatrix([1 0; 2 3])
         @test @inferred(transpose(@SMatrix([1 2 3; 4 5 6]))) === @SMatrix([1 4; 2 5; 3 6])
 
-        @test @inferred(adjoint(@SVector([1, 2, 3]))) === Adjoint(@SVector([1, 2, 3]))
         @test @inferred(adjoint(@SMatrix([1 2; 0 3]))) === @SMatrix([1 0; 2 3])
         @test @inferred(adjoint(@SMatrix([1 2 3; 4 5 6]))) === @SMatrix([1 4; 2 5; 3 6])
         @test @inferred(adjoint(@SMatrix([1 2*im 3; 4 5 6]))) === @SMatrix([1 4; -2*im 5; 3 6])
-        
+
         m = [1 2; 3 4] + im*[5 6; 7 8]
-        @test @inferred(adjoint(@SVector [m,m])) == ctranspose([m,m])
+        @test @inferred(adjoint(@SVector [m,m])) == adjoint([m,m])
         @test @inferred(transpose(@SVector [m,m])) == transpose([m,m])
-        @test @inferred(adjoint(@SMatrix [m m; m m])) == ctranspose([[m] [m]; [m] [m]])
+        @test @inferred(adjoint(@SMatrix [m m; m m])) == adjoint([[m] [m]; [m] [m]])
         @test @inferred(transpose(@SMatrix [m m; m m])) == transpose([[m] [m]; [m] [m]])
 
     end

test/matrix_multiply.jl

@@ -60,8 +60,13 @@
         m = @SMatrix [1 2; 3 4]
         bm = @SMatrix [m m; m m]
         bv = @SVector [v,v]
-        # Broken only because output turns into a normal array:
-        @test_broken (bv'*bm)'::SVector{2,SVector{2,Int}} == @SVector [[14,20],[14,20]]
+
+        if VERSION < v"0.7-"
+            # Broken only because output turns into a normal array:
+            @test_broken (bv'*bm)'::SVector{2,SVector{2,Int}} == @SVector [[14,20],[14,20]]
+        else
+            @test (bv'*bm)'::SVector{2,SVector{2,Int}} == @SVector [[14,20],[14,20]]
+        end
 
         # Outer product
         v2 = SVector(1, 2)
@@ -218,25 +223,25 @@
         @test_throws DimensionMismatch m*n
     end
 
-    @testset "A_mul_B!" begin
+    @testset "mul!" begin
         v = @SVector [2, 4]
         v2 = [2, 4]
         m = @SMatrix [1 2; 3 4]
         n = @SMatrix [2 3; 4 5]
 
         outvec = MVector{2,Int}()
-        A_mul_B!(outvec, m, v)
+        mul!(outvec, m, v)
         @test outvec == @MVector [10,22]
-        outvec2 = Vector{Int}(2)
-        A_mul_B!(outvec2, m, v2)
+        outvec2 = Vector{Int}(undef, 2)
+        mul!(outvec2, m, v2)
         @test outvec2 == [10,22]
 
         # Bad dimensions
         outvec_bad = MVector{3,Int}()
-        @test_throws DimensionMismatch A_mul_B!(outvec_bad, m, v)
+        @test_throws DimensionMismatch mul!(outvec_bad, m, v)
 
         a = MMatrix{2,2,Int,4}()
-        A_mul_B!(a, m, n)
+        mul!(a, m, n)
         @test a::MMatrix{2,2,Int,4} == @MMatrix [10 13; 22 29]
 
         a = MMatrix{2,2,Int,4}()
@@ -254,7 +259,7 @@
         @test a::MMatrix{2,2,Int,4} == @MMatrix [11 19; 16 28]
 
         a2 = MArray{Tuple{2,2},Int,2,4}()
-        A_mul_B!(a2, m, n)
+        mul!(a2, m, n)
         @test a2::MArray{Tuple{2,2},Int,2,4} == @MArray [10 13; 22 29]
 
         # Alternative builtin method used for n > 8
@@ -265,7 +270,7 @@
         m_2 = MMatrix{10,10}(m_array_2)
         n_2 = MMatrix{10,10}(n_array_2)
         a_2 = MMatrix{10,10,Int}()
-        A_mul_B!(a_2, m_2, n_2)
+        mul!(a_2, m_2, n_2)
         @test a_2 == a_array_2
 
         # BLAS used for n > 14
@@ -276,7 +281,7 @@
         m_3 = MMatrix{4,4}(m_array_3)
         n_3 = MMatrix{4,4}(n_array_3)
         a_3 = MMatrix{4,4,Float64}()
-        A_mul_B!(a_3, m_3, n_3)
+        mul!(a_3, m_3, n_3)
         @test a_3 ≈ a_array_3
 
         m_array_4 = randn(10, 10)
@@ -286,7 +291,7 @@
         m_4 = MMatrix{10,10}(m_array_4)
         n_4 = MMatrix{10,10}(n_array_4)
         a_4 = MMatrix{10,10,Float64}()
-        A_mul_B!(a_4, m_4, n_4)
+        mul!(a_4, m_4, n_4)
         @test a_4 ≈ a_array_4
 
         m_array_5 = rand(1:10, 16, 16)
@@ -296,7 +301,7 @@
         m_5 = MMatrix{16,16}(m_array_5)
         n_5 = MMatrix{16,16}(n_array_5)
         a_5 = MMatrix{16,16,Int}()
-        A_mul_B!(a_5, m_5, n_5)
+        mul!(a_5, m_5, n_5)
         @test a_5 ≈ a_array_5
 
         m_array_6 = rand(1:10, 8, 10)
@@ -306,7 +311,7 @@
         m_6 = MMatrix{8,10}(m_array_6)
         n_6 = MMatrix{10,8}(n_array_6)
         a_6 = MMatrix{8,8,Int}()
-        A_mul_B!(a_6, m_6, n_6)
+        mul!(a_6, m_6, n_6)
         @test a_6 == a_array_6
 
         # Float64
@@ -315,10 +320,10 @@
         mf = @SMatrix [1.0 2.0; 3.0 4.0]
 
         outvecf = MVector{2,Float64}()
-        A_mul_B!(outvecf, mf, vf)
+        mul!(outvecf, mf, vf)
         @test outvecf ≈ @MVector [10.0, 22.0]
         outvec2f = Vector{Float64}(2)
-        A_mul_B!(outvec2f, mf, vf2)
+        mul!(outvec2f, mf, vf2)
         @test outvec2f ≈ [10.0, 22.0]
     end
 end

test/runtests.jl

@@ -1,13 +1,10 @@
-using StaticArrays, Compat, Compat.Test
+using StaticArrays, Compat, Compat.Test, Compat.Random, Compat.LinearAlgebra
 if VERSION > v"0.7-"
-    using Random
-    using LinearAlgebra
     using InteractiveUtils
 else
-    using Base.Random
     const LinearAlgebra = Base.LinAlg
-    const Adjoint = RowVector
     const tr = trace
+    const mul! = A_mul_B!
 end
 
 # We generate a lot of matrices using rand(), but unit tests should be