Mensajes

HOLA AMIGOS LA  CUESTION ES QUE ME DEJARON UN PROYECTO PARA CALCULAR UNA INTEGRAL POR EL METODO DE SIMPSON PERO NO PUEDO MOSTRAR EL RESULTADO  SI LE PUEDEN ECHAR UN VISTAZO Y ME PUEDEN DECIR MI ERROR SE LES AGRADECERIA MUCHO!

Código [Seleccionar] Expandir

// 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();
}