// v Declaración de bibliotecas
#include <string.h>
#include <stdio.h>
#include <iostream.h>
#include <conio.h>
#include <math.h>

enum BOOL{FALSE=0,TRUE=1};

//num_seg entero positivo, ya que sirve de límite derecho del intervalo, el límite izquierdo es cero.
// c Definición de clase CDispersion
class CDistribucionT{
private:
      float m_X;
      int m_NumSeg;
      int m_DOF;
      float m_E;
      float m_ValorUno;
      float m_ValorDos;
      
      int gammaInt(int);
      float gammaFloat(float);
      float primerFactor(void);
      float xi(int);
      float baseSegundoFactor(float);
      float segundoFactor(float);
      float f(float);
      float termino(int, int);
public:
      CDistribucionT(float, int, float, int);
      void guardaValores(float, float);
      BOOL aceptableP(void);
      float devuelveP(int);
      float valorPAceptado(void);
      ~CDistribucionT();
};

typedef CDistribucionT* ptrCDistribucionT;

// m constructor de objeto tipo CDistribucionT
CDistribucionT::CDistribucionT(float x, int dof, float e, int num_seg)
{
      m_X=x;
      m_NumSeg=num_seg;
      m_DOF=dof;
      m_E=e;
      m_ValorUno=0;
      m_ValorDos=0;
}

// m método que calcula la función Gamma con valores enteros para Distribución T
int CDistribucionT::gammaInt(int equiz)
{
      if(equiz>2)
         return (equiz-1)*gammaInt(equiz-1);
      else
         return 1;
}

// m método que sobrecarga al anterior para Gamma con  valores de punto flotante
float CDistribucionT::gammaFloat(float equiz)
{
      if(equiz>1/2)
         return (equiz-1)*gammaFloat(equiz-1);
      else
         return sqrt(3.1415926536);
}

// m método que calcula el primer factor de la regla de Simpson extendida para Distribución T
float CDistribucionT::primerFactor(void)
{
      float numerador, denominador;
      if(m_DOF%2==0)
      {
	 numerador = gammaFloat((m_DOF+1)/2);
	 denominador = sqrt(m_DOF * 3.1415926536) * gammaInt(m_DOF/2);
      }
      else
      {
	 numerador = gammaInt((m_DOF+1)/2);
	 denominador = sqrt(m_DOF * 3.1415926536) * gammaFloat(m_DOF/2);
      }
      return numerador/denominador;
}

// m método que calcula Xi para obtener el valor de cada término
float CDistribucionT::xi(int i)
{
      return i* (m_X / m_NumSeg);
}

// m método que devuelve la base del segundo factor de la regla de Simpson extendida para Distribución T
float CDistribucionT::baseSegundoFactor(float xi)
{
      return (pow(xi,2)/m_DOF)+1;
}

// m método que calcula y devuelve el segundo factor de la regla de Simpson extendida para Distribución T
float CDistribucionT::segundoFactor(float xi)
{
      return 1/pow(baseSegundoFactor(xi),(m_DOF+1)/2);
}

// m método que calcula y devuelve la evaluación de la Distribución T para Xi
float CDistribucionT::f(float xi)
{
      return primerFactor() * segundoFactor(xi);
}

// m método que calcula y devuelve la evaluación para la Distribución T de un término de la regla de Simpson
float CDistribucionT::termino(int i, int multiplicador)
{
      float w;
      w = m_X / m_NumSeg;
      
      return w / 3 * multiplicador * f(xi(i));
}

// m método de CDistribucionT que guarda los valores de P a comparar
void CDistribucionT::guardaValores(float valor1, float valor2)
{
      m_ValorUno = valor1;
      m_ValorDos = valor2;
}

// m método que calcula y devuelve p para la regla de Simpson aplicada a la Distribución T 
float CDistribucionT::devuelveP(int num_seg)
{
      int multiplicador;
      float p = 0;
      for (int i = 0 ; i < num_seg ; i++)
      {
         if (i == 0 || i == num_seg)
            multiplicador = 1;
         else
            if(i % 2 == 0)
               multiplicador = 2;
            else
               multiplicador = 4;      
         p =  p + termino(i, multiplicador);
      }
      return p;
}
// m método que valida el valor p para la regla de Simpson aplicada a la Distribución T 
BOOL CDistribucionT::aceptableP(void)
{
      float valor1p, valor2p;
      int num_seg1 = m_NumSeg;
      int num_seg2 = num_seg1 * 2;
      do
      {
      valor1p = devuelveP(num_seg1);
      valor2p = devuelveP(num_seg2);
      num_seg1 = num_seg2;
      num_seg2 = num_seg1 * 2;
      }
      while( abs(valor1p - valor2p) > m_E);
      guardaValores(valor1p, valor2p);
      return TRUE;       
}
// m método que devuelve p aceptado para la regla de Simpson aplicada a la Distribución T 
float CDistribucionT::valorPAceptado(void)
{
      if (aceptableP())
         return m_ValorDos;
      else
        return 0;
}
// m destructor de objeto tipo CDistribucionT
CDistribucionT::~CDistribucionT()
{
}
//   Hilo principal del programa
int main()
{
      //  caso de prueba uno
     // clrscr();            
      ptrCDistribucionT casoPrueba1 = new CDistribucionT(1.1, 9, 0.00001, 10);
      cout << "\nPrueba 1.\n";
      cout << "Valor calculado de p (para x=1.1 y dof=9):\n";
      cout << casoPrueba1->valorPAceptado();
      cout << "\n";
      getchar();
      getchar();
      //  caso de prueba dos
      //clrscr();            
      ptrCDistribucionT casoPrueba2 = new CDistribucionT(1.1812, 10, 0.00001, 10);
      cout << "\nPrueba 1.\n";
      cout << "Valor calculado de p (para x=1.1812 y dof=10):\n";
      cout << casoPrueba2->valorPAceptado();
      cout << "\n";
      getchar();
      getchar();
      

      //  caso de prueba tres
      //clrscr();                  
      ptrCDistribucionT casoPrueba3 = new CDistribucionT(2.750, 30, 0.00001, 10);
      cout << "\nPrueba 1.\n";
      cout << "Valor calculado de p (para x=2.750 y dof=30):\n";
      cout << casoPrueba3->valorPAceptado();
      cout << "\n";
      getchar();
      getchar();
}