Ejemplo n.º 1
0
/* Retorna o polinômio de nome x. */
Polinomio RecuperaPolinomio(char x) {
	if (!Operando(&x)) {
		IMPRIME_ERRO(MSG_ERRO_NOME_INVALIDO);
	} else if (vetorPoli[x - 'A'] == NULL) {
		IMPRIME_ERRO(MSG_ERRO_POLINOMIO_NAO_INICIALIZADO);
	}

	return vetorPoli[x - 'A'];
}
Ejemplo n.º 2
0
/* Desempilha um elemento, enviando uma mensagem de erro caso a pilha esteja
 * vazia.
 */
ElemPilha* VerificaDesempilha(Pilha* pilha) {
	if (PilhaVazia(pilha)) {
		IMPRIME_ERRO(MSG_ERRO_FALTA_OPERANDO);
	}

	return (ElemPilha*) Desempilha(pilha);
}
Ejemplo n.º 3
0
/* Armazena o polinômio 'p' sob o nome 'x' na base. */
void ArmazenaPolinomio(char x, Polinomio p) {
	if (!Operando(&x)) {
		IMPRIME_ERRO(MSG_ERRO_NOME_INVALIDO);
	}

	vetorPoli[x - 'A'] = p;
}
Ejemplo n.º 4
0
Polinomio RecuperaPolinomio(char x) {
/* Retorna o polinômio de nome x.                                        */
  Polinomio poli;
  x = toupper(x);
  if (x >= 'A' && x < 'A' + TAM_BASE) 
    poli =  vetorPoli[x - 'A'];
  else {
    IMPRIME_ERRO(MSG_ERRO_NOME_INVALIDO);
    return NULL;
  }
  
  if (poli == NULL)
    IMPRIME_ERRO(MSG_ERRO_POLINOMIO_NAO_INICIALIZADO);

  return poli;
}
Ejemplo n.º 5
0
void ArmazenaPolinomio(char x, Polinomio p) {
/* Armazena o polinômio p sob o nome x na base.                          */
  x = toupper(x);
  if (x >= 'A' && x < 'A' + TAM_BASE) 
    vetorPoli[x - 'A'] = p;
  else 
    IMPRIME_ERRO(MSG_ERRO_NOME_INVALIDO);
}
Ejemplo n.º 6
0
ElemPilha* VerificaDesempilha(Pilha* pilha) {
/* Desempilha um elemento, enviando uma mensagem de erro caso a pilha      */
/* esteja vazia.                                                           */
  if (PilhaVazia(pilha)) {
    IMPRIME_ERRO(MSG_ERRO_FALTA_OPERANDO);
    return NULL;
  }
  return (ElemPilha*) Desempilha(pilha);
}
Ejemplo n.º 7
0
/* Retorna o polinômio referente à expressão dada; este polinômio devolvido é
 * sempre uma nova cópia, mesmo que a expressão seja uma variável simples.
 */
Polinomio CalcExpr(char* expr) {
	Pilha polPilha;
	ElemPilha *r;
	Polinomio p;
	int i;

	CriaPilha(&polPilha);

	i = 0;
	while (expr[i] != '\0') {
		if (Operando(expr + i)) {
			EmpilhaOperando(&polPilha, RecuperaPolinomio(expr[i]), false);
		} else if (Operador(expr + i)) {
			ExecutaOperacao(&polPilha, expr[i]);
		} else {
			IMPRIME_ERRO(MSG_ERRO_CARACTERE_INVALIDO);
		}

		i++;
	}

	r = VerificaDesempilha(&polPilha);

	if (!PilhaVazia(&polPilha)) {
		IMPRIME_ERRO(MSG_ERRO_FALTA_OPERADOR);
	}

	if (r->temp) {
		p = r->poli;
	} else {
		p = CopiaPolinomio(r->poli);
	}

	FREE(r);

	return p;
}
Ejemplo n.º 8
0
Polinomio CalcExpr(char* expr)
/* Retorna o polinômio referente à expressão dada                        */
{
    char aux;
    Pilha duracell;
    Polinomio res;
    ElemPilha *op1, *op2, *final;

    /* Inicializa Pilha da expressão */
    CriaPilha(&duracell);

    while(*expr != '\0') {
        if (Operando(*expr)) {
            /* Empilha polinômio. */
            aux = toupper(*expr);
            EmpilhaOperando(&duracell, vetorPoli[(aux - 'A')], false);
        } else
            switch(*expr) {
            case '+':
            case '-':
            case '*':
                /* Operadores Binários */

                /* Desempilha os operandos. */
                op2 = VerificaDesempilha(&duracell);
                op1 = VerificaDesempilha(&duracell);

                if (op1 == NULL || op2 == NULL)
                    IMPRIME_ERRO(MSG_ERRO_FALTA_OPERANDO);

                /* Empilha o resultado da Operação. */
                if (*expr == '+')
                    EmpilhaOperando(&duracell, SomaPolinomios(op1->poli, op2->poli), true);
                if (*expr == '-')
                    EmpilhaOperando(&duracell, SubPolinomios(op1->poli, op2->poli), true);
                if (*expr == '*')
                    EmpilhaOperando(&duracell, MultPolinomios(op1->poli, op2->poli), true);

                /* Libera a memoria dinâmica necessária. */
                if (op1->temp)
                    LiberaPolinomio(op1->poli);
                if (op2->temp)
                    LiberaPolinomio(op2->poli);

                FREE(op1);
                FREE(op2);

                break;

            case '~':
                /* Operador unário */

                /* Desempilha o operando. */
                op1 = VerificaDesempilha(&duracell);

                /* Empilha o resultado da Operação. */
                EmpilhaOperando(&duracell, MultTermo(op1->poli, 0, -1.0), true);

                /* Libera a memoria dinâmica necessária. */
                if (op1->temp)
                    LiberaPolinomio(op1->poli);

                FREE(op1);

                break;

            default:
                /* Erro: nenhum operador válido. */
                IMPRIME_ERRO(MSG_ERRO_CARACTERE_INVALIDO);
            }

        /* Avança para o próximo caractere da expressão. */
        expr += 1;
    }

    final = VerificaDesempilha(&duracell);
Ejemplo n.º 9
0
Archivo: pilha.c Proyecto: gbsf/mc202
void* Desempilha (Pilha* p) {
/* Desempilha um elemento da pilha.                                        */ 
  if (PilhaVazia(p))
    IMPRIME_ERRO(MSG_ERRO_PILHA_VAZIA);
  return p->vetor[p->topo--];
}
Ejemplo n.º 10
0
Archivo: pilha.c Proyecto: gbsf/mc202
void Empilha (Pilha* p, void *elem) {
/* Empilha um elemento na pilha.                                           */
  if (PilhaCheia(p))
    IMPRIME_ERRO(MSG_ERRO_PILHA_CHEIA);
  p->vetor[++p->topo] = elem;
}
Ejemplo n.º 11
0
Polinomio CalcExpr(char* expr) { 
/* Retorna o polinômio referente à expressão dada.                       */
/* O polinômio devolvido é sempre uma nova cópia, mesmo que a            */
/* expressão seja uma variável simples.                                  */
    Pilha operacao;
    ElemPilha *aux1, *aux2;
    Polinomio temp;
    
    CriaPilha(&operacao);
    printf("Comeca a CalcExpr\n");
    /*Faz a leitura da expressão dada, termo por termo, até chegar no final da linha*/
    while(*expr != '\0'){
        /*Caso a entrada seja um operador*/
        if(!Operando(*expr)){ 
            printf("Operando\n");
            /*Caso o operador seja binário*/
            if(*expr == '+' || *expr == '-' || *expr == '*'){
                /*Como é um operador, deve-se utilizar os dois elementos do topo da pilha*/
                aux1 = VerificaDesempilha(&operacao);
                aux2 = VerificaDesempilha(&operacao);
                
                
                /*Caso tente desempilhar mas a pilha ja esta vazia, entao falta operandos*/
                if(aux1 == NULL || aux2 == NULL){
                    IMPRIME_ERRO(MSG_ERRO_FALTA_OPERANDO);
                }
                
                /*Faz a operacao entre os dois elementos desempilhados*/
                if(*expr == '+'){
                    printf("Soma\n");
                    temp = SomaPolinomios(aux2->poli, aux1->poli);
                }
                else if(*expr == '-'){
                    printf("Sub\n");
                    temp = SubPolinomios(aux2->poli, aux1->poli);
                }
                else if(*expr == '*'){
                    printf("Multi\n");
                    temp = MultPolinomios(aux2->poli, aux1->poli);
                }
                
                /*Empilha o elemento resultante das operacoes*/
                EmpilhaOperando(&operacao, temp, true);
                
                
                /*Libera os elementos da pilha utilizados*/
                if(aux1->temp == true){
                    LiberaPolinomio(aux1->poli);
                }
                if(aux2->temp == true){
                    LiberaPolinomio(aux2->poli);
                }
                
                FREE(aux1);
                FREE(aux2);
            }
            /*Caso o operador seja unário*/
            else if(*expr == '~'){
                /*Como é um operador unario, só é nescessario usar o elemento do topo
                  da pilha*/
                aux1 = VerificaDesempilha(&operacao);
                
                temp = MultTermo(aux1->poli, 0, -1.0);
                EmpilhaOperando(&operacao, temp, true);
                
                /*Desaloca a memoria nescessaria*/
                if(aux1->temp == true){
                    LiberaPolinomio(aux1->poli);
                }
                
                FREE(aux1);
            }
            /*Se não entrou em nenhum dos outros casos, a entada é invalida*/
            else{
                IMPRIME_ERRO(MSG_ERRO_CARACTERE_INVALIDO);
            }
            
        }        
        /*Se a entrada  não for um operador, é um polinomio*/
        else{
            printf("Operador\n");
            /*Empilha o elemento apontado na pilha operacao*/
            EmpilhaOperando(&operacao, vetorPoli[*expr - 'A'], false);
        }
        
        /*Avança a leitura*/
        expr++;    
    }
    /*Depois de terminar de ler as operacoes retira o ultimo elemento e verifica se
      a pilha está vazia, se sim, é por que completou as operacoes corretamente, entao
      retorna esse polinomio
    */
    aux1 = VerificaDesempilha(&operacao);
    
    if(PilhaVazia(&operacao)){
        temp = aux1->poli;
        /*Cria um novo polinomio para poder ser retornado caso o elemento retornado seja 
          uma das 5 bases*/
        if(aux1->temp == false){
            temp = MultTermo(aux1->poli, 0, 1.0);
        }
        
        /*Desaloca o ultima elemento da pilha*/
        FREE(aux1);

        return temp;
    }else{
        /*Se a pilha ainda conter algum elemento*/
        IMPRIME_ERRO(MSG_ERRO_FALTA_OPERADOR);
    }
}