Escreva um algoritmo em Scilab, e copie o código na resposta, que forneça o polinômio de interpolação de Lagrange, dados os n+1 pontos fornecidos pelo usuário. O programa deverá perguntar para o usuário se ele vai entrar com a função ou com um vetor Y corresponde aos valores da função nos pontos. Se o usuário escolher entrar com a função, o programa deve reconhecer a função e calcular o vetor Y.

Passo 1

Beleza, o enunciado pede pra gente criar em Scilab um algoritmo que, dados n+1 pontos, gere o polinômio de interpolação de Lagrange. A parada envolve:
  • Ler n e o vetor de abscissas X (tamanho n+1).
  • Perguntar se o usuário vai entrar com uma função ou já tem um vetor Y.
  • Se ele der a função, a gente avalia ela nos pontos de X pra montar Y.
  • Montar o polinômio de Lagrange:
    P(x)=∑_{i=0}^n Y_i·ℓ_i(x), onde ℓ_i(x)=∏_{j≠i}(x−X_j)/(X_i−X_j).
  • Mostrar o vetor de coeficientes de P(x).
Matéria: Interpolação polinomial (Lagrange) e manipulação de vetores/polígonos em Scilab (conv, soma, escala).

Passo 2

Primeiro a gente lê n e X e pergunta o modo de entrada:
  1. Função: usuário digita algo tipo sin(x) ou x^2+3*x. Aí usamos evstr pra criar uma função f(x) e avaliamos Y(i)=f(X(i)).
  2. Vetor Y: ele já fornece o vetor pronto.
Isso garante que, a partir daqui, a gente tem sempre os vetores X e Y (ambos de tamanho n+1).

Passo 3

Agora vem a parte do polinômio de Lagrange. A ideia é:
Para cada índice i de 1 até n+1:
a) Montar o polinômio ℓ_i(x) = ∏_{j≠i} (x−X_j)/(X_i−X_j).
- Numerador: começamos com [1] (polinômio 1).
Para todo j≠i, fazemos Li = conv(Li, [1, -X(j)]).
- Denominador: produto escalar de (X(i)−X(j)).
- No fim, escalamos Li = Li/den.
b) Somamos ao polinômio total P = P + Y(i)*Li.
Esse processo usa teoria de polinômio base de Lagrange e funções de manipulação de polinômio (conv para multiplicar vetores-coeficiente) do Scilab.

Passo 4

Terminada a soma de todos os ℓ_i(x) ponderados por Y(i), o vetor P contém os coeficientes do polinômio final (da maior para a menor potência). Aí é só exibir P pra galera.

Resposta

/* Polinômio de Lagrange em Scilab */
clear;
disp("Interpolação de Lagrange em Scilab");

/* Passo 1: ler n e X */
n = input("Entre com o grau n (n+1 pontos): ");
X = input("Entre com o vetor X (1 x (n+1)): ");

/* Passo 2: escolher modo de entrada de Y */
modo = input("Digite 1 para entrar com função ou 2 para vetor Y: ");
if modo == 1 then
    s = input("Digite a função de x (ex.: sin(x)+x^2): ","string");
    evstr("function y=f(x); y="+s+"; endfunction");
    for i=1:n+1
        Y(i) = f(X(i));
    end
else
    Y = input("Entre com o vetor Y (1 x (n+1)): ");
end

/* Passo 3: montar polinômio de Lagrange */
P = 0;        // polinômio acumulado
for i=1:n+1
    Li = 1;   // numerador como polinômio
    den = 1;  // denominador escalar
    for j=1:n+1
        if j <> i then
            Li = conv(Li, [1, -X(j)]);       // (x - X(j))
            den = den * (X(i) - X(j));       // produto (X(i)-X(j))
        end
    end
    Li = Li / den;           // escalar
    P = P + Y(i) * Li;       // somar termo de Lagrange
end

/* Passo 4: exibir resultado */
disp("Coeficientes do polinômio interpolador P(x):");
disp(P);

Exercícios relacionados