Test continuous (#6)

* Test contnuous

* start matmul tests

* more * tests

Author: dlfivefifty

Project.toml

@@ -13,6 +13,7 @@ julia = "1.1"
 
 [extras]
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+IntervalSets = "8197267c-284f-5f27-9208-e0e47529a953"
 
 [targets]
-test = ["Test"]
+test = ["Test","IntervalSets"]

src/QuasiArrays.jl

@@ -92,6 +92,10 @@ include("quasidiagonal.jl")
 
 
 
+function materialize(A::Applied{LazyQuasiArrayApplyStyle,typeof(*),<:Tuple{Vararg{<:Union{Adjoint,QuasiAdjoint,QuasiDiagonal}}}}) 
+    checkaxescompatible(A.args...)
+    ApplyQuasiArray(A)
+end
 
 materialize(M::Applied{<:Any,typeof(*),<:Tuple{Vararg{<:Union{Adjoint,QuasiAdjoint,QuasiDiagonal}}}}) =
     apply(*,reverse(adjoint.(M.args))...)'

src/indices.jl

@@ -120,10 +120,15 @@ role as `Slice` does for offset arrays.
 struct Inclusion{T,AX} <: AbstractQuasiVector{T}
     domain::AX
 end
-Inclusion(domain) = Inclusion{eltype(domain),typeof(domain)}(domain)
+Inclusion{T}(domain) where T = Inclusion{T,typeof(domain)}(domain)
+Inclusion{T}(S::Inclusion) where T = Inclusion{T}(S.domain)
+Inclusion{T}(S::Slice) where T = Inclusion{T}(S.indices)
+Inclusion(domain) = Inclusion{eltype(domain)}(domain)
 Inclusion(S::Inclusion) = S
 Inclusion(S::Slice) = Inclusion(S.indices)
 
+convert(::Type{Inclusion}, d::Inclusion) = d
+convert(::Type{Inclusion{T}}, d::Inclusion) where T = Inclusion{T}(d)
 convert(::Type{AbstractVector}, d::Inclusion{<:Any,<:AbstractVector}) =
     convert(AbstractVector, d.domain)
 convert(::Type{AbstractArray}, d::Inclusion{<:Any,<:AbstractVector}) =

test/runtests.jl

@@ -5,4 +5,6 @@ include("test_quasibroadcast.jl")
 include("test_arrayops.jl")
 include("test_quasisubarray.jl")
 
-include("test_quasiadjtrans.jl")
+include("test_quasiadjtrans.jl")
+include("test_continuous.jl")
+include("test_matmul.jl")

test/test_continuous.jl

@@ -0,0 +1,39 @@
+using QuasiArrays, IntervalSets, Test
+import QuasiArrays: ApplyQuasiArray
+
+@testset "Continuous" begin
+    @testset "Inclusion" begin
+        x = Inclusion(0..1)
+        @test axes(x) ≡ (x,)
+        @test_throws InexactError x[0.1]
+        @test x[1] ≡ 1
+        @test_throws BoundsError x[2]
+
+        for x in (Inclusion{Float64}(0..1),Inclusion(0.0..1))
+            @test Inclusion(x) ≡ Inclusion{Float64}(x) ≡ convert(Inclusion,x) ≡ 
+                    convert(Inclusion{Float64},x) ≡ convert(AbstractQuasiArray,x) ≡
+                    convert(AbstractQuasiArray{Float64},x) ≡ convert(AbstractQuasiVector{Float64},x) ≡ 
+                    convert(AbstractQuasiVector,x) ≡ x
+            @test axes(x) ≡ (x,)
+            @test x[0.1] ≡ 0.1
+            @test x[1] ≡ 1.0
+            @test_throws BoundsError x[2]
+            @test x[BigFloat(π)/4] == π/4
+        end
+
+        @test Inclusion{Float64}(0..1) == Inclusion(0.0..1)
+        @test Inclusion{Float64}(0..1) !== Inclusion(0.0..1)
+    end
+
+    @testset "QuasiDiagonal" begin
+        x = Inclusion(0.0..1)
+        D = QuasiDiagonal(x)
+        @test D[0.1,0.2] ≡ 0.0
+        @test D[0.1,0.1] ≡ 0.1
+        @test D[1,1] ≡ 1.0
+        @test_throws BoundsError D[1.1,1.2]
+
+        D2 = D*D
+        @test D2 isa ApplyQuasiArray
+    end
+end

test/test_matmul.jl

@@ -0,0 +1,24 @@
+using QuasiArrays, Test
+import QuasiArrays: ApplyQuasiArray
+
+@testset "Multiplication" begin
+    @testset "Diag * Inclusion" begin
+        A = QuasiDiagonal(Inclusion(0:0.1:1))
+        b = Inclusion(0:0.1:1)
+        Ab = A*b
+        @test Ab isa ApplyQuasiArray
+        @test Ab[0.1] ≈ 0.1^2
+        @test_throws DimensionMismatch A*Inclusion(1:2)
+    end
+    @testset "Quasi * Quasi" begin
+        A = QuasiArray(rand(3,3),(0:0.5:1,0:0.5:1))
+        @test A*A isa ApplyQuasiArray
+        @test QuasiArray(A*A) == QuasiArray(A.parent*A.parent,A.axes)
+    end
+    @testset "Quasi * Array" begin
+        A = QuasiArray(rand(3,3),(0:0.5:1,Base.OneTo(3)))
+        B = rand(3,3)
+        @test A*B isa ApplyQuasiArray
+        @test QuasiArray(A*B) == QuasiArray(A.parent*B,A.axes)
+    end
+end