Algoritmo Paramétrico

Um polinómio ou função polinomial é uma expressão sob a forma[1]

Qualquer polinómio é suscetível ao processo de divisão,

Querendo encontrar um binómio divisor do tipo , que devolva um quociente com um polinómio de grau inferior e resto zero, ou seja,

deve-se satisfazer o valor de de modo a que se obtenha a igualdade

Trabalhando com o segundo membro, desenvolve-se a expressão,

Como uma das parcelas é a multiplicar pelo polinómio , este sobre de grau,

Agrupando as incógnitas do mesmo grau,

Colocando as incógnitas em evidência,

Daqui, igualam-se os termos de igual ordem do primeiro e segundo membro da equação,

Igualando os coeficientes por ordem crescente,

Estas equações paramétricas mostram os coeficientes do polinómio quociente que satisfazem a condição inicial, , quando o polinómio dividendo, , é dividido por um binómio divisor na forma com resto zero. Como tende a ser um número inteiro (mas não necessariamente), o algoritmo paramétrico em oposição à regra de Ruffini permite logo selecionar quais os números inteiros, , que podem ser solução das equações paramétricas geradoras de , pois logo a primeira equação, , implica forçosamente um número inteiro, ou seja, um mínimo múltiplo comum com .

Este algoritmo permite verificar qual o valor de sem ter de completar todos os cálculos sobre os coeficientes, ao contrário da regra de Ruffini, bastando parar quando não se obtém um número inteiro. Pode-se também verificar que o coeficiente de maior grau do polinómio , é igual ao coeficiente de maior grau do polinómio , tal como esperado (verifica-se noutros métodos de divisão). Podemos ver também que como é um grau inferior a , o termo é igual a zero, pelo que a última equação paramétrica serve de controlo, já que o seu resultado tem de ser forçosamente nulo, .

Exemplos editar

Verifiquemos a seguinte equação polinomial:[2]  

O coeficiente   é  , então o valor de   poderá ser  . Verifiquemos,

   

Uma vez que   ou  , então o binómio divisor terá   e pode-ser verificar a seguinte igualdade em relação ao polinómio dividendo:  .


Seguindo com outro exemplo, podemos constatar que este algoritmo para procurar quocientes de resto zero (ou seja, raízes do polinómio dividendo) é mais pragmático e eficiente que a regra de Ruffini. Considerando a seguinte função,  

conhecendo as propriedades paramétricas do algoritmo, sendo  , então o binómio   terá um  . Verificando as soluções possíveis, encontramos

 Que devolve a solução  .


Embora trabalhoso, pois analiticamente há um conjunto de soluções possíveis que têm de ser verificadas, é possível logo à partida delimitar o intervalo de procura e excluir alguns pares que de outro modo teriam de ser verificados, neste caso  , que constituiriam 50% do esforço em análise.

Quanto maior o grau do polinómio,  , e maior o termo independente,  , maior tenderá a ser o esforço analítico, como em qualquer outro algoritmo de divisão polinomial.

Note-se que essa não é uma regra. O polinómio   tem um  . O polinómio   tem um  . Há uma dilatação do conjunto de soluções possíveis, mas não necessariamente do volume de cálculo.

Monómio do Resto editar

Uma propriedade que o algoritmo paramétrico devolve em oposição a outras ferramentas de divisão polinomial é o monómio do resto: enquanto os restantes algoritmos devolvem o monómio de menor grau, um coeficiente sem variável (ou  ), este devolve o monómio de maior grau, o coeficiente de  .

Repare-se que a procura por um monómio divisor que dê resto zero começa com a procura de um mínimo múltiplo comum do termo de menor grau do polinómio dividendo,  , mas o par   será sempre uma solução possível, já que devolverá sempre números inteiros, pelo que o coeficiente de maior grau do polinómio quociente,  , que é zero quando o resto é zero, não será nulo. Por exemplo, no polinómio anterior (B), cujo  , ao proceder ao algoritmo para  , irão obter-se coeficientes inteiros que não fornecerão um   nulo, já que o par   não é solução para resto zero. Assim, a igualdade que deu início ao algoritmo paramétrico  , que subentende resto zero, deve ser reescrita como

 

com um   relacionado ao coeficiente de maior grau do polinómio quociente,  . Quando é nulo, a equação (2) ganha a forma em (1). Deve-se então perceber que valor toma   quando é não nulo. Olhando para as equações paramétricas em (I), a primeira equação tem subentendida uma parcela nula e que não foi escrita, mas seguindo a sequência numérica das outras equações pode-se completar o padrão escrevendo  , com   quando procuramos quocientes de resto zero (que é o interesse deste algoritmo para divisão de polinómios). Então, a última parcela da equação paramétrica é o valor do resto, pelo que (2) se pode reescrever

 

Realizando o algoritmo para o polinómio (B) no conjunto   temos,

   

Polinómios Incompletos editar

Como seria de esperar, o algoritmo paramétrico mantém-se válido quando os polinómios têm coeficientes nulos e por conseguinte termos omissos. Segue-se exemplo,  

Como  , então  :

     

Neste caso houve um aumento do monómios, que pode ou não ser útil, mas nem sempre é assim e obtém-se uma simplificação, que é sempre desejada:  

Sendo  , logo  :

     

fracionário editar

O mesmo se dá com números fracionários, embora o trabalho da descoberta seja maior, como em qualquer método analítico não automatizado. Sendo  

Como  , então  , mas este conjunto não devolve um resto igual a zero, mas antes um  , pelo que não há solução com  . Procurando solução no conjunto dos números facionários,  , encontramos um   que devolve resto zero.

  

O algoritmo embora válido para  , a procura analítica pode ser exaustiva e não devolver uma solução mesmo quando ela exista, então deve-se recorrer a outros métodos de divisão polinomial ou a ferramentas gráficas, como o teorema do resto.

Exemplo de código fonte editar

import java.útil.Scanner;

public class Interpolation {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // Obter o número de pontos
        System.out.print("Digite o número de pontos: ");
        int n = scanner.nextInt();

        double[] x = new double[n];
        double[] y = new double[n];

        // Obter os pontos
        for (int i = 0; i < n; i++) {
            System.out.printf("Digite o ponto %d (x, y): ", i + 1);
            x[i] = scanner.nextDouble();
            y[i] = scanner.nextDouble();
        }

        // Obter o valor de x para o qual se deseja encontrar o valor de y
        System.out.print("Digite o valor de x para o qual deseja encontrar o valor de y: ");
        double xValue = scanner.nextDouble();

        // Calcular o valor de y usando o algoritmo paramétrico
        double yValue = 0;
        for (int i = 0; i < n; i++) {
            double term = y[i];
            for (int j = 0; j < n; j++) {
                if (i != j) {
                    term *= (xValue - x[j]) / (x[i] - x[j]);
                }
            }
            yValue += term;
        }

        // Exibir o resultado
        System.out.printf("O valor de y para x = %.2f é %.2f", xValue, yValue);

        scanner.close();
    }
}

Referências

  1. Marques, Rúben (8 de setembro de 2022). «Algoritmo Paramétrico.pdf» (em inglês). doi:10.6084/m9.figshare.21066304.v1. Consultado em 8 de setembro de 2022 
  2. Marques, Rúben. «Algoritmo Paramétrico». Consultado em 19 de setembro de 2022 

Ver também editar