juliaapproximation / framefun.jl Goto Github PK

For Framefun approximation in 2D:

1. Are the default sampling points equispaced points in a cartesian grid? Taking the 'disk with a hole' in README.md as an example, how can I know/retrieve the actual sampling points?

2. Is it possible to construct a 2D Framefun approximant by giving the ctor a set of sampling points and discrete data of a same size (as function values at these points)?

3. Is the construction adaptive in 2D?

Currently, FrameFun has a field approx_op which is the approximation operators used to construct the FrameFun or, more precisely, the other field expansion. I totally understand that this might be of a historic issue - you folks just wanted to keep the information for a while, as they're not dirt cheap to acquire and it is pretty useful for any debugging work. However, this causes some troubles for the users.

1. As a user whose work is built on the top of FrameFuns, if I try to construct a FrameFun not from scratch but from another FrameFun directly (e.g FrameFun x 2), I generally don't have a sensible approx_op to supply to the constructor. However, as far as I understand, I can't construct an object with some fields missing in Julia. I'm also unable to supply something like void to the constructor, since Julia does not have a “null” value. This makes personally assembled FrameFuns almost impossible without providing a place holder, i.e. a dummy approx_op.
2. The field approx_op costs a lot in memory. So I guess it drags the speed in some degree. But I have no benchmark to justify this.

Shall we consider to get rid of approx_op at all? Comments?

Is it possible to have an automatic framefun constructor which is able to construct a framefun with a reasonably optimal length n for a given function handle? I mean something similar to the chebfun constructor which keeps increasing the length of the approximation until the function is "fully resolved".

I had a vague impression that @daanhb mentioned that the Fourier extension coefficients are not necessarily decaying, which prevents an automatic construction. But I checked with a few examples and found that the Fourier extension coefficients are indeed getting smaller and smaller as the frequency goes higher and higher. Any comments?

It'll be nice if we can have such an auto-ctor. But, of course, even if it is possible to have such a thing, I'm not suggesting this should be something default at the user level.

@JuliaRegistrator register

Following the commands suggested in an example on the website--using BasisFunctions, Plots, DomainSets, FrameFun
gr(), I have the following compile errors:

WARNING: Method definition *(ToeplitzMatrices.Circulant{T1<:Real, S} where S<:Number, ToeplitzMatrices.Circulant{T2<:Real, S} where S<:Number) where {T1<:Real, T2<:Real} in module ToeplitzMatrices at.....

WARNING: could not import BasisFunctions.stepsize into FrameFun
WARNING: could not import BasisFunctions.dualdictionary into FrameFun
WARNING: could not import BasisFunctions.quadraturenormalization into FrameFun
WARNING: Method definition convert(Type{Tuple{Vararg{Int64, N}}}, Base.IteratorsMD.CartesianIndex{N}) where {N} in module GridArrays at /Users/ronchan/.julia/packages/GridArrays/60TtN/src/subgrid/maskedsubgrid.jl:35 overwritten in module FrameFun at /Users/ronchan/.julia/packages/FrameFun/c2GQe/src/sampling/subgrid.jl:32.
** incremental compilation may be fatally broken for this module **

I have no clue what I have done wrong when I installed all the packages needed for running the example code. Currently, my revision of Julia is 1.5 and pretty sure that I have installed FrameFun perfectly via the command suggested on the website.

Would be great if you could shed some light to resolve my problem?

Hi!

First of all: Thanks a lot for making your code available :)

I want to implement 1D Fourier-extension of some functions and came across this library last week. I did a fresh install of Julia and the FrameFun, BasisFunctions and DomainSets packages. The first thing I did was to run the example code from the front-page (I run it as a script from the command-line):

gr();

B = Fourier(61) → -1..1
D = -0.5..0.5
f = x->x
F = Fun(f,B,D)
                                                                                                                                                                    
plot(F,layout = 2)

p = plot!(F,f,subplot=2)
display(p)
readline()

However, contrary to the plot on the front-page, the resulting function is only plotted in the inner interval, see figure attached.

I did the following to get the approximation on the whole interval:

gr();

B = Fourier(61) → -1..1
D = -0.5..0.5
f = x->x
F_ = Fun(f, B, D)
F = expansion(B, F_.coefficients)

plot(F,layout = 2)
p = plot!(F,f,subplot=2)
display(p)
readline()

with the result

This looks better, but it is not the same result as I see on the front-page.

What do I need to change?

Hi,

Is it possible to make this example work with ChebyshevT ? Right now, it seems you cannot square differentiation_operator(B)?

Thank you

This issue is used to trigger TagBot; feel free to unsubscribe.

If you haven't already, you should update your TagBot.yml to include issue comment triggers.
Please see this post on Discourse for instructions and more details.

If you'd like for me to do this for you, comment TagBot fix on this issue.
I'll open a PR within a few hours, please be patient!

Make a frame which consists of a union of finitely many frames. The resulting space is a sum of the spaces.

Currently, FrameFuns and BasisFunctions are not compatible with Julia 0.5, and importing them fails.