fix whitespace/newline issues (#100)

Author: jishnub

README.md

@@ -9,4 +9,4 @@ Core functionality of ApproxFun
 
 
 
-[ApproxFun.jl](https://github.com/JuliaApproximation/ApproxFun.jl) is a package for approximating functions. This package contains core functionality used by the various components of ApproxFun. It is possible to add spaces on top of this without the rest of ApproxFun, but this is undocumented for now.
+[ApproxFun.jl](https://github.com/JuliaApproximation/ApproxFun.jl) is a package for approximating functions. This package contains core functionality used by the various components of ApproxFun. It is possible to add spaces on top of this without the rest of ApproxFun, but this is undocumented for now.

src/ApproxFunBase.jl

@@ -1,15 +1,15 @@
 module ApproxFunBase
     using Base: AnyDict
 using Base, BlockArrays, BandedMatrices, BlockBandedMatrices, DomainSets, IntervalSets,
-            SpecialFunctions, AbstractFFTs, FFTW, SpecialFunctions, DSP, DualNumbers, 
+            SpecialFunctions, AbstractFFTs, FFTW, SpecialFunctions, DSP, DualNumbers,
             LinearAlgebra, SparseArrays, LowRankApprox, FillArrays, InfiniteArrays, InfiniteLinearAlgebra #, Arpack
 import StaticArrays, Calculus
 
 import DomainSets: Domain, indomain, UnionDomain, ProductDomain, FullSpace, Point, elements, DifferenceDomain,
             Interval, ChebyshevInterval, boundary, ∂, rightendpoint, leftendpoint,
             dimension, WrappedDomain, VcatDomain, component, components, ncomponents
 
-            
+
 
 import AbstractFFTs: Plan, fft, ifft
 import FFTW: plan_r2r!, fftwNumber, REDFT10, REDFT01, REDFT00, RODFT00, R2HC, HC2R,
@@ -64,7 +64,7 @@ import BandedMatrices: bandrange, bandshift,
                         colstart, colstop, colrange, rowstart, rowstop, rowrange,
                         bandwidths, _BandedMatrix, BandedMatrix
 
-import BlockArrays: blocksize, block, blockaxes, blockindex                      
+import BlockArrays: blocksize, block, blockaxes, blockindex
 import BlockBandedMatrices: blockbandwidth, blockbandwidths, blockcolstop, blockcolrange,
                             blockcolstart, blockrowstop, blockrowstart, blockrowrange,
                             subblockbandwidth, subblockbandwidths, _BlockBandedMatrix,

src/Caching/blockbanded.jl

@@ -280,7 +280,7 @@ function resizedata!(QR::QROperator{CachedOperator{T,BlockBandedMatrix{T},
          # scale rest of columns in first block
          # for ξ_2 = 2:
 
-         for ξ_2 = ξ:length(bs.axes[2][Block(J1)]) 
+         for ξ_2 = ξ:length(bs.axes[2][Block(J1)])
              # we now apply I-2v*v' in place
              r_sh = r+sz*(shft + st*(ξ_2-ξ)) # the pointer the (j,ξ_2)-th entry
              dt = BandedMatrices.dot(M, wp, 1, r_sh, 1)

src/Domain.jl

@@ -181,4 +181,4 @@ const ℕ = PositiveIntegers()
 const ℤ = Integers()
 
 ==(::PositiveIntegers, ::PositiveIntegers) = true
-==(::Integers, ::Integers) = true
+==(::Integers, ::Integers) = true

src/Domains/Domains.jl

@@ -40,23 +40,23 @@ end
 
 include("multivariate.jl")
 
-affine_setdiff(d::Domain, ptsin::UnionDomain) = 
+affine_setdiff(d::Domain, ptsin::UnionDomain) =
     _affine_setdiff(d, Number.(elements(ptsin)))
 
-affine_setdiff(d::Domain, ptsin::WrappedDomain{<:AbstractVector}) = 
+affine_setdiff(d::Domain, ptsin::WrappedDomain{<:AbstractVector}) =
     _affine_setdiff(d, ptsin.domain)
 
-function _affine_setdiff(d::Domain, p::Number) 
+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
 end
 
-function _affine_setdiff(d::Domain, pts)    
+function _affine_setdiff(d::Domain, pts)
     isempty(pts) && return d
     tol=sqrt(eps(arclength(d)))
     da=leftendpoint(d)
@@ -79,4 +79,4 @@ function _affine_setdiff(d::Domain, pts)
     end
     ret[end] = Domain(pts[end] .. rightendpoint(d))
     UnionDomain(ret)
-end
+end

src/Domains/Segment.jl

@@ -132,7 +132,7 @@ function broadcasted(::typeof(^),d::Segment,c::Number)
     end
 end
 
-broadcasted(::typeof(Base.literal_pow), ::typeof(^), d::Segment, ::Val{K}) where K = 
+broadcasted(::typeof(Base.literal_pow), ::typeof(^), d::Segment, ::Val{K}) where K =
     broadcasted(^, d, K)
 
 /(d::Segment,c::Number) = broadcast(/,d,c)
@@ -145,7 +145,7 @@ broadcasted(::typeof(sqrt), d::Segment)=Segment(sqrt(leftendpoint(d)),sqrt(right
 broadcasted(::typeof(+),d1::Segment,d2::Segment) = Segment(d1.a+d2.a,d1.b+d2.b)
 
 
-DomainSets.map_domain(map::DomainSets.AbstractAffineMap, domain::AbstractSegment) = 
+DomainSets.map_domain(map::DomainSets.AbstractAffineMap, domain::AbstractSegment) =
     Segment(map(leftendpoint(domain)),map(rightendpoint(domain)))
 
 ## intersect/union

src/LinearAlgebra/clenshaw.jl

@@ -290,4 +290,4 @@ function chebmult_getindex(cfs::AbstractVector,k::Integer,j::Integer)
     end
 
     ret
-end
+end

src/LinearAlgebra/helper.jl

@@ -749,4 +749,4 @@ function iterate(it::BlockInterlacer, (N,k,blkst,lngs))
     return (N,lngs[N]),(N,k+1,blkst,lngs)
 end
 
-cache(Q::BlockInterlacer) = CachedIterator(Q)
+cache(Q::BlockInterlacer) = CachedIterator(Q)

src/Multivariate/TensorSpace.jl

@@ -323,10 +323,10 @@ Base.transpose(d::TensorSpace) = TensorSpace(d.spaces[2],d.spaces[1])
 
 
 
-## Transforms                                                          
+## Transforms
 
-for (plan, plan!, Typ) in ((:plan_transform, :plan_transform!, :TransformPlan), 
-                           (:plan_itransform, :plan_itransform!, :ITransformPlan))                                                             
+for (plan, plan!, Typ) in ((:plan_transform, :plan_transform!, :TransformPlan),
+                           (:plan_itransform, :plan_itransform!, :ITransformPlan))
     @eval begin
         $plan!(S::TensorSpace, M::AbstractMatrix) = $Typ(S,(($plan(S.spaces[1],size(M,1)),size(M,1)),
                                                              ($plan(S.spaces[2],size(M,2)),size(M,2))),
@@ -368,7 +368,7 @@ function plan_transform(sp::TensorSpace, ::Type{T}, n::Integer) where {T}
     TransformPlan(sp,((plan_transform(sp.spaces[1],T,N),N),
                     (plan_transform(sp.spaces[2],T,M),M)),
                 Val{false})
-end  
+end
 
 function plan_transform!(sp::TensorSpace, ::Type{T}, n::Integer) where {T}
     P = plan_transform(sp, T, n)
@@ -383,7 +383,7 @@ function plan_itransform(sp::TensorSpace, v::AbstractVector{T}) where {T}
     ITransformPlan(sp,((plan_itransform(sp.spaces[1],T,N),N),
                     (plan_itransform(sp.spaces[2],T,M),M)),
                 Val{false})
-end   
+end
 
 
 function *(T::TransformPlan{TT,<:TensorSpace,true},v::AbstractVector) where TT # need where TT

src/Operators/banded/ToeplitzOperator.jl

@@ -267,4 +267,4 @@ function hankel_axpy!(α,cfs,kr,jr,ret)
     end
 
     ret
-end
+end