Take the 2-minute tour ×
Mathematica Stack Exchange is a question and answer site for users of Mathematica. It's 100% free, no registration required.

I'm curious what's inside the InterpolationFunction object?

For example:

InputForm[Interpolation[{1., 2., 3., 4.}]]
(*
  InterpolatingFunction[
    {{1., 4.}}, 
    {4, 7, 0, {4}, {4}, 0, 0, 0, 0, Automatic}, 
    {{1., 2., 3., 4.}},{Developer`PackedArrayForm, {0, 1, 2, 3, 4}, {1., 2., 3., 4.}}, 
    {Automatic}]
*)

What do those arguments mean?

share|improve this question
add comment

1 Answer

up vote 27 down vote accepted

From inspection, some investigation and ruebenko's help, what I've found so far is that InterpolatingFunction has the following underlying structure:

InterpolatingFunction[
    domain,                    (* or min/max of grid for each dimension          *)
    List[
        version,               (* 3 in Mathematica 7, 4 from 8 onwards           *)
        bitField,              (* 3 for exact/arbitrary precision
                                  7 for machine numbers, 15 for machine complex,
                                  39 for spline, 4259 for FEM elements. These are 
                                  for version 4, and are different for version 3.*)
        dataDerivatives,       (* Max order of derivatives supplied for input    *)
        domainGridSize,        (* or input sample points in each dimension       *)
        interpolationOrder,    (* actually, order + 1; for each dimension        *)
        nthDerivativeOfIntFun, (* Denotes if the current InterpolatingFunction is 
                                  an nth derivative of an existing Int. Func. and
                                  0 otherwise.                                   *)
        periodicInterpolation, (* 0 for False and {1} for True                   *)
        0, 0,                  (* One of the zeros is a permutation flag for 
                                  time-dependent InterpolatingFunction           *)
        Automatic              (* Extrapolation handler                          *)
    ],

    basicInterpolatingUnit,    (* This is setup such that it agrees with the input
                                   values at the input grid points. You might see 
                                  structures with Developer`PackedArrayForm for 
                                  2D Hermite, BSplineFunction for 2D Spline
                                  NDSolve`FEM`ElementMesh for 3D, or nothing.    *)
    Automatic                  (* Unknown                                        *)
]

You can access most of this internal data using the following arguments to any InterpolatingFunction object:

{"Domain", "Coordinates", "Grid", "ValuesOnGrid", "InterpolationOrder", "DerivativeOrder"}

See the contents of the following package for more information on what exactly the above arguments return:

SystemOpen@FindFile["DifferentialEquations`InterpolatingFunctionAnatomy`"]
share|improve this answer
7  
a few more: The fist unknown is the version. The typeInfo is bit field. The first Automatic is an extrapolation handler. One of the zeros before is a permutation flag for time dependent if. –  user21 Jul 10 '13 at 9:34
    
@ruebenko Thanks! Added to the list. Do you have an example of a time dependent IF? I don't think I've seen it. Also, is there a way one can set the extrapolation handler? –  rm -rf Jul 10 '13 at 13:46
4  
something like Interpolation[data, InterpolationOrder -> 1, "ExtrapolationHandler" -> {(Indeterminate &), "WarningMessage" -> False}] - but this is experimental. –  user21 Jul 10 '13 at 15:06
1  
@ruebenko Thanks! That will be immensely useful and will save me a lot of unnecessary Piecewise or Ifs. –  rm -rf Jul 10 '13 at 15:12
add comment

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.