Mathematica Stack Exchange is a question and answer site for users of Mathematica. Join them; it only takes a minute:

Sign up
Here's how it works:
  1. Anybody can ask a question
  2. Anybody can answer
  3. The best answers are voted up and rise to the top

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

For example:

InputForm[Interpolation[{1., 2., 3., 4.}]]
    {{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.}}, 

What do those arguments mean?

share|improve this question
up vote 47 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:

    domain,                    (* or min/max of grid for each dimension          *)
        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:

share|improve this answer
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
something like Interpolation[data, InterpolationOrder -> 1, "ExtrapolationHandler" -> {(Indeterminate &), "WarningMessage" -> False}] - but this is experimental. – user21 Jul 10 '13 at 15:06
@ruebenko Thanks! That will be immensely useful and will save me a lot of unnecessary Piecewise or Ifs. – R. M. Jul 10 '13 at 15:12
In V10, the version number is now 5 and one can pass the argument "ElementMesh" to IFs that interpolate over an ElementMesh (e.g. when using FEM in NDSolve). Perhaps the bitfield meanings have changed. – Michael E2 Dec 17 '14 at 18:27
@R.M. One can also find method used to generate IF with InterpolationMethod argument. – mmal Oct 28 '15 at 23:49

Your Answer


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.