I'm quite sure Fun used to work on intervals in the complex domain. But now
f(x) = cos(x)
Fun(f, Interval(1.0+1.0im, 2.0+2.0im))throws the error
ERROR: MethodError: no method matching isless(::Complex{Float64}, ::Complex{Float64})
Closest candidates are:
isless(::Missing, ::Any) at missing.jl:66
isless(::InfiniteArrays.OrientedInfinity{Bool}, ::Number) at /.julia/packages/InfiniteArrays/Z4yap/src/Infinity.jl:145
isless(::Number, ::InfiniteArrays.OrientedInfinity{Bool}) at /.julia/packages/InfiniteArrays/Z4yap/src/Infinity.jl:144
...
Stacktrace:
[1] <(::Complex{Float64}, ::Complex{Float64}) at ./operators.jl:260
[2] >(::Complex{Float64}, ::Complex{Float64}) at ./operators.jl:286
[3] isempty(::Interval{:closed,:closed,Complex{Float64}}) at /.julia/packages/IntervalSets/xr34V/src/IntervalSets.jl:153
Hello, I was playing around with the poisson equation example and wonder if I could replace the RHS with something like . I tried to construct the RHS like this:
fx = KroneckerDelta()
fy = KroneckerDelta()
f = Fun((x,y) -> fx(x) * fy(y))But I got the error that ERROR: MethodError: no method matching isless(::Int64, ::Nothing). What is the proper way for me to do that? Thanks in advance!
Hello ! I would like to consider ApproxFun for the following problem: I have a N-L operator Phi: L_s -> L_s, where L_s is the set of continuous functions that goes exponentially fast to zero at speed s > 0, that is: x belongs to Ls if \sup{t \geq 0} |x(t)| e^{s t} < +oo. Moreover given x in L_s, Phi(x) is the solution of a Volterra integral equation of the form Phi(x)(t) = K_0(x)(t) + \int_0^t{K(x) (t, u)Phi(x) (u) du}, where the Kernels K_0(x) and K(x) are known explicitly in term of x. I would like to compute the spectrum of the Frechet differential of Phi at the point x = 0. Do you think it is possible to do that?
Let me know if the question is unclear... I do not have a background in numerical simulations. Thanks :)
and how to encode ?
Ok great! Looking forward to see that. The Volterra equation I am looking at appears in a neuroscience problem (see https://arxiv.org/abs/1810.08562) The dynamic of the mean-field network can be reduce to a N-L Volterra equation (see equations (7) and (8) of the paper). Btw the same problem can be solved numerically by looking at the associated PDE (see equation (3)) - but I am curious to know if more efficient numerically methods can be develop by specifically exploit this Volterra equation.
Clenshaw is implemented in PolynomialSpace.jl
May i ask may be not directly related to ApproxFun
I found FastAsyTransforms.m on github and wondered if such functionality is already available as julia code?
I looked at FastTransforms.jl but could not find something like a HankelTransform. Would you kindly direct?
May be SingularIntegralEquations.jl? But no idea how to start with it? Or other place?
I found FastAsyTransforms.m on github and wondered if such functionality is already available as julia code?
I looked at FastTransforms.jl but could not find something like a HankelTransform. Would you kindly direct?
May be SingularIntegralEquations.jl? But no idea how to start with it? Or other place?
I’m trying to implement something like this FAQ example,
S = Chebyshev(1..2);
p = points(S,20); # the default grid
v = exp.(p); # values at the default grid
f = Fun(S,ApproxFun.transform(S,v));but multi-variate (2D tensor Chebyshev will do). The canonical thing,
S = Chebyshev((1..2)^2)
p = points(S, 20)errors. Of course I could just construct the points via tensor products, but then I’m unsure how to use the ApproxFun.transform(S,v) correctly. Is this documented somewhere? Is there an example I can look at?
Basically, I just want to freeze the polynomial degree, rather than prescribe a solver tolerance.
I didn’t know about this family of points, readig up on it now, very very interesting...
No, but anything other than Chebyshev^2 will use a tensor grid. Padua points are nice because you don’t oversample, and the transform is a single one dimensional DCT (though as implemented we form a tensor product by filling with zeros and use the 2D DCT, which due to aliasing we can recover the coefficients)
There’s a Chebfun example describing it
If you comment out the lines after ## Multivariate in https://github.com/JuliaApproximation/ApproxFun.jl/blob/master/src/Spaces/Chebyshev/Chebyshev.jl it will go back to the default tensor version, probably a keyword would be appropriate here to allow switching
thanks for the suggestions
Though I’d probably still need
ApproxFun to evaluate the basis functions...
In general, I wonder whether a “manual mode” of
ApproxFun might be useful. I noticed e.g. that restricting the degree in \ rather than the tolerance throws warnings even if it is intended. By “manual mode” I mean non-adaptive.
The long term plan is to do “Manual mode” via https://github.com/JuliaApproximation/ContinuumArrays.jl. This will also support FEM (in fact @jagot has a package for splines building on ContinuumArrays.jl) and make it possible to use distributed memory.
I have a FEDVR package
But that is a bit limited at the moment, in that it only supports Dirichlet1 boundary conditions, since I've yet to fix the issue with restriction matrices (i.e. dropping the first and last basis functions)
I guess I don't really understand the support for Complex numbers in ApproxFun. If I try to evaluate a complex argument to a Fun(cos) then it returns zero if the imaginary part is non zero. Curiously, it will return a complex number with a correct real part if the imaginary part of the input is zero. Also, I can easily create Fun's with complex coefficients that will return a complex number when evaluating a real number, but again will return zero if the imaginary part is non-zero. Here are a few examples. (I believe all of these work in Chebfun, btw.)
julia (v1.2)> f = Fun(cos);
julia (v1.2)> f(.1)
0.9950041652780257
julia (v1.2)> f(.1 + .1im)
0.0
julia (v1.2)> f(.1 + .0im)
0.9950041652780257 + 0.0im
julia (v1.2)> g = Fun(Chebyshev(), randn(Complex{Float64}, 20));
julia (v1.2)> g(.1)
2.1013219596855888 - 0.11052912191219874im
julia (v1.2)> g(.1 + .1im)
0.0 + 0.0im
julia (v1.2)> cos(.1 + .1im)
0.9999833333373015 - 0.00999998888888977im
If you want to evaluate on a domain in the complex plane you can use say a
Circle or Segment
I’d be shocked if those work in Chebfun unless it is doing extrapolation which is numerically dangerous. But you can use
extrapolate(f,x) in ApproxFun if you wish
Thanks. I see your point. It does look, however, that Chebfun takes more of a "let the buyer beware" type of view. It looks like it will happily evaluate many complex args. As long as you are inside of the Bernstein ellipse, life is good. It will even plot the Bernstein ellipse as well. As you say, I can use extrapolate for those cases, but that does beg the question, is returning zero the best way to flag that error?