by

Where communities thrive


  • Join over 1.5M+ people
  • Join over 100K+ communities
  • Free without limits
  • Create your own community
People
Repo info
Activity
    Stefanos Carlström
    @jagot
    Should all the other spaces also move to FunctionSpaces, or rather as (a) separate package(s)?
    Sheehan Olver
    @dlfivefifty
    FunctionSpaces.jl is for properties of spaces, ApproxFun.jl will be for properties of functions (e.g., expansions)
    Stefanos Carlström
    @jagot
    Yeah
    Sheehan Olver
    @dlfivefifty
    The question is what to do about operators
    Stefanos Carlström
    @jagot
    Yes, I wondered about that as well
    Sheehan Olver
    @dlfivefifty
    The long term goal is to separate the concept of Infinite matrices (as in JulaiArrays/InfiniteArrays.jl) from Operators.
    Stefanos Carlström
    @jagot
    Ok
    And there is no connection to LinearMaps anywhere?
    Sheehan Olver
    @dlfivefifty
    I think Operators should then "know" something about Fun as they are operators acting on functions, but the actual implementations of the underlying infinite matrices could live elsewhere
    Stefanos Carlström
    @jagot
    Yes
    Sheehan Olver
    @dlfivefifty
    LinearMaps.jl assumes that the operators act on vectors, here we want the flexibility to act on functions
    Stefanos Carlström
    @jagot
    True
    I have a kludge of a package (https://github.com/jagot/BlockMaps.jl) that I use to represent operators that are nearly block-diagonal
    Sheehan Olver
    @dlfivefifty
    Which gets turned into infinite linear systems (which no nothing about spaces, only infinite matrices and vectors)
    Stefanos Carlström
    @jagot
    They result from FEM treatment where you get full blocks with one-element overlaps between each block
    I wonder if that could be done more beautifully
    Sure. I was just thinking about if there is/would be a space working with the confluent hypergeometric functions
    Stefanos Carlström
    @jagot
    Stefanos Carlström
    @jagot
    Is AnyDomain going into Domains.jl as well?
    Sheehan Olver
    @dlfivefifty
    I don't think so: that needs to be refactored. FullPDETest.jl suffered a bit of version control neglect.
    On Tuesday let's discuss what an FEM analogue would be. That's a very different viewpoint from ApproxFun as one works with weak formulations, not operators.
    Stefanos Carlström
    @jagot
    Yes, I realized I have too many questions to work efficiently at the moment
    Sheehan Olver
    @dlfivefifty
    Domains.jl originated with @daanhb so some of the design is different. It also uses the term "Space" as things like R are Euclidean spaces. The analogue of AnyDomain() would be FullSpace{Any}().
    Some more thought should be put in to how to unify this notion of Space with ApproxFuns.
    Stefanos Carlström
    @jagot
    I see. I was also wondering, how I, if I knew a set of points x,y, would use transform to get the expansion coefficents, i.e. the best possible approximation/interpolation.
    Some notion on how to perform eigendecompositions of operators acting on a certain basis, should also be encoded. For e.g. BSplines, since the basis functions are not orthogonal, you have an overlap matrix and hence you have a generalized eigenvalue problem.
    Sheehan Olver
    @dlfivefifty
    Stefanos Carlström
    @jagot
    Maybe I do, but it seems that points then need to be attached to an existing Space.
    Ok, Vandermonde seems to be what I want
    Kirill Ignatiev
    @ikirill
    Is this supposed to work?
    julia> dot(Fun(), Fun())
    ERROR: StackOverflowError:
    Stacktrace:
     [1] dot(::Function, ::Function) at /Users/osx/buildbot/slave/package_osx64/build/usr/share/julia/stdlib/v1.0/LinearAlgebra/src/generic.jl:665 (repeats 39122 times)
     [2] top-level scope at none:0
    Sheehan Olver
    @dlfivefifty
    Can you file an issue?
    Kirill Ignatiev
    @ikirill
    Am I going crazy, or is there something wrong with transposes? JuliaApproximation/ApproxFun.jl#624
    Up there when I was solving the associated Legendre ODE:
    is there a way to get the diagonal operator whose entries are 1/sqrt(dot(psi[j], psi[k])), psi being the basis of a space?
    It would make the self-adjoint ODE actually have a symmetric matrix when solving the generalized eigenvalue problem, but I couldn't find this.
    Sheehan Olver
    @dlfivefifty
    It's just an operator that hasn't been added yet. Probably there should be a Normalized(Jacobi(1,1)) space and this done as a conversion operator.
    (Before you ask "why not always use normalized", its because the unnormalized versions have rational formulae which are much faster.)
    Mikael Slevinsky
    @MikaelSlevinsky
    I showed how to get a symmetric-definite + banded GEP for associated Legendre functions here (section 3.1 https://arxiv.org/abs/1711.07866). I have some ApproxFun-like code that I wrote to verify the correctness of the formulas, (but not the FMM speedup)
    Mikael Slevinsky
    @MikaelSlevinsky
    Sorry, that should say "one way" to get banded symmetry
    Ashton Bradley
    @AshtonSBradley
    if I have 2D cartesian grid data at a certain resolution, is there any way to make a high precision Chebychev interpolant using ApproxFun?
    Ashton Bradley
    @AshtonSBradley
    ah, I see a comment above that answers this!
    Soham Mukherjee
    @soham1112
    Hi, I was just trying out an example from https://github.com/JuliaApproximation/ApproxFunExamples/blob/master/PDEs/Rectangle%20PDEs.ipynb. When trying the example for solving the convection equation (see In[10]), I end up getting an error if I end up changing the interval for t, say, for example, from 0 .. 2 to 2 .. 3. ERROR: LoadError: LoadError: Cannot convert coefficients from Chebyshev(-1.0..1.0) to Chebyshev(-1.0..1.0)⊗ConstantSpace(Point(2.0))
    I don't understand why this should be giving an error, since I should be able to choose an arbitrary time-interval. Am I missing something?
    Sheehan Olver
    @dlfivefifty
    It’s using an embedding of a 1D interval in the 2D plane where the interval is assumed to be at t = 0. You can use a fully 2D version: u0 = Fun((x,_) -> ..., Chebyshev(-1.0..1.0)⊗ConstantSpace(Point(2.0)))
    Soham Mukherjee
    @soham1112
    Ah! I see. Thanks--that worked like a charm! However, I'm curious if there's a reason for this default behaviour?
    Mitko Georgiev
    @mitkoge
    Hi,
    i would like to ask a question about joined spaces
    I tried tzhe following
    using ApproxFun
    sp1= Chebyshev(0.0..50.0) ∪ Chebyshev(50.0..60.0)
    x1=Fun(sp1); g1 = Fun(exp(-x1^2),sp1)
    s1= sum(g1) #NaN
    sp2= Chebyshev(0.0..5.0) ∪ Chebyshev(5.0..60.0)
    x2=Fun(sp2); g2 = Fun(exp(-x2^2),sp2)
    s2= sum(g2) #0.8862269254527582
    i expected s1~= s2. but it seems it is not.