Integrable_Function.h

#ifndef QNANO_NEW_INTEGRABLE_FUNCTION_DEFINED_H
#define QNANO_NEW_INTEGRABLE_FUNCTION_DEFINED_H

#include <cstdlib>
#include <cmath>
#include <vector>
#include <iostream>

class Integrable_Function{
public:
  double (*fct)(double *d, size_t dim, void *params);
  size_t dim;
  void *params;

  double evaluate(const std::vector<double> &vec) const{
    return fct((double*) &vec[0], vec.size(), params);
  }
  double evaluate(double d) const{
    return fct(&d, 1, params);
  }
  
  Integrable_Function( double (*fct_)(double *d, size_t dim, void *params), size_t dim_, void *params_) 
    : fct(fct_), dim(dim_), params(params_){
  }
};


class IntFunc_exp: public Integrable_Function{
public: 
  double a;
  
  static double f(double *x, size_t dim, void *params){
    const IntFunc_exp *cl = (const IntFunc_exp*)params;
    return exp(cl->a * x[0]);
  }
  
  IntFunc_exp(double a_) : Integrable_Function(f, 1, this), a(a_){ }

};


class Integrable_Function_Product: public Integrable_Function{
public:
  const Integrable_Function * if1;
  const Integrable_Function * if2;

  static double f(double *x, size_t dim, void *params){
    const Integrable_Function_Product *cl=(const Integrable_Function_Product *)params;
    return cl->if1->fct(x, dim, (void*)cl->if1)*cl->if2->fct(x, dim, (void*) cl->if2);
//    return cl->if1->fct(x, dim, cl->if1->params)*cl->if2->fct(x, dim, cl->if2->params);
  }

  Integrable_Function_Product( const Integrable_Function *if1_, const Integrable_Function *if2_ ) 
    : Integrable_Function(f, if1_->dim, this), if1(if1_), if2(if2_) {
    if(if1->dim!=if2->dim){
      std::cerr<<"Integrable_Function_Product: mismatch of dimension: "<<if1->dim<<" vs. "<<if2->dim<<std::endl;
      exit(1);
    }
  }
};

/*
Integrable_Function_Product operator*(const Integrable_Function *f1, const Integrable_Function *f2){
  return Integrable_Function_Product(f1, f2);
}*/


#endif