linear_interpn interpolação linear n-dimensional

## Seqüência de Chamamento

                vp = linear_interpn(xp1,xp2,..,xpn, x1,...,xn, v)
                vp = linear_interpn(xp1,xp2,..,xpn, x1,...,xn, v, out_mode)

## Parâmetros

xp1, xp2, .., xpn

  vetores de reais (ou matrizes) de mesmo tamanho

x1 ,x2, ..., xn

  vetores linhas estritamente crescentes (com pelo menos 2 elementos) definindo o grid de interpolação n-dimensional

v

  vetor (caso n=1), matriz (caso n=2) ou hipermatriz (caso n > 2) com valores da função subjacente interpolada nos pontos do grid.

out_mode

  (opcional) string definindo a avaliação fora do grid (extrapolação)

vp

  vetor ou matriz de mesmo tamanho que `xp1, ..., xpn`

## Descrição

Dado um grid n-dimensional definido pelos n vetores `x1 ,x2, ..., xn` eos valores `v` de uma função (aqui nomeada f) nos pontos do grid :

v(i1, i2,…, in) = f(x1(i1), x2(i2),…, xn(in))

esta função computa o interpolante linear de f do grid (chamado de s a partir daqui) nos pontos nos quais as coordenadas são definidas pelos vetores (ou matrizes) `xp1, xp2, ..., xpn` :

vp(i) = s(xp1(i), xp2(i), …, xpn(i))
or
vp(i,j) = s(xp1(i,j), xp2(i,j), …, xpn(i,j))

caso xpk sejam matrizes.

O parâmetro `out_mode` ajusta a regra para extrapolação: se notarmos Pi=(xp1(i),xp2(i),...,xpn(i)) , então `out_mode` define a regra de avaliação quando:

P(i) ∉ [x1(1), x1($)] × [x2(1), x2($)] × … × [xn(1), xn($)]

As escolhas são:

"by_zero"

  uma extrapolação por zero é feita

"by_nan"

  uma extrapolação por NaN

"C0"

  a extrapolação é definida como segue:

      s(P) = s(proj(P)) onde  proj(P) é o ponto mais próximo de P
                        localizado na fronteira do grid.

"natural"

  a extrapolação é feita usando o remendo n-linear mais próximo do ponto.

"periodic"

  `s` é estendido por periodicidade.

## Exemplos

    // exemplo 1 : interpolação linear 1d
    x = linspace(0,2*%pi,11);
    y = sin(x);
    xx = linspace(-2*%pi,4*%pi,400)';
    yy = linear_interpn(xx, x, y, "periodic");
    clf()
    plot2d(xx,yy,style=2)
    plot2d(x,y,style=-9, strf="000")
    xtitle("Interpolação linear de sin(x) com 11 pontos de interpolação")

    // exemplo 2 : interpolação bilinear
    n = 8;
    x = linspace(0,2*%pi,n); y = x;
    z = 2*sin(x')*sin(y);
    xx = linspace(0,2*%pi, 40);
    [xp,yp] = ndgrid(xx,xx);
    zp = linear_interpn(xp,yp, x, y, z);
    clf()
    plot3d(xx, xx, zp, flag=[2 6 4])
    [xg,yg] = ndgrid(x,x);
    param3d1(xg,yg, list(z,-9*ones(1,n)), flag=[0 0])
    xtitle("Interpolação bilinear de 2sin(x)sin(y)")
    legends("pontos de interpolação",-9,1)
    show_window()

    // exemplo 3 : interpolação bilinear e experimentação
    //             com todos os tipos de outmode
    nx = 20; ny = 30;
    x = linspace(0,1,nx);
    y = linspace(0,2, ny);
    [X,Y] = ndgrid(x,y);
    z = 0.4*cos(2*%pi*X).*cos(%pi*Y);
    nxp = 60 ; nyp = 120;
    xp = linspace(-0.5,1.5, nxp);
    yp = linspace(-0.5,2.5, nyp);
    [XP,YP] = ndgrid(xp,yp);
    zp1 = linear_interpn(XP, YP, x, y, z, "natural");
    zp2 = linear_interpn(XP, YP, x, y, z, "periodic");
    zp3 = linear_interpn(XP, YP, x, y, z, "C0");
    zp4 = linear_interpn(XP, YP, x, y, z, "by_zero");
    zp5 = linear_interpn(XP, YP, x, y, z, "by_nan");
    clf()
    subplot(2,3,1)
       plot3d(x, y, z, leg="x@y@z", flag = [2 4 4])
       xtitle("função inicial 0.4 cos(2 pi x) cos(pi y)")
    subplot(2,3,2)
       plot3d(xp, yp, zp1, leg="x@y@z", flag = [2 4 4])
       xtitle("Natural")
    subplot(2,3,3)
       plot3d(xp, yp, zp2, leg="x@y@z", flag = [2 4 4])
       xtitle("Periodic")
    subplot(2,3,4)
       plot3d(xp, yp, zp3, leg="x@y@z", flag = [2 4 4])
       xtitle("C0")
    subplot(2,3,5)
       plot3d(xp, yp, zp4, leg="x@y@z", flag = [2 4 4])
       xtitle("by_zero")
    subplot(2,3,6)
       plot3d(xp, yp, zp5, leg="x@y@z", flag = [2 4 4])
       xtitle("by_nan")
    show_window()

    // exemplo 4 : interpolação trilinear (ver ajuda de splin3d
    //             que tem os mesmos exemplos com
    //             interpolação por spline tricúbico)
    exec("SCI/modules/interpolation/demos/interp_demo.sci")
    func =  "v=(x-0.5).^2 + (y-0.5).^3 + (z-0.5).^2";
    deff("v=f(x,y,z)",func);
    n = 5;
    x = linspace(0,1,n); y=x; z=x;
    [X,Y,Z] = ndgrid(x,y,z);
    V = f(X,Y,Z);
    // computando (e exibindo) o interpolante linear em algumas fatias
    m = 41;
    dir = ["z="  "z="  "z="  "x="  "y="];
    val = [ 0.1   0.5   0.9   0.5   0.5];
    ebox = [0 1 0 1 0 1];

    XF=[]; YF=[]; ZF=[]; VF=[];
    for i = 1:length(val)
       [Xm,Xp,Ym,Yp,Zm,Zp] = slice_parallelepiped(dir(i), val(i), ebox, m, m, m);
       Vm = linear_interpn(Xm,Ym,Zm, x, y, z, V);
       [xf,yf,zf,vf] = nf3dq(Xm,Ym,Zm,Vm,1);
       XF = [XF xf]; YF = [YF yf]; ZF = [ZF zf]; VF = [VF vf];
       Vp =  linear_interpn(Xp,Yp,Zp, x, y, z, V);
       [xf,yf,zf,vf] = nf3dq(Xp,Yp,Zp,Vp,1);
       XF = [XF xf]; YF = [YF yf]; ZF = [ZF zf]; VF = [VF vf];
    end
    nb_col = 128;
    vmin = min(VF); vmax = max(VF);
    color = dsearch(VF,linspace(vmin,vmax,nb_col+1));
    clf()
    gcf().color_map = jetcolormap(nb_col);
    gca().hiddencolor = gca().background;
    colorbar(vmin,vmax)
    plot3d(XF, YF, list(ZF,color), flag=[-1 6 4])
    xtitle("Interpolação trilinear de"+func)
    show_window()

## Ver Também

- interpln
- splin
- splin2d
- splin3d