What's inside InterpolatingFunction[{{1., 4.}}, <>]?

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.}},{DeveloperPackedArrayForm, {0, 1, 2, 3, 4}, {1., 2., 3., 4.}},
{Automatic}]
*)


What do those arguments mean?

-

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 DeveloperPackedArrayForm for
2D Hermite, BSplineFunction for 2D Spline
NDSolveFEMElementMesh 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["DifferentialEquationsInterpolatingFunctionAnatomy"]

-
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