#ifndef _VETOR_H_
#define _VETOR_H_

#include "comum.h"

/* Tipo abstrato Vetor em computação é uma estrutura seqüencial e
   estática, a qual significa seqüência de valores e não uma grandeza
   vetorial. Porém se fóssemos definir a grandeza vetorial sua
   representação seria a mesma com operações diferentes apenas
   (e.g. produto interno, soma, subtração). Um sinal de voz digital,
   por exemplo, também seria representado da mesma forma, mas com
   operações diferentes apenas (e.g. convolução, transformada de
   Fourier). A representação do tipo abstrato Vetor usa o tipo
   composto vetor de inteiros (neste caso) para armazenar os valores
   da seqüência e o tipo simples inteiro para armazenar o tamanho da
   seqüência. */

typedef struct vetor {
  int *info;   /* informação */
  int n;       /* número de elementos */
} Vetor;

/* Operações sobre Vetor (i.e. Seqüência) */

Vetor *vetCria(int n);  /* Cria seqüência vazia com capacidade para
                           armazenar n elementos. */
void  vetDestroi(Vetor *v); /* Destrói seqüência. */  
int   vetValorMaximo(Vetor *v);  /* Retorna valor máximo na seqüência. */ 
int   vetValorMinimo(Vetor *v);  /* Retorna valor mínimo na seqüência. */ 
float   vetMedia(Vetor *v);  /* Retorna a média dos valores na seqüência. */ 
float   vetVariancia(Vetor *v);  /* Retorna a variância dos valores na
				    seqüência. A variância eh o
				    somatorio dos quadrados das
				    diferencas entre os elementos da
				    seqüência e sua média dividido
				    pelo numero de elementos. */
Vetor *vetFrequencia(Vetor *v);  /* Retorna a freqüência de valores da
                                    seqüência. Válida apenas para
                                    seqüências com valores
                                    não-negativos. */
Vetor *vetFreqAcum(Vetor *v);  /* Retorna a freqüência acumulada de
                                  valores da seqüência. Válida apenas
                                  para seqüências com valores
                                  não-negativos. */
void  vetOrdena(Vetor *v);  /* Coloca os elementos da seqüência na
                               ordem crescente de valores usando o
                               quick sort. Caso você ainda não saiba o
                               QuickSort, então use um dos seguintes
                               algoritmos que você deve ter aprendido
                               em MC102: Selection, Insertion, ou
                               Bubble. */
Vetor *vetIntercala(Vetor *v1, Vetor *v2); /* Intercala duas seqüências
                                             v1 e v2 mantendo a ordem
                                             crescente de valores
                                             entre seus
                                             elementos. Caso v1 e v2
                                             não tenham sido
                                             previamente ordenadas,
                                             elas são ordenadas e
                                             depois intercaladas. */
int  vetBusca(Vetor *v, int valor); /* Retorna índice do primeiro
                                       elemento da seqüência com um
                                       dado valor ou -1 no caso deste
                                       elemento não existir na
                                       seqüência. Usa busca binária. */

#endif