/************************************************************** 

   #Programa#: #lab01.c#							
   #Autor#: #Alexandre Falcão#
   #Data#: #27/07/2001#
   #Descrição#: #Laboratório de vetores.#
   #Uso#: #lab01 < arq.tes > arq.res#
   #Parâmetros#:
     #entrada#: 
       #arq.tes#: #Arquivo de teste.#     
     #saída#:
       #arq.res#: #Arquivo com os resultados do teste.#
   #Modificação#: 
     #data#: #99/99/9999#
     #autor#: #Alexandre Falcão#
     #descrição#: #inexistente#

**************************************************************/
#include "lab01.h"

/* Funções que não estão na libdados */

/* Ler seqüência do arquivo de entrada. Assume arquivo aberto e com a
   sintaxe correta. */

Vetor *LerVetor() 
{
  int i,n;
  Vetor *v;

  fscanf(stdin,"%d",&n);
  v = vetCria(n);
  for (i=0; i < v->n; i++)
    fscanf(stdin,"%d",&v->info[i]);
  return(v);
}

/* Grava seqüência no arquivo de saída. Assume arquivo aberto. */

void GravaVetor(Vetor *v) 
{
  int i;

  for (i=0; i < v->n; i++)
    fprintf(stdout,"%d ",v->info[i]);
  fprintf(stdout,"\n");

}

int main(int argc, char **argv) {
  
  Vetor *aux,*v[3]={NULL,NULL,NULL}; /* Três vetores a serem manipulados */
  char acao[10]; /* Acao a ser tomada conforme indicado na entrada */
  int i,j; /* variáveis auxiliar */
  

  /* ------------------------------------------------------------

                  VÁLIDO APENAS PARA LINUX

     Declarações para verificação do uso da memória dinâmica.  A
     variável 'lixo' está sendo usada apenas para contornar um
     problema do funcionamento das funções da biblioteca 'malloc': a
     memória por ela apontada é desalocada logo a seguir!
     ------------------------------------------------------------ */
  
  //  void *lixo = malloc(1);                   /* truque: variável auxiliar */
  
  // struct mallinfo info;   
  // int MemDinInicial, MemDinFinal;
 
  // free(lixo);                              /* truque */
  // info = mallinfo();
  // MemDinInicial = info.uordblks;
  
  /* ------------------------------------------------------- */


  /* Executa o teste */

  fscanf(stdin,"%s",acao);
  while(strcmp(acao,"t")!=0) { 
    switch(*acao) {
    case 'l': /* Ler vetor */
      fscanf(stdin,"%d",&i);
      if (v[i] != NULL) vetDestroi(v[i]);
      v[i] = LerVetor();
      break;
    case 'g': /* Grava vetor */
      fscanf(stdin,"%d",&i);
      GravaVetor(v[i]);
      break;
    case 'M': /* Calcula valor máximo no vetor indicado no arquivo de
         entrada e grava no arquivo de saída */
      fscanf(stdin,"%d",&i);
      fprintf(stdout,"%d\n",vetValorMaximo(v[i]));
      break;
    case 'm': 
      /* Calcula valor mínimo no vetor indicado no arquivo de entrada
         e grava no arquivo de saída */
      fscanf(stdin,"%d",&i);
      fprintf(stdout,"%d\n",vetValorMinimo(v[i]));
      break;
    case 'u': 
      /* Calcula valor médio no vetor indicado no arquivo e grava no
         arquivo de saída */
      fscanf(stdin,"%d",&i);
      fprintf(stdout,"%.2f\n",vetMedia(v[i]));
      break;
    case 'v':       
      /* Calcula variância no vetor indicado no arquivo e grava no
         arquivo de saída */
      fscanf(stdin,"%d",&i);
      fprintf(stdout,"%.2f\n",vetVariancia(v[i]));
      break;
    case 'f': 
      /* Calcula a freqüência dos valores no vetor indicado no arquivo
         e grava no arquivo de saída */
      fscanf(stdin,"%d",&i);
      aux = vetFrequencia(v[i]);
      GravaVetor(aux);
      vetDestroi(aux);
      break;
    case 'F': 
      /* Calcula a freqüência acumulada dos valores no vetor indicado
         no arquivo e grava no arquivo de saída */
      fscanf(stdin,"%d",&i);
      aux = vetFreqAcum(v[i]);
      GravaVetor(aux);
      vetDestroi(aux);
      break;      
    case 'o': 
      /* Ordena o vetor indicado no arquivo de entrada e grava no
         arquivo de saída o vetor ordenado. */
      fscanf(stdin,"%d",&i);
      vetOrdena(v[i]);
      GravaVetor(v[i]);
      break;
    case 'i': 
      /* Intercala dois vetores especificados na entrada, gravando o
         vetor intercalado na saída. Assume que os dois primeiros já
         foram lidos. */
      fscanf(stdin,"%d %d",&i, &j);
      aux = vetIntercala(v[i], v[j]);
      GravaVetor(aux);
      vetDestroi(aux);
      break;
    case 'b': 
      /* Busca binária no vetor indicado no arquivo de entrada o valor também
         indicado no arquivo de entrada. Grava resultado da busca
         (ACHOU ou NAO ACHOU) no arquivo de saída. */
      fscanf(stdin,"%d %d",&i, &j);
      j = vetBusca(v[i],j);
      if (j >= 0) fprintf(stdout,"ACHOU\n");
      else fprintf(stdout,"NAO ACHOU\n");
      break;
    default:
      fprintf(stderr,"Ação %s inválida\n",acao);
      exit(-1);
    }
    fscanf(stdin,"%s",acao);
  }

  for (i=UM; i <= TRES; i++) 
    if (v[i]!=NULL) 
      vetDestroi(v[i]);


  /* ------------------------------------------------------------
     Verificação do uso da memória dinâmica.
     ------------------------------------------------------------ */

  //  info = mallinfo();
  // MemDinFinal = info.uordblks;
  // if (MemDinInicial!=MemDinFinal)
  //  printf("\n\nMemória dinâmica não foi totalmente liberada (%d, %d)\n",
  //                   MemDinInicial,MemDinFinal);

  /* ------------------------------------------------------------ */

  printf("\n\nFim da execução.\n\n");
  
  return 0;

} /* testvetor */







/* author: Gustavo Sverzut Barbieri (http://www.gustavobarbieri.com.br) */