Laboratório No. 02

Descrição:

Um polinômio é uma expressão matemática envolvendo uma soma de potências em uma ou mais variáveis multiplicadas por coeficientes. Um polinômio de apenas uma variável com coeficientes constantes, normalmente representado por p(x) ou q(x), é dado por:

a_n x^n + ... + a_2 x^2 + a_1 x + a_0

As parcelas individuais, com os coeficientes incluídos, são chamadas de monômios. A maior potência em um polinômio de uma variável é chamada ordem, ou grau.

A soma de dois polinômios é obtida pela soma de cada um dos coeficientes das variáveis de mesma potência. Assim, por exemplo,

(a_2 x^2 + a_1 x + a_0) + (b_1 x + b_0) = a_2 x^2 + (a_1+b_1) x + (a_0+b_0)

e tem ordem menor ou igual à maior ordem dos dois polinômios originais. De maneira similar, o produto de dois polinômios é obtido pela multiplicação termo a termo, e posterior combinação dos resultados, por exemplo:

(a_2 x^2 + a_1 x + a_0)*(b_1 x + b_0)
    = a_2 x^2 (b_1 x + b_0) + a_1 x (b_1 x + b_0) + a_0 (b_1 x + b_0)
    = a_2 b_1 x^3 + (a_2 b_0 + a_1 b_1) x^2 + (a_1 b_0 + a_0 b_1) x + a_0 b_0

e tem ordem igual a soma da ordem dos dois polinômios originais.

Objetivo:

O objetivo deste laboratório é implementar uma calculadora de notação pós-fixa para realizar algumas operações sobre polinômios de uma variável x.

Uma calculadora de notação pós-fixa para polinômios utiliza uma pilha para armazená-los. Entrar com um polinômio na calculadora faz com que ele seja empilhado. As operações sobre polinômios desempilham os argumentos da pilha e empilham os resultados.

Os comandos a ser disponibilizados pela a calculadora para o usuário são:

Implementação:

Esse labóratório consiste na implementação de duas bibliotecas: pilha.c e polinomios.c, para manipulação de pilhas e polinômios, respectivamente. Além do uso das duas bibliotecas para a implementação dos comandos da calculadora relacionados acima no arquivo comandos.c. O interpretador de comandos (principal.c) é fornecido na íntegra e não deve ser modificado.

pilha.c

A implementação da pilha deverá utilizar um vetor. Serão fornecidos um arquivo pilha.h e um arquivo pilha.c. O primeiro conterá a interface de manipulação de pilhas, com o conjunto de funções que podem ser chamadas por funções externas ao módulo, não é permitido modificar esse arquivo. O segundo arquivo deverá conter a implementação das funções indicadas, assim como a implementação de funções auxiliares que julgar necessárias. As descrições das funções encontram-se juntamente com os arquivos fornecidos.

Para que o módulo pilha seja uma estrutura de dados genérica o tipo empilhado é um apontador para void (ou informalmente, um apontador para "qualquer coisa"). Dessa forma o mesmo código de pilha poderia ser utilizada para outras aplicações sem nenhuma alteração. As funções também retornam void * e você precisa fazer uma conversão de tipos ("cast") para o tipo correto (assim como com as funções de alocação de memória, como malloc).

polinomios.c

De forma análoga você deverá implementar um módulo para criação e manipulação de polinômios de uma variável. No arquivo polinomios.h será fornecida a interface com os cabeçalhos das funções e você deverá implementar essas funções no arquivo polinomios.c com possivelmente alguma outra função auxiliar (se necessário). Novamente, não é permitido modificar o arquivo polinomios.h.

Os polinômios deverão ser implementados através de listas ligadas simples ordenadas em ordem decrescente dos expoentes. Cada nó da lista representa um monômio com coeficiente e expoente. Nenhum monômio com coeficiente zero deverá ser representado.

Por exemplo, o polinômio 5 x^4 + 12 x + 1 seria representado como:

   +---+---+---+    +---+----+---+    +---+---+---+
p: | 4 | 5 | --|--> | 1 | 12 | --|--> | 0 | 1 | / |
   +---+---+---+    +---+----+---+    +---+---+---+

comandos.c

No arquivo comandos.c estarão a implementação dos comandos da calculadora que foram descritos acima. Nas funções desse arquivo você deverá fazer uso da biblioteca de manipulação de pilhas e da biblioteca de manipulação de polinômios para implementar os comandos da calculadora. O comando [<<p(x)>>] para leitura de polinômios já é fornecido implementado.

Note que ao implementar as funções desse arquivo você não deve fazer uso de seu conhecimento de como é a estrutura interna da pilha ou de um polinômio, e deverá utilizar unicamente as funções fornecidas pelos módulos de manipulação de polinômios e de manipulação da pilha, que são disponibilizadas através dos arquivos .h.

Execução:

O programa principal (interpretador de comandos) lê os dados da entrada padrão, portanto para executar os testes a partir de um arquivo de entrada é necessário redirecionar o arquivo para a entrada padrão do programa e eventualmente redirecionar a saída padrão do programa para um arquivo. Assim:

./principal < arqN.in > arqN.out

O arquivo de saída arqN.out pode ser posteriormente comparado com o arquivo de resposta esperado (arqN.res) visualmente ou através do comando diff:

diff arqN.out arqN.res

Para esse laboratório, será fornecido também um arquivo Makefile para facilitar a compilação do programa e execução dos testes.

Entrada e saída:

A entrada do programa consiste em uma seqüência de comandos da calculadora de polinômios. Espaços em branco e comentários serão ignorados. Por exemplo, a seguinte entrada:

[10 x^2 - 1 x + 25]
[5 x^2 + 2 x - 25]
+
p
d
*
p
~
p
q

Gera a saída:

15 x^2 + x
225 x^4 + 30 x^3 + x^2
-225 x^4 - 30 x^3 - x^2

Testes:

Os testes estarão classificados em 4 grupos, que testam as funções em ordem crescente de dificuldade.

Grupo 1:
Testa os comandos de impressão (p, P e f) e conseqüentemente as funções de criação de polinômio e liberação de polinômios (polinomio_cria_nulo, polinomio_adiciona_monomio, polinomio_libera).
Grupo 2:
Além dos anteriores, testa os comandos de soma (+), subtração (-) e negativo (~) de polinômios, juntamente com as funções necessárias para implementação desses comandos.
Grupo 3:
Além dos anteriores, testa mais os comandos de manipulação da pilha (c, d e r).
Grupo 4:
Além dos anteriores, testa o comando de multiplicação (*) e funções necessárias para implementação do mesmo.

Observações adicionais:

  1. A soma de polinômios através das listas ordenadas de coeficientes deve seguir o paradigma de intercalação.
  2. Devem ser submetidos apenas os arquivos polinomios.c, pilha.c e comandos.c.
  3. A sua última submissão deve incluir todos os casos.
  4. O número máximo de submissões não pode passar de 20.