#include <stdio.h>
#include <iostream>
#include <math.h>
#include "Conjunto.h"
#include "Dado.cpp"

/*
        Authors:Antonio Ribeiro Alves Junior e
                Gustavo Luiz Ferreira Walbon.
        Description: Armazenará os dados em um array dinâmico. Com funções que
        retornaram alguns valores estatísticos.
*/

class Conjunto                  //BEGIN: CONJUNTO CLASS
{
        Conjunto::Conjunto()
        {                               //BEGIN: Constructor Class
                Tamanho         = 0 ;
                raiz            = NULL ;

        }                               //END: Constructor Class

        float Conjunto::AdicionarDado(float dado)
        {                               //BEGIN: AdicionarDado
                int     valor_nVezes = 1;

                if(raiz == NULL )
                {
                        raiz = new Dado();
                        raiz->valor = dado;
                        raiz->valor_vezes=1;
                        raiz->proximo = NULL;
                }
                else
                {
                        Dado*   ptrDado ;
                        ptrDado = raiz ;
                        while( ptrDado != NULL )
                        {
                                if ( ptrDado->valor == dado )
                                        valor_nVezes = ptrDado->valor_vezes++;
                               ptrDado = ptrDado->proximo;
                        }

                        ptrDado = new Dado();
                        ptrDado->valor = dado;
                        ptrDado->valor_vezes = valor_nVezes;
                        ptrDado->proximo = NULL;
                }
                return dado;
        }                               //END: AdicionarDado

        int Conjunto::Tamanho()
        {                               //BEGIN: Tamanho
                Dado*   ptrDado = raiz;
                int     n_tamanho = 0;

                while(ptrDado != NULL)
                {
                        n_tamanho++;
                        ptrDado = ptrDado->proximo;
                }
                return n_tamanho;
        }                               //END: Tamanho

        double Conjunto::Media()
        {                               //BEGIN: Media
                float   Soma = 0;

                Dado*   ptrDado = raiz;

                while(ptrDado != NULL)
                {
                        Soma+=ptrDado->valor;
                        ptrDado = ptrDado->proximo;
                }

                return  ( Soma/Tamanho() );
        }                               //END: Media
        int Conjunto::Mediana()
        {                               //BEGIN: Mediana
                float   dif_Media = raiz->valor - Media();
                float   mediana = raiz->valor;

                Dado*   ptrDado = raiz;

                while(ptrDado != NULL)
                {
                        if ( (ptrDado->valor)-Media() < dif_Media )
                        {
                                mediana = ptrDado->valor;
                                dif_Media = (ptrDado->valor) - Media();
                        }
                        ptrDado = ptrDado->proximo;
                }

                return mediana;
        }                               //END: Mediana

        float Conjunto::DesvioPadrao()
        {                               //BEGIN: DesvioPadrao

                return sqrt( Variancia() );
        }                               //END: DesvioPadrao

        float   Conjunto::Variancia()
        {                               //BEGIN: Variancia
                float   dif_Soma = 0;

                Dado*   ptrDado = raiz;

                while(ptrDado != NULL)
                {
                        dif_Soma += exp2( (ptrDado->valor - Media()) );

                        ptrDado = ptrDado->proximo;
                }
               return (dif_Soma/Tamanho());
        }                               //END: Variancia

        float   Conjunto::Moda()
        {                               //BEGIN: Moda
                Dado*   ptrDado = raiz;
                Dado*   ptrModa = raiz;

                int     nVezes = raiz->valor_vezes;

                while( ptrDado != NULL)
                {
                        if( ptrDado->valor_vezes > nVezes )
                                ptrModa = ptrDado;

                        ptrDado = ptrDado->proxima;
                }
                return  ptrModa->valor;
        }                               //END: Moda



        Conjunto::~Conjunto()           //BEGIN: Destrutor Class
        {
                // Delete em tudo!;
        }                               //END:  Destrutor Class
}                               //END: CONJUNTO CLASS