More tests, type restrictions

Author: AndiMD

src/derivative_operators/BC_operators.jl

@@ -136,16 +136,19 @@ end
 
 
 #implement Neumann and Dirichlet as special cases of RobinBC
-NeumannBC(α::NTuple{2,T}, dx::Union{AbstractVector{T}, T}, order = 1) where T = RobinBC((zero(T), one(T), α[1]), (zero(T), one(T), α[2]), dx, order)
-DirichletBC(αl::T, αr::T) where T = RobinBC((one(T), zero(T), αl), (one(T), zero(T), αr), one(T), 2one(T) )
+NeumannBC(α::NTuple{2,T}, dx::Union{AbstractVector{U}, U}, order = 1) where {T<:Number,U<:Real} = RobinBC((zero(T), one(T), α[1]), (zero(T), one(T), α[2]), dx, order)
+DirichletBC(αl::T, αr::T) where {T<:Real} = RobinBC((one(T), zero(T), αl), (one(T), zero(T), αr), one(T), 2one(T) )
+DirichletBC(U::Type,αl::T, αr::T) where {T<:Number,U<:Real} = RobinBC((one(T), zero(T), αl), (one(T), zero(T), αr), one(U), 2one(U) )
 #specialized constructors for Neumann0 and Dirichlet0
 Dirichlet0BC(T::Type) = DirichletBC(zero(T), zero(T))
-Neumann0BC(dx::Union{AbstractVector{T}, T}, order = 1) where T = NeumannBC((zero(T), zero(T)), dx, order)
+Neumann0BC(dx::Union{AbstractVector{T}, T}, order = 1) where {T<:Real} = NeumannBC((zero(T), zero(T)), dx, order)
+Neumann0BC(U::Type,dx::Union{AbstractVector{T}, T}, order = 1) where {T<:Real,U<:Number} = NeumannBC((zero(U), zero(U)), dx, order)
 
 # other acceptable argument signatures
 #RobinBC(al::T, bl::T, cl::T, dx_l::T, ar::T, br::T, cr::T, dx_r::T, order = 1) where T = RobinBC([al,bl, cl], [ar, br, cr], dx_l, order)
 
-Base.:*(Q::AffineBC, u::AbstractVector) = BoundaryPaddedVector(Q.a_l'⋅ u[1:length(Q.a_l)] + Q.b_l, Q.a_r' ⋅ u[(end-length(Q.a_r)+1):end] + Q.b_r, u)
+Base.:*(Q::AffineBC, u::AbstractVector) = BoundaryPaddedVector( Q.a_l'⋅ u[1:length(Q.a_l)] + Q.b_l, Q.a_r' ⋅ u[(end-length(Q.a_r)+1):end] + Q.b_r, u )
+
 Base.:*(Q::PeriodicBC, u::AbstractVector) = BoundaryPaddedVector(u[end], u[1], u)
 
 Base.size(Q::AtomicBC) = (Inf, Inf) #Is this nessecary?

test/robin.jl

@@ -104,3 +104,98 @@ ugeneralextended = G*u
 
 
 #TODO: Implement tests for BC's that are contingent on the sign of the coefficient on the operator near the boundary
+
+
+
+
+# Test complex Robin BC, uniform grid
+
+# Generate random parameters
+al = rand(ComplexF64,5)
+bl = rand(ComplexF64,5)
+cl = rand(ComplexF64,5)
+dx = rand(Float64,5)
+ar = rand(ComplexF64,5)
+br = rand(ComplexF64,5)
+cr = rand(ComplexF64,5)
+
+# Construct 5 arbitrary RobinBC operators for each parameter set
+for i in 1:5
+	
+	Q = RobinBC((al[i], bl[i], cl[i]), (ar[i], br[i], cr[i]), dx[i])
+
+	Q_L, Q_b = Array(Q,5i)
+
+	#Check that Q_L is is correctly computed
+	@test Q_L[2:5i+1,1:5i] ≈ Array(I, 5i, 5i)
+	@test Q_L[1,:] ≈ [1 / (1-al[i]*dx[i]/bl[i]); zeros(5i-1)]
+	@test Q_L[5i+2,:] ≈ [zeros(5i-1); 1 / (1+ar[i]*dx[i]/br[i])]
+
+	#Check that Q_b is computed correctly
+	@test Q_b ≈ [cl[i]/(al[i]-bl[i]/dx[i]); zeros(5i); cr[i]/(ar[i]+br[i]/dx[i])]
+
+	# Construct the extended operator and check that it correctly extends u to a (5i+2)
+	# vector, along with encoding boundary condition information.
+	u = rand(ComplexF64,5i)
+
+	Qextended = Q*u
+	CorrectQextended = [(cl[i]-(bl[i]/dx[i])*u[1])/(al[i]-bl[i]/dx[i]); u; (cr[i]+ (br[i]/dx[i])*u[5i])/(ar[i]+br[i]/dx[i])]
+	@test length(Qextended) ≈ 5i+2
+
+	# Check concretization
+	@test Array(Qextended) ≈ CorrectQextended # 	Q.a_l ⋅ u[1:length(Q.a_l)] + Q.b_l, 		Q.a_r ⋅ u[(end-length(Q.a_r)+1):end] + Q.b_r
+
+	# Check that Q_L and Q_b correctly compute BoundaryPaddedVector
+	@test Q_L*u + Q_b ≈ CorrectQextended
+
+	@test [Qextended[1]; Qextended.u; Qextended[5i+2]] ≈ CorrectQextended
+	
+end
+
+# Construct 5 arbitrary RobinBC operators w/non-uniform grid
+al = rand(ComplexF64,5)
+bl = rand(ComplexF64,5)
+cl = rand(ComplexF64,5)
+dx = rand(Float64,5)
+ar = rand(ComplexF64,5)
+br = rand(ComplexF64,5)
+cr = rand(ComplexF64,5)
+for j in 1:2
+    for i in 1:5
+        if j == 1
+            Q = RobinBC((al[i], bl[i], cl[i]), (ar[i], br[i], cr[i]),
+                        dx[i] .* ones(5 * i))
+        else
+            Q = RobinBC([al[i], bl[i], cl[i]], [ar[i], br[i], cr[i]],
+                        dx[i] .* ones(5 * i))
+        end
+        Q_L, Q_b = Array(Q,5i)
+
+        #Check that Q_L is is correctly computed
+        @test Q_L[2:5i+1,1:5i] ≈ Array(I, 5i, 5i)
+        @test Q_L[1,:] ≈ [1 / (1-al[i]*dx[i]/bl[i]); zeros(5i-1)]
+        @test Q_L[5i+2,:] ≈ [zeros(5i-1); 1 / (1+ar[i]*dx[i]/br[i])]
+
+        #Check that Q_b is computed correctly
+        @test Q_b ≈ [cl[i]/(al[i]-bl[i]/dx[i]); zeros(5i); cr[i]/(ar[i]+br[i]/dx[i])]
+
+        # Construct the extended operator and check that it correctly extends u to a (5i+2)
+        # vector, along with encoding boundary condition information.
+        u = rand(ComplexF64,5i)
+
+        Qextended = Q*u
+        CorrectQextended = [(cl[i]-(bl[i]/dx[i])*u[1])/(al[i]-bl[i]/dx[i]); u; (cr[i]+ (br[i]/dx[i])*u[5i])/(ar[i]+br[i]/dx[i])]
+        @test length(Qextended) ≈ 5i+2
+
+        # Check concretization
+        @test Array(Qextended) ≈ CorrectQextended
+
+        # Check that Q_L and Q_b correctly compute BoundaryPaddedVector
+        @test Q_L*u + Q_b ≈ CorrectQextended
+
+        @test [Qextended[1]; Qextended.u; Qextended[5i+2]] ≈ CorrectQextended
+
+    end
+end
+
+

test/runtests.jl

@@ -12,7 +12,6 @@ if GROUP == "All" || GROUP == "Interface"
     @time @safetestset "Poisson example" begin include("../examples/poisson.jl") end
     @time @safetestset "Heat equation example" begin include("../examples/heat_equation.jl") end
     @time @safetestset "Robin Boundary Condition Operators" begin include("robin.jl") end
-    @time @safetestset "Robin Boundary Condition Operators, Complex" begin include("robin_complex.jl") end
     @time @safetestset "JacVec Operators Interface" begin include("jacvec_operators.jl") end
     @time @safetestset "Composite Operators Interface" begin include("composite_operators_interface.jl") end
     @time @safetestset "BC and Coefficient Compositions" begin include("bc_coeff_compositions.jl") end