MaplePrimes - answers and comments on Question, Function from numbers

ArrayInterpolation

pagan — Tue, 07 Feb 2012 22:25:12 Z

Using a 2-d variant of this post, you can construct a procedure that will take a scalar and return the interpolated value.

restart:

# independent data
indep := Vector([260., 270., 280., 290., 300., 310., 320., 330., 340., 350., 360.]):

# number of independent data points
numindeppts := LinearAlgebra:-Dimension(indep):

# some made up dependent data
dep := Vector(numindeppts, (i)->evalf(sin(indep[i]^2)), datatype=float[8]):

# procedure which interpolates the data, on the fly
B := (a) -> CurveFitting:-ArrayInterpolation(
                               indep, Array(dep),
                               Array(1..1, 1..1, [[a]]),
                               'method' = 'spline')[1]:

ptsplot:=plots:-pointplot(Matrix(11,2,[[indep,dep]])):

plots:-display(plot(B,min(indep)..max(indep)),ptsplot);

Output option.

Jarekkk — Tue, 07 Feb 2012 22:34:03 Z

You might find useful the output option of the dsolve command. Setting 'output'= piecewise could be what you're looking for.

Exactly!

ABond — Wed, 08 Feb 2012 14:49:03 Z

Thanks a lot, this is exactly what I have been looking for

nice

pagan — Wed, 08 Feb 2012 20:12:09 Z

Good point!

The attached worksheet has a comparison of two techniques. I was worried that doing many evaluations of a large piecewise would be relatively expensive. But the initial dsolve/numeric calculation take the bulk of the time.

I'm only do plots because I wanted to show timing for doing many subsequent computations using the results. It's not supposed to be seen as an alternative to DEplot or odeplot.

The output=piecewise is just easier to use. And there's not need to try and guess what kind of resolution is needed, unlike for the output=Array approach. (Presumably, the level of detail in the piecewise comes from dsolve/numeric's own cleverness about choosing step-sizes adaptively, and then forming piecewise interpolating polynomials.)

dscomp.mw

@pagan Right; However both variants do not

ABond — Tue, 14 Feb 2012 14:54:39 Z

@pagan Right;

However both variants do not solve my problem, since I need the analytical form of the function explictly as function of time.

To this end the piecewise option is better, but since I use this function in further computatios this does not help either.

I think I should proceed with polynomila interpolation of a solution structure given as an Array.

Hopefully this will give me some polynomial and not piecewise function, which may be then will be simpler...

order

pagan — Tue, 14 Feb 2012 20:25:20 Z

@ABond Obtaining a single polynomial is not necessary for doing mosts sorts of further computation. And for many data points it would likely be either a poor approximation low order polynomial, or a high order polynomial that fits the many points by has far too many qualitatively unwanted inflections.

The piecewise polynomial returned diretcly from dsolve/numeric is effective. The degrees of the pieces is based on the interpolants used by the solver for each time step (ie. accurate, and reasonably compact). Typical degrees would reflect whether you'd used rkf45 or dverk78, etc (that's what those numbers in the name mean). The ArrayInterpolation apporach would use something like degree 3 pieces (but the querying process would act more like a black box).

In both cases discussed, interpolation is being set up for you, with degree not too high (which is good). And as I showed in the worksheet attached above, both can be used to obtain a procedure which take a float input x to a float output y. You can integrate that procedure with evalf/Int, you can plot it, you can Optimize is, you can numerically diferentiate it ith evalf/D, and you can use it in subequent dsolve/numeric computations by using the `known=` option.

Why do you think that you need to see the explicit algebraic form of such an interpolating procedure? For what exact purpose?