Ajuda - Melhorar eficiência

osvaldo182 · 19 de novembro de 2008

Opa,

Estou com um problema nesse programa. Na verdade ele funciona bem, mas preciso aumentar sua eficiencia. Minha ideia seria passar as variaveis em forma de ponteiro, porém quanto implementei o código o compilador achou muitos erros.

#include <stdio.h>
#include <math.h>


// Recursive auxiliary function for adaptiveSimpsons() function below
//
double adaptiveSimpsonsAux(double (*f)(double), double a, double b, double epsilon,
                         double S, double fa, double fb, double fc, int bottom) {
  double c = (a + b)/2, h = b - a;
  double d = (a + c)/2, e = (c + b)/2;
  double fd = f(d), fe = f(e);
  double Sleft = (h/12)*(fa + 4*fd + fc);
  double Sright = (h/12)*(fc + 4*fe + fb);
  double S2 = Sleft + Sright;
  if (bottom <= 0 || fabs(S2 - S) <= 15*epsilon)
    return S2 + (S2 - S)/15;
    else  return adaptiveSimpsonsAux(f, a, c, epsilon/2, Sleft,  fa, fc, fd, bottom-1) +  adaptiveSimpsonsAux(f, c, b, epsilon/2, Sright, fc, fb, fe, bottom-1);
}

//
// Adaptive Simpson's Rule
//
double adaptiveSimpsons(double (*f)(double),   // ptr to function
                           double a, double b,  // interval [a,b]
                           double epsilon,  // error tolerance
                           int maxRecursionDepth) {   // recursion cap
  double c = (a + b)/2, h = b - a;
  double fa = f(a), fb = f(, fc = f(c);
  double S = (h/6)*(fa + 4*fc + fb);
  return adaptiveSimpsonsAux(f, a, b, epsilon, S, fa, fb, fc, maxRecursionDepth);
}

double f (double argument){
    return sin(pow(argument,2));
}


int main(){
    double a = 0 , b = 113, epsilon =  0.000000001;
    int recDepth = 100;
    double I = adaptiveSimpsons(&f, a, b, epsilon, recDepth);

    printf("\n\nO valor da integral e: %.15lf",I);
    printf("\nO erro absoluto e:     %.15lf", fabs(I-0.6266421143805967));
}

Acho que o problema é na função auxiliar que é recursiva.

Alguém tem alguma sugestão para isso?

Desde já, Obrigado a todos.

osvaldo182 · 19 de novembro de 2008

Tentei de uma forma porca arrumar. ( simplesmente coloquei ponteiros nos argumentos da função f, ainda não pensei nas consequencias )

o codigo ficou assim:

#include <math.h>
#include <stdlib.h>

// Recursive auxiliary function for adaptiveSimpsons() function below
//
double adaptiveSimpsonsAux(double (*f)(double *), double *a, double *b, double epsilon,
double S, double fa, double fb, double fc, int bottom) {

double *d, *e, h, *c;
c = (double *) malloc (sizeof(double));
d = (double *) malloc (sizeof(double));
e = (double *) malloc (sizeof(double));

*c = (*a + *b)/2, h = *b - *a;
*d = (*a + *c)/2, *e = (*c + *b)/2;
double fd = f(d), fe = f(e);
double Sleft = (h/12)*(fa + 4*fd + fc);
double Sright = (h/12)*(fc + 4*fe + fb);
double S2 = Sleft + Sright;
if (bottom <= 0 || fabs(S2 - S) <= 15*epsilon)
return S2 + (S2 - S)/15;
else return adaptiveSimpsonsAux(f, a, c, epsilon/2, Sleft, fa, fc, fd, bottom-1) + adaptiveSimpsonsAux(f, c, b, epsilon/2, Sright, fc, fb, fe, bottom-1);
}

//
// Adaptive Simpson's Rule
//
double adaptiveSimpsons(double (*f)(double *), // ptr to function
double *a, double *b, // interval [a,b]
double epsilon, // error tolerance
int maxRecursionDepth) { // recursion cap

double *c;
c = (double *) malloc (sizeof(double));
*c = (*a + *b)/2;
double h = *b - *a;
double fa = f(a), fb = f(, fc = f(c);
double S = (h/6)*(fa + 4*fc + fb);
return adaptiveSimpsonsAux(f, a, b, epsilon, S, fa, fb, fc, maxRecursionDepth);
}

double f (double *argument){
return sin(pow(*argument,2));
}

int main(){
double *a , *b, epsilon = 0.000000001;
a = (double *) malloc (sizeof(double));
b = (double *) malloc (sizeof(double));
*a=0;
*b=113;
int recDepth = 100;
double I = adaptiveSimpsons(&f, a, b, epsilon, recDepth); /* <<<< AQUI É O ERRO*/

printf("\n\nO valor da integral e: %.15lf",I);
printf("\nO erro absoluto e: %.15lf", fabs(I-0.6266421143805967));
}
#include <stdio.h>