Merge branch 'registry' into development

.gitignore

@@ -0,0 +1,3 @@
+docs/build/*
+Manifest.toml
+*.log

.travis.yml

@@ -1,18 +1,29 @@
+
 language: julia
 os:
   - linux
   - osx
 julia:
+  - 1.1
   - nightly
-  - 1.0
 matrix:
     allow_failures:
         - julia: nightly
 notifications:
-    email: false
+  email: false
+
 before_script:
-    - cp test/Manifest.toml .
-    - julia -e "using Pkg; Pkg.instantiate()"
+  - julia --color=yes -e "using Pkg;Pkg.Registry.add(RegistrySpec(url=\"https://github.com/vincentcp/FrameFunRegistry\"));"
+  - julia --color=yes -e "using Pkg;Pkg.Registry.add(RegistrySpec(url=\"https://github.com/JuliaRegistries/General\"));"
+
 after_success:
-    - julia --project=coverage/ -e 'using Pkg; Pkg.instantiate()'
-    - julia --project=coverage/ coverage/coverage.jl
+  - julia --project=coverage/ --color=yes coverage/coverage.jl
+
+# jobs:
+#     include:
+#         - stage: "Documentation"
+#           julia: 1.1
+#           os: linux
+#           script:
+#             - julia --project=docs/ --color=yes docs/make.jl deploy
+#           after_success: skip

Project.toml

@@ -1,16 +1,16 @@
 name = "CompactTranslatesDict"
 uuid = "455b6770-8cd4-11e8-0457-dd6f5558b097"
 version = "0.0.0"
+
 [deps]
 BasisFunctions = "4343a256-5453-507d-8aad-01a9d7189916"
 CardinalBSplines = "87d49508-7ad8-11e8-0eda-cb6920b58870"
 DomainSets = "5b8099bc-c8ec-5219-889f-1d9e522a28bf"
 FFTW = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341"
+FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b"
 FrameFun = "bbafa164-4497-5d18-87cf-33e911f89480"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
+Reexport = "189a3867-3050-52da-a836-e630ba90ab69"
 
 [extras]
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
-
-[targets]
-test = ["Test"]

appveyor.yml

@@ -0,0 +1,44 @@
+environment:
+  matrix:
+  - julia_version: 1
+  - julia_version: nightly
+
+platform:
+  - x86 # 32-bit
+  - x64 # 64-bit
+
+# # Uncomment the following lines to allow failures on nightly julia
+# # (tests will run but not make your overall status red)
+matrix:
+   allow_failures:
+   - julia_version: nightly
+
+branches:
+  only:
+    - master
+    - /release-.*/
+
+notifications:
+  - provider: Email
+    on_build_success: false
+    on_build_failure: false
+    on_build_status_changed: false
+
+install:
+  - ps: iex ((new-object net.webclient).DownloadString("https://raw.githubusercontent.com/JuliaCI/Appveyor.jl/version-1/bin/install.ps1"))
+
+build_script:
+  - C:\julia\bin\julia --color=yes -e 'using Pkg;Pkg.Registry.add(RegistrySpec(url="https://github.com/vincentcp/FrameFunRegistry"));'
+  - C:\julia\bin\julia --color=yes -e 'using Pkg;Pkg.Registry.add(RegistrySpec(url="https://github.com/JuliaRegistries/General"));'
+  - echo "%JL_BUILD_SCRIPT%"
+  - C:\julia\bin\julia -e "%JL_BUILD_SCRIPT%"
+
+test_script:
+  - echo "%JL_TEST_SCRIPT%"
+  - C:\julia\bin\julia -e "%JL_TEST_SCRIPT%"
+
+# # Uncomment to support code coverage upload. Should only be enabled for packages
+# # which would have coverage gaps without running on Windows
+# on_success:
+#   - echo "%JL_CODECOV_SCRIPT%"
+#   - C:\julia\bin\julia -e "%JL_CODECOV_SCRIPT%"

coverage/coverage.jl

@@ -1,3 +1,6 @@
+using Pkg
+Pkg.instantiate()
+
 # Only run coverage from linux nightly build on travis.
 get(ENV, "TRAVIS_OS_NAME", "")       == "linux"   || exit()
 get(ENV, "TRAVIS_JULIA_VERSION", "") == "nightly" || exit()

src/CompactTranslatesDict.jl

@@ -1,18 +1,18 @@
 __precompile__()
 module CompactTranslatesDict
 
-using BasisFunctions, CardinalBSplines, DomainSets
+using BasisFunctions, CardinalBSplines, DomainSets, FillArrays
 using LinearAlgebra, FFTW
 
-import Base: ==, getindex, length, size, unsafe_getindex, checkbounds
+import Base: ==, getindex, length, size, unsafe_getindex, checkbounds, step
 
 # Dictionaries
 using BasisFunctions
 using BasisFunctions: ShiftedIndex, ShiftedIndexList, op_eltype, dense_evaluation_operator, Measure
 using BasisFunctions: UniformDiracCombMeasure, grid, default_gramoperator
 import BasisFunctions: hasmeasure, measure, gramoperator, innerproduct_native, mixedgramoperator
 import BasisFunctions: support, interpolation_grid, period
-import BasisFunctions: stepsize, approx_length
+import BasisFunctions: approx_length
 import BasisFunctions: transform_from_grid, transform_to_grid, hasgrid_transform, iscompatible
 import BasisFunctions: grid_evaluation_operator, unsafe_eval_element, similar_dictionary
 import BasisFunctions: matrix, apply!, adjoint, unsafe_wrap_operator, matrix!

src/dictionary/translates.jl

@@ -31,7 +31,7 @@ support(::CompactTranslationDict{T}) where T = UnitInterval{T}()
 
 support(b::CompactTranslationDict, idx) = support(b, native_index(b, idx))
 
-support(b::CompactTranslationDict{T}, idx::TransIndex) where {T} = periodize_interval(value(idx)*stepsize(b)+kernel_span(b), support(b))
+support(b::CompactTranslationDict{T}, idx::TransIndex) where {T} = periodize_interval(value(idx)*step(b)+kernel_span(b), support(b))
 
 function periodize_interval(indomain::AbstractInterval, outdomain::AbstractInterval)
     per = (supremum(outdomain) - infimum(outdomain))
@@ -50,13 +50,13 @@ end
 
 period(::CompactTranslationDict{T}) where T = T(1)
 
-stepsize(dict::CompactTranslationDict) = period(dict)/length(dict)
+step(dict::CompactTranslationDict) = period(dict)/length(dict)
 
 unsafe_eval_element(b::CompactTranslationDict, idxn::TransIndex, x::Real) =
-    eval_kernel(b, x-idxn*stepsize(b))
+    eval_kernel(b, x-idxn*step(b))
 
 function overlapping_elements(b::CompactTranslationDict, x::Real)
-   indices = ceil(Int, (x-supremum(support(b)))/stepsize(b)):floor(Int, (x-infimum(support(b)))/stepsize(b))
+   indices = ceil(Int, (x-supremum(support(b)))/step(b)):floor(Int, (x-infimum(support(b)))/step(b))
    Set(mod(i, length(b))+1 for i in indices)
 end
 
@@ -92,7 +92,7 @@ function isperiodic_compatible_grid(b::CompactTranslationDict, grid::AbstractEqu
     l1 > l2 && ((l2,l1) = (l1, l2))
     n = l2/l1
     nInt = round(Int, n)
-    (1+(infimum(support(b)) - leftendpoint(grid))≈1) && (1+(supremum(support(b)) - rightendpoint(grid))≈1) && (n≈nInt)
+    support(b)≈support(grid) && (n≈nInt)
 end
 
 approx_length(b::CompactTranslationDict, n::Int) = ceil(Int,n/length(b))*length(b)
@@ -144,12 +144,11 @@ measure(b::CompactTranslationDict{T}) where T = FourierMeasure{T}()
 gramoperator(dict::CompactTranslationDict, measure::FourierMeasure; options...) =
     _translatescirculantoperator(dict, measure)
 
-function gramoperator(dict::CompactTranslationDict, measure::UniformDiracCombMeasure; options...)
-    if isperiodic_compatible_grid(dict, grid(measure))
-        @show Matrix(BasisFunctions.default_mixedgramoperator_discretemeasure(dict, dict, measure; options...))
-        CirculantOperator(BasisFunctions.default_mixedgramoperator_discretemeasure(dict, dict, measure; options...))
+function gramoperator(dict::CompactTranslationDict, measure::BasisFunctions.DiscreteMeasure, grid::AbstractEquispacedGrid, weights::FillArrays.AbstractFill; options...)
+    if isperiodic_compatible_grid(dict, grid)
+        CirculantOperator(BasisFunctions.default_mixedgramoperator_discretemeasure(dict, dict, measure, grid, weights; options...))
     else
-        BasisFunctions.default_mixedgramoperator_discretemeasure(dict, dict, measure; options...)
+        BasisFunctions.default_mixedgramoperator_discretemeasure(dict, dict, measure, grid, weights; options...)
     end
 end
 

src/dictionary/translates_of_bsplines.jl

@@ -5,20 +5,20 @@ end
 
 # For the B spline with degree 1 (hat functions) the MidpointEquispacedGrid does not lead to evaluation_matrix that is non singular
 compatible_grid(b::DiffPeriodicBSplineBasis, grid::MidpointEquispacedGrid) = iseven(degree(b)) &&
-    (1+(infimum(support(b)) - leftendpoint(grid))≈1) && (1+(supremum(support(b)) - rightendpoint(grid))≈1) && (length(b)==length(grid))
+    suppport(b)≈support(grid) && (length(b)==length(grid))
 
 compatible_grid(b::DiffPeriodicBSplineBasis, grid::PeriodicEquispacedGrid) = isodd(degree(b)) &&
-    (1+(infimum(support(b)) - leftendpoint(grid))≈1) && (1+(supremum(support(b)) - rightendpoint(grid))≈1) && (length(b)==length(grid))
+    suppport(b)≈support(grid) && (length(b)==length(grid))
     # we use a PeriodicEquispacedGrid in stead
 
 interpolation_grid(b::DiffPeriodicBSplineBasis) = isodd(degree(b)) ?
     PeriodicEquispacedGrid(length(b), support(b)) :
     MidpointEquispacedGrid(length(b), support(b))
 
-kernel_span(b::DiffPeriodicBSplineBasis) = Interval(zero(domaintype(b)), stepsize(b)*convert(domaintype(b), degree(b)+1))
+kernel_span(b::DiffPeriodicBSplineBasis) = Interval(zero(domaintype(b)), step(b)*convert(domaintype(b), degree(b)+1))
 
 eval_kernel(b::DICT where DICT<:DiffPeriodicBSplineBasis{T,K,D}, x) where {T,K,D} =
-    (n = length(b); sqrt(T(n))*n^D*evaluate_periodic_Bspline_derivative(Val{K}(), Val{D}(), n*x, n, T))::T
+    (n = length(b); sqrt(T(n))*n^D*evaluate_periodic_Bspline_derivative(Val{K}(), Val{D}(), n*x, n, T))
 
 degree(b::DICT where DICT <: DiffPeriodicBSplineBasis{T,K} ) where {T,K} = K
 
@@ -85,9 +85,9 @@ BSplineTranslatesBasis{T,degree}(n::Int; scaled=true) where {T,degree} = BSpline
 
 
 eval_kernel(b::BSplineTranslatesBasis{T,K,true}, x) where {K,T} =
-    (n = length(b); sqrt(T(n))*evaluate_periodic_Bspline(Val{K}(), n*x, n, T))::T
+    (n = length(b); sqrt(T(n))*evaluate_periodic_Bspline(Val{K}(), n*x, n, T))
 eval_kernel(b::BSplineTranslatesBasis{T,K,false}, x) where {K,T} =
-    (n = length(b); evaluate_periodic_Bspline(Val{K}(), n*x, n, T))::T
+    (n = length(b); evaluate_periodic_Bspline(Val{K}(), n*x, n, T))
 
 scaled(b::BSplineTranslatesBasis{T,K,SCALED}) where {T,K,SCALED} = SCALED
 

test/test_bsplinetranslatedbasis.jl

@@ -5,8 +5,7 @@ function test_generic_periodicbsplinebasis(B,T)
     tol = sqrt(eps(real(T)))
     n = 5
     b = B(n,3, T)
-    @test leftendpoint(support(b)) == 0
-    @test rightendpoint(support(b))==1
+    @test support(b)≈UnitInterval{T}()
 
     @test length(b)==5
     @test CompactTranslatesDict.degree(b)==3
@@ -16,9 +15,9 @@ function test_generic_periodicbsplinebasis(B,T)
 
     @test instantiate(B, 4, Float16)==B(4,3,Float16)
     @test resize(b, 20)==B(20,CompactTranslatesDict.degree(b),T)
-    @test interpolation_grid(b)==PeriodicEquispacedGrid(n,0,1)
+    @test interpolation_grid(b)==PeriodicEquispacedGrid{T}(n,0,1)
     @test BasisFunctions.period(b)==T(1)
-    @test BasisFunctions.stepsize(b)==T(1//5)
+    @test step(b)==T(1//5)
 end
 
 function test_translatedbsplines(T)
@@ -142,10 +141,10 @@ end
 function test_bspline_orthogonality_orthonormality()
     B = BSplineTranslatesBasis(4,3)
     for m in [FourierMeasure(),
-                BasisFunctions.DiscreteMeasure(PeriodicEquispacedGrid(4,0,1)),
-                BasisFunctions.DiscreteMeasure(MidpointEquispacedGrid(4,0,1)),
-                BasisFunctions.DiscreteMeasure(PeriodicEquispacedGrid(8,0,1)),
-                BasisFunctions.DiscreteMeasure(MidpointEquispacedGrid(8,0,1))]
+                discretemeasure(PeriodicEquispacedGrid(4,0,1)),
+                discretemeasure(MidpointEquispacedGrid(4,0,1)),
+                discretemeasure(PeriodicEquispacedGrid(8,0,1)),
+                discretemeasure(MidpointEquispacedGrid(8,0,1))]
         @test BasisFunctions.unsafe_matrix(gramoperator(B, m)) isa Circulant
         test_orthogonality_orthonormality(B, false, false, m; overquad=10)
     end