Merge pull request #58 from JuliaArrays/traits

`Size` traits

Author: andyferris

src/StaticArrays.jl

@@ -13,6 +13,8 @@ export Scalar, SArray, SVector, SMatrix
 export MArray, MVector, MMatrix
 export FieldVector, MutableFieldVector
 
+export Size
+
 export @SVector, @SMatrix, @SArray
 export @MVector, @MMatrix, @MArray
 
@@ -21,6 +23,7 @@ export similar_type
 include("util.jl")
 
 include("core.jl")
+include("traits.jl")
 include("Scalar.jl")
 include("SVector.jl")
 include("FieldVector.jl")
@@ -30,7 +33,6 @@ include("MVector.jl")
 include("MMatrix.jl")
 include("MArray.jl")
 
-
 include("indexing.jl")
 include("abstractarray.jl")
 include("mapreduce.jl")

src/det.jl

@@ -1,36 +1,34 @@
+@inline det(A::StaticMatrix) = _det(Size(A), A)
 
-@generated function det{T}(A::StaticMatrix{T})
-    if size(A) == (1,1)
-        return quote
-            $(Expr(:meta, :inline))
-            @inbounds return A[1]
-        end
-    elseif size(A) == (2,2)
-        return quote
-            $(Expr(:meta, :inline))
-            @inbounds return A[1]*A[4] - A[3]*A[2]
-        end
-    elseif size(A) == (3,3)
-        return quote
-            $(Expr(:meta, :inline))
-            #@inbounds a = A[5]*A[9] - A[8]*A[6]
-            #@inbounds b = A[8]*A[3] - A[2]*A[9]
-            #@inbounds c = A[2]*A[6] - A[5]*A[3]
-            #@inbounds return A[1]*a + A[4]*b + A[7]*c
+"""
+    det(Size(m,m), mat)
 
-            @inbounds x0 = SVector(A[1], A[2], A[3])
-            @inbounds x1 = SVector(A[4], A[5], A[6])
-            @inbounds x2 = SVector(A[7], A[8], A[9])
-            return vecdot(x0, cross(x1, x2))
-        end
-    else
-        S = typeof((one(T)*zero(T) + zero(T))/one(T))
-        return quote # Implementation from Base
-            if istriu(A) || istril(A)
-                return convert($S, det(UpperTriangular(A)))::$S # Is this a Julia bug that a convert is not type stable??
-            end
-            AA = convert(Array{$S}, A)
-            return det(lufact(AA))
+Calculate the matrix determinate using an algorithm specialized on the size of
+the `m`×`m` matrix `mat`, which is much faster for small matrices.
+"""
+@inline _det(::Size{(1,1)}, A::AbstractMatrix) = @inbounds return A[1]
+
+@inline function _det(::Size{(2,2)}, A::AbstractMatrix)
+    @inbounds return A[1]*A[4] - A[3]*A[2]
+end
+
+@inline function _det(::Size{(3,3)}, A::AbstractMatrix)
+    @inbounds x0 = SVector(A[1], A[2], A[3])
+    @inbounds x1 = SVector(A[4], A[5], A[6])
+    @inbounds x2 = SVector(A[7], A[8], A[9])
+    return vecdot(x0, cross(x1, x2))
+end
+
+@generated function _det{S,T}(::Size{S}, A::AbstractMatrix{T})
+    if S[1] != S[2]
+        throw(DimensionMismatch("matrix is not square"))
+    end
+    T2 = typeof((one(T)*zero(T) + zero(T))/one(T))
+    return quote # Implementation from Base
+        if istriu(A) || istril(A)
+            return convert($T2, det(UpperTriangular(A)))::$T2 # Is this a Julia bug that a convert is not type stable??
         end
+        AA = convert(Array{$T2}, A)
+        return det(lufact(AA))
     end
 end

src/traits.jl

@@ -0,0 +1,48 @@
+"""
+    Size(static_array)
+    Size(StaticArrayType)
+    Size(dims...)
+
+A trait type allowing convenient trait-based dispatch on the size of a statically
+sized array. The dimensions are stored as a type parameter and are statically
+propagated by the compiler.
+
+For example,
+```
+det(x::StaticMatrix) = _det(Size(x), x)
+_det(::Size{(1,1)}, x::StaticMatrix) = x[1,1]
+_det(::Size{(2,2)}, x::StaticMatrix) = x[1,1]*x[2,2] - x[1,2]*x[2,1]
+# and other definitions as necessary
+```
+"""
+immutable Size{S}
+    function Size()
+        check_size(S)
+        new()
+    end
+end
+
+@pure check_size(S::Tuple{Vararg{Int}}) = nothing
+check_size(S) = error("Size was expected to be a tuple of `Int`s")
+
+@pure Size{SA<:StaticArray}(::Type{SA}) = Size{size(SA)}()
+@inline Size(a::StaticArray) = Size(typeof(a))
+
+@pure Size(s::Tuple{Vararg{Int}}) = Size{s}()
+@pure Size(s::Int...) = Size{s}()
+
+Base.show{S}(io::IO, ::Size{S}) = print(io, "Size", S)
+
+
+# Some @pure convenience functions.
+
+# (This type could *probably* be returned from the `size()` function.
+# This might enable some generic programming, e.g. with `similar(A, size(A))`.)
+
+@pure getindex{S}(::Size{S}, i::Int) = S[i]
+
+@pure Base.:(==){S}(::Size{S}, s::Tuple{Vararg{Int}}) = S == s
+@pure Base.:(==){S}(s::Tuple{Vararg{Int}}, ::Size{S}) = s == S
+
+@pure Base.:(!=){S}(::Size{S}, s::Tuple{Vararg{Int}}) = S != s
+@pure Base.:(!=){S}(s::Tuple{Vararg{Int}}, ::Size{S}) = s != S