Make RaggedMatrix immutable (#435)

* Avoid setfield for RaggedMatrix in resizedata

* Make RaggedMatrix immutable

* householder RaggedMatrix in dispatch in resizedata

Author: jishnub

Project.toml

@@ -1,6 +1,6 @@
 name = "ApproxFunBase"
 uuid = "fbd15aa5-315a-5a7d-a8a4-24992e37be05"
-version = "0.8.10"
+version = "0.8.11"
 
 [deps]
 AbstractFFTs = "621f4979-c628-5d54-868e-fcf4e3e8185c"

src/Caching/blockbanded.jl

@@ -201,7 +201,7 @@ QROperator(R::CachedOperator{T,BlockBandedMatrix{T}}) where {T} =
 resizedata!(QR::QROperator{<:CachedOperator{T,BlockBandedMatrix{T}}}, ::Colon, col::Int) where {T} =
     resizedata!(QR, :, block(domainspace(QR.R_cache),col))
 
-function resizedata!(QR::QROperator{<:CachedOperator{T,BlockBandedMatrix{T}}}, ::Colon, COL::Block) where {T<:BlasFloat}
+function resizedata!(QR::QROperator{<:CachedOperator{T,BlockBandedMatrix{T}}, <:RaggedMatrix}, ::Colon, COL::Block) where {T}
      MO = QR.R_cache
      W = QR.H
      R = MO.data
@@ -235,13 +235,16 @@ function resizedata!(QR::QROperator{<:CachedOperator{T,BlockBandedMatrix{T}}}, :
          m = size(W,2)
          resize!(W.cols, 2col+1)
 
+         Wm = W.m
          for j=m+1:2col
              cs = blockstop(rangespace(MO), blockcolstop(MO, block(domainspace(MO),j)))
              W.cols[j+1]=W.cols[j] + cs-j+1
-             W.m=max(W.m,cs-j+1)
+             Wm=max(Wm,cs-j+1)
          end
 
          resize!(W.data, W.cols[end]-1)
+         W = RaggedMatrix(W.data, W.cols, Wm)
+         QR.H = W
      end
 
      ri = firstindex(R.data)

src/Caching/ragged.jl

@@ -37,7 +37,7 @@ function resizedata!(B::CachedOperator{T,RaggedMatrix{T}},::Colon,n::Integer) wh
         end
 
         pad!(B.data.data,B.data.cols[n+1]-1)
-        B.data.m = K
+        B.data = RaggedMatrix(B.data.data, B.data.cols, K)
 
         jr=B.datasize[2]+1:n
         kr=1:K
@@ -52,8 +52,8 @@ end
 
 function resizedata!(B::CachedOperator{T,RaggedMatrix{T}},n::Integer,m::Integer) where T<:Number
     resizedata!(B,:,m)
-    B.data.m = max(B.data.m,n)   # make sure we have at least n rows
-
+    data = B.data
+    B.data = RaggedMatrix(data.data, data.cols, max(data.m,n))   # make sure we have at least n rows
     B
 end
 
@@ -63,7 +63,7 @@ end
 QROperator(R::CachedOperator{T,RaggedMatrix{T}}) where {T} =
     QROperator(R,RaggedMatrix{T}(undef,0,Int[]),0)
 
-function resizedata!(QR::QROperator{<:CachedOperator{T,RaggedMatrix{T}}}, ::Colon, col) where {T}
+function resizedata!(QR::QROperator{<:CachedOperator{T,RaggedMatrix{T}}, <:RaggedMatrix}, ::Colon, col) where {T}
     if col ≤ QR.ncols
         return QR
     end
@@ -79,7 +79,7 @@ function resizedata!(QR::QROperator{<:CachedOperator{T,RaggedMatrix{T}}}, ::Colo
         for J=1:QR.ncols
             wp=view(W,1:colstop(W,J),J)
             for j = m+1:MO.datasize[2]
-                kr = J:J+length(wp)-1
+                kr = range(J, length=length(wp))
                 v = view(MO.data,kr,j)
                 dt = dot(wp,v)
                 axpy!(-2dt, wp, v)
@@ -92,19 +92,24 @@ function resizedata!(QR::QROperator{<:CachedOperator{T,RaggedMatrix{T}}}, ::Colo
         m = size(W,2)
         resize!(W.cols,col+101)
 
+        Wm = W.m
         for j=m+1:col+100
             cs = colstop(MO.data,j)
             W.cols[j+1] = W.cols[j] + cs-j+1
-            W.m = max(W.m,cs-j+1)
+            Wm = max(Wm,cs-j+1)
         end
 
         resize!(W.data,W.cols[end]-1)
+        W = RaggedMatrix(W.data, W.cols, Wm)
+        QR.H = W
     end
 
     for k=QR.ncols+1:col
         cs = colstop(MO.data,k)
-        W[1:cs-k+1,k] = view(MO.data,k:cs,k) # diagonal and below
-        wp = view(W,1:cs-k+1,k)
+        indsk = k:cs
+        indskax = eachindex(indsk)
+        W[indskax,k] = view(MO.data,indsk,k) # diagonal and below
+        wp = view(W,indskax,k)
         W[1,k] += flipsign(norm(wp),W[1,k])
         normalize!(wp)
 

src/LinearAlgebra/RaggedMatrix.jl

@@ -6,7 +6,7 @@ getindex(A::AbstractMatrix,k::Integer,::Type{FiniteRange}) = A[k,1:rowstop(A,k)]
 
 const ⤓ = FiniteRange
 
-mutable struct RaggedMatrix{T} <: AbstractMatrix{T}
+struct RaggedMatrix{T} <: AbstractMatrix{T}
     data::Vector{T} # a Vector of non-zero entries
     cols::Vector{Int} # a Vector specifying the first index of each column
     m::Int #Number of rows