PoliGauss - Gerador de Equações Polinomiais

Introdução e Conceitos Preliminares

Um dos assuntos que fazem parte da grade curricular do ensino médio são as equações polinomiais, que são equações que possuem a forma:

Exemplos:

O objetivo de PoliGauss é gerar aleatoriamente equações polinomiais fazendo uso das Relações de Girard.

Essas relações estabelecem a ligação entre os coeficientes da equação polinomial e suas raízes. Uma equação do segundo grau, por exemplo, com raízes reais r₁ e r₂ teria a seguinte forma:

Ou ainda,

Perceba que a constante 'k' permite um leque muito grande de equações equivalentes a original com mesmas raízes. Observe que, se a equação do segundo grau tiver a forma:

e suas raízes forem os números reais r₁ e r₁, então a relação entre os coeficientes a, b e c e as raízes seria:

Essas fórmulas são as Relações de Girard para as equações do segundo grau.

Para finalizar a parte teórica, segue as relações para equações do terceiro grau:

Seja a equação:

E sejam as raízes da equação:

As relações de Girard da equação serão:

Para maiores detalhes sobre as Relações de Girard e equações polinomiais, o leitor pode consultar a bibliografia no final da postagem.

O Algoritmo

Para gerar as equações o algoritmo realiza os seguintes passos:

1. Gerar números inteiros aleatórios entre -7 e7 conforme a quantidade de raízes da equação que será criada (segundo grau são duas raízes, terceiro grau são três raízes e assim por diante);
2. Gerar um número aleatório entre -3 e 3 (exceto zero) que será o coeficiente do termo de maior grau;
3. Usar “Relações de Girard” para calcular os coeficientes a partir as raízes geradas e multiplicar pelo coeficiente do termo de maior grau (gerado no passo anterior);
4. Distribuir em um vetor os coeficientes na ordem do coeficiente do termo de maior grau até o coeficiente do termo de menor grau e, em seguida, alocar nas últimas posições do vetor as raízes em qualquer ordem;
5. Retornar o vetor contendo os coeficientes e raízes.

Observe que esse algoritmo em momento algum resolve as equações polinomiais, pois o modo como foram usadas as Relações de Girard torna isso desnecessário.

Foi estabelecido o limite de gerar equações até o quinto grau e raízes de -7 a 7 para que os coeficientes da equação não ficassem muito grandes e o algoritmo torna-se viável para situações de aprendizado.

Implementações

Foram criadas duas versões de PoliGauss: uma em Java e outra em HTML com Javascript (vide fotos).

Em Java

HTML/Javascript

Quantidade de equações

A tabela abaixo mostra quantas equações PoliGauss é capaz de gerar:

Download

Clique no link a seguir para baixar a versão em Java: Poligauss (Java/JAR).

Clique no link a seguir para baixar a versão em HTML/JavaScript: Poligauss (HTML/JavaScript).

Clique no link a seguir para baixar o código fonte em Java: Poligauss (código fonte em Java).

Código Fonte em Java

A seguir, segue a implementação do algoritmo em Java (apenas para rápida referência)

import java.util.Random;

/*
 * Desenvolvido por Henrique Felipe
 * https://www.blogcyberini.com
 */

/*
 * A classe abaixo contém métodos que geram equações de segundo a quinto grau.
 * As equações são geradas aleatoriamente fazendo uso das 'Relações de Girard'.
 * Todos os métodos retornam vetores de números inteiros que armazenam, ordenadamente,
 * os coeficientes da equação seguidos das raízes
 */
public class PoliGauss {
    
   private static Random rnd = new Random();//gerador de números aleatórios
   
   /*
    * Gera equações do segundo grau
    */
    public static int[] segundoGrau() {
        int[] resp = new int[5];
        int a, s1, s2, x1, x2;     

        x1 = 7 - rnd.nextInt(15);
        x2 = 7 - rnd.nextInt(15);
        
        do{
            a = 3 - rnd.nextInt(7);
        }while(a == 0);
         
        s1 = - a * (x1 + x2);
        s2 = a * x1 * x2;
        
        resp[0] = a;
        resp[1] = s1;
        resp[2] = s2;
        resp[3] = x1;
        resp[4] = x2;
        
        return resp;
    }
    /*
    * Gera equações do terceiro grau
    */
    public static int[] terceiroGrau() {
        int[] resp = new int[7];
        int a, s1, s2, s3, x1, x2, x3;
        
        x1 = 7 - rnd.nextInt(15);
        x2 = 7 - rnd.nextInt(15);
        x3 = 7 - rnd.nextInt(15);
        
        do{
            a = 3 - rnd.nextInt(7);
        }while(a == 0);
        
        s1 = -a * (x1 + x2 + x3);
        s2 = a * (x1*x2 + x1*x3 + x2*x3);
        s3 = -a * x1 * x2 * x3;
        
        resp[0] = a;
        resp[1] = s1;
        resp[2] = s2;
        resp[3] = s3;
        resp[4] = x1;
        resp[5] = x2;
        resp[6] = x3;
        
        return resp;
    }
    /*
    * Gera equações do quarto grau
    */
    public static int[] quartoGrau() {
        int[] resp = new int[9];
        int a, s1, s2, s3, s4, x1, x2, x3, x4;
        
        x1 = 7 - rnd.nextInt(15);
        x2 = 7 - rnd.nextInt(15);
        x3 = 7 - rnd.nextInt(15);
        x4 = 7 - rnd.nextInt(15);
        
        do{
            a = 3 - rnd.nextInt(7);
        }while(a == 0);
        
        s1 = -a * (x1 + x2 + x3 + x4);
        s2 = a * (x1*x2 + x1*x3 + x1*x4 + x2*x3 + x2*x4 + x3*x4);
        s3 = -a * (x1*x2*x3 + x1*x3*x4 + x1*x2*x4 + x2*x3*x4);
        s4 = a * x1 * x2 * x3 * x4;
        
        resp[0] = a;
        resp[1] = s1;
        resp[2] = s2;
        resp[3] = s3;
        resp[4] = s4;
        resp[5] = x1;
        resp[6] = x2;
        resp[7] = x3;
        resp[8] = x4;
        
        return resp;
    }
    /*
    * Gera equações do quinto grau
    */
    public static int[] quintoGrau() {
        int[] resp = new int[11];
        int a, s1, s2, s3, s4, s5, x1, x2, x3, x4, x5;
        
        x1 = 7 - rnd.nextInt(15);
        x2 = 7 - rnd.nextInt(15);
        x3 = 7 - rnd.nextInt(15);
        x4 = 7 - rnd.nextInt(15);
        x5 = 7 - rnd.nextInt(15);
        
        do{
            a = 3 - rnd.nextInt(7);
        }while(a == 0);
        
        s1 = - a * (x1 + x2 + x3 + x4 +x5);
        s2 = a * (x1*x2 + x1*x3 + x1*x4 + x1*x5 + x2*x3 + x2*x4 + x2*x5 + x3*x4 + x3*x5 + x4*x5);
        s3 = -a * (x1*x2*x3 + x1*x3*x4 + x1*x2*x4 + x1*x4*x5 + x1*x2*x5 + x1*x3*x5
                  + x2*x3*x4+ x2*x3*x5 + x2*x4*x5 + x3*x4*x5);
        s4 = a * (x1*x2*x3*x4 + x1*x3*x4*x5 + x1*x2*x4*x5 + x1*x2*x3*x5 + x2*x3*x4*x5);
        s5 = - a * x1 * x2 * x3 * x4 * x5;
        
        resp[0] = a;
        resp[1] = s1;
        resp[2] = s2;
        resp[3] = s3;
        resp[4] = s4;
        resp[5] = s5;
        resp[6] = x1;
        resp[7] = x2;
        resp[8] = x3;
        resp[9] = x4;
        resp[10] = x5;
        
        return resp;
    }
}

Agradecimentos

Agradeço ao Aurélio Araújo (Sistemas de Informação - FAP/CE) que testou o algoritmo e deu sugestões de melhorias.

Referências

• [1] DANTE, Luiz Roberto. Matemática, volume único. 1ª edição. São Paulo: Ática, 2005.
• [2] IEZZI, Gelson. Fundamentos de Matemática Elementar, vol. 6: Complexos, Polinômios, Equações. São Paulo: Atual, 1977.

Observações

O nome "PoliGauss" é uma combinação de palavras envolvendo o nome do matemático Carl Friedrich Gauss.

Você pode utilizar a versão HTML/Javascript nesta página do blog: PoliGauss.