Added a Size trait and SizeOf trait class

Implemented a "traitor" style trait system for convenient
dispatch on type. The system supports implementing statically
sized algorithms on dynamically sized arrays.

Author: Andy Ferris

src/StaticArrays.jl

@@ -13,6 +13,8 @@ export Scalar, SArray, SVector, SMatrix
 export MArray, MVector, MMatrix
 export FieldVector, MutableFieldVector
 
+export Size, SizeOf
+
 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(SizeOf(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(::Type{Size{(1,1)}}, A::AbstractMatrix) = @inbounds return A[1]
+
+@inline function det(::Type{Size{(2,2)}}, A::AbstractMatrix)
+    @inbounds return A[1]*A[4] - A[3]*A[2]
+end
+
+@inline function det(::Type{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}(::Type{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,70 @@
+"""
+    SizeOf(static_array)
+
+Returns the size of a static array, wrapped in a `Size` trait such as
+`Size{(2,3)}` for a 2×3 matrix.
+
+`SizeOf` implements the "traitor" paradigm for traits, whereby an abstract trait
+class `SizeOf` returns a direct subtype, in this case `Size`.
+
+For example,
+```
+det(x::StaticMatrix) = det(SizeOf(x), x)
+det(::Type{Size{1,1}}, x::AbstractMatrix) = x[1,1]
+det(::Type{Size{2,2}}, x::AbstractMatrix) = x[1,1]*x[2,2] - x[1,2]*x[2,1]
+# and other definitions as necessary
+```
+"""
+abstract SizeOf
+
+
+"""
+    Size{(dims...)} <: SizeOf
+
+A trait type allowing convenient trait-based dispatch on the size of a statically
+sized array.
+
+`Size` implements the "traitor" paradigm for traits, whereby an abstract trait
+class `SizeOf` returns a direct subtype, in this case `Size`.
+
+For example,
+```
+det(x::StaticMatrix) = det(SizeOf(x), x)
+det(::Type{Size{1,1}}, x::AbstractMatrix) = x[1,1]
+det(::Type{Size{2,2}}, x::AbstractMatrix) = x[1,1]*x[2,2] - x[1,2]*x[2,1]
+# and other definitions as necessary
+```
+"""
+immutable Size{S} <: SizeOf
+end
+
+@pure SizeOf{SA<:StaticArray}(::Type{SA}) = Size{size(SA)}
+@inline SizeOf(a::StaticArray) = Size(typeof(a))
+
+# Also define these, since may be more convenient than SizeOf
+"""
+    Size(static_array)
+    Size(StaticArrayType)
+
+Convenience constructor for the `Size` of a static array. See also `SizeOf`.
+"""
+@pure Size{SA<:StaticArray}(::Type{SA}) = Size{size(SA)}
+@inline Size(a::StaticArray) = Size(typeof(a))
+
+"""
+    Size((dims...))
+    Size(dims...)
+
+Pure function that constructs a compile-time constant `Size` of an array. This
+allows for dispatch of standard (dynamically-sized) arrays to faster, specialized
+*StaticArrays* library methods when the programmer knows or can reasonably infer
+the size. For example,
+```
+mat = [1.0 2.0; 3.0 4.0]
+det(Size(2,2), mat)  # Faster than det(mat)
+```
+"""
+@pure Size(s::Tuple{Vararg{Int}}) = Size{s}
+@pure Size(s::Int...) = Size{s}
+
+@pure getindex{S}(::Type{Size{S}}, i::Int) = S[i]