error in compling C code (warning: assignment from incompatible pointer type)

[suvas]

I have C code. On compliation it shows error,
warning: assignment from incompatible pointer type
Actually I wanted to evaluate integral then sum all the integrals. I would be glad if anyone could help me. Thanks

#include <stdlib.h>
#include <stdio.h>
#include <gsl/gsl_errno.h>
#include <gsl/gsl_math.h>
#include <gsl/gsl_vector.h>
#include <gsl/gsl_multiroots.h>
#include <gsl/gsl_integration.h>



struct rparams
{
	double mu;
	double Lambda;
	double G;
	double H;
};

struct params2
{
	double mu;
	double Lambda;
	double H;
	double G;
	double Delta;
	double mue;
	double mu8;
};

int rosenbrock_f (const gsl_vector * x, void *params, gsl_vector * f);
double EQ1 (double Delta, double mue, double mu8, void *params);
double EQ2 (double Delta, double mue, double mu8, void *params);
double EQ3 (double Delta, double mue, double mu8, void *params);
double Part1 (double p, void *params);
double Part2 (double p, void *params);
double Part3 (double p, void *params);
double Part4 (double p, void *params);
double Part5 (double p, void *params);
double Part6 (double p, void *params); 
double Sum1 (double p, void *params);
double Sum2 (double p, void *params);
double Sum3 (double p, void *params);
double Sum4 (double p, void *params);
double Sum5 (double p, void *params); 
double Sum6 (double p, void *params); 
double function (int i, double p3, void *params, int n);
double newfunction( double p3, void *params, int n);
double integra_fv(int i, double Delta, double mue, double mu8, void *params);
double Integrate (int i, double Delta, double mue, double mu8, void *params);
double lowerlimit(double Delta, double mue, double mu8, void *params, int n);
double upperlimit(double Delta, double mue, double mu8, void *params, int n);
double Integralp1p2(int i, double Delta, double mue, double mu8, void *params, int n);
int main (int argc, char *argv[])
{
	int status;
	double Delta, mue, mu8, mu, H;
	size_t iter=0;
	char name[1000];

	const size_t n= 3;
	FILE *out;
	if(argc==3)
	{
        sprintf (name,"2SC_mu%sH%snnonzero.dat2", argv[1], argv[2]);

	mu=atof(argv[1]);
	H=atof(argv[2]);

	}else{
		printf ("as user:\n run mu H\n");
		return 1;
	      }

	if ((out=fopen(name, "w"))==NULL) {
	   printf( "Error in opening the outputfile\n");
           return 1;
	}

	const gsl_multiroot_fsolver_type *T;
	gsl_multiroot_fsolver *s;

	struct rparams p= {mu, 653.0, 3.76E-6, H};

	printf("H=%g mu=%g\n", H, mu);
	gsl_multiroot_function f= {&rosenbrock_f, n, &p};

	double x_init[3]= {70.0, 150.0, 18.0};

	gsl_vector *x = gsl_vector_alloc (n);
	gsl_vector_set (x, 0, x_init[0]);
	gsl_vector_set (x, 1, x_init[1]);
	gsl_vector_set (x, 2, x_init[2]);

	T= gsl_multiroot_fsolver_hybrids;
	s=gsl_multiroot_fsolver_alloc (T, 3);
	gsl_multiroot_fsolver_set (s, &f, x);

	// print_state (iter, s);
	
	do
	{

       	iter++;
		printf ("iter= %3u x = % .3f % .3f % .3f" "f(x)= % .3e % .3e % .3e\n",

			iter,
			gsl_vector_get (s->x, 0),
			gsl_vector_get (s->x, 1),
			gsl_vector_get (s->x, 2),
			gsl_vector_get (s->f, 0),
			gsl_vector_get (s->f, 1),
			gsl_vector_get (s->f, 2));  status = 
	gsl_multiroot_fsolver_iterate (s);

		//            print_state (iter, s);
		if (status)
			break;
		status =
		gsl_multiroot_test_residual (s->f, 1e-7);
	}
	while (status == GSL_CONTINUE && iter < 10000);

	printf ("status = %s\n", gsl_strerror (status));
	Delta =gsl_vector_get (s->x,0);
	mue =gsl_vector_get (s->x, 1);
	mu8 =gsl_vector_get (s->x, 2);

	fprintf(out, "%g %g %g %g %g\n", p.mu, H, Delta, mue, mu8);
       
	fclose (out);
	return 0;
      }

     int rosenbrock_f (const gsl_vector * x, void *params, gsl_vector * f)
     {
     const double x0 = gsl_vector_get (x, 0);
     const double x1 = gsl_vector_get (x, 1);
     const double x2 = gsl_vector_get (x, 2);

     const double y0 = EQ1(x0, x1, x2, params);
     const double y1 = EQ2(x0, x1, x2, params);
     const double y2 = EQ3(x0, x1, x2, params);

     gsl_vector_set (f, 0, y0);
     gsl_vector_set (f, 1, y1);
     gsl_vector_set (f, 2, y2);

     return GSL_SUCCESS;
     }
double EQ1 (double Delta, double mue, double mu8, void *params)
{
	double G = ((struct rparams *) params)->G;
        double mu = ((struct rparams *) params)->mu;
	double H = ((struct rparams *) params)->H;

	int  nmax;
	int n;
	double Pi=M_PI;
	double avemu= mu-1.0/6.0*mue+1.0/3.0*mu8;
	double P1, P2, P3, P4, f;
       
	P1= -(Delta*H)/(2.0*Pi*Pi)*Integrate(1, Delta, mue, mu8, params); /* from 0 to infty for n equal to zero */
	P2= -(Delta*H)/(Pi*Pi)* integra_fv(1, Delta, mue, mu8, params); /* from 0 to infty for n not equal to zero */
	P3= -(Delta*H)/(2*Pi*Pi)* Integrate(4, Delta, mue, mu8, params); /* from p2 to infty for n not equal to zero  */ 
        P4= +(Delta*H)/(2.0*Pi*Pi)*integra_fv(4, Delta, mue, mu8, params); /* from 0 to infty for n not equal to zero *****/ 
	nmax=(avemu-sqrt(mue*mue/4.0-Delta*Delta))*(avemu-sqrt(mue*mue/4.0-Delta*Delta))/(H);
	double S=0;
	for(n=0;n<=nmax;n++){
	S+=-(Delta*H)/(2.0*Pi*Pi)*Integralp1p2(1, Delta, mue, mu8, params,n)+10;
	}
	f = P1+P2+P3+P4+S+Delta/(2.0*G);
	printf("I'm in EQ1 nmax=%u S=%f\n", nmax, S);
	return f;
}
double EQ2 (double Delta, double mue, double mu8, void *params)
{

	double H = ((struct rparams *) params)->H;
        
	double mu = ((struct rparams *) params)->mu;
        
        double Pi=M_PI;
	
	double mu_db, mu_ub; 
	       
	double P1, P2,P3,P4, f1,f;

        mu_db = mu +1.0/3.0*mue -2.0/3.0*mu8;
	mu_ub = mu-2.0/3.0*mue-2.0/3.0*mu8;

        P1 = H/(12.0*Pi*Pi)*Integrate(2, Delta, mue, mu8, params); /* 0 to infty for n equal to zero */
	P2 = H/(6.0*Pi*Pi)*integra_fv(2, Delta, mue, mu8, params); /* 0 to infty for n not equal to zero */ 
	P3 = H/(12.0*Pi*Pi)*integra_fv(5, Delta, mue, mu8, params); /* 0 to infty for n not equal to zero */
	P4 = -H/(12.0*Pi*Pi)*Integrate(5, Delta, mue, mu8, params); /* p2 to infty for n not equal to zero */

	f1 = P1 + P2+P3+P4 -(mu_db*mu_db*mu_db)/(9.0*Pi*Pi)-H/(4.0*Pi*Pi)*mue +H/(6.0*Pi*Pi)*mu_ub;

	int n;
	double s=0.0;
	 int max = (mue*mue)/(2.0*H);

       for (n=1; n<=max; n++)
	       s+=H/(2.0*Pi*Pi)*sqrt(mue*mue-2.0*n*H);
      

       int m;
       double f2=0.0;
       int maxm = (mu_ub*mu_ub)/(2.0*H); 
       for (m=1; m<=maxm; m++)
	       f2+=H/(3.0*Pi*Pi)*sqrt(mu_ub*mu_ub-2.0*m*H);
       
            f=f1+f2-s;
/*	printf("I am in eq2 f2=%f mue=%f mu_db=%f mu_ub=%f maxm=%u\n", f2, mue, mu_db, mu_ub, maxm); */
	return f;
}

double EQ3(double Delta, double mue, double mu8, void *params)
{

        double H = ((struct rparams *) params)->H;

        double mu = ((struct rparams *) params)->mu;

	double Pi=M_PI;
        
        double mu_db = mu +1.0/3.0*mue -2.0/3.0*mu8;
	double 	mu_ub = mu-2.0/3.0*mue-2.0/3.0*mu8;

	double P1, P2, P3, P4, f;

        P1 = -H/(6.0*Pi*Pi)*Integrate(3, Delta, mue, mu8, params); /* 0 to infty for n equal to zero */

        P2 = -H/(3.0*Pi*Pi)*integra_fv(3, Delta, mue, mu8, params); /* 0 to infty for n not equal to zero */ 
	P3 = -H/(6.0*Pi*Pi)*integra_fv(6, Delta, mue, mu8, params); /* 0 to infty for n not equal to zero */
	P4 = H/(6.0*Pi*Pi)*Integrate(6, Delta, mue, mu8, params); /* p2 to infty for n not equal to zero */

	int j;
	double f3=0;
	int maxmm =mu_ub*mu_ub/(2.0*H); 
	for(j=1; j<=maxmm; j++)
		f3+=H/(3.0*Pi*Pi)*sqrt(mu_ub*mu_ub-2.0*j*H);

        f = P1 + P2 +P3+P4+ f3 + 2.0*(mu_db*mu_db*mu_db)/(9.0*Pi*Pi)+H/(6.0*Pi*Pi)*mu_ub;

       return f;
}

double Part1 (double p3, void *params)
{

	double Delta = ((struct params2 *) params)->Delta;
        double mu = ((struct params2 *) params)->mu;
        double mue = ((struct params2 *) params)->mue;
        double mu8 = ((struct params2 *) params)->mu8;

        double avemu;


	double P1;
        
	avemu = mu-mue/6.0+mu8/3.0;

	P1 = (1.0/sqrt((p3+avemu)*(p3+avemu)+Delta*Delta)+1.0/(sqrt((p3-avemu)*(p3-avemu)+Delta*Delta)));

	return P1;
}
/* first part for mue equation*/
double Part2 (double p3, void *params)
{
       double Delta = ((struct params2 *) params)->Delta;
       double mu = ((struct params2 *) params)->mu;
       double mue = ((struct params2 *) params)->mue;
       double mu8 = ((struct params2 *) params)->mu8;

       double avemu;
       double P2;

       avemu = mu-mue/6.0+mu8/3.0;

          P2 = ((p3+avemu)/(sqrt((p3+avemu)*(p3+avemu)+Delta*Delta))-(p3-avemu)/(sqrt((p3-avemu)*(p3-avemu)+Delta*Delta)));
       return P2;
 }
/* first part for mu8 equation*/
double Part3 (double p3, void *params)
{
       double Delta = ((struct params2 *) params)->Delta;

       double mu = ((struct params2 *) params)->mu;
       double mue = ((struct params2 *) params)->mue;
       double mu8 = ((struct params2 *) params)->mu8;

       double avemu;
   
       double P3;
       
       avemu = mu-mue/6.0+mu8/3.0;

       P3 = ((p3+avemu)/sqrt((p3+avemu)*(p3+avemu)+Delta*Delta)-(p3-avemu)/sqrt((p3-avemu)*(p3-avemu)+Delta*Delta));
       /*printf("P3=%f\n", P3); */
       return P3;
}
/* part containing integration from p2 to infty */
double Part4 (double p3, void *params)
{
       double Delta = ((struct params2 *) params)->Delta;

       double Lambda = ((struct params2 *) params)->Lambda;

       double mu = ((struct params2 *) params)->mu;
       double mue = ((struct params2 *) params)->mue;
       double mu8 = ((struct params2 *) params)->mu8;
   
       double P4;
       double avemu = mu-mue/6.0+mu8/3.0;
       double b1=sqrt(p3*p3+avemu*avemu);
       
       if(mue/2.0>Delta){
			  P4=1.0/sqrt((b1-avemu)*(b1-avemu)+Delta*Delta); /* second part mue/2 greater than Delta for Delta equation */
		  }else{
			  P4=0;
		  }
	 return P4*exp(-avemu*avemu/(Lambda*Lambda));
}
double Part5 (double p3, void *params)
{
       double Delta = ((struct params2 *) params)->Delta;

       double Lambda = ((struct params2 *) params)->Lambda;

       double mu = ((struct params2 *) params)->mu;
       double mue = ((struct params2 *) params)->mue;
       double mu8 = ((struct params2 *) params)->mu8;

       double P5;      
       double avemu = mu-mue/6.0+mu8/3.0;
       double b1=sqrt(p3*p3+avemu*avemu);

       if(mue/2.0>Delta){
			  P5=((b1-avemu)/sqrt((b1-avemu)*(b1-avemu)+Delta*Delta)-3.0); /* second part mue/2 greater than Delta for mue equation */
		  }else{
			  P5=0;		          
	               } 
		return P5*exp(-avemu*avemu/(Lambda*Lambda));
}
double Part6 (double p3, void *params)
{
       double Delta = ((struct params2 *) params)->Delta;

       double Lambda = ((struct params2 *) params)->Lambda;
       double mu = ((struct params2 *) params)->mu;
       double mue = ((struct params2 *) params)->mue;
       double mu8 = ((struct params2 *) params)->mu8;
       double P6;
       double avemu = mu-mue/6.0+mu8/3.0;
       double b1=sqrt(p3*p3+avemu*avemu);

       if(mue/2.0>Delta){
			  P6=(b1-avemu)/sqrt((b1-avemu)*(b1-avemu)+Delta*Delta); /* second part mue/2 greater than Delta for mue equation */
		  }else{
			  P6=0;		          
	               } 
		return P6*exp(-avemu*avemu/(Lambda*Lambda));
}
double Sum1(double p, void *params)
{
       double  Lambda = ((struct params2 *) params)->Lambda;

       double H = ((struct params2 *) params)->H;

       double S=0;
       int n;

       int max = (10.0*Lambda*Lambda)/H;


       for (n=1;n<=max; n++){
	       S+=function(1,p, params, n);
       }
      
       return S;
}
double Sum2(double p, void *params)
{
       double  Lambda = ((struct params2 *) params)->Lambda;

       double H = ((struct params2 *) params)->H;

       double S=0;
       int n;

       int max = (10.0*Lambda*Lambda)/H;


       for (n=1;n<=max; n++){
	       S+=function(2,p, params, n);
       }
       return S;
}
double Sum3(double p, void *params)
{
       double  Lambda = ((struct params2 *) params)->Lambda;

       double H = ((struct params2 *) params)->H;

       double S=0;
       int n;

       int max = (10.0*Lambda*Lambda)/H;


       for (n=1;n<=max; n++){
	       S+=function(3,p, params, n);
       }
       return S;
}

/*  for mue/2 greater than Delta 
 *
 *
 *  */
double Sum4(double p, void *params)
{
       double mu =((struct params2*) params)->mu;
       double H = ((struct params2*) params)->H;
       double Lambda = ((struct params2*) params)->Lambda;
       double mue =((struct params2*) params)->mue;
       double mu8 =((struct params2*) params)->mu8;
       double avemu = mu-mue/6.0+mu8/3.0;
       double S=0;
       int n;

       int max = 10.0*Lambda*Lambda/H;
       for (n=avemu*avemu/H;n<=max; n++){
	       S+=function(4,p, params, n);
       }
       return S;
}
double Sum5(double p, void *params)
{
       double mu =((struct params2*) params)->mu;
       double H = ((struct params2*) params)->H;
       double Lambda = ((struct params2*) params)->Lambda;
       double mue =((struct params2*) params)->mue;
       double mu8 =((struct params2*) params)->mu8;
       double avemu = mu-mue/6.0+mu8/3.0;
       double S=0;
       int n;

       int max = 10.0*Lambda*Lambda/H;
       for (n=avemu*avemu/H;n<=max; n++){
	       S+=function(5,p, params, n);
       }
       return S;
} 
 double Sum6(double p, void *params)
{
       double mu =((struct params2*) params)->mu;
       double H = ((struct params2*) params)->H;
       double Lambda = ((struct params2*) params)->Lambda;
       double mue =((struct params2*) params)->mue;
       double mu8 =((struct params2*) params)->mu8;
       double avemu = mu-mue/6.0+mu8/3.0;
       double S=0;
       int n;

       int max = 10.0*Lambda*Lambda/H;
       for (n=avemu*avemu/H;n<=max; n++){
	       S+=function(6,p, params, n);
       }
       return S;
} 
double function(int i, double p3, void *params, int n)
{
	double mu = ((struct params2 *) params )->mu;
	double  Lambda = ((struct params2 *) params)->Lambda;
	double Delta = ((struct params2 *) params)->Delta;
	double mue = ((struct params2 *) params)->mue;
	double mu8 = ((struct params2 *) params)->mu8;
	double H = ((struct params2 *) params)->H;
	double a1, avemu, f1, f2, nint;        
        avemu = mu-mue/6.0+mu8/3.0;
	nint =n*1.0;
	a1=sqrt(p3*p3+nint*H);
         if(i==1){
		f1=1.0/sqrt((a1+avemu)*(a1+avemu)+Delta*Delta); /* first part for Delta equation */
		f2=1.0/sqrt((a1-avemu)*(a1-avemu)+Delta*Delta);                             
		return (f1+f2)*exp((-nint*H)/(Lambda*Lambda));
	}else{
	 if(i==2){
                   f1=(a1+avemu)/sqrt((a1+avemu)*(a1+avemu)+Delta*Delta); /* first part for mue equation */ 
           	   f2=(a1-avemu)/sqrt((a1-avemu)*(a1-avemu)+Delta*Delta);			       
		return (f1-f2)*exp((-nint*H)/(Lambda*Lambda));
	 }else{
	   if(i==3){
                  f1=(a1+avemu)/sqrt((a1+avemu)*(a1+avemu)+Delta*Delta);  /* first part of mu8 equation */
           	       	f2=(a1-avemu)/sqrt((a1-avemu)*(a1-avemu)+Delta*Delta);			       
		return (f1-f2)*exp((-nint*H)/(Lambda*Lambda));
        }else{
	 if(i==4){
                  if(mue/2.0>=Delta){
			  f1=1.0/sqrt((a1-avemu)*(a1-avemu)+Delta*Delta); /* second part mue/2 greater than Delta for Delta equation */
		  }else{
			  f1=0;
		  }
		 return f1*exp((-nint*H)/(Lambda*Lambda));
	 }else{
	   if(i==5){
	       	if(mue/2.0>=Delta){
			  f1=((a1-avemu)/sqrt((a1-avemu)*(a1-avemu)+Delta*Delta)-3.0); /* second part mue/2 greater than Delta for mue equation */
		  }else{
			  f1=0;		          
	               } 
		return f1*exp((-nint*H)/(Lambda*Lambda));
	 }else{
                if(mue/2.0>=Delta){
                        f1=(a1-avemu)/sqrt((a1-avemu)*(a1-avemu)+Delta*Delta); /* second part mue/2 greater than Delta for mu8 equation */
           	 }else{
		 	 f1=0;
	              } 
		return f1*exp((-nint*H)/(Lambda*Lambda));
	    }	
        }
      }
   }
 }
}
double newfunction( double p3, void *params, int n)
{
	double mu = ((struct params2 *) params )->mu;
	double  Lambda = ((struct params2 *) params)->Lambda;
	double Delta = ((struct params2 *) params)->Delta;
	double mue = ((struct params2 *) params)->mue;
	double mu8 = ((struct params2 *) params)->mu8;
	double H = ((struct params2 *) params)->H;
	double a1, avemu, f1, nint;
        avemu = mu-mue/6.0+mu8/3.0;
	nint =n*1.0;
	a1=sqrt(p3*p3+nint*H);
	if(mue/2.0>=Delta){
			  f1=1.0/sqrt((a1-avemu)*(a1-avemu)+Delta*Delta); /* second part mue/2 greater than Delta for Delta equation */
		  }else{
			  f1=0;
		  }
		 return f1*exp((-nint*H)/(Lambda*Lambda));
}


double integra_fv(int i, double Delta, double mue, double mu8, void *params) /* integration for n not equal to zero */
{
	gsl_integration_workspace * w
		= gsl_integration_workspace_alloc (10000);
	double result, error;
	double mu = ((struct rparams *) params)->mu;
	double Lambda = ((struct rparams *) params)->Lambda;
	double H = ((struct rparams *) params)->H;
	double G= ((struct rparams *) params)->G;
	struct params2 p = {mu, Lambda, H, G, Delta, mue, mu8};
	gsl_function F;
	if(i==1){
		F.function = &Sum1;
		F.params = &p;
	}else{
	if(i==2){
		F.function = &Sum2;
		F.params = &p;
	}else{
	   if(i==3){
		F.function = &Sum3;
		F.params = &p;
        }else{
	  if(i==4){
		F.function = &Sum4;
		F.params = &p;
	}else{
	  if(i==5){
	        F.function = &Sum5;
		F.params = &p;
	}else{
	        F.function = &Sum6;
		F.params = &p;
	     }
       	}
      }
    } 
  }
       gsl_integration_qag(&F, 0.0, 653.0, 0.0, 1e-7, 10000, 6, w, &result, &error);
       gsl_integration_workspace_free(w);
       return result;
}
/* integration for n equal to zero */
double Integrate(int i, double Delta, double mue, double mu8, void *params)
{
	gsl_integration_workspace * w
		= gsl_integration_workspace_alloc(10000);

	double result, error;

	double mu = ((struct rparams *) params)->mu;
	double Lambda = ((struct rparams *) params)->Lambda;
	double H = ((struct rparams *) params)->H;
	double G= ((struct rparams *) params)->G;

	struct params2 p = {mu, Lambda, H, G, Delta, mue, mu8};
       
	gsl_function F;

	if(i==1){

    F.function = &Part1;
    F.params = &p;
  }else{
    if(i==2){
      
      F.function = &Part2;
      F.params = &p;
    }else{
    if(i==3){
      
      F.function = &Part3;
      F.params = &p;
    }else{
    if(i==4){
      
      F.function = &Part4;
      F.params = &p;
      }else{
    if(i==5){
      
      F.function = &Part5;
      F.params = &p;
    }else{
       
      F.function = &Part6;
      F.params = &p;
    }
  }
   }
    }
  }
  gsl_integration_qag (&F, 0.0, 653.0, 0.0, 1e-7, 10000, 6, w, &result, &error); 	  
  gsl_integration_workspace_free (w);
  
  return result;
}
double lowerlimit(double Delta, double mue, double mu8, void *params, int n)
{
	 double mu = ((struct params2 *) params)->mu;
  	 double H = ((struct params2 *) params)->H;
         double S;
	 double nint=1.0*n;	 
         double avemu=mu-mue*1.0/6.0+mu8*1.0/3.0;
	if(mue/2.0>Delta){
	 S=sqrt((avemu-sqrt(mue*mue/4.0-Delta*Delta))*(avemu-sqrt(mue*mue/4.0-Delta*Delta))-nint*H);
	}else{
	S=0;
	}
/*	printf("the variables are mue=%f avemu=%f mu=%f s=%f\n", mue, avemu, mu, S); */
 /*	 printf("lowerlimit=%f\n", S); */
	 return S;
}
double upperlimit(double Delta, double mue, double mu8, void *params, int n)
{
	 double mu = ((struct params2 *) params)->mu;
	 double H = ((struct params2 *) params)->H;
         double S;
       	 double nint=1.0*n;
         double avemu=mu-mue/6.0+mu8*1.0/3.0;
	if(mue/2.0>Delta){
	 S=sqrt((avemu+sqrt(mue*mue/4.0-Delta*Delta))*(avemu+sqrt(mue*mue/4.0-Delta*Delta))-nint*H);
	}else{
 		S=0;
	}
/*	 printf("upperlimit S=%f\n", S); */

	 return S;
}
double Integralp1p2(int i, double Delta, double mue, double mu8, void *params, int n)
{
	gsl_integration_workspace * w
		= gsl_integration_workspace_alloc (10000);
	double result, error;
	double mu = ((struct rparams *) params)->mu;
	double Lambda = ((struct rparams *) params)->Lambda;
	double H = ((struct rparams *) params)->H;
	double G= ((struct rparams *) params)->G;
	
	struct params2 p = {mu, Lambda, H, G, Delta, mue, mu8};
	gsl_function F;
	if(i==1){
		F.function = &newfunction;
		F.params = &p;
	}else{
	if(i==2){
		F.function = &newfunction;
		F.params = &p;
	}else{
	   if(i==3){
		F.function = &newfunction;;
		F.params = &p;
        }else{
	  
		F.function = &newfunction;;
		F.params = &p;
      }
    } 
  }
	double p1=lowerlimit(Delta, mue, mu8, params,n);
	double p2=upperlimit(Delta, mue, mu8, params,n);
       gsl_integration_qag(&F, p1, p2, 0.0, 1e-7, 10000, 6, w, &result, &error);
       gsl_integration_workspace_free(w);
       return result;
}

[melle]

Could you please paste your code in a nested code field ?

In your text screen, use your far right button named "wrapped [code]". And please tell at which lines it generates those errors.

[Banfa]

[quote=suvas]I have C code. On compliation it shows error,
warning: assignment from incompatible pointer type[/code]

Perhaps you should have posted the entire error message which would have told us what line the error occurred on or indicated that line by some other means.

I for one and not going to analyse 700+ lines of you code looking for a single line with an error.

[suvas]

Could you please paste your code in a nested code field ?

In your text screen, use your far right button named "wrapped [code]". And please tell at which lines it generates those errors.

Hi,

Thanks a lot for the reply. I have error in starting from line no 690 as follows

testnew.c:690: warning: assignment from incompatible pointer type
testnew.c:694: warning: assignment from incompatible pointer type
testnew.c:698: warning: assignment from incompatible pointer type
testnew.c:702: warning: assignment from incompatible pointer type

I have defined a function named (newfunction) in line no. 527. If I remove integer part (int n) then there is no error in compilation. But I want to evaluate integral then sum all the integrals(in line no. 169). Actually the limit of integration I defined in line no. p1 in 707 and p2 in 708 also depends on integer n. So problem is about the pointer in passing the integer n. I hope it makes easier for you to understand problem.

Thanks again
Suvas

[newb16]

Can you pass it in params2 structure as you pass other parameters?

[donbock]

All four error lines are identical:

F.function = &newfunction;

The prototype for newfunction is on line 47:

double newfunction(double p3, void *params, int n);

Variable F is defined on line 688:

gsl_function F;

Unfortunately, the definition of gsl_function must be hidden in one of the header files. A quick google search found this definition for gsl_function, however I can't be certain that this is the definition used in your header files. Notice the discrepancy -- this internet citation suggests that the proper prototype for F.function is

double (*function)(double x, void *params);

The error you're getting would be explained by this discrepancy -- whether the third parameter should be there or not.

[suvas]

Can you pass it in params2 structure as you pass other parameters?

Hi,

Thanks for your suggestions. When I pass integer in params2 structure, it is working. Otherwise, it was showing error.
cheers
suvas