Algoritmo Paramétrico

Origem: Wikipédia, a enciclopédia livre.

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 | editar código-fonte]

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 | editar código-fonte]

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 | editar código-fonte]

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 | editar código-fonte]

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 | editar código-fonte]

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 | editar código-fonte]