a few deprecations

Author: daanhb

ext/BasisFunctionsRecipesBaseExt/BasisFunctionsRecipesBaseExt.jl

@@ -121,9 +121,7 @@ end
     seriestype --> :heatmap
     aspect_ratio --> 1
     colorbar --> false
-    # xrange = linspace(xlim[1],xlim[2],n)
     xrange = EquispacedGrid(n,xlim[1],xlim[2])
-    # yrange = linspace(ylim[1],ylim[2],n)
     yrange = EquispacedGrid(n,ylim[1],ylim[2])
     # grid = [SVector(i,j) for i in xrange , j in yrange]
     grid = xrange×yrange

src/bases/dictionary/basisfunction.jl

@@ -51,7 +51,7 @@ end
 dictionary(φ::BasisFunction) = φ.dictionary
 index(φ::BasisFunction) = φ.index
 
-support(φ::BasisFunction) = support(dictionary(φ), index(φ))
+support(φ::BasisFunction) = dict_support(dictionary(φ), index(φ))
 measure(φ::BasisFunction) = measure(dictionary(φ))
 
 show(io::IO, mime::MIME"text/plain", φ::BasisFunction) = composite_show(io, mime, φ)
@@ -104,15 +104,15 @@ innerproduct(f, ψ::AbstractBasisFunction, measure; options...) =
 # that leads to incomputable integrals.
 function analysis_integral(dict::Dictionary, idx, g, measure::Measure; options...)
     @boundscheck checkbounds(dict, idx)
-    domain1 = support(dict, idx)
+    domain1 = dict_support(dict, idx)
     domain2 = support(measure)
     qs = quadstrategy(promote_type(prectype(dict), prectype(measure)); options...)
     unsafe_analysis_integral1(dict, idx, g, measure, domain1, domain2, domain1 ∩ domain2, qs)
 end
 
 function analysis_integral(dict::Dictionary, idx, g, measure::DiscreteWeight; options...)
     @boundscheck checkbounds(dict, idx)
-    unsafe_analysis_integral2(dict, idx, g, measure, support(dict, idx))
+    unsafe_analysis_integral2(dict, idx, g, measure, dict_support(dict, idx))
 end
 
 # unsafe for indexing

src/bases/dictionary/dict_evaluation.jl

@@ -32,60 +32,22 @@ checkbounds(::Type{Bool}, dict::Dictionary, idx::NTuple{N,Int}) where {N} =
 @inline checkbounds(::Type{Bool}, dict::Dictionary, I...) = checkbounds_indices(Bool, axes(dict), I)
 
 "Return the support of the idx-th basis function. Default is support of the dictionary."
-function support(dict::Dictionary, idx)
+function dict_support(dict, idx)
+    checkdictionary(dict)
     checkbounds(dict, idx)
     support(dict)
 end
-# Warning: the functions above and below may be wrong for certain concrete
-# dictionaries, for example for univariate functions with non-connected support.
-# Make sure to override, and make sure that the overridden version is called.
-
 "Does the given point lie inside the support of the given function or dictionary?"
 in_support(dict::Dictionary, x) = dict_in_support(dict, x)
-in_support(dict::Dictionary, idx, x) = dict_in_support(dict, idx, x)
-
-# in_support(dict::Dictionary, x) =
-#     dict_in_support(dict, element_type_check(x, domaintype(dict)))
-# in_support(dict::Dictionary, idx, x) =
-#     dict_in_support(dict, idx, element_type_check(x, domaintype(dict)))
-#
-# element_type_check(x, T) = _element_type_check(x, T, typeof(x))
-# _element_type_check(x, T, S) = _element_type_check(x, T, S, promote_type(S,T))
-# _element_type_check(x, T, S, V) = x
-# _element_type_check(x, T, S, V) = x
-# function _element_type_check(x, T, S, ::Type{Any})
-#     @warn "Dictionary with domain type $(T) may not support evaluation with type $(S)."
-#     x
-# end
-#
-# # Some special cases
-# _element_type_check(x, ::NTuple{N,T}, ::SVector{N,T}) where {T,N} = x
-# _element_type_check(x, ::SVector{N,T}, ::NTuple{N,T}) where {T,N} = x
-
-
-# The mechanism is as follows:
-# - in_support(dict::Dictionary, ...) calls dict_in_support
-# - any linear index is converted to a native index
-# - concrete dictionary should implement dict_in_support
-# The reasoning is that concrete dictionaries need not all worry about handling
-# linear indices. Yet, they are free to implement other types of indices.
-# If a more efficient algorithm is available for linear indices, then the concrete
-# dictionary can still intercept the call to in_support.
-# The delegation to a method with a different name (dict_in_support) makes it
-# substantially easier to deal with ambiguity errors.
-
-# This is the standard conversion to a native_index for an index of type
-# Int. This calls a different function, hence it is fine if the native
-# index happens to be a linear index (Int).
-in_support(dict::Dictionary, idx::Int, x) =
-    dict_in_support(dict, native_index(dict, idx), x)
-
-# The default fallback is implemented below in terms of the support of the dictionary:
-dict_in_support(dict::Dictionary, idx, x) = default_in_support(dict, idx, x)
-dict_in_support(dict::Dictionary, x) = default_in_support(dict, x)
-
-default_in_support(dict::Dictionary, idx, x) = approx_in(x, support(dict, idx), tolerance(dict))
-default_in_support(dict::Dictionary, x) = approx_in(x, support(dict), tolerance(dict))
+in_support(dict::Dictionary, idx, x) = dict_in_support(dict, native_index(dict, idx), x)
+
+# Concrete types can override this if there is a more efficient implementation
+dict_in_support(dict, x) = default_in_support(dict, x)
+dict_in_support(dict, idx, x) = default_in_support(dict, idx, x)
+
+# by default we invoke the support of the dictionary
+default_in_support(dict, x) = approx_in(x, support(dict), tolerance(dict))
+default_in_support(dict, idx, x) = approx_in(x, dict_support(dict, idx), tolerance(dict))
 
 
 

src/bases/dictionary/dict_moments.jl

@@ -8,23 +8,29 @@
 Compute the moment of the given basisfunction, i.e. the integral on its
 support.
 """
-function moment(dict::Dictionary1d, idx; options...)
+function dict_moment(dict, idx; options...)
+    checkdictionary(dict)
     @boundscheck checkbounds(dict, idx)
-    unsafe_moment(dict, native_index(dict, idx); options...)
+    unsafe_dict_moment(dict, native_index(dict, idx); options...)
 end
 
-# This routine is called after the boundscheck. Call another function,
-# default moment, so that unsafe_moment of the concrete dictionary can still
-# fall back to `default_moment` as well for some values of the index.
-unsafe_moment(dict::Dictionary, idx; options...) = default_moment(dict, idx; options...)
+# This routine is called after the boundscheck.
+unsafe_dict_moment(dict::Dictionary, idx; options...) = default_dict_moment(dict, idx; options...)
 
 # Default to numerical integration
-default_moment(dict::Dictionary, idx; measure = lebesguemeasure(support(dict)), options...) =
+default_dict_moment(dict::Dictionary, idx; measure = lebesguemeasure(support(dict)), options...) =
     innerproduct(dict[idx], x->1, measure; options...)
 
-dict_norm(dict, idx) = dict_norm(dict, idx, measure(dict))
 
+"""
+    dict_norm(dict, idx[, μ])
+
+Compute the norm of the given basisfunction of the given dictionary,
+with respect to the given measure.
+"""
 function dict_norm(dict, idx, μ::Measure)
+    checkdictionary(dict)
     @boundscheck checkbounds(dict, idx)
     sqrt(innerproduct(dict, idx, dict, idx, μ))
 end
+dict_norm(dict, idx) = dict_norm(dict, idx, measure(dict))

src/bases/dictionary/dictionary.jl

@@ -29,6 +29,13 @@ of the features for a description of that interface and the syntax.
 abstract type Dictionary{S,T}
 end
 
+"Does the given argument implement the dictionary interface?"
+isdictionary(d::Dictionary) = true
+isdictionary(d) = false
+
+"Throws an error if the given argument does not implement the dictionary interface."
+checkdictionary(d) = isdictionary(d) || throw(ArgumentError("Not a dictionary: $(d)"))
+
 # Useful abstraction for special cases
 const Dictionary1d{S <: Number,T} = Dictionary{S,T}
 # Warning: these are shaky definitions of multivariate functions

src/bases/dictionary/expansions.jl

@@ -40,7 +40,7 @@ const Expansion4d{S <: Number,T,D,C} = Expansion{SVector{4,S},T,D,C}
                                 ncomponents,
                                 measure
 
-@forward Expansion.coefficients length, eachindex, getindex, setindex!
+@forward Expansion.coefficients length, eachindex
 codomaintype(e::Expansion) = promote_type(codomaintype(dictionary(e)), eltype(coefficients(e)))
 isreal(e::Expansion) = isreal(e.dictionary) && isreal(eltype(coefficients(e)))
 
@@ -207,12 +207,3 @@ expansion_of_one(dict::Dictionary) = Expansion(dict, coefficients_of_one(dict))
 expansion_of_x(dict::Dictionary) = Expansion(dict, coefficients_of_x(dict))
 
 apply(op::DictionaryOperator, e::Expansion) = Expansion(dest(op), op * coefficients(e))
-
-# TODO: we may not want to identify an Expansion with its array of coefficients
-iterate(e::Expansion) = iterate(coefficients(e))
-iterate(e::Expansion, state) = iterate(coefficients(e), state)
-
-Base.collect(e::Expansion) = coefficients(e)
-
-Base.BroadcastStyle(e::Expansion) = Base.Broadcast.DefaultArrayStyle{dimension(e)}()
-

src/bases/dictionary/orthog.jl

@@ -47,8 +47,8 @@ end
 function default_dict_innerproduct(Φ1::Dictionary, i, Φ2::Dictionary, j, measure::Measure; options...)
 	@boundscheck checkbounds(Φ1, i)
 	@boundscheck checkbounds(Φ2, j)
-    domain1 = support(Φ1, i)
-    domain2 = support(Φ2, j)
+    domain1 = dict_support(Φ1, i)
+    domain2 = dict_support(Φ2, j)
     domain3 = support(measure)
 
 	# This code is delicate: it is necessary when using basis functions with compact
@@ -74,8 +74,8 @@ safe_default_dict_innerproduct(Φ1::Dictionary, i, Φ2::Dictionary, j, measure::
 function default_dict_innerproduct(Φ1::Dictionary, i, Φ2::Dictionary, j, measure::DiscreteWeight; options...)
 	@boundscheck checkbounds(Φ1, i)
 	@boundscheck checkbounds(Φ2, j)
-    domain1 = support(Φ1, i)
-    domain2 = support(Φ2, j)
+    domain1 = dict_support(Φ1, i)
+    domain2 = dict_support(Φ2, j)
     unsafe_default_dict_innerproduct2(Φ1, i, Φ2, j, measure, domain1 ∩ domain2)
 end
 

src/bases/modifiers/mapped_dict.jl

@@ -127,7 +127,7 @@ end
 
 support(dict::MappedDict) = DomainSets.map_domain(forward_map(dict), support(superdict(dict)))
 
-support(dict::MappedDict, idx) = forward_map(dict).(support(superdict(dict), idx))
+dict_support(dict::MappedDict, idx) = forward_map(dict).(dict_support(superdict(dict), idx))
 
 function dict_in_support(set::MappedDict, idx, y, threshold = default_threshold(y))
     x = leftinverse(forward_map(set), y)

src/bases/modifiers/operated_dict.jl

@@ -94,9 +94,9 @@ for op in (:support, :length)
     @eval $op(s::OperatedDict) = $op(src(s))
 end
 
-function support(Φ::OperatedDict, idx)
+function dict_support(Φ::OperatedDict, idx)
 	if isdiag(operator(Φ))
-		support(src(Φ), idx)
+		dict_support(src(Φ), idx)
 	else
 		# We don't know in general what the support of a specific basis function is.
 		# The safe option is to return the support of the set itself for each element.

src/bases/modifiers/piecewise_dict.jl

@@ -18,7 +18,7 @@ end
 
 # Make a PiecewiseDict by scaling one set to each of the elements of the partition
 function PiecewiseDict(set::Dictionary1d, partition::Partition, n = ones(Int,length(partition))*length(set))
-    dicts = [rescale(resize(set, n[i]), support(partition, i)) for i in 1:length(partition)]
+    dicts = [rescale(resize(set, n[i]), partition_support(partition, i)) for i in 1:length(partition)]
     PiecewiseDict(dicts, partition)
 end
 
@@ -46,7 +46,7 @@ function PiecewiseDict(dicts::Array{S}) where {S <: Dictionary1d}
 end
 
 function PiecewiseDict(set::Dictionary, partition::Partition)
-     dicts = [rescale(set, support(partition, i)) for i in 1:length(partition)]
+    dicts = [rescale(set, dict_support(partition, i)) for i in 1:length(partition)]
     PiecewiseDict(dicts, partition)
 end
 
@@ -127,7 +127,7 @@ split_interval(set::PiecewiseDict, x) = split_interval(set, partition_index(part
 
 function split_interval(set::PiecewiseDict, i::Int, x)
     part = partition(set)
-    @assert infimum(support(part, i)) < x < supremum(support(part, i))
+    @assert infimum(partition_support(part, i)) < x < supremum(partition_support(part, i))
 
     part2 = split_interval(part, i, x)
     two_sets = split_interval(component(set, i), x)