#include "vetor.h"

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

   #Funcão#: #vetCria#							
   #Autor#: #Alexandre Falcão#
   #Data#: #27/07/2001#
   #Descrição#: #Cria seqüência vazia com capacidade para armazenar n elementos.#
   #Parâmetros#:
     #entrada#: 
        #n#: #Número de elementos da seqüência.#
     #saída#: #nenhum#
   #Retorno#: #Apontador para seqüência criada.#  
   #Modificação#: 
     #data#: #99/99/9999#
     #autor#: #Alexandre Falcão#
     #descrição#: #inexistente#

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

Vetor *vetCria(int n)
{
  Vetor *v=NULL;

  /* Aloca espaço em memória testando espaço alocado */
  
  if ((v = (Vetor *) calloc(1,sizeof(Vetor)))==NULL)
    comTrataErro(MSG1,"vetCria");
  else {
    if ((v->info = (int *) calloc(n,sizeof(int)))==NULL)
      comTrataErro(MSG1,"vetCria");
    v->n = n;
  }
  return(v);
}

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

   #Funcão#: #vetDestroi#							
   #Autor#: #Alexandre Falcão#
   #Data#: #27/07/2001#
   #Descrição#: #Destrói seqüência.#
   #Parâmetros#:
     #entrada#: 
        #v#: #Apontador para seqüência.#
     #saída#: #nenhum#
   #Retorno#: #nenhum#
   #Modificação#: 
     #data#: #99/99/9999#
     #autor#: #Alexandre Falcão#
     #descrição#: #inexistente#

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

void vetDestroi(Vetor *v)
{
  if (v!=NULL){
    if (v->info != NULL) 
      free(v->info);
    free(v);
  } else 
    comAviso(AVS1,"vetDestroi");    
}

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

   #Funcão#: #vetValorMaximo#							
   #Autor#: #Alexandre Falcão#
   #Data#: #30/07/2001#
   #Descrição#: #Retorna valor máximo na seqüência.#
   #Parâmetros#:
     #entrada#: 
        #v#: #Apontador para seqüência.#
     #saída#: #nenhum#
   #Retorno#: #Valor máximo na seqüência.#
   #Modificação#: 
     #data#: #99/99/9999#
     #autor#: #Alexandre Falcão#
     #descrição#: #inexistente#

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

int vetValorMaximo(Vetor *v)
{

  int i,max=INT_MIN;

  if (v != NULL) {
    max = v->info[0];
    for (i=1; i < v->n; i++) 
      if (v->info[i] > max)
	max = v->info[i];
  } else 
    comAviso(AVS1,"vetValorMaximo");
  
  return(max);
}

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

   #Funcão#: #vetValorMinimo#							
   #Autor#: #Gustavo Sverzut Barbieri#
   #Data#: #20/08/2001#
   #Descrição#: #Retorna valor minimo na seqüência.#
   #Parâmetros#:
     #entrada#: 
        #v#: #Apontador para seqüência.#
     #saída#: #nenhum#
   #Retorno#: #Valor minimo na seqüência.#

   #Modificação#: 
     #data#: #99/99/9999#
     #autor#: ##
     #descrição#: ##

**************************************************************/
int   vetValorMinimo(Vetor *v) {

  int i,min=INT_MIN;

  if (v != NULL) {
    min = v->info[0];
    for (i=1; i < v->n; i++) 
      if (v->info[i] < min)
	min = v->info[i];
  } else 
    comAviso(AVS1,"vetValorMinimo");
  
  return(min);
  
}

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

   #Funcão#: #vetMedia#							
   #Autor#: #Gustavo Sverzut Barbieri#
   #Data#: #20/08/2001#
   #Descrição#: #Retorna media dos valores na sequencia#
   #Parâmetros#:
     #entrada#: 
        #v#: #Apontador para seqüência.#
     #saída#: #nenhum#
   #Retorno#: #Valor media na seqüência.#

   #Modificação#: 
     #data#: #99/99/9999#
     #autor#: ##
     #descrição#: ##

**************************************************************/
float   vetMedia(Vetor *v) {
  double media=0;
  int i;
  if (v != NULL) {
    for (i=0; i < v->n; i++) {
      media += v->info[i];
    }
    return (media/v->n);
  } else {
    comAviso(AVS1,"vetMedia");
    return(INT_MIN);
  }

}

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

   #Funcão#: #vetVariancia#							
   #Autor#: #Gustavo Sverzut Barbieri#
   #Data#: #20/08/2001#
   #Descrição#: #Retorna variancia dos valores na sequencia#
   #Parâmetros#:
     #entrada#: 
        #v#: #Apontador para seqüência.#
     #saída#: #nenhum#
   #Retorno#: #Valor da variancia na seqüência.#

   #Modificação#: 
     #data#: #99/99/9999#
     #autor#: ##
     #descrição#: ##

**************************************************************/
float   vetVariancia(Vetor *v) {
  float media = 0, variancia=0;
  int i;
  if (v != NULL) {
    media = vetMedia(v);
    for (i=0; i < v->n; i++) {
      variancia += ((v->info[i] - media) * (v->info[i] - media));
    }
    return (variancia / v->n);
  } else {
    comAviso(AVS1,"vetVariancia");
    return (INT_MIN);
  }
}

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

   #Funcão#: #vetFrequencia#							
   #Autor#: #Gustavo Sverzut Barbieri#
   #Data#: #20/08/2001#
   #Descrição#: #Retorna frequencia dos valores na sequencia. Valido apenas para valores nao negativos.#
   #Parâmetros#:
     #entrada#: 
        #v#: #Apontador para seqüência.#
     #saída#: #nenhum#
   #Retorno#: #Vetor de frequencia na seqüência.#

   #Modificação#: 
     #data#: #99/99/9999#
     #autor#: ##
     #descrição#: ##

**************************************************************/
/* Retorna a freqüência de valores da seqüência. Válida apenas para seqüências com valores não-negativos. */
Vetor *vetFrequencia(Vetor *v) {
  int maximo, i,j;
  Vetor *freq = NULL;

  if (v != NULL) {
    if (vetValorMinimo(v) >= 0) {
      maximo = vetValorMaximo(v);
      freq = vetCria(maximo+1);
      if (freq != NULL) {
	for (i=0; i <= maximo; i++) {
	  freq->info[i]=0;
	  for (j=0; j < v->n; j++)
	    if (i == v->info[j]) freq->info[i]++;
	}
      } else 
	comAviso(AVS1,"vetFrequencia");
    } else {
      comAviso("Sequencia Invalida: valores negativos","vetFrequencia");
    }
  } else {
    comAviso(AVS1,"vetFrequencia");
  }

  return freq;
}

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

   #Funcão#: #vetFreqAcum#							
   #Autor#: #Gustavo Sverzut Barbieri#
   #Data#: #20/08/2001#
   #Descrição#: #Retorna frequencia acumulada de valores na sequencia. Valido apenas para valores nao negativos.#
   #Parâmetros#:
     #entrada#: 
        #v#: #Apontador para seqüência.#
     #saída#: #nenhum#
   #Retorno#: #Vetor de frequencia na seqüência.#

   #Modificação#: 
     #data#: #99/99/9999#
     #autor#: ##
     #descrição#: ##

**************************************************************/
Vetor *vetFreqAcum(Vetor *v) {
  Vetor *freq = NULL;
  int i;
  if (v != NULL) {
    freq = vetFrequencia(v);
    if (freq != NULL) {
      for (i=1; i < freq->n; i ++)
	freq->info[i] += freq->info[i-1];
    } else
      comAviso(AVS1,"vetFreqAcum");
  } else 
    comAviso(AVS1,"vetFreqAcum");

  return freq;
}

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

   #Funcão#: #vetOrdena#							
   #Autor#: #Gustavo Sverzut Barbieri#
   #Data#: #20/08/2001#
   #Descrição#: #Ordena os elementos na ordem crescente usando o QuickSort#
   #Parâmetros#:
     #entrada#: 
        #v#: #Apontador para seqüência.#
     #saída#: #nenhum#
   #Retorno#: #nenhum#

   #Modificação#: 
     #data#: #99/99/9999#
     #autor#: ##
     #descrição#: ##

**************************************************************/
void  vetOrdena(Vetor *v){
  int i,j,tmp;

  if (v != NULL) {
    for (i=0; i< v->n; i++) {
      for (j=0; j< v->n-1-i; j++) {
	if (v->info[j+1] < v->info[j]) {
	  tmp = v->info[j];        
	  v->info[j] = v->info[j+1];
	  v->info[j+1] = tmp;
	}
      }
    }
  } else {
    comAviso(AVS1,"vetOrdena");
  }
}

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

   #Funcão#: #vetIntercala#							
   #Autor#: #Gustavo Sverzut Barbieri#
   #Data#: #20/08/2001#
   #Descrição#: #Intercala os elementos mantendo a ordem crescente entre seus elementos.#
   #Parâmetros#:
     #entrada#: 
        #v#: #Apontador para seqüência.#
     #saída#: #nenhum#
   #Retorno#: #vetor intercalado e ordenado#

   #Modificação#: 
     #data#: #99/99/9999#
     #autor#: ##
     #descrição#: ##

**************************************************************/
Vetor *vetIntercala(Vetor *v1, Vetor *v2){
  Vetor *v = NULL;
  int i=0,j=0,k=0;
  if ((v1 != NULL) && (v2 != NULL)) {

    vetOrdena(v1); vetOrdena(v2);
    v = vetCria(v1->n + v2->n);

    if (v != NULL) {

      while (k < (v1->n + v2->n)) {
	if ( ((i < v1->n)&&(j < v2->n)&&(v1->info[i] <= v2->info[j])) || ((i < v1->n)&&(j >= v2->n)))
	  v->info[k++] = v1->info[i++];
	else if ( ((i < v1->n)&&(j < v2->n)&&(v1->info[i] > v2->info[j])) || ((i >= v1->n)&&(j < v2->n)))
	  v->info[k++] = v2->info[j++];
      }
    } else 
      comAviso(AVS1,"vetIntercala");
  } else
    comAviso(AVS1,"vetIntercala");
  
  return v;
}

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

   #Funcão#: #vetBusca#							
   #Autor#: #Gustavo Sverzut Barbieri#
   #Data#: #20/08/2001#
   #Descrição#: #Busca pelo metodo binario o elemento#
   #Parâmetros#:
     #entrada#: 
        #v#: #Apontador para seqüência.#
     #saída#: #nenhum#
   #Retorno#: #posicao do elemento#

   #Modificação#: 
     #data#: #99/99/9999#
     #autor#: ##
     #descrição#: ##

**************************************************************/
int  vetBusca(Vetor *v, int valor){
  int start, middle, end, pos=-1;
  
  if (v != NULL) {
    vetOrdena(v);
    start = 0;
    end   = v->n-1;

    while (start <= end) {
      middle = (start+end) /2;

      if (valor < v->info[middle]) {
	end = middle-1;
      } else if (valor == v->info[middle]) {
	while ((middle >0) && (valor == v->info[middle-1]))
	  middle--;
	pos = middle;
	break;
      } else if (valor > v->info[middle]) {
	start = middle+1;
      }
      
    }
  } else 
    comAviso(AVS1,"vetBusca");

  return pos;

}







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