replace non-breaking spaces with regular ones (#107)

Author: jishnub

src/Caching/almostbanded.jl

@@ -19,7 +19,7 @@ function CachedOperator(io::InterlaceOperator{T,1};padding::Bool=false) where T
     nds=0
     md=0
     for k=1:length(io.ops)
-        if k ≠ i
+        if k ≠ i
             d=dimension(rs[k])
             nds+=d
             md=max(md,d)
@@ -57,7 +57,7 @@ function CachedOperator(io::InterlaceOperator{T,1};padding::Bool=false) where T
     for k=1:n
         K,J=io.rangeinterlacer[k]
 
-        if K ≠ i
+        if K ≠ i
             # fill the fill matrix
             ret.fill.V[:,bcrow] = Matrix(view(io.ops[K],J:J,jr))
             ret.fill.U[k,bcrow] = 1
@@ -104,13 +104,13 @@ function CachedOperator(io::InterlaceOperator{T,2};padding::Bool=false) where T
     # we only support block size 1 for now
     for k in d∞
         bl = blocklengths(ds[k])
-        if !(bl isa AbstractFill) || getindex_value(bl) ≠ 1
+        if !(bl isa AbstractFill) || getindex_value(bl) ≠ 1
             return default_CachedOperator(io;padding=padding)
         end
     end
     for k in r∞
         bl = blocklengths(rs[k])
-        if !(bl isa AbstractFill) || getindex_value(bl) ≠ 1
+        if !(bl isa AbstractFill) || getindex_value(bl) ≠ 1
             return default_CachedOperator(io;padding=padding)
         end
     end
@@ -191,7 +191,7 @@ function resizedata!(co::CachedOperator{T,AlmostBandedMatrix{T},
 
     k=1
     for (K,J) in co.op.rangeinterlacer
-        if K ≠ ind
+        if K ≠ ind
             co.data.fill.V[co.datasize[2]:end,k] = co.op.ops[K][J,co.datasize[2]:n+u]
             k += 1
             if k > r
@@ -240,7 +240,7 @@ function resizedata!(co::CachedOperator{T,AlmostBandedMatrix{T},
 
     # fill rows
     K=k=1
-    while k ≤ r
+    while k ≤ r
         if isfinite(dimension(rs[ri[K][1]]))
             co.data.fill.V[co.datasize[2]:end,k] = co.op[K,co.datasize[2]:n+u]
             k += 1
@@ -287,7 +287,7 @@ end
 function resizedata!(QR::QROperator{CachedOperator{T,AlmostBandedMatrix{T},
                                                   MM,DS,RS,BI}},
          ::Colon,col) where {T,MM,DS,RS,BI}
-    if col ≤ QR.ncols
+    if col ≤ QR.ncols
         return QR
     end
 
@@ -353,7 +353,7 @@ end
 function resizedata!(QR::QROperator{CachedOperator{T,AlmostBandedMatrix{T},
                                        MM,DS,RS,BI}},
 ::Colon,col) where {T<:BlasFloat,MM,DS,RS,BI}
-    if col ≤ QR.ncols
+    if col ≤ QR.ncols
         return QR
     end
 

src/Caching/banded.jl

@@ -43,7 +43,7 @@ end
 function resizedata!(QR::QROperator{<:CachedOperator{T,<:BandedMatrix{T},
                                                   MM,DS,RS,BI}},
          ::Colon,col) where {T,MM,DS,RS,BI}
-    if col ≤ QR.ncols
+    if col ≤ QR.ncols
         return QR
     end
 
@@ -96,7 +96,7 @@ end
 function resizedata!(QR::QROperator{<:CachedOperator{T,<:BandedMatrix{T},
                                        MM,DS,RS,BI}},
                      ::Colon,col) where {T<:BlasFloat,MM,DS,RS,BI}
-    if col ≤ QR.ncols
+    if col ≤ QR.ncols
         return QR
     end
 

src/Caching/blockbanded.jl

@@ -141,7 +141,7 @@ QROperator(R::CachedOperator{T,BlockBandedMatrix{T}}) where {T} =
 # function resizedata!(QR::QROperator{CachedOperator{T,BlockBandedMatrix{T},
 #                                           MM,DS,RS,BI}},
 #                      ::Colon, col) where {T,MM,DS,RS,BI}
-#     if col ≤ QR.ncols
+#     if col ≤ QR.ncols
 #         return QR
 #     end
 #
@@ -214,7 +214,7 @@ function resizedata!(QR::QROperator{CachedOperator{T,BlockBandedMatrix{T},
      ds = domainspace(QR)
      col = blockstop(ds, COL)  # last column
 
-     if col ≤ QR.ncols
+     if col ≤ QR.ncols
          return QR
      end
 
@@ -297,8 +297,8 @@ function resizedata!(QR::QROperator{CachedOperator{T,BlockBandedMatrix{T},
                  # TODO: remove these debugging statement
                  # @assert w_j-1 + M ≤ length(W.data)
                  # @assert shft + st*(ξ_2-1) + M ≤ length(R.data)
-                 # @assert 0 ≤ w_j-1
-                 # if ! (0 ≤ shft + st*(ξ_2-1))
+                 # @assert 0 ≤ w_j-1
+                 # if ! (0 ≤ shft + st*(ξ_2-1))
                  #     @show shft, st, ξ_2, l, u
                  #     @show κ, bs.block_starts[K1,J]
                  #     @show K1, J

src/Caching/matrix.jl

@@ -19,7 +19,7 @@ function resizedata!(B::CachedOperator{T,Matrix{T}},n::Integer,m::Integer) where
         B.data = unsafe_resize!(B.data,:,m)
     end
 
-    if n ≤ B.datasize[1] && m ≤ B.datasize[2]
+    if n ≤ B.datasize[1] && m ≤ B.datasize[2]
         # do nothing
         B
     elseif n ≤ B.datasize[1]
@@ -56,7 +56,7 @@ function mulpars(Ac::Adjoint{T,<:QROperatorQ{QROperator{RR,Matrix{T},T},T}},
 
     k=1
     yp=view(Y,1:M)
-    while (k ≤ m+M || norm(yp) > tolerance )
+    while (k ≤ m+M || norm(yp) > tolerance )
         if k > maxlength
             @warn "Maximum length $maxlength reached."
             break
@@ -119,7 +119,7 @@ function mulpars(Ac::Adjoint{T,<:QROperatorQ{QROperator{RR,Matrix{T},T},T}},
 
     k=1
     yp=y
-    while (k ≤ min(m+M,A_dim) || BLAS.nrm2(M,yp,1) > tolerance )
+    while (k ≤ min(m+M,A_dim) || BLAS.nrm2(M,yp,1) > tolerance )
         if k > maxlength
             @warn "Maximum length $maxlength reached."
             break

src/Caching/ragged.jl

@@ -32,7 +32,7 @@ function resizedata!(B::CachedOperator{T,RaggedMatrix{T}},::Colon,n::Integer) wh
         end
 
         # avoid padding with negative length
-        if B.data.cols[n+1] ≤ 0
+        if B.data.cols[n+1] ≤ 0
             return B
         end
 

src/Domains/Domains.jl

@@ -50,10 +50,10 @@ function _affine_setdiff(d::Domain, p::Number)
     isempty(d) && return d
     p ∉ d  && return d
     a,b = endpoints(d)
-    if leftendpoint(d) > rightendpoint(d)
+    if leftendpoint(d) > rightendpoint(d)
         a,b = b,a
     end
-    UnionDomain(a..p, p..b) # TODO: Clopen interval
+    UnionDomain(a..p, p..b) # TODO: Clopen interval
 end
 
 function _affine_setdiff(d::Domain, pts)
@@ -66,7 +66,7 @@ function _affine_setdiff(d::Domain, pts)
     isapprox(db,pts[end];atol=tol) && pop!(pts)
 
     sort!(pts)
-    leftendpoint(d) > rightendpoint(d) && reverse!(pts)
+    leftendpoint(d) > rightendpoint(d) && reverse!(pts)
     filter!(p->p ∈ d,pts)
 
     isempty(pts) && return d

src/Fun.jl

@@ -66,7 +66,7 @@ end
 function coefficient(f::Fun,kr::AbstractRange)
     b = maximum(kr)
 
-    if b ≤ ncoefficients(f)
+    if b ≤ ncoefficients(f)
         f.coefficients[kr]
     else
         [coefficient(f,k) for k in kr]
@@ -591,7 +591,7 @@ function copy(bc::Broadcasted{FunStyle})
 end
 
 function copyto!(dest::Fun, bc::Broadcasted{FunStyle})
-    if broadcastdomain(bc) ≠ domain(dest)
+    if broadcastdomain(bc) ≠ domain(dest)
         throw(ArgumentError("Domain of right-hand side incompatible with destination"))
     end
     ret = copy(bc)

src/LinearAlgebra/RaggedMatrix.jl

@@ -14,9 +14,9 @@ mutable struct RaggedMatrix{T} <: AbstractMatrix{T}
         # make sure the cols are monitonically increasing
         @assert 1==cols[1]
         for j=1:length(cols)-1
-            @assert cols[j] ≤ cols[j+1]
+            @assert cols[j] ≤ cols[j+1]
         end
-        @assert cols[end] == length(data)+1
+        @assert cols[end] == length(data)+1
 
         # make sure we have less entries than the size of the matrix
         @assert length(data) ≤ m*(length(cols)-1)
@@ -58,7 +58,7 @@ function Base.setindex!(A::RaggedMatrix,v,k::Int,j::Int)
 
     if A.cols[j]+k-1 < A.cols[j+1]
         A.data[A.cols[j]+k-1]=v
-    elseif v ≠ 0
+    elseif v ≠ 0
         throw(BoundsError(A,(k,j)))
     end
     v
@@ -115,7 +115,7 @@ for (op,bop) in ((:(Base.rand), :rrand),)
 end
 
 function RaggedMatrix{T}(Z::Zeros, colns::AbstractVector{Int}) where {T}
-    if size(Z,2) ≠ length(colns)
+    if size(Z,2) ≠ length(colns)
         throw(DimensionMismatch())
     end
     RaggedMatrix(zeros(T,sum(colns)), [1; (1 .+cumsum(colns))], size(Z,1))
@@ -137,7 +137,7 @@ RaggedMatrix(A::AbstractMatrix, colns::AbstractVector{Int}) = RaggedMatrix{eltyp
 function mul!(y::Vector, A::RaggedMatrix, b::Vector)
     m=size(A,2)
 
-    if m ≠ length(b) || size(A,1) ≠ length(y)
+    if m ≠ length(b) || size(A,1) ≠ length(y)
         throw(BoundsError())
     end
     T=eltype(y)
@@ -151,7 +151,7 @@ end
 
 
 function BLAS.axpy!(a, X::RaggedMatrix, Y::RaggedMatrix)
-    if size(X) ≠ size(Y)
+    if size(X) ≠ size(Y)
         throw(BoundsError())
     end
 
@@ -181,7 +181,7 @@ colstop(X::SubArray{T,2,RaggedMatrix{T},Tuple{UnitRange{Int},UnitRange{Int}}},
 
 function BLAS.axpy!(a,X::RaggedMatrix,
                     Y::SubArray{T,2,RaggedMatrix{T},Tuple{UnitRange{Int},UnitRange{Int}}}) where T
-    if size(X) ≠ size(Y)
+    if size(X) ≠ size(Y)
         throw(BoundsError())
     end
 
@@ -194,7 +194,7 @@ function BLAS.axpy!(a,X::RaggedMatrix,
         cy=colstop(Y,j)
         if cx > cy
             for k=cy+1:cx
-                if X[k,j] ≠ 0
+                if X[k,j] ≠ 0
                     throw(BoundsError("Trying to add a non-zero to a zero."))
                 end
             end
@@ -239,7 +239,7 @@ function mul!(Y::RaggedMatrix,A::RaggedMatrix,B::RaggedMatrix)
             col = max(col,colstop(A,k))
         end
 
-        if col > colstop(Y,j)
+        if col > colstop(Y,j)
             throw(BoundsError())
         end
     end

src/LinearAlgebra/clenshaw.jl

@@ -285,7 +285,7 @@ function chebmult_getindex(cfs::AbstractVector,k::Integer,j::Integer)
     end
 
     # Hankel part
-    if k ≥ 2 && k+j-1 ≤ n
+    if k ≥ 2 && k+j-1 ≤ n
         ret += cfs[k+j-1]/2
     end
 

src/LinearAlgebra/helper.jl

@@ -110,7 +110,7 @@ scal!(n::Integer,cst::BlasFloat,ret::DenseArray{T},k::Integer) where {T<:BlasFlo
     BLAS.scal!(n,convert(T,cst),ret,k)
 
 function scal!(n::Integer,cst::Number,ret::AbstractArray,k::Integer)
-    @assert k*n ≤ length(ret)
+    @assert k*n ≤ length(ret)
     @simd for j=1:k:k*(n-1)+1
         @inbounds ret[j] *= cst
     end