merge master

Author: SimonDanisch

src/SUnitRange.jl

@@ -1,27 +1,32 @@
 # `Start` and `End` should be `Int`
-struct SUnitRange{Start, End, L} <: StaticVector{L, Int}
-    function SUnitRange{Start, End, L}() where {Start, End, L}
-        check_sunitrange_params(Start, End, L)
-        new{Start, End, L}()
+struct SUnitRange{Start, L} <: StaticVector{L, Int}
+    function SUnitRange{Start, L}() where {Start, L}
+        check_sunitrange_params(L)
+        new{Start, L}()
     end
 end
 
-@pure function check_sunitrange_params(a::Int, b::Int, c::Int)
-    if max(0, b - a + 1) != c
-        throw(DimensionMismatch("Static unit range $a:$b does not have length $c"))
+@pure function check_sunitrange_params(L::Int)
+    if L < 0
+        error("Static unit range length is negative")
     end
 end
 
-function check_sunitrange_params(a, b, c)
+function check_sunitrange_params(L)
     throw(TypeError(:SUnitRange, "type parameters must be `Int`s", Tuple{Int, Int, Int}, Tuple{typeof(a), typeof(b), typeof(c)}))
 end
 
-@pure SUnitRange{Start, End}() where {Start, End} = SUnitRange{Start, End, max(0, End - Start + 1)}()
-@pure SUnitRange(a::Int, b::Int) = SUnitRange{a, b}()
+@pure SUnitRange(a::Int, b::Int) = SUnitRange{a, max(0, b - a + 1)}()
 
-@pure @propagate_inbounds function getindex(x::SUnitRange{Start,End}, i::Int) where {Start, End}
-    @boundscheck if i < Start || i > End
+@pure @propagate_inbounds function getindex(x::SUnitRange{Start, L}, i::Int) where {Start, L}
+    @boundscheck if i < Start || i >= (Start + L)
         throw(BoundsError(x, i))
     end
-    return i
+    return Start + i - 1
+end
+
+# Shorten show for REPL use.
+show(io::IO, ::Type{SUnitRange}) = print(io, "SUnitRange")
+function show(io::IO, ::MIME"text/plain", ::SUnitRange{Start, L}) where {Start, L}
+    print(io, "SUnitRange($Start,$(Start + L - 1))")
 end

test/SUnitRange.jl

@@ -0,0 +1,6 @@
+@testset "SUnitRange" begin
+    @test length(StaticArrays.SUnitRange(1,3)) === 3
+    @test length(StaticArrays.SUnitRange(1,-10)) === 0
+
+    @test StaticArrays.SUnitRange(2,4)[2] === 3
+end

test/fixed_size_arrays.jl

@@ -33,9 +33,9 @@ StaticArrays.similar_type{SV <: RGB, T}(::Type{SV}, ::Type{T}, ::Size{(3,)}) = R
             (Point{2, Float64}(1, NaN), true),
             (Vec{11, Float64}(NaN), true),
             (Point{2, Float32}(1, 1), false),
-            (RGB{Float32}(NaN), true),
+            (RGB{Float32}(NaN, NaN, NaN), true),
         )
-        @test all(isnan, p) == r
+        @test any(isnan, p) == r
     end
 end
 

test/runtests.jl

@@ -10,6 +10,7 @@ using Base.Test
     include("MArray.jl")
     include("FieldVector.jl")
     include("Scalar.jl")
+    include("SUnitRange.jl")
     include("custom_types.jl")
 
     include("core.jl")
@@ -21,7 +22,7 @@ using Base.Test
     include("matrix_multiply.jl")
     include("det.jl")
     include("inv.jl")
-    #include("solve.jl") # Strange inference / world-age error
+    include("solve.jl") # Strange inference / world-age error
     include("eigen.jl")
     include("deque.jl")
     include("fixed_size_arrays.jl")

test/solve.jl

@@ -1,11 +1,27 @@
 @testset "Solving linear system" begin
 
-    @testset "Problem size: $n x $n. Matrix type: $m. Element type: $elty" for n in (1,2,3,4),
+    # I see an inference error in the combined testset below. I can't reproduce
+    # at the REPL or in a function for individual n, etc... speculatively, it
+    # might be reusing A, b with different types in the same (non-toplevel)
+    # scope, for which I've come accross inference bugs in the past.
+
+    for n in (1,2,3,4),
+            (m, v) in ((SMatrix{n,n}, SVector{n}), (MMatrix{n,n}, MVector{n})),
+                elty in (Float64, Int)
+
+        eval(quote
+            A = $elty.(rand(-99:2:99,$n,$n))
+            b = A*ones($elty,$n)
+            @test $m(A)\$v(b) ≈ A\b
+        end)
+    end
+
+    #=@testset "Problem size: $n x $n. Matrix type: $m. Element type: $elty" for n in (1,2,3,4),
             (m, v) in ((SMatrix{n,n}, SVector{n}), (MMatrix{n,n}, MVector{n})),
                 elty in (Float64, Int)
 
         A = elty.(rand(-99:2:99,n,n))
         b = A*ones(elty,n)
         @test m(A)\v(b) ≈ A\b
-    end
+    end =#
 end