add special type for views of Band, macro to implement banded linear algebra

src/BandedMatrices.jl

@@ -4,9 +4,11 @@ module BandedMatrices
 using Base, Compat
 
 import Base: getindex, setindex!, *, +, -, ==, <, <=, >,
-                >=, /, ^, \, transpose, showerror, reindex, checkbounds
+                >=, /, ^, \, transpose, showerror, reindex, checkbounds, @propagate_inbounds
 
-import Base: convert, size, view
+import Base: convert, size, view, indices, unsafe_indices, indices1,
+                first, last, size, length, unsafe_length, start, next, done, step,
+                to_indices, to_index, indices, show
 
 import Base.BLAS: libblas
 import Base.LAPACK: liblapack
@@ -48,19 +50,22 @@ export BandedMatrix,
        bandwidth,
        BandError,
        band,
+       Band,
        BandRange,
        bandwidths,
        colrange,
-       rowrange
+       rowrange,
+       isbanded
 
 
 
 include("blas.jl")
 include("lapack.jl")
 
-include("AbstractBandedMatrix.jl")
-include("Band.jl")
-include("utils.jl")
+include("generic/AbstractBandedMatrix.jl")
+include("generic/Band.jl")
+include("generic/utils.jl")
+include("generic/linalg.jl")
 
 include("banded/BandedMatrix.jl")
 include("banded/BandedLU.jl")
@@ -72,7 +77,7 @@ include("symbanded/SymBandedMatrix.jl")
 include("symbanded/BandedCholesky.jl")
 include("symbanded/linalg.jl")
 
-include("interface.jl")
+include("generic/interface.jl")
 include("deprecate.jl")
 
 

src/banded/BandedMatrix.jl

@@ -207,37 +207,63 @@ end
 @inline getindex(A::BandedMatrix, kr::Colon, jr::Colon) = copy(A)
 
 # ~ indexing along a band
+# we reduce it to converting a View
 
 # scalar - band - colon
-@inline function getindex(A::BandedMatrix{T}, b::Band) where {T}
-    @boundscheck checkband(A, b)
-    if b.i > 0
-        vec(A.data[A.u - b.i + 1, b.i+1:min(size(A,2),size(A,1)+b.i)])
-    elseif b.i == 0
-        vec(A.data[A.u - b.i + 1, 1:min(size(A,2),size(A,1))])
-    else # b.i < 0
-        vec(A.data[A.u - b.i + 1, 1:min(size(A,2),size(A,1)+b.i)])
+@inline getindex(A::BandedMatrix{T}, b::Band) where {T} = Vector{T}(view(A, b))
+
+# type to represent a view of a band
+const BandedMatrixBand{T} = SubArray{T, 1, Base.ReshapedArray{T,1,BandedMatrix{T},
+                                Tuple{Base.MultiplicativeInverses.SignedMultiplicativeInverse{Int}}}, Tuple{BandSlice}, false}
+
+
+band(V::BandedMatrixBand) = first(parentindexes(V)).band.i
+
+# gives a view of the parent's data matrix
+function dataview(V::BandedMatrixBand)
+    A = parent(parent(V))
+    b = band(V)
+    m,n = size(A)
+    if b > 0
+        view(A.data, A.u - b + 1, b+1:min(n,m+b))
+    elseif b == 0
+        view(A.data, A.u - b + 1, 1:min(n,m))
+    else # b < 0
+        view(A.data, A.u - b + 1, 1:min(n,m+b))
     end
 end
 
-@inline function view(A::BandedMatrix{T}, b::Band) where {T}
-    @boundscheck checkband(A, b)
-    if b.i > 0
-        view(A.data,A.u - b.i + 1, b.i+1:min(size(A,2),size(A,1)+b.i))
-    elseif b.i == 0
-        view(A.data,A.u - b.i + 1, 1:min(size(A,2),size(A,1)))
-    else # b.i < 0
-        view(A.data,A.u - b.i + 1, 1:min(size(A,2),size(A,1)+b.i))
+function convert(::Type{Vector{T}}, V::BandedMatrixBand) where T
+    A = parent(parent(V))
+    if -A.l ≤ band(V) ≤ A.u
+        Vector{T}(dataview(V))
+    else
+        zeros(T, length(V))
     end
 end
 
+convert(::Type{Array{T}}, A::BandedMatrixBand) where T = convert(Vector{T}, A)
+convert(::Type{Array}, A::BandedMatrixBand) = convert(Vector{eltype(A)}, A)
+convert(::Type{Vector}, A::BandedMatrixBand)= convert(Vector{eltype(A)}, A)
+
+
+convert(::Type{AbstractArray{T}}, A::BandedMatrixBand{T}) where T = A
+convert(::Type{AbstractVector{T}}, A::BandedMatrixBand{T}) where T = A
+convert(::Type{AbstractArray}, A::BandedMatrixBand{T}) where T = A
+convert(::Type{AbstractVector}, A::BandedMatrixBand{T}) where T = A
+
+convert(::Type{AbstractArray{T}}, A::BandedMatrixBand) where T = convert(Vector{T}, A)
+convert(::Type{AbstractVector{T}}, A::BandedMatrixBand) where T = convert(Vector{T}, A)
+
+
 # scalar - BandRange - integer -- A[1, BandRange]
 @inline getindex(A::AbstractMatrix, ::Type{BandRange}, j::Integer) = A[colrange(A, j), j]
 
 # scalar - integer - BandRange -- A[1, BandRange]
 @inline getindex(A::AbstractMatrix, k::Integer, ::Type{BandRange}) = A[k, rowrange(A, k)]
 
 
+
 # ~ indexing along a row