ODEparams * init(int nap,double * alpha,double * talpha, int nbp, double* beta, double *tbeta,double gamma, double x0,double y0) { ODEparams * pa= (ODEparams*)malloc(sizeof(ODEparams)); pa->gamma=gamma; pa->x0=x0; pa->y0=y0; pa->nap=nap; pa->nbp=nbp; pa->alpha=calloc(nap,sizeof(double)); pa->talpha=calloc(nap,sizeof(double)); pa->beta=calloc(nbp,sizeof(double)); pa->tbeta=calloc(nbp,sizeof(double)); int i; memcpy(pa->alpha,alpha,nap*sizeof(double)); memcpy(pa->talpha,talpha,nap*sizeof(double)); memcpy(pa->beta,beta,nbp*sizeof(double)); memcpy(pa->tbeta,tbeta,nbp*sizeof(double)); pa->a_acc=gsl_interp_accel_alloc (); pa->b_acc=gsl_interp_accel_alloc (); pa->a_spline = gsl_spline_alloc (gsl_interp_cspline,nap); gsl_spline_init (pa->a_spline, pa->talpha, pa->alpha, pa->nap); pa->b_spline = gsl_spline_alloc (gsl_interp_cspline,nbp); gsl_spline_init (pa->b_spline, pa->tbeta, pa->beta, pa->nbp); pa->gamma=gamma; pa->x0=x0; pa->y0=y0; return pa; }
static float interp_demData(float *demData, int nl, int ns, double l, double s) { if (l<0 || l>=nl-1 || s<0 || s>=ns-1) { return 0; } int ix = (int)s; int iy = (int)l; int bilinear = l<3 || l>=nl-3 || s<3 || s>=ns-3; //int bilinear = 1; if (bilinear) { float p00 = demData[ix + ns*(iy )]; float p10 = demData[ix+1 + ns*(iy )]; float p01 = demData[ix + ns*(iy+1)]; float p11 = demData[ix+1 + ns*(iy+1)]; return (float)bilinear_interp_fn(s-ix, l-iy, p00, p10, p01, p11); } else { double ret, x[4], y[4], xi[4], yi[4]; int ii; for (ii=0; ii<4; ++ii) { y[0] = demData[ix-1 + ns*(iy+ii-1)]; y[1] = demData[ix + ns*(iy+ii-1)]; y[2] = demData[ix+1 + ns*(iy+ii-1)]; y[3] = demData[ix+2 + ns*(iy+ii-1)]; x[0] = ix - 1; x[1] = ix; x[2] = ix + 1; x[3] = ix + 2; gsl_interp_accel *acc = gsl_interp_accel_alloc (); gsl_spline *spline = gsl_spline_alloc (gsl_interp_cspline, 4); gsl_spline_init (spline, x, y, 4); yi[ii] = gsl_spline_eval_check(spline, s, acc); gsl_spline_free (spline); gsl_interp_accel_free (acc); xi[ii] = iy + ii - 1; } gsl_interp_accel *acc = gsl_interp_accel_alloc (); gsl_spline *spline = gsl_spline_alloc (gsl_interp_cspline, 4); gsl_spline_init (spline, xi, yi, 4); ret = gsl_spline_eval_check(spline, l, acc); gsl_spline_free (spline); gsl_interp_accel_free (acc); return (float)ret; } asfPrintError("Impossible."); }
int load_lens(int l_size ,int* l_values){ double* lens_data = malloc( sizeof(double)*MAXLINES*3); int* lens_len = malloc( sizeof(int)); load_txt_dbl(lens_data_file, 3, lens_data, lens_len); int lens_size = *lens_len; int lmax = (int)get_lmax(); // printf("lmax %d\t%d\n",lmax,lens_size); double l_raw[lens_size]; double cltt_raw[lens_size]; double cltp_raw[lens_size]; int i,j; double pt; j=0; for (i=0; i<lmax+1; i++){ l_raw[i] = lens_data[j++]; cltt_raw[i] = lens_data[j++]; cltp_raw[i] = lens_data[j++]; } if (l_values[l_size-1]>l_raw[lmax]){ printf("lens do not contain enough l's, max data %d max lens: %d\n", l_values[l_size-1], (int)l_raw[lmax]); return 1; exit; } gsl_spline* sptt = gsl_spline_alloc (gsl_interp_cspline, lmax+1); gsl_spline* sptp = gsl_spline_alloc (gsl_interp_cspline, lmax+1); gsl_interp_accel* acctt = gsl_interp_accel_alloc(); gsl_interp_accel* acctp = gsl_interp_accel_alloc(); gsl_spline_init(sptt,l_raw,cltt_raw,lmax+1); gsl_spline_init(sptp,l_raw,cltp_raw,lmax+1); for (i=0; i<l_size; i++){ pt = (double)l_values[i]; lens_tt[i] = 0.0; lens_tp[i] = 0.0; if(pt!=0){ lens_tt[i] = gsl_spline_eval(sptt,pt,acctt); lens_tp[i] = gsl_spline_eval(sptp,pt,acctp); } } gsl_spline_free(sptt); gsl_spline_free(sptp); gsl_interp_accel_free(acctt); gsl_interp_accel_free(acctp); return 0; }
vector<carmen_ackerman_path_point_t> simulate_car_from_parameters(TrajectoryLookupTable::TrajectoryDimensions &td, TrajectoryLookupTable::TrajectoryControlParameters &tcp, double v0, double i_phi, TrajectoryLookupTable::CarLatencyBuffer car_latency_buffer, bool display_phi_profile) { vector<carmen_ackerman_path_point_t> path; if (!tcp.valid) { printf("Warning: invalid TrajectoryControlParameters tcp in simulate_car_from_parameters()\n"); return (path); } // Create phi profile gsl_interp_accel *acc; gsl_spline *phi_spline; if (tcp.has_k1) { double knots_x[4] = {0.0, tcp.tt / 4.0, tcp.tt / 2.0, tcp.tt}; double knots_y[4] = {i_phi, tcp.k1, tcp.k2, tcp.k3}; acc = gsl_interp_accel_alloc(); const gsl_interp_type *type = gsl_interp_cspline; phi_spline = gsl_spline_alloc(type, 4); gsl_spline_init(phi_spline, knots_x, knots_y, 4); } else { double knots_x[3] = {0.0, tcp.tt / 2.0, tcp.tt}; double knots_y[3] = {i_phi, tcp.k2, tcp.k3}; acc = gsl_interp_accel_alloc(); const gsl_interp_type *type = gsl_interp_cspline; phi_spline = gsl_spline_alloc(type, 3); gsl_spline_init(phi_spline, knots_x, knots_y, 3); } print_phi_profile_temp(phi_spline, acc, tcp.tt, display_phi_profile); Command command; Robot_State robot_state; double distance_traveled = compute_path_via_simulation(robot_state, command, path, tcp, phi_spline, acc, v0, i_phi, car_latency_buffer); gsl_spline_free(phi_spline); gsl_interp_accel_free(acc); td.dist = sqrt(robot_state.pose.x * robot_state.pose.x + robot_state.pose.y * robot_state.pose.y); td.theta = atan2(robot_state.pose.y, robot_state.pose.x); td.d_yaw = robot_state.pose.theta; td.phi_i = i_phi; td.v_i = v0; tcp.vf = command.v; tcp.sf = distance_traveled; td.control_parameters = tcp; return (path); }
/// Power spectra numerical implementation. Initializing spline. void cosmology::init_powerspectra_L() { if(verbose){ std::cout<<"# "<<"============================================================="<<std::endl; std::cout<<"# "<<"The spline for linear power spectra was not initialized. Initializing..."<<std::endl; } //Define the limits for which to calculate the variance double xx[Npower],yy[Npower]; for (int i=0;i<Npower;i++) { double k=kmin+i/(Npower-1.)*(kmax-kmin); xx[i]=k; k=pow(10.0,k); /// Improvement possible here yy[i]=log10(Delta2_L(k,0.0)); } PSL0_acc = gsl_interp_accel_alloc (); PSL0_spline = gsl_spline_alloc (gsl_interp_cspline, Npower); gsl_spline_init (PSL0_spline,xx,yy,Npower); PSL0_dlow=(yy[2]-yy[0])/(xx[2]-xx[0]); PSL0_xlow=xx[1]; PSL0_ylow=yy[1]; PSL0_dhigh=(yy[Npower-3]-yy[Npower-1])/(xx[Npower-3]-xx[Npower-1]); PSL0_xhigh=xx[Npower-2]; PSL0_yhigh=yy[Npower-2]; bool_init_PSL0=true; if(verbose){ std::cout<<"# "<<"The spline for numerical calculation of linear power spectra is now initialized"<<std::endl; std::cout<<"# "<<"============================================================="<<std::endl; } }
double calc_corr_at_R(double R,double*k,double*P,int Nk,int N,double h){ double zero,psi,x,t,dpsi,f,PIsinht; double PI_h = PI/h; double PI_2 = PI*0.5; gsl_spline*Pspl = gsl_spline_alloc(gsl_interp_cspline,Nk); gsl_spline_init(Pspl,k,P,Nk); gsl_interp_accel*acc= gsl_interp_accel_alloc(); double sum = 0; int i; for(i=0;i<N;i++){ zero = i+1; psi = h*zero*tanh(sinh(h*zero)*PI_2); x = psi*PI_h; t = h*zero; PIsinht = PI*sinh(t); dpsi = (PI*t*cosh(t)+sinh(PIsinht))/(1+cosh(PIsinht)); if (dpsi!=dpsi) dpsi=1.0; f = x*get_P(x,R,k,P,Nk,Pspl,acc); sum += f*sin(x)*dpsi; } gsl_spline_free(Pspl),gsl_interp_accel_free(acc); return sum/(R*R*R*PI*2); }
/*! \fn void create_linear_spline(double (*func)(double, void *), double *x, double *&y, int n, double *params, gsl_spline *&spline, gsl_interp_accel *&acc) * \brief Routine to create a spline, interpolated linear. */ void create_linear_spline(double (*func)(double, void *), double *x, double *&y, int n, double *params, gsl_spline *&spline, gsl_interp_accel *&acc) { //x contains the locations at which //wish to evaluate the function func() //y is input unallocated //we will allocate it and it will //contain func(x) //n is the size of the array of x and y //params is the array of parameters to pass to //func(x,params) //spline is the unallocated gsl_spline //acc is the unallocated gsl_interp_accel //allocate y y = calloc_double_array(n); //evaluate func at x locations for(int i=0;i<n;i++) y[i] = func(x[i],params); //allocate interpolants spline = gsl_spline_alloc(gsl_interp_cspline,n); acc = gsl_interp_accel_alloc(); //create interpoolation gsl_spline_init(spline, x, y, n); }
void Interpolation::calculateOutputData(double *x, double *y) { gsl_interp_accel *acc = gsl_interp_accel_alloc (); const gsl_interp_type *method; switch(d_method) { case 0: method = gsl_interp_linear; break; case 1: method = gsl_interp_cspline; break; case 2: method = gsl_interp_akima; break; } gsl_spline *interp = gsl_spline_alloc (method, d_n); gsl_spline_init (interp, d_x, d_y, d_n); double step = (d_to - d_from)/(double)(d_points - 1); for (int j = 0; j < d_points; j++) { x[j] = d_from + j*step; y[j] = gsl_spline_eval (interp, x[j], acc); } gsl_spline_free (interp); gsl_interp_accel_free (acc); }
static void comp_lens_power_spectrum(lensPowerSpectra lps) { #define WORKSPACE_NUM 100000 #define ABSERR 1e-12 #define RELERR 1e-12 #define TABLE_LENGTH 1000 gsl_integration_workspace *workspace; gsl_function F; double result,abserr; double logltab[TABLE_LENGTH]; double logpkltab[TABLE_LENGTH]; double chimax; int i; //fill in bin information chiLim = lps->chiLim; if(lps->chis1 > lps->chis2) chimax = lps->chis1; else chimax = lps->chis2; fprintf(stderr,"doing lens pk - chiLim = %lf, chiMax = %lf\n",chiLim,chimax); //init workspace = gsl_integration_workspace_alloc((size_t) WORKSPACE_NUM); F.function = &lenspk_integrand; F.params = lps; //make table double lnlmin = log(wlData.lmin); double lnlmax = log(wlData.lmax); for(i=0;i<TABLE_LENGTH;++i) { logltab[i] = i*(lnlmax-lnlmin)/(TABLE_LENGTH-1) + lnlmin; lps->ell = exp(logltab[i]); gsl_integration_qag(&F,0.0,chimax,ABSERR,RELERR,(size_t) WORKSPACE_NUM,GSL_INTEG_GAUSS51,workspace,&result,&abserr); logpkltab[i] = log(result); } //free gsl_integration_workspace_free(workspace); //init splines and accels if(lps->spline != NULL) gsl_spline_free(lps->spline); lps->spline = gsl_spline_alloc(gsl_interp_akima,(size_t) (TABLE_LENGTH)); gsl_spline_init(lps->spline,logltab,logpkltab,(size_t) (TABLE_LENGTH)); if(lps->accel != NULL) gsl_interp_accel_reset(lps->accel); else lps->accel = gsl_interp_accel_alloc(); #undef TABLE_LENGTH #undef ABSERR #undef RELERR #undef WORKSPACE_NUM }
static VALUE rb_gsl_spline_new(int argc, VALUE *argv, VALUE klass) { rb_gsl_spline *sp = NULL; const gsl_interp_type *T = NULL; double *ptrx = NULL, *ptry = NULL; size_t sizex = 0, sizey = 0, size = 0, stride = 1; int i; for (i = 0; i < argc; i++) { switch (TYPE(argv[i])) { case T_STRING: T = get_interp_type(argv[i]); break; case T_FIXNUM: if (T) size = FIX2INT(argv[i]); else T = get_interp_type(argv[i]); break; default: if (ptrx == NULL) { ptrx = get_vector_ptr(argv[i], &stride, &sizex); } else { ptry = get_vector_ptr(argv[i], &stride, &sizey); size = GSL_MIN_INT(sizex, sizey); } break; } } if (size == 0) rb_raise(rb_eRuntimeError, "spline size is not given."); sp = ALLOC(rb_gsl_spline); if (T == NULL) T = gsl_interp_cspline; sp->s = gsl_spline_alloc(T, size); sp->a = gsl_interp_accel_alloc(); if (ptrx && ptry) gsl_spline_init(sp->s, ptrx, ptry, size); return Data_Wrap_Struct(klass, 0, rb_gsl_spline_free, sp); }
int calc_ave_delta_sigma_in_bin(double*R,int NR,double*delta_sigma, double lRlow,double lRhigh, double*ave_delta_sigma){ int status = 0; gsl_spline*spline = gsl_spline_alloc(gsl_interp_cspline,NR); gsl_spline_init(spline,R,delta_sigma,NR); gsl_interp_accel*acc= gsl_interp_accel_alloc(); gsl_integration_workspace * workspace = gsl_integration_workspace_alloc(workspace_size); integrand_params*params=malloc(sizeof(integrand_params)); params->acc=acc; params->spline=spline; params->workspace=workspace; double Rlow=exp(lRlow),Rhigh=exp(lRhigh); do_integral(ave_delta_sigma,lRlow,lRhigh,params); *ave_delta_sigma *= 2./(Rhigh*Rhigh-Rlow*Rlow); gsl_spline_free(spline),gsl_interp_accel_free(acc); gsl_integration_workspace_free(workspace); free(params); return 0; }
int main (void) { int N = 4; double x[4] = {0.00, 0.10, 0.27, 0.30}; double y[4] = {0.15, 0.70, -0.10, 0.15}; /* Note: first = last for periodic data */ gsl_interp_accel *acc = gsl_interp_accel_alloc (); const gsl_interp_type *t = gsl_interp_cspline_periodic; gsl_spline *spline = gsl_spline_alloc (t, N); int i; double xi, yi; printf ("#m=0,S=5\n"); for (i = 0; i < N; i++) { printf ("%g %g\n", x[i], y[i]); } printf ("#m=1,S=0\n"); gsl_spline_init (spline, x, y, N); for (i = 0; i <= 100; i++) { xi = (1 - i / 100.0) * x[0] + (i / 100.0) * x[N-1]; yi = gsl_spline_eval (spline, xi, acc); printf ("%g %g\n", xi, yi); } gsl_spline_free (spline); gsl_interp_accel_free (acc); return 0; }
/// Initialize the spline for numerically calculating the variance /// This is valid for redshift z=0.0. Should be appropriately multiplied by the /// growth factor to extend to redshift z. void cosmology::init_varM_TH_spline() { if(verbose){ std::cout<<"# "<<"============================================================="<<std::endl; std::cout<<"# "<<"The spline for numerical calculation of variance was not initialized. Initializing..."<<std::endl; } //Define the limits for which to calculate the variance double mmin=5.0; double mmax=18.0; double xx[Nsigma],yy[Nsigma]; for (int i=0;i<Nsigma;i++) { double m=mmin+i/(Nsigma-1.)*(mmax-mmin); xx[i]=m; m=pow(10.,m); yy[i]=log(varM_TH(m,0.0))/log(10.); //std::cout<<xx[i]<<" "<<yy[i]<<std::endl; } varM_TH_num_acc = gsl_interp_accel_alloc (); varM_TH_num_spline = gsl_spline_alloc (gsl_interp_cspline, Nsigma); gsl_spline_init (varM_TH_num_spline,xx,yy,Nsigma); bool_init_varM_TH_spline=true; if(verbose){ std::cout<<"# "<<"The spline for numerical calculation of variance is now initialized"<<std::endl; std::cout<<"# "<<"============================================================="<<std::endl; } }
UNUSED static REAL8 XLALSimInspiralNRWaveformGetRefTimeFromRefFreq( UNUSED LALH5File* file, UNUSED REAL8 fRef ) { #ifndef LAL_HDF5_ENABLED XLAL_ERROR(XLAL_EFAILED, "HDF5 support not enabled"); #else /* NOTE: This is an internal function, it is expected that fRef is scaled * to correspond to the fRef with a total mass of 1 solar mass */ LALH5File *curr_group = NULL; gsl_vector *omega_t_vec = NULL; gsl_vector *omega_w_vec = NULL; gsl_interp_accel *acc; gsl_spline *spline; REAL8 ref_time; curr_group = XLALH5GroupOpen(file, "Omega-vs-time"); ReadHDF5RealVectorDataset(curr_group, "X", &omega_t_vec); ReadHDF5RealVectorDataset(curr_group, "Y", &omega_w_vec); acc = gsl_interp_accel_alloc(); spline = gsl_spline_alloc(gsl_interp_cspline, omega_w_vec->size); gsl_spline_init(spline, omega_w_vec->data, omega_t_vec->data, omega_t_vec->size); ref_time = gsl_spline_eval(spline, fRef * (LAL_MTSUN_SI * LAL_PI), acc); gsl_vector_free(omega_t_vec); gsl_vector_free(omega_w_vec); gsl_spline_free(spline); gsl_interp_accel_free(acc); return ref_time; #endif }
UNUSED static REAL8 XLALSimInspiralNRWaveformGetInterpValueFromGroupAtPoint( UNUSED LALH5File* file, /**< Pointer to HDF5 file */ UNUSED const char *groupName, /**< Name of group in HDF file */ UNUSED REAL8 ref_point /**< Point at which to evaluate */ ) { #ifndef LAL_HDF5_ENABLED XLAL_ERROR(XLAL_EFAILED, "HDF5 support not enabled"); #else LALH5File *curr_group = NULL; gsl_vector *curr_t_vec = NULL; gsl_vector *curr_y_vec = NULL; gsl_interp_accel *acc; gsl_spline *spline; REAL8 ret_val; curr_group = XLALH5GroupOpen(file, groupName); ReadHDF5RealVectorDataset(curr_group, "X", &curr_t_vec); ReadHDF5RealVectorDataset(curr_group, "Y", &curr_y_vec); acc = gsl_interp_accel_alloc(); spline = gsl_spline_alloc(gsl_interp_cspline, curr_t_vec->size); gsl_spline_init(spline, curr_t_vec->data, curr_y_vec->data, curr_t_vec->size); ret_val = gsl_spline_eval(spline, ref_point, acc); gsl_vector_free(curr_t_vec); gsl_vector_free(curr_y_vec); gsl_spline_free (spline); gsl_interp_accel_free (acc); return ret_val; #endif }
void regrid_sed(double z,double *plam,double *pval,long finelength, \ long sedlength,double *fineplam,double *finepval) { long ii; double x[sedlength],y[sedlength]; for (ii=0;ii<sedlength;ii++) { x[ii] = *(plam+ii) * (1.0 + z); y[ii] = *(pval+ii); } gsl_interp_accel *acc = gsl_interp_accel_alloc(); gsl_spline *spline = gsl_spline_alloc(gsl_interp_cspline, sedlength); gsl_spline_init(spline, x, y, sedlength); for (ii=0; ii < finelength; ii++) { if (*(fineplam+ii)/(1.0 + z) < *(plam+0)) { *(finepval+ii) = 0.0; } else { *(finepval+ii) = gsl_spline_eval (spline, *(fineplam+ii), acc); } if (*(finepval+ii) < 0.0) *(finepval+ii) = 0.0; } gsl_spline_free(spline); gsl_interp_accel_free(acc); }
void spline(double *YY, double *X, double *Y, double *XX, int m1, int m2) { // m1: length of discrete extremas // m2: length of original data points gsl_interp_accel *acc = gsl_interp_accel_alloc (); const gsl_interp_type *t = gsl_interp_cspline; gsl_spline *spline = gsl_spline_alloc (t, m1); /* Core function */ gsl_spline_init (spline, X, Y, m1); double m; if (m1 > 2 ) { for (int j = 0; j < m2; j++) { YY[j] = gsl_spline_eval (spline, XX[j], acc); } // end of for-j } // end of if else { m = (Y[1] - Y[0]) / (X[1] - X[0]); for (int j = 0; j < m2; j++) { YY[j] = Y[0] + m * (XX[j] - X[0]); } // end of for-j } //end of else // delete[] xd; gsl_spline_free (spline); gsl_interp_accel_free (acc); }
int main (void) { int i; double xi, yi; double x[10], y[10]; printf ("#m=0,S=2\n"); for (i = 0; i < 10; i++) { x[i] = i + 0.5 * sin (i); y[i] = i + cos (i * i); printf ("%g %g\n", x[i], y[i]); } printf ("#m=1,S=0\n"); { gsl_interp_accel *acc = gsl_interp_accel_alloc (); gsl_spline *spline = gsl_spline_alloc (gsl_interp_cspline, 10); gsl_spline_init (spline, x, y, 10); for (xi = x[0]; xi < x[9]; xi += 0.01) { double yi = gsl_spline_eval (spline, xi, acc); printf ("%g %g\n", xi, yi); } gsl_spline_free (spline); gsl_interp_accel_free(acc); } }
void prep_et() { /* Set ups the spline to sample et. */ double et; double gn0 = -1, gt0; slLimit = 6*mu - mu*kn/kt; double *x = (double*)calloc(100, sizeof(double)); double *y = (double*)calloc(100, sizeof(double)); /* Write first point. */ x[0] = 0; y[0] = cos(sqrt(3*kt/meff)*t_col()); /* Calculate intermediate points. */ long i; for (i = 1; i < 100; i++) { gt0 = slLimit/100.0*i; double ratio = fabs(gt0/(double)gn0); et = calculate_et(gn0, gt0); x[i] = ratio; y[i] = et; } /* Write last point. */ x[100] = 6*mu - mu*kn/kt; y[100] = 1 - 3*mu*(1 + calc_en())/x[100]; /* Interpolation with cubic spline. */ acc = gsl_interp_accel_alloc(); spline = gsl_spline_alloc(gsl_interp_cspline, 101); gsl_spline_init(spline, x, y, 101); }
UNUSED static UINT4 XLALSimInspiralNRWaveformGetDataFromHDF5File( UNUSED REAL8Vector** output, /**< Returned vector uncompressed */ UNUSED LALH5File* pointer, /**< Pointer to HDF5 file */ UNUSED REAL8 totalMass, /**< Total mass of system for scaling */ UNUSED REAL8 startTime, /**< Start time of veturn vector */ UNUSED size_t length, /**< Length of returned vector */ UNUSED REAL8 deltaT, /**< Sample rate of returned vector */ UNUSED const char *keyName /**< Name of vector to uncompress */ ) { #ifndef LAL_HDF5_ENABLED XLAL_ERROR(XLAL_EFAILED, "HDF5 support not enabled"); #else UINT4 idx; size_t comp_data_length; REAL8 massTime; gsl_interp_accel *acc; gsl_spline *spline; gsl_vector *knotsVector, *dataVector; LALH5File *group = XLALH5GroupOpen(pointer, keyName); knotsVector=dataVector=NULL; ReadHDF5RealVectorDataset(group, "X", &knotsVector); ReadHDF5RealVectorDataset(group, "Y", &dataVector); *output = XLALCreateREAL8Vector(length); comp_data_length = dataVector->size; /* SPLINE STUFF */ acc = gsl_interp_accel_alloc(); spline = gsl_spline_alloc(gsl_interp_cspline, comp_data_length); gsl_spline_init(spline, knotsVector->data, dataVector->data, comp_data_length); for (idx = 0; idx < length; idx++) { massTime = (startTime + idx*deltaT) / (totalMass * LAL_MTSUN_SI); /* This if statement is used to catch the case where massTime at idx=0 * ends up at double precision smaller than the first point in the * interpolation. In this case set it back to exactly the first point. * Sanity checking that we are not trying to use data below the * interpolation range is done elsewhere. */ if ((idx == 0) && (massTime < knotsVector->data[0])) { massTime = knotsVector->data[0]; } (*output)->data[idx] = gsl_spline_eval(spline, massTime, acc); } gsl_vector_free(knotsVector); gsl_vector_free(dataVector); gsl_spline_free (spline); gsl_interp_accel_free (acc); return XLAL_SUCCESS; #endif }
void FC_FUNC_(oct_spline_fit, OCT_SPLINE_FIT) (const int *nrc, const double *x, const double *y, void **spl, void **acc) { /* the GSL headers actually specify size_t instead of const int for nrc */ *acc = (void *)gsl_interp_accel_alloc(); *spl = (void *)gsl_spline_alloc(gsl_interp_cspline, *nrc); gsl_spline_init((gsl_spline *)(*spl), x, y, *nrc); fflush(stdout); }
void compute_correlation_func(int ObsNr, double *binsamdata, int snap, float mingalmass, float maxgalmass) { double *r,*proj,*r_tmp,*proj_tmp; int ibin, ii, jj; char buf[1000]; FILE *fa; gsl_spline *Proj_Spline; gsl_interp_accel *Proj_SplineAcc; NR=60; //printf("\ncalculating correlation function %0.2f < M < %0.2f\n",mingalmass,maxgalmass); r=malloc(NR*sizeof(double)); proj=malloc(NR*sizeof(double)); halomodel(r,proj,mingalmass,maxgalmass,snap); Proj_Spline=gsl_spline_alloc(gsl_interp_cspline,NR); Proj_SplineAcc=gsl_interp_accel_alloc(); gsl_spline_init(Proj_Spline,r,proj,NR); //for(ii=0;ii<Nbins[snap][ObsNr]-1;ii++) // printf("Nbins=%d r=%g\n",Nbins[snap][ObsNr], MCMC_Obs[ObsNr].Bin_low[snap][ii]+(MCMC_Obs[ObsNr].Bin_high[snap][ii]-MCMC_Obs[ObsNr].Bin_low[snap][ii])/2.) for(ii=0;ii<Nbins[snap][ObsNr]-1;ii++) binsamdata[ii]=gsl_spline_eval(Proj_Spline,MCMC_Obs[ObsNr].Bin_low[snap][ii]+(MCMC_Obs[ObsNr].Bin_high[snap][ii]-MCMC_Obs[ObsNr].Bin_low[snap][ii])/2.,Proj_SplineAcc); #ifndef PARALLEL //full3 - full PLANCK sprintf(buf, "%s/correlation_guo10_bug_fix_full_z0.02_%0.2f_%0.2f.txt",OutputDir, mingalmass,maxgalmass); if(!(fa = fopen(buf, "w"))) { char sbuf[1000]; sprintf(sbuf, "can't open file `%s'\n", buf); terminate(sbuf); } for(ii=0;ii<Nbins[snap][ObsNr]-1;ii++) fprintf(fa, "%g %g %g\n", MCMC_Obs[ObsNr].Bin_low[snap][ii]+(MCMC_Obs[ObsNr].Bin_high[snap][ii]-MCMC_Obs[ObsNr].Bin_low[snap][ii])/2.,binsamdata[ii],binsamdata[ii]*0.1); //for(ii=0;ii<NR;ii++) //fprintf(fa, "%g %g %g\n", r[ii],proj[ii],proj[ii]*0.1); fclose(fa); #endif //original wrp calculation out of halo_model //printf("\n\n %g<M<%g",mingalmass,maxgalmass); //for(ii=0;ii<NR;ii++) // printf("r=%g proj=%g\n",r[ii],proj[ii]); //interpolated into obs bins //for(ii=0;ii<Nbins[snap][ObsNr]-1;ii++) // printf("%g %g %g\n", MCMC_Obs[ObsNr].Bin_low[snap][ii]+(MCMC_Obs[ObsNr].Bin_high[snap][ii]-MCMC_Obs[ObsNr].Bin_low[snap][ii])/2.,binsamdata[ii],binsamdata[ii]*0.1); free(r); free(proj); gsl_spline_free(Proj_Spline); gsl_interp_accel_free(Proj_SplineAcc); }
void read_red_dist(void) { ////// // Reads redshift distribution and creates // array for interpolation FILE *fdist; double *zarr,*dndz_dist_arr; int n_z_dist; int ii; fdist=fopen(fnamedNdz,"r"); if(fdist==NULL) error_open_file(fnamedNdz); print_info("*** Reading redshift selection function "); #ifdef _VERBOSE print_info("from file %s",fnamedNdz); #endif //_VERBOSE print_info("\n"); n_z_dist=linecount(fdist); rewind(fdist); dndz_dist_arr=(double *)my_malloc(n_z_dist*sizeof(double)); zarr=(double *)my_malloc(n_z_dist*sizeof(double)); for(ii=0;ii<n_z_dist;ii++) { int sr=fscanf(fdist,"%lf %lf",&(zarr[ii]),&(dndz_dist_arr[ii])); if(sr!=2) error_read_line(fnamedNdz,ii+1); if(dndz_dist_arr[ii]>=dist_max) dist_max=dndz_dist_arr[ii]; } fclose(fdist); dist_max*=1.1; dndz_set=1; #ifdef _DEBUG char dfname[64]="debug_dndz.dat"; fdist=fopen(dfname,"w"); if(fdist==NULL) error_open_file(dfname); for(ii=0;ii<n_z_dist;ii++) fprintf(fdist,"%lf %lf \n",zarr[ii],dndz_dist_arr[ii]); fclose(fdist); #endif //_DEBUG redshift_0=zarr[0]; redshift_f=zarr[n_z_dist-1]; cute_intacc_dndz=gsl_interp_accel_alloc(); cute_spline_dndz=gsl_spline_alloc(gsl_interp_cspline,n_z_dist); gsl_spline_init(cute_spline_dndz,zarr,dndz_dist_arr,n_z_dist); free(zarr); free(dndz_dist_arr); print_info("\n"); }
ODEparams * init(int nap,double * alpha,double * talpha, int nbp, double* beta, double *tbeta,double gamma, double x0,double y0) { ODEparams * pa= (ODEparams*)malloc(sizeof(ODEparams)); pa->gamma=gamma; pa->x0=x0; pa->y0=y0; pa->nap=nap; pa->nbp=nbp; pa->alpha=calloc(nap,sizeof(double)); pa->talpha=calloc(nap,sizeof(double)); pa->beta=calloc(nbp,sizeof(double)); pa->tbeta=calloc(nbp,sizeof(double)); int i; memcpy(pa->alpha,alpha,nap*sizeof(double)); memcpy(pa->talpha,talpha,nap*sizeof(double)); memcpy(pa->beta,beta,nbp*sizeof(double)); memcpy(pa->tbeta,tbeta,nbp*sizeof(double)); /* int i; / for(i=0;i<nbp;i++) printf("%lg",pa->tb[i]);*/ pa->a_acc=gsl_interp_accel_alloc (); pa->b_acc=gsl_interp_accel_alloc (); pa->a_spline = gsl_spline_alloc (gsl_interp_linear,nap); int err = gsl_spline_init (pa->a_spline, pa->talpha, pa->alpha, pa->nap); if (err != GSL_SUCCESS) { mexErrMsgTxt("error: init vector interp - not good size / not increasing"); } pa->b_spline = gsl_spline_alloc (gsl_interp_linear,nbp); err = gsl_spline_init (pa->b_spline, pa->tbeta, pa->beta, pa->nbp); if (err != GSL_SUCCESS) { mexErrMsgTxt("error: init vector interp - not good size / not increasing"); } pa->gamma=gamma; pa->x0=x0; pa->y0=y0; return pa; }
double get_interpolated_value(double x_array[], double y_array[], int npts, double A) { double V; gsl_interp_accel *gia = gsl_interp_accel_alloc(); #ifdef INTERP_CSPLINE gsl_spline *gs = gsl_spline_alloc(gsl_interp_cspline, npts); #else gsl_spline *gs = gsl_spline_alloc(gsl_interp_akima, npts); #endif gsl_spline_init(gs, x_array, y_array, npts); V = gsl_spline_eval(gs,A,gia); //V = gsl_interp_eval(gsl_interp_akima, x_array, y_array, A, gia); gsl_spline_free (gs); gsl_interp_accel_free (gia); return V; }
cMorph& cMorph::operator=(const cMorph &source) { if (this != &source) { listSize = source.listSize; interpolationAccelerator = gsl_interp_accel_alloc(); splineAkimaPeriodic = gsl_spline_alloc(gsl_interp_akima_periodic, listSize); dataSets = source.dataSets; } return *this; }
int tester(const std::string & input_file) { //temperature std::vector<Scalar> T0,Tz; read_temperature<Scalar>(T0,Tz,input_file); gsl_interp_accel * acc = gsl_interp_accel_alloc(); gsl_spline * spline = gsl_spline_alloc(gsl_interp_cspline, T0.size()); // GLS takes only double, raaaaahhhh std::vector<double> gsl_x_point(T0.size(),0); std::vector<double> gsl_y_point(T0.size(),0); for(unsigned int i = 0; i < T0.size(); i++) { gsl_x_point[i] = (const double)Tz[i]; gsl_y_point[i] = (const double)T0[i]; } const double * x = &gsl_x_point[0]; const double * y = &gsl_y_point[0]; gsl_spline_init(spline, x, y, T0.size()); Planet::AtmosphericTemperature<Scalar,std::vector<Scalar> > temperature(Tz,T0); //neutral, ionic, altitude int return_flag(0); const Scalar tol = (std::numeric_limits<Scalar>::epsilon() * 100. < 6e-17)?6e-17: std::numeric_limits<Scalar>::epsilon() * 100.; for(Scalar z = 600.; z < 1401.; z += 10) { Scalar neu_temp = gsl_spline_eval(spline,z,acc); Scalar neu_dtemp = gsl_spline_eval_deriv(spline,z,acc); Scalar ion_temp = gsl_spline_eval(spline,z,acc); Scalar ion_dtemp = gsl_spline_eval_deriv(spline,z,acc); Scalar e_temp = electron_temperature(z); Scalar de_dtemp = delectron_temperature(z); return_flag = check(temperature.neutral_temperature(z), neu_temp, tol, "neutral temperature") || check(temperature.dneutral_temperature_dz(z), neu_dtemp, tol, "neutral temperature differentiate") || check(temperature.ionic_temperature(z), ion_temp, tol, "ionic temperature") || check(temperature.dionic_temperature_dz(z), ion_dtemp, tol, "ionic temperature differentiate") || check(temperature.electronic_temperature(z), e_temp, tol, "electron temperature") || check(temperature.delectronic_temperature_dz(z), de_dtemp, tol, "electron temperature differentiate") || return_flag; } gsl_spline_free(spline); gsl_interp_accel_free(acc); return return_flag; }
double get_linear_interpolated_value(double x_array[], double y_array[], int npts, double A) { double V; gsl_interp_accel *gia = gsl_interp_accel_alloc(); gsl_spline *gs = gsl_spline_alloc(gsl_interp_linear, npts); gsl_spline_init(gs, x_array, y_array, npts); V = gsl_spline_eval(gs,A,gia); gsl_spline_free (gs); gsl_interp_accel_free (gia); return V; }
static void local_doInterpolation(cosmoPk_t pk) { if (pk->acc != NULL) gsl_interp_accel_free(pk->acc); if (pk->spline != NULL) gsl_spline_free(pk->spline); pk->acc = gsl_interp_accel_alloc(); pk->spline = gsl_spline_alloc(gsl_interp_cspline, (int)(pk->numPoints)); gsl_spline_init(pk->spline, pk->k, pk->P, (int)(pk->numPoints)); }
qreal XYSPline::interpolateS(qreal x) { if (m_spline == 0) { m_spline = gsl_spline_alloc(gsl_interp_cspline, m_points.size()); m_xs = m_points.keys().toVector(); m_ys = m_points.values().toVector(); gsl_spline_init(m_spline, m_xs.constData(), m_ys.constData(), m_points.size()); } return gsl_spline_eval(m_spline, x, m_accel); }