exports

Author: xtalax

src/DiffEqOperators.jl

@@ -51,7 +51,7 @@ export MatrixFreeOperator
 export DiffEqScalar, DiffEqArrayOperator, DiffEqIdentity, JacVecOperator, getops
 export AbstractDerivativeOperator, DerivativeOperator,
        CenteredDifference, UpwindDifference
-export DirichletBC, Dirichlet0BC, NeumannBC, Neumann0BC, RobinBC, GeneralBC, MixedBC, MultiDimBC, PeriodicBC,
+export DirichletBC, Dirichlet0BC, NeumannBC, Neumann0BC, RobinBC, GeneralBC, MultiDimBC, PeriodicBC,
        MultiDimDirectionalBC, ComposedMultiDimBC,
        compose, decompose, perpsize
 

src/derivative_operators/BC_operators.jl

@@ -153,20 +153,7 @@ struct GeneralBC{T} <:AffineBC{T}
     end
 end
 
-"""
-Quick and dirty way to allow mixed boundary types on each end of an array - may be cleaner and more versatile to split up left and right boundaries going forward
-MixedBC(lowerBC, upperBC) is the interface.
-"""
 
-struct MixedBC{T, R, S} <: AtomicBC{T}
-    lower::R
-    upper::S
-    function MixedBC(Qlower,Qupper)
-        @assert Qlower isa AtomicBC
-        @assert Qupper isa AtomicBC
-         new{Union{gettype(Qlower), gettype(Qupper)}, typeof(Qlower), typeof(Qupper)}(Qlower, Qupper)
-     end
-end
 
 #implement Neumann and Dirichlet as special cases of RobinBC
 NeumannBC(α::AbstractVector{T}, dx::Union{AbstractVector{T}, T}, order = 1) where T = RobinBC([zero(T), one(T), α[1]], [zero(T), one(T), α[2]], dx, order)
@@ -178,7 +165,6 @@ Neumann0BC(dx::Union{AbstractVector{T}, T}, order = 1) where T = NeumannBC([zero
 # 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::MixedBC, u::AbstractVector) =  BoundaryPaddedVector((Q.lower*u).l, (Q.upper*u).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)
 

src/derivative_operators/concretization.jl

@@ -142,7 +142,7 @@ end
 ################################################################################
 # Boundary Condition Operator concretizations
 ################################################################################
-add_dims(A::AbstractArray, n::int) = cat(ndims(a) + n, a)
+add_dims(A::AbstractArray, n::Int) = cat(ndims(a) + n, a)
 #Atomic BCs
 function LinearAlgebra.Array(Q::AffineBC{T}, N::Int) where {T}
     Q_L = [transpose(Q.a_l) transpose(zeros(T, N-length(Q.a_l))); Diagonal(ones(T,N)); transpose(zeros(T, N-length(Q.a_r))) transpose(Q.a_r)]
@@ -205,7 +205,7 @@ filled with the linear operator parts of the respective Atomic BCs.
 the second element is a simularly sized array of the affine parts.
 """
 function LinearAlgebra.Array(Q::MultiDimDirectionalBC{T, B, D, N, K}, M) where {T, B, D,N,K}
-    bc_tuples = Array.(Q.BCs, fill(M, size(Q.BCs))
+    bc_tuples = Array.(Q.BCs, fill(M, size(Q.BCs)))
     Q_L = [bc_tuple[1] for bc_tuple in bc_tuples]
     inds = Array(1:N)
     inds[1], inds[D] = inds[D], inds[1]
@@ -220,7 +220,7 @@ filled with the linear operator parts of the respective Atomic BCs.
 the second element is a simularly sized array of the affine parts.
 """
 function SparseArrays.SparseMatrixCSC(Q::MultiDimDirectionalBC{T, B, D, N, K}, M) where {T, B, D,N,K}
-    bc_tuples = sparse.(Q.BCs, fill(M, size(Q.BCs))
+    bc_tuples = sparse.(Q.BCs, fill(M, size(Q.BCs)))
     Q_L = [bc_tuple[1] for bc_tuple in bc_tuples]
     inds = Array(1:N)
     inds[1], inds[D] = inds[D], inds[1]
@@ -232,7 +232,7 @@ end
 SparseArrays.sparse(Q::MultiDimDirectionalBC, N) = SparseMatrixCSC(Q, N)
 
 function BandedMatrices.BandedMatrix(Q::MultiDimDirectionalBC{T, B, D, N, K}, M) where {T, B, D,N,K}
-    bc_tuples = BandedMatrix.(Q.BCs, fill(M, size(Q.BCs))
+    bc_tuples = BandedMatrix.(Q.BCs, fill(M, size(Q.BCs)))
     Q_L = [bc_tuple[1] for bc_tuple in bc_tuples]
     inds = Array(1:N)
     inds[1], inds[D] = inds[D], inds[1]