Exemplo n.º 1
0
void init_gauss(int nbpts)
{
  ngauss = nbpts;
  xi = (double*)malloc(sizeof(double)*(ngauss+1));
  wi = (double*)malloc(sizeof(double)*(ngauss+1));
  gauleg(0.,1.,xi,wi,ngauss);
}
Exemplo n.º 2
0
void Infinite::TA_calculateE0(int nA, double (Infinite::*func)(), double (Infinite::*ref)())
{
    double refValue = (this->*ref)();
    double SP_diff = abs(refValue);
    SP_deltaE = 0.0;
    TA_deltaE = 0.0;
    twisted_x.resize(nA);
    twisted_w.resize(nA);
    gauleg(0,M_PI,twisted_x,twisted_w);
    for (int x = 0; x < twisted_x.size(); x++)
        for (int y = 0; y < twisted_x.size(); y++)
            for (int z = 0; z < twisted_x.size(); z++)
            {
                setTheta(twisted_x[x],twisted_x[y],twisted_x[z]);
                double value = (this->*func)();
                TA_deltaE += twisted_w[x] * twisted_w[y] * twisted_w[z] * value;
                if (abs(value/A - refValue) < SP_diff)
                {
                    SP_diff = abs(value/A - refValue);
                    SP_x = x;
                    SP_y = y;
                    SP_z = z;
                    SP_deltaE = value;
                }
            }
    TA_deltaE /= pow(M_PI,3);
    setTheta(0.0,0.0,0.0);
}
Exemplo n.º 3
0
void psht_make_gauss_geom_info_2 (int nrings, int nphi, int stride_lon,
  int stride_lat, psht_geom_info **geom_info)
  {
  const double pi=3.141592653589793238462643383279502884197;

  double *theta=RALLOC(double,nrings);
  double *weight=RALLOC(double,nrings);
  int *nph=RALLOC(int,nrings);
  double *phi0=RALLOC(double,nrings);
  ptrdiff_t *ofs=RALLOC(ptrdiff_t,nrings);
  int *stride_=RALLOC(int,nrings);
  int m;

  gauleg(-1,1,theta,weight,nrings);

  for (m=0; m<nrings; ++m)
    {
    theta[m] = acos(theta[m]);
    nph[m]=nphi;
    phi0[m]=0;
    ofs[m]=(ptrdiff_t)m*stride_lat;
    stride_[m]=stride_lon;
    weight[m]*=2*pi/nphi;
    }

  psht_make_geom_info (nrings, nph, ofs, stride_, phi0, theta, weight,
    geom_info);

  DEALLOC(theta);
  DEALLOC(weight);
  DEALLOC(nph);
  DEALLOC(phi0);
  DEALLOC(ofs);
  DEALLOC(stride_);
  }
Exemplo n.º 4
0
void testGauleg(){
	// declare variables
	int n;
	double *X, *W;
	
	printf("N = ");
	scanf("%u",&n);

	// note: have to make sure the range of integration is from -1 to 1, see Numerical Recipes p. 207 (p. 184 on pdf)

	// allocate memory
	X = (double*) calloc(n,sizeof(double));
	W = (double*) calloc(n,sizeof(double));

	gauleg(n, X, W);

	// print abscissas and weights
	int i;
	printf("\nX = ");
	for (i = 0; i < n; i++)
		printf("%.6f ",X[i]);
	printf("\n");

	printf("\nW = ");
	for (i = 0; i < n; i++)
		printf("%.6f ",W[i]);
	printf("\n");
}
/*We use the Cauchy Gourat theorem to compute the derivatives of the double(Mellin+Laplace) transform */
static dcomplex dermellin(dcomplex l, double sg, double r, int nummom)
{
  dcomplex term, cv, mu;
  int i;
  double r0,sumr, sumi/*,x[NPOINTS_FUSAITAGL+1],w[NPOINTS_FUSAITAGL+1]*/;
  double v;
  double *x,*w;

  x=malloc((NPOINTS_FUSAITAGL+1)*sizeof(double));
  w=malloc((NPOINTS_FUSAITAGL+1)*sizeof(double));

  sumr=0.0;
  sumi=0.0;
  
  gauleg(0, 2*M_PI, x, w,NPOINTS_FUSAITAGL);
	
  v   = 2*r/(sg*sg)-1.0;
  cv = Complex(v,0.0);
  mu = Csqrt(Cadd(Complex(v*v,0), RCmul(2.0,l)));
  r0 = Creal(RCmul(0.5,Csub(mu,cv)));	
  if(r0>1.0) r0=0.25;


  for (i=1;i<=NPOINTS_FUSAITAGL;i++) 
    {
    term = 	RCmul(pow(r0,nummom), Cexp(Complex(0.0, nummom*x[i])));
    sumr += w[i]*Creal(Cdiv(mellintransform(l, RCmul(r0, Cexp(Complex(0.0, x[i]))),  sg, r), term));
    sumi += w[i]*Cimag(Cdiv(mellintransform(l, RCmul(r0, Cexp(Complex(0.0, x[i]))),  sg, r), term));
    }

  free(x);
  free(w);
  
  return Complex(exp(factln(nummom))*sumr/(2.0*M_PI),exp(factln(nummom))*sumi/(2.0*M_PI));
}
Exemplo n.º 6
0
Infinite::Infinite(int _A, int _g_s, double _rho, int _nMax)
    : System(_A), g_s(_g_s), nMax(_nMax), gauss_x(100), gauss_w(100)
{
    thetaX = 0.0;
    thetaY = 0.0;
    thetaZ = 0.0;
    setRho(_rho);
    gauleg(-1,1,gauss_x,gauss_w);
}
Exemplo n.º 7
0
double quadsingint(func&& f, unsigned int n) {
    double I = 0.;
#if METHOD == 1 // s = sqrt(1 \pm t)
    QuadRule Q = gauleg(n);
    
    for(unsigned int i = 0; i < n; ++i) {
        double x = (Q.nodes(i) + 1.) / 2.;
        double w = Q.weights(i) * x * x * std::sqrt(2. - x * x);
        I += w * (f(x*x - 1) + f(-x*x + 1));
    }
    return I;
#elif METHOD == 2 // t = cos(s)
    QuadRule Q = gauleg(2*n);
    
    for(unsigned int i = 0; i < 2*n; ++i) {
        double x = sin(Q.nodes(i) * M_PI_2);
        double w = Q.weights(i) * cos(Q.nodes(i) * M_PI_2) * cos(Q.nodes(i) * M_PI_2);
        I += w * f(x) * M_PI_2;
    }
    return I;
#endif
}
Exemplo n.º 8
0
main(int argc, char *argv[])
{ int iq,nq;
  double wq[NN],xq[NN],x1,x2;
  void gauleg(double *x1,double *x2, int *n, double x[], double w[]);
  x1=0.; x2=1.;
  scanf("%d", &nq);
  while(nq>0)
  { gauleg(&x1,&x2,&nq,xq,wq);
    printf("\nnq=%d\n", nq);
    printf("iq    xq                wq\n");
    for(iq=1;iq<=nq;iq++)
      printf("%d %.15f %.15e\n", iq,xq[iq],wq[iq]);
    scanf("%d", &nq);
  }
}
Exemplo n.º 9
0
void NR::fred2(const DP a, const DP b, Vec_O_DP &t, Vec_O_DP &f, Vec_O_DP &w,
	DP g(const DP), DP ak(const DP, const DP))
{
	int i,j;
	DP d;

	int n=t.size();
	Mat_DP omk(n,n);
	Vec_INT indx(n);
	gauleg(a,b,t,w);
	for (i=0;i<n;i++) {
		for (j=0;j<n;j++)
			omk[i][j]=DP(i == j)-ak(t[i],t[j])*w[j];
		f[i]=g(t[i]);
	}
	ludcmp(omk,indx,d);
	lubksb(omk,indx,f);
}
Exemplo n.º 10
0
/// Number of haloes with mass greater than or equal to M
double cosmology::Nplus(double M, double z)
{
    //Int_{10^9}^{10^{16}} n(M) dM
    double result=0;
    const int N=100;
    double x[N],w[N];

    gauleg(log10(M),17.0,x,w,N);
    result=0;

    for (int i=0;i<N;i++)
    {
        double m=pow(10.,x[i]);
        result=result+w[i]*nofm(m,z)*m*log(10.);
    }
    return result;

}
Exemplo n.º 11
0
//------------------------------------------------------------------------------
GaussLaguerreIntegrator::GaussLaguerreIntegrator(Config *cfg, WaveFunction *wf) : SpatialIntegrator(cfg, wf)
{
    try {
        cfg->lookupValue("spatialIntegration.GaussLaguerre.samples", N);
        cfg->lookupValue("spatialIntegration.L", L);
        dim = cfg->lookup("systemSettings.dim");
    } catch (const SettingNotFoundException &nfex) {
        cerr << "Basis::Basis(Config *cfg)::Error reading from 'systemSettings' object setting." << endl;
    }

    x_ = zeros(dim);
    y_ = zeros(dim);
    x = new double[N];
    w1 = new double[N];
    gauleg(-L, L, x, w1, N);

#if DEBUG
    cout << "GaussLaguerreIntegrator(Setting* systemSettings)" << endl;
    cout << "N = " << N << endl;
    cout << "L = " << L << endl;
#endif
}
Exemplo n.º 12
0
Arquivo: fred2.c Projeto: gnovak/bin
void fred2(int n, float a, float b, float t[], float f[], float w[],
	float (*g)(float), float (*ak)(float, float))
{
	void gauleg(float x1, float x2, float x[], float w[], int n);
	void lubksb(float **a, int n, int *indx, float b[]);
	void ludcmp(float **a, int n, int *indx, float *d);
	int i,j,*indx;
	float d,**omk;

	indx=ivector(1,n);
	omk=matrix(1,n,1,n);
	gauleg(a,b,t,w,n);
	for (i=1;i<=n;i++) {
		for (j=1;j<=n;j++)
			omk[i][j]=(float)(i == j)-(*ak)(t[i],t[j])*w[j];
		f[i]=(*g)(t[i]);
	}
	ludcmp(omk,n,indx,&d);
	lubksb(omk,n,indx,f);
	free_matrix(omk,1,n,1,n);
	free_ivector(indx,1,n);
}
Exemplo n.º 13
0
double GaussianQuad_N(double func(const double), const double a2, const double b2, int NptGQ)
{
    double s=0.0;
    double x[NptGQ], w[NptGQ];
//    double dh=(b2-a2)/double(divs);
    gauleg(a2, b2, x, w, NptGQ);
    for (int j=1; j<=NptGQ; j++) {
      s += w[j]*func(x[j]);
    }
/*
    for (i=1; i<=divs; i++)
    {
	a0 = a2 + (i-1)*dh;
	b0 = a0 + dh;
	gauleg(a0, b0, x, w, NptGQ);
	for (j=1; j<=NptGQ; j++)
	{
	  s += w[j]*func(x[j]);
	}
    }
*/
    return s;
}
Exemplo n.º 14
0
double DiscreteAsian(int model,					//modello
                     double spot, 
					 double strike, 
	                 double rf, 
					 double dt, 
					 int ndates,
					 double lowlim,
					 double uplim,
                     int npoints,				//n. of quadrature points
					 long nfft,					//n. of points for the fft inversion
					 double ModelParameters[],  //the parameters of the model
					 double price[],
					 double solution[],double *delta)			//OUTPUT: Contains the solution	
{

int i, j, k;
double  inter_dens=0.;
double upperdens,b;
//parameters for spline interpolation
int ier;
double dfb,ddfb,arg;
//vectors where to store the outputs of the FFT inversion
double *inv, *logk;
//abscissa and weights for Gaussian quadrature with npoints
double *abscissa,*weights, *temp;
double** c,** kernelmatrix;
double optprice,optdelta;
double gamma_price;

inv=dvector(0, nfft-1);		//contains the density
logk=dvector(0, nfft-1);	//contains the abscissa of the density   
 
c = dmatrix(0, nfft-1, 0, 2);
kernelmatrix= dmatrix(0, npoints-1, 0, npoints-1);

abscissa=dvector(1,npoints);
weights=dvector(1,npoints);
temp=dvector(0,npoints-1);


//Generate abscissa and weights for quadrature
gauleg(lowlim, uplim, abscissa, weights, npoints);


b=MAX(fabs(lowlim - log(exp(uplim) + 1)),fabs(uplim - log(exp(lowlim) + 1)));
b=b*1.1;
upperdens=b;
TableIFRT(1, model, rf, dt, nfft, b, 1.5, ModelParameters, inv, logk);

//spline interpolation
i=spline(logk, inv, nfft ,c);
if(i>100) return i;

//construct the kernel matrix
for(i=1;i<=npoints;i++){
	for(j=1;j<=npoints;j++){
//		argument of the density
		arg=abscissa[i] - log(exp(abscissa[j]) + 1);
		if(arg>-upperdens)
		{
			if(arg<upperdens)
			{
			inter_dens=MAX(splevl(arg, nfft, logk, inv, c, &dfb, &ddfb, &ier),0.0);
			}
		}
		
		if(arg<-upperdens) inter_dens=0.0;
		
		if(arg>upperdens) inter_dens=0.0;
//construct the kernel
		kernelmatrix[i-1][ j-1] = weights[j] * MAX(inter_dens,0.0);
        /*printf("%d %d %d %f\n",npoints,i-1,j-1,kernelmatrix[i-1][ j-1]);*/
		}
//construct the initial condition

		arg=abscissa[i];
		if(arg>-upperdens)
		{
			if(arg<upperdens)
			{
			solution[i-1] = MAX(splevl(abscissa[i], nfft, logk, inv, c, &dfb, &ddfb, &ier),0);
			}
		}
        
		if(arg<-upperdens) solution[i-1]=0.0;
		
		if(arg>upperdens) solution[i-1]=0.0;
}
//iterations over the monitoring dates
for(k = 1;k<  ndates;k++){
	//compute K*v_n
	matvec(kernelmatrix, npoints, npoints, solution, temp);	
	//update v_n+1
	for( i = 0;i<= npoints-1;i++){ solution[i]=temp[i]; }
}
 
 optprice=0.0,optdelta=0.0;
 gamma_price=log(strike*((double)(ndates + 1))/spot-1.);
for( i = 0;i<= npoints-1;i++){
//spot price
		price[i] = spot * exp(abscissa[i+1]);
///option price
		optprice=optprice+weights[i+1]*MAX(spot*(1 + exp(abscissa[i+1]))/(ndates + 1) - strike, 0)*solution[i]*exp(-rf*dt*ndates);
        if(abscissa[i+1]>gamma_price)
         optdelta=optdelta+weights[i+1]*MAX((1 + exp(abscissa[i+1])), 0)*solution[i]*exp(-rf*dt*ndates)/(ndates + 1);
	}
 *delta=optdelta;
 
free_dvector(abscissa,1,npoints);
free_dvector(weights,1,npoints);
free_dvector(temp,0,npoints-1);
free_dvector(inv,0,nfft-1);
free_dvector(logk,0,nfft-1);
free_dmatrix(c, 0, nfft-1, 0, 2);
free_dmatrix(kernelmatrix, 0, npoints-1, 0, npoints-1);

return optprice;
  
}
static int FusaiTagliani_FixedAsian(double pseudo_stock,double pseudo_strike,NumFunc_2  *po,double t,double r,double divid,double sigma,double *ptprice,double *ptdelta)
{
  int i;
  
  double sum=0.0,sum_delta=0.;
  /* double area =0.0;*/
  int nnodi=NPOINTS_FUSAITAGL;
  double CTtK,PTtK,Dlt,Plt;
  double k2, k3, k4, m1,m2,m3,m4;
  double k2a, k3a, k4a, m1a,m2a,m3a,m4a, var,m;
  double term1, term2, term3, term4, edgedens ;
  double aa;
  int terms,totterms;
  double *x,*w;
  /*Set parameters for Laplace inversion*/
  aa=18.4;
  terms=15;
  totterms=25;
	
  x= malloc((NPOINTS_FUSAITAGL+1)*sizeof(double));
  w=malloc((NPOINTS_FUSAITAGL+1)*sizeof(double));

  /*Computation of the first four logarithmic moments*/
  m1 = MomentiLnAbWh(t, sigma, r-divid, aa, terms, totterms, 1);
  m2 = MomentiLnAbWh(t, sigma, r-divid, aa, terms, totterms, 2);
  m3 = MomentiLnAbWh(t, sigma, r-divid, aa, terms, totterms, 3);
  m4 = MomentiLnAbWh(t, sigma, r-divid, aa, terms, totterms, 4);


  /*Fit the parameters m,var of normal density*/
  var= m2-m1*m1;
  m=m1;

  /*Computation of the cumulants of the logarithm of the arithmetic average*/
  k2 = m2 - m1 *m1;
  k3 = m3 - 3 * m1 * m2 +3*m2*m1*m1 -3 * m1 * m1 * m1;
  k4 = m4 - 4 * m3 * m1 - 3*m2*m2+12*m2*m1*m1-6 * m1 * m1 * m1 * m1;
  /*k4 = m4 - 4 * m3 * m1 + 6 * m2 * m1 * m1 - 3 * m1 * m1 * m1 * m1 - 3 * k2 * k2;*/
	  
  /*Edgeworth Adjustment : Computation of theoretical moments of the
    normal density*/
  m1a = m;
  m2a = m2;
  m3a = m*m*m+3*m*var;
  m4a = m*m*m*m+6*m*m*var+3*var*var;
	  
  /*Edgeworth Adjustment : Computation of theoretical cumulants of the
    normal density*/
  k2a = m2a - m1a * m1a ;
  k3a = m3a - 3 * m1a * m2a + 3*m2a*m1a*m1a-3*m1a*m1a*m1a;
  /*k4a = m4a - 4 * m3a * m1a + 6 * m2a * m1a * m1a - 3 * m1a *m1a *m1a *m1a - 3 * k2a * k2a;*/
  k4a = m4a - 4 * m3a * m1a - 3*m2a*m2a+12*m2a*m1a*m1a-6 * m1a * m1a * m1a * m1a;

  /*Integrate, using the Laguerre quadrature, for obtaining the call price  */
  gauleg(log(pseudo_strike*t/pseudo_stock),log(pseudo_strike*t/pseudo_stock)+10., x, w, nnodi);
  sum=0.0;
  sum_delta=0.;
  for (i=1;i<=NPOINTS_FUSAITAGL;i++)
    {

      /*Density construction using Edgeworth Expansion*/
      term1= Normdens(x[i], m, pow(var,0.5));
      term2= (k2-k2a)*Der2Normdens(x[i], m, pow(var,0.5))/2.;
      term3= -(k3-k3a)*Der3Normdens(x[i], m, pow(var,0.5))/6.;
      term4= ((k4-k4a)+3*(k2-k2a))*Der4Normdens(x[i], m, pow(var,0.5))/24.;
      edgedens = term1+term2+term3+term4;

      /*Integration with to respect to payoff for obtaining the call price
	and delta*/
      sum += w[i]*(exp(x[i])*pseudo_stock/t-pseudo_strike)*edgedens;
      sum_delta += w[i]*exp(x[i])/t*edgedens;
    }
  
  /*  Call Price */
  CTtK= exp(-r*t)*sum;
	  
  /*  Put Price from Parity*/
  if(r==divid)
    PTtK=CTtK+pseudo_strike*exp(-r*t)-pseudo_stock*exp(-r*t);
  else
    PTtK=CTtK+pseudo_strike*exp(-r*t)-pseudo_stock*exp(-r*t)*(exp((r-divid)*t)-1.)/(t*(r-divid));

  /*Delta for call option*/
  Dlt=exp(-r*t)*sum_delta;

  /*Delta for put option*/
  if(r==divid)
    Plt=Dlt-exp(-r*t);
  else
    Plt=Dlt-exp(-r*t)*(exp((r-divid)*t)-1.0)/(t*(r-divid));

  /*Price*/
  if ((po->Compute)==&Call_OverSpot2)
    *ptprice=CTtK;
  else
    *ptprice=PTtK;
	 
  /*Delta */
  if ((po->Compute)==&Call_OverSpot2)
    *ptdelta=Dlt;
  else
    *ptdelta=Plt;

  free(x);
  free(w);	 
  return OK;
}