- Join over
**1.5M+ people** - Join over
**100K+ communities** - Free
**without limits** - Create
**your own community**

`imes`

\times

thank you.

```
using ApproxFun,LinearAlgebra
dm = Segment(0.001,1) × PeriodicSegment(-pi,pi)
sp = Space(dm)
Dr = Derivative(sp, [1,0]); Dθ = Derivative(sp, [0,1])
Mr = Multiplication(Fun( (r, θ) -> r, sp ), sp)
rDr = Mr * Dr
Lr = rDr * rDr; L = Lr + Dθ * Dθ
```

i modified it and now can play with.

Not sure whether this is the right place to ask since technically my question concerns SingularIntegralEquations.jl, but that package seems to be related enough to ApproxFun.jl that I'll go ahead anyway.

In the code of SingularIntegralEquations it says

```
# stieltjesintegral is an indefinite integral of stieltjes
# normalized so that there is no constant term
```

Can someone elaborate on that normalisation condition?

Sure, fine to ask here. This normalisation condition comes from the fact that Jacobi polynomials have nice integration formulae coming from the weighted differentiation

`d/dx[(1-x)^a *(1+x)^b P_n^(a,b)] = C (1-x)^{a-1} (1+x)^{b-1} P_{n+1}^(a-1,b-1)`

. Roughly speaking, for functions that vanish at ±1, derivatives and Stieltjes transforms commute, so provided `a,b > 0`

we can use this to write the integral of a Stieltjes transforms in terms of the integral of the integrand.
Note that the

`n = 0`

case is special, and dictates the normalisation constant (as the construction for other `n`

will automatically decay something like `O(z^(-n))`

)
For the cases actually implemented, I think its normalized to go to zero at ∞.

Sorry, that's not right.

You always have logarithmic growth (unless the integrand integrates to zero).

```
julia> f = exp(x) * sqrt(1-x^2);
julia> z = 10_000; stieltjesintegral(f,z) - log(z) * sum(f)
-4.264886882765495e-5
```

Oh, wait, that's true for other intervals too:

```
julia> x = Fun(1..2);
julia> f = exp(x) * sqrt((x-1)*(2-x));
julia> z = 100_000; stieltjesintegral(f,z) - log(z) * sum(f)
-2.8356239955229512e-5
```

Sorry for making it seem more complicated than it actually it is. It's really simple: it's normalized so that

`stieltjes(f,z) = log(z) *sum(f) + o(1)`

.
Which happens to be consistent with

`logkernel`

(whose normalization is imposed by the actual definition):```
julia> logkernel(f, z) -log(abs(z))/π * sum(f)
-9.026071512430178e-6
```

Hi i was playing with modified example from Quantum states.jl

```
Using ApproxFun
fc1 = Fun(1, 0..1); fc2 = Fun(2, 1..2); fc3 = Fun(3, 2..3)
fc= fc1+fc2+fc3
D = Derivative(); sp = space(fc); x= Fun(sp);
B = [Dirichlet(sp); continuity(sp,0:1)]
λ, v = ApproxFun.eigs(B, -D^2 + fc, 500,tolerance=1E-10)
#returns result
λ, v = ApproxFun.eigs(B, -D^2 - 1/x*D + fc, 500,tolerance=1E-10)
# says Not implemented but if fc=fc1+fc2 it manages to return result
```

Is 1/x*D kind of a problematic composition?

Note

`eigs`

is quite stale and needs to be rewritten, but that's low priority for me. I'll accept any PRs.
i followed you and copy paste defined

` function eigs(Bcs_in::Operator,A_in::Operator,fmul::Fun,n::Integer;tolerance::Float64=100eps())`

with the correction

` C = Conversion(ds,rangespace(A)); C = fmul * C`

now have only to check if it works correct. :-)

`λ, v = ApproxFun.eigs(B, L, x, 500,tolerance=1E-10)`

:point_up: 22. November 2018 12:35

I intendet to help with replacing it in the docs but as i see it is already fixed.

Unfortunately it might be not at http://juliaapproximation.github.io/ApproxFun.jl/latest

I intendet to help with replacing it in the docs but as i see it is already fixed.

Unfortunately it might be not at http://juliaapproximation.github.io/ApproxFun.jl/latest

is it possible to solve a nonlinear PDE in approxfun? for example I would like to add a simple nonlinear term to this problem

https://github.com/JuliaApproximation/ApproxFun.jl#solving-partial-differential-equations

, presumably switching to newton solver, but not sure how to inform it about boundary conditions etc in 2D

https://github.com/JuliaApproximation/ApproxFun.jl#solving-partial-differential-equations

, presumably switching to newton solver, but not sure how to inform it about boundary conditions etc in 2D

for the basic procedure of setting up for manual iteration, can I take it that this https://github.com/JuliaApproximation/ApproxFunExamples/blob/master/ODEs/Blasius%20and%20Falkner-Skan.jl

is a reasonable starting point, that I just need to generalise to 2D?

is a reasonable starting point, that I just need to generalise to 2D?

To get the Jacobian

```
x= Fun(0..1); sx=space(x);
a=Fun(0..pi); sa=space(a);
fa= DefiniteIntegral(x*a,sx)
# i expect fa= a here
```

but i get MethodError. Are integrals of two arguments possible?
to practice your guiding i wrote

```
function Hankel(fx::Fun, spx,spa::Space)
spxa= spx ⊗ spa
fx2= Fun((x,a)-> fx(x), spxa)
fj= Fun((x,a) -> besselj0(x*a), spxa)
fa2= (DefiniteIntegral(dmx1) ⊗ I)*(fx2*fj*x)
fa= Fun(a->fa2(0,a), spa)
end
```

from the definition. It seems to work. Thank you!

Is this the style ApproxFun is expected to be used?

Is this the style ApproxFun is expected to be used?

In Julia, capital letters are only used when it returns a special type of the same name. So this would be better as lower case. Also, there is support for Green's functions in https://github.com/JuliaApproximation/SingularIntegralEquations.jl including Helmholtz / hankel kernels

I see. I will check SpaceOperator and will have to learn what rangespace is.

And thank you for the link. It is probably some more efficient implementation? Will check it.

I tried hankel as an learning example.

The kind of high level style the ApproxFun works is fascinating me.

Like a poetry for the crowd. I do not necessarily understand but like it. :-)

And thank you for the link. It is probably some more efficient implementation? Will check it.

I tried hankel as an learning example.

The kind of high level style the ApproxFun works is fascinating me.

Like a poetry for the crowd. I do not necessarily understand but like it. :-)

when i blind try

```
spx= Space(0..1); spa= Space(0..π); spxa= spx ⊗ spa
Q2= DefiniteIntegral(spx.domain) ⊗ I
Q1= ApproxFun.SpaceOperator(Q2, spxa, spa )
x=Fun((x,a)->x,spxa); a=Fun((x,a)->a,spxa)
(Q2*(x*a))(0,1) #=0.5
(Q1*(x*a))(1) #=0.5*pi/2
```

it seems to work up to scaling cofficient