audit assert !has_offset_axes(...) in stdlib/LinearAlgebra

stdlib/LinearAlgebra/src/LinearAlgebra.jl

@@ -16,7 +16,7 @@ import Base: USE_BLAS64, abs, acos, acosh, acot, acoth, acsc, acsch, adjoint, as
  setindex!, show, similar, sin, sincos, sinh, size, size_to_strides, sqrt, StridedReinterpretArray,
  StridedReshapedArray, strides, stride, tan, tanh, transpose, trunc, typed_hcat, vec
 using Base: hvcat_fill, IndexLinear, promote_op, promote_typeof,
- @propagate_inbounds, @pure, reduce, typed_vcat, has_offset_axes
+ @propagate_inbounds, @pure, reduce, typed_vcat, require_one_based_indexing
 using Base.Broadcast: Broadcasted
 
 export

stdlib/LinearAlgebra/src/adjtrans.jl

@@ -197,7 +197,7 @@ broadcast(f, tvs::Union{Number,TransposeAbsVec}...) = transpose(broadcast((xs...
 *(u::AdjointAbsVec, v::AbstractVector) = dot(u.parent, v)
 *(u::TransposeAbsVec{T}, v::AbstractVector{T}) where {T<:Real} = dot(u.parent, v)
 function *(u::TransposeAbsVec, v::AbstractVector)
- @assert !has_offset_axes(u, v)
+ require_one_based_indexing(u, v)
  @boundscheck length(u) == length(v) || throw(DimensionMismatch())
  return sum(@inbounds(u[k]*v[k]) for k in 1:length(u))
 end

stdlib/LinearAlgebra/src/bidiag.jl

@@ -6,7 +6,7 @@ struct Bidiagonal{T,V<:AbstractVector{T}} <: AbstractMatrix{T}
  ev::V # sub/super diagonal
  uplo::Char # upper bidiagonal ('U') or lower ('L')
  function Bidiagonal{T,V}(dv, ev, uplo::AbstractChar) where {T,V<:AbstractVector{T}}
- @assert !has_offset_axes(dv, ev)
+ require_one_based_indexing(dv, ev)
  if length(ev) != length(dv)-1
  throw(DimensionMismatch("length of diagonal vector is $(length(dv)), length of off-diagonal vector is $(length(ev))"))
  end
@@ -355,9 +355,9 @@ mul!(C::AbstractMatrix, A::BiTri, B::Adjoint{<:Any,<:AbstractVecOrMat}) = A_mul_
 mul!(C::AbstractVector, A::BiTri, B::Transpose{<:Any,<:AbstractVecOrMat}) = throw(MethodError(mul!, (C, A, B)))
 
 function check_A_mul_B!_sizes(C, A, B)
- @assert !has_offset_axes(C)
- @assert !has_offset_axes(A)
- @assert !has_offset_axes(B)
+ require_one_based_indexing(C)
+ require_one_based_indexing(A)
+ require_one_based_indexing(B)
  nA, mA = size(A)
  nB, mB = size(B)
  nC, mC = size(C)
@@ -438,8 +438,8 @@ function A_mul_B_td!(C::AbstractMatrix, A::BiTriSym, B::BiTriSym)
 end
 
 function A_mul_B_td!(C::AbstractVecOrMat, A::BiTriSym, B::AbstractVecOrMat)
- @assert !has_offset_axes(C)
- @assert !has_offset_axes(B)
+ require_one_based_indexing(C)
+ require_one_based_indexing(B)
  nA = size(A,1)
  nB = size(B,2)
  if !(size(C,1) == size(B,1) == nA)
@@ -577,7 +577,7 @@ ldiv!(A::Union{Bidiagonal, AbstractTriangular}, b::AbstractVector) = naivesub!(A
 ldiv!(A::Transpose{<:Any,<:Bidiagonal}, b::AbstractVector) = ldiv!(copy(A), b)
 ldiv!(A::Adjoint{<:Any,<:Bidiagonal}, b::AbstractVector) = ldiv!(copy(A), b)
 function ldiv!(A::Union{Bidiagonal,AbstractTriangular}, B::AbstractMatrix)
- @assert !has_offset_axes(A, B)
+ require_one_based_indexing(A, B)
  nA,mA = size(A)
  tmp = similar(B,size(B,1))
  n = size(B, 1)
@@ -592,7 +592,7 @@ function ldiv!(A::Union{Bidiagonal,AbstractTriangular}, B::AbstractMatrix)
  B
 end
 function ldiv!(adjA::Adjoint{<:Any,<:Union{Bidiagonal,AbstractTriangular}}, B::AbstractMatrix)
- @assert !has_offset_axes(adjA, B)
+ require_one_based_indexing(adjA, B)
  A = adjA.parent
  nA,mA = size(A)
  tmp = similar(B,size(B,1))
@@ -608,7 +608,7 @@ function ldiv!(adjA::Adjoint{<:Any,<:Union{Bidiagonal,AbstractTriangular}}, B::A
  B
 end
 function ldiv!(transA::Transpose{<:Any,<:Union{Bidiagonal,AbstractTriangular}}, B::AbstractMatrix)
- @assert !has_offset_axes(transA, B)
+ require_one_based_indexing(transA, B)
  A = transA.parent
  nA,mA = size(A)
  tmp = similar(B,size(B,1))
@@ -625,7 +625,7 @@ function ldiv!(transA::Transpose{<:Any,<:Union{Bidiagonal,AbstractTriangular}},
 end
 #Generic solver using naive substitution
 function naivesub!(A::Bidiagonal{T}, b::AbstractVector, x::AbstractVector = b) where T
- @assert !has_offset_axes(A, b, x)
+ require_one_based_indexing(A, b, x)
  N = size(A, 2)
  if N != length(b) || N != length(x)
  throw(DimensionMismatch("second dimension of A, $N, does not match one of the lengths of x, $(length(x)), or b, $(length(b))"))

stdlib/LinearAlgebra/src/blas.jl

@@ -7,7 +7,7 @@ Interface to BLAS subroutines.
 
 import ..axpy!, ..axpby!
 import Base: copyto!
-using Base: has_offset_axes
+using Base: require_one_based_indexing
 
 export
 # Level 1
@@ -328,23 +328,23 @@ for (fname, elty) in ((:cblas_zdotu_sub,:ComplexF64),
 end
 
 function dot(DX::Union{DenseArray{T},AbstractVector{T}}, DY::Union{DenseArray{T},AbstractVector{T}}) where T<:BlasReal
- @assert !has_offset_axes(DX, DY)
+ require_one_based_indexing(DX, DY)
  n = length(DX)
  if n != length(DY)
  throw(DimensionMismatch("dot product arguments have lengths $(length(DX)) and $(length(DY))"))
  end
  GC.@preserve DX DY dot(n, pointer(DX), stride(DX, 1), pointer(DY), stride(DY, 1))
 end
 function dotc(DX::Union{DenseArray{T},AbstractVector{T}}, DY::Union{DenseArray{T},AbstractVector{T}}) where T<:BlasComplex
- @assert !has_offset_axes(DX, DY)
+ require_one_based_indexing(DX, DY)
  n = length(DX)
  if n != length(DY)
  throw(DimensionMismatch("dot product arguments have lengths $(length(DX)) and $(length(DY))"))
  end
  GC.@preserve DX DY dotc(n, pointer(DX), stride(DX, 1), pointer(DY), stride(DY, 1))
 end
 function dotu(DX::Union{DenseArray{T},AbstractVector{T}}, DY::Union{DenseArray{T},AbstractVector{T}}) where T<:BlasComplex
- @assert !has_offset_axes(DX, DY)
+ require_one_based_indexing(DX, DY)
  n = length(DX)
  if n != length(DY)
  throw(DimensionMismatch("dot product arguments have lengths $(length(DX)) and $(length(DY))"))
@@ -525,7 +525,7 @@ for (fname, elty) in ((:daxpby_,:Float64), (:saxpby_,:Float32),
 end
 
 function axpby!(alpha::Number, x::Union{DenseArray{T},AbstractVector{T}}, beta::Number, y::Union{DenseArray{T},AbstractVector{T}}) where T<:BlasFloat
- @assert !has_offset_axes(x, y)
+ require_one_based_indexing(x, y)
  if length(x) != length(y)
  throw(DimensionMismatch("x has length $(length(x)), but y has length $(length(y))"))
  end
@@ -564,7 +564,7 @@ for (fname, elty) in ((:dgemv_,:Float64),
  #* .. Array Arguments ..
  # DOUBLE PRECISION A(LDA,*),X(*),Y(*)
  function gemv!(trans::AbstractChar, alpha::($elty), A::AbstractVecOrMat{$elty}, X::AbstractVector{$elty}, beta::($elty), Y::AbstractVector{$elty})
- @assert !has_offset_axes(A, X, Y)
+ require_one_based_indexing(A, X, Y)
  m,n = size(A,1),size(A,2)
  if trans == 'N' && (length(X) != n || length(Y) != m)
  throw(DimensionMismatch("A has dimensions $(size(A)), X has length $(length(X)) and Y has length $(length(Y))"))
@@ -649,7 +649,7 @@ for (fname, elty) in ((:dgbmv_,:Float64),
  # * .. Array Arguments ..
  # DOUBLE PRECISION A(LDA,*),X(*),Y(*)
  function gbmv!(trans::AbstractChar, m::Integer, kl::Integer, ku::Integer, alpha::($elty), A::AbstractMatrix{$elty}, x::AbstractVector{$elty}, beta::($elty), y::AbstractVector{$elty})
- @assert !has_offset_axes(A, x, y)
+ require_one_based_indexing(A, x, y)
  chkstride1(A)
  ccall((@blasfunc($fname), libblas), Cvoid,
  (Ref{UInt8}, Ref{BlasInt}, Ref{BlasInt}, Ref{BlasInt},
@@ -697,7 +697,7 @@ for (fname, elty, lib) in ((:dsymv_,:Float64,libblas),
  # .. Array Arguments ..
  # DOUBLE PRECISION A(LDA,*),X(*),Y(*)
  function symv!(uplo::AbstractChar, alpha::($elty), A::AbstractMatrix{$elty}, x::AbstractVector{$elty}, beta::($elty), y::AbstractVector{$elty})
- @assert !has_offset_axes(A, x, y)
+ require_one_based_indexing(A, x, y)
  m, n = size(A)
  if m != n
  throw(DimensionMismatch("matrix A is $m by $n but must be square"))
@@ -749,7 +749,7 @@ for (fname, elty) in ((:zhemv_,:ComplexF64),
  (:chemv_,:ComplexF32))
  @eval begin
  function hemv!(uplo::AbstractChar, α::$elty, A::AbstractMatrix{$elty}, x::AbstractVector{$elty}, β::$elty, y::AbstractVector{$elty})
- @assert !has_offset_axes(A, x, y)
+ require_one_based_indexing(A, x, y)
  m, n = size(A)
  if m != n
  throw(DimensionMismatch("matrix A is $m by $n but must be square"))
@@ -794,7 +794,7 @@ for (fname, elty) in ((:dsbmv_,:Float64),
  # * .. Array Arguments ..
  # DOUBLE PRECISION A(LDA,*),X(*),Y(*)
  function sbmv!(uplo::AbstractChar, k::Integer, alpha::($elty), A::AbstractMatrix{$elty}, x::AbstractVector{$elty}, beta::($elty), y::AbstractVector{$elty})
- @assert !has_offset_axes(A, x, y)
+ require_one_based_indexing(A, x, y)
  chkstride1(A)
  ccall((@blasfunc($fname), libblas), Cvoid,
  (Ref{UInt8}, Ref{BlasInt}, Ref{BlasInt}, Ref{$elty},
@@ -858,7 +858,7 @@ for (fname, elty) in ((:zhbmv_,:ComplexF64),
  # * .. Array Arguments ..
  # DOUBLE PRECISION A(LDA,*),X(*),Y(*)
  function hbmv!(uplo::AbstractChar, k::Integer, alpha::($elty), A::AbstractMatrix{$elty}, x::AbstractVector{$elty}, beta::($elty), y::AbstractVector{$elty})
- @assert !has_offset_axes(A, x, y)
+ require_one_based_indexing(A, x, y)
  chkstride1(A)
  ccall((@blasfunc($fname), libblas), Cvoid,
  (Ref{UInt8}, Ref{BlasInt}, Ref{BlasInt}, Ref{$elty},
@@ -914,7 +914,7 @@ for (fname, elty) in ((:dtrmv_,:Float64),
  # * .. Array Arguments ..
  # DOUBLE PRECISION A(LDA,*),X(*)
  function trmv!(uplo::AbstractChar, trans::AbstractChar, diag::AbstractChar, A::AbstractMatrix{$elty}, x::AbstractVector{$elty})
- @assert !has_offset_axes(A, x)
+ require_one_based_indexing(A, x)
  n = checksquare(A)
  if n != length(x)
  throw(DimensionMismatch("A has size ($n,$n), x has length $(length(x))"))
@@ -968,7 +968,7 @@ for (fname, elty) in ((:dtrsv_,:Float64),
  # .. Array Arguments ..
  # DOUBLE PRECISION A(LDA,*),X(*)
  function trsv!(uplo::AbstractChar, trans::AbstractChar, diag::AbstractChar, A::AbstractMatrix{$elty}, x::AbstractVector{$elty})
- @assert !has_offset_axes(A, x)
+ require_one_based_indexing(A, x)
  n = checksquare(A)
  if n != length(x)
  throw(DimensionMismatch("size of A is $n != length(x) = $(length(x))"))
@@ -1002,7 +1002,7 @@ for (fname, elty) in ((:dger_,:Float64),
  (:cgerc_,:ComplexF32))
  @eval begin
  function ger!(α::$elty, x::AbstractVector{$elty}, y::AbstractVector{$elty}, A::AbstractMatrix{$elty})
- @assert !has_offset_axes(A, x, y)
+ require_one_based_indexing(A, x, y)
  m, n = size(A)
  if m != length(x) || n != length(y)
  throw(DimensionMismatch("A has size ($m,$n), x has length $(length(x)), y has length $(length(y))"))
@@ -1035,7 +1035,7 @@ for (fname, elty, lib) in ((:dsyr_,:Float64,libblas),
  (:csyr_,:ComplexF32,liblapack))
  @eval begin
  function syr!(uplo::AbstractChar, α::$elty, x::AbstractVector{$elty}, A::AbstractMatrix{$elty})
- @assert !has_offset_axes(A, x)
+ require_one_based_indexing(A, x)
  n = checksquare(A)
  if length(x) != n
  throw(DimensionMismatch("A has size ($n,$n), x has length $(length(x))"))
@@ -1065,7 +1065,7 @@ for (fname, elty, relty) in ((:zher_,:ComplexF64, :Float64),
  (:cher_,:ComplexF32, :Float32))
  @eval begin
  function her!(uplo::AbstractChar, α::$relty, x::AbstractVector{$elty}, A::AbstractMatrix{$elty})
- @assert !has_offset_axes(A, x)
+ require_one_based_indexing(A, x)
  n = checksquare(A)
  if length(x) != n
  throw(DimensionMismatch("A has size ($n,$n), x has length $(length(x))"))
@@ -1108,7 +1108,7 @@ for (gemm, elty) in
 # if any([stride(A,1), stride(B,1), stride(C,1)] .!= 1)
 # error("gemm!: BLAS module requires contiguous matrix columns")
 # end # should this be checked on every call?
- @assert !has_offset_axes(A, B, C)
+ require_one_based_indexing(A, B, C)
  m = size(A, transA == 'N' ? 1 : 2)
  ka = size(A, transA == 'N' ? 2 : 1)
  kb = size(B, transB == 'N' ? 1 : 2)
@@ -1168,7 +1168,7 @@ for (mfname, elty) in ((:dsymm_,:Float64),
  # .. Array Arguments ..
  # DOUBLE PRECISION A(LDA,*),B(LDB,*),C(LDC,*)
  function symm!(side::AbstractChar, uplo::AbstractChar, alpha::($elty), A::AbstractMatrix{$elty}, B::AbstractMatrix{$elty}, beta::($elty), C::AbstractMatrix{$elty})
- @assert !has_offset_axes(A, B, C)
+ require_one_based_indexing(A, B, C)
  m, n = size(C)
  j = checksquare(A)
  if j != (side == 'L' ? m : n)
@@ -1237,7 +1237,7 @@ for (mfname, elty) in ((:zhemm_,:ComplexF64),
  # .. Array Arguments ..
  # DOUBLE PRECISION A(LDA,*),B(LDB,*),C(LDC,*)
  function hemm!(side::AbstractChar, uplo::AbstractChar, alpha::($elty), A::AbstractMatrix{$elty}, B::AbstractMatrix{$elty}, beta::($elty), C::AbstractMatrix{$elty})
- @assert !has_offset_axes(A, B, C)
+ require_one_based_indexing(A, B, C)
  m, n = size(C)
  j = checksquare(A)
  if j != (side == 'L' ? m : n)
@@ -1303,7 +1303,7 @@ for (fname, elty) in ((:dsyrk_,:Float64),
  function syrk!(uplo::AbstractChar, trans::AbstractChar,
  alpha::($elty), A::AbstractVecOrMat{$elty},
  beta::($elty), C::AbstractMatrix{$elty})
- @assert !has_offset_axes(A, C)
+ require_one_based_indexing(A, C)
  n = checksquare(C)
  nn = size(A, trans == 'N' ? 1 : 2)
  if nn != n throw(DimensionMismatch("C has size ($n,$n), corresponding dimension of A is $nn")) end
@@ -1360,7 +1360,7 @@ for (fname, elty, relty) in ((:zherk_, :ComplexF64, :Float64),
  # COMPLEX A(LDA,*),C(LDC,*)
  function herk!(uplo::AbstractChar, trans::AbstractChar, α::$relty, A::AbstractVecOrMat{$elty},
  β::$relty, C::AbstractMatrix{$elty})
- @assert !has_offset_axes(A, C)
+ require_one_based_indexing(A, C)
  n = checksquare(C)
  nn = size(A, trans == 'N' ? 1 : 2)
  if nn != n
@@ -1404,7 +1404,7 @@ for (fname, elty) in ((:dsyr2k_,:Float64),
  function syr2k!(uplo::AbstractChar, trans::AbstractChar,
  alpha::($elty), A::AbstractVecOrMat{$elty}, B::AbstractVecOrMat{$elty},
  beta::($elty), C::AbstractMatrix{$elty})
- @assert !has_offset_axes(A, B, C)
+ require_one_based_indexing(A, B, C)
  n = checksquare(C)
  nn = size(A, trans == 'N' ? 1 : 2)
  if nn != n throw(DimensionMismatch("C has size ($n,$n), corresponding dimension of A is $nn")) end
@@ -1445,7 +1445,7 @@ for (fname, elty1, elty2) in ((:zher2k_,:ComplexF64,:Float64), (:cher2k_,:Comple
  function her2k!(uplo::AbstractChar, trans::AbstractChar, alpha::($elty1),
  A::AbstractVecOrMat{$elty1}, B::AbstractVecOrMat{$elty1},
  beta::($elty2), C::AbstractMatrix{$elty1})
- @assert !has_offset_axes(A, B, C)
+ require_one_based_indexing(A, B, C)
  n = checksquare(C)
  nn = size(A, trans == 'N' ? 1 : 2)
  if nn != n throw(DimensionMismatch("C has size ($n,$n), corresponding dimension of A is $nn")) end
@@ -1533,7 +1533,7 @@ for (mmname, smname, elty) in
  # DOUBLE PRECISION A(LDA,*),B(LDB,*)
  function trmm!(side::AbstractChar, uplo::AbstractChar, transa::AbstractChar, diag::AbstractChar, alpha::Number,
  A::AbstractMatrix{$elty}, B::AbstractMatrix{$elty})
- @assert !has_offset_axes(A, B)
+ require_one_based_indexing(A, B)
  m, n = size(B)
  nA = checksquare(A)
  if nA != (side == 'L' ? m : n)
@@ -1561,7 +1561,7 @@ for (mmname, smname, elty) in
  # DOUBLE PRECISION A(LDA,*),B(LDB,*)
  function trsm!(side::AbstractChar, uplo::AbstractChar, transa::AbstractChar, diag::AbstractChar,
  alpha::$elty, A::AbstractMatrix{$elty}, B::AbstractMatrix{$elty})
- @assert !has_offset_axes(A, B)
+ require_one_based_indexing(A, B)
  m, n = size(B)
  k = checksquare(A)
  if k != (side == 'L' ? m : n)

stdlib/LinearAlgebra/src/bunchkaufman.jl

@@ -13,7 +13,7 @@ struct BunchKaufman{T,S<:AbstractMatrix} <: Factorization{T}
  info::BlasInt
 
  function BunchKaufman{T,S}(LD, ipiv, uplo, symmetric, rook, info) where {T,S<:AbstractMatrix}
- @assert !has_offset_axes(LD)
+ require_one_based_indexing(LD)
  new(LD, ipiv, uplo, symmetric, rook, info)
  end
 end
@@ -126,7 +126,7 @@ issymmetric(B::BunchKaufman) = B.symmetric
 ishermitian(B::BunchKaufman) = !B.symmetric
 
 function _ipiv2perm_bk(v::AbstractVector{T}, maxi::Integer, uplo::AbstractChar) where T
- @assert !has_offset_axes(v)
+ require_one_based_indexing(v)
  p = T[1:maxi;]
  uploL = uplo == 'L'
  i = uploL ? 1 : maxi

stdlib/LinearAlgebra/src/cholesky.jl

@@ -34,7 +34,7 @@ struct Cholesky{T,S<:AbstractMatrix} <: Factorization{T}
  info::BlasInt
 
  function Cholesky{T,S}(factors, uplo, info) where {T,S<:AbstractMatrix}
- @assert !has_offset_axes(factors)
+ require_one_based_indexing(factors)
  new(factors, uplo, info)
  end
 end
@@ -52,7 +52,7 @@ struct CholeskyPivoted{T,S<:AbstractMatrix} <: Factorization{T}
  info::BlasInt
 
  function CholeskyPivoted{T,S}(factors, uplo, piv, rank, tol, info) where {T,S<:AbstractMatrix}
- @assert !has_offset_axes(factors)
+ require_one_based_indexing(factors)
  new(factors, uplo, piv, rank, tol, info)
  end
 end
@@ -85,7 +85,7 @@ end
 
 ## Non BLAS/LAPACK element types (generic)
 function _chol!(A::AbstractMatrix, ::Type{UpperTriangular})
- @assert !has_offset_axes(A)
+ require_one_based_indexing(A)
  n = checksquare(A)
  @inbounds begin
  for k = 1:n
@@ -109,7 +109,7 @@ function _chol!(A::AbstractMatrix, ::Type{UpperTriangular})
  return UpperTriangular(A), convert(BlasInt, 0)
 end
 function _chol!(A::AbstractMatrix, ::Type{LowerTriangular})
- @assert !has_offset_axes(A)
+ require_one_based_indexing(A)
  n = checksquare(A)
  @inbounds begin
  for k = 1:n