reactivate documenter and Coverage

Author: MikaelSlevinsky

.travis.yml

@@ -22,8 +22,5 @@ matrix:
 notifications:
   email: false
 after_success:
-  - julia -e 'cd(Pkg.dir("FastTransforms")); Pkg.add("Documenter"); include(joinpath("docs", "make.jl")); Pkg.add("Coverage"); using Coverage; Codecov.submit(Codecov.process_folder())'
-# uncomment the following lines to override the default test script
-#script:
-#  - if [[ -a .git/shallow ]]; then git fetch --unshallow; fi
-#  - julia -e 'Pkg.clone(pwd()); Pkg.build("FastTransforms"); Pkg.test("FastTransforms"; coverage=true)'
+  - julia -e 'using Pkg; cd(Pkg.dir("FastTransforms")); Pkg.add("Documenter"); include(joinpath("docs", "make.jl"))'
+  - julia -e 'using Pkg; cd(Pkg.dir("FastTransforms")); Pkg.add("Coverage"); using Coverage; Codecov.submit(Codecov.process_folder())'

docs/src/index.md

@@ -4,31 +4,13 @@
 
 `FastTransforms.jl` allows the user to conveniently work with orthogonal polynomials with degrees well into the millions.
 
-Transforms include conversion between Jacobi polynomial expansions, with Chebyshev, Legendre, and ultraspherical polynomial transforms as special cases. For the signal processor, all three types of nonuniform fast Fourier transforms available. As well, spherical harmonic transforms and transforms between orthogonal polynomials on the triangle allow for the efficient simulation of partial differential equations of evolution.
+This package provides a Julia wrapper for the [C library](https://github.com/MikaelSlevinsky/FastTransforms) of the same name. Additionally, all three types of nonuniform fast Fourier transforms available, as well as the Padua transform.
 
-Algorithms include methods based on asymptotic formulae to relate the transforms to a small number of fast Fourier transforms, matrix factorizations based on the Hadamard product, hierarchical matrix decompositions à la Fast Multipole Method, and the butterfly algorithm.
+## Fast orthogonal polynomial transforms
 
-## Fast Transforms
+For this documentation, please see the documentation for [FastTransforms](https://github.com/MikaelSlevinsky/FastTransforms). Most transforms have separate forward and inverse plans. In some instances, however, the inverse is in the sense of least-squares, and therefore only the forward transform is planned.
 
-```@docs
-leg2cheb
-```
-
-```@docs
-cheb2leg
-```
-
-```@docs
-cjt
-```
-
-```@docs
-icjt
-```
-
-```@docs
-jjt
-```
+## Nonuniform fast Fourier transforms
 
 ```@docs
 nufft1
@@ -58,66 +40,6 @@ paduatransform
 ipaduatransform
 ```
 
-```@docs
-sph2fourier
-```
-
-```@docs
-fourier2sph
-```
-
-## Planning The Fast Transforms
-
-Most transforms have separate forward and inverse plans. In some instances, however, the inverse is in the sense of least-squares, and therefore only the forward transform is planned.
-
-```@docs
-plan_leg2cheb
-```
-
-```@docs
-plan_cheb2leg
-```
-
-```@docs
-plan_cjt
-```
-
-```@docs
-plan_icjt
-```
-
-```@docs
-plan_nufft1
-```
-
-```@docs
-plan_nufft2
-```
-
-```@docs
-plan_nufft3
-```
-
-```@docs
-plan_inufft1
-```
-
-```@docs
-plan_inufft2
-```
-
-```@docs
-plan_paduatransform!
-```
-
-```@docs
-plan_ipaduatransform!
-```
-
-```@docs
-plan_sph2fourier
-```
-
 ## Other Exported Methods
 
 ```@docs
@@ -213,29 +135,3 @@ FastTransforms.chebyshevjacobimoments2
 ```@docs
 FastTransforms.chebyshevlogmoments2
 ```
-
-### Jacobi Polynomial Increment and Decrement Operators
-
-```@docs
-FastTransforms.incrementα!
-```
-
-```@docs
-FastTransforms.incrementβ!
-```
-
-```@docs
-FastTransforms.incrementαβ!
-```
-
-```@docs
-FastTransforms.decrementα!
-```
-
-```@docs
-FastTransforms.decrementβ!
-```
-
-```@docs
-FastTransforms.decrementαβ!
-```

test/libfasttransformstests.jl

@@ -6,83 +6,73 @@ FastTransforms.set_num_threads(ceil(Int, Base.Sys.CPU_THREADS/2))
     n = 64
     α, β, γ, δ, λ, μ = 0.1, 0.2, 0.3, 0.4, 0.5, 0.6
     for T in (Float32, Float64, BigFloat)
-        for (p1, p2) in ((plan_leg2cheb(T, n), plan_cheb2leg(T, n)),
-                          (plan_ultra2ultra(T, n, T(λ), T(μ)), plan_ultra2ultra(T, n, T(μ), T(λ))),
-                          (plan_jac2jac(T, n, T(α), T(β), T(γ), T(δ)), plan_jac2jac(T, n, T(γ), T(δ), T(α), T(β))),
-                          (plan_lag2lag(T, n, T(α), T(β)), plan_lag2lag(T, n, T(β), T(α))),
-                          (plan_jac2ultra(T, n, T(α), T(β), T(λ)), plan_ultra2jac(T, n, T(λ), T(α), T(β))),
-                          (plan_jac2cheb(T, n, T(α), T(β)), plan_cheb2jac(T, n, T(α), T(β))),
-                          (plan_ultra2cheb(T, n, T(λ)), plan_cheb2ultra(T, n, T(λ))))
-            Id = Matrix{T}(I, n, n)
+        Id = Matrix{T}(I, n, n)
+        for (p1, p2) in ((plan_leg2cheb(Id), plan_cheb2leg(Id)),
+                          (plan_ultra2ultra(Id, T(λ), T(μ)), plan_ultra2ultra(Id, T(μ), T(λ))),
+                          (plan_jac2jac(Id, T(α), T(β), T(γ), T(δ)), plan_jac2jac(Id, T(γ), T(δ), T(α), T(β))),
+                          (plan_lag2lag(Id, T(α), T(β)), plan_lag2lag(Id, T(β), T(α))),
+                          (plan_jac2ultra(Id, T(α), T(β), T(λ)), plan_ultra2jac(Id, T(λ), T(α), T(β))),
+                          (plan_jac2cheb(Id, T(α), T(β)), plan_cheb2jac(Id, T(α), T(β))),
+                          (plan_ultra2cheb(Id, T(λ)), plan_cheb2ultra(Id, T(λ))))
             P = deepcopy(Id)
-            lmul!(p1, P)
-            lmul!(p2, P)
+            Q = p1*P
+            P = p2*Q
             @test P ≈ Id
-            lmul!(p1, P)
-            lmul!(p1', P)
-            ldiv!(p1', P)
-            ldiv!(p1, P)
+            Q = p1*P
+            P = p1'Q
+            Q = p1'\P
+            P = p1\Q
             @test P ≈ Id
-            lmul!(p1, P)
-            lmul!(p1', P)
-            ldiv!(p1', P)
-            ldiv!(p1, P)
+            Q = p2*P
+            P = p2'Q
+            Q = p2'\P
+            P = p2\Q
             @test P ≈ Id
         end
     end
 
-    p = plan_sph2fourier(Float64, n)
-    ps = plan_sph_synthesis(Float64, n, 2n-1)
-    pa = plan_sph_analysis(Float64, n, 2n-1)
     A = sphones(Float64, n, 2n-1)
+    p = plan_sph2fourier(A)
+    ps = plan_sph_synthesis(A)
+    pa = plan_sph_analysis(A)
     B = copy(A)
-    lmul!(p, A)
-    lmul!(ps, A)
-    lmul!(pa, A)
-    ldiv!(p, A)
+    C = ps*(p*A)
+    A = p\(pa*C)
     @test A ≈ B
 
-    p = plan_sphv2fourier(Float64, n)
-    ps = plan_sphv_synthesis(Float64, n, 2n-1)
-    pa = plan_sphv_analysis(Float64, n, 2n-1)
     A = sphvones(Float64, n, 2n-1)
+    p = plan_sphv2fourier(A)
+    ps = plan_sphv_synthesis(A)
+    pa = plan_sphv_analysis(A)
     B = copy(A)
-    lmul!(p, A)
-    lmul!(ps, A)
-    lmul!(pa, A)
-    ldiv!(p, A)
+    C = ps*(p*A)
+    A = p\(pa*C)
     @test A ≈ B
 
-    p = plan_disk2cxf(Float64, n)
-    ps = plan_disk_synthesis(Float64, n, 4n-3)
-    pa = plan_disk_analysis(Float64, n, 4n-3)
     A = diskones(Float64, n, 4n-3)
+    p = plan_disk2cxf(A)
+    ps = plan_disk_synthesis(A)
+    pa = plan_disk_analysis(A)
     B = copy(A)
-    lmul!(p, A)
-    lmul!(ps, A)
-    lmul!(pa, A)
-    ldiv!(p, A)
+    C = ps*(p*A)
+    A = p\(pa*C)
     @test A ≈ B
 
-    p = plan_tri2cheb(Float64, n, α, β, γ)
-    ps = plan_tri_synthesis(Float64, n, n)
-    pa = plan_tri_analysis(Float64, n, n)
     A = triones(Float64, n, n)
+    p = plan_tri2cheb(A, α, β, γ)
+    ps = plan_tri_synthesis(A)
+    pa = plan_tri_analysis(A)
     B = copy(A)
-    lmul!(p, A)
-    lmul!(ps, A)
-    lmul!(pa, A)
-    ldiv!(p, A)
+    C = ps*(p*A)
+    A = p\(pa*C)
     @test A ≈ B
 
-    p = plan_tet2cheb(Float64, n, α, β, γ, δ)
-    ps = plan_tet_synthesis(Float64, n, n, n)
-    pa = plan_tet_analysis(Float64, n, n, n)
     A = tetones(Float64, n, n, n)
+    p = plan_tet2cheb(A, α, β, γ, δ)
+    ps = plan_tet_synthesis(A)
+    pa = plan_tet_analysis(A)
     B = copy(A)
-    lmul!(p, A)
-    lmul!(ps, A)
-    lmul!(pa, A)
-    ldiv!(p, A)
+    C = ps*(p*A)
+    A = p\(pa*C)
     @test A ≈ B
 end