AxisArray

[yakir12]

Could be mega cool if an interpolation of an AxisArray would allow for indexing as if it was an AxisArray.
So right now this works:

A = AxisArray(rand(length(22:2:60)), Axis{:time}(22s:2s:60s))
a = interpolate(A, BSpline(Constant()), OnCell())

but when indexing into a, I need to used standard indices, a[1:2], to get the values I'd get with A[22s..24s].

This functionality makes a lot of sense to me because the predictor variable is baked into the AxisArray, suppling the interpolation with everything it needs! This will also expand nicely into Images.jl's use of AxisArray and all the other packages (Plots probably)

[timholy]

Given that we have Scaled BSplines this is only a few lines of code. However, we don't want to make Interpolations depend on AxisArrays, nor the converse. Want to start a "glue" package that implements this?

[yakir12]

Sorry for the crazy talk but hear me out:

You're suggesting a glue package that would connect two packages (Interpolations.jl and AxisArrays.jl). PlotRecipes.jl takes this concept one step further and connects multiple packages to one single package (Plots.jl). But is there something we can do to facilitate the creation of these glue packages? Some kind of common API to help connect multiple packages to multiple package?

Back to earth, yea, some glue package between AxisArrays.jl and Interpolations.jl sounds good.

[tomasaschan]

I haven't been looking closely at the Julia space for quite some time (and I've never interacted with AxisArrays), but my spontaneous thought is that it should be possible to refactor scaled B-splines into something generic enough to accept an AxisArray without any glue packages. (IMO, the need for a glue package is a hint of a poorly designed model somewhere...)

The "magic" that makes scaled B-splines work happens here, in the coordlookup function. A glue package would probably define similar functions for other types, but a better solution to the problem would be to redesign that part of scaled B-splines to use some common concepts for a (mathematical) range of any type, and then just require that those concepts are implemented. For example, like this:

coordlookup(rng, x) = (x - start(rng)) / step(rng) + oneunit(eltype(rng))

There might be more efficient ways to do it for certain types of (again, mathematical) ranges, in which case either Interpolations.jl or the user who needs them can implement an optimized version specialized on that type, but now we just require that there is a start, a step and an eltype, which accurately represents the information we actually need: where the (mathematical) range starts, how much of it represents one grid cell on the unit grid of the underlying interpolation object, and the element type we index with (to enable correct promotion).

Then it would make sense that AxisArrays define the start, step and eltype methods (or whatever it is we need), and then it just works. No glue package :)

[timholy]

Conditional dependencies in Julia are still a work in progress: see Requires.jl---which is not "precompile-friendly"---and search the julia repo for "conditional dependency" issues.

Right now the safest approach is to create a new package that starts

using AxisArrays, Interpolations

and then adds any desired functionality.

[timholy]

@tlycken, amazing timing in our posts.

For AxisArrays, some of the challenges to a "generic" strategy are hinted at in JuliaArrays/AxisArrays.jl#58 and JuliaArrays/AxisArrays.jl#81. There is some unease about whether AxisArrays are "arrays with extra metadata" or "arrays that shouldn't be using integer indexing, but are right now."

[tomasaschan]

Ah. Well, as I said, I'm unfamiliar with the AxisArray concept, but I'd say this problem would fall into either of two categories:

• AxisArray is something that represents a mathematical range of some sort, with a defined start and end. In that case it should be possible to make it work with scaled B-splines without a glue package (the default implementation of coordlookup could assume a length equal to the interpolations object, to allow for continuous ranges etc too).

• AxisArray is not something that represents a mathematical range of any sort. In this case, I'm hesitant to what it would mean to scale a B-spline with it, and therefore it probably shouldn't be supported.

[timholy]

It would definitely be possible to do this, it's just that it's not obvious that you can shoehorn it into any of the concepts defined in Base (e.g., indices). Consequently, it seems you need an external concept. You're right that one could define a Coordlookup.jl package and then have both Interpolations and AxisArrays import it. That is a glue package, but at a lower level; that's probably a better design, come to think of it.