adjoint/transpose broadcast (#16)

* adjoint/transpose broadcast

* fix dot notation

* Support LazyArrays 0.12

* permutedims

* Diagonal * is now BroadcastArray

* vcat with fill

* v0.3

* Update infrange.jl

* Update runtests.jl

* Update runtests.jl

* override other OneTo case

Author: dlfivefifty

Project.toml

@@ -1,6 +1,6 @@
 name = "InfiniteArrays"
 uuid = "4858937d-0d70-526a-a4dd-2d5cb5dd786c"
-version = "0.2"
+version = "0.3"
 
 [deps]
 DSP = "717857b8-e6f2-59f4-9121-6e50c889abd2"
@@ -12,8 +12,8 @@ Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
 
 [compat]
 DSP = "0.5.1, 0.6"
-FillArrays = "0.6, 0.7"
-LazyArrays = "0.11"
+FillArrays = "0.7.1"
+LazyArrays = "0.12"
 julia = "1"
 
 [extras]

src/InfiniteArrays.jl

@@ -22,7 +22,7 @@ import Base: *, +, -, /, \, ==, isinf, isfinite, sign, angle, show, isless,
          AbstractArray, AbstractVector, Array, Vector, Matrix,
          axes, (:), _sub2ind_recurse, broadcast, promote_eltypeof,
          diff, cumsum, show_delim_array, show_circular, Int,
-         similar, _unsafe_getindex, string, zeros, fill
+         similar, _unsafe_getindex, string, zeros, fill, permutedims
 
 using Base.Broadcast
 import Base.Broadcast: BroadcastStyle, AbstractArrayStyle, Broadcasted, broadcasted,
@@ -80,7 +80,8 @@ length(::Zeros{<:Any,2,Tuple{OneToInf{Int},OneToInf{Int}}}) = ∞
 length(::Zeros{<:Any,2,<:Tuple{OneToInf{Int},<:Any}}) = ∞
 length(::Zeros{<:Any,2,<:Tuple{<:Any,OneToInf{Int}}}) = ∞
 
-
+vcat(a::Number, b::AbstractFill{<:Any,1,<:Tuple{<:OneToInf}}) = Vcat(a, b)
+vcat(a::AbstractVector, b::AbstractFill{<:Any,1,<:Tuple{<:OneToInf}}) = Vcat(a, b)
 
 ##
 # Temporary hacks for base support
@@ -89,6 +90,8 @@ OneTo(::Infinity) = OneToInf()
 OneTo{T}(::Infinity) where T<:Integer = OneToInf{T}()
 UnitRange(start::Integer, ::Infinity) = InfUnitRange(start)
 UnitRange{T}(start::Integer, ::Infinity) where T<:Real = InfUnitRange{T}(start)
+OneTo(a::OneToInf) = a
+OneTo{T}(::OneToInf) where T<:Integer = OneToInf{T}()
 
 Int(::Infinity) = ∞
 

src/infrange.jl

@@ -354,6 +354,8 @@ in(x::Real, r::InfRanges{T}) where {T<:Integer} =
 ### Lazy broadcasting
 
 BroadcastStyle(::Type{<:InfRanges}) = LazyArrayStyle{1}()
+BroadcastStyle(::Type{<:Adjoint{<:Any,<:InfRanges}}) = LazyArrayStyle{2}()
+BroadcastStyle(::Type{<:Transpose{<:Any,<:InfRanges}}) = LazyArrayStyle{2}()
 
 
 
@@ -364,6 +366,20 @@ BroadcastStyle(::Type{<:SubArray{<:Any,2,<:Any,<:Tuple{<:InfIndexRanges,<:InfInd
 BroadcastStyle(::Type{<:SubArray{<:Any,2,<:Any,<:Tuple{<:InfIndexRanges,<:Any}}})= LazyArrayStyle{1}()
 BroadcastStyle(::Type{<:SubArray{<:Any,2,<:Any,<:Tuple{<:Any,<:InfIndexRanges}}})= LazyArrayStyle{1}()
 
+broadcasted(::BroadcastStyle, f, r::Adjoint{<:Any,<:InfRanges}) = broadcast(f,parent(r))'
+broadcasted(::BroadcastStyle, f, r::Transpose{<:Any,<:InfRanges}) = transpose(broadcast(f,parent(r)))
+broadcasted(::BroadcastStyle, f, a::Number, r::Adjoint{<:Any,<:InfRanges}) = broadcast(f,a,parent(r))'
+broadcasted(::BroadcastStyle, f, a::Number, r::Transpose{<:Any,<:InfRanges}) = transpose(broadcast(f,a,parent(r)))
+broadcasted(::BroadcastStyle, f, r::Adjoint{<:Any,<:InfRanges}, a::Number) = broadcast(f,parent(r),a)'
+broadcasted(::BroadcastStyle, f, r::Transpose{<:Any,<:InfRanges}, a::Number) = transpose(broadcast(f,parent(r),a))
+
+broadcast(f, r::Adjoint{<:Any,<:InfRanges}) = broadcast(f,parent(r))'
+broadcast(f, r::Transpose{<:Any,<:InfRanges}) = transpose(broadcast(f,parent(r)))
+broadcast(f, a::Number, r::Adjoint{<:Any,<:InfRanges}) = broadcast(f,a,parent(r))'
+broadcast(f, a::Number, r::Transpose{<:Any,<:InfRanges}) = transpose(broadcast(f,a,parent(r)))
+broadcast(f, r::Adjoint{<:Any,<:InfRanges}, a::Number) = broadcast(f,parent(r),a)'
+broadcast(f, r::Transpose{<:Any,<:InfRanges}, a::Number) = transpose(broadcast(f,parent(r),a))
+
 
 cumsum(r::InfRanges) = OneToInf() .* (first(r) .+ r) .÷ 2
 
@@ -448,3 +464,10 @@ end
 
 MemoryLayout(::Type{<:AbstractInfUnitRange}) = LazyLayout()
 MemoryLayout(::Type{<:InfStepRange}) = LazyLayout()
+
+
+####
+# permutedims
+####
+permutedims(r::InfRanges) = transpose(r)
+permutedims(r::BroadcastVector{<:Number,<:Any,<:Tuple{Int,InfRanges}}) = transpose(r)

test/runtests.jl

@@ -1,7 +1,8 @@
 using LinearAlgebra, SparseArrays, InfiniteArrays, FillArrays, LazyArrays, Statistics, DSP, BandedMatrices, Test
 import InfiniteArrays: OrientedInfinity, OneToInf, InfUnitRange, InfStepRange
-import LazyArrays: CachedArray, MemoryLayout, LazyLayout
+import LazyArrays: CachedArray, MemoryLayout, LazyLayout, DiagonalLayout, LazyArrayStyle 
 import BandedMatrices: _BandedMatrix, BandedColumns
+import Base.Broadcast: broadcasted, Broadcasted, instantiate
 
 @testset "∞" begin
     @test ∞ ≠ 1
@@ -272,6 +273,12 @@ end
         @test broadcast(-, 1:2:∞, 1) ≡ 0:2:∞
         @test broadcast(-, 1:2:∞, 0.3) ≡ 1-0.3:2:∞
         @test broadcast(-, 2, 1:∞) ≡ 1:-1:-∞
+        @test exp.((1:∞)') ≡ broadcast(exp, (1:∞)') ≡ exp.(1:∞)'
+        @test exp.(transpose(1:∞)) ≡ broadcast(exp, transpose(1:∞)) ≡ transpose(exp.(1:∞))
+        @test 1 .+ (1:∞)' ≡ broadcast(+, 1, (1:∞)') ≡ (2:∞)'
+        @test 1 .+ transpose(1:∞) ≡ broadcast(+, 1, transpose(1:∞)) ≡ transpose(2:∞)
+        @test (1:∞)' .+ 1 ≡ broadcast(+, (1:∞)', 1) ≡ (2:∞)'
+        @test transpose(1:∞) .+ 1 ≡ broadcast(+, transpose(1:∞), 1) ≡ transpose(2:∞)
     end
 
     @testset "near-equal ranges" begin
@@ -421,8 +428,15 @@ end
     @test_broken D^2 isa Diagonal
     @test D*D isa Diagonal
     @test MemoryLayout(typeof(D.diag)) == LazyLayout()
-    @test MemoryLayout(typeof(D)) == LazyLayout()
-    @test Ones(∞,∞)*D isa ApplyArray
+    @test MemoryLayout(typeof(D)) == DiagonalLayout{LazyLayout}()
+    @test Base.BroadcastStyle(typeof(D)) == LazyArrayStyle{2}()
+    @test Base.BroadcastStyle(typeof(permutedims(D.diag))) == LazyArrayStyle{2}()
+    bc = broadcasted(*,Ones(∞,∞),permutedims(D.diag))
+    @test bc isa Broadcasted{LazyArrayStyle{2}}
+    @test instantiate(bc) isa Broadcasted{LazyArrayStyle{2}}
+    @test copy(instantiate(bc)) isa BroadcastArray
+    @test broadcast(*,Ones(∞,∞),permutedims(D.diag)) isa BroadcastArray
+    @test Ones(∞,∞)*D isa BroadcastArray
     @test (Ones(∞,∞)*D)[1:10,1:10] == Ones(10,10)*D[1:10,1:10]
 end
 
@@ -594,7 +608,7 @@ end
     C = Vcat([1,2,3], Zeros(∞))
     D = Vcat(Fill(1,3,∞), Zeros(∞,∞))
 
-    @test A*B isa ApplyArray
+    @test A*B isa BroadcastArray
     @test size(A*B) == (3,∞)
     @test (A*B)[1:3,1:10] == Fill(1,3,10)*Diagonal(1:10)
 
@@ -618,4 +632,9 @@ end
 @testset "Banded" begin
     A = _BandedMatrix((0:∞)', ∞, -1, 1)
     @test_broken apply(*, Eye(∞), A) ≡ A
+end
+
+@testset "permutedims" begin
+    @test permutedims(1:∞) isa Transpose
+    @test permutedims(1:∞)[1,1:10] == (1:10)
 end