JuliaLinearAlgebra · dlfivefifty · Feb 16, 2021 · Feb 15, 2021 · Feb 15, 2021 · Feb 16, 2021
diff --git a/Project.toml b/Project.toml
@@ -1,6 +1,6 @@
 name = "InfiniteLinearAlgebra"
 uuid = "cde9dba0-b1de-11e9-2c62-0bab9446c55c"
-version = "0.4.8"
+version = "0.5.0"
 
 [deps]
 ArrayLayouts = "4c555306-a7a7-4459-81d9-ec55ddd5c99a"
@@ -9,19 +9,20 @@ BlockArrays = "8e7c35d0-a365-5155-bbbb-fb81a777f24e"
 BlockBandedMatrices = "ffab5731-97b5-5995-9138-79e8c1846df0"
 FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b"
 InfiniteArrays = "4858937d-0d70-526a-a4dd-2d5cb5dd786c"
+Infinities = "e1ba4f0e-776d-440f-acd9-e1d2e9742647"
 LazyArrays = "5078a376-72f3-5289-bfd5-ec5146d43c02"
 LazyBandedMatrices = "d7e5e226-e90b-4449-9968-0f923699bf6f"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 MatrixFactorizations = "a3b82374-2e81-5b9e-98ce-41277c0e4c87"
 SemiseparableMatrices = "f8ebbe35-cbfb-4060-bf7f-b10e4670cf57"
 
 [compat]
-ArrayLayouts = "0.5.1"
+ArrayLayouts = "0.5.1, 0.6"
 BandedMatrices = "0.16"
-BlockArrays = "0.14.3"
+BlockArrays = "0.14.5"
 BlockBandedMatrices = "0.10"
 FillArrays = "0.11"
-InfiniteArrays = "0.9.3"
+InfiniteArrays = "0.10"
 LazyArrays = "0.20.2"
 LazyBandedMatrices = "0.4.5"
 MatrixFactorizations = "0.7.1, 0.8"

diff --git a/src/InfiniteLinearAlgebra.jl b/src/InfiniteLinearAlgebra.jl
@@ -13,7 +13,7 @@ import ArrayLayouts: colsupport, rowsupport, triangularlayout, MatLdivVec, trian
 import BandedMatrices: BandedMatrix, _BandedMatrix, AbstractBandedMatrix, bandeddata, bandwidths, BandedColumns, bandedcolumns,
                         _default_banded_broadcast, banded_similar
 import FillArrays: AbstractFill, getindex_value, axes_print_matrix_row
-import InfiniteArrays: OneToInf, InfUnitRange, Infinity, InfStepRange, AbstractInfUnitRange, InfAxes, InfRanges
+import InfiniteArrays: OneToInf, InfUnitRange, Infinity, PosInfinity, InfiniteCardinal, InfStepRange, AbstractInfUnitRange, InfAxes, InfRanges
 import LinearAlgebra: lmul!,  ldiv!, matprod, qr, AbstractTriangular, AbstractQ, adjoint, transpose
 import LazyArrays: applybroadcaststyle, CachedArray, CachedMatrix, CachedVector, DenseColumnMajor, FillLayout, ApplyMatrix, check_mul_axes, ApplyStyle, LazyArrayApplyStyle, LazyArrayStyle,
                     resizedata!, MemoryLayout,
@@ -44,7 +44,7 @@ end
 
 # BroadcastStyle(::Type{<:BandedMatrix{<:Any,<:Any,<:OneToInf}}) = LazyArrayStyle{2}()
 
-function ArrayLayouts._power_by_squaring(_, ::NTuple{2,Infinity}, A::AbstractMatrix{T}, p::Integer) where T
+function ArrayLayouts._power_by_squaring(_, ::NTuple{2,InfiniteCardinal{0}}, A::AbstractMatrix{T}, p::Integer) where T
     if p < 0
         inv(A)^(-p)
     elseif p == 0

diff --git a/src/banded/infbanded.jl b/src/banded/infbanded.jl
@@ -1,3 +1,5 @@
+_BandedMatrix(data::AbstractMatrix{T}, ::Infinity, l, u) where T = _BandedMatrix(data, ℵ₀, l, u)
+
 ###
 # BandIndexing
 ###
@@ -52,10 +54,10 @@ _prepad(p, a::Zeros{T,1}) where T = Zeros{T}(length(a)+p)
 _prepad(p, a::Ones{T,1}) where T = Ones{T}(length(a)+p)
 _prepad(p, a::AbstractFill{T,1}) where T = Fill{T}(getindex_value(a), length(a)+p)
 
-banded_similar(T, (m,n)::Tuple{Int,Infinity}, (l,u)::Tuple{Int,Int}) = BandedMatrix{T}(undef, (n,m), (u,l))'
+banded_similar(T, (m,n)::Tuple{Int,PosInfinity}, (l,u)::Tuple{Int,Int}) = BandedMatrix{T}(undef, (n,m), (u,l))'
 
 function BandedMatrix{T}(kv::Tuple{Vararg{Pair{<:Integer,<:AbstractVector}}},
-                         ::NTuple{2,Infinity},
+                         ::NTuple{2,PosInfinity},
                          (l,u)::NTuple{2,Integer}) where T
     ks = getproperty.(kv, :first)
     l,u = -minimum(ks),maximum(ks)
@@ -64,12 +66,12 @@ function BandedMatrix{T}(kv::Tuple{Vararg{Pair{<:Integer,<:AbstractVector}}},
     for (k,j) in zip(u .- ks .+ 1,1:length(ks))
         c[k,j] = one(T)
     end
-    _BandedMatrix(ApplyArray(*,c,rws), ∞, l, u)
+    _BandedMatrix(ApplyArray(*,c,rws), ℵ₀, l, u)
 end
 
 # Construct InfToeplitz
 function BandedMatrix{T}(kv::Tuple{Vararg{Pair{<:Integer,<:Fill{<:Any,1,Tuple{OneToInf{Int}}}}}},
-                         mn::NTuple{2,Infinity},
+                         mn::NTuple{2,PosInfinity},
                          lu::NTuple{2,Integer}) where T
     m,n = mn
     @assert isinf(n)
@@ -80,11 +82,11 @@ function BandedMatrix{T}(kv::Tuple{Vararg{Pair{<:Integer,<:Fill{<:Any,1,Tuple{On
         t[u-k+1] = v.value
     end
 
-    return _BandedMatrix(t * Ones{T}(1,∞), m, l, u)
+    return _BandedMatrix(t * Ones{T}(1,∞), Integer(m), l, u)
 end
 
 function BandedMatrix{T}(kv::Tuple{Vararg{Pair{<:Integer,<:Vcat{<:Any,1,<:Tuple{<:AbstractVector,Fill{<:Any,1,Tuple{OneToInf{Int}}}}}}}},
-                         mn::NTuple{2,Infinity},
+                         mn::NTuple{2,PosInfinity},
                          lu::NTuple{2,Integer}) where T
     m,n = mn
     @assert isinf(n)
@@ -105,38 +107,38 @@ function BandedMatrix{T}(kv::Tuple{Vararg{Pair{<:Integer,<:Vcat{<:Any,1,<:Tuple{
         end
     end
 
-    return _BandedMatrix(Hcat(data, t * Ones{T}(1,∞)), m, l, u)
+    return _BandedMatrix(Hcat(data, t * Ones{T}(1,∞)), Integer(m), l, u)
 end
 
 
 function BandedMatrix(Ac::Adjoint{T,<:InfToeplitz}) where T
     A = parent(Ac)
     l,u = bandwidths(A)
     a = A.data.args[1]
-    _BandedMatrix(reverse(conj(a)) * Ones{T}(1,∞), ∞, u, l)
+    _BandedMatrix(reverse(conj(a)) * Ones{T}(1,∞), ℵ₀, u, l)
 end
 
 function BandedMatrix(Ac::Transpose{T,<:InfToeplitz}) where T
     A = parent(Ac)
     l,u = bandwidths(A)
     a = A.data.args[1]
-    _BandedMatrix(reverse(a) * Ones{T}(1,∞), ∞, u, l)
+    _BandedMatrix(reverse(a) * Ones{T}(1,∞), ℵ₀, u, l)
 end
 
 function BandedMatrix(Ac::Adjoint{T,<:PertToeplitz}) where T
     A = parent(Ac)
     l,u = bandwidths(A)
     a,b = A.data.args
     Ac_fd = BandedMatrix(_BandedMatrix(Hcat(a, b[:,1:l+1]), size(a,2)+l, l, u)')
-    _BandedMatrix(Hcat(Ac_fd.data, reverse(conj(b.args[1])) * Ones{T}(1,∞)), ∞, u, l)
+    _BandedMatrix(Hcat(Ac_fd.data, reverse(conj(b.args[1])) * Ones{T}(1,∞)), ℵ₀, u, l)
 end
 
 function BandedMatrix(Ac::Transpose{T,<:PertToeplitz}) where T
     A = parent(Ac)
     l,u = bandwidths(A)
     a,b = A.data.args
     Ac_fd = BandedMatrix(transpose(_BandedMatrix(Hcat(a, b[:,1:l+1]), size(a,2)+l, l, u)))
-    _BandedMatrix(Hcat(Ac_fd.data, reverse(b.args[1]) * Ones{T}(1,∞)), ∞, u, l)
+    _BandedMatrix(Hcat(Ac_fd.data, reverse(b.args[1]) * Ones{T}(1,∞)), ℵ₀, u, l)
 end
 
 
@@ -191,25 +193,25 @@ for op in (:-, :+)
             TV = promote_type(eltype(λ),V)
             a = convert(AbstractVector{TV}, $op.(A.data.args[1]))
             a[u+1] += λ.λ
-            _BandedMatrix(a*Ones{TV}(1,∞), ∞, l, u)
+            _BandedMatrix(a*Ones{TV}(1,∞), ℵ₀, l, u)
         end
 
         function $op(A::InfToeplitz{T}, λ::UniformScaling) where T
             l,u = bandwidths(A)
             TV = promote_type(T,eltype(λ))
             a = TV[Zeros{TV}(max(-u,0)); A.data.args[1]; Zeros{TV}(max(-l,0))]
             a[max(0,u)+1] = $op(a[max(u,0)+1], λ.λ)
-            _BandedMatrix(a*Ones{TV}(1,∞), ∞, max(l,0), max(u,0))
+            _BandedMatrix(a*Ones{TV}(1,∞), ℵ₀, max(l,0), max(u,0))
         end
 
         function $op(λ::UniformScaling, A::PertToeplitz{V}) where V
             l,u = bandwidths(A)
             TV = promote_type(eltype(λ),V)
-            a, t = convert.(AbstractVector{TV}, A.data.args)
+            a, t = map(AbstractArray{TV}, A.data.args)
             b = $op.(t.args[1])
-            a[u+1,:] += λ.λ
+            a[u+1,:] .+= λ.λ
             b[u+1] += λ.λ
-            _BandedMatrix(Hcat(a, b*Ones{TV}(1,∞)), ∞, l, u)
+            _BandedMatrix(Hcat(a, b*Ones{TV}(1,∞)), ℵ₀, l, u)
         end
 
         function $op(A::PertToeplitz{T}, λ::UniformScaling) where T
@@ -220,7 +222,7 @@ for op in (:-, :+)
             b = AbstractVector{TV}(t.args[1])
             a[u+1,:] .= $op.(a[u+1,:],λ.λ)
             b[u+1] = $op(b[u+1], λ.λ)
-            _BandedMatrix(Hcat(a, b*Ones{TV}(1,∞)), ∞, l, u)
+            _BandedMatrix(Hcat(a, b*Ones{TV}(1,∞)), ℵ₀, l, u)
         end
     end
 end
@@ -237,7 +239,7 @@ function BandedMatrix(A::PertToeplitz{T}, (l,u)::Tuple{Int,Int}) where T
     t = b.args[1] # topelitz part
     t_pad = vcat(t,Zeros(l-A.l))
     data = Hcat([vcat(a,Zeros{T}(l-A.l,size(a,2))) repeat(t_pad,1,l)], t_pad * Ones{T}(1,∞))
-    _BandedMatrix(data, ∞, l, u)
+    _BandedMatrix(data, ℵ₀, l, u)
 end
 
 function BandedMatrix(A::SymTriPertToeplitz{T}, (l,u)::Tuple{Int,Int}) where T
@@ -251,7 +253,7 @@ function BandedMatrix(A::SymTriPertToeplitz{T}, (l,u)::Tuple{Int,Int}) where T
     data[u+1,length(a)+1:end] .= a∞.value
     data[u+2,1:length(b)] .= b
     data[u+2,length(b)+1:end] .= b∞.value
-    _BandedMatrix(Hcat(data, [Zeros{T}(u-1); b∞.value; a∞.value; b∞.value; Zeros{T}(l-1)] * Ones{T}(1,∞)), ∞, l, u)
+    _BandedMatrix(Hcat(data, [Zeros{T}(u-1); b∞.value; a∞.value; b∞.value; Zeros{T}(l-1)] * Ones{T}(1,∞)), ℵ₀, l, u)
 end
 
 function BandedMatrix(A::SymTridiagonal{T,Fill{T,1,Tuple{OneToInf{Int}}}}, (l,u)::Tuple{Int,Int}) where T
@@ -262,7 +264,7 @@ function BandedMatrix(A::SymTridiagonal{T,Fill{T,1,Tuple{OneToInf{Int}}}}, (l,u)
     data[u,2:end] .= b∞.value
     data[u+1,1:end] .= a∞.value
     data[u+2,1:end] .= b∞.value
-    _BandedMatrix(Hcat(data, [Zeros{T}(u-1); b∞.value; a∞.value; b∞.value; Zeros{T}(l-1)] * Ones{T}(1,∞)), ∞, l, u)
+    _BandedMatrix(Hcat(data, [Zeros{T}(u-1); b∞.value; a∞.value; b∞.value; Zeros{T}(l-1)] * Ones{T}(1,∞)), ℵ₀, l, u)
 end
 
 function BandedMatrix(A::TriPertToeplitz{T}, (l,u)::Tuple{Int,Int}) where T
@@ -277,7 +279,7 @@ function BandedMatrix(A::TriPertToeplitz{T}, (l,u)::Tuple{Int,Int}) where T
     data[u+1,length(a)+1:end] .= a∞.value
     data[u+2,1:length(c)] .= c
     data[u+2,length(c)+1:end] .= c∞.value
-    _BandedMatrix(Hcat(data, [Zeros{T}(u-1); b∞.value; a∞.value; c∞.value; Zeros{T}(l-1)] * Ones{T}(1,∞)), ∞, l, u)
+    _BandedMatrix(Hcat(data, [Zeros{T}(u-1); b∞.value; a∞.value; c∞.value; Zeros{T}(l-1)] * Ones{T}(1,∞)), ℵ₀, l, u)
 end
 
 function BandedMatrix(A::Tridiagonal{T,Fill{T,1,Tuple{OneToInf{Int}}}}, (l,u)::Tuple{Int,Int}) where T
@@ -289,14 +291,14 @@ function BandedMatrix(A::Tridiagonal{T,Fill{T,1,Tuple{OneToInf{Int}}}}, (l,u)::T
     data[u,2:end] .= b∞.value
     data[u+1,1:end] .= a∞.value
     data[u+2,1:end] .= c∞.value
-    _BandedMatrix(Hcat(data, [Zeros{T}(u-1); b∞.value; a∞.value; c∞.value; Zeros{T}(l-1)] * Ones{T}(1,∞)), ∞, l, u)
+    _BandedMatrix(Hcat(data, [Zeros{T}(u-1); b∞.value; a∞.value; c∞.value; Zeros{T}(l-1)] * Ones{T}(1,∞)), ℵ₀, l, u)
 end
 
 function InfToeplitz(A::Tridiagonal{T,Fill{T,1,Tuple{OneToInf{Int}}}}, (l,u)::Tuple{Int,Int}) where T
     a∞ = A.d
     b∞ = A.du
     c∞ = A.dl
-    _BandedMatrix([Zeros{T}(u-1); b∞.value; a∞.value; c∞.value; Zeros{T}(l-1)] * Ones{T}(1,∞), ∞, l, u)
+    _BandedMatrix([Zeros{T}(u-1); b∞.value; a∞.value; c∞.value; Zeros{T}(l-1)] * Ones{T}(1,∞), ℵ₀, l, u)
 end
 
 InfToeplitz(A::Tridiagonal{T,Fill{T,1,Tuple{OneToInf{Int}}}}) where T = InfToeplitz(A, bandwidths(A))
@@ -384,8 +386,8 @@ _BandedMatrix(::PertToeplitzLayout, A::AbstractMatrix) =
 
 
 
-ArrayLayouts._apply(_, ::NTuple{2,Infinity}, op, Λ::UniformScaling, A::AbstractMatrix) = op(Diagonal(Fill(Λ.λ,∞)), A)
-ArrayLayouts._apply(_, ::NTuple{2,Infinity}, op, A::AbstractMatrix, Λ::UniformScaling) = op(A, Diagonal(Fill(Λ.λ,∞)))
+ArrayLayouts._apply(_, ::NTuple{2,InfiniteCardinal{0}}, op, Λ::UniformScaling, A::AbstractMatrix) = op(Diagonal(Fill(Λ.λ,∞)), A)
+ArrayLayouts._apply(_, ::NTuple{2,InfiniteCardinal{0}}, op, A::AbstractMatrix, Λ::UniformScaling) = op(A, Diagonal(Fill(Λ.λ,∞)))
 
 _default_banded_broadcast(bc::Broadcasted, ::Tuple{<:OneToInf,<:Any}) = copy(Broadcasted{LazyArrayStyle{2}}(bc.f, bc.args))
 
@@ -417,7 +419,7 @@ function _bandedfill_mul(M::MulAdd, ::Tuple{InfAxes,InfAxes}, ::Tuple{InfAxes,In
     l,u = Al+Bl,Au+Bu
     m = min(Au+Al,Bl+Bu)+1
     λ = getindex_value(bandeddata(A))*getindex_value(bandeddata(B))
-    ret = _BandedMatrix(Hcat(Array{typeof(λ)}(undef, l+u+1,u), [1:m-1; Fill(m,l+u-2m+3); m-1:-1:1]*Fill(λ,1,∞)), ∞, l, u)
+    ret = _BandedMatrix(Hcat(Array{typeof(λ)}(undef, l+u+1,u), [1:m-1; Fill(m,l+u-2m+3); m-1:-1:1]*Fill(λ,1,∞)), ℵ₀, l, u)
     mul!(view(ret, 1:l+u,1:u), view(A,1:l+u,1:u+Bl), view(B,1:u+Bl,1:u))
     ret
 end

diff --git a/src/banded/infqltoeplitz.jl b/src/banded/infqltoeplitz.jl
@@ -47,7 +47,7 @@ function ql(Op::TriToeplitz{T}; kwds...) where T<:Real
     X = [Z A B; zero(T) d e]
     F = ql_X!(X)
     t,ω = F.τ[2],X[1,end]
-    QL(_BandedMatrix(Hcat([zero(T), e, X[2,2], X[2,1]], [ω, X[2,3], X[2,2], X[2,1]] * Ones{T}(1,∞)), ∞, 2, 1), Vcat(F.τ[1],Fill(t,∞)))
+    QL(_BandedMatrix(Hcat([zero(T), e, X[2,2], X[2,1]], [ω, X[2,3], X[2,2], X[2,1]] * Ones{T}(1,∞)), ℵ₀, 2, 1), Vcat(F.τ[1],Fill(t,∞)))
 end
 
 ql(Op::TriToeplitz{T}) where T = ql(InfToeplitz(Op))
@@ -60,7 +60,7 @@ function ql_hessenberg(A::InfToeplitz{T}; kwds...) where T
     de = tail_de(a; kwds...)
     X = [transpose(a); zero(T) transpose(de)]::Matrix{float(T)}
     F = ql_X!(X) # calculate data for fixed point
-    factors = _BandedMatrix(Hcat([zero(T); X[1,end-1]; X[2,end-1:-1:1]], [0; X[2,end:-1:1]] * Ones{float(T)}(1,∞)), ∞, l+u, 1)
+    factors = _BandedMatrix(Hcat([zero(T); X[1,end-1]; X[2,end-1:-1:1]], [0; X[2,end:-1:1]] * Ones{float(T)}(1,∞)), ℵ₀, l+u, 1)
     QLHessenberg(factors, Fill(F.Q,∞))
 end
 
@@ -79,7 +79,7 @@ function ql_pruneband(A; kwds...)
     for j = u+1:size(pert,2)
         pert[:,j] .= view(dat,j-u+1:j+l+1,j)
     end
-    H = _BandedMatrix(Hcat(pert, dat[end-l-u:end,end]*Ones{eltype(dat)}(1,∞)), ∞, l+1,u-1)
+    H = _BandedMatrix(Hcat(pert, dat[end-l-u:end,end]*Ones{eltype(dat)}(1,∞)), ℵ₀, l+1,u-1)
     Q,H
 end
 

diff --git a/src/blockbanded/blockbanded.jl b/src/blockbanded/blockbanded.jl
@@ -1,13 +1,13 @@
 const OneToInfCumsum = InfiniteArrays.RangeCumsum{Int,OneToInf{Int}}
 const OneToCumsum = InfiniteArrays.RangeCumsum{Int,OneTo{Int}}
 
-BlockArrays.sortedunion(::AbstractVector{Infinity}, ::AbstractVector{Infinity}) = [∞]
-function BlockArrays.sortedunion(::AbstractVector{Infinity}, b)
+BlockArrays.sortedunion(::AbstractVector{<:PosInfinity}, ::AbstractVector{<:PosInfinity}) = [∞]
+function BlockArrays.sortedunion(::AbstractVector{<:PosInfinity}, b)
     @assert isinf(length(b))
     b
 end
 
-function BlockArrays.sortedunion(b, ::AbstractVector{Infinity})
+function BlockArrays.sortedunion(b, ::AbstractVector{<:PosInfinity})
     @assert isinf(length(b))
     b
 end
@@ -33,8 +33,7 @@ const OneToBlocks = BlockedUnitRange{OneToCumsum}
 axes(a::OneToInfBlocks) = (a,)
 axes(a::OneToBlocks) = (a,)
 
-unitrange(b::OneToInfBlocks) = first(b):∞
-
+BlockArrays.dimlength(start, ::Infinity) = ℵ₀
 
 function copy(bc::Broadcasted{<:BroadcastStyle,<:Any,typeof(*),<:Tuple{Ones{T,1,Tuple{OneToInfBlocks}},AbstractArray{V,N}}}) where {N,T,V}
     a,b = bc.args
@@ -72,7 +71,7 @@ BroadcastStyle(::Type{<:BlockArray{T,N,<:AbstractArray{<:AbstractArray{T,N},N},<
 BroadcastStyle(::Type{<:PseudoBlockArray{T,N,<:AbstractArray{T,N},<:NTuple{N,BlockedUnitRange{<:RangeCumsum{Int,<:InfRanges}}}}}) where {T,N} = LazyArrayStyle{N}()
 
 
-BlockArrays._length(::BlockedUnitRange, ::OneToInf) = ∞
+BlockArrays._length(::BlockedUnitRange, ::OneToInf) = ℵ₀
 BlockArrays._last(::BlockedUnitRange, ::OneToInf) = ∞
 
 ###

diff --git a/src/blockbanded/infblocktridiagonal.jl b/src/blockbanded/infblocktridiagonal.jl
@@ -35,8 +35,8 @@ sizes_from_blocks(A::Diagonal, ::NTuple{2,OneToInf{Int}}) = size.(A.diag, 1), si
 sizes_from_blocks(A::Tridiagonal, ::NTuple{2,OneToInf{Int}}) = size.(A.d, 1), size.(A.d,2)
 sizes_from_blocks(A::Bidiagonal, ::NTuple{2,OneToInf{Int}}) = size.(A.dv, 1), size.(A.dv,2)
 
-axes_print_matrix_row(_, io, X, A, i, ::AbstractVector{<:Infinity}, sep) = nothing
-axes_print_matrix_row(::NTuple{2,BlockedUnitRange}, io, X, A, i, ::AbstractVector{<:Infinity}, sep) = nothing
+axes_print_matrix_row(_, io, X, A, i, ::AbstractVector{<:PosInfinity}, sep) = nothing
+axes_print_matrix_row(::NTuple{2,BlockedUnitRange}, io, X, A, i, ::AbstractVector{<:PosInfinity}, sep) = nothing
 
 
 function BlockSkylineSizes(A::BlockTriPertToeplitz, (l,u)::NTuple{2,Int})
@@ -67,7 +67,7 @@ function BlockSkylineSizes(A::BlockTriPertToeplitz, (l,u)::NTuple{2,Int})
     end
 
     BlockSkylineSizes(axes(A),
-                        _BandedMatrix(Hcat(block_starts.data, Vcat(adjoint.(bs∞)...)), ∞, l, u),
+                        _BandedMatrix(Hcat(block_starts.data, Vcat(adjoint.(bs∞)...)), ℵ₀, l, u),
                         Vcat(block_strides, Fill(block_stride∞,∞)),
                         Fill(l,∞),Fill(u,∞))
 end

diff --git a/src/infql.jl b/src/infql.jl
@@ -93,14 +93,14 @@ function ql_hessenberg!(B::InfBandedMatrix{TT}; kwds...) where TT
 
     # combine finite and infinite data
     H = Hcat(B̃.data, rightasymptotics(F∞.factors.data))
-    QLHessenberg(_BandedMatrix(H, ∞, l, 1), Vcat( LowerHessenbergQ(F.Q).q, F∞.q))
+    QLHessenberg(_BandedMatrix(H, ℵ₀, l, 1), Vcat( LowerHessenbergQ(F.Q).q, F∞.q))
 end
 
 getindex(Q::QLPackedQ{T,<:InfBandedMatrix{T}}, i::Integer, j::Integer) where T =
     (Q'*[Zeros{T}(i-1); one(T); Zeros{T}(∞)])[j]'
 
-getL(Q::QL, ::NTuple{2,Infinity}) where T = LowerTriangular(Q.factors)
-getL(Q::QLHessenberg, ::NTuple{2,Infinity}) where T = LowerTriangular(Q.factors)
+getL(Q::QL, ::NTuple{2,InfiniteCardinal{0}}) where T = LowerTriangular(Q.factors)
+getL(Q::QLHessenberg, ::NTuple{2,InfiniteCardinal{0}}) where T = LowerTriangular(Q.factors)
 
 # number of structural non-zeros in axis k
 nzzeros(A::AbstractArray, k) = size(A,k)

diff --git a/src/infqr.jl b/src/infqr.jl
@@ -139,7 +139,7 @@ function getindex(F::AdaptiveQRTau, j::Int)
     F.data.τ[j]
 end
 
-getR(Q::QR, ::NTuple{2,Infinity}) = UpperTriangular(Q.factors)
+getR(Q::QR, ::NTuple{2,InfiniteCardinal{0}}) = UpperTriangular(Q.factors)
 
 
 function adaptiveqr(A)
@@ -149,8 +149,8 @@ end
 
 _qr(::AbstractBandedLayout, ::NTuple{2,OneToInf{Int}}, A) = adaptiveqr(A)
 _qr(::AbstractAlmostBandedLayout, ::NTuple{2,OneToInf{Int}}, A) = adaptiveqr(A)
-__qr(_, ::NTuple{2,Infinity}, A) = adaptiveqr(A)
-_qr(::AbstractBlockBandedLayout, ::NTuple{2,Infinity}, A) = adaptiveqr(A)
+__qr(_, ::NTuple{2,InfiniteCardinal{0}}, A) = adaptiveqr(A)
+_qr(::AbstractBlockBandedLayout, ::NTuple{2,InfiniteCardinal{0}}, A) = adaptiveqr(A)
 
 partialqr!(F::QR, n) = partialqr!(F.factors, n)
 partialqr!(F::AdaptiveQRFactors, n) = partialqr!(F.data, n)

diff --git a/src/inful.jl b/src/inful.jl
@@ -74,8 +74,8 @@ end
 _inf_getL(::BlockTridiagonalToeplitzLayout, F::UL) = mortar(Bidiagonal(F.factors.blocks.d,F.factors.blocks.dl, :L))
 
 
-getU(F::UL, ::NTuple{2,Infinity}) = _inf_getU(MemoryLayout(F.factors), F)
-getL(F::UL, ::NTuple{2,Infinity}) = _inf_getL(MemoryLayout(F.factors), F)
+getU(F::UL, ::NTuple{2,InfiniteCardinal{0}}) = _inf_getU(MemoryLayout(F.factors), F)
+getL(F::UL, ::NTuple{2,InfiniteCardinal{0}}) = _inf_getL(MemoryLayout(F.factors), F)
 
-getU(F::UL{T,<:Tridiagonal}, ::NTuple{2,Infinity}) where T = _inf_getU(MemoryLayout(F.factors), F)
-getL(F::UL{T,<:Tridiagonal}, ::NTuple{2,Infinity}) where T = _inf_getL(MemoryLayout(F.factors), F)
+getU(F::UL{T,<:Tridiagonal}, ::NTuple{2,InfiniteCardinal{0}}) where T = _inf_getU(MemoryLayout(F.factors), F)
+getL(F::UL{T,<:Tridiagonal}, ::NTuple{2,InfiniteCardinal{0}}) where T = _inf_getL(MemoryLayout(F.factors), F)