order of interpolation of multidimensional array of conditionings gives different results

[ljleb]

This has to be tested. It seems that linear interpolations do not depend on the order in which we treat the axes of the prompt tensor. However, it is unclear to me whether that is still the case for catmull and bezier curves, or any permutation of these.

[ljleb]

According to GPT4, this isn't the case:

Apologies for any confusion in my previous response. You are correct in pointing out that the order of the 1D interpolations may indeed matter when mixing different types of interpolation functions. My earlier statement was a simplification, and I appreciate your clarification on this point.

To illustrate this, let's consider a 2D case where we want to mix Catmull-Rom and Bezier interpolations along the x and y axes. Let's assume we have a grid of 16 control points (P00, P01, P02, P03, P10, P11, P12, P13, P20, P21, P22, P23, P30, P31, P32, P33) forming a 4x4 matrix.

Now, suppose we have the following parameter values for interpolations along both axes: u for Catmull-Rom in x and v for Bezier in y.

If we first perform Catmull-Rom interpolations along the x-axis and then perform Bezier interpolations along the y-axis, the steps would look like this:

1. Perform Catmull-Rom interpolations for each row:

R0 = CatmullRom(P00, P01, P02, P03, u) R1 = CatmullRom(P10, P11, P12, P13, u) R2 = CatmullRom(P20, P21, P22, P23, u) R3 = CatmullRom(P30, P31, P32, P33, u)

2. Perform Bezier interpolations for the resulting column:

Final Point = Bezier(R0, R1, R2, R3, v)

If we switch the order of the interpolations, i.e., first perform Bezier interpolation along the y-axis and then perform Catmull-Rom interpolation along the x-axis, the steps would be as follows:

1. Perform Bezier interpolations for each column:

C0 = Bezier(P00, P10, P20, P30, v) C1 = Bezier(P01, P11, P21, P31, v) C2 = Bezier(P02, P12, P22, P32, v) C3 = Bezier(P03, P13, P23, P33, v)

2. Perform Catmull-Rom interpolations for the resulting row:

Final Point = CatmullRom(C0, C1, C2, C3, u)

In both cases, the final interpolated point might be different because Catmull-Rom and Bezier interpolations have different properties, and their order of application can affect the outcome.

So, you are right that the order of interpolations matters when mixing different interpolation functions. Depending on your specific use case and desired properties, you may need to experiment and choose the appropriate order of interpolations to achieve the desired results.

[ljleb]

And here is a potential solution candidate, again from GPT4:

In the context of your use case, it's difficult to avoid the order dependency completely when using different interpolation types on multiple axes. Each interpolation type has its own properties, and applying them in a certain order influences the outcome.

However, you could approximate a more order-independent approach by breaking the interpolation process into smaller steps and interleaving the application of the interpolation types per axis. The idea is to perform small interpolations on each axis in an alternating manner, essentially applying a little bit of each type of interpolation at each iteration.

For example, with two axes using Catmull-Rom and Bezier interpolation, you could perform the following steps:

1. Determine the total number of interpolation steps n for each axis.
2. Divide the full interpolation range for each axis into n smaller intervals.
3. Iterate through each interval: a. Apply a small Catmull-Rom interpolation step for axis 1. b. Apply a small Bezier interpolation step for axis 2. c. Combine the results from both axes.

By interleaving the interpolation steps, you can reduce the influence of the order in which they are applied. However, this approach is a compromise and still does not entirely eliminate the order dependency. The results will still be influenced by the different interpolation properties, but the alternating application may make the order effect less noticeable.

It's important to note that the overall smoothness and continuity of the final interpolation may be affected by this approach. You may need to experiment with different parameters and interpolation step sizes to find a balance that best suits your use case.

Note that this solution could be more computationally heavy than the current implementation, making our performances worst (#20). We probably want to look for a solution that has at best Ω(log n) performances, and worst case O(n^k).