Tests pass!!!

Author: dlfivefifty

.travis.yml

@@ -6,9 +6,6 @@ os:
 julia:
   - 0.6
   - nightly
-matrix:
-  allow_failures:
-    - julia: nightly
 notifications:
   email: false
 after_success:

REQUIRE

@@ -1,4 +1,4 @@
-julia 0.6
+julia 0.7-
 ToeplitzMatrices 0.2
 HierarchicalMatrices 0.1.1
 LowRankApprox 0.1.1

appveyor.yml

@@ -5,11 +5,6 @@ environment:
   - JULIA_URL: "https://julialangnightlies-s3.julialang.org/bin/winnt/x86/julia-latest-win32.exe"
   - JULIA_URL: "https://julialangnightlies-s3.julialang.org/bin/winnt/x64/julia-latest-win64.exe"
 
-matrix:
-  allow_failures:
-    - JULIA_URL: "https://julialangnightlies-s3.julialang.org/bin/winnt/x86/julia-latest-win32.exe"
-    - JULIA_URL: "https://julialangnightlies-s3.julialang.org/bin/winnt/x64/julia-latest-win64.exe"
-
 branches:
   only:
     - master

src/SphericalHarmonics/SphericalHarmonics.jl

@@ -4,8 +4,14 @@ function *(P::SphericalHarmonicPlan, X::AbstractMatrix)
     mul!(zero(X), P, X)
 end
 
-function \(P::SphericalHarmonicPlan, X::AbstractMatrix)
-    mul!(zero(X), transpose(P), X)
+if VERSION < v"0.7-"
+    function \(P::SphericalHarmonicPlan, X::AbstractMatrix)
+        At_mul_B!(zero(X), P, X)
+    end
+else
+    function \(P::SphericalHarmonicPlan, X::AbstractMatrix)
+        mul!(zero(X), transpose(P), X)
+    end
 end
 
 include("sphfunctions.jl")

src/fftBigFloat.jl

@@ -34,7 +34,7 @@ end
 rfft(v::Vector{T}) where T<:BigFloats = fft(v)[1:div(length(v),2)+1]
 function irfft(v::Vector{T},n::Integer) where T<:BigFloats
     @assert n==2length(v)-1
-    r = Vector{Complex{BigFloat}}(n)
+    r = Vector{Complex{BigFloat}}(undef, n)
     r[1:length(v)]=v
     r[length(v)+1:end]=reverse(conj(v[2:end]))
     real(ifft(r))
@@ -163,8 +163,8 @@ for (Plan,ff,ff!) in ((:DummyFFTPlan,:fft,:fft!),
     @eval begin
         *(p::$Plan{T,true}, x::StridedArray{T,N}) where {T,N} = $ff!(x)
         *(p::$Plan{T,false}, x::StridedArray{T,N}) where {T,N} = $ff(x)
-        function mul!(C::StridedVector,p::$Plan,x::StridedVector)
-            C[:]=$ff(x)
+        function LAmul!(C::StridedVector, p::$Plan, x::StridedVector)
+            C[:] = $ff(x)
             C
         end
     end

test/sphericalharmonics/apitests.jl

@@ -4,32 +4,33 @@ using Compat.Test
 import FastTransforms: normalizecolumns!, maxcolnorm
 
 @testset "Spherical harmonic API" begin
-    n = 512
-    A = sphrandn(Float64, n, n);
-    normalizecolumns!(A);
+    let n = 512
+        A = sphrandn(Float64, n, n);
+        normalizecolumns!(A);
 
-    B = sph2fourier(A)
-    C = fourier2sph(B)
-    println("The backward difference between slow plan and original: ", maxcolnorm(A-C))
+        B = sph2fourier(A)
+        C = fourier2sph(B)
+        println("The backward difference between slow plan and original: ", maxcolnorm(A-C))
 
-    P = plan_sph2fourier(A)
-    B = P*A
-    C = P\B
+        P = plan_sph2fourier(A)
+        B = P*A
+        C = P\B
 
-    println("The backward difference between slow plan and original: ", maxcolnorm(A-C))
+        println("The backward difference between slow plan and original: ", maxcolnorm(A-C))
 
 
-    n = 1024
-    A = sphrandn(Float64, n, n);
-    normalizecolumns!(A);
+        n = 1024
+        A = sphrandn(Float64, n, n);
+        normalizecolumns!(A);
 
-    B = sph2fourier(A; sketch = :none)
-    C = fourier2sph(B; sketch = :none)
-    println("The backward difference between thin plan and original: ", maxcolnorm(A-C))
+        B = sph2fourier(A; sketch = :none)
+        C = fourier2sph(B; sketch = :none)
+        println("The backward difference between thin plan and original: ", maxcolnorm(A-C))
 
-    P = plan_sph2fourier(A; sketch = :none)
-    B = P*A
-    C = P\B
+        P = plan_sph2fourier(A; sketch = :none)
+        B = P*A
+        C = P\B
 
-    println("The backward difference between thin plan and original: ", maxcolnorm(A-C))
+        println("The backward difference between thin plan and original: ", maxcolnorm(A-C))
+    end
 end

test/sphericalharmonics/synthesisanalysistests.jl

@@ -110,27 +110,29 @@ end
     end
 end
 
-# This test confirms numerically that [P_4(z⋅y) - P_4(x⋅y)]/(z⋅y - x⋅y) is actually a degree-3 polynomial on 𝕊²
-x = [0,0,1]
-y = normalize!([.123,.456,.789])
+@testset "Degree-3 polynomial" begin
+    # This test confirms numerically that [P_4(z⋅y) - P_4(x⋅y)]/(z⋅y - x⋅y) is actually a degree-3 polynomial on 𝕊²
+    x = [0,0,1]
+    y = normalize!([.123,.456,.789])
 
-z = (θ,φ) -> [sinpi(θ)*cospi(φ), sinpi(θ)*sinpi(φ), cospi(θ)]
+    z = (θ,φ) -> [sinpi(θ)*cospi(φ), sinpi(θ)*sinpi(φ), cospi(θ)]
 
-P4 = x -> (35*x^4-30*x^2+3)/8
+    P4 = x -> (35*x^4-30*x^2+3)/8
 
-n = 5
-θ = (0.5:n-0.5)/n
-φ = (0:2n-2)*2/(2n-1)
-F = [(P4(z(θ,φ)⋅y) - P4(x⋅y))/(z(θ,φ)⋅y - x⋅y) for θ in θ, φ in φ]
-V = zero(F)
-mul!(V, FastTransforms.plan_analysis(F), F)
-U3 = fourier2sph(V)
+    n = 5
+    θ = (0.5:n-0.5)/n
+    φ = (0:2n-2)*2/(2n-1)
+    F = [(P4(z(θ,φ)⋅y) - P4(x⋅y))/(z(θ,φ)⋅y - x⋅y) for θ in θ, φ in φ]
+    V = zero(F)
+    mul!(V, FastTransforms.plan_analysis(F), F)
+    U3 = fourier2sph(V)
 
-# U3 is degree-3
+    # U3 is degree-3
 
-F = [P4(z(θ,φ)⋅y) for θ in θ, φ in φ]
-V = zero(F)
-mul!(V, FastTransforms.plan_analysis(F), F)
-U4 = fourier2sph(V)
+    F = [P4(z(θ,φ)⋅y) for θ in θ, φ in φ]
+    V = zero(F)
+    mul!(V, FastTransforms.plan_analysis(F), F)
+    U4 = fourier2sph(V)
 
-# U4 is degree-4
+    # U4 is degree-4
+end

test/sphericalharmonics/vectorfieldtests.jl

@@ -1,49 +1,87 @@
 using FastTransforms, Compat
 using Compat.Test
 
-@testset "Test vector field transforms" begin
-    # f = (θ,φ) -> cospi(θ) + sinpi(θ)*(1+cospi(2θ))*sinpi(φ) + sinpi(θ)^5*(cospi(5φ)-sinpi(5φ))
-    ∇θf = (θ,φ) -> -sinpi(θ) + (cospi(θ)*(1+cospi(2θ)) - 2*sinpi(θ)*sinpi(2θ))*sinpi(φ) + 5*sinpi(θ)^4*cospi(θ)*(cospi(5φ)-sinpi(5φ))
-    ∇φf = (θ,φ) -> (1+cospi(2θ))*cospi(φ) - 5*sinpi(θ)^4*(sinpi(5φ)+cospi(5φ))
+if VERSION < v"0.7-"
+    @testset "Test vector field transforms" begin
+        # f = (θ,φ) -> cospi(θ) + sinpi(θ)*(1+cospi(2θ))*sinpi(φ) + sinpi(θ)^5*(cospi(5φ)-sinpi(5φ))
+        ∇θf = (θ,φ) -> -sinpi(θ) + (cospi(θ)*(1+cospi(2θ)) - 2*sinpi(θ)*sinpi(2θ))*sinpi(φ) + 5*sinpi(θ)^4*cospi(θ)*(cospi(5φ)-sinpi(5φ))
+        ∇φf = (θ,φ) -> (1+cospi(2θ))*cospi(φ) - 5*sinpi(θ)^4*(sinpi(5φ)+cospi(5φ))
 
-    n = 6
-    θ = (0.5:n-0.5)/n
-    φ = (0:2n-2)*2/(2n-1)
-    ∇θF = [∇θf(θ,φ) for θ in θ, φ in φ]
-    ∇φF = [∇φf(θ,φ) for θ in θ, φ in φ]
-    V1 = zero(∇θF)
-    V2 = zero(∇φF)
-    Pa = FastTransforms.plan_analysis(∇θF)
-    mul!(V1, V2, Pa, ∇θF, ∇φF)
-    P = SlowSphericalHarmonicPlan(V1)
-
-    U1 = zero(V1)
-    U2 = zero(V2)
-    FastTransforms.At_mul_B!(U1, U2, P, V1, V2)
-
-    W1 = zero(U1)
-    W2 = zero(U2)
+        n = 6
+        θ = (0.5:n-0.5)/n
+        φ = (0:2n-2)*2/(2n-1)
+        ∇θF = [∇θf(θ,φ) for θ in θ, φ in φ]
+        ∇φF = [∇φf(θ,φ) for θ in θ, φ in φ]
+        V1 = zero(∇θF)
+        V2 = zero(∇φF)
+        Pa = FastTransforms.plan_analysis(∇θF)
+        mul!(V1, V2, Pa, ∇θF, ∇φF)
+        P = SlowSphericalHarmonicPlan(V1)
 
-    mul!(W1, W2, P, U1, U2)
+        U1 = zero(V1)
+        U2 = zero(V2)
+        At_mul_B!(U1, U2, P, V1, V2)
 
-    Ps = FastTransforms.plan_synthesis(W1)
+        W1 = zero(U1)
+        W2 = zero(U2)
 
-    G1 = zero(∇θF)
-    G2 = zero(∇φF)
+        mul!(W1, W2, P, U1, U2)
 
-    mul!(G1, G2, Ps, W1, W2)
+        Ps = FastTransforms.plan_synthesis(W1)
 
-    @test vecnorm(∇θF - G1)/vecnorm(∇θF) < n*eps()
-    @test vecnorm(∇φF - G2)/vecnorm(∇φF) < n*eps()
+        G1 = zero(∇θF)
+        G2 = zero(∇φF)
 
-    y = (1.0, 2.0, 3.0)
-    for k in (10, 20, 40)
-        ∇θf = (θ,φ) -> -2k*sin(k*((sinpi(θ)*cospi(φ) - y[1])^2 + (sinpi(θ)*sinpi(φ) - y[2])^2 + (cospi(θ) - y[3])^2))*( (sinpi(θ)*cospi(φ) - y[1])*(cospi(θ)*cospi(φ)) + (sinpi(θ)*sinpi(φ) - y[2])*(cospi(θ)*sinpi(φ)) - (cospi(θ) - y[3])*sinpi(θ) )
-        ∇φf = (θ,φ) -> -2k*sin(k*((sinpi(θ)*cospi(φ) - y[1])^2 + (sinpi(θ)*sinpi(φ) - y[2])^2 + (cospi(θ) - y[3])^2))*( (sinpi(θ)*cospi(φ) - y[1])*(-sinpi(φ)) + (sinpi(θ)*sinpi(φ) - y[2])*(cospi(φ)) )
-        n = 12k
+        mul!(G1, G2, Ps, W1, W2)
 
+        @test vecnorm(∇θF - G1)/vecnorm(∇θF) < n*eps()
+        @test vecnorm(∇φF - G2)/vecnorm(∇φF) < n*eps()
+        
+        y = (1.0, 2.0, 3.0)
+        for k in (10, 20, 40)
+            ∇θf = (θ,φ) -> -2k*sin(k*((sinpi(θ)*cospi(φ) - y[1])^2 + (sinpi(θ)*sinpi(φ) - y[2])^2 + (cospi(θ) - y[3])^2))*( (sinpi(θ)*cospi(φ) - y[1])*(cospi(θ)*cospi(φ)) + (sinpi(θ)*sinpi(φ) - y[2])*(cospi(θ)*sinpi(φ)) - (cospi(θ) - y[3])*sinpi(θ) )
+            ∇φf = (θ,φ) -> -2k*sin(k*((sinpi(θ)*cospi(φ) - y[1])^2 + (sinpi(θ)*sinpi(φ) - y[2])^2 + (cospi(θ) - y[3])^2))*( (sinpi(θ)*cospi(φ) - y[1])*(-sinpi(φ)) + (sinpi(θ)*sinpi(φ) - y[2])*(cospi(φ)) )
+            n = 12k
+
+            θ = (0.5:n-0.5)/n
+            φ = (0:2n-2)*2/(2n-1)
+            ∇θF = [∇θf(θ,φ) for θ in θ, φ in φ]
+            ∇φF = [∇φf(θ,φ) for θ in θ, φ in φ]
+            V1 = zero(∇θF)
+            V2 = zero(∇φF)
+            Pa = FastTransforms.plan_analysis(∇θF)
+            mul!(V1, V2, Pa, ∇θF, ∇φF)
+            P = SlowSphericalHarmonicPlan(V1)
+
+            U1 = zero(V1)
+            U2 = zero(V2)
+            At_mul_B!(U1, U2, P, V1, V2)
+
+            W1 = zero(U1)
+            W2 = zero(U2)
+
+            mul!(W1, W2, P, U1, U2)
+
+            Ps = FastTransforms.plan_synthesis(W1)
+
+            G1 = zero(∇θF)
+            G2 = zero(∇φF)
+
+            mul!(G1, G2, Ps, W1, W2)
+
+            @test vecnorm(∇θF - G1)/vecnorm(∇θF) < n*eps()
+            @test vecnorm(∇φF - G2)/vecnorm(∇φF) < n*eps()
+        end
+    end
+else
+    @testset "Test vector field transforms" begin
+        # f = (θ,φ) -> cospi(θ) + sinpi(θ)*(1+cospi(2θ))*sinpi(φ) + sinpi(θ)^5*(cospi(5φ)-sinpi(5φ))
+        n = 6
         θ = (0.5:n-0.5)/n
         φ = (0:2n-2)*2/(2n-1)
+        ∇θf = (θ,φ) -> -sinpi(θ) + (cospi(θ)*(1+cospi(2θ)) - 2*sinpi(θ)*sinpi(2θ))*sinpi(φ) + 5*sinpi(θ)^4*cospi(θ)*(cospi(5φ)-sinpi(5φ))
+        ∇φf = (θ,φ) -> (1+cospi(2θ))*cospi(φ) - 5*sinpi(θ)^4*(sinpi(5φ)+cospi(5φ))
+
         ∇θF = [∇θf(θ,φ) for θ in θ, φ in φ]
         ∇φF = [∇φf(θ,φ) for θ in θ, φ in φ]
         V1 = zero(∇θF)
@@ -54,7 +92,7 @@ using Compat.Test
 
         U1 = zero(V1)
         U2 = zero(V2)
-        FastTransforms.At_mul_B!(U1, U2, P, V1, V2)
+        mul!(U1, transpose(U2), P, V1, V2)
 
         W1 = zero(U1)
         W2 = zero(U2)
@@ -68,7 +106,43 @@ using Compat.Test
 
         mul!(G1, G2, Ps, W1, W2)
 
-        @test vecnorm(∇θF - G1)/vecnorm(∇θF) < n*eps()
-        @test vecnorm(∇φF - G2)/vecnorm(∇φF) < n*eps()
+        @test norm(∇θF - G1)/norm(∇θF) < n*eps()
+        @test norm(∇φF - G2)/norm(∇φF) < n*eps()
+
+        for k in (10, 20, 40)
+            y = (1.0, 2.0, 3.0)
+            n = 12k
+            θ = (0.5:n-0.5)/n
+            φ = (0:2n-2)*2/(2n-1)
+            ∇θf = (θ,φ) -> -2k*sin(k*((sinpi(θ)*cospi(φ) - y[1])^2 + (sinpi(θ)*sinpi(φ) - y[2])^2 + (cospi(θ) - y[3])^2))*( (sinpi(θ)*cospi(φ) - y[1])*(cospi(θ)*cospi(φ)) + (sinpi(θ)*sinpi(φ) - y[2])*(cospi(θ)*sinpi(φ)) - (cospi(θ) - y[3])*sinpi(θ) )
+            ∇φf = (θ,φ) -> -2k*sin(k*((sinpi(θ)*cospi(φ) - y[1])^2 + (sinpi(θ)*sinpi(φ) - y[2])^2 + (cospi(θ) - y[3])^2))*( (sinpi(θ)*cospi(φ) - y[1])*(-sinpi(φ)) + (sinpi(θ)*sinpi(φ) - y[2])*(cospi(φ)) )
+
+            ∇θF = [∇θf(θ,φ) for θ in θ, φ in φ]
+            ∇φF = [∇φf(θ,φ) for θ in θ, φ in φ]
+            V1 = zero(∇θF)
+            V2 = zero(∇φF)
+            Pa = FastTransforms.plan_analysis(∇θF)
+            mul!(V1, V2, Pa, ∇θF, ∇φF)
+            P = SlowSphericalHarmonicPlan(V1)
+
+            U1 = zero(V1)
+            U2 = zero(V2)
+            FastTransforms.mul!(U1, transpose(U2), P, V1, V2)
+
+            W1 = zero(U1)
+            W2 = zero(U2)
+
+            mul!(W1, W2, P, U1, U2)
+
+            Ps = FastTransforms.plan_synthesis(W1)
+
+            G1 = zero(∇θF)
+            G2 = zero(∇φF)
+
+            mul!(G1, G2, Ps, W1, W2)
+
+            @test norm(∇θF - G1)/norm(∇θF) < n*eps()
+            @test norm(∇φF - G2)/norm(∇φF) < n*eps()
+        end
     end
 end

test/toeplitztests.jl

@@ -1,27 +1,26 @@
-using FastTransforms
+using FastTransforms, ToeplitzMatrices
 
-@testset "BigFloat" begin
+@testset "BigFloat TOeplitz" begin
     T = Toeplitz(BigFloat[1,2,3,4,5], BigFloat[1,6,7,8,0])
     @test T*ones(BigFloat,5) ≈ [22,24,19,16,15]
 
-    n = 512
-    r = map(BigFloat,rand(n))
-    T = Toeplitz(r,[r[1];map(BigFloat,rand(n-1))])
-    @test T*ones(BigFloat,n) ≈ Matrix(T)*ones(BigFloat,n)
+    let n = 512
+        r = map(BigFloat,rand(n))
+        T = Toeplitz(r,[r[1];map(BigFloat,rand(n-1))])
+        @test T*ones(BigFloat,n) ≈ Matrix(T)*ones(BigFloat,n)
 
-    T = TriangularToeplitz(BigFloat[1,2,3,4,5],:L)
-    @test T*ones(BigFloat,5) ≈ Matrix(T)*ones(BigFloat,5)
+        T = TriangularToeplitz(BigFloat[1,2,3,4,5],:L)
+        @test T*ones(BigFloat,5) ≈ Matrix(T)*ones(BigFloat,5)
 
-    n = 512
-    r = map(BigFloat,rand(n))
-    T = TriangularToeplitz(r,:L)
-    @test T*ones(BigFloat,n) ≈ Matrix(T)*ones(BigFloat,n)
+        r = map(BigFloat,rand(n))
+        T = TriangularToeplitz(r,:L)
+        @test T*ones(BigFloat,n) ≈ Matrix(T)*ones(BigFloat,n)
 
-    T = TriangularToeplitz(BigFloat[1,2,3,4,5],:U)
-    @test T*ones(BigFloat,5) ≈ Matrix(T)*ones(BigFloat,5)
+        T = TriangularToeplitz(BigFloat[1,2,3,4,5],:U)
+        @test T*ones(BigFloat,5) ≈ Matrix(T)*ones(BigFloat,5)
 
-    n = 512
-    r = map(BigFloat,rand(n))
-    T = TriangularToeplitz(r,:U)
-    @test T*ones(BigFloat,n) ≈ Matrix(T)*ones(BigFloat,n)
+        r = map(BigFloat,rand(n))
+        T = TriangularToeplitz(r,:U)
+        @test T*ones(BigFloat,n) ≈ Matrix(T)*ones(BigFloat,n)
+    end
 end