<?xml version="1.0" encoding="UTF-8"?>
<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink"
          xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns3="http://www.w3.org/1999/xhtml"
          xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org"
          xml:id="splin2d" xml:lang="pt">
    <refnamediv>
        <refname>splin2d</refname>
        <refpurpose>interpolação por spline bicúbico em grides 2d</refpurpose>
    </refnamediv>
    <refsynopsisdiv>
        <title>Seqüência de Chamamento</title>
        <synopsis>
            C = splin2d(x, y, z)
            C = splin2d(x, y, z, spline_type)
        </synopsis>
    </refsynopsisdiv>
    <refsection>
        <title>Parâmetros</title>
        <variablelist>
            <varlistentry>
                <term>x,y</term>
                <listitem>
                    <para>vetores linhas estritamente crescentes (com pelo menos dois
                        componentes) definindo o grid de interpolação
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>z</term>
                <listitem>
                    <para>nmatriz nx x ny (nx sendo o comprimento de
                        <literal>x</literal> e ny o comprimento de
                        <literal>y</literal>)
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>spline_type</term>
                <listitem>
                    <para>(opcional) um string selecionando o tipo de spline bicúbico a
                        ser computado
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>C</term>
                <listitem>
                    <para>um vetor grande com coeficientes dos elementos de área
                        bicúbicos (veja detalhes em "Observações")
                    </para>
                </listitem>
            </varlistentry>
        </variablelist>
    </refsection>
    <refsection>
        <title>Descrição</title>
        <para>Esta função computa um spline ou sub-spline bicúbico
            <emphasis>s</emphasis> que interpola os pontos
            <emphasis>(xi,yj,zij)</emphasis> i.e., temos
            <emphasis>s(xi,yj)=zij</emphasis> para todo <emphasis>i=1,..,nx</emphasis>
            e <emphasis>j=1,..,ny</emphasis>. O spline resultante s é definido pela
            tripla <literal>(x,y,C)</literal> onde <literal>C</literal> é o vetor (com
            comprimento 16(nx-1)(ny-1)) com os coeficientes de cada um dos
            (nx-1)(ny-1) elementos de área bicúbicos : em <emphasis>[x(i)
                x(i+1)]x[y(j) y(j+1)]
            </emphasis>
            ,<emphasis>s</emphasis> é definido por
            :
        </para>
        <para>
            <latex style="display" fontsize="18"
                   alt="s(x,y) = ∑_m=1→4 ∑_n=1→4 c_ij(m,n).(x-x_i)^{m-1}.(y-y_j)^{n-1}">
                s(x,y)=\sum_{k=1}^4\sum_{l=1}^4 c_{ij}(k,l)\cdot(x-x_i)^{k-1}\cdot(y-y_j)^{l-1}
            </latex>
        </para>
        <para>
            A avaliação de s em alguns pontos deve ser feita pela função
            <link linkend="interp2d">interp2d</link> Vários tipos de splines podem ser
            computados selecionando o parâmetro <literal>spline_type</literal>
            apropriado. O método usada para computar os splines (ou sub-spline)
            bicúbicos é o mesmo do antigo, i.e., computar em cada ponto do grid
            <emphasis>(xi,yj)</emphasis> uma aproximação das derivadas primeiras
            <emphasis>ds/dx(xi,yj)</emphasis> e <emphasis>ds/dy(xi,yj)</emphasis> e
            das derivadas cruzadas <emphasis>d2s/dxdy(xi,yj)</emphasis>. Estas
            derivadas são computadas pelo modo dos esquemas do spline 1d levando a uma
            função de classe C2 (s é duas vezes continuamente diferenciável) ou
            através de um esquema de aproximação local, levando a uma função de classe
            C1 apenas. Este esquema é selecionado através do parâmetro
            <literal>spline_type</literal> (ver <link linkend="splin">splin</link>
            para detalhes) :
        </para>
        <variablelist>
            <varlistentry>
                <term>"not_a_knot"</term>
                <listitem>
                    <para>é o caso padrão</para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>"periodic"</term>
                <listitem>
                    <para>usado se a função subjacente é periódica: deve-se ter
                        <emphasis>z(1,j) = z(nx,j) para todo j em [1,ny] e z(i,1) = z(i,ny)
                            para i em [1,nx]
                        </emphasis>
                        #mas isto não é verificado pela
                        interface.
                    </para>
                </listitem>
            </varlistentry>
        </variablelist>
    </refsection>
    <refsection>
        <title>Observações</title>
        <para>De um ponto de vista de precisão, use essencialmente o tipo
            <emphasis role="bold">not_a_knot</emphasis> ou <emphasis role="bold">periodic</emphasis> se a função interpolada subjacente é
            periódica.
        </para>
        <para>
            Os tipos <emphasis role="bold">natural</emphasis>, <emphasis role="bold">monotone</emphasis>, <emphasis role="bold">fast</emphasis> (ou
            <emphasis role="bold">fast_periodic</emphasis>) podem ser úteis em alguns
            casos, por exemplo para limitar oscilações (<emphasis role="bold">monotone</emphasis> é o mais poderoso para isso).
        </para>
        <para>Para obter coeficientes dos remendos bicúbicos de um modo mais
            amigável você pode usar <literal>c = matrix(C, [4,4,nx-1,ny-1])</literal>
            então o coeficiente <emphasis>(k,l)</emphasis> do remendo
            <emphasis>(i,j)</emphasis> (ver equação aqui antes) é armazenado em
            <literal>c(k,l,i,j)</literal>. Não obstante, a função <link linkend="interp2d">interp2d</link> espera pelo vetor grande
            <literal>C</literal> e não pela hipermatriz <literal>c</literal> (note que
            se pode recuperar facilmente <literal>C</literal> de <literal>c</literal>
            com <literal>C=c(:)</literal>).
        </para>
    </refsection>
    <refsection>
        <title>Exemplos</title>
        <programlisting role="example"><![CDATA[
// exemplo 1 : interpolação de cos(x)cos(y)
n = 7;  // um grid regular com n x n pontos de interpolação
        // será usado
x = linspace(0,2*%pi,n); y = x;
z = cos(x')*cos(y);
C = splin2d(x, y, z, "periodic");
m = 50; // parâmetro de discretização do grid de avaliação
xx = linspace(0,2*%pi,m); yy = xx;
[XX,YY] = ndgrid(xx,yy);
zz = interp2d(XX,YY, x, y, C);
emax = max(abs(zz - cos(xx')*cos(yy)));
clf()
plot3d(xx, yy, zz, flag=[2 4 4])
[X,Y] = ndgrid(x,y);
param3d1(X,Y,list(z,-9*ones(1,n)), flag=[0 0])
str = msprintf(" com %d x %d pontos de interpolação. ermax = %g",n,n,emax)
xtitle("Interpolação por spline de cos(x)cos(y)"+str)
     ]]></programlisting>
        <para/>
        <programlisting role="example"><![CDATA[
// exemplo 2 : diferentes funções de interpolação em dados aleatórios
n = 6;
x = linspace(0,1,n); y = x;
z = rand(n,n);
np = 50;
xp = linspace(0,1,np); yp = xp;
[XP, YP] = ndgrid(xp,yp);
ZP1 = interp2d(XP, YP, x, y, splin2d(x, y, z, "not_a_knot"));
ZP2 = linear_interpn(XP, YP, x, y, z);
ZP3 = interp2d(XP, YP, x, y, splin2d(x, y, z, "natural"));
ZP4 = interp2d(XP, YP, x, y, splin2d(x, y, z, "monotone"));
gcf().color_map = jet(64);
clf()
subplot(2,2,1)
plot3d1(xp, yp, ZP1, flag=[2 2 4])
xtitle("not_a_knot")
subplot(2,2,2)
plot3d1(xp, yp, ZP2, flag=[2 2 4])
xtitle("bilinear interpolation")
subplot(2,2,3)
plot3d1(xp, yp, ZP3, flag=[2 2 4])
xtitle("natural")
subplot(2,2,4)
plot3d1(xp, yp, ZP4, flag=[2 2 4])
xtitle("monotone")
     ]]></programlisting>
        <para/>
        <programlisting role="example"><![CDATA[
// exemplo 3 : spline not_a_knot e sub-spline monotone
//             em uma função de degraus
a = 0; b = 1; c = 0.25; d = 0.75;
// criando grid de interpolação
n = 11;
x = linspace(a,b,n);
ind = find(c &lt;= x &amp; x &lt;= d);
z = zeros(n,n); z(ind,ind) = 1;  // um degrau dentro de um quadrado
// criando grid de avaliação
np = 220;
xp = linspace(a,b, np);
[XP, YP] = ndgrid(xp, xp);
zp1 = interp2d(XP, YP, x, x, splin2d(x,x,z));
zp2 = interp2d(XP, YP, x, x, splin2d(x,x,z,"monotone"));
// plot
clf()
gcf().color_map = jet(128);
subplot(1,2,1)
plot3d1(xp, xp, zp1, flag=[-2 6 4])
xtitle("spline (not_a_knot)")
subplot(1,2,2)
plot3d1(xp, xp, zp2, flag=[-2 6 4])
xtitle("subspline (monotone)")
     ]]></programlisting>
    </refsection>
    <refsection role="see also">
        <title>Ver Também</title>
        <simplelist type="inline">
            <member>
                <link linkend="cshep2d">cshep2d</link>
            </member>
            <member>
                <link linkend="linear_interpn">linear_interpn</link>
            </member>
            <member>
                <link linkend="interp2d">interp2d</link>
            </member>
        </simplelist>
    </refsection>
</refentry>
