clean up whitespaces (#180)

Author: jishnub

src/PaduaTransform.jl

@@ -123,7 +123,7 @@ Pre-plan a Padua Transform.
 """
 function plan_paduatransform!(::Type{T},N::Integer,lex) where T
     n=Int(cld(-3+sqrt(1+8N),2))
-    if N ≠ ((n+1)*(n+2))÷2
+    if N ≠ ((n+1)*(n+2))÷2
         error("Padua transforms can only be applied to vectors of length (n+1)*(n+2)/2.")
     end
     PaduaTransformPlan(Array{T}(undef,n+2,n+1),FFTW.plan_r2r!(Array{T}(undef,n+2,n+1),FFTW.REDFT00),lex)

src/chebyshevtransform.jl

@@ -364,29 +364,29 @@ plan_chebyshevutransform(x::AbstractArray, dims...; kws...) = plan_chebyshevutra
 
 @inline function _chebu1_prescale!(_, x::AbstractVector{T}) where T
     n = length(x)
-    for k=1:n # sqrt(1-x_j^2) weight
+    for k=1:n # sqrt(1-x_j^2) weight
         x[k] *= sinpi(one(T)/(2n) + (k-one(T))/n)/n
     end
     x
 end
 
 @inline function _chebu1_postscale!(_, x::AbstractVector{T}) where T
     n = length(x)
-    for k=1:n # sqrt(1-x_j^2) weight
+    for k=1:n # sqrt(1-x_j^2) weight
         x[k] /= sinpi(one(T)/(2n) + (k-one(T))/n)/n
     end
     x
 end
 
 function *(P::ChebyshevUTransformPlan{T,1,K,true}, x::AbstractVector{T}) where {T,K}
-    length(x) ≤ 1 && return x
+    length(x) ≤ 1 && return x
     _chebu1_prescale!(P.plan.region, x)
     P.plan * x
 end
 
 function mul!(y::AbstractVector{T}, P::ChebyshevUTransformPlan{T,1,K,false}, x::AbstractVector{T}) where {T,K}
     n = length(x)
-    length(x) ≤ 1 && return copyto!(y, x)
+    length(x) ≤ 1 && return copyto!(y, x)
     _chebu1_prescale!(P.plan.region, x)
     _plan_mul!(y, P.plan, x)
     _chebu1_postscale!(P.plan.region, x)
@@ -396,7 +396,7 @@ end
 @inline function _chebu2_prescale!(_, x::AbstractVector{T}) where T
     n = length(x)
     c = one(T)/ (n+1)
-    for k=1:n # sqrt(1-x_j^2) weight
+    for k=1:n # sqrt(1-x_j^2) weight
         x[k] *= sinpi(k*c)
     end
     x
@@ -405,22 +405,22 @@ end
 @inline function _chebu2_postscale!(_, x::AbstractVector{T}) where T
     n = length(x)
     c = one(T)/ (n+1)
-    @inbounds for k=1:n # sqrt(1-x_j^2) weight
+    @inbounds for k=1:n # sqrt(1-x_j^2) weight
         x[k] /= sinpi(k*c)
     end
     x
 end
 
 function *(P::ChebyshevUTransformPlan{T,2,K,true}, x::AbstractVector{T}) where {T,K}
     n = length(x)
-    n ≤ 1 && return x
+    n ≤ 1 && return x
     _chebu2_prescale!(P.plan.region, x)
     lmul!(one(T)/ (n+1), P.plan * x)
 end
 
 function mul!(y::AbstractVector{T}, P::ChebyshevUTransformPlan{T,2,K,false}, x::AbstractVector{T}) where {T,K}
     n = length(x)
-    n ≤ 1 && return copyto!(y, x)
+    n ≤ 1 && return copyto!(y, x)
     _chebu2_prescale!(P.plan.region, x)
     _plan_mul!(y, P.plan, x)
     _chebu2_postscale!(P.plan.region, x)
@@ -485,14 +485,14 @@ plan_ichebyshevutransform(x::AbstractArray, dims...; kws...) = plan_ichebyshevut
 
 function _ichebyu1_postscale!(_, x::AbstractVector{T}) where T
     n = length(x)
-    @inbounds for k=1:n # sqrt(1-x_j^2) weight
+    @inbounds for k=1:n # sqrt(1-x_j^2) weight
         x[k] /= 2sinpi(one(T)/(2n) + (k-one(T))/n)
     end
     x
 end
 function *(P::IChebyshevUTransformPlan{T,1,K,true}, x::AbstractVector{T}) where {T<:fftwNumber,K}
     n = length(x)
-    n ≤ 1 && return x
+    n ≤ 1 && return x
 
     x = P.plan * x
     _ichebyu1_postscale!(P.plan.region, x)
@@ -501,7 +501,7 @@ end
 function mul!(y::AbstractVector{T}, P::IChebyshevUTransformPlan{T,1,K,false}, x::AbstractVector{T}) where {T<:fftwNumber,K}
     n = length(x)
     length(y) == n || throw(DimensionMismatch("output must match dimension"))
-    n ≤ 1 && return x
+    n ≤ 1 && return x
 
     _plan_mul!(y, P.plan, x)
     _ichebyu1_postscale!(P.plan.region, y)
@@ -510,7 +510,7 @@ end
 function _ichebu2_rescale!(_, x::AbstractVector{T}) where T
     n = length(x)
     c = one(T)/ (n+1)
-    for k=1:n # sqrt(1-x_j^2) weight
+    for k=1:n # sqrt(1-x_j^2) weight
         x[k] /= sinpi(k*c)
     end
     ldiv!(2, x)
@@ -519,7 +519,7 @@ end
 
 function *(P::IChebyshevUTransformPlan{T,2,K,true}, x::AbstractVector{T}) where {T<:fftwNumber,K}
     n = length(x)
-    n ≤ 1 && return x
+    n ≤ 1 && return x
 
     x = P.plan * x
     _ichebu2_rescale!(P.plan.region, x)
@@ -528,7 +528,7 @@ end
 function mul!(y::AbstractVector{T}, P::IChebyshevUTransformPlan{T,2,K,false}, x::AbstractVector{T}) where {T<:fftwNumber,K}
     n = length(x)
     length(y) == n || throw(DimensionMismatch("output must match dimension"))
-    n ≤ 1 && return x
+    n ≤ 1 && return x
 
     _plan_mul!(y, P.plan, x)
     _ichebu2_rescale!(P.plan.region, y)
@@ -679,4 +679,4 @@ end
 *(P::IChebyshevTransformPlan{T,1,Nothing,true,N,R}, x::AbstractVector{T}) where {T,N,R} =
     copyto!(x, IChebyshevTransformPlan{T,1,Nothing,false,N,R}() * x)
 # *(P::IChebyshevTransformPlan{T,SECONDKIND,false,Nothing}, x::AbstractVector{T}) where T =
-#     IChebyshevTransformPlan{T,SECONDKIND,true,Nothing}() * copy(x)
+#     IChebyshevTransformPlan{T,SECONDKIND,true,Nothing}() * copy(x)

test/chebyshevtests.jl

@@ -191,7 +191,7 @@ using FastTransforms, Test
             @test ichebyshevtransform(X,Val(2),2) ≈ ichebyshevtransform!(copy(X),Val(2),2) ≈ hcat(ichebyshevtransform.([X[k,:] for k=axes(X,1)],Val(2))...)'
 
             @test @inferred(ichebyshevtransform(X)) ≈ @inferred(ichebyshevtransform!(copy(X))) ≈ ichebyshevtransform(ichebyshevtransform(X,1),2)
-            @test @inferred(ichebyshevtransform(X,Val(2))) ≈ @inferred(ichebyshevtransform!(copy(X),Val(2))) ≈ ichebyshevtransform(ichebyshevtransform(X,Val(2),1),Val(2),2)            
+            @test @inferred(ichebyshevtransform(X,Val(2))) ≈ @inferred(ichebyshevtransform!(copy(X),Val(2))) ≈ ichebyshevtransform(ichebyshevtransform(X,Val(2),1),Val(2),2)
 
             @test ichebyshevtransform(chebyshevtransform(X)) ≈ X
             @test chebyshevtransform(ichebyshevtransform(X)) ≈ X
@@ -208,7 +208,7 @@ using FastTransforms, Test
         @test chebyshevtransform([1,2,3], Val(2)) == chebyshevtransform([1.,2,3], Val(2))
         @test ichebyshevtransform([1,2,3]) == ichebyshevtransform([1.,2,3])
         @test ichebyshevtransform([1,2,3], Val(2)) == ichebyshevtransform([1.,2,3], Val(2))
-        
+
         @test chebyshevutransform([1,2,3]) == chebyshevutransform([1.,2,3])
         @test chebyshevutransform([1,2,3], Val(2)) == chebyshevutransform([1.,2,3], Val(2))
         @test ichebyshevutransform([1,2,3]) == ichebyshevutransform([1.,2,3])

test/clenshawtests.jl

@@ -14,9 +14,9 @@ import FastTransforms: clenshaw, clenshaw!, forwardrecurrence!, forwardrecurrenc
             @test @inferred(clenshaw(elty[],1)) ≡ zero(elty)
 
             x = elty[1,0,0.1]
-            @test @inferred(clenshaw(c,x)) ≈ @inferred(clenshaw!(c,copy(x))) ≈ 
+            @test @inferred(clenshaw(c,x)) ≈ @inferred(clenshaw!(c,copy(x))) ≈
                 @inferred(clenshaw!(c,x,similar(x))) ≈
-                @inferred(clenshaw(cf,x)) ≈ @inferred(clenshaw!(cf,copy(x))) ≈ 
+                @inferred(clenshaw(cf,x)) ≈ @inferred(clenshaw!(cf,copy(x))) ≈
                 @inferred(clenshaw!(cf,x,similar(x))) ≈ elty[6,-2,-1.74]
 
             @testset "Strided" begin
@@ -34,7 +34,7 @@ import FastTransforms: clenshaw, clenshaw!, forwardrecurrence!, forwardrecurrenc
             @testset "matrix coefficients" begin
                 c = [1 2; 3 4; 5 6]
                 @test clenshaw(c,0.1) ≈ [clenshaw(c[:,1],0.1), clenshaw(c[:,2],0.1)]
-                @test clenshaw(c,[0.1,0.2]) ≈ [clenshaw(c[:,1], 0.1) clenshaw(c[:,2], 0.1); clenshaw(c[:,1], 0.2) clenshaw(c[:,2], 0.2)] 
+                @test clenshaw(c,[0.1,0.2]) ≈ [clenshaw(c[:,1], 0.1) clenshaw(c[:,2], 0.1); clenshaw(c[:,1], 0.2) clenshaw(c[:,2], 0.2)]
             end
         end
     end
@@ -45,19 +45,19 @@ import FastTransforms: clenshaw, clenshaw!, forwardrecurrence!, forwardrecurrenc
         @testset "forwardrecurrence!" begin
             @test @inferred(forwardrecurrence(N, A, B, C, 1)) == @inferred(forwardrecurrence!(Vector{Int}(undef,N), A, B, C, 1)) == 1:N
             @test forwardrecurrence!(Vector{Int}(undef,N), A, B, C, -1) == (-1) .^ (0:N-1) .* (1:N)
-            @test forwardrecurrence(N, A, B, C, 0.1) ≈ forwardrecurrence!(Vector{Float64}(undef,N), A, B, C, 0.1) ≈ 
+            @test forwardrecurrence(N, A, B, C, 0.1) ≈ forwardrecurrence!(Vector{Float64}(undef,N), A, B, C, 0.1) ≈
                     sin.((1:N) .* acos(0.1)) ./ sqrt(1-0.1^2)
         end
 
         c = [1,2,3]
-        @test c'forwardrecurrence(3, A, B, C, 0.1) ≈ clenshaw([1,2,3], A, B, C, 0.1) ≈ 
+        @test c'forwardrecurrence(3, A, B, C, 0.1) ≈ clenshaw([1,2,3], A, B, C, 0.1) ≈
             1 + (2sin(2acos(0.1)) + 3sin(3acos(0.1)))/sqrt(1-0.1^2)
 
         @testset "matrix coefficients" begin
             c = [1 2; 3 4; 5 6]
             @test clenshaw(c,A,B,C,0.1) ≈ [clenshaw(c[:,1],A,B,C,0.1), clenshaw(c[:,2],A,B,C,0.1)]
-            @test clenshaw(c,A,B,C,[0.1,0.2]) ≈ [clenshaw(c[:,1], A,B,C,0.1) clenshaw(c[:,2], A,B,C,0.1); clenshaw(c[:,1], A,B,C,0.2) clenshaw(c[:,2], A,B,C,0.2)] 
-        end            
+            @test clenshaw(c,A,B,C,[0.1,0.2]) ≈ [clenshaw(c[:,1], A,B,C,0.1) clenshaw(c[:,2], A,B,C,0.1); clenshaw(c[:,1], A,B,C,0.2) clenshaw(c[:,2], A,B,C,0.2)]
+        end
     end
 
     @testset "Chebyshev-as-general" begin
@@ -79,10 +79,10 @@ import FastTransforms: clenshaw, clenshaw!, forwardrecurrence!, forwardrecurrenc
         @test @inferred(clenshaw(Float64[], A, B, C, 1)) ≡ 0.0
 
         x = [1,0,0.1]
-        @test @inferred(clenshaw(c, A, B, C, x)) ≈ @inferred(clenshaw!(c, A, B, C, copy(x))) ≈ 
+        @test @inferred(clenshaw(c, A, B, C, x)) ≈ @inferred(clenshaw!(c, A, B, C, copy(x))) ≈
             @inferred(clenshaw!(c, A, B, C, x, one.(x), similar(x))) ≈
             @inferred(clenshaw!(cf, Af, Bf, Cf, x, one.(x),similar(x))) ≈
-            @inferred(clenshaw([1.,2,3], A, B, C, x)) ≈ 
+            @inferred(clenshaw([1.,2,3], A, B, C, x)) ≈
             @inferred(clenshaw!([1.,2,3], A, B, C, copy(x))) ≈ [6,-2,-1.74]
     end
 
@@ -136,4 +136,4 @@ import FastTransforms: clenshaw, clenshaw!, forwardrecurrence!, forwardrecurrenc
         c = randn(N)
         @test clenshaw(c, A, B, C, 0.1) == clenshaw(c, A, Vector(B), C, 0.1)
     end
-end
+end