Merge pull request #271 from SciML/compats

fix compats and undefined memory

Author: ChrisRackauckas

Project.toml

@@ -22,8 +22,8 @@ BandedMatrices = "0.15.11"
 BlockBandedMatrices = "0.8.6, 0.9"
 DiffEqBase = "6.4.1"
 ForwardDiff = "0.10"
-LazyArrays = "0.16.12"
-LazyBandedMatrices = "0.2.11"
+LazyArrays = "0.17"
+LazyBandedMatrices = "0.3"
 ModelingToolkit = "0.10.0, 1.0, 2.0, 3.0"
 NNlib = "0.6, 0.7"
 StaticArrays = "0.10, 0.11, 0.12"

src/composite_operators.jl

@@ -53,6 +53,7 @@ struct DiffEqOperatorCombination{T,O<:Tuple{Vararg{AbstractDiffEqLinearOperator{
     T = eltype(ops[1])
     if cache == nothing
       cache = Vector{T}(undef, size(ops[1], 1))
+      fill!(cache,0)
     end
     # TODO: safecheck dimensions
     new{T,typeof(ops),typeof(cache)}(ops, cache)
@@ -96,7 +97,9 @@ struct DiffEqOperatorComposition{T,O<:Tuple{Vararg{AbstractDiffEqLinearOperator{
       # Construct a list of caches to be used by mul! and ldiv!
       caches = []
       for op in ops[1:end-1]
-        push!(caches, Vector{T}(undef, size(op, 1)))
+        tmp = Vector{T}(undef, size(op, 1))
+        fill!(tmp,0)
+        push!(caches,tmp)
       end
       caches = tuple(caches...)
     end

src/derivative_operators/abstract_operator_functions.jl

@@ -166,7 +166,7 @@ end
 ################################################################################
 
 function *(coeff_func::Function, A::DerivativeOperator{T,N,Wind}) where {T,N,Wind}
-    coefficients = A.coefficients === nothing ? Vector{T}(undef, A.len) : A.coefficients
+    coefficients = A.coefficients === nothing ? zeros(T,A.len) : A.coefficients
 
     DerivativeOperator{T,N,Wind,typeof(A.dx),typeof(A.stencil_coefs),
                        typeof(A.low_boundary_coefs),typeof(coefficients),

src/derivative_operators/derivative_operator.jl

@@ -103,7 +103,7 @@ function CenteredDifference{N}(derivative_order::Int,
                                                                   calculate_weights(derivative_order, high_boundary_x[end-i], high_boundary_x)) for i in boundary_point_count:-1:1]
     high_boundary_coefs      = convert(SVector{boundary_point_count},_high_boundary_coefs)
 
-    coefficients            = coeff_func isa Nothing ? nothing : Vector{T}(undef,len)
+    coefficients            = coeff_func isa Nothing ? nothing : zeros(T,len)
 
     DerivativeOperator{T,N,false,typeof(dx),typeof(stencil_coefs),
         typeof(low_boundary_coefs),typeof(coefficients),
@@ -169,7 +169,7 @@ function UpwindDifference{N}(derivative_order::Int,
     _high_boundary_coefs     = SVector{boundary_stencil_length, T}[convert(SVector{boundary_stencil_length, T}, ((-1/dx)^derivative_order) * calculate_weights(derivative_order, oneunit(T)*x0, high_boundary_x)) for x0 in R_boundary_deriv_spots]
     high_boundary_coefs = convert(SVector{boundary_point_count},_high_boundary_coefs)
 
-    coefficients = Vector{T}(undef,len)
+    coefficients = zeros(T,len)
     if coeff_func != nothing
         compute_coeffs!(coeff_func, coefficients)
     end
@@ -215,7 +215,7 @@ function UpwindDifference{N}(derivative_order::Int,
     high_boundary_coefs = [_upwind_coefs ; _downwind_coefs]
 
     # Compute coefficients
-    coefficients = Vector{T}(undef,len)
+    coefficients = zeros(T,len)
     if coeff_func != nothing
         compute_coeffs!(coeff_func, coefficients)
     end

src/derivative_operators/multi_dim_bc_operators.jl

@@ -16,7 +16,7 @@ slice_rmul lets you multiply each vector like strip of an array `u` with a linea
 """
 function slice_rmul(A::AbstractDiffEqLinearOperator, u::AbstractArray{T,N}, dim::Int) where {T,N}
     @assert N != 1
-    u_temp = similar(u)
+    u_temp = zero(u)
 
     _slice_rmul!(u_temp, A, u, dim, CartesianIndices(axes(u)[1:dim-1]), CartesianIndices(axes(u)[(dim+1):end]))
 

src/matrixfree_operators.jl

@@ -24,7 +24,7 @@ end
   return n <= length(M.size) ? M.size[n] : 1
 end
 @inline ==(M1::MatrixFreeOperator, M2::MatrixFreeOperator) = M1.f == M2.f && M1.args == M2.args && M1.size == M2.size && M1.opnorm == M2.opnorm && M1.ishermitian == M2.ishermitian
-@inline Base.:*(A::MatrixFreeOperator, X::AbstractVecOrMat) = mul!(similar(X), A, X)
+@inline Base.:*(A::MatrixFreeOperator, X::AbstractVecOrMat) = mul!(zero(X), A, X)
 
 # Overloading LinearAlgebra functions
 LinearAlgebra.ishermitian(M::MatrixFreeOperator) = M.ishermitian
@@ -60,7 +60,7 @@ end
 
 function (M::MatrixFreeOperator{F,N})(u, p, t) where {F,N}
   update_coefficients!(M,u,p,t)
-  du = similar(u)
+  du = zero(u)
   if isconstant(M)
     M.f(du, u, p)
   else

test/upwind_operators_interface.jl

@@ -586,6 +586,7 @@ end
       L = UpwindDifference(1,2, 0.1, N, 1.0)
       analyticL = 10.0*analyticOneTwoPos()
       x = rand(7)
+      @show x
 
       # Test that multiplication agrees with analytic multiplication
       @test L*x ≈ analyticL*x