3.1.4 Aproximação de Funções — Interpolação — Interpolação de Hermite

1. Interpolação de Hermite

Seja a fórmula geral da interpolação

\( f(x) = \sum_{j=1}^{n} \sum_{i=0}^{m_j} A_{ij}(x) \frac{d^{(i)} f(a_j)}{d x^{(i)}} + E(x) \)

consideramos \(m_j = 1 \) para \(j = 1, \ldots, r \) , isto é, supomos que a primeira derivada também é uma função conhecida em \(r \) dos \(n \) pontos tabulares. Ou seja, a fórmula acima, quando desenvolvida até a primeira derivada, terá a forma

\( f(x) = \sum_{j=1}^{n} h_j(x) f(a_j) + \sum_{j=1}^{r} h_j'(x) f'(a_j) + E(x) \)

portanto, desprezando o erro da aproximação, temos \(y(x) \) interpolada por

\( y(x) = \sum_{j=1}^{n} h_{j_\alpha}(x) f(a_j) + \sum_{j=1}^{r} h_{j_\beta}(x) f'(a_j) \)

onde \(h_{j_\alpha}(x) \) e \(h_{j_\beta}(x) \) são polinômios. Novamente, usando o critério da aproximação exata, queremos minimizar o erro \(E(x) \) tal que \(E(a_j) = 0 \). Utilizando a interpolação de Lagrange, podemos utilizar as seguintes condições para satisfazerem \(h_{j_\alpha}(x) \) e \(h_{j_\beta}(x) \) :

\(p_n(x) = (x – a_1) \cdots (x – a_n) \)

\(p_r(x) = (x – a_1) \cdots (x – a_r) \)

\(l_{jn}(x) = \frac{p_n(x)}{ (x-a_j) p_n'(a_j)} \)

\( l_{jr}(x) = \frac{p_r(x)}{(x-a_j) p_r'(a_j)} \)

nestas condições, temos que \(h_j(x) \) é
\(
h_{j_\alpha}(x) = \left\{
\begin{array}{lcl}
t_j(x) l_{jn}(x) l_{jr}(x) & ~ & j = 1,\ldots ,r \\
l_{jn}(x) \frac{p_r(x)}{p_r(a_j)} & ~ & j = r + 1, \ldots, n
\end{array}
\right.
\)

onde \(t_j(x) \) é um polinômio de primeiro grau tal que \(h_{j_\alpha}(x) \) é de grau \(n+r-1 \) . Para satisfazer as condições de convergência, precisamos ter \(t_j(a_j) = 1 \) e \(t_j'(a_j) + l_{jn}'(a_j) + l_{jr}'(a_j) = 0 \) .

De maneira semelhante, fazemos para \(h_{j_\beta}(x) \) :

\(h_{j_\beta}(x) = s_j(x) l_{jr}(x) l_{jn}(x) \)

onde \(s_j(x) \) é um polinômio de primeiro grau com \(s_j(a_j) = 0 \) e \(s_j'(a_j) = 1 \) .

Tomando \(t_j(x) = 1 – (x – a_j)[l_{jn}'(a_j) + l_{jr}'(a_j)] \) e \(s_j(x) = x – a_j \) , temos que

\( h_{j_\alpha}(x) = \left\{
\begin{array}{lcl}
\left[ 1 – (x – a_j)[l_{jn}'(a_j) + l_{jr}'(a_j)] \right] l_{jn}(x)l_{jr}(x) & ~ & j = 1,\ldots ,r \\
l_{jn}(x) \frac{p_r(x)}{p_r(a_j)} & ~ & j = r + 1, \ldots, n
\end{array} \right| \)

e
\( h_{j_\beta}(x) = (x – a_j) l_{jr}(x) l_{jn}(x) \)

Ou seja, a Fórmula Interpoladora de Hermite é

\( f(x) = \sum_{j=1}^{n} h_{j_\alpha}(x) f(a_j) +
\sum_{j=1}^{n} h_{j_\beta}(x) f'(a_j)
\)

com \(h_{j_\alpha}(x) = \left[1 – 2 (x – a_j) l_j'(a_j)\right] l_j^2(x) \) e \(h_{j_\beta}(x) = (x – a_j) l_j^2(x) \) .

 

2. Implementação

def interpolation_hermite(x, x_j, f_j, diffF_j, n=0):
    """
    Return x evaluated in Hermite interpolation function.
 
    interpolation_hermite(x, x_j, f_j, diffF_j, n=0)
 
    INPUT:
      * x: evalue at this point
      * x_j: LIST, tabular points
      * f_j: LIST, tabular points (must be same size of x_j)
      * diffF_j: LIST, derivative points of x_j (f'(x_j))
      * n: polynomial degree (optional)
 
    return:
      * y(x): interpolated and evaluated x value
 
    Author: Pedro Garcia [sawp@sawp.com.br]
    see: http://www.sawp.com.br
 
    License: Creative Commons
             http://creativecommons.org/licenses/by-nc-nd/2.5/br/
 
    Dec 2010
    """
 
    if type(x_j) != type(f_j) or type(x_j) != type([]):
        print "Error: wrong type parameters"
        return float("NaN")
 
    if len(x_j) != len(f_j) or len(x_j) != len(diffF_j):
        print "Error: the tabular points must have same size"
        return float("NaN")
 
    if n < = 0:
        n = len(x_j)
    else:
        n = n + 1
 
    p = 0.0
    for j in xrange(n):
        # lagrange polinomial
        xj = x_j[j]
        ljn_num = 1.0
        ljn_den = 1.0
        for i in xrange(n):
            xi = x_j[i]
            if i != j:
                ljn_num *= (x - xi)
                ljn_den *= (xj - xi)
        ljn = ljn_num / ljn_den
 
        # hermite interpolation
        diff_ljn = 0
        for i in xrange(n):
            xi = x_j[i]
            if i != j:
                diff_ljn += 1.0 / (xj - xi)
 
        hjn = (1.0 - 2 * (x - xj) * diff_ljn) * (ljn * ljn)
        hjn_ = (x - xj) * (ljn * ljn)
        p += hjn * f_j[j] + hjn_ * diffF_j[j]
    return p

Esta função está disponível em http://www.sawp.com.br/code/interpolation/interpolation_hermite.py assim como um exemplo de como utilizá-la.

 

3. Copyright

Este documento é disponível sob a licença Creative Commons. As regras dos direitos de cópia deste conteúdo estão acessíveis em http://creativecommons.org/licenses/by-nc-nd/2.5/br/.

References

[1] Anthony Ralston and Philip Rabinowitz, A First Course in Numerical Analysis (2nd ed.), McGraw-Hill and Dover, (2001), 423-424.


[2] N.B Franco, Cálculo Numérico, Pearson Prentice Hall, (2006), 69.