Support adjoint strides (#13)

* Support adjoint strides

* v0.2.3

* Remove MemoryLayout(typeof(...)) usage

* Update test_muladd.jl

* Random in tests

Author: dlfivefifty

Project.toml

@@ -1,7 +1,7 @@
 name = "ArrayLayouts"
 uuid = "4c555306-a7a7-4459-81d9-ec55ddd5c99a"
 authors = ["Sheehan Olver <[email protected]>"]
-version = "0.2.2"
+version = "0.2.3"
 
 [deps]
 FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b"
@@ -13,6 +13,7 @@ julia = "1"
 
 [extras]
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 
 [targets]
-test = ["Test"]
+test = ["Test", "Random"]

src/ArrayLayouts.jl

@@ -26,7 +26,8 @@ import Base: AbstractArray, AbstractMatrix, AbstractVector,
       AbstractArray, AbstractVector, axes, (:), _sub2ind_recurse, broadcast, promote_eltypeof,
       similar, @_gc_preserve_end, @_gc_preserve_begin,
       @nexprs, @ncall, @ntuple, tuple_type_tail,
-      all, any, isbitsunion, issubset, replace_in_print_matrix, replace_with_centered_mark
+      all, any, isbitsunion, issubset, replace_in_print_matrix, replace_with_centered_mark,
+      strides, unsafe_convert
 
 import Base.Broadcast: BroadcastStyle, AbstractArrayStyle, Broadcasted, broadcasted,
                         combine_eltypes, DefaultArrayStyle, instantiate, materialize,
@@ -64,6 +65,15 @@ abstract type LayoutArray{T,N} <: AbstractArray{T,N} end
 const LayoutMatrix{T} = LayoutArray{T,2}
 const LayoutVector{T} = LayoutArray{T,1}
 
+## TODO: Following are type piracy whch may be removed in Julia v1.5
+_transpose_strides(a) = (a,1)
+_transpose_strides(a,b) = (b,a)
+strides(A::Adjoint) = _transpose_strides(strides(parent(A))...)
+strides(A::Transpose) = _transpose_strides(strides(parent(A))...)
+
+unsafe_convert(::Type{Ptr{T}}, A::Adjoint{<:Real}) where T<:Real = unsafe_convert(Ptr{T}, parent(A))
+unsafe_convert(::Type{Ptr{T}}, A::Transpose) where T = unsafe_convert(Ptr{T}, parent(A))
+
 include("memorylayout.jl")
 include("muladd.jl")
 include("lmul.jl")
@@ -74,7 +84,7 @@ include("factorizations.jl")
 
 @inline sub_materialize(_, V, _) = Array(V)
 @inline sub_materialize(L, V) = sub_materialize(L, V, axes(V))
-@inline sub_materialize(V::SubArray) = sub_materialize(MemoryLayout(typeof(V)), V)
+@inline sub_materialize(V::SubArray) = sub_materialize(MemoryLayout(V), V)
 
 @inline layout_getindex(A, I...) = sub_materialize(view(A, I...))
 
@@ -104,22 +114,22 @@ _copyto!(_, _, dest::AbstractArray{T,N}, src::AbstractArray{V,N}) where {T,V,N}
 
 
 copyto!(dest::LayoutArray{<:Any,N}, src::LayoutArray{<:Any,N}) where N = 
-    _copyto!(MemoryLayout(typeof(dest)), MemoryLayout(typeof(src)), dest, src)
+    _copyto!(MemoryLayout(dest), MemoryLayout(src), dest, src)
 copyto!(dest::AbstractArray{<:Any,N}, src::LayoutArray{<:Any,N}) where N = 
-    _copyto!(MemoryLayout(typeof(dest)), MemoryLayout(typeof(src)), dest, src)
+    _copyto!(MemoryLayout(dest), MemoryLayout(src), dest, src)
 copyto!(dest::LayoutArray{<:Any,N}, src::AbstractArray{<:Any,N}) where N = 
-    _copyto!(MemoryLayout(typeof(dest)), MemoryLayout(typeof(src)), dest, src)
+    _copyto!(MemoryLayout(dest), MemoryLayout(src), dest, src)
 
 copyto!(dest::SubArray{<:Any,N,<:LayoutArray}, src::SubArray{<:Any,N,<:LayoutArray}) where N = 
-    _copyto!(MemoryLayout(typeof(dest)), MemoryLayout(typeof(src)), dest, src)
+    _copyto!(MemoryLayout(dest), MemoryLayout(src), dest, src)
 copyto!(dest::SubArray{<:Any,N,<:LayoutArray}, src::LayoutArray{<:Any,N}) where N = 
-    _copyto!(MemoryLayout(typeof(dest)), MemoryLayout(typeof(src)), dest, src)
+    _copyto!(MemoryLayout(dest), MemoryLayout(src), dest, src)
 copyto!(dest::LayoutArray{<:Any,N}, src::SubArray{<:Any,N,<:LayoutArray}) where N = 
-    _copyto!(MemoryLayout(typeof(dest)), MemoryLayout(typeof(src)), dest, src)
+    _copyto!(MemoryLayout(dest), MemoryLayout(src), dest, src)
 copyto!(dest::SubArray{<:Any,N,<:LayoutArray}, src::AbstractArray{<:Any,N}) where N = 
-    _copyto!(MemoryLayout(typeof(dest)), MemoryLayout(typeof(src)), dest, src)
+    _copyto!(MemoryLayout(dest), MemoryLayout(src), dest, src)
 copyto!(dest::AbstractArray{<:Any,N}, src::SubArray{<:Any,N,<:LayoutArray}) where N = 
-    _copyto!(MemoryLayout(typeof(dest)), MemoryLayout(typeof(src)), dest, src)    
+    _copyto!(MemoryLayout(dest), MemoryLayout(src), dest, src)    
 
 
 

src/factorizations.jl

@@ -36,12 +36,12 @@ _factorize(layout, axes, A) = Base.invoke(factorize, Tuple{AbstractMatrix{eltype
 
 macro _layoutfactorizations(Typ)
     esc(quote
-        LinearAlgebra.qr(A::$Typ, args...; kwds...) = ArrayLayouts._qr(ArrayLayouts.MemoryLayout(typeof(A)), axes(A), A, args...; kwds...)
-        LinearAlgebra.qr!(A::$Typ, args...; kwds...) = ArrayLayouts._qr!(ArrayLayouts.MemoryLayout(typeof(A)), axes(A), A, args...; kwds...)
-        LinearAlgebra.lu(A::$Typ, pivot::Union{Val{false}, Val{true}}; kwds...) = ArrayLayouts._lu(ArrayLayouts.MemoryLayout(typeof(A)), axes(A), A, pivot; kwds...)
-        LinearAlgebra.lu(A::$Typ{T}; kwds...) where T = ArrayLayouts._lu(ArrayLayouts.MemoryLayout(typeof(A)), axes(A), A; kwds...)
-        LinearAlgebra.lu!(A::$Typ, args...; kwds...) = ArrayLayouts._lu!(ArrayLayouts.MemoryLayout(typeof(A)), axes(A), A, args...; kwds...)
-        LinearAlgebra.factorize(A::$Typ) = ArrayLayouts._factorize(ArrayLayouts.MemoryLayout(typeof(A)), axes(A), A)
+        LinearAlgebra.qr(A::$Typ, args...; kwds...) = ArrayLayouts._qr(ArrayLayouts.MemoryLayout(A), axes(A), A, args...; kwds...)
+        LinearAlgebra.qr!(A::$Typ, args...; kwds...) = ArrayLayouts._qr!(ArrayLayouts.MemoryLayout(A), axes(A), A, args...; kwds...)
+        LinearAlgebra.lu(A::$Typ, pivot::Union{Val{false}, Val{true}}; kwds...) = ArrayLayouts._lu(ArrayLayouts.MemoryLayout(A), axes(A), A, pivot; kwds...)
+        LinearAlgebra.lu(A::$Typ{T}; kwds...) where T = ArrayLayouts._lu(ArrayLayouts.MemoryLayout(A), axes(A), A; kwds...)
+        LinearAlgebra.lu!(A::$Typ, args...; kwds...) = ArrayLayouts._lu!(ArrayLayouts.MemoryLayout(A), axes(A), A, args...; kwds...)
+        LinearAlgebra.factorize(A::$Typ) = ArrayLayouts._factorize(ArrayLayouts.MemoryLayout(A), axes(A), A)
     end)
 end
 

src/ldiv.jl

@@ -63,7 +63,7 @@ end
     Rdiv(instantiate(L.A), instantiate(L.B))
 end
 
-__ldiv!(::Mat, ::Mat, B) where Mat = error("Overload materialize!(::Ldiv{$(typeof(MemoryLayout(Mat))),$(typeof(MemoryLayout(typeof(B))))})")
+__ldiv!(::Mat, ::Mat, B) where Mat = error("Overload materialize!(::Ldiv{$(typeof(MemoryLayout(Mat))),$(typeof(MemoryLayout(B)))})")
 __ldiv!(_, F, B) = ldiv!(F, B)
 @inline _ldiv!(A, B) = __ldiv!(A, factorize(A), B)
 @inline _ldiv!(A::Factorization, B) = ldiv!(A, B)

src/memorylayout.jl

@@ -462,7 +462,7 @@ rowsupport(_, A, k) = axes(A,2)
 
 gives an iterator containing the possible non-zero entries in the k-th row of A.
 """
-rowsupport(A, k) = rowsupport(MemoryLayout(typeof(A)), A, k)
+rowsupport(A, k) = rowsupport(MemoryLayout(A), A, k)
 rowsupport(A) = rowsupport(A, axes(A,1))
 
 colsupport(_, A, j) = axes(A,1)
@@ -472,7 +472,7 @@ colsupport(_, A, j) = axes(A,1)
 
 gives an iterator containing the possible non-zero entries in the j-th column of A.
 """
-colsupport(A, j) = colsupport(MemoryLayout(typeof(A)), A, j)
+colsupport(A, j) = colsupport(MemoryLayout(A), A, j)
 colsupport(A) = colsupport(A, axes(A,2))
 
 rowsupport(::ZerosLayout, A, _) = 1:0

src/muladd.jl

@@ -257,7 +257,6 @@ end
     end
 end
 
-
 @inline materialize!(M::BlasMatMulVecAdd{<:AbstractColumnMajor,<:AbstractStridedLayout,<:AbstractStridedLayout}) =
     _gemv!('N', M.α, M.A, M.B, M.β, M.C)
 @inline materialize!(M::BlasMatMulVecAdd{<:AbstractRowMajor,<:AbstractStridedLayout,<:AbstractStridedLayout}) =