Boundschecks in findapproxmax and friends (#393)

* Boundschecks in findapproxmax and friends

* use Base.checkbounds

Author: jishnub

src/ApproxFunBase.jl

@@ -29,7 +29,7 @@ import Base: values, convert, getindex, setindex!, *, +, -, ==, <, <=, >, |, !,
               getproperty, findfirst, unsafe_getindex, fld, div,
               eachindex, firstindex, lastindex, isreal,
               OneTo, Array, Vector, Matrix, view, ones, @propagate_inbounds,
-              print_array, split, iszero, permutedims, rad2deg, deg2rad
+              print_array, split, iszero, permutedims, rad2deg, deg2rad, checkbounds
 
 import Base.Broadcast: BroadcastStyle, Broadcasted, AbstractArrayStyle,
               broadcastable, DefaultArrayStyle, broadcasted

src/Multivariate/LowRankFun.jl

@@ -248,6 +248,9 @@ LowRankFun(f::LowRankFun) = LowRankFun(f,ChebyshevInterval(),ChebyshevInterval()
 ## Utilities
 
 function findapproxmax!(f::Function,X::AbstractMatrix,ptsx::AbstractVector,ptsy::AbstractVector,gridx,gridy)
+    checkbounds(ptsy, 1:gridy)
+    checkbounds(ptsx, 1:gridx)
+    checkbounds(X, 1:gridx, 1:gridy)
     for j=1:gridy
         ptsyj = ptsy[j]
         @simd for k=1:gridx
@@ -268,6 +271,8 @@ function findapproxmax!(A::Fun,B::Fun,X::AbstractMatrix,ptsx::AbstractVector,pts
 end
 
 function findcholeskyapproxmax!(f::Function,X::AbstractVector,pts::AbstractVector,grid)
+    checkbounds(pts, 1:grid)
+    checkbounds(X, 1:grid)
     @simd for k=1:grid
         @inbounds X[k]+=f(pts[k],pts[k])
     end
@@ -283,6 +288,9 @@ function findcholeskyapproxmax!(A::Fun,B::Fun,X::AbstractVector,pts::AbstractVec
 end
 
 function subtractrankone!(A::AbstractVector,B::AbstractVector,X::AbstractMatrix,gridx::Int,gridy::Int)
+    checkbounds(B, 1:gridy)
+    checkbounds(A, 1:gridx)
+    checkbounds(X, 1:gridx, 1:gridy)
     for j=1:gridy
         @inbounds Bj = B[j]
         @simd for k=1:gridx
@@ -292,6 +300,9 @@ function subtractrankone!(A::AbstractVector,B::AbstractVector,X::AbstractMatrix,
 end
 
 function subtractrankone!(A::AbstractVector,B::AbstractVector,X::AbstractVector,grid::Int)
+    checkbounds(A, 1:grid)
+    checkbounds(B, 1:grid)
+    checkbounds(X, 1:grid)
     @simd for k=1:grid
         @inbounds X[k] -= A[k]*B[k]
     end

src/Operators/SubOperator.jl

@@ -1,35 +1,35 @@
-Vcheckbounds(A::Operator,kr::Colon) = nothing
-
-@inline function checkbounds(A, inds...)
-    _checkbounds(A, inds...)::Bool || throw(BoundsError(A,inds))
+function checkbounds(A::Operator, inds...)
+    checkbounds(Bool, A, inds...) || throw(BoundsError(A,inds))
     nothing
 end
 
-_checkbounds(A::Operator,kr)::Bool =
+checkbounds(::Type{Bool}, A::Operator,kr::Colon) = true
+
+checkbounds(::Type{Bool}, A::Operator,kr) =
     !(maximum(kr) > length(A) || minimum(kr) < 1)
 
 
-_checkbounds(A::Operator,kr::Union{Colon,InfRanges},jr::Union{Colon,InfRanges})::Bool = true
+checkbounds(::Type{Bool}, A::Operator,kr::Union{Colon,InfRanges},jr::Union{Colon,InfRanges}) = true
 
-_checkbounds(A::Operator,kr::Union{Colon,InfRanges},jr)::Bool =
+checkbounds(::Type{Bool}, A::Operator,kr::Union{Colon,InfRanges},jr) =
     !(maximum(jr) > size(A,2) || minimum(jr) < 1)
 
-_checkbounds(A::Operator,kr,jr::Union{Colon,InfRanges})::Bool =
+checkbounds(::Type{Bool}, A::Operator,kr,jr::Union{Colon,InfRanges}) =
     !(maximum(kr) > size(A,1)  || minimum(kr) < 1 )
 
-function _checkbounds(A::Operator,kr,jr)::Bool
+function checkbounds(::Type{Bool}, A::Operator,kr,jr)
     (isempty(kr) || isempty(jr)) && return true
     (1 <= minimum(kr) <= maximum(kr) <= size(A,1)) &&
     (1 <= minimum(jr) <= maximum(jr) <= size(A,2))
 end
 
-_checkbounds(A::Operator,K::Block,J::Block)::Bool =
+checkbounds(::Type{Bool}, A::Operator,K::Block,J::Block) =
      1 ≤ first(K.n[1]) ≤ length(blocklengths(rangespace(A))) &&
      1 ≤ first(J.n[1]) ≤ length(blocklengths(domainspace(A)))
 
-_checkbounds(A::Operator,K::BlockRange{1},J::BlockRange{1})::Bool =
+checkbounds(::Type{Bool}, A::Operator,K::BlockRange{1},J::BlockRange{1}) =
     isempty(K) || isempty(J) ||
-        _checkbounds(A, Block(maximum(K.indices[1])), Block(maximum(J.indices[1])))
+        checkbounds(Bool, A, Block(maximum(K.indices[1])), Block(maximum(J.indices[1])))