{"text": "// An interface to GSL - hides all the gsl calls behind easier to use functions\n// Jason Sanders\n#ifndef GSLINTERFACE_H\n#define GSLINTERFACE_H\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n//=================================================================================================\n// RANDOM NUMBERS //\n// random number generators - rand_uniform returns random numbers uniformly distributed in the \n// interval [0,1], rand_gaussian returns gaussian distributed random numbers with sd = sigma\n\nclass rand_base{\n\tprivate:\n\t\tconst gsl_rng_type * TYPE;\n\t\tunsigned long int seed;\n public:\n \tgsl_rng * r;\n \trand_base(unsigned long int s){\n \t// construct random number generator with seed s\n \t\tseed = s;\n \t\tgsl_rng_env_setup();\n \t TYPE = gsl_rng_default;\n \t\tr = gsl_rng_alloc (TYPE);\n \t\tgsl_rng_set(r, seed);\n \t\t}\n \t~rand_base(){gsl_rng_free (r);}\n \tvoid reseed(unsigned long int newseed){\n \t// give new seed\n \t\tseed = newseed;\n \t\tgsl_rng_set(r,newseed);\n \t\t}\n};\n\nclass rand_uniform:public rand_base{\n\tpublic:\n\t\trand_uniform(unsigned long int SEED=0):rand_base(SEED){}\n\t\t~rand_uniform(){}\n\t\t// return uniformly distributed random numbers\n\t\tdouble nextnumber(){return gsl_rng_uniform (r);}\n};\n\nclass rand_gaussian:public rand_base{\n\tpublic:\n\t\tdouble sigma;\n\t\trand_gaussian(double s, unsigned long int SEED=0):rand_base(SEED){sigma = s;}\n\t\t~rand_gaussian(){}\n\t\t// return gaussian distributed random numbers\n\t\tdouble nextnumber(){return gsl_ran_gaussian (r,sigma);}\n\t\tvoid newsigma(double newsigma){sigma=newsigma;}\n};\n\n//=================================================================================================\n// ROOT FINDING\t //\n// finds root by Brent's method. Constructor initialises function and tolerances, findroot finds \n// root in given interval. Function must be of form double(*func)(double,void*)\n\nclass root_find{\n\tprivate:\n\t\tint status;\n \tconst gsl_root_fsolver_type *T; gsl_root_fsolver *s;\n \tgsl_function F;\tdouble xlo,xhi,eps,root,tol;\n \tint iter, max_iter;\n public:\n \troot_find(double tol,int max_iter)\n \t\t: tol(tol), max_iter(max_iter){\n \t\titer=0;eps=1.e-8;\n \t\tT = gsl_root_fsolver_brent;\n \t\ts = gsl_root_fsolver_alloc (T);\n\t\t}\n\t\t~root_find(){gsl_root_fsolver_free (s);}\n\t\t\n \tvoid bracket(){\n \t\t// crude bracketing routine. Expands interval till root found\n\t\t\tif(xhi0.){\n\t\t\t\txlo-=diff;xhi+=diff;\n\t\t\t}\n\t\t}\n\t\t\n \tdouble findroot(double(*func)(double,void *),double xlo1,double xhi1, void *p=NULL){\n \t\t// finds root in interval [xlo1,xhi1]\n \t\tF.function = func;F.params=p;xhi = xhi1; xlo = xlo1;\n \t if(GSL_FN_EVAL(&F,xlo)*GSL_FN_EVAL(&F,xhi)>0.){\n \t\t\tbracket();\n \t\t}\n \t\tgsl_root_fsolver_set (s, &F, xlo, xhi);\n\t\t\tdo{\n\t\t\t\titer++;\n\t\t\t\tstatus = gsl_root_fsolver_iterate (s);\n\t\t\t\troot = gsl_root_fsolver_root (s);\n\t\t\t\txlo = gsl_root_fsolver_x_lower (s);\n\t\t\t\txhi = gsl_root_fsolver_x_upper (s);\n\t\t\t\tstatus = gsl_root_test_interval (xlo, xhi, tol, eps);\n\t\t\t }\n\t\t\twhile (status == GSL_CONTINUE && iter < max_iter); \n \t\treturn root;\n\t\t}\n\t\t\n};\n\n//=================================================================================================\n// INTEGRATION //\n// Simple 1d numerical integration using adaptive Gauss-Kronrod which can deal with singularities\n// constructor takes function and tolerances and integrate integrates over specified region.\n// integrand function must be of the form double(*func)(double,void*)\nclass integrator{\n\tprivate:\n\t\tgsl_integration_workspace *w;\n\t\tvoid *p;\n\t\tdouble result,err,eps;\n\t\tgsl_function F;\n\t\tsize_t neval;\n\tpublic:\n\t\tintegrator(double eps): eps(eps){\n\t\t\tw= gsl_integration_workspace_alloc (1000);\n\t\t\tF.params = &p;\n \t\t}\n\t\t~integrator(){gsl_integration_workspace_free (w);}\n\t\tdouble integrate(double(*func)(double,void*),double xa, double xb){\n\t\t F.function = func;\n\t\t\tgsl_integration_qags (&F, xa, xb, 0, eps, 1000,w, &result, &err);\n\t\t\t//gsl_integration_qng(&F, xa, xb, 0, eps, &result, &err, &neval);\n\t\t\treturn result;\n\t\t\t}\n\t\tdouble error(){return err;}\n};\n\ninline double integrate(double(*func)(double,void*),double xa, double xb, double eps){\n\tdouble result,err; size_t neval;void *p;gsl_function F;F.function = func;F.params = &p;\n\tgsl_integration_qng(&F, xa, xb, 0, eps, &result, &err, &neval);\n\treturn result;\n}\n\nclass MCintegrator{\n\tprivate:\n\t\tgsl_monte_vegas_state *s;\n\t\tconst gsl_rng_type *T;\n \t\tgsl_rng *r;\n \t\tsize_t dim;\n \tpublic:\n \t\tMCintegrator(size_t Dim){\n \t\t\tdim=Dim;\n \t\t\tgsl_rng_env_setup ();\n \t\t\tT = gsl_rng_default;\n \t\t\tr = gsl_rng_alloc (T);\n \t\t\ts=gsl_monte_vegas_alloc(Dim);\n \t\t}\n \t\t~MCintegrator(){\n \t\t\tgsl_monte_vegas_free(s);\n \t\t\tgsl_rng_free(r);\n \t\t}\n \t\tdouble integrate(double(*func)(double*,size_t,void*),double *xlow, double *xhigh,\n \t\tsize_t calls, double *err, int burnin=10000){\n \t\t\tgsl_monte_function G = { func, dim, 0 }; double res;\n \t\t\tif(burnin)gsl_monte_vegas_integrate(&G,xlow,xhigh,dim,burnin,r,s,&res,err);\n \t\t\tgsl_monte_vegas_integrate(&G,xlow,xhigh,dim,calls,r,s,&res,err);\n \t\t\treturn res;\n \t\t}\n};\n\n//=================================================================================================\n// 1D INTERPOLATION //\n// Interpolation using cubic splines\n\nclass interpolator{\n\tprivate:\n\t\tgsl_interp_accel *acc;\n\t\tgsl_spline *spline;\n\tpublic:\n\t\tinterpolator(double *x, double *y, int n){\n\t\t\tacc = gsl_interp_accel_alloc();\n\t\t\tspline = gsl_spline_alloc(gsl_interp_cspline,n);\n\t\t\tgsl_spline_init (spline, x, y, n);\n\t\t}\n\t\t~interpolator(){\n\t\t\tgsl_spline_free (spline);\n \tgsl_interp_accel_free (acc);\n }\n double interpolate(double xi){\n \treturn gsl_spline_eval (spline, xi, acc);\n }\n double derivative(double xi){\n \treturn gsl_spline_eval_deriv(spline, xi, acc);\n }\n void new_arrays(double *x, double *y,int n){\n \tspline = gsl_spline_alloc(gsl_interp_cspline,n);\n \tgsl_spline_init (spline, x, y, n);\n }\n};\n \n//=================================================================================================\n// SORTING //\n// sorting algorithm\n// sort2 sorts first argument and then applies the sorted permutation to second list\nclass sorter{\n\tprivate:\n\t\tconst gsl_rng_type * T;\n \tgsl_rng * r;\n public:\n \tsorter(){\n \t\tgsl_rng_env_setup();\n T = gsl_rng_default;\n \t\tr = gsl_rng_alloc (T);\n \t\t}\n \t~sorter(){gsl_rng_free (r);}\n \tvoid sort(double *data, int n){\n \t\tgsl_sort(data,1,n);\n \t}\n \tvoid sort2(double *data, int n, double *data2){\n \t\tsize_t p[n];\n \t\tgsl_sort_index(p,data,1,n);\n \t\tgsl_permute(p,data2,1,n);\n \t}\n \t\n};\n\n//=================================================================================================\n// ODE SOLVER //\n// Simple ODE integrator using Runge-Kutta Dormand-Prince 8 adaptive stepping\n// dy_i/dt = f_i(t) where int (*f)(double t, const double y, double f, void *params)\n\nclass ode{\n\tprivate:\n\t\tconst gsl_odeiv2_step_type * T;\n\t\tgsl_odeiv2_step * s;\n\t\tgsl_odeiv2_control * c;\n\t\tgsl_odeiv2_evolve * e;\n \t\tgsl_odeiv2_system sys;\n\t\tint N;double h,eps;\n\t\tdouble direction; \n\tpublic:\n\t\tode(int (*derivs)(double,const double *,double*,void*),int N,double eps, void *params=NULL):N(N),eps(eps){\n\t\t\tsys.function=derivs;sys.jacobian=NULL;sys.dimension=N;sys.params=params;\n\t\t\t\n\t\t\tT = gsl_odeiv2_step_rk8pd;s = gsl_odeiv2_step_alloc (T, N);\n\t\t\tc = gsl_odeiv2_control_y_new (eps, 0.0);e = gsl_odeiv2_evolve_alloc (N);\n\t\t\tgsl_ieee_env_setup();\n\t\t}\n\t\t~ode(){\n\t\t\tgsl_odeiv2_evolve_free(e);\n \t\t\tgsl_odeiv2_control_free(c);\n \t\t\tgsl_odeiv2_step_free(s);\n \t\t}\n\t\tvoid step(double tstart, double tfinish, double *y, double step){\n\t\t\th = step;\n\t\t\tdirection = (h>0?1.:-1.);\n\t\t\twhile ((tfinish-tstart)*direction>0){\n \t\t\tint status = gsl_odeiv2_evolve_apply (e, c, s, &sys, &tstart, tfinish, &h, y);\n \t\t\tif (status != GSL_SUCCESS)break;\n \t\t}\n\t\t}\n};\n\n//=================================================================================================\n// MINIMISER //\n// finds a minimum of a function of the form double(*func)(const gsl_vector *v, void *params)\n// using a downhill simplex algorithm. Setup minimiser with initial guesses and required tolerance\n// with constructor and then minimise with minimise().\n\nclass minimiser{\n\tprivate:\n\t\tconst gsl_multimin_fminimizer_type *T; ;\n\t\tgsl_multimin_fminimizer *s;\n\t\tgsl_vector *ss, *x; \n\t\tgsl_multimin_function minex_func;\n\t\tsize_t iter; int status,N_params; double size;\n\t\tdouble eps;\n\tpublic:\n\t\tminimiser(double(*func)(const gsl_vector *v, void *params),double *parameters,\n\t\t int N, double *sizes, double eps):N_params(N), eps(eps){\n\n\t\t\tT = gsl_multimin_fminimizer_nmsimplex2rand;\n\t\t\tss = gsl_vector_alloc (N_params);x = gsl_vector_alloc (N_params);\n\t\t\tfor(int i=0;ix,i)<<\" \";\n\t\t\t\t\t\t\tstd::cout<fval<<\" \"<x,i);}\n\t\t\treturn s->fval;\n\t\t}\n};\n\nclass minimiser1D{\n\tprivate:\n\t\tconst gsl_min_fminimizer_type *T; ;\n\t\tgsl_min_fminimizer *s; \n\t\tsize_t iter; int status; double size;\n\t\tdouble m, a, b, eps;\n\tpublic:\n\t\tminimiser1D(double(*func)(double, void *params), double m, double a, double b, double eps)\n\t\t\t:m(m), a(a), b(b), eps(eps){\n\n\t\t\tgsl_function F;F.function = func;F.params = 0;\n\t\t\tT = gsl_min_fminimizer_brent;\n\t\t\ts = gsl_min_fminimizer_alloc (T); \n\t\t\tgsl_min_fminimizer_set (s, &F, m, a, b);\n\t\t\tstatus = 0; iter = 0;\n\t\t}\n\t\t~minimiser1D(){\t\n\t\t\tgsl_min_fminimizer_free (s);\n\t\t}\n\t\tdouble minimise(unsigned int maxiter){\n\t\t\tdo\n\t\t\t {\n\t\t\t\titer++; \n\t\t\t\tstatus = gsl_min_fminimizer_iterate(s);\n\t\t\t\tm = gsl_min_fminimizer_x_minimum (s);\n \t\ta = gsl_min_fminimizer_x_lower (s);\n \t\tb = gsl_min_fminimizer_x_upper (s);\n\t\t\t\tstatus = gsl_min_test_interval (a, b, eps, 0.0);\n\t\t\t}\n\t\t\twhile (status == GSL_CONTINUE && iter < maxiter);\n\t\t\treturn m;\n\t\t}\n};\n/*\ndouble Distance(void *xp, void *yp){\n double x = *((double *) xp);\n double y = *((double *) yp);\n return fabs(x - y);\n}\n\nvoid Step(const gsl_rng * r, void *xp, double step_size){\n double old_x = *((double *) xp);\n double new_x;\n \n double u = gsl_rng_uniform(r);\n new_x = u * 2 * step_size - step_size + old_x;\n \n memcpy(xp, &new_x, sizeof(new_x));\n}\n\nvoid Print(void *xp){\n printf (\"%12g\", *((double *) xp));\n}\n\nclass sim_anneal{\n\tprivate:\n\t\tconst gsl_rng_type * T;\n \tgsl_rng * r;\n \tint N_TRIES, ITER_FIXED_T;\n \tdouble STEP_SIZE, K, T_INITIAL, MU_T, T_MIN;\n \tgsl_siman_params_t params;\n public:\n \tsim_anneal(int N_TRIES, int ITER_FIXED_T, double STEP_SIZE):\n \tN_TRIES(N_TRIES), ITER_FIXED_T(ITER_FIXED_T),STEP_SIZE(STEP_SIZE){\n \t\tgsl_rng_env_setup();\n T = gsl_rng_default;\n \t \tr = gsl_rng_alloc(T);\n \t \t//params[0]=N_TRIES;params[1]=ITER_FIZED_T;params[2]=STEP_SIZE;\n \t \t//K=1.; params[3]=K; T_INITIAL=0.008; params[4]=T_INITIAL;\n \t \t//MU_T=1.003; params[5]=MU_T; T_MIN=2.0e-6; params[6]=T_MIN;\n \t \tgsl_siman_params_t params \n = {N_TRIES, ITERS_FIXED_T, STEP_SIZE,\n K, T_INITIAL, MU_T, T_MIN};\n \t}\n \t~sim_anneal(){\n \t\tgsl_rng_free(r);\n \t}\n \tdouble minimise(double(*func)(void *xp), double x){\n \t\tdouble x_initial=x;\n \t\tgsl_siman_solve(r, &x_initial, &func, Step, Distance, Print,\n \t\tNULL, NULL, NULL, \n \t\tsizeof(double), params);\n \t\treturn x_initial;\n \t}\n};*/\n\n//=================================================================================================\n// SPECIAL FUNCTIONS //\ninline double erf(double x){return gsl_sf_erf (x);}\ninline double erfc(double x){return gsl_sf_erfc (x);}\ninline double besselI(double x, int n){return gsl_sf_bessel_In (n,x);}\ninline double besselJ(double x, int n){return gsl_sf_bessel_Jn (n,x);}\ninline double gamma(double x){return gsl_sf_gamma (x);}\ninline double ellint_first(double phi, double k){ return gsl_sf_ellint_F(phi,k,1e-15);}\n// F(\\phi,k) = \\int_0^\\phi \\d t \\, \\frac{1}{\\sqrt{1-k^2\\sin^2 t}}\ninline double ellint_second(double phi, double k){ return gsl_sf_ellint_E(phi,k,1e-15);}\n// E(\\phi,k) = \\int_0^\\phi \\d t \\, \\sqrt{1-k^2\\sin^2 t}\ninline double ellint_third(double phi, double k, double n){ return gsl_sf_ellint_P(phi,k,n,1e-15);}\n// \\Pi(\\phi,k,n) = \\int_0^\\phi \\d t \\, \\frac{1}{(1+n\\sin^2 t)\\sqrt{1-k^2\\sin^2 t}}\n#endif\n", "meta": {"hexsha": "52b452f8fed9d6372c70bd7eb6e542d0ad6d5369", "size": 13846, "ext": "h", "lang": "C", "max_stars_repo_path": "new_struct/inc/GSLInterface.h", "max_stars_repo_name": "jlsanders/genfunc", "max_stars_repo_head_hexsha": "6a608a21651be37462e42289c0a15233b8e29bbb", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2019-05-12T13:24:27.000Z", "max_stars_repo_stars_event_max_datetime": "2019-10-14T01:06:54.000Z", "max_issues_repo_path": "new_struct/inc/GSLInterface.h", "max_issues_repo_name": "jlsanders/genfunc", "max_issues_repo_head_hexsha": "6a608a21651be37462e42289c0a15233b8e29bbb", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "new_struct/inc/GSLInterface.h", "max_forks_repo_name": "jlsanders/genfunc", "max_forks_repo_head_hexsha": "6a608a21651be37462e42289c0a15233b8e29bbb", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.2750582751, "max_line_length": 108, "alphanum_fraction": 0.6193124368, "num_tokens": 3989, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8056321889812553, "lm_q2_score": 0.682573740869499, "lm_q1q2_score": 0.5499033769978185}} {"text": "/* examples/C/ssmfe/precond_core.f90 */\n/* Laplacian on a square grid (using SPRAL_SSMFE_CORE routines) */\n#include \"spral.h\"\n#include \n#include \n#include \n#include \n\n/* Header that implements Laplacian and preconditioners */\n#include \"laplace2d.h\"\n\nint main(void) {\n const int ngrid = 20; /* grid points along each side */\n const int n = ngrid*ngrid; /* problem size */\n const int nep = 5; /* eigenpairs wanted */\n const int m = 3; /* dimension of the iterated subspace */\n const double tol = 1.e-6; /* eigenvector tolerance */\n\n int state = SPRAL_RANDOM_INITIAL_SEED; /* PRNG state */\n\n int ind[m]; /* permutation index */\n double lambda[n]; /* eigenvalues */\n double X[n][n]; /* eigenvectors */\n /* Work arrays */\n double lmd[m];\n double rr[3][2*m][2*m];\n double W[7][m][n];\n double U[m][n];\n\n /* Derived types */\n struct spral_ssmfe_rcid rci; /* reverse communication data */\n struct spral_ssmfe_core_options options; /* options */\n void *keep; /* private data */\n struct spral_ssmfe_inform inform; /* information */\n\n /* Initialize options to default values */\n spral_ssmfe_core_default_options(&options);\n\n /* Initialize W to lin indep vectors by randomizing */\n for(int i=0; i 0 && inform.err_X[j] < tol )\n inform.converged[j] = 1;\n }\n break;\n case 5:\n if ( rci.i < 0 ) continue;\n for(int k=0; k= nep || inform.iteration > 300 ) goto finished;\n break;\n case 11:\n if ( rci.i == 0 ) {\n if ( rci.kx != rci.ky || rci.jx > rci.jy ) {\n cblas_dcopy(n*rci.nx, &W[rci.kx][rci.jx][0], 1, &W[rci.ky][rci.jy][0], 1);\n } else if ( rci.jx < rci.jy ) {\n for(int j=rci.nx-1; j>=0; j--)\n cblas_dcopy(n, &W[rci.kx][rci.jx+j][0], 1, &W[rci.ky][rci.jy+j][0], 1);\n }\n } else {\n for(int i=0; i 0 )\n cblas_dscal(n, 1/s, &W[rci.kx][rci.jx+i][0], 1);\n } else {\n double s = sqrt(fabs(cblas_ddot(\n n, &W[rci.kx][rci.jx+i][0], 1, &W[rci.ky][rci.jy+i][0], 1)\n ));\n if ( s > 0 ) {\n cblas_dscal(n, 1/s, &W[rci.kx][rci.jx+i][0], 1);\n cblas_dscal(n, 1/s, &W[rci.ky][rci.jy+i][0], 1);\n } else {\n for(int j=0; j 0 && rci.ny > 0 )\n cblas_dgemm(\n CblasColMajor, CblasTrans, CblasNoTrans, rci.nx, rci.ny, n,\n rci.alpha, &W[rci.kx][rci.jx][0], n, &W[rci.ky][rci.jy][0], n,\n rci.beta, &rr[rci.k][rci.j][rci.i], 2*m\n );\n break;\n case 16: // Fall through to 17\n case 17:\n if( rci.ny < 1 ) continue;\n if( rci.nx < 1 ) {\n if( rci.job == 17 ) continue;\n if( rci.beta == 1.0 ) continue;\n for(int j=rci.jy; j 0 ) {\n cblas_dgemm(\n CblasColMajor, CblasTrans, CblasNoTrans, ncon, rci.nx, n,\n 1.0, &X[0][0], n, &W[rci.ky][rci.jy][0], n, 0.0, &U[0][0], n\n );\n cblas_dgemm(\n CblasColMajor, CblasNoTrans, CblasNoTrans, n, rci.nx, ncon,\n -1.0, &X[0][0], n, &U[0][0], n, 1.0, &W[rci.kx][rci.jx][0], n\n );\n }\n break;\n default:\n goto finished;\n }\n }\nfinished:\n if(inform.flag != 0) printf(\"inform.flag = %d\\n\", inform.flag);\n printf(\"%3d eigenpairs converged in %d iterations\\n\", ncon, inform.iteration);\n for(int i=0; i\n#include \n#include \"scf.h\"\n\n\n/* Given the coefficients stored mat_cos and mat_sin, this code does\n * the summation to compute the potential and accelerations\n *\n * scf_potential() is the full 3D treatment for the host halo\n *\n * scf_potential_spherical() is the spherically symmetric treatment\n * for the subhalos. This spherical code skips the loops over l,m\n * so it's simpler.\n */\n\nfloat scf_potential(float* a, double* mat_cos, double* mat_sin, int orbit_nmax, int orbit_lmax, float x, float y, float z)\n{\n double x2 = (double)x * (double)x;\n double y2 = (double)y * (double)y;\n double r = sqrt(x2+y2+(double)z*(double)z);\n double r_xy = sqrt(x2+y2);\n double phi = atan2((double)y, (double)x);\n\n double sin_theta = r_xy / r;\n double sin_phi = (double)y / r_xy;\n double cos_theta = (double)z / r;\n double cos_phi = (double)x / r_xy;\n \n double cos_theta_for_Plm = cos_theta;\n \n#ifdef USE_GSL_GEGENBAUER_HOST\n double xi = (r-1.0)/(r+1.0);\n#endif\n\n\n double a_r = 0.0;\n double a_t = 0.0;\n double a_p = 0.0;\n\n int n,l,m;\n\n float C_lm = 0.0f;\n float D_lm = 0.0f;\n float E_lm = 0.0f;\n float F_lm = 0.0f;\n\n float this_Phi_nl = 0.f;\n float this_dPhi_nl_dr = 0.f;\n\n#ifdef USE_GSL_GEGENBAUER_HOST\n double* Cna_2l_32_array = (double*)malloc((orbit_nmax+1)*sizeof(double));\n double* Cna_2l_52_array = (double*)malloc(orbit_nmax*sizeof(double));\n#endif\n \n double this_P_lm = 0.0;\n double this_dP_lm = 0.0;\n double* P_l;\n double* dP_l;\n int P_size;\n \n float cos_mphi;\n float sin_mphi;\n\n float pot = 0.f;\n a[0] = 0.f;\n a[1] = 0.f;\n a[2] = 0.f;\n\t\n for(m=0; m<=orbit_lmax; m++)\n {\n cos_mphi = cos(m*phi);\n sin_mphi = sin(m*phi);\n \n P_size = orbit_lmax - m + 1;\n P_l = (double*)malloc(P_size*sizeof(double));\n dP_l = (double*)malloc(P_size*sizeof(double));\n \n gsl_sf_legendre_Plm_deriv_array(orbit_lmax, m, cos_theta_for_Plm, P_l, dP_l);\n \n for(l=m; l<=orbit_lmax; l++)\n {\n C_lm = 0.f;\n D_lm = 0.f;\n E_lm = 0.f;\n F_lm = 0.f;\n\n#ifdef USE_GSL_GEGENBAUER_HOST\n gsl_sf_gegenpoly_array(orbit_nmax, 2*l+1.5, xi, Cna_2l_32_array);\n if(orbit_nmax > 0)\n gsl_sf_gegenpoly_array(orbit_nmax-1, 2*l+2.5, xi, Cna_2l_52_array);\n#endif\n \n for(n=0; n<=orbit_nmax; n++)\n {\n#ifdef USE_GSL_GEGENBAUER_HOST\n this_Phi_nl = Phi_nl(Cna_2l_32_array[n], l, r);\n if(n>0)\n this_dPhi_nl_dr = dPhi_nl_dr(Cna_2l_52_array[n-1], this_Phi_nl, n, l, r);\n else\n this_dPhi_nl_dr = dPhi_nl_dr(1e99, this_Phi_nl, n, l, r);\n#else \n this_Phi_nl = Phi_nl(n,l,r);\n this_dPhi_nl_dr = dPhi_nl_dr(this_Phi_nl, n, l, r);\n#endif\n \n C_lm += mat_cos[ind(n,l,m)] * this_Phi_nl;\n D_lm += mat_sin[ind(n,l,m)] * this_Phi_nl;\n \n E_lm += mat_cos[ind(n,l,m)] * this_dPhi_nl_dr;\n F_lm += mat_sin[ind(n,l,m)] * this_dPhi_nl_dr;\n }\n \n this_P_lm = P_l[l-m];\n this_dP_lm = dP_l[l-m] * -sin_theta;\n \n pot += this_P_lm * (C_lm*cos_mphi + D_lm*sin_mphi);\n\n a_r += this_P_lm * (E_lm*cos_mphi + F_lm*sin_mphi);\n a_t += this_dP_lm * (C_lm*cos_mphi + D_lm*sin_mphi);\n a_p += m * this_P_lm * (D_lm*cos_mphi - C_lm*sin_mphi);\n\n } // l loop\n \n free(P_l);\n free(dP_l);\n\n } // m loop\n\n a_r = -a_r;\n a_t = -a_t/r;\n a_p = -a_p/r_xy;\n \n a[0] = a_r*sin_theta*cos_phi + a_t*cos_theta*cos_phi - a_p*sin_phi;\n a[1] = a_r*sin_theta*sin_phi + a_t*cos_theta*sin_phi + a_p*cos_phi;\n a[2] = a_r*cos_theta - a_t*sin_theta;\n\n a[0] *= G;\n a[1] *= G;\n a[2] *= G;\n pot *= G;\n \n#ifdef USE_GSL_GEGENBAUER_HOST\n free(Cna_2l_32_array);\n free(Cna_2l_52_array);\n#endif\n\n return pot;\n\n}\n\n\nfloat scf_potential_spherical(float* a, float* mat_cos, int orbit_nmax, float x, float y, float z)\n{\n float x2 = x*x;\n float y2 = y*y;\n \n float r = sqrt(x2+y2+z*z);\n float r_xy = sqrt(x2+y2);\n \n#ifdef USE_GSL_GEGENBAUER_SUBHALO\n float xi = (r-1.0f)/(r+1.0f);\n#endif\n\n float sin_theta = r_xy / r;\n float sin_phi = y / r_xy;\n float cos_theta = z / r;\n float cos_phi = x / r_xy;\n\n\n float this_Phi_n0 = 0.f;\n float this_dPhi_n0_dr = 0.f;\n \n#ifdef USE_GSL_GEGENBAUER_SUBHALO\n double* Cna_32_array = (double*)malloc((orbit_nmax+1)*sizeof(double));\n double* Cna_52_array = (double*)malloc(orbit_nmax*sizeof(double));\n gsl_sf_gegenpoly_array(orbit_nmax, 1.5, xi, Cna_32_array);\n gsl_sf_gegenpoly_array(orbit_nmax-1, 2.5, xi, Cna_52_array);\n#endif\n\n float C_lm = 0.0f;\n float E_lm = 0.0f;\n\n int n;\n for(n=0; n<=orbit_nmax; n++)\n {\n#ifdef USE_GSL_GEGENBAUER_SUBHALO\n this_Phi_n0 = Phi_n0(Cna_32_array[n], r);\n if(n>0)\n this_dPhi_n0_dr = dPhi_n0_dr(Cna_52_array[n-1], this_Phi_n0, n, r);\n else\n this_dPhi_n0_dr = dPhi_n0_dr(1e99, this_Phi_n0, n, r);\n#else\n this_Phi_n0 = Phi_n0(n,r);\n this_dPhi_n0_dr = dPhi_n0_dr(this_Phi_n0, n, r);\n#endif\n\n C_lm += mat_cos[n] * this_Phi_n0;\n\n E_lm += mat_cos[n] * this_dPhi_n0_dr;\n }\n\n float pot = C_lm;\n\n float a_r = -E_lm;\n\n a[0] = G * a_r*sin_theta*cos_phi;\n a[1] = G * a_r*sin_theta*sin_phi;\n a[2] = G * a_r*cos_theta;\n \n pot = G * pot;\n\n#ifdef USE_GSL_GEGENBAUER_SUBHALO\n free(Cna_32_array);\n free(Cna_52_array);\n#endif\n\n return pot;\n\n}\n", "meta": {"hexsha": "8ddfa731140821c6faf343e205eca4e1f82d246b", "size": 5756, "ext": "c", "lang": "C", "max_stars_repo_path": "scf_potential.c", "max_stars_repo_name": "wayne927/vl2-scf", "max_stars_repo_head_hexsha": "e04d8738e92333f546ec6ef4b4f61c7e87456aba", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2016-04-07T19:05:02.000Z", "max_stars_repo_stars_event_max_datetime": "2017-03-08T23:45:46.000Z", "max_issues_repo_path": "scf_potential.c", "max_issues_repo_name": "wayne927/vl2-scf", "max_issues_repo_head_hexsha": "e04d8738e92333f546ec6ef4b4f61c7e87456aba", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "scf_potential.c", "max_forks_repo_name": "wayne927/vl2-scf", "max_forks_repo_head_hexsha": "e04d8738e92333f546ec6ef4b4f61c7e87456aba", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.1636363636, "max_line_length": 122, "alphanum_fraction": 0.579742877, "num_tokens": 1955, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8824278633625322, "lm_q2_score": 0.6224593382055109, "lm_q1q2_score": 0.5492754638427448}} {"text": "/*\n * dgl.c -- Loesung einer DGL mit der GNU scientific library\n *\n * (c) 2016 Prof Dr Andreas Mueller, Hochschule Rapperswil \n */\n#include \n#include \n#include \n#include \n#include \n\nstatic long\tevalcounter = 0;\n\nint\tf(double x, const double y[], double f[], void *params) {\n\tevalcounter++;\n\tdouble\tomega = *(double *)params;\n\tf[0] = y[1];\n\tf[1] = -y[0] + sin(omega * x);\n\treturn GSL_SUCCESS;\n}\n\nstatic inline double\tsqr(double x) { return x * x; }\n\nint\tmain(int argc, char *argv[]) {\n\tdouble\tomega = 0.1;\n\tgsl_odeiv2_system\tsys = { f, NULL, 2, &omega };\n\tgsl_odeiv2_driver\t*driver\n\t\t= gsl_odeiv2_driver_alloc_y_new(&sys, gsl_odeiv2_step_rkf45,\n\t\t\t1e-6, 1e-6, 0.0);\n\tdouble\tx = 0.0;\n\tdouble\ty[2] = { 0.0, 0.0 };\n\tlong\tlastcounter = evalcounter;\n\tfor (int i = 1; i <= 10000; i++) {\n\t\tdouble\txnext = i;\n\t\tint\tstatus = gsl_odeiv2_driver_apply(driver, &x, xnext, y);\n\t\tif (status != GSL_SUCCESS) {\n\t\t\tfprintf(stderr, \"error: return value = %d\\n\", status);\n\t\t}\n\t\tdouble yexakt = (omega * sin(x) - sin(omega * x))\n\t\t\t\t\t/ (sqr(omega) - 1);\n\t\tdouble delta = y[0] - yexakt;\n\t\tlong\tevaldensity = evalcounter - lastcounter;\n\t\tlastcounter = evalcounter;\n\t\tif ((i < 10) ||\n\t\t\t((i < 100) && (0 == i % 10)) ||\n\t\t\t((i < 1000) && (0 == i % 100)) ||\n\t\t\t((i < 10000) && (0 == i % 1000)) ||\n\t\t\t((i < 100000) && (0 == i % 10000))) {\n\t\t\tprintf(\"%5.0f& %12.8f& %12.8f& %12.8f&%ld\\\\\\\\\\n\",\n\t\t\t\t x, y[0], yexakt, delta, evaldensity);\n\t\t}\n\t}\n\treturn EXIT_SUCCESS;\n}\n", "meta": {"hexsha": "c6876c45e060b26bb1449cb65051646d1729ae45", "size": 1504, "ext": "c", "lang": "C", "max_stars_repo_path": "skript/chapters/examples/dgl.c", "max_stars_repo_name": "MatthiasRubin/SeminarDGL", "max_stars_repo_head_hexsha": "a7c452c44097ca851c661d3bc1093204ddae7f67", "max_stars_repo_licenses": ["CC0-1.0"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-01-05T07:48:28.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-05T07:48:28.000Z", "max_issues_repo_path": "skript/chapters/examples/dgl.c", "max_issues_repo_name": "MatthiasRubin/SeminarDGL", "max_issues_repo_head_hexsha": "a7c452c44097ca851c661d3bc1093204ddae7f67", "max_issues_repo_licenses": ["CC0-1.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "skript/chapters/examples/dgl.c", "max_forks_repo_name": "MatthiasRubin/SeminarDGL", "max_forks_repo_head_hexsha": "a7c452c44097ca851c661d3bc1093204ddae7f67", "max_forks_repo_licenses": ["CC0-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.3454545455, "max_line_length": 62, "alphanum_fraction": 0.5944148936, "num_tokens": 565, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7745833945721304, "lm_q2_score": 0.7090191337850932, "lm_q1q2_score": 0.5491944474638489}} {"text": "#include \"AFS.h\"\n#include \"cs.h\"\n#include \"AFS_ctmc.h\"\n#include \"sparseExp.h\"\n#include \"adkCSparse.h\"\n#include \"adkGSL.h\"\n//#include \"cuba.h\"\n#include \n\n\nvoid fillExpectedAFS_unnorm(afsStateSpace *S, double *visitMat ,gsl_vector *rates, gsl_matrix *expAFS);\n\n\n\n//fills a sparse transition matrix for Continuous Time model\nstruct cs_di_sparse *fillTransitionMatrix_ctmc(afsStateSpace *S, double *topol, int *moveType, int *nzCount,\n\tint *dim1, int *dim2, double theta1, double theta2, double mig1, double mig2){\n\tint i, j,k;\n\tint N = S->nstates;\n\tdouble c0r[N],c1r[N],m0r[N],m1r[N],totR[N],rowSums[N], tmp;;\n\t\n\t\n\tstruct cs_di_sparse *triplet;\n\n\t\n\n\t//now allocate new cs_sparse obj\n\ttriplet = cs_spalloc(N, N, *nzCount + N , 1, 1); //alloc sparse mat with extra space for nonzero identity mats\n\tfor(i=0;istates[i]->aCounts[0] * (S->states[i]->aCounts[0]-1) / theta1 ;\n\t\tc1r[i] = S->states[i]->aCounts[1] * (S->states[i]->aCounts[1]-1) / theta2;\n\t\tm0r[i] = S->states[i]->aCounts[0] * mig1 ;\n\t\tm1r[i] = S->states[i]->aCounts[1] * mig2 ;\n\t\ttotR[i] = c0r[i] + c1r[i] + m0r[i] + m1r[i];\n\t\trowSums[i] = 0.0;\n\t}\n\t\n\tfor(k=0;k<*nzCount;k++){\n\t\ti = dim1[k];\n\t\tj= dim2[k];\n\t\tswitch(moveType[k]){\n\t\t\tcase 0: //coal pop0\n\t\t\ttmp = c0r[i] / totR[i] * topol[k];\n\t\t\tcs_entry(triplet,i,j,tmp);\n\t\t\trowSums[i] += tmp;\n\t\t\tbreak;\n\t\t\tcase 1: //coal pop1\n\t\t\ttmp = c1r[i] / totR[i] * topol[k];\n\t\t\tcs_entry(triplet,i,j,tmp);\n\t\t\trowSums[i] += tmp;\n\t\t\tbreak;\n\t\t\tcase 2: //mig pop0\n\t\t\ttmp = m0r[i] / totR[i] * topol[k];\n\t\t\tcs_entry(triplet,i,j,tmp);\n\t\t\trowSums[i] += tmp;\n\t\t\tbreak;\n\t\t\tcase 3: //mig pop1\n\t\t\ttmp = m1r[i] / totR[i] * topol[k];\n\t\t\tcs_entry(triplet,i,j,tmp);\n\t\t\trowSums[i] += tmp;\n\t\t\tbreak;\n\t\t}\n\t}\n\t//now add diagonal elements; topol pre-set to -1\n\tfor(k=0;knstates;\n\tdouble c0r[N],c1r[N],m0r[N],m1r[N],totR[N],rowSums[N], tmp;;\n\n\tfor(i=0;istates[i]->aCounts[0] * (S->states[i]->aCounts[0]-1) / theta1 ;\n\t\tc1r[i] = S->states[i]->aCounts[1] * (S->states[i]->aCounts[1]-1) / theta2;\n\t\tm0r[i] = S->states[i]->aCounts[0] * mig1 ;\n\t\tm1r[i] = S->states[i]->aCounts[1] * mig2 ;\n\t\ttotR[i] = c0r[i] + c1r[i] + m0r[i] + m1r[i];\n\t\trowSums[i] = 0.0;\n\t}\t\n\tnewnz=0;\n\tfor(k=0;k<*nzCount;++k){\n\t\ti = dim1[k];\n\t\tj= dim2[k];\n\t\tswitch(moveType[k]){\n\t\t\tcase 0: //coal pop0\n\t\t\ttmp = c0r[i] / totR[i] * topol[k];\n\t\t\tnewArray[k]=tmp;\n\t\t\tnewDim1[k] = i+1;\n\t\t\tnewDim2[k] = j+1;\n\t\t\trowSums[i] += tmp;\n\t\t\tnewnz++;\n\t\t\tbreak;\n\t\t\tcase 1: //coal pop1\n\t\t\ttmp = c1r[i] / totR[i] * topol[k];\n\t\t\tnewArray[k]=tmp;\n\t\t\tnewDim1[k] = i+1;\n\t\t\tnewDim2[k] = j+1;\n\t\t\trowSums[i] += tmp;\n\t\t\tnewnz++;\n\t\t\tbreak;\n\t\t\tcase 2: //mig pop0\n\t\t\ttmp = m0r[i] / totR[i] * topol[k];\n\t\t\tnewArray[k]=tmp;\n\t\t\tnewDim1[k] = i+1;\n\t\t\tnewDim2[k] = j+1;\n\t\t\trowSums[i] += tmp;\n\t\t\tnewnz++;\n\t\t\tbreak;\n\t\t\tcase 3: //mig pop1\n\t\t\ttmp = m1r[i] / totR[i] * topol[k];\n\t\t\tnewArray[k]=tmp;\n\t\t\tnewDim1[k] = i+1;\n\t\t\tnewDim2[k] = j+1;\n\t\t\trowSums[i] += tmp;\n\t\t\tnewnz++;\n\t\t\tbreak;\n\t\t}\n\t}\n\n\t//now add diagonal elements; topol pre-set to -1\n\tfor(k=0;knstates,abFlag;\n\tdouble c0r[N],c1r[N],m0r[N],m1r[N],totR[N],rowSums[N], tmp;;\n\tstruct cs_di_sparse *triplet, *tmat;\n\n\tgsl_vector_set_zero(rates);\n\t//allocate new cs_sparse obj\n\ttriplet = cs_spalloc(N, N, *nzCount + N , 1, 1); //alloc sparse mat with extra space for nonzero identity mats\n\n\tfor(i=0;istates[i]->aCounts[0] * (S->states[i]->aCounts[0]-1) / theta1 ;\n\t//\tprintf(\"co check:%f\\n\",c0r[i]);\n\t\tif(theta2 == 0)\n\t\t\tc1r[i] = 0.0;\n\t\telse\n\t\t\tc1r[i] = S->states[i]->aCounts[1] * (S->states[i]->aCounts[1]-1) / theta2;\n\t\tm0r[i] = S->states[i]->aCounts[0] * mig1 ;\n\t\tm1r[i] = S->states[i]->aCounts[1] * mig2 ;\n\t\ttotR[i] = c0r[i] + c1r[i] + m0r[i] + m1r[i];\n\t\n\t\t\n\t\trowSums[i] = 0.0;\n\t\tif(S->states[i]->nalleles > 1 && c0r[i] >= 0 && c1r[i] >= 0 && totR[i] != 0.0)\n\t\t\tgsl_vector_set(rates,i,1.0/totR[i]);\n\t\telse\n\t\t\tgsl_vector_set(rates,i,0);\n\t}\n\n\tnewnz=0;\n\tfor(k=0;k<*nzCount;k++){\n\t\ti = dim1[k];\n\t\tj= dim2[k];\n//\t\tprintf(\"i: %d, j:%d, movetype: %d\\n\",i,j,moveType[k]);\n\t\tif(S->states[i]->nalleles ==1 || S->states[j]->nalleles ==1 )abFlag=1;\n\t//\tif(S->states[i]->nalleles ==1 )abFlag=1;\n\t\telse abFlag = 0;\n\t\tswitch(moveType[k]){\n\t\t\tcase 0: //coal pop0\n\t\t\tif(totR[i]==0)tmp=0;\n\t\t\telse tmp = c0r[i] / totR[i] * topol[k];\n\t\t\tnewArray[k]=tmp* totR[i];\n\t\t\tnewDim1[k] = i;\n\t\t\tnewDim2[k] = j;\n\t\t\trowSums[i] += tmp* totR[i];\n\t\t\tif(abFlag==0)cs_entry(triplet,i,j,tmp);\t\t\t\n\t\t\tbreak;\n\t\t\tcase 1: //coal pop1\n\t\t\tif(totR[i]==0)tmp=0;\n\t\t\telse tmp = c1r[i] / totR[i] * topol[k];\n\t\t\tnewArray[k]=tmp* totR[i];\n\t\t\tnewDim1[k] = i;\n\t\t\tnewDim2[k] = j;\n\t\t\trowSums[i] += tmp* totR[i];\n\t\t\tif(abFlag==0)cs_entry(triplet,i,j,tmp);\t\t\t\n\t\t\tbreak;\n\t\t\tcase 2: //mig pop0\n\t\t\tif(totR[i]==0)tmp=0;\n\t\t\telse tmp = m0r[i] / totR[i] * topol[k];\n\t\t\tnewArray[k]=tmp* totR[i];\n\t\t\tnewDim1[k] = i;\n\t\t\tnewDim2[k] = j;\n\t\t\trowSums[i] += tmp* totR[i];\n\t\t\tif(abFlag==0)cs_entry(triplet,i,j,tmp);\t\t\t\n\t\t\tbreak;\n\t\t\tcase 3: //mig pop1\n\t\t\tif(totR[i]==0)tmp=0;\n\t\t\telse tmp = m1r[i] / totR[i] * topol[k];\t\t\t\n\t\t\tnewArray[k]=tmp * totR[i];\n\t\t\tnewDim1[k] = i;\n\t\t\tnewDim2[k] = j;\n\t\t\trowSums[i] += tmp* totR[i];\n\t\t\tif(abFlag==0)cs_entry(triplet,i,j,tmp);\t\t\t\n\t\t\tbreak;\n\t\t\tcase -1:\n\t\t\tabcount+=1;\n\t\t\tbreak;\n\t\t\t\n\t\t}\n\t}\n\tnewnz=*nzCount ;\n\t//now add diagonal elements; topol pre-set to -1\n\tfor(k=0;ksize1;\n\tm2=expAFS->size2;\n\t\n\tgsl_matrix_set_zero(expAFS);\n\t\n\tfor(j=0;jnstates;j++){\n\t\tif(S->states[j]->nalleles != 1){\n\t\t\tfor(k=0;kstates[j]->popMats[0],k,l) + gsl_matrix_int_get(S->states[j]->popMats[1],k,l);\n\t\t\t\ttmpRes = gsl_matrix_get(expAFS,k,l) + (count * visitMat[j]);\t\n\t\t\t\tgsl_matrix_set(expAFS,k,l, tmpRes);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n//\ttmpRes = matrixSumDouble(expAFS);\n//\tgsl_matrix_scale(expAFS, 1.0 / tmpRes);\n}\n\n\n//fills up an AFS matrix using expected times and a precalculated visitMat\nvoid fillExpectedAFS_unnorm(afsStateSpace *S, double *visitMat ,gsl_vector *rates, gsl_matrix *expAFS){\n\tint j, k, l, m1, m2, count;\n\n\tdouble tmpRes;\n\n\tm1=expAFS->size1;\n\tm2=expAFS->size2;\n\t\n\tgsl_matrix_set_zero(expAFS);\t\n\tfor(j=0;jnstates;j++){\n\t\tfor(k=0;kstates[j]->popMats[0],k,l) + gsl_matrix_int_get(S->states[j]->popMats[1],k,l);\n\t\t\t\ttmpRes = gsl_matrix_get(expAFS,k,l) + (count * gsl_vector_get(rates,j) * visitMat[j]);\t\n//\t\t\t\tprintf(\"tmpRes[%d][%d]: %f rates[j]: %f visits[j]: %f count: %d\\n\",tmpRes,k,l,gsl_vector_get(rates,j),visitMat[j],count);\n\t\t\t\tgsl_matrix_set(expAFS,k,l, tmpRes);\n\t\t\t}\n\t\t}\n\t}\n}\n\n//fills up an AFS matrix using expected times and a precalculated visitMat\nvoid fillExpectedAFS_unnorm_mat(afsStateSpace *S, double **visitMat , double *initialStateProbs, gsl_vector *rates, gsl_matrix *expAFS){\n\tint j, k, l,i, m1, m2, count;\n\n\tdouble tmpRes,sum;\n\n\tm1=expAFS->size1;\n\tm2=expAFS->size2;\n\t\n\tgsl_matrix_set_zero(expAFS);\t\n\tfor(j=0;jnstates;j++){\n\t\tfor(k=0;kstates[j]->popMats[0],k,l) + gsl_matrix_int_get(S->states[j]->popMats[1],k,l);\n\t\t\t\tsum=0.0;\n\t\t\t\tfor(i=0;instates;i++){\n\t\t\t\t\tsum += visitMat[i][j] * initialStateProbs[i];\n\t\t\t\t}\n\t\t\t\ttmpRes\t= gsl_matrix_get(expAFS,k,l) + (count * gsl_vector_get(rates,j) * sum);\n\t\t\t//\tprintf(\"tmpRes[%d][%d]: %f rates[j]: %f visits[j]: %f count: %d\\n\",k,l,tmpRes,gsl_vector_get(rates,j),sum,count);\n\t\t\t\tgsl_matrix_set(expAFS,k,l, tmpRes);\n\t\t\t}\n\t\t}\n\t}\n}\n\n/// I believe the below is now completely unused\n//fillLogAFS -- uses cxsparse library for inversion -- will replace above\n// void fillLogAFS(void * p){\n// \tstruct im_lik_params * params = (struct im_lik_params *) p;\n// \tstruct expoMatObj anExpoMatObj;\n// \tint i,j, N = params->stateSpace->nstates;\n// \tcs *spMat, *mt, *ident, *eye, *tmpMat ,*tmpMat2;\n// \tdouble timeV, sum, thetaA, theta2, mig1, mig2;\n// \tint Na;\n// \tgsl_vector *tmpStates;\n// \t\n// \t\n// \t//initialize some vectors\n// \tgsl_vector_set_zero(params->rates);\n// \ttmpStates = gsl_vector_alloc(N);\n// \t\n// \t//For straight MLE the paramVector takes the form [N2,NA,m1,m2,t]\n// \ttheta2 = gsl_vector_get(params->paramVector,0);\n// \tthetaA = gsl_vector_get(params->paramVector,1);\n// \tmig1 = gsl_vector_get(params->paramVector,2);\n// \tmig2 = gsl_vector_get(params->paramVector,3);\n// \ttimeV = gsl_vector_get(params->paramVector,4);\n// //\tprintf(\"params-> %f %f %f %f %f\\n\",theta2,thetaA,mig1,mig2,timeV);\n// \t//fill transMat\n// \ttmpMat= fillTransitionMatrixArray_embed_ctmc(params->stateSpace, params->topA, params->moveA,\n// \t \t&(params->nnz),params->dim1, params->dim2,1.0, theta2, mig1, mig2, \n// \t \tparams->new, params->newdim1, params->newdim2,params->rates);\n// \t\n// \t//using CSparse\n// \t// S = (I-P)^-1\n// \t\n// \t//add negative ident\n// \tident = cs_spalloc(N,N,N,1,1);\n// \tfor(i=0;ib[i] = 0.0;\n// \t\tparams->b[j]=1.0;\n// \t\tcs_lusol(0, mt, params->b, 1e-12);\n// \t\tfor(i=0; iinvMat[j][i]=params->b[i];\n// \t\t\tgsl_matrix_set(params->invMatGSL,j,i,params->b[i]);\n// \t\t}\n// \t\tprintf(\"inv mat row %d complete\\n\",j);\n// \t}\n// \t\n// \t//Get Island Time 0-INF Unnormal\n// \tgsl_matrix_set_zero(params->expAFS);\n// \tfor(i=0; ib[i] = params->invMat[0][i];\n// \tfillExpectedAFS_unnorm(params->stateSpace, params->b,params->rates,params->expAFS);\n// \t// printf(\"////////////////////Island Time 0 - INF unnormalized\\n\");\n// \t// for(i=0;i< (params->expAFS->size1) ;i++){\n// \t// \tfor(j=0;j< (params->expAFS->size2);j++){\n// \t// \t\tprintf(\"%.5f \",gsl_matrix_get(params->expAFS,i,j));\n// \t// \t}\n// \t// \tprintf(\"\\n\");\n// \t// }\n// \t\n// \t//Matrix Exponentiation to get state vector at time t\n// \t//\n// \n// \t//push indices\n// \tfor(i=0;innz;i++){\n// \t\tparams->expodim1[i]=params->newdim1[i]+1;\n// \t\tparams->expodim2[i]=params->newdim2[i]+1;\n// \t\t\n// \t}\n// \t//reset expoInit\n// \tfor(i = 0;iexpoInit[i]=0.0;\n// \t\tparams->expoResult[i]=0.0;\n// \t}\n// \tparams->expoInit[0] = 1.0;\n// \n// \t//sanity check ///////\n// //\tfor(i=0;innz;i++){\n// //\t\tprintf(\"a[%d]=%f expodim1=%d expodim2=%d \\n\", i,params->anExpoMatObj->a[i],params->anExpoMatObj->ai[i],params->anExpoMatObj->aj[i]);\n// //\t}\n// //\tprintf(\"rank=%d nnz=%d\\n\", params->anExpoMatObj->rank, params->anExpoMatObj->nnz);\n// \t\n// //\tfor(i=0;ianExpoMatObj->resultSpace[%d]=%f\\n\",i,params->anExpoMatObj->resultSpace[i]);\n// //\tfor(i=0;ianExpoMatObj->initVec[%d]=%f\\n\",i,params->anExpoMatObj->initVec[i]);\n// \t\n// \tanExpoMatObj.ai = params->expodim1;\n// \tanExpoMatObj.aj = params->expodim2;\n// \tanExpoMatObj.a = params->new;\n// \tanExpoMatObj.initVec = params->expoInit;\n// \tanExpoMatObj.resultSpace = params->expoResult;\n// //\tsparse_exponential_single_row(N, params->nnz, anExpoMatObj.ai, anExpoMatObj.aj,\n// //\t\tanExpoMatObj.a, timeV,anExpoMatObj.initVec, params->expoResult, 0); \n// \t//state vector at time t stored in b[i] \n// \tfor(i=0; ib[i] = params->expoResult[i];\n// //\t\tprintf(\"params->expoResult[%d]=%f\\n\",i,params->expoResult[i] );\t\t\n// \t\tgsl_vector_set(tmpStates,i,params->expoResult[i]);\n// \t}\n// \n// \tgsl_blas_dgemv(CblasTrans, 1.0, params->invMatGSL,tmpStates, 0.0, params->resVec);\n// \t\n// \n// \tfor(i=0; ib[i] = gsl_vector_get(params->resVec,i);\n// \t}\n// \tgsl_matrix_set_zero(params->expAFS2);\n// \tfillExpectedAFS_unnorm(params->stateSpace, params->b,params->rates,params->expAFS2);\n// \t\n// \t//now subtract older AFS (t_t - t_INF) from total AFS (t_0 - t_INF)\n// \t/////////////////\n// \t///////\n// //\tprintf(\"////////////////////Island time0-t=%f unnormalized\\n\",timeV);\n// \t\n// \tgsl_matrix_sub(params->expAFS,params->expAFS2);\n// \t// for(i=0;i< (params->expAFS->size1) ;i++){\n// \t// \tfor(j=0;j< (params->expAFS->size2);j++){\n// \t// \t\tprintf(\"%.5f \",gsl_matrix_get(params->expAFS,i,j));\n// \t// \t}\n// \t// \tprintf(\"\\n\");\n// \t// }\n// \t// printf(\"////////////////////\\n\");\n// \t\n// \t\n// \t//mapping of states already complete when params initialized\n// \t//state vector at time t stored in st[] for largerStateSpace; use reverseMap\n// \tfor(i=0;ist[i]=0.0;\n// \tfor(i=0;ist[params->map[i]]+=params->expoResult[i];\n// \tfor(i=0; ireducedStateSpace->nstates; i++){\n// \t\tgsl_vector_set(params->ancStateVec,i,params->st[params->reverseMap[i]]);\n// \t}\n// \tNa = params->reducedStateSpace->nstates;\n// \t//fill up ancestral transition matrix\n// \tgsl_vector_set_zero(params->rates);\n// \ttmpMat2= fillTransitionMatrixArray_embed_ctmc(params->reducedStateSpace, params->topA2, params->moveA2, &(params->nnzA),\n// \t\tparams->dim1A, params->dim2A,thetaA, 0, 0, 0,params->new, params->newdim1, params->newdim2,params->rates);\n// \t\t\n// \tident = cs_spalloc(Na,Na,Na,1,1);\n// \tfor(i=0;ib[i] = 0.0;\n// \t\tparams->b[j]=1.0;\n// \t\tcs_lusol(0, mt, params->b, 1e-12);\n// \t\tfor(i=0; iinvMatGSLA,j,i,params->b[i]);\n// \t\t}\n// \t}\n// \n// \t//get contribution starting at st\n// \tgsl_blas_dgemv(CblasTrans, 1.0, params->invMatGSLA, params->ancStateVec, 0.0, params->ancResVec);\n// \tfor(i=0; ib[i] = gsl_vector_get(params->ancResVec,i);\n// \tgsl_matrix_set_zero(params->expAFS2);\n// \tfillExpectedAFS_unnorm(params->reducedStateSpace, params->b,params->rates,params->expAFS2);\n// \t\n// \t////////////////////normalized IM AFS\n// \tgsl_matrix_add(params->expAFS,params->expAFS2);\n// \tsum = matrixSumDouble(params->expAFS);\n// \tgsl_matrix_scale(params->expAFS, 1.0 / sum);\n// \t\n// \t\n// \t///////////// Replace AFS with log(AFS)\n// \t// for(i=0;iexpAFS->size1;i++){\n// \t// \tfor(j=0;jexpAFS->size2;j++){\n// \t// \t\tgsl_matrix_set(params->expAFS,i,j,log(gsl_matrix_get(params->expAFS,i,j)));\n// \t// \t}\n// \t// }\n// \t\n// \t//clean up\n// \tcs_spfree(spMat);\n// \tcs_spfree(mt);\n// \tcs_spfree(ident);\n// \tcs_spfree(eye);\n// \tcs_spfree(tmpMat);\n// \tcs_spfree(tmpMat2);\n// \tgsl_vector_free(tmpStates);\n// }\n\n\n//////////////////// Uniformization Algorithm for Exponentiation\n/// P. 413 from Stewart Book \nvoid uniformizExpSparseMat(int N, int nnz, double *vals, int *dim1, int *dim2, double tSoln, double *result){\n\tint i, k, ii;\n\tdouble cosi, sigma, nu, gamma, eps,y[N],tmpY[N],scale;\n\tstruct cs_di_sparse *tmpMat, *ctmc, *ident, *eye, *new;\n\t\n\t//stuff values into more convenient matrix\n\t//uniformization of matrix\n\ttmpMat = cs_spalloc(N,N,N,1,1);\n\tident = cs_spalloc(N,N,N,1,1);\n\tfor(i=0;i\n#include \n#include \n\n#include \n\ntypedef struct {\n int N;\n double *x, *y; /* length N; */\n} lorentzdata;\n\nstatic double sqr(double x)\n{\n return x * x;\n}\n\nstatic int count = 0;\n\nstatic double lorentzerr(int n, const double *p, double *grad, void *data)\n{\n lorentzdata *d = (lorentzdata *) data;\n int N = d->N;\n const double *xs = d->x;\n const double *ys = d->y;\n double val = 0;\n int i, j;\n\n for (i = 0; i < N; ++i) {\n double x = xs[i], y = ys[i];\n double lorsum = 0;\n\n for (j = 0; j < n; j += 3) {\n double A = p[j + 0];\n double w = p[j + 1];\n double G = p[j + 2];\n double lor = A / (sqr(x - w) + G * G);\n\n lorsum += lor;\n }\n\n val += sqr(y - lorsum);\n\n if (grad)\n for (j = 0; j < n; j += 3) {\n double A = p[j + 0];\n double w = p[j + 1];\n double G = p[j + 2];\n double deninv = 1.0 / (sqr(x - w) + G * G);\n\n grad[j + 0] += -2 * (y - lorsum) * deninv;\n grad[j + 1] += 4 * A * (w - x) * (y - lorsum) * sqr(deninv);\n grad[j + 2] += 4 * A * G * (y - lorsum) * sqr(deninv);\n }\n }\n ++count;\n // printf(\"%d: f(%g,%g,%g) = %g\\n\", count, p[0],p[1],p[2], val);\n return val;\n}\n\nextern double nlopt_urand(double a, double b);\n\nint main(void)\n{\n lorentzdata d;\n int i;\n double A = 1, w = 0, G = 1, noise = 0.01;\n double lb[3] = { -HUGE_VAL, -HUGE_VAL, 0 };\n double ub[3] = { HUGE_VAL, HUGE_VAL, HUGE_VAL };\n double p[3] = { 0, 1, 2 }, minf;\n\n nlopt_srand_time();\n\n d.N = 200;\n d.x = (double *) malloc(sizeof(double) * d.N * 2);\n d.y = d.x + d.N;\n for (i = 0; i < d.N; ++i) {\n d.x[i] = nlopt_urand(-0.5, 0.5) * 8 * G + w;\n d.y[i] = 2 * noise * nlopt_urand(-0.5, 0.5) + A / (sqr(d.x[i] - w) + G * G);\n }\n\n nlopt_minimize(NLOPT_LN_NEWUOA_BOUND, 3, lorentzerr, &d, lb, ub, p, &minf, -HUGE_VAL, 0, 0, 1e-6, NULL, 0, 0);\n\n printf(\"%d minf=%g at A=%g, w=%g, G=%g\\n\", count, minf, p[0], p[1], p[2]);\n\n count = 0;\n nlopt_minimize(NLOPT_LN_COBYLA, 3, lorentzerr, &d, lb, ub, p, &minf, -HUGE_VAL, 0, 0, 1e-6, NULL, 0, 0);\n\n printf(\"%d minf=%g at A=%g, w=%g, G=%g\\n\", count, minf, p[0], p[1], p[2]);\n\n count = 0;\n nlopt_minimize(NLOPT_LN_NELDERMEAD, 3, lorentzerr, &d, lb, ub, p, &minf, -HUGE_VAL, 0, 0, 1e-6, NULL, 0, 0);\n\n printf(\"%d minf=%g at A=%g, w=%g, G=%g\\n\", count, minf, p[0], p[1], p[2]);\n\n count = 0;\n nlopt_minimize(NLOPT_LN_SBPLX, 3, lorentzerr, &d, lb, ub, p, &minf, -HUGE_VAL, 0, 0, 1e-6, NULL, 0, 0);\n\n printf(\"%d minf=%g at A=%g, w=%g, G=%g\\n\", count, minf, p[0], p[1], p[2]);\n\n return 0;\n}\n", "meta": {"hexsha": "6566425e3872dcf734410f18d2523e75e0afe8ae", "size": 2791, "ext": "c", "lang": "C", "max_stars_repo_path": "test/lorentzfit.c", "max_stars_repo_name": "bowie7070/nlopt", "max_stars_repo_head_hexsha": "95df031058531d84fe9c0727458129f773d22959", "max_stars_repo_licenses": ["MIT-0", "MIT"], "max_stars_count": 1224.0, "max_stars_repo_stars_event_min_datetime": "2015-01-14T22:56:04.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-30T18:52:57.000Z", "max_issues_repo_path": "nlopt/test/lorentzfit.c", "max_issues_repo_name": "yjjuan/automl_cplusplus", "max_issues_repo_head_hexsha": "7c427584ed94915b549d31a2097f952c3cfdef36", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 349.0, "max_issues_repo_issues_event_min_datetime": "2015-01-16T22:22:32.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-29T18:30:05.000Z", "max_forks_repo_path": "nlopt/test/lorentzfit.c", "max_forks_repo_name": "yjjuan/automl_cplusplus", "max_forks_repo_head_hexsha": "7c427584ed94915b549d31a2097f952c3cfdef36", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 437.0, "max_forks_repo_forks_event_min_datetime": "2015-02-20T07:40:41.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-30T15:21:01.000Z", "avg_line_length": 27.362745098, "max_line_length": 114, "alphanum_fraction": 0.46470799, "num_tokens": 1140, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.795658090372256, "lm_q2_score": 0.6893056167854461, "lm_q1q2_score": 0.5484515907343781}} {"text": "/* multifit_nlinear/subspace2D.c\n * \n * Copyright (C) 2016 Patrick Alken\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n/*\n * This module implements a 2D subspace trust region subproblem method,\n * as outlined in\n *\n * [1] G. A. Shultz, R. B. Schnabel, and R. H. Byrd\n * A Family of Trust-Region-Based Algorithms for Unconstrained\n * Minimization with Strong Global Convergence Properties,\n * SIAM Journal on Numerical Analysis 1985 22:1, 47-67 \n *\n * [2] R. H. Byrd, R. B. Schnabel, G. A. Shultz,\n * Approximate solution of the trust region problem by\n * minimization over two-dimensional subspaces,\n * Mathematical Programming, January 1988, Volume 40,\n * Issue 1, pp 247-263\n *\n * The idea is to solve:\n *\n * min_{dx} g^T dx + 1/2 dx^T B dx\n * \n * with constraints:\n *\n * ||D dx|| <= delta\n * dx \\in span{dx_sd, dx_gn}\n *\n * where B is the Hessian matrix, B = J^T J\n *\n * The steps are as follows:\n *\n * 1. preloop:\n * a. Compute Gauss-Newton and steepest descent vectors,\n * dx_gn, dx_sd\n * b. Compute an orthonormal basis for span(D dx_sd, D dx_gn) by\n * constructing W = [ D dx_sd, D dx_gn ] and performing a QR\n * decomposition of W. The 2 columns of the Q matrix\n * will then span the column space of W. W should have rank 2\n * unless D*dx_sd and D*dx_gn are parallel, in which case it will\n * have rank 1.\n * c. Precompute various quantities needed for the step calculation\n *\n * 2. step:\n * a. If the Gauss-Newton step is inside the trust region, use it\n * b. if W has rank 1, we cannot form a 2D subspace, so in this case\n * follow the steepest descent direction to the trust region boundary\n * and use that as the step.\n * c. In the full rank 2 case, if the GN point is outside the trust region,\n * then the minimizer of the objective function lies on the trust\n * region boundary. Therefore the minimization problem becomes:\n *\n * min_{dx} g^T dx + 1/2 dx^T B dx, with ||dx|| = delta, dx = Q * x\n *\n * where x is a 2-vector to be determined and the columns of Q are\n * the orthonormal basis vectors of the subspace. Note the equality\n * constraint now instead of <=. In terms of the new variable x,\n * the minimization problem becomes:\n *\n * min_x subg^T x + 1/2 x^T subB x, with ||Q*x|| = ||x|| = delta\n *\n * where:\n * subg = Q^T g (2-by-1)\n * subB = Q^T B Q (2-by-2)\n *\n * This equality constrained 2D minimization problem can be solved\n * with a Lagrangian multiplier, which results in a 4th degree polynomial\n * equation to be solved. The equation is:\n *\n * lambda^4 1\n * + lambda^3 2 tr(B)\n * + lambda^2 (tr(B)^2 + 2 det(B) - g^T g / delta^2)\n * + lambda^1 (2 det(B) tr(B) - 2 g^T adj(B)^T g / delta^2)\n * + lambda^0 (det(B)^2 - g^T adj(B)^T adj(B) g / delta^2)\n *\n * where adj(B) is the adjugate matrix of B.\n *\n * We then check each of the 4 solutions for lambda to determine which\n * lambda results in the smallest objective function value. This x\n * is then used to construct the final step: dx = Q*x\n */\n\ntypedef struct\n{\n size_t n; /* number of observations */\n size_t p; /* number of parameters */\n gsl_vector *dx_gn; /* Gauss-Newton step, size p */\n gsl_vector *dx_sd; /* steepest descent step, size p */\n double norm_Dgn; /* || D dx_gn || */\n double norm_Dsd; /* || D dx_sd || */\n gsl_vector *workp; /* workspace, length p */\n gsl_vector *workn; /* workspace, length n */\n gsl_matrix *W; /* orthonormal basis for 2D subspace, p-by-2 */\n gsl_matrix *JQ; /* J * Q, n-by-p */\n gsl_vector *tau; /* Householder scalars */\n gsl_vector *subg; /* subspace gradient = W^T g, 2-by-1 */\n gsl_matrix *subB; /* subspace Hessian = W^T B W, 2-by-2 */\n gsl_permutation *perm; /* permutation matrix */\n\n double trB; /* Tr(subB) */\n double detB; /* det(subB) */\n double normg; /* || subg || */\n double term0; /* g^T adj(B)^T adj(B) g */\n double term1; /* g^T adj(B)^T g */\n\n size_t rank; /* rank of [ dx_sd, dx_gn ] matrix */\n\n gsl_poly_complex_workspace *poly_p;\n\n /* tunable parameters */\n gsl_multifit_nlinear_parameters params;\n} subspace2D_state_t;\n\n#include \"common.c\"\n\nstatic void * subspace2D_alloc (const void * params, const size_t n, const size_t p);\nstatic void subspace2D_free(void *vstate);\nstatic int subspace2D_init(const void *vtrust_state, void *vstate);\nstatic int subspace2D_preloop(const void * vtrust_state, void * vstate);\nstatic int subspace2D_step(const void * vtrust_state, const double delta,\n gsl_vector * dx, void * vstate);\nstatic int subspace2D_preduction(const void * vtrust_state, const gsl_vector * dx,\n double * pred, void * vstate);\nstatic int subspace2D_solution(const double lambda, gsl_vector * x,\n subspace2D_state_t * state);\nstatic double subspace2D_objective(const gsl_vector * x, subspace2D_state_t * state);\nstatic int subspace2D_calc_gn(const gsl_multifit_nlinear_trust_state * trust_state, gsl_vector * dx);\nstatic int subspace2D_calc_sd(const gsl_multifit_nlinear_trust_state * trust_state, gsl_vector * dx,\n subspace2D_state_t * state);\n\nstatic void *\nsubspace2D_alloc (const void * params, const size_t n, const size_t p)\n{\n const gsl_multifit_nlinear_parameters *par = (const gsl_multifit_nlinear_parameters *) params;\n subspace2D_state_t *state;\n \n state = calloc(1, sizeof(subspace2D_state_t));\n if (state == NULL)\n {\n GSL_ERROR_NULL (\"failed to allocate subspace2D state\", GSL_ENOMEM);\n }\n\n state->dx_gn = gsl_vector_alloc(p);\n if (state->dx_gn == NULL)\n {\n GSL_ERROR_NULL (\"failed to allocate space for dx_gn\", GSL_ENOMEM);\n }\n\n state->dx_sd = gsl_vector_alloc(p);\n if (state->dx_sd == NULL)\n {\n GSL_ERROR_NULL (\"failed to allocate space for dx_sd\", GSL_ENOMEM);\n }\n\n state->workp = gsl_vector_alloc(p);\n if (state->workp == NULL)\n {\n GSL_ERROR_NULL (\"failed to allocate space for workp\", GSL_ENOMEM);\n }\n\n state->workn = gsl_vector_alloc(n);\n if (state->workn == NULL)\n {\n GSL_ERROR_NULL (\"failed to allocate space for workn\", GSL_ENOMEM);\n }\n\n state->W = gsl_matrix_alloc(p, 2);\n if (state->W == NULL)\n {\n GSL_ERROR_NULL (\"failed to allocate space for W\", GSL_ENOMEM);\n }\n\n state->JQ = gsl_matrix_alloc(n, p);\n if (state->JQ == NULL)\n {\n GSL_ERROR_NULL (\"failed to allocate space for JQ\", GSL_ENOMEM);\n }\n\n state->tau = gsl_vector_alloc(2);\n if (state->tau == NULL)\n {\n GSL_ERROR_NULL (\"failed to allocate space for tau\", GSL_ENOMEM);\n }\n\n state->subg = gsl_vector_alloc(2);\n if (state->subg == NULL)\n {\n GSL_ERROR_NULL (\"failed to allocate space for subg\", GSL_ENOMEM);\n }\n\n state->subB = gsl_matrix_alloc(2, 2);\n if (state->subB == NULL)\n {\n GSL_ERROR_NULL (\"failed to allocate space for subB\", GSL_ENOMEM);\n }\n\n state->perm = gsl_permutation_alloc(2);\n if (state->perm == NULL)\n {\n GSL_ERROR_NULL (\"failed to allocate space for perm\", GSL_ENOMEM);\n }\n\n state->poly_p = gsl_poly_complex_workspace_alloc(5);\n if (state->poly_p == NULL)\n {\n GSL_ERROR_NULL (\"failed to allocate space for poly workspace\", GSL_ENOMEM);\n }\n\n state->n = n;\n state->p = p;\n state->rank = 0;\n state->params = *par;\n\n return state;\n}\n\nstatic void\nsubspace2D_free(void *vstate)\n{\n subspace2D_state_t *state = (subspace2D_state_t *) vstate;\n\n if (state->dx_gn)\n gsl_vector_free(state->dx_gn);\n\n if (state->dx_sd)\n gsl_vector_free(state->dx_sd);\n\n if (state->workp)\n gsl_vector_free(state->workp);\n\n if (state->workn)\n gsl_vector_free(state->workn);\n\n if (state->W)\n gsl_matrix_free(state->W);\n\n if (state->JQ)\n gsl_matrix_free(state->JQ);\n\n if (state->tau)\n gsl_vector_free(state->tau);\n\n if (state->subg)\n gsl_vector_free(state->subg);\n\n if (state->subB)\n gsl_matrix_free(state->subB);\n\n if (state->perm)\n gsl_permutation_free(state->perm);\n\n if (state->poly_p)\n gsl_poly_complex_workspace_free(state->poly_p);\n\n free(state);\n}\n\n/*\nsubspace2D_init()\n Initialize subspace2D solver\n\nInputs: vtrust_state - trust state\n vstate - workspace\n\nReturn: success/error\n*/\n\nstatic int\nsubspace2D_init(const void *vtrust_state, void *vstate)\n{\n (void)vtrust_state;\n (void)vstate;\n\n return GSL_SUCCESS;\n}\n\n/*\nsubspace2D_preloop()\n Initialize subspace2D method prior to iteration loop.\nThis involves computing the Gauss-Newton step and\nsteepest descent step\n\nNotes: on output,\n1) state->dx_gn contains Gauss-Newton step\n2) state->dx_sd contains steepest descent step\n3) state->rank contains the rank([dx_sd, dx_gn])\n4) if full rank subspace (rank = 2), then:\n state->trB = Tr(subB)\n state->detB = det(subB)\n state->normg = || subg ||\n*/\n\nstatic int\nsubspace2D_preloop(const void * vtrust_state, void * vstate)\n{\n int status;\n const gsl_multifit_nlinear_trust_state *trust_state =\n (const gsl_multifit_nlinear_trust_state *) vtrust_state;\n subspace2D_state_t *state = (subspace2D_state_t *) vstate;\n gsl_vector_view v;\n double work_data[2];\n gsl_vector_view work = gsl_vector_view_array(work_data, 2);\n int signum;\n\n /* calculate Gauss-Newton step */\n status = subspace2D_calc_gn(trust_state, state->dx_gn);\n if (status)\n return status;\n\n /* now calculate the steepest descent step */\n status = subspace2D_calc_sd(trust_state, state->dx_sd, state);\n if (status)\n return status;\n\n /* store norms */\n state->norm_Dgn = scaled_enorm(trust_state->diag, state->dx_gn);\n state->norm_Dsd = scaled_enorm(trust_state->diag, state->dx_sd);\n\n /*\n * now compute orthonormal basis for span(D dx_sd, D dx_gn) using\n * QR decomposition; set W = [ D dx_sd, D dx_gn ] and normalize each\n * column to unit magnitude. Then the Q matrix will form a basis for Col(W)\n */\n\n v = gsl_matrix_column(state->W, 0);\n gsl_vector_memcpy(&v.vector, state->dx_sd);\n gsl_vector_mul(&v.vector, trust_state->diag);\n if (state->norm_Dsd != 0)\n gsl_vector_scale(&v.vector, 1.0 / state->norm_Dsd);\n\n v = gsl_matrix_column(state->W, 1);\n gsl_vector_memcpy(&v.vector, state->dx_gn);\n gsl_vector_mul(&v.vector, trust_state->diag);\n if (state->norm_Dgn != 0)\n gsl_vector_scale(&v.vector, 1.0 / state->norm_Dgn);\n\n /* use a rank revealing QR decomposition in case dx_sd and dx_gn\n * are parallel */\n gsl_linalg_QRPT_decomp(state->W, state->tau, state->perm, &signum, &work.vector);\n\n /* check for parallel dx_sd, dx_gn, in which case rank will be 1 */\n state->rank = gsl_linalg_QRPT_rank(state->W, -1.0);\n\n if (state->rank == 2)\n {\n /*\n * full rank subspace, compute:\n * subg = Q^T D^{-1} g\n * subB = Q^T D^{-1} B D^{-1} Q where B = J^T J\n */\n const size_t p = state->p;\n size_t i;\n gsl_matrix_view JQ = gsl_matrix_submatrix(state->JQ, 0, 0, state->n, GSL_MIN(2, p));\n double B00, B10, B11, g0, g1;\n\n /* compute subg */\n gsl_vector_memcpy(state->workp, trust_state->g);\n gsl_vector_div(state->workp, trust_state->diag);\n gsl_linalg_QR_QTvec(state->W, state->tau, state->workp);\n\n g0 = gsl_vector_get(state->workp, 0);\n g1 = gsl_vector_get(state->workp, 1);\n\n gsl_vector_set(state->subg, 0, g0);\n gsl_vector_set(state->subg, 1, g1);\n\n /* compute subB */\n\n /* compute J D^{-1} */\n gsl_matrix_memcpy(state->JQ, trust_state->J);\n\n for (i = 0; i < p; ++i)\n {\n gsl_vector_view c = gsl_matrix_column(state->JQ, i);\n double di = gsl_vector_get(trust_state->diag, i);\n gsl_vector_scale(&c.vector, 1.0 / di);\n }\n\n /* compute J D^{-1} Q */\n gsl_linalg_QR_matQ(state->W, state->tau, state->JQ);\n\n /* compute subB = Q^T D^{-1} J^T J D^{-1} Q */\n gsl_blas_dsyrk(CblasLower, CblasTrans, 1.0, &JQ.matrix, 0.0, state->subB);\n\n B00 = gsl_matrix_get(state->subB, 0, 0);\n B10 = gsl_matrix_get(state->subB, 1, 0);\n B11 = gsl_matrix_get(state->subB, 1, 1);\n\n state->trB = B00 + B11;\n state->detB = B00*B11 - B10*B10;\n state->normg = gsl_blas_dnrm2(state->subg);\n\n /* g^T adj(B)^T adj(B) g */\n state->term0 = (B10*B10 + B11*B11)*g0*g0 -\n 2*B10*(B00 + B11)*g0*g1 +\n (B00*B00 + B10*B10)*g1*g1;\n\n /* g^T adj(B)^T g */\n state->term1 = B11 * g0 * g0 + g1 * (B00*g1 - 2*B10*g0);\n\n }\n\n return GSL_SUCCESS;\n}\n\n\n/*\nsubspace2D_step()\n Calculate a new step with 2D subspace method. Based on [1]. We\nseek a vector dx in span{dx_gn, dx_sd} which minimizes the model\nfunction subject to ||dx|| <= delta\n*/\n\nstatic int\nsubspace2D_step(const void * vtrust_state, const double delta,\n gsl_vector * dx, void * vstate)\n{\n const gsl_multifit_nlinear_trust_state *trust_state =\n (const gsl_multifit_nlinear_trust_state *) vtrust_state;\n subspace2D_state_t *state = (subspace2D_state_t *) vstate;\n\n if (state->norm_Dgn <= delta)\n {\n /* Gauss-Newton step is inside trust region, use it as final step\n * since it is the global minimizer of the quadratic model function */\n gsl_vector_memcpy(dx, state->dx_gn);\n }\n else if (state->rank < 2)\n {\n /* rank of [dx_sd, dx_gn] is 1, meaning dx_sd and dx_gn\n * are parallel so we can't form a 2D subspace. Follow the steepest\n * descent direction to the trust region boundary as our step */\n gsl_vector_memcpy(dx, state->dx_sd);\n gsl_vector_scale(dx, delta / state->norm_Dsd);\n }\n else\n {\n int status;\n const double delta_sq = delta * delta;\n double u = state->normg / delta;\n double a[5];\n double z[8];\n\n#if 1\n a[0] = state->detB * state->detB - state->term0 / delta_sq;\n a[1] = 2 * state->detB * state->trB - 2 * state->term1 / delta_sq;\n a[2] = state->trB * state->trB + 2 * state->detB - u * u;\n a[3] = 2 * state->trB;\n a[4] = 1.0;\n#else\n double TrB_D = state->trB * delta;\n double detB_D = state->detB * delta;\n double normg_sq = state->normg * state->normg;\n\n a[0] = detB_D * detB_D - state->term0;\n a[1] = 2 * state->detB * state->trB * delta_sq - 2 * state->term1;\n a[2] = TrB_D * TrB_D + 2 * state->detB * delta_sq - normg_sq;\n a[3] = 2 * state->trB * delta_sq;\n a[4] = delta_sq;\n#endif\n\n status = gsl_poly_complex_solve(a, 5, state->poly_p, z);\n if (status == GSL_SUCCESS)\n {\n size_t i;\n double min = 0.0;\n int mini = -1;\n double x_data[2];\n gsl_vector_view x = gsl_vector_view_array(x_data, 2);\n\n /*\n * loop through all four values of the Lagrange multiplier\n * lambda. For each lambda, evaluate the objective function\n * with Re(lambda) to determine which lambda minimizes the\n * function\n */\n for (i = 0; i < 4; ++i)\n {\n double cost, normx;\n\n /*fprintf(stderr, \"root: %.12e + %.12e i\\n\",\n z[2*i], z[2*i+1]);*/\n\n status = subspace2D_solution(z[2*i], &x.vector, state);\n if (status != GSL_SUCCESS)\n continue; /* singular matrix system */\n\n /* ensure ||x|| = delta */\n\n normx = gsl_blas_dnrm2(&x.vector);\n if (normx == 0.0)\n continue;\n\n gsl_vector_scale(&x.vector, delta / normx);\n\n /* evaluate objective function to determine minimizer */\n cost = subspace2D_objective(&x.vector, state);\n if (mini < 0 || cost < min)\n {\n mini = (int) i;\n min = cost;\n }\n }\n\n if (mini < 0)\n {\n /* did not find minimizer - should not get here */\n return GSL_FAILURE;\n }\n else\n {\n /* compute x which minimizes objective function */\n subspace2D_solution(z[2*mini], &x.vector, state);\n\n /* dx = Q * x */\n gsl_vector_set_zero(dx);\n gsl_vector_set(dx, 0, gsl_vector_get(&x.vector, 0));\n gsl_vector_set(dx, 1, gsl_vector_get(&x.vector, 1));\n gsl_linalg_QR_Qvec(state->W, state->tau, dx);\n\n /* compute final dx by multiplying by D^{-1} */\n gsl_vector_div(dx, trust_state->diag);\n }\n }\n else\n {\n GSL_ERROR (\"gsl_poly_complex_solve failed\", status);\n }\n }\n\n return GSL_SUCCESS;\n}\n\nstatic int\nsubspace2D_preduction(const void * vtrust_state, const gsl_vector * dx,\n double * pred, void * vstate)\n{\n const gsl_multifit_nlinear_trust_state *trust_state =\n (const gsl_multifit_nlinear_trust_state *) vtrust_state;\n subspace2D_state_t *state = (subspace2D_state_t *) vstate;\n\n *pred = quadratic_preduction(trust_state->f, trust_state->J, dx, state->workn);\n\n return GSL_SUCCESS;\n}\n\n/* solve 2D subspace problem: (B + lambda*I) x = -g */\nstatic int\nsubspace2D_solution(const double lambda, gsl_vector * x,\n subspace2D_state_t * state)\n{\n int status = GSL_SUCCESS;\n double C_data[4];\n gsl_matrix_view C = gsl_matrix_view_array(C_data, 2, 2);\n double B00 = gsl_matrix_get(state->subB, 0, 0);\n double B10 = gsl_matrix_get(state->subB, 1, 0);\n double B11 = gsl_matrix_get(state->subB, 1, 1);\n\n /* construct C = B + lambda*I */\n gsl_matrix_set(&C.matrix, 0, 0, B00 + lambda);\n gsl_matrix_set(&C.matrix, 1, 0, B10);\n gsl_matrix_set(&C.matrix, 0, 1, B10);\n gsl_matrix_set(&C.matrix, 1, 1, B11 + lambda);\n\n /* use modified Cholesky in case C is not positive definite */\n gsl_linalg_mcholesky_decomp(&C.matrix, state->perm, NULL);\n gsl_linalg_mcholesky_solve(&C.matrix, state->perm, state->subg, x);\n\n gsl_vector_scale(x, -1.0);\n\n return status;\n}\n\n/* evaluate 2D objective function: f(x) = g^T x + 1/2 x^T B x */\nstatic double\nsubspace2D_objective(const gsl_vector * x, subspace2D_state_t * state)\n{\n double f;\n double y_data[2];\n gsl_vector_view y = gsl_vector_view_array(y_data, 2);\n\n /* compute: y = g + 1/2 B x */\n gsl_vector_memcpy(&y.vector, state->subg);\n gsl_blas_dsymv(CblasLower, 0.5, state->subB, x, 1.0, &y.vector);\n\n /* compute: f = x^T ( g + 1/2 B x ) */\n gsl_blas_ddot(x, &y.vector, &f);\n\n return f;\n}\n\n/*\nsubspace2D_calc_gn()\n Calculate Gauss-Newton step which satisfies:\n\nJ dx_gn = -f\n\nInputs: trust_state - trust state variables\n dx - (output) Gauss-Newton step\n\nReturn: success/error\n*/\n\nstatic int\nsubspace2D_calc_gn(const gsl_multifit_nlinear_trust_state * trust_state, gsl_vector * dx)\n{\n int status;\n const gsl_multifit_nlinear_parameters *params = trust_state->params;\n\n /* initialize linear least squares solver */\n status = (params->solver->init)(trust_state, trust_state->solver_state);\n if (status)\n return status;\n\n /* prepare the linear solver to compute Gauss-Newton step */\n status = (params->solver->presolve)(0.0, trust_state, trust_state->solver_state);\n if (status)\n return status;\n\n /* solve: J dx_gn = -f for Gauss-Newton step */\n status = (params->solver->solve)(trust_state->f,\n dx,\n trust_state,\n trust_state->solver_state);\n if (status)\n return status;\n\n return GSL_SUCCESS;\n}\n\n/*\nsubspace2D_calc_sd()\n Calculate steepest descent step,\n\ndx_sd = - || D^{-1} g ||^2 / || J D^{-2} g ||^2 D^{-2} g\n\nInputs: trust_state - trust state variables\n dx - (output) steepest descent vector\n state - workspace\n\nReturn: success/error\n*/\n\nstatic int\nsubspace2D_calc_sd(const gsl_multifit_nlinear_trust_state * trust_state, gsl_vector * dx,\n subspace2D_state_t * state)\n{\n double norm_Dinvg; /* || D^{-1} g || */\n double norm_JDinv2g; /* || J D^{-2} g || */\n double alpha; /* || D^{-1} g ||^2 / || J D^{-2} g ||^2 */\n double u;\n\n /* compute workp = D^{-1} g and its norm */\n gsl_vector_memcpy(state->workp, trust_state->g);\n gsl_vector_div(state->workp, trust_state->diag);\n norm_Dinvg = gsl_blas_dnrm2(state->workp);\n\n /* compute workp = D^{-2} g */\n gsl_vector_div(state->workp, trust_state->diag);\n\n /* compute: workn = J D^{-2} g */\n gsl_blas_dgemv(CblasNoTrans, 1.0, trust_state->J, state->workp, 0.0, state->workn);\n norm_JDinv2g = gsl_blas_dnrm2(state->workn);\n\n u = norm_Dinvg / norm_JDinv2g;\n alpha = u * u;\n\n /* dx_sd = -alpha D^{-2} g */\n gsl_vector_memcpy(dx, state->workp);\n gsl_vector_scale(dx, -alpha);\n\n return GSL_SUCCESS;\n}\n\nstatic const gsl_multifit_nlinear_trs subspace2D_type =\n{\n \"2D-subspace\",\n subspace2D_alloc,\n subspace2D_init,\n subspace2D_preloop,\n subspace2D_step,\n subspace2D_preduction,\n subspace2D_free\n};\n\nconst gsl_multifit_nlinear_trs *gsl_multifit_nlinear_trs_subspace2D = &subspace2D_type;\n", "meta": {"hexsha": "1c532783dc2d2dc998fa6d1987cfa5eccefb94f0", "size": 22109, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.6/multifit_nlinear/subspace2D.c", "max_stars_repo_name": "ielomariala/Hex-Game", "max_stars_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-06-14T11:51:37.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-14T11:51:37.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/multifit_nlinear/subspace2D.c", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-12-16T17:41:24.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-22T00:00:16.000Z", "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/multifit_nlinear/subspace2D.c", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-01-20T16:22:57.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-14T12:31:02.000Z", "avg_line_length": 31.0519662921, "max_line_length": 101, "alphanum_fraction": 0.6247681939, "num_tokens": 6483, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8705972650509008, "lm_q2_score": 0.6297746143530797, "lm_q1q2_score": 0.5482800568542769}} {"text": "/*\nF(4,3)\ncc -static -o test_cblas_open main43.c -I /opt/OpenBLAS/include/ -L/opt/OpenBLAS/lib -lopenblas -lpthread -lgfortran\n\t->For each cube of kernel\n\t\t-> for each tile (a tile is a cube d x d x channel)\n\t\t\t-> for each channel\n\t\t\t\t-> Apply the winograd algorithm\n\t\t\t-> sum the result of the previous channel to the result of the next channell\n\t\t-> write the tile in a single output layer\n\t->Add the output layer in che cube layer and change the kernel cube\n*/\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#define MAX_ELEMENTS 100\n#define FILENAMELEN 10\n#define DDIMENSION(m,r) (m+r-1)\n#define OUTPUTDIMENSION(m,w,d) (m * (w / d))\n\ntypedef float * Matrix;\ntypedef Matrix * Cube;\ntypedef Cube * Hypercube;\n\nvoid productABAt(float result[], float A[], float B[], int rowsA, int colsB, int colsA);\nvoid twoDcorrelation(float C[], float g[], float D[], int m, int r, int d);\nMatrix elaborateTile(Cube tile, Cube g, int m, int r, int d, int channel);\nCube fillTheTile(Cube image, int starth, int startw, int w, int d, int channel);\nvoid saveOutputTile(Matrix output, Matrix tileOutput, int starth, int startw, int w, int d, int m);\nMatrix elaborateKernel(Cube image, Cube g, int m, int r, int channel, int w, int h, int d);\n\n/*START FUNCTION TO CREATE VARIABLES*/\n\tCube generateCube(int w, int h, int ch);\n\tMatrix generateMatrix(int w, int h);\n\tHypercube readKernels(int w, int h, int ch, int k, char fileName[]);\n\tCube readInput(int w, int h, int ch, char fileName[]);\n\n\tvoid printCube(Cube c, int w, int channel);\n/*END FUNCTION TO CREARE VARIABLES*/\n\n/*START FUNCTIONS TO READ THE FILES*/\n\tvoid readFile(float result[], char fileName[]);\n\tvoid generateNameAT(char* at, int m, int r);\n\tvoid generateNameG(char* g, int m, int r);\n\tvoid generateNameBT(char* g, int m, int r);\n/* END FUNCRIONS TO READ THE FILES*/\n\n\nstatic Matrix A;\t//Parameters that are used to make the lowest operation.\nstatic Matrix B;\t//\nstatic Matrix G;\t//\n\nvoid main(int argc, char *argv[])\n{\n\t\n\tint m = atoi(argv[1]);\t\t\t//dimension of the output tile\n\tint r = atoi(argv[2]);\t\t\t//dimension of the kernel rxr\n\tint channel = atoi(argv[3]);\t//dimension of the channel\n\tint k = atoi(argv[4]);\t\t\t//number of kernel\n\tint w = atoi(argv[5]);\t\t\t//width of the image -> multiple of d\n\tint h = atoi(argv[6]);\t\t\t//height of the image -> multiple of d\n\n\tchar * inputFilename = argv[7];\n\tchar * kernelFilename = argv[8];\n\t\t\n\tint d = DDIMENSION(m,r);\n\n\tchar fnameAT[FILENAMELEN];\n\tchar fnameG[FILENAMELEN];\n\tchar fnameBT[FILENAMELEN];\n\n\tgenerateNameAT(fnameAT, m,r);\n\tgenerateNameG(fnameG, m,r);\n\tgenerateNameBT(fnameBT, m,r);\n\t\n\tA = generateMatrix(m, d);\n\tB = generateMatrix(d, d);\n\tG = generateMatrix(r, d);\n\n\treadFile(A, fnameAT);\n\treadFile(B, fnameBT);\n\treadFile(G, fnameG);\n\t\n\tCube image = readInput(w, h, channel, inputFilename);\n\tHypercube kernel = readKernels(r, r, channel, k, kernelFilename);\n\n\tprintf(\"IMAGE\\n\");\n\tprintCube(image, w, channel);\n\n\tprintf(\"\\nKERNELS\\n\");\n\tfor(int i = 0; i < k; i++)\n\t{\n\t\tprintf(\"Kernel number %d\\n\", i);\n\t\tprintCube(kernel[i], r, channel);\n\t}\n\tprintf(\"\\n------------------\\n\");\n\tCube output = (Cube)malloc(k * sizeof(Matrix));\t//k is the number of filters\n\t\n\t//printf(\"START THE COMPUTATION - SLEEP FOR 3 SECONDS\\n\");\n \t//sleep(3);\n\t/*\n\t *\tSTART COMPUTATION.\n\t */\n\tclock_t start = clock();\n\tfor(int i = 0; i < k; i ++)\n\t\toutput[i] = elaborateKernel(image, kernel[i], m, r, channel, w, h, d);\n\t\n\tclock_t end = clock();\n\t/*\n\t *\tEND COMPUTATION.\n\t */\n\t\n\tprintf(\"OUTPUT:\\n\");\n\tprintCube(output, OUTPUTDIMENSION(m,w,d), k);\n\t\n\tfloat seconds = (float)(end - start) / CLOCKS_PER_SEC;\n\t\n\tprintf(\"\\nTIME IN SECONDS TO DO F(%d,%d) = %f\\n\",m,r,seconds);\n\t\n}\n\nvoid printCube(Cube c, int w, int channel)\n{\n\tfor(int i = 0; i < channel; i++)\n\t{\n\t\tprintf(\"channel %d:\\n\",i);\n\t\tfor(int j = 0; j < w * w; j ++)\n\t\t{\n\t\t\tprintf(\"%.2f \", c[i][j]);\n\t\t\tif((j+1) % w == 0) printf(\"\\n\");\n\t\t}\n\t}\n}\n\n\nMatrix elaborateKernel(Cube image, Cube g, int m, int r, int channel, int w, int h, int d)\n{\n\tMatrix output = generateMatrix(OUTPUTDIMENSION(m,w,d), OUTPUTDIMENSION(m,w,d));\n\t\n\tfor(int i = 0; i < h; i = i + d)\n\t{\n\t\tfor (int j = 0; j < w; j = j + d)\n\t\t{\n\t\t\tCube tile = fillTheTile(image, i, j, w, d, channel);\n\t\t\t\n\t\t\tMatrix tileOutput = elaborateTile(tile, g, m, r, d, channel);\n\t\t\tsaveOutputTile(output, tileOutput, i, j, w, d, m);\n\n\t\t\tfree(tileOutput);\n\t\t\tfree(tile);\n\t\t}\n\t}\n\treturn output;\n}\n\n\n/*\n\tWrite the output tile on the output image.\n*/\n\nvoid saveOutputTile(Matrix output, Matrix tileOutput, int starth, int startw, int w, int d, int m)\n{\n\t\tint outputWidth = OUTPUTDIMENSION(m,w,d);\n\t\tint offsetw = (startw / d) * m;\n\t\tint offseth = (starth / d) * m;\n\t\tfor(int y = 0; y < m; y ++)\n\t\t\tfor(int x = 0; x < m; x++)\n\t\t\t\toutput[(x + offsetw) + (outputWidth * (y + offseth))] = tileOutput[x + (m * y)];\n\n}\n\n/*\n\tThis function takes an image, it divides the image based on starth and startw and it returns a tile.\n\t\t- image -> the all image\n\t\t- starth -> height coordinate of the image where to start to make the tile\n\t\t- startw -> width coordinate of the image where to start to make the tile\n\t\t- w -> total width of the image\n\t\t- d -> dimension of the tile -> d x d\n\t\t- channel -> number of channels of the image\n\tRESULT\n\t\t- A cube d x d x channell that represent a single tile.\n*/\nCube fillTheTile(Cube image, int starth, int startw, int w, int d, int channel)\n{\n\tCube tile = generateCube(d, d, channel);\n\tfor(int c = 0; c < channel; c++)\n\t\tfor(int y = 0; y < d; y ++)\n\t\t\tfor(int x = 0; x < d; x++)\n\t\t\t\ttile[c][x + (d * y)] = image[c][(startw + x) + (w * (y + starth))];\n\treturn tile;\n}\n\n/*\n\tThis function is used to make the combination with a tile and a kernel.\n\t\t- tile has the dimension d x d and has 'channel' channels\n\t\t- g is the kernel, it has the dimension of r x r and has 'channel' channels\n\t\t- m -> dimension of the output\n\t\t- r -> dimension of the kernel\n\t\t- d -> dimension of the tile\n\t\t- channell -> number of channels\n\tRESULT\n\t\t- it returns a matrix calculated by an element wise sum of the result of the function twoDcorrelation \n\t\t\tcalculated for each channel.\n*/\nMatrix elaborateTile(Cube tile, Cube g, int m, int r, int d, int channel)\n{\n\tMatrix temp = generateMatrix(d,d);\n\tMatrix tileOutputBig = generateMatrix(d,d);\n\tMatrix tileOutput = generateMatrix(m,m);\n\n\tfor(int i = 0; i < m * m; i++)\n\t\t\ttileOutput[i] = 0;\n\n\tfor(int i = 0; i < channel; i++)\n\t{\n\t \ttwoDcorrelation(temp, g[i], tile[i], m, r, d);\n\t\tfor(int j = 0 ; j < d * d; j++)\n\t\t\ttileOutputBig[j] = tileOutputBig[j] + temp[j];\n\t\t\n\t}\n\tproductABAt(tileOutput, A, tileOutputBig, m, d, d);\n\tfree(temp);\n\tfree(tileOutputBig);\n\n\treturn tileOutput;\n}\n\nCube generateCube(int w, int h, int ch)\n{\n\tCube cube = (Cube)malloc(ch * sizeof(Matrix));\n\tfor(int i = 0; i < ch; i++)\n\t\tcube[i] = generateMatrix(w,h);\n\n\treturn cube;\n}\n\nMatrix generateMatrix(int w, int h)\n{\n\treturn (Matrix)malloc(w * h * sizeof(float));\n}\n\n/*\n\tCalculate a single channel for a single kernel for a single tile\n\tInput Parameter:\n\t\t- result -> matrix of the result\n\t\t- g -> the considered kernel\n\t\t- D -> the considered tile\n\t\t- m -> Dimension of the output\n\t\t- r -> dimension of the kernel\n\t\t- d -> dimension of the tile (m + r - 1)\n*/\nvoid twoDcorrelation(float C[], float g[], float D[], int m, int r, int d)\n{\n\t\n\t\n\tfloat GgG[MAX_ELEMENTS];\n\tfloat BDB[MAX_ELEMENTS];\n\tint i=0;\n\n\tproductABAt(GgG, G, g, d, r, r);\n\tproductABAt(BDB, B, D, d, d, d);\n\n \tfor(i=0;i rowsA\n *\t\t- Number of cols of B -> colsB \n *\t\t- Number of cols of A that is equal to the numer of rows of B -> colsA\n * Result\n *\t\t- Matrix result -> that is an rowsA x rowsA matrix\n */\nvoid productABAt(float result[], float A[], float B[], int rowsA, int colsB, int colsA)\n{\n\tfloat C[MAX_ELEMENTS];\n\n\tcblas_sgemm(CblasRowMajor,\t//Modo in cui è salvata la matrice, legge i numeri riga per riga \n\t\tCblasNoTrans,\t//Non fare trasposta \n\t\tCblasNoTrans, \t//Non fare trasposta\n\t\trowsA, \t\t//numero righe matrice A\n\t\tcolsB, \t\t//numero colonne matrice B\n\t\tcolsA, \t\t//numero colonne A & numero righe B\n\t\t1, \t\t//moltiplicatore prima matrice\n\t\tA, \t\t//Matrice A\n\t\tcolsA, \t\t//numero colonne matrice A\n\t\tB, \t\t//Matrice B\n\t\tcolsB, \t\t//numero colonne matrice B\n\t\t0, \t\t//Moltiplicatore matrice C\n\t\tC,\t\t//matrice C\n\t\tcolsB);\t\t//numero righe matrice C\n\n\t//C has rowsA rows and colsB cols\n\t//the result has rowsA rows and rowsA cols \n\n\tcblas_sgemm(CblasRowMajor,\n\t\tCblasNoTrans,\n\t\tCblasTrans,\n\t\trowsA,\t//numero righe matrice C\n\t\trowsA,\n\t\tcolsB,\n\t\t1,\n\t\tC,\n\t\tcolsB,\n\t\tA,\n\t\tcolsA,\n\t\t0,\n\t\tresult,\n\t\trowsA);\n}\n\nCube readInput(int w, int h, int ch, char fileName[])\n{\n\n FILE *f;\n f = fopen(fileName, \"r\");\n if(f==NULL)\n\t{\n \tprintf(\"I can not read the file %s\\n\", fileName);\n\t\texit(0);\n\t}\n\t\t\t\n int fi = 0;\n int linesize = w*h;\n Cube matrix = (Cube)malloc(ch * sizeof(Matrix));\n\n for(int i = 0; i < ch; i++)\n\t{\n matrix[i] = (Matrix)malloc(linesize * sizeof(float));\n while(!feof(f)&&fi\n#include \n#include \n#include \n\n#include \"error.h\"\n\ndouble\ngsl_cdf_fdist_Pinv (const double P, const double nu1, const double nu2)\n{\n double result;\n double y;\n\n if (P < 0.0)\n {\n CDF_ERROR (\"P < 0.0\", GSL_EDOM);\n }\n if (P > 1.0)\n {\n CDF_ERROR (\"P > 1.0\", GSL_EDOM);\n }\n if (nu1 < 1.0)\n {\n CDF_ERROR (\"nu1 < 1\", GSL_EDOM);\n }\n if (nu2 < 1.0)\n {\n CDF_ERROR (\"nu2 < 1\", GSL_EDOM);\n }\n\n if (P < 0.5)\n {\n y = gsl_cdf_beta_Pinv (P, nu1 / 2.0, nu2 / 2.0);\n\n result = nu2 * y / (nu1 * (1.0 - y));\n }\n else\n {\n y = gsl_cdf_beta_Qinv (P, nu2 / 2.0, nu1 / 2.0);\n\n result = nu2 * (1 - y) / (nu1 * y);\n }\n\n return result;\n}\n\ndouble\ngsl_cdf_fdist_Qinv (const double Q, const double nu1, const double nu2)\n{\n double result;\n double y;\n\n if (Q < 0.0)\n {\n CDF_ERROR (\"Q < 0.0\", GSL_EDOM);\n }\n if (Q > 1.0)\n {\n CDF_ERROR (\"Q > 1.0\", GSL_EDOM);\n }\n if (nu1 < 1.0)\n {\n CDF_ERROR (\"nu1 < 1\", GSL_EDOM);\n }\n if (nu2 < 1.0)\n {\n CDF_ERROR (\"nu2 < 1\", GSL_EDOM);\n }\n\n if (Q > 0.5)\n {\n y = gsl_cdf_beta_Qinv (Q, nu1 / 2.0, nu2 / 2.0);\n\n result = nu2 * y / (nu1 * (1.0 - y));\n }\n else\n {\n y = gsl_cdf_beta_Pinv (Q, nu2 / 2.0, nu1 / 2.0);\n\n result = nu2 * (1 - y) / (nu1 * y);\n }\n\n return result;\n}\n", "meta": {"hexsha": "231f5c1259cd60b182e909cc39d4b93bdc2acc94", "size": 2245, "ext": "c", "lang": "C", "max_stars_repo_path": "pkgs/libs/gsl/src/cdf/fdistinv.c", "max_stars_repo_name": "manggoguy/parsec-modified", "max_stars_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 64.0, "max_stars_repo_stars_event_min_datetime": "2015-03-06T00:30:56.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-24T13:26:53.000Z", "max_issues_repo_path": "pkgs/libs/gsl/src/cdf/fdistinv.c", "max_issues_repo_name": "manggoguy/parsec-modified", "max_issues_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 12.0, "max_issues_repo_issues_event_min_datetime": "2020-12-15T08:30:19.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-13T03:54:24.000Z", "max_forks_repo_path": "pkgs/libs/gsl/src/cdf/fdistinv.c", "max_forks_repo_name": "manggoguy/parsec-modified", "max_forks_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 40.0, "max_forks_repo_forks_event_min_datetime": "2015-02-26T15:31:16.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-03T23:23:37.000Z", "avg_line_length": 21.380952381, "max_line_length": 77, "alphanum_fraction": 0.579064588, "num_tokens": 793, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8031738057795403, "lm_q2_score": 0.6825737473266735, "lm_q1q2_score": 0.5482253543655667}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \"userFunc.h\"\n\n#define G 6.67384e-8 /* 2010 CODATA value in CGS units */\n#define ALPHAMIN 1.0e-3 /* Minimum alpha allowed for numerical reasons */\n\n/**************************************************************************/\n/* This defines userFunc routines for the Krumholz & Burkert (2010) GI */\n/* disk problem. */\n/**************************************************************************/\n\nvoid\nuserEOS(const double t, const double dt, const grid *grd, \n\tconst double *col, const double *pres, const double *eInt,\n\tvoid *params,\n\tdouble *gamma, double *delta) {\n fprintf(stderr, \n\t \"Warning: userEOS function called but not implemented!\\n\");\n return;\n}\n\nvoid\nuserAlpha(const double t, const double dt, const grid *grd, \n\t const double *col, const double *pres, const double *eInt,\n\t const double *gamma, const double *delta,\n\t void *params,\n\t double *alpha) {\n\n gsl_poly_complex_workspace *wksp;\n double coef[6], sol[10];\n double omega, kappa, T1, sigma, kcrit, J, Q, d, tfast, tgrowth;\n int i, j;\n const int m=2;\n gsl_complex nu2, nu;\n double alphacoef = ((double *) params)[4];\n\n /* Allocate workspace */\n wksp = gsl_poly_complex_workspace_alloc(6);\n\n /* Store the coefficiencts of the dispersion relation polynomial\n that don't change */\n coef[2] = -8.0;\n coef[3] = coef[4] = 0.0;\n\n /* Loop over cells */\n for (i=0; inr; i++) {\n\n /* Handle negative column densities, which may arise if the time\n step overshoots. We just need to make sure the code doesn't\n barf here, as the negative column densities will be fixed by\n the iterative solver. */\n if (col[i] <= 0.0) {\n alpha[i] = ALPHAMIN;\n continue;\n }\n\n /* The various quantities needed for the stability analysis */\n sigma = sqrt(pres[i]/col[i]);\n omega = grd->vphi_g[i+1]/grd->r_g[i+1];\n kappa = sqrt(2.0*(1.0+grd->beta_g[i+1]))*omega;\n T1 = -(2.0*m*omega/(kappa*grd->r_g[i+1])) * \n (2.0*m*omega/(kappa*grd->r_g[i+1])) * (grd->beta_g[i+1]-1);\n kcrit = kappa*kappa / (2.0*M_PI*G*col[i]);\n Q = kappa*sigma / (M_PI*G*col[i]);\n if (Q < 0)\n printf(\"Q < 0! kappa = %f, sigma = %f, col = %f\\n\", kappa, sigma, col[i]);\n J = sqrt(T1)/kcrit;\n \n /* Coefficients of the disperison relation polynomial */\n coef[0] = -Q*Q*Q*Q;\n coef[1] = 6.0*Q*Q;\n coef[5] = 16.0*J*J;\n\n /* Find roots, giving minima and maxima of D */\n gsl_poly_complex_solve(coef, 6, wksp, sol);\n\n /* For each root, compute the growth time of the instability */\n tfast = 1.0e30;\n for (j=0; j<5; j++) {\n\n /* Skip roots with negative real part, or imaginary part that is\n\t greater than roundoff */\n if ((sol[2*j] < 0) || (fabs(sol[2*j+1]) > 1.0e-6)) continue;\n\n /* Compute D */\n d = (Q*Q/(4.0*sol[2*j]*sol[2*j]) - 1.0/sol[2*j]) *\n\t(Q*Q/(4.0*sol[2*j]*sol[2*j]) - 1.0/sol[2*j] - \n\t 4.0*J*J*sol[2*j]*sol[2*j]);\n\n /* Ignore stable roots */\n if (d > 0) continue;\n\n /* Get frequency and growth time */\n GSL_SET_COMPLEX(&nu2, \n\t\t 1.0 + 0.5*(Q*Q/(4.0*sol[2*j]*sol[2*j]) - 1.0/sol[2*j]),\n\t\t 0.5 * sqrt(-d));\n nu = gsl_complex_sqrt(nu2);\n tgrowth = 1.0 / (GSL_IMAG(nu)*kappa) / (2.0*M_PI/omega);\n\n /* Store minimum growth time */\n if (tgrowth < tfast) tfast = tgrowth;\n }\n\n /* Now check for gravitational instability */\n if (Q < 1) {\n GSL_SET_COMPLEX(&nu, 0.0, sqrt(1.0/(Q*Q)-1.0));\n tgrowth = 1.0 / (GSL_IMAG(nu)*kappa) / (2.0*M_PI/omega);\n if (tgrowth < tfast) tfast = tgrowth;\n }\n\n /* Compute alpha based on the fastest growing mode timescale */\n alpha[i] = alphacoef * exp(-tfast+1.0);\n if (alpha[i] > 1.0) alpha[i] = 1.0;\n if (alpha[i] < ALPHAMIN) alpha[i] = ALPHAMIN;\n }\n\n /* Free workspace */\n gsl_poly_complex_workspace_free(wksp);\n}\n\nvoid\nuserMassSrc(const double t, const double dt, const grid *grd,\n\t const double *col, const double *pres, const double *eInt,\n\t const double *gamma, const double *delta,\n\t void *params,\n\t double *massSrc) {\n /* Estimate Mdot by \n dSigma/dt = - eta_ML Sigma_SFR \n = - eta_ML eps_ff Sigma_g/t_ff, \n */\n\n int i;\n double shapefac = ((double *) params)[2];\n double zetad = ((double *) params)[3];\n double etaML = ((double *) params)[5];\n double epsffmax = ((double *) params)[6];\n double rhostar, a, b, c, h;\n double rhog, tff, alphavir, epsff;\n\n for (i=0; inr; i++) {\n /* Stellar density */\n rhostar = shapefac * SQR(grd->vphi_g[i+1]) * \n (1.0+2.0*grd->beta_g[i+1]) / \n (4.0*M_PI*G*SQR(grd->r_g[i+1]));\n /* Get scale height from OML model */\n if (rhostar > 0.0) {\n a = 2.0*M_PI*zetad*G*rhostar*col[i];\n b = M_PI/2.0*G*SQR(col[i]);\n c = -pres[i];\n h = (-b + sqrt(b*b-4.0*a*c))/(2.0*a);\n } else {\n h = pres[i] / (M_PI/2.0*G*SQR(col[i]));\n }\n /* Gas density and free-fall time */\n rhog = col[i]/(2*h);\n tff = sqrt(3*M_PI/(32*G*rhog));\n /* Virial ratio */\n alphavir = pres[i]/(M_PI/2.0*G*col[i]*col[i]*h);\n /* epsff */\n if (alphavir <= 1.0) epsff = epsffmax;\n else epsff = epsffmax*exp(-alphavir);\n /* Mdot */\n massSrc[i] = -(1.0+etaML) * epsff * col[i] / tff;\n }\n}\n\n\nvoid\nuserIntEnSrc(const double t, const double dt, const grid *grd,\n\t const double *col, const double *pres, const double *eInt,\n\t const double *gamma, const double *delta,\n\t void *params, \n\t double *intEnSrc) {\n /* Cooling rate = eta Sigma sigma^2 Omega = eta P vphi/r */\n int i;\n double eta = ((double *) params)[0];\n double sigmath = ((double *) params)[1];\n double shapefac = ((double *) params)[2];\n double zetad = ((double *) params)[3];\n double sigma2, sigmaNT, rhostar, a, b, c, h;\n\n for (i=0; inr; i++) {\n /* Gas velocity dispersion */\n sigma2 = pres[i]/col[i];\n if (sigma2 > SQR(sigmath)) {\n sigmaNT = sqrt(sigma2 - SQR(sigmath));\n /* Stellar density */\n rhostar = shapefac * SQR(grd->vphi_g[i+1]) * \n\t(1.0+2.0*grd->beta_g[i+1]) / \n\t(4.0*M_PI*G*SQR(grd->r_g[i+1]));\n /* Get scale height from OML model */\n if (rhostar > 0.0) {\n\ta = 2.0*M_PI*zetad*G*rhostar*col[i];\n\tb = M_PI/2.0*G*SQR(col[i]);\n\tc = -pres[i];\n\th = (-b + sqrt(b*b-4.0*a*c))/(2.0*a);\n } else {\n\th = pres[i] / (M_PI/2.0*G*SQR(col[i]));\n }\n /* Cooling rate = eta Sigma sigmaNT^2 / (h/sigmaNT) */\n intEnSrc[i] = -eta * col[i] * SQR(sigmaNT) / (h/sigmaNT);\n } else {\n intEnSrc[i] = 0.0;\n }\n }\n}\n\nvoid\nuserIBC(const double t, const double dt, const grid *grd,\n\tconst double *col, const double *pres, const double *eInt,\n\tconst double *gamma, const double *delta,\n\tconst pres_bc_type ibc_pres, const enth_bc_type ibc_enth,\n\tvoid *params, \n\tdouble *ibc_pres_val, double *ibc_enth_val) {\n fprintf(stderr, \n\t \"Warning: userIBC function called but not implemented!\\n\");\n return;\n}\n\nvoid\nuserOBC(const double t, const double dt, const grid *grd,\n\tconst double *col, const double *pres, const double *eInt,\n\tconst double *gamma, const double *delta,\n\tconst pres_bc_type obc_pres, const enth_bc_type obc_enth,\n\tvoid *params, \n\tdouble *obc_pres_val, double *obc_enth_val) {\n fprintf(stderr, \n\t \"Warning: userOBC function called but not implemented!\\n\");\n return;\n}\n\n\nvoid\nuserPreTimestep(const double t, const double dt,\n\t\tconst grid *grd, double *col, double *pres,\n\t\tdouble *eInt, double *mBnd, double *eBnd,\n\t\tdouble *mSrc, double *eSrc,\n\t\tvoid *params, const unsigned long nUserOut,\n\t\tdouble *userOut) {\n fprintf(stderr,\n\t \"Warning: userPreTimestep function called but not implemented!\\n\");\n return;\n}\n\nvoid\nuserPostTimestep(const double t, const double dt,\n\t\t const grid *grd, double *col, double *pres,\n\t\t double *eInt, double *mBnd, double *eBnd,\n\t\t double *mSrc, double *eSrc,\n\t\t void *params, const unsigned long nUserOut,\n\t\t double *userOut) {\n fprintf(stderr,\n\t \"Warning: userPostTimestep function called but not implemented!\\n\");\n return;\n}\n\nvoid\nuserCheckRead(\n\t FILE *fp, grid *grd, const unsigned long nOut,\n\t double *tOut, double *colOut,\n\t double *presOut, double *eIntOut, double *mBndOut,\n\t double *eBndOut, double *mSrcOut, double *eSrcOut,\n\t const unsigned long nUserOut, double *userOut,\n\t void *params\n\t ) {\n fprintf(stderr,\n\t \"Warning: userCheckRead function called but not implemented!\\n\");\n return;\n}\n\nvoid\nuserCheckWrite(\n\t FILE *fp,\n\t const grid *grd, const unsigned long nOut,\n\t const double *tOut, const double *colOut,\n\t const double *presOut, const double *eIntOut,\n\t const double *mBndOut, const double *eBndOut,\n\t const double *mSrcOut, const double *eSrcOut,\n\t const unsigned long nUserOut, const double *userOut,\n\t const void *params\n\t ) {\n fprintf(stderr,\n\t \"Warning: userCheckWrite function called but not implemented!\\n\");\n return;\n}\n", "meta": {"hexsha": "f36eb2b2f7f4de3f5acb7098679634597c5d63c1", "size": 9023, "ext": "c", "lang": "C", "max_stars_repo_path": "src/amuse/community/vader/src/prob/userFunc_cmzdisk.c", "max_stars_repo_name": "franciscaconcha/amuse-vader", "max_stars_repo_head_hexsha": "646b3136c39da7152c82a032f8151555ec1e3d44", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/amuse/community/vader/src/prob/userFunc_cmzdisk.c", "max_issues_repo_name": "franciscaconcha/amuse-vader", "max_issues_repo_head_hexsha": "646b3136c39da7152c82a032f8151555ec1e3d44", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/amuse/community/vader/src/prob/userFunc_cmzdisk.c", "max_forks_repo_name": "franciscaconcha/amuse-vader", "max_forks_repo_head_hexsha": "646b3136c39da7152c82a032f8151555ec1e3d44", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-11-19T04:41:37.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-20T02:11:17.000Z", "avg_line_length": 31.1137931034, "max_line_length": 80, "alphanum_fraction": 0.5963648454, "num_tokens": 2943, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8856314647623016, "lm_q2_score": 0.6187804337438501, "lm_q1q2_score": 0.5480114219028183}} {"text": "#include \n#include \n\nint main()\n{\n double a[] = { 0.11, 0.12, 0.13,\n 0.21, 0.22, 0.23 };\n\n double b[] = { 1011, 1012,\n 1021, 1022,\n 1031, 1032 };\n\n double c[] = { 0.00, 0.00,\n 0.00, 0.00 };\n\n gsl_matrix_view A = gsl_matrix_view_array(a, 2, 3);\n gsl_matrix_view B = gsl_matrix_view_array(b, 3, 2);\n gsl_matrix_view C = gsl_matrix_view_array(c, 2, 2);\n\n gsl_matrix *D = gsl_matrix_alloc(2, 3);\n int i, j;\n for (i=1; i<3; i++)\n for (j=1; j<4; j++)\n gsl_matrix_set (D, i-1, j-1, ((float) i)/10 + ((float) j)/100);\n \n for (i=0; i<2; i++)\n for (j=0; j<3; j++)\n printf(\"D(%d,%d) = %f\\n\", i, j, gsl_matrix_get(D, i, j));\n \n gsl_blas_dgemm(CblasNoTrans, CblasNoTrans,\n 1.0, D, &B.matrix,\n 0.0, &C.matrix);\n\n printf (\"[ %g, %g\\n\", c[0], c[1]);\n printf (\" %g, %g ]\\n\", c[2], c[3]);\n\n return 0;\n}\n", "meta": {"hexsha": "58ff15383212cedf0ce62763b73c3ad0e1fa7b83", "size": 938, "ext": "c", "lang": "C", "max_stars_repo_path": "benchmarks/matrix_library_tests/gslProduct.c", "max_stars_repo_name": "tcrundall/chronostar", "max_stars_repo_head_hexsha": "bdb5cd965e862ba5cc21bee75d5c8620e106c0cc", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 4.0, "max_stars_repo_stars_event_min_datetime": "2018-05-28T11:05:42.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-14T01:13:11.000Z", "max_issues_repo_path": "benchmarks/matrix_library_tests/gslProduct.c", "max_issues_repo_name": "tcrundall/chronostar", "max_issues_repo_head_hexsha": "bdb5cd965e862ba5cc21bee75d5c8620e106c0cc", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 13.0, "max_issues_repo_issues_event_min_datetime": "2019-08-14T07:30:24.000Z", "max_issues_repo_issues_event_max_datetime": "2021-11-08T23:44:29.000Z", "max_forks_repo_path": "benchmarks/matrix_library_tests/gslProduct.c", "max_forks_repo_name": "tcrundall/chronostar", "max_forks_repo_head_hexsha": "bdb5cd965e862ba5cc21bee75d5c8620e106c0cc", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4.0, "max_forks_repo_forks_event_min_datetime": "2016-04-21T08:25:26.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-25T06:53:52.000Z", "avg_line_length": 24.0512820513, "max_line_length": 69, "alphanum_fraction": 0.4861407249, "num_tokens": 385, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8459424373085145, "lm_q2_score": 0.6477982247516797, "lm_q1q2_score": 0.5480000091305648}} {"text": "/* randist/test.c\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000 James Theiler, Brian Gough\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 2 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#define N 100000\nvoid testMoments (double (*f) (void), const char *name,\n\t\t double a, double b, double p);\nvoid testPDF (double (*f) (void), double (*pdf)(double), const char *name);\nvoid testDiscretePDF (double (*f) (void), double (*pdf)(unsigned int), \n\t\t\tconst char *name);\n\nvoid test_shuffle (void);\nvoid test_choose (void);\ndouble test_beta (void);\ndouble test_beta_pdf (double x);\ndouble test_bernoulli (void);\ndouble test_bernoulli_pdf (unsigned int n);\ndouble test_binomial (void);\ndouble test_binomial_pdf (unsigned int n);\ndouble test_binomial_large (void);\ndouble test_binomial_large_pdf (unsigned int n);\ndouble test_cauchy (void);\ndouble test_cauchy_pdf (double x);\ndouble test_chisq (void);\ndouble test_chisq_pdf (double x);\ndouble test_discrete1 (void);\ndouble test_discrete1_pdf (unsigned int n);\ndouble test_discrete2 (void);\ndouble test_discrete2_pdf (unsigned int n);\ndouble test_erlang (void);\ndouble test_erlang_pdf (double x);\ndouble test_exponential (void);\ndouble test_exponential_pdf (double x);\ndouble test_exppow0 (void);\ndouble test_exppow0_pdf (double x);\ndouble test_exppow1 (void);\ndouble test_exppow1_pdf (double x);\ndouble test_exppow1a (void);\ndouble test_exppow1a_pdf (double x);\ndouble test_exppow2 (void);\ndouble test_exppow2_pdf (double x);\ndouble test_exppow2a (void);\ndouble test_exppow2a_pdf (double x);\ndouble test_fdist (void);\ndouble test_fdist_pdf (double x);\ndouble test_flat (void);\ndouble test_flat_pdf (double x);\ndouble test_gamma (void);\ndouble test_gamma_pdf (double x);\ndouble test_gamma1 (void);\ndouble test_gamma1_pdf (double x);\ndouble test_gamma_int (void);\ndouble test_gamma_int_pdf (double x);\ndouble test_gamma_large (void);\ndouble test_gamma_large_pdf (double x);\ndouble test_gaussian (void);\ndouble test_gaussian_pdf (double x);\ndouble test_gaussian_ratio_method (void);\ndouble test_gaussian_ratio_method_pdf (double x);\ndouble test_gaussian_tail (void);\ndouble test_gaussian_tail_pdf (double x);\ndouble test_gaussian_tail1 (void);\ndouble test_gaussian_tail1_pdf (double x);\ndouble test_gaussian_tail2 (void);\ndouble test_gaussian_tail2_pdf (double x);\ndouble test_ugaussian (void);\ndouble test_ugaussian_pdf (double x);\ndouble test_ugaussian_ratio_method (void);\ndouble test_ugaussian_ratio_method_pdf (double x);\ndouble test_ugaussian_tail (void);\ndouble test_ugaussian_tail_pdf (double x);\ndouble test_bivariate_gaussian1 (void);\ndouble test_bivariate_gaussian1_pdf (double x);\ndouble test_bivariate_gaussian2 (void);\ndouble test_bivariate_gaussian2_pdf (double x);\ndouble test_bivariate_gaussian3 (void);\ndouble test_bivariate_gaussian3_pdf (double x);\ndouble test_bivariate_gaussian4 (void);\ndouble test_bivariate_gaussian4_pdf (double x);\ndouble test_gumbel1 (void);\ndouble test_gumbel1_pdf (double x);\ndouble test_gumbel2 (void);\ndouble test_gumbel2_pdf (double x);\ndouble test_geometric (void);\ndouble test_geometric_pdf (unsigned int x);\ndouble test_geometric1 (void);\ndouble test_geometric1_pdf (unsigned int x);\ndouble test_hypergeometric1 (void);\ndouble test_hypergeometric1_pdf (unsigned int x);\ndouble test_hypergeometric2 (void);\ndouble test_hypergeometric2_pdf (unsigned int x);\ndouble test_hypergeometric3 (void);\ndouble test_hypergeometric3_pdf (unsigned int x);\ndouble test_hypergeometric4 (void);\ndouble test_hypergeometric4_pdf (unsigned int x);\ndouble test_hypergeometric5 (void);\ndouble test_hypergeometric5_pdf (unsigned int x);\ndouble test_hypergeometric6 (void);\ndouble test_hypergeometric6_pdf (unsigned int x);\ndouble test_landau (void);\ndouble test_landau_pdf (double x);\ndouble test_levy1 (void);\ndouble test_levy1_pdf (double x);\ndouble test_levy2 (void);\ndouble test_levy2_pdf (double x);\ndouble test_levy1a (void);\ndouble test_levy1a_pdf (double x);\ndouble test_levy2a (void);\ndouble test_levy2a_pdf (double x);\ndouble test_levy_skew1 (void);\ndouble test_levy_skew1_pdf (double x);\ndouble test_levy_skew2 (void);\ndouble test_levy_skew2_pdf (double x);\ndouble test_levy_skew1a (void);\ndouble test_levy_skew1a_pdf (double x);\ndouble test_levy_skew2a (void);\ndouble test_levy_skew2a_pdf (double x);\ndouble test_levy_skew1b (void);\ndouble test_levy_skew1b_pdf (double x);\ndouble test_levy_skew2b (void);\ndouble test_levy_skew2b_pdf (double x);\ndouble test_logistic (void);\ndouble test_logistic_pdf (double x);\ndouble test_lognormal (void);\ndouble test_lognormal_pdf (double x);\ndouble test_logarithmic (void);\ndouble test_logarithmic_pdf (unsigned int n);\ndouble test_negative_binomial (void);\ndouble test_negative_binomial_pdf (unsigned int n);\ndouble test_pascal (void);\ndouble test_pascal_pdf (unsigned int n);\ndouble test_pareto (void);\ndouble test_pareto_pdf (double x);\ndouble test_poisson (void);\ndouble test_poisson_pdf (unsigned int x);\ndouble test_poisson_large (void);\ndouble test_poisson_large_pdf (unsigned int x);\ndouble test_dir2d (void);\ndouble test_dir2d_pdf (double x);\ndouble test_dir2d_trig_method (void);\ndouble test_dir2d_trig_method_pdf (double x);\ndouble test_dir3dxy (void);\ndouble test_dir3dxy_pdf (double x);\ndouble test_dir3dyz (void);\ndouble test_dir3dyz_pdf (double x);\ndouble test_dir3dzx (void);\ndouble test_dir3dzx_pdf (double x);\ndouble test_rayleigh (void);\ndouble test_rayleigh_pdf (double x);\ndouble test_rayleigh_tail (void);\ndouble test_rayleigh_tail_pdf (double x);\ndouble test_tdist1 (void);\ndouble test_tdist1_pdf (double x);\ndouble test_tdist2 (void);\ndouble test_tdist2_pdf (double x);\ndouble test_laplace (void);\ndouble test_laplace_pdf (double x);\ndouble test_weibull (void);\ndouble test_weibull_pdf (double x);\ndouble test_weibull1 (void);\ndouble test_weibull1_pdf (double x);\n\ngsl_rng *r_global;\n\nint\nmain (void)\n{\n gsl_ieee_env_setup ();\n\n gsl_rng_env_setup() ;\n r_global = gsl_rng_alloc (gsl_rng_default);\n\n#define FUNC(x) test_ ## x, \"test gsl_ran_\" #x\n#define FUNC2(x) test_ ## x, test_ ## x ## _pdf, \"test gsl_ran_\" #x\n\n test_shuffle() ;\n test_choose() ;\n\n testMoments (FUNC (ugaussian), 0.0, 100.0, 0.5);\n testMoments (FUNC (ugaussian), -1.0, 1.0, 0.6826895);\n testMoments (FUNC (ugaussian), 3.0, 3.5, 0.0011172689);\n testMoments (FUNC (ugaussian_tail), 3.0, 3.5, 0.0011172689/0.0013498981);\n testMoments (FUNC (exponential), 0.0, 1.0, 1- exp(-0.5));\n testMoments (FUNC (cauchy), 0.0, 10000.0, 0.5);\n\n testMoments (FUNC (discrete1), -0.5, 0.5, 0.59 );\n testMoments (FUNC (discrete1), 0.5, 1.5, 0.40 );\n testMoments (FUNC (discrete1), 1.5, 3.5, 0.01 );\n\n testPDF (FUNC2(beta));\n testPDF (FUNC2(cauchy));\n testPDF (FUNC2(chisq));\n testPDF (FUNC2(erlang));\n testPDF (FUNC2(exponential));\n\n testPDF (FUNC2(exppow0));\n testPDF (FUNC2(exppow1));\n testPDF (FUNC2(exppow1a));\n testPDF (FUNC2(exppow2));\n testPDF (FUNC2(exppow2a));\n\n testPDF (FUNC2(fdist));\n testPDF (FUNC2(flat));\n testPDF (FUNC2(gamma));\n testPDF (FUNC2(gamma1));\n testPDF (FUNC2(gamma_int));\n testPDF (FUNC2(gamma_large));\n testPDF (FUNC2(gaussian));\n testPDF (FUNC2(gaussian_ratio_method));\n testPDF (FUNC2(ugaussian));\n testPDF (FUNC2(ugaussian_ratio_method));\n testPDF (FUNC2(gaussian_tail));\n testPDF (FUNC2(gaussian_tail1));\n testPDF (FUNC2(gaussian_tail2));\n testPDF (FUNC2(ugaussian_tail));\n \n testPDF (FUNC2(bivariate_gaussian1));\n testPDF (FUNC2(bivariate_gaussian2));\n testPDF (FUNC2(bivariate_gaussian3));\n testPDF (FUNC2(bivariate_gaussian4));\n\n testPDF (FUNC2(gumbel1));\n testPDF (FUNC2(gumbel2));\n testPDF (FUNC2(landau));\n testPDF (FUNC2(levy1));\n testPDF (FUNC2(levy2));\n testPDF (FUNC2(levy1a));\n testPDF (FUNC2(levy2a));\n testPDF (FUNC2(levy_skew1));\n testPDF (FUNC2(levy_skew2));\n testPDF (FUNC2(levy_skew1a));\n testPDF (FUNC2(levy_skew2a));\n testPDF (FUNC2(levy_skew1b));\n testPDF (FUNC2(levy_skew2b));\n testPDF (FUNC2(logistic));\n testPDF (FUNC2(lognormal));\n testPDF (FUNC2(pareto));\n testPDF (FUNC2(rayleigh));\n testPDF (FUNC2(rayleigh_tail));\n testPDF (FUNC2(tdist1));\n testPDF (FUNC2(tdist2));\n testPDF (FUNC2(laplace));\n testPDF (FUNC2(weibull));\n testPDF (FUNC2(weibull1));\n\n testPDF (FUNC2(dir2d));\n testPDF (FUNC2(dir2d_trig_method));\n testPDF (FUNC2(dir3dxy));\n testPDF (FUNC2(dir3dyz));\n testPDF (FUNC2(dir3dzx));\n\n testDiscretePDF (FUNC2(discrete1));\n testDiscretePDF (FUNC2(discrete2));\n testDiscretePDF (FUNC2(poisson));\n testDiscretePDF (FUNC2(poisson_large));\n testDiscretePDF (FUNC2(bernoulli));\n testDiscretePDF (FUNC2(binomial));\n testDiscretePDF (FUNC2(binomial_large));\n testDiscretePDF (FUNC2(geometric));\n testDiscretePDF (FUNC2(geometric1));\n testDiscretePDF (FUNC2(hypergeometric1));\n testDiscretePDF (FUNC2(hypergeometric2));\n testDiscretePDF (FUNC2(hypergeometric3));\n testDiscretePDF (FUNC2(hypergeometric4));\n testDiscretePDF (FUNC2(hypergeometric5));\n testDiscretePDF (FUNC2(hypergeometric6));\n testDiscretePDF (FUNC2(logarithmic));\n testDiscretePDF (FUNC2(negative_binomial));\n testDiscretePDF (FUNC2(pascal));\n\n exit (gsl_test_summary());\n}\n\nvoid\ntest_shuffle (void)\n{\n double count[10][10] ;\n int x[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9} ;\n int i, j, status = 0;\n\n for (i = 0; i < 10; i++)\n {\n for (j = 0; j < 10; j++)\n\t{\n\t count[i][j] = 0 ;\n\t}\n }\n\n for (i = 0 ; i < N; i++)\n {\n for (j = 0; j < 10; j++)\n\tx[j] = j ;\n\n gsl_ran_shuffle (r_global, x, 10, sizeof(int)) ;\n\n for (j = 0; j < 10; j++)\n\tcount[x[j]][j] ++ ;\n }\n\n for (i = 0; i < 10; i++)\n {\n for (j = 0; j < 10; j++)\n\t{\n\t double expected = N / 10.0 ;\n\t double d = fabs(count[i][j] - expected);\n\t double sigma = d / sqrt(expected) ;\n\t if (sigma > 5 && d > 1)\n\t {\n\t status = 1 ;\n\t gsl_test (status, \n\t\t\t\"gsl_ran_shuffle %d,%d (%g observed vs %g expected)\", \n\t\t\ti, j, count[i][j]/N, 0.1) ;\n\t }\n\t}\n }\n \n gsl_test (status, \"gsl_ran_shuffle on {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}\") ;\n\n}\n\nvoid\ntest_choose (void)\n{\n double count[10] ;\n int x[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9} ;\n int y[3] = {0, 1, 2} ;\n int i, j, status = 0;\n\n for (i = 0; i < 10; i++)\n {\n count[i] = 0 ;\n }\n\n for (i = 0 ; i < N; i++)\n {\n for (j = 0; j < 10; j++)\n\tx[j] = j ;\n\n gsl_ran_choose (r_global, y, 3, x, 10, sizeof(int)) ;\n\n for (j = 0; j < 3; j++)\n\tcount[y[j]]++ ;\n }\n\n for (i = 0; i < 10; i++)\n {\n double expected = 3.0 * N / 10.0 ;\n double d = fabs(count[i] - expected);\n double sigma = d / sqrt(expected) ;\n if (sigma > 5 && d > 1)\n\t{\n\t status = 1 ;\n\t gsl_test (status, \n\t\t \"gsl_ran_choose %d (%g observed vs %g expected)\", \n\t\t i, count[i]/N, 0.1) ;\n\t}\n }\n \n gsl_test (status, \"gsl_ran_choose (3) on {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}\") ;\n\n}\n\n\n\n\nvoid\ntestMoments (double (*f) (void), const char *name,\n\t double a, double b, double p)\n{\n int i;\n double count = 0, expected, sigma;\n int status;\n\n for (i = 0; i < N; i++)\n {\n double r = f ();\n if (r < b && r > a)\n\tcount++;\n }\n\n expected = p * N;\n sigma = fabs (count - expected) / sqrt (expected);\n\n status = (sigma > 3);\n\n gsl_test (status, \"%s [%g,%g] (%g observed vs %g expected)\",\n\t name, a, b, count / N, p);\n}\n\n#define BINS 100\n\nvoid\ntestPDF (double (*f) (void), double (*pdf)(double), const char *name)\n{\n double count[BINS], p[BINS];\n double a = -5.0, b = +5.0 ;\n double dx = (b - a) / BINS ;\n int i,j,status = 0, status_i =0 ;\n\n for (i = 0; i < BINS; i++)\n count[i] = 0 ;\n\n for (i = 0; i < N; i++)\n {\n double r = f ();\n if (r < b && r > a)\n\t{ \n\t j = (int)((r - a)/dx) ;\n\t count[j]++;\n\t}\n }\n \n for (i = 0; i < BINS; i++)\n {\n /* Compute an approximation to the integral of p(x) from x to\n x+dx using Simpson's rule */\n\n double x = a + i * dx ;\n#define STEPS 100\n double sum = 0 ;\n \n if (fabs(x) < 1e-10) /* hit the origin exactly */\n\tx = 0.0 ; \n \n for (j = 1; j < STEPS; j++)\n\tsum += pdf(x + j * dx / STEPS) ;\n\n p[i] = 0.5 * (pdf(x) + 2*sum + pdf(x + dx - 1e-7)) * dx / STEPS ;\n }\n\n for (i = 0; i < BINS; i++)\n {\n double x = a + i * dx ;\n double d = fabs(count[i] - N*p[i]) ;\n if (p[i] != 0)\n\t{\n\t double s = d / sqrt(N*p[i]) ;\n\t status_i = (s > 5) && (d > 1) ;\n\t}\n else\n\t{\n\t status_i = (count[i] != 0) ;\n\t}\n status |= status_i ;\n if (status_i) \n\tgsl_test (status_i, \"%s [%g,%g) (%g/%d=%g observed vs %g expected)\", \n\t\t name, x, x+dx, count[i],N,count[i]/N, p[i]) ;\n }\n\n if (status == 0)\n gsl_test (status, \"%s, sampling against pdf over range [%g,%g) \", \n\t name, a, b) ;\n}\n\nvoid\ntestDiscretePDF (double (*f) (void), double (*pdf)(unsigned int), const char *name)\n{\n double count[BINS], p[BINS];\n unsigned int i ;\n int status = 0, status_i =0 ;\n\n for (i = 0; i < BINS; i++)\n count[i] = 0 ;\n\n for (i = 0; i < N; i++)\n {\n int r = (int)(f ());\n if (r>= 0 && r < BINS)\n\tcount[r]++;\n }\n \n for (i = 0; i < BINS; i++)\n p[i] = pdf(i) ;\n\n for (i = 0; i < BINS; i++)\n {\n double d = fabs(count[i] - N*p[i]) ;\n if (p[i] != 0)\n\t{\n\t double s = d/sqrt(N*p[i]) ;\n\t status_i = (s > 5) && (d > 1);\n\t}\n else\n\t{\n\t status_i = (count[i] != 0) ;\n\t}\n status |= status_i ;\n if (status_i) \n\tgsl_test (status_i, \"%s i=%d (%g observed vs %g expected)\", \n\t\t name, i, count[i]/N, p[i]) ;\n }\n\n if (status == 0)\n gsl_test (status, \"%s, sampling against pdf over range [%d,%d) \", \n\t name, 0, BINS) ;\n}\n\n \n\ndouble\ntest_beta (void)\n{\n return gsl_ran_beta (r_global, 2.0, 3.0);\n}\n\ndouble\ntest_beta_pdf (double x)\n{\n return gsl_ran_beta_pdf (x, 2.0, 3.0);\n}\n\ndouble\ntest_bernoulli (void)\n{\n return gsl_ran_bernoulli (r_global, 0.3);\n}\n\ndouble\ntest_bernoulli_pdf (unsigned int n)\n{\n return gsl_ran_bernoulli_pdf (n, 0.3);\n}\n\n\ndouble\ntest_binomial (void)\n{\n return gsl_ran_binomial (r_global, 0.3, 5);\n}\n\ndouble\ntest_binomial_pdf (unsigned int n)\n{\n return gsl_ran_binomial_pdf (n, 0.3, 5);\n}\n\ndouble\ntest_binomial_large (void)\n{\n return gsl_ran_binomial (r_global, 0.3, 55);\n}\n\ndouble\ntest_binomial_large_pdf (unsigned int n)\n{\n return gsl_ran_binomial_pdf (n, 0.3, 55);\n}\n\ndouble\ntest_cauchy (void)\n{\n return gsl_ran_cauchy (r_global, 2.0);\n}\n\ndouble\ntest_cauchy_pdf (double x)\n{\n return gsl_ran_cauchy_pdf (x, 2.0);\n}\n\ndouble\ntest_chisq (void)\n{\n return gsl_ran_chisq (r_global, 13.0);\n}\n\ndouble\ntest_chisq_pdf (double x)\n{\n return gsl_ran_chisq_pdf (x, 13.0);\n}\n\ndouble\ntest_dir2d (void)\n{\n double x=0, y=0, theta;\n gsl_ran_dir_2d (r_global, &x, &y);\n theta = atan2(x,y);\n return theta;\n}\n\ndouble\ntest_dir2d_pdf (double x)\n{\n if (x > -M_PI && x <= M_PI)\n {\n return 1 / (2 * M_PI) ;\n }\n else\n {\n return 0 ;\n }\n}\n\ndouble\ntest_dir2d_trig_method (void)\n{\n double x=0, y=0, theta;\n gsl_ran_dir_2d_trig_method (r_global, &x, &y);\n theta = atan2(x,y);\n return theta;\n}\n\ndouble\ntest_dir2d_trig_method_pdf (double x)\n{\n if (x > -M_PI && x <= M_PI)\n {\n return 1 / (2 * M_PI) ;\n }\n else\n {\n return 0 ;\n }\n}\n\ndouble\ntest_dir3dxy (void)\n{\n double x=0, y=0, z=0, theta;\n gsl_ran_dir_3d (r_global, &x, &y, &z);\n theta = atan2(x,y);\n return theta;\n}\n\ndouble\ntest_dir3dxy_pdf (double x)\n{\n if (x > -M_PI && x <= M_PI)\n {\n return 1 / (2 * M_PI) ;\n }\n else\n {\n return 0 ;\n }\n}\n\ndouble\ntest_dir3dyz (void)\n{\n double x=0, y=0, z=0, theta;\n gsl_ran_dir_3d (r_global, &x, &y, &z);\n theta = atan2(y,z);\n return theta;\n}\n\ndouble\ntest_dir3dyz_pdf (double x)\n{\n if (x > -M_PI && x <= M_PI)\n {\n return 1 / (2 * M_PI) ;\n }\n else\n {\n return 0 ;\n }\n}\n\ndouble\ntest_dir3dzx (void)\n{\n double x=0, y=0, z=0, theta;\n gsl_ran_dir_3d (r_global, &x, &y, &z);\n theta = atan2(z,x);\n return theta;\n}\n\ndouble\ntest_dir3dzx_pdf (double x)\n{\n if (x > -M_PI && x <= M_PI)\n {\n return 1 / (2 * M_PI) ;\n }\n else\n {\n return 0 ;\n }\n}\n\nstatic gsl_ran_discrete_t *g1 = NULL;\nstatic gsl_ran_discrete_t *g2 = NULL;\n\ndouble\ntest_discrete1 (void)\n{\n static double P[3]={0.59, 0.4, 0.01};\n if (g1==NULL) {\n g1 = gsl_ran_discrete_preproc(3,P);\n }\n return gsl_ran_discrete(r_global,g1);\n}\ndouble test_discrete1_pdf (unsigned int n)\n{\n return gsl_ran_discrete_pdf((size_t)n,g1);\n}\n\ndouble\ntest_discrete2 (void)\n{\n static double P[10]={ 1, 9, 3, 4, 5, 8, 6, 7, 2, 0 };\n if (g2==NULL) {\n g2 = gsl_ran_discrete_preproc(10,P);\n }\n return gsl_ran_discrete(r_global,g2);\n}\ndouble test_discrete2_pdf (unsigned int n)\n{\n return gsl_ran_discrete_pdf((size_t)n,g2);\n}\n\n \ndouble\ntest_erlang (void)\n{\n return gsl_ran_erlang (r_global, 3.0, 4.0);\n}\n\ndouble\ntest_erlang_pdf (double x)\n{\n return gsl_ran_erlang_pdf (x, 3.0, 4.0);\n}\n\ndouble\ntest_exponential (void)\n{\n return gsl_ran_exponential (r_global, 2.0);\n}\n\ndouble\ntest_exponential_pdf (double x)\n{\n return gsl_ran_exponential_pdf (x, 2.0);\n}\n\ndouble\ntest_exppow0 (void)\n{\n return gsl_ran_exppow (r_global, 3.7, 0.3);\n}\n\ndouble\ntest_exppow0_pdf (double x)\n{\n return gsl_ran_exppow_pdf (x, 3.7, 0.3);\n}\n\ndouble\ntest_exppow1 (void)\n{\n return gsl_ran_exppow (r_global, 3.7, 1.0);\n}\n\ndouble\ntest_exppow1_pdf (double x)\n{\n return gsl_ran_exppow_pdf (x, 3.7, 1.0);\n}\n\ndouble\ntest_exppow1a (void)\n{\n return gsl_ran_exppow (r_global, 3.7, 1.9);\n}\n\ndouble\ntest_exppow1a_pdf (double x)\n{\n return gsl_ran_exppow_pdf (x, 3.7, 1.9);\n}\n\ndouble\ntest_exppow2 (void)\n{\n return gsl_ran_exppow (r_global, 3.7, 2.0);\n}\n\ndouble\ntest_exppow2_pdf (double x)\n{\n return gsl_ran_exppow_pdf (x, 3.7, 2.0);\n}\n\n\ndouble\ntest_exppow2a (void)\n{\n return gsl_ran_exppow (r_global, 3.7, 7.5);\n}\n\ndouble\ntest_exppow2a_pdf (double x)\n{\n return gsl_ran_exppow_pdf (x, 3.7, 7.5);\n}\n\ndouble\ntest_fdist (void)\n{\n return gsl_ran_fdist (r_global, 3.0, 4.0);\n}\n\ndouble\ntest_fdist_pdf (double x)\n{\n return gsl_ran_fdist_pdf (x, 3.0, 4.0);\n}\n\ndouble\ntest_flat (void)\n{\n return gsl_ran_flat (r_global, 3.0, 4.0);\n}\n\ndouble\ntest_flat_pdf (double x)\n{\n return gsl_ran_flat_pdf (x, 3.0, 4.0);\n}\n\ndouble\ntest_gamma (void)\n{\n return gsl_ran_gamma (r_global, 2.5, 2.17);\n}\n\ndouble\ntest_gamma_pdf (double x)\n{\n return gsl_ran_gamma_pdf (x, 2.5, 2.17);\n}\n\ndouble\ntest_gamma1 (void)\n{\n return gsl_ran_gamma (r_global, 1.0, 2.17);\n}\n\ndouble\ntest_gamma1_pdf (double x)\n{\n return gsl_ran_gamma_pdf (x, 1.0, 2.17);\n}\n\n\ndouble\ntest_gamma_int (void)\n{\n return gsl_ran_gamma (r_global, 10.0, 2.17);\n}\n\ndouble\ntest_gamma_int_pdf (double x)\n{\n return gsl_ran_gamma_pdf (x, 10.0, 2.17);\n}\n\n\ndouble\ntest_gamma_large (void)\n{\n return gsl_ran_gamma (r_global, 20.0, 2.17);\n}\n\ndouble\ntest_gamma_large_pdf (double x)\n{\n return gsl_ran_gamma_pdf (x, 20.0, 2.17);\n}\n\n\ndouble\ntest_gaussian (void)\n{\n return gsl_ran_gaussian (r_global, 3.0);\n}\n\ndouble\ntest_gaussian_pdf (double x)\n{\n return gsl_ran_gaussian_pdf (x, 3.0);\n}\n\ndouble\ntest_gaussian_ratio_method (void)\n{\n return gsl_ran_gaussian_ratio_method (r_global, 3.0);\n}\n\ndouble\ntest_gaussian_ratio_method_pdf (double x)\n{\n return gsl_ran_gaussian_pdf (x, 3.0);\n}\n\ndouble\ntest_gaussian_tail (void)\n{\n return gsl_ran_gaussian_tail (r_global, 1.7, 0.25);\n}\n\ndouble\ntest_gaussian_tail_pdf (double x)\n{\n return gsl_ran_gaussian_tail_pdf (x, 1.7, 0.25) ;\n}\n\ndouble\ntest_gaussian_tail1 (void)\n{\n return gsl_ran_gaussian_tail (r_global, -1.7, 5.0);\n}\n\ndouble\ntest_gaussian_tail1_pdf (double x)\n{\n return gsl_ran_gaussian_tail_pdf (x, -1.7, 5.0) ;\n}\n\ndouble\ntest_gaussian_tail2 (void)\n{\n return gsl_ran_gaussian_tail (r_global, 0.1, 2.0);\n}\n\ndouble\ntest_gaussian_tail2_pdf (double x)\n{\n return gsl_ran_gaussian_tail_pdf (x, 0.1, 2.0) ;\n}\n\n\ndouble\ntest_ugaussian (void)\n{\n return gsl_ran_ugaussian (r_global);\n}\n\ndouble\ntest_ugaussian_pdf (double x)\n{\n return gsl_ran_ugaussian_pdf (x);\n}\n\ndouble\ntest_ugaussian_ratio_method (void)\n{\n return gsl_ran_ugaussian_ratio_method (r_global);\n}\n\ndouble\ntest_ugaussian_ratio_method_pdf (double x)\n{\n return gsl_ran_ugaussian_pdf (x);\n}\n\ndouble\ntest_ugaussian_tail (void)\n{\n return gsl_ran_ugaussian_tail (r_global, 3.0);\n}\n\ndouble\ntest_ugaussian_tail_pdf (double x)\n{\n return gsl_ran_ugaussian_tail_pdf (x, 3.0) ;\n}\n\ndouble\ntest_bivariate_gaussian1 (void)\n{\n double x = 0, y = 0;\n gsl_ran_bivariate_gaussian (r_global, 3.0, 2.0, 0.3, &x, &y);\n return x ;\n}\n\ndouble\ntest_bivariate_gaussian1_pdf (double x)\n{\n return gsl_ran_gaussian_pdf (x, 3.0);\n}\n\ndouble\ntest_bivariate_gaussian2 (void)\n{\n double x = 0, y = 0;\n gsl_ran_bivariate_gaussian (r_global, 3.0, 2.0, 0.3, &x, &y);\n return y ;\n}\n\ndouble\ntest_bivariate_gaussian2_pdf (double y)\n{\n int i, n = 10 ;\n double sum = 0 ;\n double a = -10, b = 10, dx = (b - a)/n ;\n for (i = 0; i < n ; i++)\n {\n double x = a + i * dx ;\n sum += gsl_ran_bivariate_gaussian_pdf (x, y, 3.0, 2.0, 0.3) * dx ;\n }\n return sum ;\n}\n\n\ndouble\ntest_bivariate_gaussian3 (void)\n{\n double x = 0, y = 0;\n gsl_ran_bivariate_gaussian (r_global, 3.0, 2.0, 0.3, &x, &y);\n return x + y ;\n}\n\ndouble\ntest_bivariate_gaussian3_pdf (double x)\n{\n double sx = 3.0, sy = 2.0, r = 0.3;\n double su = (sx+r*sy) ;\n double sv = sy*sqrt(1-r*r) ;\n double sigma = sqrt(su*su + sv*sv) ;\n \n return gsl_ran_gaussian_pdf (x, sigma);\n}\n\ndouble\ntest_bivariate_gaussian4 (void)\n{\n double x = 0, y = 0;\n gsl_ran_bivariate_gaussian (r_global, 3.0, 2.0, -0.5, &x, &y);\n return x + y ;\n}\n\ndouble\ntest_bivariate_gaussian4_pdf (double x)\n{\n double sx = 3.0, sy = 2.0, r = -0.5;\n double su = (sx+r*sy) ;\n double sv = sy*sqrt(1-r*r) ;\n double sigma = sqrt(su*su + sv*sv) ;\n \n return gsl_ran_gaussian_pdf (x, sigma);\n}\n\n\ndouble\ntest_geometric (void)\n{\n return gsl_ran_geometric (r_global, 0.5);\n}\n\ndouble\ntest_geometric_pdf (unsigned int n)\n{\n return gsl_ran_geometric_pdf (n, 0.5);\n}\n\ndouble\ntest_geometric1 (void)\n{\n return gsl_ran_geometric (r_global, 1.0);\n}\n\ndouble\ntest_geometric1_pdf (unsigned int n)\n{\n return gsl_ran_geometric_pdf (n, 1.0);\n}\n\ndouble\ntest_hypergeometric1 (void)\n{\n return gsl_ran_hypergeometric (r_global, 5, 7, 4);\n}\n\ndouble\ntest_hypergeometric1_pdf (unsigned int n)\n{\n return gsl_ran_hypergeometric_pdf (n, 5, 7, 4);\n}\n\n\ndouble\ntest_hypergeometric2 (void)\n{\n return gsl_ran_hypergeometric (r_global, 5, 7, 11);\n}\n\ndouble\ntest_hypergeometric2_pdf (unsigned int n)\n{\n return gsl_ran_hypergeometric_pdf (n, 5, 7, 11);\n}\n\ndouble\ntest_hypergeometric3 (void)\n{\n return gsl_ran_hypergeometric (r_global, 5, 7, 1);\n}\n\ndouble\ntest_hypergeometric3_pdf (unsigned int n)\n{\n return gsl_ran_hypergeometric_pdf (n, 5, 7, 1);\n}\n\ndouble\ntest_hypergeometric4 (void)\n{\n return gsl_ran_hypergeometric (r_global, 5, 7, 20);\n}\n\ndouble\ntest_hypergeometric4_pdf (unsigned int n)\n{\n return gsl_ran_hypergeometric_pdf (n, 5, 7, 20);\n}\n\ndouble\ntest_hypergeometric5 (void)\n{\n return gsl_ran_hypergeometric (r_global, 2, 7, 5);\n}\n\ndouble\ntest_hypergeometric5_pdf (unsigned int n)\n{\n return gsl_ran_hypergeometric_pdf (n, 2, 7, 5);\n}\n\n\ndouble\ntest_hypergeometric6 (void)\n{\n return gsl_ran_hypergeometric (r_global, 2, 10, 3);\n}\n\ndouble\ntest_hypergeometric6_pdf (unsigned int n)\n{\n return gsl_ran_hypergeometric_pdf (n, 2, 10, 3);\n}\n\n\n\n\ndouble\ntest_gumbel1 (void)\n{\n return gsl_ran_gumbel1 (r_global, 3.12, 4.56);\n}\n\ndouble\ntest_gumbel1_pdf (double x)\n{\n return gsl_ran_gumbel1_pdf (x, 3.12, 4.56);\n}\n\ndouble\ntest_gumbel2 (void)\n{\n return gsl_ran_gumbel2 (r_global, 3.12, 4.56);\n}\n\ndouble\ntest_gumbel2_pdf (double x)\n{\n return gsl_ran_gumbel2_pdf (x, 3.12, 4.56);\n}\n\ndouble\ntest_landau (void)\n{\n return gsl_ran_landau (r_global);\n}\n\ndouble\ntest_landau_pdf (double x)\n{\n return gsl_ran_landau_pdf (x);\n}\n\ndouble\ntest_levy1 (void)\n{\n return gsl_ran_levy (r_global, 5.0, 1.0);\n}\n\ndouble\ntest_levy1_pdf (double x)\n{\n return gsl_ran_cauchy_pdf (x, 5.0);\n}\n\ndouble\ntest_levy2 (void)\n{\n return gsl_ran_levy (r_global, 5.0, 2.0);\n}\n\ndouble\ntest_levy2_pdf (double x)\n{\n return gsl_ran_gaussian_pdf (x, sqrt(2.0) * 5.0 );\n}\n\ndouble\ntest_levy1a (void)\n{\n return gsl_ran_levy (r_global, 5.0, 1.01);\n}\n\ndouble\ntest_levy1a_pdf (double x)\n{\n return gsl_ran_cauchy_pdf (x, 5.0);\n}\n\ndouble\ntest_levy2a (void)\n{\n return gsl_ran_levy (r_global, 5.0, 1.99);\n}\n\ndouble\ntest_levy2a_pdf (double x)\n{\n return gsl_ran_gaussian_pdf (x, sqrt(2.0) * 5.0 );\n}\n\n\ndouble\ntest_levy_skew1 (void)\n{\n return gsl_ran_levy_skew (r_global, 5.0, 1.0, 0.0);\n}\n\ndouble\ntest_levy_skew1_pdf (double x)\n{\n return gsl_ran_cauchy_pdf (x, 5.0);\n}\n\ndouble\ntest_levy_skew2 (void)\n{\n return gsl_ran_levy_skew (r_global, 5.0, 2.0, 0.0);\n}\n\ndouble\ntest_levy_skew2_pdf (double x)\n{\n return gsl_ran_gaussian_pdf (x, sqrt(2.0) * 5.0 );\n}\n\ndouble\ntest_levy_skew1a (void)\n{\n return gsl_ran_levy_skew (r_global, 5.0, 1.01, 0.0);\n}\n\ndouble\ntest_levy_skew1a_pdf (double x)\n{\n return gsl_ran_cauchy_pdf (x, 5.0);\n}\n\ndouble\ntest_levy_skew2a (void)\n{\n return gsl_ran_levy_skew (r_global, 5.0, 1.99, 0.0);\n}\n\ndouble\ntest_levy_skew2a_pdf (double x)\n{\n return gsl_ran_gaussian_pdf (x, sqrt(2.0) * 5.0 );\n}\n\ndouble\ntest_levy_skew1b (void)\n{\n return gsl_ran_levy_skew (r_global, 5.0, 1.01, 0.001);\n}\n\ndouble\ntest_levy_skew1b_pdf (double x)\n{\n return gsl_ran_cauchy_pdf (x, 5.0);\n}\n\ndouble\ntest_levy_skew2b (void)\n{\n return gsl_ran_levy_skew (r_global, 5.0, 1.99, 0.001);\n}\n\ndouble\ntest_levy_skew2b_pdf (double x)\n{\n return gsl_ran_gaussian_pdf (x, sqrt(2.0) * 5.0 );\n}\n\n\ndouble\ntest_logistic (void)\n{\n return gsl_ran_logistic (r_global, 3.1);\n}\n\ndouble\ntest_logistic_pdf (double x)\n{\n return gsl_ran_logistic_pdf (x, 3.1);\n}\n\ndouble\ntest_logarithmic (void)\n{\n return gsl_ran_logarithmic (r_global, 0.4);\n}\n\ndouble\ntest_logarithmic_pdf (unsigned int n)\n{\n return gsl_ran_logarithmic_pdf (n, 0.4);\n}\n\n\ndouble\ntest_lognormal (void)\n{\n return gsl_ran_lognormal (r_global, 2.7, 1.3);\n}\n\ndouble\ntest_lognormal_pdf (double x)\n{\n return gsl_ran_lognormal_pdf (x, 2.7, 1.3);\n}\n\ndouble\ntest_negative_binomial (void)\n{\n return gsl_ran_negative_binomial (r_global, 0.3, 20.0);\n}\n\ndouble\ntest_negative_binomial_pdf (unsigned int n)\n{\n return gsl_ran_negative_binomial_pdf (n, 0.3, 20.0);\n}\n\ndouble\ntest_pascal (void)\n{\n return gsl_ran_pascal (r_global, 0.8, 3);\n}\n\ndouble\ntest_pascal_pdf (unsigned int n)\n{\n return gsl_ran_pascal_pdf (n, 0.8, 3);\n}\n\n\ndouble\ntest_pareto (void)\n{\n return gsl_ran_pareto (r_global, 1.9, 2.75);\n}\n\ndouble\ntest_pareto_pdf (double x)\n{\n return gsl_ran_pareto_pdf (x, 1.9, 2.75);\n}\n\ndouble\ntest_rayleigh (void)\n{\n return gsl_ran_rayleigh (r_global, 1.9);\n}\n\ndouble\ntest_rayleigh_pdf (double x)\n{\n return gsl_ran_rayleigh_pdf (x, 1.9);\n}\n\ndouble\ntest_rayleigh_tail (void)\n{\n return gsl_ran_rayleigh_tail (r_global, 2.7, 1.9);\n}\n\ndouble\ntest_rayleigh_tail_pdf (double x)\n{\n return gsl_ran_rayleigh_tail_pdf (x, 2.7, 1.9);\n}\n\n\ndouble\ntest_poisson (void)\n{\n return gsl_ran_poisson (r_global, 5.0);\n}\n\ndouble\ntest_poisson_pdf (unsigned int n)\n{\n return gsl_ran_poisson_pdf (n, 5.0);\n}\n\ndouble\ntest_poisson_large (void)\n{\n return gsl_ran_poisson (r_global, 30.0);\n}\n\ndouble\ntest_poisson_large_pdf (unsigned int n)\n{\n return gsl_ran_poisson_pdf (n, 30.0);\n}\n\n\ndouble\ntest_tdist1 (void)\n{\n return gsl_ran_tdist (r_global, 1.75);\n}\n\ndouble\ntest_tdist1_pdf (double x)\n{\n return gsl_ran_tdist_pdf (x, 1.75);\n}\n\ndouble\ntest_tdist2 (void)\n{\n return gsl_ran_tdist (r_global, 12.75);\n}\n\ndouble\ntest_tdist2_pdf (double x)\n{\n return gsl_ran_tdist_pdf (x, 12.75);\n}\n\n\ndouble\ntest_laplace (void)\n{\n return gsl_ran_laplace (r_global, 2.75);\n}\n\ndouble\ntest_laplace_pdf (double x)\n{\n return gsl_ran_laplace_pdf (x, 2.75);\n}\n\ndouble\ntest_weibull (void)\n{\n return gsl_ran_weibull (r_global, 3.14, 2.75);\n}\n\ndouble\ntest_weibull_pdf (double x)\n{\n return gsl_ran_weibull_pdf (x, 3.14, 2.75);\n}\n\n\ndouble\ntest_weibull1 (void)\n{\n return gsl_ran_weibull (r_global, 2.97, 1.0);\n}\n\ndouble\ntest_weibull1_pdf (double x)\n{\n return gsl_ran_weibull_pdf (x, 2.97, 1.0);\n}\n", "meta": {"hexsha": "8c2cfb066077c1c76d3ad1f6e95722cd24ed2547", "size": 28635, "ext": "c", "lang": "C", "max_stars_repo_path": "code/em/treba/gsl-1.0/randist/test.c", "max_stars_repo_name": "ICML14MoMCompare/spectral-learn", "max_stars_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-12-18T18:09:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-10T11:31:28.000Z", "max_issues_repo_path": "code/em/treba/gsl-1.0/randist/test.c", "max_issues_repo_name": "ICML14MoMCompare/spectral-learn", "max_issues_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "code/em/treba/gsl-1.0/randist/test.c", "max_forks_repo_name": "ICML14MoMCompare/spectral-learn", "max_forks_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2015-10-02T01:32:59.000Z", "max_forks_repo_forks_event_max_datetime": "2015-10-02T01:32:59.000Z", "avg_line_length": 18.8760711931, "max_line_length": 83, "alphanum_fraction": 0.6768290554, "num_tokens": 10245, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7690802476562641, "lm_q2_score": 0.7122321903471563, "lm_q1q2_score": 0.5477637093409544}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n\n#include \"cosmocalc.h\"\n#include \"haloprofs.h\"\n#include \"weaklens.h\"\n\ndouble eps_fun(double x, void *p)\n{\n double *v = (double*)p;\n return NFWprof_menc(x,v[0],v[1],v[2]) - v[3];\n}\n\ndouble solve_scale_nfw(gsl_root_fsolver *s, gsl_function F, double *p)\n{\n int status;\n int iter,max_iter = 100;\n double x_lo = 0.0,x_hi = 5.0;\n double r;\n \n iter = 0;\n gsl_root_fsolver_set(s,&F,x_lo,x_hi);\n do\n {\n iter++;\n status = gsl_root_fsolver_iterate(s);\n r = gsl_root_fsolver_root(s);\n x_lo = gsl_root_fsolver_x_lower(s);\n x_hi = gsl_root_fsolver_x_upper(s);\n status = gsl_root_test_interval(x_lo, x_hi,0,0.001);\n }\n while (status == GSL_CONTINUE && iter < max_iter);\n \n return r;\n}\n\nint main(int argc, char **argv)\n{\n //init\n cosmoData.cosmoNum = 1;\n cosmoData.OmegaM = 0.27;\n cosmoData.OmegaL = 0.73;\n cosmoData.OmegaB = 0.045;\n cosmoData.OmegaNu = 0.0;\n cosmoData.OmegaK = 0.0;\n cosmoData.h = 0.7;\n cosmoData.w0 = -1.0;\n cosmoData.wa = 0.0;\n cosmoData.SpectralIndex = 0.96;\n cosmoData.Sigma8 = 0.8;\n cosmoData.useSmoothTransFunc = 0;\n \n //prints mass function in bins to stdout\n double a = atof(argv[1]);\n double mp = atof(argv[2]);\n double np;\n double mmin = 1e1;\n double mmax = 1e18;\n long Nm = 2000;\n double m,dlnm = log(mmax/mmin)/Nm;\n long i;\n double rvir,rs,c;\n \n cosmoData.delta = 200.0*RHO_CRIT*hubble_noscale(a)*hubble_noscale(a)/(cosmoData.OmegaM*RHO_CRIT/a/a/a);\n //fprintf(stderr,\"delta = %f\\n\",cosmoData.delta);\n \n gsl_root_fsolver *s;\n gsl_function F;\n double p[4],r1,rN,rN2;\n \n F.function = &eps_fun;\n F.params = p;\n s = gsl_root_fsolver_alloc(gsl_root_fsolver_brent);\n \n fprintf(stdout,\"# m rs rvir r1 rN rN2\\n\");\n for(i=0;i= 1.0)\n\t{\n\t p[0] = m;\n\t p[1] = rvir;\n\t p[2] = c;\n\t p[3] = mp;\n\t r1 = solve_scale_nfw(s,F,p);\n\t}\n else\n\tr1 = -1.0;\n \n if(np > 100)\n\t{\n\t p[0] = m;\n\t p[1] = rvir;\n\t p[2] = c;\n\t p[3] = mp*100.0;\n\t rN = solve_scale_nfw(s,F,p);\n\t}\n else\n\trN = -1.0;\n \n if(np > 10)\n\t{\n\t p[0] = m;\n\t p[1] = rvir;\n\t p[2] = c;\n\t p[3] = mp*10.0;\n\t rN2 = solve_scale_nfw(s,F,p);\n\t}\n else\n\trN2 = -1.0;\n \n fprintf(stdout,\"%e %e %e %e %e %e\\n\",m,rs,rvir,r1,rN,rN2);\n }\n \n gsl_root_fsolver_free(s);\n \n return 0;\n}\n\n", "meta": {"hexsha": "b01fd12dd91b5b3db04107806c28f3c659a76d86", "size": 2778, "ext": "c", "lang": "C", "max_stars_repo_path": "example/main.c", "max_stars_repo_name": "beckermr/cosmocalc", "max_stars_repo_head_hexsha": "aa7d7cb58f05a36d446e02b45a9117d93eb16556", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "example/main.c", "max_issues_repo_name": "beckermr/cosmocalc", "max_issues_repo_head_hexsha": "aa7d7cb58f05a36d446e02b45a9117d93eb16556", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2016-04-05T19:10:45.000Z", "max_issues_repo_issues_event_max_datetime": "2016-04-05T19:36:21.000Z", "max_forks_repo_path": "example/main.c", "max_forks_repo_name": "beckermr/cosmocalc", "max_forks_repo_head_hexsha": "aa7d7cb58f05a36d446e02b45a9117d93eb16556", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2017-07-14T12:17:31.000Z", "max_forks_repo_forks_event_max_datetime": "2017-08-11T17:31:51.000Z", "avg_line_length": 20.1304347826, "max_line_length": 105, "alphanum_fraction": 0.5860331174, "num_tokens": 1079, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9124361676202372, "lm_q2_score": 0.600188359260205, "lm_q1q2_score": 0.5476335663736595}} {"text": "// 2019-05-16 by Liya Ding\n\n#include \n#include \n#include \n#include \n#include \n#include \n//#include \"convolver.h\"\n\nstatic double approxZero(double n);\nstatic double opposite(double theta);\nstatic int getTemplateN(int M);\ndouble* getWeights(int M, double sigma); \nvoid computeBaseTemplates(double* input, int nx, int ny, int M, int borderCondition, double sigma, double** templates); \ndouble pointRespM1(int i, double angle, double* alpha, double** templates);\ndouble pointRespM2(int i, double angle, double* alpha, double** templates);\ndouble pointRespM3(int i, double angle, double* alpha, double** templates); \ndouble pointRespM4(int i, double angle, double* alpha, double** templates); \ndouble pointRespM5(int i, double angle, double* alpha, double** templates); \n\nint getRealRoots(double* z, int nz, double* roots); \nvoid filterM1(double** templates, int nx, int ny, double* alpha, double* response, double* orientation); \nvoid filterM2(double** templates, int nx, int ny, double* alpha, double* response, double* orientation); \nvoid filterM3(double** templates, int nx, int ny, double* alpha, double* response, double* orientation); \nvoid filterM4(double** templates, int nx, int ny, double* alpha, double* response, double* orientation); \nvoid filterM5(double** templates, int nx, int ny, double* alpha, double* response, double* orientation); \nint mirror(int x, int nx);\ndouble interp(double* image, int nx, int ny, double x, double y);\nvoid computeNMS(double* response, double* orientation, double* nms, int nx, int ny); \nvoid steerablefilter2Dcore(double * input, long* in_sz, int M, double sigma,double* &response, double* &orientation, double* &nms);", "meta": {"hexsha": "0b36b33f7f3418c411dca805d1cd9a8572a119d3", "size": 1723, "ext": "h", "lang": "C", "max_stars_repo_path": "hackathon/liyad/steerablefilter2D/steerableDetector.h", "max_stars_repo_name": "zzhmark/vaa3d_tools", "max_stars_repo_head_hexsha": "3ca418add85a59ac7e805d55a600b78330d7e53d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-12-27T19:14:03.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-27T19:14:03.000Z", "max_issues_repo_path": "hackathon/liyad/steerablefilter2D/steerableDetector.h", "max_issues_repo_name": "zzhmark/vaa3d_tools", "max_issues_repo_head_hexsha": "3ca418add85a59ac7e805d55a600b78330d7e53d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "hackathon/liyad/steerablefilter2D/steerableDetector.h", "max_forks_repo_name": "zzhmark/vaa3d_tools", "max_forks_repo_head_hexsha": "3ca418add85a59ac7e805d55a600b78330d7e53d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 55.5806451613, "max_line_length": 131, "alphanum_fraction": 0.7457922229, "num_tokens": 449, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.84997116805678, "lm_q2_score": 0.6442251064863697, "lm_q1q2_score": 0.5475727662517231}} {"text": "#include \r\n#include \r\n#include \r\n#include \r\n\r\n#include \"dgp.h\"\r\n#include \"vec.h\"\r\n#include \"fobj_sph.h\"\r\n\r\ntypedef struct\r\n{\r\n double tau;\r\n double lambda;\r\n double rho;\r\n dgp_t *G;\r\n} gsl_params_t;\r\n\r\nvoid gsl_fdf(const gsl_vector *x, void *params, double *f, gsl_vector *g)\r\n{\r\n gsl_params_t *p = (gsl_params_t *)params;\r\n *f = fobj_sph(p->lambda, p->tau, *(p->G), x->data, g->data);\r\n}\r\n\r\nvoid gsl_df(const gsl_vector *x, void *params, gsl_vector *g)\r\n{\r\n gsl_params_t *p = (gsl_params_t *)params;\r\n fobj_sph(p->lambda, p->tau, *(p->G), x->data, g->data);\r\n}\r\n\r\ndouble gsl_f(const gsl_vector *x, void *params)\r\n{\r\n gsl_params_t *p = (gsl_params_t *)params;\r\n return fobj_sph(p->lambda, p->tau, *(p->G), x->data, NULL);\r\n}\r\n\r\ndouble init_tau(dgp_t &G)\r\n{\r\n std::vector tau_all(G.m_nedges);\r\n\r\n for (int i = 0; i < G.m_nedges; i++)\r\n {\r\n tau_all[i] = (G.m_l[i] + G.m_u[i]) / 2.0;\r\n }\r\n\r\n std::sort(tau_all.begin(), tau_all.end());\r\n \r\n return tau_all[(int)(0.75 * G.m_nedges)];;\r\n}\r\n\r\ndouble gsl_vector_norm(gsl_vector *v)\r\n{\r\n double v_nrm = 0.0;\r\n for (size_t i = 0; i < v->size; i++)\r\n {\r\n v_nrm += v->data[i] * v->data[i];\r\n }\r\n return sqrt(v_nrm);\r\n}\r\n\r\nvoid init_sol(dgp_t &G, double *x)\r\n{\r\n double dij, lij, uij, *xi, *xj;\r\n double y[3], y_nrm;\r\n int *neighs, nneighs, j;\r\n std::vector s(G.m_nnodes);\r\n std::vector b(G.m_nnodes, false);\r\n\r\n // s = [0, 1, 2, ..., nnodes-1]\r\n for (int k = 0; k < G.m_nnodes; k++)\r\n {\r\n s[k] = k;\r\n } \r\n std::random_shuffle(s.begin(), s.end());\r\n\r\n // x = zeros(3 * nnodes)\r\n for (int k = 0; k < (3 * G.m_nnodes); ++k)\r\n {\r\n x[k] = 0.0;\r\n }\r\n\r\n std::default_random_engine rndEngine;\r\n std::normal_distribution gaussian(0.0, 1.0);\r\n\r\n for (int k = 0; k < G.m_nnodes; k++)\r\n {\r\n int i = s[k];\r\n xi = &(x[3 * i]);\r\n G.neighs(i, nneighs, &neighs);\r\n for (int jj = 0; jj < nneighs; jj++)\r\n {\r\n j = neighs[jj];\r\n if (b[j])\r\n {\r\n continue;\r\n }\r\n G.vals(i, j, NULL, &lij, &uij);\r\n dij = (lij + uij) / 2.0;\r\n xj = &(x[3 * j]);\r\n // y is randomly distributed inside the sphere((0,0,0),1)\r\n vec_set(y, gaussian(rndEngine), gaussian(rndEngine), gaussian(rndEngine));\r\n y_nrm = vec_norm(y);\r\n // xj = dij * (y / y_nrm) + xi (randomly distributed over sphere(xi, dij))\r\n vec_axpby(dij / y_nrm, y, 1.0, xi, xj);\r\n }\r\n }\r\n}\r\n\r\nvoid sph_print_iter(int i, gsl_params_t &p, double f, double fs, gsl_vector *g, int k)\r\n{\r\n if ((i % 10) == 0)\r\n {\r\n printf(\" iter | tau | f | fs | nrm(g) | #f_calls \\n\");\r\n }\r\n printf(\"%5d | %3.2e | %3.2e | %3.2e | %3.2e | %5d\\n\", i, p.tau, f, fs, gsl_vector_norm(g), k);\r\n}\r\n\r\nbool sph(dgp_t &G, double ftol, double &f, double *x, bool verbose)\r\n{\r\n gsl_params_t gsl_params;\r\n gsl_params.lambda = 0.5;\r\n gsl_params.rho = 0.99;\r\n gsl_params.tau = init_tau(G);\r\n gsl_params.G = &G;\r\n\r\n gsl_vector *y = gsl_vector_alloc(3 * G.m_nnodes);\r\n gsl_vector *g = gsl_vector_alloc(3 * G.m_nnodes);\r\n\r\n init_sol(G, y->data);\r\n\r\n const gsl_multimin_fdfminimizer_type *fdfmin_method = gsl_multimin_fdfminimizer_vector_bfgs2;\r\n gsl_multimin_fdfminimizer *fdfmin;\r\n\r\n gsl_multimin_function_fdf gsl_fobj;\r\n gsl_fobj.n = 3 * G.m_nnodes;\r\n gsl_fobj.f = gsl_f;\r\n gsl_fobj.df = gsl_df;\r\n gsl_fobj.fdf = gsl_fdf;\r\n gsl_fobj.params = (void *)(&gsl_params);\r\n\r\n double fs;\r\n bool solved = false;\r\n int maxit = 1000, k = 0, status;\r\n for (int i = 0; i < maxit; i++)\r\n {\r\n fs = fobj_sph(gsl_params.lambda, gsl_params.tau, G, y->data, g->data);\r\n f = fobj_sph(gsl_params.lambda, 1E-16, G, y->data, NULL);\r\n\r\n if (verbose)\r\n {\r\n sph_print_iter(i, gsl_params, f, fs, g, k);\r\n }\r\n\r\n if (f < ftol)\r\n {\r\n solved = true;\r\n break;\r\n }\r\n \r\n gsl_params.tau *= gsl_params.rho;\r\n fdfmin = gsl_multimin_fdfminimizer_alloc(fdfmin_method, 3 * G.m_nnodes);\r\n gsl_multimin_fdfminimizer_set(fdfmin, &gsl_fobj, y, 0.01, 1E-3);\r\n\r\n // call local optimization\r\n for (k = 0, status = GSL_CONTINUE; k < 1000 && status == GSL_CONTINUE; k++)\r\n {\r\n status = gsl_multimin_fdfminimizer_iterate(fdfmin);\r\n if (status)\r\n {\r\n break;\r\n }\r\n status = gsl_multimin_test_gradient(fdfmin->gradient, 1E-8);\r\n }\r\n\r\n // copy from fdfmin to y\r\n for (int j = 0; j < 3 * G.m_nnodes; j++)\r\n {\r\n y->data[j] = fdfmin->x->data[j];\r\n }\r\n\r\n gsl_multimin_fdfminimizer_free(fdfmin);\r\n }\r\n\r\n // copy solution from y to x\r\n for (int i = 0; i < 3 * G.m_nnodes; i++)\r\n {\r\n x[i] = y->data[i];\r\n }\r\n\r\n gsl_vector_free(y);\r\n\r\n return solved;\r\n}\r\n", "meta": {"hexsha": "eebf1857c4fef701c9388cd39ec987f2bcb00c37", "size": 4913, "ext": "h", "lang": "C", "max_stars_repo_path": "sph.h", "max_stars_repo_name": "michaelsouza/sph", "max_stars_repo_head_hexsha": "f0b285ee936f27fe6d2dada457aec95618e7dbc7", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "sph.h", "max_issues_repo_name": "michaelsouza/sph", "max_issues_repo_head_hexsha": "f0b285ee936f27fe6d2dada457aec95618e7dbc7", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "sph.h", "max_forks_repo_name": "michaelsouza/sph", "max_forks_repo_head_hexsha": "f0b285ee936f27fe6d2dada457aec95618e7dbc7", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 25.4559585492, "max_line_length": 98, "alphanum_fraction": 0.5383675962, "num_tokens": 1647, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7905302989295535, "lm_q2_score": 0.6926419958239132, "lm_q1q2_score": 0.5475544840098406}} {"text": "/* fft/gsl_fft_complex_float.h\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n#ifndef __GSL_FFT_COMPLEX_FLOAT_H__\n#define __GSL_FFT_COMPLEX_FLOAT_H__\n\n#include \n\n#include \n#include \n#include \n\n#undef __BEGIN_DECLS\n#undef __END_DECLS\n#ifdef __cplusplus\n# define __BEGIN_DECLS extern \"C\" {\n# define __END_DECLS }\n#else\n# define __BEGIN_DECLS /* empty */\n# define __END_DECLS /* empty */\n#endif\n\n__BEGIN_DECLS\n\n/* Power of 2 routines */\n\n\nint gsl_fft_complex_float_radix2_forward (gsl_complex_packed_array_float data,\n const size_t stride,\n const size_t n);\n\nint gsl_fft_complex_float_radix2_backward (gsl_complex_packed_array_float data,\n const size_t stride,\n const size_t n);\n\nint gsl_fft_complex_float_radix2_inverse (gsl_complex_packed_array_float data,\n const size_t stride,\n const size_t n);\n\nint gsl_fft_complex_float_radix2_transform (gsl_complex_packed_array_float data,\n const size_t stride,\n const size_t n,\n const gsl_fft_direction sign);\n\nint gsl_fft_complex_float_radix2_dif_forward (gsl_complex_packed_array_float data,\n const size_t stride,\n const size_t n);\n\nint gsl_fft_complex_float_radix2_dif_backward (gsl_complex_packed_array_float data,\n const size_t stride,\n const size_t n);\n\nint gsl_fft_complex_float_radix2_dif_inverse (gsl_complex_packed_array_float data,\n const size_t stride,\n const size_t n);\n\nint gsl_fft_complex_float_radix2_dif_transform (gsl_complex_packed_array_float data,\n const size_t stride,\n const size_t n,\n const gsl_fft_direction sign);\n\n/* Mixed Radix general-N routines */\n\ntypedef struct\n {\n size_t n;\n size_t nf;\n size_t factor[64];\n gsl_complex_float *twiddle[64];\n gsl_complex_float *trig;\n }\ngsl_fft_complex_wavetable_float;\n\ntypedef struct\n{\n size_t n;\n float *scratch;\n}\ngsl_fft_complex_workspace_float;\n\n\ngsl_fft_complex_wavetable_float *gsl_fft_complex_wavetable_float_alloc (size_t n);\n\nvoid gsl_fft_complex_wavetable_float_free (gsl_fft_complex_wavetable_float * wavetable);\n\ngsl_fft_complex_workspace_float *gsl_fft_complex_workspace_float_alloc (size_t n);\n\nvoid gsl_fft_complex_workspace_float_free (gsl_fft_complex_workspace_float * workspace);\n\n\nint gsl_fft_complex_float_memcpy (gsl_fft_complex_wavetable_float * dest,\n gsl_fft_complex_wavetable_float * src);\n\n\nint gsl_fft_complex_float_forward (gsl_complex_packed_array_float data,\n const size_t stride,\n const size_t n,\n const gsl_fft_complex_wavetable_float * wavetable,\n gsl_fft_complex_workspace_float * work);\n\nint gsl_fft_complex_float_backward (gsl_complex_packed_array_float data,\n const size_t stride,\n const size_t n,\n const gsl_fft_complex_wavetable_float * wavetable,\n gsl_fft_complex_workspace_float * work);\n\nint gsl_fft_complex_float_inverse (gsl_complex_packed_array_float data,\n const size_t stride,\n const size_t n,\n const gsl_fft_complex_wavetable_float * wavetable,\n gsl_fft_complex_workspace_float * work);\n\nint gsl_fft_complex_float_transform (gsl_complex_packed_array_float data,\n const size_t stride, const size_t n,\n const gsl_fft_complex_wavetable_float * wavetable,\n gsl_fft_complex_workspace_float * work,\n const gsl_fft_direction sign);\n\n__END_DECLS\n\n#endif /* __GSL_FFT_COMPLEX_FLOAT_H__ */\n\n\n", "meta": {"hexsha": "d3ff395f976eb924d1363748f0de1d7180191bf3", "size": 5349, "ext": "h", "lang": "C", "max_stars_repo_path": "315/gsltest/gsl/include/gsl/gsl_fft_complex_float.h", "max_stars_repo_name": "shi-bash-cmd/qtTest", "max_stars_repo_head_hexsha": "3eb0cf4b8fcfa2c36e133e4df2b2a3e6d2d3e589", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 77.0, "max_stars_repo_stars_event_min_datetime": "2015-01-18T00:45:00.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-24T22:20:56.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/gsl/gsl_fft_complex_float.h", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 11.0, "max_issues_repo_issues_event_min_datetime": "2020-05-29T16:26:06.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-07T08:59:52.000Z", "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/gsl/gsl_fft_complex_float.h", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 30.0, "max_forks_repo_forks_event_min_datetime": "2015-02-01T15:12:21.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-30T23:53:15.000Z", "avg_line_length": 38.2071428571, "max_line_length": 88, "alphanum_fraction": 0.5999252197, "num_tokens": 1010, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8740772220439509, "lm_q2_score": 0.6261241772283034, "lm_q1q2_score": 0.5472808814862697}} {"text": "//This file contains mostly untested code for computing splined\n//periodic flux tube configurations\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"intT.h\" \n\n//extern \"C\"\n//__device__ __host__ float interp(float rho2, float *rho2sp, float4 *coefs);\n\n\nint func (double t, const double y[], double f[],\n void *params)\n{\n double *p = (double *)params;\n double lambda2 = p[0];\n double a = p[1];\n f[0] = 2.0/lambda2*t*exp(-pow(sin(pi*t/a),2)/lambda2);\n return GSL_SUCCESS;\n}\n\nint jac(double t, const double y[], double *dfdy, double dfdt[], void *params)\n{\n double *p = (double *)params;\n double lambda2 = p[0];\n double a = p[1];\n \n gsl_matrix_view dfdy_mat \n = gsl_matrix_view_array(dfdy, 1, 1);\n gsl_matrix * m = &dfdy_mat.matrix;\n\n double der=0.0;\n\n gsl_matrix_set (m, 0, 0, der);\n dfdt[0] = 2.0/lambda2*exp(-pow(sin(pi*t/a),2)/lambda2)*(1.0-\n\t2.0*pi/(a*lambda2)*t*sin(pi*t/a)*cos(pi/a*t));\n return GSL_SUCCESS;\n}\n\nfloat4* flspline(double *fli, float *rho2, int N)\n//Computes the cubic spline coefficients for f_lambda(rho^2)\n//uses Burden and Faires algorithm 3.5 (Clamped Cubic Spline)\n//Step numbers refer to this textbook\n{\n int i;\n double* h;\n double* l;\n double* mu;\n double* z;\n double* alpha;\n float4* flscoefs;\n h=(double *)malloc(N*sizeof(*h));\n l=(double *)malloc(N*sizeof(*l));\n mu=(double *)malloc(N*sizeof(*mu));\n z=(double *)malloc(N*sizeof(*z));\n alpha = (double *)malloc(N*sizeof(*alpha));\n flscoefs=(float4 *)malloc(N*sizeof(*flscoefs));\n\n \n//Step 1\n for(i=0;i-1;i--)\n {\n\tflscoefs[i].z = z[i]-mu[i]*flscoefs[i+1].z;\n\tflscoefs[i].y = (fli[i+1]-fli[i])/h[i] - h[i]*(flscoefs[i+1].z+2.0*flscoefs[i].z)/3.0;\n\tflscoefs[i].w = (flscoefs[i+1].z-flscoefs[i].z)/(3.0*h[i]);\n }\n//Free allocated memory\n free(h);free(l);free(mu);free(z);free(alpha);\n//Step 8\n return flscoefs;\n\n \n\n}\n\nfloat4* getspline(float* rho2, double lambda2, double a, int Npoints)\n{\n\n double params[2];\n const gsl_odeiv2_step_type * T = gsl_odeiv2_step_rk8pd;\n float4 *coefs;\n\n gsl_odeiv2_step * s = gsl_odeiv2_step_alloc (T, 1);\n gsl_odeiv2_control * c = gsl_odeiv2_control_y_new (1e-9,1e-7);\n gsl_odeiv2_evolve * e = gsl_odeiv2_evolve_alloc (1);\n\n params[0] = lambda2;\n params[1] = a;\n\n\n gsl_odeiv2_system sys = {func, jac, 1, params};\n\n double rho = 0.0;\n double rhof = 20.0;\n double h = rhof/((double)Npoints);\n double y[1] = { 0.00 };\n double *flambda;\n int i=0;\n\n\n flambda=(double *)malloc(Npoints*sizeof(*flambda));\n while (irho2sp[0])\n// if(0)\n {\n \twhile(upperi-loweri > 1)\n\t{\n\t\tif(rho2 >= rho2sp[(upperi+loweri)/2]) loweri=(upperi+loweri)/2;\n\t\telse upperi=(upperi+loweri)/2;\n \t}\n \t//interpolate using the jth interval\n \tj=loweri;\n\trho2diff=rho2-rho2sp[j];\n\t//rho2diff=0.0;\n \tflambda= coefs[j].x+rho2diff*(coefs[j].y+rho2diff*(coefs[j].z+rho2diff*coefs[j].w));\n }\n else\n {\n\tj=0;\n\trho2diff=0.0f;\n\tflambda=0.0f;\n }\n \n //*flambda= coefs[j].x+rho2diff*(coefs[j].y+rho2diff*(coefs[j].z+rho2diff*coefs[j].w));\n //*fprime = coefs[j].y+rho2diff*(2.0f*coefs[j].z + rho2diff*(3.0f*coefs[j].w));\n //*flambda=1.0f-exp(-1.0f*rho2);\n //*fprime=1.0f*exp(-1.0f*rho2);\n return flambda;\n}\n\n\ndouble testspline(float rho2, double lambda2, double a, int Npoints, float *rho2sp, float4 *flcoefs)\n{\n printf(\"testspline: rho2=%f\\n\",(double)rho2);\n double flodeiv, flspline;\n double params[2];\n const gsl_odeiv2_step_type * T = gsl_odeiv2_step_rk8pd;\n float4 *coefs;\n\n gsl_odeiv2_step * s = gsl_odeiv2_step_alloc (T, 1);\n gsl_odeiv2_control * c = gsl_odeiv2_control_y_new (1e-9,1e-7);\n gsl_odeiv2_evolve * e = gsl_odeiv2_evolve_alloc (1);\n\n params[0] = lambda2;\n params[1] = a;\n\n\n gsl_odeiv2_system sys = {func, jac, 1, params};\n\n double rho = 0.0;\n double rhof = sqrt(rho2);\n double h = rhof/((double)Npoints);\n double y[1] = { 0.00 };\n double *flambda;\n int i=0;\n flambda=(double *)malloc(Npoints*sizeof(*flambda));\n\n while(rho\n#include \n\n#undef __BEGIN_DECLS\n#undef __END_DECLS\n#ifdef __cplusplus\n# define __BEGIN_DECLS extern \"C\" {\n# define __END_DECLS }\n#else\n# define __BEGIN_DECLS /* empty */\n# define __END_DECLS /* empty */\n#endif\n\n__BEGIN_DECLS\n\n\n/* Sin(x) with GSL semantics. This is actually important\n * because we want to control the error estimate, and trying\n * to guess the error for the standard library implementation\n * every time it is used would be a little goofy.\n */\nGSL_EXPORT int gsl_sf_sin_e(double x, gsl_sf_result * result);\nGSL_EXPORT double gsl_sf_sin(const double x);\n\n\n/* Cos(x) with GSL semantics.\n */\nGSL_EXPORT int gsl_sf_cos_e(double x, gsl_sf_result * result);\nGSL_EXPORT double gsl_sf_cos(const double x);\n\n\n/* Hypot(x,y) with GSL semantics.\n */\nGSL_EXPORT int gsl_sf_hypot_e(const double x, const double y, gsl_sf_result * result);\nGSL_EXPORT double gsl_sf_hypot(const double x, const double y);\n\n\n/* Sin(z) for complex z\n *\n * exceptions: GSL_EOVRFLW\n */\nGSL_EXPORT int gsl_sf_complex_sin_e(const double zr, const double zi, gsl_sf_result * szr, gsl_sf_result * szi);\n\n\n/* Cos(z) for complex z\n *\n * exceptions: GSL_EOVRFLW\n */\nGSL_EXPORT int gsl_sf_complex_cos_e(const double zr, const double zi, gsl_sf_result * czr, gsl_sf_result * czi);\n\n\n/* Log(Sin(z)) for complex z\n *\n * exceptions: GSL_EDOM, GSL_ELOSS\n */\nGSL_EXPORT int gsl_sf_complex_logsin_e(const double zr, const double zi, gsl_sf_result * lszr, gsl_sf_result * lszi);\n\n\n/* Sinc(x) = sin(pi x) / (pi x)\n *\n * exceptions: none\n */\nGSL_EXPORT int gsl_sf_sinc_e(double x, gsl_sf_result * result);\nGSL_EXPORT double gsl_sf_sinc(const double x);\n\n\n/* Log(Sinh(x)), x > 0\n *\n * exceptions: GSL_EDOM\n */\nGSL_EXPORT int gsl_sf_lnsinh_e(const double x, gsl_sf_result * result);\nGSL_EXPORT double gsl_sf_lnsinh(const double x);\n\n\n/* Log(Cosh(x))\n *\n * exceptions: none\n */\nGSL_EXPORT int gsl_sf_lncosh_e(const double x, gsl_sf_result * result);\nGSL_EXPORT double gsl_sf_lncosh(const double x);\n\n\n/* Convert polar to rectlinear coordinates.\n *\n * exceptions: GSL_ELOSS\n */\nGSL_EXPORT int gsl_sf_polar_to_rect(const double r, const double theta, gsl_sf_result * x, gsl_sf_result * y);\n\n/* Convert rectilinear to polar coordinates.\n * return argument in range [-pi, pi]\n *\n * exceptions: GSL_EDOM\n */\nGSL_EXPORT int gsl_sf_rect_to_polar(const double x, const double y, gsl_sf_result * r, gsl_sf_result * theta);\n\n/* Sin(x) for quantity with an associated error.\n */\nGSL_EXPORT int gsl_sf_sin_err_e(const double x, const double dx, gsl_sf_result * result);\n\n\n/* Cos(x) for quantity with an associated error.\n */\nGSL_EXPORT int gsl_sf_cos_err_e(const double x, const double dx, gsl_sf_result * result);\n\n\n/* Force an angle to lie in the range (-pi,pi].\n *\n * exceptions: GSL_ELOSS\n */\nGSL_EXPORT int gsl_sf_angle_restrict_symm_e(double * theta);\nGSL_EXPORT double gsl_sf_angle_restrict_symm(const double theta);\n\n\n/* Force an angle to lie in the range [0, 2pi)\n *\n * exceptions: GSL_ELOSS\n */\nGSL_EXPORT int gsl_sf_angle_restrict_pos_e(double * theta);\nGSL_EXPORT double gsl_sf_angle_restrict_pos(const double theta);\n\n\nGSL_EXPORT int gsl_sf_angle_restrict_symm_err_e(const double theta, gsl_sf_result * result);\n\nGSL_EXPORT int gsl_sf_angle_restrict_pos_err_e(const double theta, gsl_sf_result * result);\n\n\n__END_DECLS\n\n#endif /* __GSL_SF_TRIG_H__ */\n", "meta": {"hexsha": "45f23d7b87bc70e7cc1103c0ad83595c3ba7157d", "size": 4259, "ext": "h", "lang": "C", "max_stars_repo_path": "src/core/gsl/include/gsl/gsl_sf_trig.h", "max_stars_repo_name": "dynaryu/vaws", "max_stars_repo_head_hexsha": "f6ed9b75408f7ce6100ed59b7754f745e59be152", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/core/gsl/include/gsl/gsl_sf_trig.h", "max_issues_repo_name": "dynaryu/vaws", "max_issues_repo_head_hexsha": "f6ed9b75408f7ce6100ed59b7754f745e59be152", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/core/gsl/include/gsl/gsl_sf_trig.h", "max_forks_repo_name": "dynaryu/vaws", "max_forks_repo_head_hexsha": "f6ed9b75408f7ce6100ed59b7754f745e59be152", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.6558441558, "max_line_length": 117, "alphanum_fraction": 0.7497065039, "num_tokens": 1122, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8056321889812553, "lm_q2_score": 0.6791786926816161, "lm_q1q2_score": 0.5471682168945177}} {"text": "#include \n\n#include \n#include \n#include \n#include \"timer.c\"\n#include \"timer.h\"\n#include \"integrand.h\"\n\n\ndouble dipole_approx (double r);\n\ndouble gaussian (double *x, int dim);\n\nint main (void)\n{\n double res, err;\n\n size_t dim = 6;\n double x1[] = { 0., 0., 0., 0., 0., 0., };\n double xu[] = { 1., 1., 1., 1., 1., 1., };\n double distmin = 1.001;\n double distmax = 4.;\n double dist;\n int numpoints = 20;\n double nt = (distmax - distmin) / (numpoints - 1);\n double vegas[20], dipole[20], distance[20];\n//vegas integration\n gsl_rng *r = gsl_rng_alloc (gsl_rng_taus2);\n unsigned long seed = 1UL;\n\n gsl_rng_set (r, seed);\n\n size_t calls = 1000000;\n \n dist = distmin;\n\n gsl_monte_function G = { &g, dim, &dist };\n\n gsl_monte_vegas_state *sv = gsl_monte_vegas_alloc (dim);\n\n gsl_monte_vegas_init (sv);\n\n timer_start ();\n\n for (int i = 0; i < numpoints; i++){\n gsl_monte_vegas_integrate (&G, x1, xu, dim, calls / 5, r, sv, &res,\n &err);\n do\n {\n gsl_monte_vegas_integrate (&G, x1, xu, dim, calls, r, sv, &res,\n &err);\n\t fflush(stdout);\n }\n while (fabs (gsl_monte_vegas_chisq (sv) - 1.0) > 0.2);\n dist += nt;\n vegas[i] = res;\n distance[i] = dist;\n dipole[i] = -2. / pow (dist, 3.);\n }\n timer_stop();\n //double vegastime = timer_stop();\n gsl_monte_vegas_free (sv); \n\n\n//Monte carlo integration\n double sum;\n double x[6];\n\n long i, j, nn;\n nn = 1000000;\n\n timer_start ();\n \n\n double monte[20];\n \n dist = distmin;\n for (j = 0; j < numpoints; j++)\n {\n sum = 0.;\n for (i = 0; i < nn; i++)\n {\n for (int k = 0; k < (int) dim; k++)\n {\n x[k] = gsl_rng_uniform (r);\n }\n sum += g (x, dim, &dist);\n }\n res = sum/nn;\n\tfflush(stdout);\n dist += nt; \n\tmonte[j] = res; \n }\n timer_stop (); \n //double montetime = timer_stop();\n //printf(\"Vegas time: %f Monte time: %f\", vegastime, montetime);\n\n gsl_rng_free(r);\n\n double monteerr = 0.0;\n\n for (int jj = 0; jj < numpoints; jj++)\n {\n monteerr += fabs(monte[jj] - vegas[jj]);\n }\n//prints the output of each integration\n printf(\"# Dist Vegas Monte Dipolapprox\\n\");\n for( int l = 0; l < numpoints; l++)\n {\n double dd = distance[l];\n double vv = fabs(vegas[l]);\n double mm = fabs(monte[l]);\n double di = fabs(dipole[l]);\n printf(\" %.6f %.6f %.6f %.6f\\n\", dd, vv, mm, di);\n }\n\n \n return 0; \n}\n\n\n\n\n\n\n", "meta": {"hexsha": "203653a9221b232312e86eb8e6d70e951e3c8efe", "size": 2695, "ext": "c", "lang": "C", "max_stars_repo_path": "main.c", "max_stars_repo_name": "hrwhitelock/fin2", "max_stars_repo_head_hexsha": "6f63f26819591cd46b2055a452ee0bf176d74fbe", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "main.c", "max_issues_repo_name": "hrwhitelock/fin2", "max_issues_repo_head_hexsha": "6f63f26819591cd46b2055a452ee0bf176d74fbe", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "main.c", "max_forks_repo_name": "hrwhitelock/fin2", "max_forks_repo_head_hexsha": "6f63f26819591cd46b2055a452ee0bf176d74fbe", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 21.2204724409, "max_line_length": 79, "alphanum_fraction": 0.5120593692, "num_tokens": 871, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8354835452961425, "lm_q2_score": 0.6548947223065755, "lm_q1q2_score": 0.5471537643884304}} {"text": "/**\n * File: trace_conf.h\n */\n\n#ifndef _TRACE_CONF_H\n#define _TRACE_CONF_H\n\n#include \n#include \n#include \n#include \"aXe_grism.h\"\n#include \"aXe_errors.h\"\n#include \"spc_cfg.h\"\n#include \"disp_conf.h\"\n\n\n/**\n\tA structure to contain the coefficient of a 2D\n\tpolynomial that can be used to compute the given\n\tcoefficient of the polynomial dispersion relation\n\tas at a particular i.j location in the image\n*/\ntypedef struct\n{\n gsl_vector *pol;\t\t/* A vector containing the 2D polynomial coefficients */\n d_point offset;\t\t/* X and Y offsets to apply to input coordinates */\n d_point cpoint;\t\t/* The detector location at which this structure was computed */\n int ID;\t\t\t/* The ID of the beam for which this coefficient is defined */\n char file[MAXCHAR];\n}\ntracestruct;\n\n\nextern int\nget_beam_trace_norder (char *filename, int beamID);\n\nextern gsl_vector *\nget_beam_trace_order (char *filename, int beamID, int order);\n\nextern float\nget_trace_coeff_at_pos (char *filename, int beamID, int order, d_point p);\n\nextern gsl_vector *\nget_trace_coeffs_at_pos (char *filename, int beamID, d_point p);\n\nextern gsl_vector *\nget_beam_trace_xoff (char *filename, int beamID);\n\nextern gsl_vector *\nget_beam_trace_yoff (char *filename, int beamID);\n\nextern float\nget_trace_xoff_at_pos (char *filename, int beamID, d_point p);\n\nextern float\nget_trace_yoff_at_pos (char *filename, int beamID, d_point p);\n\nextern float\neval_trace_off_at_pos (gsl_vector *coeffs, d_point p, int beamID);\n\nextern tracestruct *\nget_tracestruct_at_pos (char *filename, int beamID, d_point p);\n\nextern void\ntracestruct_fprintf (FILE * file, tracestruct * trace);\n\nextern void\nfree_tracestruct (tracestruct * trace);\n#endif\n", "meta": {"hexsha": "aac59024d40aeaa35938e0a4d6a66f4ae02ba525", "size": 1728, "ext": "h", "lang": "C", "max_stars_repo_path": "cextern/src/trace_conf.h", "max_stars_repo_name": "sosey/pyaxe", "max_stars_repo_head_hexsha": "f57de55daf77de21d5868ace08b69090778d5975", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "cextern/src/trace_conf.h", "max_issues_repo_name": "sosey/pyaxe", "max_issues_repo_head_hexsha": "f57de55daf77de21d5868ace08b69090778d5975", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "cextern/src/trace_conf.h", "max_forks_repo_name": "sosey/pyaxe", "max_forks_repo_head_hexsha": "f57de55daf77de21d5868ace08b69090778d5975", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 24.6857142857, "max_line_length": 86, "alphanum_fraction": 0.7552083333, "num_tokens": 444, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8539127603871312, "lm_q2_score": 0.6406358411176238, "lm_q1q2_score": 0.5470471194916817}} {"text": "#ifndef NUFFTW_PLAN_H\n#define NUFFTW_PLAN_H\n\n#include \n#include \n#include // st::numeric_limits\n#include // std::max\n#include // Bessel functions\n#include // Lambert W functions\n#include \n#include \"timer.h\"\n\nnamespace nufftw\n{\n using namespace std::complex_literals;\n typedef std::complex complex;\n\n struct options\n {\n double tol = std::numeric_limits::epsilon();\n unsigned int fftw_flags = FFTW_ESTIMATE;\n };\n\n namespace details\n {\n void cheb_vals(int n, int p, const double* x, double* vals);\n void bessel_coeffs(int r, double gam, complex* cfs);\n }\n\n class plan_base\n {\n \tpublic:\n \t\tplan_base(const int* ns_, complex* in_, complex* out_, const options& opts_ = options()) :\n in(in_), out(out_), opts(opts_)\n {\n n=1;\n for (int i=0; i\n {\n public:\n plan1(const int* n_, complex* in_, complex* out_, const double* omega_, const options& opts_ = options()) :\n plan_base(n_, in_, out_, opts_), omega(omega_)\n {}\n virtual ~plan1();\n virtual void execute();\n protected:\n const double* omega;\n plan1<1>* plans;\n };\n\n class plan1_2d : public plan_base\n {\n \n };\n\n class plan1_1d : public plan_base\n {\n public:\n plan1(int n_, complex* in_, complex* out_, const double* omega_, const options& opts_ = options()) :\n plan_base<1>(&n_, in_, out_, opts_), omega(omega_), t(new int[n]),\n er(new double[n]), temp(new double[n])\n {\n timer::tic();\n gam = 0;\n for (int i=0; iopts.tol) {\n // Asymptotic approximation to Lambert-W:\n // double xi = std::log(std::log(10./opts.tol)/(7.*gam);\n // double log_xi=std::log(xi), inv_xi=1./xi;\n // double lw = xi-log_xi*(1+inv_xi*(1+inv_xi*(0.5*log_xi-1)));\n double lw = gsl_sf_lambert_W0(std::log(10./opts.tol)/(7.*gam));\n r = std::ceil(5.*gam*std::exp(lw));\n }\n timer::toc(\"Compute r\");\n\n timer::tic();\n // Plan the FFTs\n fft_data = reinterpret_cast(fftw_alloc_complex(n*r));\n // int stride = r;\n int stride = 1;\n // int dist = 1;\n int dist = n;\n fp = fftw_plan_many_dft(1, &n, r,\n reinterpret_cast(fft_data), NULL, stride, dist,\n reinterpret_cast(fft_data), NULL, stride, dist,\n FFTW_BACKWARD, opts.fftw_flags\n );\n timer::toc(\"Plan the FFTs\");\n\n // Construct a low rank approximation, using Chebyshev expansions\n // for A_K = exp(-2*pi*1im*(x[j]-j/N)*k):\n \n // Construct a low rank approximation to\n // A_{jk} = exp(-2*pi*1i*(x_j-s_j/N)*k), 0<=j,k<=N-1,\n // where |x_j-j/N|<= gam <=1/2. See [1].\n u = new complex[n*r];\n v = new double[n*r];\n\n // Compute u\n timer::tic();\n double* cheb = new double[n*r];\n complex* bess = new complex[r*r];\n timer::tic();\n double fac = 1./gam;\n for (int i=0; i(fft_data));\n }\n\n virtual void execute()\n {\n for (int i=0; i\n // class plan2 : public plan_base\n // {\n // public:\n // plan2();\n // virtual ~plan2();\n // };\n\n // template<>\n // class plan2<1> : public plan_base<1>\n // {\n // public:\n // plan2();\n // virtual ~plan2();\n // };\n\n // template\n // class plan3 : public plan_base\n // {\n // public:\n // plan3();\n // virtual ~plan3();\n // };\n\n // template<>\n // class plan3<1> : public plan_base<1>\n // {\n // public:\n // plan3();\n // virtual ~plan3();\n // };\n\n typedef plan_base* plan;\n\n // Methods for planning\n template\n void destroy_plan(plan p)\n {\n if (p) delete p;\n }\n\n template\n void execute(const plan p)\n {\n p->execute();\n }\n\n namespace details\n {\n /** Evaluate Chebyshev polynomials of degree 0,...,p-1 at x.\n * (row-major order) */\n void cheb_vals(int n, int p, const double* x, double* vals)\n {\n for (int i=0; i\n#include \n#include \n\nnamespace sens_loc::math {\n\n/// Calculate the first derivate with the central differential quotient.\n/// \\tparam Real precision of the calculation\n/// \\param y__1 \\f$y_{i-1}\\f$\n/// \\param y_1 \\f$y_{i+1}\\f$\n/// \\param dx \\f$2. * dx\\f$\n/// \\returns first derivative at this point of order \\f$\\mathcal{O}(dx^2)\\f$\ntemplate \ninline Real first_derivative_central(Real y__1, Real y_1, Real dx) noexcept {\n static_assert(std::is_floating_point_v);\n\n Expects(dx > Real(0.));\n // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)\n return (y_1 - y__1) / (Real(2.) * dx);\n}\n\n/// Calculate the second derivate with the central differential quotient.\n/// \\tparam Real precision of the calculation\n/// \\param y__1 \\f$y_{i-1}\\f$\n/// \\param y_0 \\f$y_{i}\\f$\n/// \\param y_1 \\f$y_{i+1}\\f$\n/// \\param dx \\f$dx\\f$\n/// \\returns second derivative at this point of order \\f$\\mathcal{O}(dx^2)\\f$\ntemplate \ninline Real\nsecond_derivative_central(Real y__1, Real y_0, Real y_1, Real dx) noexcept {\n static_assert(std::is_floating_point_v);\n\n Expects(dx > Real(0.));\n // NOLINTNEXTLINE(cppcoreguidelines-avoid-magic-numbers)\n return (y_1 + y__1 - Real(2.) * y_0) / (dx * dx);\n}\n\n/// Calculate the derivatives for a surface patch.\n///\n/// Index convention:\n/// \\f$d\\_\\_1 == d_{-1}\\f$\n/// \\f$d\\_\\_0 == d_{0}\\f$\n/// \\f$d\\_1 == d_{1}\\f$\n///\n/// Angle convention:\n/// \\f$\\varphi\\f$ -> u direction\n/// \\f$\\theta\\f$ -> v direction\n///\n/// \\tparam Real precision of the calculation\n/// \\param d__1__1,d__1__0,d__1_1 neighbours \"above\" central pixel\n/// \\param d__0__1,d__0__0,d__0_1 same row as the central pixel\n/// \\param d_1__1,d_1__0,d_1_1 row \"after\" the central pixel\n/// \\param d_phi angle between rays in x direction \\f$(u - 1, u + 1)\\f$\n/// \\param d_theta angle between rays in y direction \\f$(v - 1, v + 1)\\f$\n/// \\param d_phi_theta angle between rays in diagonal direction\n/// \\f$(u - 1, v + 1)\\f$\n/// \\returns partial derivatives \\f$(f_u, f_v, f_uu, f_vv, f_uv)\\f$\n/// \\pre the depth values shuold be positive, as they encode depth values\n/// \\pre \\p / d_phi, \\p d_theta, \\p d_phi_theta are all positive angles\n// clang-format off\ntemplate \ninline std::tuple\nderivatives(Real d__1__1, Real d__1__0, Real d__1_1,\n Real d__0__1, Real d__0__0, Real d__0_1,\n Real d_1__1, Real d_1__0, Real d_1_1,\n Real d_phi, Real d_theta, Real d_phi_theta) noexcept {\n static_assert(std::is_floating_point_v);\n\n Expects(d_phi > 0.);\n Expects(d_theta > 0.);\n Expects(d_phi_theta > 0.);\n\n (void)d__1__1;\n (void)d__1_1;\n (void)d_1__1;\n (void)d_1_1;\n\n // clang-format on\n const Real f_u = math::first_derivative_central(d__0__1, d__0_1, d_phi);\n const Real f_v = math::first_derivative_central(d__1__0, d_1__0, d_theta);\n const Real f_uu =\n math::second_derivative_central(d__0__1, d__0__0, d__0_1, d_phi);\n const Real f_vv =\n math::second_derivative_central(d__1__0, d__0__0, d_1__0, d_theta);\n const Real f_uv =\n math::second_derivative_central(d__1__0, d__0__0, d_1__0, d_phi_theta);\n\n return std::make_tuple(f_u, f_v, f_uu, f_vv, f_uv);\n};\n// clang-format on\n} // namespace sens_loc::math\n\n#endif /* end of include guard: DERIVATIVES_H_5CHQ89V7 */\n", "meta": {"hexsha": "1df168888a06557143f36074a538a3f354f6a9df", "size": 3458, "ext": "h", "lang": "C", "max_stars_repo_path": "src/include/sens_loc/math/derivatives.h", "max_stars_repo_name": "JonasToth/depth-conversions", "max_stars_repo_head_hexsha": "5c8338276565d846c07673e83f94f6841006872b", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2021-09-30T07:09:49.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-14T09:14:35.000Z", "max_issues_repo_path": "src/include/sens_loc/math/derivatives.h", "max_issues_repo_name": "JonasToth/depth-conversions", "max_issues_repo_head_hexsha": "5c8338276565d846c07673e83f94f6841006872b", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/include/sens_loc/math/derivatives.h", "max_forks_repo_name": "JonasToth/depth-conversions", "max_forks_repo_head_hexsha": "5c8338276565d846c07673e83f94f6841006872b", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.2857142857, "max_line_length": 79, "alphanum_fraction": 0.6766917293, "num_tokens": 1172, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8175744850834648, "lm_q2_score": 0.6688802669716106, "lm_q1q2_score": 0.546859439851805}} {"text": "/*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*\n** **\n** This file forms part of the Underworld geophysics modelling application. **\n** **\n** For full license and copyright information, please refer to the LICENSE.md file **\n** located at the project root, or contact the authors. **\n** **\n**~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*~*/\n#include \n#include \n#include \n\n#include \"common-driver-utils.h\"\n\n\n// Calculate {r} = {F} - [K]{u} - [G]{p}\n// Calculate || {r} ||_2\ndouble BSSCR_StokesMomentumResidual( Mat K, Mat G, Vec F, Vec u, Vec p )\n{\n\tVec uStar;\n\t// PetscReal negOne = -1.0;\n\tPetscReal f_norm;\n\tPetscReal r1_norm;\n\t\n\t\n\tVecNorm( F, NORM_2, &f_norm ); // u_norm = || {uStar} ||_2\n\t\n\tVecDuplicate( u, &uStar );\n\tMatMult( K, u, uStar ); // {uStar} = [K]{u}\n\tMatMultAdd( G, p, uStar, uStar ); // {uStar} = {uStar} + [G]{p}\n\tVecAYPX( uStar, -1.0, F ); // {uStar} = {F} - {uStar}\n\tVecNorm( uStar, NORM_2, &r1_norm ); // r_norm = || {uStar} ||_2\n\tStg_VecDestroy(&uStar );\n\t/*\n\tprintf(\"%s \\n\", __func__ );\n\tprintf(\"\\t||f - Ku - Gp|| = %g \\n\", r1_norm );\n\tprintf(\"\\t||f - Ku - Gp||/||f|| = %g \\n\", r1_norm/f_norm );\n\t*/\n\t\n\t// return ( (double)(r1_norm/f_norm) );\n\treturn ( (double)(r1_norm) );\n}\n\n// Calculate {r} = {H} - [G]^T{u} - [C]{p}\n// Calculate || {r} ||_2\ndouble BSSCR_StokesContinuityResidual( Mat G, Mat C, Vec H, Vec u, Vec p )\n{\n\tVec pStar;\n\t// PetscReal negOne = -1.0;\n\tPetscReal r2_norm;\n\tPetscReal u_norm;\n\t\n\tVecNorm( u, NORM_2, &u_norm ); // u_norm = || {uStar} ||_2\n\t\n\tVecDuplicate( H, &pStar );\n\tMatMultTranspose( G, u, pStar ); // {pStar} = [G]^T{u}\n\tif( C != PETSC_NULL ) {\n\t\tMatMultAdd( C, p, pStar, pStar );\t/* {pStar} = {pStar} + [C] {p} */\n\t}\n\tVecAYPX( pStar, -1.0, H ); // {pStar} = {H} - {pStar}\n\t\n\tVecNorm( pStar, NORM_2, &r2_norm ); // norm = || {pStar} ||_2\n\tStg_VecDestroy(&pStar );\n\t\n\t/*\n\tprintf(\"%s \\n\", __func__ );\n\tprintf(\"\\t||h - Du|| = %g \\n\", r2_norm );\n\tprintf(\"\\t||h - Du||/||u|| = %g \\n\", r2_norm/u_norm );\n\t*/\n\t\n\t// return ( (double)(r2_norm/u_norm) );\n\treturn ( (double)(r2_norm) );\n}\n\n", "meta": {"hexsha": "cc8cbe87b5240eda6db351e1885ba39059b395cb", "size": 2715, "ext": "c", "lang": "C", "max_stars_repo_path": "underworld/libUnderworld/Solvers/KSPSolvers/src/BSSCR/stokes_residual.c", "max_stars_repo_name": "longgangfan/underworld2", "max_stars_repo_head_hexsha": "5c8acc17fa4d97e86a62b13b8bfb2af6e81a8ee4", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": 116.0, "max_stars_repo_stars_event_min_datetime": "2015-09-28T10:30:55.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-22T04:12:38.000Z", "max_issues_repo_path": "underworld/libUnderworld/Solvers/KSPSolvers/src/BSSCR/stokes_residual.c", "max_issues_repo_name": "longgangfan/underworld2", "max_issues_repo_head_hexsha": "5c8acc17fa4d97e86a62b13b8bfb2af6e81a8ee4", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": 561.0, "max_issues_repo_issues_event_min_datetime": "2015-09-29T06:05:50.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-22T23:37:29.000Z", "max_forks_repo_path": "underworld/libUnderworld/Solvers/KSPSolvers/src/BSSCR/stokes_residual.c", "max_forks_repo_name": "longgangfan/underworld2", "max_forks_repo_head_hexsha": "5c8acc17fa4d97e86a62b13b8bfb2af6e81a8ee4", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": 68.0, "max_forks_repo_forks_event_min_datetime": "2015-12-14T21:57:46.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-25T04:54:26.000Z", "avg_line_length": 36.2, "max_line_length": 87, "alphanum_fraction": 0.4162062615, "num_tokens": 956, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7931059609645724, "lm_q2_score": 0.6893056104028799, "lm_q1q2_score": 0.5466923885368472}} {"text": "/* min/brent.c\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000 Brian Gough\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 2 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n/* brent.c -- brent minimum finding algorithm */\n\n#include \n\n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n\n#include \"min.h\"\n\ntypedef struct\n {\n double d, e, v, w;\n double f_v, f_w;\n }\nbrent_state_t;\n\nstatic int brent_init (void *vstate, gsl_function * f, double x_minimum, double f_minimum, double x_lower, double f_lower, double x_upper, double f_upper);\nstatic int brent_iterate (void *vstate, gsl_function * f, double *x_minimum, double * f_minimum, double * x_lower, double * f_lower, double * x_upper, double * f_upper);\n\nstatic int\nbrent_init (void *vstate, gsl_function * f, double x_minimum, double f_minimum, double x_lower, double f_lower, double x_upper, double f_upper)\n{\n brent_state_t *state = (brent_state_t *) vstate;\n\n const double golden = 0.3819660; /* golden = (3 - sqrt(5))/2 */\n\n double v = x_lower + golden * (x_upper - x_lower);\n double w = v;\n\n double f_vw;\n\n x_minimum = 0 ; /* avoid warnings about unused varibles */\n f_minimum = 0 ;\n f_lower = 0 ;\n f_upper = 0 ;\n\n state->v = v;\n state->w = w;\n\n state->d = 0;\n state->e = 0;\n\n SAFE_FUNC_CALL (f, v, &f_vw);\n\n state->f_v = f_vw;\n state->f_w = f_vw;\n\n return GSL_SUCCESS;\n}\n\nstatic int\nbrent_iterate (void *vstate, gsl_function * f, double *x_minimum, double * f_minimum, double * x_lower, double * f_lower, double * x_upper, double * f_upper)\n{\n brent_state_t *state = (brent_state_t *) vstate;\n\n const double x_left = *x_lower;\n const double x_right = *x_upper;\n\n const double z = *x_minimum;\n double d = state->e;\n double e = state->d;\n double u, f_u;\n const double v = state->v;\n const double w = state->w;\n const double f_v = state->f_v;\n const double f_w = state->f_w;\n const double f_z = *f_minimum;\n\n const double golden = 0.3819660; /* golden = (3 - sqrt(5))/2 */\n\n const double w_lower = (z - x_left);\n const double w_upper = (x_right - z);\n\n const double tolerance = GSL_SQRT_DBL_EPSILON * fabs (z);\n\n double p = 0, q = 0, r = 0;\n\n const double midpoint = 0.5 * (x_left + x_right);\n\n if (fabs (e) > tolerance)\n {\n /* fit parabola */\n\n r = (z - w) * (f_z - f_v);\n q = (z - v) * (f_z - f_w);\n p = (z - v) * q - (z - w) * r;\n q = 2 * (q - r);\n\n if (q > 0)\n {\n p = -p;\n }\n else\n {\n q = -q;\n }\n\n r = e;\n e = d;\n }\n\n if (fabs (p) < fabs (0.5 * q * r) && p < q * w_lower && p < q * w_upper)\n {\n double t2 = 2 * tolerance ;\n\n d = p / q;\n u = z + d;\n\n if ((u - x_left) < t2 || (x_right - u) < t2)\n {\n d = (z < midpoint) ? tolerance : -tolerance ;\n }\n }\n else\n {\n e = (z < midpoint) ? x_right - z : -(z - x_left) ;\n d = golden * e;\n }\n\n\n if (fabs (d) >= tolerance)\n {\n u = z + d;\n }\n else\n {\n u = z + ((d > 0) ? tolerance : -tolerance) ;\n }\n\n state->e = e;\n state->d = d;\n\n SAFE_FUNC_CALL(f, u, &f_u);\n\n if (f_u <= f_z)\n {\n if (u < z)\n {\n *x_upper = z;\n *f_upper = f_z;\n }\n else\n {\n *x_lower = z;\n *f_lower = f_z;\n }\n\n state->v = w;\n state->f_v = f_w;\n state->w = z;\n state->f_w = f_z;\n *x_minimum = u;\n *f_minimum = f_u;\n return GSL_SUCCESS;\n }\n else\n {\n if (u < z)\n {\n *x_lower = u;\n *f_lower = f_u;\n return GSL_SUCCESS;\n }\n else\n {\n *x_upper = u;\n *f_upper = f_u;\n return GSL_SUCCESS;\n }\n\n if (f_u <= f_w || w == z)\n {\n state->v = w;\n state->f_v = f_w;\n state->w = u;\n state->f_w = f_u;\n return GSL_SUCCESS;\n }\n else if (f_u <= f_v || v == z || v == w)\n {\n state->v = u;\n state->f_v = f_u;\n return GSL_SUCCESS;\n }\n }\n\n return GSL_FAILURE;\n}\n\n\nstatic const gsl_min_fminimizer_type brent_type =\n{\"brent\", /* name */\n sizeof (brent_state_t),\n &brent_init,\n &brent_iterate};\n\nconst gsl_min_fminimizer_type *gsl_min_fminimizer_brent = &brent_type;\n", "meta": {"hexsha": "499e01590d0bacfeb41eaef3ca784e0d5c5db947", "size": 5064, "ext": "c", "lang": "C", "max_stars_repo_path": "pkgs/libs/gsl/src/min/brent.c", "max_stars_repo_name": "manggoguy/parsec-modified", "max_stars_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 64.0, "max_stars_repo_stars_event_min_datetime": "2015-03-06T00:30:56.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-24T13:26:53.000Z", "max_issues_repo_path": "pkgs/libs/gsl/src/min/brent.c", "max_issues_repo_name": "manggoguy/parsec-modified", "max_issues_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 12.0, "max_issues_repo_issues_event_min_datetime": "2020-12-15T08:30:19.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-13T03:54:24.000Z", "max_forks_repo_path": "pkgs/libs/gsl/src/min/brent.c", "max_forks_repo_name": "manggoguy/parsec-modified", "max_forks_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 40.0, "max_forks_repo_forks_event_min_datetime": "2015-02-26T15:31:16.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-03T23:23:37.000Z", "avg_line_length": 22.6071428571, "max_line_length": 169, "alphanum_fraction": 0.5576619273, "num_tokens": 1559, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7772998611746912, "lm_q2_score": 0.7025300698514777, "lm_q1q2_score": 0.5460765257665997}} {"text": "/* specfunc/dilog.c\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2004 Gerard Jungman\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n/* Author: G. Jungman */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n\n/* Evaluate series for real dilog(x)\n * Sum[ x^k / k^2, {k,1,Infinity}]\n *\n * Converges rapidly for |x| < 1/2.\n */\nstatic\nint\ndilog_series_1(const double x, gsl_sf_result * result)\n{\n const int kmax = 1000;\n double sum = x;\n double term = x;\n int k;\n for(k=2; kval = sum;\n result->err = 2.0 * fabs(term);\n result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);\n\n if(k == kmax)\n GSL_ERROR (\"error\", GSL_EMAXITER);\n else\n return GSL_SUCCESS;\n}\n\n\n/* Compute the associated series\n *\n * sum_{k=1}{infty} r^k / (k^2 (k+1))\n *\n * This is a series which appears in the one-step accelerated\n * method, which splits out one elementary function from the\n * full definition of Li_2(x). See below.\n */\nstatic int\nseries_2(double r, gsl_sf_result * result)\n{\n static const int kmax = 100;\n double rk = r;\n double sum = 0.5 * r;\n int k;\n for(k=2; k<10; k++)\n {\n double ds;\n rk *= r;\n ds = rk/(k*k*(k+1.0));\n sum += ds;\n }\n for(; kval = sum;\n result->err = 2.0 * kmax * GSL_DBL_EPSILON * fabs(sum);\n\n return GSL_SUCCESS;\n}\n\n\n/* Compute Li_2(x) using the accelerated series representation.\n *\n * Li_2(x) = 1 + (1-x)ln(1-x)/x + series_2(x)\n *\n * assumes: -1 < x < 1\n */\nstatic int\ndilog_series_2(double x, gsl_sf_result * result)\n{\n const int stat_s3 = series_2(x, result);\n double t;\n if(x > 0.01)\n t = (1.0 - x) * log(1.0-x) / x;\n else\n {\n static const double c3 = 1.0/3.0;\n static const double c4 = 1.0/4.0;\n static const double c5 = 1.0/5.0;\n static const double c6 = 1.0/6.0;\n static const double c7 = 1.0/7.0;\n static const double c8 = 1.0/8.0;\n const double t68 = c6 + x*(c7 + x*c8);\n const double t38 = c3 + x *(c4 + x *(c5 + x * t68));\n t = (x - 1.0) * (1.0 + x*(0.5 + x*t38));\n }\n result->val += 1.0 + t;\n result->err += 2.0 * GSL_DBL_EPSILON * fabs(t);\n return stat_s3;\n}\n\n\n/* Calculates Li_2(x) for real x. Assumes x >= 0.0.\n */\nstatic\nint\ndilog_xge0(const double x, gsl_sf_result * result)\n{\n if(x > 2.0) {\n gsl_sf_result ser;\n const int stat_ser = dilog_series_2(1.0/x, &ser);\n const double log_x = log(x);\n const double t1 = M_PI*M_PI/3.0;\n const double t2 = ser.val;\n const double t3 = 0.5*log_x*log_x;\n result->val = t1 - t2 - t3;\n result->err = GSL_DBL_EPSILON * fabs(log_x) + ser.err;\n result->err += GSL_DBL_EPSILON * (fabs(t1) + fabs(t2) + fabs(t3));\n result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);\n return stat_ser;\n }\n else if(x > 1.01) {\n gsl_sf_result ser;\n const int stat_ser = dilog_series_2(1.0 - 1.0/x, &ser);\n const double log_x = log(x);\n const double log_term = log_x * (log(1.0-1.0/x) + 0.5*log_x);\n const double t1 = M_PI*M_PI/6.0;\n const double t2 = ser.val;\n const double t3 = log_term;\n result->val = t1 + t2 - t3;\n result->err = GSL_DBL_EPSILON * fabs(log_x) + ser.err;\n result->err += GSL_DBL_EPSILON * (fabs(t1) + fabs(t2) + fabs(t3));\n result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);\n return stat_ser;\n }\n else if(x > 1.0) {\n /* series around x = 1.0 */\n const double eps = x - 1.0;\n const double lne = log(eps);\n const double c0 = M_PI*M_PI/6.0;\n const double c1 = 1.0 - lne;\n const double c2 = -(1.0 - 2.0*lne)/4.0;\n const double c3 = (1.0 - 3.0*lne)/9.0;\n const double c4 = -(1.0 - 4.0*lne)/16.0;\n const double c5 = (1.0 - 5.0*lne)/25.0;\n const double c6 = -(1.0 - 6.0*lne)/36.0;\n const double c7 = (1.0 - 7.0*lne)/49.0;\n const double c8 = -(1.0 - 8.0*lne)/64.0;\n result->val = c0+eps*(c1+eps*(c2+eps*(c3+eps*(c4+eps*(c5+eps*(c6+eps*(c7+eps*c8)))))));\n result->err = 2.0 * GSL_DBL_EPSILON * fabs(result->val);\n return GSL_SUCCESS;\n }\n else if(x == 1.0) {\n result->val = M_PI*M_PI/6.0;\n result->err = 2.0 * GSL_DBL_EPSILON * M_PI*M_PI/6.0;\n return GSL_SUCCESS;\n }\n else if(x > 0.5) {\n gsl_sf_result ser;\n const int stat_ser = dilog_series_2(1.0-x, &ser);\n const double log_x = log(x);\n const double t1 = M_PI*M_PI/6.0;\n const double t2 = ser.val;\n const double t3 = log_x*log(1.0-x);\n result->val = t1 - t2 - t3;\n result->err = GSL_DBL_EPSILON * fabs(log_x) + ser.err;\n result->err += GSL_DBL_EPSILON * (fabs(t1) + fabs(t2) + fabs(t3));\n result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);\n return stat_ser;\n }\n else if(x > 0.25) {\n return dilog_series_2(x, result);\n }\n else if(x > 0.0) {\n return dilog_series_1(x, result);\n }\n else {\n /* x == 0.0 */\n result->val = 0.0;\n result->err = 0.0;\n return GSL_SUCCESS;\n }\n}\n\n\n/* Evaluate the series representation for Li2(z):\n *\n * Li2(z) = Sum[ |z|^k / k^2 Exp[i k arg(z)], {k,1,Infinity}]\n * |z| = r\n * arg(z) = theta\n * \n * Assumes 0 < r < 1.\n * It is used only for small r.\n */\nstatic\nint\ndilogc_series_1(\n const double r,\n const double x,\n const double y,\n gsl_sf_result * real_result,\n gsl_sf_result * imag_result\n )\n{\n const double cos_theta = x/r;\n const double sin_theta = y/r;\n const double alpha = 1.0 - cos_theta;\n const double beta = sin_theta;\n double ck = cos_theta;\n double sk = sin_theta;\n double rk = r;\n double real_sum = r*ck;\n double imag_sum = r*sk;\n const int kmax = 50 + (int)(22.0/(-log(r))); /* tuned for double-precision */\n int k;\n for(k=2; kval = real_sum;\n real_result->err = 2.0 * kmax * GSL_DBL_EPSILON * fabs(real_sum);\n imag_result->val = imag_sum;\n imag_result->err = 2.0 * kmax * GSL_DBL_EPSILON * fabs(imag_sum);\n\n return GSL_SUCCESS;\n}\n\n\n/* Compute\n *\n * sum_{k=1}{infty} z^k / (k^2 (k+1))\n *\n * This is a series which appears in the one-step accelerated\n * method, which splits out one elementary function from the\n * full definition of Li_2.\n */\nstatic int\nseries_2_c(\n double r,\n double x,\n double y,\n gsl_sf_result * sum_re,\n gsl_sf_result * sum_im\n )\n{\n const double cos_theta = x/r;\n const double sin_theta = y/r;\n const double alpha = 1.0 - cos_theta;\n const double beta = sin_theta;\n double ck = cos_theta;\n double sk = sin_theta;\n double rk = r;\n double real_sum = 0.5 * r*ck;\n double imag_sum = 0.5 * r*sk;\n const int kmax = 30 + (int)(18.0/(-log(r))); /* tuned for double-precision */\n int k;\n for(k=2; kval = real_sum;\n sum_re->err = 2.0 * kmax * GSL_DBL_EPSILON * fabs(real_sum);\n sum_im->val = imag_sum;\n sum_im->err = 2.0 * kmax * GSL_DBL_EPSILON * fabs(imag_sum);\n\n return GSL_SUCCESS;\n}\n\n\n/* Compute Li_2(z) using the one-step accelerated series.\n *\n * Li_2(z) = 1 + (1-z)ln(1-z)/z + series_2_c(z)\n *\n * z = r exp(i theta)\n * assumes: r < 1\n * assumes: r > epsilon, so that we take no special care with log(1-z)\n */\nstatic\nint\ndilogc_series_2(\n const double r,\n const double x,\n const double y,\n gsl_sf_result * real_dl,\n gsl_sf_result * imag_dl\n )\n{\n if(r == 0.0)\n {\n real_dl->val = 0.0;\n imag_dl->val = 0.0;\n real_dl->err = 0.0;\n imag_dl->err = 0.0;\n return GSL_SUCCESS;\n }\n else\n {\n gsl_sf_result sum_re;\n gsl_sf_result sum_im;\n const int stat_s3 = series_2_c(r, x, y, &sum_re, &sum_im);\n\n /* t = ln(1-z)/z */\n gsl_sf_result ln_omz_r;\n gsl_sf_result ln_omz_theta;\n const int stat_log = gsl_sf_complex_log_e(1.0-x, -y, &ln_omz_r, &ln_omz_theta);\n const double t_x = ( ln_omz_r.val * x + ln_omz_theta.val * y)/(r*r);\n const double t_y = (-ln_omz_r.val * y + ln_omz_theta.val * x)/(r*r);\n\n /* r = (1-z) ln(1-z)/z */\n const double r_x = (1.0 - x) * t_x + y * t_y;\n const double r_y = (1.0 - x) * t_y - y * t_x;\n\n real_dl->val = sum_re.val + r_x + 1.0;\n imag_dl->val = sum_im.val + r_y;\n real_dl->err = sum_re.err + 2.0*GSL_DBL_EPSILON*(fabs(real_dl->val) + fabs(r_x));\n imag_dl->err = sum_im.err + 2.0*GSL_DBL_EPSILON*(fabs(imag_dl->val) + fabs(r_y));\n return GSL_ERROR_SELECT_2(stat_s3, stat_log);\n }\n}\n\n\n/* Evaluate a series for Li_2(z) when |z| is near 1.\n * This is uniformly good away from z=1.\n *\n * Li_2(z) = Sum[ a^n/n! H_n(theta), {n, 0, Infinity}]\n *\n * where\n * H_n(theta) = Sum[ e^(i m theta) m^n / m^2, {m, 1, Infinity}]\n * a = ln(r)\n *\n * H_0(t) = Gl_2(t) + i Cl_2(t)\n * H_1(t) = 1/2 ln(2(1-c)) + I atan2(-s, 1-c)\n * H_2(t) = -1/2 + I/2 s/(1-c)\n * H_3(t) = -1/2 /(1-c)\n * H_4(t) = -I/2 s/(1-c)^2\n * H_5(t) = 1/2 (2 + c)/(1-c)^2\n * H_6(t) = I/2 s/(1-c)^5 (8(1-c) - s^2 (3 + c))\n */\nstatic\nint\ndilogc_series_3(\n const double r,\n const double x,\n const double y,\n gsl_sf_result * real_result,\n gsl_sf_result * imag_result\n )\n{\n const double theta = atan2(y, x);\n const double cos_theta = x/r;\n const double sin_theta = y/r;\n const double a = log(r);\n const double omc = 1.0 - cos_theta;\n const double omc2 = omc*omc;\n double H_re[7];\n double H_im[7];\n double an, nfact;\n double sum_re, sum_im;\n gsl_sf_result Him0;\n int n;\n\n H_re[0] = M_PI*M_PI/6.0 + 0.25*(theta*theta - 2.0*M_PI*fabs(theta));\n gsl_sf_clausen_e(theta, &Him0);\n H_im[0] = Him0.val;\n\n H_re[1] = -0.5*log(2.0*omc);\n H_im[1] = -atan2(-sin_theta, omc);\n\n H_re[2] = -0.5;\n H_im[2] = 0.5 * sin_theta/omc;\n\n H_re[3] = -0.5/omc;\n H_im[3] = 0.0;\n\n H_re[4] = 0.0;\n H_im[4] = -0.5*sin_theta/omc2;\n\n H_re[5] = 0.5 * (2.0 + cos_theta)/omc2;\n H_im[5] = 0.0;\n\n H_re[6] = 0.0;\n H_im[6] = 0.5 * sin_theta/(omc2*omc2*omc) * (8.0*omc - sin_theta*sin_theta*(3.0 + cos_theta));\n\n sum_re = H_re[0];\n sum_im = H_im[0];\n an = 1.0;\n nfact = 1.0;\n for(n=1; n<=6; n++) {\n double t;\n an *= a;\n nfact *= n;\n t = an/nfact;\n sum_re += t * H_re[n];\n sum_im += t * H_im[n];\n }\n\n real_result->val = sum_re;\n real_result->err = 2.0 * 6.0 * GSL_DBL_EPSILON * fabs(sum_re) + fabs(an/nfact);\n imag_result->val = sum_im;\n imag_result->err = 2.0 * 6.0 * GSL_DBL_EPSILON * fabs(sum_im) + Him0.err + fabs(an/nfact);\n\n return GSL_SUCCESS;\n}\n\n\n/* Calculate complex dilogarithm Li_2(z) in the fundamental region,\n * which we take to be the intersection of the unit disk with the\n * half-space x < MAGIC_SPLIT_VALUE. It turns out that 0.732 is a\n * nice choice for MAGIC_SPLIT_VALUE since then points mapped out\n * of the x > MAGIC_SPLIT_VALUE region and into another part of the\n * unit disk are bounded in radius by MAGIC_SPLIT_VALUE itself.\n *\n * If |z| < 0.98 we use a direct series summation. Otherwise z is very\n * near the unit circle, and the series_2 expansion is used; see above.\n * Because the fundamental region is bounded away from z = 1, this\n * works well.\n */\nstatic\nint\ndilogc_fundamental(double r, double x, double y, gsl_sf_result * real_dl, gsl_sf_result * imag_dl)\n{\n if(r > 0.98) \n return dilogc_series_3(r, x, y, real_dl, imag_dl);\n else if(r > 0.25)\n return dilogc_series_2(r, x, y, real_dl, imag_dl);\n else\n return dilogc_series_1(r, x, y, real_dl, imag_dl);\n}\n\n\n/* Compute Li_2(z) for z in the unit disk, |z| < 1. If z is outside\n * the fundamental region, which means that it is too close to z = 1,\n * then it is reflected into the fundamental region using the identity\n *\n * Li2(z) = -Li2(1-z) + zeta(2) - ln(z) ln(1-z).\n */\nstatic\nint\ndilogc_unitdisk(double x, double y, gsl_sf_result * real_dl, gsl_sf_result * imag_dl)\n{\n static const double MAGIC_SPLIT_VALUE = 0.732;\n static const double zeta2 = M_PI*M_PI/6.0;\n const double r = hypot(x, y);\n\n if(x > MAGIC_SPLIT_VALUE)\n {\n /* Reflect away from z = 1 if we are too close. The magic value\n * insures that the reflected value of the radius satisfies the\n * related inequality r_tmp < MAGIC_SPLIT_VALUE.\n */\n const double x_tmp = 1.0 - x;\n const double y_tmp = - y;\n const double r_tmp = hypot(x_tmp, y_tmp);\n /* const double cos_theta_tmp = x_tmp/r_tmp; */\n /* const double sin_theta_tmp = y_tmp/r_tmp; */\n\n gsl_sf_result result_re_tmp;\n gsl_sf_result result_im_tmp;\n\n const int stat_dilog = dilogc_fundamental(r_tmp, x_tmp, y_tmp, &result_re_tmp, &result_im_tmp);\n\n const double lnz = log(r); /* log(|z|) */\n const double lnomz = log(r_tmp); /* log(|1-z|) */\n const double argz = atan2(y, x); /* arg(z) assuming principal branch */\n const double argomz = atan2(y_tmp, x_tmp); /* arg(1-z) */\n real_dl->val = -result_re_tmp.val + zeta2 - lnz*lnomz + argz*argomz;\n real_dl->err = result_re_tmp.err;\n real_dl->err += 2.0 * GSL_DBL_EPSILON * (zeta2 + fabs(lnz*lnomz) + fabs(argz*argomz));\n imag_dl->val = -result_im_tmp.val - argz*lnomz - argomz*lnz;\n imag_dl->err = result_im_tmp.err;\n imag_dl->err += 2.0 * GSL_DBL_EPSILON * (fabs(argz*lnomz) + fabs(argomz*lnz));\n\n return stat_dilog;\n }\n else\n {\n return dilogc_fundamental(r, x, y, real_dl, imag_dl);\n }\n}\n\n\n\n/*-*-*-*-*-*-*-*-*-*-*-* Functions with Error Codes *-*-*-*-*-*-*-*-*-*-*-*/\n\n\nint\ngsl_sf_dilog_e(const double x, gsl_sf_result * result)\n{\n if(x >= 0.0) {\n return dilog_xge0(x, result);\n }\n else {\n gsl_sf_result d1, d2;\n int stat_d1 = dilog_xge0( -x, &d1);\n int stat_d2 = dilog_xge0(x*x, &d2);\n result->val = -d1.val + 0.5 * d2.val;\n result->err = d1.err + 0.5 * d2.err;\n result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);\n return GSL_ERROR_SELECT_2(stat_d1, stat_d2);\n }\n}\n\n\nint\ngsl_sf_complex_dilog_xy_e(\n const double x,\n const double y,\n gsl_sf_result * real_dl,\n gsl_sf_result * imag_dl\n )\n{\n const double zeta2 = M_PI*M_PI/6.0;\n const double r2 = x*x + y*y;\n\n if(y == 0.0)\n {\n if(x >= 1.0)\n {\n imag_dl->val = -M_PI * log(x);\n imag_dl->err = 2.0 * GSL_DBL_EPSILON * fabs(imag_dl->val);\n }\n else\n {\n imag_dl->val = 0.0;\n imag_dl->err = 0.0;\n }\n return gsl_sf_dilog_e(x, real_dl);\n }\n else if(fabs(r2 - 1.0) < GSL_DBL_EPSILON)\n {\n /* Lewin A.2.4.1 and A.2.4.2 */\n\n const double theta = atan2(y, x);\n const double term1 = theta*theta/4.0;\n const double term2 = M_PI*fabs(theta)/2.0;\n real_dl->val = zeta2 + term1 - term2;\n real_dl->err = 2.0 * GSL_DBL_EPSILON * (zeta2 + term1 + term2);\n return gsl_sf_clausen_e(theta, imag_dl);\n }\n else if(r2 < 1.0)\n {\n return dilogc_unitdisk(x, y, real_dl, imag_dl);\n }\n else\n {\n /* Reduce argument to unit disk. */\n const double r = sqrt(r2);\n const double x_tmp = x/r2;\n const double y_tmp = -y/r2;\n /* const double r_tmp = 1.0/r; */\n gsl_sf_result result_re_tmp, result_im_tmp;\n\n const int stat_dilog =\n dilogc_unitdisk(x_tmp, y_tmp, &result_re_tmp, &result_im_tmp);\n\n /* Unwind the inversion.\n *\n * Li_2(z) + Li_2(1/z) = -zeta(2) - 1/2 ln(-z)^2\n */\n const double theta = atan2(y, x);\n const double theta_abs = fabs(theta);\n const double theta_sgn = ( theta < 0.0 ? -1.0 : 1.0 );\n const double ln_minusz_re = log(r);\n const double ln_minusz_im = theta_sgn * (theta_abs - M_PI);\n const double lmz2_re = ln_minusz_re*ln_minusz_re - ln_minusz_im*ln_minusz_im;\n const double lmz2_im = 2.0*ln_minusz_re*ln_minusz_im;\n real_dl->val = -result_re_tmp.val - 0.5 * lmz2_re - zeta2;\n real_dl->err = result_re_tmp.err + 2.0*GSL_DBL_EPSILON*(0.5 * fabs(lmz2_re) + zeta2);\n imag_dl->val = -result_im_tmp.val - 0.5 * lmz2_im;\n imag_dl->err = result_im_tmp.err + 2.0*GSL_DBL_EPSILON*fabs(lmz2_im);\n return stat_dilog;\n }\n}\n\n\nint\ngsl_sf_complex_dilog_e(\n const double r,\n const double theta,\n gsl_sf_result * real_dl,\n gsl_sf_result * imag_dl\n )\n{\n const double cos_theta = cos(theta);\n const double sin_theta = sin(theta);\n const double x = r * cos_theta;\n const double y = r * sin_theta;\n return gsl_sf_complex_dilog_xy_e(x, y, real_dl, imag_dl);\n}\n\n\nint\ngsl_sf_complex_spence_xy_e(\n const double x,\n const double y,\n gsl_sf_result * real_sp,\n gsl_sf_result * imag_sp\n )\n{\n const double oms_x = 1.0 - x;\n const double oms_y = - y;\n return gsl_sf_complex_dilog_xy_e(oms_x, oms_y, real_sp, imag_sp);\n}\n\n\n\n/*-*-*-*-*-*-*-*-*-* Functions w/ Natural Prototypes *-*-*-*-*-*-*-*-*-*-*/\n\n#include \"eval.h\"\n\ndouble gsl_sf_dilog(const double x)\n{\n EVAL_RESULT(gsl_sf_dilog_e(x, &result));\n}\n", "meta": {"hexsha": "15586ef0d384ec5b3adf88dfe007c9ed5758e034", "size": 18052, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.6/specfunc/dilog.c", "max_stars_repo_name": "ielomariala/Hex-Game", "max_stars_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-01-11T02:53:04.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-25T17:31:22.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/specfunc/dilog.c", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-12-16T17:41:24.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-22T00:00:16.000Z", "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/specfunc/dilog.c", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 14.0, "max_forks_repo_forks_event_min_datetime": "2015-07-21T04:47:52.000Z", "max_forks_repo_forks_event_max_datetime": "2020-03-12T12:31:25.000Z", "avg_line_length": 27.2277526395, "max_line_length": 110, "alphanum_fraction": 0.6131176601, "num_tokens": 6513, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7772998611746912, "lm_q2_score": 0.7025300636233416, "lm_q1q2_score": 0.5460765209254704}} {"text": "/* blas/blas.c\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001 Gerard Jungman & Brian \n * Gough\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 2 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n/* GSL implementation of BLAS operations for vectors and dense\n * matrices. Note that GSL native storage is row-major. */\n\n#include \n#include \n#include \n#include \n#include \n\n/* ========================================================================\n * Level 1\n * ========================================================================\n */\n\n/* CBLAS defines vector sizes in terms of int. GSL defines sizes in\n terms of size_t, so we need to convert these into integers. There\n is the possibility of overflow here. FIXME: Maybe this could be\n caught */\n\n#define INT(X) ((int)(X))\n\n\n\nint gsl_blas_ddot (const gsl_vector * X, const gsl_vector * Y, double *result){\n if (X->size == Y->size){\n\t *result = ddot (&INT (X->size), X->data, &INT (X->stride), Y->data, &INT (Y->stride));\n return GSL_SUCCESS;\n }\n else {\n GSL_ERROR (\"invalid length\", GSL_EBADLEN);\n }\n}\n\n/**\n* DNRM2 returns the euclidean norm of a vector via the function\n* name, so that\n*\n* DNRM2 := sqrt( x'*x )\n*/\n\ndouble gsl_blas_dnrm2 (const gsl_vector * X){\n return dnrm2 (&INT (X->size), X->data, &INT (X->stride));\n}\n\n/**\n* interchanges two vectors.\t\n*/\nint gsl_blas_dswap (gsl_vector * X, gsl_vector * Y){\n if (X->size == Y->size){\n dswap (&INT (X->size), X->data, &INT (X->stride), Y->data, &INT (Y->stride));\n return GSL_SUCCESS;\n }\n else{\n GSL_ERROR (\"invalid length\", GSL_EBADLEN);\n };\n}\n\n\n\n/**\n* copies a vector, x, to a vector, y.\n*/\nint gsl_blas_dcopy (const gsl_vector * X, gsl_vector * Y){\n if (X->size == Y->size){\n dcopy (&INT (X->size), X->data, &INT (X->stride), Y->data, &INT (Y->stride));\n return GSL_SUCCESS;\n }\n else {\n GSL_ERROR (\"invalid length\", GSL_EBADLEN);\n }\n}\n\n\n/* ===========================================================================\n * Level 2\n * ===========================================================================\n */\n\nint\ngsl_blas_dgemv (CBLAS_TRANSPOSE_t TransA, double alpha, const gsl_matrix * A,\n const gsl_vector * X, double beta, gsl_vector * Y)\n{\n\t//here the matrix is by default transposed, so to get the right behaviour we will transpose it when the user didn't want it tranposed, and leave it the way it is when it should be transposed\n\n //note that M and N are changed to show that the matrix is transposed by default.\n const size_t M = A->size1;\n const size_t N = A->size2;\n\n char aTransp = (TransA == CblasNoTrans) ? 'T' : 'N';\n\n if ((TransA == CblasNoTrans && N == X->size && M == Y->size)\n || (TransA == CblasTrans && M == X->size && N == Y->size))\n {\n dgemv (&aTransp, &INT (N), &INT (M), &alpha, A->data,\n &INT (A->tda), X->data, &INT (X->stride), &beta, Y->data,\n &INT (Y->stride));\n return GSL_SUCCESS;\n }\n else\n {\n GSL_ERROR (\"invalid length\", GSL_EBADLEN);\n }\n}\n\n\n/*\n * ===========================================================================\n * Prototypes for level 3 BLAS\n * ===========================================================================\n */\n\n\nint gsl_blas_dgemm (CBLAS_TRANSPOSE_t TransA, CBLAS_TRANSPOSE_t TransB,\n double alpha, const gsl_matrix * A, const gsl_matrix * B,\n double beta, gsl_matrix * C)\n{\n/**\n\tSince BLAS uses column major matrices, when asked to perform C = A*B we will\n\tactually compute C = B*A, with the number of rows and cols switched up.\n\t(C' = B' * A' if C = A * B, and we're working with transposes by default)\n\n\tThat's why we need to switch the order of the matrices as well as the order of M and N.\n\n*/\n\n const size_t M = C->size1;\n const size_t N = C->size2;\n const size_t MA = (TransA == CblasNoTrans) ? A->size1 : A->size2;\n const size_t NA = (TransA == CblasNoTrans) ? A->size2 : A->size1;\n const size_t MB = (TransB == CblasNoTrans) ? B->size1 : B->size2;\n const size_t NB = (TransB == CblasNoTrans) ? B->size2 : B->size1;\n\n char aTransp = (TransA == CblasNoTrans) ? 'N' : 'T';\n char bTransp = (TransB == CblasNoTrans) ? 'N' : 'T';\n\n if (M == MA && N == NB && NA == MB) /* [MxN] = [MAxNA][MBxNB] */\n {\n\t dgemm (&bTransp, &aTransp, &INT (N), &INT (M), &INT (NA),\n &alpha, B->data, &INT (B->tda), A->data, &INT (A->tda), &beta,\n C->data, &INT (C->tda));\n return GSL_SUCCESS;\n }\n else\n {\n GSL_ERROR (\"invalid length\", GSL_EBADLEN);\n }\n}\n\n", "meta": {"hexsha": "1d9a57c6233901507687aef73794171978c6eec4", "size": 5326, "ext": "c", "lang": "C", "max_stars_repo_path": "Cartwheel/cartwheel-3d/gsl/blas/blas.c", "max_stars_repo_name": "MontyThibault/centre-of-mass-awareness", "max_stars_repo_head_hexsha": "58778f148e65749e1dfc443043e9fc054ca3ff4d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Cartwheel/cartwheel-3d/gsl/blas/blas.c", "max_issues_repo_name": "MontyThibault/centre-of-mass-awareness", "max_issues_repo_head_hexsha": "58778f148e65749e1dfc443043e9fc054ca3ff4d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Cartwheel/cartwheel-3d/gsl/blas/blas.c", "max_forks_repo_name": "MontyThibault/centre-of-mass-awareness", "max_forks_repo_head_hexsha": "58778f148e65749e1dfc443043e9fc054ca3ff4d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.5147928994, "max_line_length": 191, "alphanum_fraction": 0.5692827638, "num_tokens": 1504, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.808067204308405, "lm_q2_score": 0.6757645944891559, "lm_q1q2_score": 0.5460632066394552}} {"text": "/* linalg/hermtd.c\n * \n * Copyright (C) 2001, 2007, 2009 Brian Gough\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n/* Factorise a hermitian matrix A into\n *\n * A = U T U'\n *\n * where U is unitary and T is real symmetric tridiagonal. Only the\n * diagonal and lower triangular part of A is referenced and modified.\n *\n * On exit, T is stored in the diagonal and first subdiagonal of\n * A. Since T is symmetric the upper diagonal is not stored.\n *\n * U is stored as a packed set of Householder transformations in the\n * lower triangular part of the input matrix below the first subdiagonal.\n *\n * The full matrix for U can be obtained as the product\n *\n * U = U_N ... U_2 U_1\n *\n * where \n *\n * U_i = (I - tau_i * v_i * v_i')\n *\n * and where v_i is a Householder vector\n *\n * v_i = [0, ..., 0, 1, A(i+2,i), A(i+3,i), ... , A(N,i)]\n *\n * This storage scheme is the same as in LAPACK. See LAPACK's\n * chetd2.f for details.\n *\n * See Golub & Van Loan, \"Matrix Computations\" (3rd ed), Section 8.3 */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\nint \ngsl_linalg_hermtd_decomp (gsl_matrix_complex * A, gsl_vector_complex * tau) \n{\n if (A->size1 != A->size2)\n {\n GSL_ERROR (\"hermitian tridiagonal decomposition requires square matrix\",\n GSL_ENOTSQR);\n }\n else if (tau->size + 1 != A->size1)\n {\n GSL_ERROR (\"size of tau must be (matrix size - 1)\", GSL_EBADLEN);\n }\n else\n {\n const size_t N = A->size1;\n size_t i;\n \n const gsl_complex zero = gsl_complex_rect (0.0, 0.0);\n const gsl_complex one = gsl_complex_rect (1.0, 0.0);\n const gsl_complex neg_one = gsl_complex_rect (-1.0, 0.0);\n\n for (i = 0 ; i < N - 1; i++)\n {\n gsl_vector_complex_view c = gsl_matrix_complex_column (A, i);\n gsl_vector_complex_view v = gsl_vector_complex_subvector (&c.vector, i + 1, N - (i + 1));\n gsl_complex tau_i = gsl_linalg_complex_householder_transform (&v.vector);\n \n /* Apply the transformation H^T A H to the remaining columns */\n\n if ((i + 1) < (N - 1) \n && !(GSL_REAL(tau_i) == 0.0 && GSL_IMAG(tau_i) == 0.0)) \n {\n gsl_matrix_complex_view m = \n gsl_matrix_complex_submatrix (A, i + 1, i + 1, \n N - (i+1), N - (i+1));\n gsl_complex ei = gsl_vector_complex_get(&v.vector, 0);\n gsl_vector_complex_view x = gsl_vector_complex_subvector (tau, i, N-(i+1));\n gsl_vector_complex_set (&v.vector, 0, one);\n \n /* x = tau * A * v */\n gsl_blas_zhemv (CblasLower, tau_i, &m.matrix, &v.vector, zero, &x.vector);\n\n /* w = x - (1/2) tau * (x' * v) * v */\n {\n gsl_complex xv, txv, alpha;\n gsl_blas_zdotc(&x.vector, &v.vector, &xv);\n txv = gsl_complex_mul(tau_i, xv);\n alpha = gsl_complex_mul_real(txv, -0.5);\n gsl_blas_zaxpy(alpha, &v.vector, &x.vector);\n }\n \n /* apply the transformation A = A - v w' - w v' */\n gsl_blas_zher2(CblasLower, neg_one, &v.vector, &x.vector, &m.matrix);\n\n gsl_vector_complex_set (&v.vector, 0, ei);\n }\n \n gsl_vector_complex_set (tau, i, tau_i);\n }\n \n return GSL_SUCCESS;\n }\n} \n\n\n/* Form the orthogonal matrix U from the packed QR matrix */\n\nint\ngsl_linalg_hermtd_unpack (const gsl_matrix_complex * A, \n const gsl_vector_complex * tau,\n gsl_matrix_complex * U, \n gsl_vector * diag, \n gsl_vector * sdiag)\n{\n if (A->size1 != A->size2)\n {\n GSL_ERROR (\"matrix A must be sqaure\", GSL_ENOTSQR);\n }\n else if (tau->size + 1 != A->size1)\n {\n GSL_ERROR (\"size of tau must be (matrix size - 1)\", GSL_EBADLEN);\n }\n else if (U->size1 != A->size1 || U->size2 != A->size1)\n {\n GSL_ERROR (\"size of U must match size of A\", GSL_EBADLEN);\n }\n else if (diag->size != A->size1)\n {\n GSL_ERROR (\"size of diagonal must match size of A\", GSL_EBADLEN);\n }\n else if (sdiag->size + 1 != A->size1)\n {\n GSL_ERROR (\"size of subdiagonal must be (matrix size - 1)\", GSL_EBADLEN);\n }\n else\n {\n const size_t N = A->size1;\n\n size_t i;\n\n /* Initialize U to the identity */\n\n gsl_matrix_complex_set_identity (U);\n\n for (i = N - 1; i-- > 0;)\n {\n gsl_complex ti = gsl_vector_complex_get (tau, i);\n\n gsl_vector_complex_const_view c = gsl_matrix_complex_const_column (A, i);\n\n gsl_vector_complex_const_view h = \n gsl_vector_complex_const_subvector (&c.vector, i + 1, N - (i+1));\n\n gsl_matrix_complex_view m = \n gsl_matrix_complex_submatrix (U, i + 1, i + 1, N-(i+1), N-(i+1));\n\n gsl_linalg_complex_householder_hm (ti, &h.vector, &m.matrix);\n }\n\n /* Copy diagonal into diag */\n\n for (i = 0; i < N; i++)\n {\n gsl_complex Aii = gsl_matrix_complex_get (A, i, i);\n gsl_vector_set (diag, i, GSL_REAL(Aii));\n }\n\n /* Copy subdiagonal into sdiag */\n\n for (i = 0; i < N - 1; i++)\n {\n gsl_complex Aji = gsl_matrix_complex_get (A, i+1, i);\n gsl_vector_set (sdiag, i, GSL_REAL(Aji));\n }\n\n return GSL_SUCCESS;\n }\n}\n\nint\ngsl_linalg_hermtd_unpack_T (const gsl_matrix_complex * A, \n gsl_vector * diag, \n gsl_vector * sdiag)\n{\n if (A->size1 != A->size2)\n {\n GSL_ERROR (\"matrix A must be sqaure\", GSL_ENOTSQR);\n }\n else if (diag->size != A->size1)\n {\n GSL_ERROR (\"size of diagonal must match size of A\", GSL_EBADLEN);\n }\n else if (sdiag->size + 1 != A->size1)\n {\n GSL_ERROR (\"size of subdiagonal must be (matrix size - 1)\", GSL_EBADLEN);\n }\n else\n {\n const size_t N = A->size1;\n\n size_t i;\n\n /* Copy diagonal into diag */\n\n for (i = 0; i < N; i++)\n {\n gsl_complex Aii = gsl_matrix_complex_get (A, i, i);\n gsl_vector_set (diag, i, GSL_REAL(Aii));\n }\n\n /* Copy subdiagonal into sd */\n\n for (i = 0; i < N - 1; i++)\n {\n gsl_complex Aji = gsl_matrix_complex_get (A, i+1, i);\n gsl_vector_set (sdiag, i, GSL_REAL(Aji));\n }\n\n return GSL_SUCCESS;\n }\n}\n", "meta": {"hexsha": "3660e96a4f3d3ee3aded5b17b2d88601bf1a8c44", "size": 7326, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.4/linalg/hermtd.c", "max_stars_repo_name": "peterahrens/FillEstimationIPDPS2017", "max_stars_repo_head_hexsha": "857b6ee8866a2950aa5721d575d2d7d0797c4302", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-12-18T18:09:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-10T11:31:28.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/linalg/hermtd.c", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/linalg/hermtd.c", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 14.0, "max_forks_repo_forks_event_min_datetime": "2015-07-21T04:47:52.000Z", "max_forks_repo_forks_event_max_datetime": "2020-03-12T12:31:25.000Z", "avg_line_length": 30.398340249, "max_line_length": 99, "alphanum_fraction": 0.5685230685, "num_tokens": 2056, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7956581000631542, "lm_q2_score": 0.6859494485880928, "lm_q1q2_score": 0.5457812350029702}} {"text": "#include \n#include \n#include \n\n#include \n#include \n\n#include \"../include/run_svd.h\"\n\nint main(void) {\n FILE *fp = fopen(\"./data/my_data.csv\", \"r\");\n if (fp == NULL) {\n perror(\"Unable to open file!\");\n\n exit(1);\n }\n int m = 4;\n int n = 5;\n\n char chunk[128];\n\n const char s[2] = \",\";\n int i = 0;\n int j = 0;\n gsl_matrix *mat = gsl_matrix_alloc(m, n);\n while (fgets(chunk, sizeof(chunk), fp) != NULL) {\n char *token;\n\n token = strtok(chunk, s);\n while (token != NULL) {\n double x = atof(token);\n gsl_matrix_set(mat, i, j, x);\n\n j = (j + 1) % n;\n if (j == 0) {\n i = (i + 1) % m;\n }\n\n token = strtok(NULL, s);\n }\n }\n printf(\"a_matrix\\n\");\n pretty_print(mat);\n\n int result = run_svd(mat);\n\n fclose(fp);\n\n return result;\n}\n", "meta": {"hexsha": "abf2bfbe9b406bf294c2e5d08cb2af19937923e9", "size": 867, "ext": "c", "lang": "C", "max_stars_repo_path": "src/c/src/project.c", "max_stars_repo_name": "paul-reiners/getting-smaller", "max_stars_repo_head_hexsha": "c1b9f0a0e72d7f92b9ce84aa111c063efcac1241", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/c/src/project.c", "max_issues_repo_name": "paul-reiners/getting-smaller", "max_issues_repo_head_hexsha": "c1b9f0a0e72d7f92b9ce84aa111c063efcac1241", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/c/src/project.c", "max_forks_repo_name": "paul-reiners/getting-smaller", "max_forks_repo_head_hexsha": "c1b9f0a0e72d7f92b9ce84aa111c063efcac1241", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 17.0, "max_line_length": 51, "alphanum_fraction": 0.5340253749, "num_tokens": 274, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8031737869342624, "lm_q2_score": 0.679178699175393, "lm_q1q2_score": 0.5454985278217866}} {"text": "#include \n#include \n\nvoid\nprint_all_multisets ( size_t n, size_t k );\n\nint\nmain (void)\n{\n gsl_multiset * c;\n size_t i;\n\n printf(\"all multisets of {0,1,2,3} by size (lex. order)\\n\") ;\n for(i = 0; i <= 4; i++)\n {\n c = gsl_multiset_calloc (4, i);\n do\n {\n printf(\"{\");\n gsl_multiset_fprintf (stdout, c, \" %u\");\n printf(\" }\\n\");\n }\n while (gsl_multiset_next(c) == GSL_SUCCESS);\n gsl_multiset_free(c);\n }\n printf(\"all multisets of {1,2,3,4} by size (reverse lex. order)\\n\") ;\n for(i = 0; i <= 4; i++)\n {\n c = gsl_multiset_alloc (4, i) ;\n gsl_multiset_init_last(c) ;\n do\n {\n printf(\"{\");\n gsl_multiset_fprintf (stdout, c, \" %u\");\n printf(\" }\\n\");\n }\n while (gsl_multiset_prev(c) == GSL_SUCCESS);\n gsl_multiset_free(c);\n }\n printf(\"\\n\");\n\n print_all_multisets(5, 3);\n print_all_multisets(5, 0);\n print_all_multisets(5, 5);\n print_all_multisets(1, 1);\n print_all_multisets(3, 1);\n\n return 0;\n}\n\nvoid\nprint_all_multisets (size_t n, size_t k)\n{\n gsl_multiset * c = gsl_multiset_calloc (n, k);\n\n printf(\"multisets %u choose %u (with replacement)\\n\", n, k);\n do\n {\n gsl_multiset_fprintf (stdout, c, \" %u\");\n printf(\"\\n\");\n }\n while (gsl_multiset_next(c) == GSL_SUCCESS);\n while (gsl_multiset_next(c) == GSL_SUCCESS);\n do\n {\n gsl_multiset_fprintf (stdout, c, \" %u\");\n printf(\"\\n\");\n }\n while (gsl_multiset_prev(c) == GSL_SUCCESS);\n printf(\"\\n\");\n gsl_multiset_free(c);\n}\n", "meta": {"hexsha": "3c4749ad945bc3160a4e6d3467045777734f93cf", "size": 1579, "ext": "c", "lang": "C", "max_stars_repo_path": "Chimera/3rd_Party/GSL_MSVC/multiset/demo.c", "max_stars_repo_name": "zzpwahaha/Chimera-Control-Trim", "max_stars_repo_head_hexsha": "df1bbf6bea0b87b8c7c9a99dce213fdc249118f2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-06-14T11:51:37.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-14T11:51:37.000Z", "max_issues_repo_path": "Chimera/3rd_Party/GSL_MSVC/multiset/demo.c", "max_issues_repo_name": "zzpwahaha/Chimera-Control-Trim", "max_issues_repo_head_hexsha": "df1bbf6bea0b87b8c7c9a99dce213fdc249118f2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Chimera/3rd_Party/GSL_MSVC/multiset/demo.c", "max_forks_repo_name": "zzpwahaha/Chimera-Control-Trim", "max_forks_repo_head_hexsha": "df1bbf6bea0b87b8c7c9a99dce213fdc249118f2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-01-20T16:22:57.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-14T12:31:02.000Z", "avg_line_length": 21.6301369863, "max_line_length": 71, "alphanum_fraction": 0.5655478151, "num_tokens": 515, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.746138993030751, "lm_q2_score": 0.7310585786300049, "lm_q1q2_score": 0.545471311705484}} {"text": "/* multimin/vector_bfgs2.c\n * \n * Copyright (C) 2007 Brian Gough\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 2 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA\n * 02110-1301, USA.\n */\n\n/* vector_bfgs2.c -- Fletcher's implementation of the BFGS method,\n from R.Fletcher, \"Practical Method's of Optimization\", Second\n Edition, ISBN 0471915475. Algorithms 2.6.2 and 2.6.4. */\n\n/* Thanks to Alan Irwin irwin@beluga.phys.uvic.ca. for suggesting this\n algorithm and providing sample fortran benchmarks */\n\n#include \n#include \n#include \n\n#include \"linear_minimize.c\"\n#include \"linear_wrapper.c\"\n\ntypedef struct\n{\n int iter;\n double step;\n double g0norm;\n double pnorm;\n double delta_f;\n double fp0; /* f'(0) for f(x-alpha*p) */\n gsl_vector *x0;\n gsl_vector *g0;\n gsl_vector *p;\n /* work space */\n gsl_vector *dx0;\n gsl_vector *dg0;\n gsl_vector *x_alpha;\n gsl_vector *g_alpha;\n /* wrapper function */\n wrapper_t wrap;\n /* minimization parameters */\n double rho;\n double sigma;\n double tau1;\n double tau2;\n double tau3;\n int order;\n}\nvector_bfgs2_state_t;\n\nstatic int\nvector_bfgs2_alloc (void *vstate, size_t n)\n{\n vector_bfgs2_state_t *state = (vector_bfgs2_state_t *) vstate;\n\n state->p = gsl_vector_calloc (n);\n\n if (state->p == 0)\n {\n GSL_ERROR (\"failed to allocate space for p\", GSL_ENOMEM);\n }\n\n state->x0 = gsl_vector_calloc (n);\n\n if (state->x0 == 0)\n {\n gsl_vector_free (state->p);\n GSL_ERROR (\"failed to allocate space for g0\", GSL_ENOMEM);\n }\n\n state->g0 = gsl_vector_calloc (n);\n\n if (state->g0 == 0)\n {\n gsl_vector_free (state->x0);\n gsl_vector_free (state->p);\n GSL_ERROR (\"failed to allocate space for g0\", GSL_ENOMEM);\n }\n\n state->dx0 = gsl_vector_calloc (n);\n\n if (state->dx0 == 0)\n {\n gsl_vector_free (state->g0);\n gsl_vector_free (state->x0);\n gsl_vector_free (state->p);\n GSL_ERROR (\"failed to allocate space for g0\", GSL_ENOMEM);\n }\n\n state->dg0 = gsl_vector_calloc (n);\n\n if (state->dg0 == 0)\n {\n gsl_vector_free (state->dx0);\n gsl_vector_free (state->g0);\n gsl_vector_free (state->x0);\n gsl_vector_free (state->p);\n GSL_ERROR (\"failed to allocate space for g0\", GSL_ENOMEM);\n }\n\n state->x_alpha = gsl_vector_calloc (n);\n\n if (state->x_alpha == 0)\n {\n gsl_vector_free (state->dg0);\n gsl_vector_free (state->dx0);\n gsl_vector_free (state->g0);\n gsl_vector_free (state->x0);\n gsl_vector_free (state->p);\n GSL_ERROR (\"failed to allocate space for g0\", GSL_ENOMEM);\n }\n\n state->g_alpha = gsl_vector_calloc (n);\n\n if (state->g_alpha == 0)\n {\n gsl_vector_free (state->x_alpha);\n gsl_vector_free (state->dg0);\n gsl_vector_free (state->dx0);\n gsl_vector_free (state->g0);\n gsl_vector_free (state->x0);\n gsl_vector_free (state->p);\n GSL_ERROR (\"failed to allocate space for g0\", GSL_ENOMEM);\n }\n\n return GSL_SUCCESS;\n}\n\nstatic int\nvector_bfgs2_set (void *vstate, gsl_multimin_function_fdf * fdf,\n const gsl_vector * x, double *f, gsl_vector * gradient,\n double step_size, double tol)\n{\n vector_bfgs2_state_t *state = (vector_bfgs2_state_t *) vstate;\n\n state->iter = 0;\n state->step = step_size;\n state->delta_f = 0;\n\n GSL_MULTIMIN_FN_EVAL_F_DF (fdf, x, f, gradient);\n\n /* Use the gradient as the initial direction */\n\n gsl_vector_memcpy (state->x0, x);\n gsl_vector_memcpy (state->g0, gradient);\n state->g0norm = gsl_blas_dnrm2 (state->g0);\n\n gsl_vector_memcpy (state->p, gradient);\n gsl_blas_dscal (-1 / state->g0norm, state->p);\n state->pnorm = gsl_blas_dnrm2 (state->p); /* should be 1 */\n state->fp0 = -state->g0norm;\n\n /* Prepare the wrapper */\n\n prepare_wrapper (&state->wrap, fdf,\n state->x0, *f, state->g0,\n state->p, state->x_alpha, state->g_alpha);\n\n /* Prepare 1d minimisation parameters */\n\n state->rho = 0.01;\n state->sigma = tol;\n state->tau1 = 9;\n state->tau2 = 0.05;\n state->tau3 = 0.5;\n state->order = 3; /* use cubic interpolation where possible */\n\n return GSL_SUCCESS;\n}\n\nstatic void\nvector_bfgs2_free (void *vstate)\n{\n vector_bfgs2_state_t *state = (vector_bfgs2_state_t *) vstate;\n\n gsl_vector_free (state->x_alpha);\n gsl_vector_free (state->g_alpha);\n gsl_vector_free (state->dg0);\n gsl_vector_free (state->dx0);\n gsl_vector_free (state->g0);\n gsl_vector_free (state->x0);\n gsl_vector_free (state->p);\n}\n\nstatic int\nvector_bfgs2_restart (void *vstate)\n{\n vector_bfgs2_state_t *state = (vector_bfgs2_state_t *) vstate;\n\n state->iter = 0;\n return GSL_SUCCESS;\n}\n\nstatic int\nvector_bfgs2_iterate (void *vstate, gsl_multimin_function_fdf * fdf,\n gsl_vector * x, double *f,\n gsl_vector * gradient, gsl_vector * dx)\n{\n vector_bfgs2_state_t *state = (vector_bfgs2_state_t *) vstate;\n double alpha = 0.0, alpha1;\n gsl_vector *x0 = state->x0;\n gsl_vector *g0 = state->g0;\n gsl_vector *p = state->p;\n\n double g0norm = state->g0norm;\n double pnorm = state->pnorm;\n double delta_f = state->delta_f;\n double pg, dir;\n int status;\n\n double f0 = *f;\n\n if (pnorm == 0.0 || g0norm == 0.0 || state->fp0 == 0)\n {\n gsl_vector_set_zero (dx);\n return GSL_ENOPROG;\n }\n\n if (delta_f < 0)\n {\n double del = GSL_MAX_DBL (-delta_f, 10 * GSL_DBL_EPSILON * fabs(f0));\n alpha1 = GSL_MIN_DBL (1.0, 2.0 * del / (-state->fp0));\n }\n else\n {\n alpha1 = fabs(state->step);\n }\n\n /* line minimisation, with cubic interpolation (order = 3) */\n\n status = minimize (&state->wrap.fdf_linear, state->rho, state->sigma, \n state->tau1, state->tau2, state->tau3, state->order,\n alpha1, &alpha);\n\n if (status != GSL_SUCCESS)\n {\n return status;\n }\n\n update_position (&(state->wrap), alpha, x, f, gradient);\n \n state->delta_f = *f - f0;\n\n /* Choose a new direction for the next step */\n\n {\n /* This is the BFGS update: */\n /* p' = g1 - A dx - B dg */\n /* A = - (1+ dg.dg/dx.dg) B + dg.g/dx.dg */\n /* B = dx.g/dx.dg */\n\n gsl_vector *dx0 = state->dx0;\n gsl_vector *dg0 = state->dg0;\n\n double dxg, dgg, dxdg, dgnorm, A, B;\n\n /* dx0 = x - x0 */\n gsl_vector_memcpy (dx0, x);\n gsl_blas_daxpy (-1.0, x0, dx0);\n\n gsl_vector_memcpy (dx, dx0); /* keep a copy */\n\n /* dg0 = g - g0 */\n gsl_vector_memcpy (dg0, gradient);\n gsl_blas_daxpy (-1.0, g0, dg0);\n\n gsl_blas_ddot (dx0, gradient, &dxg);\n gsl_blas_ddot (dg0, gradient, &dgg);\n gsl_blas_ddot (dx0, dg0, &dxdg);\n\n dgnorm = gsl_blas_dnrm2 (dg0);\n\n if (dxdg != 0)\n {\n B = dxg / dxdg;\n A = -(1.0 + dgnorm * dgnorm / dxdg) * B + dgg / dxdg;\n }\n else\n {\n B = 0;\n A = 0;\n }\n\n gsl_vector_memcpy (p, gradient);\n gsl_blas_daxpy (-A, dx0, p);\n gsl_blas_daxpy (-B, dg0, p);\n }\n\n gsl_vector_memcpy (g0, gradient);\n gsl_vector_memcpy (x0, x);\n state->g0norm = gsl_blas_dnrm2 (g0);\n state->pnorm = gsl_blas_dnrm2 (p);\n\n /* update direction and fp0 */\n\n gsl_blas_ddot (p, gradient, &pg);\n dir = (pg >= 0.0) ? -1.0 : +1.0;\n gsl_blas_dscal (dir / state->pnorm, p);\n state->pnorm = gsl_blas_dnrm2 (p);\n gsl_blas_ddot (p, g0, &state->fp0);\n\n change_direction (&state->wrap);\n\n return GSL_SUCCESS;\n}\n\nstatic const gsl_multimin_fdfminimizer_type vector_bfgs2_type = {\n \"vector_bfgs2\", /* name */\n sizeof (vector_bfgs2_state_t),\n &vector_bfgs2_alloc,\n &vector_bfgs2_set,\n &vector_bfgs2_iterate,\n &vector_bfgs2_restart,\n &vector_bfgs2_free\n};\n\nconst gsl_multimin_fdfminimizer_type\n * gsl_multimin_fdfminimizer_vector_bfgs2 = &vector_bfgs2_type;\n", "meta": {"hexsha": "d4f5cb3d6ca676305a6b520fe327d4709459f232", "size": 8363, "ext": "c", "lang": "C", "max_stars_repo_path": "pkgs/libs/gsl/src/multimin/vector_bfgs2.c", "max_stars_repo_name": "manggoguy/parsec-modified", "max_stars_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 64.0, "max_stars_repo_stars_event_min_datetime": "2015-03-06T00:30:56.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-24T13:26:53.000Z", "max_issues_repo_path": "pkgs/libs/gsl/src/multimin/vector_bfgs2.c", "max_issues_repo_name": "manggoguy/parsec-modified", "max_issues_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 12.0, "max_issues_repo_issues_event_min_datetime": "2020-12-15T08:30:19.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-13T03:54:24.000Z", "max_forks_repo_path": "pkgs/libs/gsl/src/multimin/vector_bfgs2.c", "max_forks_repo_name": "manggoguy/parsec-modified", "max_forks_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 40.0, "max_forks_repo_forks_event_min_datetime": "2015-02-26T15:31:16.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-03T23:23:37.000Z", "avg_line_length": 25.2658610272, "max_line_length": 75, "alphanum_fraction": 0.6361353581, "num_tokens": 2630, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7490872019117029, "lm_q2_score": 0.7279754371026367, "lm_q1q2_score": 0.545317083239663}} {"text": "// @Copyright 2007-2017 Kristjan Haule\n#include \n#include \n#include \"smesh.h\"\n\nstruct rparams{\n double x0, L;\n int Nw;\n};\n\nint tanmesh_f(const gsl_vector* x, void* params, gsl_vector* f){\n double x0 = ((struct rparams *) params)->x0;\n double L = ((struct rparams *) params)->L;\n int Nw = ((struct rparams *) params)->Nw;\n const double d = gsl_vector_get (x, 0);\n const double w = gsl_vector_get (x, 1);\n gsl_vector_set (f, 0, L-w/tan(d) );\n gsl_vector_set (f, 1, x0-w*tan(M_PI/(2*Nw)-d/Nw) );\n return GSL_SUCCESS;\n}\n\ntypedef int (*gsl_FNC)(const gsl_vector * x, void * params, gsl_vector * f);\n\nclass FindRoot{\n const gsl_multiroot_fsolver_type *T;\n gsl_multiroot_fsolver *s;\n size_t n;\n void* params;\n gsl_vector *x;\n gsl_multiroot_function f;\npublic:\n FindRoot(size_t n_, gsl_FNC fnc, double x_init[], void* params_) : n(n_), params(params_)\n {\n x = gsl_vector_alloc (n);\n f.f = fnc;\n f.n = n;\n f.params = params;\n for (int i=0; ix,i)<<\" \";\n clog<<\" f(x)=\";\n for (int i=0; if,i)<<\" \";\n clog< call(){\n size_t i, iter = 0;\n //print_state (iter, s);\n int status;\n do{\n iter++;\n status = gsl_multiroot_fsolver_iterate (s);\n //print_state (iter, s);\n if (status) /* check if solver is stuck */\n\tbreak;\n status = gsl_multiroot_test_residual (s->f, 1e-7);\n } while (status == GSL_CONTINUE && iter < 1000);\n //clog<<\"status = \"< res(n);\n for (int i=0; ix, i);\n return res;\n }\n ~FindRoot(){\n gsl_multiroot_fsolver_free (s);\n gsl_vector_free (x);\n }\n};\n\n\ndouble sqr(double x){return x*x;}\n\nvoid GiveTanMesh(mesh1D& om, double& x0, double L, int Nw)\n{\n double tnw = tan(M_PI/(2*Nw));\n if (x0 > L*0.25*Nw*sqr(tnw) ){\n x0 = L*0.25*Nw*sqr(tnw)-1e-15;\n }\n double d0 = Nw/2.*( tnw - sqrt( sqr(tnw) - 4*x0/(L*Nw)));\n double w0 = L*d0;\n double x_init[2] = {d0, w0};\n struct rparams p = {x0,L,Nw};\n\n FindRoot fr(2, &tanmesh_f, x_init, &p);\n vector dw = fr.call();\n double d = dw[0];\n double w = dw[1];\n \n om.resize(2*Nw+1);\n double dh = 1.0/static_cast(2*Nw);\n for (int i=0; i<2*Nw+1; i++){\n double t0 = i/static_cast(2*Nw);\n double t = t0*(M_PI-2*d) - M_PI/2 + d;\n om[i] = w*tan(t);\n om.Dh(i) = dh*w*(M_PI-2*d)/sqr(cos(t));\n }\n \n om.Delta(0) = 1.0/(om[1]-om[0]);\n for (int i=1; i\n#include \n\nint\nmain (void)\n{\n int i, n = 4;\n double x[4] = { 1970, 1980, 1990, 2000 };\n double y[4] = { 12, 11, 14, 13 };\n double w[4] = { 0.1, 0.2, 0.3, 0.4 };\n\n double c0, c1, cov00, cov01, cov11, chisq;\n\n gsl_fit_wlinear (x, 1, w, 1, y, 1, n, \n &c0, &c1, &cov00, &cov01, &cov11, \n &chisq);\n\n printf (\"# best fit: Y = %g + %g X\\n\", c0, c1);\n printf (\"# covariance matrix:\\n\");\n printf (\"# [ %g, %g\\n# %g, %g]\\n\", \n cov00, cov01, cov01, cov11);\n printf (\"# chisq = %g\\n\", chisq);\n\n for (i = 0; i < n; i++)\n printf (\"data: %g %g %g\\n\", \n x[i], y[i], 1/sqrt(w[i]));\n\n printf (\"\\n\");\n\n for (i = -30; i < 130; i++)\n {\n double xf = x[0] + (i/100.0) * (x[n-1] - x[0]);\n double yf, yf_err;\n\n gsl_fit_linear_est (xf, \n c0, c1, \n cov00, cov01, cov11, \n &yf, &yf_err);\n\n printf (\"fit: %g %g\\n\", xf, yf);\n printf (\"hi : %g %g\\n\", xf, yf + yf_err);\n printf (\"lo : %g %g\\n\", xf, yf - yf_err);\n }\n return 0;\n}\n", "meta": {"hexsha": "5c3696971028b093ea6d806deed68fed1089dfc0", "size": 1136, "ext": "c", "lang": "C", "max_stars_repo_path": "pkgs/libs/gsl/src/doc/examples/fitting.c", "max_stars_repo_name": "manggoguy/parsec-modified", "max_stars_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 64.0, "max_stars_repo_stars_event_min_datetime": "2015-03-06T00:30:56.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-24T13:26:53.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/doc/examples/fitting.c", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 12.0, "max_issues_repo_issues_event_min_datetime": "2020-12-15T08:30:19.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-13T03:54:24.000Z", "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/doc/examples/fitting.c", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 40.0, "max_forks_repo_forks_event_min_datetime": "2015-02-26T15:31:16.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-03T23:23:37.000Z", "avg_line_length": 24.6956521739, "max_line_length": 53, "alphanum_fraction": 0.4154929577, "num_tokens": 469, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7905303087996143, "lm_q2_score": 0.6893056167854461, "lm_q1q2_score": 0.5449169820947073}} {"text": "#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n\nint\nmain(void)\n{\n const size_t N = 1000; /* length of time series */\n const size_t K = 25; /* window size */\n const double t = 4.0; /* number of scale factors for outlier detection */\n gsl_vector *x = gsl_vector_alloc(N); /* input vector */\n gsl_vector *y = gsl_vector_alloc(N); /* output (filtered) vector */\n gsl_vector *xmedian = gsl_vector_alloc(N); /* window medians */\n gsl_vector *xsigma = gsl_vector_alloc(N); /* window scale estimates */\n gsl_vector_int *ioutlier = gsl_vector_int_alloc(N); /* outlier detected? */\n gsl_filter_impulse_workspace * w = gsl_filter_impulse_alloc(K);\n gsl_rng *r = gsl_rng_alloc(gsl_rng_default);\n size_t noutlier;\n size_t i;\n\n /* generate input signal */\n for (i = 0; i < N; ++i)\n {\n double xi = 10.0 * sin(2.0 * M_PI * i / (double) N);\n double ei = gsl_ran_gaussian(r, 2.0);\n double u = gsl_rng_uniform(r);\n double outlier = (u < 0.01) ? 15.0*GSL_SIGN(ei) : 0.0;\n\n gsl_vector_set(x, i, xi + ei + outlier);\n }\n\n /* apply impulse detection filter */\n gsl_filter_impulse(GSL_FILTER_END_TRUNCATE, GSL_FILTER_SCALE_QN, t, x, y,\n xmedian, xsigma, &noutlier, ioutlier, w);\n\n /* print results */\n for (i = 0; i < N; ++i)\n {\n double xi = gsl_vector_get(x, i);\n double yi = gsl_vector_get(y, i);\n double xmedi = gsl_vector_get(xmedian, i);\n double xsigmai = gsl_vector_get(xsigma, i);\n int outlier = gsl_vector_int_get(ioutlier, i);\n\n printf(\"%zu %f %f %f %f %d\\n\",\n i,\n xi,\n yi,\n xmedi + t * xsigmai,\n xmedi - t * xsigmai,\n outlier);\n }\n\n gsl_vector_free(x);\n gsl_vector_free(y);\n gsl_vector_free(xmedian);\n gsl_vector_free(xsigma);\n gsl_vector_int_free(ioutlier);\n gsl_filter_impulse_free(w);\n gsl_rng_free(r);\n\n return 0;\n}\n", "meta": {"hexsha": "6a81193fac0a0873a4aa5b1262a584cb0455fc60", "size": 2166, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.6/doc/examples/impulse.c", "max_stars_repo_name": "ielomariala/Hex-Game", "max_stars_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-06-14T11:51:37.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-14T11:51:37.000Z", "max_issues_repo_path": "gsl-2.6/doc/examples/impulse.c", "max_issues_repo_name": "ielomariala/Hex-Game", "max_issues_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-12-16T17:41:24.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-22T00:00:16.000Z", "max_forks_repo_path": "test/lib/gsl-2.6/doc/examples/impulse.c", "max_forks_repo_name": "karanbirsandhu/nu-sense", "max_forks_repo_head_hexsha": "83fd1fc4cbd053a4f9b673d5cd5841823ddd4d8b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-01-20T16:22:57.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-14T12:31:02.000Z", "avg_line_length": 31.3913043478, "max_line_length": 106, "alphanum_fraction": 0.5817174515, "num_tokens": 605, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8104789178257653, "lm_q2_score": 0.6723317057447908, "lm_q1q2_score": 0.544910673291989}} {"text": "#include \n#include \n\n#include \n#include \n\n#define N (4096*4*16)\n\ndouble g (double *x, int dim);\n\nint\nmain (void)\n{\n double sum;\n double s = 12.;\n int dim = 4;\n double x[4];\n\n gsl_rng *r;\n\n r = gsl_rng_alloc (gsl_rng_taus2);\n gsl_rng_set (r, 1UL);\n\n long i, j, nn;\n\n printf (\"# Iter Npoints Volume AbsErr\\n\");\n nn = N;\n for (j = 0; j < 16; j++)\n {\n sum = 0.;\n for (i = 0; i < nn; i++)\n\t{\n\t // 4-dimensional random point\n\t for (int k = 0; k < dim; k++)\n\t {\n\t x[k] = s * gsl_rng_uniform (r) - s / 2;\n\t }\n\t sum += g (x, dim);\n\t}\n double integ = (sum * pow (s, (double) dim)) / nn;\n double exact = M_PI * M_PI;\n\n printf (\"%3ld %16ld %f %f\\n\", j, nn, integ, fabs (exact - integ));\n nn *= 2;\n }\n\n gsl_rng_free (r);\n\n return 0;\n}\n\ndouble\ng (double *x, int dim)\n{\n double r2 = 0., q;\n\n for (int i = 0; i < dim; i++)\n {\n q = x[i];\n r2 += q * q;\n }\n\n return exp (-r2);\n}\n", "meta": {"hexsha": "c6e656d9f0774f7b8bddff576b55770532fe8e47", "size": 1014, "ext": "c", "lang": "C", "max_stars_repo_path": "gaussian.c", "max_stars_repo_name": "jlichtman13/fin2", "max_stars_repo_head_hexsha": "25ce6ca213186edff973cae42a954e31947514a0", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "gaussian.c", "max_issues_repo_name": "jlichtman13/fin2", "max_issues_repo_head_hexsha": "25ce6ca213186edff973cae42a954e31947514a0", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "gaussian.c", "max_forks_repo_name": "jlichtman13/fin2", "max_forks_repo_head_hexsha": "25ce6ca213186edff973cae42a954e31947514a0", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 15.6, "max_line_length": 77, "alphanum_fraction": 0.4871794872, "num_tokens": 376, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.865224068675884, "lm_q2_score": 0.6297746143530797, "lm_q1q2_score": 0.5448961541793573}} {"text": "#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n\r\n#include \"com3.h\"\r\n\r\n// #define debugmode 1\r\nint unit_tests(void);\r\n\r\nconst int64_t comr = 2; // Radius of com filter in pixels\r\n// The filter will be (2*comr+1)^3 pixels\r\n\r\nint pointInDomain(int64_t * restrict Point, size_t * Domain, int nDim)\r\n // Check if a point is in the domain of a 3D image\r\n{\r\n for(int kk = 0; kk= (int64_t) Domain[kk])\r\n return 0;\r\n\r\n return 1;\r\n}\r\n\r\nint checkBounds(int64_t * restrict D, \r\n const size_t M, const size_t N, const size_t P)\r\n{\r\n if(D[0]>=comr && D[0]+comr<(int64_t) M &&\r\n D[1]>=comr && D[1]+comr<(int64_t) N &&\r\n D[2]>=comr && D[2]+comr<(int64_t) P)\r\n return 1; // ok\r\n\r\n return 0;\r\n}\r\n\r\nvoid com3_localw(double * restrict V, double * restrict W, const size_t M, const size_t N, const size_t P, \r\n int64_t * restrict D, double * restrict C)\r\n{\r\n\r\n#ifdef debugmode\r\n printf(\"D: [%u %u %u]\\n\", D[0], D[1], D[2]);\r\n printf(\"M: %lu N: %lu P: %lu\\n\", M, N, P);\r\n#endif\r\n\r\n double sum = 0;\r\n double dx = 0;\r\n double dy = 0;\r\n double dz = 0; \r\n\r\n#ifdef debugmode\r\n printf(\"sum: %f\\n\", sum);\r\n#endif\r\n\r\n if(checkBounds(D, M, N, P))\r\n {\r\n\r\n double val = V[D[0] + D[1]*M + D[2]*M*N];\r\n\r\n for(int kk = -comr; kk<=comr; kk++) {\r\n for(int ll = -comr; ll<=comr; ll++) {\r\n for(int mm = -comr; mm<=comr; mm++) {\r\n\r\n size_t pos = (D[0]+kk) + (D[1]+ll)*M + (D[2]+mm)*M*N;\r\n // printf(\"pos: %lu V[pos]: %f\\n\", pos, V[pos]);\r\n dx += kk*V[pos]*val/W[pos];\r\n dy += ll*V[pos]*val/W[pos];\r\n dz += mm*V[pos]*val/W[pos];\r\n\r\n sum += V[pos];\r\n } } }\r\n\r\n //printf(\"sum: %f\\n\", sum);\r\n }\r\n\r\n if(sum>0)\r\n {\r\n#ifdef debugmode\r\n printf(\"sum: %f (%f, %f, %f)\\n\", sum, dx, dy, dz);\r\n#endif\r\n C[0] = D[0] + dx/sum;\r\n C[1] = D[1] + dy/sum;\r\n C[2] = D[2] + dz/sum;\r\n }\r\n else\r\n {\r\n#ifdef debugmode\r\n printf(\"No com calculation\\n\");\r\n#endif\r\n C[0] = D[0];\r\n C[1] = D[1];\r\n C[2] = D[2];\r\n }\r\n}\r\n\r\nvoid com3_local(double * restrict V, const size_t M, const size_t N, const size_t P, \r\n int64_t * restrict D, double * restrict C)\r\n{\r\n\r\n#ifdef debugmode\r\n printf(\"D: [%u %u %u]\\n\", D[0], D[1], D[2]);\r\n printf(\"M: %lu N: %lu P: %lu\\n\", M, N, P);\r\n#endif\r\n\r\n double sum = 0;\r\n double dx = 0;\r\n double dy = 0;\r\n double dz = 0; \r\n\r\n#ifdef debugmode\r\n printf(\"sum: %f\\n\", sum);\r\n#endif\r\n\r\n if(checkBounds(D, M, N, P))\r\n {\r\n\r\n for(int kk = -comr; kk<=comr; kk++) {\r\n for(int ll = -comr; ll<=comr; ll++) {\r\n for(int mm = -comr; mm<=comr; mm++) {\r\n\r\n size_t pos = (D[0]+kk) + (D[1]+ll)*M + (D[2]+mm)*M*N;\r\n // printf(\"pos: %lu V[pos]: %f\\n\", pos, V[pos]);\r\n dx += kk*V[pos];\r\n dy += ll*V[pos];\r\n dz += mm*V[pos];\r\n\r\n sum += V[pos];\r\n } } }\r\n\r\n //printf(\"sum: %f\\n\", sum);\r\n }\r\n\r\n if(sum>0)\r\n {\r\n#ifdef debugmode\r\n printf(\"sum: %f (%f, %f, %f)\\n\", sum, dx, dy, dz);\r\n#endif\r\n C[0] = D[0] + dx/sum;\r\n C[1] = D[1] + dy/sum;\r\n C[2] = D[2] + dz/sum;\r\n }\r\n else\r\n {\r\n#ifdef debugmode\r\n printf(\"No com calculation\\n\");\r\n#endif\r\n C[0] = D[0];\r\n C[1] = D[1];\r\n C[2] = D[2];\r\n }\r\n}\r\n\r\nvoid setLmax(double *V, double * W, size_t * Domain, int64_t * Dot)\r\n // Adds V(dot) to all W within comr of dot\r\n // uses global value comr\r\n{\r\n uint32_t m = Dot[0];\r\n uint32_t n = Dot[1];\r\n uint32_t p = Dot[2];\r\n\r\n size_t M = Domain[0];\r\n size_t N = Domain[1];\r\n size_t P = Domain[2];\r\n\r\n double val = V[m + n*M + p*M*N];\r\n\r\n for(uint32_t pp = GSL_MAX(p-comr,0) ; pp<= GSL_MIN(p+comr, P-1) ; pp++) { \r\n for(uint32_t nn = GSL_MAX(n-comr,0) ; nn<= GSL_MIN(n+comr, N-1) ; nn++) {\r\n for(uint32_t mm = GSL_MAX(m-comr,0) ; mm<= GSL_MIN(m+comr, M-1) ; mm++) {\r\n W[mm + nn*M + pp*M*N] += val;\r\n }\r\n }\r\n }\r\n}\r\n\r\nvoid setWeights(double * V, double * W, size_t M, size_t N, size_t P, double * D, size_t nD)\r\n{\r\n size_t Domain[] = {M, N, P};\r\n int64_t Dot[] = {0,0,0};\r\n for(size_t kk = 0; kk \", kk, D[3*kk], D[3*kk+1], D[3*kk+2]);\r\n printf(\" [%f %f %f]\\n\", C[3*kk], C[3*kk+1], C[3*kk+2]);\r\n }\r\n\r\n free(C);\r\n free(D);\r\n free(V);\r\n\r\n return 0;\r\n}\r\n\r\nint main(int argc, char ** argv)\r\n{\r\n printf(\"%s\\n\", argv[0]);\r\n if(argc == 1)\r\n return unit_tests();\r\n}\r\n#endif\r\n", "meta": {"hexsha": "4eca838340c62baec965be7af61b832a353161e3", "size": 6913, "ext": "c", "lang": "C", "max_stars_repo_path": "common/mex/com3.c", "max_stars_repo_name": "elgw/dotter", "max_stars_repo_head_hexsha": "8fe0ab3610ff5473bccbac169795a0d1b72c1938", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-12-15T08:20:13.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-15T08:20:13.000Z", "max_issues_repo_path": "common/mex/com3.c", "max_issues_repo_name": "elgw/dotter", "max_issues_repo_head_hexsha": "8fe0ab3610ff5473bccbac169795a0d1b72c1938", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "common/mex/com3.c", "max_forks_repo_name": "elgw/dotter", "max_forks_repo_head_hexsha": "8fe0ab3610ff5473bccbac169795a0d1b72c1938", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 22.3, "max_line_length": 108, "alphanum_fraction": 0.4841602777, "num_tokens": 2612, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7826624688140726, "lm_q2_score": 0.6959583250334526, "lm_q1q2_score": 0.5447004608623888}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \"ellipsoid.h\"\n#include \"../sphere/sphere.h\"\n#include \"ellSolv.h\"\n\n\n#undef __FUNCT__\n#define __FUNCT__ \"InitEllipsoidalAndConvertPoints\"\nPetscErrorCode InitEllipsoidalAndConvertPoints(EllipsoidalSystem *e, PetscReal a, PetscReal b, PetscReal c, Vec xyz, Vec ell)\n{\n PetscErrorCode ierr;\n PetscLogEvent initEvent;\n PetscFunctionBegin;\n\n ierr = PetscLogEventRegister(\"Init ellipsoidal system\", 0, &initEvent);CHKERRQ(ierr);\n ierr = PetscLogEventBegin(initEvent, 0, 0, 0, 0);CHKERRQ(ierr);\n ierr = initEllipsoidalSystem(e, a, b, c, 32);CHKERRQ(ierr);\n ierr = PetscLogEventEnd(initEvent, 0, 0, 0, 0);CHKERRQ(ierr);\n \n PetscFunctionReturn(0);\n}\n\n#undef __FUNCT__\n#define __FUNCT__ \"HowMany\"\nPetscErrorCode HowMany(PetscInt N, PetscInt *num)\n{\n PetscErrorCode ierr;\n PetscInt n, p;\n PetscFunctionBegin;\n *num = 0;\n for(n = 0; n <= N; ++n) {\n for(p=0; p < 2*n + 1; ++p)\n *num += 1;\n }\n PetscFunctionReturn(0);\n}\n\n\n#undef __FUNCT__\n#define __FUNCT__ \"CalcEllipsoidFreeEnergy\"\nPetscErrorCode CalcEllipsoidFreeEnergy(EllipsoidalSystem *e, PetscReal eps1, PetscReal eps2, PetscInt nSrc, Vec srcXYZ, Vec srcMag, PetscReal tol, PetscInt Nmax, Vec tarSol, PetscReal *freeE)\n{\n PetscErrorCode ierr;\n PetscInt flopCount;\n //EllipsoidalSystem e;\n PetscReal x, y, z;\n PetscInt n, p, npsize;\n Vec srcEll, tarEll;\n PetscScalar *tarEllArray;\n Vec coulCoefs, reactCoefs, extCoefs;\n const PetscScalar *coulCoefsArray, *reactCoefsArray, *extCoefsArray;\n const PetscScalar *srcMagArray;\n Vec EnpVals, FnpVals;\n const PetscScalar *EnpValsArray, *FnpValsArray;\n PetscScalar *tarSolArray;\n PetscFunctionBegin;\n flopCount = 0;\n \n /* init ellipsoidal system */\n //ierr = initEllipsoidalSystem(&e, a, b, c);CHKERRQ(ierr);\n \n /* initialize expansion vectors */\n ierr = HowMany(Nmax, &npsize);CHKERRQ(ierr);\n //ierr = VecCreateSeq(PETSC_COMM_SELF, npsize, &coulCoefs);CHKERRQ(ierr);\n ierr = VecCreateSeq(PETSC_COMM_SELF, npsize, &reactCoefs);CHKERRQ(ierr);\n ierr = VecCreateSeq(PETSC_COMM_SELF, npsize, &extCoefs);CHKERRQ(ierr);\n \n /* initialize point vectors */\n ierr = VecDuplicate(srcXYZ, &srcEll);CHKERRQ(ierr);\n ierr = VecDuplicate(srcEll, &tarEll);CHKERRQ(ierr);\n \n /* convert points from cartesian to ellipsoidal */\n ierr = CartesianToEllipsoidalVec(e, srcXYZ, srcEll);CHKERRQ(ierr);\n ierr = VecCopy(srcEll, tarEll);CHKERRQ(ierr); //source+target same\n\n /* Calculate Gnp */\n ierr = CalcCoulombEllCoefs(e, nSrc, srcEll, srcMag, Nmax, &coulCoefs);CHKERRQ(ierr);\n /* calculate Bnp and Cnp */\n ierr = CalcReactAndExtCoefsFromCoulomb(e, eps1, eps2, Nmax, coulCoefs, reactCoefs, extCoefs);\n\n // create EnpVals and FnpVals vectors\n ierr = VecCreateSeq(PETSC_COMM_SELF, nSrc, &EnpVals);CHKERRQ(ierr);\n ierr = VecCreateSeq(PETSC_COMM_SELF, nSrc, &FnpVals);CHKERRQ(ierr);\n \n // get read-only pointers for expansion coefficients\n ierr = VecGetArrayRead(coulCoefs, &coulCoefsArray);CHKERRQ(ierr);\n ierr = VecGetArrayRead(reactCoefs, &reactCoefsArray);CHKERRQ(ierr);\n ierr = VecGetArrayRead(extCoefs, &extCoefsArray);CHKERRQ(ierr);\n // get write pointer for solution vector\n ierr = VecZeroEntries(tarSol);CHKERRQ(ierr);\n ierr = VecGetArray(tarSol, &tarSolArray);CHKERRQ(ierr);\n PetscInt ind = 0;\n for(n=0; n <= Nmax; ++n) {\n for(p=0; p < 2*n+1; ++p) {\n PetscReal Gnp = coulCoefsArray[ind];\n PetscReal Cnp = extCoefsArray[ind];\n PetscReal Bnp = reactCoefsArray[ind];\n \n ierr = CalcSolidInteriorHarmonicVec(e, tarEll, n, p, EnpVals);CHKERRQ(ierr);\n //ierr = CalcSolidExteriorHarmonicVec(&e, tarEll, n, p, FnpVals);CHKERRQ(ierr);\n\n ierr = VecGetArrayRead(EnpVals, &EnpValsArray);CHKERRQ(ierr);\n //ierr = VecGetArrayRead(FnpVals, &FnpValsArray);CHKERRQ(ierr);\n for(PetscInt k=0; k < nSrc; ++k) {\n\tPetscReal Enp = EnpValsArray[k];\n\t//PetscReal Fnp = FnpValsArray[k];\n\ttarSolArray[k] += Bnp*Enp; flopCount += 2;\n }\n ierr = VecRestoreArrayRead(EnpVals, &EnpValsArray);CHKERRQ(ierr);\n //ierr = VecRestoreArrayRead(FnpVals, &FnpValsArray);CHKERRQ(ierr);\n\n ind++;\n }\n }\n // get read-only pointers for expansion coefficients\n ierr = VecRestoreArrayRead(coulCoefs, &coulCoefsArray);CHKERRQ(ierr);\n ierr = VecRestoreArrayRead(reactCoefs, &reactCoefsArray);CHKERRQ(ierr);\n ierr = VecRestoreArrayRead(extCoefs, &extCoefsArray);CHKERRQ(ierr);\n *freeE = 0;\n ierr = VecGetArrayRead(srcMag, &srcMagArray);CHKERRQ(ierr);\n /* calculate free energy */\n for(PetscInt k=0; k < nSrc; ++k) {\n printf(\"sum[d] = %15.15f\\n\", srcMagArray[k]*tarSolArray[k]);\n *freeE += srcMagArray[k]*tarSolArray[k];\n }\n ierr = VecRestoreArrayRead(srcMag, &srcMagArray);CHKERRQ(ierr);\n ierr = VecRestoreArray(tarSol, &tarSolArray);CHKERRQ(ierr);\n ierr = PetscLogFlops(flopCount);CHKERRQ(ierr);\n PetscFunctionReturn(0);\n}\n\n#undef __FUNCT__\n#define __FUNCT__ \"CalcEllipsoidTester\"\nPetscErrorCode CalcEllipsoidTester(PetscReal a, PetscReal b, PetscReal c, PetscReal eps1, PetscReal eps2, PetscInt nSrc, Vec srcXYZ, Vec srcMag, PetscInt nTar, Vec tarXYZ, PetscInt Nmax, Vec tarSol)\n{\n PetscErrorCode ierr;\n EllipsoidalSystem e;\n PetscReal x, y, z;\n PetscInt n, p, npsize;\n Vec srcEll, tarEll;\n PetscScalar *tarEllArray;\n Vec coulCoefs, reactCoefs, extCoefs;\n const PetscScalar *coulCoefsArray, *reactCoefsArray, *extCoefsArray;\n Vec EnpVals, FnpVals;\n const PetscScalar *EnpValsArray, *FnpValsArray;\n PetscScalar *tarSolArray;\n PetscFunctionBegin;\n\n\n /* init ellipsoidal system */\n ierr = initEllipsoidalSystem(&e, a, b, c, 32);CHKERRQ(ierr);\n\n /* initialize expansion vectors */\n ierr = HowMany(Nmax, &npsize);CHKERRQ(ierr);\n //ierr = VecCreateSeq(PETSC_COMM_SELF, npsize, &coulCoefs);CHKERRQ(ierr);\n ierr = VecCreateSeq(PETSC_COMM_SELF, npsize, &reactCoefs);CHKERRQ(ierr);\n ierr = VecCreateSeq(PETSC_COMM_SELF, npsize, &extCoefs);CHKERRQ(ierr);\n \n /* initialize ellipsoid vectors */\n ierr = VecDuplicate(srcXYZ, &srcEll);CHKERRQ(ierr);\n ierr = VecDuplicate(tarXYZ, &tarEll);CHKERRQ(ierr);\n \n /* convert points from cartesian to ellipsoidal */\n ierr = CartesianToEllipsoidalVec(&e, srcXYZ, srcEll);CHKERRQ(ierr);\n ierr = CartesianToEllipsoidalVec(&e, tarXYZ, tarEll);CHKERRQ(ierr);\n \n\n /* Calculate Gnp */\n ierr = CalcCoulombEllCoefs(&e, nSrc, srcEll, srcMag, Nmax, &coulCoefs);CHKERRQ(ierr);\n //printf(\"\\n\\n##################################\\n########## COUL COEFS #############\\n###########################################\\n\\n\");\n //printf(\"nmax: %d\\n\", Nmax);\n //ierr = VecView(coulCoefs, PETSC_VIEWER_STDOUT_SELF);CHKERRQ(ierr);\n //printf(\"\\n\\n##################################\\n########## OVER #############\\n###########################################\\n\\n\");\n /* calculate Bnp and Cnp */\n ierr = CalcReactAndExtCoefsFromCoulomb(&e, eps1, eps2, Nmax, coulCoefs, reactCoefs, extCoefs);\n\n // create EnpVals and FnpVals vectors\n ierr = VecCreateSeq(PETSC_COMM_SELF, nTar, &EnpVals);CHKERRQ(ierr);\n ierr = VecCreateSeq(PETSC_COMM_SELF, nTar, &FnpVals);CHKERRQ(ierr);\n \n // get read-only pointers for expansion coefficients\n ierr = VecGetArrayRead(coulCoefs, &coulCoefsArray);CHKERRQ(ierr);\n ierr = VecGetArrayRead(reactCoefs, &reactCoefsArray);CHKERRQ(ierr);\n ierr = VecGetArrayRead(extCoefs, &extCoefsArray);CHKERRQ(ierr);\n // get write pointer for solution vector\n ierr = VecZeroEntries(tarSol);CHKERRQ(ierr);\n ierr = VecGetArray(tarSol, &tarSolArray);CHKERRQ(ierr);\n PetscInt ind = 0;\n for(n=0; n <= Nmax; ++n) {\n printf(\"n: %d\\n\", n);\n for(p=0; p < 2*n+1; ++p) {\n PetscReal Gnp = coulCoefsArray[ind];\n PetscReal Cnp = extCoefsArray[ind];\n PetscReal Bnp = reactCoefsArray[ind];\n \n ierr = CalcSolidInteriorHarmonicVec(&e, tarEll, n, p, EnpVals);CHKERRQ(ierr);\n ierr = CalcSolidExteriorHarmonicVec(&e, tarEll, n, p, FnpVals);CHKERRQ(ierr);\n\n ierr = VecGetArrayRead(EnpVals, &EnpValsArray);CHKERRQ(ierr);\n ierr = VecGetArrayRead(FnpVals, &FnpValsArray);CHKERRQ(ierr);\n for(PetscInt k=0; k < nTar; ++k) {\n\tif(n==0 && p==0) {\n\t tarSolArray[k] = 0;\n\t}\n\tPetscReal lambda;\n\tPetscInt index = 3*k+0;\n\tierr = VecGetValues(tarEll, 1, &index, &lambda);CHKERRQ(ierr);\n\t\n\tPetscReal Enp = EnpValsArray[k];\n\tPetscReal Fnp = FnpValsArray[k];\n\tif(PetscAbsReal(lambda) <= a)\n\t tarSolArray[k] += Bnp*Enp; //(Gnp/eps1)*Fnp;\n\telse {\n\t tarSolArray[k] += Cnp*Fnp;//(Gnp/eps1)*Fnp;\n\t}\n\t\n\t\n }\n ierr = VecRestoreArrayRead(EnpVals, &EnpValsArray);CHKERRQ(ierr);\n ierr = VecRestoreArrayRead(FnpVals, &FnpValsArray);CHKERRQ(ierr);\n\n ind++;\n }\n }\n \n PetscFunctionReturn(0);\n}\n\n\n\n#undef __FUNCT__\n#define __FUNCT__ \"CalcEllipsoidCoulombPotential\"\nPetscErrorCode CalcEllipsoidCoulombPotential(PetscReal a, PetscReal b, PetscReal c, PetscReal eps1, PetscReal eps2, PetscInt nCharges, Vec chargeXYZ, Vec chargeMag, PetscInt nSol, Vec solXYZ, PetscInt Nmax, Vec targetSol)\n{\n PetscErrorCode ierr;\n Vec chargeEll;\n Vec solEll;\n Vec coulCoefs;\n Vec FnpVals;\n EllipsoidalSystem e;\n PetscScalar *vecPtr;\n PetscScalar *coulCoefsArray;\n PetscScalar *FnpValsArray;\n PetscFunctionBegin;\n\n ierr = initEllipsoidalSystem(&e, a, b, c, 32);CHKERRQ(ierr);\n\n // create charge ellipsoidal vec and convert from xyz\n ierr = VecCreateSeq(PETSC_COMM_SELF, 3*nCharges, &chargeEll);CHKERRQ(ierr);\n printf(\"Converting charge points to ellipsoidal\\n\");\n ierr = CartesianToEllipsoidalVec(&e, chargeXYZ, chargeEll);CHKERRQ(ierr);\n // create solution ellipsoidal vec and convert from xyz\n ierr = VecCreateSeq(PETSC_COMM_SELF, 3*nSol, &solEll);CHKERRQ(ierr);\n printf(\"Converting solution points to ellipsoidal\\n\");\n ierr = CartesianToEllipsoidalVec(&e, solXYZ, solEll);CHKERRQ(ierr);\n\n //calculate coulomb coefficients\n ierr = CalcCoulombEllCoefs(&e, nCharges, chargeEll, chargeMag, Nmax, &coulCoefs);CHKERRQ(ierr);\n\n //initialize vector for interior harmonic calculations\n ierr = VecCreateSeq(PETSC_COMM_SELF, nSol, &FnpVals);CHKERRQ(ierr);\n\n ierr = VecGetArrayRead(coulCoefs, &coulCoefsArray);CHKERRQ(ierr);\n ierr = VecGetArray(targetSol, &vecPtr);CHKERRQ(ierr);\n PetscInt index = 0;\n for(PetscInt n=0; n<=Nmax; ++n) {\n for(PetscInt p=0; p < 2*n+1; ++p) {\n //calculate Enp Vals\n ierr = CalcSolidExteriorHarmonicVec(&e, solEll, n, p, FnpVals);CHKERRQ(ierr);\n ierr = VecGetArrayRead(FnpVals, &FnpValsArray);CHKERRQ(ierr);\n for(PetscInt k=0; kstageInfo[stageExtSolids].eventLog->eventInfo[EXTERIOR_FLOPS[i]].flops);\n fprintf(fpint, \"Int %d = %.4e\\n\", i, stageLog->stageInfo[stageIntSolids].eventLog->eventInfo[INTERIOR_FLOPS[i]].flops);\n }\n */\n\n\n ierr = VecDestroy(&tarIntXYZ);CHKERRQ(ierr);CHKERRQ(ierr);\n ierr = VecDestroy(&tarExtXYZ);CHKERRQ(ierr);CHKERRQ(ierr);\n ierr = VecDestroy(&tarIntEll);CHKERRQ(ierr);CHKERRQ(ierr);\n ierr = VecDestroy(&tarExtEll);CHKERRQ(ierr);CHKERRQ(ierr);\n ierr = VecDestroy(&srcEll);CHKERRQ(ierr);CHKERRQ(ierr);\n ierr = VecDestroy(&tarEll);CHKERRQ(ierr);CHKERRQ(ierr);\n ierr = VecDestroy(&coulCoefs);CHKERRQ(ierr);\n ierr = VecDestroy(&reactCoefs);CHKERRQ(ierr);\n ierr = VecDestroy(&extCoefs);CHKERRQ(ierr);\n ierr = VecDestroy(&EnpVals); CHKERRQ(ierr);\n ierr = VecDestroy(&FnpVals); CHKERRQ(ierr);\n PetscFunctionReturn(0);\n}\n\n\n#undef __FUNCT__\n#define __FUNCT__ \"CalcSolidInteriorHarmonic\"\nPetscErrorCode CalcSolidInteriorHarmonic(EllipsoidalSystem* e, PetscReal lambda, PetscReal mu, PetscReal nu, PetscInt n, PetscInt p, PetscReal *val)\n{\n PetscErrorCode ierr;\n PetscInt signm = 1;\n PetscInt signn = 1;\n PetscReal eL, eM, eN;\n PetscFunctionBegin;\n \n if(mu < 0)\n signm = -1;\n if(nu < 0)\n signn = -1;\n\n calcLame(e, n, p, lambda, signm, signn, &eL);\n calcLame(e, n, p, mu, signm, signn, &eM);\n calcLame(e, n, p, nu, signm, signn, &eN);\n \n *val = eL*eM*eN;\n \n ierr= PetscLogFlops(3);CHKERRQ(ierr);\n PetscFunctionReturn(0);\n}\n\n\n#undef __FUNCT__\n#define __FUNCT__ \"CalcSolidInteriorHarmonicVec\"\n/*\n ellPoints is ellPoints of size 3*nPoints containing ellipsoidal coordinates\n outputs solid harmonics to values of size nPoints\n*/\nPetscErrorCode CalcSolidInteriorHarmonicVec(EllipsoidalSystem* e, Vec ellPoints, PetscInt n, PetscInt p, Vec values)\n{\n PetscErrorCode ierr;\n PetscInt signm = 1;\n PetscInt signn = 1;\n PetscInt nPoints;\n PetscReal lambda, mu, nu;\n PetscReal eL, eM, eN;\n PetscReal Enp;\n const PetscScalar* ellPointsArray;\n PetscFunctionBegin;\n ierr = VecGetSize(ellPoints, &nPoints);CHKERRQ(ierr);\n nPoints = nPoints/3;\n \n ierr = VecGetArrayRead(ellPoints, &ellPointsArray); CHKERRQ(ierr);\n for(PetscInt k=0; ka, 1, 1, &Ea);CHKERRQ(ierr);\n ierr = calcI (e, n, p, e->a, 1, 1, &Ia);CHKERRQ(ierr);\n Fa = (2*n + 1) * Ea * Ia;\n calcLameDerivative(e, n, p, e->a, 1, 1, &EaDer);\n calcIDerivative (e, n, p, e->a, 1, 1, &IaDer);\n FaDer = (2*n + 1) * (Ea*IaDer + EaDer*Ia);\n\n temp = (Fa/Ea)*(eps1 - eps2)/(eps1*eps2);\n temp /= (1 - (eps1/eps2)*((EaDer*Fa)/(FaDer*Ea)));\n Bnp = temp*Gnp;\n\n Cnp = (eps1/eps2)*(EaDer/FaDer)*Bnp;\n Cnp += (Gnp/eps2);\n \n ierr = VecSetValues(reacCoefs, 1, &count, &Bnp, INSERT_VALUES);CHKERRQ(ierr);\n ierr = VecSetValues(extCoefs, 1, &count, &Cnp, INSERT_VALUES);CHKERRQ(ierr);\n\n count++;\n }\n }\n\n ierr = VecAssemblyBegin(reacCoefs);CHKERRQ(ierr);\n ierr = VecAssemblyEnd (reacCoefs);CHKERRQ(ierr);\n ierr = VecAssemblyBegin(extCoefs);CHKERRQ(ierr);\n ierr = VecAssemblyEnd (extCoefs);CHKERRQ(ierr);\n ierr = VecRestoreArrayRead(coulCoefs, &coulCoefsArray);CHKERRQ(ierr);\n\n\n ierr = PetscLogFlops(29*count);\n PetscFunctionReturn(0);\n}\n\n\n", "meta": {"hexsha": "ea85ccd6b74b5c9ae27b5e7b911e19aaed4fe3db", "size": 27348, "ext": "c", "lang": "C", "max_stars_repo_path": "src/ellipsoid/ellSolvPetsc.c", "max_stars_repo_name": "tom-klotz/ellipsoid-solvation", "max_stars_repo_head_hexsha": "2bcaab45a9096ae078711b4f4e1495c2bead16a0", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2016-11-05T20:15:01.000Z", "max_stars_repo_stars_event_max_datetime": "2016-11-05T20:15:01.000Z", "max_issues_repo_path": "src/ellipsoid/ellSolvPetsc.c", "max_issues_repo_name": "tom-klotz/ellipsoid-solvation", "max_issues_repo_head_hexsha": "2bcaab45a9096ae078711b4f4e1495c2bead16a0", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/ellipsoid/ellSolvPetsc.c", "max_forks_repo_name": "tom-klotz/ellipsoid-solvation", "max_forks_repo_head_hexsha": "2bcaab45a9096ae078711b4f4e1495c2bead16a0", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.6558018253, "max_line_length": 228, "alphanum_fraction": 0.6895202574, "num_tokens": 8857, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8596637648915617, "lm_q2_score": 0.6334102636778401, "lm_q1q2_score": 0.5445198519942489}} {"text": "#include \n#include \n#include \n#include \n#include \"integral.c\"\n#include \"timer.c\"\n#include \"timer.h\"\n#define N 20\ndouble g (double *t,size_t dim, void *params);\n\nint main (void)\n{\n\tdouble res, err;\n\t// 6 dimensional integral\n\tsize_t dim = 6;\n\n\tint dims=6;\n\t//evaluating all dimensions from 0 to 1\n\tdouble x1[] = { 0., 0., 0. ,0.,0.,0. };\n\tdouble xu[] = { 1., 1., 1. ,1.,1.,1. };\n\tFILE *file;\n\tfile=fopen(\"data.txt\",\"w\");\n\n\tdouble rmin=1.001;\n\tdouble rmax=4;\n\tdouble rtot=rmin;\n\tdouble rstep= (rmax-rmin)/(N);\n\n\tgsl_rng *r = gsl_rng_alloc (gsl_rng_taus2);\n\tunsigned long seed = 1UL;\n\tgsl_rng_set (r, seed);\n\n\t// 10^6 function evaluations per iteration\n\n\tsize_t calls = 1000000;\n\tgsl_monte_function G= { &g, dim, &rtot};\n\tgsl_monte_vegas_state *sv = gsl_monte_vegas_alloc (dim);\n\tgsl_monte_vegas_init (sv);\n\n\t//Vegas integration\n\tdouble vegas[N];\n\tdouble rval[N];\n\tdouble di[N];\n\ttimer_start ();\n\tfor (int i = 0; i<=N-1; i++)\n\t{\n\t\tgsl_monte_vegas_integrate (&G,x1,xu,dim,calls/5,r,sv,&res,&err);\n\t\tdo \n\t\t{\n\t\t\tgsl_monte_vegas_integrate (&G, x1,xu,dim,calls,r,sv,&res,&err);\n\t\t\tfflush (stdout);\n\t\t}\n\n\t\twhile (fabs (gsl_monte_vegas_chisq (sv)-1.0) >0.2);\n\t\trtot+=rstep;\n\t\tvegas[i]=res;\n\t\trval[i]=rtot;\n\t\tdi[i] = -.2 / pow (rtot,3.);\n\t}\n\ttimer_stop ();\n\tdouble tvegas=timer_stop();\n\tgsl_monte_vegas_free (sv);\n\trtot=rmin;\n\tprintf (\" %10.6f\\n\",tvegas);\n\t//homemade\n\trtot=rmin;\t\n\tdouble x[6];\n\n\n \tr = gsl_rng_alloc (gsl_rng_taus2);\n \tgsl_rng_set (r, 1UL);\n\tdouble thome;\n\tlong i, j;\n\tdouble r2=0.;\n\tdouble home[20];\n\tfor (j = 0; j < N; j++)\n \t{\n\t\tr2=0.;\n \t\tfor (i = 0; i < 1.e6; i++)\n \t{\n \t\tfor (int k = 0; k <= dims; k++)\n \t\t{\n \t\tx[k] = gsl_rng_uniform (r) ;\n \t\t}\n\t\tr2+= g(x,dim, &rtot);\n\t\t\n }\n res = r2/1.e6;\n\tfflush (stdout);\n\trtot+=rstep;\n\thome [j]=res;\n }\n\ttimer_stop();\n\trtot=rmin;\n\tthome=timer_stop();\n\tprintf (\" %10.6f\\n\",thome);\n\tfor (int t=0;t\n#include \n#include \n#include \n\n#define IDX2D(i, j, xsize, ysize) ((j) * (xsize) + (i))\n\nstatic int\nbilinear_init(void * state, const double xa[], const double ya[],\n const double za[], size_t xsize, size_t ysize)\n{\n return GSL_SUCCESS;\n}\n\nstatic int\nbilinear_eval(const void * state, const double xarr[], const double yarr[],\n const double zarr[], size_t xsize, size_t ysize,\n double x, double y, gsl_interp_accel * xa,\n gsl_interp_accel * ya, double * z)\n{\n double xmin, xmax, ymin, ymax, zminmin, zminmax, zmaxmin, zmaxmax;\n double dx, dy;\n double t, u;\n size_t xi, yi;\n\n if (xa != NULL)\n xi = gsl_interp_accel_find(xa, xarr, xsize, x);\n else\n xi = gsl_interp_bsearch(xarr, x, 0, xsize - 1);\n\n if (ya != NULL)\n yi = gsl_interp_accel_find(ya, yarr, ysize, y);\n else\n yi = gsl_interp_bsearch(yarr, y, 0, ysize - 1);\n\n xmin = xarr[xi];\n xmax = xarr[xi + 1];\n ymin = yarr[yi];\n ymax = yarr[yi + 1];\n zminmin = zarr[IDX2D(xi, yi, xsize, ysize)];\n zminmax = zarr[IDX2D(xi, yi + 1, xsize, ysize)];\n zmaxmin = zarr[IDX2D(xi + 1, yi, xsize, ysize)];\n zmaxmax = zarr[IDX2D(xi + 1, yi + 1, xsize, ysize)];\n dx = xmax - xmin;\n dy = ymax - ymin;\n t = (x - xmin)/dx;\n u = (y - ymin)/dy;\n *z = (1.-t)*(1.-u)*zminmin + t*(1.-u)*zmaxmin + (1.-t)*u*zminmax + t*u*zmaxmax;\n\n return GSL_SUCCESS;\n}\n\nstatic int\nbilinear_deriv_x(const void * state, const double xarr[],\n const double yarr[], const double zarr[],\n size_t xsize, size_t ysize, double x, double y,\n gsl_interp_accel * xa, gsl_interp_accel * ya, double * z_p)\n{\n double xmin, xmax, ymin, ymax, zminmin, zminmax, zmaxmin, zmaxmax;\n double dx, dy;\n double dt, u;\n size_t xi, yi;\n\n if (xa != NULL)\n xi = gsl_interp_accel_find(xa, xarr, xsize, x);\n else\n xi = gsl_interp_bsearch(xarr, x, 0, xsize - 1);\n\n if (ya != NULL)\n yi = gsl_interp_accel_find(ya, yarr, ysize, y);\n else\n yi = gsl_interp_bsearch(yarr, y, 0, ysize - 1);\n\n xmin = xarr[xi];\n xmax = xarr[xi + 1];\n ymin = yarr[yi];\n ymax = yarr[yi + 1];\n zminmin = zarr[IDX2D(xi, yi, xsize, ysize)];\n zminmax = zarr[IDX2D(xi, yi + 1, xsize, ysize)];\n zmaxmin = zarr[IDX2D(xi + 1, yi, xsize, ysize)];\n zmaxmax = zarr[IDX2D(xi + 1, yi + 1, xsize, ysize)];\n dx = xmax - xmin;\n dy = ymax - ymin;\n dt = 1./dx; /* partial t / partial x */\n u = (y - ymin)/dy;\n *z_p = dt*(-(1.-u)*zminmin + (1.-u)*zmaxmin - u*zminmax + u*zmaxmax);\n\n return GSL_SUCCESS;\n}\n\nstatic int\nbilinear_deriv_y(const void * state, const double xarr[],\n const double yarr[], const double zarr[],\n size_t xsize, size_t ysize, double x, double y,\n gsl_interp_accel * xa, gsl_interp_accel * ya, double * z_p)\n{\n double xmin, xmax, ymin, ymax, zminmin, zminmax, zmaxmin, zmaxmax;\n double dx, dy;\n double t, du;\n size_t xi, yi;\n\n if (xa != NULL)\n xi = gsl_interp_accel_find(xa, xarr, xsize, x);\n else\n xi = gsl_interp_bsearch(xarr, x, 0, xsize - 1);\n\n if (ya != NULL)\n yi = gsl_interp_accel_find(ya, yarr, ysize, y);\n else\n yi = gsl_interp_bsearch(yarr, y, 0, ysize - 1);\n\n xmin = xarr[xi];\n xmax = xarr[xi + 1];\n ymin = yarr[yi];\n ymax = yarr[yi + 1];\n zminmin = zarr[IDX2D(xi, yi, xsize, ysize)];\n zminmax = zarr[IDX2D(xi, yi + 1, xsize, ysize)];\n zmaxmin = zarr[IDX2D(xi + 1, yi, xsize, ysize)];\n zmaxmax = zarr[IDX2D(xi + 1, yi + 1, xsize, ysize)];\n dx = xmax - xmin;\n dy = ymax - ymin;\n t = (x - xmin)/dx;\n du = 1./dy; /* partial u / partial y */\n *z_p = du*(-(1.-t)*zminmin - t*zmaxmin + (1.-t)*zminmax + t*zmaxmax);\n\n return GSL_SUCCESS;\n}\n\nstatic int\nbilinear_deriv2(const void * state, const double xarr[],\n const double yarr[], const double zarr[],\n size_t xsize, size_t ysize, double x, double y,\n gsl_interp_accel * xa, gsl_interp_accel * ya, double * z_pp)\n{\n *z_pp = 0.0;\n return GSL_SUCCESS;\n}\n\nstatic int\nbilinear_derivxy(const void * state, const double xarr[],\n const double yarr[], const double zarr[],\n size_t xsize, size_t ysize, double x, double y,\n gsl_interp_accel * xa, gsl_interp_accel * ya, double * z_pp)\n{\n double xmin, xmax, ymin, ymax, zminmin, zminmax, zmaxmin, zmaxmax;\n double dx, dy;\n double dt, du;\n size_t xi, yi;\n\n if (xa != NULL)\n xi = gsl_interp_accel_find(xa, xarr, xsize, x);\n else\n xi = gsl_interp_bsearch(xarr, x, 0, xsize - 1);\n\n if (ya != NULL)\n yi = gsl_interp_accel_find(ya, yarr, ysize, y);\n else\n yi = gsl_interp_bsearch(yarr, y, 0, ysize - 1);\n\n xmin = xarr[xi];\n xmax = xarr[xi + 1];\n ymin = yarr[yi];\n ymax = yarr[yi + 1];\n zminmin = zarr[IDX2D(xi, yi, xsize, ysize)];\n zminmax = zarr[IDX2D(xi, yi + 1, xsize, ysize)];\n zmaxmin = zarr[IDX2D(xi + 1, yi, xsize, ysize)];\n zmaxmax = zarr[IDX2D(xi + 1, yi + 1, xsize, ysize)];\n dx = xmax - xmin;\n dy = ymax - ymin;\n dt = 1./dx; /* partial t / partial x */\n du = 1./dy; /* partial u / partial y */\n *z_pp = dt*du*(zminmin-zmaxmin-zminmax+zmaxmax);\n\n return GSL_SUCCESS;\n}\n\nstatic const gsl_interp2d_type bilinear_type = {\n \"bilinear\",\n 2,\n NULL,\n &bilinear_init,\n &bilinear_eval,\n &bilinear_deriv_x,\n &bilinear_deriv_y,\n &bilinear_deriv2,\n &bilinear_derivxy,\n &bilinear_deriv2,\n NULL\n};\n\nconst gsl_interp2d_type * gsl_interp2d_bilinear = &bilinear_type;\n\n#undef IDX2D\n", "meta": {"hexsha": "d6206cd8ae006181b81f486dc4e0ce6ea56e4173", "size": 6278, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.6/interpolation/bilinear.c", "max_stars_repo_name": "ielomariala/Hex-Game", "max_stars_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-06-14T11:51:37.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-14T11:51:37.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/interpolation/bilinear.c", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-12-16T17:41:24.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-22T00:00:16.000Z", "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/interpolation/bilinear.c", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-01-20T16:22:57.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-14T12:31:02.000Z", "avg_line_length": 29.4741784038, "max_line_length": 81, "alphanum_fraction": 0.6231283848, "num_tokens": 2142, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.826711776992821, "lm_q2_score": 0.658417500561683, "lm_q1q2_score": 0.5443215018925207}} {"text": "/*\n * TableFunction.h\n *\n * Author:\n * Oleg Kalashev\n *\n * Copyright (c) 2020 Institute for Nuclear Research, RAS\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\n\n#ifndef TABLEFUNCTION_H_\n#define TABLEFUNCTION_H_\n\n#include \n#include \n#include \n\n#include \"MathUtils.h\"\n#include \"TableReader.h\"\n\n\nnamespace Utils {\n\ntemplate\nclass IScale\n{\npublic:\n\tvirtual X ToScale(X aX) = 0;\n\tvirtual X FromScale(X aXprime) = 0;\n\tvirtual IScale* Clone() const = 0;\n\tvirtual ~IScale(){}\n};\n\ntemplate\nclass LogScaleX : public IScale\n{\npublic:\n\tX ToScale(X aX);\n\tX FromScale(X aXprime);\n\tIScale* Clone() const;\n};\n\ntypedef LogScaleX LogScale;\n\ntemplate\nclass TableFunctionX : public SmartReferencedObj, virtual public FunctionX{\npublic:\n\tstatic int FindLeftX(const std::vector&, X xValue);\n\tTableFunctionX(const std::vector& _x, const std::vector& _y, X _leftVal=0., X _rightVal=0.);\n\n\t//takes ownership of aXscale and aYscale\n\tTableFunctionX(const std::vector& _x, const std::vector& _y, IScale* aXscale, IScale* aYscale, X _leftVal=0., X _rightVal=0.);\n\n\t//stores smart ref to aReader\n\tTableFunctionX(TableReaderX* aReader, X _leftVal=0., X _rightVal=0.);\n\n\tbool InTableRange(X aArg) const;\n\n\tvirtual X f(X _x) const;\n\tvirtual X f_scaled(X _x) const = 0;\n\tvirtual X Xmin() const;\n\tvirtual X Xmax() const;\n\n\tvoid SetAutoLimits();\n\tvoid Print(std::ostream& aOut, X aXcoef=1., X aYcoef=1.);\nprivate:\n\t//common part of constructors\n\tvoid Init();\nprotected:\n\tint FindLeftX(X xValue) const;\n\t//used for cloning\n\tTableFunctionX(const TableFunctionX& aTableFunction);\n\n\tstd::vector\t\t\tfCloneX;\n\tstd::vector\t\t\tfCloneY;\n\tconst std::vector&\tm_x;\n\tconst std::vector&\tm_y;\n\tX\t\t\t\t\t\tm_leftVal;\n\tX\t\t\t\t\t\tm_rightVal;\n\tSafePtr >\t\tfXscale;\n\tSafePtr >\t\tfYscale;\n\tSmartPtr >\tfTable;\n\tX\t\t\t\t\t\tfXmin;\n\tX\t\t\t\t\t\tfXmax;\n};\n\ntypedef TableFunctionX TableFunction;\n\ntemplate\nclass LinearFuncX : public TableFunctionX\n{\npublic:\n\tLinearFuncX(const std::vector& _x,const std::vector& _y, X _leftVal=0., X _rightVal=0.):\n\t TableFunctionX(_x, _y, _leftVal, _rightVal) {};\n\n\t//stores smart ref to aReader\n\tLinearFuncX(TableReaderX* aReader, X _leftVal=0., X _rightVal=0.):\n\t\tTableFunctionX(aReader,_leftVal,_rightVal) {};\n\n\t//takes ownership of aXscale and aYscale\n\tLinearFuncX(const std::vector& _x,const std::vector& _y, IScale* aXscale, IScale* aYscale, X _leftVal=0., X _rightVal=0.):\n\t\tTableFunctionX(_x, _y, aXscale, aYscale, _leftVal, _rightVal) {}\n\n\tX f_scaled(X _x) const;\n\tFunctionX* Clone() const { return new LinearFuncX(*this); }\nprotected:\n\tLinearFuncX(const TableFunctionX& aTableFunction):\n\t\tTableFunctionX(aTableFunction) {};\n};\n\ntypedef LinearFuncX LinearFunc;\n\nclass GSLTableFunc : public TableFunction\n{\npublic:\n\tGSLTableFunc(const Vector& _x, const Vector& _y, const gsl_interp_type * aInterpType=gsl_interp_linear,\n\t\t\tdouble _leftVal=0., double _rightVal=0.):\n\t TableFunction(_x, _y, _leftVal, _rightVal),fAcc(0),fSpline(0) {Init(aInterpType);}\n\n\t//stores smart ref to aReader\n\tGSLTableFunc(TableReader *aReader, const gsl_interp_type * aInterpType=gsl_interp_linear, double _leftVal=0., double _rightVal=0.):\n\t\tTableFunction(aReader,_leftVal,_rightVal),fAcc(0),fSpline(0) {Init(aInterpType);}\n\n\t//takes ownership of aXscale and aYscale\n\t//_x and _y are values are modified with scale functions given by aXscale and aYscale parameters\n\tGSLTableFunc(const Vector& _x, const Vector& _y, IScale* aXscale, IScale* aYscale, const gsl_interp_type * aInterpType=gsl_interp_linear, double _leftVal=0., double _rightVal=0.):\n\t\tTableFunction(_x, _y, aXscale, aYscale, _leftVal, _rightVal) {Init(aInterpType);}\n\n\tvirtual ~GSLTableFunc();\n\n\tdouble f_scaled(double _x) const;\n\tFunction* Clone() const { return new GSLTableFunc(*this); }\nprotected:\n\tGSLTableFunc(const GSLTableFunc& aTableFunction):\n\t\tTableFunction(aTableFunction) {Init(aTableFunction.fSpline->interp->type);};\nprivate:\n\tvoid Init(const gsl_interp_type * aInterpType);\n gsl_interp_accel *fAcc;\n gsl_spline *fSpline;\n const gsl_interp_type *fInterpType;\n};\n\ntemplate\nclass MatrixFunctionX : public Function2X\n{\npublic:\n\tMatrixFunctionX(const std::string& aFile)\n\t{\n\t\tstd::ifstream dataFile(aFile.c_str());\n\t\tif(!dataFile)\n\t\t\tException::Throw(\"Failed to open \" + aFile);\n\t\tstd::string header;\n\t\tstd::getline(dataFile, header);\n\t\tint logscX,logscY;\n\t\tconst char* headerFormat = \"# minX=%lg stepX=%lg logscaleX=%d minY=%lg stepY=%lg logscaleY=%d\";\n\t\tif(sscanf(header.c_str(),headerFormat,\n\t\t\t\t &xMin,&xStep,&logscX,&yMin,&yStep,&logscY)!=6)\n\t\t\tException::Throw(\"Invalid header format in \" + aFile + \"\\nExpected format: \" + headerFormat);\n\t\tlogScaleX = (bool)logscX;\n\t\tlogScaleY = (bool)logscY;\n\t\tif((logScaleX && (xMin<=0 || xStep<=1.))||xStep<=0.)\n\t\t\tException::Throw(\"Invalid X scale in \" + aFile);\n\t\tif((logScaleY && (yMin<=0 || yStep<=1.))||yStep<=0.)\n\t\t\tException::Throw(\"Invalid Y scale in \" + aFile);\n\t\tfData = new TableReaderX(dataFile, TableReader::Auto);\n\t\tnCols = fData->numberOfColumns();\n\t\tif(logScaleX) {\n\t\t\txMax = xMin*pow(xStep,nCols-1);\n\t\t\txStep = log(xStep);//convert multiplier to log step\n\t\t}\n\t\telse{\n\t\t\txMax = xMin + xStep*(nCols-1);\n\t\t}\n\t\tnRows = fData->getColumn(0).size();\n\t\tif(logScaleY){\n\t\t\tyMax = yMin*pow(yStep,nRows-1);\n\t\t\tyStep = log(yStep);//convert multiplier to log step\n\t\t}\n\t\telse{\n\t\t\tyMax = yMin + yStep*(nRows-1);\n\t\t}\n\t}\n\n\tX f(double x, double y) const\n\t{\n\t\tdouble binX, binY;\n\n\t\tif(logScaleX)\n\t\t{//log scale\n\t\t\tbinX = log(x/xMin)/xStep;\n\t\t}\n\t\telse\n\t\t{//linear scale\n\t\t\tbinX = (x-xMin)/xStep;\n\t\t}\n\t\tif(binX<0. || binX>nCols-1)\n\t\t\treturn 0.;\n\t\tif(logScaleY)\n\t\t{//log scale\n\t\t\tbinY = log(y/yMin)/yStep;\n\t\t}\n\t\telse\n\t\t{//linear scale\n\t\t\tbinY = (y-yMin)/yStep;\n\t\t}\n\t\tif(binY<0. || binY>nRows-1)\n\t\t\treturn 0.;\n\t\tint iX = floor(binX);\n\t\tint iY = floor(binY);\n\t\tdouble weightX = 1.-binX+iX;\n\t\tdouble weightY = 1.-binY+iY;\n\n\t\t//linear f interpolation //TODO implement logscale f interpolation\n\t\tdouble f_11 = fData->getColumn(iX)[iY]*weightX*weightY;\n\t\tdouble f_21 = (weightX<1.)? (fData->getColumn(iX+1)[iY]*(1.-weightX)*weightY) : 0.;\n\t\tdouble f_12 = (weightY<1.)? (fData->getColumn(iX)[iY+1]*weightX*(1.-weightY)) : 0.;\n\t\tdouble f_22 = (weightX<1.&&weightY<1.)?(fData->getColumn(iX+1)[binY+1]*(1.-weightX)*(1.-weightY)) : 0.;\n\t\tdouble result = f_11 + f_21 + f_12 + f_22;\n\t\treturn result;\n\t}\n\n\tvirtual X MinArg(int aArgNo) const {return aArgNo==1?xMin:yMin;};\n\tvirtual X MaxArg(int aArgNo) const {return aArgNo==1?xMax:yMax;}\n\nprivate:\n\tSafePtr > fData;\n\tX xMin;\n\tX yMin;\n\tX xMax;\n\tX yMax;\n\tX xStep;\n\tX yStep;\n\tint nCols;\n\tint nRows;\n\tbool logScaleX;\n\tbool logScaleY;\n};\n\ntypedef MatrixFunctionX MatrixFunction;\n\n} /* namespace Utils */\n\n#endif /* TABLEFUNCTION_H_ */\n", "meta": {"hexsha": "f29c7d38dde01184b3236a6ba10f36e0379cdf41", "size": 8025, "ext": "h", "lang": "C", "max_stars_repo_path": "src/lib/TableFunction.h", "max_stars_repo_name": "alexkorochkin/mcray", "max_stars_repo_head_hexsha": "2cfa58d2cd6f872612f6396d65781ad83211c06c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 7.0, "max_stars_repo_stars_event_min_datetime": "2020-12-16T08:23:31.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-15T22:56:26.000Z", "max_issues_repo_path": "src/lib/TableFunction.h", "max_issues_repo_name": "alexkorochkin/mcray", "max_issues_repo_head_hexsha": "2cfa58d2cd6f872612f6396d65781ad83211c06c", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/lib/TableFunction.h", "max_forks_repo_name": "alexkorochkin/mcray", "max_forks_repo_head_hexsha": "2cfa58d2cd6f872612f6396d65781ad83211c06c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2020-12-16T08:23:34.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-10T21:05:54.000Z", "avg_line_length": 30.6297709924, "max_line_length": 196, "alphanum_fraction": 0.7054205607, "num_tokens": 2498, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.785308580887758, "lm_q2_score": 0.6926419894793248, "lm_q1q2_score": 0.543937697821282}} {"text": "/***************************************************************************\n File : Fit.h\n Project : QtiPlot\n --------------------------------------------------------------------\n Copyright : (C) 2006 by Ion Vasilief\n Email (use @ for *) : ion_vasilief*yahoo.fr\n Description : Fit base class\n\n ***************************************************************************/\n\n/***************************************************************************\n * *\n * This program is free software; you can redistribute it and/or modify *\n * it under the terms of the GNU General Public License as published by *\n * the Free Software Foundation; either version 2 of the License, or *\n * (at your option) any later version. *\n * *\n * This program is distributed in the hope that it will be useful, *\n * but WITHOUT ANY WARRANTY; without even the implied warranty of *\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *\n * GNU General Public License for more details. *\n * *\n * You should have received a copy of the GNU General Public License *\n * along with this program; if not, write to the Free Software *\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, *\n * Boston, MA 02110-1301 USA *\n * *\n ***************************************************************************/\n#ifndef FIT_H\n#define FIT_H\n\n#include \n\n#include \"../ApplicationWindow.h\"\n#include \"Filter.h\"\n\n#include \n#include \n\nclass Table;\nclass Matrix;\n\n//! Fit base class\nclass Fit : public Filter\n{\n\tQ_OBJECT\n\n\tpublic:\n\n\t\ttypedef double (*fit_function_simplex)(const gsl_vector *, void *);\n\t\ttypedef int (*fit_function)(const gsl_vector *, void *, gsl_vector *);\n\t\ttypedef int (*fit_function_df)(const gsl_vector *, void *, gsl_matrix *);\n\t\ttypedef int (*fit_function_fdf)(const gsl_vector *, void *, gsl_vector *, gsl_matrix *);\n\n\t\tenum Algorithm{ScaledLevenbergMarquardt, UnscaledLevenbergMarquardt, NelderMeadSimplex};\n\t\tenum WeightingMethod{NoWeighting, Instrumental, Statistical, Dataset};\n enum FitType{BuiltIn = 0, Plugin = 1, User = 2};\r\n\n\t\tFit(ApplicationWindow *parent, Graph *g = 0, const QString& name = QString());\n\t\tFit(ApplicationWindow *parent, Table *t, const QString& name = QString());\n\t\t~Fit();\n\n\t\t//! Actually does the fit. Should be reimplemented in derived classes.\n\t\tvirtual void fit();\n virtual bool run(){fit(); return true;};\n\n\t\t//! Sets the data set to be used for weighting\n\t\tbool setWeightingData(WeightingMethod w, const QString& colName = QString::null);\n\n\t\tvoid setDataCurve(int curve, double start, double end);\n\t\tbool setDataFromTable(Table *t, const QString& xColName, const QString& yColName, int from = 1, int to = -1);\n\n\t\tQString resultFormula(){return d_result_formula;};\n\t\tQString formula(){return d_formula;};\r\n\t\tvirtual void setFormula(const QString&){};\r\n\n\t\tint numParameters(){return d_p;};\n\t\tQStringList parameterNames(){return d_param_names;};\r\n\t\tvirtual void setParametersList(const QStringList&){};\n void setParameterExplanations(const QStringList& lst){d_param_explain = lst;};\r\n\r\n double initialGuess(int parIndex){return gsl_vector_get(d_param_init, parIndex);};\n\t\tvoid setInitialGuess(int parIndex, double val){gsl_vector_set(d_param_init, parIndex, val);};\n\t\tvoid setInitialGuesses(double *x_init);\n\n\t\tvirtual void guessInitialValues(){};\n\n\t\tvoid setParameterRange(int parIndex, double left, double right);\n\t\tvoid setAlgorithm(Algorithm s){d_solver = s;};\n\n\t\t//! Specifies weather the result of the fit is a function curve\n\t\tvoid generateFunction(bool yes, int points = 100);\n\n\t\t//! Output string added to the plot as a new legend\n\t\tvirtual QString legendInfo();\n\n\t\t//! Returns a vector with the fit results\n\t\tdouble* results(){return d_results;};\n\n\t\t//! Returns a vector with the fit residuals\n\t\tdouble* residuals();\n\n\t\t//! Plot residuals and display data values in a column\n\t\tQwtPlotCurve* showResiduals();\n\n\t\tvoid showPredictionLimits(double confidenceLevel);\n\t\tvoid showConfidenceLimits(double confidenceLevel);\n\t\t//! Lower Confidence Limit\n\t\tdouble lcl(int parIndex, double confidenceLevel);\n\t\t//! Upper Confidence Limit\n\t\tdouble ucl(int parIndex, double confidenceLevel);\n\n\t\t//! Returns a vector with the standard deviations of the results\n\t\tdouble* errors();\n\n\t\t//! Returns the sum of squares of the residuals from the best-fit line\n\t\tdouble chiSquare() {return chi_2;};\n\n\t\t//! Returns R^2\n\t\tdouble rSquare();\n\n\t\t//! Returns adjusted R^2\n\t\tdouble adjustedRSquare(){return d_adjusted_r_square;};\n\n\t\t//! Returns the Residual Sum of Squares\n\t\tdouble rss(){return d_rss;};\n\n\t\t//! Returns the Root Mean Squared Error\n\t\tdouble rmse(){return sqrt(d_rss/(d_n - d_p));};\n\n\t\t//! Specifies wheather the errors must be scaled with sqrt(chi_2/dof)\n\t\tvoid scaleErrors(bool yes = true){d_scale_errors = yes;};\n\n\t\tTable* parametersTable(const QString& tableName);\n\t\tvoid writeParametersToTable(Table *t, bool append = false);\n\n\t\tMatrix* covarianceMatrix(const QString& matrixName);\n\r\n bool save(const QString& fileName);\r\n bool load(const QString& fileName);\r\n\r\n FitType type(){return d_fit_type;};\r\n void setType(FitType t){d_fit_type = t;};\r\n\r\n QString fileName(){return d_file_name;};\r\n\t\tvoid setFileName(const QString& fn){d_file_name = fn;};\r\n\r\n //! Frees the memory allocated for the X and Y data sets\r\n void freeMemory();\r\n\r\n //! Calculates the data for the output fit curve\r\n virtual double eval(double *, double){return 0.0;};\r\n\n\tprivate:\n\t\tvoid init();\n\n\t\t//! Pointer to the GSL multifit minimizer (for simplex algorithm)\n\t\tgsl_multimin_fminimizer * fitSimplex(gsl_multimin_function f, int &iterations, int &status);\n\n\t\t//! Pointer to the GSL multifit solver\n\t\tgsl_multifit_fdfsolver * fitGSL(gsl_multifit_function_fdf f, int &iterations, int &status);\n\n\t\t//! Customs and stores the fit results according to the derived class specifications. Used by exponential fits.\n\t\tvirtual void customizeFitResults(){};\n\n\tprotected:\n\t\t//! Allocates the memory for the fit workspace\n\t\tvoid initWorkspace(int par);\n\t\t//! Frees the memory allocated for the fit workspace\n\t\tvoid freeWorkspace();\n\t\t//! Adds the result curve as a FunctionCurve to the plot, if d_gen_function = true\n\t\tvirtual FunctionCurve * insertFitFunctionCurve(const QString& name, double *x, double *y, int penWidth = 1);\n\n\t\t//! Adds the result curve to the plot\n\t\tvirtual void generateFitCurve();\n\r\n //! Calculates the data for the output fit curve and store itin the X an Y vectors\r\n\t\tvirtual void calculateFitCurveData(double *X, double *Y) {Q_UNUSED(X) Q_UNUSED(Y)};\r\n\n\t\t//! Output string added to the result log\n\t\tvirtual QString logFitInfo(int iterations, int status);\n\n\t\tfit_function d_f;\n\t\tfit_function_df d_df;\n\t\tfit_function_fdf d_fdf;\n\t\tfit_function_simplex d_fsimplex;\n\n\t\t//! Number of fit parameters\n\t\tint d_p;\n\n\t\t//! Initial guesses for the fit parameters\n\t\tgsl_vector *d_param_init;\n\n\t\t/*! \\brief Tells whether the fitter uses non-linear/simplex fitting\n\t\t * with an initial parameters set, that must be freed in the destructor.\n\t\t */\n\t\tbool is_non_linear;\n\n\t\t//! weighting data set used for the fit\n\t\tdouble *d_w;\n\n\t\t//! Names of the fit parameters\n\t\tQStringList d_param_names;\n\n\t\t//! Stores a list of short explanations for the significance of the fit parameters\n\t\tQStringList d_param_explain;\n\n\t\t//! Specifies weather the result curve is a FunctionCurve or a normal curve with the same x values as the fit data\n\t\tbool d_gen_function;\n\n\t\t//! Algorithm type\n\t\tAlgorithm d_solver;\n\n\t\t//! The fit formula given on input\n\t\tQString d_formula;\n\n\t\t//! The result fit formula, where the fit parameters are replaced with the calculated values.\n\t\tQString d_result_formula;\n\n\t\t//! Covariance matrix\n\t\tgsl_matrix *covar;\n\n\t\t//! The kind of weighting to be performed on the data\n\t\tWeightingMethod d_weighting;\n\n\t\t//! The name of the weighting dataset\n\t\tQString weighting_dataset;\n\n\t\t//! Stores the result parameters\n\t\tdouble *d_results;\n\n\t\t//! Stores standard deviations of the result parameters\n\t\tdouble *d_errors;\n\n\t\t//! Stores fit residuals\n\t\tdouble *d_residuals;\n\n\t\t//! The sum of squares of the residuals from the best-fit line\n\t\tdouble chi_2;\n\n\t\t//! Residual sum of squares\n\t\tdouble d_rss;\n\n\t\t//! Adjusted R^2\n\t\tdouble d_adjusted_r_square;\n\n\t\t//! Specifies wheather the errors must be scaled with sqrt(chi_2/dof)\n\t\tbool d_scale_errors;\n\n\t\t//! Table window used for the output of fit parameters\n\t\tTable *d_param_table;\n\n\t\t//! Matrix window used for the output of covariance matrix\n\t\tMatrix *d_cov_matrix;\r\n\r\n\t\tFitType d_fit_type;\r\n\r\n\t\t//! Path of the XML file where the user stores the fit model\r\n QString d_file_name;\n\n\t\t//! Stores the left limits of the research interval for the result parameters\n\t\tdouble *d_param_range_left;\n\n\t\t//! Stores the right limits of the research interval for the result parameters\n\t\tdouble *d_param_range_right;\n};\n\n#endif\n", "meta": {"hexsha": "99feb4e564be453410786d11ebf4e8950b2cac05", "size": 9451, "ext": "h", "lang": "C", "max_stars_repo_path": "thirdparty/qtiplot/qtiplot/src/analysis/Fit.h", "max_stars_repo_name": "hoehnp/SpaceDesignTool", "max_stars_repo_head_hexsha": "9abd34048274b2ce9dbbb685124177b02d6a34ca", "max_stars_repo_licenses": ["IJG"], "max_stars_count": 6.0, "max_stars_repo_stars_event_min_datetime": "2018-09-05T12:41:59.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-01T05:34:23.000Z", "max_issues_repo_path": "thirdparty/qtiplot/qtiplot/src/analysis/Fit.h", "max_issues_repo_name": "hoehnp/SpaceDesignTool", "max_issues_repo_head_hexsha": "9abd34048274b2ce9dbbb685124177b02d6a34ca", "max_issues_repo_licenses": ["IJG"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2015-02-07T19:09:21.000Z", "max_issues_repo_issues_event_max_datetime": "2015-08-14T03:15:42.000Z", "max_forks_repo_path": "thirdparty/qtiplot/qtiplot/src/analysis/Fit.h", "max_forks_repo_name": "hoehnp/SpaceDesignTool", "max_forks_repo_head_hexsha": "9abd34048274b2ce9dbbb685124177b02d6a34ca", "max_forks_repo_licenses": ["IJG"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2015-03-25T15:50:31.000Z", "max_forks_repo_forks_event_max_datetime": "2017-12-06T12:16:47.000Z", "avg_line_length": 35.1338289963, "max_line_length": 116, "alphanum_fraction": 0.6528409692, "num_tokens": 2149, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8128673223709251, "lm_q2_score": 0.6688802603710086, "lm_q1q2_score": 0.5437109062345489}} {"text": "/* cheb/integ.c\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n#include \n#include \n#include \n#include \n#include \n\nint gsl_cheb_calc_integ(gsl_cheb_series * integ, const gsl_cheb_series * f)\n{\n const size_t n = f->order + 1;\n const double con = 0.25 * (f->b - f->a);\n\n if(integ->order != f->order) \n {\n GSL_ERROR (\"order of chebyshev series must be equal\", GSL_ENOMEM);\n }\n\n /* set the other parameters in the chebyshev struct */\n\n integ->a = f->a;\n integ->b = f->b;\n\n /* FIXME: should probably set integ->f[] as well */\n\n if(n == 1) {\n integ->c[0] = 0.;\n }\n else if(n == 2) {\n integ->c[1] = con * f->c[0];\n integ->c[0] = 2.0 * integ->c[1];\n }\n else {\n double sum = 0.0;\n double fac = 1.0;\n size_t i;\n for(i=1; i<=n-2; i++) {\n integ->c[i] = con * (f->c[i-1] - f->c[i+1])/((double)i);\n sum += fac * integ->c[i];\n fac = -fac;\n }\n integ->c[n-1] = con * f->c[n-2]/(n-1.0);\n sum += fac * integ->c[n-1];\n integ->c[0] = 2.0 * sum;\n }\n\n return GSL_SUCCESS;\n}\n", "meta": {"hexsha": "7720563080dde1b7f74315ab1bd1ee3ba93089f3", "size": 1845, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.6/cheb/integ.c", "max_stars_repo_name": "ielomariala/Hex-Game", "max_stars_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-12-18T18:09:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-10T11:31:28.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/cheb/integ.c", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-12-16T17:41:24.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-22T00:00:16.000Z", "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/cheb/integ.c", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 14.0, "max_forks_repo_forks_event_min_datetime": "2015-07-21T04:47:52.000Z", "max_forks_repo_forks_event_max_datetime": "2020-03-12T12:31:25.000Z", "avg_line_length": 27.9545454545, "max_line_length": 81, "alphanum_fraction": 0.6216802168, "num_tokens": 597, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7956581194449495, "lm_q2_score": 0.6825737473266735, "lm_q1q2_score": 0.5430953441804331}} {"text": "/*\nThis file is for the different functions for emitting and absorbing synchrotron photons\n*/\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"hdf5.h\"\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"mclib.h\"\n#include \n#include \"mpi.h\"\n#include \n#include \n#include \n#include \n\ndouble calcCyclotronFreq(double magnetic_field)\n{\n //B has to be in gauss\n return CHARGE_EL*magnetic_field/(2*M_PI*M_EL*C_LIGHT);\n}\n\ndouble calcEB(double magnetic_field)\n{\n //helper function to compare to vurm 2013\n return PL_CONST*calcCyclotronFreq(magnetic_field);\n}\n\ndouble calcBoundaryE(double magnetic_field, double temp)\n{\n //helper function to compare to vurm 2013\n return 14*pow(M_EL*C_LIGHT*C_LIGHT, 1.0/10.0)*pow(calcEB(magnetic_field), 9.0/10.0)*pow(calcDimlessTheta(temp), 3.0/10.0);\n}\n\ndouble calcDimlessTheta(double temp)\n{\n //temp has to be in kelvin\n return K_B*temp/(M_EL*C_LIGHT*C_LIGHT);\n}\n\ndouble calcB(double el_dens, double temp)\n{\n //calc the B field from assuming its some fraction of the matter energy density\n //assume equipartition here\n #if B_FIELD_CALC == INTERNAL_E\n return sqrt(8*M_PI*3*el_dens*K_B*temp/2);\n #else\n //otherwise calculate B from the total energy\n return sqrt(8*M_PI*EPSILON_B*(el_dens*M_P*C_LIGHT*C_LIGHT+4*A_RAD*temp*temp*temp*temp/3));\n #endif\n}\n\ndouble n_el_MJ(double el_dens, double dimlesstheta, double gamma)\n{\n //function to calulate the number density of electrons using the maxwell juttner distribution\n return el_dens*gamma*sqrt(gamma*gamma-1)*exp(-gamma/dimlesstheta)/(dimlesstheta*gsl_sf_bessel_Kn(2, 1.0/dimlesstheta));\n}\n\ndouble n_el_MB(double el_dens, double dimlesstheta, double gamma)\n{\n //function to calc the number density of electrons at a given dimensionless temp and lorentz factor with the maxwell boltzmann dist\n double temp=dimlesstheta*(M_EL*C_LIGHT*C_LIGHT)/K_B;\n double v=C_LIGHT*sqrt(1-(1/pow(gamma, 2)));\n \n return el_dens*4*M_PI*pow(M_EL/(2*M_PI*K_B*temp) , 3/2)*(v*C_LIGHT*C_LIGHT/(pow(gamma, 3)))*exp((-M_EL*pow(v, 2))/(2*K_B*temp));\n}\n\n//These functions are to calculate the emissivity from Wardzinski+ 2000\ndouble Z(double nu, double nu_c, double gamma )\n{\n return pow(sqrt(pow(gamma,2)-1)*exp(1/gamma)/(1+gamma) ,2*nu*gamma/nu_c);\n}\n\ndouble Z_sec_der(double nu, double nu_c, double gamma)\n{\n //calculated from mathematica and plugged in theta (from paper=pi/2)\n return nu*(-2*pow(gamma,3)*(1+gamma) + 4*pow(gamma,4)*(1+gamma-pow(gamma,2)-pow(gamma,3))*log(sqrt(pow(gamma,2)-1)*exp(1/gamma)/(1+gamma) ))/(nu_c*pow(gamma,5)*(1+gamma));\n}\n\ndouble chi(double dimlesstheta, double gamma)\n{\n double val=0;\n \n if (dimlesstheta<=0.08)\n {\n val=sqrt(2*dimlesstheta*(pow(gamma,2)-1)/(gamma*(3*pow(gamma,2)-1)));\n }\n else\n {\n val=sqrt(2*dimlesstheta/(3*gamma));\n }\n \n return val;\n}\n\ndouble gamma0(double nu, double nu_c, double dimlesstheta)\n{\n double val=0;\n\n if (dimlesstheta<=0.08)\n {\n val=sqrt(pow(1+(2*nu*dimlesstheta/nu_c)*(1+(9*nu*dimlesstheta/(2*nu_c))), (-1.0/3.0) ));\n }\n else\n {\n val=sqrt(pow((1+(4*nu*dimlesstheta/(3*nu_c))), (2.0/3.0)) );\n }\n \n return val;\n}\n\ndouble jnu(double nu, double nu_c, double dimlesstheta, double el_dens)\n{\n double dimlesstheta_ref=calcDimlessTheta(1e7);\n double gamma=gamma0(nu, nu_c, dimlesstheta);\n double val=0;\n \n if (dimlessthetanu_c);\n double dimlesstheta = params[1];//(params->dimlesstheta);\n double el_dens = params[2];//(params->el_dens);\n \n //printf(\"Nu %e nu_c %e dimlesstheta %e el_dens %e VAL %e\\n\", nu, nu_c, dimlesstheta, el_dens, jnu(nu, nu_c, dimlesstheta, el_dens)/(PL_CONST*nu));\n \n return jnu(nu, nu_c, dimlesstheta, el_dens)/(PL_CONST*nu);\n}\n\ndouble blackbody_ph_spect(double nu, void *p)\n{\n //struct jnu_params * params = (struct jnu_params *)p;\n double *params;\n params=(double *)p;\n double temp = params[0];//(params->nu_c);\n \n //printf(\"Nu %e nu_c %e dimlesstheta %e el_dens %e VAL %e\\n\", nu, nu_c, dimlesstheta, el_dens, jnu(nu, nu_c, dimlesstheta, el_dens)/(PL_CONST*nu));\n \n return (8*M_PI*nu*nu)/(exp(PL_CONST*nu/(K_B*temp))-1)/(C_LIGHT*C_LIGHT*C_LIGHT);\n}\n\n//the functions here are to calculate the total absorption cross section from Ghisellini+ 1991\ndouble C(double nu_ph, double nu_c, double gamma_el, double p_el)\n{\n return ((2.0*pow(gamma_el,2)-1)/(gamma_el*pow(p_el,2)))+2*nu_ph*((gamma_el/pow(p_el,2))-gamma_el*log((gamma_el+1)/p_el))/nu_c;\n}\n\ndouble G(double gamma_el, double p_el)\n{\n return sqrt(1-2*pow(p_el,2)*(gamma_el*log((gamma_el+1)/p_el)-1));\n}\n\ndouble G_prime(double gamma_el, double p_el)\n{\n return (3*gamma_el-(3*pow(gamma_el,2)-1)*log((gamma_el+1)/p_el))/G(gamma_el, p_el);\n}\n\ndouble synCrossSection(double el_dens, double T, double nu_ph, double p_el)\n{\n double b_cr=FINE_STRUCT*sqrt(M_EL*C_LIGHT*C_LIGHT/pow(R_EL,3.0));\n double B=calcB(el_dens, T);\n double nu_c=calcCyclotronFreq(B);\n double gamma_el=sqrt(p_el*p_el+1);\n \n //printf(\"calc gamma %e, temp %e\\n\", gamma_el, T);\n \n return (3.0*M_PI*M_PI/8.0)*(THOM_X_SECT/FINE_STRUCT)*(b_cr/B)*pow(nu_c/nu_ph, 2.0) * exp(-2*nu_ph*(gamma_el*log((gamma_el+1)/p_el)-1)/nu_c)* ((C(nu_ph, nu_c, gamma_el, p_el)/G(gamma_el, p_el))-(G_prime(gamma_el, p_el)/pow(G(gamma_el, p_el),2.0)));\n}\n\ndouble calcSynchRLimits(int frame_scatt, int frame_inj, double fps, double r_inj, char *min_or_max)\n{\n double val=r_inj;\n if (strcmp(min_or_max, \"min\")==0)\n {\n //printf(\"IN MIN\\nframe_scatt %e frame_inj %e fps %e r_inj %e C_LIGHT %e\\n\", frame_scatt, frame_inj, fps, r_inj, C_LIGHT);\n val+=(C_LIGHT*(frame_scatt-frame_inj)/fps - 0.5*C_LIGHT/fps);\n }\n else\n {\n //printf(\"IN MAX\\n\");\n val+=(C_LIGHT*(frame_scatt-frame_inj)/fps + 0.5*C_LIGHT/fps);\n }\n \n //printf(\"Val %e\\n\", val);\n \n return val;\n}\n\nint rebinSynchCompPhotons(struct photon **ph_orig, int *num_ph, int *num_null_ph, int *num_ph_emit, int *scatt_synch_num_ph, double **all_time_steps, int **sorted_indexes, int max_photons, double thread_theta_min, double thread_theta_max , gsl_rng * rand, FILE *fPtr)\n{\n int i=0, j=0, k=0, count=0, count_c_ph=0, end_count=(*scatt_synch_num_ph), idx=0, num_thread=1;\n #if defined(_OPENMP)\n num_thread=omp_get_num_threads();\n #endif\n int synch_comp_photon_count=0, synch_photon_count=0, num_avg=12, num_bins=(0.1)*max_photons; //some factor of the max number of photons that is specified in the mc.par file, num bins is also in test function\n double dtheta_bin=0.5*M_PI/180; //the size of the bin that we want to produce for spatial binning in theta\n int num_bins_theta=(thread_theta_max-thread_theta_min)/dtheta_bin;//try this many bins such that we have 0.5 degree resolution, can also try to do adaptive binning with constant SNR\n double avg_values[12]={0}; //number of averages that'll be taken is given by num_avg in above line\n double p0_min=DBL_MAX, p0_max=0, log_p0_min=0, log_p0_max=0;//look at p0 of photons not by frequency since its just nu=p0*C_LIGHT/PL_CONST\n double rand1=0, rand2=0, phi=0, theta=0;\n double min_range=0, max_range=0, energy=0;\n double ph_r=0, ph_theta=0, temp_theta_max=0, temp_theta_min=DBL_MAX;\n //int *synch_comp_photon_idx=NULL; make this an array b/c had issue with deallocating this memory for some reason\n int synch_comp_photon_idx[*scatt_synch_num_ph];\n //struct photon *rebin_ph=malloc(num_bins* sizeof (struct photon ));\n int num_null_rebin_ph=0;\n struct photon *tmp=NULL;\n double *tmp_double=NULL;\n int *tmp_int=NULL;\n gsl_histogram * h = gsl_histogram_alloc (num_bins);\n gsl_histogram2d * h_phi_theta = gsl_histogram2d_alloc (360, 180); //x is for phi goes from 0 to 2pi and y is for theta, goes from 0 to pi\n gsl_histogram2d_set_ranges_uniform (h_phi_theta, 0.0, 360.0,0.0, 180.0); //set the ranges to be 1 degree wide\n gsl_histogram2d_pdf * pdf_phi_theta = gsl_histogram2d_pdf_alloc (h_phi_theta->nx, h_phi_theta->ny);\n \n //calc min and max p0 and set the bins to be even within this interval\n //save the frequencies of photons to a\n //#pragma omp parallel for num_threads(num_thread) reduction(min:nu_min) reduction(max:nu_max)\n //synch_comp_photon_idx=malloc((*scatt_synch_num_ph)*sizeof(int));\n //if (synch_comp_photon_idx==NULL)\n //{\n // printf(\"Error with allocating space to hold data for synch_comp_photon_idx\\n\");\n // exit(1);\n //}\n \n \n fprintf(fPtr, \"In the rebin func; num_threads %d scatt_synch_num_ph %d, num_ph %d\\n\", num_thread, (*scatt_synch_num_ph), *num_ph);\n fflush(fPtr); //try to see if all the photons are being set to some value at the end of this function when allocating things\n \n /*\n count=0;\n for (i=0;i<*num_ph;i++)\n {\n //fprintf(fPtr, \"%d %c %e %e\\n\", i, (*ph_orig)[i].type, (*ph_orig)[i].weight, (*ph_orig)[i].p0 );\n //fflush(fPtr);\n \n if (((*ph_orig)[i].weight != 0) && (((*ph_orig)[i].type == COMPTONIZED_PHOTON) || ((*ph_orig)[i].type == OLD_COMPTONIZED_PHOTON)) && ((*ph_orig)[i].p0 > 0))\n {\n count++;\n }\n }\n fprintf(fPtr, \"in rebin: count is: %d and scatt_synch_num_ph is %d\\n\", count, *scatt_synch_num_ph );\n */\n int min_idx=0, max_idx=0;\n count=0;\n for (i=0;i<*num_ph;i++)\n {\n if (((*ph_orig)[i].weight != 0) && (((*ph_orig)[i].type == COMPTONIZED_PHOTON) || ((*ph_orig)[i].type == OLD_COMPTONIZED_PHOTON)) && ((*ph_orig)[i].p0 > 0))\n {\n //see if the photon's nu is larger than nu_max or smaller than nu_min\n if (((*ph_orig)[i].p0< p0_min))\n {\n //dont include any absorbed OLD_COMPTONIZED_PHOTON photons that have negative P0 values\n p0_min= (*ph_orig)[i].p0;\n min_idx=i;\n //fprintf(fPtr, \"new p0 min %e\\n\", (p0_min) );\n }\n \n if ((*ph_orig)[i].p0> p0_max)\n {\n p0_max= (*ph_orig)[i].p0;\n max_idx=i;\n //fprintf(fPtr, \"new p0 max %e\\n\", (p0_max) );\n }\n \n //look at min and max theta of photons\n ph_r=pow(((*ph_orig)[i].r0)*((*ph_orig)[i].r0) + ((*ph_orig)[i].r1)*((*ph_orig)[i].r1) + ((*ph_orig)[i].r2)*((*ph_orig)[i].r2),0.5);\n ph_theta=acos(((*ph_orig)[i].r2) /ph_r); //this is the photons theta psition in the FLASH grid, gives in radians\n \n if (ph_theta > temp_theta_max )\n {\n temp_theta_max=ph_theta;\n //fprintf(fPtr, \"The new max is: %e from photon %d with x: %e y: %e z: %e\\n\", temp_r_max, i, ((ph+i)->r0), (ph+i)->r1, (ph+i)->r2);\n }\n \n //if ((i==0) || (ph_rr0), (ph+i)->r1, (ph+i)->r2);\n }\n\n \n // also save the index of these photons because they wil become null later on\n //*(synch_comp_photon_idx+count)=i;\n synch_comp_photon_idx[count]=i;\n //fprintf(fPtr, \"Save index %d\\n\", i );\n count++;\n \n if ((*ph_orig)[i].type == COMPTONIZED_PHOTON)\n {\n //keep track of the number of COMPTONIZED_PHOTON photons so we can know if the array needs to be increased in size, also take num_null_ph into account in doing this\n count_c_ph+=1;\n }\n }\n else if (((*ph_orig)[i].type == SYNCHROTRON_POOL_PHOTON) && ((*ph_orig)[i].weight != 0))\n {\n synch_photon_count++;\n }\n }\n \n \n //temp_theta_min=floor(temp_theta_min*180/M_PI)*M_PI/180;\n //temp_theta_max=ceil(temp_theta_max*180/M_PI)*M_PI/180;\n num_bins_theta=1+(temp_theta_max-temp_theta_min)/dtheta_bin;\n \n fprintf(fPtr, \"min, max (keV): %e %e log p0 min, max: %e %e idx: %d %d\\n\", p0_min*C_LIGHT/1.6e-9,p0_max*C_LIGHT/1.6e-9 , log10(p0_min), log10(p0_max), min_idx, max_idx );\n fprintf(fPtr, \"min, max (theta in deg): %e %e number of bins %d count: %d\\n\", temp_theta_min*180/M_PI, temp_theta_max*180/M_PI, num_bins_theta, count );\n fflush(fPtr);\n \n if (num_bins_theta*num_bins>=max_photons)\n {\n fprintf(fPtr, \"The number of rebinned photons, %d, is larger than max_photons %d nd will not rebin efficiently. Adjust the parameters such that the number of bins in theta and energy are less than the number of photons that will lead to rebinning.\\n\", num_bins_theta*num_bins, max_photons);\n fflush(fPtr);\n printf( \"The number of rebinned photons, %d, is larger than max_photons %d nd will not rebin efficiently. Adjust the parameters such that the number of bins in theta and energy are less than the number of photons that will lead to rebinning.\\n\", num_bins_theta*num_bins, max_photons);\n exit(1);\n\n }\n\n gsl_histogram_set_ranges_uniform (h, log10(p0_min), log10(p0_max*(1+1e-6)));\n \n gsl_histogram * h_theta_space = gsl_histogram_alloc (num_bins_theta);\n gsl_histogram_set_ranges_uniform (h_theta_space, temp_theta_min, temp_theta_max+dtheta_bin);\n \n struct photon *rebin_ph=malloc(num_bins*num_bins_theta* sizeof (struct photon ));\n \n gsl_histogram2d * h_energy_theta = gsl_histogram2d_alloc (num_bins, num_bins_theta); //x is for energy and y is for spatial theta, goes from 0 to pi\n gsl_histogram2d_set_ranges_uniform (h_energy_theta, log10(p0_min), log10(p0_max*(1+1e-6)), temp_theta_min, temp_theta_max+dtheta_bin);\n\n\n\n \n //populate histogram for photons with nu that falss within the proper histogram bin\n //may not need this loop, can just check if the photon nu falls within the bin edges and do averages etc within next loop\n for (i=0;i<*num_ph;i++)\n {\n if (((*ph_orig)[i].weight != 0) && (((*ph_orig)[i].type == COMPTONIZED_PHOTON) || ((*ph_orig)[i].type == OLD_COMPTONIZED_PHOTON)) && ((*ph_orig)[i].p0 > 0))\n {\n //gsl_histogram_accumulate (h, log10((*ph_orig)[i].p0), (*ph_orig)[i].weight);\n gsl_histogram_increment (h, log10((*ph_orig)[i].p0));\n \n ph_r=pow(((*ph_orig)[i].r0)*((*ph_orig)[i].r0) + ((*ph_orig)[i].r1)*((*ph_orig)[i].r1) + ((*ph_orig)[i].r2)*((*ph_orig)[i].r2),0.5);\n ph_theta=acos(((*ph_orig)[i].r2) /ph_r); //this is the photons theta psition in the FLASH grid, gives in radians\n gsl_histogram_increment (h_theta_space, ph_theta);\n \n gsl_histogram2d_increment(h_energy_theta, log10((*ph_orig)[i].p0), ph_theta);\n\n }\n }\n \n //gsl_histogram_fprintf(fPtr, h_theta_space, \"%g\", \"%g\");\n gsl_histogram2d_fprintf(fPtr, h_energy_theta, \"%g\", \"%g\");\n\n //for the photons that fall within a given nu bin, histogram thier theta and phi and choose a random number to sample from the distribution to get the new photons' 4 momentum, to parallelize this can put num+ph lop outside and cpunt loop inside and make avg_value array 2D with count index and other index being the average values\n \n for (count=0;count 1)\n {\n for (j=0;j 0))\n {\n gsl_histogram_get_range(h, count, &min_range, &max_range);\n //if the photon nu falls in the count bin of the nu histogram then add it to the phi_theta 2d hist\n if ((log10((*ph_orig)[i].p0)< max_range ) && (log10((*ph_orig)[i].p0)>=min_range))\n {\n gsl_histogram2d_increment(h_phi_theta, fmod(atan2((*ph_orig)[i].p2,((*ph_orig)[i].p1)*180/M_PI + 360),360.0), (180/M_PI)*acos(((*ph_orig)[i].p3)/((*ph_orig)[i].p0)) );\n \n avg_values[0] += (*ph_orig)[i].r0*(*ph_orig)[i].weight; //used to calc weighted averages\n avg_values[1] += (*ph_orig)[i].r1*(*ph_orig)[i].weight;\n avg_values[2] += (*ph_orig)[i].r2*(*ph_orig)[i].weight;\n avg_values[3] += (*ph_orig)[i].s0*(*ph_orig)[i].weight;\n avg_values[4] += (*ph_orig)[i].s1*(*ph_orig)[i].weight;\n avg_values[5] += (*ph_orig)[i].s2*(*ph_orig)[i].weight;\n avg_values[6] += (*ph_orig)[i].s3*(*ph_orig)[i].weight;\n avg_values[7] += (*ph_orig)[i].num_scatt*(*ph_orig)[i].weight;\n avg_values[8] += (*ph_orig)[i].weight;\n \n //average theta and phi of photons\n avg_values[9] += fmod(atan2((*ph_orig)[i].p2,((*ph_orig)[i].p1)*180/M_PI + 360),360.0) *(*ph_orig)[i].weight;\n avg_values[10] += (180/M_PI)*acos(((*ph_orig)[i].p3)/((*ph_orig)[i].p0))*(*ph_orig)[i].weight;\n avg_values[11] +=(*ph_orig)[i].p0*(*ph_orig)[i].weight;\n }\n }\n }\n \n //fprintf(fPtr, \"bin %e-%e has %e photons\\n\",pow(10, min_range)*C_LIGHT/1.6e-9, pow(10,max_range)*C_LIGHT/1.6e-9, gsl_histogram_get(h, count));\n \n energy=avg_values[11]/avg_values[8];//pow(10,0.5*(max_range+min_range));\n \n //initiate pdf as the histogram of phi and theta\n gsl_histogram2d_pdf_init (pdf_phi_theta, h_phi_theta);\n \n //get two random values\n rand1=gsl_rng_uniform(rand);\n rand2=gsl_rng_uniform(rand);\n \n //choose random phi and theta value\n gsl_histogram2d_pdf_sample (pdf_phi_theta, rand1, rand2, &phi, &theta);//phi and theta are in degreesneed to convert into radians later\n \n phi=avg_values[9]/avg_values[8];\n theta=avg_values[10]/avg_values[8];\n \n (rebin_ph+count)->type = COMPTONIZED_PHOTON;\n \n (rebin_ph+count)->p0=energy;\n (rebin_ph+count)->p1=energy*sin(theta*M_PI/180)*cos(phi*M_PI/180);\n (rebin_ph+count)->p2=energy*sin(theta*M_PI/180)*sin(phi*M_PI/180);\n (rebin_ph+count)->p3=energy*cos(theta*M_PI/180);\n (rebin_ph+count)->comv_p0=0;\n (rebin_ph+count)->comv_p1=0;\n (rebin_ph+count)->comv_p2=0;\n (rebin_ph+count)->comv_p3=0;\n (rebin_ph+count)->r0=avg_values[0]/avg_values[8];\n (rebin_ph+count)->r1= avg_values[1]/avg_values[8];\n (rebin_ph+count)->r2=avg_values[2]/avg_values[8];\n (rebin_ph+count)->s0=avg_values[3]/avg_values[8]; // stokes parameterized are normalized such that I always =1\n (rebin_ph+count)->s1=avg_values[4]/avg_values[8];\n (rebin_ph+count)->s2=avg_values[5]/avg_values[8];\n (rebin_ph+count)->s3=avg_values[6]/avg_values[8];\n (rebin_ph+count)->num_scatt=avg_values[7]/avg_values[8];\n (rebin_ph+count)->weight=avg_values[8];\n (rebin_ph+count)->nearest_block_index=0; //hopefully this is not actually the block that this photon's located in b/c we need to get the 4 mometum in the findNearestProperties function\n \n \n \n //gsl_histogram2d_fprintf (stdout, h_phi_theta, \"%g\", \"%g\");\n //fprintf(fPtr, \"Chosen phi: %e chosen theta: %e weight: %e\\n\\n\", phi, theta, avg_values[8] );\n //reset the histogram and the pdf\n gsl_histogram2d_reset(pdf_phi_theta);\n gsl_histogram_reset(h_phi_theta);\n }\n else if (gsl_histogram_get(h, count) == 1)\n {\n gsl_histogram_get_range(h, count, &min_range, &max_range);\n //fprintf(fPtr, \"bin %e-%e has %e photons\\n\", pow(10, min_range)*C_LIGHT/1.6e-9, pow(10,max_range)*C_LIGHT/1.6e-9, 1.0);\n\n //for thr case of just 1 hoton being in the bin just set the rebinned photon to the one photons parameters\n for (i=0;i<*num_ph;i++)\n {\n if (((*ph_orig)[i].weight != 0) && (((*ph_orig)[i].type == COMPTONIZED_PHOTON) || ((*ph_orig)[i].type == OLD_COMPTONIZED_PHOTON))&& ((*ph_orig)[i].p0 > 0))\n {\n if ((log10((*ph_orig)[i].p0)< max_range ) && (log10((*ph_orig)[i].p0)>=min_range))\n {\n (rebin_ph+count)->p0=(*ph_orig)[i].p0;\n (rebin_ph+count)->p1=(*ph_orig)[i].p1;\n (rebin_ph+count)->p2=(*ph_orig)[i].p2;\n (rebin_ph+count)->p3=(*ph_orig)[i].p3;\n (rebin_ph+count)->comv_p0=(*ph_orig)[i].comv_p0;\n (rebin_ph+count)->comv_p1=(*ph_orig)[i].comv_p1;\n (rebin_ph+count)->comv_p2=(*ph_orig)[i].comv_p2;\n (rebin_ph+count)->comv_p3=(*ph_orig)[i].comv_p3;\n (rebin_ph+count)->r0=(*ph_orig)[i].r0;\n (rebin_ph+count)->r1= (*ph_orig)[i].r1;\n (rebin_ph+count)->r2=(*ph_orig)[i].r2; //y coordinate in flash becomes z coordinate in MCRaT\n (rebin_ph+count)->s0=(*ph_orig)[i].s0; //initalize stokes parameters as non polarized photon, stokes parameterized are normalized such that I always =1\n (rebin_ph+count)->s1=(*ph_orig)[i].s1;\n (rebin_ph+count)->s2=(*ph_orig)[i].s2;\n (rebin_ph+count)->s3=(*ph_orig)[i].s3;\n (rebin_ph+count)->num_scatt=(*ph_orig)[i].num_scatt;\n (rebin_ph+count)->weight=(*ph_orig)[i].weight;\n (rebin_ph+count)->nearest_block_index=(*ph_orig)[i].nearest_block_index; //hopefully this is not actually the block that this photon's located in b/c we need to get the 4 mometum in the findNearestProperties function\n \n \n i=*num_ph;\n }\n }\n }\n \n }\n else\n {\n //fprintf(fPtr, \"Rebinned Photon is a null photon because there are no photons in this energy bin.\\n\");\n (rebin_ph+count)->type = COMPTONIZED_PHOTON;\n \n gsl_histogram_get_range(h, count, &min_range, &max_range);\n energy=pow(10,0.5*(max_range+min_range));\n \n //fprintf(fPtr, \"bin %e-%e has %e photons\\n\", pow(10, min_range)*C_LIGHT/1.6e-9, pow(10,max_range)*C_LIGHT/1.6e-9, 0.0);\n\n \n (rebin_ph+count)->p0=energy;\n (rebin_ph+count)->p1=0;\n (rebin_ph+count)->p2=0;\n (rebin_ph+count)->p3=0;\n (rebin_ph+count)->comv_p0=0;\n (rebin_ph+count)->comv_p1=0;\n (rebin_ph+count)->comv_p2=0;\n (rebin_ph+count)->comv_p3=0;\n (rebin_ph+count)->r0=0;\n (rebin_ph+count)->r1= 0;\n (rebin_ph+count)->r2=0;\n (rebin_ph+count)->s0=1; // stokes parameterized are normalized such that I always =1\n (rebin_ph+count)->s1=0;\n (rebin_ph+count)->s2=0;\n (rebin_ph+count)->s3=0;\n (rebin_ph+count)->num_scatt=0;\n (rebin_ph+count)->weight=0;\n (rebin_ph+count)->nearest_block_index=-1; //hopefully this is not actually the block that this photon's located in b/c we need to get the 4 mometum in the findNearestProperties function\n\n }\n \n \n }\n \n \n //find indexes of old photons that will not become null photons\n //if the photons are OLD_COMPTONIZED_PHOTON photons make them have p0=-1\n //for the COMPTONIZED_PHOTON photons replace the first num_bins indexes with the new rebinned photons and replace the rest of the indexes with null values\n //may need to expand the array of photons, shouldnt need to do this though\n \n //this is a default setting, see comment below where there was an else statement that had the failing line\n //end_count=(scatt_synch_num_ph);\n \n if ((count_c_ph+(*num_null_ph))=0 ;i--)\n {\n //fprintf(fPtr, \"idx %d\\n\", i);\n //fflush(fPtr);\n if (((*ph_orig)[i].weight == 0) || (i >= *num_ph))\n {\n //preset values for the the newly created spots to hold the emitted phtoons in\n (*ph_orig)[i].weight=0;\n (*ph_orig)[i].nearest_block_index=-1;\n *(null_ph_indexes+j)=i; //save this information so we can use the same syntax for both cases in saving the emitted photon data\n fprintf(fPtr, \"NULL PHOTON INDEX %d\\n\", i);\n fflush(fPtr);\n j++;\n }\n \n }\n count_null_indexes=ph_tot; //use this to count the number fo null photons we have actually created, (this can help if we decide to directly double (or *1.5) number of photons each time we need to allocate more memory, then use factor*((*num_ph)+ph_tot)-(*num_ph)\n \n //loop through the original set of photons to see if\n \n fprintf(fPtr,\"Val %d\\n\", (*(null_ph_indexes+count_null_indexes-1)));\n *num_ph+=net_ph; //update number of photons\n *num_null_ph=ph_tot-null_ph_count; //((*num_ph)+ph_tot)-(*num_ph)-ph_tot; //reserved space - emitted photons-original photons\n fprintf(fPtr,\"old Num PH %d\\n\", *num_ph);\n fflush(fPtr);\n */\n \n *num_ph=( *num_ph)+(num_bins-count_c_ph+(*num_null_ph));\n end_count=(*scatt_synch_num_ph)+num_bins-count_c_ph+(*num_null_ph);\n }\n //else dont knwo why this is failing try to put this before if, so it gets sets and only if the above if statement is true will end_count be modified\n //{\n // end_count=(*scatt_synch_num_ph);\n //}\n \n //go through and assign the rebinned photons to the COMPTONIZED_PHOTON phtoons and make all OLD_COMPTONIZED_PHOTON photons become \"absorbed\"\n j=0;\n count=0;\n i=0;\n for (i=0;ip0;\n (*ph_orig)[idx].p1=(rebin_ph+count)->p1;\n (*ph_orig)[idx].p2=(rebin_ph+count)->p2;\n (*ph_orig)[idx].p3=(rebin_ph+count)->p3;\n (*ph_orig)[idx].comv_p0=(rebin_ph+count)->comv_p0;\n (*ph_orig)[idx].comv_p1=(rebin_ph+count)->comv_p1;\n (*ph_orig)[idx].comv_p2=(rebin_ph+count)->comv_p2;\n (*ph_orig)[idx].comv_p3=(rebin_ph+count)->comv_p3;\n (*ph_orig)[idx].r0=(rebin_ph+count)->r0;\n (*ph_orig)[idx].r1=(rebin_ph+count)->r1;\n (*ph_orig)[idx].r2=(rebin_ph+count)->r2; //y coordinate in flash becomes z coordinate in MCRaT\n (*ph_orig)[idx].s0=(rebin_ph+count)->s0; //initalize stokes parameters as non polarized photon, stokes parameterized are normalized such that I always =1\n (*ph_orig)[idx].s1=(rebin_ph+count)->s1;\n (*ph_orig)[idx].s2=(rebin_ph+count)->s2;\n (*ph_orig)[idx].s3=(rebin_ph+count)->s3;\n (*ph_orig)[idx].num_scatt=(rebin_ph+count)->num_scatt;\n (*ph_orig)[idx].weight=(rebin_ph+count)->weight;\n (*ph_orig)[idx].nearest_block_index=(rebin_ph+count)->nearest_block_index;\n (*ph_orig)[idx].type = COMPTONIZED_PHOTON;\n \n \n if ((rebin_ph+count)->weight==0)\n {\n //if the bin had no photons in it, the rebinned photon is effectively null\n //j++;\n num_null_rebin_ph++;\n }\n \n count++;\n \n }\n else\n {\n if ((*ph_orig)[idx].type == OLD_COMPTONIZED_PHOTON)\n {\n //if the photon is a compton scatered synch photon from a past frame treat it as though it has been absorbed\n (*ph_orig)[idx].p0=-1; //set its energy negative so we know for later analysis that it can't be used and its been \"absorbed\", this makes it still get saves in the hdf5 files\n (*ph_orig)[idx].nearest_block_index=-1;\n (*ph_orig)[idx].weight=0; //now making the absorbed OLD_COMPTONIZED_PHOTON photons become null photons\n\n }\n else\n {\n //all rebinned photns have been saved so just treat the rest of the phootn array as null photons\n (*ph_orig)[idx].weight=0;\n (*ph_orig)[idx].nearest_block_index=-1;\n //j++;\n }\n }\n \n \n }\n else if ((*ph_orig)[idx].type != SYNCHROTRON_POOL_PHOTON)\n {\n //this is a realloc photon that has to be set to null\n (*ph_orig)[idx].type = COMPTONIZED_PHOTON;\n (*ph_orig)[idx].weight=0;\n (*ph_orig)[idx].nearest_block_index=-1;\n\n }\n \n //if ((*ph_orig)[idx].weight==0)\n //{\n //if the bin had no photons in it, the rebinned photon is effectively null\n // j++;\n //}\n \n }\n \n //make sure that all the rebinned photons have been saved\n if (count 0))\n {\n count++;\n }\n }\n fprintf(fPtr, \"at end of rebin f(x): count is: %d and scatt_synch_num_ph is %d\\n\", count, *scatt_synch_num_ph );\n */\n \n ////gsl_histogram_fprintf (stdout, h, \"%g\", \"%g\");\n gsl_histogram_free (h); gsl_histogram_free(h_theta_space); gsl_histogram2d_free (h_energy_theta);\n gsl_histogram2d_pdf_free (pdf_phi_theta);\n gsl_histogram2d_free (h_phi_theta);\n free(rebin_ph);\n //free( synch_comp_photon_idx);\n \n return num_null_rebin_ph; //num_bins-num_null_rebin_ph;\n}\n\nint rebin2dSynchCompPhotons(struct photon **ph_orig, int *num_ph, int *num_null_ph, int *num_ph_emit, int *scatt_synch_num_ph, double **all_time_steps, int **sorted_indexes, int max_photons, double thread_theta_min, double thread_theta_max , gsl_rng * rand, FILE *fPtr)\n{\n int i=0, j=0, k=0, count=0, count_x=0, count_y=0, count_c_ph=0, end_count=(*scatt_synch_num_ph), idx=0, num_thread=1;\n #if defined(_OPENMP)\n num_thread=omp_get_num_threads();\n #endif\n int synch_comp_photon_count=0, synch_photon_count=0, num_avg=12, num_bins=(SYNCHROTRON_REBIN_E_PERC)*max_photons; //some factor of the max number of photons that is specified in the mc.par file, num bins is also in test function\n double dtheta_bin=SYNCHROTRON_REBIN_ANG*M_PI/180; //the size of the bin that we want to produce for spatial binning in theta\n int num_bins_theta=(thread_theta_max-thread_theta_min)/dtheta_bin;//try this many bins such that we have 0.5 degree resolution, can also try to do adaptive binning with constant SNR\n double avg_values[12]={0}; //number of averages that'll be taken is given by num_avg in above line\n double p0_min=DBL_MAX, p0_max=0, log_p0_min=0, log_p0_max=0;//look at p0 of photons not by frequency since its just nu=p0*C_LIGHT/PL_CONST\n double rand1=0, rand2=0, phi=0, theta=0;\n double min_range=0, max_range=0, min_range_theta=0, max_range_theta=0, energy=0;\n double ph_r=0, ph_theta=0, temp_theta_max=0, temp_theta_min=DBL_MAX;\n //int *synch_comp_photon_idx=NULL; make this an array b/c had issue with deallocating this memory for some reason\n int synch_comp_photon_idx[*scatt_synch_num_ph];\n //struct photon *rebin_ph=malloc(num_bins* sizeof (struct photon ));\n int num_null_rebin_ph=0, num_in_bin=0;\n struct photon *tmp=NULL;\n double *tmp_double=NULL;\n int *tmp_int=NULL;\n double count_weight=0;\n\n fprintf(fPtr, \"In the rebin func; num_threads %d scatt_synch_num_ph %d, num_ph %d\\n\", num_thread, (*scatt_synch_num_ph), *num_ph);\n fflush(fPtr);\n \n int min_idx=0, max_idx=0;\n count=0;\n for (i=0;i<*num_ph;i++)\n {\n if (((*ph_orig)[i].weight != 0) && (((*ph_orig)[i].type == COMPTONIZED_PHOTON) || ((*ph_orig)[i].type == OLD_COMPTONIZED_PHOTON)) && ((*ph_orig)[i].p0 > 0))\n {\n //see if the photon's nu is larger than nu_max or smaller than nu_min\n if (((*ph_orig)[i].p0< p0_min))\n {\n //dont include any absorbed OLD_COMPTONIZED_PHOTON photons that have negative P0 values\n p0_min= (*ph_orig)[i].p0;\n min_idx=i;\n //fprintf(fPtr, \"new p0 min %e\\n\", (p0_min) );\n }\n \n if ((*ph_orig)[i].p0> p0_max)\n {\n p0_max= (*ph_orig)[i].p0;\n max_idx=i;\n //fprintf(fPtr, \"new p0 max %e\\n\", (p0_max) );\n }\n \n //look at min and max theta of photons\n ph_r=pow(((*ph_orig)[i].r0)*((*ph_orig)[i].r0) + ((*ph_orig)[i].r1)*((*ph_orig)[i].r1) + ((*ph_orig)[i].r2)*((*ph_orig)[i].r2),0.5);\n ph_theta=acos(((*ph_orig)[i].r2) /ph_r); //this is the photons theta psition in the FLASH grid, gives in radians\n \n if (ph_theta > temp_theta_max )\n {\n temp_theta_max=ph_theta;\n //fprintf(fPtr, \"The new max is: %e from photon %d with x: %e y: %e z: %e\\n\", temp_r_max, i, ((ph+i)->r0), (ph+i)->r1, (ph+i)->r2);\n }\n \n //if ((i==0) || (ph_rr0), (ph+i)->r1, (ph+i)->r2);\n }\n\n \n // also save the index of these photons because they wil become null later on\n synch_comp_photon_idx[count]=i;\n //fprintf(fPtr, \"Save index %d\\n\", i );\n count++;\n \n if ((*ph_orig)[i].type == COMPTONIZED_PHOTON)\n {\n //keep track of the number of COMPTONIZED_PHOTON photons so we can know if the array needs to be increased in size, also take num_null_ph into account in doing this\n count_c_ph+=1;\n }\n }\n else if (((*ph_orig)[i].type == SYNCHROTRON_POOL_PHOTON) && ((*ph_orig)[i].weight != 0))\n {\n synch_photon_count++;\n }\n }\n \n \n num_bins_theta=1+(temp_theta_max-temp_theta_min)/dtheta_bin;\n \n fprintf(fPtr, \"Rebin: min, max (keV): %e %e log p0 min, max: %e %e idx: %d %d\\n\", p0_min*C_LIGHT/1.6e-9,p0_max*C_LIGHT/1.6e-9 , log10(p0_min), log10(p0_max), min_idx, max_idx );\n fprintf(fPtr, \"Rebin: min, max (theta in deg): %e %e number of bins %d count: %d\\n\", temp_theta_min*180/M_PI, temp_theta_max*180/M_PI, num_bins_theta, count );\n fflush(fPtr);\n \n if (count != end_count)\n {\n end_count=count; //need this for some reason idk why end_count gets off by 1 compared to what it should be\n fprintf(fPtr, \"Rebin: not equal to end_count therefore resetting count to be: %d\\n\", count );\n fflush(fPtr);\n }\n \n if (num_bins_theta*num_bins>=max_photons)\n {\n fprintf(fPtr, \"The number of rebinned photons, %d, is larger than max_photons %d and will not rebin efficiently. Adjust the parameters such that the number of bins in theta and energy are less than the number of photons that will lead to rebinning.\\n\", num_bins_theta*num_bins, max_photons);\n fflush(fPtr);\n \n printf(\"Rebin: min, max (theta in deg): %e %e number of bins %d count: %d\\n\", temp_theta_min*180/M_PI, temp_theta_max*180/M_PI, num_bins_theta, count );\n printf( \"In angle range: %e-%e: The number of rebinned photons, %d, is larger than max_photons %d and will not rebin efficiently. Adjust the parameters such that the number of bins in theta and energy are less than the number of photons that will lead to rebinning.\\n\", thread_theta_min*180/M_PI, thread_theta_max*180/M_PI, num_bins_theta*num_bins, max_photons);\n exit(1);\n\n }\n\n \n struct photon *rebin_ph=malloc(num_bins*num_bins_theta* sizeof (struct photon ));\n struct photon *synch_ph=malloc(synch_photon_count* sizeof (struct photon ));\n int synch_photon_idx[synch_photon_count];\n \n gsl_histogram2d * h_energy_theta = gsl_histogram2d_alloc (num_bins, num_bins_theta); //x is for energy and y is for spatial theta, goes from 0 to pi\n gsl_histogram2d_set_ranges_uniform (h_energy_theta, log10(p0_min), log10(p0_max*(1+1e-6)), temp_theta_min, temp_theta_max+dtheta_bin);\n\n //populate histogram for photons with nu that falss within the proper histogram bin\n //may not need this loop, can just check if the photon nu falls within the bin edges and do averages etc within next loop\n count=0;\n for (i=0;i<*num_ph;i++)\n {\n if (((*ph_orig)[i].weight != 0) && (((*ph_orig)[i].type == COMPTONIZED_PHOTON) || ((*ph_orig)[i].type == OLD_COMPTONIZED_PHOTON)) && ((*ph_orig)[i].p0 > 0))\n {\n \n ph_r=pow(((*ph_orig)[i].r0)*((*ph_orig)[i].r0) + ((*ph_orig)[i].r1)*((*ph_orig)[i].r1) + ((*ph_orig)[i].r2)*((*ph_orig)[i].r2),0.5);\n ph_theta=acos(((*ph_orig)[i].r2) /ph_r); //this is the photons theta psition in the FLASH grid, gives in radians\n \n gsl_histogram2d_increment(h_energy_theta, log10((*ph_orig)[i].p0), ph_theta);\n \n count_weight+=(*ph_orig)[i].weight;\n\n }\n \n if (((*ph_orig)[i].type == SYNCHROTRON_POOL_PHOTON) && ((*ph_orig)[i].weight != 0))\n {\n //save the sych photons here because they may get written over later and corrupted\n (synch_ph+count)->p0=(*ph_orig)[i].p0;\n (synch_ph+count)->p1=(*ph_orig)[i].p1;\n (synch_ph+count)->p2=(*ph_orig)[i].p2;\n (synch_ph+count)->p3=(*ph_orig)[i].p3;\n (synch_ph+count)->comv_p0=(*ph_orig)[i].comv_p0;\n (synch_ph+count)->comv_p1=(*ph_orig)[i].comv_p1;\n (synch_ph+count)->comv_p2=(*ph_orig)[i].comv_p2;\n (synch_ph+count)->comv_p3=(*ph_orig)[i].comv_p3;\n (synch_ph+count)->r0=(*ph_orig)[i].r0;\n (synch_ph+count)->r1= (*ph_orig)[i].r1;\n (synch_ph+count)->r2=(*ph_orig)[i].r2; //y coordinate in flash becomes z coordinate in MCRaT\n (synch_ph+count)->s0=(*ph_orig)[i].s0; //initalize stokes parameters as non polarized photon, stokes parameterized are normalized such that I always =1\n (synch_ph+count)->s1=(*ph_orig)[i].s1;\n (synch_ph+count)->s2=(*ph_orig)[i].s2;\n (synch_ph+count)->s3=(*ph_orig)[i].s3;\n (synch_ph+count)->num_scatt=(*ph_orig)[i].num_scatt;\n (synch_ph+count)->weight=(*ph_orig)[i].weight;\n (synch_ph+count)->nearest_block_index=(*ph_orig)[i].nearest_block_index; //hopefully this is not actually the block that this photon's located in b/c we need to get the 4 mometum in the findNearestProperties function\n synch_photon_idx[count]=i;\n count++;\n }\n \n }\n \n //fprintf(fPtr, \"counted_weight 1 %e\\n\", count_weight);\n //fflush(fPtr);\n //count_weight=0;\n //gsl_histogram2d_fprintf(fPtr, h_energy_theta, \"%g\", \"%g\");\n \n for (count_x=0;count_x 1)\n {\n \n rand1=gsl_rng_uniform(rand)*num_in_bin;//random photon to choose theta and phi of 4 mometum for rebinned photon\n \n for (j=0;j 0))\n {\n ph_r=pow(((*ph_orig)[i].r0)*((*ph_orig)[i].r0) + ((*ph_orig)[i].r1)*((*ph_orig)[i].r1) + ((*ph_orig)[i].r2)*((*ph_orig)[i].r2),0.5);\n ph_theta=acos(((*ph_orig)[i].r2) /ph_r); //this is the photons theta psition in the FLASH grid, gives in radians\n\n //if the photon nu falls in the count bin of the nu histogram then add it to the phi_theta 2d hist\n if ((log10((*ph_orig)[i].p0)< max_range ) && (log10((*ph_orig)[i].p0)>=min_range) && (ph_theta < max_range_theta) && (ph_theta >= min_range_theta))\n {\n //not doing average values, choosing random photon instead\n avg_values[0] += ph_r*(*ph_orig)[i].weight; // doing r, theta averages in space\n avg_values[1] += ph_theta*(*ph_orig)[i].weight;\n avg_values[2] += ((atan((*ph_orig)[i].p2/((*ph_orig)[i].p1))*180/M_PI)-(atan(((*ph_orig)[i].r1)/ ((*ph_orig)[i].r0))*180/M_PI))*(*ph_orig)[i].weight;// look at delta \\phi between the 4 mometum and its location\n avg_values[3] += (*ph_orig)[i].s0*(*ph_orig)[i].weight;\n avg_values[4] += (*ph_orig)[i].s1*(*ph_orig)[i].weight;\n avg_values[5] += (*ph_orig)[i].s2*(*ph_orig)[i].weight;\n avg_values[6] += (*ph_orig)[i].s3*(*ph_orig)[i].weight;\n avg_values[7] += (*ph_orig)[i].num_scatt*(*ph_orig)[i].weight;\n avg_values[8] += (*ph_orig)[i].weight;\n \n //get theta and phi of random photon\n {\n avg_values[9] += fmod(atan2((*ph_orig)[i].p2,((*ph_orig)[i].p1))*180/M_PI + 360.0,360.0) *(*ph_orig)[i].weight;\n avg_values[10] += (180/M_PI)*acos(((*ph_orig)[i].p3)/((*ph_orig)[i].p0))*(*ph_orig)[i].weight;\n\n }\n \n avg_values[11] +=(*ph_orig)[i].p0*(*ph_orig)[i].weight;\n \n j++;\n \n }\n }\n }\n \n \n energy=avg_values[11]/avg_values[8];\n \n \n phi=avg_values[9]/avg_values[8];\n theta=avg_values[10]/avg_values[8];\n \n (rebin_ph+count)->type = COMPTONIZED_PHOTON;\n \n \n (rebin_ph+count)->p0=energy;\n (rebin_ph+count)->p1=energy*sin(theta*M_PI/180)*cos(phi*M_PI/180);\n (rebin_ph+count)->p2=energy*sin(theta*M_PI/180)*sin(phi*M_PI/180);\n (rebin_ph+count)->p3=energy*cos(theta*M_PI/180);\n (rebin_ph+count)->comv_p0=0;\n (rebin_ph+count)->comv_p1=0;\n (rebin_ph+count)->comv_p2=0;\n (rebin_ph+count)->comv_p3=0;\n \n //calculate the rebinned photon's positional phi as a displacement from its 4-momentum phi direction\n rand1=(M_PI/180)*(phi-avg_values[2]/avg_values[8]);\n \n \n (rebin_ph+count)->r0= (avg_values[0]/avg_values[8])*sin(avg_values[1]/avg_values[8])*cos(rand1); //avg_values[0]/avg_values[8]; now do avg r * avg theta * random phi\n (rebin_ph+count)->r1= (avg_values[0]/avg_values[8])*sin(avg_values[1]/avg_values[8])*sin(rand1); //avg_values[1]/avg_values[8];\n (rebin_ph+count)->r2= (avg_values[0]/avg_values[8])*cos(avg_values[1]/avg_values[8]); //avg_values[2]/avg_values[8];\n\n (rebin_ph+count)->s0=avg_values[3]/avg_values[8]; // stokes parameterized are normalized such that I always =1\n (rebin_ph+count)->s1=avg_values[4]/avg_values[8];\n (rebin_ph+count)->s2=avg_values[5]/avg_values[8];\n (rebin_ph+count)->s3=avg_values[6]/avg_values[8];\n (rebin_ph+count)->num_scatt=avg_values[7]/avg_values[8];\n (rebin_ph+count)->weight=avg_values[8];\n (rebin_ph+count)->nearest_block_index=0; //hopefully this is not actually the block that this photon's located in b/c we need to get the 4 mometum in the findNearestProperties function\n \n //fprintf(fPtr, \"bin %e-%e, %e-%e has %e photons: Theta of averages photon is: %e\\n\",pow(10, min_range)*C_LIGHT/1.6e-9, pow(10,max_range)*C_LIGHT/1.6e-9, min_range_theta, max_range_theta, gsl_histogram2d_get(h_energy_theta, count_x, count_y), ph_theta);\n //fflush(fPtr);\n \n count_weight+=(rebin_ph+count)->weight;\n \n }\n else if (num_in_bin == 1)\n {\n //fprintf(fPtr, \"bin %e-%e has %e photons\\n\", pow(10, min_range)*C_LIGHT/1.6e-9, pow(10,max_range)*C_LIGHT/1.6e-9, 1.0);\n\n //for thr case of just 1 hoton being in the bin just set the rebinned photon to the one photons parameters\n for (i=0;i<*num_ph;i++)\n {\n if (((*ph_orig)[i].weight != 0) && (((*ph_orig)[i].type == COMPTONIZED_PHOTON) || ((*ph_orig)[i].type == OLD_COMPTONIZED_PHOTON))&& ((*ph_orig)[i].p0 > 0))\n {\n ph_r=pow(((*ph_orig)[i].r0)*((*ph_orig)[i].r0) + ((*ph_orig)[i].r1)*((*ph_orig)[i].r1) + ((*ph_orig)[i].r2)*((*ph_orig)[i].r2),0.5);\n ph_theta=acos(((*ph_orig)[i].r2) /ph_r); //this is the photons theta psition in the FLASH grid, gives in radians\n\n //if the photon nu falls in the count bin of the nu histogram then add it to the phi_theta 2d hist\n if ((log10((*ph_orig)[i].p0)< max_range ) && (log10((*ph_orig)[i].p0)>=min_range) && (ph_theta < max_range_theta) && (ph_theta >= min_range_theta))\n {\n (rebin_ph+count)->p0=(*ph_orig)[i].p0;\n (rebin_ph+count)->p1=(*ph_orig)[i].p1;\n (rebin_ph+count)->p2=(*ph_orig)[i].p2;\n (rebin_ph+count)->p3=(*ph_orig)[i].p3;\n (rebin_ph+count)->comv_p0=(*ph_orig)[i].comv_p0;\n (rebin_ph+count)->comv_p1=(*ph_orig)[i].comv_p1;\n (rebin_ph+count)->comv_p2=(*ph_orig)[i].comv_p2;\n (rebin_ph+count)->comv_p3=(*ph_orig)[i].comv_p3;\n (rebin_ph+count)->r0=(*ph_orig)[i].r0;\n (rebin_ph+count)->r1= (*ph_orig)[i].r1;\n (rebin_ph+count)->r2=(*ph_orig)[i].r2; //y coordinate in flash becomes z coordinate in MCRaT\n (rebin_ph+count)->s0=(*ph_orig)[i].s0; //initalize stokes parameters as non polarized photon, stokes parameterized are normalized such that I always =1\n (rebin_ph+count)->s1=(*ph_orig)[i].s1;\n (rebin_ph+count)->s2=(*ph_orig)[i].s2;\n (rebin_ph+count)->s3=(*ph_orig)[i].s3;\n (rebin_ph+count)->num_scatt=(*ph_orig)[i].num_scatt;\n (rebin_ph+count)->weight=(*ph_orig)[i].weight;\n (rebin_ph+count)->nearest_block_index=(*ph_orig)[i].nearest_block_index; //hopefully this is not actually the block that this photon's located in b/c we need to get the 4 mometum in the findNearestProperties function\n \n (rebin_ph+count)->type = COMPTONIZED_PHOTON;\n \n count_weight+=(rebin_ph+count)->weight;\n\n i=*num_ph;\n }\n }\n }\n }\n else\n {\n //fprintf(fPtr, \"Rebinned Photon is a null photon because there are no photons in this energy bin.\\n\");\n (rebin_ph+count)->type = COMPTONIZED_PHOTON;\n \n energy=pow(10,0.5*(max_range+min_range));\n \n //fprintf(fPtr, \"bin %e-%e has %e photons\\n\", pow(10, min_range)*C_LIGHT/1.6e-9, pow(10,max_range)*C_LIGHT/1.6e-9, 0.0);\n\n \n (rebin_ph+count)->p0=energy;\n (rebin_ph+count)->p1=0;\n (rebin_ph+count)->p2=0;\n (rebin_ph+count)->p3=0;\n (rebin_ph+count)->comv_p0=0;\n (rebin_ph+count)->comv_p1=0;\n (rebin_ph+count)->comv_p2=0;\n (rebin_ph+count)->comv_p3=0;\n (rebin_ph+count)->r0=0;\n (rebin_ph+count)->r1= 0;\n (rebin_ph+count)->r2=0;\n (rebin_ph+count)->s0=1; // stokes parameterized are normalized such that I always =1\n (rebin_ph+count)->s1=0;\n (rebin_ph+count)->s2=0;\n (rebin_ph+count)->s3=0;\n (rebin_ph+count)->num_scatt=0;\n (rebin_ph+count)->weight=0;\n (rebin_ph+count)->nearest_block_index=-1; //hopefully this is not actually the block that this photon's located in b/c we need to get the 4 mometum in the findNearestProperties function\n \n count_weight+=(rebin_ph+count)->weight;\n\n\n }\n \n \n \n }\n }\n \n //fprintf(fPtr, \"counted_weight 2 %e\\n\", count_weight);\n //fflush(fPtr);\n \n //exit(0);\n \n \n if ((count_c_ph+(*num_null_ph))p0;\n (*ph_orig)[idx].p1=(synch_ph+count)->p1;\n (*ph_orig)[idx].p2=(synch_ph+count)->p2;\n (*ph_orig)[idx].p3=(synch_ph+count)->p3;\n (*ph_orig)[idx].comv_p0=(synch_ph+count)->comv_p0;\n (*ph_orig)[idx].comv_p1=(synch_ph+count)->comv_p1;\n (*ph_orig)[idx].comv_p2=(synch_ph+count)->comv_p2;\n (*ph_orig)[idx].comv_p3=(synch_ph+count)->comv_p3;\n (*ph_orig)[idx].r0=(synch_ph+count)->r0;\n (*ph_orig)[idx].r1=(synch_ph+count)->r1;\n (*ph_orig)[idx].r2=(synch_ph+count)->r2; //y coordinate in flash becomes z coordinate in MCRaT\n (*ph_orig)[idx].s0=(synch_ph+count)->s0; //initalize stokes parameters as non polarized photon, stokes parameterized are normalized such that I always =1\n (*ph_orig)[idx].s1=(synch_ph+count)->s1;\n (*ph_orig)[idx].s2=(synch_ph+count)->s2;\n (*ph_orig)[idx].s3=(synch_ph+count)->s3;\n (*ph_orig)[idx].num_scatt=(synch_ph+count)->num_scatt;\n (*ph_orig)[idx].weight=(synch_ph+count)->weight;\n (*ph_orig)[idx].nearest_block_index=(synch_ph+count)->nearest_block_index;\n //(*ph_orig)[idx].type = SYNCHROTRON_POOL_PHOTON;\n \n count++;\n }\n }\n \n //go through the newly added phootns in the array and make sure that there are no SYNCHROTRON_POOL_PHOTON type photons there that can cause issues later on\n for (i=( *num_ph)-(num_bins*num_bins_theta-count_c_ph+(*num_null_ph));i<(*num_ph);i++)\n {\n if ((*ph_orig)[i].type == SYNCHROTRON_POOL_PHOTON)\n {\n (*ph_orig)[i].type = COMPTONIZED_PHOTON;\n }\n }\n \n /*\n fprintf(fPtr, \"\\nAfter Rebin: \\n\");\n fflush(fPtr);\n\n for (i=0;i<*num_ph;i++)\n {\n fprintf(fPtr, \"%d %c %e %e %e %d\\n\", i, (*ph_orig)[i].type, (*ph_orig)[i].weight, (*ph_orig)[i].p0, (*ph_orig)[i].s0, (*ph_orig)[i].nearest_block_index );\n\n }\n fprintf(fPtr, \"After Rebin: \\n\\n\");\n fflush(fPtr);\n */\n\n \n \n }\n \n //go through and assign the rebinned photons to the COMPTONIZED_PHOTON phtoons and make all OLD_COMPTONIZED_PHOTON photons become \"absorbed\"\n j=0;\n count=0;\n i=0;\n for (i=0;ip0;\n (*ph_orig)[idx].p1=(rebin_ph+count)->p1;\n (*ph_orig)[idx].p2=(rebin_ph+count)->p2;\n (*ph_orig)[idx].p3=(rebin_ph+count)->p3;\n (*ph_orig)[idx].comv_p0=(rebin_ph+count)->comv_p0;\n (*ph_orig)[idx].comv_p1=(rebin_ph+count)->comv_p1;\n (*ph_orig)[idx].comv_p2=(rebin_ph+count)->comv_p2;\n (*ph_orig)[idx].comv_p3=(rebin_ph+count)->comv_p3;\n (*ph_orig)[idx].r0=(rebin_ph+count)->r0;\n (*ph_orig)[idx].r1=(rebin_ph+count)->r1;\n (*ph_orig)[idx].r2=(rebin_ph+count)->r2; //y coordinate in flash becomes z coordinate in MCRaT\n (*ph_orig)[idx].s0=(rebin_ph+count)->s0; //initalize stokes parameters as non polarized photon, stokes parameterized are normalized such that I always =1\n (*ph_orig)[idx].s1=(rebin_ph+count)->s1;\n (*ph_orig)[idx].s2=(rebin_ph+count)->s2;\n (*ph_orig)[idx].s3=(rebin_ph+count)->s3;\n (*ph_orig)[idx].num_scatt=(rebin_ph+count)->num_scatt;\n (*ph_orig)[idx].weight=(rebin_ph+count)->weight;\n (*ph_orig)[idx].nearest_block_index=(rebin_ph+count)->nearest_block_index;\n (*ph_orig)[idx].type = COMPTONIZED_PHOTON;\n \n if ((rebin_ph+count)->weight==0)\n {\n //if the bin had no photons in it, the rebinned photon is effectively null\n //j++;\n num_null_rebin_ph++;\n }\n \n count++;\n \n }\n else\n {\n if ((*ph_orig)[idx].type == OLD_COMPTONIZED_PHOTON)\n {\n //if the photon is a compton scatered synch photon from a past frame treat it as though it has been absorbed\n (*ph_orig)[idx].p0=-1; //set its energy negative so we know for later analysis that it can't be used and its been \"absorbed\", this makes it still get saves in the hdf5 files\n (*ph_orig)[idx].nearest_block_index=-1;\n (*ph_orig)[idx].weight=0; //now making the absorbed OLD_COMPTONIZED_PHOTON photons become null photons\n //num_null_rebin_ph++;\n }\n else\n {\n //all rebinned photns have been saved so just treat the rest of the phootn array as null photons\n (*ph_orig)[idx].weight=0;\n (*ph_orig)[idx].nearest_block_index=-1;\n //j++;\n //num_null_rebin_ph++;\n }\n }\n \n \n }\n else if ((*ph_orig)[idx].type != SYNCHROTRON_POOL_PHOTON)\n {\n //this is a realloc photon that has to be set to null\n (*ph_orig)[idx].type = COMPTONIZED_PHOTON;\n (*ph_orig)[idx].weight=0;\n (*ph_orig)[idx].nearest_block_index=-1;\n //num_null_rebin_ph++;\n }\n \n if ((*ph_orig)[idx].weight==0)\n {\n //if the bin had no photons in it, the rebinned photon is effectively null\n j++;\n }\n \n }\n \n //make sure that all the rebinned photons have been saved\n if (count= rmin) && (*(r+i)-(*(szx+i))/2.0 < rmax ) && (*(theta+i)< theta_max) && (*(theta+i) >=theta_min) )\n {\n block_cnt+=1;\n }\n }\n \n fprintf(fPtr, \"Block cnt %d\\n\", block_cnt);\n fflush(fPtr);\n \n //min_photons=block_cnt;//do this so we have at least one synch photon in each block that meets the radius requiements, need to double check to see if this changes things or not (I dont expect it to)\n \n if (block_cnt==0)\n {\n min_photons=block_cnt; //this is for the case of there being no blocks near photons, probably b/c photons are off the hydro grid, and lets the program progress past the while loop below\n }\n \n //allocate memory to record density of photons for each block\n ph_dens=malloc(block_cnt * sizeof(int));\n \n \n //calculate the photon density for each block and save it to the array\n j=0;\n ph_tot=-1;\n ph_weight_adjusted=ph_weight;\n while ((ph_tot>max_photons) || (ph_tot= rmin) && (*(r+i)-(*(szx+i))/2.0 < rmax ) && (*(theta+i)< theta_max) && (*(theta+i) >=theta_min) )\n {\n //set parameters fro integration fo phtoons spectrum\n el_dens= (*(dens+i))/M_P;\n nu_c=calcCyclotronFreq(calcB(el_dens,*(temp+i)));\n dimlesstheta=calcDimlessTheta( *(temp+i));\n //fprintf(fPtr, \"B field is: %e at r=%e\\n\", calcB(el_dens,*(temp+i)), *(r+i));\n //fflush(fPtr);\n\n //printf(\"Temp %e, el_dens %e, B %e, nu_c %e, dimlesstheta %e\\n\",*(temp+i), el_dens, calcB(el_dens, *(temp+i), epsilon_b), nu_c, dimlesstheta);\n\n params[0] = *(temp+i); //nu_c;\n params[1]=dimlesstheta;\n params[2]= el_dens;\n F.params = ¶ms;\n \n //printf(\"Integrating\\n\"); //instead integrating from 0 to nu_c\n status=gsl_integration_qags(&F, 10, nu_c, 0, 1e-2, 10000, w, &ph_dens_calc, &error); //find number of low energy seed photons in the tail of the BB distribution\n //printf (\"error: %s\\n\", gsl_strerror (status));\n \n #if DIMENSIONS==2\n #if GEOMETRY == CARTESIAN\n //printf(\"ph_dens_calc init=%e\\n\", ph_dens_calc);\n ph_dens_calc*=2*M_PI*(*(x+i))*pow(*(szx+i),2.0)/(ph_weight_adjusted);\n #elif GEOMETRY == SPHERICAL\n ph_dens_calc*=2*M_PI*pow(*(r+i),2.0)*sin(*(theta+i))*(*(szx+i))*(*(szy+i))/(ph_weight_adjusted);\n #endif\n //printf(\"Temp %e, el_dens %e, B %e, nu_c %e, dimlesstheta %e, number of photons to emit %e, error %e, Intervals %zu\\n\", *(temp+i), el_dens, calcB(el_dens, *(temp+i), epsilon_b), nu_c, dimlesstheta, ph_dens_calc, error, w->size);\n //exit(0);\n #else\n #error Emitting photons with thermal synchrotron isnt available for non-2D hydro simulations.\n #endif\n\n \n (*(ph_dens+j))=gsl_ran_poisson(rand,ph_dens_calc) ; //choose from poission distribution with mean of ph_dens_calc\n \n //printf(\"%d, %lf \\n\",*(ph_dens+j), ph_dens_calc);\n \n //sum up all the densities to get total number of photons\n ph_tot+=(*(ph_dens+j));\n \n j++;\n }\n }\n \n if (ph_tot>max_photons)\n {\n //if the number of photons is too big make ph_weight larger\n ph_weight_adjusted*=10;\n \n }\n else if (ph_tot=0 ;i--)\n {\n //fprintf(fPtr, \"idx %d\\n\", i);\n //fflush(fPtr);\n if (((*ph_orig)[i].weight == 0) || (i >= *num_ph))\n {\n //preset values for the the newly created spots to hold the emitted phtoons in\n (*ph_orig)[i].weight=0;\n (*ph_orig)[i].nearest_block_index=-1;\n *(null_ph_indexes+j)=i; //save this information so we can use the same syntax for both cases in saving the emitted photon data\n //fprintf(fPtr, \"NULL PHOTON INDEX %d\\n\", i);\n //fflush(fPtr);\n j++;\n }\n }\n count_null_indexes=ph_tot; //use this to count the number fo null photons we have actually created, (this can help if we decide to directly double (or *1.5) number of photons each time we need to allocate more memory, then use factor*((*num_ph)+ph_tot)-(*num_ph)\n \n //loop through the original set of photons to see if\n \n //fprintf(fPtr,\"Val %d\\n\", (*(null_ph_indexes+count_null_indexes-1)));\n *num_ph+=net_ph; //update number of photons\n *num_null_ph=ph_tot-null_ph_count; //((*num_ph)+ph_tot)-(*num_ph)-ph_tot; //reserved space - emitted photons-original photons\n //fprintf(fPtr,\"New Num PH %d\\nNew null hum_ph %d\\n\", *num_ph, *num_null_ph);\n //fflush(fPtr);\n }\n else\n {\n //otherwise need to find the indexes of these null photons to save the newly emitted photons in them, start searching from the end of the array to efficiently find them\n //dont need to update the number of photons here\n null_ph_indexes=malloc(null_ph_count*sizeof(int));\n j=0;\n for (i=(*num_ph)-1;i>=0;i--)\n {\n if ((*ph_orig)[i].weight == 0) //if photons are null COMPTONIZED_PHOTON photons and not absorbed OLD_COMPTONIZED_PHOTON photons\n {\n // if the weight is 0, this is a photons that has been absorbed and is now null\n *(null_ph_indexes+j)=i;\n j++;\n //fprintf(fPtr, \"NULL PHOTON INDEX %d\\n\", i);\n //fflush(fPtr);\n \n if (j == null_ph_count)\n {\n i=-1; //have found al the indexes and can exit the loop, dont want to do this so we can do the first part of the if statement\n }\n }\n \n }\n \n count_null_indexes=null_ph_count;\n \n *num_null_ph=null_ph_count-ph_tot;\n \n }\n \n if (inject_single_switch == 0)\n {\n //go through blocks and assign random energies/locations to proper number of photons\n ph_tot=0;\n for (i=0;i= rmin) && (*(r+i)-(*(szx+i))/2.0 < rmax ) && (*(theta+i)< theta_max) && (*(theta+i) >=theta_min) )\n {\n \n el_dens= (*(dens+i))/M_P;\n nu_c=calcCyclotronFreq(calcB(el_dens,*(temp+i)));\n dimlesstheta=calcDimlessTheta( *(temp+i));\n max_jnu=2*jnu(nu_c/10, nu_c, dimlesstheta, el_dens);\n \n for(j=0;j<( *(ph_dens+k) ); j++ )\n {\n //printf(\"flash_array_idx: %d Temp %e, el_dens %e, B %e, nu_c %e, dimlesstheta %e\\n\",i, *(temp+i), el_dens, calcB(el_dens, *(temp+i), epsilon_b), nu_c, dimlesstheta);\n\n fr_dum=nu_c; //set the frequency directly to the cyclotron frequency\n //fprintf(fPtr, \"%lf\\n \",fr_dum);\n //exit(0);\n position_phi=gsl_rng_uniform(rand)*2*M_PI;\n com_v_phi=gsl_rng_uniform(rand)*2*M_PI;\n com_v_theta=gsl_rng_uniform(rand)*M_PI; // acos((gsl_rng_uniform(rand)*2)-1) this was for compton scatt, should be isotropic now?\n //printf(\"%lf, %lf, %lf\\n\", position_phi, com_v_phi, com_v_theta);\n \n //populate 4 momentum comoving array\n *(p_comv+0)=PL_CONST*fr_dum/C_LIGHT;\n *(p_comv+1)=(PL_CONST*fr_dum/C_LIGHT)*sin(com_v_theta)*cos(com_v_phi);\n *(p_comv+2)=(PL_CONST*fr_dum/C_LIGHT)*sin(com_v_theta)*sin(com_v_phi);\n *(p_comv+3)=(PL_CONST*fr_dum/C_LIGHT)*cos(com_v_theta);\n \n //populate boost matrix, not sure why multiplying by -1, seems to give correct answer in old python code...\n *(boost+0)=-1*(*(vx+i))*cos(position_phi);\n *(boost+1)=-1*(*(vx+i))*sin(position_phi);\n *(boost+2)=-1*(*(vy+i));\n //printf(\"%lf, %lf, %lf\\n\", *(boost+0), *(boost+1), *(boost+2));\n \n //boost to lab frame\n lorentzBoost(boost, p_comv, l_boost, 'p', fPtr);\n //printf(\"Assigning values to struct\\n\");\n \n idx=(*(null_ph_indexes+count_null_indexes-1));\n //fprintf(fPtr, \"Placing photon in index %d\\n\", idx);\n (*ph_orig)[idx].p0=(*(l_boost+0));\n (*ph_orig)[idx].p1=(*(l_boost+1));\n (*ph_orig)[idx].p2=(*(l_boost+2));\n (*ph_orig)[idx].p3=(*(l_boost+3));\n (*ph_orig)[idx].comv_p0=(*(p_comv+0));\n (*ph_orig)[idx].comv_p1=(*(p_comv+1));\n (*ph_orig)[idx].comv_p2=(*(p_comv+2));\n (*ph_orig)[idx].comv_p3=(*(p_comv+3));\n //position_rand=gsl_rng_uniform_pos(rand)*(*(szx+i))-(*(szx+i))/2.0; //choose between -size/2 to size/2\n (*ph_orig)[idx].r0= (*(x+i))*cos(position_phi); //put photons @center of the box with random phi\n (*ph_orig)[idx].r1=(*(x+i))*sin(position_phi) ;\n //position_rand=gsl_rng_uniform_pos(rand)*(*(szx+i))-(*(szx+i))/2.0; //choose between -size/2 to size/2\n (*ph_orig)[idx].r2=(*(y+i)); //y coordinate in flash becomes z coordinate in MCRaT\n (*ph_orig)[idx].s0=1; //initalize stokes parameters as non polarized photon, stokes parameterized are normalized such that I always =1\n (*ph_orig)[idx].s1=0;\n (*ph_orig)[idx].s2=0;\n (*ph_orig)[idx].s3=0;\n (*ph_orig)[idx].num_scatt=0;\n (*ph_orig)[idx].weight=ph_weight_adjusted;\n (*ph_orig)[idx].nearest_block_index=0; //these photons can be scattered\n (*ph_orig)[idx].type=SYNCHROTRON_POOL_PHOTON;\n //printf(\"%d\\n\",ph_tot);\n ph_tot++; //count how many photons have been emitted\n count_null_indexes--; //keep track fo the null photon indexes\n \n if ((count_null_indexes == 0) || (ph_tot == null_ph_count))\n {\n //if count_null_indexes is 0, then all the null photon spaces are filled with emitted photons\n //if ph_tot is equal to what it used to be\n i=array_length;\n printf(\"Exiting Emitting loop\\n\");\n }\n }\n k++;\n }\n }\n }\n else\n {\n //need to replace the scattered synch photon with another.\n //place new photon near the old one and make sure that it has the same nu_c as the other unscattered synch photons\n idx=(*(null_ph_indexes+count_null_indexes-1));\n i=(*ph_orig)[scatt_ph_index].nearest_block_index;\n \n el_dens= (*(dens+i))/M_P;\n nu_c=calcCyclotronFreq(calcB(el_dens,*(temp+i)));\n \n fr_dum=nu_c; //_scatt; //set the frequency directly to the cyclotron frequency\n //fprintf(fPtr, \"%lf %d\\n \",fr_dum, (*ph_orig)[scatt_ph_index].nearest_block_index);\n //exit(0);\n position_phi=gsl_rng_uniform(rand)*2*M_PI;\n com_v_phi=gsl_rng_uniform(rand)*2*M_PI;\n com_v_theta=gsl_rng_uniform(rand)*M_PI; // acos((gsl_rng_uniform(rand)*2)-1) this was for compton scatt, should be isotropic now?\n \n //populate 4 momentum comoving array\n *(p_comv+0)=PL_CONST*fr_dum/C_LIGHT;\n *(p_comv+1)=(PL_CONST*fr_dum/C_LIGHT)*sin(com_v_theta)*cos(com_v_phi);\n *(p_comv+2)=(PL_CONST*fr_dum/C_LIGHT)*sin(com_v_theta)*sin(com_v_phi);\n *(p_comv+3)=(PL_CONST*fr_dum/C_LIGHT)*cos(com_v_theta);\n \n //populate boost matrix, not sure why multiplying by -1, seems to give correct answer in old python code...\n *(boost+0)=-1*(*(vx+i))*cos(position_phi);\n *(boost+1)=-1*(*(vx+i))*sin(position_phi);\n *(boost+2)=-1*(*(vy+i));\n //printf(\"%lf, %lf, %lf\\n\", *(boost+0), *(boost+1), *(boost+2));\n \n //boost to lab frame\n lorentzBoost(boost, p_comv, l_boost, 'p', fPtr);\n \n //fprintf(fPtr, \"Placing photon in index %d\\n\", idx);\n (*ph_orig)[idx].p0=(*(l_boost+0));\n (*ph_orig)[idx].p1=(*(l_boost+1));\n (*ph_orig)[idx].p2=(*(l_boost+2));\n (*ph_orig)[idx].p3=(*(l_boost+3));\n (*ph_orig)[idx].comv_p0=(*(p_comv+0));\n (*ph_orig)[idx].comv_p1=(*(p_comv+1));\n (*ph_orig)[idx].comv_p2=(*(p_comv+2));\n (*ph_orig)[idx].comv_p3=(*(p_comv+3));\n //position_rand=gsl_rng_uniform_pos(rand)*(*(szx+i))-(*(szx+i))/2.0; //choose between -size/2 to size/2\n (*ph_orig)[idx].r0= (*(x+i))*cos(position_phi); //put photons at center of the box with random phi\n (*ph_orig)[idx].r1=(*(x+i))*sin(position_phi) ;\n //position_rand=gsl_rng_uniform_pos(rand)*(*(szx+i))-(*(szx+i))/2.0; //choose between -size/2 to size/2\n (*ph_orig)[idx].r2=(*(y+i)); //y coordinate in flash becomes z coordinate in MCRaT\n (*ph_orig)[idx].s0=1; //initalize stokes parameters as non polarized photon, stokes parameterized are normalized such that I always =1\n (*ph_orig)[idx].s1=0;\n (*ph_orig)[idx].s2=0;\n (*ph_orig)[idx].s3=0;\n (*ph_orig)[idx].num_scatt=0;\n (*ph_orig)[idx].weight=(*ph_orig)[scatt_ph_index].weight;\n (*ph_orig)[idx].nearest_block_index=i; //these photons can be scattered\n (*ph_orig)[idx].type=SYNCHROTRON_POOL_PHOTON;\n \n //change position of scattered synchrotron photon to be random in the hydro grid\n position_rand=gsl_rng_uniform_pos(rand)*(*(szx+i))-(*(szx+i))/2.0; //choose between -size/2 to size/2\n (*ph_orig)[scatt_ph_index].r0=(*(x+i)+position_rand)*cos(position_phi);\n (*ph_orig)[scatt_ph_index].r1=(*(x+i)+position_rand)*sin(position_phi);\n position_rand=gsl_rng_uniform_pos(rand)*(*(szx+i))-(*(szx+i))/2.0;\n (*ph_orig)[scatt_ph_index].r2=(*(y+i)+position_rand);\n \n }\n \n \n //printf(\"(*ph_orig)[0].p0 %e (*ph_orig)[71].p0 %e (*ph_orig)[72].p0 %e (*ph_orig)[73].p0 %e\\n\", (*ph_orig)[0].p0, (*ph_orig)[71].p0, (*ph_orig)[96].p0, (*ph_orig)[97].p0);\n //printf(\"At End of function\\n\");\n \n \n {\n free(null_ph_indexes);\n }\n \n //exit(0);\n free(ph_dens); free(p_comv); free(boost); free(l_boost);\n //free(ph_emit);\n \n gsl_integration_workspace_free (w);\n \n return ph_tot;\n \n}\n\ndouble phAbsSynch(struct photon **ph_orig, int *num_ph, int *num_abs_ph, int *scatt_synch_num_ph, double *temp, double *dens, FILE *fPtr)\n{\n int i=0, count=0, abs_ph_count=0, synch_ph_count=0, num_thread=1;\n int other_count=0;\n #if defined(_OPENMP)\n num_thread=omp_get_num_threads();\n #endif\n\n double el_dens=0, nu_c=0, abs_count=0;\n //struct photon tmp_ph;//hold temporay photon to move its data\n \n fprintf(fPtr, \"In phAbsSynch func begin: abs_ph_count: %d synch_ph_count: %d scatt_synch_num_ph: %d num_threads: %d\\n\", abs_ph_count, synch_ph_count, *scatt_synch_num_ph, num_thread);\n \n *scatt_synch_num_ph=0;//set thsi equal to 0, to recount in this function and get prepared for the next frame\n \n #pragma omp parallel for num_threads(num_thread) firstprivate(el_dens, nu_c) reduction(+:abs_ph_count)\n for (i=0;i<*num_ph;i++)\n {\n if (((*ph_orig)[i].weight != 0) && ((*ph_orig)[i].nearest_block_index != -1))\n {\n // if the photon isnt a null photon already, see if it should be absorbed\n \n el_dens= (*(dens+(*ph_orig)[i].nearest_block_index))/M_P;\n nu_c=calcCyclotronFreq(calcB(el_dens,*(temp+(*ph_orig)[i].nearest_block_index)));\n //printf(\"photon %d has lab nu %e comv frequency %e and nu_c %e with FLASH grid number %d\\n\", i, (*ph_orig)[i].p0*C_LIGHT/PL_CONST, (*ph_orig)[i].comv_p0*C_LIGHT/PL_CONST, nu_c, (*ph_orig)[i].nearest_block_index);\n if (((*ph_orig)[i].comv_p0*C_LIGHT/PL_CONST <= nu_c) || ((*ph_orig)[i].type == SYNCHROTRON_POOL_PHOTON))\n {\n //if the photon has a frequency less that nu_c, it should be absorbed and becomes a null photon\n //preset values for the the newly created spots to hold the emitted phtoons in;\n \n //if this is a synchrotron photons or photons that have been scattered that were once synch photons in this frame\n //fprintf(fPtr,\"photon %d being absorbed\\n\", i);\n if (((*ph_orig)[i].type != INJECTED_PHOTON) && ((*ph_orig)[i].type != OLD_COMPTONIZED_PHOTON) )\n {\n (*ph_orig)[i].weight=0;\n (*ph_orig)[i].nearest_block_index=-1;\n abs_ph_count++;\n \n if ((*ph_orig)[i].type == SYNCHROTRON_POOL_PHOTON)\n {\n synch_ph_count++;\n }\n }\n else\n {\n //have an injected photon or OLD_COMPTONIZED_PHOTON (previous COMPTONIZED_PHOTON photon) that has a nu that can be absorbed\n abs_count+=(*ph_orig)[i].weight;\n (*ph_orig)[i].p0=-1; //set its energy negative so we know for later analysis that it can't be used and its been absorbed, this makes it still get saves in the hdf5 files\n (*ph_orig)[i].nearest_block_index=-1;\n //also set the weight equal to 0 since we no longer care about saving it\n (*ph_orig)[i].weight=0;\n abs_ph_count++;\n\n }\n }\n else\n {\n //if the phootn isnt going to be absorbed, see if its a COMPTONIZED_PHOTON photon thats survived and change it to an injected type\n \n //replace the potantial null photon with this photon's data\n (*ph_orig)[count].p0=(*ph_orig)[i].p0;\n (*ph_orig)[count].p1=(*ph_orig)[i].p1;\n (*ph_orig)[count].p2=(*ph_orig)[i].p2;\n (*ph_orig)[count].p3=(*ph_orig)[i].p3;\n (*ph_orig)[count].comv_p0=(*ph_orig)[i].comv_p0;\n (*ph_orig)[count].comv_p1=(*ph_orig)[i].comv_p1;\n (*ph_orig)[count].comv_p2=(*ph_orig)[i].comv_p2;\n (*ph_orig)[count].comv_p3=(*ph_orig)[i].comv_p3;\n (*ph_orig)[count].r0= (*ph_orig)[i].r0;\n (*ph_orig)[count].r1=(*ph_orig)[i].r1 ;\n (*ph_orig)[count].r2=(*ph_orig)[i].r2;\n (*ph_orig)[count].s0=(*ph_orig)[i].s0;\n (*ph_orig)[count].s1=(*ph_orig)[i].s1;\n (*ph_orig)[count].s2=(*ph_orig)[i].s2;\n (*ph_orig)[count].s3=(*ph_orig)[i].s3;\n (*ph_orig)[count].num_scatt=(*ph_orig)[i].num_scatt;\n (*ph_orig)[count].weight=(*ph_orig)[i].weight;\n (*ph_orig)[count].nearest_block_index=(*ph_orig)[i].nearest_block_index;\n (*ph_orig)[count].type=(*ph_orig)[i].type;\n \n //increment count\n count+=1;\n \n if (((*ph_orig)[i].type == COMPTONIZED_PHOTON) || ((*ph_orig)[i].type == OLD_COMPTONIZED_PHOTON) )\n {\n //if the photon is a COMPTONIZED_PHOTON phton (scattered synch photon from the current frame) or a OLD_COMPTONIZED_PHOTON photon (scattered synch photon) from an old frame\n //count how many of these there are\n *scatt_synch_num_ph+=1;\n }\n \n }\n }\n else\n {\n //see if the photon was a previous INJECTED_PHOTON photon absorbed that we still have to account for in the array\n if (((*ph_orig)[i].p0 < 0) )\n {\n //replace the potantial null photon with this photon's data\n (*ph_orig)[count].p0=(*ph_orig)[i].p0;\n (*ph_orig)[count].p1=(*ph_orig)[i].p1;\n (*ph_orig)[count].p2=(*ph_orig)[i].p2;\n (*ph_orig)[count].p3=(*ph_orig)[i].p3;\n (*ph_orig)[count].comv_p0=(*ph_orig)[i].comv_p0;\n (*ph_orig)[count].comv_p1=(*ph_orig)[i].comv_p1;\n (*ph_orig)[count].comv_p2=(*ph_orig)[i].comv_p2;\n (*ph_orig)[count].comv_p3=(*ph_orig)[i].comv_p3;\n (*ph_orig)[count].r0= (*ph_orig)[i].r0;\n (*ph_orig)[count].r1=(*ph_orig)[i].r1 ;\n (*ph_orig)[count].r2=(*ph_orig)[i].r2;\n (*ph_orig)[count].s0=(*ph_orig)[i].s0;\n (*ph_orig)[count].s1=(*ph_orig)[i].s1;\n (*ph_orig)[count].s2=(*ph_orig)[i].s2;\n (*ph_orig)[count].s3=(*ph_orig)[i].s3;\n (*ph_orig)[count].num_scatt=(*ph_orig)[i].num_scatt;\n (*ph_orig)[count].weight=(*ph_orig)[i].weight;\n (*ph_orig)[count].nearest_block_index=(*ph_orig)[i].nearest_block_index;\n (*ph_orig)[count].type=(*ph_orig)[i].type;\n \n //increment count\n count+=1;\n }\n }\n \n //fprintf(fPtr, \"photon %d has energy %e and weight %e with FLASH grid number %d\\n\", i, (*ph_orig)[i].p0*C_LIGHT/1.6e-9, (*ph_orig)[i].weight, (*ph_orig)[i].nearest_block_index);\n }\n //fprintf(fPtr, \"In phAbsSynch func: abs_ph_count: %d synch_ph_count: %d scatt_synch_num_ph: %d\\n\", abs_ph_count, synch_ph_count, *scatt_synch_num_ph);\n *num_abs_ph=abs_ph_count; //+synch_ph_count; dont need this\n \n //fprintf(fPtr, \"In phAbsSynch func: count before_loop= %d\\n\", count);\n\n while (count<*num_ph)\n {\n //overwrite the last few photons to make sure that they are null photons\n (*ph_orig)[count].weight=0;\n (*ph_orig)[count].nearest_block_index=-1;\n //fprintf(fPtr, \"photon %d has frequency %e and weight %e with FLASH grid number %d\\n\", count, (*ph_orig)[count].comv_p0*C_LIGHT/PL_CONST, (*ph_orig)[count].weight, (*ph_orig)[count].nearest_block_index);\n //fflush(fPtr);\n \n count+=1;\n }\n //fprintf(fPtr, \"In phAbsSynch func: count after loop= %d\\n\", count);\n\n return abs_count;\n}\n\n\n", "meta": {"hexsha": "050b22730a693238f7634ec217d3beb9ba5c8481", "size": 100479, "ext": "c", "lang": "C", "max_stars_repo_path": "Src/mc_synch.c", "max_stars_repo_name": "outflows/MCRaT", "max_stars_repo_head_hexsha": "ad7e6a32b1a3136479f546adb2b50cdb1d2edb14", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Src/mc_synch.c", "max_issues_repo_name": "outflows/MCRaT", "max_issues_repo_head_hexsha": "ad7e6a32b1a3136479f546adb2b50cdb1d2edb14", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Src/mc_synch.c", "max_forks_repo_name": "outflows/MCRaT", "max_forks_repo_head_hexsha": "ad7e6a32b1a3136479f546adb2b50cdb1d2edb14", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2022-03-19T09:13:42.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-19T09:13:42.000Z", "avg_line_length": 48.7762135922, "max_line_length": 475, "alphanum_fraction": 0.5676310473, "num_tokens": 28082, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8723473746782093, "lm_q2_score": 0.6224593452091673, "lm_q1q2_score": 0.5430007756371343}} {"text": "/* mcmc.h\n * David W. Pearson\n * 17 July 2018\n * \n * This header file will be responsible for running Markov Chain Monte Carlo fitting.\n */\n\n#ifndef _MCMC_H_\n#define _MCMC_H_\n\n#include \"bispectrum_model.h\"\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nstd::random_device seeder;\nstd::mt19937_64 gen(seeder());\nstd::uniform_real_distribution dist(-1.0, 1.0);\n\nclass bkmcmc{\n int num_data, num_pars;\n std::vector data; // These should have size of num_data\n std::vector> Psi; // num_data vectors of size num_data\n std::vector theta_0, theta_i, param_vars, min, max; // These should all have size of num_pars\n std::vector k; // This should have size of num_data\n std::vector limit_pars; // This should have size of num_pars\n double chisq_0, chisq_i;\n \n // Sets the values of theta_i.\n void get_param_real(); // done\n \n // Calculates the chi^2 for the current proposal, theta_i\n double calc_chi_squared(); // done\n \n // Performs one MCMC trial. Returns true if proposal accepted, false otherwise\n bool trial(float4 *ks, double *Bk, double &L, double &R); // done\n \n // Writes the current accepted parameters to the screen\n void write_theta_screen(); // done\n \n // Burns the requested number of parameter realizations to move to a higher likelihood region\n void burn_in(int num_burn, float4 *ks, double *Bk); // done\n \n // Changes the initial guesses for the search range around parameters until acceptance = 0.234\n void tune_vars(float4 *ks, double *Bk); // done\n \n public:\n std::vector model; // These should have size num_data\n \n // Initializes most of the data members and gets an initial chisq_0\n bkmcmc(std::string data_file, std::string cov_file, std::vector &pars, \n std::vector &vars, float4 *ks, double *Bk); // done\n \n // Displays information to the screen to check that the vectors are all the correct size\n void check_init(); // done\n \n // Sets which parameters should be limited and what the limits are\n void set_param_limits(std::vector &lim_pars, std::vector &min_in,\n std::vector &max_in); // done\n \n // Runs the MCMC chain for num_draws realizations, writing to reals_file\n void run_chain(int num_draws, int num_burn, std::string reals_file, float4 *ks, double *Bk, bool new_chain);\n \n};\n\nvoid bkmcmc::get_param_real() {\n for (int i = 0; i < bkmcmc::num_pars; ++i) {\n if (bkmcmc::limit_pars[i]) {\n if (bkmcmc::theta_0[i] + bkmcmc::param_vars[i] > bkmcmc::max[i]) {\n double center = bkmcmc::max[i] - bkmcmc::param_vars[i];\n bkmcmc::theta_i[i] = center + dist(gen)*bkmcmc::param_vars[i];\n } else if (bkmcmc::theta_0[i] - bkmcmc::param_vars[i] < bkmcmc::min[i]) {\n double center = bkmcmc::min[i] + bkmcmc::param_vars[i];\n bkmcmc::theta_i[i] = center + dist(gen)*bkmcmc::param_vars[i];\n } else {\n bkmcmc::theta_i[i] = bkmcmc::theta_0[i] + dist(gen)*bkmcmc::param_vars[i];\n }\n } else {\n bkmcmc::theta_i[i] = bkmcmc::theta_0[i] + dist(gen)*bkmcmc::param_vars[i];\n }\n }\n}\n\ndouble bkmcmc::calc_chi_squared() {\n double chisq = 0.0;\n for (int i = 0; i < bkmcmc::num_data; ++i) {\n for (int j = i; j < bkmcmc::num_data; ++j) {\n if (bkmcmc::data[i] > 0 && bkmcmc::data[j] > 0) {\n chisq += (bkmcmc::data[i] - bkmcmc::model[i])*Psi[i][j]*(bkmcmc::data[j] - bkmcmc::model[j]);\n }\n }\n }\n return chisq;\n}\n\nbool bkmcmc::trial(float4 *ks, double *d_Bk, double &L, double &R) {\n bkmcmc::get_param_real();\n model_calc(bkmcmc::theta_i, ks, d_Bk, bkmcmc::model);\n bkmcmc::chisq_i = bkmcmc::calc_chi_squared();\n \n L = exp(0.5*(bkmcmc::chisq_0 - bkmcmc::chisq_i));\n R = (dist(gen) + 1.0)/2.0;\n \n if (L > R) {\n for (int i = 0; i < bkmcmc::num_pars; ++i)\n bkmcmc::theta_0[i] = bkmcmc::theta_i[i];\n bkmcmc::chisq_0 = bkmcmc::chisq_i;\n return true;\n } else {\n return false;\n }\n}\n\nvoid bkmcmc::write_theta_screen() {\n std::cout.precision(6);\n for (int i = 0; i < bkmcmc::num_pars; ++i) {\n std::cout.width(15);\n std::cout << bkmcmc::theta_0[i];\n }\n std::cout.width(15);\n std::cout << pow(bkmcmc::theta_0[3]*bkmcmc::theta_0[4]*bkmcmc::theta_0[4],1.0/3.0);\n std::cout.width(15);\n std::cout << bkmcmc::chisq_0;\n std::cout.flush();\n}\n\nvoid bkmcmc::burn_in(int num_burn, float4 *ks, double *d_Bk) {\n std::cout << \"Burning the first \" << num_burn << \" trials to move to higher likelihood...\" << std::endl;\n double L, R;\n for (int i = 0; i < num_burn; ++i) {\n bool move = bkmcmc::trial(ks, d_Bk, L, R);\n if (true) {\n std::cout << \"\\r\";\n std::cout.width(5);\n std::cout << i;\n bkmcmc::write_theta_screen();\n std::cout.width(15);\n std::cout << L;\n std::cout.width(15);\n std::cout << R;\n std::cout.flush();\n }\n }\n std::cout << std::endl;\n}\n\nvoid bkmcmc::tune_vars(float4 *ks, double *d_Bk) {\n std::cout << \"Tuning acceptance ratio...\" << std::endl;\n double acceptance = 0.0;\n while (acceptance <= 0.233 || acceptance >= 0.235) {\n int accept = 0;\n double L, R;\n for (int i = 0; i < 10000; ++i) {\n bool move = bkmcmc::trial(ks, d_Bk, L, R);\n if (move) {\n std::cout << \"\\r\";\n bkmcmc::write_theta_screen();\n accept++;\n }\n }\n std::cout << std::endl;\n acceptance = double(accept)/10000.0;\n \n if (acceptance <= 0.233) {\n for (int i = 0; i < bkmcmc::num_pars; ++i)\n bkmcmc::param_vars[i] *= 0.99;\n }\n if (acceptance >= 0.235) {\n for (int i = 0; i < bkmcmc::num_pars; ++i)\n bkmcmc::param_vars[i] *= 1.01;\n }\n std::cout << \"acceptance = \" << acceptance << std::endl;\n }\n std::ofstream fout;\n fout.open(\"variances.dat\", std::ios::out);\n for (int i = 0; i < bkmcmc::num_pars; ++i)\n fout << bkmcmc::param_vars[i] << \" \";\n fout << \"\\n\";\n fout.close();\n}\n\nbkmcmc::bkmcmc(std::string data_file, std::string cov_file, std::vector &pars, \n std::vector &vars, float4 *ks, double *d_Bk) {\n std::ifstream fin;\n std::ofstream fout;\n \n std::cout << \"Reading in and storing data file...\" << std::endl;\n if (std::ifstream(data_file)) {\n fin.open(data_file.c_str(), std::ios::in);\n while (!fin.eof()) {\n float4 kt;\n double B;\n fin >> kt.w >> kt.x >> kt.y >> kt.z >> B;\n if (!fin.eof()) {\n bkmcmc::k.push_back(kt);\n bkmcmc::data.push_back(B);\n bkmcmc::model.push_back(0.0);\n }\n }\n fin.close();\n } else {\n std::stringstream message;\n message << \"Could not open \" << data_file << std::endl;\n throw std::runtime_error(message.str());\n }\n \n bkmcmc::num_data = bkmcmc::data.size();\n std::cout << \"num_data = \" << bkmcmc::num_data << std::endl;\n \n gsl_matrix *cov = gsl_matrix_alloc(bkmcmc::num_data, bkmcmc::num_data);\n gsl_matrix *psi = gsl_matrix_alloc(bkmcmc::num_data, bkmcmc::num_data);\n gsl_permutation *perm = gsl_permutation_alloc(bkmcmc::num_data);\n \n std::cout << \"Reading in covariance and computing its inverse...\" << std::endl;\n if (std::ifstream(cov_file)) {\n fin.open(cov_file.c_str(), std::ios::in);\n for (int i = 0; i < bkmcmc::num_data; ++i) {\n for (int j = 0; j < bkmcmc::num_data; ++j) {\n double element;\n fin >> element;\n gsl_matrix_set(cov, i, j, element);\n }\n }\n fin.close();\n } else {\n std::stringstream message;\n message << \"Could not open \" << cov_file << std::endl;\n throw std::runtime_error(message.str());\n }\n \n int s;\n gsl_linalg_LU_decomp(cov, perm, &s);\n gsl_linalg_LU_invert(cov, perm, psi);\n \n for (int i = 0; i < bkmcmc::num_data; ++i) {\n std::vector row;\n row.reserve(bkmcmc::num_data);\n for (int j = 0; j < bkmcmc::num_data; ++j) {\n row.push_back((1.0 - double(bkmcmc::num_data + 1.0)/2048.0)*gsl_matrix_get(psi, i, j));\n }\n bkmcmc::Psi.push_back(row);\n }\n \n gsl_matrix_free(cov);\n gsl_matrix_free(psi);\n gsl_permutation_free(perm);\n \n gpuErrchk(cudaMemcpy(ks, bkmcmc::k.data(), bkmcmc::num_data*sizeof(float4), cudaMemcpyHostToDevice));\n \n gpuErrchk(cudaMemcpy(d_Bk, bkmcmc::model.data(), bkmcmc::num_data*sizeof(double), \n cudaMemcpyHostToDevice));\n \n bkmcmc::num_pars = pars.size();\n std::cout << \"num_pars = \" << bkmcmc::num_pars << std::endl;\n \n for (int i = 0; i < bkmcmc::num_pars; ++i) {\n bkmcmc::theta_0.push_back(pars[i]);\n bkmcmc::theta_i.push_back(0.0);\n bkmcmc::limit_pars.push_back(false);\n bkmcmc::max.push_back(0.0);\n bkmcmc::min.push_back(0.0);\n bkmcmc::param_vars.push_back(vars[i]);\n }\n \n std::cout << \"Calculating initial model and chi^2...\" << std::endl;\n model_calc(bkmcmc::theta_0, ks, d_Bk, bkmcmc::model);\n bkmcmc::chisq_0 = bkmcmc::calc_chi_squared();\n \n fout.open(\"Bk_mod_check.dat\", std::ios::out);\n for (int i =0; i < bkmcmc::num_data; ++i) {\n fout.precision(3);\n fout << bkmcmc::k[i].x << \" \" << bkmcmc::k[i].y << \" \" << bkmcmc::k[i].z << \" \";\n fout.precision(15);\n fout << bkmcmc::data[i] << \" \" << bkmcmc::model[i] << \"\\n\";\n }\n fout.close();\n}\n\nvoid bkmcmc::check_init() {\n std::cout << \"Number of data points: \" << bkmcmc::num_data << std::endl;\n std::cout << \" data.size() = \" << bkmcmc::data.size() << std::endl;\n std::cout << \" model.size() = \" << bkmcmc::model.size() << std::endl;\n std::cout << \" Psi.size() = \" << bkmcmc::Psi.size() << std::endl;\n std::cout << \"Number of parameters: \" << bkmcmc::num_pars << std::endl;\n std::cout << \" theta_0.size() = \" << bkmcmc::theta_0.size() << std::endl;\n std::cout << \" theta_i.size() = \" << bkmcmc::theta_i.size() << std::endl;\n std::cout << \" limit_pars.size()= \" << bkmcmc::limit_pars.size() << std::endl;\n std::cout << \" min.size() = \" << bkmcmc::min.size() << std::endl;\n std::cout << \" max.size() = \" << bkmcmc::max.size() << std::endl;\n std::cout << \" param_vars.size()= \" << bkmcmc::param_vars.size() << std::endl;\n}\n\nvoid bkmcmc::set_param_limits(std::vector &lim_pars, std::vector &min_in,\n std::vector &max_in) {\n for (int i = 0; i < bkmcmc::num_pars; ++i) {\n bkmcmc::limit_pars[i] = lim_pars[i];\n bkmcmc::max[i] = max_in[i];\n bkmcmc::min[i] = min_in[i];\n }\n}\n\nvoid bkmcmc::run_chain(int num_draws, int num_burn, std::string reals_file, float4 *ks, double *d_Bk, bool new_chain) {\n int num_old_rels = 0;\n if (new_chain) {\n std::cout << \"Starting new chain...\" << std::endl;\n bkmcmc::burn_in(num_burn, ks, d_Bk);\n bkmcmc::tune_vars(ks, d_Bk);\n } else {\n std::cout << \"Resuming previous chain...\" << std::endl;\n std::ifstream fin;\n fin.open(\"variances.dat\", std::ios::in);\n for (int i = 0; i < bkmcmc::num_pars; ++i) {\n double var;\n fin >> var;\n bkmcmc::param_vars[i] = var;\n }\n fin.close();\n fin.open(reals_file.c_str(), std::ios::in);\n while (!fin.eof()) {\n double alpha;\n num_old_rels++;\n std::cout << \"\\r\";\n for (int i = 0; i < bkmcmc::num_pars; ++i) {\n fin >> bkmcmc::theta_0[i];\n std::cout.width(10);\n std::cout << bkmcmc::theta_0[i];\n }\n fin >> alpha;\n fin >> bkmcmc::chisq_0;\n std::cout.width(10);\n std::cout << alpha;\n std::cout.width(10);\n std::cout << bkmcmc::chisq_0;\n }\n fin.close();\n num_old_rels--;\n }\n \n std::ofstream fout;\n double L, R;\n fout.open(reals_file.c_str(), std::ios::app);\n fout.precision(15);\n for (int i = 0; i < num_draws; ++i) {\n bool move = bkmcmc::trial(ks, d_Bk, L, R);\n for (int par = 0; par < bkmcmc::num_pars; ++par) {\n fout << bkmcmc::theta_0[par] << \" \";\n }\n double alpha = pow(bkmcmc::theta_0[3]*bkmcmc::theta_0[4]*bkmcmc::theta_0[4], 1.0/3.0);\n fout << alpha << \" \" << bkmcmc::chisq_0 << \"\\n\";\n if (move) {\n std::cout << \"\\r\";\n std::cout.width(15);\n std::cout << i + num_old_rels;\n bkmcmc::write_theta_screen();\n }\n }\n std::cout << std::endl;\n fout.close();\n}\n \n#endif\n", "meta": {"hexsha": "e32bd6f013212785a6da0fc6844cd3468fac91e9", "size": 13338, "ext": "h", "lang": "C", "max_stars_repo_path": "include/mcmc.h", "max_stars_repo_name": "dpearson1983/BIMODAL", "max_stars_repo_head_hexsha": "6fd93c1f75c190629ec272786c46ff46d9d7bd98", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "include/mcmc.h", "max_issues_repo_name": "dpearson1983/BIMODAL", "max_issues_repo_head_hexsha": "6fd93c1f75c190629ec272786c46ff46d9d7bd98", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "include/mcmc.h", "max_forks_repo_name": "dpearson1983/BIMODAL", "max_forks_repo_head_hexsha": "6fd93c1f75c190629ec272786c46ff46d9d7bd98", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.3433242507, "max_line_length": 119, "alphanum_fraction": 0.5434098066, "num_tokens": 4015, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8376199714402813, "lm_q2_score": 0.6477982043529715, "lm_q1q2_score": 0.5426087134292016}} {"text": "/* \n Compile as\n\n gcc compGraph2graph6.c -O2 -lgsl -lgslcblas -o compGraph2graph6\n*/ \n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n\n/* Order of input graphs - note this code will only work for orders smaller than 62 */\n#define N 19\n\n/* Maximum order we expect for the the comparability graph */\n#define MAX_ORDER 75000\n\n/* Forbidden eigenvalue of the star complement */\n#define SC_EIG 2 \n\n/* Specified precision used while doing floating point operations we treat EPS as zero */\n#define EPS 0.000001\n\n#define EXPECTED_CLIQUE 57\n\n/* graph6 related things */\n\n#define SIZELEN(n) ((n)<=SMALLN?1:((n)<=SMALLISHN?4:8))\n#define G6LEN(n) (SIZELEN(n) \\\n + ((size_t)(n)/12)*((size_t)(n)-1) + (((size_t)(n)%12)*((size_t)(n)-1)+11)/12)\n\n#define SMALLN 62\n#define BIAS6 63\n#define TOPBIT6 32\n#define SMALLISHN 258047\n#define MAXBYTE 126\n#define C6MASK 63\n\nstatic gsl_matrix *mat, *mat_inv;\nstatic gsl_permutation *perm;\n\nstatic gsl_vector *vecs[1<> 12);\n *p++ = BIAS6 + ((n >> 6) & C6MASK);\n *p++ = BIAS6 + (n & C6MASK);\n }\n *pp = p;\n}\n\n/* Given that mat_inv is the M = SC_EIG*I - A we \n compute all binary vectors x such that x M x^t == SC_EIG\n and x M j^t == -1. \n\n Finally for any pair x,y of such vectors we add an edge to our \n graph if x M y^t is either 0 or -1.\n*/\n\n/* This is a global thingie since declaring it localy as \n * an array of size 1<\n\n gsl_blas_ddot(vecs_prod[cache_size], vec_j, &res); //calculate and store it in space allocated for result\n \n if (fabs(res+1) < EPS) { //if = -1 (within EPS precision)\n gsl_blas_ddot(vecs_prod[cache_size], vecs[i], &res); //calculate and store it in space allocated for result\n\n if (fabs(res-SC_EIG) < EPS) { //if = r (within EPS precision)\n verts[cache_size] = vecs[i]; //it's a vertex, store vecs[i] in verts\n cache_size+=1; //search for the next vector\n } \n }\n }\n //we now have matched arrays vert[] and vec_prod[], with valid vertices in the former and in the latter\n if (cache_size < EXPECTED_CLIQUE) { //if there aren't enough elements to form target clique, no point in continuing, skip to next star complement candidate\n skipped++;\n return;\n }\n\n assert(cache_size < MAX_ORDER); //check if order is less than maximum allowed order\n\t//prepare to output compatibility graph\n char *p = gcode; //point *p at start of gcode\n encodegraphsize(cache_size, &p);\n\n int k = 6, x = 0; //initialize bit written counter and bit to be written\n\n for (i = 1; i < cache_size; i++) { //loop through all vertices u_i\n for (j = 0; j < i; j++) { //loop through up to , since = we don't have to check the rest as they will be checked in a later iteration\n x <<= 1; //ready next bit\n gsl_blas_ddot(vecs_prod[i], verts[j], &res); //calculate and store it in space allocated for result\n\n /* We have an edge */\n if (fabs(res) <= EPS || fabs(res+1) <= EPS) { //if = 0 or -1 (it's an edge)\n x |= 1; //set last bit of x to 1\n } \n if (--k == 0) { //decrease bit written counter\n *p++ = BIAS6 + x; //if we wrote 6 bits, add padding for ASCII character and write byte to where *p is pointing and advance pointer *p forward by 1 character\n k = 6; //reset counters\n x = 0;\n }\n \n }\n }\n\t//all full bytes written to gcode, prepare to write to file\n if (k != 6) { //if last byte is incomplete (still waiting to be written)\n *p++ = BIAS6 + (x << k); //push last bits to front, add padding, write to *p, advance *p\n } \n *p++ = '\\n'; //stitch on newline, advance *p\n *p = '\\0'; //stitch on null (to end string)\n\n fputs(gcode, outFile); //write to output file\n}\n\n\nstatic void init_vectors(void) {\n \n unsigned i,j;\n\n vec_j = gsl_vector_alloc(N); //allocate memory for vec_j with size N\n\n assert(vec_j); //check if vec_j was created successfully\n\n gsl_vector_set_all(vec_j, 1); //initialize vec_j as all 1's\n\n for (i = 0; i < 1< 1); //check if arguments were provided (you can provide multiple, only the first will be used though)\n \n infile = fopen(argv[1], \"r\"); //open first argument in read mode and point *infile at it\n mat = gsl_matrix_alloc(N, N); //allocate memory for mat as NxN matrix (not initialized yet, contents are garbage)\n mat_inv = gsl_matrix_alloc(N, N); //allocate memory for mat_inv as NxN matrix\n perm = gsl_permutation_calloc(N); //initialize perm as identity permutation of length N\n\n char buf[512]; //declare string of 511+1 characters\n\n snprintf(buf, sizeof(buf), \"%s.out\", argv[1]); //fill buf with name of input file, append .out to the name\n outFile = fopen(buf, \"w\"); //create file with name contained in buf in write mode, point *outFile at it\n\n assert (outFile && infile && mat && mat_inv && perm); //check if everything exists\n \n init_vectors();\n\n while (1) {\n if (!fgets(line, sizeof(line), infile)) \n break;\n stringtomat(line);\n constructGraph();\n nproc++;\n\t}\n \n printf(\"Successfuly processed: %u graphs. Skipped: %u\\n\" , nproc, skipped);\n\n return 0;\n}\n", "meta": {"hexsha": "0695cb17080eaf86979b101270df76c1ecd7af4f", "size": 8395, "ext": "c", "lang": "C", "max_stars_repo_path": "C/compGraph2graph6.c", "max_stars_repo_name": "ThatEvilChickenNextDoor/GMSwitchedGraph", "max_stars_repo_head_hexsha": "b4af75f318e5d9eb04ef3e01c5f74a8e898a3881", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "C/compGraph2graph6.c", "max_issues_repo_name": "ThatEvilChickenNextDoor/GMSwitchedGraph", "max_issues_repo_head_hexsha": "b4af75f318e5d9eb04ef3e01c5f74a8e898a3881", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "C/compGraph2graph6.c", "max_forks_repo_name": "ThatEvilChickenNextDoor/GMSwitchedGraph", "max_forks_repo_head_hexsha": "b4af75f318e5d9eb04ef3e01c5f74a8e898a3881", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.4462151394, "max_line_length": 236, "alphanum_fraction": 0.6096486004, "num_tokens": 2420, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8872046056466901, "lm_q2_score": 0.6113819732941511, "lm_q1q2_score": 0.5424209025159326}} {"text": "/*\n\nExcited States software: KGS\nContributors: See CONTRIBUTORS.txt\nContact: kgs-contact@simtk.org\n\nCopyright (C) 2009-2017 Stanford University\n\nPermission is hereby granted, free of charge, to any person obtaining a copy of\nthis software and associated documentation files (the \"Software\"), to deal in\nthe Software without restriction, including without limitation the rights to\nuse, copy, modify, merge, publish, distribute, sublicense, and/or sell copies\nof the Software, and to permit persons to whom the Software is furnished to do\nso, subject to the following conditions:\n\nThis entire text, including the above copyright notice and this permission notice\nshall be included in all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS, CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR\nOTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\nFROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\nIN THE SOFTWARE.\n\n*/\n\n#ifndef JACOBIANRELATED_H\n#define JACOBIANRELATED_H\n\n#include \n#include \n#include \n#include \n\n///These values have to be chosen according to the numerical analysis\nstatic const double SINGVAL_TOL = 0.000000000001; // only generic 10^-12\n//static const double SINGVAL_TOL = 0.000001; // include non-generic 10^-10\nstatic const double RIGID_TOL = 0.0000000001; //depends on molecule, but 10^-10 seems a good fit!\n//static const double RIGID_TOL = 0.000001; //depends on molecule ToDo: Adapt to obtain on-the-fly parameter selection\n\nclass NullSpaceRet\n{\npublic:\n//\tstatic gsl_matrix* Ut;//The Ut from the SVD\n\tstatic gsl_matrix* V;//The V from the SVD\n\tstatic gsl_vector* singularValues;\n\tint nullspaceSize;\n\tint m, n;\n\n//\tgsl_matrix* P;//Null-space projection matrix\n\tgsl_matrix* m_nullspaceBasis; //basis of the nullspace\n//\tgsl_matrix* Jinv;//Jacobian pseudo-inverse\n\n gsl_vector* m_rigidAngles;\n gsl_vector* m_rigidHBonds;\n\n int m_numCoordinated;\n int m_numRigid;\n int m_numRigidHBonds;\n\n\tNullSpaceRet (int input_m, int input_n);\n\t~NullSpaceRet ();\n\tvoid print();\n\n\t// A function to make the projection operation more efficient;\n\tvoid NullSpacePostCompute();\n\n\t/// A function that identifies rigidified dihedral angles\n\tvoid RigidityAnalysis(gsl_matrix* HBondJacobian);\n\t\n\t//A function to project a vector on the nullspace\n\tvoid ProjectOnNullSpace (gsl_vector *to_project, gsl_vector *after_project);\n\n\t// To manipulate owner configations of NullSpaceRet instances\n\tvoid numOwners(unsigned int numOwners);\n\tunsigned int numOwners() const;\nprivate:\n\tunsigned int numOwners_;\n};\n\nvoid nr_svd(gsl_matrix* a_g, int m, int n, double w[], gsl_matrix* v_out);\nvoid ComputeNullSpace(gsl_matrix* Jac, NullSpaceRet* Ret);\n//void ProjectOnNullSpace (NullSpaceRet* nullspace, gsl_vector *e, gsl_vector *to_project, gsl_vector *after_project);\nvoid TorsionUpdate(NullSpaceRet* nullspace, gsl_vector *e, double lambda, gsl_vector *dTheta);\n\n#endif\n\n", "meta": {"hexsha": "4cbd7c6edf6d56e7b0b4753c2fa4b01f8864e200", "size": 3241, "ext": "h", "lang": "C", "max_stars_repo_path": "src/JacobianRelated.h", "max_stars_repo_name": "XiyuChenFAU/kgs_vibration_entropy", "max_stars_repo_head_hexsha": "117c4a3d39ec6285eccc1d3b8e5de9a21db21ec9", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2020-05-23T18:26:14.000Z", "max_stars_repo_stars_event_max_datetime": "2020-05-23T18:26:14.000Z", "max_issues_repo_path": "src/JacobianRelated.h", "max_issues_repo_name": "XiyuChenFAU/kgs_vibration_entropy", "max_issues_repo_head_hexsha": "117c4a3d39ec6285eccc1d3b8e5de9a21db21ec9", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 8.0, "max_issues_repo_issues_event_min_datetime": "2017-01-26T19:54:38.000Z", "max_issues_repo_issues_event_max_datetime": "2021-02-06T16:06:30.000Z", "max_forks_repo_path": "src/JacobianRelated.h", "max_forks_repo_name": "XiyuChenFAU/kgs_vibration_entropy", "max_forks_repo_head_hexsha": "117c4a3d39ec6285eccc1d3b8e5de9a21db21ec9", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.0111111111, "max_line_length": 118, "alphanum_fraction": 0.7815489047, "num_tokens": 806, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8459424217727027, "lm_q2_score": 0.640635847978761, "lm_q1q2_score": 0.5419410407135622}} {"text": "/*\nProject 2: A Simple Ocean Model\nThis code models a set of equations for a 2-layer model of Ekman heat transport defined by F. Codron 2012: Ekman Heat Transport for Slab Oceans\nThe model is designed to take input from the Met Office Unified Model (UM) in .dat file form. As a result, this model uses the same spatial \nhorizontal resolution as the UM (90 latitude grid points and 144 longitude points, using spacing of 2.0 and 2.5 degrees respectively). The code\nsolves the heat transport using a finite difference method, and a sparse linear algebra GSL solver.\nModel can be ran on an Ubuntu terminal using the following set of commands:\n\tgcc -Wall -I/GSL_PATH/gsl/include -c pr2_ocean_transport_v7.c\n\tgcc -L/GSL_PATH/gsl/lib pr2_ocean_transport_v7.o -lgsl -lgslcblas -lm\n\t./a.out [-v {NO_TRANSPORT, DIFUSION_ONLY, DIFUSION_EKMAN}] \nwhere the options for -v are integers defined in enum Transport.\nCreated by Jake K. Eager\n*/\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#define C_D 0.0013 // drag coefficient, dimensionless\n#define C_V 4000.0 // specific heat capacity of water J/kg/K\n#define EMISSIVITY 0.985 // effective blackbody emissivity of ocean water\n#define HEAT_TRANSFER_COEFFICIENT 3000. /* heat transfer coefficient for water W/m2/K 50-3000*/\n#define RHO_AIR 1.22 // air density kg/m3\n#define RHO_WATER 1027 // km/m3\n#define R_PLANET (1.12384*6.371e6) // radius of planet in m (as fraction of Earth radius)\n#define EPSILON (0.00001) // 0.00001 pretty good need to find appropriate value\n#define OMEGA (6.501e-6) // angular frequency planet, about its central axis\n// #define OMEGA (7.272e-5) // Earth value for omega\n#define SIGMA (5.67e-8) // stefan boltzman constant\n#define H_S 50.0 // thickness of surface layer in m\n#define H_D 150.0 // thickness of deep layer below\n#define D (25000.0) // horizontal diffusion coefficient m2/s\n// #define D (25000.0*50.0/(H_S+H_D)) // horizontal diffusion coefficient m2/s MIGHT NEED THIS FIX, UNSURE...\n#define N_LATS 90 /* number of latitude points */\n#define N_LONS 144 /* number of longitude points */\n#define LAT_MIN -89.0\n#define DELTA_LAT 2.0\n#define LON_MIN 1.25\n#define DELTA_LON 2.5\n#define HOURS_PER_DAY 24.\n#define MINUTES_PER_HOUR 60.\n#define SECONDS_PER_MINUTE 60.\n#define DELTA_T (12.0*MINUTES_PER_HOUR*SECONDS_PER_MINUTE) // time step of 1 hours\n#define TIME_STEPS (20000*2) // for time step of 12 hours, 20,000 time steps needed for 10,000 day run\n#define TIME_OUTPUT_FREQ (25.0*HOURS_PER_DAY*MINUTES_PER_HOUR*SECONDS_PER_MINUTE) // print update frequency in seconds, but first term is number of days\n#define DATA_OUTPUT_FREQ (100.0*HOURS_PER_DAY*MINUTES_PER_HOUR*SECONDS_PER_MINUTE) // output frequency in seconds, but first term is number of days\n#define TIME_OUTPUT_TOL (1e-6) // days\n#define T_OFFSET 0.0 // IF you want to restart run, specify start time here, so it doesn't save over stuff, and change input temp files to output ones\n#define TOL (1e-6)\n#define MAX_ITER 100\n// input data files\n// #define LAND_MASK_DATA \"input_data/land_mask_day_cont_100_180.dat\"\n#define LAND_MASK_DATA \"input_data/land_mask_no_land.dat\"\n#define MAX_FILE_LINE_SIZE 4000\n#define SW_FLUX_NET_DOWN_DATA \"input_data/ProCb/surface_net_downward_shortwave_flux.dat\"\n#define LW_FLUX_DOWN_DATA \"input_data/ProCb/surface_downwelling_longwave_flux_in_air.dat\"\n// #define LW_FLUX_DOWN_DATA \"input_data/ProCb/surface_net_downward_longwave_flux.dat\"\n#define LATENT_UP_FLUX_DATA \"input_data/ProCb/surface_upward_latent_heat_flux.dat\"\n#define SENSIBLE_UP_FLUX_DATA \"input_data/ProCb/surface_upward_sensible_heat_flux.dat\"\n// #define INITIAL_SURFACE_TEMP_DATA \"output_data/ProCb/T_surf_1000_days.dat\"\n// #define INITIAL_DEEP_TEMP_DATA \"output_data/ProCb/T_deep_1000_days.dat\"\n#define INITIAL_SURFACE_TEMP_DATA \"input_data/ProCb/surface_temperature.dat\"\n#define INITIAL_DEEP_TEMP_DATA \"input_data/ProCb/surface_temperature.dat\"\n#define U_WIND_DATA \"input_data/ProCb/x_wind.dat\"\n#define V_WIND_DATA \"input_data/ProCb/y_wind.dat\"\n#define X_STRESS_DATA \"input_data/ProCb/surface_downward_eastward_stress.dat\"\n#define Y_STRESS_DATA \"input_data/ProCb/surface_downward_northward_stress.dat\"\n#define LATS_FILE \"input_data/lats.dat\"\n#define LONS_FILE \"input_data/lons.dat\"\n// output data files\n#define MAX_FNAME_CHAR 100\n// #define PYTHON_EXE \"python\"\n// #define PYTHON_SCRIPT \t\t\"plotting_scripts/temperature_contour_plot.py\"\n#define OUTPUT_UPWARD_Q_FLUX \"output_data/ProCb/upward_surface_Q_flux_\"\n#define OUTPUT_SURFACE_TEMP_DATA \"output_data/ProCb/T_surf_\"\n#define OUTPUT_DEEP_TEMP_DATA \"output_data/ProCb/T_deep_\"\n#define OUTPUT_X_MASS_FLUX_DATA \"output_data/ProCb/eastward_flow_\"\n#define OUTPUT_Y_MASS_FLUX_DATA \"output_data/ProCb/northward_flow_\"\n#define OUTPUT_VERITCAL_FLUX_DATA \"output_data/ProCb/vertical_mass_flux_\"\n#define OUTPUT_DATA_EXT \"_days.dat\"\n\n\ntypedef enum coords { THETA, PHI, N_COORDS } Coords;\ntypedef enum depths { SURFACE, DEEP, N_DEPTHS } Depths;\ntypedef enum transport {NO_TRANSPORT, DIFUSION_ONLY, DIFUSION_EKMAN} Transport;\ntypedef enum errors { MALLOC_ERR, FREE_ERR, FOPEN_ERR, DEPTH_ERR, DERIVATIVE_ERR, READ_DATA_ERR, SOLVER_ERR, VERSION_ERR } Errors;\n\ntypedef struct grid_vals { // values of latitude and longitude\n\tdouble lat[N_LATS];\n\tdouble lon[N_LONS];\n} Grid_vals;\n\nstatic int select_version(int argc, char **argv);\nstatic void time_stepper(int n_times, int n_lats, int n_lons, int version);\n\nint main(int argc, char **argv)\n{\n\tint version = select_version(argc, argv);\n\ttime_stepper(TIME_STEPS,N_LATS,N_LONS,version);\n\n\treturn 0;\n}\n\n/* Selects the whether to solve using no horizontal transport, diffusion only or diffusion and Ekman transport. */\nstatic int select_version(int argc, char **argv) \n{\n\textern char *optarg;\n\tint c, err = 0; \n\t// char *case_number=NULL;\n\tint version=DIFUSION_EKMAN; // default case is the step function test case\n\tstatic char usage[] = \"usage: %s [-v version_number] [name ...]\\n\"; \n\n\twhile ((c = getopt(argc, argv, \"v:\")) != -1)\n\t\tswitch (c) {\n\t\tcase 'v':\n\t\t\tversion=atoi(optarg);\n\t\t\tif(version!=NO_TRANSPORT && version!=DIFUSION_EKMAN && version!=DIFUSION_ONLY){\n\t\t\t\tfprintf(stderr, \"Version selected not valid, please enter [-v {%i, %i, %i}]\\n\", NO_TRANSPORT, DIFUSION_ONLY, DIFUSION_EKMAN);\n\t\t\t\texit(VERSION_ERR);\n\t\t\t}\n\t\t\tbreak;\n\t\tcase '?':\n\t\t\terr = 1;\n\t\t\tbreak;\n\t\t}\n\tif (err) {\n\t\tfprintf(stderr, usage, argv[0]);\n\t\texit(1);\n\t}\n\treturn version;\n}\n\n/* Checks memory allocation has been successful */\nstatic void *xmalloc(size_t n)\n{ \n void *p = malloc(n);\n if(p == NULL) {\n fprintf(stderr,\"Out of memory.\\n\");\n exit(MALLOC_ERR);\n }\n return p;\n}\n\n/* checks pointer being freed is not NULL */\nstatic void xfree(void *p)\n{\n\tif(p == NULL) {\n fprintf(stderr,\"Pointer is NULL, so cannot free.\\n\");\n exit(FREE_ERR);\n }\n\tfree(p);\n}\n\n/* allocates a 2d array of pointers */\nstatic int **create_2d_int_pointer(int n, int m)\n{\n\tint **p = (int **)xmalloc(n*sizeof(int*));\n\tfor(int i=0;i=n_lons){\n\t\t\t\tj_temp -=n_lons;\n\t\t\t}\n\t\t\treturn (A[i][j_temp]-A[i-1][j])/(2*d_theta);\n\t\t}\n\t\telse if(i==0){\n\t\t\tint j_temp = j+n_lons/2;\n\t\t\tif(j_temp>=n_lons){\n\t\t\t\tj_temp -=n_lons;\n\t\t\t}\n\t\t\treturn (A[i+1][j]-A[i][j_temp])/(2*d_theta);\n\t\t}\n\t\telse{\n\t\t\treturn (A[i+1][j]-A[i-1][j])/(2*d_theta);\n\t\t}\n\t}\n\telse if(a==PHI){\n\t\tif(j==n_lons-1){\n\t\t\treturn (A[i][0]-A[i][j-1])/(2*d_phi);\n\t\t}\n\t\telse if(j==0){\n\t\t\treturn (A[i][j+1]-A[i][n_lons-1])/(2*d_phi);\n\t\t}\n\t\telse{\n\t\t\treturn (A[i][j+1]-A[i][j-1])/(2*d_phi);\n\t\t}\n\t}\n\telse{\n\t\tfprintf(stderr, \"Specified derivative is not respect to either theta or phi\\n\");\n\t\texit(DERIVATIVE_ERR);\n\t}\n}\n\n/* Returns the horizontal divergence of quanitity M. determines whether there is an up or downward flow between the ocean layers */ \nstatic double calculate_div_M(double ***M, Grid_vals *grid, int i, int j, int n_lats, int n_lons)\n{\n\tdouble theta=deg_to_rad(grid->lat[i]);\n\tdouble dM_theta_dtheta = dA_da(M[THETA],i,j,THETA,n_lats,n_lons);\n\tdouble dM_phi_dphi = dA_da(M[PHI],i,j,PHI,n_lats,n_lons);\n\tdouble div_M=1./R_PLANET*(dM_theta_dtheta-tan(theta)*M[THETA][i][j]+1./cos(theta)*dM_phi_dphi);\n\treturn div_M;\n}\n\nstatic void calc_flow_Sv(double ***Sv_flow, double ***M, Grid_vals *grid, int n_lats, int n_lons)\n{\n\tfor(int i=0;ilat[i]);\n\t\tfor(int j=0;jlat[i]=LAT_MIN+(i*DELTA_LAT);\n\t\tfprintf(lats_out, \"%i\\t%lg\\n\", i, grid->lat[i]);\n\t}\n\tfclose(lats_out);\n\n\tFILE *lons_out;\n\tlons_out = xfopen(lons_file, \"w\" );\n\tfor(int j=0;jlon[j]=LON_MIN+(j*DELTA_LON);\n\t\tfprintf(lons_out, \"%i\\t%lg\\n\", j, grid->lon[j]);\n\t}\n\tfclose(lons_out);\n}\n\n/* Calculates the surface stress on the ocean surface as a result of the atmospheric winds near the surface. \nReads in velocity data from .dat files */\nstatic void calculate_surface_stress(double ***tau, Grid_vals *grid, int n_lats, int n_lons)\n{\n\tdouble ***v = create_3d_pointer(N_COORDS,N_LATS,N_LONS);\n\tread_input_data(v[THETA],V_WIND_DATA,n_lats,n_lons);\n\tread_input_data(v[PHI],U_WIND_DATA,n_lats,n_lons);\n\tfor(int coord=THETA;coordlat[i]);\n\t\tfor(int j=0;j=n_lons){\n\t\tnew_lon -= n_lons;\n\t}\n\treturn new_lon;\n}\n\n/* calculates and sets the matrix elements for a 2 layer ocean with 144 longitude points and 90 latitude points.\nversion determines whether the matrix is calculated for a no horizontal transport model, diffusion only model or the full Ekman model. */\nstatic void calculate_matrix(gsl_spmatrix *A, double ***M, int **land_mask, Grid_vals *grid, int n_lats, int n_lons, int version)\n{\n\tdouble d_theta=deg_to_rad(DELTA_LAT);\n\tdouble d_phi=deg_to_rad(DELTA_LON);\n\tdouble s_dfsn = DELTA_T*D/pow(R_PLANET,2);\n\t\n\tfor(int height=SURFACE; heightlat[lat]);\n\t\t\tfor(int lon=0; lon0.0){\n\t\t\t\t\t\t\t\tAii+=(+DELTA_T/(RHO_WATER*thickness)*div_M);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tgsl_spmatrix_set(A, i, i, Aii);\n\t\t\t\t/* Neigbouring points */\n\t\t\t\tint lon_j, lat_j;\n\t\t\t\tif(version != NO_TRANSPORT){\n\t\t\t\t\t/* neighbouring latitude - below */\n\t\t\t\t\tif(lat==0){\n\t\t\t\t\t\tlon_j = calculate_new_lon(lon,n_lons);\n\t\t\t\t\t\tlat_j = lat;\n\t\t\t\t\t\tj = calculate_matrix_index(height,lat_j,lon_j,n_lats,n_lons);\n\t\t\t\t\t}\n\t\t\t\t\telse{\n\t\t\t\t\t\tlon_j = lon;\n\t\t\t\t\t\tlat_j = lat-1;\n\t\t\t\t\t\tj = calculate_matrix_index(height,lat_j,lon_j,n_lats,n_lons);\n\t\t\t\t\t}\n\t\t\t\t\tAij=-s_dfsn*(1./pow(d_theta,2)+tan(theta)/(2*d_theta));\n\t\t\t\t\tif(version==DIFUSION_EKMAN){\n\t\t\t\t\t\tif(height==SURFACE){\n\t\t\t\t\t\t\tAij+= s_ekmn*(-M_theta/(2.*d_theta));\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse{\n\t\t\t\t\t\t\tAij+= -s_ekmn*(-M_theta/(2.*d_theta));\t\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif(land_mask[lat_j][lon_j]==1){\n\t\t\t\t\t\tAii+=Aij;\n\t\t\t\t\t\tAij=0.;\n\t\t\t\t\t}\n\t\t\t\t\tgsl_spmatrix_set(A, i, j, Aij);\n\t\t\t\t\t/* neighbouring latitude - above */\n\t\t\t\t\tif(lat==n_lats-1){\n\t\t\t\t\t\tlon_j = calculate_new_lon(lon,n_lons);\n\t\t\t\t\t\tlat_j = lat;\n\t\t\t\t\t\tj = calculate_matrix_index(height,lat_j,lon_j,n_lats,n_lons);\n\t\t\t\t\t}\n\t\t\t\t\telse{\n\t\t\t\t\t\tlon_j = lon;\n\t\t\t\t\t\tlat_j = lat+1;\n\t\t\t\t\t\tj = calculate_matrix_index(height,lat_j,lon_j,n_lats,n_lons);\n\t\t\t\t\t}\n\t\t\t\t\tAij=-s_dfsn*(1./pow(d_theta,2)-tan(theta)/(2*d_theta));\n\t\t\t\t\tif(version==DIFUSION_EKMAN){\n\t\t\t\t\t\tif(height==SURFACE){\n\t\t\t\t\t\t\tAij+= s_ekmn*(M_theta/(2.*d_theta));\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse{\n\t\t\t\t\t\t\tAij+= -s_ekmn*(M_theta/(2.*d_theta));\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif(land_mask[lat_j][lon_j]==1){\n\t\t\t\t\t\tAii+=Aij;\n\t\t\t\t\t\tAij=0.;\n\t\t\t\t\t}\n\t\t\t\t\tgsl_spmatrix_set(A, i, j, Aij);\n\t\t\t\t\t/* neighbouring longitude - left */\n\t\t\t\t\tif(lon==0){\n\t\t\t\t\t\tlon_j = n_lons-1;\n\t\t\t\t\t\tlat_j = lat;\n\t\t\t\t\t\tj = calculate_matrix_index(height,lat_j,lon_j,n_lats,n_lons);\n\t\t\t\t\t}\n\t\t\t\t\telse{\n\t\t\t\t\t\tlon_j = lon-1;\n\t\t\t\t\t\tlat_j = lat;\n\t\t\t\t\t\tj = calculate_matrix_index(height,lat_j,lon_j,n_lats,n_lons);\n\t\t\t\t\t}\n\t\t\t\t\tAij=-s_dfsn*1./pow(cos(theta)*d_phi,2);\n\t\t\t\t\tif(version==DIFUSION_EKMAN){\n\t\t\t\t\t\tif(height==SURFACE){\n\t\t\t\t\t\t\tAij+= s_ekmn*(-M_phi/(2.*d_phi*cos(theta)));\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse{\n\t\t\t\t\t\t\tAij+= -s_ekmn*(-M_phi/(2.*d_phi*cos(theta)));\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif(land_mask[lat_j][lon_j]==1){\n\t\t\t\t\t\tAii+=Aij;\n\t\t\t\t\t\tAij=0.;\n\t\t\t\t\t}\n\t\t\t\t\tgsl_spmatrix_set(A, i, j, Aij);\n\t\t\t\t\t/* neighbouring longitude - right */\n\t\t\t\t\tif(lon==n_lons-1){\n\t\t\t\t\t\tlon_j = 0;\n\t\t\t\t\t\tlat_j = lat;\n\t\t\t\t\t\tj = calculate_matrix_index(height,lat_j,lon_j,n_lats,n_lons);\n\t\t\t\t\t}\n\t\t\t\t\telse{\n\t\t\t\t\t\tlon_j = lon+1;\n\t\t\t\t\t\tlat_j = lat;\n\t\t\t\t\t\tj = calculate_matrix_index(height,lat_j,lon_j,n_lats,n_lons);\n\t\t\t\t\t}\n\t\t\t\t\tAij=-s_dfsn*1./pow(cos(theta)*d_phi,2);\n\t\t\t\t\tif(version==DIFUSION_EKMAN){\n\t\t\t\t\t\tif(height==SURFACE){\n\t\t\t\t\t\t\tAij+= s_ekmn*(M_phi/(2.*d_phi*cos(theta)));\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse{\n\t\t\t\t\t\t\tAij+= -s_ekmn*(M_phi/(2.*d_phi*cos(theta)));\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tif(land_mask[lat_j][lon_j]==1){\n\t\t\t\t\t\tAii+=Aij;\n\t\t\t\t\t\tAij=0.;\n\t\t\t\t\t}\n\t\t\t\t\tgsl_spmatrix_set(A, i, j, Aij);\n\t\t\t\t\tgsl_spmatrix_set(A, i, i, Aii);\n\t\t\t\t\t/* interaction between deep and surface layer */\n\t\t\t\t\tif(version==DIFUSION_EKMAN){\n\t\t\t\t\t\tif(height==SURFACE && div_M>0.0){\n\t\t\t\t\t\t\tAij=(-DELTA_T/(RHO_WATER*thickness)*div_M);\n\t\t\t\t\t\t\tj = calculate_matrix_index(DEEP,lat,lon,n_lats,n_lons);\n\t\t\t\t\t\t\tgsl_spmatrix_set(A, i, j, Aij);\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse if(height==DEEP && div_M<0.0){\n\t\t\t\t\t\t\tAij=(+DELTA_T/(RHO_WATER*thickness)*div_M);\n\t\t\t\t\t\t\tj = calculate_matrix_index(SURFACE,lat,lon,n_lats,n_lons);\n\t\t\t\t\t\t\tgsl_spmatrix_set(A, i, j, Aij);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n\n/* Reads in atmospheric fluxes, net stellar sw flux (subrtracts reflected sw radiation from the incident) \nand incoming lw flux from atmospheric emission */\nstatic void calculate_F_a(double **F_a, int n_lats, int n_lons)\n{\n\tdouble **F_net_sw_down = create_2d_pointer(n_lats,n_lons);\n\tdouble **F_lw_down = create_2d_pointer(n_lats,n_lons);\n\tdouble **F_latent_up = create_2d_pointer(n_lats,n_lons);\n\tdouble **F_sensible_up = create_2d_pointer(n_lats,n_lons);\n\tread_input_data(F_net_sw_down,SW_FLUX_NET_DOWN_DATA,n_lats,n_lons);\n\tread_input_data(F_lw_down,LW_FLUX_DOWN_DATA,n_lats,n_lons);\n\tread_input_data(F_latent_up,LATENT_UP_FLUX_DATA,n_lats,n_lons);\n\tread_input_data(F_sensible_up,SENSIBLE_UP_FLUX_DATA,n_lats,n_lons);\n\tfor(int i=0;iT[SURFACE][i][j]){ /* convection condition */\n\t\t\t\tF_c[i][j] = HEAT_TRANSFER_COEFFICIENT*(T[DEEP][i][j]-T[SURFACE][i][j]);\n\t\t\t}\n\t\t\telse{\n\t\t\t\tF_c[i][j] = 0.0;\n\t\t\t}\n\t\t}\n\t}\n}\n\n/* calculated and sets the vector b in matrix Ax=b. EMISSIVITY*SIGMA*T^4 is a blackbody emission from one of the layers, \nto ensure an energy exchange between the layers. 1.0/(RHO_WATER*C_V*H_S) prefactor converts a flux in W/m2 to K/s */\nstatic void calculate_vector_b(double ***T, int **land_mask, gsl_vector *b, int n_lats, int n_lons)\n{ // calculates b from matrix equation Ax=b\n\tdouble **F_a = create_2d_pointer(n_lats,n_lons);\n\tcalculate_F_a(F_a,n_lats,n_lons);\n\tdouble **F_c = create_2d_pointer(n_lats,n_lons);\n\tcalculate_F_c(F_c,T,n_lats,n_lons);\t\n\tdouble b_hij = 0.0;\n\tfor(int h=0;h\n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n\n#include \"nrsrc/nrutil.h\"\n\n#include \"prototypes.h\"\n#include \"globvars.h\"\n\n\ndouble comp_DF_halo_exact(double E, double L);\ndouble comp_DF_bulge_exact(double E, double L);\n\ndouble comp_DF_H_iso(double E);\ndouble comp_DF_H_ani(double Q);\n\ndouble comp_DF_halo_Eddington(double Q);\ndouble comp_DF_bulge_Eddington(double Q);\n\nvoid comp_DF_init(void);\nvoid compute_d2rhodpsi2_halo(void);\nvoid compute_d2rhodpsi2_bulge(void);\n\ndouble eddington_integrand(double t, void *params);\n\n\n#define WORKSIZE 100000\ngsl_integration_workspace *Workspace;\n\ndouble *xi, *yi, *eddint;\ndouble *list_radius;\ndouble *list_E; /* tabulated energies */\ndouble *DistFunc_halo, *DistFunc_bulge; /* distribution function(s) */\ndouble *psi_R;\ndouble *rho_R_halo,*rho_R_bulge;\ndouble *drhodpsi_halo,*d2rhodpsi2_halo;\ndouble *drhodpsi_bulge,*d2rhodpsi2_bulge;\n\n\n/* size of DF look-up table */\nint DFSIZE= RSIZE * 2;\n\n\nvoid compute_DF_lookuptable(void)\n{\n FILE *fd;\n char dffile[100]=\"\";\n int i;\n\n printf(\"Start computing distribution function.\\n\"); fflush(stdout);\n\n#ifdef MAXWELLIAN\n AnisotropyRadius= -1;\n printf(\"MAXWELLIAN is turned on\\n\");\n#else\n printf(\"MAXWELLIAN is turned off\\n\");\n#endif\n\n#ifdef DF_H_MODEL\n printf(\"DF_H_MODEL is turned on\\n\");\n#else\n printf(\"DF_H_MODEL is turned off\\n\");\n#endif\n\n#ifdef DF_EDDINGTON\n printf(\"DF_EDDINGTON is turned on\\n\");\n#else\n printf(\"DF_EDDINGTON is turned off\\n\");\n#endif\n\n printf(\"AnisotropyRadius= %g\\n\", AnisotropyRadius);\n printf(\"ra= %g\\n\", AnisotropyRadius * RH);\n\n comp_DF_init();\n\n for(i = 0; i <= DFSIZE; i++)\n {\n\tprintf(\"Computing DF table bin %d/%d (e= %g)\\n\", i, DFSIZE, -1.0*psi_R[i]); fflush(stdout);\n\n\tlist_E[i]= -1.0 * psi_R[i];\n\n\tDistFunc_halo[i] = comp_DF_halo_exact(list_E[i], 0.0);\n\tDistFunc_bulge[i] = comp_DF_bulge_exact(list_E[i], 0.0);\n }\n printf(\"\\n\");\n\n\n /* write this to a file so we have a record of it */\n if(strstr(OutputFile,\".hdf5\"))\n strncpy(dffile, OutputFile, strlen(OutputFile)-5);\n if(strstr(OutputFile,\".dat\"))\n strncpy(dffile, OutputFile, strlen(OutputFile)-4);\n strcat(dffile, \".df\");\n printf(\"DF look-up table saved in file: %s\\n\",dffile);\n if((fd = fopen(dffile,\"w\")))\n {\n\tfprintf(fd,\" Energy f_halo(E) f_bulge(E)\\n\");\n\tfor(i= 0; i<= DFSIZE; i++)\n\t fprintf(fd,\" %10.5e %10.5e %10.5e\\n\",list_E[i],DistFunc_halo[i],DistFunc_bulge[i]);\n\tfclose(fd);\n }\n\n}\n\n\n\n\n\n\n\n\n\n\ndouble comp_DF_halo_exact(double E, double L)\n{\n double Q, f_e= 0.0;\n\n if((N_HALO == 0) || (M_HALO == 0))\n return 0;\n\n\n if (AnisotropyRadius > 0.0)\n\tQ= - E - (L*L/2./(AnisotropyRadius * RH)/(AnisotropyRadius * RH));\n else\n\tQ= - E;\n\n\n#ifdef DF_H_MODEL\n\t/* calculate f_e exactly from the H90 analytic formula */\n if (AnisotropyRadius > 0.0)\n f_e= comp_DF_H_ani(Q);\n else\n f_e= comp_DF_H_iso(E);\n#endif\n\n\n#ifdef DF_EDDINGTON\n\t/* calculate f_e using Eddington's formula */\n\tf_e= comp_DF_halo_Eddington(Q);\n\tprintf(\"f_e_edd(Q)/f_H_iso(E)= %g\\n\",f_e/comp_DF_H_iso(E));\n\tprintf(\"f_e_edd(Q)/f_H_ani(Q)= %g\\n\",f_e/comp_DF_H_ani(Q)); fflush(stdout);\n\tprintf(\"------\\n\");\n#endif\n\n\n return f_e;\n}\n\n\n\n\n\ndouble comp_DF_bulge_exact(double E, double L)\n{\n double Q, f_e= 0.0;\n\n if((N_BULGE == 0) || (M_BULGE == 0))\n return 0;\n\n\n/* for the moment, we only assume isotropic DF and use Eddington's formula */\n\n/*\n if (AnisotropyRadius > 0.0)\n Q= - E - (L*L/2./(AnisotropyRadius * RH)/(AnisotropyRadius * RH));\n else\n*/\n Q= - E;\n\n f_e= comp_DF_bulge_Eddington(Q);\n\n return f_e;\n}\n\n\n\n\n\n\n\n\n\n\n\n/*\n interpolate the halo f_e from the pre-computed table\n*/\ndouble comp_DF_halo(double E, double L)\n{\n double f_e= 0.0, Q, ee, ue;\n int ie;\n\n ee= E;\n\n if(AnisotropyRadius > 0.0)\n {\n Q= - E - (L*L/2./(AnisotropyRadius * RH)/(AnisotropyRadius * RH));\n\n /* in this case, table is stored in terms of -Q */\n ee= -1.0 * Q;\n }\n\n /* if e>0 or q<0 then dist. func. is zero */\n if(ee>0.0)\n return 0.0;\n\n ie= find_idx(ee, list_E, DFSIZE);\n\n/*\n printf(\"\\nE= %g Q= %g ee= %g\\n\",E, Q, ee);\n printf(\"ie= %d list_E[0]= %g list_E[DFSIZE]= %g \\n\",ie, list_E[0], list_E[DFSIZE]);\n printf(\"list_E[%d]= %g\\n\", ie-1, list_E[ie-1]);\n printf(\"list_E[%d]= %g\\n\", ie, list_E[ie]);\n printf(\"list_E[%d]= %g\\n\", ie+1, list_E[ie+1]);\n fflush(stdout);\n*/\n\n if(ie < 0 || ie > DFSIZE)\n ie= 0;\n\n ue = (ee - list_E[ie]) / (list_E[ie + 1] - list_E[ie]);\n\n if(ee>list_E[0])\n {\n /*\n printf(\"\\nparticle has energy very close to zero\\n\");\n printf(\"ee= %g, table min list_E[0]= %g\\n\",ee,list_E[0]);\n printf(\"return 0.\\n\");\n */\n ue= 0.0;\n }\n\n if(ie < 0 || ie >= DFSIZE || ue < 0 || ue > 1)\n {\n printf(\"\\nee= %g (in bounds? list_E[0]= %g list_E[DFSIZE]= %g\\n\",ee, list_E[0], list_E[DFSIZE]);\n printf(\"in: comp_DF_fromtable\\nerror: ie=%d out of range ue=%g\\nstopping\\n\", ie, ue);\n exit(0);\n }\n\n f_e= DistFunc_halo[ie] * (1-ue) + DistFunc_halo[ie+1] * ue;\n\n return f_e;\n}\n\n\n\n\n\n\n/*\n interpolate the bulge f_e from the pre-computed table\n*/\ndouble comp_DF_bulge(double E, double L)\n{\n double f_e= 0.0, Q, ee, ue;\n int ie;\n \n ee= E;\n \n /* for the moment, we'll assume the bulge is isotropic */\n/*\n if(AnisotropyRadius > 0.0)\n {\n Q= - E - (L*L/2./(AnisotropyRadius * RH)/(AnisotropyRadius * RH));\n ee= -1.0 * Q;\n }\n*/\n\n /* if e>0 or q<0 then dist. func. is zero */\n if(ee>0.0)\n return 0.0;\n\n ie= find_idx(ee, list_E, DFSIZE);\n\n if(ie < 0 || ie > DFSIZE)\n ie= 0;\n\n ue = (ee - list_E[ie]) / (list_E[ie + 1] - list_E[ie]);\n\n if(ee>list_E[0])\n {\n /*\n printf(\"\\nparticle has energy very close to zero\\n\");\n printf(\"ee= %g, table min list_E[0]= %g\\n\",ee,list_E[0]);\n printf(\"return 0.\\n\");\n */\n ue= 0.0;\n }\n\n if(ie < 0 || ie >= DFSIZE || ue < 0 || ue > 1)\n {\n printf(\"\\nee= %g (in bounds? list_E[0]= %g list_E[DFSIZE]= %g\\n\",ee, list_E[0], list_E[DFSIZE]);\n printf(\"in: comp_DF_fromtable\\nerror: ie=%d out of range ue=%g\\nstopping\\n\", ie, ue);\n exit(0);\n }\n\n f_e= DistFunc_bulge[ie] * (1-ue) + DistFunc_bulge[ie+1] * ue;\n\n return f_e;\n}\n\n\n\n\n\n\n\n\n/* ----------------------------------------------------------------- */\n\n\n\n/* the following are analytic forms of the distribution\n function, currently, it's only Hernquist 1990 */\n\n/* Isotropic Hernquist Model */\n\ndouble comp_DF_H_iso(double E)\n{\n double vg, q, prefac, f_e;\n\n if (E >= 0.0)\n\treturn 0.0;\n\n vg= sqrt(G * M_HALO / RH);\n q= sqrt(-1.0 * E * RH / G / M_HALO);\n\n if (q >= 1.0)\n\treturn (1.0e+30);\n\n prefac= M_HALO / (8.0 * sqrt(2.0) * PI * PI * PI * RH * RH * RH * vg * vg * vg);\n\n f_e= pow((1-q*q), -5./2.) * ( 3.*asin(q) + q*pow((1.-q*q),0.5)*(1.-2.*q*q) * (8.*q*q*q*q - 8.*q*q - 3.));\n/*\n printf(\" E= %g vg= %g q= %g prefac= %g f_e %g\\n\", E, vg, q, prefac, f_e); fflush(stdout);\n*/\n\n return prefac * f_e;\n}\n\n\n\n/* Anisotropic Hernquist Model */\n\ndouble comp_DF_H_ani(double Q)\n{\n\n if (AnisotropyRadius <= 0.0)\n\treturn 0;\n\n double vg, qbar, prefac, f_e, f_iso;\n double ra;\n\n ra= AnisotropyRadius * RH;\n\n if (Q <= 0.0)\n\treturn 0;\n\n vg= sqrt(G * M_HALO / RH);\n qbar= sqrt(RH * Q / G / M_HALO);\n\n if (qbar >= 1.0)\n\treturn 1.0e+30;\n\n prefac= M_HALO / (sqrt(2.0) * PI * PI * PI * RH * RH * RH * vg * vg * vg);\n\n f_e= (RH * RH / ra / ra) * qbar * (1. - 2.*qbar*qbar);\n\n f_iso= comp_DF_H_iso(-1.0*Q);\n\n/*\nprintf(\"DF_ani Q= %g qbar= %g f_iso= %g prefac= %g f_e= %g\\n\",Q,qbar,f_iso,prefac,f_e); fflush(stdout);\n*/\n\n return f_iso + prefac * f_e;\n}\n\n\n\n\n\n\n\n/* ----------------------------------------------------------------- \n\n Now, calculate DF using the Eddington formula.\n\n ----------------------------------------------------------------- */\n\ngsl_spline * d2rhodpsi2_spline_halo;\ngsl_interp_accel * d2rhodpsi2_spline_acc_halo;\n\ngsl_spline * d2rhodpsi2_spline_bulge;\ngsl_interp_accel * d2rhodpsi2_spline_acc_bulge;\n\n\n// Parameter struct for the Eddington integration function.\ntypedef struct {\n const gsl_spline* s;\n gsl_interp_accel* a;\n double Q;\n} spline_params;\n\n\n\n/* The integrand for the Eddington integration. Now uses \n the GSL spline functionality rather than the NR, which is evil. */\ndouble eddington_integrand(double t, void *params)\n{\n spline_params* p = params;\n\n//printf(\"t= %g\\t\", t);\n//printf(\"Q= %g\\t\",p->Q);\n//printf(\"sqrt(p->Q-t)= %g \\t\", sqrt(p->Q-t));\n//printf(\"d2rhodpsi2= %g \\t\", gsl_spline_eval(p->s, t, p->a));\n double v2 = gsl_spline_eval(p->s, t, p->a) / sqrt(p->Q - t);\n//printf(\"v2= %g \\n\",v2); fflush(stdout);\n \n return v2;\n}\n\n\n\n\n\n\n\ndouble comp_DF_halo_Eddington(double Q)\n{\n double f_e;\n int i;\n double result, abserr;\n\n\n /* first, we'll generate the spline for d2rho/dpsi2 term in integrand */\n\n\n if(Q<=0)\n return 0.0;\n\n\n /* load spline for d2rho/dpsi2 term into function parameters */\n spline_params p;\n p.s = d2rhodpsi2_spline_halo;\n p.a = d2rhodpsi2_spline_acc_halo;\n p.Q = Q;\n\n\n\n /* error checking: write entire DF integrand and the spline */\n/*\n FILE *fd;\n char tempfile[100]=\"\";\n sprintf(tempfile, \"df_integrands/%g.txt\", Q);\n if((fd = fopen(tempfile,\"w\")))\n {\n fprintf(fd,\"Q= %g \\n\",Q);\n fprintf(fd,\" xi yi d2rho_dpsi2 Q Q-psiR sqrt(Q-psiR) \\n\");\n for(i = 0; i <= DFSIZE; i++)\n fprintf(fd,\" %8.5e %8.5e %8.5e %8.5e %8.5e %8.5e \\n\",xi[i],yi[i],d2rho_dpsi2[i], Q, Q-psi_R[i], sqrt(Q-psi_R[i]));\n fclose(fd);\n }\n*/\n\n\n\n gsl_function F;\n F.function = &eddington_integrand;\n F.params = &p;\n\n\n double epsabs=0;\n double epsrel=1e-4;\n int intstatus;\n\n /* do our own error handling, so that we can adjust the accuracy if needed (i.e., at small r) */\n gsl_error_handler_t * old_handler = gsl_set_error_handler_off(); /* turn off the error-handler */\n\n do\n {\n intstatus= gsl_integration_qags(&F, 0.0, Q, epsabs, epsrel, WORKSIZE, Workspace, &result, &abserr);\n printf(\"epsrel = %g result = %g +/- %g (%g %)\\n\", epsrel, result, abserr, 100.0*abserr/result);\n epsrel *= 2.0;\n } while(intstatus == GSL_EROUND);\n\n //printf(\"Workspace.intervals = %d\\n\", Workspace->size);\n //printf(\"Workspace.maximum_level = %d\\n\", Workspace->maximum_level);\n\n\n gsl_set_error_handler(old_handler); /* turn it on again */\n\n\n f_e = result / sqrt(8.0) / PI / PI;\n\n if(f_e<0)\n f_e= 0.0;\n\n\n return f_e;\n}\n\n\n\n\n\ndouble comp_DF_bulge_Eddington(double Q)\n{\n double f_e;\n int i;\n double result, abserr;\n\n\n\n if(Q<=0)\n return 0.0;\n\n spline_params p;\n p.s = d2rhodpsi2_spline_bulge;\n p.a = d2rhodpsi2_spline_acc_bulge;\n p.Q = Q;\n\n\n gsl_function F;\n F.function = &eddington_integrand;\n F.params = &p;\n\n\n double epsabs=0;\n double epsrel=1e-4;\n int intstatus;\n\n gsl_error_handler_t * old_handler = gsl_set_error_handler_off(); /* turn off the error-handler */\n\n do\n {\n intstatus= gsl_integration_qags(&F, 0.0, Q, epsabs, epsrel, WORKSIZE, Workspace, &result, &abserr);\n //printf(\"epsrel = %g result = %g +/- %g (%g %)\\n\", epsrel, result, abserr, 100.0*abserr/result);\n //printf(\"error = %g\\n\", abserr);\n epsrel *= 2.0;\n } while(intstatus == GSL_EROUND);\n\n gsl_set_error_handler(old_handler); /* turn it on again */\n\n\n f_e = result / sqrt(8.0) / PI / PI;\n\n if(f_e<0)\n f_e= 0.0;\n\n\n return f_e;\n}\n\n\n\n\n\n\n\n\n\n/*\n Computes d2_rho / dpsi2, which is the primary term\n in the integral when using the Eddington formulation\n to calculate the distribution function.\n\n We do this for the halo and bulge components separately.\n\n*/\nvoid compute_d2rhodpsi2_halo()\n{\n FILE *fd;\n char drhodpsifile[100]=\"\";\n int i;\n\n double R, RplusdR, RminusdR, dR;\n double rho_RplusdR, rho_RminusdR;\n double psi_RplusdR, psi_RminusdR;\n double slope1, slope2, ra;\n\n // normalize just in case we get really small densities\n double rho_norm, psi_norm;\n\n\n for(i = 0; i <= DFSIZE; i++)\n {\n\tif(i < RSIZE)\n\t /* continues same scaling as list_R \n R= list_R[RSIZE] * exp((RSIZE-i) * (log(LL) - log(Baselen)) / (RSIZE - 1)); */\n\t /* more modest scaling to zero energy (ie larger radii) */\n R= list_R[RSIZE] * pow(10., 5.0 * (RSIZE-i) / RSIZE);\n //R= list_R[RSIZE] * pow(10., 7.0 * (RSIZE-i) / RSIZE);\n\telse\n R= list_R[DFSIZE-i];\n\n if(i == DFSIZE)\n R= list_R[1] * 0.5;\n\n\n\t/* interval of integration */\n\tdR= R * exp(1.0e-2 * (log(LL) - log(Baselen)) / (RSIZE - 1)) - R;\n\tif(dR>1.5)\n\t dR= 1.5;\n\tif((dR/R)<1.0e-4)\n\t dR=1.0e-4*R;\n RplusdR= R + dR;\n RminusdR= R - dR;\n\n\tlist_radius[i]= R;\n\n /* compute psi (=-phi, i.e., negative the potential) along the z axis, although\n the full DF assumes spherical symmetry */\n psi_R[i]= -1.0 * comp_phi(0, R);;\n psi_RplusdR= -1.0 * comp_phi(0, RplusdR);\n psi_RminusdR= -1.0 * comp_phi(0, RminusdR);\n\n /* -------------------------------\n\t DF for halo component */\n rho_R_halo[i]= comp_rho_halo(R,0);\n rho_RplusdR= comp_rho_halo(RplusdR,0);\n rho_RminusdR= comp_rho_halo(RminusdR,0);\n\n\tif(AnisotropyRadius>0)\n\t {\n\t ra= AnisotropyRadius * RH;\n rho_R_halo[i] *= (1.0 + (R * R / ra / ra ));\n rho_RplusdR *= (1.0 + (RplusdR * RplusdR / ra / ra));\n rho_RminusdR *= (1.0 + (RminusdR * RminusdR / ra / ra));\n\t }\n\n\t// normalize\n\trho_norm= rho_R_halo[i];\n\trho_R_halo[i] /= rho_norm;\n\trho_RplusdR /= rho_norm;\n\trho_RminusdR /= rho_norm;\n\tpsi_norm= psi_R[i];\n\tpsi_R[i] /= psi_norm;\n\tpsi_RplusdR /= psi_norm;\n\tpsi_RminusdR /= psi_norm;\n\n slope1= (rho_RplusdR - rho_R_halo[i]) / (psi_RplusdR - psi_R[i]);\n slope2= (rho_R_halo[i] - rho_RminusdR) / (psi_R[i] - psi_RminusdR);\n\n drhodpsi_halo[i]= 0.5*(slope1+slope2);\n\n d2rhodpsi2_halo[i]= (rho_RplusdR+rho_RminusdR-2.*rho_R_halo[i])/(psi_RplusdR-psi_R[i])/(psi_R[i]-psi_RminusdR);\n\n\t// now put units back in\n\tpsi_R[i] *= psi_norm;\n\trho_R_halo[i] *= rho_norm;\n\tdrhodpsi_halo[i] *= rho_norm / psi_norm;\n\td2rhodpsi2_halo[i] *= rho_norm / psi_norm / psi_norm;\n\n//printf(\"i= %d, R= %g, second derivative denominators: %g, %g diff= %g\\n\",i,R,(psi_RplusdR-psi_R[i]),(psi_R[i]-psi_RminusdR),(psi_RplusdR-psi_R[i])/(psi_R[i]-psi_RminusdR));\n//printf(\"i= %d, R= %g, rho= %g drhodpsi_halo= %g d2rhodpsi2_halo= %g second derivative denominators: %g, %g diff= %g\\n\",i,R,rho_R_halo[i],drhodpsi_halo[i],d2rhodpsi2_halo[i],(psi_RplusdR-psi_R[i]),(psi_R[i]-psi_RminusdR),(psi_RplusdR-psi_R[i])/(psi_R[i]-psi_RminusdR));\n//printf(\"i= %d, R= %g, rho_0= %g ani_factor= %g rho_R_halo= %g\\n\",i,R,comp_rho_halo(R,0),(1.0 + (R * R / ra / ra )),rho_R_halo[i]);\n\n\n }\n\n\n\n xi[0] = 0;\n yi[0] = 0;\n /* generate spline for the d2rho / dpsi2 term */\n for(i = 0; i <= DFSIZE; i++)\n {\n\txi[i + 1] = psi_R[i];\n\tyi[i + 1] = d2rhodpsi2_halo[i];\n\tif( (xi[i+1] - xi[i]) < 0) xi[i+1] = xi[i] + 1e-5;\n\n\tprintf(\"xi[i] = %f yi[i] = %f delta_x = %f\\n\",xi[i + 1], yi[i + 1], xi[i+1] - xi[i]);\n }\n\n printf(\"check_abcdefg\\n\");\n\n gsl_spline_init(d2rhodpsi2_spline_halo, xi, yi, DFSIZE+1);\n\n\n printf(\"check_abcdefg done\\n\");\n\n\n\n /* write this to a file so we have a record of it */\n strcpy(drhodpsifile,\"\");\n if(strstr(OutputFile,\".hdf5\"))\n strncpy(drhodpsifile, OutputFile, strlen(OutputFile)-5);\n if(strstr(OutputFile,\".dat\"))\n strncpy(drhodpsifile, OutputFile, strlen(OutputFile)-4);\n strcat(drhodpsifile, \".drhodpsi_halo\");\n if((fd = fopen(drhodpsifile,\"w\")))\n {\n fprintf(fd,\"# drhodpsi file, halo component\\n\");\n fprintf(fd,\"# n= %d \\n\",DFSIZE);\n fprintf(fd,\"# \\n\");\n fprintf(fd,\"# R (kpc) psi rho drho/dpsi d2rho/dpsi2 spline(psi) \\n\");\n fprintf(fd,\"# \\n\");\n for(i = 0; i <= DFSIZE; i++)\n fprintf(fd,\" %8.5e %8.5e %8.5e %8.5e %8.5e %8.5e \\n\",list_radius[i],psi_R[i],rho_R_halo[i],drhodpsi_halo[i],d2rhodpsi2_halo[i],gsl_spline_eval(d2rhodpsi2_spline_halo, 0.999*psi_R[i], d2rhodpsi2_spline_acc_halo));\n\n fclose(fd);\n }\n\n}\n\n\n\n\nvoid compute_d2rhodpsi2_bulge()\n{\n FILE *fd;\n char drhodpsifile[100]=\"\";\n int i;\n\n double R, RplusdR, RminusdR, dR;\n double rho_RplusdR, rho_RminusdR;\n double psi_RplusdR, psi_RminusdR;\n double slope1, slope2, ra;\n\n // normalize just in case we get really small densities\n double rho_norm, psi_norm;\n\n\n if(M_BULGE == 0)\n return;\n\n\n for(i = 0; i <= DFSIZE; i++)\n {\n\tif(i < RSIZE)\n\t /* continues same scaling as list_R \n R= list_R[RSIZE] * exp((RSIZE-i) * (log(LL) - log(Baselen)) / (RSIZE - 1)); */\n\t /* more modest scaling to zero energy (ie larger radii) */\n R= list_R[RSIZE] * pow(10., 5.0 * (RSIZE-i) / RSIZE);\n //R= list_R[RSIZE] * pow(10., 7.0 * (RSIZE-i) / RSIZE);\n\telse\n R= list_R[DFSIZE-i];\n\n if(i == DFSIZE)\n R= list_R[1] * 0.5;\n\n\n\t/* interval of integration */\n\tdR= R * exp(1.0e-2 * (log(LL) - log(Baselen)) / (RSIZE - 1)) - R;\n\tif(dR>1.5)\n\t dR= 1.5;\n\tif((dR/R)<1.0e-4)\n\t dR=1.0e-4*R;\n RplusdR= R + dR;\n RminusdR= R - dR;\n\n\tlist_radius[i]= R;\n\n /* compute psi (=-phi, i.e., negative the potential) along the z axis, although\n the full DF assumes spherical symmetry */\n psi_R[i]= -1.0 * comp_phi(0, R);;\n psi_RplusdR= -1.0 * comp_phi(0, RplusdR);\n psi_RminusdR= -1.0 * comp_phi(0, RminusdR);\n\n /* -------------------------------\n\t DF for bulge component */\n rho_R_bulge[i]= comp_rho_bulge(R,0);\n rho_RplusdR= comp_rho_bulge(RplusdR,0);\n rho_RminusdR= comp_rho_bulge(RminusdR,0);\n\n\tif(AnisotropyRadius>0)\n\t {\n\t ra= AnisotropyRadius * RH;\n rho_R_bulge[i] *= (1.0 + (R * R / ra / ra ));\n rho_RplusdR *= (1.0 + (RplusdR * RplusdR / ra / ra));\n rho_RminusdR *= (1.0 + (RminusdR * RminusdR / ra / ra));\n\t }\n\n\t// normalize\n\trho_norm= rho_R_bulge[i];\n\trho_R_bulge[i] /= rho_norm;\n\trho_RplusdR /= rho_norm;\n\trho_RminusdR /= rho_norm;\n\tpsi_norm= psi_R[i];\n\tpsi_R[i] /= psi_norm;\n\tpsi_RplusdR /= psi_norm;\n\tpsi_RminusdR /= psi_norm;\n\n slope1= (rho_RplusdR - rho_R_bulge[i]) / (psi_RplusdR - psi_R[i]);\n slope2= (rho_R_bulge[i] - rho_RminusdR) / (psi_R[i] - psi_RminusdR);\n\n drhodpsi_bulge[i]= 0.5*(slope1+slope2);\n\n d2rhodpsi2_bulge[i]= (rho_RplusdR+rho_RminusdR-2.*rho_R_bulge[i])/(psi_RplusdR-psi_R[i])/(psi_R[i]-psi_RminusdR);\n\n\t// now put units back in\n\tpsi_R[i] *= psi_norm;\n\trho_R_bulge[i] *= rho_norm;\n\tdrhodpsi_bulge[i] *= rho_norm / psi_norm;\n\td2rhodpsi2_bulge[i] *= rho_norm / psi_norm / psi_norm;\n\n//printf(\"i= %d, R= %g, second derivative denominators: %g, %g diff= %g\\n\",i,R,(psi_RplusdR-psi_R[i]),(psi_R[i]-psi_RminusdR),(psi_RplusdR-psi_R[i])/(psi_R[i]-psi_RminusdR));\n//printf(\"i= %d, R= %g, rho= %g drhodpsi_bulge= %g d2rhodpsi2_bulge= %g second derivative denominators: %g, %g diff= %g\\n\",i,R,rho_R_bulge[i],drhodpsi_bulge[i],d2rhodpsi2_bulge[i],(psi_RplusdR-psi_R[i]),(psi_R[i]-psi_RminusdR),(psi_RplusdR-psi_R[i])/(psi_R[i]-psi_RminusdR));\n//printf(\"i= %d, R= %g, rho_0= %g ani_factor= %g rho_R_bulge= %g\\n\",i,R,comp_rho_bulge(R,0),(1.0 + (R * R / ra / ra )),rho_R_bulge[i]);\n\n\n }\n\n\n\n\n /* generate spline for the d2rho / dpsi2 term */\n for(i = 0; i <= DFSIZE; i++)\n {\n\txi[i + 1] = psi_R[i];\n\tyi[i + 1] = d2rhodpsi2_bulge[i];\n if( (xi[i+1] - xi[i]) < 0) xi[i+1] = xi[i] + 1e-5;\n\n }\n\n gsl_spline_init(d2rhodpsi2_spline_bulge, xi, yi, DFSIZE+1);\n\n\n\n\n /* write this to a file so we have a record of it */\n strcpy(drhodpsifile,\"\");\n if(strstr(OutputFile,\".hdf5\"))\n strncpy(drhodpsifile, OutputFile, strlen(OutputFile)-5);\n if(strstr(OutputFile,\".dat\"))\n strncpy(drhodpsifile, OutputFile, strlen(OutputFile)-4);\n strcat(drhodpsifile, \".drhodpsi_bulge\");\n if((fd = fopen(drhodpsifile,\"w\")))\n {\n fprintf(fd,\"# drhodpsi file, bulge component\\n\");\n fprintf(fd,\"# n= %d \\n\",DFSIZE);\n fprintf(fd,\"# \\n\");\n fprintf(fd,\"# R (kpc) psi rho drho/dpsi d2rho/dpsi2 spline(psi) \\n\");\n fprintf(fd,\"# \\n\");\n for(i = 0; i <= DFSIZE; i++)\n fprintf(fd,\" %8.5e %8.5e %8.5e %8.5e %8.5e %8.5e \\n\",list_radius[i],psi_R[i],rho_R_bulge[i],drhodpsi_bulge[i],d2rhodpsi2_bulge[i],gsl_spline_eval(d2rhodpsi2_spline_bulge, 0.999*psi_R[i], d2rhodpsi2_spline_acc_bulge));\n\n fclose(fd);\n }\n\n}\n\n\n\n\n\n\n\n\n\nvoid comp_DF_init(void)\n{\n /* stores spline on the Eddington integrand */\n xi= vector(1, DFSIZE+1);\n yi= vector(1, DFSIZE+1);\n eddint= vector(1, DFSIZE+1);\n\n /* arrays for energies, radii, d2rho/dpsi2 term in Eddington integrand, and pre-computed DF */\n list_radius= vector(0, DFSIZE);\n list_E= vector(0, DFSIZE);\n psi_R= vector(0, DFSIZE);\n\n /* halo specific */\n rho_R_halo= vector(0, DFSIZE);\n drhodpsi_halo= vector(0, DFSIZE);\n d2rhodpsi2_halo= vector(0, DFSIZE);\n DistFunc_halo= vector(0, DFSIZE);\n\n /* bulge specific */\n rho_R_bulge= vector(0, DFSIZE);\n drhodpsi_bulge= vector(0, DFSIZE);\n d2rhodpsi2_bulge= vector(0, DFSIZE);\n DistFunc_bulge= vector(0, DFSIZE);\n\n\n /* setup the d2rho_dpsi2 array */\n\n /* for the halo */\n printf(\"allocating for halo\\n\");\n d2rhodpsi2_spline_halo = gsl_spline_alloc(gsl_interp_cspline, DFSIZE+1);\n d2rhodpsi2_spline_acc_halo = gsl_interp_accel_alloc();\n printf(\"evaluating for halo\\n\");\n compute_d2rhodpsi2_halo();\n\n /* for the bulge */\n printf(\"allocating for bulge\\n\");\n d2rhodpsi2_spline_bulge = gsl_spline_alloc(gsl_interp_cspline, DFSIZE+1);\n d2rhodpsi2_spline_acc_bulge = gsl_interp_accel_alloc();\n compute_d2rhodpsi2_bulge();\n\n printf(\"some workplace alloc\\n\");\n Workspace = gsl_integration_workspace_alloc(WORKSIZE);\n}\n\n\n\nvoid comp_DF_Eddington_close(void)\n{\n free_vector(xi, 1, DFSIZE+1);\n free_vector(yi, 1, DFSIZE+1);\n free_vector(eddint, 1, DFSIZE+1);\n free_vector(psi_R, 1, DFSIZE);\n free_vector(list_radius, 1, DFSIZE);\n free_vector(list_E, 1, DFSIZE);\n free_vector(rho_R_halo, 1, DFSIZE);\n free_vector(rho_R_bulge, 1, DFSIZE);\n free_vector(drhodpsi_halo, 1, DFSIZE);\n free_vector(drhodpsi_bulge, 1, DFSIZE);\n free_vector(d2rhodpsi2_halo, 1, DFSIZE);\n free_vector(d2rhodpsi2_bulge, 1, DFSIZE);\n free_vector(DistFunc_halo, 1, DFSIZE);\n free_vector(DistFunc_bulge, 1, DFSIZE);\n\n\n gsl_integration_workspace_free(Workspace);\n\n gsl_spline_free(d2rhodpsi2_spline_halo);\n printf(\"check_1234\\n\");\n gsl_interp_accel_free(d2rhodpsi2_spline_acc_halo);\n\n gsl_spline_free(d2rhodpsi2_spline_bulge);\n printf(\"check_abcd\\n\");\n gsl_interp_accel_free(d2rhodpsi2_spline_acc_bulge);\n}\n\n\n\n\n/* ----------------------------------------------------------------- */\n\n\n\ndouble compute_ani_beta(double r)\n{\n double beta;\n \n /* isotropic model */\n beta = 0.0;\n \n if (AnisotropyRadius > 0)\n {\n double ra;\n\n ra= AnisotropyRadius * RH;\n\n /* Osipkov & Merritt anisotropy dependency */\n beta = r * r / (r * r + ra * ra);\n }\n \n return beta;\n} \n\n\n\n\n", "meta": {"hexsha": "0a9c255ac36476eb3963e07fb4a5ca9eaf630bce", "size": 23257, "ext": "c", "lang": "C", "max_stars_repo_path": "paul_analysis/C/ICs/MakeGalaxy/distfunc.c", "max_stars_repo_name": "lzkelley/arepo-mbh-sims_analysis", "max_stars_repo_head_hexsha": "f14519552cedd39a040b53e6d7cc538b5b8f38a3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "paul_analysis/C/ICs/MakeGalaxy/distfunc.c", "max_issues_repo_name": "lzkelley/arepo-mbh-sims_analysis", "max_issues_repo_head_hexsha": "f14519552cedd39a040b53e6d7cc538b5b8f38a3", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "paul_analysis/C/ICs/MakeGalaxy/distfunc.c", "max_forks_repo_name": "lzkelley/arepo-mbh-sims_analysis", "max_forks_repo_head_hexsha": "f14519552cedd39a040b53e6d7cc538b5b8f38a3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 24.1505711319, "max_line_length": 288, "alphanum_fraction": 0.6010663456, "num_tokens": 8356, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8705972549785201, "lm_q2_score": 0.6224593312018546, "lm_q1q2_score": 0.5419113850801002}} {"text": "#include \n#include \n#include \n#include \n#include \n\n\ndouble sin_term(int l,int m,double phi,double theta){\n double out = gsl_pow_int(-1.0,m)*gsl_sf_legendre_sphPlm(l,m,gsl_sf_cos(theta))*gsl_sf_sin(m*phi);\n return out;\n}\n\ndouble cos_term(int l,int m, double phi, double theta){\n double out= gsl_pow_int(-1.0,m)*gsl_sf_legendre_sphPlm(l,m,gsl_sf_cos(theta))*gsl_sf_cos(m*phi);\n return out; \n}\n\n\n\n\nfloat acos_fast(float x) {\n float negate = (float)x < 0;\n x = x < 0 ? -x : x;\n float ret = -0.0187293;\n ret = ret * x;\n ret = ret + 0.0742610;\n ret = ret * x;\n ret = ret - 0.2121144;\n ret = ret * x;\n ret = ret + 1.5707288;\n ret = ret * sqrt(1.0-x);\n ret = ret - 2 * negate * ret;\n return negate * 3.14159265358979 + ret;\n}\n\n\nfloat fast_grf(int L, float x, float y,float z,float rands[]){\n float result = 0.0;\n float phi =atan2(y,x);\n float theta = acos_fast(z);\n float temp ; \n register int l = 0;\n register int m = 1; \n for (l=0; l<= L;l++){\n result += gsl_sf_legendre_sphPlm(l,0,gsl_sf_cos(theta))*rands[2*L*l];\n temp = 0.0;\n for(m=1;m<=l;m++){\n temp += (1 - ((m & 1) << 1))*gsl_sf_legendre_sphPlm(l,m,gsl_sf_cos(theta))*(rands[2*m+2*L*l+l]*gsl_sf_sin(m*phi)+rands[1+2*m+2*L*l]*gsl_sf_cos(m*phi));\n }\n result += 1.41421*temp; \n }\n return result;\n}\n\n", "meta": {"hexsha": "a85e7ef4ba4b6d49d4e43c57f0eacea63fd0bd58", "size": 1369, "ext": "c", "lang": "C", "max_stars_repo_path": "fast_spherharms.c", "max_stars_repo_name": "erik-grennberg-jansson/matern_sfem", "max_stars_repo_head_hexsha": "1e9468084abf41cc0ae85f1b4b1254904ed2d72f", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "fast_spherharms.c", "max_issues_repo_name": "erik-grennberg-jansson/matern_sfem", "max_issues_repo_head_hexsha": "1e9468084abf41cc0ae85f1b4b1254904ed2d72f", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "fast_spherharms.c", "max_forks_repo_name": "erik-grennberg-jansson/matern_sfem", "max_forks_repo_head_hexsha": "1e9468084abf41cc0ae85f1b4b1254904ed2d72f", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 24.8909090909, "max_line_length": 157, "alphanum_fraction": 0.626734843, "num_tokens": 509, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8807970904940926, "lm_q2_score": 0.6150878555160665, "lm_q1q2_score": 0.5417675935368022}} {"text": "#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n\n#include \"utils.h\"\n#include \"norm.h\"\n\n/*\n * * Program that reads reference spectra and measure spectra data\n * and linearly unmixes the data using method of least squares fit.\n * Assumes readings is set to 400 and file path is preset to:\n * \n * syntax: ./linearUnmixer MUfilename ref1filename ref2filename ref3filename ...\n * returns: completion status, prints composition of ref1, ref2, ... , refn\n * \n * * ****************************************************************\n * * Author Dept. Date Notes\n * * ****************************************************************\n * * Jake Z Bio. Eng. Mar 12 2020 Initial version\n * * Jake Z \" Apr 03 2020 It works now! \n * TODO: investigate the discrepancy between what you set $readings and the amount \n * of space you allocate to the matrices as you forgot to account for the initial \n * data clearing of the title headers in the data.\n * */\n\nconst int readings = 1000;\t//num of data points in each reading\nconst int skip = 50;\t\t//num of data points to discard from beginning\n\nint main(int argc, char *argv[])\n{\n\tif ( argc <= 2 )\n\t{\n\t\tfprintf( stderr, \"error, incorrect usage.\\n correct usage: ./unmix unknown ref1 ref2 ... refn\\n\");\n\t\treturn 3;\n\t}\n\n\t//allocate memory for vars\n\tint numRefs = argc - 2;\n\tchar *filePath = \"./assets/\";\t// create prompt/arg for desired assets\n\n\tgsl_vector *muVector = gsl_vector_alloc(readings);\n\tgsl_vector *fVector = gsl_vector_alloc(readings);\n\tgsl_vector *x = gsl_vector_alloc(numRefs);\n\n\tgsl_matrix *refMatrix = gsl_matrix_alloc(readings, numRefs);\n\tgsl_matrix *C = gsl_matrix_alloc( numRefs, numRefs );\n\tgsl_matrix *Cinverse = gsl_matrix_alloc( numRefs, numRefs );\n\n\tint s;\n\tgsl_permutation *p = gsl_permutation_alloc(numRefs);\n\n\t//initialize vars to 0\n\t\n\tgsl_vector_set_zero(muVector);\n\tgsl_vector_set_zero(fVector);\n\tgsl_vector_set_zero(x);\n\tgsl_matrix_set_zero(refMatrix);\n\tgsl_matrix_set_zero(C);\n\tgsl_permutation_init(p);\t//INITIALISED THE PERMUTATION\n\n\treadFileVector( muVector, filePath, argv[1] );\t//read vals of unknown arg\n\treadFileMatrix( refMatrix, filePath, argc, argv );\t//read the refs into matrix\n\n\tnormalizeVector( muVector );\n\n\t//create fn that reads the files\n\n\tFILE *csvfile = fopen( \"./muVector.csv\", \"wt\" );\n\tgsl_vector_fprintf( csvfile, muVector, \"%f\" );\n\tfclose(csvfile);\n\t\n\tFILE *csvfile2 = fopen( \"./refVectors.txt\", \"wt\" );\n\tgsl_matrix_fprintf( csvfile2, refMatrix, \"%f\" );\n\tfclose(csvfile2);\n\n\t//now we have variable muVector with vals and refMatrix with vals.\n\t\n\tgsl_blas_dgemm( CblasTrans, CblasNoTrans, 1, refMatrix, refMatrix, 0, C); //matrix C is now A^T A\n\tgsl_blas_dgemv( CblasTrans, 1, refMatrix, muVector, 0, fVector); //fVector is 'b'\n\tgsl_linalg_LU_decomp( C, p, &s);\n\tgsl_linalg_LU_invert( C, p, Cinverse ); \n\n\t//TODO maybe implement the other way you can solve for basis using inverse on both sides, (A^T A )^-1 A^T A x = (a^t a)^-1 (a^t b) = x\n \n\tgsl_blas_dgemv( CblasNoTrans, 1, Cinverse, fVector, 0, x);\n\t\n\tgsl_vector_fprintf( stdout, x, \"%f\" );\n\n\tgsl_matrix_free(Cinverse);\n\tgsl_matrix_free(C);\n\tgsl_matrix_free(refMatrix);\n\tgsl_vector_free(muVector);\n\tgsl_vector_free(fVector);\n\tgsl_vector_free(x);\n\n\treturn 0;\n}\n", "meta": {"hexsha": "602d782d5cb56a477e24316ab17c57fb1049b532", "size": 3417, "ext": "c", "lang": "C", "max_stars_repo_path": "src/unmixapp.c", "max_stars_repo_name": "jakeinater/spectralILU", "max_stars_repo_head_hexsha": "825dbd5c5495b0ce0a0d14a5bed865b9bfdda98d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/unmixapp.c", "max_issues_repo_name": "jakeinater/spectralILU", "max_issues_repo_head_hexsha": "825dbd5c5495b0ce0a0d14a5bed865b9bfdda98d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/unmixapp.c", "max_forks_repo_name": "jakeinater/spectralILU", "max_forks_repo_head_hexsha": "825dbd5c5495b0ce0a0d14a5bed865b9bfdda98d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.1747572816, "max_line_length": 135, "alphanum_fraction": 0.6698858648, "num_tokens": 956, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7931059609645723, "lm_q2_score": 0.6825737408694988, "lm_q1q2_score": 0.5413533026814868}} {"text": "/*! \\file\n Compute 3D shape features and moments.\n\nThe following functions compute several shape features, including\ncentral moments, center of gravity, and volume size.\n\n\\par Author:\nGabriele Lohmann, MPI-CBS\n*/\n\n\n/* From the Vista library: */\n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n\n\n\n/* From the standard C libaray: */\n#include \n#include \n#include \n\n#define SQR(x) ((x)*(x))\n#define ABS(x) ((x) > 0 ? (x) : -(x))\n\n\nstatic double power(double a, int k)\n{\n register double res;\n register int i;\n\n res = 1.0;\n for (i=0; i prior to the call.\n*/\nvoid VolumeCentroid(Volume v, double mean[3])\n{\n double npixels;\n long c,i,ce;\n VTrack t;\n\n mean[0] = 0;\n mean[1] = 0;\n mean[2] = 0;\n npixels = 0;\n\n for (i=0; inbuckets; i++) { \n for (t = v->bucket[i].first; t != NULL; t = t->next) {\n mean[0] += (double) (t->band * t->length);\n mean[1] += (double) (t->row * t->length);\n\n ce = t->col + t->length;\n for (c = t->col; clength;\n }\n }\n if (npixels > 0) {\n mean[0] /= npixels;\n mean[1] /= npixels;\n mean[2] /= npixels;\n }\n}\n\n\n\n\n\n/*!\n\\fn double VolumeMoment(Volume v,double mean[3],int m0,int m1,int m2)\n\\brief Compute central moments of a volume.\n\\param v input volume\n\\param *mean input array containing \nthe center of gravity as mean[0],mean[1],mean[2] (slice,row,column).\nIf mean is NULL, the center of gravity is taken to be (0,0,0).\n\\param m0 first index of moment\n\\param m1 second index of moment \n\\param m2 third index of moment\n*/\ndouble VolumeMoment(Volume v,double mean[3],long m0,long m1,long m2)\n{\n double res=0;\n double a = 1.0,sum = 0;\n long i,ca,ce,ci;\n double b,r,c;\n VTrack t;\n double g0,g1,g2;\n\n g0 = mean[0]; \n g1 = mean[1]; \n g2 = mean[2];\n \n res = 0;\n for (i=0; inbuckets; i++) { \n for (t = v->bucket[i].first; t != NULL; t = t->next) {\n b = (double) t->band - g0;\n r = (double) t->row - g1;\n a = power(b,m0) * power(r,m1);\n ca = t->col;\n ce = ca + t->length;\n sum = 0;\n for (ci=ca; ci prior to the call.\n*/\nvoid VBinCentroid(VImage src,double mean[3])\n{\n double npixels;\n long b,r,c;\n\n mean[0] = 0;\n mean[1] = 0;\n mean[2] = 0;\n npixels = 0;\n for (b=0; b 0) {\n\t mean[0] += b;\n\t mean[1] += r;\n\t mean[2] += c;\n\t npixels++;\n\t}\n }\n }\n }\n if (npixels > 0) {\n mean[0] /= npixels;\n mean[1] /= npixels;\n mean[2] /= npixels;\n }\n}\n\n\n\n\n/*!\n\\fn double VBinMoment(VImage src,double mean[3],int m0, int m1, int m2)\n\\brief Compute central moments of a binary raster image.\n\\param src input image (bit repn)\n\\param *mean input array containing \nthe center of gravity as mean[0],mean[1],mean[2] (slice,row,column).\nIf mean is NULL, the center of gravity is taken to be (0,0,0);\n\\param m0 first index of moment\n\\param m1 second index of moment \n\\param m2 third index of moment\n*/\ndouble VBinMoment(VImage src, double mean[3], long m0, long m1, long m2)\n{\n double res;\n long b,r,c;\n double g0,g1,g2;\n\n g0 = mean[0]; \n g1 = mean[1]; \n g2 = mean[2];\n\n res = 0;\n for (b=0; b 0) \n\t res += power((double)(b - g0),m0) \n\t * power((double)(r - g1),m1) \n\t * power((double)(c - g2),m2);\n }\n }\n }\n return res;\n}\n\n\n/*!\n \\fn long VolumeSize(Volume v)\n \\brief compute volume size, output the number of voxels of a single volume\n \\param v a single volume\n*/\nlong VolumeSize(Volume v) \n{\n long i,isize;\n VTrack t;\n\n isize = 0;\n for (i=0; i 0) n++;\n bin_pp++;\n }\n return n;\n}\n\n\n\n/*!\n \\fn float VolumeDir(Volume vol,float *e,float x[3])\n \\brief computer principal direction of a volume from its interia matrix\n \\param vol input volume\n \\param e output largest eigenvalue\n \\param x output first eigenvector\n*/\nfloat VolumeDir(Volume vol,float *e,float x[3])\n{\n gsl_matrix *a=NULL;\n static gsl_matrix *evec=NULL;\n static gsl_vector *eval=NULL;\n static gsl_eigen_symmv_workspace *workspace=NULL;\n double m020,m002,m200,m110,m101,m011;\n double norm,angle;\n double mean[3];\n float tiny=1.0e-5;\n\n mean[0] = mean[1] = mean[2] = 0;\n VolumeCentroid(vol,mean);\n\n m020 = VolumeMoment(vol,mean,0,2,0);\n m002 = VolumeMoment(vol,mean,0,0,2);\n m200 = VolumeMoment(vol,mean,2,0,0);\n\n m110 = VolumeMoment(vol,mean,1,1,0);\n m101 = VolumeMoment(vol,mean,1,0,1);\n m011 = VolumeMoment(vol,mean,0,1,1);\n\n\n /* inertia matrix */\n if (a == NULL) {\n a = gsl_matrix_calloc(3,3);\n workspace = gsl_eigen_symmv_alloc(3);\n }\n gsl_matrix_set(a,0,0,m020 + m002);\n gsl_matrix_set(a,1,1,m200 + m002);\n gsl_matrix_set(a,2,2,m200 + m020);\n\n gsl_matrix_set(a,0,1,-m110);\n gsl_matrix_set(a,1,0,-m110);\n\n gsl_matrix_set(a,0,2,-m101);\n gsl_matrix_set(a,2,0,-m101);\n\n gsl_matrix_set(a,1,2,-m011);\n gsl_matrix_set(a,2,1,-m011);\n\n gsl_eigen_symmv(a,eval,evec,workspace);\n gsl_eigen_symmv_sort(eval,evec,GSL_EIGEN_SORT_VAL_DESC);\n\n x[0] = gsl_matrix_get(evec,0,0);\n x[1] = gsl_matrix_get(evec,1,0);\n x[2] = gsl_matrix_get(evec,2,0);\n\n *e = gsl_vector_get(eval,0);\n\n angle = 0;\n norm = sqrt((double)(SQR(x[0]) + SQR(x[1]) + SQR(x[2])));\n if (norm > tiny) {\n angle = ABS(x[1])/ norm;\n }\n\n return angle;\n}\n\n\n\n\n/*!\n \\fn void VolumeEigen(Volume vol,gsl_vector *eval,gsl_matrix *evec)\n \\brief computer principal directions of a volume from its interia matrix\n \\param vol input volume\n \\param eval output eigenvalues\n \\param evec output matrix of eigenvectors (columns)\n*/\nvoid VolumeEigen(Volume vol,gsl_vector *eval,gsl_matrix *evec)\n{ \n static gsl_matrix *a=NULL;\n static gsl_eigen_symmv_workspace *workspace=NULL;\n double m020,m002,m200,m110,m101,m011;\n double mean[3];\n\n mean[0] = mean[1] = mean[2] = 0;\n VolumeCentroid(vol,mean);\n\n m020 = VolumeMoment(vol,mean,0,2,0);\n m002 = VolumeMoment(vol,mean,0,0,2);\n m200 = VolumeMoment(vol,mean,2,0,0);\n\n m110 = VolumeMoment(vol,mean,1,1,0);\n m101 = VolumeMoment(vol,mean,1,0,1);\n m011 = VolumeMoment(vol,mean,0,1,1);\n\n\n /* inertia matrix */\n if (a == NULL) {\n a = gsl_matrix_calloc(3,3);\n workspace = gsl_eigen_symmv_alloc(3);\n }\n\n gsl_matrix_set(a,0,0,m020 + m002);\n gsl_matrix_set(a,1,1,m200 + m002);\n gsl_matrix_set(a,2,2,m200 + m020);\n\n gsl_matrix_set(a,0,1,-m110);\n gsl_matrix_set(a,1,0,-m110);\n\n gsl_matrix_set(a,0,2,-m101);\n gsl_matrix_set(a,2,0,-m101);\n\n gsl_matrix_set(a,1,2,-m011);\n gsl_matrix_set(a,2,1,-m011);\n\n gsl_eigen_symmv(a,eval,evec,workspace);\n gsl_eigen_symmv_sort(eval,evec,GSL_EIGEN_SORT_VAL_DESC);\n\n return;\n}\n\n\n", "meta": {"hexsha": "41116d0df07f0e61aa17a60a4e1244af05694f51", "size": 8156, "ext": "c", "lang": "C", "max_stars_repo_path": "src/lib_via/ShapeMoments.c", "max_stars_repo_name": "zrajna/lipsia", "max_stars_repo_head_hexsha": "8e7252653bd641df8f8d22ca5a9820507f154014", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 17.0, "max_stars_repo_stars_event_min_datetime": "2017-04-10T16:33:42.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-18T10:55:03.000Z", "max_issues_repo_path": "src/lib_via/ShapeMoments.c", "max_issues_repo_name": "zrajna/lipsia", "max_issues_repo_head_hexsha": "8e7252653bd641df8f8d22ca5a9820507f154014", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 7.0, "max_issues_repo_issues_event_min_datetime": "2019-11-12T15:47:56.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-16T13:42:05.000Z", "max_forks_repo_path": "src/lib_via/ShapeMoments.c", "max_forks_repo_name": "zrajna/lipsia", "max_forks_repo_head_hexsha": "8e7252653bd641df8f8d22ca5a9820507f154014", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 8.0, "max_forks_repo_forks_event_min_datetime": "2017-09-29T10:33:53.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-22T08:05:46.000Z", "avg_line_length": 21.807486631, "max_line_length": 76, "alphanum_fraction": 0.6272682688, "num_tokens": 2819, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8221891479496521, "lm_q2_score": 0.6584174938590246, "lm_q1q2_score": 0.5413437182710967}} {"text": "/*\n * Monte Carlo.cpp\n *\n * Copyright 2017 Benjamin Church \n *\n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 2 of the License, or\n * (at your option) any later version.\n *\n * This program is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,\n * MA 02110-1301, USA.\n *\n *\n */\n\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#define ADIABATIC_CUTOFF 1\n\n#define INTEGRATION_POINTS 81\n#define INTEGRAL_FUDGE_FACTOR 1.0125\n#define INTEGRATION_SECTIONS 8\n#define CUTOFF_SCALE 1E3\n#define min(x,y) (x < y? x : y)\n#define sign(x) (x >= 0? 1.0 : -1.0)\n#define dot_macro(A, B) ((A).x * (B).x + (A).y * (B).y + (A).z * (B).z)\n#define mag_sq(A) dot_macro(A, A)\n#define mag(A) sqrt(dot_macro(A, A))\n#define assign_vec(A, x_val, y_val, z_val) {(A).x = x_val; (A).y = y_val; (A).z = z_val;}\n#define assign_vec_diff(d, A, B) {(d).x = (A).x - (B).x; (d).y = (A).y - (B).y; (d).z = (A).z - (B).z;}\n#define make_unit(A) {double len = mag(A); assign_vec(A, (A.x)/len, (A.y)/len, (A.z)/len);}\n#define rho_profile(x, a, b) (pow(x, 2 - a)*pow((1 + x), a - b))\n\ngsl_rng *RNG;\ngsl_integration_workspace * w;\n\nconst int default_log_num_trials = 6;\nint num_trials, num_points = 100;\n\nconst double pi = 3.14159265;\ndouble crit_density = 1.3211775E-7,\n\tf = 0.1,\n\tg = 1E-4,\n\tp = 1.9,\n\tG = 0.0045,\n\tk = 2,\n\tM_prim = 1E12,\n\tT_age = 1E4;\n\ndouble m_max, m_min, expected_num, R_core_prim, R_max_prim, c_prim;\n\ndouble MaxRadius(double M)\n{\n return pow(3.0*M/(4.0 * pi * 200.0 * crit_density), 1.0/3.0);\n}\n\ntypedef struct\n{\n\tdouble x, y, z;\n} vector;\n\ntypedef struct\n{\n\tdouble m, s, max_val;\n}data_cell;\n\nvoid update_cell(data_cell *ptr, double new_data, int k)\n{\n\tdouble old_m = ptr->m;\n\tptr->m += (new_data - old_m)/(double) k;\n\tptr->s += (new_data - old_m)*(new_data - ptr->m);\n\tif(ptr->max_val < new_data) ptr->max_val = new_data;\n}\n\nvoid reset_cell(data_cell *ptr)\n{\n\tptr->m = 0;\n\tptr->s = 0;\n\tptr->max_val = 0;\n}\n\ntypedef struct\n{\n\tdouble R, theta, phi;\n\tdouble cos_theta;\n\tdouble M, r_core, r_max, alpha, beta, c, normalization;\n\tdouble integs[INTEGRATION_SECTIONS];\n\tvector v, position;\n} halo;\n\ndouble Power(double x, int y)\n{\n\tif(y > 0)\n\t{\n\t\tdouble result = 1;\n\t\twhile(y > 0)\n\t\t{\n\t\t\tif(y % 2 == 0)\n\t\t\t{\n\t\t\t\tx = x*x;\n\t\t\t\ty = y/2;\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tresult = x*result;\n\t\t\t\ty--;\n\t\t\t}\n\t\t}\n\t\treturn result;\n\t}\n\telse if(y < 0)\n\t\treturn 1/Power(x, -y);\n\telse\n\t\treturn 1;\n}\n\nvoid print_vector(vector *A)\n{\n\tprintf(\"(%.3f, %.3f, %.3f)\\n\", A->x, A->y, A->z);\n}\n\ndouble perp_mag_sq(vector *A, vector *u)\n{\n\tdouble dot_prod = dot_macro(*A, *u);\n\treturn mag_sq(*A) - dot_prod*dot_prod/mag_sq(*u);\n}\n\ndouble MFreeNFW(double r)\n{\n if(r < R_max_prim)\n return M_prim*(log(1 + r/R_core_prim)-r/(r + R_core_prim))/(log(1 + c_prim) - c_prim/( 1 + c_prim));\n else\n return M_prim;\n}\n\ndouble DFreeNFW(double r)\n{\n if(r < R_max_prim)\n return 200.0/3.0 * crit_density / (log(1 + c_prim) - c_prim/(1 + c_prim))*pow(c_prim, 3) * 1.0/(r/R_core_prim*pow(1+r/R_core_prim, 2.0));\n else\n return 0.0;\n}\n\ndouble PhiFreeNFW(double r)\n{\n if(r < R_max_prim)\n return -M_prim*G*((R_max_prim/r * log(1 + r/R_core_prim) - log(1 + c_prim))/(log(1 + c_prim) - c_prim/(1 + c_prim)) + 1)/R_max_prim;\n else\n return -M_prim*G/r;\n}\n\ndouble TidalRadius(double M, double R)\n{\n\treturn R*pow(M/(2*MFreeNFW(R)), 1.0/3.0);\n}\n\ndouble NFW_func(double x, double r)\n{\n return (log(1.0 + x) - x/(1.0 + x))/(log(1.0 + c_prim) - c_prim/(1.0 + c_prim)) - r;\n}\n\ndouble df (double x)\n{\n return x/((1.0 + x)*(1.0 + x)) * 1.0/(log(1.0 + c_prim) - c_prim/(1.0 + c_prim));\n}\n\ndouble newton(double r)\n{\n int itr, maxmitr = 100;\n double h, x0 = 0.1, x1, allerr = pow(10, -6);\n\n for (itr = 0; itr < maxmitr; itr++)\n {\n h = NFW_func(x0, r)/df(x0);\n x1 = x0 - h;\n\n if (fabs(h) < allerr)\n {\n return x1;\n }\n x0 = x1;\n }\n return x1;\n}\n\ndouble rho_profile_func(double x, void *params)\n{\n\tdouble *param_ptr = (double *)params;\n\treturn pow(x, 2 - param_ptr[0])*pow((1 + x), param_ptr[0] - param_ptr[1]);\n}\n\ndouble integ_profile(double alpha, double beta, double r)\n{\n\t/*if(alpha > 3)\n\t\treturn 1;\n\tdouble dist = 0, step = r/INTEGRATION_POINTS, sum = 0;\n\tint i;\n\n\tfor(i = 0; i < INTEGRATION_POINTS; i++)\n\t{\n\t\tif(i == 0 && alpha > 2 && alpha < 3)\n\t\t\tsum += 8.0/(3.0*step) * 1/(3.0 - alpha) * pow(step, 3 - alpha);\n\t\telse if(i == 0 || i == INTEGRATION_POINTS - 1)\n\t\t\tsum += rho_profile(dist, alpha, beta);\n\t\telse if(i%3 == 0)\n\t\t\tsum += 2*rho_profile(dist, alpha, beta);\n\t\telse\n\t\t\tsum += 3*rho_profile(dist, alpha, beta);\n\t\tdist += step;\n\t}\n\n\treturn 3.0*step/8.0*sum * INTEGRAL_FUDGE_FACTOR;*/\n\t//printf(\"int %f\\n\", 3*step/8*sum);\n\n\tdouble result, error;\n\tdouble arr[2];\n\tarr[0] = alpha;\n\tarr[1] = beta;\n\n\tgsl_function F;\n\tF.function = &rho_profile_func;\n \tF.params = arr;\n\n \tgsl_integration_qags (&F, 0, r, 0, 1e-7, 1000, w, &result, &error);\n\tif(error/result > 1e-7)printf(\"LARGE INTEG ERROR WARNING %f for result %f\", error, result);\n\n\t//printf(\"alpha: %.3f beta: %.3f r: %.3f err %f\\n\", alpha, beta, r, (result - quick_result)/result);\n\n\treturn result;\n}\n\ndouble worst_thing_ever(int lr, double a, double b, double r)\n{\n\tswitch(lr)\n\t{\n\t\tcase -2: return pow(2,-2 + b)*pow(3,-4 + a - b)*(-20.25 - ((8*a*a*a + 12*a*a*(-2 + b) + b*(38 + (-15 + b)*b) +\n\t\t\t\t\t2*a*(8 + 3*(-7 + b)*b))*(-0.0078125 + Power(1 - 2*r,4)/8.))/2. +\n\t\t\t\t\t81*r - 27*(-6 + 2*a + b)*(0.1875 + (-1 + r)*r) + (3*(4*a*a + 4*a*(-4 + b) + (-9 + b)*(-2 + b))*(-1 + 4*r)*(7 + 4*r*(-5 + 4*r)))/32.);\n\t\tbreak;\n\n\t\tcase -1: return (pow(2,-4 + a - b)*(-24 + 48*r - ((-2 + a + b)*(a*a + (-7 + b)*b + a*(-1 + 2*b))*(-3 + 2*r)*(-1 + 2*r)*(5 + 4*(-2 + r)*r))/64. -\n\t\t\t\t\t3*(-4 + a + b)*(3 - 8*r + 4*r*r) + 6*(8 + a*a - 7*b + b*b + a*(-5 + 2*b))*(-0.2916666666666667 + (r*(3 + (-3 + r)*r))/3.)))/3.0;\n\t\tbreak;\n\n\t\tcase 0: return pow(2,-4 - a)*pow(3,-4 + a - b)*(-(a*a*a*(-1 + Power(-2 + r,4))) -\n\t\t\t\t\t16*(27 + (3*b)/4. + (b*b*b*(-1 + Power(-2 + r,4)))/2. + 40*b*r - 48*b*r*r - 27*r*r*r + 4*b*r*r*r +\n\t\t\t\t\t(13*b*r*r*r*r)/4. - 3*b*b*(1 + Power(-2 + r,3)*r)) - 3*a*a*(-1 + r)*(-41 + 2*b*(-3 + r)*(5 + (-4 + r)*r) - r*(-23 + r + r*r)) -\n\t\t\t\t\t2*a*(-1 + r)*(-75 + 6*b*b*(-3 + r)*(5 + (-4 + r)*r) + r*(-187 + r*(77 + r)) - 3*b*(37 + r*(5 + r*(-19 + 5*r)))));\n\t\tbreak;\n\n\t\tcase 1: return -(pow(2,-5 - 2*a)*pow(5,-3 + a - b)*(-2 + r)*(a*a*a*(-120 + 68*r - 14*r*r + r*r*r) +\n\t\t\t\t\ta*a*(-1880 + 596*r - 38*r*r - 3*r*r*r + 12*b*(-120 + 68*r - 14*r*r + r*r*r)) +\n\t\t\t\t\t2*a*(-2200 - 1932*r + 426*r*r + r*r*r + b*(-3920 + 344*r + 268*r*r - 42*r*r*r) + 24*b*b*(-120 + 68*r - 14*r*r + r*r*r)) +\n\t\t\t\t\t8*(-500*(4 + 2*r + r*r) + 8*b*b*b*(-120 + 68*r - 14*r*r + r*r*r) - 4*b*b*(40 + 212*r - 86*r*r + 9*r*r*r) +\n\t\t\t\t\tb*(-200 - 1892*r + 206*r*r + 31*r*r*r))))/3.0;\n\t\tbreak;\n\n\t\tcase 2: return pow(2,-4 - 3*a)*pow(3,-7 + 2*a - 2*b)*(-8957952 - ((-2 + a)*(-1 + a)*a + 8*(182 + 3*(-11 + a)*a)*b + 192*(-10 + a)*b*b + 512*b*b*b)*\n\t\t\t\t\t(-64 + Power(-8 + r,4)/4.) + 2239488*r - 15552*(-18 + a + 8*b)*(48 - 16*r + r*r) +\n\t\t\t\t\t72*(162 + a*a - 224*b + 64*b*b + a*(-19 + 16*b))*(-448 + r*(192 + (-24 + r)*r)));\n\n\t\tbreak;\n\n\t\tcase 3: return (pow(2,-5 - 4*a)*pow(17,-3 + a - b)*(-965935104 - (a*a*a + a*a*(-3 + 48*b) + 32*b*(307 - 432*b + 128*b*b) + a*(2 - 912*b + 768*b*b))*\n\t\t\t\t\t(-1024 + Power(-16 + r,4)/4.) + 120741888*r - 221952*(-34 + a + 16*b)*(192 - 32*r + r*r) +\n\t\t\t\t\t272*(578 + a*a - 832*b + 256*b*b + a*(-35 + 32*b))*(-3584 + r*(768 + (-48 + r)*r))))/3.0;\n\n\t\tbreak;\n\n\t\tcase 4: return pow(2,-6 - 5*a)*pow(33,-4 + a - b)*11*(-113048027136 -\n\t\t\t\t(a*a*a + a*a*(-3 + 96*b) + 64*b*(1123 - 1632*b + 512*b*b) + a*(2 - 3360*b + 3072*b*b))*(-16384 + Power(-32 + r,4)/4.) + 7065501696*r -\n\t\t\t\t3345408*(-66 + a + 32*b)*(768 - 64*r + r*r) + 1056*(2178 + a*a - 3200*b + 1024*b*b + a*(-67 + 64*b))*(-28672 + r*(3072 + (-96 + r)*r)));\n\n\t\tbreak;\n\n\t\tcase 5: return (pow(2,-7 - 6*a)*pow(65,-3 + a - b)*\n \t\t\t(-13822328832000 + 431947776000*r - (((-2 + a)*(-1 + a)*a + 64*(8582 + 3*(-67 + a)*a)*b +\n \t12288*(-66 + a)*b*b + 262144*b*b*b)*(-96 + r)*(-32 + r)*\n \t\t(5120 + (-128 + r)*r))/4. - 51916800*(-130 + a + 64*b)*(3072 - 128*r + r*r) + 4160*(8450 + a*a - 12544*b + 4096*b*b + a*(-131 + 128*b))*\n \t\t(-229376 + r*(12288 + (-192 + r)*r))))/3.0;\n\t\tbreak;\n\t};\n\n\treturn 1;\n}\n\ndouble sec_integ_profile(halo *ptr, double r)\n{\n\tdouble a = ptr->alpha, b = ptr->beta;\n\tint lr = floor(log2(r)); //MAKE BETTER!\n\tif(lr < -2) return pow(r, 3-a)*(1/(3-a) + r*(a-b)/(4-a) + (a*a - a + b - 2*a*b + b*b)/(5-a)*r*r/2.0);\n\tif(lr >= INTEGRATION_SECTIONS - 2) return integ_profile(a, b, r); //MAKE BETTER\n\treturn ptr->integs[lr + 2] + worst_thing_ever(lr, a, b, r);\n}\n\ndouble get_M()\n{\n\tdouble r = gsl_rng_uniform(RNG);\n\treturn M_prim*pow(pow(m_max/M_prim, 1.0-p)*r + pow(m_min/M_prim, 1.0-p)*(1.0-r), 1.0/(1.0-p));\n}\n\ndouble c_bar(double M)\n{\n\treturn pow(10.0, 1.0 - 0.1 * (log10(M) - 12));\n}\n\nvoid set_shape(halo *ptr, double M, double R)\n{\n\tptr->r_max = pow(3*M/(4 * pi * 200.0 * crit_density), 1.0/3.0);\n\tptr->alpha = gsl_ran_gaussian_ziggurat(RNG, 0.2) + 1.25; //suggested by J. Ostriker\n\tptr->beta = 3; //probalby need to change\n\tptr->c = gsl_ran_lognormal(RNG, log(c_bar(M)), 0.25); //Ludlow el. al. (2013) and Frank van den Bosch\n\tptr->r_core = ptr->r_max/ptr->c;\n\tint i;\n\tdouble r = 1.0/4.0, a = ptr->alpha, b = ptr->beta;\n\tptr->integs[0] = pow(r, 3-a)*(1/(3-a) + r*(a-b)/(4-a) + (a*a - a + b - 2*a*b + b*b)/(5-a)*r*r/2.0);\n\tr *= 2;\n\tfor(i = 0; i < INTEGRATION_SECTIONS - 1; i++)\n\t{\n\t\tptr->integs[i + 1] = ptr->integs[i] + worst_thing_ever(i - 2, ptr->alpha, ptr->beta, r);\n\t\tr *= 2;\n\t}\n\tptr->normalization = sec_integ_profile(ptr, ptr->c);\n\n}\n\nvoid set_velocity(halo *ptr, double R)\n{\n\tdouble v_sigma = sqrt(1.0/3.0)*sqrt(-PhiFreeNFW(R));\n\n\tptr->v.x = gsl_ran_gaussian_ziggurat(RNG, v_sigma);\n\tptr->v.y = gsl_ran_gaussian_ziggurat(RNG, v_sigma);\n\tptr->v.z = gsl_ran_gaussian_ziggurat(RNG, v_sigma);\n}\n\ndouble enclosed_mass(halo *ptr, double r)\n{\n\tdouble x = r/(ptr->r_core);\n\tif(x > ptr->c)\n\t\treturn ptr->M;\n\telse\n\t{\n\t/*\tdouble sec = sec_integ_profile(ptr, x), integ = integ_profile(ptr->alpha, ptr->beta, x);\n\t\tdouble lerr = log(fabs(sec - integ));\n\t\tif(lerr > -4)\n\t\t{\n\t\t\tprintf(\"alpha: %f beta: %f r: %f \\n\", ptr->alpha, ptr->beta, x);\n\t\t\tprintf(\"lerr: %f sec: %f real: %f r: \\n\", lerr, sec, integ);\n\t\t}*/\n\t\treturn ptr->M * sec_integ_profile(ptr, x)/ptr->normalization;\n\t}\n}\n\n\nvoid truncate(halo *ptr, double R)\n{\n\tdouble l2 = R*R*perp_mag_sq(&(ptr->v), &(ptr->position));\n\tdouble r0 = l2/(M_prim * G);\n\tdouble E = 0.5*mag_sq(ptr->v) + PhiFreeNFW(R);\n\tdouble ecc = sqrt(1.0 + 2.0*E*l2/(M_prim * G * M_prim * G));\n\tdouble R_min = min(fabs(r0/(1.0 + ecc)), fabs(r0/(1.0 - ecc)));\n\n\t/*printf(\"velocity: \");\n\tprint_vector(ptr->v);\n\tprintf(\"position \");\n\tprint_vector(halo_pos(ptr));\n\tprintf(\"R = %.3f theta = %.3f phi = %.3f\\n l2 = %.3f e = %.3f \\n\", ptr->R, ptr->theta, ptr->phi, l2, ecc);*/\n\n\tif(E > 0 || R_min < 0.1)\n\t{\n\t\tptr->M = 0;\n\t}\n\telse\n\t{\n\t\tdouble Rt = TidalRadius(ptr->M, R_min);\n\t\tdouble R_max = min(ptr->r_max, Rt);\n\t\tdouble new_M = enclosed_mass(ptr, R_max);\n\n\t\tptr->r_max = R_max;\n\t\tptr->c = R_max/ptr->r_core;\n\t\tptr->normalization *= (new_M/ptr->M);\n\t\tptr->M = new_M;\n\t}\n}\n\nhalo *make_halo(halo *ptr)\n{\n\tptr->R = newton(gsl_rng_uniform(RNG)) * R_core_prim;\n\tptr->cos_theta = 2*gsl_rng_uniform(RNG) - 1;\n\tptr->theta = acos(ptr->cos_theta);\n\tptr->phi = 2*pi*gsl_rng_uniform(RNG);\n\tassign_vec(ptr->position, ptr->R * sin(ptr->theta) * cos(ptr->phi), ptr->R * sin(ptr->theta) * sin(ptr->phi), ptr->R * ptr->cos_theta);\n\n\tptr->M = get_M();\n\tset_shape(ptr, ptr->M, ptr->R);\n\tset_velocity(ptr, ptr->R);\n\ttruncate(ptr, ptr->R);\n\n\treturn ptr;\n}\n\nvoid print_halo_basic(halo *ptr)\n{\n\tprintf(\"\\n R = %3f \\n theta = %3f \\n M = %3f \\n\", ptr->R, ptr->theta, ptr->M);\n}\n\ndouble Fluc(halo *halos, int num_halos, double D)\n{\n\tdouble sum = 0;\n\tint i;\n\tvector my_pos = {0, 0, D}, diff;\n\tdouble natural_fluc = 2 * pi* pow(D, 3.0/2.0)/sqrt(MFreeNFW(D) * G) * 1/(PhiFreeNFW(D));\n\tfor(i = 0; i < num_halos; i++)\n\t{\n\t\tdouble R = halos[i].R;\n\t\tdouble r = sqrt(R*R + D*D - 2.0*R*D*halos[i].cos_theta);\n\n\t\tassign_vec_diff(diff, halos[i].position, my_pos);\n\t\tmake_unit(diff)\n\t\tdouble v_r = dot_macro(halos[i].v, diff);\n\n\t\tdouble produced_fluc = ((r > CUTOFF_SCALE) ? (enclosed_mass(halos + i, r) * G /(r*r) * v_r) : 0);\n\t\t//sum += produced_fluc; //KILLEM\n\t\t// kill heating which is adiabtic\n\n\t\tif(produced_fluc/natural_fluc > 1 || ! ADIABATIC_CUTOFF)\n\t\t\tsum += produced_fluc;\n\t\t/*printf(\"%.3f\\n\", D);\n\t\tprintf(\"velocity: \");\n\t\tprint_vector(halos[i]->v);\n\t\tprintf(\"position \");\n\t\tprint_vector(halo_pos(halos[i]));\n\t\tprintf(\"R = %.3f theta = %.3f phi = %.3f\\n v_r = %.3f \\n\", halos[i]->R, halos[i]->theta, halos[i]->phi, v_r);*/\n\t}\n\treturn sum*sum;\n}\n\ndouble Fluc_mass_range(halo *halos, int num_halos, double D, double min_mass, double max_mass)\n{\n\tdouble sum = 0;\n\tint i;\n\tvector my_pos = {0, 0, D}, diff;\n\tdouble natural_fluc = 2 * pi* pow(D, 3.0/2.0)/sqrt(MFreeNFW(D) * G) * 1/(PhiFreeNFW(D));\n\tfor(i = 0; i < num_halos; i++)\n\t{\n\t\tdouble R = halos[i].R;\n\t\tdouble r = sqrt(R*R + D*D - 2.0*R*D*halos[i].cos_theta);\n\t\tif(halos[i].M < max_mass && halos[i].M > min_mass)\n\t\t{\n\t\t\tassign_vec_diff(diff, halos[i].position, my_pos);\n\t\t\tmake_unit(diff)\n\t\t\tdouble v_r = dot_macro(halos[i].v, diff);\n\n\t\t\tdouble produced_fluc = ((r > CUTOFF_SCALE) ? (enclosed_mass(halos + i, r) * G /(r*r) * v_r) : 0);\n\t\t\t//sum += produced_fluc; //KILLEM\n\t\t\t// kill heating which is adiabtic\n\n\t\t\tif(produced_fluc/natural_fluc > 1 || ! ADIABATIC_CUTOFF)\n\t\t\t\tsum += produced_fluc;\n\t\t\t/*printf(\"%.3f\\n\", D);\n\t\t\tprintf(\"velocity: \");\n\t\t\tprint_vector(halos[i]->v);\n\t\t\tprintf(\"position \");\n\t\t\tprint_vector(halo_pos(halos[i]));\n\t\t\tprintf(\"R = %.3f theta = %.3f phi = %.3f\\n v_r = %.3f \\n\", halos[i]->R, halos[i]->theta, halos[i]->phi, v_r);*/\n\t\t}\n\t}\n\treturn sum*sum;\n}\n\ndouble H_Density(halo *halos, int num_halos, double D, double dD)\n{\n\tdouble sum = 0;\n\tint i;\n\tfor(i = 0; i < num_halos; i++)\n\t{\n\t\tif(halos[i].R < D && halos[i].R > D - dD)\n\t\t\tsum += halos[i].M;\n\t}\n\treturn sum/(4.0*pi*D*D*dD);\n}\n\n\nint print_out = 0;\n\nvoid init(int argc, char **argv)\n{\n\tconst gsl_rng_type *T;\n\tgsl_rng_env_setup();\n\tT = gsl_rng_default;\n\tRNG = gsl_rng_alloc (T);\n\tw = gsl_integration_workspace_alloc (1000);\n\n\tif(argc >= 2)\n\t\tnum_trials = (int)pow(10, atoi(argv[1]));\n\telse\n\t\tnum_trials = (int)pow(10, default_log_num_trials);\n\n\tif(argc > 2)\n\t\tprint_out = 1;\n\n\tR_max_prim = MaxRadius(M_prim);\n\tc_prim = c_bar(M_prim);\n\tR_core_prim = R_max_prim/c_prim;\n\tm_max = f*M_prim;\n\tm_min = g*M_prim;\n\texpected_num = (2.0-p)/(1.0-p)*f*(pow(m_max/M_prim, 1.0-p) - pow(m_min/M_prim, 1.0-p))\n\t\t/ (pow(m_max/M_prim, 2.0-p) - pow(m_min/M_prim, 2.0-p));\n}\n\ndouble std_err_mean(double sum_of_squares)\n{\n\treturn sqrt(sum_of_squares/((double) num_trials*(num_trials - 1)));\n}\n\nvoid sq_root_data(data_cell *data, int num)\n{\n\tint i;\n\tfor(i = 0; i < num; i++)\n\t{\n\t\tdata[i].m = sqrt(data[i].m);\n\t\tdata[i].s *= pow(1.0/(2.0*data[i].m), 2);\n\t\tdata[i].max_val = sqrt(data[i].max_val);\n\t}\n}\n\nvoid print_to_file(char *name, double *Ds, data_cell *data)\n{\n\tint j;\n\tchar path[100], filename[50], snum[10], addendum[10];\n\tstrcpy(path, \"data_files/\");\n\tstrcpy(filename, name);\n\tstrcpy(addendum, \".txt\");\n\tsnprintf(snum, 10, \"%d_%d\", (int)gsl_rng_default_seed, (int)log10(num_trials));\n\tstrcat(path, filename);\n\tstrcat(path, snum);\n\tstrcat(path, addendum);\n\n\tFILE *f = NULL;\n\n\tif(!print_out)\n\t\tf = fopen(path, \"w\");\n\n\tif(!print_out && f != NULL)\n\t{\n\t\tfor(j = 0; j < num_points; j++)\n\t\t{\n\t\t\tdouble sig = std_err_mean(data[j].s)/data[j].m/log(10);\n\t\t\tprintf(\"%f, %f, %f, %f\\n\", data[j].m, data[j].s, sig, log10(data[j].m));\n\t\t\tif(data[j].m > 0)\n\t\t\t\tfprintf(f, \"%f %f %f %f\\n\", log10(Ds[j]), log10(data[j].m), sig, log10(data[j].max_val));\n\t\t}\n\t\tfclose(f);\n\t}\n\telse\n\t{\n\t\tfor(j = 0; j < num_points; j++)\n\t\t{\n\t\t\tdouble sig = std_err_mean(data[j].s)/data[j].m/log(10);\n\t\t\tprintf(\"%f, %f, %f, %f\\n\", data[j].m, data[j].s, sig, log10(data[j].m));\n\t\t\tif(data[j].m > 0)\n\t\t\t\tprintf(\"%f : %f +/- %f\\n\", log10(Ds[j]), log10(data[j].m), sig);\n\t\t}\n\t}\n}\n\nint main(int argc, char **argv)\n{\n\tinit(argc, argv);\n\tunsigned int max_allowed_halos = (int)(10*expected_num);\n\n\tdouble Ds[num_points];\n\tdata_cell Flucs[num_points], Dens[num_points];\n\thalo *halolist = malloc(max_allowed_halos*sizeof(halo));\n\n\tdouble mass = 0, avg_mass = 0;\n\tint i,j;\n\n\tfor(i = 0; i < num_points; i++)\n\t{\n\t\tDs[i] = pow(10, 5.0*i/(double) num_points);\n\t\treset_cell(&Flucs[i]);\n\t\treset_cell(&Dens[i]);\n\t}\n\tint hist_num = 10;\n\n\tdata_cell Hist_Flucs[hist_num];\n\tfor(int i = 0; i < hist_num; i++)\n\t\treset_cell(Hist_Flucs + i);\n\n\tfor(i = 0; i < num_trials; i++)\n\t{\n\t\tif(i % 100 == 0)printf(\"%d out of %d \\n\", i/100, num_trials/100);\n\t\tunsigned int num_halos = gsl_ran_poisson(RNG, expected_num);\n\t\tif(num_halos > max_allowed_halos)\n\t\t{\n\t\t\tmax_allowed_halos *= 2;\n\t\t\tfree(halolist);\n\t\t\thalolist = malloc(max_allowed_halos*sizeof(halo));\n\t\t\tprintf(\"ALLOCATING\\n\");\n\t\t}\n\t\tmass = 0;\n\t\t//printf(\"Expect: %f Have: %lu \\n\", expected_num, num_halos);\n\n\t\tfor(j = 0; j < num_halos; j++)\n\t\t{\n\t\t\tmake_halo(halolist + j);\n\t\t\t//print_halo_basic(halolist + j);\n\t\t\tmass += halolist[j].M;\n\n\t\t\tif(mass != mass)\n\t\t\t{\n\t\t\t\tprint_halo_basic(halolist + j);\n\t\t\t\tprintf(\"%f %f %d %f\\n\", mass, halolist[j].M, j, halolist[j].alpha);\n\t\t\t\treturn -1;\n\t\t\t}\n\t\t}\n\n\t\tfor(j = 0; j < num_points; j++)\n\t\t{\n\t\t\tupdate_cell(Flucs + j, Fluc(halolist, num_halos, Ds[j]), i + 1);\n\t\t\tupdate_cell(Dens + j, (j == 0 ? H_Density(halolist, num_halos, Ds[j], Ds[j]) : H_Density(halolist, num_halos, Ds[j], Ds[j] - Ds[j-1])), i + 1);\n\t\t}\n\t\t//printf(\"Mass frac: %f \\n\", mass/M_prim);\n\t\tavg_mass += mass/num_trials;\n\n\t\tfor(int j = 0; j < hist_num; j++)\n\t\t\tupdate_cell(Hist_Flucs + j, Fluc_mass_range(halolist, num_halos, 1e4, M_prim*g*pow(f/g, (double) j/ (double) hist_num), M_prim*g*pow(f/g, (double) (j + 1)/ (double) hist_num)), i + 1);\n\n\n\t\t/*for(j = 0; j < num_points; j++)\n\t\t{\n\t\t\t//printf(\"%f : %f\\n\", pow(10, 5.0*j/num_points), log10(Flucs[j]));\n\t\t\t//printf(\"%f : %f\\n\", pow(10, 5.0*j/num_points), log10(Dens[j]));\n\t\t\t//printf(\"%f : %f\\n\", pow(10, 5.0*j/num_points), Hist[j]);\n\t\t}*/\n\n\t}\n\tprint_to_file(\"Density\", Ds, Dens);\n\tsq_root_data(Flucs, num_points);\n\tprint_to_file(\"Flucs\", Ds, Flucs);\n\n\tprintf(\"Mass frac: %f \\n\", avg_mass/M_prim);\n\tsq_root_data(Hist_Flucs, hist_num);\n\tfor(int i = 0; i < hist_num; i++)\n\t\tprintf(\"Mass: %f Fluc: %f SDEV: %f\\n\", M_prim*g*pow(f/g, (double) i/ (double) hist_num), Hist_Flucs[i].m, std_err_mean(Hist_Flucs[i].s));\n\tgsl_rng_free (RNG);\n\tgsl_integration_workspace_free (w);\n\treturn 0;\n}\n", "meta": {"hexsha": "8befb792ad5166c15b81728c399c6590217d7a92", "size": 19228, "ext": "c", "lang": "C", "max_stars_repo_path": "Monte_Carlo/Monte_Carlo.c", "max_stars_repo_name": "benvchurch/project-eva", "max_stars_repo_head_hexsha": "38e3e61ec1913fb2d94fbb8a5db53b90ec32ed66", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2017-07-27T19:02:16.000Z", "max_stars_repo_stars_event_max_datetime": "2017-07-27T19:02:16.000Z", "max_issues_repo_path": "Monte_Carlo/Monte_Carlo.c", "max_issues_repo_name": "benvchurch/project-eva", "max_issues_repo_head_hexsha": "38e3e61ec1913fb2d94fbb8a5db53b90ec32ed66", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Monte_Carlo/Monte_Carlo.c", "max_forks_repo_name": "benvchurch/project-eva", "max_forks_repo_head_hexsha": "38e3e61ec1913fb2d94fbb8a5db53b90ec32ed66", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 28.7414050822, "max_line_length": 187, "alphanum_fraction": 0.5785313085, "num_tokens": 7465, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7853085808877581, "lm_q2_score": 0.6893056167854461, "lm_q1q2_score": 0.5413176157157396}} {"text": "#include \n#include \n\n// include files for optimized libraries\n#if defined USE_ESSL\n#include \n#elif defined USE_MKL\n#include \n#include \n#elif defined USE_LAPACK\n#include \n#include \n#endif\n\n// interface to f2c code\n\n#include \"f2c.h\"\n#include \"mrrr.h\"\n\nstatic inline int PCA_ssytd2(char uplo, int n, real *a, int lda, real *d, real *e, real *tau)\n{\n int info;\n ssytd2_(&uplo, &n, a, &lda, d, e, tau, &info, 1);\n return info;\n}\n\nstatic inline int PCA_sstemr(char jobz, char range, int n, real *d, real *e, real vl, real vu,\n int il, int iu, int *m, real *w, real *z, int ldz, int nzc, int *isuppz, int *tryrac,\n real *work, int lwork, int *iwork, int liwork)\n{\n int info;\n pca_sstemr__(&jobz, &range, &n, d, e, &vl, &vu, &il, &iu, m, w, z, &ldz, &nzc, isuppz,\n tryrac, work, &lwork, iwork, &liwork, &info, 1, 1);\n return info;\n}\n\nstatic inline int PCA_sorm2l(char side, char trans, int m, int n, int k, real *a, int lda, real *tau, real *c, int ldc, real *work)\n{\n int info;\n sorm2l_(&side, &trans, &m, &n, &k, a, &lda, tau, c, &ldc, work, &info, 1, 1);\n return info;\n}\n\n#ifndef NO_PULP\n#include \"utils.h\"\n#include \"hwTrace.h\"\n#endif\n\n#if 1\n\n#define ALLOC(t, v, s) t v[s];\n#define FREE(v)\n\n#else\n\n#define ALLOC(t, v, s) t *v = malloc(sizeof(t) * (s));\n#define FREE(v) free(v);\n\n#endif\n\n// PCA main routine\n// input is a column-major matrix with a row for each sample and a column for each variable\n// output is a column-major matrix with a row for each sample and a column for each component\n\nvoid PCA_mrrr(int samples, int variables, float *input, int components, float *output)\n{\n int lwork = 18 * variables;\n int liwork = 10 * variables;\n ALLOC(real, A, variables * variables);\n ALLOC(real, T, samples * variables);\n ALLOC(real, d, variables);\n ALLOC(real, e, variables);\n ALLOC(real, tau, variables);\n ALLOC(int, isuppz, variables * 2);\n ALLOC(real, w, variables);\n ALLOC(real, Z, variables * variables);\n ALLOC(real, work, lwork);\n ALLOC(int, iwork, liwork);\n\n // pulp_trace_kernel_declare(0, \"kernel 0\");\n // pulp_trace_kernel_start(0, 1);\n\n // compute and subtract mean\n for (int j = 0; j < variables; j++) {\n real mean = 0.0;\n #pragma omp parallel for reduction(+:mean)\n for (int i = 0; i < samples; i++)\n mean += input[j * samples + i];\n mean /= samples;\n #pragma omp parallel for\n for (int i = 0; i < samples; i++)\n T[j * samples + i] = input[j * samples + i] - mean;\n }\n\n // compute A=T^T*T\n for (int j = 0; j < variables; j++)\n for (int i = 0; i <= j; i++) {\n real dot = 0;\n #pragma omp parallel for reduction(+:dot)\n for (int k = 0; k < samples; k++)\n dot += T[j * samples + k] * T[i * samples + k];\n A[i + j * variables] = dot;\n }\n\n // tridiagonalization\n#if defined USE_MKL || USE_LAPACK\n int info = LAPACKE_ssytrd(LAPACK_COL_MAJOR, 'U', variables, A, variables, d, e, tau);\n#else\n int info = PCA_ssytd2('U', variables, A, variables, d, e, tau);\n#endif\n if (info != 0) {\n printf(\"Error in SSYTRD/SSYTD2: %i\\n\", info);\n abort();\n }\n\n // compute eigenvalues\n int il = variables - components + 1, iu = variables, m, tryrac = 1;\n real vl = 0.0, vu = 0.0;\n info = PCA_sstemr('V', 'I', variables, d, e, vl, vu, il, iu, &m, w, Z, variables, variables,\n isuppz, &tryrac, work, lwork, iwork, liwork);\n if (info != 0) {\n printf(\"Error in SSTEMR: %i\\n\", info);\n abort();\n }\n printf(\"%d: \", m);\n for (int i = 0; i < m; i++) printf(\"%d \", (int)w[i]); printf(\"\\n\");\n\n // compute eigenvectors\n#if defined USE_MKL || USE_LAPACK\n info = LAPACKE_sormtr(LAPACK_COL_MAJOR, 'L', 'U', 'N', variables, m, A, variables, tau,\n Z, variables);\n#else\n info = PCA_sorm2l('L', 'N', variables - 1, m, variables - 1, A + variables, variables, tau,\n Z, variables, work);\n#endif\n if (info != 0) {\n printf(\"Error in SORMTR/SORM2L: %i\\n\", info);\n abort();\n }\n\n#if defined USE_ESSL || USE_MKL || USE_LAPACK\n cblas_sgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, samples, components, variables,\n 1.0, T, samples, Z, variables, 0.0, output, samples);\n#else\n #pragma omp parallel for\n for (int i = 0; i < samples; i++)\n for (int j = 0; j < components; j++) {\n real t = 0;\n for (int k = 0; k < variables; k++)\n t += T[i + k * samples] * Z[j * variables + k];\n output[i + j * samples] = t;\n }\n#endif\n\n FREE(T);\n FREE(A);\n FREE(e);\n FREE(d);\n FREE(tau);\n FREE(w);\n FREE(Z);\n FREE(isuppz);\n FREE(work);\n FREE(iwork);\n // pulp_trace_kernel_stop(0, 1);\n}\n", "meta": {"hexsha": "31e2a8d86896dd2d4128d9dca91139466f4b54bb", "size": 4858, "ext": "c", "lang": "C", "max_stars_repo_path": "mb/pca/pca_mrrr.c", "max_stars_repo_name": "stmach/micro-benchmarks", "max_stars_repo_head_hexsha": "784280fea7f87be97bcde7a23a46b00f90351da6", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2019-02-15T12:10:51.000Z", "max_stars_repo_stars_event_max_datetime": "2020-02-20T23:43:18.000Z", "max_issues_repo_path": "mb/pca/pca_mrrr.c", "max_issues_repo_name": "stmach/micro-benchmarks", "max_issues_repo_head_hexsha": "784280fea7f87be97bcde7a23a46b00f90351da6", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2021-08-08T15:11:12.000Z", "max_issues_repo_issues_event_max_datetime": "2021-08-08T15:11:12.000Z", "max_forks_repo_path": "mb/pca/pca_mrrr.c", "max_forks_repo_name": "stmach/micro-benchmarks", "max_forks_repo_head_hexsha": "784280fea7f87be97bcde7a23a46b00f90351da6", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2019-02-15T12:11:04.000Z", "max_forks_repo_forks_event_max_datetime": "2020-04-03T14:21:37.000Z", "avg_line_length": 29.0898203593, "max_line_length": 131, "alphanum_fraction": 0.5743104158, "num_tokens": 1592, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.785308580887758, "lm_q2_score": 0.6893056104028797, "lm_q1q2_score": 0.5413176107034553}} {"text": "// Alessandro Casalino\n//\n// Compile with (Mac with default homebrew gsl 2.6) gcc-9 -O2 quintessence_evolve.c -o quintessence_evolve.exe -L/usr/local/Cellar/gsl/2.6/lib -I/usr/local/Cellar/gsl/2.6/include -lgsl\n// Run with ./quintessence_evolve.exe\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n\n// PHYSICAL PARAMETERS VALUES\n\n// INITIAL CONDITIONS\n// Initial value of the scale factor\ndouble a_init = 1e-15;\n// Final value of the scale factor\ndouble a_end = 1.1;\n\n// Values of fractional density for the cosmological matter today\ndouble Omega_rad_0 = 8e-5;\ndouble Omega_b_0 = 0.0486;\ndouble Omega_Lambda_0 = 0.;//0.6911;\ndouble Omega_cdm_0 = 0.2589;\n\n// Physical constants for output conversions\ndouble _G_ = 6.67428e-11; /**< Newton constant in m^3/Kg/s^2 */\ndouble _MPc_over_m_ = 3.085677581282e22; // Conversion factor from Mpc to m\ndouble _Gyr_over_Mpc_ = 3.06601394e2; // Conversion factor from Gyr to Mpc\ndouble _c_ = 2.99792458e8; // Speed of light in m/s\ndouble _H0_ = 67.74; // H0 of LCDM in Km/s/Mpc\n\ndouble fourpiG = 1.;\n\ndouble T_CONF = 1.;\n\n// COMPUTATION PARAMETERS VALUES\n\n// Number of points used in the computation\nint points = (int) 1e6;\n\n// Raise this value to make the csv file smaller, but decreasing resolution\n// The value inserted is the ratio between the number of values written in a full resolution file / decreased resolution file\nint csv_resolution = 10;\n\ndouble delta_bisection = 1e-2;\ndouble mg_field_init_min = 1e-20;\ndouble mg_field_init_max = 2e1; //1e16 max for LCDM (model 1)\n\n\n// QUINTESSENCE PARAMETERS\n// Initial value of the quintessence velocity (phi derivated with respect to tau)\ndouble mg_field_p_bk_0 = 0.;\n\n// TEST MODE\n// Provides some informations on the terminal and the .csv file during the computation (1: on, others: off)\nint TEST_MODE = 1;\n\n\n// Definition of the POTENTIAL\n// For a list of the models see above\ndouble mg_pot(const double mg_field_bk) {\n\n return mg_field_bk * mg_field_bk / 2.;\n\n}\n\ndouble mg_pot_p(const double mg_field_bk) {\n\n return mg_field_bk;\n\n}\n\n// Definitions of DIFFERENTIAL EQUATION system\n// Need to have first order equations to use Runge Kutta\n//\ndouble a_p_rk4(const double a, const double a_p, const double mg_field_bk, const double mg_field_p_bk)\n{\n\treturn a_p;\n}\ndouble a_pp_rk4(const double a, const double a_p, const double mg_field_bk, const double mg_field_p_bk)\n{\n double a3 = a * a * a;\n double rhoa3 = (Omega_cdm_0 + Omega_b_0) + (Omega_Lambda_0 * a3) + (Omega_rad_0 / a);\n double Pa3 = - (Omega_Lambda_0 * a3) + 1./3. * (Omega_rad_0 / a );\n\n return fourpiG / 3. * ( (rhoa3 - 3. * Pa3) - a * mg_field_p_bk * mg_field_p_bk + 4. * a3 * mg_pot(mg_field_bk) );\n}\ndouble mg_field_bk_p_rk4(const double a, const double a_p, const double mg_field_bk, const double mg_field_p_bk)\n{\n\treturn mg_field_p_bk;\n}\ndouble mg_field_bk_pp_rk4(const double a, const double a_p, const double mg_field_bk, const double mg_field_p_bk)\n{\n\treturn - 2. * a_p/a * mg_field_p_bk - mg_pot_p(mg_field_bk) * a * a;\n}\ndouble Hconf(const double a, const double mg_field_bk, const double mg_field_p_bk)\n{\n\treturn sqrt((2. * fourpiG / 3.) * ( ((Omega_cdm_0 + Omega_b_0) / a) + (Omega_Lambda_0 * a * a) + (Omega_rad_0 / a / a) + (mg_field_p_bk * mg_field_p_bk / 2.) + (a * a * mg_pot(mg_field_bk)) ));\n}\n\n// Integrand for the particle horizon integral\ndouble particleHorizonIntegrand(double a, double mg_field_bk, double mg_field_p_bk)\n{\n //return 2. / (sqrt(a) * Hconf(a, mg_field_bk, mg_field_p_bk));\n\treturn 1. / ( a * Hconf(a, mg_field_bk, mg_field_p_bk) );\n}\n// Particle horizon integral step\ndouble particleHorizon(const int i, double * a, double * mg_field_bk, double * mg_field_p_bk) {\n double h = a[i]-a[i-1];\n double fa = particleHorizonIntegrand(a[i-1],mg_field_bk[i-1],mg_field_p_bk[i-1]);\n double fb = particleHorizonIntegrand(a[i],mg_field_bk[i],mg_field_p_bk[i]);\n\n return h*(fa+fb)/2.;\n}\n\n// Function used to print results stored in vectors as a csv file\nvoid csv(double * t, double * a, double * a_p, double * mg_field_bk, double * mg_field_p_bk, double * particleHorizonVec, char * filename) {\n\n FILE *fp;\n fp = fopen (filename, \"w+\");\n fprintf(fp, \"%s, %s, %s, %s, %s, %s, %s, %s\", \"t\", \"a(t)\", \"H(t)/H0\", \"H_prime(t)/H0^2\", \"Omega_df\", \"Omega_r\", \"Omega_b\", \"Omega_cdm\");\n fprintf(fp, \", %s\", \"omega_df\");\n fprintf(fp, \", %s\", \"PH\"); // Particle horizon\n fprintf(fp, \", %s\", \"mg_field\");\n fprintf(fp, \", %s\", \"mg_field_p\");\n if(TEST_MODE==1) fprintf(fp, \", %s\", \"H_check(t)/H0\");\n fprintf(fp, \"\\n\");\n\n // Time conversion factor\n // double tcf = 1./_H0_/(60.*60.*24.*365.*1e9)*_MPc_over_m_/1000.;\n\n int i = 0;\n double particleHorizonRes = 0.;\n\n for(i=1;idelta_bisection){\n\n a_p[0] = a_init * Hconf(a[0], mg_field_init_min, mg_field_p_bk[0]);\n mg_field_bk[0] = min;\n double rk4_min = rk4(t, a, a_p, mg_field_bk, mg_field_p_bk, Omega_f_0);\n a_p[0] = a_init * Hconf(a[0], C, mg_field_p_bk[0]);\n mg_field_bk[0] = C;\n double rk4_C = rk4(t, a, a_p, mg_field_bk, mg_field_p_bk, Omega_f_0);\n\n if(rk4_min*rk4_C>=0) {\n min=C;\n }\n else {\n max=C;\n }\n\n C=(max+min)/2.;\n\n if (TEST_MODE == 1) printf(\"TEST_MODE ON - min: %e , max: %e, C: %e, rk4_min: %e , rk4_C: %e \\n\", min, max, C, rk4_min, rk4_C);\n\n }\n\n double result = (max+min)/2.;\n\n if(TEST_MODE==1) printf(\"\\n\");\n printf(\"\\t-> Result of bisection method is mg_field_bk: %e (internal units).\\n\", result);\n //if(TEST_MODE==1) printf(\"\\t--> Confront with LCDM value: %e (internal units).\\n\", (2. * fourpiG / 3.) * ( Omega_Lambda_0 + 6. * OmegaCDM_0 )/ pow(a_init,3.));\n\n return result;\n\n}\n\nint main() {\n\n double Omega_f_0 = 1. - Omega_Lambda_0 - Omega_rad_0 - Omega_b_0 - Omega_cdm_0;\n\n int i = 0;\n\n printf(\"\\n\\t\\t----------------------------------------\\n\\n\");\n\n // Definition of the vector needed for the evolution functions\n double * t; double * a; double * a_p; double * mg_field_bk; double * mg_field_p_bk; double * particleHorizonVec;\n t = (double *) malloc(sizeof(double) * points);\n a = (double *) malloc(sizeof(double) * points);\n a_p = (double *) malloc(sizeof(double) * points);\n mg_field_bk = (double *) malloc(sizeof(double) * points);\n mg_field_p_bk = (double *) malloc(sizeof(double) * points);\n particleHorizonVec = (double *) malloc(sizeof(double) * points);\n\n if(!t||!a||!a_p||!mg_field_bk||!mg_field_p_bk||!particleHorizonVec){\n printf(\"Error! The memory cannot be allocated. The program will be terminated.\\n\");\n exit(1);\n }\n\n // Initial conditions (tau=0)\n a[0] = a_init;\n mg_field_p_bk[0] = mg_field_p_bk_0;\n\n printf(\" Searching for best initial value for the dark fluid ... \\n \\n\");\n mg_field_bk[0] = bisection(mg_field_init_min, mg_field_init_max, t, a, a_p, mg_field_bk, mg_field_p_bk, Omega_f_0);\n a_p[0] = a_init * Hconf(a_init, mg_field_bk[0], mg_field_p_bk[0]);\n\n printf(\"\\n\\n Evolving the system ...\\n\");\n\n rk4(t, a, a_p, mg_field_bk, mg_field_p_bk, Omega_f_0);\n\n char filename[50];\n sprintf (filename, \"mg_bk.csv\");\n int last_int = scan_for_a0(a);\n\n printf(\"\\n RESULTS:\\n\");\n printf(\"\\t-> H0: %f \\n\", a_p[last_int]/a[last_int]/sqrt(2. * fourpiG / 3.));\n printf(\"\\t-> number of points %d \\n\", last_int);\n //printf(\"\\t-> Age of the Universe: %f Gyr\\n\", t[last_int] /_H0_/(60.*60.*24.*365.*1e9)*_MPc_over_m_/1000.);\n\n csv(t, a, a_p, mg_field_bk, mg_field_p_bk, particleHorizonVec, filename);\n\n printf(\"\\n The results are saved in '.csv' files. The name is labelled with the value of c, and the model (m).\\n\");\n\n if(TEST_MODE==1) printf(\"\\n TEST_MODE ON: check the values of H in .csv file. They must be equal!\");\n\n printf(\"\\n\\t\\t----------------------------------------\\n\");\n\n double * a_int; double * a_p_int; double * mg_field_bk_int; double * mg_field_p_bk_int; double * particleHorizonVec_int;\n a_int = (double *) malloc(sizeof(double) * last_int);\n a_p_int = (double *) malloc(sizeof(double) * last_int);\n mg_field_bk_int = (double *) malloc(sizeof(double) * last_int);\n mg_field_p_bk_int = (double *) malloc(sizeof(double) * last_int);\n particleHorizonVec_int = (double *) malloc(sizeof(double) * last_int);\n\n if(!a_int||!a_p_int||!mg_field_bk_int||!mg_field_p_bk_int||!particleHorizonVec_int){\n printf(\"Error! The memory cannot be allocated. The program will be terminated.\\n\");\n exit(1);\n }\n\n memcpy(a_int, a, last_int * sizeof(double));\n memcpy(a_p_int, a_p, last_int * sizeof(double));\n memcpy(mg_field_bk_int, mg_field_bk, last_int * sizeof(double));\n memcpy(mg_field_p_bk_int, mg_field_p_bk, last_int * sizeof(double));\n memcpy(particleHorizonVec_int, particleHorizonVec, last_int * sizeof(double));\n\n free(a);free(a_p);free(mg_field_bk);free(mg_field_p_bk);free(particleHorizonVec);\n\n // Spline interpolation with gsl\n gsl_interp_accel *acc_mg_field = gsl_interp_accel_alloc();\n gsl_spline * spline_mg_field = gsl_spline_alloc(gsl_interp_cspline,last_int);\n gsl_interp_accel *acc_mg_field_p = gsl_interp_accel_alloc();\n gsl_spline * spline_mg_field_p = gsl_spline_alloc(gsl_interp_cspline,last_int);\n gsl_interp_accel *acc_a_p = gsl_interp_accel_alloc();\n gsl_spline * spline_a_p = gsl_spline_alloc(gsl_interp_cspline,last_int);\n gsl_interp_accel *acc_particleHorizon = gsl_interp_accel_alloc();\n gsl_spline * spline_particleHorizon = gsl_spline_alloc(gsl_interp_cspline,last_int);\n\n gsl_spline_init(spline_mg_field,a_int,mg_field_bk_int,last_int);\n gsl_spline_init(spline_mg_field_p,a_int,mg_field_p_bk_int,last_int);\n gsl_spline_init(spline_a_p,a_int,a_p_int,last_int);\n gsl_spline_init(spline_particleHorizon,a_int,particleHorizonVec_int,last_int);\n\n double a_eval = 1e-2;\n printf(\"spline eval: %e %e \\n\",a_eval,gsl_spline_eval(spline_mg_field,a_eval,acc_mg_field));\n printf(\"spline eval: %e %e \\n\",a_eval,gsl_spline_eval(spline_mg_field_p,a_eval,acc_mg_field_p));\n printf(\"spline eval: %e %e \\n\",a_eval,gsl_spline_eval(spline_a_p,a_eval,acc_a_p));\n printf(\"spline eval: %e %e \\n\",a_eval,gsl_spline_eval(spline_particleHorizon,a_eval,acc_particleHorizon));\n printf(\"%d %e \\n\",last_int, particleHorizonVec_int[gsl_interp_bsearch(a_int,a_eval,0,last_int-1)]);\n\n gsl_spline_free(spline_mg_field);gsl_interp_accel_free(acc_mg_field);\n gsl_spline_free(spline_mg_field_p);gsl_interp_accel_free(acc_mg_field_p);\n gsl_spline_free(spline_a_p);gsl_interp_accel_free(acc_a_p);\n gsl_spline_free(spline_particleHorizon);gsl_interp_accel_free(acc_particleHorizon);\n free(t);free(a_int);free(a_p_int);free(mg_field_bk_int);free(mg_field_p_bk_int);free(particleHorizonVec_int);\n\n printf(\"\\n\");\n\n exit(0);\n\n}\n", "meta": {"hexsha": "ed6dd0dd26ff4952ed73de96ca5e732d293e3359", "size": 16913, "ext": "c", "lang": "C", "max_stars_repo_path": "mg/quintessence_evolve.c", "max_stars_repo_name": "alessandrocasalino/mgevolution", "max_stars_repo_head_hexsha": "97dd3f4320f0c61eccae387d5fd945336084e863", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "mg/quintessence_evolve.c", "max_issues_repo_name": "alessandrocasalino/mgevolution", "max_issues_repo_head_hexsha": "97dd3f4320f0c61eccae387d5fd945336084e863", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "mg/quintessence_evolve.c", "max_forks_repo_name": "alessandrocasalino/mgevolution", "max_forks_repo_head_hexsha": "97dd3f4320f0c61eccae387d5fd945336084e863", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.0600461894, "max_line_length": 502, "alphanum_fraction": 0.6480813575, "num_tokens": 5981, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8175744806385542, "lm_q2_score": 0.6619228758499942, "lm_q1q2_score": 0.5411712514458372}} {"text": "/* rng/knuthran2002.c\n * \n * Copyright (C) 2007 Brian Gough\n * Copyright (C) 2001 Brian Gough, Carlo Perassi\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 2 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n/*\n * This generator is taken from\n *\n * Donald E. Knuth, The Art of Computer Programming, Volume 2, Section 3.6\n * Third Edition, Addison-Wesley, \n * \n * The modifications introduced in the 9th printing (2002) are\n * included here; there's no backwards compatibility with the\n * original. [ see http://www-cs-faculty.stanford.edu/~knuth/taocp.html ] \n * \n */\n\n#include \n#include \n#include \n\n#define BUFLEN 1009 /* length of the buffer aa[] */\n#define KK 100 /* the long lag */\n#define LL 37 /* the short lag */\n#define MM (1L << 30) /* the modulus */\n#define TT 70 /* guaranteed separation between streams */\n\n#define is_odd(x) ((x) & 1) /* the units bit of x */\n#define mod_diff(x, y) (((x) - (y)) & (MM - 1)) /* (x - y) mod MM */\n\nstatic inline void ran_array (long int aa[], unsigned int n,\n long int ran_x[]);\nstatic inline unsigned long int ran_get (void *vstate);\nstatic double ran_get_double (void *vstate);\nstatic void ran_set (void *state, unsigned long int s);\n\ntypedef struct\n{\n unsigned int i;\n long int aa[BUFLEN]; \n long int ran_x[KK]; /* the generator state */\n}\nran_state_t;\n\nstatic inline void\nran_array (long int aa[], unsigned int n, long int ran_x[])\n{\n unsigned int i;\n unsigned int j;\n\n for (j = 0; j < KK; j++)\n aa[j] = ran_x[j];\n\n for (; j < n; j++)\n aa[j] = mod_diff (aa[j - KK], aa[j - LL]);\n\n for (i = 0; i < LL; i++, j++)\n ran_x[i] = mod_diff (aa[j - KK], aa[j - LL]);\n\n for (; i < KK; i++, j++)\n ran_x[i] = mod_diff (aa[j - KK], ran_x[i - LL]);\n}\n\nstatic inline unsigned long int\nran_get (void *vstate)\n{\n ran_state_t *state = (ran_state_t *) vstate;\n\n unsigned int i = state->i;\n unsigned long int v;\n\n if (i == 0)\n {\n /* fill buffer with new random numbers */\n ran_array (state->aa, BUFLEN, state->ran_x);\n }\n\n v = state->aa[i];\n\n state->i = (i + 1) % KK;\n\n return v;\n}\n\nstatic double\nran_get_double (void *vstate)\n{\n ran_state_t *state = (ran_state_t *) vstate;\n\n return ran_get (state) / 1073741824.0; /* RAND_MAX + 1 */\n}\n\nstatic void\nran_set (void *vstate, unsigned long int s)\n{\n ran_state_t *state = (ran_state_t *) vstate;\n\n long x[KK + KK - 1]; /* the preparation buffer */\n\n register int j;\n register int t;\n register long ss;\n\n if (s == 0 ) \n s = 314159; /* default seed used by Knuth */\n\n ss = (s + 2)&(MM-2);\n\n for (j = 0; j < KK; j++)\n {\n x[j] = ss; /* bootstrap the buffer */\n ss <<= 1;\n if (ss >= MM) /* cyclic shift 29 bits */\n ss -= MM - 2;\n }\n x[1]++; /* make x[1] (and only x[1]) odd */\n\n ss = s & (MM - 1);\n t = TT - 1;\n while (t)\n {\n for (j = KK - 1; j > 0; j--) /* square */\n {\n x[j + j] = x[j];\n x[j + j - 1] = 0;\n }\n\n for (j = KK + KK - 2; j >= KK; j--)\n {\n x[j - (KK - LL)] = mod_diff (x[j - (KK - LL)], x[j]);\n x[j - KK] = mod_diff (x[j - KK], x[j]);\n }\n\n if (is_odd (ss))\n { /* multiply by \"z\" */\n for (j = KK; j > 0; j--)\n {\n x[j] = x[j - 1];\n }\n x[0] = x[KK]; /* shift the buffer cyclically */\n x[LL] = mod_diff (x[LL], x[KK]);\n }\n\n if (ss)\n ss >>= 1;\n else\n t--;\n }\n\n for (j = 0; j < LL; j++)\n state->ran_x[j + KK - LL] = x[j];\n for (; j < KK; j++)\n state->ran_x[j - LL] = x[j];\n\n\n for (j = 0; j< 10; j++) \n ran_array(x, KK+KK-1, state->ran_x); /* warm things up */\n\n state->i = 0;\n\n return;\n}\n\nstatic const gsl_rng_type ran_type = {\n \"knuthran2002\", /* name */\n 0x3fffffffUL, /* RAND_MAX = (2 ^ 30) - 1 */\n 0, /* RAND_MIN */\n sizeof (ran_state_t),\n &ran_set,\n &ran_get,\n &ran_get_double\n};\n\nconst gsl_rng_type *gsl_rng_knuthran2002 = &ran_type;\n", "meta": {"hexsha": "838b351f61f86e14850720b2dbc8885d08230d7c", "size": 4882, "ext": "c", "lang": "C", "max_stars_repo_path": "pkgs/libs/gsl/src/rng/knuthran2002.c", "max_stars_repo_name": "manggoguy/parsec-modified", "max_stars_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 64.0, "max_stars_repo_stars_event_min_datetime": "2015-03-06T00:30:56.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-24T13:26:53.000Z", "max_issues_repo_path": "pkgs/libs/gsl/src/rng/knuthran2002.c", "max_issues_repo_name": "manggoguy/parsec-modified", "max_issues_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 12.0, "max_issues_repo_issues_event_min_datetime": "2020-12-15T08:30:19.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-13T03:54:24.000Z", "max_forks_repo_path": "pkgs/libs/gsl/src/rng/knuthran2002.c", "max_forks_repo_name": "manggoguy/parsec-modified", "max_forks_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 40.0, "max_forks_repo_forks_event_min_datetime": "2015-02-26T15:31:16.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-03T23:23:37.000Z", "avg_line_length": 25.6947368421, "max_line_length": 81, "alphanum_fraction": 0.5362556329, "num_tokens": 1468, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8175744673038222, "lm_q2_score": 0.661922862511608, "lm_q1q2_score": 0.541171231714149}} {"text": "/* Copied from the article:\nhttp://amitsaha.github.io/site/notes/articles/c_scientific/article.html\n*/\n\n/*Listing-1: gsl_vector.c*/\n\n/* Simple demo of the vector support in GSL\n * Also uses the random number generation feature\n */\n\n#include \n#include /*For Vectors*/\n#include /* For Random numbers*/\n\nint main ()\n{\n int i,n;\n /* Setup the Random number generator*/\n const gsl_rng_type * T;\n gsl_rng * r;\n gsl_rng_env_setup();\n T = gsl_rng_default;\n r = gsl_rng_alloc (T);\n\n n = 10;\n\n /* Allocate the vector of the specified size*/\n gsl_vector * v = gsl_vector_alloc (n);\n\n /* Set the elements to a uniform random number in [0,1]*/\n for (i = 0; i < n; i++)\n {\n gsl_vector_set (v, i, gsl_rng_uniform (r));\n }\n\n /* Print the vector*/\n for (i = 0; i < n; i++)\n {\n printf (\"v_%d = %g\\n\", i, gsl_vector_get (v, i));\n }\n\n gsl_vector_free (v);\n\n return 0;\n}\n", "meta": {"hexsha": "86d291ef0009b38ba1fbb203dbdda330c7a55153", "size": 933, "ext": "c", "lang": "C", "max_stars_repo_path": "c/gsl_vector.c", "max_stars_repo_name": "FedoraScientific/scientific_spin_tests", "max_stars_repo_head_hexsha": "953620749c50092e0265846f49d89b1de77e93d3", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2015-04-06T02:09:57.000Z", "max_stars_repo_stars_event_max_datetime": "2015-04-06T02:09:57.000Z", "max_issues_repo_path": "c/gsl_vector.c", "max_issues_repo_name": "FedoraScientific/scientific_spin_tests", "max_issues_repo_head_hexsha": "953620749c50092e0265846f49d89b1de77e93d3", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2018-03-27T06:42:26.000Z", "max_issues_repo_issues_event_max_datetime": "2018-03-27T06:42:26.000Z", "max_forks_repo_path": "c/gsl_vector.c", "max_forks_repo_name": "FedoraScientific/scientific_spin_tests", "max_forks_repo_head_hexsha": "953620749c50092e0265846f49d89b1de77e93d3", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 20.2826086957, "max_line_length": 71, "alphanum_fraction": 0.6259378349, "num_tokens": 278, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7401743505760728, "lm_q2_score": 0.7310585669110203, "lm_q1q2_score": 0.541110799996439}} {"text": "static const char help[] =\n\"Solves a 2D dam-saturation problem. No options.\\n\"\n\"The exact soluution is not known, but\\n\"\n\"a coarse-grid discrete solution can be checked against that source.\\n\"\n\"Note Poisson2DFunctionLocal() sets-up this unconstrained problem:\\n\"\n\" - u_xx - u_yy = - 1\\n\"\n\"while we want this complementarity problem:\\n\"\n\" F(u) = - u_xx - u_yy + 1 >= 0\\n\"\n\" u >= 0\\n\"\n\" u F(u) = 0.\\n\"\n\"As with obstacle.c, this is solved (default) by -snes_type vinewtonrsls.\\n\"\n\"Reference: pages 667-668 of Brandt & Cryer (1983).\\n\\n\";\n\n/*\nnote PFAS is not implemented in PETSc, but the following runs for X = 1,2,3,4,5,6\nquickly solve the same problems as in Brandt & Cryer Table 4.2:\n s ./dam -snes_monitor -pc_type mg -snes_grid_sequence X\n\non ed-galago I can go up to X = 11 giving 4097 x 6145 grid and serial runtime of 297 seconds\n(the next step runs out of memory)\n\non parallel I am getting error messages with vinewtonrsls + mg:\n mpiexec -n 4 ./dam -snes_converged_reason -snes_grid_sequence 5 -snes_type vinewtonrsls -pc_type mg\nbut this works with either vinewtonssls or another PC (gamg or bjacobi+ilu or asm+lu or etc.)\n\nrun as:\n ./dam -da_refine 1 -snes_view_solution :foo.m:ascii_matlab -snes_converged_reason -snes_rtol 1.0e-12\nNonlinear solve converged due to CONVERGED_FNORM_RELATIVE iterations 4\ndone on 5 x 7 grid\n\nthen in Matlab/Octave you can compare to Brandt & Cryer Table 4.1:\n>> foo\n>> format long g\n>> u = flipud(reshape(Vec_0x84000000_0,5,7)') % use loaded name here\nu =\n 0 0 0 0 0\n 8 2.53716015237691 0 0 0\n 32 18.148640609503 6.78414305345868 0 0\n 72 47.2732592321936 24.9879316043211 7.91201621181146 0\n 128 89.9564647149903 53.982307919772 22.6601332428759 0\n 200 146.570291707977 94.3247021169195 44.7462088399388 0\n 288 218 148 78 8\n\nregarding computing seepage face height, runs\n ./dam -snes_converged_reason -pc_type mg -snes_rtol 1.0e-8 -snes_grid_sequence X\ngives:\n X grid height\n 6 129x193 8.8750000\n 7 257x385 8.7500000\n 8 513x769 8.7500000\n 9 1025x1537 8.7343750\n 10 2049x3073 8.7187500\n 11 4097x6145 8.7109375\nbut note these numbers depend (at the second digit, even) on the value of\n\"wetthreshold\" in GetSeepageFaceHeight()\n*/\n\n#include \n#include \"../../ch6/poissonfunctions.h\"\n\ntypedef struct {\n double a, y1, y2;\n} DamCtx;\n\ndouble g_fcn(double x, double y, double z, void *ctx) {\n PoissonCtx *user = (PoissonCtx*)ctx;\n DamCtx *dctx = (DamCtx*)(user->addctx);\n const double a = dctx->a,\n y1 = dctx->y1,\n y2 = dctx->y2,\n tol = a * 1.0e-8;\n // see (4.2) in Brandt & Cryer for following:\n if (x < tol) {\n return (y1 - y) * (y1 - y) / 2.0; // AB\n } else if (x > a - tol) {\n if (y < y2) {\n return (y2 - y) * (y2 - y) / 2.0; // CD\n } else {\n return 0.0; // DF\n }\n } else if (y < tol) {\n return (y1 * y1 * (a - x) + y2 * y2 * x) / (2.0 * a); // BC\n } else if (y > y1 - tol) {\n return 0.0; // FA\n } else {\n return NAN;\n }\n}\n\ndouble f_fcn(double x, double y, double z, void *ctx) {\n return -1.0;\n}\n\nextern PetscErrorCode FormBounds(SNES, Vec, Vec);\nextern PetscErrorCode GetSeepageFaceHeight(DMDALocalInfo*, Vec, double*, DamCtx*);\n\nint main(int argc,char **argv) {\n PetscErrorCode ierr;\n DM da, da_after;\n SNES snes;\n Vec u;\n PoissonCtx user;\n DamCtx dctx;\n DMDALocalInfo info;\n double height;\n\n PetscInitialize(&argc,&argv,NULL,help);\n\n dctx.a = 16.0; // a, y1, y2 from Brandt & Cryer\n dctx.y1 = 24.0;\n dctx.y2 = 4.0;\n user.cx = 1.0;\n user.cy = 1.0;\n user.cz = 1.0;\n user.g_bdry = &g_fcn;\n user.f_rhs = &f_fcn;\n user.addctx = &dctx;\n\n ierr = DMDACreate2d(PETSC_COMM_WORLD,\n DM_BOUNDARY_NONE, DM_BOUNDARY_NONE, DMDA_STENCIL_STAR,\n 3,4, // override with -da_refine or -da_grid_x,_y\n PETSC_DECIDE,PETSC_DECIDE, // num of procs in each dim\n 1,1,NULL,NULL, // dof = 1 and stencil width = 1\n &da);CHKERRQ(ierr);\n ierr = DMSetFromOptions(da); CHKERRQ(ierr);\n ierr = DMSetUp(da); CHKERRQ(ierr);\n ierr = DMDASetUniformCoordinates(da,0.0,dctx.a,0.0,dctx.y1,-1.0,-1.0);CHKERRQ(ierr);\n ierr = DMSetApplicationContext(da,&user);CHKERRQ(ierr);\n\n ierr = SNESCreate(PETSC_COMM_WORLD,&snes);CHKERRQ(ierr);\n ierr = SNESSetDM(snes,da);CHKERRQ(ierr);\n ierr = SNESSetApplicationContext(snes,&user);CHKERRQ(ierr);\n\n ierr = SNESSetType(snes,SNESVINEWTONRSLS);CHKERRQ(ierr);\n ierr = SNESVISetComputeVariableBounds(snes,&FormBounds);CHKERRQ(ierr);\n \n ierr = DMDASNESSetFunctionLocal(da,INSERT_VALUES,\n (DMDASNESFunction)Poisson2DFunctionLocal,&user); CHKERRQ(ierr);\n ierr = DMDASNESSetJacobianLocal(da,\n (DMDASNESJacobian)Poisson2DJacobianLocal,&user); CHKERRQ(ierr);\n ierr = SNESSetFromOptions(snes);CHKERRQ(ierr);\n\n ierr = DMCreateGlobalVector(da,&u);CHKERRQ(ierr);\n // initial iterate has u=g on boundary and u=0 in interior\n ierr = InitialState(da, ZEROS, PETSC_TRUE, u, &user); CHKERRQ(ierr);\n\n /* solve */\n ierr = SNESSolve(snes,NULL,u);CHKERRQ(ierr);\n ierr = VecDestroy(&u); CHKERRQ(ierr);\n ierr = DMDestroy(&da); CHKERRQ(ierr);\n\n // report seepage face\n ierr = SNESGetSolution(snes,&u); CHKERRQ(ierr); /* do not destroy u */\n ierr = SNESGetDM(snes,&da_after); CHKERRQ(ierr);\n ierr = DMDAGetLocalInfo(da_after,&info); CHKERRQ(ierr);\n ierr = GetSeepageFaceHeight(&info,u,&height,&dctx); CHKERRQ(ierr);\n ierr = PetscPrintf(PETSC_COMM_WORLD,\n \"done on %3d x %3d grid; computed seepage face height = %.7f\\n\",\n info.mx,info.my,height); CHKERRQ(ierr);\n\n SNESDestroy(&snes);\n return PetscFinalize();\n}\n\n// for call-back: tell SNESVI we want 0 <= u < +infinity\nPetscErrorCode FormBounds(SNES snes, Vec Xl, Vec Xu) {\n PetscErrorCode ierr;\n ierr = VecSet(Xl,0.0);CHKERRQ(ierr);\n ierr = VecSet(Xu,PETSC_INFINITY);CHKERRQ(ierr);\n return 0;\n}\n\nPetscErrorCode GetSeepageFaceHeight(DMDALocalInfo *info, Vec u, double *height, DamCtx *dctx) {\n PetscErrorCode ierr;\n MPI_Comm comm;\n const double dy = dctx->y1 / (PetscReal)(info->my-1),\n wetthreshhold = 1.0e-6; // what does \"u>0\" mean?\n int j;\n double **au, locwetmax = - PETSC_INFINITY;\n ierr = DMDAVecGetArrayRead(info->da,u,&au); CHKERRQ(ierr);\n if (info->xs+info->xm == info->mx) { // do we even own (part of) the x=a side of the rectangle?\n for (j=info->ys; jys+info->ym; j++) {\n if (au[j][info->mx-2] > wetthreshhold) { // is the first inter point wet?\n locwetmax = PetscMax(j*dy,locwetmax);\n }\n }\n }\n ierr = DMDAVecRestoreArrayRead(info->da,u,&au); CHKERRQ(ierr);\n ierr = PetscObjectGetComm((PetscObject)(info->da),&comm); CHKERRQ(ierr);\n ierr = MPI_Allreduce(&locwetmax,height,1,MPI_DOUBLE,MPI_MAX,comm); CHKERRQ(ierr);\n *height -= dctx->y2; // height is segment ED in figure\n return 0;\n}\n\n", "meta": {"hexsha": "2d1d6dbd4bb8b0e1cc3b9c253a5dae42cca3700d", "size": 7555, "ext": "c", "lang": "C", "max_stars_repo_path": "c/ch12/solns/dam.c", "max_stars_repo_name": "mapengfei-nwpu/p4pdes", "max_stars_repo_head_hexsha": "706411c1e745d7f825f336dcab3a62852538eaa4", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "c/ch12/solns/dam.c", "max_issues_repo_name": "mapengfei-nwpu/p4pdes", "max_issues_repo_head_hexsha": "706411c1e745d7f825f336dcab3a62852538eaa4", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "c/ch12/solns/dam.c", "max_forks_repo_name": "mapengfei-nwpu/p4pdes", "max_forks_repo_head_hexsha": "706411c1e745d7f825f336dcab3a62852538eaa4", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.7435897436, "max_line_length": 104, "alphanum_fraction": 0.6039708802, "num_tokens": 2445, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7431680086124811, "lm_q2_score": 0.7279754371026367, "lm_q1q2_score": 0.541008055910367}} {"text": "/* linalg/bidiag.c\n * \n * Copyright (C) 2001, 2007 Brian Gough\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n/* Factorise a matrix A into\n *\n * A = U B V^T\n *\n * where U and V are orthogonal and B is upper bidiagonal. \n *\n * On exit, B is stored in the diagonal and first superdiagonal of A.\n *\n * U is stored as a packed set of Householder transformations in the\n * lower triangular part of the input matrix below the diagonal.\n *\n * V is stored as a packed set of Householder transformations in the\n * upper triangular part of the input matrix above the first\n * superdiagonal.\n *\n * The full matrix for U can be obtained as the product\n *\n * U = U_1 U_2 .. U_N\n *\n * where \n *\n * U_i = (I - tau_i * u_i * u_i')\n *\n * and where u_i is a Householder vector\n *\n * u_i = [0, .. , 0, 1, A(i+1,i), A(i+3,i), .. , A(M,i)]\n *\n * The full matrix for V can be obtained as the product\n *\n * V = V_1 V_2 .. V_(N-2)\n *\n * where \n *\n * V_i = (I - tau_i * v_i * v_i')\n *\n * and where v_i is a Householder vector\n *\n * v_i = [0, .. , 0, 1, A(i,i+2), A(i,i+3), .. , A(i,N)]\n *\n * See Golub & Van Loan, \"Matrix Computations\" (3rd ed), Algorithm 5.4.2 \n *\n * Note: this description uses 1-based indices. The code below uses\n * 0-based indices \n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\nint \ngsl_linalg_bidiag_decomp (gsl_matrix * A, gsl_vector * tau_U, gsl_vector * tau_V) \n{\n if (A->size1 < A->size2)\n {\n GSL_ERROR (\"bidiagonal decomposition requires M>=N\", GSL_EBADLEN);\n }\n else if (tau_U->size != A->size2)\n {\n GSL_ERROR (\"size of tau_U must be N\", GSL_EBADLEN);\n }\n else if (tau_V->size + 1 != A->size2)\n {\n GSL_ERROR (\"size of tau_V must be (N - 1)\", GSL_EBADLEN);\n }\n else\n {\n const size_t M = A->size1;\n const size_t N = A->size2;\n gsl_vector * tmp = gsl_vector_alloc(M);\n size_t j;\n \n for (j = 0 ; j < N; j++)\n {\n /* apply Householder transformation to current column */\n gsl_vector_view v = gsl_matrix_subcolumn(A, j, j, M - j);\n double tau_j = gsl_linalg_householder_transform (&v.vector);\n\n /* apply the transformation to the remaining columns */\n if (j + 1 < N)\n {\n gsl_matrix_view m = gsl_matrix_submatrix (A, j, j + 1, M - j, N - j - 1);\n gsl_vector_view work = gsl_vector_subvector(tau_U, j, N - j - 1);\n gsl_linalg_householder_left (tau_j, &v.vector, &m.matrix, &work.vector);\n }\n\n gsl_vector_set (tau_U, j, tau_j); \n\n /* apply Householder transformation to current row */\n if (j + 1 < N)\n {\n v = gsl_matrix_subrow (A, j, j + 1, N - j - 1);\n tau_j = gsl_linalg_householder_transform (&v.vector);\n \n /* apply the transformation to the remaining rows */\n if (j + 1 < M)\n {\n gsl_matrix_view m = gsl_matrix_submatrix (A, j + 1, j + 1, M - j - 1, N - j - 1);\n gsl_vector_view work = gsl_vector_subvector(tmp, 0, M - j - 1);\n gsl_linalg_householder_right (tau_j, &v.vector, &m.matrix, &work.vector);\n }\n\n gsl_vector_set (tau_V, j, tau_j);\n }\n }\n\n gsl_vector_free(tmp);\n\n return GSL_SUCCESS;\n }\n}\n\n/* Form the orthogonal matrices U, V, diagonal d and superdiagonal sd\n from the packed bidiagonal matrix A */\n\nint\ngsl_linalg_bidiag_unpack (const gsl_matrix * A, \n const gsl_vector * tau_U, \n gsl_matrix * U, \n const gsl_vector * tau_V,\n gsl_matrix * V,\n gsl_vector * diag, \n gsl_vector * superdiag)\n{\n const size_t M = A->size1;\n const size_t N = A->size2;\n\n const size_t K = GSL_MIN(M, N);\n\n if (M < N)\n {\n GSL_ERROR (\"matrix A must have M >= N\", GSL_EBADLEN);\n }\n else if (tau_U->size != K)\n {\n GSL_ERROR (\"size of tau must be MIN(M,N)\", GSL_EBADLEN);\n }\n else if (tau_V->size + 1 != K)\n {\n GSL_ERROR (\"size of tau must be MIN(M,N) - 1\", GSL_EBADLEN);\n }\n else if (U->size1 != M || U->size2 != N)\n {\n GSL_ERROR (\"size of U must be M x N\", GSL_EBADLEN);\n }\n else if (V->size1 != N || V->size2 != N)\n {\n GSL_ERROR (\"size of V must be N x N\", GSL_EBADLEN);\n }\n else if (diag->size != K)\n {\n GSL_ERROR (\"size of diagonal must match size of A\", GSL_EBADLEN);\n }\n else if (superdiag->size + 1 != K)\n {\n GSL_ERROR (\"size of subdiagonal must be (diagonal size - 1)\", GSL_EBADLEN);\n }\n else\n {\n size_t i, j;\n\n /* Copy diagonal into diag */\n\n for (i = 0; i < N; i++)\n {\n double Aii = gsl_matrix_get (A, i, i);\n gsl_vector_set (diag, i, Aii);\n }\n\n /* Copy superdiagonal into superdiag */\n\n for (i = 0; i < N - 1; i++)\n {\n double Aij = gsl_matrix_get (A, i, i+1);\n gsl_vector_set (superdiag, i, Aij);\n }\n\n /* Initialize V to the identity */\n\n gsl_matrix_set_identity (V);\n\n for (i = N - 1; i-- > 0;)\n {\n /* Householder row transformation to accumulate V */\n gsl_vector_const_view h = gsl_matrix_const_subrow (A, i, i + 1, N - i - 1);\n double ti = gsl_vector_get (tau_V, i);\n gsl_matrix_view m = gsl_matrix_submatrix (V, i + 1, i + 1, N- i - 1, N - i - 1);\n gsl_vector_view work = gsl_matrix_subrow(U, 0, 0, N - i - 1);\n \n gsl_linalg_householder_left (ti, &h.vector, &m.matrix, &work.vector);\n }\n\n /* Initialize U to the identity */\n\n gsl_matrix_set_identity (U);\n\n for (j = N; j-- > 0;)\n {\n /* Householder column transformation to accumulate U */\n gsl_vector_const_view h = gsl_matrix_const_subcolumn (A, j, j, M - j);\n double tj = gsl_vector_get (tau_U, j);\n gsl_matrix_view m = gsl_matrix_submatrix (U, j, j, M - j, N - j);\n \n gsl_linalg_householder_hm (tj, &h.vector, &m.matrix);\n }\n\n return GSL_SUCCESS;\n }\n}\n\nint\ngsl_linalg_bidiag_unpack2 (gsl_matrix * A, \n gsl_vector * tau_U, \n gsl_vector * tau_V,\n gsl_matrix * V)\n{\n const size_t M = A->size1;\n const size_t N = A->size2;\n\n const size_t K = GSL_MIN(M, N);\n\n if (M < N)\n {\n GSL_ERROR (\"matrix A must have M >= N\", GSL_EBADLEN);\n }\n else if (tau_U->size != K)\n {\n GSL_ERROR (\"size of tau must be MIN(M,N)\", GSL_EBADLEN);\n }\n else if (tau_V->size + 1 != K)\n {\n GSL_ERROR (\"size of tau must be MIN(M,N) - 1\", GSL_EBADLEN);\n }\n else if (V->size1 != N || V->size2 != N)\n {\n GSL_ERROR (\"size of V must be N x N\", GSL_EBADLEN);\n }\n else\n {\n size_t i, j;\n\n /* Initialize V to the identity */\n\n gsl_matrix_set_identity (V);\n\n for (i = N - 1; i-- > 0;)\n {\n /* Householder row transformation to accumulate V */\n gsl_vector_const_view r = gsl_matrix_const_row (A, i);\n gsl_vector_const_view h = \n gsl_vector_const_subvector (&r.vector, i + 1, N - (i+1));\n \n double ti = gsl_vector_get (tau_V, i);\n \n gsl_matrix_view m = \n gsl_matrix_submatrix (V, i + 1, i + 1, N-(i+1), N-(i+1));\n \n gsl_linalg_householder_hm (ti, &h.vector, &m.matrix);\n }\n\n /* Copy superdiagonal into tau_v */\n\n for (i = 0; i < N - 1; i++)\n {\n double Aij = gsl_matrix_get (A, i, i+1);\n gsl_vector_set (tau_V, i, Aij);\n }\n\n /* Allow U to be unpacked into the same memory as A, copy\n diagonal into tau_U */\n\n for (j = N; j-- > 0;)\n {\n /* Householder column transformation to accumulate U */\n double tj = gsl_vector_get (tau_U, j);\n double Ajj = gsl_matrix_get (A, j, j);\n gsl_matrix_view m = gsl_matrix_submatrix (A, j, j, M-j, N-j);\n\n gsl_vector_set (tau_U, j, Ajj);\n gsl_linalg_householder_hm1 (tj, &m.matrix);\n }\n\n return GSL_SUCCESS;\n }\n}\n\n\nint\ngsl_linalg_bidiag_unpack_B (const gsl_matrix * A, \n gsl_vector * diag, \n gsl_vector * superdiag)\n{\n const size_t M = A->size1;\n const size_t N = A->size2;\n\n const size_t K = GSL_MIN(M, N);\n\n if (diag->size != K)\n {\n GSL_ERROR (\"size of diagonal must match size of A\", GSL_EBADLEN);\n }\n else if (superdiag->size + 1 != K)\n {\n GSL_ERROR (\"size of subdiagonal must be (matrix size - 1)\", GSL_EBADLEN);\n }\n else\n {\n size_t i;\n\n /* Copy diagonal into diag */\n\n for (i = 0; i < K; i++)\n {\n double Aii = gsl_matrix_get (A, i, i);\n gsl_vector_set (diag, i, Aii);\n }\n\n /* Copy superdiagonal into superdiag */\n\n for (i = 0; i < K - 1; i++)\n {\n double Aij = gsl_matrix_get (A, i, i+1);\n gsl_vector_set (superdiag, i, Aij);\n }\n\n return GSL_SUCCESS;\n }\n}\n", "meta": {"hexsha": "d2a15e0317b18dd2b7db2ed46294ac1b88ace725", "size": 9968, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.6/linalg/bidiag.c", "max_stars_repo_name": "ielomariala/Hex-Game", "max_stars_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "gsl-2.6/linalg/bidiag.c", "max_issues_repo_name": "ielomariala/Hex-Game", "max_issues_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-12-16T17:41:24.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-22T00:00:16.000Z", "max_forks_repo_path": "test/lib/gsl-2.6/linalg/bidiag.c", "max_forks_repo_name": "karanbirsandhu/nu-sense", "max_forks_repo_head_hexsha": "83fd1fc4cbd053a4f9b673d5cd5841823ddd4d8b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 28.3181818182, "max_line_length": 99, "alphanum_fraction": 0.54785313, "num_tokens": 2853, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8128673087708699, "lm_q2_score": 0.6654105521116443, "lm_q1q2_score": 0.540890484722731}} {"text": "/*\n LAPACKE_dgesv Example\n =====================\n\n The program computes the solution to the system of linear\n equations with a square matrix A and multiple\n right-hand sides B, where A is the coefficient matrix\n and b is the right-hand side matrix:\n\n Description\n ===========\n\n The routine solves for X the system of linear equations A*X = B,\n where A is an n-by-n matrix, the columns of matrix B are individual\n right-hand sides, and the columns of X are the corresponding\n solutions.\n\n The LU decomposition with partial pivoting and row interchanges is\n used to factor A as A = P*L*U, where P is a permutation matrix, L\n is unit lower triangular, and U is upper triangular. The factored\n form of A is then used to solve the system of equations A*X = B.\n\n LAPACKE Interface\n =================\n\n LAPACKE_dgesv (row-major, high-level) Example Program Results\n\n -- LAPACKE Example routine (version 3.7.0) --\n -- LAPACK is a software package provided by Univ. of Tennessee, --\n -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..--\n December 2016\n\n*/\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#ifndef _LAPACKE_EXAMPLE_AUX_\n#define _LAPACKE_EXAMPLE_AUX_\n\n\nvoid print_matrix_rowmajor( char* desc, lapack_int m, lapack_int n, double* mat, lapack_int ldm );\nvoid print_matrix_colmajor( char* desc, lapack_int m, lapack_int n, double* mat, lapack_int ldm );\nvoid print_vector( char* desc, lapack_int n, lapack_int* vec );\n\n#endif /* _LAPACKE_EXAMPLE_AUX_*/\n\n#define FLT double\n//void mset(FLT **m, int n, int in) {\nvoid mset(FLT *m, int n, int in) {\n\tint i,j;\n for(i=0;i tmax)tmax=dt;\n\t\t\tif(dt < tmin)tmin=dt;\n\t\t\ttvect[icount]=dt;\n\t\t\tif(t2-tstart> 120.0)icount=1000000;\n\t\t\t/* Check for the exact singularity */\n\t\t\tif( info > 0 ) {\n\t\t\t\t\tprintf( \"The diagonal element of the triangular factor of A,\\n\" );\n\t\t\t\t\tprintf( \"U(%i,%i) is zero, so that A is singular;\\n\", info, info );\n\t\t\t\t\tprintf( \"the solution could not be computed.\\n\" );\n\t\t\t\t\texit( 1 );\n\t\t\t}\n\t\t\tif (info <0) exit( 1 );\n\t\t\t/* Print solution */\n\t\t\tif(DOP)print_matrix_rowmajor( \"Solution\", n, nrhs, b, ldb );\n\t\t\t/* Print details of LU factorization */\n\t\t\tif(DOP)print_matrix_rowmajor( \"Details of LU factorization\", n, n, A, lda );\n\t\t\t/* Print pivot indices */\n\t\t\tif(DOP)print_vector( \"Pivot indices\", n, ipiv );\n }\n printf(\"size= %d min=%g max=%g total=%g inverts=%d\\n\",n,tmin,tmax,t2-tstart,jcount);\n n=0;\n for(icount=0;icount\n#include \n\n/* Function that computes the inverse of a matrix using its Cholesky decomposition */\n\nvoid mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) {\n\n\t#define L_matlab prhs[0]\n\t#define ret_matlab plhs[0]\n\n\tint i, j, n, m;\n\tdouble *L, *ret;\n\tgsl_matrix *result;\n\n\tn = mxGetN(L_matlab);\n\tm = mxGetM(L_matlab);\n\t\n\t/* We ask for memory to store the matrix in the gnu library format */\n\n\tresult = gsl_matrix_alloc(n, m);\n\n\t/* We copy the matrix from the matlab format to the gnu library format */\n\n\tL = mxGetPr(L_matlab);\n\tfor (i = 0 ; i < n ; i++)\n\t\tfor (j = 0 ; j < m ; j++)\n\t\t\tgsl_matrix_set(result, i, j, L[ i + n * j ]);\n\n\tgsl_linalg_cholesky_decomp(result);\n\n\t/* We obtain the inverse of the matrix */\n\n\tgsl_linalg_cholesky_invert(result);\n\n\t/* We ask for memory to return the solution */\n\n\tret_matlab = mxCreateDoubleMatrix(n, m, mxREAL);\n\n\t/* We copy the solution from the gnu library representation to the matlab representation */\n\n\tret = mxGetPr(ret_matlab);\n\tfor (i = 0 ; i < n ; i++)\n\t\tfor (j = 0 ; j < m ; j++)\n\t\t\tret[ i + j * n ] = gsl_matrix_get(result, i, j);\n\n\t/* We are done */\n\n\tgsl_matrix_free(result);\n\n\treturn;\n}\n", "meta": {"hexsha": "e313a649a94120c6e1fa73e4007e4c29418d360d", "size": 1548, "ext": "c", "lang": "C", "max_stars_repo_path": "utils/chol2invchol.c", "max_stars_repo_name": "pubino/Max-value-Entropy-Search", "max_stars_repo_head_hexsha": "59bbd0b7332481fc6ef95a590c6a507049e7db30", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 46.0, "max_stars_repo_stars_event_min_datetime": "2017-03-22T16:13:35.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-07T13:36:25.000Z", "max_issues_repo_path": "baselines/FITBO/utility/chol2invchol.c", "max_issues_repo_name": "ntienvu/ICDM2019_PVRS", "max_issues_repo_head_hexsha": "ff2fbd6bb376b6cb84363006960c7d78abf891af", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 5.0, "max_issues_repo_issues_event_min_datetime": "2017-06-12T02:35:05.000Z", "max_issues_repo_issues_event_max_datetime": "2021-05-11T19:21:23.000Z", "max_forks_repo_path": "baselines/FITBO/utility/chol2invchol.c", "max_forks_repo_name": "ntienvu/ICDM2019_PVRS", "max_forks_repo_head_hexsha": "ff2fbd6bb376b6cb84363006960c7d78abf891af", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 15.0, "max_forks_repo_forks_event_min_datetime": "2017-05-27T02:48:48.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-22T21:41:42.000Z", "avg_line_length": 25.8, "max_line_length": 92, "alphanum_fraction": 0.6782945736, "num_tokens": 470, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7956581000631542, "lm_q2_score": 0.6791787056691698, "lm_q1q2_score": 0.5403940385560839}} {"text": "#include \n#include \n#include \n#include \n#include \n\n#define pi M_PI\n\n\n//#############################################################################\n//#############################################################################\n//Ray path solver\n\n//Data structure for pointers to julia cavity data and functions\ntypedef struct {\n //pointer to Boundary object\n void *bnd;\n //pointer to radius function\n double (*rfunc_p)(void *bnd,double theta);\n //pointer to (mutating) radius and normal vector angle function\n void (*rsys_p)(void *bnd, double theta, double results[]);\n //pointer to RefractiveIndex object\n void *idx;\n //pointer to refractive index value function\n double (*nfunc_p)(void *idx, double r, double theta);\n //pointer to (mutating) refractive index value and derivative function\n void (*nderiv_p)(void *idx, double r, double theta, double results[]);\n} cavinfo;\n\n\n//#############################################################################\n//Functions for ODE\n\n//ODE derivatives function\nint odefunc(double t, const double y[], double f[], void *params){\n //Get Julia pointers\n cavinfo *cip = (cavinfo *)params;\n \n //Calculate n and its derivatives and store in results array\n double results[3];\n (*(*cip).nderiv_p)((*cip).idx,y[0],y[1],results);\n //results[0] = n, results[1] = dn/dr, results[2] = dn/dtheta\n \n //Debugging purposes\n //printf(\"n = %.5f, dr_n = %.5f, dtheta_n = %.5f\\n\",n,dr_n,dtheta_n);\n \n //Calculate and store derivative of ODE coordinate vector\n //Equations are:\n //r' = p_r/n\n //theta' = p_theta/(r^2*n)\n //p_r' = p_theta^2/(r^3*n) + dn/dr\n //p_theta' = dn/dtheta\n f[0] = y[2]/results[0];\n f[1] = y[3]/(y[0]*y[0]*results[0]);\n f[2] = y[3]*y[3]/(y[0]*y[0]*y[0]*results[0]) + results[1];\n f[3] = results[2];\n \n return GSL_SUCCESS;\n}\n\n\n//ODE Jacobian function\nint odejac(double t, const double y[], double *dfdy, double dfdt[], void *params){\n //RK8PD does not require the Jacobian\n return GSL_SUCCESS;\n}\n\n\n//#############################################################################\n//Solver functions\n\n//Ray reflection\n//Re-compute a ray coordinate vector to simulate a bounce, using the ODE coordinate vectors S0 and S immediately before and after the bounce, where S0 = (r0,theta0,pr0,ptheta0), and S = (r,theta,pr,ptheta).\ndouble raybounce(cavinfo *cip, double S0[], double S[]){\n \n //Binary search for intersection of trajectory with cavity boundary\n //Assume that light trajectory between (r0,theta0) and (r,theta) is a straight line\n //(fastest way to interpolate, after all this is already within 1 stepsize of time)\n const double x0 = S0[0]*cos(S0[1]), y0 = S0[0]*sin(S0[1]);\n const double x1 = S[0]*cos(S[1]), y1 = S[0]*sin(S[1]);\n double uA = 0.0, uB = 1.0; //bounds of the binary search\n double xC,yC,rC,thetaC,RC,uC;\n do{\n uC = 0.5*(uA+uB); //get middle point\n xC = (1-uC)*x0 + uC*x1; yC = (1-uC)*y0 + uC*y1;\n rC = hypot(xC,yC); thetaC = atan2(yC,xC);\n RC = (*(*cip).rfunc_p)((*cip).bnd,thetaC);\n //Change boundary\n if(rC > RC) uB = uC;\n else uA = uC;\n } while(fabs(rC-RC) > 1e-12);\n \n //Get angle of incidence and store in results array\n double results[2];\n (*(*cip).rsys_p)((*cip).bnd,thetaC,results);\n //results[0] = rC, results[1] = alpha\n //Use linear interpolation to find ray angle phi at intersection\n const double phi0 = S0[1] + atan2(S0[3],S0[0]*S0[2]);\n const double phi1 = S[1] + atan2(S[3],S[0]*S[2]);\n const double phiC = (1-uC)*phi0 + uC*phi1;\n //Angle of incidence\n const double chi = phiC - results[1];\n \n //Store interpolated and reflected ODE coordinate vector\n const double phi = pi - chi + results[1]; //ray angle after reflection\n const double n = (*(*cip).nfunc_p)((*cip).idx,rC,thetaC);\n const double pr = n*cos(phi-thetaC);\n const double ptheta = n*rC*sin(phi-thetaC);\n S[0] = rC; S[1] = thetaC; S[2] = pr; S[3] = ptheta;\n \n //Report bounce information\n return chi;\n}\n\n\n//Ray evolution\nvoid rayevolve(\n //Storage arrays\n double raypath_r[], double raypath_theta[], long bounceindices[],\n double bouncepts_chi[], long lengths[],\n //Initial conditions\n double r0, double theta0, double pr0, double ptheta0,\n //Simulation parameters\n double tmax, long bouncemax, double reltol, double abstol,\n //Cavity parameters\n void *bnd, double (*rfunc_p)(void *bnd,double theta),\n void (*rsys_p)(void *bnd, double theta,double results[]),\n void *idx, double (*nfunc_p)(void *idx, double r, double theta),\n void (*nderiv_p)(void *idx, double r, double theta,double results[])){\n \n //Condense input cavity data into cavinfo struct\n cavinfo ci = {bnd,rfunc_p,rsys_p,idx,nfunc_p,nderiv_p};\n \n //Initialize solver\n gsl_odeiv2_system sys = {odefunc,odejac,4,&ci};\n const gsl_odeiv2_step_type *steptype = gsl_odeiv2_step_rk8pd;\n gsl_odeiv2_step *step = gsl_odeiv2_step_alloc(steptype,4);\n gsl_odeiv2_control *control = gsl_odeiv2_control_y_new(abstol,reltol);\n gsl_odeiv2_evolve *evolve = gsl_odeiv2_evolve_alloc(4);\n \n //Initialize parameters\n double t = 0.0, dt = 0.0001;\n double y0[4], y[4] = {r0,theta0,pr0,ptheta0};\n \n //Prepare results record\n long bouncenum = 0, stepnum = 1; //indicates postion to record next\n const long prealloc = 250*ceil(tmax); //length of preallocated raypath array\n raypath_r[0] = y[0]; raypath_theta[0] = y[1];\n \n //Solver loop\n while(t < tmax && bouncenum < bouncemax && stepnum < prealloc){\n //Record initial position\n y0[0] = y[0], y0[1] = y[1], y0[2] = y[2], y0[3] = y[3];\n \n //Run Solver\n int status = \n gsl_odeiv2_evolve_apply(evolve,control,step,&sys,&t,tmax,&dt,y);\n if(status != GSL_SUCCESS) break;\n \n //Check Hamiltonian once in a while for sanity check\n if(stepnum%1000 == 0){\n double H = y[2]*y[2]+y[3]*y[3]/(y[0]*y[0]) - gsl_pow_2((*ci.nfunc_p)(ci.idx,y[0],y[1]));\n if(H > 1e-9) printf(\"Warning: Error in Hamiltonian is %.f\\n\",H);\n }\n \n //Check difference in ray and boundary radial positions\n double dr = y[0] - (*ci.rfunc_p)(ci.bnd,y[1]);\n if(dr > 0){\n //Boundary crossing!\n //get chi and corrected y\n bouncepts_chi[bouncenum] = raybounce(&ci,y0,y);\n //store (Julia's 1-based) index for thetaC values recorded in \n //raypath_theta array\n bounceindices[bouncenum] = stepnum+1;\n bouncenum += 1;\n }\n \n //Record position \n raypath_r[stepnum] = y[0]; raypath_theta[stepnum] = y[1];\n stepnum += 1;\n \n //Display progress for debugging\n //printf(\"t = %.5f, y = [%.5f,%.5f,%.5f,%.5f]\\n\",t,y[0],y[1],y[2],y[3]);\n \n }\n //Store lengths of arrays\n lengths[0] = stepnum; lengths[1] = bouncenum;\n \n //Free memory\n gsl_odeiv2_step_free(step);\n gsl_odeiv2_control_free(control);\n gsl_odeiv2_evolve_free(evolve);\n \n}\n\n", "meta": {"hexsha": "ceaa11cf8a1a376f571e03987ba8b733ba224e6d", "size": 7481, "ext": "c", "lang": "C", "max_stars_repo_path": "src/ray.c", "max_stars_repo_name": "amyascwk/CavChaos.jl", "max_stars_repo_head_hexsha": "f4a2f9801af5e67a5648d37901a4e5cd377c064d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/ray.c", "max_issues_repo_name": "amyascwk/CavChaos.jl", "max_issues_repo_head_hexsha": "f4a2f9801af5e67a5648d37901a4e5cd377c064d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/ray.c", "max_forks_repo_name": "amyascwk/CavChaos.jl", "max_forks_repo_head_hexsha": "f4a2f9801af5e67a5648d37901a4e5cd377c064d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.1683673469, "max_line_length": 206, "alphanum_fraction": 0.5705119636, "num_tokens": 2214, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8887587964389112, "lm_q2_score": 0.6076631698328916, "lm_q1q2_score": 0.5400659874609344}} {"text": "/* specfunc/sincos_pi.c\n * \n * Copyright (C) 2017 Gerard Jungman, Konrad Griessinger (konradg@gmx.net)\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n/* routines for computing sin(pi*x) and cos(pi*x), respectively, with argument reduction */\n\n#include \n#include \n#include \n#include \n#include \n\n/* Any double precision number bigger than this is automatically an even integer. */\n#define TWOBIG (2.0 / GSL_DBL_EPSILON)\n\n/* routine computing sin(pi*x) valid for |x| <= 0.25 using a Taylor expansion around the origin and otherwise a rational approximation from the reference below. Spot-checked to give around 2e-16 relative accuracy. */\n/* I. Koren and O. Zinaty. Evaluating elementary functions in a numerical\ncoprocessor based on rational approximations. IEEE Transactions on\nComputers, Vol.39, No.8, August 1990, pp 1030-1037. */\n/*\nstatic int\nsin_pi_koren(const double x, gsl_sf_result *result)\n{\n result->val = 0.0;\n result->err = 0.0;\n if (16.0*fabs(x) < 1.0) {\n const double y = M_PI * x;\n const double a = y*y;\n result->val = y*(1.0 - a*(1.0 - a*(1.0 - a*(1.0 - a*(1.0 - a/110.0)/72.0)/42.0)/20.0)/6.0);\n }\n else {\n const double a0 = 1805490264.690988571178600370234394843221;\n const double a1 = -164384678.227499837726129612587952660511;\n const double a2 = 3664210.647581261810227924465160827365;\n const double a3 = -28904.140246461781357223741935980097;\n const double a4 = 76.568981088717405810132543523682;\n const double b0 = 2298821602.638922662086487520330827251172;\n const double b1 = 27037050.118894436776624866648235591988;\n const double b2 = 155791.388546947693206469423979505671;\n const double b3 = 540.567501261284024767779280700089;\n const double t = 16.0*x*x;\n result->val = 4.0*x*(((( a4*t + a3 )*t + a2 )*t + a1 )*t + a0)/(((( t + b3 )*t + b2 )*t + b1 )*t + b0);\n }\n \n result->err = GSL_DBL_EPSILON*fabs(result->val);\n \n return GSL_SUCCESS;\n}\n*/\n\n/* routine computing cos(pi*x) valid for |x| <= 0.25 using a Taylor expansion around the origin and otherwise a rational approximation from the reference below. Spot-checked to give around 2e-16 relative accuracy. */\n/* I. Koren and O. Zinaty. Evaluating elementary functions in a numerical\ncoprocessor based on rational approximations. IEEE Transactions on\nComputers, Vol.39, No.8, August 1990, pp 1030-1037. */\n/*\nstatic int\ncos_pi_koren(const double x, gsl_sf_result *result)\n{\n result->val = 0.0;\n result->err = 0.0;\n if (20.0*fabs(x) < 1.0) {\n const double y = M_PI * x;\n const double a = y*y;\n result->val = 1.0 - 0.5*a*(1.0 - a*(1.0 - a*(1.0 - a*(1.0 - a/90.0)/56.0)/30.0)/12.0);\n }\n else {\n const double a0 = 1090157078.174871420428849017262549038606;\n const double a1 = -321324810.993150712401352959397648541681;\n const double a2 = 12787876.849523878944051885325593878177;\n const double a3 = -150026.206045948110568310887166405972;\n const double a4 = 538.333564203182661664319151379451;\n const double b0 = 1090157078.174871420428867295670039506886;\n const double b1 = 14907035.776643879767410969509628406502;\n const double b2 = 101855.811943661368302608146695082218;\n const double b3 = 429.772865107391823245671264489311;\n const double t = 16.0*x*x;\n result->val = (((( a4*t + a3 )*t + a2 )*t + a1 )*t + a0)/(((( t + b3 )*t + b2 )*t + b1 )*t + b0);\n }\n \n result->err = GSL_DBL_EPSILON*fabs(result->val);\n \n return GSL_SUCCESS;\n}\n*/\n\n/* routine computing sin(pi*x) using a Taylor expansion around the origin and otherwise the library function. */\nstatic int\nsin_pi_taylor(const double x, gsl_sf_result *result)\n{\n result->val = 0.0;\n result->err = 0.0;\n if (16.0*fabs(x) < 1.0) {\n const double y = M_PI * x;\n const double a = y*y;\n result->val = y*(1.0 - a*(1.0 - a*(1.0 - a*(1.0 - a*(1.0 - a/110.0)/72.0)/42.0)/20.0)/6.0);\n }\n else {\n result->val = sin(M_PI*x);\n }\n \n result->err = GSL_DBL_EPSILON*fabs(result->val);\n \n return GSL_SUCCESS;\n}\n\n/* routine computing sin(pi*x) using a Taylor expansion around the origin and otherwise the library function. */\nstatic int\ncos_pi_taylor(const double x, gsl_sf_result *result)\n{\n result->val = 0.0;\n result->err = 0.0;\n if (20.0*fabs(x) < 1.0) {\n const double y = M_PI * x;\n const double a = y*y;\n result->val = 1.0 - 0.5*a*(1.0 - a*(1.0 - a*(1.0 - a*(1.0 - a/90.0)/56.0)/30.0)/12.0);\n }\n else {\n result->val = cos(M_PI*x);\n }\n \n result->err = GSL_DBL_EPSILON*fabs(result->val);\n \n return GSL_SUCCESS;\n}\n\nint\ngsl_sf_sin_pi_e(const double x, gsl_sf_result *result)\n{\n double intx = 0.0, fracx = 0.0;\n long q;\n int sign = 1, status;\n\n result->val = 0.0;\n result->err = 0.0;\n fracx = modf(x,&intx);\n if (fracx == 0.0) return GSL_SUCCESS;\n if(fabs(intx) >= TWOBIG) return GSL_SUCCESS; /* to be sure. Actually should be covered by the line above */\n\n q = ( ( (intx >= LONG_MIN) && (intx <= LONG_MAX) ) ? intx : fmod(intx, 2.0) );\n sign = ( q % 2 ? -1 : 1 );\n\n /* int sign = 1 - 2*((int)round(fmod(fabs(intx),2.0))); */\n if (fabs(fracx) == 0.5) { /* probably unnecessary */\n if (fracx < 0.0) sign = -sign;\n result->val = ( sign != 1 ? -1.0 : 1.0 );\n return GSL_SUCCESS;\n }\n if (fabs(fracx) > 0.5) {\n sign = -sign;\n fracx = ( fracx > 0.0 ? fracx-1.0 : fracx+1.0 );\n }\n\n status = 0;\n if (fracx > 0.25) {\n status = cos_pi_taylor((fracx-0.5), result);\n }\n else if (fracx < -0.25) {\n status = cos_pi_taylor((fracx+0.5), result);\n sign = -sign;\n }\n else {\n status = sin_pi_taylor(fracx, result);\n }\n if (sign != 1) result->val = -result->val;\n return status;\n}\n\nint\ngsl_sf_cos_pi_e(const double x, gsl_sf_result *result)\n{\n double intx = 0.0, fracx = 0.0;\n long q;\n int sign = 1, status;\n\n result->val = 0.0;\n result->err = 0.0;\n fracx = modf(x,&intx);\n if (fabs(fracx) == 0.5) return GSL_SUCCESS;\n \n if(fabs(intx) >= TWOBIG) {\n result->val = 1.0;\n return GSL_SUCCESS;\n }\n\n q = ( ( (intx >= LONG_MIN) && (intx <= LONG_MAX) ) ? intx : fmod(intx, 2.0) );\n sign = ( q % 2 ? -1 : 1 );\n\n /* int sign = 1 - 2*((int)round(fmod(fabs(intx),2.0))); */\n if (fracx == 0.0) { /* probably unnecessary */\n result->val = ( sign != 1 ? -1.0 : 1.0 );\n return GSL_SUCCESS;\n }\n if (fabs(fracx) > 0.5) {\n sign = -sign;\n fracx = ( fracx > 0.0 ? fracx-1.0 : fracx+1.0 );\n }\n\n status = 0;\n if (fracx > 0.25) {\n status = sin_pi_taylor((fracx-0.5), result);\n sign = -sign;\n }\n else if (fracx < -0.25) {\n status = sin_pi_taylor((fracx+0.5), result);\n }\n else {\n status = cos_pi_taylor(fracx, result);\n }\n if (sign != 1) result->val = -result->val;\n return status;\n}\n\n/*-*-*-*-*-*-*-*-*-* Functions w/ Natural Prototypes *-*-*-*-*-*-*-*-*-*-*/\n\n#include \"eval.h\"\n\ndouble\ngsl_sf_sin_pi(const double x)\n{\n EVAL_RESULT(gsl_sf_sin_pi_e(x, &result));\n}\n\ndouble\ngsl_sf_cos_pi(const double x)\n{\n EVAL_RESULT(gsl_sf_cos_pi_e(x, &result));\n}\n", "meta": {"hexsha": "bf46bdb1cca7a5e99e67f60fc6d3e514c1096a25", "size": 7690, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.6/specfunc/sincos_pi.c", "max_stars_repo_name": "ielomariala/Hex-Game", "max_stars_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-06-14T11:51:37.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-14T11:51:37.000Z", "max_issues_repo_path": "gsl-2.6/specfunc/sincos_pi.c", "max_issues_repo_name": "ielomariala/Hex-Game", "max_issues_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-12-16T17:41:24.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-22T00:00:16.000Z", "max_forks_repo_path": "test/lib/gsl-2.6/specfunc/sincos_pi.c", "max_forks_repo_name": "karanbirsandhu/nu-sense", "max_forks_repo_head_hexsha": "83fd1fc4cbd053a4f9b673d5cd5841823ddd4d8b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-01-20T16:22:57.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-14T12:31:02.000Z", "avg_line_length": 31.646090535, "max_line_length": 216, "alphanum_fraction": 0.6409622887, "num_tokens": 2676, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7905303186696747, "lm_q2_score": 0.6825737344123242, "lm_q1q2_score": 0.5395952317805245}} {"text": "#ifndef UTIL_H\n#define UTIL_H\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#ifdef USE_MKL\n#include \n#include \n#include \n#else\n#include \n#include \n#endif\n\ntypedef Eigen::SparseMatrix SpMat;\ntypedef Eigen::VectorBlock, -1> Segment;\ntypedef Eigen::Block, -1, -1> MatrixBlock;\n\nbool are_connected(Eigen::VectorXi &a, Eigen::VectorXi &b, SpMat &A);\nbool should_be_disconnected(int lvl1, int lvl2, int sep1, int sep2);\ndouble elapsed(timeval& start, timeval& end);\nvoid swap2perm(Eigen::VectorXi* swap, Eigen::VectorXi* perm);\nbool isperm(Eigen::VectorXi* perm);\nSpMat symmetric_graph(SpMat& A);\n\ntypedef timeval timer;\ntimer wctime();\n\n/* Concatenate the matrices vertically in the vector H */\nvoid concatenate(std::vector H, Eigen::MatrixXd* V);\nEigen::MatrixXd Vconcatenate(std::vector H);\nvoid rVconcatenate(std::vector H, Eigen::MatrixXd& Hc);\n\nEigen::VectorXd Vconcatenate(std::vector H);\n\n\n/* Concatenate the matrices horizontally in the vector H */\nEigen::MatrixXd Hconcatenate(std::vector H);\n/* Reverse the concatenation*/\nvoid rHconcatenate(std::vector H, Eigen::MatrixXd& Hc);\n\n\n/**\n * C <- alpha A * B + beta C\n * C <- alpha A^T * B + beta C\n * C <- alpha A * B^T + beta C\n * C <- alpha A^T * B^T + beta C\n * Gemm\n */\nvoid gemm(Eigen::MatrixXd* A, Eigen::MatrixXd* B, Eigen::MatrixXd* C, CBLAS_TRANSPOSE tA, CBLAS_TRANSPOSE tB, double alpha, double beta);\n\n/** Return a new\n * C <- alpha A^(/T) * B^(/T)\n **/\nEigen::MatrixXd* gemm_new(Eigen::MatrixXd* A, Eigen::MatrixXd* B, CBLAS_TRANSPOSE tA, CBLAS_TRANSPOSE tB, double alpha);\n\n/**\n * C <- C - A * A^T\n */\nvoid syrk(Eigen::MatrixXd* A, Eigen::MatrixXd* C);\n\n/** \n * A <- L, L L^T = A\n * Return != 0 if potf failed (not spd)\n */ \nint potf(Eigen::MatrixXd* A);\n\n/**\n * A <- [L\\U] (lower and upper)\n * p <- swap (NOT a permutation)\n * A[p] = L*U\n * L is unit diagonal\n * U is not\n * Return != 0 if getf failed (singular)\n */\nint getf(Eigen::MatrixXd* A, Eigen::VectorXi* swap);\n\n/**\n * Compute an estimated 1-norm condition number of A using its LU or Cholesky factorization\n */\ndouble rcond_1_getf(Eigen::MatrixXd* A_LU, double A_1_norm);\ndouble rcond_1_potf(Eigen::MatrixXd* A_LLT, double A_1_norm);\n\n/**\n * B <- B * L^(-1)\n * B <- B * L^(-T)\n * B <- B * U^(-1)\n * B <- B * U^(-T)\n */\nvoid trsm_right(Eigen::MatrixXd* L, Eigen::MatrixXd* B, CBLAS_UPLO uplo, CBLAS_TRANSPOSE trans, CBLAS_DIAG diag);\n\n/**\n * B <- L^(-1) * B\n * B <- L^(-T) * B\n * B <- U^(-1) * B\n * B <- U^(-T) * B\n */\nvoid trsm_left(Eigen::MatrixXd* L, Eigen::MatrixXd* B, CBLAS_UPLO uplo, CBLAS_TRANSPOSE trans, CBLAS_DIAG diag);\n\n/**\n * x <- L^(-1) * x\n * x <- L^(-T) * x\n * x <- U^(-1) * x\n * x <- U^(-T) * x\n */\nvoid trsv(Eigen::MatrixXd* L, Segment* x, CBLAS_UPLO uplo, CBLAS_TRANSPOSE trans, CBLAS_DIAG diag);\n\n/**\n * x <- L^T * x\n */\nvoid trmv_trans(Eigen::MatrixXd* L, Segment* x);\n\n/**\n * A <- L^T * A\n */\nvoid trmm_trans(Eigen::MatrixXd* L, Eigen::MatrixXd* A);\n\n/**\n * x2 <- x2 - A21 * x1\n */\nvoid gemv_notrans(Eigen::MatrixXd* A21, Segment* x1, Segment* x2);\n\n/**\n * x2 <- x2 - A12^T * x1\n */\nvoid gemv_trans(Eigen::MatrixXd* A12, Segment* x1, Segment* x2);\n\n/**\n * AP = QR\n */\nvoid geqp3(Eigen::MatrixXd* A, Eigen::VectorXi* jpvt, Eigen::VectorXd* tau);\n\n/**\n * Form householder vector from x\n */\ndouble house(Eigen::VectorXd& x);\n\n/**\n * RRQR with truncation when the max R_ii < tol\n */\nvoid rrqr(Eigen::MatrixXd* A, Eigen::VectorXi* jpvt, Eigen::VectorXd* tau, double& tol, int& rank);\n\n// template\n// Eigen::MatrixXd get_gaussian(const int rows, const int cols, T* gen);\ntemplate\nEigen::MatrixXd get_gaussian(const int rows, const int cols, T* gen) {\n std::normal_distribution norm_dist(0.0, 1.0);\n Eigen::MatrixXd W(rows, cols);\n for(int j = 0; j < cols; j++){\n for(int i = 0; i < rows; i++){\n W(i,j) = norm_dist(*gen);\n }\n }\n Eigen::VectorXd col_norms = W.colwise().norm();\n assert(col_norms.size() == cols);\n assert(col_norms.minCoeff() >= 0);\n if (col_norms.minCoeff() > 0) {\n return W.normalized();\n }\n return W;\n}\n\nEigen::MatrixXd get_uniform(const int rows, const int cols);\nvoid random_rrqr(const Eigen::MatrixXd* A, Eigen::MatrixXd* v, Eigen::VectorXd* h, double tol, std::function gen_gaussian);\n\n\n// void laqps(Eigen::MatrixXd* A, Eigen::VectorXi* jpvt, Eigen::VectorXd* tau, double& tol, int block_size, int& rank);\nvoid laqps(Eigen::MatrixXd* A, Eigen::VectorXi* jpvt, Eigen::VectorXd* tau, double& tol, int block_size, int& rank);\n/**\n * A = U S U^T\n * Compute the full EVD, where if A is mxm, U is mxm and S is mxm\n */\n\nvoid geevd(Eigen::MatrixXd* A, Eigen::MatrixXd* U, Eigen::VectorXd* S);\n\n/**\n * A = U S VT\n * Compute the full SVD, where if A is mxn, U is mxm, V is nxn, and S is min(M,N)\n * VT is V^T, *not* V.\n */\nvoid gesvd(Eigen::MatrixXd* A, Eigen::MatrixXd* U, Eigen::VectorXd* S, Eigen::MatrixXd* VT);\n\n/** \n * Compute the singular values of a matrix A\n * A = m x n matrix\n * S = min(M,N) vector\n */\nvoid gesvd_values(Eigen::MatrixXd* A, Eigen::VectorXd* S);\n\n/**\n * x <- Q * x\n * A <- Q * A\n */\nvoid ormqr_notrans(Eigen::MatrixXd* v, Eigen::VectorXd* h, Segment* x);\nvoid ormqr_notrans_left(Eigen::MatrixXd* v, Eigen::VectorXd* h, Eigen::MatrixXd* A);\n\n/**\n * A <- A * Q\n * */\nvoid ormqr_notrans_right(Eigen::MatrixXd* v, Eigen::VectorXd* h, Eigen::MatrixXd* A);\n/**\n * x <- Q^T * x\n * A <- Q^T * A\n */\nvoid ormqr_trans(Eigen::MatrixXd* v, Eigen::VectorXd* h, Segment* x);\nvoid ormqr_trans_left(Eigen::MatrixXd* v, Eigen::VectorXd* h, Eigen::MatrixXd* A);\n\n/**\n * A <- A * Q\n * A <- A * Q^T\n * A <- Q * A\n * A <- Q^T * A\n */\nvoid ormqr(Eigen::MatrixXd* v, Eigen::VectorXd* h, Eigen::MatrixXd* A, char side, char trans);\n\n/**\n * Create the thin Q\n */\nvoid orgqr(Eigen::MatrixXd* v, Eigen::VectorXd* h);\n\n/* Finds upper triangular matrix T such that,\n H = I - V * T * V^T\n using Householder vectors V and their norms tau\n H = Householder reflector matrix \n*/\nvoid larft(Eigen::MatrixXd* V, Eigen::VectorXd* tau, Eigen::MatrixXd* T);\n\n/* Apply householder vectors on a rectangular matrix \nV = [1 * * * *\n v(1) 1 * * *\n v(1) v(2) * * *\n v(1) v(2) v(3) * *]; \nH = H(1) H(2) H(3) ... H(k)\nC <- H^T C\n*/\nvoid larfb(Eigen::MatrixXd* V, Eigen::MatrixXd* T, Eigen::MatrixXd* C);\nvoid larfb(Eigen::MatrixXd* V, Eigen::MatrixXd* T, Eigen::VectorXd* C, char side = 'L', char trans = 'T', char direct = 'F', char storev = 'C');\n\n/**\n * A = QR\n */\nvoid geqrf(Eigen::MatrixXd* A, Eigen::VectorXd* tau);\n\nint choose_rank(Eigen::VectorXd& s, double tol, bool rel = true);\n\nstd::size_t hashv(std::vector vals);\n\n// Hash function for Eigen matrix and vector.\n// The code is from `hash_combine` function of the Boost library. See\n// http://www.boost.org/doc/libs/1_55_0/doc/html/hash/reference.html#boost.hash_combine .\ntemplate\nstruct matrix_hash : std::unary_function {\n std::size_t operator()(T const& matrix) const {\n // Note that it is oblivious to the storage order of Eigen matrix (column- or\n // row-major). It will give you the same hash value for two different matrices if they\n // are the transpose of each other in different storage order.\n size_t seed = 0;\n for (size_t i = 0; i < matrix.size(); ++i) {\n auto elem = *(matrix.data() + i);\n seed ^= std::hash()(elem) + 0x9e3779b9 + (seed << 6) + (seed >> 2);\n }\n return seed;\n }\n};\n\nvoid block2dense(Eigen::VectorXi &rowval, Eigen::VectorXi &colptr, Eigen::VectorXd &nnzval, int i, int j, int li, int lj, Eigen::MatrixXd *dst, bool transpose);\n\nEigen::MatrixXd linspace_nd(int n, int dim);\n\n// Returns A[p,p]\nSpMat symm_perm(SpMat &A, Eigen::VectorXi &p);\n\n// Permute the columns of non-square matrix A\nSpMat col_perm(SpMat &A, Eigen::VectorXi &p);\n\n// Random vector with seed\nEigen::VectorXd random(int size, int seed);\n\nEigen::MatrixXd random(int rows, int cols, int seed);\n\n// Print vector\ntemplate\nstd::ostream& operator<<(std::ostream& os, const std::vector& v) {\n for(auto v_ : v) {\n os << v_ << \" \" ;\n }\n os << std::endl;\n return os;\n}\n\n#endif\n", "meta": {"hexsha": "01cfbe26bb2a18ceab1e024a6ffbb749db918df9", "size": 8610, "ext": "h", "lang": "C", "max_stars_repo_path": "include/util.h", "max_stars_repo_name": "Abeynaya/spaQR_public", "max_stars_repo_head_hexsha": "4fd28b1a23c73feb914b40e4285d5a076ffc9058", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "include/util.h", "max_issues_repo_name": "Abeynaya/spaQR_public", "max_issues_repo_head_hexsha": "4fd28b1a23c73feb914b40e4285d5a076ffc9058", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "include/util.h", "max_forks_repo_name": "Abeynaya/spaQR_public", "max_forks_repo_head_hexsha": "4fd28b1a23c73feb914b40e4285d5a076ffc9058", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 28.6046511628, "max_line_length": 160, "alphanum_fraction": 0.6398373984, "num_tokens": 2740, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7981867777396212, "lm_q2_score": 0.6757646010190476, "lm_q1q2_score": 0.5393863693978943}} {"text": "/* specfunc/elljac.c\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 2 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.\n */\n\n/* Author: G. Jungman */\n\n#include \n#include \n#include \n#include \"gsl_sf_pow_int.h\"\n#include \"gsl_sf_elljac.h\"\n\n\n/* See [Thompson, Atlas for Computing Mathematical Functions] */\n\n\nint\ngsl_sf_elljac_e(double u, double m, double * sn, double * cn, double * dn)\n{\n if(fabs(m) > 1.0) {\n *sn = 0.0;\n *cn = 0.0;\n *dn = 0.0;\n GSL_ERROR (\"|m| > 1.0\", GSL_EDOM);\n }\n else if(fabs(m) < 2.0*GSL_DBL_EPSILON) {\n *sn = sin(u);\n *cn = cos(u);\n *dn = 1.0;\n return GSL_SUCCESS;\n }\n else if(fabs(m - 1.0) < 2.0*GSL_DBL_EPSILON) {\n *sn = tanh(u);\n *cn = 1.0/cosh(u);\n *dn = *cn;\n return GSL_SUCCESS;\n }\n else {\n int status = GSL_SUCCESS;\n const int N = 16;\n double a[16];\n double b[16];\n double c[16];\n double phi[16];\n double psi[16]; /* psi[i] := phi[i] - Pi 2^{i-1} */\n double two_N;\n int n = 0;\n\n a[0] = 1.0;\n b[0] = sqrt(1.0 - m);\n c[0] = sqrt(m);\n\n while( fabs(c[n]) > 4.0 * GSL_DBL_EPSILON) {\n a[n+1] = 0.5 * (a[n] + b[n]);\n b[n+1] = sqrt(a[n] * b[n]);\n c[n+1] = 0.5 * (a[n] - b[n]);\n if(n >= N - 2) {\n status = GSL_EMAXITER;\n\tc[N-1] = 0.0;\n\tbreak;\n }\n ++n;\n }\n\n --n;\n two_N = (double)(1 << n ); /* 2^n */ /* gsl_sf_pow_int(2.0, n); */\n phi[n] = two_N * a[n] * u;\n psi[n] = two_N * (a[n]*u - 0.5*M_PI);\n\n while(n > 0) {\n const double psi_sgn = ( n == 1 ? -1.0 : 1.0 );\n const double phi_asin_arg = c[n] * sin(phi[n])/a[n];\n const double psi_asin_arg = c[n]/a[n] * psi_sgn * sin(psi[n]);\n const double phi_asin = asin(phi_asin_arg);\n const double psi_asin = asin(psi_asin_arg);\n phi[n-1] = 0.5 * (phi[n] + phi_asin);\n psi[n-1] = 0.5 * (psi[n] + psi_asin);\n --n;\n }\n\n *sn = sin(phi[0]);\n *cn = cos(phi[0]);\n {\n /* const double dn_method_1 = *cn / cos(phi[1] - phi[0]); */\n const double dn_method_2 = sin(psi[0])/sin(psi[1] - psi[0]);\n *dn = dn_method_2;\n /* printf(\"%18.16g %18.16g\\n\", dn_method_1, dn_method_2); */\n }\n\n return status;\n }\n}\n\n", "meta": {"hexsha": "bddaad2a265b5913889c235f6ba20ed8f92daff3", "size": 2891, "ext": "c", "lang": "C", "max_stars_repo_path": "code/em/treba/gsl-1.0/specfunc/elljac.c", "max_stars_repo_name": "ICML14MoMCompare/spectral-learn", "max_stars_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-12-18T18:09:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-10T11:31:28.000Z", "max_issues_repo_path": "code/em/treba/gsl-1.0/specfunc/elljac.c", "max_issues_repo_name": "ICML14MoMCompare/spectral-learn", "max_issues_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "code/em/treba/gsl-1.0/specfunc/elljac.c", "max_forks_repo_name": "ICML14MoMCompare/spectral-learn", "max_forks_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2015-10-02T01:32:59.000Z", "max_forks_repo_forks_event_max_datetime": "2015-10-02T01:32:59.000Z", "avg_line_length": 26.5229357798, "max_line_length": 74, "alphanum_fraction": 0.5627810446, "num_tokens": 1020, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7606506526772883, "lm_q2_score": 0.7090191399336402, "lm_q1q2_score": 0.539315871551213}} {"text": "/* rng/taus.c\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000 James Theiler, Brian Gough\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 2 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n#include \n#include \n#include \n\n/* This is a maximally equidistributed combined Tausworthe\n generator. The sequence is,\n\n x_n = (s1_n ^ s2_n ^ s3_n) \n\n s1_{n+1} = (((s1_n & 4294967294) <<12) ^ (((s1_n <<13) ^ s1_n) >>19))\n s2_{n+1} = (((s2_n & 4294967288) << 4) ^ (((s2_n << 2) ^ s2_n) >>25))\n s3_{n+1} = (((s3_n & 4294967280) <<17) ^ (((s3_n << 3) ^ s3_n) >>11))\n\n computed modulo 2^32. In the three formulas above '^' means\n exclusive-or (C-notation), not exponentiation. Note that the\n algorithm relies on the properties of 32-bit unsigned integers (it\n is formally defined on bit-vectors of length 32). I have added a\n bitmask to make it work on 64 bit machines.\n\n We initialize the generator with s1_1 .. s3_1 = s_n MOD m, where\n s_n = (69069 * s_{n-1}) mod 2^32, and s_0 = s is the user-supplied\n seed.\n\n The theoretical value of x_{10007} is 2733957125. The subscript\n 10007 means (1) seed the generator with s=1 (2) do six warm-up\n iterations, (3) then do 10000 actual iterations.\n\n The period of this generator is about 2^88.\n\n From: P. L'Ecuyer, \"Maximally Equidistributed Combined Tausworthe\n Generators\", Mathematics of Computation, 65, 213 (1996), 203--213.\n\n This is available on the net from L'Ecuyer's home page,\n\n http://www.iro.umontreal.ca/~lecuyer/myftp/papers/tausme.ps\n ftp://ftp.iro.umontreal.ca/pub/simulation/lecuyer/papers/tausme.ps \n\n Update: April 2002\n\n There is an erratum in the paper \"Tables of Maximally\n Equidistributed Combined LFSR Generators\", Mathematics of\n Computation, 68, 225 (1999), 261--269:\n http://www.iro.umontreal.ca/~lecuyer/myftp/papers/tausme2.ps\n\n ... the k_j most significant bits of z_j must be non-\n zero, for each j. (Note: this restriction also applies to the \n computer code given in [4], but was mistakenly not mentioned in\n that paper.)\n \n This affects the seeding procedure by imposing the requirement\n s1 > 1, s2 > 7, s3 > 15.\n\n The generator taus2 has been added to satisfy this requirement.\n The original taus generator is unchanged.\n\n Update: November 2002\n\n There was a bug in the correction to the seeding procedure for s2.\n It affected the following seeds 254679140 1264751179 1519430319\n 2274823218 2529502358 3284895257 3539574397 (s2 < 8).\n\n*/\n\nstatic inline unsigned long int taus_get (void *vstate);\nstatic double taus_get_double (void *vstate);\nstatic void taus_set (void *state, unsigned long int s);\n\ntypedef struct\n {\n unsigned long int s1, s2, s3;\n }\ntaus_state_t;\n\nstatic inline unsigned long\ntaus_get (void *vstate)\n{\n taus_state_t *state = (taus_state_t *) vstate;\n\n#define MASK 0xffffffffUL\n#define TAUSWORTHE(s,a,b,c,d) (((s &c) <>b)\n\n state->s1 = TAUSWORTHE (state->s1, 13, 19, 4294967294UL, 12);\n state->s2 = TAUSWORTHE (state->s2, 2, 25, 4294967288UL, 4);\n state->s3 = TAUSWORTHE (state->s3, 3, 11, 4294967280UL, 17);\n\n return (state->s1 ^ state->s2 ^ state->s3);\n}\n\nstatic double\ntaus_get_double (void *vstate)\n{\n return taus_get (vstate) / 4294967296.0 ;\n}\n\nstatic void\ntaus_set (void *vstate, unsigned long int s)\n{\n taus_state_t *state = (taus_state_t *) vstate;\n\n if (s == 0)\n s = 1; /* default seed is 1 */\n\n#define LCG(n) ((69069 * n) & 0xffffffffUL)\n state->s1 = LCG (s);\n state->s2 = LCG (state->s1);\n state->s3 = LCG (state->s2);\n\n /* \"warm it up\" */\n taus_get (state);\n taus_get (state);\n taus_get (state);\n taus_get (state);\n taus_get (state);\n taus_get (state);\n return;\n}\n\nstatic void\ntaus2_set (void *vstate, unsigned long int s)\n{\n taus_state_t *state = (taus_state_t *) vstate;\n\n if (s == 0)\n s = 1; /* default seed is 1 */\n\n#define LCG(n) ((69069 * n) & 0xffffffffUL)\n state->s1 = LCG (s);\n if (state->s1 < 2) state->s1 += 2UL;\n state->s2 = LCG (state->s1);\n if (state->s2 < 8) state->s2 += 8UL;\n state->s3 = LCG (state->s2);\n if (state->s3 < 16) state->s3 += 16UL;\n\n /* \"warm it up\" */\n taus_get (state);\n taus_get (state);\n taus_get (state);\n taus_get (state);\n taus_get (state);\n taus_get (state);\n return;\n}\n\n\nstatic const gsl_rng_type taus_type =\n{\"taus\", /* name */\n 0xffffffffUL, /* RAND_MAX */\n 0, /* RAND_MIN */\n sizeof (taus_state_t),\n &taus_set,\n &taus_get,\n &taus_get_double};\n\nconst gsl_rng_type *gsl_rng_taus = &taus_type;\n\nstatic const gsl_rng_type taus2_type =\n{\"taus2\", /* name */\n 0xffffffffUL, /* RAND_MAX */\n 0, /* RAND_MIN */\n sizeof (taus_state_t),\n &taus2_set,\n &taus_get,\n &taus_get_double};\n\nconst gsl_rng_type *gsl_rng_taus2 = &taus2_type;\n", "meta": {"hexsha": "fd039f54025f618e35b8b97ddf49f6964940e970", "size": 5550, "ext": "c", "lang": "C", "max_stars_repo_path": "pkgs/libs/gsl/src/rng/taus.c", "max_stars_repo_name": "manggoguy/parsec-modified", "max_stars_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 64.0, "max_stars_repo_stars_event_min_datetime": "2015-03-06T00:30:56.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-24T13:26:53.000Z", "max_issues_repo_path": "pkgs/libs/gsl/src/rng/taus.c", "max_issues_repo_name": "manggoguy/parsec-modified", "max_issues_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 12.0, "max_issues_repo_issues_event_min_datetime": "2020-12-15T08:30:19.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-13T03:54:24.000Z", "max_forks_repo_path": "pkgs/libs/gsl/src/rng/taus.c", "max_forks_repo_name": "manggoguy/parsec-modified", "max_forks_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 40.0, "max_forks_repo_forks_event_min_datetime": "2015-02-26T15:31:16.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-03T23:23:37.000Z", "avg_line_length": 30.0, "max_line_length": 81, "alphanum_fraction": 0.6583783784, "num_tokens": 1806, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8418256472515683, "lm_q2_score": 0.640635861701035, "lm_q1q2_score": 0.53930369892904}} {"text": "/*\n NAME:\n normalize_row\n PURPOSE:\n normalize a row (or column) of a matrix given as logs\n CALLING SEQUENCE:\n normalize_row(gsl_matrix * q, int row,bool isrow,bool noweight,\n double weight)\n INPUT:\n q - matrix\n row - row to be normalized\n isrow - is it a row or a column\n noweight - add a weight to all of the values?\n weight - weight to be added to all of the values\n OUTPUT:\n normalization factor (i.e. logsum)\n REVISION HISTORY:\n 2008-09-21 - Written Bovy\n 2010-04-01 - Added noweight and weight inputs to allow the qij to have \n weights - Bovy\n*/\n#include \n#include \n#include \"proj_gauss_mixtures.h\"\n\ndouble normalize_row(gsl_matrix * q, int row, bool isrow,\n\t\t bool noweight, double weight){\n double loglike;\n if (isrow)\n loglike = logsum(q,row,true);\n else\n loglike = logsum(q,row,false);\n\n int dd;\n if (isrow)\n for (dd = 0; dd != q->size2; ++dd) {\n if ( noweight ) \n\tgsl_matrix_set(q,row,dd,gsl_matrix_get(q,row,dd)-loglike);\n else\n\tgsl_matrix_set(q,row,dd,gsl_matrix_get(q,row,dd)-loglike+weight);\n }\n else\n for (dd = 0; dd != q->size1; ++dd) {\n if ( noweight ) \n\tgsl_matrix_set(q,dd,row,gsl_matrix_get(q,dd,row)-loglike);\n else\n\tgsl_matrix_set(q,dd,row,gsl_matrix_get(q,dd,row)-loglike+weight);\n }\n if ( ! noweight ) loglike*= exp(weight);\n\n return loglike;\n}\n", "meta": {"hexsha": "db4155cfa0a2f192873f0c3a1f4fc61875da99b0", "size": 1452, "ext": "c", "lang": "C", "max_stars_repo_path": "src/normalize_row.c", "max_stars_repo_name": "surbut/mashr", "max_stars_repo_head_hexsha": "b66d2af16503bc46d785ac9c9ba447ecc29b6fae", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/normalize_row.c", "max_issues_repo_name": "surbut/mashr", "max_issues_repo_head_hexsha": "b66d2af16503bc46d785ac9c9ba447ecc29b6fae", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/normalize_row.c", "max_forks_repo_name": "surbut/mashr", "max_forks_repo_head_hexsha": "b66d2af16503bc46d785ac9c9ba447ecc29b6fae", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.3962264151, "max_line_length": 76, "alphanum_fraction": 0.6280991736, "num_tokens": 433, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8104788995148791, "lm_q2_score": 0.6654105653819835, "lm_q1q2_score": 0.5393012227563635}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nstatic char module_docstring[] = \"GSL Statistics module\";\nstatic char t_test_docstring[] = \"Perform an independent samples t-test\";\n\ndouble t_test(const double *data1, int n1, const double *data2, int n2)\n{\n double mean1, mean2, var1, var2, num, sp, denom, t, dof, p;\n mean1 = gsl_stats_mean(data1, 1, n1);\n mean2 = gsl_stats_mean(data2, 1, n2);\n var1 = gsl_stats_variance(data1, 1, n1);\n var2 = gsl_stats_variance(data2, 1, n2);\n num = mean1 - mean2;\n sp = sqrt((((n1 - 1) * var1) + ((n2 - 1) * var2)) / (n1 + n2 - 2));\n denom = sp * sqrt((1 / (double) n1) + (1 / (double) n2));\n t = fabs(num / denom);\n dof = (double) n1 + n2 - 2;\n p = (1 - gsl_cdf_tdist_P(t, dof)) * 2;\n return p;\n}\n\nstatic double* PySequence_ToDoubleArray(PyObject* inp, int n)\n{\n // Allocate array\n double *out;\n out = malloc(n * sizeof(double));\n for (int i = 0; i < n; i++)\n {\n PyObject *fitem;\n PyObject *item = PySequence_Fast_GET_ITEM(inp, i);\n if(!item) {\n Py_DECREF(inp);\n free(out);\n return NULL;\n }\n fitem = PyNumber_Float(item);\n if(!fitem) {\n Py_DECREF(inp);\n free(out);\n PyErr_SetString(PyExc_TypeError, \"all items must be numbers\");\n return NULL;\n }\n out[i] = PyFloat_AS_DOUBLE(fitem);\n Py_DECREF(fitem);\n }\n return out;\n}\n\nstatic PyObject *t_test_py(PyObject *self, PyObject *args)\n{\n PyObject *inp1, *inp2;\n PyObject* data1;\n PyObject* data2;\n double *d1, *d2;\n int n1, n2;\n double res;\n\n if (!PyArg_ParseTuple(args, \"OO\", &inp1, &inp2))\n return 0;\n data1 = PySequence_Fast(inp1, \"argument must be iterable\");\n data2 = PySequence_Fast(inp2, \"argument must be iterable\");\n n1 = PySequence_Fast_GET_SIZE(data1);\n n2 = PySequence_Fast_GET_SIZE(data2);\n\n d1 = PySequence_ToDoubleArray(data1, n1);\n d2 = PySequence_ToDoubleArray(data2, n2);\n\n Py_DECREF(data1);\n Py_DECREF(data2);\n \n res = t_test(d1, n1, d2, n2);\n free(d1);\n free(d2);\n\n return Py_BuildValue(\"d\", res);\n}\n\nstatic PyMethodDef module_methods[] = {\n {\"t_test_py\", t_test_py, METH_VARARGS, t_test_docstring},\n {NULL, NULL, 0, NULL}\n};\n\nstatic struct PyModuleDef gslstatsmodule = {\n PyModuleDef_HEAD_INIT,\n \"gslstats\",\n module_docstring,\n -1,\n module_methods,\n};\n\nPyMODINIT_FUNC PyInit_gslstats(void)\n{\n Py_Initialize();\n return PyModule_Create(&gslstatsmodule);\n}\n", "meta": {"hexsha": "8fdbf7866560a425da33fe9a76a35c2298b7e260", "size": 2669, "ext": "c", "lang": "C", "max_stars_repo_path": "python-c-api/v1/gslstats.c", "max_stars_repo_name": "kgoettler/python-c-ext", "max_stars_repo_head_hexsha": "96a89cf9ee32a074185ffce842a999975ba0de19", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "python-c-api/v1/gslstats.c", "max_issues_repo_name": "kgoettler/python-c-ext", "max_issues_repo_head_hexsha": "96a89cf9ee32a074185ffce842a999975ba0de19", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "python-c-api/v1/gslstats.c", "max_forks_repo_name": "kgoettler/python-c-ext", "max_forks_repo_head_hexsha": "96a89cf9ee32a074185ffce842a999975ba0de19", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.1666666667, "max_line_length": 74, "alphanum_fraction": 0.611090296, "num_tokens": 813, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7745833737577158, "lm_q2_score": 0.6959583250334526, "lm_q1q2_score": 0.5390777473991807}} {"text": "#include \n#include \n#include \n#include \"MeshAttributes.h\"\n#include \"mathfunctions.h\"\n#include \"oneTimeStep.h\"\n\nextern const double g;\n\nvoid oneTimeStep2D (double time, double dt)\n{\n\n\t// store H, Qx, Qy \n\tgsl_vector *gzeta = gsl_vector_alloc(3*NumEl);\n\tgsl_vector *gQx = gsl_vector_alloc(3*NumEl);\n\tgsl_vector *gQy = gsl_vector_alloc(3*NumEl);\n\n\tint j = 0;\n\tfor (int i=0; i < NumEl; ++i) {\n\t\tfor (int k=0; k < 3; ++k){\n\t\t\tgsl_vector_set(gzeta,j,zeta[index(i,k,3)]);\n\t\t\tgsl_vector_set(gQx,j, Qx[index(i,k,3)]);\n\t\t\tgsl_vector_set(gQy,j, Qy[index(i,k,3)]);\n\t\t\t++j;\n\t\t}\n\t}\n\n\t/************ print out zeta, Qx and Qy for debugging ********************/\n\t#ifdef DEBUG\n\tprintf(\"Initial values:\\n zeta \\n\");\n\tgsl_vector_fprintf(stdout,gzeta,\"%e\");\n\tprintf(\"\\n Qx \\n\");\n\tgsl_vector_fprintf(stdout,gQx,\"%e\");\n\tprintf(\"\\n Qy \\n\");\n\tgsl_vector_fprintf(stdout,gQy,\"%e\");\n\tprintf(\"\\n\");\n\t#endif\n\t/***************************************************************************/\n\n\t// Calculate the wet-dry status of the elements\n//\twetDryStatus2D();\n\n\t// Intermediate RK step\n\tcompute2DL(time);\n\n\tgsl_vector *gRHSZeta = gsl_vector_alloc(3*NumEl);\n\tgsl_vector *gRHSQx = gsl_vector_alloc(3*NumEl);\n\tgsl_vector *gRHSQy = gsl_vector_alloc(3*NumEl);\t\n\n\tj = 0;\n\tfor (int i=0; i < NumEl; ++i) {\n\t\tfor (int k=0; k < 3; ++k){\n\t\t\tgsl_vector_set(gRHSZeta,j,RHSZeta[index(i,k,3)]);\n\t\t\tgsl_vector_set(gRHSQx,j,RHSQx[index(i,k,3)]);\n\t\t\tgsl_vector_set(gRHSQy,j,RHSQy[index(i,k,3)]);\n\t\t\t++j;\n\t\t}\n\t}\n\n\t/************ print out RHSZeta, RHSQx and RHSQy for debugging ********************/\n\t#ifdef DEBUG\n\tprintf(\"After first computeL:\\n RHSZeta \\n\");\n\tgsl_vector_fprintf(stdout,gRHSZeta,\"%e\");\n\tprintf(\"\\n RHSQx \\n\");\n\tgsl_vector_fprintf(stdout,gRHSQx,\"%e\");\n\tprintf(\"\\n RHSQy \\n\");\n\tgsl_vector_fprintf(stdout,gRHSQy,\"%e\");\n\tprintf(\"\\n\");\n\t#endif\n\t/***************************************************************************/\n\n\t// w_1 = w + dt*L; \n\tgsl_vector *gzeta_1 = gsl_vector_alloc(3*NumEl);\n\tgsl_vector *gQx_1 = gsl_vector_alloc(3*NumEl);\n\tgsl_vector *gQy_1 = gsl_vector_alloc(3*NumEl);\n\tfor (int i=0; i<3*NumEl; ++i)\n\t{\n\t\tgsl_vector_set(gzeta_1,i,gsl_vector_get(gzeta,i));\n\t\tgsl_vector_set(gQx_1,i,gsl_vector_get(gQx,i));\n\t\tgsl_vector_set(gQy_1,i,gsl_vector_get(gQy,i));\n\t}\n\n\tgsl_vector_scale(gRHSZeta,dt);\n\tgsl_vector_scale(gRHSQx,dt);\n\tgsl_vector_scale(gRHSQy,dt);\n\tgsl_vector_add(gzeta_1,gRHSZeta);\n\tgsl_vector_add(gQx_1, gRHSQx);\n\tgsl_vector_add(gQy_1, gRHSQy);\n\t\n\t/************ print out zeta, Qx and Qy for debugging ********************/\n\t#ifdef DEBUG\n\tprintf(\"After first computeL:\\n Zeta \\n\");\n\tgsl_vector_fprintf(stdout,gzeta_1,\"%e\");\n\tprintf(\"\\n Qx \\n\");\n\tgsl_vector_fprintf(stdout,gQx_1,\"%e\");\n\tprintf(\"\\n Qy \\n\");\n\tgsl_vector_fprintf(stdout,gQy_1,\"%e\");\n\tprintf(\"\\n\");\n\t#endif\n\t/***************************************************************************/\n\t\n\tj = 0;\n\tfor (int i=0; izeta[index(i,k,3)]);\n\t\t}\n\t\tprintf(\"\\n\");\n\n\t}\n\n\tprintf(\"Qx\\n\");\n\tfor (int i=0; i < NumEl; ++i) \n\t{\n\t\tfor (int k =0; k <3; ++k)\n\t\t{\n\t\t\tprintf(\"%1.15f\\t\",junc->Qx[index(i,k,3)]);\n\t\t}\n\t\tprintf(\"\\n\");\n\n\t}\n\n\tprintf(\"Qy\\n\");\n\tfor (int i=0; i < NumEl; ++i) \n\t{\n\t\tfor (int k =0; k <3; ++k)\n\t\t{\n\t\t\tprintf(\"%1.15f\\t\",junc->Qy[index(i,k,3)]);\n\t\t}\n\t\tprintf(\"\\n\");\n\n\t}\n*/\n\t// Apply minmod slope limiter on w_1\n\tSlopeLimiter();\n\n\t// Apply the positive-depth operator on w_1\n//\tPDop2D();\n\n\tj = 0;\t\t\t\n\tfor (int i=0; i FinalTime)\n\t\t\tdt = FinalTime - time;\n\n\t}\n}\n", "meta": {"hexsha": "0cce59f174c3818e109ea325cb114e75a883a9bb", "size": 10160, "ext": "c", "lang": "C", "max_stars_repo_path": "2DCode/time_evolution.c", "max_stars_repo_name": "evalseth/DG-RAIN", "max_stars_repo_head_hexsha": "f4765de2050adedfbe57ea25437c54de1f05ca9c", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-10-05T12:23:11.000Z", "max_stars_repo_stars_event_max_datetime": "2021-10-05T12:23:11.000Z", "max_issues_repo_path": "2DCode/time_evolution.c", "max_issues_repo_name": "evalseth/DG-RAIN", "max_issues_repo_head_hexsha": "f4765de2050adedfbe57ea25437c54de1f05ca9c", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "2DCode/time_evolution.c", "max_forks_repo_name": "evalseth/DG-RAIN", "max_forks_repo_head_hexsha": "f4765de2050adedfbe57ea25437c54de1f05ca9c", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2019-06-18T02:50:05.000Z", "max_forks_repo_forks_event_max_datetime": "2020-04-03T20:59:00.000Z", "avg_line_length": 25.0864197531, "max_line_length": 85, "alphanum_fraction": 0.5901574803, "num_tokens": 3677, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8558511396138365, "lm_q2_score": 0.6297746074044135, "lm_q1q2_score": 0.5389933154469237}} {"text": "/*\n * Licensed to the OpenAirInterface (OAI) Software Alliance under one or more\n * contributor license agreements. See the NOTICE file distributed with\n * this work for additional information regarding copyright ownership.\n * The OpenAirInterface Software Alliance licenses this file to You under\n * the OAI Public License, Version 1.0 (the \"License\"); you may not use this file\n * except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.openairinterface.org/?page_id=698\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *-------------------------------------------------------------------------------\n * For more information about the OpenAirInterface (OAI) Software Alliance:\n * contact@openairinterface.org\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"PHY/TOOLS/defs.h\"\n#include \"defs.h\"\n\n// NEW code with lookup table for sin/cos based on delay profile (TO BE TESTED)\n\ndouble **cos_lut=NULL,**sin_lut=NULL;\n\n\n//#if 1\n\n\n\nint init_freq_channel(channel_desc_t *desc,uint16_t nb_rb,int16_t n_samples)\n{\n\n\n double delta_f,freq; // 90 kHz spacing\n double delay;\n int16_t f;\n uint8_t l;\n\n if ((n_samples&1)==0) {\n fprintf(stderr, \"freq_channel_init: n_samples has to be odd\\n\");\n return(-1); \n }\n\n cos_lut = (double **)malloc(n_samples*sizeof(double*));\n sin_lut = (double **)malloc(n_samples*sizeof(double*));\n\n delta_f = nb_rb*180000/(n_samples-1);\n\n for (f=-(n_samples>>1); f<=(n_samples>>1); f++) {\n freq=delta_f*(double)f*1e-6;// due to the fact that delays is in mus\n\n cos_lut[f+(n_samples>>1)] = (double *)malloc((int)desc->nb_taps*sizeof(double));\n sin_lut[f+(n_samples>>1)] = (double *)malloc((int)desc->nb_taps*sizeof(double));\n\n\n for (l=0; l<(int)desc->nb_taps; l++) {\n if (desc->nb_taps==1)\n delay = desc->delays[l];\n else\n delay = desc->delays[l]+NB_SAMPLES_CHANNEL_OFFSET/desc->sampling_rate;\n\n cos_lut[f+(n_samples>>1)][l] = cos(2*M_PI*freq*delay);\n sin_lut[f+(n_samples>>1)][l] = sin(2*M_PI*freq*delay);\n //printf(\"values cos:%d, sin:%d\\n\", cos_lut[f][l], sin_lut[f][l]);\n\n }\n }\n\n return(0);\n}\n\nint freq_channel(channel_desc_t *desc,uint16_t nb_rb,int16_t n_samples)\n{\n\n\n int16_t f,f2,d;\n uint8_t aarx,aatx,l;\n double *clut,*slut;\n static int freq_channel_init=0;\n static int n_samples_max=0;\n\n // do some error checking\n // n_samples has to be a odd number because we assume the spectrum is symmetric around the DC and includes the DC\n if ((n_samples&1)==0) {\n fprintf(stderr, \"freq_channel: n_samples has to be odd\\n\");\n return(-1); \n }\n\n // printf(\"no of taps:%d,\",(int)desc->nb_taps);\n\n if (freq_channel_init == 0) {\n // we are initializing the lut for the largets possible n_samples=12*nb_rb+1\n // if called with n_samples<12*nb_rb+1, we decimate the lut\n n_samples_max=12*nb_rb+1;\n if (init_freq_channel(desc,nb_rb,n_samples_max)==0)\n freq_channel_init=1;\n else\n return(-1);\n }\n\n d=(n_samples_max-1)/(n_samples-1);\n\n //printf(\"no_samples=%d, n_samples_max=%d, d=%d\\n\",n_samples,n_samples_max,d);\n\n start_meas(&desc->interp_freq);\n\n for (f=-n_samples_max/2,f2=-n_samples/2; fnb_rx; aarx++) {\n for (aatx=0; aatxnb_tx; aatx++) {\n desc->chF[aarx+(aatx*desc->nb_rx)][n_samples/2+f2].x=0.0;\n desc->chF[aarx+(aatx*desc->nb_rx)][n_samples/2+f2].y=0.0;\n\n for (l=0; l<(int)desc->nb_taps; l++) {\n\n desc->chF[aarx+(aatx*desc->nb_rx)][n_samples/2+f2].x+=(desc->a[l][aarx+(aatx*desc->nb_rx)].x*clut[l]+\n desc->a[l][aarx+(aatx*desc->nb_rx)].y*slut[l]);\n desc->chF[aarx+(aatx*desc->nb_rx)][n_samples/2+f2].y+=(-desc->a[l][aarx+(aatx*desc->nb_rx)].x*slut[l]+\n desc->a[l][aarx+(aatx*desc->nb_rx)].y*clut[l]);\n }\n }\n }\n }\n\n stop_meas(&desc->interp_freq);\n\n return(0);\n}\n\ndouble compute_pbch_sinr(channel_desc_t *desc,\n channel_desc_t *desc_i1,\n channel_desc_t *desc_i2,\n double snr_dB,double snr_i1_dB,\n double snr_i2_dB,\n uint16_t nb_rb)\n{\n\n double avg_sinr,snr=pow(10.0,.1*snr_dB),snr_i1=pow(10.0,.1*snr_i1_dB),snr_i2=pow(10.0,.1*snr_i2_dB);\n uint16_t f;\n uint8_t aarx,aatx;\n double S;\n struct complex S_i1;\n struct complex S_i2;\n\n avg_sinr=0.0;\n\n // printf(\"nb_rb %d\\n\",nb_rb);\n for (f=(nb_rb-6); f<(nb_rb+6); f++) {\n S = 0.0;\n S_i1.x =0.0;\n S_i1.y =0.0;\n S_i2.x =0.0;\n S_i2.y =0.0;\n\n for (aarx=0; aarxnb_rx; aarx++) {\n for (aatx=0; aatxnb_tx; aatx++) {\n S += (desc->chF[aarx+(aatx*desc->nb_rx)][f].x*desc->chF[aarx+(aatx*desc->nb_rx)][f].x +\n desc->chF[aarx+(aatx*desc->nb_rx)][f].y*desc->chF[aarx+(aatx*desc->nb_rx)][f].y);\n // printf(\"%d %d chF[%d] => (%f,%f)\\n\",aarx,aatx,f,desc->chF[aarx+(aatx*desc->nb_rx)][f].x,desc->chF[aarx+(aatx*desc->nb_rx)][f].y);\n\n if (desc_i1) {\n S_i1.x += (desc->chF[aarx+(aatx*desc->nb_rx)][f].x*desc_i1->chF[aarx+(aatx*desc->nb_rx)][f].x +\n desc->chF[aarx+(aatx*desc->nb_rx)][f].y*desc_i1->chF[aarx+(aatx*desc->nb_rx)][f].y);\n S_i1.y += (desc->chF[aarx+(aatx*desc->nb_rx)][f].x*desc_i1->chF[aarx+(aatx*desc->nb_rx)][f].y -\n desc->chF[aarx+(aatx*desc->nb_rx)][f].y*desc_i1->chF[aarx+(aatx*desc->nb_rx)][f].x);\n }\n\n if (desc_i2) {\n S_i2.x += (desc->chF[aarx+(aatx*desc->nb_rx)][f].x*desc_i2->chF[aarx+(aatx*desc->nb_rx)][f].x +\n desc->chF[aarx+(aatx*desc->nb_rx)][f].y*desc_i2->chF[aarx+(aatx*desc->nb_rx)][f].y);\n S_i2.y += (desc->chF[aarx+(aatx*desc->nb_rx)][f].x*desc_i2->chF[aarx+(aatx*desc->nb_rx)][f].y -\n desc->chF[aarx+(aatx*desc->nb_rx)][f].y*desc_i2->chF[aarx+(aatx*desc->nb_rx)][f].x);\n }\n }\n }\n\n // printf(\"snr %f f %d : S %f, S_i1 %f, S_i2 %f\\n\",snr,f-nb_rb,S,snr_i1*sqrt(S_i1.x*S_i1.x + S_i1.y*S_i1.y),snr_i2*sqrt(S_i2.x*S_i2.x + S_i2.y*S_i2.y));\n avg_sinr += (snr*S/(desc->nb_tx+snr_i1*sqrt(S_i1.x*S_i1.x + S_i1.y*S_i1.y)+snr_i2*sqrt(S_i2.x*S_i2.x + S_i2.y*S_i2.y)));\n }\n\n // printf(\"avg_sinr %f (%f,%f,%f)\\n\",avg_sinr/12.0,snr,snr_i1,snr_i2);\n return(10*log10(avg_sinr/12.0));\n}\n\n\ndouble compute_sinr(channel_desc_t *desc,\n channel_desc_t *desc_i1,\n channel_desc_t *desc_i2,\n double snr_dB,double snr_i1_dB,\n double snr_i2_dB,\n uint16_t nb_rb)\n{\n\n double avg_sinr,snr=pow(10.0,.1*snr_dB),snr_i1=pow(10.0,.1*snr_i1_dB),snr_i2=pow(10.0,.1*snr_i2_dB);\n uint16_t f;\n uint8_t aarx,aatx;\n double S;\n struct complex S_i1;\n struct complex S_i2;\n\n DevAssert( nb_rb > 0 );\n\n avg_sinr=0.0;\n\n // printf(\"nb_rb %d\\n\",nb_rb);\n for (f=0; f<2*nb_rb; f++) {\n S = 0.0;\n S_i1.x =0.0;\n S_i1.y =0.0;\n S_i2.x =0.0;\n S_i2.y =0.0;\n\n for (aarx=0; aarxnb_rx; aarx++) {\n for (aatx=0; aatxnb_tx; aatx++) {\n S += (desc->chF[aarx+(aatx*desc->nb_rx)][f].x*desc->chF[aarx+(aatx*desc->nb_rx)][f].x +\n desc->chF[aarx+(aatx*desc->nb_rx)][f].y*desc->chF[aarx+(aatx*desc->nb_rx)][f].y);\n\n if (desc_i1) {\n S_i1.x += (desc->chF[aarx+(aatx*desc->nb_rx)][f].x*desc_i1->chF[aarx+(aatx*desc->nb_rx)][f].x +\n desc->chF[aarx+(aatx*desc->nb_rx)][f].y*desc_i1->chF[aarx+(aatx*desc->nb_rx)][f].y);\n S_i1.y += (desc->chF[aarx+(aatx*desc->nb_rx)][f].x*desc_i1->chF[aarx+(aatx*desc->nb_rx)][f].y -\n desc->chF[aarx+(aatx*desc->nb_rx)][f].y*desc_i1->chF[aarx+(aatx*desc->nb_rx)][f].x);\n }\n\n if (desc_i2) {\n S_i2.x += (desc->chF[aarx+(aatx*desc->nb_rx)][f].x*desc_i2->chF[aarx+(aatx*desc->nb_rx)][f].x +\n desc->chF[aarx+(aatx*desc->nb_rx)][f].y*desc_i2->chF[aarx+(aatx*desc->nb_rx)][f].y);\n S_i2.y += (desc->chF[aarx+(aatx*desc->nb_rx)][f].x*desc_i2->chF[aarx+(aatx*desc->nb_rx)][f].y -\n desc->chF[aarx+(aatx*desc->nb_rx)][f].y*desc_i2->chF[aarx+(aatx*desc->nb_rx)][f].x);\n }\n }\n }\n\n // printf(\"f %d : S %f, S_i1 %f, S_i2 %f\\n\",f-nb_rb,snr*S,snr_i1*sqrt(S_i1.x*S_i1.x + S_i1.y*S_i1.y),snr_i2*sqrt(S_i2.x*S_i2.x + S_i2.y*S_i2.y));\n avg_sinr += (snr*S/(desc->nb_tx+snr_i1*sqrt(S_i1.x*S_i1.x + S_i1.y*S_i1.y)+snr_i2*sqrt(S_i2.x*S_i2.x + S_i2.y*S_i2.y)));\n }\n\n // printf(\"avg_sinr %f (%f,%f,%f)\\n\",avg_sinr/12.0,snr,snr_i1,snr_i2);\n return(10*log10(avg_sinr/(nb_rb*2)));\n}\n\nint pbch_polynomial_degree=6;\ndouble pbch_awgn_polynomial[7]= {-7.2926e-05, -2.8749e-03, -4.5064e-02, -3.5301e-01, -1.4655e+00, -3.6282e+00, -6.6907e+00};\n\nvoid load_pbch_desc(FILE *pbch_file_fd)\n{\n\n int i, ret;\n char dummy[25];\n\n ret = fscanf(pbch_file_fd,\"%d\",&pbch_polynomial_degree);\n\n if (ret < 0) {\n printf(\"fscanf failed: %s\\n\", strerror(errno));\n exit(EXIT_FAILURE);\n }\n\n if (pbch_polynomial_degree>6) {\n printf(\"Illegal degree for pbch interpolation polynomial %d\\n\",pbch_polynomial_degree);\n exit(-1);\n }\n\n printf(\"PBCH polynomial : \");\n\n for (i=0; i<=pbch_polynomial_degree; i++) {\n ret = fscanf(pbch_file_fd,\"%s\",dummy);\n\n if (ret < 0) {\n printf(\"fscanf failed: %s\\n\", strerror(errno));\n exit(EXIT_FAILURE);\n }\n\n pbch_awgn_polynomial[i] = strtod(dummy,NULL);\n printf(\"%f \",pbch_awgn_polynomial[i]);\n }\n\n printf(\"\\n\");\n}\n\ndouble pbch_bler(double sinr)\n{\n\n int i;\n double log10_bler=pbch_awgn_polynomial[pbch_polynomial_degree];\n double sinrpow=sinr;\n double bler=0.0;\n\n // printf(\"log10bler %f\\n\",log10_bler);\n if (sinr<-10.0)\n bler= 1.0;\n else if (sinr>=0.0)\n bler=0.0;\n else {\n for (i=1; i<=pbch_polynomial_degree; i++) {\n // printf(\"sinrpow %f\\n\",sinrpow);\n log10_bler += (pbch_awgn_polynomial[pbch_polynomial_degree-i]*sinrpow);\n sinrpow *= sinr;\n // printf(\"log10bler %f\\n\",log10_bler);\n }\n\n bler = pow(10.0,log10_bler);\n }\n\n //printf (\"sinr %f bler %f\\n\",sinr,bler);\n return(bler);\n\n}\n\n", "meta": {"hexsha": "88b3ce6406bfbf72272d75f155f69edefb1704b4", "size": 10547, "ext": "c", "lang": "C", "max_stars_repo_path": "openair1/SIMULATION/TOOLS/abstraction.c", "max_stars_repo_name": "t0930198/OAI_nb_IoT", "max_stars_repo_head_hexsha": "45212d3b2fd22fdeec8e0062844eaff8de3039a0", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2018-01-08T06:59:34.000Z", "max_stars_repo_stars_event_max_datetime": "2019-04-07T13:56:25.000Z", "max_issues_repo_path": "openair1/SIMULATION/TOOLS/abstraction.c", "max_issues_repo_name": "shahab1992/OAI", "max_issues_repo_head_hexsha": "45212d3b2fd22fdeec8e0062844eaff8de3039a0", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2021-05-28T09:06:21.000Z", "max_issues_repo_issues_event_max_datetime": "2021-05-28T14:49:39.000Z", "max_forks_repo_path": "openair1/SIMULATION/TOOLS/abstraction.c", "max_forks_repo_name": "shahab1992/OAI", "max_forks_repo_head_hexsha": "45212d3b2fd22fdeec8e0062844eaff8de3039a0", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 5.0, "max_forks_repo_forks_event_min_datetime": "2019-02-14T16:06:26.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-05T03:52:29.000Z", "avg_line_length": 32.7546583851, "max_line_length": 159, "alphanum_fraction": 0.5977055087, "num_tokens": 3885, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8459424295406087, "lm_q2_score": 0.6370307806984444, "lm_q1q2_score": 0.5388913663161928}} {"text": "/* interpolation/steffen.c\n * \n * Copyright (C) 2014 Jean-François Caron\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n/* Author: J.-F. Caron\n *\n * This interpolation method is taken from \n * M.Steffen, \"A simple method for monotonic interpolation in one dimension\",\n * Astron. Astrophys. 239, 443-450 (1990).\n *\n * This interpolation method guarantees monotonic interpolation functions between\n * the given data points. A consequence of this is that extremal values can only\n * occur at the data points. The interpolating function and its first derivative\n * are guaranteed to be continuous, but the second derivative is not.\n *\n * The implementation is modelled on the existing Akima interpolation method\n * previously included in GSL by Gerard Jungman.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \"integ_eval.h\"\n#include \n\ntypedef struct\n{\n double * a; /* eqs 2-5 of paper */\n double * b;\n double * c;\n double * d;\n\n double * y_prime; /* eq 11 of paper */\n} steffen_state_t;\n\nstatic void steffen_free (void * vstate);\nstatic double steffen_copysign(const double x, const double y);\n\nstatic void *\nsteffen_alloc (size_t size)\n{\n steffen_state_t *state;\n \n state = (steffen_state_t *) calloc (1, sizeof (steffen_state_t));\n \n if (state == NULL)\n {\n GSL_ERROR_NULL(\"failed to allocate space for state\", GSL_ENOMEM);\n }\n\n state->a = (double *) malloc (size * sizeof (double));\n \n if (state->a == NULL)\n {\n steffen_free(state);\n GSL_ERROR_NULL(\"failed to allocate space for a\", GSL_ENOMEM);\n }\n \n state->b = (double *) malloc (size * sizeof (double));\n \n if (state->b == NULL)\n {\n steffen_free(state);\n GSL_ERROR_NULL(\"failed to allocate space for b\", GSL_ENOMEM);\n }\n \n state->c = (double *) malloc (size * sizeof (double));\n \n if (state->c == NULL)\n {\n steffen_free(state);\n GSL_ERROR_NULL(\"failed to allocate space for c\", GSL_ENOMEM);\n }\n \n state->d = (double *) malloc (size * sizeof (double));\n \n if (state->d == NULL)\n {\n steffen_free(state);\n GSL_ERROR_NULL(\"failed to allocate space for d\", GSL_ENOMEM);\n }\n\n state->y_prime = (double *) malloc (size * sizeof (double));\n if (state->y_prime == NULL)\n {\n steffen_free(state);\n GSL_ERROR_NULL(\"failed to allocate space for y_prime\", GSL_ENOMEM);\n }\n\n return state;\n}\n\nstatic int\nsteffen_init (void * vstate, const double x_array[],\n const double y_array[], size_t size)\n{\n steffen_state_t *state = (steffen_state_t *) vstate;\n size_t i;\n double *a = state->a;\n double *b = state->b;\n double *c = state->c;\n double *d = state->d;\n double *y_prime = state->y_prime;\n\n /*\n * first assign the interval and slopes for the left boundary.\n * We use the \"simplest possibility\" method described in the paper\n * in section 2.2\n */\n double h0 = (x_array[1] - x_array[0]);\n double s0 = (y_array[1] - y_array[0]) / h0;\n\n y_prime[0] = s0;\n\n /* Now we calculate all the necessary s, h, p, and y' variables \n from 1 to N-2 (0 to size - 2 inclusive) */\n for (i = 1; i < (size - 1); i++)\n {\n double pi;\n\n /* equation 6 in the paper */\n double hi = (x_array[i+1] - x_array[i]);\n double him1 = (x_array[i] - x_array[i - 1]);\n\n /* equation 7 in the paper */\n double si = (y_array[i+1] - y_array[i]) / hi;\n double sim1 = (y_array[i] - y_array[i - 1]) / him1;\n\n /* equation 8 in the paper */\n pi = (sim1*hi + si*him1) / (him1 + hi);\n\n /* This is a C equivalent of the FORTRAN statement below eqn 11 */\n y_prime[i] = (steffen_copysign(1.0,sim1) + steffen_copysign(1.0,si)) *\n GSL_MIN(fabs(sim1),\n GSL_MIN(fabs(si), 0.5*fabs(pi))); \n }\n\n /*\n * we also need y' for the rightmost boundary; we use the\n * \"simplest possibility\" method described in the paper in\n * section 2.2\n *\n * y' = s_{n-1}\n */\n y_prime[size-1] = (y_array[size - 1] - y_array[size - 2]) /\n (x_array[size - 1] - x_array[size - 2]);\n\n /* Now we can calculate all the coefficients for the whole range. */\n for (i = 0; i < (size - 1); i++)\n {\n double hi = (x_array[i+1] - x_array[i]);\n double si = (y_array[i+1] - y_array[i]) / hi;\n\n /* These are from equations 2-5 in the paper. */\n a[i] = (y_prime[i] + y_prime[i+1] - 2*si) / hi / hi;\n b[i] = (3*si - 2*y_prime[i] - y_prime[i+1]) / hi;\n c[i] = y_prime[i];\n d[i] = y_array[i];\n }\n\n return GSL_SUCCESS;\n}\n\nstatic void\nsteffen_free (void * vstate)\n{\n steffen_state_t *state = (steffen_state_t *) vstate;\n\n RETURN_IF_NULL(state);\n\n if (state->a)\n free (state->a);\n\n if (state->b)\n free (state->b);\n\n if (state->c)\n free (state->c);\n\n if (state->d)\n free (state->d);\n\n if (state->y_prime)\n free (state->y_prime);\n\n free (state);\n}\n\nstatic int\nsteffen_eval (const void * vstate,\n const double x_array[], const double y_array[], size_t size,\n double x, gsl_interp_accel * a, double *y)\n{\n const steffen_state_t *state = (const steffen_state_t *) vstate;\n\n size_t index;\n \n if (a != 0)\n {\n index = gsl_interp_accel_find (a, x_array, size, x);\n }\n else\n {\n index = gsl_interp_bsearch (x_array, x, 0, size - 1);\n }\n \n /* evaluate */\n {\n const double x_lo = x_array[index];\n const double delx = x - x_lo;\n const double a = state->a[index];\n const double b = state->b[index];\n const double c = state->c[index];\n const double d = state->d[index];\n /* Use Horner's scheme for efficient evaluation of polynomials. */\n /* *y = a*delx*delx*delx + b*delx*delx + c*delx + d; */\n *y = d + delx*(c + delx*(b + delx*a));\n\n return GSL_SUCCESS;\n }\n}\n\nstatic int\nsteffen_eval_deriv (const void * vstate,\n const double x_array[], const double y_array[], size_t size,\n double x, gsl_interp_accel * a, double *dydx)\n{\n const steffen_state_t *state = (const steffen_state_t *) vstate;\n\n size_t index;\n\n /* DISCARD_POINTER(y_array); /\\* prevent warning about unused parameter *\\/ */\n \n if (a != 0)\n {\n index = gsl_interp_accel_find (a, x_array, size, x);\n }\n else\n {\n index = gsl_interp_bsearch (x_array, x, 0, size - 1);\n }\n \n /* evaluate */\n {\n double x_lo = x_array[index];\n double delx = x - x_lo;\n double a = state->a[index];\n double b = state->b[index];\n double c = state->c[index];\n /*double d = state->d[index];*/\n /* *dydx = 3*a*delx*delx*delx + 2*b*delx + c; */\n *dydx = c + delx*(2*b + delx*3*a);\n return GSL_SUCCESS;\n }\n}\n\nstatic int\nsteffen_eval_deriv2 (const void * vstate,\n const double x_array[], const double y_array[], size_t size,\n double x, gsl_interp_accel * a, double *y_pp)\n{\n const steffen_state_t *state = (const steffen_state_t *) vstate;\n\n size_t index;\n\n /* DISCARD_POINTER(y_array); /\\* prevent warning about unused parameter *\\/ */\n\n if (a != 0)\n {\n index = gsl_interp_accel_find (a, x_array, size, x);\n }\n else\n {\n index = gsl_interp_bsearch (x_array, x, 0, size - 1);\n }\n \n /* evaluate */\n {\n const double x_lo = x_array[index];\n const double delx = x - x_lo;\n const double a = state->a[index];\n const double b = state->b[index];\n *y_pp = 6*a*delx + 2*b;\n return GSL_SUCCESS;\n }\n}\n\nstatic int\nsteffen_eval_integ (const void * vstate,\n const double x_array[], const double y_array[], size_t size,\n gsl_interp_accel * acc, double a, double b,\n double * result)\n{\n /* a and b are the boundaries of the integration. */\n \n const steffen_state_t *state = (const steffen_state_t *) vstate;\n\n size_t i, index_a, index_b;\n\n /* Find the data points in the x_array that are nearest to the desired */\n /* a and b integration boundaries. */\n\n if (acc != 0)\n {\n index_a = gsl_interp_accel_find (acc, x_array, size, a);\n index_b = gsl_interp_accel_find (acc, x_array, size, b);\n }\n else\n {\n index_a = gsl_interp_bsearch (x_array, a, 0, size - 1);\n index_b = gsl_interp_bsearch (x_array, b, 0, size - 1);\n }\n \n *result = 0.0;\n\n /* Iterate over all the segments between data points and sum the */\n /* contributions into result. */\n for(i=index_a; i<=index_b; i++) \n {\n const double x_hi = x_array[i + 1];\n const double x_lo = x_array[i];\n const double dx = x_hi - x_lo;\n if(dx != 0.0) \n {\n /*\n * check if we are at a boundary point, so take the\n * a and b parameters instead of the data points.\n */\n double x1 = (i == index_a) ? a-x_lo : 0.0;\n double x2 = (i == index_b) ? b-x_lo : x_hi-x_lo;\n\n *result += (1.0/4.0)*state->a[i]*(x2*x2*x2*x2 - x1*x1*x1*x1)\n +(1.0/3.0)*state->b[i]*(x2*x2*x2 - x1*x1*x1)\n +(1.0/2.0)*state->c[i]*(x2*x2 - x1*x1)\n +state->d[i]*(x2-x1);\n }\n else /* if the interval was zero, i.e. consecutive x values in data. */\n {\n *result = 0.0;\n return GSL_EINVAL;\n }\n }\n \n return GSL_SUCCESS;\n}\n\nstatic double\nsteffen_copysign(const double x, const double y)\n{\n if ((x < 0 && y > 0) || (x > 0 && y < 0))\n return -x;\n\n return x;\n}\n\nstatic const gsl_interp_type steffen_type = \n{\n \"steffen\", \n 3,\n &steffen_alloc,\n &steffen_init,\n &steffen_eval,\n &steffen_eval_deriv,\n &steffen_eval_deriv2,\n &steffen_eval_integ,\n &steffen_free\n};\n\nconst gsl_interp_type * gsl_interp_steffen = &steffen_type;\n", "meta": {"hexsha": "1c9ce1046c0d21cf9778dba690c3824e4da8d8b2", "size": 10382, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.6/interpolation/steffen.c", "max_stars_repo_name": "ielomariala/Hex-Game", "max_stars_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-06-14T11:51:37.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-14T11:51:37.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/interpolation/steffen.c", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-12-16T17:41:24.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-22T00:00:16.000Z", "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/interpolation/steffen.c", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-01-20T16:22:57.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-14T12:31:02.000Z", "avg_line_length": 26.826873385, "max_line_length": 81, "alphanum_fraction": 0.6018108264, "num_tokens": 3053, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7634837635542924, "lm_q2_score": 0.7057850216484838, "lm_q1q2_score": 0.5388554045884321}} {"text": "/* cdf/tdist.c\n *\n * Copyright (C) 2002 Jason H. Stover.\n *\n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n *\n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software Foundation,\n * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n/*\n * Computes the Student's t cumulative distribution function using\n * the method detailed in \n * \n * W.J. Kennedy and J.E. Gentle, \"Statistical Computing.\" 1980. \n * Marcel Dekker. ISBN 0-8247-6898-1.\n *\n * G.W. Hill and A.W. Davis. \"Generalized asymptotic expansions\n * of Cornish-Fisher type.\" Annals of Mathematical Statistics, \n * vol. 39, 1264-1273. 1968.\n *\n * G.W. Hill. \"Algorithm 395: Student's t-distribution,\" Communications\n * of the ACM, volume 13, number 10, page 617. October 1970.\n *\n * G.W. Hill, \"Remark on algorithm 395: Student's t-distribution,\"\n * Transactions on Mathematical Software, volume 7, number 2, page\n * 247. June 1982.\n */\n\n#include \n#include \n#include \n#include \n#include \n\n#include \"beta_inc.c\"\n\nstatic double\npoly_eval (const double c[], unsigned int n, double x)\n{\n unsigned int i;\n double y = c[0] * x;\n\n for (i = 1; i < n; i++)\n {\n y = x * (y + c[i]);\n }\n\n y += c[n];\n\n return y;\n}\n\n/* \n * Use the Cornish-Fisher asymptotic expansion to find a point u such\n * that gsl_cdf_gauss(y) = tcdf(t).\n * \n */\n\nstatic double\ncornish_fisher (double t, double n)\n{\n const double coeffs6[10] = {\n 0.265974025974025974026,\n 5.449696969696969696970,\n 122.20294372294372294372,\n 2354.7298701298701298701,\n 37625.00902597402597403,\n 486996.1392857142857143,\n 4960870.65,\n 37978595.55,\n 201505390.875,\n 622437908.625\n };\n const double coeffs5[8] = {\n 0.2742857142857142857142,\n 4.499047619047619047619,\n 78.45142857142857142857,\n 1118.710714285714285714,\n 12387.6,\n 101024.55,\n 559494.0,\n 1764959.625\n };\n const double coeffs4[6] = {\n 0.3047619047619047619048,\n 3.752380952380952380952,\n 46.67142857142857142857,\n 427.5,\n 2587.5,\n 8518.5\n };\n const double coeffs3[4] = {\n 0.4,\n 3.3,\n 24.0,\n 85.5\n };\n\n double a = n - 0.5;\n double b = 48.0 * a * a;\n\n double z2 = a * log1p (t * t / n);\n double z = sqrt (z2);\n\n double p5 = z * poly_eval (coeffs6, 9, z2);\n double p4 = -z * poly_eval (coeffs5, 7, z2);\n double p3 = z * poly_eval (coeffs4, 5, z2);\n double p2 = -z * poly_eval (coeffs3, 3, z2);\n double p1 = z * (z2 + 3.0);\n double p0 = z;\n\n double y = p5;\n y = (y / b) + p4;\n y = (y / b) + p3;\n y = (y / b) + p2;\n y = (y / b) + p1;\n y = (y / b) + p0;\n\n if (t < 0)\n y *= -1;\n\n return y;\n}\n\n#if 0\n/*\n * Series approximation for t > 4.0. This needs to be fixed;\n * it shouldn't subtract the result from 1.0. A better way is\n * to use two different series expansions. Figuring this out\n * means rummaging through Fisher's paper in Metron, v5, 1926, \n * \"Expansion of Student's integral in powers of n^{-1}.\"\n */\n\n#define MAXI 40\n\nstatic double\nnormal_approx (const double x, const double nu)\n{\n double y;\n double num;\n double diff;\n double q;\n int i;\n double lg1, lg2;\n\n y = 1 / sqrt (1 + x * x / nu);\n num = 1.0;\n q = 0.0;\n diff = 2 * GSL_DBL_EPSILON;\n for (i = 2; (i < MAXI) && (diff > GSL_DBL_EPSILON); i += 2)\n {\n diff = q;\n num *= y * y * (i - 1) / i;\n q += num / (nu + i);\n diff = q - diff;\n }\n q += 1 / nu;\n lg1 = gsl_sf_lngamma (nu / 2.0);\n lg2 = gsl_sf_lngamma ((nu + 1.0) / 2.0);\n\n diff = lg2 - lg1;\n q *= pow (y, nu) * exp (diff) / sqrt (M_PI);\n\n return q;\n}\n#endif\n\ndouble\ngsl_cdf_tdist_P (const double x, const double nu)\n{\n double P;\n\n double x2 = x * x;\n\n if (nu > 30 && x2 < 10 * nu)\n {\n double u = cornish_fisher (x, nu);\n P = gsl_cdf_ugaussian_P (u);\n\n return P;\n }\n\n if (x2 < nu)\n {\n double u = x2 / nu;\n double eps = u / (1 + u);\n\n if (x >= 0)\n {\n P = beta_inc_AXPY (0.5, 0.5, 0.5, nu / 2.0, eps);\n }\n else\n {\n P = beta_inc_AXPY (-0.5, 0.5, 0.5, nu / 2.0, eps);\n }\n }\n else\n {\n double v = nu / (x * x);\n double eps = v / (1 + v);\n\n if (x >= 0)\n {\n P = beta_inc_AXPY (-0.5, 1.0, nu / 2.0, 0.5, eps);\n }\n else\n {\n P = beta_inc_AXPY (0.5, 0.0, nu / 2.0, 0.5, eps);\n }\n }\n\n return P;\n}\n\n\ndouble\ngsl_cdf_tdist_Q (const double x, const double nu)\n{\n double Q;\n\n double x2 = x * x;\n\n if (nu > 30 && x2 < 10 * nu)\n {\n double u = cornish_fisher (x, nu);\n Q = gsl_cdf_ugaussian_Q (u);\n\n return Q;\n }\n\n if (x2 < nu)\n {\n double u = x2 / nu;\n double eps = u / (1 + u);\n\n if (x >= 0)\n {\n Q = beta_inc_AXPY (-0.5, 0.5, 0.5, nu / 2.0, eps);\n }\n else\n {\n Q = beta_inc_AXPY (0.5, 0.5, 0.5, nu / 2.0, eps);\n }\n }\n else\n {\n double v = nu / (x * x);\n double eps = v / (1 + v);\n\n if (x >= 0)\n {\n Q = beta_inc_AXPY (0.5, 0.0, nu / 2.0, 0.5, eps);\n }\n else\n {\n Q = beta_inc_AXPY (-0.5, 1.0, nu / 2.0, 0.5, eps);\n }\n }\n\n return Q;\n}\n", "meta": {"hexsha": "b324482986c8c94ce36a7161f9e9efe9a74d5e61", "size": 5722, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.6/cdf/tdist.c", "max_stars_repo_name": "ielomariala/Hex-Game", "max_stars_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-12-18T18:09:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-10T11:31:28.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/cdf/tdist.c", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-12-16T17:41:24.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-22T00:00:16.000Z", "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/cdf/tdist.c", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-01-20T16:22:57.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-14T12:31:02.000Z", "avg_line_length": 21.0367647059, "max_line_length": 74, "alphanum_fraction": 0.5623907725, "num_tokens": 2074, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7431680086124812, "lm_q2_score": 0.7248702702332476, "lm_q1q2_score": 0.5387003952316337}} {"text": "/* multifit/gsl_multifit.h\r\n * \r\n * Copyright (C) 2000, 2007, 2010 Brian Gough\r\n * Copyright (C) 2013, Patrick Alken\r\n * \r\n * This program is free software; you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation; either version 3 of the License, or (at\r\n * your option) any later version.\r\n * \r\n * This program is distributed in the hope that it will be useful, but\r\n * WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\r\n * General Public License for more details.\r\n * \r\n * You should have received a copy of the GNU General Public License\r\n * along with this program; if not, write to the Free Software\r\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\r\n */\r\n\r\n#ifndef __GSL_MULTIFIT_H__\r\n#define __GSL_MULTIFIT_H__\r\n\r\n#if !defined( GSL_FUN )\r\n# if !defined( GSL_DLL )\r\n# define GSL_FUN extern\r\n# elif defined( BUILD_GSL_DLL )\r\n# define GSL_FUN extern __declspec(dllexport)\r\n# else\r\n# define GSL_FUN extern __declspec(dllimport)\r\n# endif\r\n#endif\r\n\r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n\r\n#undef __BEGIN_DECLS\r\n#undef __END_DECLS\r\n#ifdef __cplusplus\r\n# define __BEGIN_DECLS extern \"C\" {\r\n# define __END_DECLS }\r\n#else\r\n# define __BEGIN_DECLS /* empty */\r\n# define __END_DECLS /* empty */\r\n#endif\r\n\r\n__BEGIN_DECLS\r\n\r\ntypedef struct \r\n{\r\n size_t nmax; /* maximum number of observations */\r\n size_t pmax; /* maximum number of parameters */\r\n size_t n; /* number of observations in current SVD decomposition */\r\n size_t p; /* number of parameters in current SVD decomposition */\r\n gsl_matrix * A; /* least squares matrix for SVD, n-by-p */\r\n gsl_matrix * Q;\r\n gsl_matrix * QSI;\r\n gsl_vector * S;\r\n gsl_vector * t;\r\n gsl_vector * xt;\r\n gsl_vector * D;\r\n double rcond; /* reciprocal condition number */\r\n} \r\ngsl_multifit_linear_workspace;\r\n\r\nGSL_FUN gsl_multifit_linear_workspace *\r\ngsl_multifit_linear_alloc (const size_t n, const size_t p);\r\n\r\nGSL_FUN void\r\ngsl_multifit_linear_free (gsl_multifit_linear_workspace * w);\r\n\r\nGSL_FUN int\r\ngsl_multifit_linear (const gsl_matrix * X,\r\n const gsl_vector * y,\r\n gsl_vector * c,\r\n gsl_matrix * cov,\r\n double * chisq,\r\n gsl_multifit_linear_workspace * work);\r\n\r\nGSL_FUN int\r\ngsl_multifit_linear_tsvd (const gsl_matrix * X,\r\n const gsl_vector * y,\r\n const double tol,\r\n gsl_vector * c,\r\n gsl_matrix * cov,\r\n double * chisq,\r\n size_t * rank,\r\n gsl_multifit_linear_workspace * work);\r\n\r\nGSL_FUN int\r\ngsl_multifit_linear_svd (const gsl_matrix * X,\r\n gsl_multifit_linear_workspace * work);\r\n\r\nGSL_FUN int\r\ngsl_multifit_linear_bsvd (const gsl_matrix * X,\r\n gsl_multifit_linear_workspace * work);\r\n\r\nGSL_FUN size_t\r\ngsl_multifit_linear_rank(const double tol, const gsl_multifit_linear_workspace * work);\r\n\r\nGSL_FUN int\r\ngsl_multifit_linear_solve (const double lambda,\r\n const gsl_matrix * X,\r\n const gsl_vector * y,\r\n gsl_vector * c,\r\n double *rnorm,\r\n double *snorm,\r\n gsl_multifit_linear_workspace * work);\r\n\r\nGSL_FUN int\r\ngsl_multifit_linear_applyW(const gsl_matrix * X,\r\n const gsl_vector * w,\r\n const gsl_vector * y,\r\n gsl_matrix * WX,\r\n gsl_vector * Wy);\r\n\r\nGSL_FUN int\r\ngsl_multifit_linear_stdform1 (const gsl_vector * L,\r\n const gsl_matrix * X,\r\n const gsl_vector * y,\r\n gsl_matrix * Xs,\r\n gsl_vector * ys,\r\n gsl_multifit_linear_workspace * work);\r\n\r\nGSL_FUN int\r\ngsl_multifit_linear_wstdform1 (const gsl_vector * L,\r\n const gsl_matrix * X,\r\n const gsl_vector * w,\r\n const gsl_vector * y,\r\n gsl_matrix * Xs,\r\n gsl_vector * ys,\r\n gsl_multifit_linear_workspace * work);\r\n\r\nGSL_FUN int\r\ngsl_multifit_linear_L_decomp (gsl_matrix * L, gsl_vector * tau);\r\n\r\nGSL_FUN int\r\ngsl_multifit_linear_stdform2 (const gsl_matrix * LQR,\r\n const gsl_vector * Ltau,\r\n const gsl_matrix * X,\r\n const gsl_vector * y,\r\n gsl_matrix * Xs,\r\n gsl_vector * ys,\r\n gsl_matrix * M,\r\n gsl_multifit_linear_workspace * work);\r\n\r\nGSL_FUN int\r\ngsl_multifit_linear_wstdform2 (const gsl_matrix * LQR,\r\n const gsl_vector * Ltau,\r\n const gsl_matrix * X,\r\n const gsl_vector * w,\r\n const gsl_vector * y,\r\n gsl_matrix * Xs,\r\n gsl_vector * ys,\r\n gsl_matrix * M,\r\n gsl_multifit_linear_workspace * work);\r\n\r\nGSL_FUN int\r\ngsl_multifit_linear_genform1 (const gsl_vector * L,\r\n const gsl_vector * cs,\r\n gsl_vector * c,\r\n gsl_multifit_linear_workspace * work);\r\n\r\nGSL_FUN int\r\ngsl_multifit_linear_genform2 (const gsl_matrix * LQR,\r\n const gsl_vector * Ltau,\r\n const gsl_matrix * X,\r\n const gsl_vector * y,\r\n const gsl_vector * cs,\r\n const gsl_matrix * M,\r\n gsl_vector * c,\r\n gsl_multifit_linear_workspace * work);\r\n\r\nGSL_FUN int\r\ngsl_multifit_linear_wgenform2 (const gsl_matrix * LQR,\r\n const gsl_vector * Ltau,\r\n const gsl_matrix * X,\r\n const gsl_vector * w,\r\n const gsl_vector * y,\r\n const gsl_vector * cs,\r\n const gsl_matrix * M,\r\n gsl_vector * c,\r\n gsl_multifit_linear_workspace * work);\r\n\r\nGSL_FUN int\r\ngsl_multifit_linear_lreg (const double smin, const double smax,\r\n gsl_vector * reg_param);\r\n\r\nGSL_FUN int\r\ngsl_multifit_linear_lcurve (const gsl_vector * y,\r\n gsl_vector * reg_param,\r\n gsl_vector * rho, gsl_vector * eta,\r\n gsl_multifit_linear_workspace * work);\r\n\r\nGSL_FUN int\r\ngsl_multifit_linear_lcurvature (const gsl_vector * y,\r\n const gsl_vector * reg_param,\r\n const gsl_vector * rho,\r\n const gsl_vector * eta,\r\n gsl_vector * kappa,\r\n gsl_multifit_linear_workspace * work);\r\n\r\nGSL_FUN int\r\ngsl_multifit_linear_lcorner(const gsl_vector *rho,\r\n const gsl_vector *eta,\r\n size_t *idx);\r\n\r\nGSL_FUN int\r\ngsl_multifit_linear_lcorner2(const gsl_vector *reg_param,\r\n const gsl_vector *eta,\r\n size_t *idx);\r\n\r\nGSL_FUN int\r\ngsl_multifit_linear_Lk(const size_t p, const size_t k, gsl_matrix *L);\r\n\r\nGSL_FUN int\r\ngsl_multifit_linear_Lsobolev(const size_t p, const size_t kmax,\r\n const gsl_vector *alpha, gsl_matrix *L,\r\n gsl_multifit_linear_workspace *work);\r\n\r\nGSL_FUN int\r\ngsl_multifit_wlinear (const gsl_matrix * X,\r\n const gsl_vector * w,\r\n const gsl_vector * y,\r\n gsl_vector * c,\r\n gsl_matrix * cov,\r\n double * chisq,\r\n gsl_multifit_linear_workspace * work);\r\n\r\nGSL_FUN int\r\ngsl_multifit_wlinear_tsvd (const gsl_matrix * X,\r\n const gsl_vector * w,\r\n const gsl_vector * y,\r\n const double tol,\r\n gsl_vector * c,\r\n gsl_matrix * cov,\r\n double * chisq,\r\n size_t * rank,\r\n gsl_multifit_linear_workspace * work);\r\n\r\nGSL_FUN int\r\ngsl_multifit_wlinear_svd (const gsl_matrix * X,\r\n const gsl_vector * w,\r\n const gsl_vector * y,\r\n double tol,\r\n size_t * rank,\r\n gsl_vector * c,\r\n gsl_matrix * cov,\r\n double *chisq, \r\n gsl_multifit_linear_workspace * work);\r\n\r\nGSL_FUN int\r\ngsl_multifit_wlinear_usvd (const gsl_matrix * X,\r\n const gsl_vector * w,\r\n const gsl_vector * y,\r\n double tol,\r\n size_t * rank,\r\n gsl_vector * c,\r\n gsl_matrix * cov,\r\n double *chisq, \r\n gsl_multifit_linear_workspace * work);\r\n\r\nGSL_FUN int\r\ngsl_multifit_linear_est (const gsl_vector * x,\r\n const gsl_vector * c,\r\n const gsl_matrix * cov, double *y, double *y_err);\r\n\r\nGSL_FUN double\r\ngsl_multifit_linear_rcond (const gsl_multifit_linear_workspace * w);\r\n\r\nGSL_FUN int\r\ngsl_multifit_linear_residuals (const gsl_matrix *X, const gsl_vector *y,\r\n const gsl_vector *c, gsl_vector *r);\r\n\r\n/* gcv.c */\r\nGSL_FUN int\r\ngsl_multifit_linear_gcv_init(const gsl_vector * y,\r\n gsl_vector * reg_param,\r\n gsl_vector * UTy,\r\n double * delta0,\r\n gsl_multifit_linear_workspace * work);\r\n\r\nGSL_FUN int\r\ngsl_multifit_linear_gcv_curve(const gsl_vector * reg_param,\r\n const gsl_vector * UTy,\r\n const double delta0,\r\n gsl_vector * G,\r\n gsl_multifit_linear_workspace * work);\r\n\r\nGSL_FUN int\r\ngsl_multifit_linear_gcv_min(const gsl_vector * reg_param,\r\n const gsl_vector * UTy,\r\n const gsl_vector * G,\r\n const double delta0,\r\n double * lambda,\r\n gsl_multifit_linear_workspace * work);\r\n\r\nGSL_FUN double\r\ngsl_multifit_linear_gcv_calc(const double lambda,\r\n const gsl_vector * UTy,\r\n const double delta0,\r\n gsl_multifit_linear_workspace * work);\r\n\r\nGSL_FUN int\r\ngsl_multifit_linear_gcv(const gsl_vector * y,\r\n gsl_vector * reg_param,\r\n gsl_vector * G,\r\n double * lambda,\r\n double * G_lambda,\r\n gsl_multifit_linear_workspace * work);\r\n\r\ntypedef struct\r\n{\r\n const char * name; /* method name */\r\n int (*wfun)(const gsl_vector *r, gsl_vector *w);\r\n int (*psi_deriv)(const gsl_vector *r, gsl_vector *dpsi);\r\n double tuning_default; /* default tuning constant */\r\n} gsl_multifit_robust_type;\r\n\r\ntypedef struct\r\n{\r\n double sigma_ols; /* OLS estimate of sigma */\r\n double sigma_mad; /* MAD estimate of sigma */\r\n double sigma_rob; /* robust estimate of sigma */\r\n double sigma; /* final estimate of sigma */\r\n double Rsq; /* R^2 coefficient of determination */\r\n double adj_Rsq; /* degree of freedom adjusted R^2 */\r\n double rmse; /* root mean squared error */\r\n double sse; /* residual sum of squares */\r\n size_t dof; /* degrees of freedom */\r\n size_t numit; /* number of iterations */\r\n gsl_vector *weights; /* final weights */\r\n gsl_vector *r; /* final residuals y - X c */\r\n} gsl_multifit_robust_stats;\r\n\r\ntypedef struct\r\n{\r\n size_t n; /* number of observations */\r\n size_t p; /* number of parameters */\r\n size_t numit; /* number of iterations */\r\n size_t maxiter; /* maximum iterations */\r\n const gsl_multifit_robust_type *type;\r\n double tune; /* tuning parameter */\r\n\r\n gsl_vector *r; /* residuals at current iteration */\r\n gsl_vector *weights; /* weights at current iteration */\r\n gsl_vector *c_prev; /* coefficients from previous iteration */\r\n gsl_vector *resfac; /* multiplicative factors for residuals */\r\n\r\n gsl_vector *psi; /* psi(r) */\r\n gsl_vector *dpsi; /* psi'(r) */\r\n\r\n gsl_matrix *QSI; /* Q S^{-1} of original matrix X */\r\n gsl_vector *D; /* balancing parameters of original matrix X */\r\n\r\n gsl_vector *workn; /* workspace of length n */\r\n\r\n gsl_multifit_robust_stats stats; /* various statistics */\r\n\r\n gsl_multifit_linear_workspace *multifit_p;\r\n} gsl_multifit_robust_workspace;\r\n\r\n/* available types */\r\nGSL_VAR const gsl_multifit_robust_type * gsl_multifit_robust_default;\r\nGSL_VAR const gsl_multifit_robust_type * gsl_multifit_robust_bisquare;\r\nGSL_VAR const gsl_multifit_robust_type * gsl_multifit_robust_cauchy;\r\nGSL_VAR const gsl_multifit_robust_type * gsl_multifit_robust_fair;\r\nGSL_VAR const gsl_multifit_robust_type * gsl_multifit_robust_huber;\r\nGSL_VAR const gsl_multifit_robust_type * gsl_multifit_robust_ols;\r\nGSL_VAR const gsl_multifit_robust_type * gsl_multifit_robust_welsch;\r\n\r\nGSL_FUN gsl_multifit_robust_workspace *gsl_multifit_robust_alloc(const gsl_multifit_robust_type *T,\r\n const size_t n, const size_t p);\r\nGSL_FUN void gsl_multifit_robust_free(gsl_multifit_robust_workspace *w);\r\nGSL_FUN int gsl_multifit_robust_tune(const double tune,\r\n gsl_multifit_robust_workspace *w);\r\nGSL_FUN int gsl_multifit_robust_maxiter(const size_t maxiter,\r\n gsl_multifit_robust_workspace *w);\r\nGSL_FUN const char *gsl_multifit_robust_name(const gsl_multifit_robust_workspace *w);\r\nGSL_FUN gsl_multifit_robust_stats gsl_multifit_robust_statistics(const gsl_multifit_robust_workspace *w);\r\nGSL_FUN int gsl_multifit_robust_weights(const gsl_vector *r, gsl_vector *wts,\r\n gsl_multifit_robust_workspace *w);\r\nGSL_FUN int gsl_multifit_robust(const gsl_matrix * X, const gsl_vector * y,\r\n gsl_vector * c, gsl_matrix *cov,\r\n gsl_multifit_robust_workspace *w);\r\nGSL_FUN int gsl_multifit_robust_est(const gsl_vector * x, const gsl_vector * c,\r\n const gsl_matrix * cov, double *y, double *y_err);\r\nGSL_FUN int gsl_multifit_robust_residuals(const gsl_matrix * X,\r\n const gsl_vector * y,\r\n const gsl_vector * c, gsl_vector * r,\r\n gsl_multifit_robust_workspace * w);\r\n\r\n__END_DECLS\r\n\r\n#endif /* __GSL_MULTIFIT_H__ */\r\n", "meta": {"hexsha": "691b91202180aabe59ef4b823c6bbcdcaca95463", "size": 15904, "ext": "h", "lang": "C", "max_stars_repo_path": "vendor/gsl/gsl/gsl_multifit.h", "max_stars_repo_name": "mgreter/astrometrylib", "max_stars_repo_head_hexsha": "ef4d4539a537ab49329b77648aac893d2b4ad318", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2021-01-09T05:48:44.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-09T16:18:47.000Z", "max_issues_repo_path": "VimbaCam/ExternLib/GSL_MSVC/gsl/gsl_multifit.h", "max_issues_repo_name": "zzpwahaha/VimbaCamJILA", "max_issues_repo_head_hexsha": "3baed1b5313e6c198d54a33c2c84357035d5146a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2021-01-11T01:08:01.000Z", "max_issues_repo_issues_event_max_datetime": "2021-01-13T16:28:48.000Z", "max_forks_repo_path": "VimbaCam/ExternLib/GSL_MSVC/gsl/gsl_multifit.h", "max_forks_repo_name": "zzpwahaha/VimbaCamJILA", "max_forks_repo_head_hexsha": "3baed1b5313e6c198d54a33c2c84357035d5146a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-01-20T16:22:57.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-14T12:31:02.000Z", "avg_line_length": 39.8596491228, "max_line_length": 106, "alphanum_fraction": 0.5443284708, "num_tokens": 3344, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8006920020959544, "lm_q2_score": 0.6723316991792861, "lm_q1q2_score": 0.5383306142884375}} {"text": "//\n// geru.h\n// Linear Algebra Template Library\n//\n// Created by Rodney James on 12/23/11.\n// Copyright (c) 2011 University of Colorado Denver. All rights reserved.\n//\n\n#ifndef _geru_h\n#define _geru_h\n\n/// @file geru.h Performs complex vector outer product.\n\n\n#include \"latl.h\"\n\nnamespace LATL\n{\n /// @brief Performs a vector outer product of two complex vectors.\n /// \n /// For a complex matrix A, complex vectors x and y, and complex scalar alpha,\n ///\n /// A := alpha * x * y.' + A\n ///\n /// is computed. \n /// @return 0 if success.\n /// @return -i if the ith argument is invalid.\n /// @tparam real_t Floating point type.\n /// @param m Specifies the number of rows of the matrix A. m>=0\n /// @param n Specifies the number of coumns of the matrix A. n>=0\n /// @param alpha Complex scalar.\n /// @param x Pointer to complex vector x.\n /// @param incx Increment of the vector x. x!=0\n /// @param y Pointer to complex vector y.\n /// @param incy Increment of the vector y. y!=0\n /// @param A Pointer to complex m-by-n matrix A.\n /// @param ldA Column length of matrix A. ldA>=m.\n /// @ingroup BLAS\n\n template \n int GERU(int_t m, int_t n, complex alpha, complex *x, int_t incx, complex *y, int_t incy, complex *A, int_t ldA)\n {\n using std::conj;\n\n const complex zero(0.0,0.0);\n int_t i,j,kx,jy,ix;\n \n if(m<0)\n return -1;\n else if(n<0)\n return -2;\n else if(incx==0)\n return -5;\n else if(incy==0)\n return -7;\n else if(ldA0)?0:(1-n)*incy;\n kx=(incx>0)?0:(1-m)*incx;\n \n if(incx==1)\n {\n for(j=0;j\n\n template <> int GERU(int_t m, int_t n, complex alpha, complex *x, int_t incx, complex *y, int_t incy, complex *A, int_t ldA)\n {\n if(m<0)\n return -1;\n else if(n<0)\n return -2;\n else if(incx==0)\n return -5;\n else if(incy==0)\n return -7;\n else if(ldA int GERU(int_t m, int_t n, complex alpha, complex *x, int_t incx, complex *y, int_t incy, complex *A, int_t ldA)\n {\n if(m<0)\n return -1;\n else if(n<0)\n return -2;\n else if(incx==0)\n return -5;\n else if(incy==0)\n return -7;\n else if(ldA\n#include \n#include \n#include \n#include \n#include \n\n#include \"gsl_linalg.h\"\n\n\n/* store one of the suggested choices for the\n * Taylor series / square method from Moler + VanLoan\n */\nstruct moler_vanloan_optimal_suggestion\n{\n int k;\n int j;\n};\ntypedef struct moler_vanloan_optimal_suggestion mvl_suggestion_t;\n\n\n/* table from Moler and Van Loan\n * mvl_tab[gsl_mode_t][matrix_norm_group]\n */\nstatic mvl_suggestion_t mvl_tab[3][6] =\n{\n /* double precision */\n {\n { 5, 1 }, { 5, 4 }, { 7, 5 }, { 9, 7 }, { 10, 10 }, { 8, 14 }\n },\n\n /* single precision */\n {\n { 2, 1 }, { 4, 0 }, { 7, 1 }, { 6, 5 }, { 5, 9 }, { 7, 11 }\n },\n\n /* approx precision */\n {\n { 1, 0 }, { 3, 0 }, { 5, 1 }, { 4, 5 }, { 4, 8 }, { 2, 11 }\n }\n};\n\n\ninline\nstatic double\nsup_norm(const gsl_matrix * A)\n{\n double min, max;\n gsl_matrix_minmax(A, &min, &max);\n return GSL_MAX_DBL(fabs(min), fabs(max));\n}\n\n\nstatic\nmvl_suggestion_t\nobtain_suggestion(const gsl_matrix * A, gsl_mode_t mode)\n{\n const unsigned int mode_prec = GSL_MODE_PREC(mode);\n const double norm_A = sup_norm(A);\n if(norm_A < 0.01) return mvl_tab[mode_prec][0];\n else if(norm_A < 0.1) return mvl_tab[mode_prec][1];\n else if(norm_A < 1.0) return mvl_tab[mode_prec][2];\n else if(norm_A < 10.0) return mvl_tab[mode_prec][3];\n else if(norm_A < 100.0) return mvl_tab[mode_prec][4];\n else if(norm_A < 1000.0) return mvl_tab[mode_prec][5];\n else\n {\n /* outside the table we simply increase the number\n * of squarings, bringing the reduced matrix into\n * the range of the table; this is obviously suboptimal,\n * but that is the price paid for not having those extra\n * table entries\n */\n const double extra = log(1.01*norm_A/1000.0) / M_LN2;\n const int extra_i = (unsigned int) ceil(extra);\n mvl_suggestion_t s = mvl_tab[mode][5];\n s.j += extra_i;\n return s;\n }\n}\n\n\n/* use series representation to calculate matrix exponential;\n * this is used for small matrices; we use the sup_norm\n * to measure the size of the terms in the expansion\n */\nstatic void\nmatrix_exp_series(\n const gsl_matrix * B,\n gsl_matrix * eB,\n int number_of_terms\n )\n{\n int count;\n gsl_matrix * temp = gsl_matrix_calloc(B->size1, B->size2);\n\n /* init the Horner polynomial evaluation,\n * eB = 1 + B/number_of_terms; we use\n * eB to collect the partial results\n */ \n gsl_matrix_memcpy(eB, B);\n gsl_matrix_scale(eB, 1.0/number_of_terms);\n gsl_matrix_add_diagonal(eB, 1.0);\n for(count = number_of_terms-1; count >= 1; --count)\n {\n /* mult_temp = 1 + B eB / count */\n gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, 1.0, B, eB, 0.0, temp);\n gsl_matrix_scale(temp, 1.0/count);\n gsl_matrix_add_diagonal(temp, 1.0);\n\n /* transfer partial result out of temp */\n gsl_matrix_memcpy(eB, temp);\n }\n\n /* now eB holds the full result; we're done */\n gsl_matrix_free(temp);\n}\n\n\nint\ngsl_linalg_exponential_ss(\n const gsl_matrix * A,\n gsl_matrix * eA,\n gsl_mode_t mode\n )\n{\n if(A->size1 != A->size2)\n {\n GSL_ERROR(\"cannot exponentiate a non-square matrix\", GSL_ENOTSQR);\n }\n else if(A->size1 != eA->size1 || A->size2 != eA->size2)\n {\n GSL_ERROR(\"exponential of matrix must have same dimension as matrix\", GSL_EBADLEN);\n }\n else\n {\n int i;\n const mvl_suggestion_t sugg = obtain_suggestion(A, mode);\n const double divisor = exp(M_LN2 * sugg.j);\n\n gsl_matrix * reduced_A = gsl_matrix_alloc(A->size1, A->size2);\n\n /* decrease A by the calculated divisor */\n gsl_matrix_memcpy(reduced_A, A);\n gsl_matrix_scale(reduced_A, 1.0/divisor);\n\n /* calculate exp of reduced matrix; store in eA as temp */\n matrix_exp_series(reduced_A, eA, sugg.k);\n\n /* square repeatedly; use reduced_A for scratch */\n for(i = 0; i < sugg.j; ++i)\n {\n gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, 1.0, eA, eA, 0.0, reduced_A);\n gsl_matrix_memcpy(eA, reduced_A);\n }\n\n gsl_matrix_free(reduced_A);\n\n return GSL_SUCCESS;\n }\n}\n\n", "meta": {"hexsha": "3d0df25c6521684ce0fb306d90d7c523b03a5655", "size": 5018, "ext": "c", "lang": "C", "max_stars_repo_path": "pkgs/libs/gsl/src/linalg/exponential.c", "max_stars_repo_name": "manggoguy/parsec-modified", "max_stars_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 64.0, "max_stars_repo_stars_event_min_datetime": "2015-03-06T00:30:56.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-24T13:26:53.000Z", "max_issues_repo_path": "pkgs/libs/gsl/src/linalg/exponential.c", "max_issues_repo_name": "manggoguy/parsec-modified", "max_issues_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 12.0, "max_issues_repo_issues_event_min_datetime": "2020-12-15T08:30:19.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-13T03:54:24.000Z", "max_forks_repo_path": "pkgs/libs/gsl/src/linalg/exponential.c", "max_forks_repo_name": "manggoguy/parsec-modified", "max_forks_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 40.0, "max_forks_repo_forks_event_min_datetime": "2015-02-26T15:31:16.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-03T23:23:37.000Z", "avg_line_length": 26.6914893617, "max_line_length": 87, "alphanum_fraction": 0.6673973695, "num_tokens": 1565, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8031737963569014, "lm_q2_score": 0.6688802537704063, "lm_q1q2_score": 0.5372270927289449}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n// Compute comoving mass function\ndouble mass_function(double M_interp, double z, cosmo_info **cosmo, int mode, ...) {\n va_list vargs;\n va_start(vargs, mode);\n\n // Get passed parameters (if mode specifies they are there).\n double *P = NULL;\n if(SID_CHECK_BITFIELD_SWITCH(mode, MF_PASS_PARAMS))\n P = (double *)va_arg(vargs, double *);\n\n // Initialize/compute some misc. cosmology things\n double sigma_interp = sqrt(power_spectrum_variance(k_of_M(M_interp, *cosmo), z, cosmo, PSPEC_LINEAR_TF, PSPEC_ALL_MATTER));\n double Omega_M = ((double *)ADaPS_fetch(*cosmo, \"Omega_M\"))[0];\n double rho_o = Omega_M * rho_crit_z(0, *cosmo);\n\n // Compute mass function (eqn 41 of Lukic et al, 2007, for example)\n double dlnInvs_dlogM = dln_Inv_sigma_dlogM(cosmo, M_interp, PSPEC_LINEAR_TF, PSPEC_ALL_MATTER);\n double rval = rho_o * scaled_mass_function(sigma_interp, mode, P) * dlnInvs_dlogM / M_interp;\n va_end(vargs);\n return (rval);\n}\n", "meta": {"hexsha": "4d7adc95adc2464b3a7493b39167b7049251a2b1", "size": 1235, "ext": "c", "lang": "C", "max_stars_repo_path": "src/gbpAstro/gbpCosmo/mass_functions/mass_function.c", "max_stars_repo_name": "gbpoole/gbpCode", "max_stars_repo_head_hexsha": "5157d2e377edbd4806258d1c16b329373186d43a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2015-10-20T11:39:53.000Z", "max_stars_repo_stars_event_max_datetime": "2015-10-20T11:39:53.000Z", "max_issues_repo_path": "src/gbpAstro/gbpCosmo/mass_functions/mass_function.c", "max_issues_repo_name": "gbpoole/gbpCode", "max_issues_repo_head_hexsha": "5157d2e377edbd4806258d1c16b329373186d43a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2017-07-30T11:10:49.000Z", "max_issues_repo_issues_event_max_datetime": "2019-06-18T00:40:46.000Z", "max_forks_repo_path": "src/gbpAstro/gbpCosmo/mass_functions/mass_function.c", "max_forks_repo_name": "gbpoole/gbpCode", "max_forks_repo_head_hexsha": "5157d2e377edbd4806258d1c16b329373186d43a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4.0, "max_forks_repo_forks_event_min_datetime": "2015-01-23T00:50:40.000Z", "max_forks_repo_forks_event_max_datetime": "2016-08-01T08:14:24.000Z", "avg_line_length": 37.4242424242, "max_line_length": 127, "alphanum_fraction": 0.7020242915, "num_tokens": 355, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9005297887874625, "lm_q2_score": 0.5964331462646254, "lm_q1q2_score": 0.5371058152315248}} {"text": "/*\nVEGAS_TABLE Version 1. 5/27/16\nreport issues to Tim Waters,\nwaters@lanl.gov\n\n**** Basic code description: \nInput: \tAn ascii table with entries\n\t\ton a uniform grid of (x,y) values\n\t\tand a (x,y) value for which an\n interpolated value is sought\nOutput: The interpolated value \n corresponding to that (x,y) pair\n\n**** Detailed description: \n\n>> Step 1. Instantiation:\nThe class constructor calls a method\nto parse an ascii text file which contains \nan (N+1)x(M+1) table:\nThe first row contains the M values of x.\nThe first column contains the N values of y.\nThe remainder of the table contains the NxM \nvalues of z. \n\nHere is a simple example of an input file:\n\n4\t1e0 1e1 1e2 1e3\n1e4\t1e-20\t2e-20\t3e-20\t4e-20\n1e5\t5e-20\t6e-20\t7e-20\t8e-20\n1e6\t1e-19\t2e-19\t3e-19\t4e-19\n1e7\t5e-19\t6e-19\t7e-19\t8e-19\n1e8\t1e-18\t2e-18\t3e-18\t4e-18\n\nIn this example, N = 5 and M = 4. \nM must be specified as the first element.\nThe remaining elements in row 1 are values\nof the photoionization parameter, xi.\nThe left column below M are the temperature \nvalues. The remaining elements are net heating \nrates that are functions of T and xi. \n\nBy default, the input file is limited to size \n1000 x 1000. To increase this size limit, \nincrease Nmax in the default constructor.\n\n>> Step 2. Table initialization:\nThe file parsed above is read into a \ntable, but this is not the actual table \nused. The actual table is made upon calling\nan initialization function, and optionally\narray arguments can be passed specifying the \nmin/max of both T and xi. This may be useful\nwhen combining multiple overlapping tables\nand will allow for flexibility if tables \ngenerated from non-uniform grids are needed,\nalthough a table-search algorithm has not \nbeen implemented. The input table is then \nreduced to a size that contains only the \nvalues between these limits. \n\n>> Step 3. Invocation:\nThe code returns the interpolated value\nof whatever rate was in the input file. \nThe code uses the bicubic and bilinear\ninterpolation algorithms from the GSL\nlibrary. By default, bicubic is used.\n\nImportantly, the code assumes that a \nnearly uniform grid was produced via \nx = j*(xmax-xmin)/(M-1) + xmin \ny = i*(ymax-ymin)/(N-1) + ymin\nThis allows avoiding an expensive\ntable search for the lookup operation.\nFor a uniform grid generated from the\nabove formulas, the table indices \nfor a desired value of (x,y) are\ni_x = (M-1)*(x - xmin)/(xmax - xmin)\ni_y = (N-1)*(y - ymin)/(ymax - ymin)\nSince xstar may slightly modify the\ngrid locations (x,y) originally \nspecified, our lookup operation\nconsists of first guessing that the\nlookup value indices are (i_x,i_y)\nand then allowing for some wiggle \nroom by searching 1 index left, right, \nabove, and below upon finding that our \nguess was incorrect. The code will \nterminate if this search fails. \n\n**** Example usages: \n1. Bicubic interpolation on a table that was\ngenerated from a log-log spaced grid\nVEGAS_LUT hc_xstar(\"input_table.tab\",\"bicubic\");\t\t\t\nhc_xstar.initialize_table();\nhc_rate = hc_xstar.get_rate(T,xi);\n\n1a. If lin-lin spacing was used instead, use\nVEGAS_LUT hc_xstar(\"input_table.tab\",\"bicubic\",false,false);\n\n1c. To apply a bounding box, use instead\nconst double T_bbox[2] = {1e5,1e7};\nconst double xi_bbox[2] = {1e1,5e2};\nhc_xstar.initialize_table(T_bbox,xi_bbox);\n*/\n\n#ifndef H_VEGAS_TABLE\n#define H_VEGAS_TABLE\n\n#include \t\t// std::cout, std::endl\n#include // std::setprecision\n#include \t\t// std::ifstream\n#include \n#include \n#include \n#include \n\n#include \n#include \n\n\nclass VEGAS_LUT\n{\npublic:\n //default constructor will parse the input file\n //log-log spacing for (T,xi) is assumed by default\n\tVEGAS_LUT(\tconst std::string a=\"VEGAS_table.tab\", \n\t\t\t\tconst std::string b=\"bicubic\", \n\t\t\t\tbool c=true, bool d=true): \n\tfilename(a),gsl_routine(b),logT(c),logxi(d) \n\t{\n\t // allocate a (Nmax x Nmax) table for reading in the file\n\t int Nmax = 1000;\n\t input_table = new double*[Nmax];\n\t for (int i = 0; i < Nmax; i++)\n \tinput_table[i] = new double[Nmax];\n xivals = new double[Nmax];\n Tvals = new double[Nmax];\n \n gsl_init();\n parse_file();\n\t}\n\t~VEGAS_LUT() { free_memory(); } \n\t\n\t//user must call the initialize_table method\n\tvoid initialize_table(const double*, const double*); \n\t\n\t//user function that returns an interpolated value\n\tdouble get_rate(double, double);\n\t\n\t// actual table (T,xi) bounds: \n\t// hydro code needs to know Temp bounds when doing implicit root finding\n\tdouble y_min,y_max,x_min,x_max; \t\n\nprivate:\n\tbool logT,logxi;\t\t\t\t\t// determines log gridding\n\tdouble* xlim;\t\t\t\t\t\t// input table xi bounds\n\tdouble* ylim;\t\t\t\t\t\t// input table T bounds\n\tconst double* T_bounds;\t\t\t\t// user specified T bounds\n\tconst double* xi_bounds;\t\t\t// user specified xi bounds\n\tdouble** \tinput_table; \t\t\t// pointer to input table\n\tdouble** \ttable;\t\t\t\t\t// pointer to actual table\n\tdouble* \txivals; \t\t\t\t// xi-vals from input table \n\tdouble*\t\tTvals; \t\t\t\t\t// T-vals from input table \n\tdouble* \txvals; \t\t\t\t\t// xi-vals for actual table\n\tdouble*\t\tyvals; \t\t\t\t\t// T-vals for actual table\n\tunsigned int \tNT,\t // # rows of input table (# of Ts)\n\t\t\t\t\tNxi, // # cols of input table (# of xis)\n\t\t\t\t\tN,\t // # rows of actual table (# of Ts)\n\t\t\t\t\tM,\t // # cols of actual table (# of xis)\n\t\t\t\t\ti_T, // T-offset between the input and actual tables\n\t\t\t\t\ti_xi; // xi-offset between the input and actual tables\n\ttypedef std::vector array_t;\t//dynamic array data type\n\tstd::string filename, gsl_routine;\t\t//input strings\n\t\n\t//member functions for handling the input file\n\tvoid parse_file();\n\tbool read_value(std::ifstream&, const int, array_t&);\n\tvoid free_input_table(); \n\tvoid free_memory(); \n\t\n\t//other member functions\n\tvoid reduce_input_table();\n\tvoid make_table(unsigned int, unsigned int);\n\tvoid determine_box_indices(double, double, unsigned int&, unsigned int&);\n\t\n\t//GSL variables and member functions\n\tbool use_gsl_bicubic;\n\tconst gsl_interp2d_type *gsl_scheme;\n\ttypedef gsl_spline2d* spline_t;\n\tspline_t **spline_table;\n gsl_interp_accel *xacc, *yacc;\n size_t nx,ny;\n void gsl_init();\n void make_spline_table();\n};\n\n\nvoid VEGAS_LUT::gsl_init()\n{\n if (gsl_routine == \"bilinear\")\n {\n gsl_scheme = gsl_interp2d_bilinear;\n use_gsl_bicubic = false;\n nx = 2;\n ny = 2;\n }\n else if (gsl_routine == \"bicubic\")\n {\n gsl_scheme = gsl_interp2d_bicubic;\n use_gsl_bicubic = true;\n nx = 4;\n ny = 4;\n }\n else\n {\n std::cout << \"ERROR: GSL interpolation scheme \" << gsl_routine \n << \" not recognized. Choose from:\\n\"\n << \"bilinear\\n\"\n << \"bicubic\\n\"\n << std::endl;\n exit(0);\n }\n}\n\nbool VEGAS_LUT::read_value(std::ifstream& fin, const int j, array_t& input_data)\n{\n double value;\n if (fin >> value) \n { \n input_data[j]=value; \n return true; \n }\n else return false;\n}\n\nvoid VEGAS_LUT::parse_file()\n{\n std::ifstream fin(filename.c_str());\n if (!fin)\n {\n std::cout << \"File \" << filename << \" does not exist!\" << std::endl;\n\texit(0);\n }\t\n bool file_is_open = false;\n bool end_of_line = false;\n \n // read in first value: Nxi\n array_t val1(1);\n file_is_open = read_value(fin,0,val1);\n Nxi = (unsigned int) val1[0];\n \n // read in remainder of first row: all xi-values\n array_t this_row(Nxi+1);\n int i=1,j;\n while(!end_of_line)\n {\n file_is_open = read_value(fin,i,this_row);\n xivals[i-1] = this_row[i];\n if( i!=0 && i%Nxi == 0 )\n end_of_line = true;\n else i++; //next row element\n }\n \n // read in 1st element of 2nd row: the 1st T value\n file_is_open = read_value(fin,0,this_row);\n Tvals[0] = this_row[0];\n \n // read in the rest of the file\n end_of_line = false;\n i = 1; j=0;\n while(file_is_open)\n {\n file_is_open = read_value(fin,i,this_row);\n\n if( i!=0 && i%Nxi == 0 )\n {\n end_of_line = true;\n i=0; // j++; //reset column, increment row\n }\n else i++; //next row element\n\n if(end_of_line)\n {\n // 1st element of this_row is T\n Tvals[j] = this_row[0];\n\n // remaining elements are rates\n for (int ii=0; ii Tvals[NT-1])\n {\n std::cout << \"ERROR: Tmin or Tmax is not contained within file \" \n << filename << \"!\"\n << std::endl;\n exit(0);\n }\n \n if (ximin < xivals[0] || ximax > xivals[Nxi-1])\n {\n std::cout << \"ERROR: x_min or x_max is not contained within file \" \n << filename << \"!\"\n << std::endl;\n exit(0);\n }\n \n // find the indices of the table corresponding to input min/max values\n int i = 0;\n while (Tvals[i] < Tmax && i < NT) \n i++;\n y_max = Tvals[i]; //so y_max is slightly greater than Tmax\n \n int ii = 0;\n while (Tvals[ii] <= Tmin && ii < i) \n ii++;\n y_min = Tvals[ii-1]; //so y_min is slightly less than Tmin\n \n // assign private variables\n i_T = ii-1; // start position in input table\n N = i - ii + 2; // # of T-vals in desired table\n \n i = 0;\n while (xivals[i] < ximax && i < Nxi) \n i++;\n x_max = xivals[i]; //so x_max is slightly greater than ximax\n \n ii = 0;\n while (xivals[ii] <= ximin && ii < i) \n ii++;\n x_min = xivals[ii-1]; //so x_min is slightly less than ximin\n \n // assign private variables\n i_xi = ii-1; // start position in input table\n M = i - ii + 2; // # of xi-vals in desired table\n}\n\nvoid VEGAS_LUT::initialize_table(const double * T_bbox = NULL, const double * xi_bbox = NULL)\n{\t\n\tint i0,j0; \n\t\n\tif (T_bbox != NULL || xi_bbox != NULL)\n\t{\n\t T_bounds = T_bbox;\n\t xi_bounds = xi_bbox;\n\t reduce_input_table(); // this sets i_xi, i_T, N, M, y_min, Tmax, x_min, x_max\n\t i0 = i_xi; \n\t j0 = i_T;\n\t}\n\telse // the actual table will be the same size as the input table\n\t{\n\t y_min = Tvals[0];\n\t y_max = Tvals[NT-1];\n\t x_min = xivals[0];\n\t x_max = xivals[Nxi-1];\n\t N = NT;\n\t M = Nxi;\n\t i0 = 0;\n\t j0 = 0;\n\t}\n\t\n\t// store the values of xi and T that will be used\n // they way they will be used (i.e. log or lin)\n xvals = new double[M];\n yvals = new double[N];\n double x,y;\n for (int i=0; i xvals[i] && x < xvals[i+1]) //then we guessed right\n {\n i_x = i;\n correct_guess = true;\n }\n \n if (!correct_guess)\n {\n if (i==0 || i==(M-1))\n {\n if (i==0 && x < xvals[2])\n i_x = 1;\n else if (i==(M-1) && x > xvals[M-2])\n i_x = M-2;\n }\n else if (x < xvals[i]) //then move to the left 1\n i_x = i-1;\n else if (x > xvals[i+1]) //then move to the right 1\n i_x = i+1;\n else // we give up\n {\n std::cout << \"ERROR: search for the table xi-index failed!\" \n \t\t\t<< \"\\nDouble check inputs or try debugging \"\n \t\t\t<< \"function determine_box_indices()\"\n \t\t\t<< std::endl;\n exit(0);\n }\n }\n \n /* now we check our guess in y and if needed, adjust one box up/down */\n correct_guess = false; // reset \n \n if (y > yvals[j] && y < yvals[j+1]) //then we guessed right\n {\n i_y = j;\n correct_guess = true;\n }\n \n if (!correct_guess)\n {\n if (j==0 || j==(N-1))\n {\n if (j==0 && y < yvals[2])\n i_y = 1;\n else if (j==(N-1) && y > yvals[N-2])\n i_y = N-2;\n }\n else if (y < yvals[j]) //then move down 1\n i_y = j-1;\n else if (y > yvals[j+1]) //then move up 1\n i_y = j+1;\n else // we give up\n {\n std::cout << \"ERROR: search for the table T-index failed!\" \n \t\t\t<< \"\\nDouble check inputs or try debugging \"\n \t\t\t<< \"function determine_box_indices()\"\n \t\t\t<< std::endl;\n exit(0);\n }\n }\n \n}\n\ndouble VEGAS_LUT::get_rate(double y_val, double x_val)\n{ \n\tunsigned int i_x,i_y;\n\tdouble x,y;\n\n\t/* terminate program if values exceed bounding box \n if (y_val < y_min || y_val > y_max || x_val < x_min || x_val > x_max)\n {\n std::cout \n << \"\\nFATAL ERROR: (y_val,x_val) = (\" << y_val << \", \" << x_val << \") \" \n << \"lies outside of table's bounding box!\\n\" \n << \">> Bounding Box:\\n\" \n << \"(y_min,y_max) = (\" << y_min << \", \" << y_max << \")\\n\" \n << \"(x_min,x_max) = (\" << x_min << \", \" << x_max << \")\\n\"\n << std::endl;\n\t exit(0);\n } \n */\n \n /* use boundary rates for values outside bounding box */\n double eps = 1e-10;\n if (y_val < y_min) y_val = y_min*(1. + eps);\n if (y_val > y_max) y_val = y_max*(1. - eps);\n if (x_val < x_min) x_val = x_min*(1. + eps);\n if (x_val > x_max) x_val = x_max*(1. - eps);\n\t\n\t// apply any log scaling \n\tif (logT) y = log10(y_val);\n\telse y = y_val;\n if (logxi) x = log10(x_val);\n else x = x_val;\n \n\t determine_box_indices(x,y,i_x,i_y);\n \n\treturn gsl_spline2d_eval(spline_table[i_y][i_x], x, y, xacc, yacc); \n}\n\n#endif //H_VEGAS_TABLE\n", "meta": {"hexsha": "20f20398ada1208dafa8b12d98014be85c92b013", "size": 19660, "ext": "h", "lang": "C", "max_stars_repo_path": "vegas_tables.h", "max_stars_repo_name": "twaters/VegasTables", "max_stars_repo_head_hexsha": "115a9e71f8727d9ad45a21087af4959bb23082ce", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "vegas_tables.h", "max_issues_repo_name": "twaters/VegasTables", "max_issues_repo_head_hexsha": "115a9e71f8727d9ad45a21087af4959bb23082ce", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "vegas_tables.h", "max_forks_repo_name": "twaters/VegasTables", "max_forks_repo_head_hexsha": "115a9e71f8727d9ad45a21087af4959bb23082ce", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.8470254958, "max_line_length": 95, "alphanum_fraction": 0.601525941, "num_tokens": 6154, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7826624789529375, "lm_q2_score": 0.6859494550081926, "lm_q1q2_score": 0.5368669008931285}} {"text": "/*\n Copyright (C) 2002 M. Marques, A. Castro, A. Rubio, G. Bertsch, M. Oliveira\n\n This program is free software; you can redistribute it and/or modify\n it under the terms of the GNU General Public License as published by\n the Free Software Foundation; either version 2, or (at your option)\n any later version.\n\n This program is distributed in the hope that it will be useful,\n but WITHOUT ANY WARRANTY; without even the implied warranty of\n MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n GNU General Public License for more details.\n\n You should have received a copy of the GNU General Public License\n along with this program; if not, write to the Free Software\n Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA\n 02110-1301, USA.\n\n $Id: minimizer_low.c 11822 2014-02-25 21:18:45Z dstrubbe $\n*/\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"string_f.h\"\n\n\n\n/* A. First, the interface to the gsl function that calculates the minimum\n of an N-dimensional function, with the knowledge of the function itself\n and its gradient. */\n\n/* This is a type used to communicate with Fortran; func_d is the type of the\n interface to a Fortran subroutine that calculates the function and its\n gradient. */\ntypedef void (*func_d)(const int*, const double*, double*, const int*, double*);\ntypedef struct{\n func_d func;\n} param_fdf_t;\n\n/* Compute both f and df together. */\nstatic void\nmy_fdf (const gsl_vector *v, void *params, double *f, gsl_vector *df)\n{\n double *x, *gradient, ff2;\n int i, dim, getgrad;\n param_fdf_t * p;\n\n p = (param_fdf_t *) params;\n \n dim = v->size;\n x = (double *)malloc(dim*sizeof(double));\n gradient = (double *)malloc(dim*sizeof(double));\n\n for(i=0; ifunc(&dim, x, &ff2, &getgrad, gradient);\n\n if(f != NULL)\n *f = ff2;\n \n if(df != NULL){\n for(i=0; ifunc(&x, &fx);\n return fx;\n}\n\nvoid FC_FUNC_(oct_1dminimize, OCT_1DMINIMIZE)(double *a, double *b, double *m, func1 f, int *status)\n{\n int iter = 0;\n int max_iter = 100;\n const gsl_min_fminimizer_type *T;\n gsl_min_fminimizer *s;\n gsl_function F;\n param_f1_t p;\n\n p.func = f;\n\n F.function = &fn1;\n F.params = (void *) &p;\n\n T = gsl_min_fminimizer_brent;\n s = gsl_min_fminimizer_alloc (T);\n\n *status = gsl_min_fminimizer_set (s, &F, *m, *a, *b);\n\n gsl_set_error_handler_off();\n\n do\n {\n iter++;\n *status = gsl_min_fminimizer_iterate (s);\n\n *m = gsl_min_fminimizer_x_minimum (s);\n *a = gsl_min_fminimizer_x_lower (s);\n *b = gsl_min_fminimizer_x_upper (s);\n\n *status = gsl_min_test_interval (*a, *b, 0.00001, 0.0);\n\n /*if (*status == GSL_SUCCESS) printf (\"Converged:\\n\");*/\n /*printf (\"%5d [%.7f, %.7f] %.7f \\n\", iter, *a, *b,*m);*/\n }\n while (*status == GSL_CONTINUE && iter < max_iter);\n gsl_min_fminimizer_free(s);\n\n}\n\n\n\n\n/* C. Third, the interface to the gsl function that calculates the minimum\n of an N-dimensional function, with the knowledge of the function itself,\n but not its gradient. */\n\n/* This is a type used to communicate with Fortran; funcn is the type of the\n interface to a Fortran subroutine that calculates the function and its\n gradient. */\ntypedef void (*funcn)(int*, double*, double*);\ntypedef struct{\n funcn func;\n} param_fn_t;\n\ndouble fn(const gsl_vector *v, void * params)\n{\n double val;\n double *x;\n int i, dim;\n param_fn_t * p;\n\n p = (param_fn_t *) params;\n dim = v->size;\n x = (double *)malloc(dim*sizeof(double));\n\n for(i=0; ifunc(&dim, x, &val);\n\n free(x);\n return val;\n}\n\ntypedef void (*print_f_fn_ptr)(const int*, const int*, const double*, const double*, const double*);\n\nint FC_FUNC_(oct_minimize_direct, OCT_MINIMIZE_DIRECT)\n (const int *method, const int *dim, double *point, const double *step, \n const double *toldr, const int *maxiter, funcn f, \n const print_f_fn_ptr write_info, double *minimum)\n{\n int iter = 0, status, i;\n double size;\n\n const gsl_multimin_fminimizer_type *T = NULL;\n gsl_multimin_fminimizer *s = NULL;\n gsl_vector *x, *ss;\n gsl_multimin_function my_func;\n\n param_fn_t p;\n p.func = f;\n\n my_func.f = &fn;\n my_func.n = *dim;\n my_func.params = (void *) &p;\n\n /* Set the initial vertex size vector */\n ss = gsl_vector_alloc (*dim);\n gsl_vector_set_all (ss, *step);\n\n /* Starting point */\n x = gsl_vector_alloc (*dim);\n for(i=0; i<*dim; i++) gsl_vector_set (x, i, point[i]);\n\n switch(*method){\n case 6:\n T = gsl_multimin_fminimizer_nmsimplex;\n break;\n }\n\n s = gsl_multimin_fminimizer_alloc (T, *dim);\n gsl_multimin_fminimizer_set (s, &my_func, x, ss);\n\n do\n {\n iter++;\n status = gsl_multimin_fminimizer_iterate(s);\n\n if(status) break;\n\n *minimum = gsl_multimin_fminimizer_minimum(s);\n for(i=0; i<*dim; i++) point[i] = gsl_vector_get(gsl_multimin_fminimizer_x(s), i);\n\n size = gsl_multimin_fminimizer_size (s);\n status = gsl_multimin_test_size (size, *toldr);\n\n write_info(&iter, dim, minimum, &size, point);\n\n }\n while (status == GSL_CONTINUE && iter < *maxiter);\n\n if(status == GSL_CONTINUE) status = 1025;\n\n gsl_vector_free(x); \n gsl_vector_free(ss);\n gsl_multimin_fminimizer_free(s);\n return status;\n}\n", "meta": {"hexsha": "49e98c62fe815469c9e0469e272439cb82f941db", "size": 9354, "ext": "c", "lang": "C", "max_stars_repo_path": "src/math/minimizer_low.c", "max_stars_repo_name": "gimunu/octopus-metric", "max_stars_repo_head_hexsha": "baabccd5402922a2f62f5cf6030d15e7ea76dc9b", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/math/minimizer_low.c", "max_issues_repo_name": "gimunu/octopus-metric", "max_issues_repo_head_hexsha": "baabccd5402922a2f62f5cf6030d15e7ea76dc9b", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/math/minimizer_low.c", "max_forks_repo_name": "gimunu/octopus-metric", "max_forks_repo_head_hexsha": "baabccd5402922a2f62f5cf6030d15e7ea76dc9b", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 25.9113573407, "max_line_length": 112, "alphanum_fraction": 0.6643147317, "num_tokens": 2770, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8152325073083132, "lm_q2_score": 0.6584175005616829, "lm_q1q2_score": 0.5367633498385734}} {"text": "#include \n#include \n// interpSphericalPotential: 6 arguments: amp (not used here), rmin, rmax,\n// M(args;\n //Get args\n double rmin= *(args+1);\n double rmax= *(args+2);\n double Mmax= *(args+3);\n double Phi0= *(args+4);\n double Phimax= *(args+5);\n if ( r >= rmax ) {\n return -Mmax/r+Phimax;\n }\n else {\n return r < rmin ? 0. : \\\n -gsl_spline_eval_integ(*potentialArgs->spline1d,\n\t\t\t rmin,r,*potentialArgs->acc1d) + Phi0;\n }\n}\ndouble interpSphericalPotentialrforce(double r,double t,\n\t\t\t\t struct potentialArg * potentialArgs){\n double * args= potentialArgs->args;\n //Get args\n double rmin= *(args+1);\n double rmax= *(args+2);\n double Mmax= *(args+3);\n if ( r >= rmax ) {\n return -Mmax/r/r;\n }\n else {\n return r < rmin ? 0. : gsl_spline_eval(*potentialArgs->spline1d,\n\t\t\t\t\t r,*potentialArgs->acc1d);\n }\n}\ndouble interpSphericalPotentialr2deriv(double r,double t,\n\t\t\t\t struct potentialArg * potentialArgs){\n double * args= potentialArgs->args;\n //Get args\n double rmin= *(args+1);\n double rmax= *(args+2);\n double Mmax= *(args+3);\n if ( r >= rmax ) {\n return -2. * Mmax / r / r / r;\n }\n else {\n return r < rmin ? 0. : -gsl_spline_eval_deriv(*potentialArgs->spline1d,\n\t\t\t\t\t\t r,*potentialArgs->acc1d);\n }\n}\ndouble interpSphericalPotentialrdens(double r,double t,\n\t\t\t\t struct potentialArg * potentialArgs){\n double * args= potentialArgs->args;\n //Get args\n double rmin= *(args+1);\n double rmax= *(args+2);\n if ( r >= rmax ) {\n return 0.;\n }\n else {\n return r < rmin ? 0. : M_1_PI / 4. \\\n * ( interpSphericalPotentialr2deriv(r,t,potentialArgs)\n\t - 2. * interpSphericalPotentialrforce(r,t,potentialArgs)/r);\n }\n}\n", "meta": {"hexsha": "3f0994ec913e4304222daaf011ae0fd72eed95e0", "size": 1890, "ext": "c", "lang": "C", "max_stars_repo_path": "galpy/potential/potential_c_ext/interpSphericalPotential.c", "max_stars_repo_name": "gusbeane/galpy", "max_stars_repo_head_hexsha": "d6db971285f163456c81775fc2fdc7d75189762c", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 147.0, "max_stars_repo_stars_event_min_datetime": "2015-01-01T14:06:17.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-24T14:47:41.000Z", "max_issues_repo_path": "galpy/potential/potential_c_ext/interpSphericalPotential.c", "max_issues_repo_name": "gusbeane/galpy", "max_issues_repo_head_hexsha": "d6db971285f163456c81775fc2fdc7d75189762c", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 269.0, "max_issues_repo_issues_event_min_datetime": "2015-01-07T15:58:31.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-30T18:42:08.000Z", "max_forks_repo_path": "galpy/potential/potential_c_ext/interpSphericalPotential.c", "max_forks_repo_name": "gusbeane/galpy", "max_forks_repo_head_hexsha": "d6db971285f163456c81775fc2fdc7d75189762c", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 110.0, "max_forks_repo_forks_event_min_datetime": "2015-02-08T10:57:24.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-28T07:56:49.000Z", "avg_line_length": 27.7941176471, "max_line_length": 75, "alphanum_fraction": 0.6365079365, "num_tokens": 604, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8519528170040852, "lm_q2_score": 0.6297746074044135, "lm_q1q2_score": 0.5365382508558318}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nvoid init_Vmax_to_Mvir_NFW(cosmo_info **cosmo, int mode, double z) {\n interp_info *interp;\n if(!ADaPS_exist((*cosmo), \"lVmax_to_lMvir_%.5f_interp\", z)) {\n SID_log(\"Initializing Vmax->M_vir interpolation...\", SID_LOG_OPEN);\n int n_k;\n double *lk_P;\n double *lM;\n double *lVmax;\n int n_M = 201;\n double lM_lo = 0.;\n double lM_hi = 20.;\n double dlM = (lM_hi - lM_lo) / (double)(n_M - 1);\n lM = (double *)SID_malloc(sizeof(double) * n_M);\n lVmax = (double *)SID_malloc(sizeof(double) * n_M);\n int i_M;\n for(i_M = 0; i_M < n_M; i_M++) {\n if(i_M == 0)\n lM[i_M] = lM_lo;\n else if(i_M == (n_M - 1))\n lM[i_M] = lM_hi;\n else\n lM[i_M] = lM[i_M - 1] + dlM;\n }\n for(i_M = 0; i_M < n_M; i_M++) {\n lM[i_M] += take_log10(M_SOL);\n lVmax[i_M] = take_log10(V_max_NFW(take_alog10(lM[i_M]), z, mode, cosmo));\n }\n init_interpolate(lVmax, lM, (size_t)n_M, gsl_interp_cspline, &interp);\n ADaPS_store_interp(cosmo, (void *)(interp), \"lVmax_to_lMvir_%.5f_interp\", z);\n SID_free(SID_FARG lM);\n SID_free(SID_FARG lVmax);\n SID_log(\"Done.\", SID_LOG_CLOSE);\n }\n}\ndouble Vmax_to_Mvir_NFW(double V_max, double z, int mode, cosmo_info **cosmo) {\n double c_vir;\n double R_vir;\n double V2_vir;\n double g_c;\n double r_val = 0.;\n if(V_max > 0.) {\n interp_info *interp;\n init_Vmax_to_Mvir_NFW(cosmo, mode, z);\n interp = (interp_info *)ADaPS_fetch(*cosmo, \"lVmax_to_lMvir_%.5f_interp\", z);\n r_val = take_alog10(interpolate(interp, take_log10(V_max)));\n }\n return (r_val);\n}\n", "meta": {"hexsha": "2c96bd1477e691777b3c5435b8a79ab0d3f6def6", "size": 1964, "ext": "c", "lang": "C", "max_stars_repo_path": "src/gbpAstro/gbpCosmo/NFW_etc/Vmax_to_Mvir_NFW.c", "max_stars_repo_name": "gbpoole/gbpCode", "max_stars_repo_head_hexsha": "5157d2e377edbd4806258d1c16b329373186d43a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2015-10-20T11:39:53.000Z", "max_stars_repo_stars_event_max_datetime": "2015-10-20T11:39:53.000Z", "max_issues_repo_path": "src/gbpAstro/gbpCosmo/NFW_etc/Vmax_to_Mvir_NFW.c", "max_issues_repo_name": "gbpoole/gbpCode", "max_issues_repo_head_hexsha": "5157d2e377edbd4806258d1c16b329373186d43a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2017-07-30T11:10:49.000Z", "max_issues_repo_issues_event_max_datetime": "2019-06-18T00:40:46.000Z", "max_forks_repo_path": "src/gbpAstro/gbpCosmo/NFW_etc/Vmax_to_Mvir_NFW.c", "max_forks_repo_name": "gbpoole/gbpCode", "max_forks_repo_head_hexsha": "5157d2e377edbd4806258d1c16b329373186d43a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4.0, "max_forks_repo_forks_event_min_datetime": "2015-01-23T00:50:40.000Z", "max_forks_repo_forks_event_max_datetime": "2016-08-01T08:14:24.000Z", "avg_line_length": 33.8620689655, "max_line_length": 85, "alphanum_fraction": 0.5631364562, "num_tokens": 643, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8615382236515259, "lm_q2_score": 0.6224593312018546, "lm_q1q2_score": 0.5362725064989626}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#define FALSE 0\n#define TRUE 1\n\n#ifndef M_PI\n#define M_PI 3.141592653589793238462643383280 /* pi */\n#endif\n\n#define LN2PI 1.83787706640934548356065947\n\nextern char parameterfilename[50];\nextern char parameterlogfilename[50];\n\n#define MBIG 1000000000\n#define MSEED 161803398\n#define MZ 0\n#define FAC (1.0/MBIG)\n#define MIN(A,B) ((A) < (B) ? (A) : (B))\n#define MAX(A,B) ((A) > (B) ? (A) : (B))\nenum {NOT_AVAILABLE=0, ABOVE_DETECTION=1, BELOW_DETECTION=2, MEASURED=3};\n\ntypedef struct {\n int n;\n int m;\n int **a;\n} Matrix;\n\nvoid ReadParam( char*, void*, char* ) ;\nvoid ExperimentNumber( char*, char* );\nvoid Error( char* );\nvoid FileError( char*, char* );\ndouble ***doublematrix3( int, int, int );\ndouble **doublematrix( int, int );\nint **integermatrix( int, int );\nuint **uintegermatrix( int, int );\nuint *uintegervector( int );\nchar **charmatrix( int, int );\ndouble *doublevector( int );\nint *integervector( int );\nchar *charvector( int );\n\nvoid Int_HeapSort(int*, int);\nvoid HeapSort( double*, int );\nvoid circmeanvar( double*, int, double*, double* );\nvoid meanvar( double*, int, double*, double* );\nvoid meanvarl( long double*, int, long double*, long double* );\nvoid wmeanvar( long double *x, int n, long double *m, long double *s2 );\ndouble mean( double*, int, int );\nint choldc_block(double**, long long);\n\nuint binomialRNG(uint, double, const gsl_rng*);\nvoid multinomialRNG(uint, const double*, size_t, unsigned int*, \n\t\t const gsl_rng*);\nint poissonRNG(double, const gsl_rng*);\nint uniform_intRNG(int, int, const gsl_rng*);\ndouble normalRNG(double, double, const gsl_rng*);\ndouble betaRNG(double, double, const gsl_rng*);\ndouble chisqRNG(double, const gsl_rng*);\ndouble scaleinvchisqRNG(double, double, const gsl_rng*);\ndouble invgammaRNG(double, double, const gsl_rng*);\ndouble gammaRNG(double, double, const gsl_rng*);\ndouble uniformRNG(double, double, const gsl_rng*);\ndouble paretoRNG(double, double, const gsl_rng*);\nvoid dirichlet_multinomialRNG(uint, const double*, size_t, uint*,\n\t\t\t\tconst gsl_rng*);\nvoid dirichletRNG(const double*, size_t, double*, const gsl_rng*);\nuint beta_binomialRNG(uint, double, double, const gsl_rng*);\nuint negative_binomialRNG(double, double, const gsl_rng*);\nuint beta_negative_binomialRNG(uint, double, double, const gsl_rng*);\n/* Matrix *wishartRNG(int, int, Matrix*, Matrix*, const gsl_rng*); */\n/* void MVNRNG(int, Matrix*, Matrix*, Matrix*, const gsl_rng*); */\n\ndouble poissonCMF(const double, const double, int);\ndouble gamma_scalePDF(const double, const double, const double);\ndouble betaPDF(const double, const double, const double);\ndouble exponentialPDF(const double, const double);\ndouble poissonPMF(const double, const double);\ndouble geometricPDF(const double, const double);\ndouble trnormalPDF(const double, const double, const double);\ndouble normalCDF(const double, const double, const double, int);\ndouble normalPDF(const double, const double, const double);\ndouble binomialPMF(const double, const double, const double);\ndouble multinomialPMF(const unsigned int, const double*, const double*);\ndouble uniformPDF(const double, const double, const double);\ndouble logisticPDF(const double, const double, const double);\ndouble betabinomialPMF(const double, const double, const double, const double);\n/* double MVNPDF(Matrix*, Matrix*, Matrix*, const double, int); */\n\ndouble identity(double);\ndouble logit(double);\ndouble invlogit(double);\n\nMatrix *MatrixInit(Matrix*, int, int, int*);\nMatrix *MatrixDestroy(Matrix*);\n/* Matrix *Matrix_Init(Matrix*, char*, int, int); */\n/* Matrix *Matrix_Fill(Matrix*, int, int, ...); */\n/* Matrix *Matrix_Destroy(Matrix*); */\n/* Matrix *Matrix_Copy(Matrix*, Matrix*); */\n/* Matrix *Matrix_Sub_Copy(Matrix*, Matrix*, int); */\n/* Matrix *Matrix_Scalar_Multiply(Matrix*, double, Matrix*); */\n/* Matrix *Matrix_Multiply(Matrix*, Matrix*, Matrix*); */\n/* Matrix *Matrix_Multiply(Matrix*, Matrix*, Matrix*); */\n/* Matrix *Matrix_Cholesky(Matrix*, Matrix*); */\n/* Matrix *Matrix_Invert(Matrix*, Matrix*); */\n/* Matrix *Matrix_Add(Matrix*, Matrix*, Matrix*); */\n/* Matrix *Matrix_Add_Diagonal(Matrix*, Matrix*); */\n/* Matrix *Matrix_Subtract(Matrix*, Matrix*, Matrix*); */\n/* Matrix *Matrix_Transpose(Matrix*, Matrix*); */\n/* double Matrix_Log_Determinant(Matrix*, int); */\n/* void Matrix_Print(Matrix*); */\n\ndouble rtnewt(void(*)(double, double*, double*, double*), \n\t double, double, double, double*);\ndouble rtbis( double (*)(double, double*), double, double, double, int*,\n\t double* );\n\nsize_t strlen(const char*);\nchar *strncpy(char*, const char*, size_t);\nchar *strcpy(char*, const char*);\nchar *strcat(char*, const char*);\nchar *strchr ( const char*, int );\nint strcmp (const char*, const char*);\nvoid *calloc(size_t, size_t);\nvoid *malloc(size_t);\nvoid free(void*);\nvoid exit(int);\n\ndouble von_mises_cdf ( double x, double a, double b );\ndouble von_mises_cdf_inv ( double cdf, double a, double b );\n\n", "meta": {"hexsha": "ae790a3938b4758f53122d0bfffee4ff3583d7bf", "size": 5163, "ext": "h", "lang": "C", "max_stars_repo_path": "func.h", "max_stars_repo_name": "nicksavill/bayesian-dynamical-model-inference", "max_stars_repo_head_hexsha": "24418e397cca4ffa9b17d1d17b1ff59f3f49c87c", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "func.h", "max_issues_repo_name": "nicksavill/bayesian-dynamical-model-inference", "max_issues_repo_head_hexsha": "24418e397cca4ffa9b17d1d17b1ff59f3f49c87c", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "func.h", "max_forks_repo_name": "nicksavill/bayesian-dynamical-model-inference", "max_forks_repo_head_hexsha": "24418e397cca4ffa9b17d1d17b1ff59f3f49c87c", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 36.8785714286, "max_line_length": 79, "alphanum_fraction": 0.7133449545, "num_tokens": 1366, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8615382165412808, "lm_q2_score": 0.6224593312018546, "lm_q1q2_score": 0.5362725020731243}} {"text": "/*\n # This file is part of the Astrometry.net suite.\n # Licensed under a 3-clause BSD style license - see LICENSE\n */\n\n#include \n#include \n\n#include \"compat.h\"\n#include \"sip-utils.h\"\n#include \"gslutils.h\"\n#include \"mathutil.h\"\n#include \"sip.h\"\n\ndouble wcs_pixel_center_for_size(double size) {\n return 0.5 + 0.5 * size;\n}\n\nint sip_compute_inverse_polynomials(sip_t* sip, int NX, int NY,\n double xlo, double xhi,\n double ylo, double yhi) {\n int inv_sip_order;\n int M, N;\n int i, j, p, q, gu, gv;\n double maxu, maxv, minu, minv;\n double u, v, U, V;\n gsl_matrix *mA;\n gsl_vector *b1, *b2, *x1, *x2;\n tan_t* tan;\n\n assert(sip->a_order == sip->b_order);\n assert(sip->ap_order == sip->bp_order);\n tan = &(sip->wcstan);\n\n logverb(\"sip_compute-inverse_polynomials: A %i, AP %i\\n\",\n sip->a_order, sip->ap_order);\n\n /*\n basic idea: lay down a grid in image, for each gridpoint, push\n through the polynomial to get yourself into warped image\n coordinate (but not yet lifted onto the sky). Then, using the\n set of warped gridpoints as inputs, fit back to their original\n grid locations as targets.\n */\n inv_sip_order = sip->ap_order;\n\n // Number of grid points to use:\n if (NX == 0)\n NX = 10 * (inv_sip_order + 1);\n if (NY == 0)\n NY = 10 * (inv_sip_order + 1);\n if (xhi == 0)\n xhi = tan->imagew;\n if (yhi == 0)\n yhi = tan->imageh;\n\n logverb(\"NX,NY %i,%i, x range [%f, %f], y range [%f, %f]\\n\",\n NX,NY, xlo, xhi, ylo, yhi);\n\n // Number of coefficients to solve for:\n // We only compute the upper triangle polynomial terms\n N = (inv_sip_order + 1) * (inv_sip_order + 2) / 2;\n\n // Number of samples to fit.\n M = NX * NY;\n\n mA = gsl_matrix_alloc(M, N);\n b1 = gsl_vector_alloc(M);\n b2 = gsl_vector_alloc(M);\n assert(mA);\n assert(b1);\n assert(b2);\n\n /*\n * Rearranging formula (4), (5), and (6) from the SIP paper gives the\n * following equations:\n * \n * +----------------------- Linear pixel coordinates in PIXELS\n * | before SIP correction\n * | +--- Intermediate world coordinates in DEGREES\n * | |\n * v v\n * -1\n * U = [CD11 CD12] * x\n * V [CD21 CD22] y\n * \n * +---------------- PIXEL distortion delta from telescope to\n * | linear coordinates\n * | +----------- Linear PIXEL coordinates before SIP correction\n * | | +--- Polynomial U,V terms in powers of PIXELS\n * v v v\n * \n * -f(u1,v1) = p11 p12 p13 p14 p15 ... * ap1\n * -f(u2,v2) = p21 p22 p23 p24 p25 ... ap2\n * ...\n * \n * -g(u1,v1) = p11 p12 p13 p14 p15 ... * bp1\n * -g(u2,v2) = p21 p22 p23 p24 p25 ... bp2\n * ...\n * \n * which recovers the A and B's.\n */\n\n minu = xlo - tan->crpix[0];\n maxu = xhi - tan->crpix[0];\n minv = ylo - tan->crpix[1];\n maxv = yhi - tan->crpix[1];\n\t\n // Sample grid locations.\n i = 0;\n for (gu=0; gu inv_sip_order)\n continue;\n assert(j < N);\n gsl_matrix_set(mA, i, j,\n pow(U, (double)p) * pow(V, (double)q));\n j++;\n }\n assert(j == N);\n gsl_vector_set(b1, i, -fuv);\n gsl_vector_set(b2, i, -guv);\n i++;\n }\n }\n assert(i == M);\n\n // Solve the linear equation.\n if (gslutils_solve_leastsquares_v(mA, 2, b1, &x1, NULL, b2, &x2, NULL)) {\n ANERROR(\"Failed to solve SIP inverse matrix equation!\");\n return -1;\n }\n\n // Extract the coefficients\n j = 0;\n for (p = 0; p <= inv_sip_order; p++)\n for (q = 0; q <= inv_sip_order; q++) {\n if ((p + q > inv_sip_order))\n continue;\n assert(j < N);\n sip->ap[p][q] = gsl_vector_get(x1, j);\n sip->bp[p][q] = gsl_vector_get(x2, j);\n j++;\n }\n assert(j == N);\n\n // Check that we found values that actually invert the polynomial.\n // The error should be particularly small at the grid points.\n if (true) {\n // rms error accumulators:\n double sumdu = 0;\n double sumdv = 0;\n int Z;\n for (gu = 0; gu < NX; gu++) {\n for (gv = 0; gv < NY; gv++) {\n double newu, newv;\n // Calculate grid position in original image pixels\n u = (gu * (maxu - minu) / (NX-1)) + minu;\n v = (gv * (maxv - minv) / (NY-1)) + minv;\n sip_calc_distortion(sip, u, v, &U, &V);\n sip_calc_inv_distortion(sip, U, V, &newu, &newv);\n sumdu += square(u - newu);\n sumdv += square(v - newv);\n }\n }\n sumdu /= (NX*NY);\n sumdv /= (NX*NY);\n debug(\"RMS error of inverting a distortion (at the grid points, in pixels):\\n\");\n debug(\" du: %g\\n\", sqrt(sumdu));\n debug(\" dv: %g\\n\", sqrt(sumdu));\n debug(\" dist: %g\\n\", sqrt(sumdu + sumdv));\n\n sumdu = 0;\n sumdv = 0;\n Z = 1000;\n for (i=0; i= 1 && x <= wcs->imagew && y >= 1 && y <= wcs->imageh);\n}\n\nbool sip_pixel_is_inside_image(const sip_t* wcs, double x, double y) {\n return tan_pixel_is_inside_image(&(wcs->wcstan), x, y);\n}\n\nint* sip_filter_stars_in_field(const sip_t* sip, const tan_t* tan,\n const double* xyz, const double* radec,\n int N, double** p_xy, int* inds, int* p_Ngood) {\n int i, Ngood;\n int W, H;\n double* xy = NULL;\n bool allocd = false;\n\t\n assert(sip || tan);\n assert(xyz || radec);\n assert(p_Ngood);\n\n Ngood = 0;\n if (!inds) {\n inds = malloc(N * sizeof(int));\n allocd = true;\n }\n\n if (p_xy)\n xy = malloc(N * 2 * sizeof(double));\n\n if (sip) {\n W = (int)sip->wcstan.imagew;\n H = (int)sip->wcstan.imageh;\n } else {\n W = (int)tan->imagew;\n H = (int)tan->imageh;\n }\n\n for (i=0; i= W) || (y >= H))\n continue;\n\n inds[Ngood] = i;\n if (xy) {\n xy[Ngood * 2 + 0] = x;\n xy[Ngood * 2 + 1] = y;\n }\n Ngood++;\n }\n\n if (allocd)\n inds = realloc(inds, Ngood * sizeof(int));\n\n if (xy)\n xy = realloc(xy, Ngood * 2 * sizeof(double));\n if (p_xy)\n *p_xy = xy;\n\n *p_Ngood = Ngood;\n\t\n return inds;\n}\n", "meta": {"hexsha": "6b2ffed853e8ef9e4fcd4c3c1f999a3673e66140", "size": 8850, "ext": "c", "lang": "C", "max_stars_repo_path": "astrometrylib/src/util/sip-utils.c", "max_stars_repo_name": "mgreter/astrometrylib", "max_stars_repo_head_hexsha": "ef4d4539a537ab49329b77648aac893d2b4ad318", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2021-01-09T05:48:44.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-09T16:18:47.000Z", "max_issues_repo_path": "astrometrylib/src/util/sip-utils.c", "max_issues_repo_name": "mgreter/astrometrylib", "max_issues_repo_head_hexsha": "ef4d4539a537ab49329b77648aac893d2b4ad318", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2021-01-11T01:08:01.000Z", "max_issues_repo_issues_event_max_datetime": "2021-01-13T16:28:48.000Z", "max_forks_repo_path": "astrometrylib/src/util/sip-utils.c", "max_forks_repo_name": "mgreter/astrometrylib", "max_forks_repo_head_hexsha": "ef4d4539a537ab49329b77648aac893d2b4ad318", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2021-01-19T22:59:43.000Z", "max_forks_repo_forks_event_max_datetime": "2021-01-19T22:59:43.000Z", "avg_line_length": 30.1020408163, "max_line_length": 88, "alphanum_fraction": 0.4702824859, "num_tokens": 2650, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8418256432832333, "lm_q2_score": 0.6370308082623217, "lm_q1q2_score": 0.536268869956667}} {"text": "/* specfunc/legendre_P.c\n * \n * Copyright (C) 2009-2013 Patrick Alken\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n#include \n#include \n#include \n#include \n#include \n\n/*\n * The routines in this module compute associated Legendre functions\n * (ALFs) up to order and degree 2700, using the method described\n * in\n *\n * [1] S. A. Holmes and W. E. Featherstone, A unified approach\n * to the Clenshaw summation and the recursive computation of very\n * high degree and order normalised associated Legendre functions,\n * Journal of Geodesy, 76, pg. 279-299, 2002.\n *\n * Further information on ALFs can be found in\n *\n * [2] Abramowitz and Stegun, Handbook of Mathematical Functions,\n * Chapter 8, 1972.\n */\n\nstatic void legendre_sqrts(const size_t lmax, double *array);\n\n#define LEGENDRE\n#include \"legendre_source.c\"\n#undef LEGENDRE\n\n#define LEGENDRE_DERIV\n#include \"legendre_source.c\"\n#undef LEGENDRE_DERIV\n\n#define LEGENDRE_DERIV_ALT\n#include \"legendre_source.c\"\n#undef LEGENDRE_DERIV_ALT\n\n#define LEGENDRE_DERIV2\n#include \"legendre_source.c\"\n#undef LEGENDRE_DERIV2\n\n#define LEGENDRE_DERIV2_ALT\n#include \"legendre_source.c\"\n#undef LEGENDRE_DERIV2_ALT\n\n/* number of P_{lm} functions for a given lmax */\nsize_t\ngsl_sf_legendre_nlm(const size_t lmax)\n{\n return ((lmax + 1) * (lmax + 2) / 2);\n}\n\n/*\ngsl_sf_legendre_array_n()\n This routine returns the minimum result_array[] size needed\nfor a given lmax\n*/\n\nsize_t\ngsl_sf_legendre_array_n(const size_t lmax)\n{\n size_t nlm = gsl_sf_legendre_nlm(lmax);\n size_t nsqrt = 2 * lmax + 2; /* extra room to precompute sqrt factors */\n\n return (nlm + nsqrt);\n} /* gsl_sf_legendre_array_n() */\n\n/*\ngsl_sf_legendre_array_index()\nThis routine computes the index into a result_array[] corresponding\nto a given (l,m)\n*/\n\nsize_t\ngsl_sf_legendre_array_index(const size_t l, const size_t m)\n{\n return (l * (l + 1) / 2 + m);\n} /* gsl_sf_legendre_array_index() */\n\n/*********************************************************\n * INTERNAL ROUTINES *\n *********************************************************/\n\n/*\nlegendre_sqrts()\n Precompute square root factors needed for Legendre recurrence.\nOn output, array[i] = sqrt(i)\n*/\n\nstatic void\nlegendre_sqrts(const size_t lmax, double *array)\n{\n size_t l;\n for (l = 0; l <= 2 * lmax + 1; ++l)\n array[l] = sqrt((double) l);\n}\n", "meta": {"hexsha": "45e26fa22d691fc10f4bfd3cb5b1fe986f04f0ec", "size": 3112, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.6/specfunc/legendre_P.c", "max_stars_repo_name": "ielomariala/Hex-Game", "max_stars_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2020-10-18T13:15:00.000Z", "max_stars_repo_stars_event_max_datetime": "2020-10-18T13:15:00.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/specfunc/legendre_P.c", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-12-16T17:41:24.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-22T00:00:16.000Z", "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/specfunc/legendre_P.c", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.0608695652, "max_line_length": 81, "alphanum_fraction": 0.6937660668, "num_tokens": 838, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7662936430859597, "lm_q2_score": 0.6992544210587585, "lm_q1q2_score": 0.5358342177570796}} {"text": "/**\n * (c) Author: Woongkyu Jee, woong.jee.16@ucl.ac.uk, wldndrb1@gmail.com\n * Created: 02.06.2019 ~\n * \t\n * University College London, Department of Chemistry\n **/\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include\"sp_cluster_type.h\"\n\n#define SP_SUPPORT_TRUE 1\n#define SP_SUPPORT_FALSE -1\n\n#define DEBUG_SUPPORT\n\n/* Get the Lowest energy state */\nint sp_cluster_support_get_lowest_state( gsl_vector* v )\n{\n int Return = 0;\n double min;\n\n min = gsl_vector_get(v,0);\n for(int i=0;i<4;i++)\n {\n if( gsl_vector_get(v,i) < min )\n {\n min = gsl_vector_get(v,i);\n Return = i;\n }\n }\n return Return;\n // Returns the index of element in gsl_vector* eval\n}\n\nvoid sp_cluster_support_sign_gs_eigenvector( void* sp_sys_void )\n{\n sp_cluster_system* sp_sys = (sp_cluster_system*)sp_sys_void;\n int low_idx;\n\n for(int i=0;inumber_of_sp_ion;i++)\n {\n low_idx = sp_cluster_support_get_lowest_state(sp_sys->sp_ion[i].eigen_value);\n if( gsl_matrix_get(sp_sys->sp_ion[i].eigen_vector,0,low_idx) < 0. ) // eigen_vector : matrix(4,4) // eigen_vector_gs : vector(4)\n {\n gsl_matrix_set(sp_sys->sp_ion[i].eigen_vector,0,low_idx,-1.*gsl_matrix_get(sp_sys->sp_ion[i].eigen_vector,0,low_idx));\n gsl_matrix_set(sp_sys->sp_ion[i].eigen_vector,1,low_idx,-1.*gsl_matrix_get(sp_sys->sp_ion[i].eigen_vector,1,low_idx));\n gsl_matrix_set(sp_sys->sp_ion[i].eigen_vector,2,low_idx,-1.*gsl_matrix_get(sp_sys->sp_ion[i].eigen_vector,2,low_idx));\n gsl_matrix_set(sp_sys->sp_ion[i].eigen_vector,3,low_idx,-1.*gsl_matrix_get(sp_sys->sp_ion[i].eigen_vector,3,low_idx));\n }\n }\n return;\n}\n\nvoid sp_cluster_support_load_gs_eigenvector( void* sp_sys_void )\n{\n sp_cluster_system* sp_sys = (sp_cluster_system*)sp_sys_void;\n int low_idx;\n for(int i=0;inumber_of_sp_ion;i++)\n { low_idx = sp_cluster_support_get_lowest_state(sp_sys->sp_ion[i].eigen_value);\n\n gsl_vector_set(sp_sys->sp_ion[i].eigen_vector_gs,0,gsl_matrix_get(sp_sys->sp_ion[i].eigen_vector,0,low_idx));\n gsl_vector_set(sp_sys->sp_ion[i].eigen_vector_gs,1,gsl_matrix_get(sp_sys->sp_ion[i].eigen_vector,1,low_idx));\n gsl_vector_set(sp_sys->sp_ion[i].eigen_vector_gs,2,gsl_matrix_get(sp_sys->sp_ion[i].eigen_vector,2,low_idx));\n gsl_vector_set(sp_sys->sp_ion[i].eigen_vector_gs,3,gsl_matrix_get(sp_sys->sp_ion[i].eigen_vector,3,low_idx));\n }\n return;\n}\n\n\n/* Matrix Viewer: Print out a N x N matrix on console */\nvoid sp_cluster_support_matrix_view( const gsl_matrix* m )\n{\n if( m != NULL )\n { for(int i=0;isize1;i++)\n { for(int j=0;jsize2;j++)\n { //printf(\"%s%12.4lf\",gsl_matrix_get(m,i,j)>0.?\"+\":\"\",gsl_matrix_get(m,i,j));\n printf(\"%12.4e\",gsl_matrix_get(m,i,j));\n }\n puts(\"\");\n }\n }\n else\n puts(\"sp_cluster_support_matrix_view input 'm' (gsl_matrix*) is a null pointer ... in SP_Support.c or SP_Support.h\");\n\n return;\n}\n\n/* Vector Viewer: Print out a vector on console */\nvoid sp_cluster_support_vector_view( const gsl_vector* v )\n{\n if( v != NULL )\n { for(int i=0;isize;i++)\n { //printf(\"%s%12.4f\",gsl_vector_get(v,i)>0.?\"+\":\"\",gsl_vector_get(v,i));\n printf(\"%12.4e\",gsl_vector_get(v,i));\n }\n puts(\"\");\n }\n else\n puts(\"sp_cluster_support_vector_view input 'v' (gsl_vector*) is a null pointer ... in SP_Support.c or SP_Support.h\");\n\n return;\n}\n\n\n/* Matrix Viewer: Print out a N x N matrix on file */\nvoid sp_cluster_support_matrix_view_f( FILE* fp, const gsl_matrix* m )\n{\n if( m != NULL )\n { for(int i=0;isize1;i++)\n { for(int j=0;jsize2;j++)\n fprintf(fp,\"%s%.18lf\\t\",gsl_matrix_get(m,i,j)>0.?\"+\":\"\",gsl_matrix_get(m,i,j));\n fprintf(fp,\"\\n\");\n }\n }\n else\n fputs(\"sp_cluster_support_matrix_view input 'm' (gsl_matrix*) is a null pointer ... in SP_Support.c or SP_Support.h\",fp);\n\n fflush(fp);\n\n return;\n}\n\n/* Vector Viewer: Print out a vector on file */\nvoid sp_cluster_support_vector_view_f( FILE* fp, const gsl_vector* v )\n{\n if( v != NULL )\n { for(int i=0;isize;i++)\n fprintf(fp,\"%s%.18f\\t\",gsl_vector_get(v,i)>0.?\"+\":\"\",gsl_vector_get(v,i));\n fprintf(fp,\"\\n\");\n }\n else\n fputs(\"sp_cluster_support_vector_view input 'v' (gsl_vector*) is a null pointer ... in SP_Support.c or SP_Support.h\",fp);\n\n fflush(fp);\n\n return;\n}\n\n\n\n/* Transformation Matrix calculator */\n/* \n * this function takes a vector, and the vector is transformed along transformed z-axis\n * the final return is the transformation matrix (rank 2 tensor), and the this data type is\n * gsl_matrix*\n */\n\ngsl_matrix* sp_cluster_support_get_transformation_matrix( const gsl_vector* v )\n{\n // gsl_vector_get(v,0) == 'x'\n // gsl_vector_get(v,1) == 'y'\n // gsl_vector_get(v,2) == 'z'\n gsl_matrix* pReturn = NULL;\n \n const double rxy = sqrt(pow(gsl_vector_get(v,0),2.)+pow(gsl_vector_get(v,1),2.));\n const double R = sqrt(pow(gsl_vector_get(v,0),2.)+pow(gsl_vector_get(v,1),2.)+pow(gsl_vector_get(v,2),2.));\n double n1, n2, tmp; // dummy variables for workspace\n pReturn = gsl_matrix_calloc(4,4); // Normally a rotation matrix is 3x3 \n // For the 1st column or row has an element of '1' at T_11.\n \n if( pReturn != NULL )\n {\n gsl_matrix_set(pReturn,0,0,1.);\n \n if( gsl_vector_get(v,0) == 0. && gsl_vector_get(v,1) == 0. && gsl_vector_get(v,2) > 0. ) // if vector 'v' is on z-axis\n { gsl_matrix_set(pReturn,1,1,1.); gsl_matrix_set(pReturn,2,2,1.); gsl_matrix_set(pReturn,3,3,1.);\n // set the matrix as I\n }\n else if( gsl_vector_get(v,0) == 0. && gsl_vector_get(v,1) == 0. && gsl_vector_get(v,2) < 0. ) // if vector 'v' is on negative z-axis\n { gsl_matrix_set(pReturn,1,1,1.); gsl_matrix_set(pReturn,2,2,1.); gsl_matrix_set(pReturn,3,3,-1.);\n // set the matrix has xy-plane reflection\n }\n else\n { gsl_matrix_set(pReturn,3,1,gsl_vector_get(v,0)/R);\n gsl_matrix_set(pReturn,3,2,gsl_vector_get(v,1)/R);\n gsl_matrix_set(pReturn,3,3,gsl_vector_get(v,2)/R); // set k' in the transformed (local) symmetry\n\n gsl_matrix_set(pReturn,2,1,gsl_vector_get(v,2)*gsl_vector_get(v,0)/rxy);\n gsl_matrix_set(pReturn,2,2,gsl_vector_get(v,2)*gsl_vector_get(v,1)/rxy);\n gsl_matrix_set(pReturn,2,3,-R*sqrt(1.-gsl_vector_get(v,2)*gsl_vector_get(v,2)/R/R));\n\n n1 = 1./sqrt(pow(gsl_matrix_get(pReturn,2,1),2.) \n + pow(gsl_matrix_get(pReturn,2,2),2.)\n + pow(gsl_matrix_get(pReturn,2,3),2.));\n\n for(int i=0;i<3;i++)\n { tmp = gsl_matrix_get(pReturn,2,i+1);\n tmp = tmp*n1;\n gsl_matrix_set(pReturn,2,i+1,tmp); // set j' in the transformed (local) symmetry\n }\n\n gsl_matrix_set(pReturn,1,1,n1/R*(pow(gsl_vector_get(v,2),2.)*gsl_vector_get(v,1)/rxy\n + R*gsl_vector_get(v,1)*sqrt(1.-pow(gsl_vector_get(v,2),2.)/R/R)));\n gsl_matrix_set(pReturn,1,2,n1/R*(-pow(gsl_vector_get(v,2),2.)*gsl_vector_get(v,0)/rxy\n - R*gsl_vector_get(v,0)*sqrt(1.-pow(gsl_vector_get(v,2),2.)/R/R)));\n gsl_matrix_set(pReturn,1,3,0.);\n \n n2 = 1./sqrt(pow(gsl_matrix_get(pReturn,1,1),2.)\n + pow(gsl_matrix_get(pReturn,1,2),2.)\n + pow(gsl_matrix_get(pReturn,1,3),2.));\n\n for(int i=0;i<3;i++)\n { tmp = gsl_matrix_get(pReturn,1,i+1);\n tmp = tmp/n2;\n gsl_matrix_set(pReturn,1,i+1,tmp); // set i' in the transformed (local) symmetry \n }\n }\n } \n else\n puts(\"sp_cluster_get_trans_mat 'pReturn' alloc error ... in SP_support.c or SP_support.h\");\n\n return pReturn;\n} /* SEE THE DETAILS IN THE 'N1' RING BINDER */\n\n\n\ndouble sp_cluster_support_kronecker_delta( int a, int b )\n{\n double Return = 0.;\n\n if( a == b )\n Return = 1.;\n\n return Return;\n}\n\n// norm of vector\ndouble sp_cluster_support_get_norm( double v1, double v2, double v3 )\n{ return pow(v1*v1+v2*v2+v3*v3,0.5);\n}\n\n// SPLINER\n\ndouble** sp_cluster_support_get_spline( const double** data, const int knot_stride )\n{\n double** pReturn = (double**)malloc((knot_stride-1)*sizeof(double*));\n for(int i=0;i=0;j--)\n {\n c[j] = z[j]-mu[j]*c[j+1];\n\n b[j] = (f[j+1]-f[j])/h[j] - h[j]*(c[j+1]+2.*c[j])/3.;\n\n d[j] = (c[j+1]-c[j])/(3.*h[j]);\n\n a[j] = f[j];\n }\n // R-E END\n\n // SAVE DATA\n for(int i=0;inumber_of_classic_ion;i++)\n\t{\tif( sp_sys->classic_ion[i].if_shell == SP_SUPPORT_FALSE )\n\t\t\tatom_number++;\n\t\t// CNT ONLY WHEN ITS CORE\n\t}\n\n\tif( cur_energy != 0. )\n\t{\t\n\t\t//printf(\"\\t%d\\n\",sp_sys->number_of_classic_ion+sp_sys->number_of_sp_ion);\n\t\tprintf(\"\\t%d\\n\",atom_number+sp_sys->number_of_sp_ion);\n\t\tprintf(\" SCF DONE %.6lf\\n\",cur_energy);\n\t}\n\n\t// CORE POSITION ONLY ... \"xyz\" Format Compatible \n\tfor(int n=0;nnumber_of_sp_ion+sp_sys->number_of_classic_ion;n++)\n\t{\n \t offset = n-sp_sys->number_of_classic_ion;\n\t if( n < sp_sys->number_of_classic_ion )\n\t {\n\t\tif( sp_sys->classic_ion[n].if_shell == SP_SUPPORT_FALSE ) // if it is core\n\t\t{\tfprintf(stdout,\"%3s%12.6lf%12.6lf%12.6lf\\n\", sp_sys->classic_ion[n].atom_name,\n\t\t\tgsl_vector_get(sp_sys->classic_ion[n].core_position,0), gsl_vector_get(sp_sys->classic_ion[n].core_position,1), gsl_vector_get(sp_sys->classic_ion[n].core_position,2));\n\t\t}\n\t }\n\t else // this is for printing sp-ions\n\t {\n\t\t offset = n - sp_sys->number_of_classic_ion;\n\t\t fprintf(stdout,\"%3s%12.6lf%12.6lf%12.6lf\\n\", sp_sys->sp_ion[offset].atom_name,\n\t\t\t gsl_vector_get(sp_sys->sp_ion[offset].core_position,0), gsl_vector_get(sp_sys->sp_ion[offset].core_position,1), gsl_vector_get(sp_sys->sp_ion[offset].core_position,2));\n\t }\n\t}\n\t\n\tprintf(\"\\n\");\n\tprintf(\" CONFIGURATION_XYZ_SC_INFO\\n\");\n\tprintf(\" %d\\t%d\\n\",sp_sys->number_of_classic_ion,sp_sys->number_of_sp_ion);\n\n\t// SHOW SHELL CORE POSITION BOTH\n\tfor(int n=0;nnumber_of_sp_ion+sp_sys->number_of_classic_ion;n++)\n\t{\n \t offset = n-sp_sys->number_of_classic_ion;\n\t if( n < sp_sys->number_of_classic_ion )\n\t {\n\t\tif( sp_sys->classic_ion[n].if_shell == SP_SUPPORT_FALSE )\n\t\t{\n\t\t\tfprintf(stdout,\"%3s%3s%12.6lf%12.6lf%12.6lf\\n\", sp_sys->classic_ion[n].atom_name,\"c\",\n\t\t\tgsl_vector_get(sp_sys->classic_ion[n].core_position,0), gsl_vector_get(sp_sys->classic_ion[n].core_position,1), gsl_vector_get(sp_sys->classic_ion[n].core_position,2));\n\t\t}\n\t\telse if( sp_sys->classic_ion[n].if_shell == SP_SUPPORT_TRUE )\n\t\t{\n\t\t\tfprintf(stdout,\"%3s%3s%12.6lf%12.6lf%12.6lf\\n\", sp_sys->classic_ion[n].atom_name,\"s\",\n\t\t\tgsl_vector_get(sp_sys->classic_ion[n].core_position,0), gsl_vector_get(sp_sys->classic_ion[n].core_position,1), gsl_vector_get(sp_sys->classic_ion[n].core_position,2));\n\t\t}\n\t }\n\t else // this is for printing sp-ions\n\t {\n\t\t offset = n - sp_sys->number_of_classic_ion;\n\t\t fprintf(stdout,\"%3s%15.6lf%12.6lf%12.6lf\\n\", sp_sys->sp_ion[offset].atom_name,\n\t\t\t gsl_vector_get(sp_sys->sp_ion[offset].core_position,0), gsl_vector_get(sp_sys->sp_ion[offset].core_position,1), gsl_vector_get(sp_sys->sp_ion[offset].core_position,2));\n\t }\n\t}\n\n\n\treturn;\n}\n\n\n/// DIIS_SUPPORT TOOLS\n\n/*\nint if_diis; \nint diis_max_depth;\nint diis_cur_depth;\n\ngsl_vector** diis_error_vector; // SAVE AS CIRCULAR QUEUE \ngsl_vector* diis_coefficient_vector;\ngsl_permutation* diis_ws_p; \ngsl_matrix* diis_error_matrix; \ngsl_matrix* diis_error_matrix_inv; \n*/\n\nvoid sp_cluster_support_diis_error_vector_queue_init( void* sp_sys_void )\n{\n sp_cluster_system* sp_sys = (sp_cluster_system*)sp_sys_void;\n sp_sys->diis_error_vector_queue_front = 0;\n sp_sys->diis_error_vector_queue_rear = 0;\n return;\n}\n\nint sp_cluster_support_diis_error_vector_queue_isfull( void* sp_sys_void )\n{ sp_cluster_system* sp_sys = (sp_cluster_system*)sp_sys_void;\n if( (sp_sys->diis_error_vector_queue_rear+1)%sp_sys->diis_max_depth == sp_sys->diis_error_vector_queue_front )\n return SP_SUPPORT_TRUE;\n else\n return SP_SUPPORT_FALSE;\n}\n\nint sp_cluster_support_diis_error_vector_queue_isempty( void* sp_sys_void )\n{ sp_cluster_system* sp_sys = (sp_cluster_system*)sp_sys_void;\n if( sp_sys->diis_error_vector_queue_front == sp_sys->diis_error_vector_queue_rear )\n return SP_SUPPORT_TRUE;\n else\n return SP_SUPPORT_FALSE;\n}\n\nvoid sp_cluster_support_diis_error_vector_enqueue( void* sp_sys_void )\n{\n sp_cluster_system* sp_sys = (sp_cluster_system*)sp_sys_void;\n double delta_evec[4];\n int low_idx;\n\n double delta_evec_sum = 0.;\n\n //if( !((sp_sys->diis_error_vector_queue_rear+1)%sp_sys->diis_max_depth == sp_sys->diis_error_vector_queue_front) ) // check if queue is full\n if( sp_cluster_support_diis_error_vector_queue_isfull( sp_sys ) == SP_SUPPORT_FALSE )\n {\n sp_sys->diis_error_vector_queue_rear = (sp_sys->diis_error_vector_queue_rear+1)%sp_sys->diis_max_depth; // rear index ++\n sp_sys->diis_cur_depth++;\n\n for(int i=0;inumber_of_sp_ion;i++)\n {\n low_idx = sp_cluster_support_get_lowest_state(sp_sys->sp_ion[i].eigen_value);\n\n // current eigenvector - (loaded) previous eigenvector_gs\n delta_evec[0] = gsl_matrix_get(sp_sys->sp_ion[i].eigen_vector,0,low_idx) - gsl_vector_get(sp_sys->sp_ion[i].eigen_vector_gs,0);\n delta_evec[1] = gsl_matrix_get(sp_sys->sp_ion[i].eigen_vector,1,low_idx) - gsl_vector_get(sp_sys->sp_ion[i].eigen_vector_gs,1);\n delta_evec[2] = gsl_matrix_get(sp_sys->sp_ion[i].eigen_vector,2,low_idx) - gsl_vector_get(sp_sys->sp_ion[i].eigen_vector_gs,2);\n delta_evec[3] = gsl_matrix_get(sp_sys->sp_ion[i].eigen_vector,3,low_idx) - gsl_vector_get(sp_sys->sp_ion[i].eigen_vector_gs,3);\n\n delta_evec_sum += delta_evec[0]*delta_evec[0] + delta_evec[1]*delta_evec[1] + delta_evec[2]*delta_evec[2] + delta_evec[3]*delta_evec[3];\n\n gsl_vector_set(sp_sys->diis_error_vector[ sp_sys->diis_error_vector_queue_rear ],i*4+0,delta_evec[0]);\n gsl_vector_set(sp_sys->diis_error_vector[ sp_sys->diis_error_vector_queue_rear ],i*4+1,delta_evec[0]);\n gsl_vector_set(sp_sys->diis_error_vector[ sp_sys->diis_error_vector_queue_rear ],i*4+2,delta_evec[0]);\n gsl_vector_set(sp_sys->diis_error_vector[ sp_sys->diis_error_vector_queue_rear ],i*4+3,delta_evec[0]);\n \n\n // loading .. previous eigen_vector_gs (note that the function 'sp_cluster_support_load_gs_eigenvector()' must be called before enqueue)\n gsl_vector_set(sp_sys->diis_prev_eigen_vector[ sp_sys->diis_error_vector_queue_rear ],i*4+0, gsl_vector_get(sp_sys->sp_ion[i].eigen_vector_gs,0));\n gsl_vector_set(sp_sys->diis_prev_eigen_vector[ sp_sys->diis_error_vector_queue_rear ],i*4+1, gsl_vector_get(sp_sys->sp_ion[i].eigen_vector_gs,1));\n gsl_vector_set(sp_sys->diis_prev_eigen_vector[ sp_sys->diis_error_vector_queue_rear ],i*4+2, gsl_vector_get(sp_sys->sp_ion[i].eigen_vector_gs,2));\n gsl_vector_set(sp_sys->diis_prev_eigen_vector[ sp_sys->diis_error_vector_queue_rear ],i*4+3, gsl_vector_get(sp_sys->sp_ion[i].eigen_vector_gs,3));\n\n #ifdef DEBUG_SUPPORT\n printf(\"\\ndelta evec\\n\");\n printf(\"%12.6lf%12.6lf%12.6lf%12.6lf\\n\",delta_evec[0],delta_evec[1],delta_evec[2],delta_evec[3]);\n printf(\"%12.6lf%12.6lf%12.6lf%12.6lf\\n\",\n gsl_matrix_get(sp_sys->sp_ion[i].eigen_vector,0,low_idx),\n gsl_matrix_get(sp_sys->sp_ion[i].eigen_vector,1,low_idx),\n gsl_matrix_get(sp_sys->sp_ion[i].eigen_vector,2,low_idx),\n gsl_matrix_get(sp_sys->sp_ion[i].eigen_vector,3,low_idx));\n #endif\n/*\n printf(\"%12.6lf%12.6lf%12.6lf%12.6lf\\n\",gsl_vector_get(sp_sys->diis_prev_eigen_vector[ sp_sys->diis_error_vector_queue_rear ], i*4 + 0 ),\n gsl_vector_get(sp_sys->diis_prev_eigen_vector[ sp_sys->diis_error_vector_queue_rear ], i*4 + 1 ),\n gsl_vector_get(sp_sys->diis_prev_eigen_vector[ sp_sys->diis_error_vector_queue_rear ], i*4 + 2 ),\n gsl_vector_get(sp_sys->diis_prev_eigen_vector[ sp_sys->diis_error_vector_queue_rear ], i*4 + 3 ));\n*/\n /* Note that the both,\n \n Error vector ( sp_sys->diis_error_vector )\n Prev evecs ( sp_sys->diis_prev_eigen_vector )\n\n Follows the form of (gsl_vector)v[i][j]\n\n v[i] ... 'i' -> index in the queue // queue is circular type, max dept is 'sp_sys->diis_max_depth'\n v[i][j] ... 'j' -> DATA, s_sp1, px_sp1, py_sp1, pz_sp1 // s_sp2, px_sp2, py_sp2, pz_sp2 // ....\n i.e., length of number_of_sp_ions * 4 (each lone pair ground-state MO saved with stride of 4)\n */\n }\n printf(\"delta_evec_sum: %12.8lf\\n\",sqrt(delta_evec_sum)/sp_sys->number_of_sp_ion);\n\n }\n return; // if queue is full do nothing\n} \n\nvoid sp_cluster_support_diis_error_vector_dequeue( void* sp_sys_void )\n{ sp_cluster_system* sp_sys = (sp_cluster_system*)sp_sys_void;\n if( sp_cluster_support_diis_error_vector_queue_isempty( sp_sys ) == SP_SUPPORT_FALSE )\n { sp_sys->diis_error_vector_queue_front = (sp_sys->diis_error_vector_queue_front+1)%sp_sys->diis_max_depth;\n sp_sys->diis_cur_depth--;\n }\n #ifdef DEBUG_SUPPORT\n const int front = sp_sys->diis_error_vector_queue_front;\n const int rear = sp_sys->diis_error_vector_queue_rear;\n printf(\"%d\\t%d\\n\",front,rear);\n #endif\n\n return; // if queue is empty do nothing\n}\n\ndouble sp_cluster_support_diis_get_error_vector_gnorm( void* sp_sys_void ) // returns latest .. i.e., the one at rear\n{ sp_cluster_system* sp_sys = (sp_cluster_system*)sp_sys_void;\n double ret;\n if( sp_cluster_support_diis_error_vector_queue_isempty( sp_sys ) == SP_SUPPORT_FALSE )\n { ret = gsl_blas_dnrm2( sp_sys->diis_error_vector[ sp_sys->diis_error_vector_queue_rear ] );\n return ret/sp_sys->number_of_sp_ion;\n }\n return 0.;\n}\n\nvoid sp_cluster_support_diis_solve_least_square_problem( void* sp_sys_void )\n{ sp_cluster_system* sp_sys = (sp_cluster_system*)sp_sys_void;\n\n // int count = front > rear ? (MAX - front + rear) : (rear - front);\n const int queue_capacity = sp_sys->diis_max_depth;\n const int front = sp_sys->diis_error_vector_queue_front;\n const int rear = sp_sys->diis_error_vector_queue_rear;\n const int cur_size = front > rear ? (queue_capacity - front + rear) : (rear - front); // number of elements in the queue (error_vector)\n \n/*\ngsl_vector* diis_coefficient_vector;\ngsl_permutation* diis_ws_p; \ngsl_matrix* diis_error_matrix; \ngsl_matrix* diis_error_matrix_inv; \n*/\n size_t len = cur_size + 1;\n\nprintf(\"\\n#### IN LSP SOLVER / len : %zu\\n\",len);\nprintf(\"ws size : ErrorMat / %zu %zu\\n\",sp_sys->diis_error_matrix->size1,sp_sys->diis_error_matrix->size2);\nprintf(\"cursize/max_depth/cur_depth : %4d%4d%4d\\n\", cur_size, sp_sys->diis_max_depth - 1, sp_sys->diis_cur_depth );\n //if( !(cur_size == (sp_sys->diis_max_depth - 1)) )\n //if( !(cur_size == (sp_sys->diis_max_depth)) )\n //if( !(len == (sp_sys->diis_max_depth)) )\n if( !(len == sp_sys->diis_error_matrix->size1) )\n { \nprintf(\"Resizing!!\\n\");\n // if current size is not same with actual max_depth in use ... i.e., max_depth - 1, since circular queue in use\n // have to resize the workspaces ... diis_ws_p (gsl_permutation*) / diis_error_matrix (gsl_matrix*) / diis_error_matrix_inv (gsl_matrix*) \n\n gsl_vector_free(sp_sys->diis_coefficient_vector);\n gsl_vector_free(sp_sys->diis_least_square_condition);\n gsl_permutation_free(sp_sys->diis_ws_p);\n gsl_matrix_free(sp_sys->diis_error_matrix);\n gsl_matrix_free(sp_sys->diis_error_matrix_inv);\n\n sp_sys->diis_coefficient_vector = gsl_vector_calloc(len);\n sp_sys->diis_least_square_condition = gsl_vector_calloc(len);\n sp_sys->diis_ws_p = gsl_permutation_calloc(len);\n sp_sys->diis_error_matrix = gsl_matrix_calloc(len,len);\n sp_sys->diis_error_matrix_inv = gsl_matrix_calloc(len,len); // len = cur_size (error_vector length) + 1 // 1 is to represent least square sense of coeff\n }\n\n int ii=0; int jj=0; // tags to get actual matrix indices !\n double elem_tmp;\n for(int i=(front+1)%queue_capacity; i!=(rear+1)%queue_capacity ; i=(i+1)%queue_capacity) // for loop circulate over queue elements\n {\n for(int j=(front+1)%queue_capacity; j!=(rear+1)%queue_capacity ; j=(j+1)%queue_capacity)\n { \n #ifdef DEBUG_SUPPORT\n printf(\"i,j / tag_i,tag_j : %d\\t%d / %d\\t%d\\n\",i,j,ii,jj);\n //printf(\"size1 / size2 : %d\\t%d\\n\", sp_sys->diis_error_matrix->size1, sp_sys->diis_error_matrix->size2);\n #endif\n\n gsl_blas_ddot(sp_sys->diis_error_vector[j],sp_sys->diis_error_vector[i],&elem_tmp);\n gsl_matrix_set(sp_sys->diis_error_matrix,ii,jj,elem_tmp);\n jj++;\n }\n jj=0;\n ii++;\n }\n printf(\"ERROR - 0 ?\\n\");\n ///// SET RESTS \n for(int i=0;idiis_error_matrix,i,len-1,-1.);\n gsl_matrix_set(sp_sys->diis_error_matrix,len-1,i,-1.); }\n printf(\"ERROR?\\n\");\n gsl_matrix_set(sp_sys->diis_error_matrix,len-1,len-1,0.);\n printf(\"ERROR?\\n\");\n\n ///// SET least Square Condition vector\n gsl_vector_set(sp_sys->diis_least_square_condition,len-1,-1.);\n\n //// calculate inverse\n int signum; // variable for LU_decomp\n\n #ifdef DEBUG_SUPPORT\n printf(\"ErrorMatrix\\n\");\n sp_cluster_support_matrix_view( sp_sys->diis_error_matrix );\n #endif\n\n /* Say,\n Error matrix E\n Coefficient Vector C\n RHS Least Square Condition L\n\n Need to find 'C' vector\n\n Solve : EC = L, i.e., C = E_Inverse L\n */\n\n gsl_linalg_LU_decomp(sp_sys->diis_error_matrix,sp_sys->diis_ws_p,&signum);\n gsl_linalg_LU_invert(sp_sys->diis_error_matrix,sp_sys->diis_ws_p,sp_sys->diis_error_matrix_inv); // invert is saved in 'sp_sys->diis_error_matrix_inv'\n // Inverse Found\n\n // int gsl_blas_dgemv(CBLAS_TRANSPOSE_t TransA, double alpha, const gsl_matrix *A, const gsl_vector *x, double beta, gsl_vector *y)\n gsl_blas_dgemv(CblasNoTrans,1.,sp_sys->diis_error_matrix_inv,sp_sys->diis_least_square_condition,0.,sp_sys->diis_coefficient_vector);\n // Solve LeaseSquare Problem Answer saved in 'sp_sys->diis_coefficient_vector'\n\n #ifdef DEBUG_SUPPORT\n //sp_cluster_support_vector_view( sp_sys->diis_least_square_condition );\n printf(\"coefficient vector, ignore the last dummy lambda value\\n\");\n sp_cluster_support_vector_view( sp_sys->diis_coefficient_vector );\n //sp_cluster_support_matrix_view( sp_sys->diis_error_matrix );\n printf(\"InverseMatrix\\n\");\n sp_cluster_support_matrix_view( sp_sys->diis_error_matrix_inv );\n printf(\"cursize/max_depth/cur_depth : %d\\t%d\\t%d\\n\", cur_size, sp_sys->diis_max_depth - 1, sp_sys->diis_cur_depth );\n\n \n\n printf(\" ---- FINALISE LEAST SQUARE SOLVER \\n\\n\");\n #endif\n return;\n}\n\n\nvoid sp_cluster_support_diis_least_square_result_update( void* sp_sys_void )\n{ sp_cluster_system* sp_sys = (sp_cluster_system*)sp_sys_void;\n int low_idx;\n int jj = 0;\n double cs, cx, cy, cz, norm_factor;\n\n const int queue_capacity = sp_sys->diis_max_depth;\n const int front = sp_sys->diis_error_vector_queue_front;\n const int rear = sp_sys->diis_error_vector_queue_rear;\n\n for(int i=0;inumber_of_sp_ion;i++)\n {\n low_idx = sp_cluster_support_get_lowest_state(sp_sys->sp_ion[i].eigen_value);\n \n // results are in 'sp_sys->diis_coefficient_vector' ... data structure sp_sys->diis_coefficient_vector->size or 'stride'?\n // size can also be obtained by 'sp_sys->diis_cur_depth'\n\n jj = 0;\n cs = 0.; cx = 0.; cy = 0.; cz = 0.;\n\n for(int j=(front+1)%queue_capacity; j!=(rear+1)%queue_capacity ; j=(j+1)%queue_capacity)\n { \n cs += gsl_vector_get( sp_sys->diis_coefficient_vector,jj) * gsl_vector_get(sp_sys->diis_prev_eigen_vector[j],i*4+0);\n cx += gsl_vector_get( sp_sys->diis_coefficient_vector,jj) * gsl_vector_get(sp_sys->diis_prev_eigen_vector[j],i*4+1);\n cy += gsl_vector_get( sp_sys->diis_coefficient_vector,jj) * gsl_vector_get(sp_sys->diis_prev_eigen_vector[j],i*4+2);\n cz += gsl_vector_get( sp_sys->diis_coefficient_vector,jj) * gsl_vector_get(sp_sys->diis_prev_eigen_vector[j],i*4+3);\n jj++;\n\n printf(\"index j / tag jj: %d\\t%d\\n\",j,jj);\n }\n \n#ifdef DEBUG_SUPPORT\nprintf(\"%dth\\t%12.4lf%12.4lf%12.4lf%12.4lf%20.4lf\\n\",i+1,cs,cx,cy,cz,sqrt(cs*cs+cx*cx+cy*cy+cz*cz));\n#endif \n norm_factor = sqrt(cs*cs+cx*cx+cy*cy+cz*cz); \n norm_factor = 1.;\n\n gsl_matrix_set(sp_sys->sp_ion[i].eigen_vector,0,low_idx,cs/norm_factor);\n gsl_matrix_set(sp_sys->sp_ion[i].eigen_vector,1,low_idx,cx/norm_factor);\n gsl_matrix_set(sp_sys->sp_ion[i].eigen_vector,2,low_idx,cy/norm_factor);\n gsl_matrix_set(sp_sys->sp_ion[i].eigen_vector,3,low_idx,cz/norm_factor);\n // set eigenvector ... updated!!!\n\n // finish up the rest ...\n }\n\n\n return;\n}\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n", "meta": {"hexsha": "f860481510256732fa35f546e67ba1a996d7642b", "size": 28009, "ext": "c", "lang": "C", "max_stars_repo_path": "src/sp_cluster_support.c", "max_stars_repo_name": "sweetmixture/SLAM_2.2.1_snapshot", "max_stars_repo_head_hexsha": "60335c37ce75b82f6589c67f3a1c1be37decfd71", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2022-02-02T07:01:42.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-02T07:01:42.000Z", "max_issues_repo_path": "src/sp_cluster_support.c", "max_issues_repo_name": "sweetmixture/SLAM_2.2.1_snapshot", "max_issues_repo_head_hexsha": "60335c37ce75b82f6589c67f3a1c1be37decfd71", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/sp_cluster_support.c", "max_forks_repo_name": "sweetmixture/SLAM_2.2.1_snapshot", "max_forks_repo_head_hexsha": "60335c37ce75b82f6589c67f3a1c1be37decfd71", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.2282913165, "max_line_length": 175, "alphanum_fraction": 0.6490770824, "num_tokens": 8568, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8459424295406088, "lm_q2_score": 0.6334102567576901, "lm_q1q2_score": 0.5358286114975412}} {"text": "#pragma once\n#include \n#include \n#include \n#include \n#include \n#include \"DataFrame.h\"\n#include \"Ops.h\"\n\nnamespace adsl {\n\n\t// Evaluate the result of a fit at a given point based on the DataFrame description\n\t// double <- DataFrame\n\t/*\n\tauto evalFit = [](double t) {\n\t\tauto retFunc = [t](DataFrame& df) {\n\t\t\tif (df.getDesc() == \"gsl_fit_linear\") {\n\t\t\t\tdouble m = df + select({ \"slope\" }) + getFirst + single();\n\t\t\t\tdouble b = df + select({ \"intercept\" }) + getFirst + single();\n\t\t\t\treturn (m * t) + b;\n\t\t\t}\n\t\t\telse {\n\t\t\t\treturn (double)NAN;\n\t\t\t}\n\t\t};\n\t\treturn retFunc;\n\t};\n\t*/\n\n\t// Perform a linear fit using gsl_fit_linear\n\t// df must have only 2 columns\n\t// DataFrame <- DataFrame\n\tauto fitLinear = [](DataFrame& df) {\n\t\tif (df.getCols() == 2) {\n\t\t\tif (df.getData()[0].type != DBL || df.getData()[1].type != DBL) {\n\t\t\t\tstd::cout << \"[fitLinear] <> At least one of the columns is not of type DBL \" << std::endl;\n\t\t\t\texit(1);\n\t\t\t\tDataFrame empty_df;\n\t\t\t\treturn empty_df;\n\t\t\t}\n\t\t\t// Setup\n\t\t\tDataFrame ret;\n\t\t\tauto xData = df.getData()[0].toVec_dbl();\n\t\t\tauto yData = df.getData()[1].toVec_dbl();\n\t\t\tsize_t length = xData.size();\n\t\t\tdouble* x;\n\t\t\tdouble* y;\n\t\t\tx = (double*)malloc(length * sizeof(double));\n\t\t\ty = (double*)malloc(length * sizeof(double));\n\t\t\tstd::copy(xData.begin(), xData.end(), x);\n\t\t\tstd::copy(yData.begin(), yData.end(), y);\n\n\t\t\t// Fitting & r-squared\n\t\t\tdouble c0, c1, cov00, cov01, cov11, sumsq;\n\t\t\tgsl_fit_linear(x, 1, y, 1, length, &c0, &c1, &cov00, &cov01, &cov11, &sumsq);\n\t\t\tvd tmpSlope = {c1};\n\t\t\tDataList slope(&tmpSlope, DataType::DBL, \"slope\");\n\t\t\tvd tmpIntercept = {c0};\n\t\t\tDataList intercept(&tmpIntercept, DataType::DBL, \"intercept\");\n\t\t\tvd tmpRsqrd = { gsl_stats_correlation(x, 1, y, 1, length) };\n\t\t\tDataList rsqrd(&tmpRsqrd, DataType::DBL, \"r-squared\");\n\n\t\t\t// Clean up\n\t\t\tfree(x);\n\t\t\tfree(y);\n\n\t\t\t// Return\n\t\t\tret.addCol(slope);\n\t\t\tret.addCol(intercept);\n\t\t\tret.addCol(rsqrd);\n\t\t\tret.setDesc(\"gsl_fit_linear\");\n\t\t\treturn ret;\n\t\t}\n\t\telse {\n\t\t\tstd::cout << \"[fitLinear] <> DataFrame doesn't have two columns; has \" << df.getCols() << std::endl;\n\t\t\texit(1);\n\t\t\tDataFrame empty_df;\n\t\t\treturn empty_df;\n\t\t}\n\t};\n\n\t// TODO: add more fit types\n\n\t// Calculate the moving average of a DataList\n\t// DataList <- DataList <- double\n\t/*\n\tauto SMA = [](double period) {\n\t\tauto retFunc = [period](DataList& dl) {\n\t\t\tDataFrame ret;\n\t\t\tdouble* input;\n\t\t\tdouble* output;\n\t\t\t// TODO\n\t\t};\n\t\treturn retFunc;\n\t};\n\t*/\n\n\n }", "meta": {"hexsha": "dc869e308039c4a19f10d5ceed6a10b1097eb558", "size": 2532, "ext": "h", "lang": "C", "max_stars_repo_path": "Includes/GSL.h", "max_stars_repo_name": "ianfr/adsl-cpp", "max_stars_repo_head_hexsha": "f1c92598a49dfa03fa7938abbdc990c5f7877579", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Includes/GSL.h", "max_issues_repo_name": "ianfr/adsl-cpp", "max_issues_repo_head_hexsha": "f1c92598a49dfa03fa7938abbdc990c5f7877579", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": 13.0, "max_issues_repo_issues_event_min_datetime": "2021-08-20T20:18:58.000Z", "max_issues_repo_issues_event_max_datetime": "2021-12-31T20:11:22.000Z", "max_forks_repo_path": "Includes/GSL.h", "max_forks_repo_name": "ianfr/adsl-cpp", "max_forks_repo_head_hexsha": "f1c92598a49dfa03fa7938abbdc990c5f7877579", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 25.5757575758, "max_line_length": 110, "alphanum_fraction": 0.6141390205, "num_tokens": 806, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8267117940706734, "lm_q2_score": 0.6477982179521103, "lm_q1q2_score": 0.5355424269589742}} {"text": "/* linalg/qrpt.c\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\n#include \"apply_givens.c\"\n\n/* Factorise a general M x N matrix A into\n *\n * A P = Q R\n *\n * where Q is orthogonal (M x M) and R is upper triangular (M x N).\n * When A is rank deficient, r = rank(A) < n, then the permutation is\n * used to ensure that the lower n - r rows of R are zero and the first\n * r columns of Q form an orthonormal basis for A.\n *\n * Q is stored as a packed set of Householder transformations in the\n * strict lower triangular part of the input matrix.\n *\n * R is stored in the diagonal and upper triangle of the input matrix.\n *\n * P: column j of P is column k of the identity matrix, where k =\n * permutation->data[j]\n *\n * The full matrix for Q can be obtained as the product\n *\n * Q = Q_k .. Q_2 Q_1\n *\n * where k = MIN(M,N) and\n *\n * Q_i = (I - tau_i * v_i * v_i')\n *\n * and where v_i is a Householder vector\n *\n * v_i = [1, m(i+1,i), m(i+2,i), ... , m(M,i)]\n *\n * This storage scheme is the same as in LAPACK. See LAPACK's\n * dgeqpf.f for details.\n * \n */\n\nint\ngsl_linalg_QRPT_decomp (gsl_matrix * A, gsl_vector * tau, gsl_permutation * p, int *signum, gsl_vector * norm)\n{\n const size_t M = A->size1;\n const size_t N = A->size2;\n\n if (tau->size != GSL_MIN (M, N))\n {\n GSL_ERROR (\"size of tau must be MIN(M,N)\", GSL_EBADLEN);\n }\n else if (p->size != N)\n {\n GSL_ERROR (\"permutation size must be N\", GSL_EBADLEN);\n }\n else if (norm->size != N)\n {\n GSL_ERROR (\"norm size must be N\", GSL_EBADLEN);\n }\n else\n {\n size_t i;\n\n *signum = 1;\n\n gsl_permutation_init (p); /* set to identity */\n\n /* Compute column norms and store in workspace */\n\n for (i = 0; i < N; i++)\n {\n gsl_vector_view c = gsl_matrix_column (A, i);\n double x = gsl_blas_dnrm2 (&c.vector);\n gsl_vector_set (norm, i, x);\n }\n\n for (i = 0; i < GSL_MIN (M, N); i++)\n {\n /* Bring the column of largest norm into the pivot position */\n\n double max_norm = gsl_vector_get(norm, i);\n size_t j, kmax = i;\n\n for (j = i + 1; j < N; j++)\n {\n double x = gsl_vector_get (norm, j);\n\n if (x > max_norm)\n {\n max_norm = x;\n kmax = j;\n }\n }\n\n if (kmax != i)\n {\n gsl_matrix_swap_columns (A, i, kmax);\n gsl_permutation_swap (p, i, kmax);\n gsl_vector_swap_elements(norm,i,kmax);\n\n (*signum) = -(*signum);\n }\n\n /* Compute the Householder transformation to reduce the j-th\n column of the matrix to a multiple of the j-th unit vector */\n\n {\n gsl_vector_view c_full = gsl_matrix_column (A, i);\n gsl_vector_view c = gsl_vector_subvector (&c_full.vector, \n i, M - i);\n double tau_i = gsl_linalg_householder_transform (&c.vector);\n\n gsl_vector_set (tau, i, tau_i);\n\n /* Apply the transformation to the remaining columns */\n\n if (i + 1 < N)\n {\n gsl_matrix_view m = gsl_matrix_submatrix (A, i, i + 1, M - i, N - (i+1));\n\n gsl_linalg_householder_hm (tau_i, &c.vector, &m.matrix);\n }\n }\n\n /* Update the norms of the remaining columns too */\n\n if (i + 1 < M) \n {\n for (j = i + 1; j < N; j++)\n {\n double x = gsl_vector_get (norm, j);\n\n if (x > 0.0)\n {\n double y = 0;\n double temp= gsl_matrix_get (A, i, j) / x;\n \n if (fabs (temp) >= 1)\n y = 0.0;\n else\n y = x * sqrt (1 - temp * temp);\n \n /* recompute norm to prevent loss of accuracy */\n\n if (fabs (y / x) < sqrt (20.0) * GSL_SQRT_DBL_EPSILON)\n {\n gsl_vector_view c_full = gsl_matrix_column (A, j);\n gsl_vector_view c = \n gsl_vector_subvector(&c_full.vector,\n i+1, M - (i+1));\n y = gsl_blas_dnrm2 (&c.vector);\n }\n \n gsl_vector_set (norm, j, y);\n }\n }\n }\n }\n\n return GSL_SUCCESS;\n }\n}\n\nint\ngsl_linalg_QRPT_decomp2 (const gsl_matrix * A, gsl_matrix * q, gsl_matrix * r, gsl_vector * tau, gsl_permutation * p, int *signum, gsl_vector * norm)\n{\n const size_t M = A->size1;\n const size_t N = A->size2;\n\n if (q->size1 != M || q->size2 !=M) \n {\n GSL_ERROR (\"q must be M x M\", GSL_EBADLEN);\n }\n else if (r->size1 != M || r->size2 !=N)\n {\n GSL_ERROR (\"r must be M x N\", GSL_EBADLEN);\n }\n else if (tau->size != GSL_MIN (M, N))\n {\n GSL_ERROR (\"size of tau must be MIN(M,N)\", GSL_EBADLEN);\n }\n else if (p->size != N)\n {\n GSL_ERROR (\"permutation size must be N\", GSL_EBADLEN);\n }\n else if (norm->size != N)\n {\n GSL_ERROR (\"norm size must be N\", GSL_EBADLEN);\n }\n\n gsl_matrix_memcpy (r, A);\n\n gsl_linalg_QRPT_decomp (r, tau, p, signum, norm);\n\n /* FIXME: aliased arguments depends on behavior of unpack routine! */\n\n gsl_linalg_QR_unpack (r, tau, q, r);\n\n return GSL_SUCCESS;\n}\n\n\n/* Solves the system A x = b using the Q R P^T factorisation,\n\n R z = Q^T b\n\n x = P z;\n\n to obtain x. Based on SLATEC code. */\n\nint\ngsl_linalg_QRPT_solve (const gsl_matrix * QR,\n const gsl_vector * tau,\n const gsl_permutation * p,\n const gsl_vector * b,\n gsl_vector * x)\n{\n if (QR->size1 != QR->size2)\n {\n GSL_ERROR (\"QR matrix must be square\", GSL_ENOTSQR);\n }\n else if (QR->size1 != p->size)\n {\n GSL_ERROR (\"matrix size must match permutation size\", GSL_EBADLEN);\n }\n else if (QR->size1 != b->size)\n {\n GSL_ERROR (\"matrix size must match b size\", GSL_EBADLEN);\n }\n else if (QR->size2 != x->size)\n {\n GSL_ERROR (\"matrix size must match solution size\", GSL_EBADLEN);\n }\n else\n {\n gsl_vector_memcpy (x, b);\n\n gsl_linalg_QRPT_svx (QR, tau, p, x);\n \n return GSL_SUCCESS;\n }\n}\n\nint\ngsl_linalg_QRPT_svx (const gsl_matrix * QR,\n const gsl_vector * tau,\n const gsl_permutation * p,\n gsl_vector * x)\n{\n if (QR->size1 != QR->size2)\n {\n GSL_ERROR (\"QR matrix must be square\", GSL_ENOTSQR);\n }\n else if (QR->size1 != p->size)\n {\n GSL_ERROR (\"matrix size must match permutation size\", GSL_EBADLEN);\n }\n else if (QR->size2 != x->size)\n {\n GSL_ERROR (\"matrix size must match solution size\", GSL_EBADLEN);\n }\n else\n {\n /* compute sol = Q^T b */\n\n gsl_linalg_QR_QTvec (QR, tau, x);\n\n /* Solve R x = sol, storing x inplace in sol */\n\n gsl_blas_dtrsv (CblasUpper, CblasNoTrans, CblasNonUnit, QR, x);\n\n gsl_permute_vector_inverse (p, x);\n\n return GSL_SUCCESS;\n }\n}\n\n/* Find the least squares solution to the overdetermined system \n *\n * A x = b \n * \n * for M >= N using the QRPT factorization A P = Q R. Assumes\n * A has full column rank.\n */\n\nint\ngsl_linalg_QRPT_lssolve (const gsl_matrix * QR, const gsl_vector * tau, const gsl_permutation * p,\n const gsl_vector * b, gsl_vector * x, gsl_vector * residual)\n{\n const size_t N = QR->size2;\n int status = gsl_linalg_QRPT_lssolve2(QR, tau, p, b, N, x, residual);\n return status;\n}\n\n/* Find the least squares solution to the overdetermined system \n *\n * A x = b \n * \n * for M >= N using the QRPT factorization A P = Q R, where A\n * is assumed rank deficient with a given rank.\n */\n\nint\ngsl_linalg_QRPT_lssolve2 (const gsl_matrix * QR, const gsl_vector * tau, const gsl_permutation * p,\n const gsl_vector * b, const size_t rank, gsl_vector * x, gsl_vector * residual)\n{\n const size_t M = QR->size1;\n const size_t N = QR->size2;\n\n if (M < N)\n {\n GSL_ERROR (\"QR matrix must have M>=N\", GSL_EBADLEN);\n }\n else if (M != b->size)\n {\n GSL_ERROR (\"matrix size must match b size\", GSL_EBADLEN);\n }\n else if (rank == 0 || rank > N)\n {\n GSL_ERROR (\"rank must have 0 < rank <= N\", GSL_EBADLEN);\n }\n else if (N != x->size)\n {\n GSL_ERROR (\"matrix size must match solution size\", GSL_EBADLEN);\n }\n else if (M != residual->size)\n {\n GSL_ERROR (\"matrix size must match residual size\", GSL_EBADLEN);\n }\n else\n {\n gsl_matrix_const_view R11 = gsl_matrix_const_submatrix (QR, 0, 0, rank, rank);\n gsl_vector_view QTb1 = gsl_vector_subvector(residual, 0, rank);\n gsl_vector_view x1 = gsl_vector_subvector(x, 0, rank);\n size_t i;\n\n /* compute work = Q^T b */\n gsl_vector_memcpy(residual, b);\n gsl_linalg_QR_QTvec (QR, tau, residual);\n\n /* solve R_{11} x(1:r) = [Q^T b](1:r) */\n gsl_vector_memcpy(&(x1.vector), &(QTb1.vector));\n gsl_blas_dtrsv (CblasUpper, CblasNoTrans, CblasNonUnit, &(R11.matrix), &(x1.vector));\n\n /* x(r+1:N) = 0 */\n for (i = rank; i < N; ++i)\n gsl_vector_set(x, i, 0.0);\n\n /* compute x = P y */\n gsl_permute_vector_inverse (p, x);\n\n /* compute residual = b - A x = Q (Q^T b - R x) */\n gsl_vector_set_zero(&(QTb1.vector));\n gsl_linalg_QR_Qvec(QR, tau, residual);\n\n return GSL_SUCCESS;\n }\n}\n\nint\ngsl_linalg_QRPT_QRsolve (const gsl_matrix * Q, const gsl_matrix * R,\n const gsl_permutation * p,\n const gsl_vector * b,\n gsl_vector * x)\n{\n if (Q->size1 != Q->size2 || R->size1 != R->size2)\n {\n return GSL_ENOTSQR;\n }\n else if (Q->size1 != p->size || Q->size1 != R->size1\n || Q->size1 != b->size)\n {\n return GSL_EBADLEN;\n }\n else\n {\n /* compute b' = Q^T b */\n\n gsl_blas_dgemv (CblasTrans, 1.0, Q, b, 0.0, x);\n\n /* Solve R x = b', storing x inplace */\n\n gsl_blas_dtrsv (CblasUpper, CblasNoTrans, CblasNonUnit, R, x);\n\n /* Apply permutation to solution in place */\n\n gsl_permute_vector_inverse (p, x);\n\n return GSL_SUCCESS;\n }\n}\n\nint\ngsl_linalg_QRPT_Rsolve (const gsl_matrix * QR,\n const gsl_permutation * p,\n const gsl_vector * b,\n gsl_vector * x)\n{\n if (QR->size1 != QR->size2)\n {\n GSL_ERROR (\"QR matrix must be square\", GSL_ENOTSQR);\n }\n else if (QR->size1 != b->size)\n {\n GSL_ERROR (\"matrix size must match b size\", GSL_EBADLEN);\n }\n else if (QR->size2 != x->size)\n {\n GSL_ERROR (\"matrix size must match x size\", GSL_EBADLEN);\n }\n else if (p->size != x->size)\n {\n GSL_ERROR (\"permutation size must match x size\", GSL_EBADLEN);\n }\n else\n {\n /* Copy x <- b */\n\n gsl_vector_memcpy (x, b);\n\n /* Solve R x = b, storing x inplace */\n\n gsl_blas_dtrsv (CblasUpper, CblasNoTrans, CblasNonUnit, QR, x);\n\n gsl_permute_vector_inverse (p, x);\n\n return GSL_SUCCESS;\n }\n}\n\n\nint\ngsl_linalg_QRPT_Rsvx (const gsl_matrix * QR,\n const gsl_permutation * p,\n gsl_vector * x)\n{\n if (QR->size1 != QR->size2)\n {\n GSL_ERROR (\"QR matrix must be square\", GSL_ENOTSQR);\n }\n else if (QR->size2 != x->size)\n {\n GSL_ERROR (\"matrix size must match x size\", GSL_EBADLEN);\n }\n else if (p->size != x->size)\n {\n GSL_ERROR (\"permutation size must match x size\", GSL_EBADLEN);\n }\n else\n {\n /* Solve R x = b, storing x inplace */\n\n gsl_blas_dtrsv (CblasUpper, CblasNoTrans, CblasNonUnit, QR, x);\n\n gsl_permute_vector_inverse (p, x);\n\n return GSL_SUCCESS;\n }\n}\n\n\n\n/* Update a Q R P^T factorisation for A P= Q R , A' = A + u v^T,\n\n Q' R' P^-1 = QR P^-1 + u v^T\n = Q (R + Q^T u v^T P ) P^-1\n = Q (R + w v^T P) P^-1\n\n where w = Q^T u.\n\n Algorithm from Golub and Van Loan, \"Matrix Computations\", Section\n 12.5 (Updating Matrix Factorizations, Rank-One Changes) */\n\nint\ngsl_linalg_QRPT_update (gsl_matrix * Q, gsl_matrix * R,\n const gsl_permutation * p,\n gsl_vector * w, const gsl_vector * v)\n{\n const size_t M = R->size1;\n const size_t N = R->size2;\n\n if (Q->size1 != M || Q->size2 != M)\n {\n GSL_ERROR (\"Q matrix must be M x M if R is M x N\", GSL_ENOTSQR);\n }\n else if (w->size != M)\n {\n GSL_ERROR (\"w must be length M if R is M x N\", GSL_EBADLEN);\n }\n else if (v->size != N)\n {\n GSL_ERROR (\"v must be length N if R is M x N\", GSL_EBADLEN);\n }\n else\n {\n size_t j, k;\n double w0;\n\n /* Apply Given's rotations to reduce w to (|w|, 0, 0, ... , 0) \n\n J_1^T .... J_(n-1)^T w = +/- |w| e_1\n\n simultaneously applied to R, H = J_1^T ... J^T_(n-1) R\n so that H is upper Hessenberg. (12.5.2) */\n\n for (k = M - 1; k > 0; k--)\n {\n double c, s;\n double wk = gsl_vector_get (w, k);\n double wkm1 = gsl_vector_get (w, k - 1);\n\n gsl_linalg_givens (wkm1, wk, &c, &s);\n gsl_linalg_givens_gv (w, k - 1, k, c, s);\n apply_givens_qr (M, N, Q, R, k - 1, k, c, s);\n }\n\n w0 = gsl_vector_get (w, 0);\n\n /* Add in w v^T (Equation 12.5.3) */\n\n for (j = 0; j < N; j++)\n {\n double r0j = gsl_matrix_get (R, 0, j);\n size_t p_j = gsl_permutation_get (p, j);\n double vj = gsl_vector_get (v, p_j);\n gsl_matrix_set (R, 0, j, r0j + w0 * vj);\n }\n\n /* Apply Givens transformations R' = G_(n-1)^T ... G_1^T H \n Equation 12.5.4 */\n\n for (k = 1; k < GSL_MIN(M,N+1); k++)\n {\n double c, s;\n double diag = gsl_matrix_get (R, k - 1, k - 1);\n double offdiag = gsl_matrix_get (R, k, k - 1);\n\n gsl_linalg_givens (diag, offdiag, &c, &s);\n apply_givens_qr (M, N, Q, R, k - 1, k, c, s);\n\n gsl_matrix_set (R, k, k - 1, 0.0); /* exact zero of G^T */\n }\n\n return GSL_SUCCESS;\n }\n}\n\n/*\ngsl_linalg_QRPT_rank()\n Estimate rank of triangular matrix from QRPT decomposition\n\nInputs: QR - QRPT decomposed matrix\n tol - tolerance for rank determination; if < 0,\n a default value is used:\n 20 * (M + N) * eps(max(|diag(R)|))\n\nReturn: rank estimate\n*/\n\nsize_t\ngsl_linalg_QRPT_rank (const gsl_matrix * QR, const double tol)\n{\n const size_t M = QR->size1;\n const size_t N = QR->size2;\n gsl_vector_const_view diag = gsl_matrix_const_diagonal(QR);\n double eps;\n size_t i;\n size_t r = 0;\n\n if (tol < 0.0)\n {\n double min, max, absmax;\n int ee;\n\n gsl_vector_minmax(&diag.vector, &min, &max);\n absmax = GSL_MAX(fabs(min), fabs(max));\n ee = (int) (log(absmax) / M_LN2); /* can't use log2 since its not ANSI */\n\n eps = 20.0 * (M + N) * pow(2.0, (double) ee) * GSL_DBL_EPSILON;\n }\n else\n eps = tol;\n\n /* count number of diagonal elements with |di| > eps */\n for (i = 0; i < GSL_MIN(M, N); ++i)\n {\n double di = gsl_vector_get(&diag.vector, i);\n if (fabs(di) > eps)\n ++r;\n }\n\n return r;\n}\n\nint\ngsl_linalg_QRPT_rcond(const gsl_matrix * QR, double * rcond, gsl_vector * work)\n{\n const size_t M = QR->size1;\n const size_t N = QR->size2;\n\n if (M < N)\n {\n GSL_ERROR (\"M must be >= N\", GSL_EBADLEN);\n }\n else if (work->size != 3 * N)\n {\n GSL_ERROR (\"work vector must have length 3*N\", GSL_EBADLEN);\n }\n else\n {\n gsl_matrix_const_view R = gsl_matrix_const_submatrix (QR, 0, 0, N, N);\n int status;\n\n status = gsl_linalg_tri_upper_rcond(&R.matrix, rcond, work);\n\n return status;\n }\n}\n", "meta": {"hexsha": "df8b062a4975dc05e88a275a64707cdb1fc8af48", "size": 17042, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.4/linalg/qrpt.c", "max_stars_repo_name": "peterahrens/FillEstimationIPDPS2017", "max_stars_repo_head_hexsha": "857b6ee8866a2950aa5721d575d2d7d0797c4302", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-01-13T05:01:59.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-13T05:01:59.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/linalg/qrpt.c", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/linalg/qrpt.c", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.4627329193, "max_line_length": 149, "alphanum_fraction": 0.5443609905, "num_tokens": 4997, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7690802476562641, "lm_q2_score": 0.6959583250334526, "lm_q1q2_score": 0.5352478009751664}} {"text": "#include \n#include \n\n#include \"csm_all.h\"\n\n#include \n\n\nvoid find_neighbours(LDP ld, int i, int max_num, int*indexes, size_t*num_found);\nvoid filter_orientation(double theta0, double rho0, size_t n,\n \tconst double*thetas, const double*rhos, double *alpha, double*cov0_alpha );\n\n/** Requires the \"cluster\" field to be set */\nvoid ld_compute_orientation(LDP ld, int size_neighbourhood, double sigma) {\n\tint i;\n\tfor(i=0;inrays;i++){\n\t\tif(!ld_valid_ray(ld,i) || (ld->cluster[i] == -1)) {\n\t\t\tld->alpha[i] = GSL_NAN;\n\t\t\tld->cov_alpha[i] = GSL_NAN;\n\t\t\tld->alpha_valid[i] = 0;\n\t\t\tcontinue;\n\t\t}\n\t\t\n\t\tint neighbours[size_neighbourhood*2];\n\t\tsize_t num_neighbours;\n\t\tfind_neighbours(ld, i, size_neighbourhood, neighbours, &num_neighbours);\n\n\t\tif(0==num_neighbours) {\n\t\t\tld->alpha[i] = GSL_NAN;\n\t\t\tld->cov_alpha[i] = GSL_NAN;\n\t\t\tld->alpha_valid[i] = 0;\n\t\t\tcontinue;\n\t\t}\n\n/*\t\tprintf(\"orientation for i=%d:\\n\",i); */\n\t\tdouble thetas[num_neighbours];\n\t\tdouble readings[num_neighbours];\n\t\tsize_t a=0; \n\t\tfor(a=0;atheta[neighbours[a]];\n\t\t\treadings[a] = ld->readings[neighbours[a]];\n\t\t\t/* printf(\" j = %d theta = %f rho = %f\\n\", neighbours[a], thetas[a],readings[a]); */\n\t\t}\n\t\t\n\t\tdouble alpha=42, cov0_alpha=32;\n\t\tfilter_orientation(ld->theta[i],ld->readings[i],num_neighbours,\n\t\t\tthetas,readings,&alpha,&cov0_alpha);\n\t\t\n\t\tif(gsl_isnan(alpha)) {\n\t\t\tld->alpha[i] = GSL_NAN;\n\t\t\tld->cov_alpha[i] = GSL_NAN;\n\t\t\tld->alpha_valid[i] = 0;\n\t\t} else { \n\t\t\tld->alpha[i] = alpha;\n\t\t\tld->cov_alpha[i] = cov0_alpha * square(sigma);\n\t\t\tld->alpha_valid[i] = 1;\n\t\t}\n\t\t/* printf(\"---------- i = %d alpha = %f sigma=%f cov_alpha = %f\\n\", i, alpha, ld->cov_alpha[i]);*/\n\t}\n}\n\n/** A very cool algorithm for finding the orientation */\n\nvoid filter_orientation(double theta0, double rho0, size_t n,\n \tconst double*thetas, const double*rhos, double *alpha, double*cov0_alpha ) {\n\t\n\tegsl_push();\n\t/* Y = L x + R epsilon */\n\tval Y = zeros(n,1);\n\tval L = ones(n,1);\n\tval R = zeros(n,n+1);\n\n \tsize_t i; for(i=0;i0)\n\t\t*alpha = *alpha + M_PI;\n\t\n\tdouble dalpha_df1 = rho0 / (square(rho0) + square(f1));\n\tdouble dalpha_drho = -f1 / (square(rho0) + square(f1));\n\t\n\t*cov0_alpha\t= square(dalpha_df1) * cov_f1 + square(dalpha_drho);\n\n\n\tif(gsl_isnan(*alpha)) {\n\t\tegsl_print(\"Y\",Y);\n\t\tegsl_print(\"L\",L);\n\t\tegsl_print(\"R\",R);\n\t\tegsl_print(\"eRinv\",eRinv);\n\t\tegsl_print(\"vcov_f1\",vcov_f1);\n\t\t\n\t\tprintf(\" f1 = %f cov =%f \\n\", f1,cov_f1);\n\t\tprintf(\" f1/rho = %f \\n\", f1/rho0);\n\t\tprintf(\" atan = %f \\n\", atan(f1/rho0));\n\t\tprintf(\" theta0= %f \\n\", theta0);\n\t}\n\t\n\tegsl_pop();\n/*\n//\tprintf(\"dalpha_df1 = %f dalpha_drho = %f\\n\",dalpha_df1,dalpha_drho);\n//\tprintf(\"f1 = %f covf1 = %f alpha = %f cov_alpha = %f\\n \",f1,cov_f1,*alpha,*cov0_alpha);\n//\tprintf(\"sotto = %f\\n \",(square(rho0) + square(f1)));\n\t\n//\tprintf(\" alpha = %f sigma= %f°\\n\", *alpha, rad2deg(0.01*sqrt(*cov0_alpha)));\n\n\tprintf(\"l= \");\n\tgsl_matrix_fprintf(stdout, l, \"%f\");\n\tprintf(\"\\ny= \");\n\tgsl_matrix_fprintf(stdout, y, \"%f\");\n\tprintf(\"\\nr= \");\n\tgsl_matrix_fprintf(stdout, r, \"%f\");\n\tprintf(\"\\ninv(r*r)= \");\n\tgsl_matrix_fprintf(stdout, Rinv, \"%f\");\n\tprintf(\"\\nf1 = %lf \",f1);\n\tprintf(\"\\ncov_f1 = %lf \",cov_f1);\n*/\n}\n\n/* indexes: an array of size \"max_num*2\" */\nvoid find_neighbours(LDP ld, int i, int max_num, int*indexes, size_t*num_found) {\n\t*num_found = 0;\n\t\n\tint up = i; \n\twhile ((up+1 <= i+max_num) && (up+1nrays) && ld_valid_ray(ld,up+1)\n\t\t\t&& (ld->cluster[up+1] == ld->cluster[i])) {\n\t\tup+=1; \n\t\tindexes[(*num_found)++] = up;\n\t}\n\tint down = i; \n\twhile ((down >= i-max_num) && (down-1>=0) && ld_valid_ray(ld,down-1) && \n\t\t\t(ld->cluster[down-1] == ld->cluster[i])) {\n\t\tdown-=1;\n\t\tindexes[(*num_found)++] = down;\n\t}\n}\n\n\n", "meta": {"hexsha": "5c3eb8998d50b87ba69b2afd2ca6e6c4d08eda13", "size": 4208, "ext": "c", "lang": "C", "max_stars_repo_path": "src/csm/sm/csm/orientation.c", "max_stars_repo_name": "alecone/ROS_project", "max_stars_repo_head_hexsha": "f058fb0bc5c4c9b1a590b7536f75b83af35b7785", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/csm/sm/csm/orientation.c", "max_issues_repo_name": "alecone/ROS_project", "max_issues_repo_head_hexsha": "f058fb0bc5c4c9b1a590b7536f75b83af35b7785", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/csm/sm/csm/orientation.c", "max_forks_repo_name": "alecone/ROS_project", "max_forks_repo_head_hexsha": "f058fb0bc5c4c9b1a590b7536f75b83af35b7785", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 28.0533333333, "max_line_length": 100, "alphanum_fraction": 0.6116920152, "num_tokens": 1542, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8080672135527632, "lm_q2_score": 0.6619228758499941, "lm_q1q2_score": 0.5348781738749364}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n\n#include \"allvars.h\"\n#include \"proto.h\"\n\nvoid get_cov_matrix(double *theta, int nstep, int ntheta)\n{\n int i, j;\n double cov;\n \n for(i=0; i1.0e-6 ? cov : 1.0e-6;\n cov_matrix[i*ntheta + i] = cov;\n for(j=0; j0.0001?cov:0.0;\n cov_matrix[i*ntheta + j] = cov_matrix[j*ntheta + i] = cov;\n }\n }\n}\nvoid get_cov_matrix_diag(double *theta, int nstep, int ntheta)\n{\n int i, j;\n double cov;\n \n for(i=0; i1.0e-6 ? cov : 1.0e-6;\n cov_matrix[i*ntheta + i] = cov;\n for(j=0; j\n#include \n#include \n#include \n\n#include \"defines.h\"\n#include \"matrix_vector_ops.h\"\n\n#define DEFAULT_DIFF_ERROR_TOLERANCE 5e-5\n#define DEFAULT_DIFF_STEPSIZE 1e-2\n\n#define MAX_DIFF_CORRECTION_ATTEMPTS 100\n\n#define RUNGE_KUTTA_ORDER 5\n\ntypedef int (*DynamicsFunction) (gsl_vector *dy,\n double t,\n const gsl_vector *y,\n const gsl_vector *u);\n\n// Runge-Kutte-Dormand-Prince embedded method modified for controlled systems\n//TODO implement adaptive step size\nint rungeKutteStep(DynamicsFunction dyn,\n double t,\n gsl_vector *y_next,\n gsl_vector *rk_e_next,\n const VehicleState *vehicle,\n const Controller *controller,\n double h);\n\nint rungeKutteAdaptiveStep(DynamicsFunction dyn,\n double t,\n gsl_vector *y_next,\n gsl_vector *rk_e_next,\n const VehicleState *vehicle,\n const Controller *controller,\n double *stepSize,\n double tolerance);\n\n//TODO implement implicit RK method as well for stiff equations\n", "meta": {"hexsha": "645b419905d8edb0ce7488184a48fdab0cb6062a", "size": 1358, "ext": "h", "lang": "C", "max_stars_repo_path": "diff.h", "max_stars_repo_name": "umd-agrc/SimpleControlSim", "max_stars_repo_head_hexsha": "d04a8fa496ec414e2cffdc70ee0beda85e0d7cb4", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "diff.h", "max_issues_repo_name": "umd-agrc/SimpleControlSim", "max_issues_repo_head_hexsha": "d04a8fa496ec414e2cffdc70ee0beda85e0d7cb4", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "diff.h", "max_forks_repo_name": "umd-agrc/SimpleControlSim", "max_forks_repo_head_hexsha": "d04a8fa496ec414e2cffdc70ee0beda85e0d7cb4", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.5813953488, "max_line_length": 77, "alphanum_fraction": 0.5648011782, "num_tokens": 263, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.863391624034103, "lm_q2_score": 0.6187804337438501, "lm_q1q2_score": 0.5342498436106293}} {"text": "static char help[] = \"Solves the Liouville-Bratu reaction-diffusion problem in 1D. Option prefix lb_. Solves\\n\"\n\" - u'' - lambda e^u = 0\\n\"\n\"on [0,1] subject to homogeneous Dirichlet boundary conditions. Optionally uses manufactured solution to problem with f(x) on right-hand-side.\\n\\n\";\n\n#include \n\ntypedef struct {\n PetscBool manufactured;\n PetscReal lambda;\n} AppCtx;\n\nextern PetscErrorCode Exact(DM, DMDALocalInfo*, Vec, AppCtx*);\nextern PetscErrorCode FormFunctionLocal(DMDALocalInfo*, PetscReal*,\n PetscReal*, AppCtx*);\nextern PetscErrorCode FormJacobianLocal(DMDALocalInfo*, PetscReal*,\n Mat, Mat, AppCtx*);\n\nint main(int argc,char **args) {\n PetscErrorCode ierr;\n DM da;\n SNES snes;\n AppCtx user;\n Vec u, uexact;\n PetscReal unorm, errnorm;\n DMDALocalInfo info;\n\n PetscInitialize(&argc,&args,(char*)0,help);\n user.lambda = 1.0;\n user.manufactured = PETSC_FALSE;\n ierr = PetscOptionsBegin(PETSC_COMM_WORLD,\n \"lb_\",\"options for bratu1D\",\"\"); CHKERRQ(ierr);\n ierr = PetscOptionsReal(\"-lambda\",\"coefficient of nonlinear zeroth-order term\",\n \"bratu1D.c\",user.lambda,&(user.lambda),NULL); CHKERRQ(ierr);\n ierr = PetscOptionsBool(\"-manu\",\"if set, use a manufactured solution\",\n \"bratu1D.c\",user.manufactured,&(user.manufactured),NULL); CHKERRQ(ierr);\n ierr = PetscOptionsEnd(); CHKERRQ(ierr);\n\n ierr = DMDACreate1d(PETSC_COMM_WORLD,DM_BOUNDARY_NONE,9,1,1,NULL,&da); CHKERRQ(ierr);\n ierr = DMSetFromOptions(da); CHKERRQ(ierr);\n ierr = DMSetUp(da); CHKERRQ(ierr);\n ierr = DMDASetUniformCoordinates(da,0.0,1.0,-1.0,-1.0,-1.0,-1.0); CHKERRQ(ierr);\n ierr = DMSetApplicationContext(da,&user); CHKERRQ(ierr);\n\n ierr = SNESCreate(PETSC_COMM_WORLD,&snes); CHKERRQ(ierr);\n ierr = SNESSetDM(snes,da); CHKERRQ(ierr);\n ierr = DMDASNESSetFunctionLocal(da,INSERT_VALUES,\n (DMDASNESFunction)FormFunctionLocal,&user); CHKERRQ(ierr);\n ierr = DMDASNESSetJacobianLocal(da,\n (DMDASNESJacobian)FormJacobianLocal,&user); CHKERRQ(ierr);\n ierr = SNESSetFromOptions(snes); CHKERRQ(ierr);\n\n ierr = DMCreateGlobalVector(da,&u); CHKERRQ(ierr);\n ierr = VecSet(u,0.0); CHKERRQ(ierr);\n ierr = SNESSolve(snes,NULL,u); CHKERRQ(ierr);\n\n ierr = DMDAGetLocalInfo(da,&info); CHKERRQ(ierr);\n if (user.manufactured) {\n ierr = VecDuplicate(u,&uexact); CHKERRQ(ierr);\n ierr = Exact(da,&info,uexact,&user); CHKERRQ(ierr);\n ierr = VecNorm(u,NORM_INFINITY,&unorm); CHKERRQ(ierr);\n ierr = VecAXPY(u,-1.0,uexact); CHKERRQ(ierr); // u <- u + (-1.0) uxact\n ierr = VecNorm(u,NORM_INFINITY,&errnorm); CHKERRQ(ierr);\n ierr = PetscPrintf(PETSC_COMM_WORLD,\n \"on %d point grid: |u-u_exact|_inf/|u|_inf = %g\\n\",\n info.mx,errnorm/unorm); CHKERRQ(ierr);\n VecDestroy(&uexact);\n } else {\n ierr = PetscPrintf(PETSC_COMM_WORLD,\"done on %d point grid\\n\",info.mx); CHKERRQ(ierr);\n }\n\n VecDestroy(&u); SNESDestroy(&snes); DMDestroy(&da);\n return PetscFinalize();\n}\n\nPetscErrorCode Exact(DM da, DMDALocalInfo *info, Vec uex, AppCtx *user) {\n PetscErrorCode ierr;\n PetscInt i;\n PetscReal h = 1.0 / (info->mx-1), x, *auex;\n ierr = DMDAVecGetArray(da,uex,&auex); CHKERRQ(ierr);\n for (i=info->xs; ixs+info->xm; i++) {\n x = i * h;\n auex[i] = sin(PETSC_PI * x);\n }\n ierr = DMDAVecRestoreArray(da,uex,&auex); CHKERRQ(ierr);\n return 0;\n}\n\nPetscErrorCode FormFunctionLocal(DMDALocalInfo *info, PetscReal *u,\n PetscReal *f, AppCtx *user) {\n PetscInt i;\n PetscReal h = 1.0 / (info->mx-1), x, R, compf, uex;\n for (i=info->xs; ixs+info->xm; i++) {\n if ((i == 0) || (i == info->mx-1)) {\n f[i] = u[i];\n } else { // interior location\n R = user->lambda * PetscExpReal(u[i]);\n f[i] = - u[i+1] + 2.0 * u[i] - u[i-1] - h*h * R;\n if (user->manufactured) {\n x = i * h;\n uex = sin(PETSC_PI * x);\n compf = PETSC_PI * PETSC_PI * uex - user->lambda * PetscExpReal(uex);\n f[i] -= h * h * compf;\n }\n }\n }\n return 0;\n}\n\nPetscErrorCode FormJacobianLocal(DMDALocalInfo *info, PetscReal *u,\n Mat J, Mat P, AppCtx *user) {\n PetscErrorCode ierr;\n PetscInt i, col[3];\n PetscReal h = 1.0 / (info->mx-1), dRdu, v[3];\n for (i=info->xs; ixs+info->xm; i++) {\n if ((i == 0) | (i == info->mx-1)) {\n v[0] = 1.0;\n ierr = MatSetValues(P,1,&i,1,&i,v,INSERT_VALUES); CHKERRQ(ierr);\n } else {\n dRdu = user->lambda * PetscExpReal(u[i]);\n col[0] = i-1; v[0] = - 1.0;\n col[1] = i; v[1] = 2.0 - h*h * dRdu;\n col[2] = i+1; v[2] = - 1.0;\n ierr = MatSetValues(P,1,&i,3,col,v,INSERT_VALUES); CHKERRQ(ierr);\n }\n }\n ierr = MatAssemblyBegin(P,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);\n ierr = MatAssemblyEnd(P,MAT_FINAL_ASSEMBLY);CHKERRQ(ierr);\n if (J != P) {\n ierr = MatAssemblyBegin(J,MAT_FINAL_ASSEMBLY); CHKERRQ(ierr);\n ierr = MatAssemblyEnd(J,MAT_FINAL_ASSEMBLY); CHKERRQ(ierr);\n }\n return 0;\n}\n\n", "meta": {"hexsha": "9ef6257f3267b670cc98e7dd54e81bafb0c5ccc4", "size": 5370, "ext": "c", "lang": "C", "max_stars_repo_path": "c/ch4/solns/bratu1D.c", "max_stars_repo_name": "thw1021/p4pdes", "max_stars_repo_head_hexsha": "421fd3d809b1e23e5a6f3c3e51252cb275a76140", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 115.0, "max_stars_repo_stars_event_min_datetime": "2015-03-13T04:35:40.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-05T23:12:02.000Z", "max_issues_repo_path": "c/ch4/solns/bratu1D.c", "max_issues_repo_name": "thw1021/p4pdes", "max_issues_repo_head_hexsha": "421fd3d809b1e23e5a6f3c3e51252cb275a76140", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 52.0, "max_issues_repo_issues_event_min_datetime": "2015-09-24T17:42:48.000Z", "max_issues_repo_issues_event_max_datetime": "2021-11-29T12:36:20.000Z", "max_forks_repo_path": "c/ch4/solns/bratu1D.c", "max_forks_repo_name": "thw1021/p4pdes", "max_forks_repo_head_hexsha": "421fd3d809b1e23e5a6f3c3e51252cb275a76140", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 46.0, "max_forks_repo_forks_event_min_datetime": "2016-07-23T09:26:58.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-22T07:43:17.000Z", "avg_line_length": 39.7777777778, "max_line_length": 149, "alphanum_fraction": 0.5860335196, "num_tokens": 1649, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7401743620390163, "lm_q2_score": 0.7217432122827968, "lm_q1q2_score": 0.5342158217074094}} {"text": "#include \n#include \n\n#include \n#include \n#include \n\n#ifdef _MACOSX\n#include \n#else\n#include \n#endif\n\n#include \n\n#include \"util.h\"\n#include \"spbessel.h\"\n\n/* Use the modified Gram-Schmidt process to compute (in place) the portion of\n * the n-dimensional vector v orthogonal to each of the nv vectors s. The\n * projection * of the vector onto each of the basis vectors is stored in the\n * length-nv array c. */\nint cmgs (complex double *v, complex double *c, complex double *s, int n, int nv) {\n\tint i, j, k;\n\tcomplex double *sv, cv;\n\n\tfor (i = 0, sv = s; i < nv; ++i, sv += n) {\n\t\tc[i] = 0;\n\t\tk = 0;\n\n\t\tdo {\n\t\t\tcv = pardot (sv, v, n);\n\t\t\tc[i] += cv;\n#pragma omp parallel for default(shared) private(j)\n\t\t\tfor (j = 0; j < n; ++j) v[j] -= cv * sv[j];\n\t\t} while (cabs(cv / c[i]) > IMGS_TOL && ++k < IMGS_ITS);\n\t\t\n\t}\n\n\treturn n;\n}\n\ncomplex double pardot (complex double *x, complex double *y, int n) {\n\tcomplex double dp;\n\n\t/* Compute the local portion. */\n\tcblas_zdotc_sub (n, x, 1, y, 1, &dp);\n\n\treturn dp;\n}\n\n/* The MSE between two vectors. */\ndouble rmserror (complex double *v, complex double *r, int n) {\n\tdouble err = 0, errd = 0, e;\n\tint i;\n\n\tfor (i = 0; i < n; ++i) {\n\t\te = cabs (v[i] - r[i]);\n\t\terr += e * e;\n\t\te = cabs (r[i]);\n\t\terrd += e * e;\n\t}\n\n\treturn sqrt (err / errd);\n}\n\n/* Open a file or die. */\nFILE *critopen (char *fname, char *mode) {\n\tFILE *fptr;\n\n\tfptr = fopen (fname, mode);\n\n\tif (!fptr) {\n\t\tfprintf (stderr, \"ERROR: Could not open input file %s.\\n\", fname);\n\t\texit (EXIT_FAILURE);\n\n\t\treturn NULL;\n\t}\n\n\treturn fptr;\n}\n\n/* Compute the number of harmonics required using the excess bandwidth\n * formula. */\nint exband (complex double kr, double ndig) {\n\tdouble akr;\n\tint l;\n\t\n\takr = creal (kr);\n\tndig *= ndig;\n\n\tl = ceil (akr + 1.8 * cbrt(ndig * akr));\n\n\treturn l;\n}\n\n/* Computes the Legendre polynomials up to order n for the argument x. The\n * values are stored in the array v. */\nint legpoly (int n, double x, double *v) {\n\tint i;\n\n\t/* Don't bother computing anything for order less than zero. */\n\tif (n < 0) return -1;\n\n\t/* Make sure the argument is within [-1,1] as expected. */\n\tif (fabs(x) > 1.0 + DBL_EPSILON) return -2;\n\n\t/* The first function value. */\n\tv[0] = 1.0;\n\n\t/* If the order happens to be zero, there is no going further. */\n\tif (n < 1) return 0;\n\n\t/* The second function value. */\n\tv[1] = x;\n\n\t/* The recursion formula for Legendre polynomials. */\n\tfor (i = 1; i < n - 1; ++i)\n\t\tv[i + 1] = ((2 * i + 1) * x * v[i] - i * v[i - 1]) / (i + 1);\n\n\treturn 0;\n}\n\n/* Computes the wave number from the relative sound speed and\n * unitless (dB) attenuation coefficient. */\ncomplex double wavenum (double cr, double alpha) {\n\tdouble kr, ki;\n\n\tki = log(10) * alpha / 20;\n\tkr = 2 * M_PI / cr;\n\n\treturn kr + I * ki;\n}\n\n/* Computes the inverse wave number from the relative sound speed and\n * unitless (dB) attenuation coefficient. */\ncomplex double invwavenum (double cr, double alpha) {\n\tdouble kr, ki, mag, csq;\n\n\tcsq = cr * cr;\n\n\tkr = 2 * M_PI * cr;\n\tki = log(10) * alpha / 20;\n\tmag = 4 * M_PI * M_PI + ki * ki * csq;\n\n\treturn (kr / mag) - I * (ki * csq / mag);\n}\n\n/* Copy the spherical harmonic representation from one location to another. */\nint copysh (int deg, complex double *out, int ldo, complex double *in, int ldi) {\n\tint i, j, offo, offi;\n\n\t/* Copy the spherical harmonic coefficients into the right place. */\n\tfor (i = 0; i < deg; ++i) {\n\t\toffo = i * ldo;\n\t\toffi = i * ldi;\n\t\t/* Copy the zero-order coefficients. */\n\t\tout[offo] = in[offi];\n\n\t\t/* Copy the other coefficients. */\n\t\tfor (j = 1; j <= i; ++j) {\n\t\t\tout[offo + j] = in[offi + j];\n\t\t\tout[offo + ldo - j] = in[offi + ldi - j];\n\t\t}\n\t}\n\n\treturn deg;\n}\n\n/* Multiply in a radial component to the spherical harmonic. */\nint shradial (int deg, complex double *a, int lda, complex double k, double r) {\n\tcomplex double kr, *hlkr;\n\tint i, j, off;\n\n\thlkr = malloc (deg * sizeof(complex double));\n\n\t/* Compute the Hankel functions for all degrees. */\n\tkr = k * r;\n\tspbesh (hlkr, kr, deg);\n\n\tfor (i = 0; i < deg; ++i) {\n\t\toff = i * lda;\n\n\t\t/* The zero-order coefficients. */\n\t\ta[off] *= hlkr[i];\n\n\t\t/* The other coefficients. */\n\t\tfor (j = 1; j <= i; ++j) {\n\t\t\ta[off + j] *= hlkr[i];\n\t\t\ta[off + lda - j] *= hlkr[i];\n\t\t}\n\t}\n\n\tfree (hlkr);\n\n\treturn deg;\n}\n\n/* Compute the harmonic coefficients for an incident plane wave. */\nint shincident (int deg, complex double *a, int lda,\n\t\tcomplex double mag, double theta, double phi) {\n\tdouble cth, *lgvals;\n\tint l, m, dm1, npm, off;\n\tlong lgi, lgn;\n\tcomplex double scale[4] = { 1, -I, -1, I }, cx, fx;\n\n\t/* The coefficient has a 4 pi factor that must be included. */\n\tmag *= 4 * M_PI;\n\n\tdm1 = deg - 1;\n\tcth = cos(theta);\n\n\tlgn = gsl_sf_legendre_array_n (dm1);\n\tlgvals = malloc (lgn * sizeof(double));\n\n\t/* Compute the Legendre polynomials of zero order for all degrees. */\n\tgsl_sf_legendre_array_e (GSL_SF_LEGENDRE_SPHARM, dm1, cth, 1., lgvals);\n\n\t/* Compute the zero-order coefficients for all degrees. */\n\tfor (l = 0; l < deg; ++l) {\n\t\tlgi = gsl_sf_legendre_array_index(l, 0);\n\t\ta[l * lda] += scale[l % 4] * mag * lgvals[lgi];\n\t}\n\n\tfor (m = 1; m < deg; ++m) {\n\t\tnpm = lda - m;\n\n\t\t/* Compute the phi variation. */\n\t\tcx = cexp (I * m * phi);\n\n#pragma omp critical(incaug)\n\t\tfor (l = m; l < deg; ++l) {\n\t\t\toff = l * lda;\n\t\t\tlgi = gsl_sf_legendre_array_index(l, m);\n\t\t\tfx = scale[l % 4] * mag * lgvals[lgi];\n\t\t\t/* The positive-order coefficient. */\n\t\t\ta[off + m] += fx * conj (cx);\n\t\t\t/* The negative-order coefficient. */\n\t\t\ta[off + npm] += fx * cx;\n\t\t}\n\t}\n\n\tfree (lgvals);\n\n\treturn deg;\n}\n\nstatic int lgval (double *p, double *dp, double t, int m) {\n\tdouble p0 = 1.0, p1 = t;\n\tint k;\n\n\t/* Set values explicitly for low orders. */\n\tif (m < 1) {\n\t\t*p = 1.0;\n\t\t*dp = 0.0;\n\t\treturn m;\n\t} else if (m < 2) {\n\t\t*p = t;\n\t\t*dp = 1.0;\n\t\treturn m;\n\t}\n\n\t/* Otherwise compute the values explicitly. */\n\tfor (k = 1; k < m; ++k) {\n\t\t*p = ((2.0 * k + 1.0) * t * p1 - k * p0) / (1.0 + k);\n\t\tp0 = p1; p1 = *p;\n\t}\n\n\t*dp = m * (p0 - t * p1) / (1.0 - t * t);\n\n\treturn m;\n}\n\nint gauleg (int m, double *nodes, double *weights) {\n\tint i, j, nroots = (m + 1) / 2;\n\tdouble t, p, dp, dt;\n\tconst int maxit = 100;\n\tconst double tol = 1.0e-14;\n\n#pragma omp parallel for default(shared) private(i,j,t,p,dp,dt)\n\tfor (i = 0; i < nroots; ++i) {\n\t\tt = cos (M_PI * (i + 0.75) / (m + 0.5));\n\n\t\tfor (j = 0; j < maxit; ++j) {\n\t\t\t/* Compute the value of the Legendre polynomial. */\n\t\t\tlgval (&p, &dp, t, m);\n\n\t\t\t/* Perform a Newton-Raphson update. */\n\t\t\tdt = -p / dp;\n\t\t\tt += dt;\n\n\t\t\t/* Break if convergence has been achieved. */\n\t\t\tif (fabs(dt) < tol) break;\n\t\t}\n\n\t\t/* Update the nodes and weights. */\n\t\tnodes[i] = t;\n\t\tnodes[m - i - 1] = -t;\n\n\t\tweights[i] = 2.0 / (1.0 - t * t) / (dp * dp);\n\t\tweights[m - i - 1] = weights[i];\n\t}\n\n\treturn 0;\n}\n", "meta": {"hexsha": "d9f432e2f388702544ca883ac9320f8fca007497", "size": 6836, "ext": "c", "lang": "C", "max_stars_repo_path": "util.c", "max_stars_repo_name": "ahesford/fastsphere", "max_stars_repo_head_hexsha": "18d8bd2d73aaabeafe4ead48955c8d8190eddbf2", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "util.c", "max_issues_repo_name": "ahesford/fastsphere", "max_issues_repo_head_hexsha": "18d8bd2d73aaabeafe4ead48955c8d8190eddbf2", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "util.c", "max_forks_repo_name": "ahesford/fastsphere", "max_forks_repo_head_hexsha": "18d8bd2d73aaabeafe4ead48955c8d8190eddbf2", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 22.339869281, "max_line_length": 83, "alphanum_fraction": 0.5880631949, "num_tokens": 2383, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7745833893685269, "lm_q2_score": 0.6893056295505783, "lm_q1q2_score": 0.5339246908480931}} {"text": "/*\n * Copyright 2016 Maikel Nadolski\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#include \n#include \n\n#ifndef HMM_ALGORITHM_BACKWARD_H_\n#define HMM_ALGORITHM_BACKWARD_H_\n\nnamespace maikel { namespace hmm {\n\ntemplate \n class backward_range_fn {\n public:\n using model = hidden_markov_model;\n using row_vector = typename model::row_vector;\n using matrix = typename model::matrix;\n using symbol_type = typename std::iterator_traits::value_type;\n\n backward_range_fn() = delete;\n\n backward_range_fn(I seq_it, I seq_end, J scaling_it, model const& hmm)\n : hmm_{&hmm}, seq_it_{seq_it}, seq_end_{seq_end}, scaling_it_{scaling_it},\n beta_(hmm.states()), next_beta_(hmm.states())\n {\n if (seq_it != seq_end)\n initial_coefficients(*scaling_it);\n }\n\n class iterator\n : public boost::iterator_facade<\n iterator, row_vector, std::input_iterator_tag, row_vector const&\n > {\n public:\n iterator() = default;\n private:\n friend class backward_range_fn;\n friend class boost::iterator_core_access;\n\n iterator(backward_range_fn& parent)\n : parent_{parent ? &parent : nullptr} {}\n\n backward_range_fn* parent_ = nullptr;\n\n row_vector const& dereference() const\n {\n Expects(parent_ && *parent_);\n return parent_->beta_;\n }\n\n void increment()\n {\n Expects(parent_ && *parent_);\n if (!parent_->next())\n parent_ = nullptr;\n }\n\n bool equal(iterator other) const noexcept\n {\n return parent_ == other.parent_;\n }\n };\n\n operator bool() const noexcept\n {\n return seq_it_ != seq_end_;\n }\n\n iterator begin() noexcept\n {\n return {*this};\n }\n\n iterator end() noexcept\n {\n return {};\n }\n\n private:\n model const* hmm_; // not owning\n I seq_it_, seq_end_;\n J scaling_it_;\n row_vector beta_;\n row_vector next_beta_;\n\n void initial_coefficients(T scaling) noexcept\n {\n Expects(beta_.size() == hmm_->states());\n beta_.fill(scaling);\n }\n\n void recursion_advance(symbol_type s, T scaling) noexcept\n {\n using size_type = typename model::size_type;\n matrix const& A = hmm_->transition_matrix();\n matrix const& B = hmm_->symbol_probabilities();\n next_beta_.swap(beta_);\n\n // check pre conditions\n size_type states = A.rows();\n Expects(A.cols() == states);\n Expects(B.rows() == states);\n Expects(next_beta_.size() == states);\n Expects(beta_.size() == states);\n size_type ob = gsl::narrow(s);\n Expects(0 <= ob && ob < B.cols());\n\n // recursion formula\n for (size_type i = 0; i < states; ++i) {\n beta_(i) = 0.0;\n for (size_type j = 0; j < states; ++j)\n beta_(i) += A(i,j)*B(j,ob)*next_beta_(j);\n beta_(i) *= scaling;\n }\n }\n\n bool next()\n {\n Expects(*this);\n symbol_type s = *seq_it_++;\n ++scaling_it_;\n if (seq_it_ == seq_end_)\n return false;\n recursion_advance(s, *scaling_it_);\n return true;\n }\n };\n\n template \n backward_range_fn\n backward(I begin, I end, J scaling, hidden_markov_model const& hmm)\n {\n return {begin, end, scaling, hmm};\n }\n\n} // namespace hmm\n} // namespace maikel\n\n#endif /* HMM_ALGORITHM_BACKWARD_H_ */\n", "meta": {"hexsha": "475c5f03167f54a3bc88a6d70c3efd7e0acaa24d", "size": 4391, "ext": "h", "lang": "C", "max_stars_repo_path": "include/maikel/hmm/algorithm/backward.h", "max_stars_repo_name": "maikel/hidden-markov-model", "max_stars_repo_head_hexsha": "db97cd0344a3cb55afdd2d341fd2c5c326f6476a", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2020-06-14T07:16:01.000Z", "max_stars_repo_stars_event_max_datetime": "2020-06-14T07:16:01.000Z", "max_issues_repo_path": "include/maikel/hmm/algorithm/backward.h", "max_issues_repo_name": "maikel/Hidden-Markov-Model", "max_issues_repo_head_hexsha": "db97cd0344a3cb55afdd2d341fd2c5c326f6476a", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "include/maikel/hmm/algorithm/backward.h", "max_forks_repo_name": "maikel/Hidden-Markov-Model", "max_forks_repo_head_hexsha": "db97cd0344a3cb55afdd2d341fd2c5c326f6476a", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 28.6993464052, "max_line_length": 83, "alphanum_fraction": 0.5622864951, "num_tokens": 975, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7745833841649233, "lm_q2_score": 0.6893056167854461, "lm_q1q2_score": 0.5339246773735606}} {"text": "/*\n * Copyright 2021 The DAPHNE Consortium\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n#pragma once\n\n#include \n#include \n#include \n\n#include \n#include \n\n#include \n#include \n\n// ****************************************************************************\n// Struct for partial template specialization\n// ****************************************************************************\n\ntemplate\nstruct Solve {\n static void apply(DTRes *& res, const DTLhs * lhs, const DTRhs * rhs, DCTX(ctx)) = delete;\n};\n\n// ****************************************************************************\n// Convenience function\n// ****************************************************************************\n\ntemplate\nvoid solve(DTRes *& res, const DTLhs * lhs, const DTRhs * rhs, DCTX(ctx)) {\n Solve::apply(res, lhs, rhs, ctx);\n}\n\n// ****************************************************************************\n// (Partial) template specializations for different data/value types\n// ****************************************************************************\n\n// ----------------------------------------------------------------------------\n// DenseMatrix <- DenseMatrix, DenseMatrix\n// ----------------------------------------------------------------------------\n\ntemplate<>\nstruct Solve, DenseMatrix, DenseMatrix> {\n static void apply(DenseMatrix *& res, const DenseMatrix * lhs, const DenseMatrix * rhs, DCTX(ctx)) {\n const auto nr1 = static_cast(lhs->getNumRows());\n const auto nc1 = static_cast(lhs->getNumCols());\n const auto nc2 = static_cast(rhs->getNumCols());\n assert((nr1 == static_cast(rhs->getNumRows())) && \"#rows of lhs and #rows of rhs must be the same\");\n assert((nr1 == nc1) && \"#rows and #cols of lhs must be the same\");\n assert((static_cast(lhs->getRowSkip()) == nc1) && \"#cols of lhs must match row skip\");\n assert((nc2==1) && \"#cols of rhs must be 1\");\n\n if(res == nullptr)\n res = DataObjectFactory::create>(nr1, nc2, false);\n\n // solve system of equations via LU decomposition\n int ipiv[nr1]; // permutation indexes\n float work[nr1*nc1]; // LU factorization of gesv\n memcpy(work, lhs->getValues(), nr1*nc1*sizeof(float)); //for in-place A\n memcpy(res->getValues(), rhs->getValues(), nr1*sizeof(float)); //for in-place b-out\n [[maybe_unused]] int info = LAPACKE_sgesv(LAPACK_ROW_MAJOR, nr1, 1, work, nc1, ipiv, res->getValues(), 1);\n assert((info<=0) && \"A factor Ui is exactly singular, so the solution could not be computed\");\n }\n};\n\ntemplate<>\nstruct Solve, DenseMatrix, DenseMatrix> {\n static void apply(DenseMatrix *& res, const DenseMatrix * lhs, const DenseMatrix * rhs, DCTX(ctx)) {\n const auto nr1 = static_cast(lhs->getNumRows());\n const auto nc1 = static_cast(lhs->getNumCols());\n const auto nc2 = static_cast(rhs->getNumCols());\n assert((nr1 == static_cast(rhs->getNumRows())) && \"#rows of lhs and #rows of rhs must be the same\");\n assert((nr1 == nc1) && \"#rows and #cols of lhs must be the same\");\n assert((static_cast(lhs->getRowSkip()) == nc1) && \"#cols of lhs must match row skip\");\n assert((nc2==1) && \"#cols of rhs must be 1\");\n\n if(res == nullptr)\n res = DataObjectFactory::create>(nr1, nc2, false);\n\n // solve system of equations via LU decomposition\n int ipiv[nr1]; // permutation indexes\n double work[nr1*nc1]; // LU factorization of gesv\n memcpy(work, lhs->getValues(), nr1*nc1*sizeof(double)); //for in-place A\n memcpy(res->getValues(), rhs->getValues(), nr1*sizeof(double)); //for in-place b-out\n [[maybe_unused]] int info = LAPACKE_dgesv(LAPACK_ROW_MAJOR, nr1, 1, work, nc1, ipiv, res->getValues(), 1);\n assert((info<=0) && \"A factor Ui is exactly singular, so the solution could not be computed\");\n }\n};\n", "meta": {"hexsha": "cfccb6c9e890096b68933db7dbe15dc6f16bbe88", "size": 4901, "ext": "h", "lang": "C", "max_stars_repo_path": "src/runtime/local/kernels/Solve.h", "max_stars_repo_name": "daphne-eu/daphne", "max_stars_repo_head_hexsha": "64d4040132cf4059efaf184c4e363dbb921c87d6", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 10.0, "max_stars_repo_stars_event_min_datetime": "2022-03-31T21:49:35.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-31T23:37:06.000Z", "max_issues_repo_path": "src/runtime/local/kernels/Solve.h", "max_issues_repo_name": "daphne-eu/daphne", "max_issues_repo_head_hexsha": "64d4040132cf4059efaf184c4e363dbb921c87d6", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 3.0, "max_issues_repo_issues_event_min_datetime": "2022-03-31T22:10:10.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T22:46:30.000Z", "max_forks_repo_path": "src/runtime/local/kernels/Solve.h", "max_forks_repo_name": "daphne-eu/daphne", "max_forks_repo_head_hexsha": "64d4040132cf4059efaf184c4e363dbb921c87d6", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 48.0490196078, "max_line_length": 128, "alphanum_fraction": 0.5766170169, "num_tokens": 1116, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7981867681382279, "lm_q2_score": 0.6688802537704063, "lm_q1q2_score": 0.5338913680284783}} {"text": "/* cdf/inverse_normal.c\n *\n * Copyright (C) 2002 Przemyslaw Sliwa and Jason H. Stover.\n *\n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n *\n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.\n */\n\n/*\n * Computes the inverse normal cumulative distribution function \n * according to the algorithm shown in \n *\n * Wichura, M.J. (1988).\n * Algorithm AS 241: The Percentage Points of the Normal Distribution.\n * Applied Statistics, 37, 477-484.\n */\n\n#include \n#include \n#include \n#include \n\n#include \"rat_eval.h\"\n\nstatic double\nsmall (double q)\n{\n const double a[8] = { 3.387132872796366608, 133.14166789178437745,\n 1971.5909503065514427, 13731.693765509461125,\n 45921.953931549871457, 67265.770927008700853,\n 33430.575583588128105, 2509.0809287301226727\n };\n\n const double b[8] = { 1.0, 42.313330701600911252,\n 687.1870074920579083, 5394.1960214247511077,\n 21213.794301586595867, 39307.89580009271061,\n 28729.085735721942674, 5226.495278852854561\n };\n\n double r = 0.180625 - q * q;\n\n double x = q * rat_eval (a, 8, b, 8, r);\n\n return x;\n}\n\nstatic double\nintermediate (double r)\n{\n const double a[] = { 1.42343711074968357734, 4.6303378461565452959,\n 5.7694972214606914055, 3.64784832476320460504,\n 1.27045825245236838258, 0.24178072517745061177,\n 0.0227238449892691845833, 7.7454501427834140764e-4\n };\n\n const double b[] = { 1.0, 2.05319162663775882187,\n 1.6763848301838038494, 0.68976733498510000455,\n 0.14810397642748007459, 0.0151986665636164571966,\n 5.475938084995344946e-4, 1.05075007164441684324e-9\n };\n\n double x = rat_eval (a, 8, b, 8, (r - 1.6));\n\n return x;\n}\n\nstatic double\ntail (double r)\n{\n const double a[] = { 6.6579046435011037772, 5.4637849111641143699,\n 1.7848265399172913358, 0.29656057182850489123,\n 0.026532189526576123093, 0.0012426609473880784386,\n 2.71155556874348757815e-5, 2.01033439929228813265e-7\n };\n\n const double b[] = { 1.0, 0.59983220655588793769,\n 0.13692988092273580531, 0.0148753612908506148525,\n 7.868691311456132591e-4, 1.8463183175100546818e-5,\n 1.4215117583164458887e-7, 2.04426310338993978564e-15\n };\n\n double x = rat_eval (a, 8, b, 8, (r - 5.0));\n\n return x;\n}\n\ndouble\ngsl_cdf_ugaussian_Pinv (const double P)\n{\n double r, x, pp;\n\n double dP = P - 0.5;\n\n if (P == 1.0)\n {\n return GSL_POSINF;\n }\n else if (P == 0.0)\n {\n return GSL_NEGINF;\n }\n\n if (fabs (dP) <= 0.425)\n {\n x = small (dP);\n\n return x;\n }\n\n pp = (P < 0.5) ? P : 1.0 - P;\n\n r = sqrt (-log (pp));\n\n if (r <= 5.0)\n {\n x = intermediate (r);\n }\n else\n {\n x = tail (r);\n }\n\n if (P < 0.5)\n {\n return -x;\n }\n else\n {\n return x;\n }\n\n}\n\ndouble\ngsl_cdf_ugaussian_Qinv (const double Q)\n{\n double r, x, pp;\n\n double dQ = Q - 0.5;\n\n if (Q == 1.0)\n {\n return GSL_NEGINF;\n }\n else if (Q == 0.0)\n {\n return GSL_POSINF;\n }\n\n if (fabs (dQ) <= 0.425)\n {\n x = small (dQ);\n\n return -x;\n }\n\n pp = (Q < 0.5) ? Q : 1.0 - Q;\n\n r = sqrt (-log (pp));\n\n if (r <= 5.0)\n {\n x = intermediate (r);\n }\n else\n {\n x = tail (r);\n }\n\n if (Q < 0.5)\n {\n return x;\n }\n else\n {\n return -x;\n }\n}\n\n\ndouble\ngsl_cdf_gaussian_Pinv (const double P, const double sigma)\n{\n return sigma * gsl_cdf_ugaussian_Pinv (P);\n}\n\ndouble\ngsl_cdf_gaussian_Qinv (const double Q, const double sigma)\n{\n return sigma * gsl_cdf_ugaussian_Qinv (Q);\n}\n", "meta": {"hexsha": "5376b757fccbbd5bc3b7e7dc1910d96766e21cbf", "size": 4130, "ext": "c", "lang": "C", "max_stars_repo_path": "folding_libs/gsl-1.14/cdf/gaussinv.c", "max_stars_repo_name": "parasol-ppl/PPL_utils", "max_stars_repo_head_hexsha": "92728bb89692fda1705a0dee436592d97922a6cb", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-01-11T02:53:04.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-25T17:31:22.000Z", "max_issues_repo_path": "CMVS-PMVS/program/thirdParty/gsl-1.13/cdf/gaussinv.c", "max_issues_repo_name": "skair39/structured", "max_issues_repo_head_hexsha": "0cb4635af7602f2a243a9b739e5ed757424ab2a7", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "CMVS-PMVS/program/thirdParty/gsl-1.13/cdf/gaussinv.c", "max_forks_repo_name": "skair39/structured", "max_forks_repo_head_hexsha": "0cb4635af7602f2a243a9b739e5ed757424ab2a7", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 14.0, "max_forks_repo_forks_event_min_datetime": "2015-07-21T04:47:52.000Z", "max_forks_repo_forks_event_max_datetime": "2020-03-12T12:31:25.000Z", "avg_line_length": 20.3448275862, "max_line_length": 77, "alphanum_fraction": 0.6426150121, "num_tokens": 1510, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8333245953120234, "lm_q2_score": 0.6406358479787609, "lm_q1q2_score": 0.5338576087592759}} {"text": "/* statistics/gsl_statistics_ulong.h\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000 Jim Davies, Brian Gough\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 2 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n#ifndef __GSL_STATISTICS_ULONG_H__\n#define __GSL_STATISTICS_ULONG_H__\n\n#include \n#include \n\n#undef __BEGIN_DECLS\n#undef __END_DECLS\n#ifdef __cplusplus\n# define __BEGIN_DECLS extern \"C\" {\n# define __END_DECLS }\n#else\n# define __BEGIN_DECLS /* empty */\n# define __END_DECLS /* empty */\n#endif\n\n__BEGIN_DECLS\n\nGSL_EXPORT double gsl_stats_ulong_mean (const unsigned long data[], const size_t stride, const size_t n);\nGSL_EXPORT double gsl_stats_ulong_variance (const unsigned long data[], const size_t stride, const size_t n);\nGSL_EXPORT double gsl_stats_ulong_sd (const unsigned long data[], const size_t stride, const size_t n);\nGSL_EXPORT double gsl_stats_ulong_variance_with_fixed_mean (const unsigned long data[], const size_t stride, const size_t n, const double mean);\nGSL_EXPORT double gsl_stats_ulong_sd_with_fixed_mean (const unsigned long data[], const size_t stride, const size_t n, const double mean);\nGSL_EXPORT double gsl_stats_ulong_absdev (const unsigned long data[], const size_t stride, const size_t n);\nGSL_EXPORT double gsl_stats_ulong_skew (const unsigned long data[], const size_t stride, const size_t n);\nGSL_EXPORT double gsl_stats_ulong_kurtosis (const unsigned long data[], const size_t stride, const size_t n);\nGSL_EXPORT double gsl_stats_ulong_lag1_autocorrelation (const unsigned long data[], const size_t stride, const size_t n);\n\nGSL_EXPORT double gsl_stats_ulong_covariance (const unsigned long data1[], const size_t stride1,const unsigned long data2[], const size_t stride2, const size_t n);\n\nGSL_EXPORT double gsl_stats_ulong_variance_m (const unsigned long data[], const size_t stride, const size_t n, const double mean);\nGSL_EXPORT double gsl_stats_ulong_sd_m (const unsigned long data[], const size_t stride, const size_t n, const double mean);\nGSL_EXPORT double gsl_stats_ulong_absdev_m (const unsigned long data[], const size_t stride, const size_t n, const double mean);\nGSL_EXPORT double gsl_stats_ulong_skew_m_sd (const unsigned long data[], const size_t stride, const size_t n, const double mean, const double sd);\nGSL_EXPORT double gsl_stats_ulong_kurtosis_m_sd (const unsigned long data[], const size_t stride, const size_t n, const double mean, const double sd);\nGSL_EXPORT double gsl_stats_ulong_lag1_autocorrelation_m (const unsigned long data[], const size_t stride, const size_t n, const double mean);\n\nGSL_EXPORT double gsl_stats_ulong_covariance_m (const unsigned long data1[], const size_t stride1,const unsigned long data2[], const size_t stride2, const size_t n, const double mean1, const double mean2);\n\n\nGSL_EXPORT double gsl_stats_ulong_pvariance (const unsigned long data1[], const size_t stride1, const size_t n1, const unsigned long data2[], const size_t stride2, const size_t n2);\nGSL_EXPORT double gsl_stats_ulong_ttest (const unsigned long data1[], const size_t stride1, const size_t n1, const unsigned long data2[], const size_t stride2, const size_t n2);\n\nGSL_EXPORT unsigned long gsl_stats_ulong_max (const unsigned long data[], const size_t stride, const size_t n);\nGSL_EXPORT unsigned long gsl_stats_ulong_min (const unsigned long data[], const size_t stride, const size_t n);\nGSL_EXPORT void gsl_stats_ulong_minmax (unsigned long * min, unsigned long * max, const unsigned long data[], const size_t stride, const size_t n);\n\nGSL_EXPORT size_t gsl_stats_ulong_max_index (const unsigned long data[], const size_t stride, const size_t n);\nGSL_EXPORT size_t gsl_stats_ulong_min_index (const unsigned long data[], const size_t stride, const size_t n);\nGSL_EXPORT void gsl_stats_ulong_minmax_index (size_t * min_index, size_t * max_index, const unsigned long data[], const size_t stride, const size_t n);\n\nGSL_EXPORT double gsl_stats_ulong_median_from_sorted_data (const unsigned long sorted_data[], const size_t stride, const size_t n) ;\nGSL_EXPORT double gsl_stats_ulong_quantile_from_sorted_data (const unsigned long sorted_data[], const size_t stride, const size_t n, const double f) ;\n\n__END_DECLS\n\n#endif /* __GSL_STATISTICS_ULONG_H__ */\n", "meta": {"hexsha": "c08392883cce19dfd8e7bd72722c1cc6904392f0", "size": 4872, "ext": "h", "lang": "C", "max_stars_repo_path": "src/core/gsl/include/gsl/gsl_statistics_ulong.h", "max_stars_repo_name": "dynaryu/vaws", "max_stars_repo_head_hexsha": "f6ed9b75408f7ce6100ed59b7754f745e59be152", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/core/gsl/include/gsl/gsl_statistics_ulong.h", "max_issues_repo_name": "dynaryu/vaws", "max_issues_repo_head_hexsha": "f6ed9b75408f7ce6100ed59b7754f745e59be152", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/core/gsl/include/gsl/gsl_statistics_ulong.h", "max_forks_repo_name": "dynaryu/vaws", "max_forks_repo_head_hexsha": "f6ed9b75408f7ce6100ed59b7754f745e59be152", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 63.2727272727, "max_line_length": 205, "alphanum_fraction": 0.7988505747, "num_tokens": 1164, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8056321796478255, "lm_q2_score": 0.6619228691808011, "lm_q1q2_score": 0.5332663638568713}} {"text": "//\n// Created by L.Jonathan Feldstein\n//\n\n#ifndef CIMPLE_SYSTEM_H\n#define CIMPLE_SYSTEM_H\n\n#include \n#include \n#include \"cimple_polytope_library.h\"\n\n// EXAMPLE ALLOCATION FOR STRUCT\n// Try to allocate structure.\n// struct struct_name *return_**** = malloc(sizeof(struct));\n// Try to allocate data, free structure if fail.\n// return_****->**** = malloc(***);\n// Free structure if fail, return NULL\n// if (return_****->**** == NULL){\n// return NULL;\n//}\n\n/**\n * Functions that help perform several mathematical operations\n * on the way to calculating the input.\n */\ntypedef struct auxiliary_matrices{\n\n gsl_matrix * A_K;\n gsl_matrix * A_N;\n gsl_matrix * Ct;\n\n /*\n B_diag = B\n E_diag = E\n for i in range(N-1):\n B_diag = _block_diag2(B_diag, B)\n E_diag = _block_diag2(E_diag, E)\n */\n gsl_matrix * B_diag;\n gsl_matrix * E_diag;\n\n gsl_matrix * L_default;\n gsl_matrix * E_default;\n\n\n //LU = ([Uset->size1*N, n+N*m])\n\n gsl_matrix * LU;\n\n //MU = tile(Uset->G, N)\n\n gsl_vector * MU;\n\n //GU = ([Uset->size1*N, p*N])\n\n gsl_matrix * GU;\n\n //K_hat = tile(K, N)\n\n gsl_vector * K_hat;\n\n\n}auxiliary_matrices;\n\n/**\n * Cost function to be minimized:\n *\n * |Rx|_{ord} + |Qu|_{ord} + r'x + mid_weight * |xc - x(N)|_{ord}\n *\n * R: state cost matrix for:\n * x = [x(1)' x(2)' .. x(N)']'\n * If empty, zero matrix is used.\n * dim[N*n x N*n] (n = x.size)\n *\n * r: cost vector for state trajectory:\n * x = [x(1)' x(2)' .. x(N)']'\n * r: size (N*xdim x 1)\n *\n * Q: input cost matrix for control input::\n * u = [u(0)' u(1)' .. u(N-1)']'\n * If empty, identity matrix is used.\n * dim[N*m x N*m] m = u.size\n *\n * distance_error_weight: cost weight for |x(N)-xc|_{ord}\n *\n * ord: norm used for cost function: ord in {1, 2, INFINITY}\n*/\ntypedef struct cost_function{\n\n gsl_matrix *R;\n gsl_matrix *Q;\n gsl_vector *r;\n double distance_error_weight;\n\n}cost_function;\n\n/**\n * Abstraction of the system\n * contains all the polytopes\n *\n * number_of_region = total number of possible states that can be reached\n * regions: array of region, each containing one or multiple polytopes\n *\n * closed_loop: if 'true' only first input of next N calculated inputs is applied.\n * All others are discarded.\n * conservative: if 'true' x(0)...x(N-1) are in starting polytope, x(N) is in final polytope\n * if false x(1)...x(N-1) can be anywhere\n *\n * ord: norm that is used for minimizing cost function in {1, 2, INFINITY}\n *\n * time_horizon: number of next steps that are taken into account in calculation of the path\n */\ntypedef struct discrete_dynamics{\n\n int abstract_states_count;\n int number_of_original_regions;\n abstract_state **abstract_states_set;\n abstract_state **original_regions;\n int closed_loop;\n int conservative;\n int ord;\n size_t time_horizon;\n\n}discrete_dynamics;\n\n/**\n * Dynamics of the system\n *\n * x(t+1) = Ax(t) + Bu(t) + E\n *\n * A system dynamics\n * B input dynamics\n * E disturbance\n * U_set, W_set constraints on states and inputs\n * aux_matrices: auxiliary matrices to fasten calculation of next input\n */\ntypedef struct system_dynamics{\n\n gsl_matrix *A;\n gsl_matrix *B;\n gsl_matrix *E;\n gsl_vector *K;\n polytope *W_set;\n polytope *U_set;\n auxiliary_matrices *aux_matrices;\n\n}system_dynamics;\n\n/**\n * State plant is in at the beginning of the calculation\n *\n * current_abs_state starting region\n */\ntypedef struct current_state{\n\n int current_abs_state;\n gsl_vector *x;\n\n} current_state;\n\n/**\n * @brief \"Constructor\" Dynamically allocates the memory all auxiliary matrices need\n * @param n s_dyn.A.size2\n * @param p s_dyn.E.size2\n * @param m s_dyn.B.size2\n * @param u_set_size Uset.size1\n * @param N time horizon\n * @return\n */\nstruct auxiliary_matrices *aux_matrices_alloc(size_t n,\n size_t p,\n size_t m,\n size_t u_set_size,\n size_t N);\n\n/**\n * @brief \"Destructor\" Deallocates the dynamically allocated memory of the auxiliary matrices\n * @param aux_matrices\n */\nvoid aux_matrices_free(auxiliary_matrices *aux_matrices);\n\n/**\n * @brief \"Constructor\" Dynamically allocates the memory the complete system dynamics need\n * @param n\n * @param m\n * @param p\n * @param w_set_size\n * @param u_set_size\n * @param N\n * @return\n */\nstruct system_dynamics *system_dynamics_alloc (size_t n,\n size_t m,\n size_t p,\n size_t w_set_size,\n size_t u_set_size,\n size_t N);\n\n/**\n * @brief \"Destructor\" Deallocates the dynamically allocated memory of the system dynamics\n * @param system_dynamics\n */\nvoid system_dynamics_free(system_dynamics * system_dynamics);\n\n/**\n * @brief \"Constructor\" Dynamically allocates the memory for the state of the plant\n * @param n\n * @param abstract_state\n * @return\n */\nstruct current_state *state_alloc(size_t n, int abstract_state);\n\n/**\n * @brief \"Destructor\" Deallocates the dynamically allocated memory of the state of the plant\n * @param state\n */\nvoid state_free(current_state *state);\n\n/**\n * @brief \"Constructor\" Dynamically allocates the memory for cost function matrices\n * @param n\n * @param m\n * @param N\n * @param distance_error_weight\n * @return\n */\nstruct cost_function *cost_function_alloc(size_t n,size_t m, size_t N, double distance_error_weight);\n\n/**\n * @brief \"Destructor\" Deallocates the dynamically allocated memory of the cost function matrices\n * @param cost_function\n */\nvoid cost_function_free(cost_function *cost_function);\n\n/**\n * @brief \"Constructor\" Dynamically allocates the memory for the discrete abstraction of the system\n * @param polytopes_in_region\n * @param polytope_sizes\n * @param hull_sizes\n * @param orig_polytopes_in_region\n * @param orig_polytope_sizes\n * @param orig_hull_sizes\n * @param n\n * @param abstract_states_count\n * @param number_of_original_regions\n * @param closed_loop\n * @param conservative\n * @param ord\n * @param time_horizon\n * @return\n */\nstruct discrete_dynamics *discrete_dynamics_alloc(int *polytopes_in_region,\n size_t *polytope_sizes,\n size_t *hull_sizes,\n int *orig_polytopes_in_region,\n size_t *orig_polytope_sizes,\n size_t *orig_hull_sizes,\n int *transitions_in_sizes,\n int *transitions_out_sizes,\n size_t n,\n int abstract_states_count,\n int number_of_original_regions,\n int closed_loop,\n int conservative,\n int ord,\n size_t time_horizon);\n/**\n * @brief \"Destructor\" Deallocates the dynamically allocated memory of the discrete dynamics\n * @param d_dyn\n */\nvoid discrete_dynamics_free(discrete_dynamics *d_dyn);\n\n\n/**\n *\n */\ntypedef struct control_computation_arguments{\n\n gsl_matrix *u;\n current_state * now;\n discrete_dynamics *d_dyn;\n system_dynamics *s_dyn;\n int target_abs_state;\n cost_function * f_cost;\n size_t current_time_horizon;\n polytope **polytope_list_backup;\n\n}control_computation_arguments;\n\ntypedef struct total_safemode_computation_arguments{\n\n current_state *now;\n gsl_matrix *u;\n polytope *current;\n polytope *safe;\n system_dynamics *s_dyn;\n size_t time_horizon;\n cost_function *f_cost;\n polytope **polytope_list_backup;\n\n}total_safemode_computation_arguments;\n\ntypedef struct next_safemode_computation_arguments{\n\n current_state *now;\n gsl_matrix *u;\n system_dynamics *s_dyn;\n size_t time_horizon;\n cost_function *f_cost;\n polytope **polytope_list_backup;\n\n}next_safemode_computation_arguments;\n\n/**\n * \"Constructor\" Dynamically allocates the space for the get_input thread\n */\nstruct control_computation_arguments *cc_arguments_alloc(current_state *now,\n gsl_matrix* u,\n system_dynamics *s_dyn,\n discrete_dynamics *d_dyn,\n cost_function *f_cost,\n size_t current_time_horizon,\n int target_abs_state,\n polytope **polytope_list);\n\n/**\n * \"Constructor\" Dynamically allocates the space for the arguments of the safemode computation thread\n */\nstruct total_safemode_computation_arguments *sm_arguments_alloc(current_state *now,\n gsl_matrix * u,\n polytope *current,\n polytope *safe,\n system_dynamics * s_dyn,\n size_t time_horizon,\n cost_function *f_cost,\n polytope **polytope_list_safemode);\n\n\n\n/**\n * \"Constructor\" Dynamically allocates the space for the arguments of the next step towards safemode computation thread\n */\nstruct next_safemode_computation_arguments *next_sm_arguments_alloc(current_state *now,\n gsl_matrix * u,\n system_dynamics * s_dyn,\n size_t time_horizon,\n cost_function *f_cost,\n polytope **polytope_list_safemode);\n#endif //CIMPLE_SYSTEM_H\n", "meta": {"hexsha": "002af29f31936abc55ba87a18d44f04e65665297", "size": 10723, "ext": "h", "lang": "C", "max_stars_repo_path": "Interface/Cimple/cimple_system.h", "max_stars_repo_name": "shaesaert/TuLiPXML", "max_stars_repo_head_hexsha": "56cf4d58a9d7e17b6f6aebe6de8d5a1231035671", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-05-28T23:44:28.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-28T23:44:28.000Z", "max_issues_repo_path": "Interface/Cimple/cimple_system.h", "max_issues_repo_name": "shaesaert/TuLiPXML", "max_issues_repo_head_hexsha": "56cf4d58a9d7e17b6f6aebe6de8d5a1231035671", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2017-10-03T18:54:08.000Z", "max_issues_repo_issues_event_max_datetime": "2018-08-21T09:50:09.000Z", "max_forks_repo_path": "Interface/Cimple/cimple_system.h", "max_forks_repo_name": "shaesaert/TuLiPXML", "max_forks_repo_head_hexsha": "56cf4d58a9d7e17b6f6aebe6de8d5a1231035671", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2018-10-06T12:58:52.000Z", "max_forks_repo_forks_event_max_datetime": "2018-10-06T12:58:52.000Z", "avg_line_length": 30.6371428571, "max_line_length": 119, "alphanum_fraction": 0.5614100532, "num_tokens": 2239, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8418256472515683, "lm_q2_score": 0.6334102636778401, "lm_q1q2_score": 0.5332210051963843}} {"text": "#include \n#include \n#include \n/*#include \n#include \n#include \n#include \n#include */\n#include \"ral_nlls.h\"\n\n/* define the usertype */\nstruct usertype {\n double y_data[67];\n double x_data[67];\n};\n\nvoid generate_data_example ( double *x_data, double *y_data, const int m); // prototype\nint eval_F ( const int n, const int m, void *params, \n const double *X, double *f);\nint eval_J ( const int n, const int m, void *params, \n const double *X, double *f);\nint eval_HF ( const int n, const int m, void *params, \n\t const double *X, const double *f, double *hf);\n\n/* A c driver for the ral_nlls program */\nint main(void) {\n \n /* Problem data */\n const int n = 2;\n const int m = 67;\n \n /* Derived types */\n struct ral_nlls_options options;\n struct ral_nlls_inform status;\n struct usertype params;\n \n printf(\"===============\\n\");\n printf(\"RAL NLLS driver\\n\");\n printf(\"~ C version ~\\n\");\n printf(\"===============\\n\");\n\n /* Generate the data... */\n generate_data_example(params.x_data,params.y_data,m);\n\n double x[n];\n x[0] = 1.0;\n x[1] = 2.0;\n\n ral_nlls_default_options(&options);\n \n options.print_level = 3;\n \n nlls_solve(n, m, x,\n\t eval_F, eval_J, eval_HF, ¶ms,\n\t &options, &status, NULL, NULL, NULL, NULL );\n\n int i;\n printf(\"\\nX = \\n\");\n for(i=0; i < n; i++) {\n printf(\" %5.4f \\n\",x[i]);\n }\n\n return 0; /* success */\n}\n\n/* Do a function evaluation */\nint eval_F(int n, int m, void *params, \n\t const double *X, double *f){\n \n struct usertype *myparams = (struct usertype *) params;\n\n int i;\n \n for(i=0; iy_data[i] - exp( X[0] * myparams->x_data[i] + X[1] );\n }\n\n return 0;\n}\n\n/* Evaluate the Jacobian */\nint eval_J( const int n, const int m, void *params, \n\t const double *X, double *J){\n \n struct usertype *myparams = (struct usertype *) params;\n\n int i;\n\n for(i=0; ix_data[i] * exp( X[0] * myparams->x_data[i] + X[1] );\n J[m + i] = - exp( X[0] * myparams->x_data[i] + X[1] );\n }\n \n return 0;\n}\n\n/* Evaluate the Hessian */\nint eval_HF( const int n, const int m, void *params, \n\t const double *X, const double *f, \n\t double *hf){\n \n struct usertype *myparams = (struct usertype *) params;\n\n int i;\n\n for(i=0; i\n#include\n#include\n#include\n#include\n#include \"../shared/toolkit_c.h\"\n\n#define BUB_MAXWORDS_LIMIT 100000\n\nstruct bub_options{\n\tdouble lambda_N;\n\tint use_weighting;\n\tdouble mesh_min;\n\tdouble mesh_max;\n\tdouble mesh_inc;\n\tint opt_use_weighting;\n\tdouble opt_mesh_min;\n\tdouble opt_mesh_max;\n\tdouble opt_mesh_inc;\n\tint bag_threshold;\n};\n\nint bag1(int N,double m,double *a,double lambda_0,struct bub_options *bubopts);\nint bub1(int N,double m,double *a,double lambda_0,int K,int compat,struct bub_options *bubopts);\nvoid make_binom(int N,int meshsize,double *p,double **B_jN);\nvoid make_weight(double *p,int meshsize,double m,int use_weighting,double *f,double *c);\ndouble compute_error(double *a,int N,double m,int compat,struct bub_options *bubopts);\n\nint entropy_bub(struct hist1d *in,struct options_entropy *opts,struct estimate *entropy)\n{\n\tdouble *a;\n\tint *h;\n\tdouble H;\n\tstruct bub_options *bubopts;\n\tdouble eps,epsm;\n\tint N,i,j,max_bin;\n\tdouble m;\n\tint status;\n\n\tN = (*in).P;\n\n\tif(opts->possible_words_flag==0)\n\t{\n\t\tif(opts->bub_possible_words_strategy==0)\n\t\t\tm = (double)in->C; \n\t\telse if(opts->bub_possible_words_strategy==1)\n\t\t\tm = (double)in->N; \n\t\telse if(opts->bub_possible_words_strategy==2)\n\t\t\tm = MIN(max_possible_words(in,1),BUB_MAXWORDS_LIMIT);\n\t\telse\n\t\t\tm = (double)in->C;\n\t}\n\telse\n\t\tif(opts->possible_words>0)\n\t\t\tm = opts->possible_words;\n\t\telse\n\t\t\tswitch((int)(opts->possible_words))\n\t\t\t{\n\t\t\t\tcase 0: /* Inf */\n\t\t\t\t\tentropy->value = NAN; /* this value based on piece-meal derivation when m=INFINITY */\n\t\t\t\t\treturn EXIT_SUCCESS;\n\t\t\t\tcase -1: /* recommended */\n\t\t\t\t\tm = (double)in->C;\n\t\t\t\t\tbreak;\n\t\t\t\tcase -2: /* unique */\n\t\t\t\t\tm = (double)in->C;\n\t\t\t\t\tbreak;\n\t\t\t\tcase -3: /* total */\n\t\t\t\t\tm = (double)in->P;\n\t\t\t\t\tbreak;\n\t\t\t\tcase -4: /* possible */\n\t\t\t\t\tm = max_possible_words(in,0);\n\t\t\t\t\tbreak;\n\t\t\t\tcase -5: /* min_tot_pos */\n\t\t\t\t\tm = max_possible_words(in,1);\n\t\t\t\t\tbreak;\n\t\t\t\tcase -6: /* min_lim_tot_pos */\n\t\t\t\t\tm = MIN(BUB_MAXWORDS_LIMIT,max_possible_words(in,1));\n\t\t\t\t\tbreak;\n\t\t\t}\n\n\t/* First find a vector */\n\ta = (double *)malloc((N+1)*sizeof(double));\n\n\tbubopts = (struct bub_options *)malloc(sizeof(struct bub_options));\n\t(*bubopts).bag_threshold = 20;\n\tif(N<(*bubopts).bag_threshold)\n\t{\n\t\t(*bubopts).lambda_N = 0;\n\t\t(*bubopts).mesh_min = 0;\n\t\t(*bubopts).mesh_max = 1;\n\t\t(*bubopts).mesh_inc = 1/(5*(double)N);\n\t\t(*bubopts).use_weighting = 0;\n\t\tstatus = bag1(N,m,a,(*opts).bub_lambda_0,bubopts);\n\t}\n\telse\n\t{\n\t\teps = (1/(double)N)*1e-10;\n\t\tepsm = (1/m)*1e-10;\n\t\t(*bubopts).lambda_N = 1;\n\t\t(*bubopts).mesh_min = eps;\n\t\t(*bubopts).mesh_max = MIN(1,3/(double)N)-eps;\n\t\t(*bubopts).mesh_inc = MIN(1,3/(double)N)/100;\n\t\t(*bubopts).lambda_N = 1;\n\t\t(*bubopts).use_weighting = 0;\n\t\t(*bubopts).opt_mesh_min = epsm;\n\t\t(*bubopts).opt_mesh_max = MIN(1,3/m)-epsm;\n\t\t(*bubopts).opt_mesh_inc = MIN(1,3/m)/100;\n\t\t(*bubopts).opt_use_weighting = 0;\n\t\tstatus = bub1(N,m,a,(*opts).bub_lambda_0,(*opts).bub_K,(*opts).bub_compat,bubopts);\n\t}\n\t \n\t/* Get counts of counts */\n\th = (int *)calloc(N+1,sizeof(int));\n\tfor(i=0; i<(*in).C; i++)\n\t\th[(int)(*in).wordcnt[i]]++;\n\n\t/* Then compute entropy */\n\tH = 0;\n\tfor(j=0; j<=N; j++)\n\t\tH += a[j]*h[j];\n\tentropy->value = NAT2BIT(H);\n\n\tfree(a);\n\tfree(h);\n\tfree(bubopts);\n\n\treturn EXIT_SUCCESS; /*\tTODO return status; reports errors with staverify.m - need to look into these errors and possibly pass them to message structure */\n}\n\nint bag1(int N,double m,double *a,double lambda_0,struct bub_options *bubopts)\n{\n\tint meshsize;\n\tint i,j;\n\tdouble *p,*Y,**X,**B_jN,*A_data,**D,*I0,*IN;\n\tdouble *f,c;\n\tgsl_vector *b,*x,*tau,*norm,*S,*work;\n\tgsl_matrix *A,*V;\n\tint *signum;\n\tint d_status, s_status, status = EXIT_SUCCESS;\n\n\tmeshsize = floor(((*bubopts).mesh_max-(*bubopts).mesh_min)/(*bubopts).mesh_inc)+1;\n\n\tA = gsl_matrix_calloc(meshsize+(N+1)+2,N+1);\n\tA_data = (*A).data;\n\tX = VectorToMatrixDouble(&A_data[0],meshsize,N+1);\n\tD = VectorToMatrixDouble(&A_data[meshsize*(N+1)],N+1,N+1);\n\tI0 = &A_data[(meshsize+(N+1))*(N+1)];\n\tIN = &A_data[(meshsize+(N+1)+1)*(N+1)];\n\n\tb = gsl_vector_calloc(meshsize+(N+1)+2);\n\tY = (*b).data;\n\n\t/* Make mesh */\n\tp = (double *)malloc(meshsize*sizeof(double));\n\tfor(i=0; i1/m)\n\t\t\tf[i] = 1./p[i];\n\t\telse\n\t\t\tf[i] = m;\n\n\tif(use_weighting)\n\t\t*c = 2;\n\telse\n\t\t*c = 1;\n}\n\ndouble compute_error(double *a,int N,double m,int compat,struct bub_options *bubopts)\n{\n\tint i,j;\n\tdouble max_bias,max_error,max_variance0,max_variance1;\n\tdouble *p,*f,**B_jN;\n\tdouble temp1,temp2,temp3,temp4,temp5;\n\tint meshsize;\n\tdouble c;\n\n\tmeshsize = floor(((*bubopts).opt_mesh_max-(*bubopts).opt_mesh_min)/(*bubopts).opt_mesh_inc)+1;\n\n\t/* Make mesh */\n\tp = (double *)malloc(meshsize*sizeof(double));\n\tfor(i=0; imax_bias)\n\t\t\tmax_bias = temp2;\n\t}\n\n\t/* Steele loose bound on variance */\n\tmax_variance1 = 0;\n\tfor(i=0; imax_variance1)\n\t\t\tmax_variance1 = temp4;\n\t}\n\tif(compat)\n\t\tmax_variance1 *= 4*N*c;\n\telse\n\t\tmax_variance1 *= 2*N*c;\n\n\t/* McDiarmid bound on variance */\n\tmax_variance0 = 0;\n\tfor(j=1; jmax_variance0)\n\t\t\tmax_variance0=temp5;\n\t}\n\tmax_variance0 = N*pow(max_variance0,2);\n\n#ifdef DEBUG\n\tprintf(\"maxbias=%f maxvariance0=%f maxvariance1=%f\\n\",max_bias,max_variance0,max_variance1);\n#endif\n\n\tmax_error = NAT2BIT(sqrt(pow(max_bias,2) + MIN(max_variance0,max_variance1)));\n\tfree(p);\n\tfree(f);\n\tFreeMatrixDouble(B_jN);\n\n\treturn max_error;\n}\n\n", "meta": {"hexsha": "63a45d2e08b08a5fe85180f07c66b3e0249c41fb", "size": 11483, "ext": "c", "lang": "C", "max_stars_repo_path": "Master-Code/spike/entropy/entropy_bub_c.c", "max_stars_repo_name": "joaodornas/random-code", "max_stars_repo_head_hexsha": "8db8cbccab674c4b77efaed86086dc6a99e5b9a1", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-01-13T05:01:59.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-13T05:01:59.000Z", "max_issues_repo_path": "Master-Code/spike/entropy/entropy_bub_c.c", "max_issues_repo_name": "joaodornas/random-code", "max_issues_repo_head_hexsha": "8db8cbccab674c4b77efaed86086dc6a99e5b9a1", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Master-Code/spike/entropy/entropy_bub_c.c", "max_forks_repo_name": "joaodornas/random-code", "max_forks_repo_head_hexsha": "8db8cbccab674c4b77efaed86086dc6a99e5b9a1", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 23.8731808732, "max_line_length": 156, "alphanum_fraction": 0.6338935818, "num_tokens": 4025, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8459424295406087, "lm_q2_score": 0.6297746074044135, "lm_q1q2_score": 0.5327530614506726}} {"text": "#include \n#include \n#include \n\nJNIEXPORT jint Java_JAMAJni_SingularValueDecomposition_dgesvd (JNIEnv *env, jclass klass, jint matrix_layout, jchar jobu, jchar jobvt, jint m, jint n, jdoubleArray a, jint lda, jdoubleArray s, jdoubleArray u, jint ldu, jdoubleArray vt, jint ldvt, jdoubleArray superb){\n \n //superb contains the unconverged superdiagonal elements of an upper bidiagonal matrix B whose diagonal is in S (not necessarily sorted).\n \n double *aElems, *sElems, *uElems, *vtElems, *superbElems;\n int info;\n \n aElems = (*env)-> GetDoubleArrayElements (env, a, NULL);\n sElems = (*env)-> GetDoubleArrayElements (env, s, NULL);\n uElems = (*env)-> GetDoubleArrayElements (env, u, NULL);\n vtElems = (*env)-> GetDoubleArrayElements (env, vt, NULL);\n superbElems = (*env)-> GetDoubleArrayElements (env, superb, NULL);\n \n assert(aElems && sElems && uElems && vtElems && superbElems);\n \n info = LAPACKE_dgesvd((int) matrix_layout, (char) jobu, (char) jobvt, (lapack_int) m, (lapack_int) n, aElems, (lapack_int) lda, sElems, uElems, (lapack_int) ldu, vtElems, (lapack_int) ldvt, superbElems);\n \n (*env)-> ReleaseDoubleArrayElements (env, a, aElems, 0);\n (*env)-> ReleaseDoubleArrayElements (env, s, sElems, 0);\n (*env)-> ReleaseDoubleArrayElements (env, u, uElems, 0);\n (*env)-> ReleaseDoubleArrayElements (env, vt, vtElems, 0);\n (*env)-> ReleaseDoubleArrayElements (env, superb, superbElems, 0);\n \n return info;\n}\n\nJNIEXPORT jint Java_JAMAJni_SingularValueDecomposition_dgesdd\n(JNIEnv *env, jclass klass, jint matrix_layout, jchar jobz, jint m, jint n,\n jdoubleArray a, jint lda, jdoubleArray s, jdoubleArray u, jint ldu,\n jdoubleArray vt, jint ldvt){\n \n double *aElems, *sElems, *uElems, *vtElems;\n int info;\n \n aElems = (*env)-> GetDoubleArrayElements (env, a, NULL);\n sElems = (*env)-> GetDoubleArrayElements (env, s, NULL);\n uElems = (*env)-> GetDoubleArrayElements (env, u, NULL);\n vtElems = (*env)-> GetDoubleArrayElements (env, vt, NULL);\n \n assert(aElems && sElems && uElems && vtElems);\n \n info = LAPACKE_dgesdd((int) matrix_layout, (char) jobz, (lapack_int) m, (lapack_int) n, aElems, (lapack_int) lda, sElems, uElems, (lapack_int) ldu, vtElems, (lapack_int) ldvt);\n \n (*env)-> ReleaseDoubleArrayElements (env, a, aElems, 0);\n (*env)-> ReleaseDoubleArrayElements (env, s, sElems, 0);\n (*env)-> ReleaseDoubleArrayElements (env, u, uElems, 0);\n (*env)-> ReleaseDoubleArrayElements (env, vt, vtElems, 0);\n \n return info;\n}\n\nJNIEXPORT jint Java_JAMAJni_SingularValueDecomposition_dgeev (JNIEnv *env, jclass klass, jint matrix_layout, jchar jobvl, jchar jobvr, jint n, jdoubleArray a, jint lda, jdoubleArray wr, jdoubleArray wi, jdoubleArray vl, jint ldvl, jdoubleArray vr, jint ldvr){\n \n double *aElems, *wrElems, *wiElems, *vlElems, *vrElems;\n int info;\n \n aElems = (*env)-> GetDoubleArrayElements (env, a, NULL);\n wrElems = (*env)-> GetDoubleArrayElements (env, wr, NULL);\n wiElems = (*env)-> GetDoubleArrayElements (env, wi, NULL);\n vlElems = (*env)-> GetDoubleArrayElements (env, vl, NULL);\n vrElems = (*env)-> GetDoubleArrayElements (env, vr, NULL);\n \n assert(aElems && wrElems && wiElems && vlElems && vrElems);\n \n info = LAPACKE_dgeev((int) matrix_layout, (char) jobvl, (char) jobvr, (lapack_int) n, aElems, (lapack_int) lda, wrElems, wiElems, vlElems, (lapack_int) ldvl, vrElems, (lapack_int) ldvr);\n \n (*env)-> ReleaseDoubleArrayElements (env, a, aElems, 0);\n (*env)-> ReleaseDoubleArrayElements (env, vl, vlElems, 0);\n (*env)-> ReleaseDoubleArrayElements (env, vr, vrElems, 0);\n (*env)-> ReleaseDoubleArrayElements (env, wr, wrElems, 0);\n (*env)-> ReleaseDoubleArrayElements (env, wi, wiElems, 0);\n \n return info;\n \n}\n\n\n", "meta": {"hexsha": "3293ac0a1caf786f80b70d3803fb01dd77fdf55b", "size": 3853, "ext": "c", "lang": "C", "max_stars_repo_path": "src/jni_lapacke/c/SingularValueDecomposition.c", "max_stars_repo_name": "dw6ja/JAMAJni", "max_stars_repo_head_hexsha": "2e7cb4e16bacffa965e49d905a87043e31a8a718", "max_stars_repo_licenses": ["AAL"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/jni_lapacke/c/SingularValueDecomposition.c", "max_issues_repo_name": "dw6ja/JAMAJni", "max_issues_repo_head_hexsha": "2e7cb4e16bacffa965e49d905a87043e31a8a718", "max_issues_repo_licenses": ["AAL"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/jni_lapacke/c/SingularValueDecomposition.c", "max_forks_repo_name": "dw6ja/JAMAJni", "max_forks_repo_head_hexsha": "2e7cb4e16bacffa965e49d905a87043e31a8a718", "max_forks_repo_licenses": ["AAL"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 46.987804878, "max_line_length": 268, "alphanum_fraction": 0.6786919284, "num_tokens": 1241, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7690802370707281, "lm_q2_score": 0.6926419831347361, "lm_q1q2_score": 0.5326972605944021}} {"text": "\n#include \"kepler.h\"\n\n#include \n#include \n#include \n\n#include \n#include \n#include \n\n#define OVERPHASE(x) ( 2.0 * M_PI * floor ( 0.5 + 0.5 * x * M_1_PI ) )\n\n#define DEBUG 0\n\n/****************************************************************************/\n\nstruct delta_params { double ecosmu, esinmu; };\n\nstatic double delta_f ( double delta, void *params ) {\n\n struct delta_params * op = ( struct delta_params * ) params;\n double ecosmu = op->ecosmu;\n double esinmu = op->esinmu;\n\n return ecosmu * sin(delta) + esinmu * cos(delta) - delta;\n\n}\n\nstatic double delta_df ( double delta, void *params ) {\n\n struct delta_params * op = ( struct delta_params * ) params;\n double ecosmu = op->ecosmu;\n double esinmu = op->esinmu;\n\n return ecosmu * cos(delta) - esinmu * sin(delta) - 1.0;\n\n}\n\nstatic void delta_fdf ( double delta, void *params, double * f, double * df ) {\n struct delta_params * op = ( struct delta_params * ) params;\n double ecosmu = op->ecosmu;\n double esinmu = op->esinmu;\n double cosdelta = cos(delta);\n double sindelta = sin(delta);\n *f = ecosmu * sindelta + esinmu * cosdelta - delta;\n *df = ecosmu * cosdelta - esinmu * sindelta - 1.0;\n}\n\ndouble kepler_psiofmu ( double mu, double ecc ) {\n\n int status;\n int iter = 0, max_iter = 100;\n double x0, x, x_expected;\n gsl_function_fdf FDF;\n static gsl_root_fdfsolver * solver;\n static int solverexists = 0;\n struct delta_params params = { ecc * cos(mu), ecc * sin(mu) };\n\n if ( ! solverexists ) { solverexists = 1;\n solver = gsl_root_fdfsolver_alloc ( gsl_root_fdfsolver_newton );\n }\n\n if ( DEBUG ) printf( \"kepler_psiofmu ( mu = %lg, ecc = %lg )\\n\", mu, ecc );\n\n /* early exit make this more tollerant */\n if ( 0.0 == ecc ) return mu;\n if ( 0.0 == mu - OVERPHASE(mu) ) return 0.0;\n\n FDF.f = &delta_f;\n FDF.df = &delta_df;\n FDF.fdf = &delta_fdf;\n FDF.params = ¶ms;\n\n x_expected = x = (¶ms)->esinmu;\n\n gsl_root_fdfsolver_set (solver, &FDF, x);\n\n if ( DEBUG ) printf (\"using %s method\\n\", gsl_root_fdfsolver_name (solver));\n if ( DEBUG ) printf (\"%-5s %10s %10s\\n\", \"iter\", \"root\", \"err\");\n\n do {\n iter++;\n status = gsl_root_fdfsolver_iterate (solver);\n x0 = x;\n x = gsl_root_fdfsolver_root (solver);\n status = gsl_root_test_delta (x, x0, 0, 1e-3);\n if ( DEBUG && status == GSL_SUCCESS ) printf (\"Converged:\\n\");\n if ( DEBUG ) printf (\"%5d %10.7f %+10.7f\\n\", iter, x, x - x_expected);\n } while (status == GSL_CONTINUE && iter < max_iter);\n\n if ( DEBUG ) printf( \"kepler_psiofmu ( mu = %lg, ecc = %lg ) = %lg\\n\",\n mu, ecc, mu+x );\n\n return mu + x;\n\n}\n\n/****************************************************************************/\n\ndouble kepler_thetaofmu ( double mu, double ecc ) {\n\n double overmu = OVERPHASE(mu), psi, theta;\n\n psi = kepler_psiofmu ( mu, ecc );\n theta = 2.0 * atan( sqrt((1.0+ecc)/(1.0-ecc)) * tan(0.5*psi) );\n\n return overmu + theta;\n\n}\n\n/****************************************************************************/\n\ndouble kepler_rv ( double mu, double ecc, double omega ) {\n\n double psi, theta;\n\n psi = kepler_psiofmu ( mu, ecc );\n theta = 2.0 * atan( sqrt((1.0+ecc)/(1.0-ecc)) * tan(0.5*psi) );\n\n return cos(theta + omega) + ecc*cos(omega);\n}\n\n/****************************************************************************/\n\ndouble kepler_lite ( double mu, double ecc, double omega ) {\n\n double psi, theta;\n\n psi = kepler_psiofmu ( mu, ecc );\n theta = 2.0 * atan( sqrt((1.0+ecc)/(1.0-ecc)) * tan(0.5*psi) );\n\n return (1.0 - ecc*ecc) * sin(theta + omega) / (1.0 + ecc*cos(theta));\n}\n\n/****************************************************************************/\n\ndouble kepler_sep ( double mu, double ecc, double omega, double inc ) {\n\n double psi, theta, tmpd;\n\n psi = kepler_psiofmu ( mu, ecc );\n theta = 2.0 * atan( sqrt((1.0+ecc)/(1.0-ecc)) * tan(0.5*psi) );\n tmpd = sin(theta + omega) * sin(inc);\n tmpd = sqrt(1.0 - tmpd*tmpd);\n\n return tmpd * (1.0 - ecc*ecc) / (1.0 + ecc * cos(theta));\n}\n\n/****************************************************************************/\n\n", "meta": {"hexsha": "fecfcab6f8aabc1e677c075b2db11d42b3c0ae19", "size": 4130, "ext": "c", "lang": "C", "max_stars_repo_path": "fd3_Jul2014update/kepler.c", "max_stars_repo_name": "mrawls/FDBinary-tools", "max_stars_repo_head_hexsha": "26b78a12df53d9a1a477fcf247cbf2dad8c39836", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2020-05-25T09:45:03.000Z", "max_stars_repo_stars_event_max_datetime": "2020-08-28T14:43:53.000Z", "max_issues_repo_path": "fd3_Jul2014update/kepler.c", "max_issues_repo_name": "mrawls/FDBinary-tools", "max_issues_repo_head_hexsha": "26b78a12df53d9a1a477fcf247cbf2dad8c39836", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "fd3_Jul2014update/kepler.c", "max_forks_repo_name": "mrawls/FDBinary-tools", "max_forks_repo_head_hexsha": "26b78a12df53d9a1a477fcf247cbf2dad8c39836", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.1710526316, "max_line_length": 79, "alphanum_fraction": 0.5503631961, "num_tokens": 1269, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8221891305219503, "lm_q2_score": 0.647798211152541, "lm_q1q2_score": 0.5326126479811825}} {"text": "/* \n * File: BlshIndex.h\n * Author: chteflio\n *\n * Created on March 4, 2016, 3:19 PM\n */\n\n#ifndef BLSHINDEX_H\n#define\tBLSHINDEX_H\n\n#include \n#include \n#include \n#include \n#include \n\nnamespace mips {\n \n\n class BlshIndex : public LshIndex {\n\n int computeMinMatches(int nTrials) {\n double p;\n double epsilon = 1 - R;\n int guess = nTrials / 2;\n int start = 0;\n int end = nTrials;\n\n // std::cout<<\"threshold: \"< epsilon) {\n if (start == end) {\n retValue = start - 1;\n break;\n }\n end = guess - 1;\n if (end < start) {\n retValue = guess - 1;\n break;\n }\n } else if (p < epsilon) {\n if (start == end) {\n retValue = start;\n break;\n }\n start = guess + 1;\n if (start > end) {\n retValue = guess;\n break;\n }\n } else {\n retValue = guess;\n break;\n }\n guess = (start + end) / 2;\n if (end < 0 || start > nTrials) {\n std::cout << \"Problem in computeMinMatches start \" << start << \" end \" << end << std::endl;\n exit(1);\n }\n\n } while (1);\n\n if (retValue < 0)\n retValue = 0;\n else if (retValue > nTrials)\n retValue = nTrials;\n\n return retValue;\n }\n\n\n inline double posteriorCdf(double s, double n, double x) {\n if (x >= 1.0)\n return 1.0;\n if (x <= 0.5)\n return 0;\n double b1 = 1.0;\n double bHalf = boost::math::ibeta(s + 1, n - s + 1, 0.5);\n double bx = boost::math::ibeta(s + 1, n - s + 1, x);\n double den = b1 - bHalf;\n if (den < 1.0e-15)\n return exp(log(bx - bHalf) - log(den));\n else\n return (bx - bHalf) / den;\n\n\n }\n\n public:\n double minMathesT; // threshold for matching, r = c2r(simT)\n long long hashGroups = 0;\n int32_t *minMatches; // minimum number of hashes that should be observed to meet simT \n double R;\n double worst;\n\n BlshIndex() : LshIndex(), minMathesT(0), minMatches(nullptr) {\n }\n\n inline ~BlshIndex() {\n if (minMatches != nullptr)\n delete[] minMatches;\n }\n\n inline void allocateBayesLSHMemory(double worstCaseTheta) {\n if (minMatches == nullptr) {\n // set up cache space and pre-compute all minimum matches \n minMatches = da_i32malloc(hashGroups, NULL); //\"allocateBayesLSHMemory: minMatches\"\n \n\n // std::cout << \"worstCaseTheta: \" << worstCaseTheta << std::endl; \n minMathesT = (1.0 - acos(worstCaseTheta) * INVPI); // min matches threshold\n for (int i = 0; i < hashGroups; i++) {\n minMatches[i] = computeMinMatches((i + 1) * 32);\n // std::cout<alloc();\n\n if (forProbeVectors) {\n switch (LSH_CODE_LENGTH) {\n case 8:\n lshBins = new LshBinsDense();\n break;\n case 16:\n lshBins = new LshBinsSparse();\n break;\n case 24:\n case 32:\n lshBins = new LshBinsSparse();\n break;\n default:\n lshBins = new LshBinsSparse();\n break;\n }\n\n lshBins->init(cosSketches->bytesPerCode, cosSketches->numHashTables, cosSketches->nVectors);\n }\n\n if (worstCaseTheta < std::numeric_limits::max()) {\n if (worstCaseTheta > 0) {\n worstCaseTheta /= matrix.getVectorLength(start);\n worstCaseTheta = (worstCaseTheta > 1 ? 1 : worstCaseTheta); // it will break in the loop afterwards\n\n } else {\n worstCaseTheta /= matrix.getVectorLength(end - 1);\n worstCaseTheta = (worstCaseTheta < -1 ? -1 : worstCaseTheta); // it will have to check everything\n }\n\n worst = worstCaseTheta;\n allocateBayesLSHMemory(worstCaseTheta);\n }\n\n\n initialized = true;\n }\n omp_unset_lock(&writelock);\n }\n\n };\n\n}\n\n\n#endif\t/* BLSHINDEX_H */\n\n", "meta": {"hexsha": "9c8201dd2bb4f888075d84981bba49d3b7aa877a", "size": 6171, "ext": "h", "lang": "C", "max_stars_repo_path": "mips/structs/BlshIndex.h", "max_stars_repo_name": "uma-pi1/LEMP", "max_stars_repo_head_hexsha": "e24ce821692aba8403ca8733382f53641f7f96d5", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 7.0, "max_stars_repo_stars_event_min_datetime": "2018-07-28T07:05:37.000Z", "max_stars_repo_stars_event_max_datetime": "2020-11-16T17:34:42.000Z", "max_issues_repo_path": "mips/structs/BlshIndex.h", "max_issues_repo_name": "d3v3l0/LEMP-benchmarking", "max_issues_repo_head_hexsha": "0279528b427aa4fae59e4d3598b1f098fcb4cf4b", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2021-12-16T03:30:55.000Z", "max_issues_repo_issues_event_max_datetime": "2021-12-16T03:30:55.000Z", "max_forks_repo_path": "mips/structs/BlshIndex.h", "max_forks_repo_name": "d3v3l0/LEMP-benchmarking", "max_forks_repo_head_hexsha": "0279528b427aa4fae59e4d3598b1f098fcb4cf4b", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 9.0, "max_forks_repo_forks_event_min_datetime": "2015-09-16T08:21:24.000Z", "max_forks_repo_forks_event_max_datetime": "2019-12-04T06:37:41.000Z", "avg_line_length": 33.1774193548, "max_line_length": 130, "alphanum_fraction": 0.4289418247, "num_tokens": 1366, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8221891218080991, "lm_q2_score": 0.6477982043529716, "lm_q1q2_score": 0.5326126367458333}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"su2_matrix.c\"\n\n#ifndef gauge_config\n#include \"config.h\"\n#define gauge_config 1\n\n#define sq(x) ((x)*(x))\n#define cb(x) ((x)*(x)*(x))\n#endif\n\nint acc, tot; // acceptance rate\n\n#define FORWARD 1 //true\n#define BACKWARD 0 //false\n\n// Access pattern methods --------------------------------------------------\n\n// index of link site=(t,x,y,z) in direction dir\nint index(const int* site, int dir){\n return dir+site[0]*4+site[1]*N*4+site[2]*N*N*4+site[3]*N*N*N*4;\n}\n\n// shift site array by one to direction dir\nvoid shift(int* site, int dir, int forward){\n if(forward == 1){\n site[dir] = (site[dir]+1)%N;\n }else{\n site[dir] = (site[dir]-1+N)%N;\n }\n}\n\n// end of access pattern methods -------------------------------------------\n\n// Plaquette methods -------------------------------------------------------\n\n// plaquette operator at site (t,x,y,z) in plane (mu,nu)\n// normally mu>nu\ndouble plaquette(const su2_matrix* links, int mu, int nu, int* site){\n su2_matrix A,B,C,D;\n A = links[index(site,mu)];\n shift(site,mu,FORWARD);\n B = links[index(site,nu)];\n shift(site,mu,BACKWARD);\n shift(site,nu,FORWARD);\n C = su2_inv(links[index(site,mu)]);\n shift(site,nu,BACKWARD); // restore site position\n D = su2_inv(links[index(site,nu)]);\n\n A = su2_mul(A,B);\n A = su2_mul(A,C);\n A = su2_mul(A,D);\n\n return su2_trace(A)/2.0;\n}\n\ndouble plaquette_mean(const su2_matrix* links, int mu, int nu){\n double mean = 0;\n int site[4];\n for(int z=0;z0){\n if(exp(-dS) nu\ndouble action(su2_matrix* links, int* site, int dir){\n int mu,nu;\n double result=0;\n for(int k=0; k<4; k++){\n if(k==dir) continue; // loop over planes\n if(k>dir){mu=k; nu=dir;} // mu=larger number\n if(k\n#include \n\n/** Use Apple's Accelerate library for LAPACK and BLAS */\n#ifdef __APPLE__\n#include \n#else\n#include \n#include \n#define USE_LAPACKE\n#endif\n\n#define EPS 1e-16\n\n/** @brief Normalizes a vector\n * @param[in] in - input vector\n * @param[out] out - output vector. */\nvoid mat3d_vectornormalize(vec3 in, vec3 out) {\n float norm=cblas_snrm2(3, in, 1);\n if (norm>EPS) norm = 1.0/norm;\n if (out!=in) cblas_scopy(3, in, 1, out, 1);\n cblas_sscal(3, norm, out, 1);\n}\n\n/** @brief Stores the identity matrix in out.\n * @param[out] out - output matrix. */\nvoid mat3d_identity4x4(mat4x4 out) {\n static float ident[] = { 1.0f, 0.0f, 0.0f, 0.0f,\n 0.0f, 1.0f, 0.0f, 0.0f,\n 0.0f, 0.0f, 1.0f, 0.0f,\n 0.0f, 0.0f, 0.0f, 1.0f };\n cblas_scopy(16, ident, 1, out, 1);\n}\n\n/** @brief Stores the identity matrix in out.\n * @param[out] out - output matrix. */\nvoid mat3d_identity3x3(mat4x4 out) {\n static float ident[] = { 1.0f, 0.0f, 0.0f,\n 0.0f, 1.0f, 0.0f,\n 0.0f, 0.0f, 1.0f };\n cblas_scopy(9, ident, 1, out, 1);\n}\n\n/** @brief Multiply out = a*b\n * @param[in] a input matrix\n * @param[in] b input matrix\n * @param[out] out filled with a*b\n * @warning: out must be distinct from a and b */\nvoid mat3d_mul4x4(mat4x4 a, mat4x4 b, mat4x4 out) {\n cblas_sgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, 4, 4, 4, 1.0, a, 4, b, 4, 0.0, out, 4);\n}\n\n/** @brief Multiply: out = a*b\n * @param[in] a input matrix\n * @param[in] b input matrix\n * @param[out] out filled with a*b\n * @warning: out must be distinct from a and b */\nvoid mat3d_mul3x3(mat3x3 a, mat3x3 b, mat3x3 out) {\n cblas_sgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, 3, 3, 3, 1.0, a, 3, b, 3, 0.0, out, 3);\n}\n\n/** @brief Add with scale: out = a + alpha*b\n * @param[in] a input matrix\n * @param[in] b input matrix\n * @param[out] out filled with a + alpha*b */\nvoid mat3d_addscale3x3(mat3x3 a, float alpha, mat3x3 b, mat3x3 out) {\n if (a!=out) cblas_scopy(9, a, 1, out, 1);\n cblas_saxpy(9, alpha, b, 1, out, 1);\n}\n\n/** @brief Copy: out = a\n * @param[in] a input matrix\n * @param[out] out filled with a*b */\nvoid mat3d_copy4x4(mat4x4 a, mat4x4 out) {\n cblas_scopy(16, a, 1, out, 1);\n}\n\n/** @brief Matrix inversion\n * @param[in] a input matrix\n * @param[out] out filled with inverse(a) */\nvoid mat3d_invert4x4(mat4x4 a, mat4x4 out) {\n int m = 4, n = 4;\n int piv[4];\n int info;\n /* Copy a into out */\n memcpy(out, a, sizeof(float)*16);\n /* Compute LU decomposition, storing result in place */\n#ifdef USE_LAPACKE\n info = LAPACKE_sgetrf(LAPACK_COL_MAJOR, m, n, out, m, piv);\n#else\n sgetrf_(&m, &n, out, &m, piv, &info);\n#endif\n \n if (!info) {\n /* Now compute inverse */\n#ifdef USE_LAPACKE\n info=LAPACKE_sgetri(LAPACK_COL_MAJOR, n, out, n, piv);\n#else\n float work[16];\n int lwork=16;\n sgetri_(&n, out, &n, piv, work, &lwork, &info);\n#endif\n }\n}\n\n/** @brief Convert a 3x3 matrix to a 4x4 matrix\n * @param[in] in input matrix\n * @param[out] out filled with inverse(a) */\nvoid mat3d_lift(mat3x3 in, mat4x4 out) {\n mat4x4 new = { in[0], in[1], in[2], 0.0f, // Col major order!\n in[3], in[4], in[5], 0.0f,\n in[6], in[7], in[8], 0.0f,\n 0.0f, 0.0f, 0.0f, 1.0f };\n cblas_scopy(16, new, 1, out, 1);\n}\n\n/** @brief Print a 3x3 matrix */\nvoid mat3d_print3x3(mat3x3 in) {\n for (unsigned int j=0; j<3; j++) { // row\n printf(\"[ \");\n for (unsigned int i=0; i<3; i++) { // column\n printf(\"%g \", in[i*3+j]);\n }\n printf(\"]\\n\");\n }\n}\n\n/** @brief Print a 3x3 matrix */\nvoid mat3d_print4x4(mat4x4 in) {\n for (unsigned int j=0; j<4; j++) { // row\n printf(\"[ \");\n for (unsigned int i=0; i<4; i++) { // column\n printf(\"%g \", in[i*4+j]);\n }\n printf(\"]\\n\");\n }\n}\n\n/** @brief Translate by a vector\n * @param[in] in input matrix\n * @param[in] vec translation vector\n * @param[out] out on output, contains T*in where T is the translation matrix computed from vec */\nvoid mat3d_translate(mat4x4 in, vec3 vec, mat4x4 out) {\n mat4x4 tr = { 1.0f, 0.0f, 0.0f, 0.0f, // Col major order!\n 0.0f, 1.0f, 0.0f, 0.0f,\n 0.0f, 0.0f, 1.0f, 0.0f,\n vec[0], vec[1], vec[2], 1.0f };\n mat4x4 in2;\n if (in==out) mat3d_copy4x4(in, in2); /* Use a copy if in and out are the same matrix */\n if (in) mat3d_mul4x4(tr, (in==out ? in2 : in), out);\n else mat3d_copy4x4(tr, out);\n}\n\n/** @brief Scale by a factor\n * @param[in] in input matrix\n * @param[in] scale scale factor\n * @param[out] out on output, contains T*in where T is the translation matrix computed from vec */\nvoid mat3d_scale(mat4x4 in, float scale, mat4x4 out) {\n mat4x4 tr = { scale, 0.0f, 0.0f, 0.0f, // Col major order!\n 0.0f, scale, 0.0f, 0.0f,\n 0.0f, 0.0f, scale, 0.0f,\n 0.0f, 0.0f, 0.0f, 1.0f };\n mat4x4 in2;\n if (in==out) mat3d_copy4x4(in, in2); /* Use a copy if in and out are the same matrix */\n if (in) mat3d_mul4x4(tr, (in==out ? in2 : in), out);\n else mat3d_copy4x4(tr, out);\n}\n\n/** @brief Rotate by angle around an axis\n * @param[in] in input matrix\n * @param[in] axis rotation axis\n * @param[in] angle rotation angle\n * @param[out] out on output, contains R*in where R is the translation matrix computed from vec */\nvoid mat3d_rotate(mat4x4 in, vec3 axis, float angle, mat4x4 out) {\n vec3 u;\n mat3x3 rot;\n mat4x4 rot4;\n mat4x4 in2;\n if (in==out) mat3d_copy4x4(in, in2); /* Use a copy if in and out are the same matrix */\n \n /* Construct rotation matrix from Rodrigues formula */\n mat3d_vectornormalize(axis, u);\n mat3x3 w = { 0.0f, u[2], -u[1], // Col major order\n -u[2], 0.0f, u[0],\n u[1], -u[0], 0.0f };\n mat3x3 w2;\n \n /* Rodrigues formula: R = I + sin(a) W + 2 sin(a/2)^2 W^2 */\n mat3d_identity3x3(rot);\n mat3d_addscale3x3(rot, sin(angle), w, rot);\n mat3d_mul3x3(w, w, w2);\n float phi = sin(angle/2);\n mat3d_addscale3x3(rot, 2*phi*phi, w2, rot);\n \n /* Convert to 4x4 matrix */\n mat3d_lift(rot, rot4);\n\n /* Multiply the input matrix by this */\n if (in) mat3d_mul4x4(rot4, (in==out ? in2 : in), out);\n else mat3d_copy4x4(rot4, out);\n}\n\n/** @brief Orthographic projection matrix\n * @param[in] in input matrix\n * @param[in] left } Bounds of the viewing area\n * @param[in] right }\n * @param[in] bottom }\n * @param[in] top }\n * @param[in] near }\n * @param[in] far }\n * @param[out] out on output, contains R*in where R is the translation matrix computed from vec */\nvoid mat3d_ortho(mat4x4 in, mat4x4 out, float left, float right, float bottom, float top, float near, float far) {\n mat4x4 pr = { 2.0f/(right-left), 0.0f, 0.0f, 0.0f, // Col major order!\n 0.0f, 2.0f/(top-bottom), 0.0f, 0.0f,\n 0.0f, 0.0f, -2.0f/(far-near), 0.0f,\n 0.0f, 0.0f, 0.0f, 1.0f };\n mat4x4 in2;\n if (in==out) mat3d_copy4x4(in, in2); /* Use a copy if in and out are the same matrix */\n \n /* Multiply the input matrix by this */\n if (in) mat3d_mul4x4(pr, (in==out ? in2 : in), out);\n else mat3d_copy4x4(pr, out);\n}\n\n/** @brief Perspective projection matrix\n * @param[in] in input matrix\n * @param[in] left } Bounds of the viewing area\n * @param[in] right }\n * @param[in] bottom }\n * @param[in] top }\n * @param[in] near }\n * @param[in] far }\n * @param[out] out on output, contains R*in where R is the translation matrix computed from vec */\nvoid mat3d_frustum(mat4x4 in, mat4x4 out, float left, float right, float bottom, float top, float near, float far) {\n mat4x4 pr = { 2*near/(right-left), 0.0f, 0.0f, 0.0f, // Col major order!\n 0.0f, 2*near/(top-bottom), 0.0f, 0.0f,\n (right+left)/(right-left), (top+bottom)/(top-bottom), -(far+near)/(far-near), -1.0f,\n 0.0f, 0.0f, -2*far*near/(far-near), 0.0f };\n mat4x4 in2;\n if (in==out) mat3d_copy4x4(in, in2); /* Use a copy if in and out are the same matrix */\n \n /* Multiply the input matrix by this */\n if (in) mat3d_mul4x4(pr, (in==out ? in2 : in), out);\n else mat3d_copy4x4(pr, out);\n}\n", "meta": {"hexsha": "3f555cf409690def174c0c3f4e3dd1401f913610", "size": 8569, "ext": "c", "lang": "C", "max_stars_repo_path": "morphoview/matrix3d.c", "max_stars_repo_name": "mattsep/morpho", "max_stars_repo_head_hexsha": "50bb935653c0675b81e9f2d78573cf117971a147", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 10.0, "max_stars_repo_stars_event_min_datetime": "2021-09-18T14:44:14.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-26T11:41:50.000Z", "max_issues_repo_path": "morphoview/matrix3d.c", "max_issues_repo_name": "mattsep/morpho", "max_issues_repo_head_hexsha": "50bb935653c0675b81e9f2d78573cf117971a147", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 79.0, "max_issues_repo_issues_event_min_datetime": "2021-10-05T17:33:19.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T16:06:10.000Z", "max_forks_repo_path": "morphoview/matrix3d.c", "max_forks_repo_name": "mattsep/morpho", "max_forks_repo_head_hexsha": "50bb935653c0675b81e9f2d78573cf117971a147", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-10-05T16:56:16.000Z", "max_forks_repo_forks_event_max_datetime": "2021-10-31T19:55:27.000Z", "avg_line_length": 33.8695652174, "max_line_length": 116, "alphanum_fraction": 0.5785972692, "num_tokens": 3174, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8354835330070839, "lm_q2_score": 0.6370307806984444, "lm_q1q2_score": 0.5322287272921972}} {"text": "/*\n * test_shaw.c\n *\n * Test L-curve (Tikhonov) regression routines using Shaw\n * problem. See example 1.10 of\n *\n * [1] R.C. Aster, B. Borchers and C. H. Thurber,\n * Parameter Estimation and Inverse Problems (2nd ed), 2012.\n */\n\n#include \n\n/* alternate (and inefficient) method of computing G(lambda) */\nstatic double\nshaw_gcv_G(const double lambda, const gsl_matrix * X, const gsl_vector * y,\n gsl_multifit_linear_workspace * work)\n{\n const size_t n = X->size1;\n const size_t p = X->size2;\n gsl_matrix * XTX = gsl_matrix_alloc(p, p);\n gsl_matrix * XI = gsl_matrix_alloc(p, n);\n gsl_matrix * XXI = gsl_matrix_alloc(n, n);\n gsl_vector * c = gsl_vector_alloc(p);\n gsl_vector_view d;\n double rnorm, snorm;\n double term1, term2, G;\n size_t i;\n\n /* compute regularized solution with this lambda */\n gsl_multifit_linear_solve(lambda, X, y, c, &rnorm, &snorm, work);\n\n /* compute X^T X */\n gsl_blas_dsyrk(CblasLower, CblasTrans, 1.0, X, 0.0, XTX);\n\n /* add lambda*I */\n d = gsl_matrix_diagonal(XTX);\n gsl_vector_add_constant(&d.vector, lambda * lambda);\n\n /* invert (X^T X + lambda*I) */\n gsl_linalg_cholesky_decomp1(XTX);\n gsl_linalg_cholesky_invert(XTX);\n gsl_matrix_transpose_tricpy('L', 0, XTX, XTX);\n\n /* XI = (X^T X + lambda*I)^{-1} X^T */\n gsl_blas_dgemm(CblasNoTrans, CblasTrans, 1.0, XTX, X, 0.0, XI);\n\n /* XXI = X (X^T X + lambda*I)^{-1} X^T */\n gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, 1.0, X, XI, 0.0, XXI);\n\n /* compute: term1 = Tr(I - X XI) */\n term1 = 0.0;\n for (i = 0; i < n; ++i)\n {\n double *Ai = gsl_matrix_ptr(XXI, i, i);\n term1 += 1.0 - (*Ai);\n }\n\n gsl_matrix_free(XTX);\n gsl_matrix_free(XI);\n gsl_matrix_free(XXI);\n gsl_vector_free(c);\n\n term2 = rnorm / term1;\n\n return term2 * term2;;\n}\n\n/* construct design matrix and rhs vector for Shaw problem */\nstatic int\nshaw_system(gsl_matrix * X, gsl_vector * y)\n{\n int s = GSL_SUCCESS;\n const size_t n = X->size1;\n const size_t p = X->size2;\n const double dtheta = M_PI / (double) p;\n size_t i, j;\n gsl_vector *m = gsl_vector_alloc(p);\n\n /* build the design matrix */\n for (i = 0; i < n; ++i)\n {\n double si = (i + 0.5) * M_PI / n - M_PI / 2.0;\n double csi = cos(si);\n double sni = sin(si);\n\n for (j = 0; j < p; ++j)\n {\n double thetaj = (j + 0.5) * M_PI / p - M_PI / 2.0;\n double term1 = csi + cos(thetaj);\n double term2 = gsl_sf_sinc(sni + sin(thetaj));\n double Xij = term1 * term1 * term2 * term2 * dtheta;\n\n gsl_matrix_set(X, i, j, Xij);\n }\n }\n\n /* construct coefficient vector */\n {\n const double a1 = 2.0;\n const double a2 = 1.0;\n const double c1 = 6.0;\n const double c2 = 2.0;\n const double t1 = 0.8;\n const double t2 = -0.5;\n\n for (j = 0; j < p; ++j)\n {\n double tj = -M_PI / 2.0 + (j + 0.5) * dtheta;\n double mj = a1 * exp(-c1 * (tj - t1) * (tj - t1)) +\n a2 * exp(-c2 * (tj - t2) * (tj - t2));\n gsl_vector_set(m, j, mj);\n }\n }\n\n /* construct rhs vector */\n gsl_blas_dgemv(CblasNoTrans, 1.0, X, m, 0.0, y);\n\n gsl_vector_free(m);\n\n return s;\n}\n\nstatic int\ntest_shaw_system_l(gsl_rng *rng_p, const size_t n, const size_t p,\n const double lambda_expected,\n gsl_vector *rhs)\n{\n const size_t npoints = 1000; /* number of points on L-curve */\n const double tol1 = 1.0e-12;\n const double tol2 = 1.0e-9;\n const double tol3 = 1.0e-5;\n gsl_vector * reg_param = gsl_vector_alloc(npoints);\n gsl_vector * rho = gsl_vector_alloc(npoints);\n gsl_vector * eta = gsl_vector_alloc(npoints);\n\n gsl_matrix * X = gsl_matrix_alloc(n, p);\n gsl_matrix * cov = gsl_matrix_alloc(p, p);\n gsl_vector * c = gsl_vector_alloc(p);\n gsl_vector * ytmp = gsl_vector_alloc(n);\n gsl_vector * y;\n gsl_vector * r = gsl_vector_alloc(n);\n gsl_multifit_linear_workspace * work = \n gsl_multifit_linear_alloc (n, p);\n\n size_t reg_idx, i;\n double lambda, rnorm, snorm;\n\n /* build design matrix */\n shaw_system(X, ytmp);\n\n if (rhs)\n y = rhs;\n else\n {\n y = ytmp;\n\n /* add random noise to exact rhs vector */\n test_random_vector_noise(rng_p, y);\n }\n\n /* SVD decomposition */\n gsl_multifit_linear_svd(X, work);\n\n /* calculate L-curve */\n gsl_multifit_linear_lcurve(y, reg_param, rho, eta, work);\n\n /* test rho and eta vectors */\n for (i = 0; i < npoints; ++i)\n {\n double rhoi = gsl_vector_get(rho, i);\n double etai = gsl_vector_get(eta, i);\n double lami = gsl_vector_get(reg_param, i);\n\n /* solve regularized system and check for consistent rho/eta values */\n gsl_multifit_linear_solve(lami, X, y, c, &rnorm, &snorm, work);\n gsl_test_rel(rhoi, rnorm, tol3, \"shaw rho n=%zu p=%zu lambda=%e\",\n n, p, lami);\n gsl_test_rel(etai, snorm, tol1, \"shaw eta n=%zu p=%zu lambda=%e\",\n n, p, lami);\n }\n\n /* calculate corner of L-curve */\n gsl_multifit_linear_lcorner(rho, eta, ®_idx);\n\n lambda = gsl_vector_get(reg_param, reg_idx);\n\n /* test against known lambda value if given */\n if (lambda_expected > 0.0)\n {\n gsl_test_rel(lambda, lambda_expected, tol1,\n \"shaw: n=%zu p=%zu L-curve corner lambda\",\n n, p);\n }\n\n /* compute regularized solution with optimal lambda */\n gsl_multifit_linear_solve(lambda, X, y, c, &rnorm, &snorm, work);\n\n /* compute residual norm ||y - X c|| */\n gsl_vector_memcpy(r, y);\n gsl_blas_dgemv(CblasNoTrans, 1.0, X, c, -1.0, r);\n\n /* test rnorm value */\n gsl_test_rel(rnorm, gsl_blas_dnrm2(r), tol2,\n \"shaw: n=%zu p=%zu rnorm\", n, p);\n\n /* test snorm value */\n gsl_test_rel(snorm, gsl_blas_dnrm2(c), tol2,\n \"shaw: n=%zu p=%zu snorm\", n, p);\n\n gsl_matrix_free(X);\n gsl_matrix_free(cov);\n gsl_vector_free(reg_param);\n gsl_vector_free(rho);\n gsl_vector_free(eta);\n gsl_vector_free(r);\n gsl_vector_free(c);\n gsl_vector_free(ytmp);\n gsl_multifit_linear_free(work);\n\n return 0;\n} /* test_shaw_system_l() */\n\nstatic int\ntest_shaw_system_gcv(gsl_rng *rng_p, const size_t n, const size_t p,\n const double lambda_expected,\n gsl_vector *rhs)\n{\n const size_t npoints = 200; /* number of points on L-curve */\n const double tol1 = 1.0e-12;\n const double tol2 = 1.4e-10;\n const double tol3 = 1.0e-5;\n gsl_vector * reg_param = gsl_vector_alloc(npoints);\n gsl_vector * G = gsl_vector_alloc(npoints);\n\n gsl_matrix * X = gsl_matrix_alloc(n, p);\n gsl_matrix * cov = gsl_matrix_alloc(p, p);\n gsl_vector * c = gsl_vector_alloc(p);\n gsl_vector * ytmp = gsl_vector_alloc(n);\n gsl_vector * y;\n gsl_vector * r = gsl_vector_alloc(n);\n gsl_multifit_linear_workspace * work = \n gsl_multifit_linear_alloc (n, p);\n\n size_t reg_idx, i;\n double lambda, rnorm, snorm, G_lambda;\n\n /* build design matrix */\n shaw_system(X, ytmp);\n\n if (rhs)\n y = rhs;\n else\n {\n y = ytmp;\n\n /* add random noise to exact rhs vector */\n test_random_vector_noise(rng_p, y);\n }\n\n /* SVD decomposition */\n gsl_multifit_linear_svd(X, work);\n\n /* calculate GCV curve */\n gsl_multifit_linear_gcv(y, reg_param, G, &lambda, &G_lambda, work);\n\n /* test G vector */\n for (i = 0; i < npoints; ++i)\n {\n double lami = gsl_vector_get(reg_param, i);\n\n if (lami > 1.0e-5)\n {\n /* test unreliable for small lambda */\n double Gi = gsl_vector_get(G, i);\n double Gi_expected = shaw_gcv_G(lami, X, y, work);\n\n gsl_test_rel(Gi, Gi_expected, tol3, \"shaw[%zu,%zu] gcv G i=%zu lambda=%e\",\n n, p, i, lami);\n }\n }\n\n /* test against known lambda value if given */\n if (lambda_expected > 0.0)\n {\n gsl_test_rel(lambda, lambda_expected, tol2,\n \"shaw gcv: n=%zu p=%zu lambda\",\n n, p);\n }\n\n /* compute regularized solution with optimal lambda */\n gsl_multifit_linear_solve(lambda, X, y, c, &rnorm, &snorm, work);\n\n /* compute residual norm ||y - X c|| */\n gsl_vector_memcpy(r, y);\n gsl_blas_dgemv(CblasNoTrans, 1.0, X, c, -1.0, r);\n\n /* test rnorm value */\n gsl_test_rel(rnorm, gsl_blas_dnrm2(r), tol2,\n \"shaw gcv: n=%zu p=%zu rnorm\", n, p);\n\n /* test snorm value */\n gsl_test_rel(snorm, gsl_blas_dnrm2(c), tol2,\n \"shaw gcv: n=%zu p=%zu snorm\", n, p);\n\n gsl_matrix_free(X);\n gsl_matrix_free(cov);\n gsl_vector_free(reg_param);\n gsl_vector_free(G);\n gsl_vector_free(r);\n gsl_vector_free(c);\n gsl_vector_free(ytmp);\n gsl_multifit_linear_free(work);\n\n return 0;\n} /* test_shaw_system_gcv() */\n\nvoid\ntest_shaw(void)\n{\n gsl_rng * r = gsl_rng_alloc(gsl_rng_default);\n\n {\n double shaw20_y[] = {\n 8.7547455124379323e-04, 5.4996835885761936e-04,\n 1.7527999407005367e-06, 1.9552372913117047e-03,\n 1.4411645433785081e-02, 5.2800013336393704e-02,\n 1.3609152023257112e-01, 2.7203484587635818e-01,\n 4.3752225136193390e-01, 5.7547667319875240e-01,\n 6.2445052213539942e-01, 5.6252658286441348e-01,\n 4.2322239923561566e-01, 2.6768469219560631e-01,\n 1.4337901162734543e-01, 6.5614569346074361e-02,\n 2.6013851831752945e-02, 9.2336933089481269e-03,\n 3.2269066658993694e-03, 1.3999201459261811e-03 };\n gsl_vector_view rhs = gsl_vector_view_array(shaw20_y, 20);\n\n /* lambda and rhs values from [1] */\n test_shaw_system_l(r, 20, 20, 5.793190958069266e-06, &rhs.vector);\n\n test_shaw_system_gcv(r, 20, 20, 1.24921780949051038e-05, &rhs.vector);\n }\n\n {\n size_t n, p;\n\n for (n = 10; n <= 50; n += 2)\n {\n for (p = n - 6; p <= n; p += 2)\n test_shaw_system_l(r, n, p, -1.0, NULL);\n }\n }\n\n gsl_rng_free(r);\n} /* test_shaw() */\n", "meta": {"hexsha": "33c99188a8d573c1a06f1542fd5854c50bff78fe", "size": 9735, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.4/multifit/test_shaw.c", "max_stars_repo_name": "peterahrens/FillEstimationIPDPS2017", "max_stars_repo_head_hexsha": "857b6ee8866a2950aa5721d575d2d7d0797c4302", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-01-13T05:01:59.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-13T05:01:59.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/multifit/test_shaw.c", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/multifit/test_shaw.c", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.5, "max_line_length": 84, "alphanum_fraction": 0.6159219312, "num_tokens": 3236, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7279754607093178, "lm_q2_score": 0.7310585903489891, "lm_q1q2_score": 0.5321927141148098}} {"text": "/*\r\nPerforming approximate Bayesian computation sequential Monte Carlo (Toni et al.\r\n2009) for linear regression.\r\n\r\nSynthetic data is generated by `ground_truth_and_analysis.ipynb`.\r\n\r\nThis script writes particles.csv, where each row corresponds to a particle and\r\neach column corresponds to a round of SMC.\r\n\r\nDefining #DEBUG_MODE will silence all writing to stdout. One may then add\r\nprintf statements in the code, and perhaps write the output to file as:\r\n`./run.sh > output.txt`\r\n\r\nParameter ordering convention:\r\n0 - gradient\r\n1 - intercept\r\n2 - standard deviation\r\n\r\nAuthor: Juvid Aryaman\r\n*/\r\n\r\n#include \r\n#include \r\n#include \r\n\r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n\r\n\r\n#define N_DATA 30\r\n#define N_PARAMETERS 3\r\n\r\n#define N_PARTICLES 2000\r\n#define N_ROUNDS_SMC 25\r\n#define QUANTILE_ACCEPT_DISTANCE 0.8\r\n\r\n#define RND gsl_rng_uniform(r)\r\n#define SEED 1\r\n#define DISTANCE_THRESHOLD_INIT_GRADIENT 2\r\n#define DISTANCE_THRESHOLD_INIT_INTERCEPT 50\r\n#define DISTANCE_THRESHOLD_INIT_SIGMA 2\r\n\r\n#define X_DATA_FILENAME \"x.csv\"\r\n#define Y_DATA_FILENAME \"y.csv\"\r\n\r\n//#define DEBUG_MODE\r\n\r\n#include \"smc.h\"\r\n#include \"lin_reg.h\"\r\n\r\nint main(int argc, char *argv[]) {\r\n\r\n/* set up GSL RNG */\r\ngsl_rng *r = gsl_rng_alloc(gsl_rng_mt19937);\r\n/* end of GSL setup */\r\n\r\ngsl_rng_set(r, SEED);\r\n\r\n/////////////////////////\r\n/*Read data*/\r\n/////////////////////////\r\n\r\nFILE *data_pointer_x, *data_pointer_y;\r\n\r\ndata_pointer_x = fopen(X_DATA_FILENAME, \"r\");\r\ndata_pointer_y = fopen(Y_DATA_FILENAME, \"r\");\r\n\r\ndouble data_x[N_DATA];\r\ndouble data_y[N_DATA];\r\nint i, j, read_error_status_x, read_error_status_y;\r\nfor (i=0; i < N_DATA; i++){\r\n\tread_error_status_x = fscanf(data_pointer_x, \"%lf\\n\", &data_x[i]);\r\n\tread_error_status_y = fscanf(data_pointer_y, \"%lf\\n\", &data_y[i]);\r\n}\r\nif (read_error_status_x != 1){printf(\"Error reading X data\\n\"); return 0;}\r\nif (read_error_status_y != 1){printf(\"Error reading Y data\\n\"); return 0;}\r\n\r\n/////////////////////////\r\n/*Initialise variables*/\r\n/////////////////////////\r\n\r\n/*Fit a linear model to the data, which will be used as summary statistics of\r\nthe data*/\r\ndouble gradient_fit_data, intercept_fit_data, sigma_fit_data, cov00, cov01, cov11, sumsq;\r\nint gsl_fit_return_value;\r\ngsl_fit_return_value = gsl_fit_linear(data_x, 1, data_y, 1, N_DATA,\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t&intercept_fit_data, &gradient_fit_data,\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t&cov00, &cov01, &cov11, &sumsq);\r\nif (gsl_fit_return_value != 0) {printf(\"Fit failed.\\n\"); return -1;}\r\nsigma_fit_data = sqrt(sumsq/(N_DATA-2));\r\n\r\n#ifndef DEBUG_MODE\r\n\tprintf(\"gradient ML = %.8f\\n\", gradient_fit_data);\r\n\tprintf(\"intercept ML = %.8f\\n\", intercept_fit_data);\r\n\tprintf(\"sigma ML = %.8f\\n\", sigma_fit_data);\r\n#endif\r\n\r\n\r\n\r\n/*Make a (N_PARAMETERS X N_ROUNDS_SMC X N_PARTICLES) array to store all\r\nparticles at all rounds of SMC*/\r\ndouble*** theta_particle;\r\ntheta_particle = (double***) malloc(N_PARAMETERS * sizeof(double**));\r\nfor (i = 0; i < N_PARAMETERS; i++){\r\n\ttheta_particle[i] = (double**) malloc(N_ROUNDS_SMC * sizeof(double*));\r\n}\r\nfor (i = 0; i < N_PARAMETERS; i++){\r\n\tfor (j = 0; j < N_ROUNDS_SMC; j++){\r\n\t\ttheta_particle[i][j] = (double*) malloc(N_PARTICLES * sizeof(double));\r\n\t}\r\n}\r\n\r\ndouble** distance;\r\ndistance = (double**) malloc(N_PARAMETERS * sizeof(double*));\r\nfor (i = 0; i < N_PARAMETERS; i++) {\r\n\tdistance[i] = (double*) malloc(N_PARTICLES * sizeof(double));\r\n}\r\ndouble **distance_threshold_all = malloc(N_PARAMETERS * sizeof(double*));\r\nfor (i = 0; i < N_PARAMETERS; i++) {\r\n\tdistance_threshold_all[i] = (double*) malloc(N_ROUNDS_SMC * sizeof(double));\r\n}\r\n\r\ndouble distance_threshold[] = {DISTANCE_THRESHOLD_INIT_GRADIENT,\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t DISTANCE_THRESHOLD_INIT_INTERCEPT,\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t DISTANCE_THRESHOLD_INIT_SIGMA};\r\n\r\ndouble *simulated_data = (double*) malloc(N_DATA * sizeof(double));\r\ndouble *weight = malloc(N_PARTICLES * sizeof(double));\r\n\r\ndouble weight_normalizer = 0.0;\r\n\r\nint time_smc=0; // an index of each round of SMC\r\nint param_index_chosen, prior_violated;\r\nint particle_index;\r\n/////////////////////////\r\n/*Perform ABC SMC*/\r\n/////////////////////////\r\n\r\n/*For every round of SMC*/\r\nfor (time_smc = 0; time_smc < N_ROUNDS_SMC; time_smc++) {\r\n\t#ifndef DEBUG_MODE\r\n\t\tprintf(\"Round %d of SMC\\n\", time_smc);\r\n\t#endif\r\n\tfor (i = 0; i < N_PARAMETERS; i++) {\r\n\t\tdistance_threshold_all[i][time_smc] = distance_threshold[i];\r\n\t}\r\n\r\n\t/*Draw or perturb a particle and compute distance*/\r\n\tfor (particle_index = 0; particle_index < N_PARTICLES; particle_index++) {\r\n\t\t// printf(\"%d\\n\", particle_index);\r\n\t\tfor (i = 0; i < N_PARAMETERS; i++) {\r\n\t\t\t// reset distance of particle along each dimension\r\n\t\t\tdistance[i][particle_index] = distance_threshold[i] + 1.0;\r\n\t\t}\r\n\t\twhile ((distance[0][particle_index] > distance_threshold[0])||\r\n\t\t\t\t\t (distance[1][particle_index] > distance_threshold[1])||\r\n\t\t\t\t (distance[2][particle_index] > distance_threshold[2])) {\r\n\t\t\tif (time_smc == 0) {\r\n\t\t\t\t// Sample from the prior\r\n\t\t\t\tsample_prior(r, theta_particle, particle_index);\r\n\t\t\t}\r\n\t\t\telse{\r\n\t\t\t\t/*Sample from the old weights*/\r\n\t\t\t\tparam_index_chosen = weighted_choice(r, weight);\r\n\t\t\t\tif ((param_index_chosen < 0)||(param_index_chosen >= N_PARTICLES)) {\r\n\t\t\t\t\tprintf(\"Error in param_index_chosen\\n\");\r\n\t\t\t\t\tprintf(\"time_smc = %d\\n\", time_smc);\r\n\t\t\t\t\treturn -1;\r\n\t\t\t\t}\r\n\r\n\t\t\t\tperturb_particle(r, theta_particle, time_smc, param_index_chosen,\r\n\t\t\t\t\t\t\t\t\t\t\t\t particle_index);\r\n\r\n\t\t\t\t// Check if prior support is 0\r\n\t\t\t\tprior_violated = check_prior_violated(theta_particle, time_smc,\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tparticle_index);\r\n\t\t\t\tif(prior_violated == 1) continue;\r\n\t\t\t\t}\r\n\r\n\t\t\tsimulate_dataset(r, theta_particle, data_x, simulated_data, time_smc,\r\n\t\t\t\t\t\t\t\t\t\t\t particle_index);\r\n\r\n\r\n\r\n\r\n\t\t\t// Compute distance between data and simulation\r\n\t\t\tdistance_metric_sum_stats(simulated_data,\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t data_x,\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t gradient_fit_data,\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t intercept_fit_data,\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t sigma_fit_data,\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t distance, particle_index);\r\n\t\t\t//distance[particle_index] = distance_metric_sum_res(simulated_data, data_y);\r\n\t\t\t// distance[particle_index] = distance_metric_sum_abs_res(simulated_data, data_y);\r\n\r\n\t\t}\r\n\t}\r\n\r\n\t#ifndef DEBUG_MODE\r\n\t\tprintf(\"Particles sampled.\\n\");\r\n\t#endif\r\n\r\n\r\n\t/*Compute weights*/\r\n\tif (time_smc==0){ for (i = 0; i < N_PARTICLES; i++) weight[i] = 1.0;}\r\n\telse{\r\n\t\tweight_normalizer = 0.0;\r\n\t\tfor (particle_index = 0; particle_index < N_PARTICLES; particle_index++) {\r\n\t\t\tweight_normalizer += weight[particle_index]*kernel_pdf();\r\n\t\t}\r\n\t\t// print_double_array(weight, N_PARTICLES);\r\n\t\t// printf(\"\\n\" );\r\n\t\t// printf(\"weight_normalizer=%f\\n\", weight_normalizer);\r\n\t\t// printf(\"kernel_pdf()=%f\\n\", kernel_pdf());\r\n\t\tfor (particle_index = 0; particle_index < N_PARTICLES; particle_index++) {\r\n\t\t\tweight[particle_index] = prior_pdf(theta_particle, time_smc,\r\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t particle_index)/weight_normalizer;\r\n\t\t}\r\n\r\n\t}\r\n\r\n\t/*Normalise weights*/\r\n\tweight_normalizer = 0.0;\r\n\tfor (i = 0; i < N_PARTICLES; i++)\tweight_normalizer += weight[i];\r\n\tfor (i = 0; i < N_PARTICLES; i++)\tweight[i] = weight[i]/weight_normalizer;\r\n\r\n\t/* Resample weights*/\r\n\tdistance_threshold[0] = update_distance_threshold(distance[0]);\r\n\tdistance_threshold[1] = update_distance_threshold(distance[1]);\r\n\tdistance_threshold[2] = update_distance_threshold(distance[2]);\r\n\r\n\r\n}\r\n\r\n#ifndef DEBUG_MODE\r\n\tprintf(\"Writing particles to file\\n\");\r\n#endif\r\n\twrite_particles_to_csv(theta_particle);\r\n\r\n\tchar *dist_filename = \"distances.txt\";\r\n\twrite_2d_double_array_to_csv(distance_threshold_all, N_PARAMETERS, N_ROUNDS_SMC, dist_filename);\r\n#ifndef DEBUG_MODE\r\n\tprintf(\"Done!\\n\");\r\n#endif\r\n\r\nreturn 0; //return from main\r\n} //close main\r\n", "meta": {"hexsha": "faab26c0d683e2330e7f3bc0fb82a53980228af4", "size": 7798, "ext": "c", "lang": "C", "max_stars_repo_path": "Notebooks/ABC_SMC/Linear_regression/distance_metric_3d/smc.c", "max_stars_repo_name": "jaryaman/ML_demos", "max_stars_repo_head_hexsha": "df270b58d35d1248079e4651988ded4074237bfc", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2018-07-28T18:14:12.000Z", "max_stars_repo_stars_event_max_datetime": "2018-07-31T16:51:10.000Z", "max_issues_repo_path": "Notebooks/ABC_SMC/Linear_regression/distance_metric_3d/smc.c", "max_issues_repo_name": "jaryaman/ML_demos", "max_issues_repo_head_hexsha": "df270b58d35d1248079e4651988ded4074237bfc", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3.0, "max_issues_repo_issues_event_min_datetime": "2020-06-21T18:23:19.000Z", "max_issues_repo_issues_event_max_datetime": "2020-09-28T14:21:39.000Z", "max_forks_repo_path": "Notebooks/ABC_SMC/Linear_regression/distance_metric_3d/smc.c", "max_forks_repo_name": "jaryaman/ML_demos", "max_forks_repo_head_hexsha": "df270b58d35d1248079e4651988ded4074237bfc", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2018-07-02T14:25:20.000Z", "max_forks_repo_forks_event_max_datetime": "2018-07-02T14:25:20.000Z", "avg_line_length": 31.0677290837, "max_line_length": 98, "alphanum_fraction": 0.6697871249, "num_tokens": 2016, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.734119526900183, "lm_q2_score": 0.7248702761768248, "lm_q1q2_score": 0.5321414242109356}} {"text": "/* -----------------------------------------------------------------------------\n JAM_AXI_VEL_LOSINT\n \n Calculates integrand for line-of-sight integral required for first moment\n calculation.\n \n INPUTS\n zp : line-of-sight coordinate z' (integration variable)\n params : function parameters passed as a structure\n \n NOTES\n * Based on janis1_jeans_mge_los_integrand IDL code by Michele Cappellari.\n \n Laura L Watkins [lauralwatkins@gmail.com]\n \n This code is released under a BSD 2-clause license.\n If you use this code for your research, please cite:\n Watkins et al. 2013, MNRAS, 436, 2598\n \"Discrete dynamical models of omega Centauri\"\n http://adsabs.harvard.edu/abs/2013MNRAS.436.2598W\n----------------------------------------------------------------------------- */\n\n#include \n#include \n#include \n#include \n#include \n#include \"jam.h\"\n#include \"../mge/mge.h\"\n\n\ndouble jam_axi_vel_losint(double zp, void *params) {\n \n struct params_losint *lp;\n struct params_mgeint mp;\n double xp, yp, si, ci, r, z, r2, z2, nu, intg, result, error, nu_i;\n double sign_kappa, sum;\n int i;\n \n // get parameters\n lp = params;\n xp = lp->xp;\n yp = lp->yp;\n \n // if the integrationFlag is already set, do not proceed\n if (*lp->integrationFlag!=0) {\n return 0.;\n }\n \n // intrinsic R and z\n si = sin(lp->incl);\n ci = cos(lp->incl);\n r = sqrt(pow(zp*si - yp*ci, 2) + pow(xp, 2)); // eqn 25\n z = sqrt(pow(zp*ci + yp*si, 2));\n \n // do some prep for the integrand to avoid repeat calculations\n r2 = r * r;\n z2 = z * z;\n \n // parameters for integrand function\n mp.r2 = r2;\n mp.z2 = z2;\n mp.pot = lp->pot;\n mp.s2p = lp->s2p;\n mp.e2p = lp->e2p;\n \n // perform integration\n gsl_integration_workspace *w = gsl_integration_workspace_alloc(1000);\n gsl_set_error_handler_off();\n gsl_function F;\n F.function = &jam_axi_vel_mgeint;\n \n sum = 0.;\n for (i=0; ilum->ntotal; i++) {\n if (lp->kappa[i]==0.) sign_kappa = 0.;\n else sign_kappa = lp->kappa[i]/fabs(lp->kappa[i]);\n nu_i = lp->lum->area[i] * exp(-0.5/lp->s2l[i]*(r2+z2/lp->q2l[i]));\n \n mp.bani = lp->bani[i];\n mp.s2l = lp->s2l[i];\n mp.q2l = lp->q2l[i];\n mp.s2q2l = lp->s2q2l[i];\n F.params = ∓\n *lp->integrationFlag += gsl_integration_qag(&F, 0., 1., 0., 1e-5,\n 1000, 6, w, &result, &error);\n sum += sign_kappa * pow(lp->kappa[i], 2) * nu_i * fabs(result);\n }\n \n gsl_integration_workspace_free(w);\n \n // check if the integration failed\n if (*lp->integrationFlag!=0) {\n return 0.;\n }\n \n // mge volume density\n nu = mge_dens(lp->lum, r, z);\n \n // keep track of kappa signs - see note 8 p77 of Cappellari 2008\n intg = nu*sum/fabs(nu*sum)*sqrt(fabs(nu*sum));\n \n intg *= pow(zp, lp->zpow);\n \n return intg;\n \n}\n", "meta": {"hexsha": "477498c004427fa754ebcaf77be672c1958a7991", "size": 3043, "ext": "c", "lang": "C", "max_stars_repo_path": "src/jam/jam_axi_vel_losint.c", "max_stars_repo_name": "slzoutendijk/cjam", "max_stars_repo_head_hexsha": "6ed576de012cc368f65acaf17432aa66a0933520", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 12.0, "max_stars_repo_stars_event_min_datetime": "2016-05-27T06:10:56.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-18T12:50:31.000Z", "max_issues_repo_path": "src/jam/jam_axi_vel_losint.c", "max_issues_repo_name": "slzoutendijk/cjam", "max_issues_repo_head_hexsha": "6ed576de012cc368f65acaf17432aa66a0933520", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/jam/jam_axi_vel_losint.c", "max_forks_repo_name": "slzoutendijk/cjam", "max_forks_repo_head_hexsha": "6ed576de012cc368f65acaf17432aa66a0933520", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2019-07-25T09:30:07.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-02T13:33:21.000Z", "avg_line_length": 28.4392523364, "max_line_length": 80, "alphanum_fraction": 0.5527440026, "num_tokens": 945, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8918110511888303, "lm_q2_score": 0.5964331462646255, "lm_q1q2_score": 0.531905671134117}} {"text": "/* roots/brent.c\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000 Reid Priedhorsky, Brian Gough\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 2 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n/* brent.c -- brent root finding algorithm */\n\n#include \n\n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n\n#include \"roots.h\"\n\n\ntypedef struct\n {\n double a, b, c, d, e;\n double fa, fb, fc;\n }\nbrent_state_t;\n\nstatic int brent_init (void * vstate, gsl_function * f, double * root, double x_lower, double x_upper);\nstatic int brent_iterate (void * vstate, gsl_function * f, double * root, double * x_lower, double * x_upper);\n\n\nstatic int\nbrent_init (void * vstate, gsl_function * f, double * root, double x_lower, double x_upper)\n{\n brent_state_t * state = (brent_state_t *) vstate;\n\n double f_lower, f_upper ;\n\n *root = 0.5 * (x_lower + x_upper) ;\n\n SAFE_FUNC_CALL (f, x_lower, &f_lower);\n SAFE_FUNC_CALL (f, x_upper, &f_upper);\n \n state->a = x_lower;\n state->fa = f_lower;\n\n state->b = x_upper;\n state->fb = f_upper;\n\n state->c = x_upper;\n state->fc = f_upper;\n\n state->d = x_upper - x_lower ;\n state->e = x_upper - x_lower ;\n\n if ((f_lower < 0.0 && f_upper < 0.0) || (f_lower > 0.0 && f_upper > 0.0))\n {\n GSL_ERROR (\"endpoints do not straddle y=0\", GSL_EINVAL);\n }\n\n return GSL_SUCCESS;\n\n}\n\nstatic int\nbrent_iterate (void * vstate, gsl_function * f, double * root, double * x_lower, double * x_upper)\n{\n brent_state_t * state = (brent_state_t *) vstate;\n\n double tol, m;\n\n int ac_equal = 0;\n\n double a = state->a, b = state->b, c = state->c;\n double fa = state->fa, fb = state->fb, fc = state->fc;\n double d = state->d, e = state->e;\n \n if ((fb < 0 && fc < 0) || (fb > 0 && fc > 0))\n {\n ac_equal = 1;\n c = a;\n fc = fa;\n d = b - a;\n e = b - a;\n }\n \n if (fabs (fc) < fabs (fb))\n {\n ac_equal = 1;\n a = b;\n b = c;\n c = a;\n fa = fb;\n fb = fc;\n fc = fa;\n }\n \n tol = 0.5 * GSL_DBL_EPSILON * fabs (b);\n m = 0.5 * (c - b);\n \n if (fb == 0)\n {\n *root = b;\n *x_lower = b;\n *x_upper = b;\n \n return GSL_SUCCESS;\n }\n \n if (fabs (m) <= tol)\n {\n *root = b;\n\n if (b < c) \n {\n *x_lower = b;\n *x_upper = c;\n }\n else\n {\n *x_lower = c;\n *x_upper = b;\n }\n\n return GSL_SUCCESS;\n }\n \n if (fabs (e) < tol || fabs (fa) <= fabs (fb))\n {\n d = m; /* use bisection */\n e = m;\n }\n else\n {\n double p, q, r; /* use inverse cubic interpolation */\n double s = fb / fa;\n \n if (ac_equal)\n {\n p = 2 * m * s;\n q = 1 - s;\n }\n else\n {\n q = fa / fc;\n r = fb / fc;\n p = s * (2 * m * q * (q - r) - (b - a) * (r - 1));\n q = (q - 1) * (r - 1) * (s - 1);\n }\n \n if (p > 0)\n {\n q = -q;\n }\n else\n {\n p = -p;\n }\n \n if (2 * p < GSL_MIN (3 * m * q - fabs (tol * q), fabs (e * q)))\n {\n e = d;\n d = p / q;\n }\n else\n {\n /* interpolation failed, fall back to bisection */\n \n d = m;\n e = m;\n }\n }\n \n a = b;\n fa = fb;\n \n if (fabs (d) > tol)\n {\n b += d;\n }\n else\n {\n b += (m > 0 ? +tol : -tol);\n }\n \n SAFE_FUNC_CALL (f, b, &fb);\n\n state->a = a ;\n state->b = b ;\n state->c = c ;\n state->d = d ;\n state->e = e ;\n state->fa = fa ;\n state->fb = fb ;\n state->fc = fc ;\n \n /* Update the best estimate of the root and bounds on each\n iteration */\n \n *root = b;\n \n if ((fb < 0 && fc < 0) || (fb > 0 && fc > 0)) \n {\n c = a;\n }\n\n if (b < c)\n {\n *x_lower = b;\n *x_upper = c;\n }\n else\n {\n *x_lower = c;\n *x_upper = b;\n }\n\n return GSL_SUCCESS ;\n}\n\n \nstatic const gsl_root_fsolver_type brent_type =\n{\"brent\", /* name */\n sizeof (brent_state_t),\n &brent_init,\n &brent_iterate};\n\nconst gsl_root_fsolver_type * gsl_root_fsolver_brent = &brent_type;\n", "meta": {"hexsha": "5cd527541a58221718c50bfdecf4174410b27b21", "size": 4911, "ext": "c", "lang": "C", "max_stars_repo_path": "pkgs/libs/gsl/src/roots/brent.c", "max_stars_repo_name": "manggoguy/parsec-modified", "max_stars_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 64.0, "max_stars_repo_stars_event_min_datetime": "2015-03-06T00:30:56.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-24T13:26:53.000Z", "max_issues_repo_path": "pkgs/libs/gsl/src/roots/brent.c", "max_issues_repo_name": "manggoguy/parsec-modified", "max_issues_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 12.0, "max_issues_repo_issues_event_min_datetime": "2020-12-15T08:30:19.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-13T03:54:24.000Z", "max_forks_repo_path": "pkgs/libs/gsl/src/roots/brent.c", "max_forks_repo_name": "manggoguy/parsec-modified", "max_forks_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 40.0, "max_forks_repo_forks_event_min_datetime": "2015-02-26T15:31:16.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-03T23:23:37.000Z", "avg_line_length": 20.0448979592, "max_line_length": 110, "alphanum_fraction": 0.5084504174, "num_tokens": 1562, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7431680086124811, "lm_q2_score": 0.7154239897159438, "lm_q1q2_score": 0.5316802217507941}} {"text": "#include \n#include \n#include \"../problems/mooney-rivlin.h\"\n\n// Build libCEED context object\nPetscErrorCode PhysicsContext_MR(MPI_Comm comm, Ceed ceed, Units *units,\n CeedQFunctionContext *ctx) {\n PetscErrorCode ierr;\n Physics_MR phys;\n\n PetscFunctionBegin;\n\n ierr = PetscMalloc1(1, units); CHKERRQ(ierr);\n ierr = PetscMalloc1(1, &phys); CHKERRQ(ierr);\n ierr = ProcessPhysics_MR(comm, phys, *units); CHKERRQ(ierr);\n CeedQFunctionContextCreate(ceed, ctx);\n CeedQFunctionContextSetData(*ctx, CEED_MEM_HOST, CEED_COPY_VALUES,\n sizeof(*phys), phys);\n ierr = PetscFree(phys); CHKERRQ(ierr);\n\n PetscFunctionReturn(0);\n}\n\n// Build libCEED smoother context object\nPetscErrorCode PhysicsSmootherContext_MR(MPI_Comm comm, Ceed ceed,\n CeedQFunctionContext ctx, CeedQFunctionContext *ctx_smoother) {\n PetscErrorCode ierr;\n PetscScalar nu_smoother = 0;\n PetscBool nu_flag = PETSC_FALSE;\n Physics_MR phys, phys_smoother;\n\n PetscFunctionBegin;\n\n ierr = PetscOptionsBegin(comm, NULL,\n \"Mooney Rivlin physical parameters for smoother\", NULL);\n CHKERRQ(ierr);\n\n ierr = PetscOptionsScalar(\"-nu_smoother\", \"Poisson's ratio for smoother\",\n NULL, nu_smoother, &nu_smoother, &nu_flag);\n CHKERRQ(ierr);\n if (nu_smoother < 0 ||\n nu_smoother >= 0.5) SETERRQ(PETSC_COMM_SELF, PETSC_ERR_SUP,\n \"Mooney-Rivlin model requires Poisson ratio -nu option in [0, .5)\");\n\n ierr = PetscOptionsEnd(); CHKERRQ(ierr); // End of setting Physics\n\n if (nu_flag) {\n // Copy context\n CeedQFunctionContextGetData(ctx, CEED_MEM_HOST, &phys);\n ierr = PetscMalloc1(1, &phys_smoother); CHKERRQ(ierr);\n ierr = PetscMemcpy(phys_smoother, phys, sizeof(*phys)); CHKERRQ(ierr);\n CeedQFunctionContextRestoreData(ctx, &phys);\n // Create smoother context\n CeedQFunctionContextCreate(ceed, ctx_smoother);\n phys_smoother->lambda = 2 * (phys_smoother->mu_1 + phys_smoother->mu_2) *\n nu_smoother / (1 - 2*nu_smoother);\n CeedQFunctionContextSetData(*ctx_smoother, CEED_MEM_HOST, CEED_COPY_VALUES,\n sizeof(*phys_smoother), phys_smoother);\n ierr = PetscFree(phys_smoother); CHKERRQ(ierr);\n } else {\n *ctx_smoother = NULL;\n }\n\n PetscFunctionReturn(0);\n}\n\n// Process physics options - Mooney-Rivlin\nPetscErrorCode ProcessPhysics_MR(MPI_Comm comm, Physics_MR phys, Units units) {\n PetscErrorCode ierr;\n PetscReal nu = -1;\n phys->mu_1 = -1;\n phys->mu_2 = -1;\n phys->lambda = -1;\n units->meter = 1; // 1 meter in scaled length units\n units->second = 1; // 1 second in scaled time units\n units->kilogram = 1; // 1 kilogram in scaled mass units\n\n PetscFunctionBeginUser;\n\n ierr = PetscOptionsBegin(comm, NULL, \"Mooney Rivlin physical parameters\", NULL);\n CHKERRQ(ierr);\n\n ierr = PetscOptionsScalar(\"-mu_1\", \"Material Property mu_1\", NULL,\n phys->mu_1, &phys->mu_1, NULL); CHKERRQ(ierr);\n if (phys->mu_1 < 0) SETERRQ(PETSC_COMM_SELF, PETSC_ERR_SUP,\n \"Mooney-Rivlin model requires non-negative -mu_1 option (Pa)\");\n\n ierr = PetscOptionsScalar(\"-mu_2\", \"Material Property mu_2\", NULL,\n phys->mu_2, &phys->mu_2, NULL); CHKERRQ(ierr);\n if (phys->mu_2 < 0) SETERRQ(PETSC_COMM_SELF, PETSC_ERR_SUP,\n \"Mooney-Rivlin model requires non-negative -mu_2 option (Pa)\");\n\n ierr = PetscOptionsScalar(\"-nu\", \"Poisson ratio\", NULL,\n nu, &nu, NULL); CHKERRQ(ierr);\n if (nu < 0 || nu >= 0.5) SETERRQ(PETSC_COMM_SELF, PETSC_ERR_SUP,\n \"Mooney-Rivlin model requires Poisson ratio -nu option in [0, .5)\");\n phys->lambda = 2 * (phys->mu_1 + phys->mu_2) * nu / (1 - 2*nu);\n\n ierr = PetscOptionsScalar(\"-units_meter\", \"1 meter in scaled length units\",\n NULL, units->meter, &units->meter, NULL);\n CHKERRQ(ierr);\n units->meter = fabs(units->meter);\n\n ierr = PetscOptionsScalar(\"-units_second\", \"1 second in scaled time units\",\n NULL, units->second, &units->second, NULL);\n CHKERRQ(ierr);\n units->second = fabs(units->second);\n\n ierr = PetscOptionsScalar(\"-units_kilogram\", \"1 kilogram in scaled mass units\",\n NULL, units->kilogram, &units->kilogram, NULL);\n CHKERRQ(ierr);\n units->kilogram = fabs(units->kilogram);\n\n ierr = PetscOptionsEnd(); CHKERRQ(ierr); // End of setting Physics\n\n // Define derived units\n units->Pascal = units->kilogram / (units->meter * PetscSqr(units->second));\n\n // Scale material parameters based on units of Pa\n phys->mu_1 *= units->Pascal;\n phys->mu_2 *= units->Pascal;\n phys->lambda *= units->Pascal;\n\n PetscFunctionReturn(0);\n};", "meta": {"hexsha": "a9c44b5b0d145180422a316482dfdcf98e61995b", "size": 4870, "ext": "c", "lang": "C", "max_stars_repo_path": "examples/solids/problems/mooney-rivlin.c", "max_stars_repo_name": "AdelekeBankole/libCEED", "max_stars_repo_head_hexsha": "aae8ce39fa1e28b745979a9cbffc67a790eb3f5e", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 123.0, "max_stars_repo_stars_event_min_datetime": "2018-01-29T02:04:05.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-21T18:13:48.000Z", "max_issues_repo_path": "examples/solids/problems/mooney-rivlin.c", "max_issues_repo_name": "AdelekeBankole/libCEED", "max_issues_repo_head_hexsha": "aae8ce39fa1e28b745979a9cbffc67a790eb3f5e", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": 781.0, "max_issues_repo_issues_event_min_datetime": "2017-12-22T17:20:35.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-29T21:34:34.000Z", "max_forks_repo_path": "examples/solids/problems/mooney-rivlin.c", "max_forks_repo_name": "AdelekeBankole/libCEED", "max_forks_repo_head_hexsha": "aae8ce39fa1e28b745979a9cbffc67a790eb3f5e", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 41.0, "max_forks_repo_forks_event_min_datetime": "2017-12-27T22:35:13.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-01T13:02:07.000Z", "avg_line_length": 38.96, "max_line_length": 105, "alphanum_fraction": 0.6410677618, "num_tokens": 1326, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7826624789529375, "lm_q2_score": 0.6791787056691698, "lm_q1q2_score": 0.53156768943108}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"cosmocalc.h\"\n\ndouble transfer_function(double k)\n{\n static int initFlag = 1;\n static int currCosmoNum;\n static gsl_spline *cosmocalc_transfer_function_spline = NULL;\n static gsl_interp_accel *cosmocalc_transfer_function_acc = NULL;\n static double c0,c1;\n \n double transfer_function_table[COSMOCALC_TRANSFER_FUNCTION_TABLE_LENGTH];\n double k_table[COSMOCALC_TRANSFER_FUNCTION_TABLE_LENGTH];\n long i;\n double cov00,cov01,cov11,sumsq;\n \n if(initFlag == 1 || currCosmoNum != cosmoData.cosmoNum)\n {\n initFlag = 0;\n currCosmoNum = cosmoData.cosmoNum;\n \n for(i=0;i 1+zd)\n //fprintf(stderr,\"paper eh 98 1\\n\");\n#else\n Rd = 31.5*omb*h*h\n /(theta2p7*theta2p7*theta2p7*theta2p7)\n /((1.0+zd)/1e3);\n#endif\nReq = 31.5*omb*h*h/(theta2p7*theta2p7*theta2p7*theta2p7)/(zeq/1e3);\n \n //eqn 6\n s = 2.0/3.0/keq*sqrt(6.0/Req)*\n log((sqrt(1.0 + Rd) + sqrt(Rd + Req))/(1.0 + sqrt(Req)));\n \n //eqn 7\n ksilk = 1.6*pow(omb*h*h,0.52)*pow(om0*h*h,0.73)*(1.0 + pow(10.4*om0*h*h,-0.95));\n \n //eqn 10\n q = k/13.41/keq;\n \n //eqn 11\n a1 = pow(46.9*om0*h*h,0.670)*(1.0 + pow(32.1*om0*h*h,-0.532));\n a2 = pow(12.0*om0*h*h,0.424)*(1.0 + pow(45.0*om0*h*h,-0.582));\n ac = pow(a1,-1.0*omb/om0)*pow(a2,-1.0*(omb/om0)*(omb/om0)*(omb/om0));\n \n //eqn 12\n b1 = 0.944/(1.0 + pow(458.0*om0*h*h,-0.708));\n b2 = pow(0.395*om0*h*h,-0.0266);\n bc = 1.0/(1.0 + b1*(pow(omc/om0,b2) - 1.0));\n \n //eqn 15\n#ifdef USEPAPER_EH98\n y = (1.0 + zeq)/(1.0 + zd); //matches wayne's paper, but not the code (1+zeq -> zeq)\n //fprintf(stderr,\"paper eh 98 2\\n\");\n#else\n y = (zeq)/(1.0 + zd);\n#endif\n Gy = y*(-6.0*sqrt(1.0 + y) + (2.0 + 3.0*y)*log((sqrt(1.0 + y) + 1.0)/(sqrt(1.0 + y) - 1.0)));\n \n //eqn 14\n ab = 2.07*keq*s*pow(1.0 + Rd,-3.0/4.0)*Gy;\n \n //----------------------------------\n // Get CDM part of transfer function\n //----------------------------------\n \n //eqn 18\n f = 1.0/(1.0 + (k*s/5.4)*(k*s/5.4)*(k*s/5.4)*(k*s/5.4));\n \n //eqn 20\n C = 14.2/ac + 386.0/(1.0 + 69.9*pow(q,1.08)); \n \n //eqn 19\n T0t = log(M_E + 1.8*bc*q)/(log(M_E + 1.8*bc*q) + C*q*q); \n \n //eqn 17\n C1bc = 14.2 + 386.0/(1.0 + 69.9*pow(q,1.08)); \n T0t1bc = log(M_E + 1.8*bc*q)/(log(M_E + 1.8*bc*q) + C1bc*q*q); \n Tc = f*T0t1bc + (1.0 - f)*T0t;\n \n //-------------------------------------\n // Get baryon part of transfer function\n //-------------------------------------\n \n //eqn 24\n bb = 0.5 + omb/om0 + (3.0 - 2.0*omb/om0)*sqrt((17.2*om0*h*h)*(17.2*om0*h*h) + 1.0);\n \n //eqn 23\n bnode = 8.41*pow(om0*h*h,0.435);\n \n //eqn 22\n st = s/pow(1.0 + (bnode/k/s)*(bnode/k/s)*(bnode/k/s),1.0/3.0);\n \n //eqn 21\n C11 = 14.2 + 386.0/(1.0 + 69.9*pow(q,1.08));\n T0t11 = log(M_E + 1.8*q)/(log(M_E + 1.8*q) + C11*q*q); \n Tb = (T0t11/(1.0 + (k*s/5.2)*(k*s/5.2)) \n\t+ ab/(1.0 + (bb/k/s)*(bb/k/s)*(bb/k/s))/exp(pow(k/ksilk,1.4)))*sin(k*st)/(k*st);\n\n //------------------------\n // total transfer function\n //------------------------\n Tk = omb/om0*Tb + omc/om0*Tc;\n \n return Tk;\n}\t\n\ndouble transfunct_eh98_smooth(double kin)\n{\n //vars\n double k,Tk;\n double omb,om0,omc,h;\n double theta2p7,s,q;\n double Gamma,alphaGamma,L0,C0;\n \n //get cosmoparms\n omb = cosmoData.OmegaB;\n om0 = cosmoData.OmegaM;\n omc = cosmoData.OmegaM - cosmoData.OmegaB;\n h = cosmoData.h;\n \n //convert k from hMpc^-1 to Mpc^-1\n k = kin*h;\n \n //-----------\n //input parms \n //-----------\n theta2p7 = TCMB/2.7;\n \n //eqn 26\n s = 44.5*log(9.83/om0/h/h)/sqrt(1.0 + 10.0*pow(omb*h*h,0.75));\n \n //eqn 31\n alphaGamma = 1.0 - 0.328*log(431.0*om0*h*h)*omb/om0 + 0.38*log(22.3*om0*h*h)*(omb/om0)*(omb/om0);\n \n //eqn 30\n Gamma = om0*h*(alphaGamma + (1.0 - alphaGamma)/(1.0 + pow(0.43*k*s,4.0)));\n \n //eqn 28\n q = kin*theta2p7*theta2p7/Gamma;\n \n //eqns 29\n C0 = 14.2 + 731.0/(1.0 + 62.5*q);\n L0 = log(2.0*exp(1.0) + 1.8*q);\n Tk = L0/(L0 + C0*q*q);\n \n return Tk;\n}\t\n", "meta": {"hexsha": "81c616fafd3b75978fec8cf9c138c03d967d6b9e", "size": 6775, "ext": "c", "lang": "C", "max_stars_repo_path": "src/transfer_function.c", "max_stars_repo_name": "beckermr/cosmocalc", "max_stars_repo_head_hexsha": "aa7d7cb58f05a36d446e02b45a9117d93eb16556", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/transfer_function.c", "max_issues_repo_name": "beckermr/cosmocalc", "max_issues_repo_head_hexsha": "aa7d7cb58f05a36d446e02b45a9117d93eb16556", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2016-04-05T19:10:45.000Z", "max_issues_repo_issues_event_max_datetime": "2016-04-05T19:36:21.000Z", "max_forks_repo_path": "src/transfer_function.c", "max_forks_repo_name": "beckermr/cosmocalc", "max_forks_repo_head_hexsha": "aa7d7cb58f05a36d446e02b45a9117d93eb16556", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2017-07-14T12:17:31.000Z", "max_forks_repo_forks_event_max_datetime": "2017-08-11T17:31:51.000Z", "avg_line_length": 29.329004329, "max_line_length": 142, "alphanum_fraction": 0.5930627306, "num_tokens": 2790, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8539127566694177, "lm_q2_score": 0.6224593241981982, "lm_q1q2_score": 0.5315259574406661}} {"text": "/* linalg/balance.c\n * \n * Copyright (C) 2001 Brian Gough\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 2 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.\n */\n\n/* Balance a general matrix by scaling the columns\n *\n * B = A D\n *\n * where D is a diagonal matrix\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"gsl_linalg.h\"\n\nint\ngsl_linalg_balance_columns (gsl_matrix * A, gsl_vector * D)\n{\n const size_t N = A->size2;\n size_t j;\n\n if (D->size != A->size2)\n {\n GSL_ERROR(\"length of D must match second dimension of A\", GSL_EINVAL);\n }\n \n gsl_vector_set_all (D, 1.0);\n\n for (j = 0; j < N; j++)\n {\n gsl_vector_view A_j = gsl_matrix_column (A, j);\n \n double s = gsl_blas_dasum(&A_j.vector);\n \n double f = 1.0;\n \n if (s == 0.0)\n {\n gsl_vector_set (D, j, f);\n continue;\n }\n\n while (s > 1.0)\n {\n s /= 2.0;\n f *= 2.0;\n }\n \n while (s < 0.5)\n {\n s *= 2.0;\n f /= 2.0;\n }\n \n gsl_vector_set (D, j, f);\n\n if (f != 1.0)\n {\n gsl_blas_dscal(1.0/f, &A_j.vector);\n }\n }\n\n return GSL_SUCCESS;\n}\n", "meta": {"hexsha": "3257095cf06b92af32692b1657c232c0580162c7", "size": 1905, "ext": "c", "lang": "C", "max_stars_repo_path": "code/em/treba/gsl-1.0/linalg/balance.c", "max_stars_repo_name": "ICML14MoMCompare/spectral-learn", "max_stars_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-12-18T18:09:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-10T11:31:28.000Z", "max_issues_repo_path": "code/em/treba/gsl-1.0/linalg/balance.c", "max_issues_repo_name": "ICML14MoMCompare/spectral-learn", "max_issues_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "code/em/treba/gsl-1.0/linalg/balance.c", "max_forks_repo_name": "ICML14MoMCompare/spectral-learn", "max_forks_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2015-10-02T01:32:59.000Z", "max_forks_repo_forks_event_max_datetime": "2015-10-02T01:32:59.000Z", "avg_line_length": 22.4117647059, "max_line_length": 76, "alphanum_fraction": 0.5921259843, "num_tokens": 548, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7634837743174788, "lm_q2_score": 0.6959583313396339, "lm_q1q2_score": 0.5313528935788782}} {"text": "/**\n *\n * @precisions normal z -> c d s\n *\n **/\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"auxiliary.h\"\n\n/*-------------------------------------------------------------------\n * Check the orthogonality of Q\n */\n\nint z_check_orthogonality(int M, int N, int LDQ, PLASMA_Complex64_t *Q)\n{\n double alpha, beta;\n double normQ;\n int info_ortho;\n int i;\n int minMN = min(M, N);\n double eps;\n double *work = (double *)malloc(minMN*sizeof(double));\n\n eps = LAPACKE_dlamch_work('e');\n alpha = 1.0;\n beta = -1.0;\n\n /* Build the idendity matrix USE DLASET?*/\n PLASMA_Complex64_t *Id = (PLASMA_Complex64_t *) malloc(minMN*minMN*sizeof(PLASMA_Complex64_t));\n memset((void*)Id, 0, minMN*minMN*sizeof(PLASMA_Complex64_t));\n for (i = 0; i < minMN; i++)\n Id[i*minMN+i] = (PLASMA_Complex64_t)1.0;\n\n /* Perform Id - Q'Q */\n if (M >= N)\n cblas_zherk(CblasColMajor, CblasUpper, CblasConjTrans, N, M, alpha, Q, LDQ, beta, Id, N);\n else\n cblas_zherk(CblasColMajor, CblasUpper, CblasNoTrans, M, N, alpha, Q, LDQ, beta, Id, M);\n\n normQ = LAPACKE_zlansy_work(LAPACK_COL_MAJOR, 'i', 'u', minMN, Id, minMN, work);\n\n printf(\"============\\n\");\n printf(\"Checking the orthogonality of Q \\n\");\n printf(\"||Id-Q'*Q||_oo / (N*eps) = %e \\n\",normQ/(minMN*eps));\n\n if ( isnan(normQ / (minMN * eps)) || (normQ / (minMN * eps) > 10.0) ) {\n printf(\"-- Orthogonality is suspicious ! \\n\");\n info_ortho=1;\n }\n else {\n printf(\"-- Orthogonality is CORRECT ! \\n\");\n info_ortho=0;\n }\n\n free(work); free(Id);\n\n return info_ortho;\n}\n\n/*------------------------------------------------------------\n * Check the factorization QR\n */\n\nint z_check_QRfactorization(int M, int N, PLASMA_Complex64_t *A1, PLASMA_Complex64_t *A2, int LDA, PLASMA_Complex64_t *Q)\n{\n double Anorm, Rnorm;\n PLASMA_Complex64_t alpha, beta;\n int info_factorization;\n int i,j;\n double eps;\n\n eps = LAPACKE_dlamch_work('e');\n\n PLASMA_Complex64_t *Ql = (PLASMA_Complex64_t *)malloc(M*N*sizeof(PLASMA_Complex64_t));\n PLASMA_Complex64_t *Residual = (PLASMA_Complex64_t *)malloc(M*N*sizeof(PLASMA_Complex64_t));\n double *work = (double *)malloc(max(M,N)*sizeof(double));\n\n alpha=1.0;\n beta=0.0;\n\n if (M >= N) {\n /* Extract the R */\n PLASMA_Complex64_t *R = (PLASMA_Complex64_t *)malloc(N*N*sizeof(PLASMA_Complex64_t));\n memset((void*)R, 0, N*N*sizeof(PLASMA_Complex64_t));\n LAPACKE_zlacpy_work(LAPACK_COL_MAJOR,'u', M, N, A2, LDA, R, N);\n\n /* Perform Ql=Q*R */\n memset((void*)Ql, 0, M*N*sizeof(PLASMA_Complex64_t));\n cblas_zgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, M, N, N, CBLAS_SADDR(alpha), Q, LDA, R, N, CBLAS_SADDR(beta), Ql, M);\n free(R);\n }\n else {\n /* Extract the L */\n PLASMA_Complex64_t *L = (PLASMA_Complex64_t *)malloc(M*M*sizeof(PLASMA_Complex64_t));\n memset((void*)L, 0, M*M*sizeof(PLASMA_Complex64_t));\n LAPACKE_zlacpy_work(LAPACK_COL_MAJOR,'l', M, N, A2, LDA, L, M);\n\n /* Perform Ql=LQ */\n memset((void*)Ql, 0, M*N*sizeof(PLASMA_Complex64_t));\n cblas_zgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, M, N, M, CBLAS_SADDR(alpha), L, M, Q, LDA, CBLAS_SADDR(beta), Ql, M);\n free(L);\n }\n\n /* Compute the Residual */\n for (i = 0; i < M; i++)\n for (j = 0 ; j < N; j++)\n Residual[j*M+i] = A1[j*LDA+i]-Ql[j*M+i];\n\n Rnorm = LAPACKE_zlange_work(LAPACK_COL_MAJOR, 'i', M, N, Residual, M, work);\n Anorm = LAPACKE_zlange_work(LAPACK_COL_MAJOR, 'i', M, N, A2, LDA, work);\n\n if (M >= N) {\n printf(\"============\\n\");\n printf(\"Checking the QR Factorization \\n\");\n printf(\"-- ||A-QR||_oo/(||A||_oo.N.eps) = %e \\n\",Rnorm/(Anorm*N*eps));\n }\n else {\n printf(\"============\\n\");\n printf(\"Checking the LQ Factorization \\n\");\n printf(\"-- ||A-LQ||_oo/(||A||_oo.N.eps) = %e \\n\",Rnorm/(Anorm*N*eps));\n }\n\n if (isnan(Rnorm / (Anorm * N *eps)) || (Rnorm / (Anorm * N * eps) > 10.0) ) {\n printf(\"-- Factorization is suspicious ! \\n\");\n info_factorization = 1;\n }\n else {\n printf(\"-- Factorization is CORRECT ! \\n\");\n info_factorization = 0;\n }\n\n free(work); free(Ql); free(Residual);\n\n return info_factorization;\n}\n\n/*------------------------------------------------------------------------\n * Check the factorization of the matrix A2\n */\n\nint z_check_LLTfactorization(int N, PLASMA_Complex64_t *A1, PLASMA_Complex64_t *A2, int LDA, int uplo)\n{\n double Anorm, Rnorm;\n PLASMA_Complex64_t alpha;\n int info_factorization;\n int i,j;\n double eps;\n\n eps = LAPACKE_dlamch_work('e');\n\n PLASMA_Complex64_t *Residual = (PLASMA_Complex64_t *)malloc(N*N*sizeof(PLASMA_Complex64_t));\n PLASMA_Complex64_t *L1 = (PLASMA_Complex64_t *)malloc(N*N*sizeof(PLASMA_Complex64_t));\n PLASMA_Complex64_t *L2 = (PLASMA_Complex64_t *)malloc(N*N*sizeof(PLASMA_Complex64_t));\n double *work = (double *)malloc(N*sizeof(double));\n\n memset((void*)L1, 0, N*N*sizeof(PLASMA_Complex64_t));\n memset((void*)L2, 0, N*N*sizeof(PLASMA_Complex64_t));\n\n alpha= 1.0;\n\n LAPACKE_zlacpy_work(LAPACK_COL_MAJOR,' ', N, N, A1, LDA, Residual, N);\n\n /* Dealing with L'L or U'U */\n if (uplo == PlasmaUpper){\n LAPACKE_zlacpy_work(LAPACK_COL_MAJOR,'u', N, N, A2, LDA, L1, N);\n LAPACKE_zlacpy_work(LAPACK_COL_MAJOR,'u', N, N, A2, LDA, L2, N);\n cblas_ztrmm(CblasColMajor, CblasLeft, CblasUpper, CblasConjTrans, CblasNonUnit, N, N, CBLAS_SADDR(alpha), L1, N, L2, N);\n }\n else{\n LAPACKE_zlacpy_work(LAPACK_COL_MAJOR,'l', N, N, A2, LDA, L1, N);\n LAPACKE_zlacpy_work(LAPACK_COL_MAJOR,'l', N, N, A2, LDA, L2, N);\n cblas_ztrmm(CblasColMajor, CblasRight, CblasLower, CblasConjTrans, CblasNonUnit, N, N, CBLAS_SADDR(alpha), L1, N, L2, N);\n }\n\n /* Compute the Residual || A -L'L|| */\n for (i = 0; i < N; i++)\n for (j = 0; j < N; j++)\n Residual[j*N+i] = L2[j*N+i] - Residual[j*N+i];\n\n Rnorm = LAPACKE_zlange_work(LAPACK_COL_MAJOR, 'i', N, N, Residual, N, work);\n Anorm = LAPACKE_zlange_work(LAPACK_COL_MAJOR, 'i', N, N, A1, LDA, work);\n\n printf(\"============\\n\");\n printf(\"Checking the Cholesky Factorization \\n\");\n printf(\"-- ||L'L-A||_oo/(||A||_oo.N.eps) = %e \\n\",Rnorm/(Anorm*N*eps));\n\n if ( isnan(Rnorm/(Anorm*N*eps)) || (Rnorm/(Anorm*N*eps) > 10.0) ){\n printf(\"-- Factorization is suspicious ! \\n\");\n info_factorization = 1;\n }\n else{\n printf(\"-- Factorization is CORRECT ! \\n\");\n info_factorization = 0;\n }\n\n free(Residual); free(L1); free(L2); free(work);\n\n return info_factorization;\n}\n\n/*--------------------------------------------------------------\n * Check the gemm\n */\ndouble z_check_gemm(PLASMA_enum transA, PLASMA_enum transB, int M, int N, int K,\n PLASMA_Complex64_t alpha, PLASMA_Complex64_t *A, int LDA,\n PLASMA_Complex64_t *B, int LDB,\n PLASMA_Complex64_t beta, PLASMA_Complex64_t *Cplasma,\n PLASMA_Complex64_t *Cref, int LDC,\n double *Cinitnorm, double *Cplasmanorm, double *Clapacknorm )\n{\n PLASMA_Complex64_t beta_const = -1.0;\n double Rnorm;\n double *work = (double *)malloc(max(K,max(M, N))* sizeof(double));\n\n *Cinitnorm = LAPACKE_zlange_work(LAPACK_COL_MAJOR, 'i', M, N, Cref, LDC, work);\n *Cplasmanorm = LAPACKE_zlange_work(LAPACK_COL_MAJOR, 'i', M, N, Cplasma, LDC, work);\n\n cblas_zgemm(CblasColMajor, (CBLAS_TRANSPOSE)transA, (CBLAS_TRANSPOSE)transB, M, N, K,\n CBLAS_SADDR(alpha), A, LDA, B, LDB, CBLAS_SADDR(beta), Cref, LDC);\n\n *Clapacknorm = LAPACKE_zlange_work(LAPACK_COL_MAJOR, 'i', M, N, Cref, LDC, work);\n\n cblas_zaxpy(LDC * N, CBLAS_SADDR(beta_const), Cplasma, 1, Cref, 1);\n\n Rnorm = LAPACKE_zlange_work(LAPACK_COL_MAJOR, 'i', M, N, Cref, LDC, work);\n\n free(work);\n\n return Rnorm;\n}\n\n/*--------------------------------------------------------------\n * Check the trsm\n */\ndouble z_check_trsm(PLASMA_enum side, PLASMA_enum uplo, PLASMA_enum trans, PLASMA_enum diag,\n int M, int NRHS, PLASMA_Complex64_t alpha,\n PLASMA_Complex64_t *A, int LDA,\n PLASMA_Complex64_t *Bplasma, PLASMA_Complex64_t *Bref, int LDB,\n double *Binitnorm, double *Bplasmanorm, double *Blapacknorm )\n{\n PLASMA_Complex64_t beta_const = -1.0;\n double Rnorm;\n double *work = (double *)malloc(max(M, NRHS)* sizeof(double));\n /*double eps = LAPACKE_dlamch_work('e');*/\n\n *Binitnorm = LAPACKE_zlange_work(LAPACK_COL_MAJOR, 'i', M, NRHS, Bref, LDB, work);\n *Bplasmanorm = LAPACKE_zlange_work(LAPACK_COL_MAJOR, 'm', M, NRHS, Bplasma, LDB, work);\n\n cblas_ztrsm(CblasColMajor, (CBLAS_SIDE)side, (CBLAS_UPLO)uplo,\n (CBLAS_TRANSPOSE)trans, (CBLAS_DIAG)diag, M, NRHS,\n CBLAS_SADDR(alpha), A, LDA, Bref, LDB);\n\n *Blapacknorm = LAPACKE_zlange_work(LAPACK_COL_MAJOR, 'm', M, NRHS, Bref, LDB, work);\n\n cblas_zaxpy(LDB * NRHS, CBLAS_SADDR(beta_const), Bplasma, 1, Bref, 1);\n\n Rnorm = LAPACKE_zlange_work(LAPACK_COL_MAJOR, 'm', M, NRHS, Bref, LDB, work);\n Rnorm = Rnorm / *Blapacknorm; \n /* max(M,NRHS) * eps);*/\n\n free(work);\n\n return Rnorm;\n}\n\n/*--------------------------------------------------------------\n * Check the solution\n */\n\ndouble z_check_solution(int M, int N, int NRHS, PLASMA_Complex64_t *A, int LDA,\n PLASMA_Complex64_t *B, PLASMA_Complex64_t *X, int LDB,\n double *anorm, double *bnorm, double *xnorm )\n{\n/* int info_solution; */\n double Rnorm = -1.00;\n PLASMA_Complex64_t zone = 1.0;\n PLASMA_Complex64_t mzone = -1.0;\n double *work = (double *)malloc(max(M, N)* sizeof(double));\n\n *anorm = LAPACKE_zlange_work(LAPACK_COL_MAJOR, 'i', M, N, A, LDA, work);\n *xnorm = LAPACKE_zlange_work(LAPACK_COL_MAJOR, 'i', M, NRHS, X, LDB, work);\n *bnorm = LAPACKE_zlange_work(LAPACK_COL_MAJOR, 'i', N, NRHS, B, LDB, work);\n\n cblas_zgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, M, NRHS, N, CBLAS_SADDR(zone), A, LDA, X, LDB, CBLAS_SADDR(mzone), B, LDB);\n\n Rnorm = LAPACKE_zlange_work(LAPACK_COL_MAJOR, 'i', N, NRHS, B, LDB, work);\n\n free(work);\n\n return Rnorm;\n}\n", "meta": {"hexsha": "33a65837af5a2c44d44b0994863d588d15dcdc4c", "size": 10542, "ext": "c", "lang": "C", "max_stars_repo_path": "timing/zauxiliary.c", "max_stars_repo_name": "zhuangsc/Plasma-ompss1", "max_stars_repo_head_hexsha": "bcc99c164a256bc7df7c936b9c43afd38c12aea2", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "timing/zauxiliary.c", "max_issues_repo_name": "zhuangsc/Plasma-ompss1", "max_issues_repo_head_hexsha": "bcc99c164a256bc7df7c936b9c43afd38c12aea2", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "timing/zauxiliary.c", "max_forks_repo_name": "zhuangsc/Plasma-ompss1", "max_forks_repo_head_hexsha": "bcc99c164a256bc7df7c936b9c43afd38c12aea2", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.3758389262, "max_line_length": 134, "alphanum_fraction": 0.5913488902, "num_tokens": 3577, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8244619177503205, "lm_q2_score": 0.6442251064863697, "lm_q1q2_score": 0.5311390667566568}} {"text": "#include \"parameters.h\" // Includes all defined parameters\n#include \"axi.h\" // Axisymmetric coordinates\n#include \"navier-stokes/centered.h\" // To solve the Navier-Stokes\n#include \"two-phase.h\" // Implements two-phase flow\n// #include // For openMP parallel\n#include \n\n\ndouble * forces_array;\ndouble * times_array;\n\ndouble gradient = 0.5;\ndouble intercept = 4.9;\n\nint main () {\n\n forces_array = malloc(INTERP_NO * sizeof(double));\n times_array = malloc(INTERP_NO * sizeof(double));\n\n DT = 1e-2;\n\n run();\n\n free(forces_array);\n free(times_array);\n}\n\nevent force(i++) {\n if (i < INTERP_NO) {\n forces_array[i] = gradient * t + intercept;\n times_array[i] = t;\n } else {\n double c0, c1, cov00, cov01, cov11, sumsq;\n gsl_fit_linear ( times_array, 1, forces_array, 1, INTERP_NO, &c0, &c1, \\\n &cov00, &cov01, &cov11, &sumsq);\n\n fprintf(stderr, \"t = %g, c0 = %g, c1 = %g\\n\", t, c0, c1);\n \n double current_force = gradient * t + intercept;\n double interp_force = c0 + c1 * t;\n fprintf(stderr, \"f = %g, f_interp = %g\", current_force, interp_force);\n fprintf(stderr, \"\\n\");\n\n // #pragma omp critical\n for (int j = 0; j < INTERP_NO - 1; j++) {\n forces_array[j] = forces_array[j + 1];\n times_array[j] = times_array[j + 1];\n }\n forces_array[INTERP_NO - 1] = current_force;\n times_array[INTERP_NO - 1] = t;\n }\n}\n\nevent end(t = 1) {\n fprintf(stderr, \"Ended\\n\");\n}", "meta": {"hexsha": "fda2da105df234611cf828b8b3714e0f3d271508", "size": 1536, "ext": "c", "lang": "C", "max_stars_repo_path": "deprecated_code/regression_test/code/regression.c", "max_stars_repo_name": "MNegus/plate-impact", "max_stars_repo_head_hexsha": "353ad2e1b36520b2088d90a362cff0116e1dd248", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "deprecated_code/regression_test/code/regression.c", "max_issues_repo_name": "MNegus/plate-impact", "max_issues_repo_head_hexsha": "353ad2e1b36520b2088d90a362cff0116e1dd248", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "deprecated_code/regression_test/code/regression.c", "max_forks_repo_name": "MNegus/plate-impact", "max_forks_repo_head_hexsha": "353ad2e1b36520b2088d90a362cff0116e1dd248", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.4285714286, "max_line_length": 80, "alphanum_fraction": 0.587890625, "num_tokens": 452, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8198933447152498, "lm_q2_score": 0.6477982179521103, "lm_q1q2_score": 0.5311254476173342}} {"text": "/*\n * testgen.c\n * Patrick Alken\n *\n * Compile: gcc -g -O2 -Wall -o testgen testgen.c -lm -lgsl -llapack -lf77blas -lcblas -latlas -lg2c\n *\n * Usage: testgen [options]\n *\n * -i : incremental matrices\n * -z : compute Schur vectors and test them\n * -n size : size of matrices\n * -l lower-bound : lower bound for matrix elements\n * -u upper-bound : upper bound for matrix elements\n * -c num : number of matrices to solve\n */\n\n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\ntypedef struct\n{\n gsl_eigen_gen_workspace *gen_p;\n gsl_matrix *A;\n gsl_matrix *B;\n gsl_vector_complex *alpha;\n gsl_vector *beta;\n gsl_vector_complex *evals;\n\n gsl_matrix *Q;\n gsl_matrix *Z;\n int compute_schur;\n\n size_t n_evals;\n} gen_workspace;\n\ngen_workspace *gen_alloc(size_t n, int compute_schur);\nvoid gen_free(gen_workspace *w);\nint gen_proc(gen_workspace *w);\n\ntypedef struct\n{\n gsl_matrix *A;\n gsl_matrix *B;\n gsl_matrix *Q;\n gsl_matrix *Z;\n int N;\n\n char jobvsl;\n char jobvsr;\n char sort;\n int selctg;\n int lda;\n int ldb;\n int sdim;\n double *alphar;\n double *alphai;\n gsl_vector *beta;\n int ldvsr;\n int lwork;\n int info;\n double *work;\n \n gsl_vector_complex *evals;\n gsl_vector_complex *alpha;\n size_t n_evals;\n} lapack_workspace;\n\nlapack_workspace *lapack_alloc(const size_t n);\nvoid lapack_free(lapack_workspace *w);\nint lapack_proc(lapack_workspace *w);\n\nvoid dgges_(char *jobvsl, char *jobvsr, char *sort, int *selctg, int *n,\n double *a, int *lda, double *b, int *ldb, int *sdim,\n double *alphar, double *alphai, double *beta, double *vsl,\n int *ldvsl, double *vsr, int *ldvsr, double *work, int *lwork,\n int *bwork, int *info);\n\n/*\n * Global variables\n */\nunsigned long count = 0;\n\n/*\n * Prototypes\n */\n\nvoid make_random_matrix(gsl_matrix *m, gsl_rng *r, int lower, int upper);\nvoid make_random_integer_matrix(gsl_matrix *m, gsl_rng *r, int lower,\n int upper);\nvoid make_start_matrix(gsl_matrix *m, int lower);\nint inc_matrix (gsl_matrix *m, int lower, int upper);\nvoid output_matrix(gsl_matrix *m);\nvoid print_matrix(gsl_matrix *m, const char *str);\nint test_evals(gsl_vector_complex *obs, gsl_vector_complex *expected,\n gsl_matrix *A, gsl_matrix *B,\n const char *obsname, const char *expname);\nint test_alpha(gsl_vector_complex *obs, gsl_vector_complex *expected,\n gsl_matrix *A, gsl_matrix *B, const char *obsname,\n const char *expname);\nint test_beta(gsl_vector *obs, gsl_vector *expected,\n gsl_matrix *A, gsl_matrix *B, const char *obsname,\n const char *expname);\nvoid test_schur(gsl_matrix *A, gsl_matrix *S, gsl_matrix *Q, gsl_matrix *Z);\nvoid print_vector(gsl_vector_complex *eval, const char *str);\nint cmp(double a, double b);\nint compare(const void *a, const void *b);\nvoid sort_complex_vector(gsl_vector_complex *v);\n\ngen_workspace *\ngen_alloc(size_t n, int compute_schur)\n{\n gen_workspace *w;\n\n w = (gen_workspace *) calloc(1, sizeof(gen_workspace));\n\n w->gen_p = gsl_eigen_gen_alloc(n);\n\n w->A = gsl_matrix_alloc(n, n);\n w->B = gsl_matrix_alloc(n, n);\n w->alpha = gsl_vector_complex_alloc(n);\n w->beta = gsl_vector_alloc(n);\n w->evals = gsl_vector_complex_alloc(n);\n w->compute_schur = compute_schur;\n\n if (compute_schur)\n {\n w->Q = gsl_matrix_alloc(n, n);\n w->Z = gsl_matrix_alloc(n, n);\n gsl_eigen_gen_params(1, 1, 0, w->gen_p);\n }\n\n return (w);\n} /* gen_alloc() */\n\nvoid\ngen_free(gen_workspace *w)\n{\n if (w->gen_p)\n gsl_eigen_gen_free(w->gen_p);\n\n if (w->A)\n gsl_matrix_free(w->A);\n\n if (w->B)\n gsl_matrix_free(w->B);\n\n if (w->alpha)\n gsl_vector_complex_free(w->alpha);\n\n if (w->beta)\n gsl_vector_free(w->beta);\n\n if (w->evals)\n gsl_vector_complex_free(w->evals);\n\n if (w->Q)\n gsl_matrix_free(w->Q);\n\n if (w->Z)\n gsl_matrix_free(w->Z);\n\n free(w);\n}\n\nint\ngen_proc(gen_workspace *w)\n{\n int s;\n\n s = gsl_eigen_gen_QZ(w->A, w->B, w->alpha, w->beta, w->Q, w->Z, w->gen_p);\n\n w->n_evals = w->gen_p->n_evals;\n\n return s;\n} /* gen_proc() */\n\nlapack_workspace *\nlapack_alloc(const size_t n)\n{\n lapack_workspace *w;\n double work[1];\n\n w = (lapack_workspace *) calloc(1, sizeof(lapack_workspace));\n\n w->A = gsl_matrix_alloc(n, n);\n w->B = gsl_matrix_alloc(n, n);\n w->Q = gsl_matrix_alloc(n, n);\n w->Z = gsl_matrix_alloc(n, n);\n w->alphar = malloc(n * sizeof(double));\n w->alphai = malloc(n * sizeof(double));\n w->beta = gsl_vector_alloc(n);\n w->alpha = gsl_vector_complex_alloc(n);\n w->evals = gsl_vector_complex_alloc(n);\n\n w->N = (int) n;\n w->n_evals = 0;\n\n w->jobvsl = 'N';\n w->jobvsr = 'N';\n w->sort = 'N';\n w->info = 0;\n\n w->lwork = -1;\n dgges_(&w->jobvsl,\n &w->jobvsr,\n &w->sort,\n (int *) 0,\n &w->N,\n w->A->data,\n (int *) &w->A->tda,\n w->B->data,\n (int *) &w->B->tda,\n &w->sdim,\n w->alphar,\n w->alphai,\n w->beta->data,\n w->Q->data,\n (int *) &w->Q->tda,\n w->Z->data,\n (int *) &w->Z->tda,\n work,\n &w->lwork,\n (int *) 0,\n &w->info);\n\n w->lwork = (int) work[0];\n w->work = malloc(w->lwork * sizeof(double));\n\n return (w);\n} /* lapack_alloc() */\n\nvoid\nlapack_free(lapack_workspace *w)\n{\n if (w->A)\n gsl_matrix_free(w->A);\n\n if (w->B)\n gsl_matrix_free(w->B);\n\n if (w->Q)\n gsl_matrix_free(w->Q);\n\n if (w->Z)\n gsl_matrix_free(w->Z);\n\n if (w->work)\n free(w->work);\n\n if (w->alphar)\n free(w->alphar);\n\n if (w->alphai)\n free(w->alphai);\n\n if (w->beta)\n gsl_vector_free(w->beta);\n\n if (w->alpha)\n gsl_vector_complex_free(w->alpha);\n\n if (w->evals)\n gsl_vector_complex_free(w->evals);\n\n free(w);\n} /* lapack_free() */\n\nint\nlapack_proc(lapack_workspace *w)\n{\n dgges_(&w->jobvsl,\n &w->jobvsr,\n &w->sort,\n (int *) 0,\n &w->N,\n w->A->data,\n (int *) &w->A->tda,\n w->B->data,\n (int *) &w->B->tda,\n &w->sdim,\n w->alphar,\n w->alphai,\n w->beta->data,\n w->Q->data,\n (int *) &w->Q->tda,\n w->Z->data,\n (int *) &w->Z->tda,\n w->work,\n &w->lwork,\n (int *) 0,\n &w->info);\n\n return (w->info);\n} /* lapack_proc() */\n\n/**********************************************\n * General routines\n **********************************************/\n\nvoid\nmake_random_matrix(gsl_matrix *m, gsl_rng *r, int lower, int upper)\n{\n size_t i, j;\n size_t N = m->size1;\n\n for (i = 0; i < N; ++i)\n {\n for (j = 0; j < N; ++j)\n {\n gsl_matrix_set(m,\n i,\n j,\n gsl_rng_uniform(r) * (upper - lower) + lower);\n }\n }\n} /* make_random_matrix() */\n\nvoid\nmake_random_integer_matrix(gsl_matrix *m, gsl_rng *r, int lower, int upper)\n{\n size_t i, j;\n size_t N = m->size1;\n\n for (i = 0; i < N; ++i)\n {\n for (j = 0; j < N; ++j)\n {\n double a = gsl_rng_uniform(r) * (upper - lower) + lower;\n gsl_matrix_set(m, i, j, floor(a));\n }\n }\n} /* make_random_integer_matrix() */\n\nvoid\nmake_start_matrix(gsl_matrix *m, int lower)\n\n{\n size_t i, j;\n size_t N = m->size1;\n\n for (i = 0; i < N; ++i)\n for (j = 0; j < N; ++j)\n gsl_matrix_set(m, i, j, (double)lower);\n} /* make_start_matrix() */\n\nint\ninc_matrix (gsl_matrix *m, int lower, int upper)\n{\n size_t i = 0;\n size_t N = m->size1 * m->size2;\n int carry = 1;\n\n for (i = 0; carry > 0 && i < N; i++)\n {\n double v = m->data[i] + carry;\n carry = (v > upper) ? 1 : 0;\n m->data[i] = (v > upper) ? lower : v;\n }\n\n return carry;\n} /* inc_matrix() */\n\nvoid\noutput_matrix(gsl_matrix *m)\n{\n size_t i, j;\n size_t N = m->size1;\n size_t M = m->size2;\n\n for (i = 0; i < N; ++i)\n {\n for (j = 0; j < M; ++j)\n {\n printf(\"%10.18e%s\",\n /*printf(\"%10.18e%s\",*/\n gsl_matrix_get(m, i, j),\n (j < M - 1) ? \",\" : \";\\n\");\n }\n }\n}\n\nvoid\nprint_matrix(gsl_matrix *m, const char *str)\n\n{\n size_t i, j;\n size_t N = m->size1;\n size_t M = m->size2;\n gsl_matrix_view v;\n size_t rows, cols;\n size_t r, c;\n char buf[100];\n\n /*print_octave(m, str);\n return;*/\n\n /*rows = GSL_MIN(15, N);*/\n rows = N;\n cols = GSL_MIN(15, N);\n /*cols = N;*/\n\n for (i = 0; i < N; i += rows)\n {\n for (j = 0; j < M; j += cols)\n {\n r = GSL_MIN(rows, N - i);\n c = GSL_MIN(cols, N - j);\n\n v = gsl_matrix_submatrix(m, i, j, r, c);\n\n sprintf(buf, \"%s(%u:%u,%u:%u)\",\n str,\n i + 1,\n i + r,\n j + 1,\n j + c);\n\n printf(\"%s = [\\n\", buf);\n\n output_matrix(&v.matrix);\n\n printf(\"]\\n\");\n }\n }\n} /* print_matrix() */\n\nint\ntest_evals(gsl_vector_complex *obs, gsl_vector_complex *expected,\n gsl_matrix *A, gsl_matrix *B, const char *obsname,\n const char *expname)\n{\n size_t N = expected->size;\n size_t i, k;\n double max, max_abserr, max_relerr;\n\n max = 0.0;\n max_abserr = 0.0;\n max_relerr = 0.0;\n k = 0;\n\n for (i = 0; i < N; ++i)\n {\n gsl_complex z = gsl_vector_complex_get(expected, i);\n max = GSL_MAX_DBL(max, gsl_complex_abs(z));\n }\n\n for (i = 0; i < N; ++i)\n {\n gsl_complex z_obs = gsl_vector_complex_get(obs, i);\n gsl_complex z_exp = gsl_vector_complex_get(expected, i);\n\n double x_obs = GSL_REAL(z_obs);\n double y_obs = GSL_IMAG(z_obs);\n double x_exp = GSL_REAL(z_exp);\n double y_exp = GSL_IMAG(z_exp);\n\n double abserr_x = fabs(x_obs - x_exp);\n double abserr_y = fabs(y_obs - y_exp);\n double noise = max * GSL_DBL_EPSILON * N * N;\n\n max_abserr = GSL_MAX_DBL(max_abserr, abserr_x + abserr_y);\n\n if (abserr_x < noise && abserr_y < noise)\n continue;\n\n if (abserr_x > 1.0e-6 || abserr_y > 1.0e-6)\n ++k;\n }\n\n if (k)\n {\n printf(\"==== CASE %lu ===========================\\n\\n\", count);\n\n print_matrix(A, \"A\");\n print_matrix(B, \"B\");\n\n printf(\"=== eval - %s ===\\n\", expname);\n print_vector(expected, expname);\n\n printf(\"=== eval - %s ===\\n\", obsname);\n print_vector(obs, obsname);\n\n printf(\"max abserr = %g max relerr = %g\\n\", max_abserr, max_relerr);\n\n printf(\"=========================================\\n\\n\");\n }\n\n return k;\n} /* test_evals() */\n\nint\ntest_alpha(gsl_vector_complex *obs, gsl_vector_complex *expected,\n gsl_matrix *A, gsl_matrix *B, const char *obsname,\n const char *expname)\n{\n size_t N = expected->size;\n size_t i, k;\n double max, max_abserr, max_relerr;\n\n max = 0.0;\n max_abserr = 0.0;\n max_relerr = 0.0;\n k = 0;\n\n for (i = 0; i < N; ++i)\n {\n gsl_complex z = gsl_vector_complex_get(expected, i);\n max = GSL_MAX_DBL(max, gsl_complex_abs(z));\n }\n\n for (i = 0; i < N; ++i)\n {\n gsl_complex z_obs = gsl_vector_complex_get(obs, i);\n gsl_complex z_exp = gsl_vector_complex_get(expected, i);\n\n double x_obs = GSL_REAL(z_obs);\n double y_obs = fabs(GSL_IMAG(z_obs));\n double x_exp = GSL_REAL(z_exp);\n double y_exp = fabs(GSL_IMAG(z_exp));\n\n double abserr_x = fabs(x_obs - x_exp);\n double abserr_y = fabs(y_obs - y_exp);\n double noise = max * GSL_DBL_EPSILON * N * N;\n\n max_abserr = GSL_MAX_DBL(max_abserr, abserr_x + abserr_y);\n\n if (abserr_x < noise && abserr_y < noise)\n continue;\n\n if (abserr_x > 1.0e-6 || abserr_y > 1.0e-6)\n ++k;\n }\n\n if (k)\n {\n printf(\"==== CASE %lu ===========================\\n\\n\", count);\n\n print_matrix(A, \"A\");\n print_matrix(B, \"B\");\n\n printf(\"=== alpha - %s ===\\n\", expname);\n print_vector(expected, expname);\n\n printf(\"=== alpha - %s ===\\n\", obsname);\n print_vector(obs, obsname);\n\n printf(\"max abserr = %g max relerr = %g\\n\", max_abserr, max_relerr);\n\n printf(\"=========================================\\n\\n\");\n }\n\n return k;\n} /* test_alpha() */\n\nint\ntest_beta(gsl_vector *obs, gsl_vector *expected,\n gsl_matrix *A, gsl_matrix *B, const char *obsname,\n const char *expname)\n{\n size_t N = expected->size;\n size_t i, k;\n double max, max_abserr, max_relerr;\n\n max = 0.0;\n max_abserr = 0.0;\n max_relerr = 0.0;\n k = 0;\n\n for (i = 0; i < N; ++i)\n {\n double z = gsl_vector_get(expected, i);\n max = GSL_MAX_DBL(max, fabs(z));\n }\n\n for (i = 0; i < N; ++i)\n {\n double v_obs = gsl_vector_get(obs, i);\n double v_exp = gsl_vector_get(expected, i);\n double abserr = fabs(v_obs - v_exp);\n double noise = max * GSL_DBL_EPSILON * N * N;\n\n max_abserr = GSL_MAX_DBL(max_abserr, abserr);\n\n if (abserr < noise)\n continue;\n\n if (abserr > 1.0e-6)\n ++k;\n }\n\n if (k)\n {\n printf(\"==== CASE %lu ===========================\\n\\n\", count);\n\n print_matrix(A, \"A\");\n print_matrix(B, \"B\");\n\n printf(\"=== beta - %s ===\\n\", expname);\n printf(\"%s = [\\n\", expname);\n gsl_vector_fprintf(stdout, expected, \"%.12e\");\n printf(\"]\\n\");\n\n printf(\"=== beta - %s ===\\n\", obsname);\n printf(\"%s = [\\n\", obsname);\n gsl_vector_fprintf(stdout, obs, \"%.12e\");\n printf(\"]\\n\");\n\n printf(\"max abserr = %g max relerr = %g\\n\", max_abserr, max_relerr);\n\n printf(\"=========================================\\n\\n\");\n }\n\n return k;\n} /* test_beta() */\n\n/* test if A = Q S Z^t */\nvoid\ntest_schur(gsl_matrix *A, gsl_matrix *S, gsl_matrix *Q, gsl_matrix *Z)\n{\n const size_t N = A->size1;\n gsl_matrix *T1, *T2;\n size_t i, j, k;\n double lhs, rhs;\n double abserr;\n\n T1 = gsl_matrix_alloc(N, N);\n T2 = gsl_matrix_alloc(N, N);\n\n /* compute T1 = S Z^t */\n gsl_blas_dgemm(CblasNoTrans,\n CblasTrans,\n 1.0,\n S,\n Z,\n 0.0,\n T1);\n\n /* compute T2 = Q T1 = Q S Z^t */\n gsl_blas_dgemm(CblasNoTrans,\n CblasNoTrans,\n 1.0,\n Q,\n T1,\n 0.0,\n T2);\n\n k = 0;\n for (i = 0; i < N; ++i)\n {\n for (j = 0; j < N; ++j)\n {\n lhs = gsl_matrix_get(A, i, j);\n rhs = gsl_matrix_get(T2, i, j);\n\n abserr = fabs(lhs - rhs);\n\n if (abserr > 1.0e-6)\n ++k;\n }\n }\n\n if (k)\n {\n printf(\"==== CASE %lu ===========================\\n\\n\", count);\n\n print_matrix(A, \"A\");\n\n printf(\"=== Schur Form matrix ===\\n\");\n print_matrix(S, \"S\");\n\n printf(\"=== Left Schur matrix ===\\n\");\n print_matrix(Q, \"Q\");\n\n printf(\"=== Right Schur matrix ===\\n\");\n print_matrix(Z, \"Z\");\n\n printf(\"=== Q S Z^t ===\\n\");\n print_matrix(T1, \"Q S Z^t\");\n\n printf(\"=== A - Q S Z^t ===\\n\");\n gsl_matrix_sub(T2, A);\n print_matrix(T1, \"A - Q S Z^t\");\n\n printf(\"=========================================\\n\\n\");\n }\n\n gsl_matrix_free(T1);\n gsl_matrix_free(T2);\n} /* test_schur() */\n\nvoid\nprint_vector(gsl_vector_complex *eval, const char *str)\n{\n size_t N = eval->size;\n size_t i;\n gsl_complex z;\n\n printf(\"%s = [\\n\", str);\n\n for (i = 0; i < N; ++i)\n {\n z = gsl_vector_complex_get(eval, i);\n printf(\"%.18e %.18e;\\n\", GSL_REAL(z), GSL_IMAG(z));\n }\n\n printf(\"]\\n\");\n} /* print_vector() */\n\nint\ncmp(double a, double b)\n{\n return ((a > b) ? 1 : ((a < b) ? -1 : 0));\n} /* cmp() */\n\nint\ncompare(const void *a, const void *b)\n{\n const double *x = a;\n const double *y = b;\n int r1 = cmp(y[0], x[0]);\n int r2 = cmp(y[1], x[1]);\n\n if (!gsl_finite(x[0]))\n return 1;\n if (!gsl_finite(y[0]))\n return -1;\n\n if (fabs(x[0] - y[0]) < 1.0e-8)\n {\n /* real parts are very close to each other */\n return r2;\n }\n else\n {\n return r1 ? r1 : r2;\n }\n} /* compare() */\n\nvoid\nsort_complex_vector(gsl_vector_complex *v)\n{\n qsort(v->data, v->size, 2 * sizeof(double), &compare);\n} /* sort_complex_vector() */\n\nint\nmain(int argc, char *argv[])\n{\n gen_workspace *gen_workspace_p;\n lapack_workspace *lapack_workspace_p;\n size_t N;\n int c;\n int lower;\n int upper;\n int incremental;\n size_t nmat;\n gsl_matrix *A, *B;\n gsl_rng *r;\n int s;\n int compute_schur;\n size_t i;\n\n gsl_ieee_env_setup();\n gsl_rng_env_setup();\n\n N = 30;\n lower = -10;\n upper = 10;\n incremental = 0;\n nmat = 0;\n compute_schur = 0;\n\n while ((c = getopt(argc, argv, \"ic:n:l:u:z\")) != (-1))\n {\n switch (c)\n {\n case 'i':\n incremental = 1;\n break;\n\n case 'n':\n N = strtol(optarg, NULL, 0);\n break;\n\n case 'l':\n lower = strtol(optarg, NULL, 0);\n break;\n\n case 'u':\n upper = strtol(optarg, NULL, 0);\n break;\n\n case 'c':\n nmat = strtoul(optarg, NULL, 0);\n break;\n\n case 'z':\n compute_schur = 1;\n break;\n\n case '?':\n default:\n printf(\"usage: %s [-i] [-z] [-n size] [-l lower-bound] [-u upper-bound] [-c num]\\n\", argv[0]);\n exit(1);\n break;\n } /* switch (c) */\n }\n\n A = gsl_matrix_alloc(N, N);\n B = gsl_matrix_alloc(N, N);\n gen_workspace_p = gen_alloc(N, compute_schur);\n lapack_workspace_p = lapack_alloc(N);\n\n r = gsl_rng_alloc(gsl_rng_default);\n\n if (incremental)\n {\n make_start_matrix(A, lower);\n\n /* we need B to be non-singular */\n make_random_integer_matrix(B, r, lower, upper);\n }\n\n fprintf(stderr, \"testing N = %d\", N);\n if (incremental)\n fprintf(stderr, \" incrementally\");\n else\n fprintf(stderr, \" randomly\");\n\n fprintf(stderr, \" on element range [%d, %d]\", lower, upper);\n\n if (compute_schur)\n fprintf(stderr, \", with Schur vectors\");\n\n fprintf(stderr, \"\\n\");\n\n while (1)\n {\n if (nmat && (count >= nmat))\n break;\n\n ++count;\n\n if (!incremental)\n {\n make_random_matrix(A, r, lower, upper);\n make_random_matrix(B, r, lower, upper);\n }\n else\n {\n s = inc_matrix(A, lower, upper);\n if (s)\n break; /* all done */\n\n make_random_integer_matrix(B, r, lower, upper);\n }\n\n /*if (count != 89120)\n continue;*/\n\n /* make copies of matrices */\n gsl_matrix_memcpy(gen_workspace_p->A, A);\n gsl_matrix_memcpy(gen_workspace_p->B, B);\n gsl_matrix_transpose_memcpy(lapack_workspace_p->A, A);\n gsl_matrix_transpose_memcpy(lapack_workspace_p->B, B);\n\n /* compute eigenvalues with LAPACK */\n s = lapack_proc(lapack_workspace_p);\n\n if (s != GSL_SUCCESS)\n {\n printf(\"LAPACK failed, case %lu\\n\", count);\n exit(1);\n }\n\n#if 0\n print_matrix(A, \"A\");\n print_matrix(B, \"B\");\n gsl_matrix_transpose(lapack_workspace_p->A);\n gsl_matrix_transpose(lapack_workspace_p->B);\n print_matrix(lapack_workspace_p->A, \"S_lapack\");\n print_matrix(lapack_workspace_p->B, \"T_lapack\");\n#endif\n\n /* compute eigenvalues with GSL */\n s = gen_proc(gen_workspace_p);\n\n if (s != GSL_SUCCESS)\n {\n printf(\"=========== CASE %lu ============\\n\", count);\n printf(\"Failed to converge: found %u eigenvalues\\n\",\n gen_workspace_p->n_evals);\n print_matrix(A, \"A\");\n print_matrix(B, \"B\");\n print_matrix(gen_workspace_p->A, \"Af\");\n print_matrix(gen_workspace_p->B, \"Bf\");\n print_matrix(lapack_workspace_p->A, \"Ae\");\n print_matrix(lapack_workspace_p->B, \"Be\");\n exit(1);\n }\n\n#if 0\n print_matrix(gen_workspace_p->A, \"S_gsl\");\n print_matrix(gen_workspace_p->B, \"T_gsl\");\n#endif\n\n /* compute alpha / beta vectors */\n for (i = 0; i < N; ++i)\n {\n double beta;\n gsl_complex alpha, z;\n\n beta = gsl_vector_get(gen_workspace_p->beta, i);\n if (beta == 0.0)\n GSL_SET_COMPLEX(&z, GSL_POSINF, GSL_POSINF);\n else\n {\n alpha = gsl_vector_complex_get(gen_workspace_p->alpha, i);\n z = gsl_complex_div_real(alpha, beta);\n }\n\n gsl_vector_complex_set(gen_workspace_p->evals, i, z);\n\n beta = gsl_vector_get(lapack_workspace_p->beta, i);\n GSL_SET_COMPLEX(&alpha,\n lapack_workspace_p->alphar[i],\n lapack_workspace_p->alphai[i]);\n\n if (beta == 0.0)\n GSL_SET_COMPLEX(&z, GSL_POSINF, GSL_POSINF);\n else\n z = gsl_complex_div_real(alpha, beta);\n\n gsl_vector_complex_set(lapack_workspace_p->evals, i, z);\n gsl_vector_complex_set(lapack_workspace_p->alpha, i, alpha);\n }\n\n#if 0\n gsl_sort_vector(gen_workspace_p->beta);\n gsl_sort_vector(lapack_workspace_p->beta);\n sort_complex_vector(gen_workspace_p->alpha);\n sort_complex_vector(lapack_workspace_p->alpha);\n\n s = test_alpha(gen_workspace_p->alpha,\n lapack_workspace_p->alpha,\n A,\n B,\n \"gen\",\n \"lapack\");\n s = test_beta(gen_workspace_p->beta,\n lapack_workspace_p->beta,\n A,\n B,\n \"gen\",\n \"lapack\");\n#endif\n#if 1\n sort_complex_vector(gen_workspace_p->evals);\n sort_complex_vector(lapack_workspace_p->evals);\n\n s = test_evals(gen_workspace_p->evals,\n lapack_workspace_p->evals,\n A,\n B,\n \"gen\",\n \"lapack\");\n#endif\n\n if (compute_schur)\n {\n test_schur(A,\n gen_workspace_p->A,\n gen_workspace_p->Q,\n gen_workspace_p->Z);\n test_schur(B,\n gen_workspace_p->B,\n gen_workspace_p->Q,\n gen_workspace_p->Z);\n }\n }\n\n gsl_matrix_free(A);\n gsl_matrix_free(B);\n gen_free(gen_workspace_p);\n lapack_free(lapack_workspace_p);\n\n if (r)\n gsl_rng_free(r);\n\n return 0;\n} /* main() */\n", "meta": {"hexsha": "9d12d93d51a0afe1e9940e2d7003eac6fb5e0f30", "size": 22665, "ext": "c", "lang": "C", "max_stars_repo_path": "Chimera/3rd_Party/GSL_MSVC/eigen/testgen2.c", "max_stars_repo_name": "zzpwahaha/Chimera-Control-Trim", "max_stars_repo_head_hexsha": "df1bbf6bea0b87b8c7c9a99dce213fdc249118f2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-06-14T11:51:37.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-14T11:51:37.000Z", "max_issues_repo_path": "Chimera/3rd_Party/GSL_MSVC/eigen/testgen2.c", "max_issues_repo_name": "zzpwahaha/Chimera-Control-Trim", "max_issues_repo_head_hexsha": "df1bbf6bea0b87b8c7c9a99dce213fdc249118f2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Chimera/3rd_Party/GSL_MSVC/eigen/testgen2.c", "max_forks_repo_name": "zzpwahaha/Chimera-Control-Trim", "max_forks_repo_head_hexsha": "df1bbf6bea0b87b8c7c9a99dce213fdc249118f2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-01-20T16:22:57.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-14T12:31:02.000Z", "avg_line_length": 22.552238806, "max_line_length": 106, "alphanum_fraction": 0.5316567395, "num_tokens": 6774, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.815232480373843, "lm_q2_score": 0.6513548578981939, "lm_q1q2_score": 0.5310056364078967}} {"text": "// Copyright (c) 2021 Stig Rune Sellevag\n//\n// This file is distributed under the MIT License. See the accompanying file\n// LICENSE.txt or http://www.opensource.org/licenses/mit-license.php for terms\n// and conditions.\n\n#ifndef SCILIB_LINALG_MATRIX_DECOMPOSITION_H\n#define SCILIB_LINALG_MATRIX_DECOMPOSITION_H\n\n#ifdef USE_MKL\n#include \n#else\n#ifdef __clang__\n#pragma clang diagnostic push\n#pragma clang diagnostic ignored \"-Wreturn-type-c-linkage\"\n#endif\n#include \n#ifdef __clang__\n#pragma clang diagnostic pop\n#endif\n#endif\n\n#include \n#include \n#include \n#include \n#include \n#include \n\nnamespace Sci {\nnamespace Linalg {\n\nnamespace stdex = std::experimental;\n\n// LU factorization.\ntemplate \ninline void lu(Sci::Matrix_view a,\n Sci::Vector_view ipiv)\n{\n static_assert(a.is_contiguous());\n static_assert(ipiv.is_contiguous());\n\n const BLAS_INT m = static_cast(a.extent(0));\n const BLAS_INT n = static_cast(a.extent(1));\n\n assert(static_cast(ipiv.size()) >= std::min(m, n));\n\n auto matrix_layout = LAPACK_ROW_MAJOR;\n BLAS_INT lda = n;\n\n if constexpr (std::is_same_v) {\n matrix_layout = LAPACK_COL_MAJOR;\n lda = m;\n }\n\n BLAS_INT info =\n LAPACKE_dgetrf(matrix_layout, m, n, a.data(), lda, ipiv.data());\n if (info < 0) {\n throw std::runtime_error(\"dgetrf: illegal input parameter\");\n }\n if (info > 0) {\n throw std::runtime_error(\"dgetrf: U matrix is singular\");\n }\n}\n\ntemplate \ninline void lu(Sci::Matrix& a,\n Sci::Vector& ipiv)\n{\n lu(a.view(), ipiv.view());\n}\n\n// QR factorization.\ntemplate \ninline void qr(Sci::Matrix_view a,\n Sci::Matrix_view q,\n Sci::Matrix_view r)\n{\n assert(q.extent(0) == a.extent(0) && q.extent(1) == a.extent(1));\n assert(r.extent(0) == a.extent(0) && r.extent(1) == a.extent(1));\n\n const BLAS_INT m = static_cast(a.extent(0));\n const BLAS_INT n = static_cast(a.extent(1));\n\n auto matrix_layout = LAPACK_ROW_MAJOR;\n BLAS_INT lda = n;\n\n if constexpr (std::is_same_v) {\n matrix_layout = LAPACK_COL_MAJOR;\n lda = m;\n }\n Sci::copy(a, q);\n Sci::Vector tau(std::min(m, n));\n\n // Compute QR factorization:\n\n BLAS_INT info =\n LAPACKE_dgeqrf(matrix_layout, m, n, q.data(), lda, tau.data());\n if (info != 0) {\n throw std::runtime_error(\"dgeqrf failed\");\n }\n\n // Compute Q:\n\n info = LAPACKE_dorgqr(matrix_layout, m, n, n, q.data(), lda, tau.data());\n if (info != 0) {\n throw std::runtime_error(\"dorgqr failed\");\n }\n\n // Compute R:\n\n matrix_product(transposed(q), a, r);\n transposed(q);\n}\n\ntemplate \ninline void qr(Sci::Matrix& a,\n Sci::Matrix& q,\n Sci::Matrix& r)\n{\n qr(a.view(), q.view(), r.view());\n}\n\n// Singular value decomposition.\ntemplate \ninline void svd(Sci::Matrix_view a,\n Sci::Vector_view s,\n Sci::Matrix_view u,\n Sci::Matrix_view vt)\n{\n const BLAS_INT m = static_cast(a.extent(0));\n const BLAS_INT n = static_cast(a.extent(1));\n const BLAS_INT ldu = m;\n const BLAS_INT ldvt = n;\n\n assert(static_cast(s.extent(0)) == std::min(m, n));\n assert(static_cast(u.extent(0)) == m);\n assert(static_cast(u.extent(1)) == ldu);\n assert(static_cast(vt.extent(0)) == n);\n assert(static_cast(vt.extent(1)) == ldvt);\n\n auto matrix_layout = LAPACK_ROW_MAJOR;\n BLAS_INT lda = n;\n\n if constexpr (std::is_same_v) {\n matrix_layout = LAPACK_COL_MAJOR;\n lda = m;\n }\n\n Sci::Vector superb(std::min(m, n) - 1);\n\n BLAS_INT info =\n LAPACKE_dgesvd(matrix_layout, 'A', 'A', m, n, a.data(), lda, s.data(),\n u.data(), ldu, vt.data(), ldvt, superb.data());\n if (info != 0) {\n throw std::runtime_error(\"dgesvd failed\");\n }\n}\n\ntemplate \ninline void svd(Sci::Matrix& a,\n Sci::Vector& s,\n Sci::Matrix& u,\n Sci::Matrix& vt)\n{\n svd(a.view(), s.view(), u.view(), vt.view());\n}\n\n} // namespace Linalg\n} // namespace Sci\n\n#endif // SCILIB_LINALG_MATRIX_DECOMPOSITION_H\n", "meta": {"hexsha": "6302ce512a1a57388f480873f780924ee1944442", "size": 5025, "ext": "h", "lang": "C", "max_stars_repo_path": "include/scilib/linalg_impl/matrix_decomposition.h", "max_stars_repo_name": "stigrs/scilib", "max_stars_repo_head_hexsha": "c49f1f882bf2031a4de537e0f5701b2648af181f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "include/scilib/linalg_impl/matrix_decomposition.h", "max_issues_repo_name": "stigrs/scilib", "max_issues_repo_head_hexsha": "c49f1f882bf2031a4de537e0f5701b2648af181f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "include/scilib/linalg_impl/matrix_decomposition.h", "max_forks_repo_name": "stigrs/scilib", "max_forks_repo_head_hexsha": "c49f1f882bf2031a4de537e0f5701b2648af181f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.0462427746, "max_line_length": 78, "alphanum_fraction": 0.6411940299, "num_tokens": 1364, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8376199795472731, "lm_q2_score": 0.6334102775181399, "lm_q1q2_score": 0.5305571036997769}} {"text": "#pragma once\n\n#include \n#include \n\n#include \n#include \n\nnamespace con {\n\n using std::vector;\n using std::cout;\n using std::cerr;\n using std::endl;\n using std::string;\n\n static boost::mt19937 rng(0);\n\n #define BUG(x) std::cout<<#x<<\" = \"<<(x)< Vec;\n\n Real sigmoid(const Real &z) {\n return 1.0 / (1.0 + std::exp(-z));\n }\n\n Real derivativeSigmoid(const Real &v) {\n return v * (1.0 - v);\n }\n\n Real sqr(const Real &x) {\n return x * x;\n }\n\n Real randomize(const Real &min, const Real &max) {\n boost::uniform_real dst(min, max);\n return dst(rng);\n }\n\n void randomizeVec(const Real &min, const Real &max, Vec *a) {\n for (auto it = a->begin(); it != a->end(); it++) {\n (*it) = randomize(min, max);\n }\n }\n\n void gaussianRng(const Real &mean, const Real &std, Vec *a) {\n boost::normal_distribution random_distribution(mean, std);\n boost::variate_generator>\n variate_generator(rng, random_distribution);\n\n for (auto it = a->begin(); it != a->end(); it++) {\n *it = variate_generator();\n }\n }\n\n void clear(Vec *a) {\n for (auto it = a->begin(); it != a->end(); it++) {\n (*it) = 0;\n }\n }\n\n void clear(vector *a) {\n for (int i = 0; i < a->size(); i++) {\n clear(&a->at(i));\n }\n }\n\n void print(const Vec &a) {\n for (auto x : a) {\n cout << x << \" \";\n }\n cout << endl;\n }\n\n void reshape(const int num, const int width, const int height, const int depth, vector *a) {\n a->resize(num);\n for (int i = 0; i < num; i++) {\n a->at(i).resize(width * height * depth);\n }\n }\n\n int ceilDiv(const int &x, const int &y) {\n return (x + y - 1) / y;\n }\n\n void gemm(\n const CBLAS_TRANSPOSE &TransA, const CBLAS_TRANSPOSE &TransB,\n const int &M, const int &N, const int &K,\n const Real &alpha, const Vec &vecA, const Vec &vecB,\n const Real &beta, Vec *vecC) {\n\n const Real *A = &vecA[0];\n const Real *B = &vecB[0];\n Real *C = &vecC->at(0);\n\n int lda = (TransA == CblasNoTrans) ? K : M;\n int ldb = (TransB == CblasNoTrans) ? N : K;\n\n cblas_dgemm(CblasRowMajor, TransA, TransB, M, N, K, alpha, A, lda, B,\n ldb, beta, C, N);\n }\n\n void gemv(\n const CBLAS_TRANSPOSE &TransA,\n const int &M, const int &N,\n const Real &alpha, const Vec &matA, const Vec &vecX,\n const double beta, Vec *vecY) {\n\n const Real *A = &matA[0];\n const Real *x = &vecX[0];\n Real *y = &vecY->at(0);\n\n cblas_dgemv(CblasRowMajor, TransA, M, N, alpha, A, N, x, 1, beta, y, 1);\n }\n\n void vexp(const int &n, const Vec &input, Vec *output) {\n // vsExp(n, &input[0], &output->at(0));\n for (int i = 0; i < n; i++) {\n output->at(i) = exp(input[i]);\n }\n }\n\n void vdiv(const int &n, const Vec &a, const Vec &b, Vec *c) {\n // vsDiv(n, &a[0], &b[0], &c->at(0));\n for (int i = 0; i < n; i++) {\n c->at(i) = a[i] / b[i];\n }\n }\n\n void copy(const int &n, const Vec &input, Vec *output) {\n for (int i = 0; i < n; i++) {\n output->at(i) = input[i];\n }\n }\n\n void ones(const int &n, Vec *v) {\n v->resize(n);\n std::fill(v->begin(), v->end(), 1.0);\n }\n}\n", "meta": {"hexsha": "4ac832f5ca6c25116efe44dbc1298fb7088078b2", "size": 3294, "ext": "h", "lang": "C", "max_stars_repo_path": "Noob_Examples/TempCode/deep-learning/cifar/10/lkmtue/util.h", "max_stars_repo_name": "robgrzel/OpenMPI_Examples", "max_stars_repo_head_hexsha": "c9643a958bfbfcfcaeb413bf42e5080c6f0c1df5", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Noob_Examples/TempCode/deep-learning/cifar/10/lkmtue/util.h", "max_issues_repo_name": "robgrzel/OpenMPI_Examples", "max_issues_repo_head_hexsha": "c9643a958bfbfcfcaeb413bf42e5080c6f0c1df5", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Noob_Examples/TempCode/deep-learning/cifar/10/lkmtue/util.h", "max_forks_repo_name": "robgrzel/OpenMPI_Examples", "max_forks_repo_head_hexsha": "c9643a958bfbfcfcaeb413bf42e5080c6f0c1df5", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 23.034965035, "max_line_length": 99, "alphanum_fraction": 0.5440194293, "num_tokens": 1112, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8056321983146849, "lm_q2_score": 0.6584175072643415, "lm_q1q2_score": 0.5304423437862464}} {"text": "#ifndef IFT_COMMON_H_\n#define IFT_COMMON_H_\n\n#include \n#include \n#include \n#if !defined(__APPLE__)\n\t#include \n#endif\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n/* \n * Common data types\n */\n\n\n#define INFINITY_INT INT_MAX\n#define INFINITY_FLT FLT_MAX\n#define INFINITY_DBL DBL_MAX\n#define INFINITY_LDBL LDBL_MAX\n\ntypedef struct timeval timer;\n\ntypedef unsigned char uchar;\ntypedef unsigned short ushort;\ntypedef unsigned int uint;\ntypedef unsigned long long ullong;\n\ntypedef struct ift_band {\n float *val;\n} iftBand;\n\n\ntypedef struct ift_vector {\n float x,y,z;\n} iftVector, iftPoint;\n\ntypedef struct ift_voxel {\n int x,y,z;\n} iftVoxel;\n\ntypedef struct ift_dcomplex\n{\n double r;\n double i;\n} iftComplex;\n\n\ntypedef struct file_list {\n char **filesRoutes;\n char **filesNames;\n int n;\n} fileList;\n\ntypedef struct ift_name_metric_pair {\n char *name;\n float metric;\n} iftNameMetricPair;\n\n/** \n * Common definitions \n */\n\n#define IFT_RANDOM_SEED (unsigned int) 213344\n#define MAXWEIGHT 4095.0\n#define AXIS_X 0\n#define AXIS_Y 1\n#define AXIS_Z 2\n#define PI 3.1415926536\n#define INTERIOR 0\n#define EXTERIOR 1\n#define BOTH 2\n#define WHITE 0\n#define GRAY 1\n#define BLACK 2\n#define NIL -1\n#define INCREASING 1\n#define DECREASING 0\n#define Epsilon 1E-05\n\n/** \n * Common operations \n */\n\n#ifndef MAX\n#define MAX(x,y) (((x) > (y))?(x):(y))\n#endif\n\n#ifndef MIN\n#define MIN(x,y) (((x) < (y))?(x):(y))\n#endif\n\n#define ROUND(x) ((x < 0)?(int)(x-0.5):(int)(x+0.5))\n#define SIGN(x) ((x >= 0)?1:-1)\n\n\n/** \n * Common functions to allocate memory\n */\n\nchar *iftAllocCharArray(int n); \nuchar *iftAllocUCharArray(int n); \nshort *iftAllocShortArray(int n);\nushort *iftAllocUShortArray(int n);\nuint *iftAllocUIntArray(int n); \nullong *iftAllocULLongArray(int n); \nint *iftAllocIntArray(int n); \nfloat *iftAllocFloatArray(int n);\ndouble *iftAllocDoubleArray(int n);\niftComplex *iftAllocComplexArray(int n);\nlong double *iftAllocLongDoubleArray(int n);\n\nvoid iftPrintFloatArray(float* v, int n);\n/** \n * Error messages \n */\n\n#define MSG1 \"Cannot allocate memory space\"\n#define MSG2 \"Cannot open file\"\n\n/**\n * Error message msg is printed in function func and the program\n * exits abnormally.\n */\n \nvoid iftError(char *msg,char *func); \n\n/**\n * Warning message msg is printed in function func and the program\n * continues.\n */\n \nvoid iftWarning(char *msg,char *func); \n\n/**\n * The contents of a and b are interchanged. \n */\n\nvoid iftSwitchValues(int *a, int *b); \nvoid iftSSwitchValues(char *a, char *b, int size); \nvoid iftFSwitchValues(float *a, float *b); \nvoid iftDSwitchValues(double *a, double *b);\nvoid iftSwitchVoxels(iftVoxel *u, iftVoxel *v);\n\n\n\n/**\n * Returns a random integer number between low and high.\n */\n\nint iftRandomInteger (int low, int high);\n\n/*\n * Randomly selects nelems of the set [low, high]\n */\nint *iftRandomIntegers (int low, int high, int nelems);\n\n/**\n * Randomly selects a normal distributed (N(0,1)) float number\n */\n\nfloat iftRandomNormalFloat(void);\n\n/**\n * Returns the distance between P0 and the line from P1 to P2, whose\n * size is P1P2\n */\n\nfloat iftVoxelLineDist2D(iftVoxel P0, iftVoxel P1, iftVoxel P2, float P1P2);\n\n/**\n * Returns the position of P0 with respect to the line from P1 to\n * P2. Negative values indicate left side, 0 indicates on the line,\n * and positive values indicate right side.\n */\n\nint iftVoxelLinePosition2D (iftVoxel P0, iftVoxel P1, iftVoxel P2);\n\n/**\n * Returns initial time \n */\n\ntimer *iftTic(void); \n\n/**\n * Returns final time \n */\n\ntimer *iftToc(void); \n\n/**\n * Computes the difference in ms from the initial time to the final time\n */\n\nfloat iftCompTime(timer *tic, timer *toc); \n\n/** \n * Generates seed for rand(), used in iftRandomInteger.\n */\n\nvoid iftRandomSeed(unsigned int); \n\n/**\n * Returns the factorial of a number or NIL in case of overflow\n */\n\nlong double iftFactorial(int n);\n\n/**\n * Returns the limit to avoid overflow in factorial computation\n */\n\nint iftFactorialLimit(void);\n\nfloat iftVoxelDistance(iftVoxel u, iftVoxel v);\nint iftSquaredVoxelDistance(iftVoxel u, iftVoxel v);\n\nfloat iftPointDistance(iftPoint u, iftPoint v);\n\nint iftVoxelSquareDistance(iftVoxel u, iftVoxel v);\n\nfloat iftInnerProduct(iftVector a, iftVector b);\n\niftVector iftCrossProduct(iftVector a, iftVector b);\n\nchar iftCollinearPoints(iftPoint P1, iftPoint P2, iftPoint P3);\n\nchar iftCollinearVoxels(iftVoxel P1, iftVoxel P2, iftVoxel P3);\n\niftVector iftNormalizeVector(iftVector v);\n\nvoid iftNormalizeFloatArray(float *array, int nelems);\n\nfloat iftVectorMagnitude(iftVector v);\n\nvoid iftRemoveCarriageReturn(char *token); /* useful to get rid of the\n\t\t\t\t\t carriage return and the\n\t\t\t\t\t line feed characteres\n\t\t\t\t\t introduced by DOS\n\t\t\t\t\t systems when reading\n\t\t\t\t\t strings from ASCII\n\t\t\t\t\t files */\n\n\nvoid iftWriteFloatArray(float *v, int size, char *filename);\nfloat *iftReadFloatArray(char *filename, int *size);\n\n\n/**\n * Evaluates the sigmoid function, with x = value. \n * Alfa controls the decay of the function.\n */\n\nfloat iftSigmoidalValue(float value, float alfa);\n\nvoid iftVerifyToken(FILE *fp, char *token, char *function);\nvoid iftReadIntValue(FILE *fp, int *value, char *token, char *function);\nvoid iftReadIntValues(FILE *fp, int **value, int nvalues, char *token, char *function);\nvoid iftWriteIntValue(FILE *fp, int value, char *token);\nvoid iftWriteIntValues(FILE *fp, int *value, int nvalues, char *token);\nvoid iftReadFloatValue(FILE *fp, float *value, char *token, char *function);\nvoid iftReadFloatValues(FILE *fp, float **value, int nvalues, char *token, char *function);\nvoid iftWriteFloatValue(FILE *fp, float value, char *token);\nvoid iftWriteFloatValues(FILE *fp, float *value, int nvalues, char *token);\nvoid iftReadDoubleValue(FILE *fp, double *value, char *token, char *function);\nvoid iftReadDoubleValues(FILE *fp, double **value, int nvalues, char *token, char *function);\nvoid iftWriteDoubleValue(FILE *fp, double value, char *token);\nvoid iftWriteDoubleValues(FILE *fp, double *value, int nvalues, char *token);\nvoid iftSkipComments(FILE *fp);\nchar iftVoxelsAreEqual(iftVoxel u1, iftVoxel u2);\nchar iftPointsAreEqual(iftPoint u1, iftPoint u2);\n\n/**\n * Common function to handle arrays\n */\n\nvoid iftCopyFloatArray(float *array1, float *array2, int nelems);\nvoid iftCopyIntArray(int *array1, int *array2, int nelems);\nint *iftMergeIntArray(int *array1, int n1, int *array2, int n2, int *nelems);\nint *iftIntArrayOfUniqueElemsTransform(int *array, int *n);\nfileList *iftCreateFileList(void);\nvoid iftDestroyFileList(fileList **list);\nfileList *iftGetFiles(char *dirname, char *type);\n\n/* These functions are currently used to communicate with numpy */\nvoid iftWriteRawIntArray(char *filename, int *array, int n);\nint* iftReadRawIntArray(char *filename, int n);\n\nfloat iftMean(float *x, int n);\nfloat iftVar(float *x, int n);\nfloat iftCov(float *x, float *y, int n);\n\nint iftAlmostZero(float x);\n\n#endif\n", "meta": {"hexsha": "34dc8eda690326abe44c5894296ccfb73e44d121", "size": 7303, "ext": "h", "lang": "C", "max_stars_repo_path": "IFTVessel/include/iftCommon.h", "max_stars_repo_name": "rphellan/4DASLMRAVirtualPhantoms", "max_stars_repo_head_hexsha": "ad2419f3204bcbeec90f3c5c651d3a35b7dd0d27", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "IFTVessel/include/iftCommon.h", "max_issues_repo_name": "rphellan/4DASLMRAVirtualPhantoms", "max_issues_repo_head_hexsha": "ad2419f3204bcbeec90f3c5c651d3a35b7dd0d27", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "IFTVessel/include/iftCommon.h", "max_forks_repo_name": "rphellan/4DASLMRAVirtualPhantoms", "max_forks_repo_head_hexsha": "ad2419f3204bcbeec90f3c5c651d3a35b7dd0d27", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2021-11-20T22:53:06.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-20T22:53:06.000Z", "avg_line_length": 23.8660130719, "max_line_length": 93, "alphanum_fraction": 0.7062850883, "num_tokens": 2074, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7025300573952052, "lm_q2_score": 0.7549149923816046, "lm_q1q2_score": 0.5303504729263496}} {"text": "#include \n#include \n#include \n\n/* Cholesky */\n\nJNIEXPORT jint Java_JAMAJni_CholeskyDecomposition_dpotrf (JNIEnv *env, jclass klass, jint matrix_layout, jchar uplo, jint n, jdoubleArray a, jint lda){\n \n double *aElems;\n int info;\n \n aElems = (*env)-> GetDoubleArrayElements (env, a, NULL);\n \n assert(aElems);\n \n info = LAPACKE_dpotrf((int) matrix_layout, (char) uplo, (lapack_int) n, aElems, (lapack_int) lda);\n \n (*env)-> ReleaseDoubleArrayElements (env, a, aElems, 0);\n \n return info;\n \n}\n\n\nJNIEXPORT jint Java_JAMAJni_CholeskyDecomposition_dpotri(JNIEnv *env, jclass klass, jint matrix_layout, jchar uplo, jint n, jdoubleArray a, jint lda){\n \n double *aElems;\n int info;\n \n aElems = (*env)-> GetDoubleArrayElements (env, a, NULL);\n \n assert(aElems);\n \n info = LAPACKE_dpotri((int) matrix_layout, (char) uplo, (lapack_int) n, aElems, (lapack_int) lda);\n \n (*env)-> ReleaseDoubleArrayElements (env, a, aElems, 0);\n \n return info;\n \n}\n\nJNIEXPORT jint Java_JAMAJni_CholeskyDecomposition_dpotrs (JNIEnv *env, jclass klass, jint matrix_layout, jchar uplo, jint n, jint nrhs, jdoubleArray a, jint lda, jdoubleArray b, jint ldb){\n \n double *aElems, *bElems;\n int info;\n \n aElems = (*env)-> GetDoubleArrayElements (env, a, NULL);\n bElems = (*env)-> GetDoubleArrayElements (env, b, NULL);\n \n assert(aElems && bElems);\n \n info = LAPACKE_dpotrs ((int) matrix_layout, (char) uplo, (lapack_int) n, (lapack_int) nrhs, aElems, (lapack_int) lda, bElems, (lapack_int) ldb);\n \n (*env)-> ReleaseDoubleArrayElements (env, a, aElems, JNI_ABORT);\n (*env)-> ReleaseDoubleArrayElements (env, b, bElems, 0);\n \n return info;\n \n}\n\n\n\n\n", "meta": {"hexsha": "5991416a298f2a82eaf39f493b9a64fd5f901da3", "size": 1768, "ext": "c", "lang": "C", "max_stars_repo_path": "src/jni_lapacke/c/CholeskyDecomposition.c", "max_stars_repo_name": "dw6ja/JAMAJni", "max_stars_repo_head_hexsha": "2e7cb4e16bacffa965e49d905a87043e31a8a718", "max_stars_repo_licenses": ["AAL"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/jni_lapacke/c/CholeskyDecomposition.c", "max_issues_repo_name": "dw6ja/JAMAJni", "max_issues_repo_head_hexsha": "2e7cb4e16bacffa965e49d905a87043e31a8a718", "max_issues_repo_licenses": ["AAL"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/jni_lapacke/c/CholeskyDecomposition.c", "max_forks_repo_name": "dw6ja/JAMAJni", "max_forks_repo_head_hexsha": "2e7cb4e16bacffa965e49d905a87043e31a8a718", "max_forks_repo_licenses": ["AAL"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.625, "max_line_length": 188, "alphanum_fraction": 0.6555429864, "num_tokens": 553, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7690802370707281, "lm_q2_score": 0.6893056104028799, "lm_q1q2_score": 0.5301313222628298}} {"text": "#include \"../include/matrix.h\"\n\n#ifndef MATREX_NO_BLAS\n\n#include \n\nvoid\nmatrix_dot(const float alpha, const Matrix first, const Matrix second, Matrix result) {\n MX_SET_ROWS(result, MX_ROWS(first));\n MX_SET_COLS(result, MX_COLS(second));\n\n cblas_sgemm(\n CblasRowMajor,\n CblasNoTrans,\n CblasNoTrans,\n MX_ROWS(first),\n MX_COLS(second),\n MX_COLS(first),\n alpha,\n first + 2,\n MX_COLS(first),\n second + 2,\n MX_COLS(second),\n 0.0,\n result + 2,\n MX_COLS(result)\n );\n}\n\nvoid\nmatrix_dot_and_add(\n const float alpha, const Matrix first, const Matrix second, const Matrix third, Matrix result\n) {\n const uint64_t data_size = MX_ROWS(first) * MX_COLS(second) + 2;\n\n MX_SET_ROWS(result, MX_ROWS(first));\n MX_SET_COLS(result, MX_COLS(second));\n\n cblas_sgemm(\n CblasRowMajor,\n CblasNoTrans,\n CblasNoTrans,\n MX_ROWS(first),\n MX_COLS(second),\n MX_COLS(first),\n alpha,\n first + 2,\n MX_COLS(first),\n second + 2,\n MX_COLS(second),\n 0.0,\n result + 2,\n MX_COLS(result)\n );\n\n for(uint64_t index = 2; index < data_size; index += 1) {\n result[index] += third[index];\n }\n}\n\nvoid\nmatrix_dot_and_apply(\n const float alpha, const Matrix first, const Matrix second, const char *function_name, Matrix result\n) {\n const math_func_ptr_t func = math_func_from_name(function_name);\n\n const uint64_t data_size = MX_ROWS(first) * MX_COLS(second) + 2;\n\n MX_SET_ROWS(result, MX_ROWS(first));\n MX_SET_COLS(result, MX_COLS(second));\n\n cblas_sgemm(\n CblasRowMajor,\n CblasNoTrans,\n CblasNoTrans,\n MX_ROWS(first),\n MX_COLS(second),\n MX_COLS(first),\n alpha,\n first + 2,\n MX_COLS(first),\n second + 2,\n MX_COLS(second),\n 0.0,\n result + 2,\n MX_COLS(result)\n );\n\n for(uint64_t index = 2; index < data_size; index += 1) {\n result[index] = func(result[index]);\n }\n}\n\n\nvoid\nmatrix_dot_nt(const float alpha, const Matrix first, const Matrix second, Matrix result) {\n MX_SET_ROWS(result, MX_ROWS(first));\n MX_SET_COLS(result, MX_ROWS(second));\n\n cblas_sgemm(\n CblasRowMajor,\n CblasNoTrans,\n CblasTrans,\n MX_ROWS(first),\n MX_ROWS(second),\n MX_COLS(first),\n alpha,\n first + 2,\n MX_COLS(first),\n second + 2,\n MX_COLS(second),\n 0.0,\n result + 2,\n MX_COLS(result)\n );\n}\n\nvoid\nmatrix_dot_tn(const float alpha, const Matrix first, const Matrix second, Matrix result) {\n MX_SET_ROWS(result, MX_COLS(first));\n MX_SET_COLS(result, MX_COLS(second));\n\n cblas_sgemm(\n CblasRowMajor,\n CblasTrans,\n CblasNoTrans,\n MX_COLS(first),\n MX_COLS(second),\n MX_ROWS(first),\n alpha,\n first + 2,\n MX_COLS(first),\n second + 2,\n MX_COLS(second),\n 0.0,\n result + 2,\n MX_COLS(result)\n );\n}\n\n#else\n\nvoid\nmatrix_dot(const float alpha, const Matrix first, const Matrix second, Matrix result) {\n const int64_t rows = MX_ROWS(first);\n const int64_t cols = MX_COLS(second);\n\n MX_SET_ROWS(result, rows);\n MX_SET_COLS(result, cols);\n\n for (int64_t r = 0; r < rows; r++)\n for (int64_t c = 0; c < cols; c++) {\n const int64_t elem_offset = 2 + r*cols + c;\n result[elem_offset] = 0.0;\n for (int64_t k = 0; k < MX_COLS(first); k++)\n result[elem_offset] += first[2 + r*MX_COLS(first) + k] * second[2 + k*MX_COLS(second) + c];\n result[elem_offset] *= alpha;\n }\n}\n\nvoid\nmatrix_dot_and_add(\n const float alpha, const Matrix first, const Matrix second, const Matrix third, Matrix result\n) {\n const int64_t rows = MX_ROWS(first);\n const int64_t cols = MX_COLS(second);\n\n MX_SET_ROWS(result, rows);\n MX_SET_COLS(result, cols);\n\n for (int64_t r = 0; r < rows; r++)\n for (int64_t c = 0; c < cols; c++) {\n const int64_t elem_offset = 2 + r*cols + c;\n result[elem_offset] = third[elem_offset];\n for (int64_t k = 0; k < MX_COLS(first); k++)\n result[elem_offset] += first[2 + r*MX_COLS(first) + k] * second[2 + k*MX_COLS(second) + c];\n result[elem_offset] *= alpha;\n }\n}\n\nvoid\nmatrix_dot_and_apply(\n const float alpha, const Matrix first, const Matrix second, const char *function_name, Matrix result\n) {\n const math_func_ptr_t func = math_func_from_name(function_name);\n\n const int64_t rows = MX_ROWS(first);\n const int64_t cols = MX_COLS(second);\n\n MX_SET_ROWS(result, rows);\n MX_SET_COLS(result, cols);\n\n for (int64_t r = 0; r < rows; r++)\n for (int64_t c = 0; c < cols; c++) {\n const int64_t elem_offset = 2 + r*cols + c;\n result[elem_offset] = 0.0;\n for (int64_t k = 0; k < MX_COLS(first); k++)\n result[elem_offset] += first[2 + r*MX_COLS(first) + k] * second[2 + k*MX_COLS(second) + c];\n result[elem_offset] = func(alpha * result[elem_offset]);\n }\n}\n\nvoid\nmatrix_dot_nt(const float alpha, const Matrix first, const Matrix second, Matrix result) {\n const int64_t rows = MX_ROWS(first);\n const int64_t cols = MX_ROWS(second);\n\n MX_SET_ROWS(result, rows);\n MX_SET_COLS(result, cols);\n\n for (int64_t r = 0; r < rows; r++)\n for (int64_t c = 0; c < cols; c++) {\n const int64_t elem_offset = 2 + r*cols + c;\n result[elem_offset] = 0.0;\n for (int64_t k = 0; k < MX_COLS(first); k++)\n result[elem_offset] += first[2 + r*MX_COLS(first) + k] * second[2 + c*MX_COLS(second) + k];\n result[elem_offset] *= alpha;\n }\n}\n\nvoid\nmatrix_dot_tn(const float alpha, const Matrix first, const Matrix second, Matrix result) {\n const int64_t rows = MX_COLS(first);\n const int64_t cols = MX_COLS(second);\n\n MX_SET_ROWS(result, rows);\n MX_SET_COLS(result, cols);\n\n for (int64_t r = 0; r < rows; r++)\n for (int64_t c = 0; c < cols; c++) {\n const int64_t elem_offset = 2 + r*cols + c;\n result[elem_offset] = 0.0;\n for (int64_t k = 0; k < MX_ROWS(first); k++)\n result[elem_offset] += first[2 + r + k*rows]*second[2 + c + k*cols];\n result[elem_offset] *= alpha;\n }\n}\n\n\n#endif\n", "meta": {"hexsha": "4e3fb9c945bd9723bde8ef0dc03c89edd21e773f", "size": 5886, "ext": "c", "lang": "C", "max_stars_repo_path": "native/src/matrix_dot.c", "max_stars_repo_name": "scripbox/matrex", "max_stars_repo_head_hexsha": "9a080311836a151ef9f2b780c3cd751a0fa0df22", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 464.0, "max_stars_repo_stars_event_min_datetime": "2018-05-13T00:48:25.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-01T18:29:38.000Z", "max_issues_repo_path": "native/src/matrix_dot.c", "max_issues_repo_name": "scripbox/matrex", "max_issues_repo_head_hexsha": "9a080311836a151ef9f2b780c3cd751a0fa0df22", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 30.0, "max_issues_repo_issues_event_min_datetime": "2018-05-28T11:00:37.000Z", "max_issues_repo_issues_event_max_datetime": "2021-12-09T11:38:28.000Z", "max_forks_repo_path": "native/src/matrix_dot.c", "max_forks_repo_name": "scripbox/matrex", "max_forks_repo_head_hexsha": "9a080311836a151ef9f2b780c3cd751a0fa0df22", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 34.0, "max_forks_repo_forks_event_min_datetime": "2018-05-21T15:40:11.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-29T07:30:02.000Z", "avg_line_length": 24.4232365145, "max_line_length": 102, "alphanum_fraction": 0.6405028882, "num_tokens": 1763, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8774767906859264, "lm_q2_score": 0.6039318337259583, "lm_q1q2_score": 0.5299361672509204}} {"text": "/*\n * This file is part of MXE. See LICENSE.md for licensing information.\n */\n\n/* taken from http://www.netlib.org/lapack/lapacke.html */\n\n/* Calling CGEQRF and CUNGQR to compute Q with workspace querying */\n\n#include \n#include \n#include \n#include \n\nint main (int argc, const char * argv[])\n{\n (void)argc;\n (void)argv;\n\n lapack_complex_float *a,*tau,*r,*work,one,zero,query;\n lapack_int info,m,n,lda,lwork;\n int i,j;\n float err;\n m = 10; n = 5; lda = m;\n one = lapack_make_complex_float(1.0,0.0);\n zero= lapack_make_complex_float(0.0,0.0);\n a = calloc(m*n,sizeof(lapack_complex_float));\n r = calloc(n*n,sizeof(lapack_complex_float));\n tau = calloc(m,sizeof(lapack_complex_float));\n for(j=0;j\n#include \n#include \n#include \n#include \n#include \n\nvoid P_update_simple(const uint8_t* G, const double* zetabeta, const double* zetagamma, const double* xi, const double* beta, const double* gamma, double* var_beta, double* var_gamma, long N, long L, long K)\n{\n uint8_t genotype;\n long idx, n, l, k;\n double theta_beta_sum, theta_gamma_sum;\n double *var_beta_tmp, *var_gamma_tmp;\n\n var_beta_tmp = (double*) malloc(K * sizeof(double));\n var_gamma_tmp = (double*) malloc(K * sizeof(double));\n\n // loop over loci\n for (l=0; lmintol && iter<1000) {\n\n numvar = 0;\n tol = 0.0;\n\n // loop over loci\n for (l=0; l\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"gslCompute.h\"\n#include \"MVNsampling.h\"\n#include \"Input.h\"\n#include \"Basis.h\"\n#include \"SampSetUp.h\"\n#include \"Output_t0.h\"\n#include \"SampInit.h\"\n#include \"SampZinter.h\"\n#include \"SampTheta.h\"\n#include \"SampPhi2Inv.h\"\n#include \"SampLoading.h\"\n#include \"SampLatent.h\"\n#include \"SampMu.h\"\n#include \"SampAlpha.h\"\n#include \"SampBeta.h\"\n#include \"SampGamma.h\"\n#include \"Sampweights.h\"\n#include \"SampErr_e.h\"\n#include \"SampErr_zeta.h\"\n#include \"SampErr_eps.h\"\n#include \"testing_training.h\"\n#include \"SampMean.h\"\n#include \"SampOutput.h\"\n\n#include \n#include \n//#include \n\nSEXP csblf(SEXP outputpath, SEXP seed, SEXP nburnin, SEXP niter){\n gsl_set_error_handler_off();\n //////////////////////////////////////////////////////////\n ///// GSL Random Number Generator Initialization /////\n //////////////////////////////////////////////////////////\n const gsl_rng_type * T;\n gsl_rng * r;\n gsl_rng_env_setup();\n T = gsl_rng_default;\n r = gsl_rng_alloc(T);\n gsl_rng_set(r, asInteger(seed));\n //////////////////////////////////////////////////////////\n ///// Input Data /////\n //////////////////////////////////////////////////////////\n // Input/Output data directory\n char *inpathx, *inpath, *outpath; //, *outputpath;\n inpathx = (char *)calloc(500,sizeof(char));\n inpath = (char *)calloc(500,sizeof(char));\n outpath = (char *)calloc(500,sizeof(char));\n char *outppath = CHAR(asChar(outputpath));\n \n char dataSource[20] = \"RealData\"; // data from simulation or read data source\n int sim = strcmp(dataSource, \"Simulation\") == 0 ? 1 : 0;\n strcat(inpathx, outppath);\n strcat(inpathx, \"Data/\");\n strcat(inpath, inpathx);\n strcat(outpath, outppath);\n strcat(outpath, \"Result/\");\n\n // Input data\n struct Inputdata data;\n data = input(inpathx, inpath, sim);\n int L = data.sizes[0]; // number of parcels; restricted to be 1\n int nobs = data.sizes[1]; // number of training observations\n int P = data.sizes[3]; // number of imaging predictors\n int nts = data.sizes[4]; // number of observations for test\n \n ///// Basis Function /////\n // Define basis functions\n struct BasisFunc BF;\n double bandwidth = 1.0/10.0;\n int dd = 6.0;\n BF = genBasis(L, outpath, data, bandwidth, dd);\n int M = BF.M;\n //////////////////////////////////////////////////////////\n ///// MCMC /////\n //////////////////////////////////////////////////////////\n // Number of latent factors\n int K ;\n K = strcmp(dataSource, \"Simulation\") == 0 ? 20 : 9;\n // Length of chain\n int iter = asInteger(niter); // total iterations\n int burnin = asInteger(nburnin); // iterations after burnin\n // Parameters\n struct Sampling PostSamp;\n PostSamp = setupSamp(M, nobs, nts, L, P, K, BF, data);\n // Initialization\n bool printInit = false;\n //set_initial2(L, nobs, nts, K, P, PostSamp, data, BF, r, outpath, printInit, inpath);\n set_initial(L, nobs, nts, K, P, PostSamp, data, BF, r, outpath, printInit);\n clock_t start, end;\n start = clock();\n int *singular = (int *)calloc(2, sizeof(int));\n int t;\n // Start MCMC\n Rprintf(\"************ Start MCMC ************\\n\");\n for(t=1; t<=iter; t++){\n if (t % 50 == 0) {\n Rprintf(\"**** t=%d *****\\n\", t);\n }\n // Post sampling of Zinter\n Zinter_samp(nobs, L, K, PostSamp, data, BF, r, singular);\n err2inv_u_samp(L, PostSamp, data, r);\n err2inv_e_samp(nobs, L, PostSamp, data, BF, r);\n // Post sampling of theta\n theta_samp(nobs, L, K, PostSamp, data, BF, r, singular);\n // Post sampling of Phi2Inv\n phi2inv_samp(K, nobs, L, PostSamp, data, BF, r);\n // Post sampling of Loadings and its hyperparameters\n load_samp(K, L, nobs, PostSamp, BF, r);\n // Update latent variables\n latent_samp(L, K, nobs, PostSamp, data, BF, r);\n // Update mu\n mu_samp(L, K, nobs, PostSamp, data, BF, r);\n // Update alpha\n alpha_samp(nobs, K, P, L, PostSamp, data, BF, r);\n // Update beta\n beta_samp_approx(nobs, L, K, PostSamp, data, BF, r);\n // Update Gamma\n gamma_samp(P, nobs, K, L, PostSamp, data, BF, r);\n // Update Error\n err2inv_zeta_samp(nobs, L, K, PostSamp, data, BF, r);\n err2inv_eps_samp(nobs, L, K, PostSamp, data, BF, r);\n ///////// Posterior estimations and predictions /////////\n if(t>(iter-burnin) && t%1==0){\n // Training set\n est_training(nobs, P, L, K, PostSamp, data, BF);\n // test\n if(nts>0){\n est_testing(nts, nobs, P, L, K, PostSamp, data, BF);\n }\n // For posterior mean\n samp_mean(L, K, nobs, nts, P, PostSamp, data, BF);\n }\n // Write posterior samplings\n if(t%50==0){\n output_samp(outpath, t, burnin, nobs, nts, M, K, L, P, singular, PostSamp, data, BF);\n }\n // Write posterior mean\n if(t==iter){\n output_mean(L, K, nobs, nts, P, outpath, PostSamp, data, BF, burnin);\n }\n }\n end = clock();\n double mcmc_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;\n Rprintf(\"MCMC: %.2f secs\\n\", mcmc_time_used);\n ////////////////////////////////////////////////////////////\n ///// Release Memory /////\n ////////////////////////////////////////////////////////////\n Rprintf(\"Release Memory.\\n\");\n gsl_rng_free(r);\n free(outpath);\n free(inpath);\n free(inpathx);\n free(singular);\n // Input Data\n free(data.sizes);\n free(data.parcel_len);\n free(data.parcel_len_sum);\n free(data.axes);\n free(data.Z);\n free(data.X);\n int l;\n for(l=0; l 0){\n free(data.Z_test);\n free(data.X_test);\n for(l=0; l 0){\n for(l=0; l\n\n#undef __BEGIN_DECLS\n#undef __END_DECLS\n#ifdef __cplusplus\n# define __BEGIN_DECLS extern \"C\" {\n# define __END_DECLS }\n#else\n# define __BEGIN_DECLS /* empty */\n# define __END_DECLS /* empty */\n#endif\n\n__BEGIN_DECLS\n\n\n/* Real part of DiLogarithm(x), for real argument.\n * In Lewin's notation, this is Li_2(x).\n *\n * Li_2(x) = - Re[ Integrate[ Log[1-s] / s, {s, 0, x}] ]\n *\n * Note that Im[Li_2(x)] = { 0 for x <= 1, -Pi*log(x) for x > 1 }\n */\nint gsl_sf_dilog_e(const double x, gsl_sf_result * result);\ndouble gsl_sf_dilog(const double x);\n\n\n/* DiLogarithm(z), for complex argument z = r Exp[i theta].\n */\nint gsl_sf_complex_dilog_e(const double r, double theta, gsl_sf_result * result_re, gsl_sf_result * result_im);\n\n\n__END_DECLS\n\n#endif /* __GSL_SF_DILOG_H__ */\n", "meta": {"hexsha": "6c64e3dfef362aca7cca09e2533763c54961cea3", "size": 1687, "ext": "h", "lang": "C", "max_stars_repo_path": "code/em/treba/gsl-1.0/specfunc/gsl_sf_dilog.h", "max_stars_repo_name": "ICML14MoMCompare/spectral-learn", "max_stars_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-12-18T18:09:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-10T11:31:28.000Z", "max_issues_repo_path": "code/em/treba/gsl-1.0/specfunc/gsl_sf_dilog.h", "max_issues_repo_name": "ICML14MoMCompare/spectral-learn", "max_issues_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "code/em/treba/gsl-1.0/specfunc/gsl_sf_dilog.h", "max_forks_repo_name": "ICML14MoMCompare/spectral-learn", "max_forks_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2015-10-02T01:32:59.000Z", "max_forks_repo_forks_event_max_datetime": "2015-10-02T01:32:59.000Z", "avg_line_length": 28.593220339, "max_line_length": 111, "alphanum_fraction": 0.7131001778, "num_tokens": 473, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8128673269042767, "lm_q2_score": 0.6513548714339145, "lm_q1q2_score": 0.5294650932085648}} {"text": "#include \n #include \n #include \n #include \n #include \n\n int\n main (int argc, char **argv)\n {\n int i, j, k, n = 256, nc = 20;\n double *data = malloc (n * sizeof (double));\n double *abscoeff = malloc (n * sizeof (double));\n size_t *p = malloc (n * sizeof (size_t));\n \n FILE * f;\n gsl_wavelet *w;\n gsl_wavelet_workspace *work;\n \n w = gsl_wavelet_alloc (gsl_wavelet_daubechies, 4);\n work = gsl_wavelet_workspace_alloc (n);\n \n f = fopen (argv[1], \"r\");\n for (i = 0; i < n; i++)\n {\n fscanf (f, \"%lg\", &data[i]);\n }\n fclose (f);\n \n gsl_wavelet_transform_forward (w, data, 1, n, work);\n \n for (i = 0; i < n; i++)\n {\n abscoeff[i] = fabs (data[i]);\n\t printf (\"abscoeff[%d] = %g\\n\", i, abscoeff[i]);\n }\n\n printf (\"(-1,0) = %g\\n\\n\", abscoeff[0]);\n i = 1;\n for (j = 0; j < 8; j++)\n\t {\n\t for (k = 0; k < gsl_pow_int(2, j); k++)\n\t {\n\t printf (\"(%d,%d) = %g\\n\", j, k, abscoeff[i]);\n\t i++;\n\t }\n\t printf(\"\\n\");\n\t }\n\n /* ************** */\n j = 0;\n for (i = 0; i < n; ++i)\n\t j += abscoeff[i];\n for (i = 0; i < n; ++i)\n\t abscoeff[i] /= j;\n /* ************** */\n \n gsl_sort_index (p, abscoeff, 1, n);\n \n for (i = 0; (i + nc) < n; i++)\n\t {\n\t printf (\"p[%d] = %ld\\n\", i, p[i]);\n\t data[p[i]] = 0;\n\t } \n \n gsl_wavelet_transform_inverse (w, data, 1, n, work);\n \n for (i = 0; i < n; i++)\n {\n printf (\"%g\\n\", data[i]);\n }\n \n gsl_wavelet_free (w);\n gsl_wavelet_workspace_free (work);\n \n free (data);\n free (abscoeff);\n free (p);\n return 0;\n }\n", "meta": {"hexsha": "c698e7a8b7d86e724a5fe7b5db4be1677bb1f77b", "size": 1866, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl_wavelet/dwt.c", "max_stars_repo_name": "klaricmn/snippets", "max_stars_repo_head_hexsha": "a1ae04c13a2209dee013284358d2d987bb0fb4fc", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "gsl_wavelet/dwt.c", "max_issues_repo_name": "klaricmn/snippets", "max_issues_repo_head_hexsha": "a1ae04c13a2209dee013284358d2d987bb0fb4fc", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "gsl_wavelet/dwt.c", "max_forks_repo_name": "klaricmn/snippets", "max_forks_repo_head_hexsha": "a1ae04c13a2209dee013284358d2d987bb0fb4fc", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 23.325, "max_line_length": 59, "alphanum_fraction": 0.4131832797, "num_tokens": 603, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8311430645886584, "lm_q2_score": 0.6370307944803832, "lm_q1q2_score": 0.5294637267617736}} {"text": "/* tsqr.c\n * \n * Copyright (C) 2015 Patrick Alken\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n/*\n * This module implements the sequential TSQR algorithm\n * described in\n *\n * [1] Demmel, J., Grigori, L., Hoemmen, M. F., and Langou, J.\n * \"Communication-optimal parallel and sequential QR and LU factorizations\",\n * UCB Technical Report No. UCB/EECS-2008-89, 2008.\n *\n * The algorithm operates on a tall least squares system:\n *\n * [ A_1 ] x = [ b_1 ]\n * [ A_2 ] [ b_2 ]\n * [ ... ] [ ... ]\n * [ A_k ] [ b_k ]\n *\n * as follows:\n *\n * 1. Initialize\n * a. [Q_1,R_1] = qr(A_1)\n * b. z_1 = Q_1^T b_1\n * 2. Loop i = 2:k\n * a. [Q_i,R_i] = qr( [ R_{i-1} ; A_i ] )\n * b. z_i = Q_i^T [ z_{i-1} ; b_i ]\n * 3. Output:\n * a. R = R_k\n * b. Q^T b = z_k\n *\n * Step 2(a) is optimized to take advantage\n * of the sparse structure of the matrix\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\ntypedef struct\n{\n size_t p; /* number of columns of LS matrix */\n int init; /* QR system has been initialized */\n int svd; /* SVD of R has been computed */\n double normb; /* || b || for computing residual norm */\n\n gsl_vector *tau; /* Householder scalars, p-by-1 */\n gsl_matrix *R; /* [ R ; A_i ], size p-by-p */\n gsl_vector *QTb; /* [ Q^T b ; b_i ], size p-by-1 */\n\n gsl_multifit_linear_workspace *multifit_workspace_p;\n} tsqr_state_t;\n\nstatic void *tsqr_alloc(const size_t p);\nstatic void tsqr_free(void *vstate);\nstatic int tsqr_reset(void *vstate);\nstatic int tsqr_accumulate(gsl_matrix * A, gsl_vector * b,\n void * vstate);\nstatic int tsqr_solve(const double lambda, gsl_vector * x,\n double * rnorm, double * snorm,\n void * vstate);\nstatic int tsqr_rcond(double * rcond, void * vstate);\nstatic int tsqr_lcurve(gsl_vector * reg_param, gsl_vector * rho,\n gsl_vector * eta, void * vstate);\nstatic int tsqr_svd(tsqr_state_t * state);\nstatic double tsqr_householder_transform (double *v0, gsl_vector * v);\nstatic int tsqr_householder_hv (const double tau, const gsl_vector * v, double *w0,\n gsl_vector * w);\nstatic int tsqr_householder_hm (const double tau, const gsl_vector * v, gsl_matrix * R,\n gsl_matrix * A);\nstatic int tsqr_QR_decomp (gsl_matrix * R, gsl_matrix * A, gsl_vector * tau);\n\n/*\ntsqr_alloc()\n Allocate workspace for solving large linear least squares\nproblems using the TSQR approach\n\nInputs: p - number of columns of LS matrix\n\nReturn: pointer to workspace\n*/\n\nstatic void *\ntsqr_alloc(const size_t p)\n{\n tsqr_state_t *state;\n\n if (p == 0)\n {\n GSL_ERROR_NULL(\"p must be a positive integer\",\n GSL_EINVAL);\n }\n\n state = calloc(1, sizeof(tsqr_state_t));\n if (!state)\n {\n GSL_ERROR_NULL(\"failed to allocate tsqr state\", GSL_ENOMEM);\n }\n\n state->p = p;\n state->init = 0;\n state->svd = 0;\n state->normb = 0.0;\n\n state->R = gsl_matrix_alloc(p, p);\n if (state->R == NULL)\n {\n tsqr_free(state);\n GSL_ERROR_NULL(\"failed to allocate R matrix\", GSL_ENOMEM);\n }\n\n state->QTb = gsl_vector_alloc(p);\n if (state->QTb == NULL)\n {\n tsqr_free(state);\n GSL_ERROR_NULL(\"failed to allocate QTb vector\", GSL_ENOMEM);\n }\n\n state->tau = gsl_vector_alloc(p);\n if (state->tau == NULL)\n {\n tsqr_free(state);\n GSL_ERROR_NULL(\"failed to allocate tau vector\", GSL_ENOMEM);\n }\n\n state->multifit_workspace_p = gsl_multifit_linear_alloc(p, p);\n if (state->multifit_workspace_p == NULL)\n {\n tsqr_free(state);\n GSL_ERROR_NULL(\"failed to allocate multifit workspace\", GSL_ENOMEM);\n }\n\n return state;\n}\n\nstatic void\ntsqr_free(void *vstate)\n{\n tsqr_state_t *state = (tsqr_state_t *) vstate;\n\n if (state->R)\n gsl_matrix_free(state->R);\n\n if (state->QTb)\n gsl_vector_free(state->QTb);\n\n if (state->tau)\n gsl_vector_free(state->tau);\n\n if (state->multifit_workspace_p)\n gsl_multifit_linear_free(state->multifit_workspace_p);\n\n free(state);\n}\n\nstatic int\ntsqr_reset(void *vstate)\n{\n tsqr_state_t *state = (tsqr_state_t *) vstate;\n\n gsl_matrix_set_zero(state->R);\n gsl_vector_set_zero(state->QTb);\n state->init = 0;\n state->svd = 0;\n state->normb = 0.0;\n\n return GSL_SUCCESS;\n}\n\n/*\ntsqr_accumulate()\n Add a new block of rows to the QR system\n\nInputs: A - new block of rows, n-by-p\n b - new rhs vector n-by-1\n vstate - workspace\n\nReturn: success/error\n\nNotes:\n1) On output, the upper triangular portion of state->R(1:p,1:p)\ncontains current R matrix\n\n2) state->QTb(1:p) contains current Q^T b vector\n\n3) A and b are destroyed\n*/\n\nstatic int\ntsqr_accumulate(gsl_matrix * A, gsl_vector * b, void * vstate)\n{\n tsqr_state_t *state = (tsqr_state_t *) vstate;\n const size_t n = A->size1;\n const size_t p = A->size2;\n\n if (p != state->p)\n {\n GSL_ERROR(\"columns of A do not match workspace\", GSL_EBADLEN);\n }\n else if (n != b->size)\n {\n GSL_ERROR(\"A and b have different numbers of rows\", GSL_EBADLEN);\n }\n else if (state->init == 0)\n {\n int status;\n const size_t npmin = GSL_MIN(n, p);\n gsl_vector_view tau = gsl_vector_subvector(state->tau, 0, npmin);\n gsl_matrix_view R = gsl_matrix_submatrix(state->R, 0, 0, npmin, p);\n gsl_matrix_view Av = gsl_matrix_submatrix(A, 0, 0, npmin, p);\n gsl_vector_view QTb = gsl_vector_subvector(state->QTb, 0, npmin);\n gsl_vector_view bv = gsl_vector_subvector(b, 0, npmin);\n\n /* this is the first matrix block A_1, compute its (dense) QR decomposition */\n\n /* compute QR decomposition of A */\n status = gsl_linalg_QR_decomp(A, &tau.vector);\n if (status)\n return status;\n\n /* store upper triangular R factor in state->R */\n gsl_matrix_tricpy('U', 1, &R.matrix, &Av.matrix);\n\n /* compute ||b|| */\n state->normb = gsl_blas_dnrm2(b);\n\n /* compute Q^T b and keep the first p elements */\n gsl_linalg_QR_QTvec(A, &tau.vector, b);\n gsl_vector_memcpy(&QTb.vector, &bv.vector);\n\n state->init = 1;\n\n return GSL_SUCCESS;\n }\n else\n {\n int status;\n\n /* compute QR decomposition of [ R_{i-1} ; A_i ], accounting for\n * sparse structure */\n status = tsqr_QR_decomp(state->R, A, state->tau);\n if (status)\n return status;\n\n /* update ||b|| */\n state->normb = gsl_hypot(state->normb, gsl_blas_dnrm2(b));\n\n /*\n * compute Q^T [ QTb_{i - 1}; b_i ], accounting for the sparse\n * structure of the Householder reflectors\n */\n {\n size_t i;\n\n for (i = 0; i < p; i++)\n {\n const double ti = gsl_vector_get (state->tau, i);\n gsl_vector_const_view h = gsl_matrix_const_column (A, i);\n double *wi = gsl_vector_ptr(state->QTb, i);\n tsqr_householder_hv (ti, &(h.vector), wi, b);\n }\n }\n\n return GSL_SUCCESS;\n }\n}\n\n/*\ntsqr_solve()\n Solve the least squares system:\n\nchi^2 = || QTb - R x ||^2 + lambda^2 || x ||^2\n\nusing the SVD of R\n\nInputs: lambda - regularization parameter\n x - (output) solution vector p-by-1\n rnorm - (output) residual norm ||b - A x||\n snorm - (output) solution norm ||x||\n vstate - workspace\n\nReturn: success/error\n*/\n\nstatic int\ntsqr_solve(const double lambda, gsl_vector * x,\n double * rnorm, double * snorm,\n void * vstate)\n{\n tsqr_state_t *state = (tsqr_state_t *) vstate;\n const size_t p = x->size;\n\n if (p != state->p)\n {\n GSL_ERROR(\"solution vector does not match workspace\", GSL_EBADLEN);\n }\n else\n {\n int status;\n\n /* compute SVD of R if not already computed */\n if (state->svd == 0)\n {\n status = tsqr_svd(state);\n if (status)\n return status;\n }\n\n status = gsl_multifit_linear_solve(lambda, state->R, state->QTb, x, rnorm, snorm,\n state->multifit_workspace_p);\n if (status)\n return status;\n\n /*\n * Since we're solving a reduced square system above, we need\n * to account for the full residual vector:\n *\n * rnorm = || [ Q1^T b - R x ; Q2^T b ] ||\n *\n * where Q1 is the thin Q factor of X, and Q2\n * are the remaining columns of Q. But:\n *\n * || Q2^T b ||^2 = ||b||^2 - ||Q1^T b||^2\n * \n * so add this into the rnorm calculation\n */\n {\n double norm_Q1Tb = gsl_blas_dnrm2(state->QTb);\n double ratio = norm_Q1Tb / state->normb;\n double diff = 1.0 - ratio*ratio;\n\n if (diff > GSL_DBL_EPSILON)\n {\n double norm_Q2Tb = state->normb * sqrt(diff);\n *rnorm = gsl_hypot(*rnorm, norm_Q2Tb);\n }\n }\n\n return GSL_SUCCESS;\n }\n}\n\n/*\ntsqr_lcurve()\n Compute L-curve of least squares system\n\nInputs: reg_param - (output) vector of regularization parameters\n rho - (output) vector of residual norms\n eta - (output) vector of solution norms\n vstate - workspace\n\nReturn: success/error\n*/\n\nstatic int\ntsqr_lcurve(gsl_vector * reg_param, gsl_vector * rho,\n gsl_vector * eta, void * vstate)\n{\n tsqr_state_t *state = (tsqr_state_t *) vstate;\n int status;\n\n /* compute SVD of R if not already computed */\n if (state->svd == 0)\n {\n status = tsqr_svd(state);\n if (status)\n return status;\n }\n\n status = gsl_multifit_linear_lcurve(state->QTb, reg_param, rho, eta,\n state->multifit_workspace_p);\n\n /* now add contribution to rnorm from Q2 factor */\n {\n double norm_Q1Tb = gsl_blas_dnrm2(state->QTb);\n double ratio = norm_Q1Tb / state->normb;\n double diff = 1.0 - ratio*ratio;\n size_t i;\n\n if (diff > GSL_DBL_EPSILON)\n {\n double norm_Q2Tb = state->normb * sqrt(diff);\n\n for (i = 0; i < rho->size; ++i)\n {\n double *rhoi = gsl_vector_ptr(rho, i);\n *rhoi = gsl_hypot(*rhoi, norm_Q2Tb);\n }\n }\n }\n\n return status;\n}\n\nstatic int\ntsqr_rcond(double * rcond, void * vstate)\n{\n tsqr_state_t *state = (tsqr_state_t *) vstate;\n\n /* compute SVD of R if not already computed */\n if (state->svd == 0)\n {\n int status = tsqr_svd(state);\n if (status)\n return status;\n }\n\n *rcond = gsl_multifit_linear_rcond(state->multifit_workspace_p);\n\n return GSL_SUCCESS;\n}\n\n/*\ntsqr_svd()\n Compute the SVD of the upper triangular\nR factor. This allows us to compute the upper/lower\nbounds on the regularization parameter and compute\nthe matrix reciprocal condition number.\n\nInputs: state - workspace\n\nReturn: success/error\n*/\n\nstatic int\ntsqr_svd(tsqr_state_t * state)\n{\n int status;\n\n status = gsl_multifit_linear_svd(state->R, state->multifit_workspace_p);\n if (status)\n {\n GSL_ERROR(\"error computing SVD of R\", status);\n }\n\n state->svd = 1;\n\n return GSL_SUCCESS;\n}\n\n/*\ntsqr_householder_transform()\n This routine is an optimized version of\ngsl_linalg_householder_transform(), designed for the QR\ndecomposition of M-by-N matrices of the form:\n\nT = [ R ]\n [ A ]\n\nwhere R is N-by-N upper triangular, and A is (M-N)-by-N dense.\nThis routine computes a householder transformation (tau,v) of a \nx so that P x = [ I - tau*v*v' ] x annihilates x(1:n-1). x will\nbe a subcolumn of the matrix T, and so its structure will be:\n\nx = [ x0 ] <- 1 nonzero value for the diagonal element of R\n [ 0 ] <- N - j - 1 zeros, where j is column of matrix in [0,N-1]\n [ x ] <- M-N nonzero values for the dense part A\n\nInputs: v0 - pointer to diagonal element of R\n on input, v0 = x0;\n v - on input, x vector\n on output, householder vector v\n*/\n\nstatic double\ntsqr_householder_transform (double *v0, gsl_vector * v)\n{\n /* replace v[0:M-1] with a householder vector (v[0:M-1]) and\n coefficient tau that annihilate v[1:M-1] */\n\n double alpha, beta, tau ;\n \n /* compute xnorm = || [ 0 ; v ] ||, ignoring zero part of vector */\n double xnorm = gsl_blas_dnrm2(v);\n\n if (xnorm == 0) \n {\n return 0.0; /* tau = 0 */\n }\n\n alpha = *v0;\n beta = - (alpha >= 0.0 ? +1.0 : -1.0) * hypot(alpha, xnorm) ;\n tau = (beta - alpha) / beta ;\n \n {\n double s = (alpha - beta);\n \n if (fabs(s) > GSL_DBL_MIN) \n {\n gsl_blas_dscal (1.0 / s, v);\n *v0 = beta;\n }\n else\n {\n gsl_blas_dscal (GSL_DBL_EPSILON / s, v);\n gsl_blas_dscal (1.0 / GSL_DBL_EPSILON, v);\n *v0 = beta;\n }\n }\n \n return tau;\n}\n\n/*\ntsqr_householder_hv()\n Apply Householder reflector to a vector. The Householder\nreflectors are for the QR decomposition of the matrix\n\n [ R ]\n [ A ]\n\nwhere R is p-by-p upper triangular and A is n-by-p dense.\nTherefore all relevant components of the Householder\nvector are stored in the columns of A, while the components\nin R are 0, except for diag(R) which are 1.\n\nThe vector w to be transformed is partitioned as\n\n [ w1 ]\n [ w2 ]\n\nwhere w1 is p-by-1 and w2 is n-by-1. The w2 portion\nof w is transformed by v, but most of w1 remains unchanged\nexcept for the first element, w0\n\nInputs: tau - Householder scalar\n v - Householder vector, n-by-1\n w0 - (input/output)\n on input, w1(0);\n on output, transformed w1(0)\n w - (input/output) n-by-1\n on input, vector w2;\n on output, P*w2\n*/\n\nstatic int\ntsqr_householder_hv (const double tau, const gsl_vector * v, double *w0, gsl_vector * w)\n{\n /* applies a householder transformation v to vector w */\n \n if (tau == 0)\n return GSL_SUCCESS ;\n\n {\n double d1, d;\n\n /* compute d1 = v(2:n)' w(2:n) */\n gsl_blas_ddot (v, w, &d1);\n\n /* compute d = v'w = w(1) + d1 since v(1) = 1 */\n d = *w0 + d1;\n\n /* compute w = w - tau (v) (v'w) */\n *w0 -= tau * d;\n gsl_blas_daxpy (-tau * d, v, w);\n }\n \n return GSL_SUCCESS;\n}\n\n/*\ntsqr_householder_hm()\n Apply Householder reflector to a submatrix of\n\n [ R ]\n [ A ]\n\nwhere R is p-by-p upper triangular and A is n-by-p dense.\nThe diagonal terms of R are already transformed by\ntsqr_householder_transform(), so we just need to operate\non the submatrix A(:,i:p) as well as the superdiagonal\nelements of R\n\nInputs: tau - Householder scalar\n v - Householder vector\n R - upper triangular submatrix of R, (p-i)-by-(p-i-1)\n A - dense submatrix of A, n-by-(p-i)\n*/\n\nstatic int\ntsqr_householder_hm (const double tau, const gsl_vector * v, gsl_matrix * R,\n gsl_matrix * A)\n{\n /* applies a householder transformation v,tau to matrix [ R ; A ] */\n\n if (tau == 0.0)\n {\n return GSL_SUCCESS;\n }\n else\n {\n size_t j;\n\n for (j = 0; j < A->size2; j++)\n {\n double R0j = gsl_matrix_get (R, 0, j);\n double wj;\n gsl_vector_view A1j = gsl_matrix_column(A, j);\n\n gsl_blas_ddot (&A1j.vector, v, &wj);\n wj += R0j;\n\n gsl_matrix_set (R, 0, j, R0j - tau * wj);\n\n gsl_blas_daxpy (-tau * wj, v, &A1j.vector);\n }\n\n return GSL_SUCCESS;\n }\n}\n\n/*\ntsqr_QR_decomp()\n Compute the QR decomposition of the matrix\n\n [ R ]\n [ A ]\n\nwhere R is p-by-p upper triangular and A is n-by-p dense.\n\nInputs: R - upper triangular p-by-p matrix\n A - dense n-by-p matrix\n tau - Householder scalars\n*/\n\nstatic int\ntsqr_QR_decomp (gsl_matrix * R, gsl_matrix * A, gsl_vector * tau)\n{\n const size_t n = A->size1;\n const size_t p = R->size2;\n\n if (R->size2 != A->size2)\n {\n GSL_ERROR (\"R and A have different number of columns\", GSL_EBADLEN);\n }\n else if (tau->size != p)\n {\n GSL_ERROR (\"size of tau must be p\", GSL_EBADLEN);\n }\n else\n {\n size_t i;\n\n for (i = 0; i < p; i++)\n {\n /* Compute the Householder transformation to reduce the j-th\n column of the matrix [ R ; A ] to a multiple of the j-th unit vector,\n taking into account the sparse structure of R */\n\n gsl_vector_view c = gsl_matrix_column(A, i);\n double *Rii = gsl_matrix_ptr(R, i, i);\n double tau_i = tsqr_householder_transform(Rii, &c.vector);\n\n gsl_vector_set (tau, i, tau_i);\n\n /* Apply the transformation to the remaining columns and\n update the norms */\n\n if (i + 1 < p)\n {\n gsl_matrix_view Rv = gsl_matrix_submatrix(R, i, i + 1, p - i, p - (i + 1));\n gsl_matrix_view Av = gsl_matrix_submatrix(A, 0, i + 1, n, p - (i + 1));\n tsqr_householder_hm (tau_i, &(c.vector), &(Rv.matrix), &(Av.matrix));\n }\n }\n\n return GSL_SUCCESS;\n }\n}\n\nstatic const gsl_multilarge_linear_type tsqr_type =\n{\n \"tsqr\",\n tsqr_alloc,\n tsqr_reset,\n tsqr_accumulate,\n tsqr_solve,\n tsqr_rcond,\n tsqr_lcurve,\n tsqr_free\n};\n\nconst gsl_multilarge_linear_type * gsl_multilarge_linear_tsqr =\n &tsqr_type;\n", "meta": {"hexsha": "68033ac5d28c9a08a92eff37cdbb12f45fd28524", "size": 17885, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.4/multilarge/tsqr.c", "max_stars_repo_name": "peterahrens/FillEstimationIPDPS2017", "max_stars_repo_head_hexsha": "857b6ee8866a2950aa5721d575d2d7d0797c4302", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2020-10-18T13:15:00.000Z", "max_stars_repo_stars_event_max_datetime": "2020-10-18T13:15:00.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/multilarge/tsqr.c", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/multilarge/tsqr.c", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 25.3328611898, "max_line_length": 89, "alphanum_fraction": 0.6046966732, "num_tokens": 5207, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7826624688140726, "lm_q2_score": 0.6757646140788307, "lm_q1q2_score": 0.5288956011921266}} {"text": "#include \n#include \n#include \n#include \"klp_matrix_initializers.h\"\n#include \"klp_matrix_functions.h\"\n#include \"shared/constants.h\"\n\nTRANSITION_MATRIX transpose_matrix(TRANSITION_MATRIX matrix) {\n int i, j;\n TRANSITION_MATRIX transposed_matrix = init_transition_matrix(matrix.row_length, matrix.type);\n \n for (i = 0; i < matrix.row_length; ++i) {\n for (j = 0; j < matrix.row_length; ++j) {\n T_COL_ORDER(transposed_matrix, i, j) = T_ROW_ORDER(matrix, i, j);\n }\n }\n \n free_transition_matrix(matrix);\n return transposed_matrix;\n}\n\nTRANSITION_MATRIX inverse(TRANSITION_MATRIX transition_matrix) {\n int i, j, signum;\n gsl_matrix* matrix_to_invert = gsl_matrix_alloc(transition_matrix.row_length, transition_matrix.row_length);\n gsl_matrix* inversion_matrix = gsl_matrix_alloc(transition_matrix.row_length, transition_matrix.row_length);\n gsl_permutation* permutation = gsl_permutation_alloc(transition_matrix.row_length);\n \n for (i = 0; i < transition_matrix.row_length; ++i) {\n for (j = 0; j < transition_matrix.row_length; ++j) {\n gsl_matrix_set(matrix_to_invert, i, j, T_ROW_ORDER(transition_matrix, i, j));\n }\n }\n \n gsl_linalg_LU_decomp(matrix_to_invert, permutation, &signum);\n gsl_linalg_LU_invert(matrix_to_invert, permutation, inversion_matrix);\n \n for (i = 0; i < transition_matrix.row_length; ++i) {\n for (j = 0; j < transition_matrix.row_length; ++j) {\n T_ROW_ORDER(transition_matrix, i, j) = gsl_matrix_get(inversion_matrix, i, j);\n }\n }\n \n gsl_matrix_free(matrix_to_invert);\n gsl_matrix_free(inversion_matrix);\n gsl_permutation_free(permutation);\n \n return transition_matrix;\n}\n\nTRANSITION_MATRIX convert_klp_matrix_to_transition_matrix(KLP_MATRIX* klp_matrix, KLP_PARAMS* klp_params) {\n int resolved;\n double* number_of_adjacent_moves;\n transition_probability probability_function = NULL;\n \n resolved = find_start_and_end_positions_in_klp_matrix(klp_matrix, klp_params);\n \n if (klp_params->max_dist) {\n if (!klp_params->bp_dist) {\n set_bp_dist_from_start_and_end_positions(*klp_matrix, klp_params, resolved);\n }\n \n extend_klp_matrix_to_all_possible_positions(klp_matrix, *klp_params);\n populate_remaining_probabilities_in_klp_matrix(klp_matrix, *klp_params);\n \n if (resolved != 2) {\n find_start_and_end_positions_in_klp_matrix(klp_matrix, klp_params);\n }\n }\n \n number_of_adjacent_moves = populate_number_of_adjacent_moves(*klp_matrix, *klp_params);\n \n#ifdef DEBUG\n int i;\n printf(\"\\nFull dataset:\\n\");\n \n for (i = 0; i < klp_matrix->length; ++i) {\n printf(\"%d\\t%d\\t%f\\t%d possible move(s)\\n\", klp_matrix->k[i], klp_matrix->l[i], klp_matrix->p[i], (int)number_of_adjacent_moves[i]);\n }\n \n printf(\"\\n\");\n#endif\n \n switch (10 * klp_params->hastings + klp_params->energy_based) {\n case 0:\n probability_function = &transition_rate_from_probabilities;\n#ifdef DEBUG\n printf(\"probability_function: transition_rate_from_probabilities\\n\");\n#endif\n break;\n \n case 1:\n probability_function = &transition_rate_from_energies;\n#ifdef DEBUG\n printf(\"probability_function: transition_rate_from_energies\\n\");\n#endif\n break;\n \n case 10:\n probability_function = &transition_rate_from_probabilities_with_hastings;\n#ifdef DEBUG\n printf(\"probability_function: transition_rate_from_probabilities_with_hastings\\n\");\n#endif\n break;\n \n case 11:\n probability_function = &transition_rate_from_energies_with_hastings;\n#ifdef DEBUG\n printf(\"probability_function: transition_rate_from_energies_with_hastings\\n\");\n#endif\n break;\n }\n \n return populate_transition_matrix_from_stationary_matrix(*klp_matrix, *klp_params, number_of_adjacent_moves, probability_function);\n}\n\nint find_start_and_end_positions_in_klp_matrix(KLP_MATRIX* klp_matrix, KLP_PARAMS* klp_params) {\n int i, resolved = 0;\n \n if (klp_params->start_state == -1) {\n for (i = 0; i < klp_matrix->length && klp_params->start_state == -1; ++i) {\n if (klp_matrix->k[i] == 0) {\n klp_params->start_state = i;\n resolved++;\n }\n }\n } else {\n resolved++;\n }\n \n if (klp_params->end_state == -1) {\n for (i = 0; i < klp_matrix->length && klp_params->end_state == -1; ++i) {\n if (klp_matrix->l[i] == 0) {\n klp_params->end_state = i;\n resolved++;\n }\n }\n } else {\n resolved++;\n }\n \n#ifdef DEBUG\n printf(\"\\nstart_index:\\t%d\\n\", klp_params->start_state);\n printf(\"end_index:\\t%d\\n\", klp_params->end_state);\n printf(\"resolved:\\t%d\\n\", resolved);\n#endif\n return resolved;\n}\n\nvoid set_bp_dist_from_start_and_end_positions(const KLP_MATRIX klp_matrix, KLP_PARAMS* klp_params, int resolved) {\n int distance_from_start, distance_from_end;\n \n distance_from_start = distance_from_end = -1;\n \n if (klp_params->start_state > 0) {\n distance_from_start = klp_matrix.l[klp_params->start_state];\n }\n \n if (klp_params->end_state > 0) {\n distance_from_end = klp_matrix.k[klp_params->end_state];\n }\n \n if (distance_from_start == distance_from_end && resolved) {\n klp_params->bp_dist = distance_from_start;\n } else if (distance_from_start >= 0 && distance_from_end == -1) {\n klp_params->bp_dist = distance_from_start;\n } else if (distance_from_end >= 0 && distance_from_start == -1) {\n klp_params->bp_dist = distance_from_end;\n } else {\n fprintf(stderr, \"Can't infer the input structure distances for the energy grid. We found (0, %d) and (%d, 0). Consider using the -d flag to manually set the base pair distance between the two structures.\\n\", distance_from_end, distance_from_start);\n printf(\"-3\\n\");\n exit(0);\n }\n \n#ifdef DEBUG\n printf(\"bp_dist:\\t%d\\n\", klp_params->bp_dist);\n#endif\n}\n\nvoid extend_klp_matrix_to_all_possible_positions(KLP_MATRIX* klp_matrix, const KLP_PARAMS klp_params) {\n int i, j, m, position_in_input_data, pointer, valid_positions = 0;\n \n#ifdef DEBUG\n printf(\"\\nAccessible positions (top-left is [0, 0]):\\n\");\n#endif\n \n for (i = 0; i <= klp_params.max_dist; ++i) {\n for (j = 0; j <= klp_params.max_dist; ++j) {\n if (\n i + j >= klp_params.bp_dist &&\n i + klp_params.bp_dist >= j &&\n j + klp_params.bp_dist >= i &&\n (i + j) % 2 == klp_params.bp_dist % 2\n ) {\n#ifdef DEBUG\n position_in_input_data = -1;\n \n for (m = 0; m < klp_matrix->length && position_in_input_data == -1; ++m) {\n if (klp_matrix->k[m] == i && klp_matrix->l[m] == j) {\n position_in_input_data = m;\n }\n }\n \n printf(position_in_input_data == -1 ? \"X\" : \"O\");\n#endif\n valid_positions++;\n } else {\n#ifdef DEBUG\n printf(\" \");\n#endif\n }\n }\n \n#ifdef DEBUG\n printf(\"\\n\");\n#endif\n }\n \n klp_matrix->k = realloc(klp_matrix->k, valid_positions * sizeof(int));\n klp_matrix->l = realloc(klp_matrix->l, valid_positions * sizeof(int));\n klp_matrix->p = realloc(klp_matrix->p, valid_positions * sizeof(double));\n \n pointer = klp_matrix->length;\n \n#ifdef DEBUG\n printf(\"\\nInput dataset:\\n\");\n \n for (i = 0; i < klp_matrix->length; ++i) {\n printf(\"%d\\t%d\\t%d\\t%f\\n\", i, klp_matrix->k[i], klp_matrix->l[i], klp_matrix->p[i]);\n }\n \n#endif\n \n for (i = 0; i <= klp_params.max_dist; ++i) {\n for (j = 0; j <= klp_params.max_dist; ++j) {\n if (\n i + j >= klp_params.bp_dist &&\n i + klp_params.bp_dist >= j &&\n j + klp_params.bp_dist >= i &&\n (i + j) % 2 == klp_params.bp_dist % 2\n ) {\n position_in_input_data = -1;\n \n for (m = 0; m < klp_matrix->length && position_in_input_data == -1; ++m) {\n if (klp_matrix->k[m] == i && klp_matrix->l[m] == j) {\n position_in_input_data = m;\n }\n }\n \n if (position_in_input_data < 0) {\n klp_matrix->k[pointer] = i;\n klp_matrix->l[pointer] = j;\n klp_matrix->p[pointer] = 0.;\n pointer++;\n }\n }\n }\n }\n \n klp_matrix->length = valid_positions;\n}\n\nvoid populate_remaining_probabilities_in_klp_matrix(KLP_MATRIX* klp_matrix, const KLP_PARAMS klp_params) {\n int i;\n double epsilon_per_cell;\n \n if (klp_params.epsilon) {\n // Extend the energy grid by adding an epsilon value to all 0-probability positions.\n epsilon_per_cell = klp_params.epsilon / klp_matrix->length;\n \n for (i = 0; i < klp_matrix->length; ++i) {\n if (klp_matrix->p[i] > 0) {\n klp_matrix->p[i] = (klp_matrix->p[i] + epsilon_per_cell) / (1. + klp_params.epsilon);\n } else {\n klp_matrix->p[i] = epsilon_per_cell / (1. + klp_params.epsilon);\n }\n }\n }\n}\n\ndouble* populate_number_of_adjacent_moves(const KLP_MATRIX klp_matrix, const KLP_PARAMS klp_params) {\n int i;\n double* number_of_adjacent_moves;\n \n number_of_adjacent_moves = malloc(klp_matrix.length * sizeof(double));\n \n for (i = 0; i < klp_matrix.length; ++i) {\n number_of_adjacent_moves[i] = RUN_TYPE(klp_params.run_type, DIAG_MOVES_ONLY_FLAG) ? (double)number_of_permissible_single_bp_moves(klp_matrix, i) : (double)(klp_matrix.length - 1);\n }\n \n return number_of_adjacent_moves;\n}\n\nint number_of_permissible_single_bp_moves(const KLP_MATRIX klp_matrix, int i) {\n int j, x, y, a, b, num_moves = 0;\n \n x = klp_matrix.k[i];\n y = klp_matrix.l[i];\n \n for (j = 0; j < klp_matrix.length; ++j) {\n a = klp_matrix.k[j];\n b = klp_matrix.l[j];\n \n if (\n // Because N(x, y) is restricted to entries in *k and *l, we *assume* the input data satisfies the triangle inequality and bounds.\n (int)abs(x - a) == 1 && (int)abs(y - b) == 1\n ) {\n num_moves++;\n }\n }\n \n return num_moves;\n}\n\nTRANSITION_MATRIX populate_transition_matrix_from_stationary_matrix(const KLP_MATRIX klp_matrix, const KLP_PARAMS klp_params, const double* number_of_adjacent_moves, transition_probability probability_function) {\n int i, j;\n double row_sum;\n TRANSITION_MATRIX transition_matrix;\n \n transition_matrix = init_transition_matrix(klp_matrix.length, MATRIX_TYPE(klp_params.rate_matrix));\n \n for (i = 0; i < transition_matrix.row_length; ++i) {\n row_sum = 0.;\n \n for (j = 0; j < transition_matrix.row_length; ++j) {\n if (i != j) {\n if (RUN_TYPE(klp_params.run_type, FULLY_CONNECTED_FLAG) || (RUN_TYPE(klp_params.run_type, DIAG_MOVES_ONLY_FLAG) && ONE_BP_MOVE(i, j))) {\n if (NONZERO_TO_NONZERO_PROB(i, j)) {\n T_ROW_ORDER(transition_matrix, i, j) = \\\n probability_function(klp_matrix, number_of_adjacent_moves, i, j, klp_params.rate_matrix);\n }\n }\n \n row_sum += T_ROW_ORDER(transition_matrix, i, j);\n }\n }\n \n T_ROW_ORDER(transition_matrix, i, i) = klp_params.rate_matrix ? -row_sum : 1 - row_sum;\n }\n \n return transition_matrix;\n}\n\ndouble transition_rate_from_probabilities(const KLP_MATRIX klp_matrix, const double* number_of_adjacent_moves, int i, int j, short rate_matrix) {\n if (rate_matrix) {\n return MIN(1., klp_matrix.p[j] / klp_matrix.p[i]);\n } else {\n return MIN(1., klp_matrix.p[j] / klp_matrix.p[i]) / number_of_adjacent_moves[i];\n }\n}\n\ndouble transition_rate_from_energies(const KLP_MATRIX klp_matrix, const double* number_of_adjacent_moves, int i, int j, short rate_matrix) {\n if (rate_matrix) {\n return MIN(1., exp(-(klp_matrix.p[j] - klp_matrix.p[i]) / RT));\n } else {\n return MIN(1., exp(-(klp_matrix.p[j] - klp_matrix.p[i]) / RT)) / number_of_adjacent_moves[i];\n }\n}\n\ndouble transition_rate_from_probabilities_with_hastings(const KLP_MATRIX klp_matrix, const double* number_of_adjacent_moves, int i, int j, short rate_matrix) {\n if (rate_matrix) {\n return MIN(1., (number_of_adjacent_moves[i] / number_of_adjacent_moves[j]) * (klp_matrix.p[j] / klp_matrix.p[i]));\n } else {\n return MIN(1., (number_of_adjacent_moves[i] / number_of_adjacent_moves[j]) * (klp_matrix.p[j] / klp_matrix.p[i])) / number_of_adjacent_moves[i];\n }\n}\n\ndouble transition_rate_from_energies_with_hastings(const KLP_MATRIX klp_matrix, const double* number_of_adjacent_moves, int i, int j, short rate_matrix) {\n if (rate_matrix) {\n return MIN(1., (number_of_adjacent_moves[i] / number_of_adjacent_moves[j]) * exp(-(klp_matrix.p[j] - klp_matrix.p[i]) / RT));\n } else {\n return MIN(1., (number_of_adjacent_moves[i] / number_of_adjacent_moves[j]) * exp(-(klp_matrix.p[j] - klp_matrix.p[i]) / RT)) / number_of_adjacent_moves[i];\n }\n}\n", "meta": {"hexsha": "d969dc181a115622f3aa75e4af053101dc3a68f9", "size": 12477, "ext": "c", "lang": "C", "max_stars_repo_path": "src/klp_matrix/c/klp_matrix_functions.c", "max_stars_repo_name": "evansenter/hermes", "max_stars_repo_head_hexsha": "8ad3800f98fcfe7fb2e9f57cdf11b18cf781ac2d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/klp_matrix/c/klp_matrix_functions.c", "max_issues_repo_name": "evansenter/hermes", "max_issues_repo_head_hexsha": "8ad3800f98fcfe7fb2e9f57cdf11b18cf781ac2d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/klp_matrix/c/klp_matrix_functions.c", "max_forks_repo_name": "evansenter/hermes", "max_forks_repo_head_hexsha": "8ad3800f98fcfe7fb2e9f57cdf11b18cf781ac2d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 33.3609625668, "max_line_length": 252, "alphanum_fraction": 0.6704335978, "num_tokens": 3504, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7826624789529375, "lm_q2_score": 0.6757645944891558, "lm_q1q2_score": 0.5288955927115092}} {"text": "/* specfunc/gamma_inc.c\n *\n * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman\n *\n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 2 of the License, or (at\n * your option) any later version.\n *\n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n/* Author: G. Jungman */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"error.h\"\n\n/* The dominant part,\n * D(a,x) := x^a e^(-x) / Gamma(a+1)\n */\nstatic\nint\ngamma_inc_D(const double a, const double x, gsl_sf_result * result)\n{\n if(a < 10.0) {\n double lnr;\n gsl_sf_result lg;\n gsl_sf_lngamma_e(a+1.0, &lg);\n lnr = a * log(x) - x - lg.val;\n result->val = exp(lnr);\n result->err = 2.0 * GSL_DBL_EPSILON * (fabs(lnr) + 1.0) * fabs(result->val);\n return GSL_SUCCESS;\n }\n else {\n gsl_sf_result gstar;\n gsl_sf_result ln_term;\n double term1;\n if (x < 0.5*a) {\n double u = x/a; \n double ln_u = log(u);\n ln_term.val = ln_u - u + 1.0;\n ln_term.err = (fabs(ln_u) + fabs(u) + 1.0) * GSL_DBL_EPSILON;\n } else {\n double mu = (x-a)/a;\n gsl_sf_log_1plusx_mx_e(mu, &ln_term); /* log(1+mu) - mu */\n };\n gsl_sf_gammastar_e(a, &gstar);\n term1 = exp(a*ln_term.val)/sqrt(2.0*M_PI*a);\n result->val = term1/gstar.val;\n result->err = 2.0 * GSL_DBL_EPSILON * (fabs(a*ln_term.val) + 1.0) * fabs(result->val);\n result->err += gstar.err/fabs(gstar.val) * fabs(result->val);\n return GSL_SUCCESS;\n }\n\n}\n\n\n/* P series representation.\n */\nstatic\nint\ngamma_inc_P_series(const double a, const double x, gsl_sf_result * result)\n{\n const int nmax = 5000;\n\n gsl_sf_result D;\n int stat_D = gamma_inc_D(a, x, &D);\n\n double sum = 1.0;\n double term = 1.0;\n int n;\n for(n=1; nval = D.val * sum;\n result->err = D.err * fabs(sum);\n result->err += (1.0 + n) * GSL_DBL_EPSILON * fabs(result->val);\n\n if(n == nmax)\n GSL_ERROR (\"error\", GSL_EMAXITER);\n else\n return stat_D;\n}\n\n\n/* Q large x asymptotic\n */\nstatic\nint\ngamma_inc_Q_large_x(const double a, const double x, gsl_sf_result * result)\n{\n const int nmax = 5000;\n\n gsl_sf_result D;\n const int stat_D = gamma_inc_D(a, x, &D);\n\n double sum = 1.0;\n double term = 1.0;\n double last = 1.0;\n int n;\n for(n=1; n 1.0) break;\n if(fabs(term/sum) < GSL_DBL_EPSILON) break;\n sum += term;\n last = term;\n }\n\n result->val = D.val * (a/x) * sum;\n result->err = D.err * fabs((a/x) * sum);\n result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);\n\n if(n == nmax)\n GSL_ERROR (\"error in large x asymptotic\", GSL_EMAXITER);\n else\n return stat_D;\n}\n\n\n/* Uniform asymptotic for x near a, a and x large.\n * See [Temme, p. 285]\n */\nstatic\nint\ngamma_inc_Q_asymp_unif(const double a, const double x, gsl_sf_result * result)\n{\n const double rta = sqrt(a);\n const double eps = (x-a)/a;\n\n gsl_sf_result ln_term;\n const int stat_ln = gsl_sf_log_1plusx_mx_e(eps, &ln_term); /* log(1+eps) - eps */\n const double eta = GSL_SIGN(eps) * sqrt(-2.0*ln_term.val);\n\n gsl_sf_result erfc;\n\n double R;\n double c0, c1;\n\n /* This used to say erfc(eta*M_SQRT2*rta), which is wrong.\n * The sqrt(2) is in the denominator. Oops.\n * Fixed: [GJ] Mon Nov 15 13:25:32 MST 2004\n */\n gsl_sf_erfc_e(eta*rta/M_SQRT2, &erfc);\n\n if(fabs(eps) < GSL_ROOT5_DBL_EPSILON) {\n c0 = -1.0/3.0 + eps*(1.0/12.0 - eps*(23.0/540.0 - eps*(353.0/12960.0 - eps*589.0/30240.0)));\n c1 = -1.0/540.0 - eps/288.0;\n }\n else {\n const double rt_term = sqrt(-2.0 * ln_term.val/(eps*eps));\n const double lam = x/a;\n c0 = (1.0 - 1.0/rt_term)/eps;\n c1 = -(eta*eta*eta * (lam*lam + 10.0*lam + 1.0) - 12.0 * eps*eps*eps) / (12.0 * eta*eta*eta*eps*eps*eps);\n }\n\n R = exp(-0.5*a*eta*eta)/(M_SQRT2*M_SQRTPI*rta) * (c0 + c1/a);\n\n result->val = 0.5 * erfc.val + R;\n result->err = GSL_DBL_EPSILON * fabs(R * 0.5 * a*eta*eta) + 0.5 * erfc.err;\n result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);\n\n return stat_ln;\n}\n\n\n/* Continued fraction which occurs in evaluation\n * of Q(a,x) or Gamma(a,x).\n *\n * 1 (1-a)/x 1/x (2-a)/x 2/x (3-a)/x\n * F(a,x) = ---- ------- ----- -------- ----- -------- ...\n * 1 + 1 + 1 + 1 + 1 + 1 +\n *\n * Hans E. Plesser, 2002-01-22 (hans dot plesser at itf dot nlh dot no).\n *\n * Split out from gamma_inc_Q_CF() by GJ [Tue Apr 1 13:16:41 MST 2003].\n * See gamma_inc_Q_CF() below.\n *\n */\nstatic int\ngamma_inc_F_CF(const double a, const double x, gsl_sf_result * result)\n{\n const int nmax = 5000;\n const double small = gsl_pow_3 (GSL_DBL_EPSILON);\n\n double hn = 1.0; /* convergent */\n double Cn = 1.0 / small;\n double Dn = 1.0;\n int n;\n\n /* n == 1 has a_1, b_1, b_0 independent of a,x,\n so that has been done by hand */\n for ( n = 2 ; n < nmax ; n++ )\n {\n double an;\n double delta;\n\n if(GSL_IS_ODD(n))\n an = 0.5*(n-1)/x;\n else\n an = (0.5*n-a)/x;\n\n Dn = 1.0 + an * Dn;\n if ( fabs(Dn) < small )\n Dn = small;\n Cn = 1.0 + an/Cn;\n if ( fabs(Cn) < small )\n Cn = small;\n Dn = 1.0 / Dn;\n delta = Cn * Dn;\n hn *= delta;\n if(fabs(delta-1.0) < GSL_DBL_EPSILON) break;\n }\n\n result->val = hn;\n result->err = 2.0*GSL_DBL_EPSILON * fabs(hn);\n result->err += GSL_DBL_EPSILON * (2.0 + 0.5*n) * fabs(result->val);\n\n if(n == nmax)\n GSL_ERROR (\"error in CF for F(a,x)\", GSL_EMAXITER);\n else\n return GSL_SUCCESS;\n}\n\n\n/* Continued fraction for Q.\n *\n * Q(a,x) = D(a,x) a/x F(a,x)\n *\n * Hans E. Plesser, 2002-01-22 (hans dot plesser at itf dot nlh dot no):\n *\n * Since the Gautschi equivalent series method for CF evaluation may lead\n * to singularities, I have replaced it with the modified Lentz algorithm\n * given in\n *\n * I J Thompson and A R Barnett\n * Coulomb and Bessel Functions of Complex Arguments and Order\n * J Computational Physics 64:490-509 (1986)\n *\n * In consequence, gamma_inc_Q_CF_protected() is now obsolete and has been\n * removed.\n *\n * Identification of terms between the above equation for F(a, x) and\n * the first equation in the appendix of Thompson&Barnett is as follows:\n *\n * b_0 = 0, b_n = 1 for all n > 0\n *\n * a_1 = 1\n * a_n = (n/2-a)/x for n even\n * a_n = (n-1)/(2x) for n odd\n *\n */\nstatic\nint\ngamma_inc_Q_CF(const double a, const double x, gsl_sf_result * result)\n{\n gsl_sf_result D;\n gsl_sf_result F;\n const int stat_D = gamma_inc_D(a, x, &D);\n const int stat_F = gamma_inc_F_CF(a, x, &F);\n\n result->val = D.val * (a/x) * F.val;\n result->err = D.err * fabs((a/x) * F.val) + fabs(D.val * a/x * F.err);\n\n return GSL_ERROR_SELECT_2(stat_F, stat_D);\n}\n\n\n/* Useful for small a and x. Handles the subtraction analytically.\n */\nstatic\nint\ngamma_inc_Q_series(const double a, const double x, gsl_sf_result * result)\n{\n double term1; /* 1 - x^a/Gamma(a+1) */\n double sum; /* 1 + (a+1)/(a+2)(-x)/2! + (a+1)/(a+3)(-x)^2/3! + ... */\n int stat_sum;\n double term2; /* a temporary variable used at the end */\n\n {\n /* Evaluate series for 1 - x^a/Gamma(a+1), small a\n */\n const double pg21 = -2.404113806319188570799476; /* PolyGamma[2,1] */\n const double lnx = log(x);\n const double el = M_EULER+lnx;\n const double c1 = -el;\n const double c2 = M_PI*M_PI/12.0 - 0.5*el*el;\n const double c3 = el*(M_PI*M_PI/12.0 - el*el/6.0) + pg21/6.0;\n const double c4 = -0.04166666666666666667\n * (-1.758243446661483480 + lnx)\n * (-0.764428657272716373 + lnx)\n * ( 0.723980571623507657 + lnx)\n * ( 4.107554191916823640 + lnx);\n const double c5 = -0.0083333333333333333\n * (-2.06563396085715900 + lnx)\n * (-1.28459889470864700 + lnx)\n * (-0.27583535756454143 + lnx)\n * ( 1.33677371336239618 + lnx)\n * ( 5.17537282427561550 + lnx);\n const double c6 = -0.0013888888888888889\n * (-2.30814336454783200 + lnx)\n * (-1.65846557706987300 + lnx)\n * (-0.88768082560020400 + lnx)\n * ( 0.17043847751371778 + lnx)\n * ( 1.92135970115863890 + lnx)\n * ( 6.22578557795474900 + lnx);\n const double c7 = -0.00019841269841269841\n * (-2.5078657901291800 + lnx)\n * (-1.9478900888958200 + lnx)\n * (-1.3194837322612730 + lnx)\n * (-0.5281322700249279 + lnx)\n * ( 0.5913834939078759 + lnx)\n * ( 2.4876819633378140 + lnx)\n * ( 7.2648160783762400 + lnx);\n const double c8 = -0.00002480158730158730\n * (-2.677341544966400 + lnx)\n * (-2.182810448271700 + lnx)\n * (-1.649350342277400 + lnx)\n * (-1.014099048290790 + lnx)\n * (-0.191366955370652 + lnx)\n * ( 0.995403817918724 + lnx)\n * ( 3.041323283529310 + lnx)\n * ( 8.295966556941250 + lnx);\n const double c9 = -2.75573192239859e-6\n * (-2.8243487670469080 + lnx)\n * (-2.3798494322701120 + lnx)\n * (-1.9143674728689960 + lnx)\n * (-1.3814529102920370 + lnx)\n * (-0.7294312810261694 + lnx)\n * ( 0.1299079285269565 + lnx)\n * ( 1.3873333251885240 + lnx)\n * ( 3.5857258865210760 + lnx)\n * ( 9.3214237073814600 + lnx);\n const double c10 = -2.75573192239859e-7\n * (-2.9540329644556910 + lnx)\n * (-2.5491366926991850 + lnx)\n * (-2.1348279229279880 + lnx)\n * (-1.6741881076349450 + lnx)\n * (-1.1325949616098420 + lnx)\n * (-0.4590034650618494 + lnx)\n * ( 0.4399352987435699 + lnx)\n * ( 1.7702236517651670 + lnx)\n * ( 4.1231539047474080 + lnx)\n * ( 10.342627908148680 + lnx);\n\n term1 = a*(c1+a*(c2+a*(c3+a*(c4+a*(c5+a*(c6+a*(c7+a*(c8+a*(c9+a*c10)))))))));\n }\n\n {\n /* Evaluate the sum.\n */\n const int nmax = 5000;\n double t = 1.0;\n int n;\n sum = 1.0;\n\n for(n=1; nval = term1 + term2;\n result->err = GSL_DBL_EPSILON * (fabs(term1) + 2.0*fabs(term2));\n result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);\n return stat_sum;\n}\n\n\n/* series for small a and x, but not defined for a == 0 */\nstatic int\ngamma_inc_series(double a, double x, gsl_sf_result * result)\n{\n gsl_sf_result Q;\n gsl_sf_result G;\n const int stat_Q = gamma_inc_Q_series(a, x, &Q);\n const int stat_G = gsl_sf_gamma_e(a, &G);\n result->val = Q.val * G.val;\n result->err = fabs(Q.val * G.err) + fabs(Q.err * G.val);\n result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);\n\n return GSL_ERROR_SELECT_2(stat_Q, stat_G);\n}\n\n\nstatic int\ngamma_inc_a_gt_0(double a, double x, gsl_sf_result * result)\n{\n /* x > 0 and a > 0; use result for Q */\n gsl_sf_result Q;\n gsl_sf_result G;\n const int stat_Q = gsl_sf_gamma_inc_Q_e(a, x, &Q);\n const int stat_G = gsl_sf_gamma_e(a, &G);\n\n result->val = G.val * Q.val;\n result->err = fabs(G.val * Q.err) + fabs(G.err * Q.val);\n result->err += 2.0*GSL_DBL_EPSILON * fabs(result->val);\n\n return GSL_ERROR_SELECT_2(stat_G, stat_Q);\n}\n\n\nstatic int\ngamma_inc_CF(double a, double x, gsl_sf_result * result)\n{\n gsl_sf_result F;\n gsl_sf_result pre;\n const int stat_F = gamma_inc_F_CF(a, x, &F);\n const int stat_E = gsl_sf_exp_e((a-1.0)*log(x) - x, &pre);\n\n result->val = F.val * pre.val;\n result->err = fabs(F.err * pre.val) + fabs(F.val * pre.err);\n result->err += (2.0 + fabs(a)) * GSL_DBL_EPSILON * fabs(result->val);\n\n return GSL_ERROR_SELECT_2(stat_F, stat_E);\n}\n\n\n/* evaluate Gamma(0,x), x > 0 */\n#define GAMMA_INC_A_0(x, result) gsl_sf_expint_E1_e(x, result)\n\n\n/*-*-*-*-*-*-*-*-*-*-*-* Functions with Error Codes *-*-*-*-*-*-*-*-*-*-*-*/\n\nint\ngsl_sf_gamma_inc_Q_e(const double a, const double x, gsl_sf_result * result)\n{\n if(a < 0.0 || x < 0.0) {\n DOMAIN_ERROR(result);\n }\n else if(x == 0.0) {\n result->val = 1.0;\n result->err = 0.0;\n return GSL_SUCCESS;\n }\n else if(a == 0.0)\n {\n result->val = 0.0;\n result->err = 0.0;\n return GSL_SUCCESS;\n }\n else if(x <= 0.5*a) {\n /* If the series is quick, do that. It is\n * robust and simple.\n */\n gsl_sf_result P;\n int stat_P = gamma_inc_P_series(a, x, &P);\n result->val = 1.0 - P.val;\n result->err = P.err;\n result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);\n return stat_P;\n }\n else if(a >= 1.0e+06 && (x-a)*(x-a) < a) {\n /* Then try the difficult asymptotic regime.\n * This is the only way to do this region.\n */\n return gamma_inc_Q_asymp_unif(a, x, result);\n }\n else if(a < 0.2 && x < 5.0) {\n /* Cancellations at small a must be handled\n * analytically; x should not be too big\n * either since the series terms grow\n * with x and log(x).\n */\n return gamma_inc_Q_series(a, x, result);\n }\n else if(a <= x) {\n if(x <= 1.0e+06) {\n /* Continued fraction is excellent for x >~ a.\n * We do not let x be too large when x > a since\n * it is somewhat pointless to try this there;\n * the function is rapidly decreasing for\n * x large and x > a, and it will just\n * underflow in that region anyway. We\n * catch that case in the standard\n * large-x method.\n */\n return gamma_inc_Q_CF(a, x, result);\n }\n else {\n return gamma_inc_Q_large_x(a, x, result);\n }\n }\n else {\n if(x > a - sqrt(a)) {\n /* Continued fraction again. The convergence\n * is a little slower here, but that is fine.\n * We have to trade that off against the slow\n * convergence of the series, which is the\n * only other option.\n */\n return gamma_inc_Q_CF(a, x, result);\n }\n else {\n gsl_sf_result P;\n int stat_P = gamma_inc_P_series(a, x, &P);\n result->val = 1.0 - P.val;\n result->err = P.err;\n result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);\n return stat_P;\n }\n }\n}\n\n\nint\ngsl_sf_gamma_inc_P_e(const double a, const double x, gsl_sf_result * result)\n{\n if(a <= 0.0 || x < 0.0) {\n DOMAIN_ERROR(result);\n }\n else if(x == 0.0) {\n result->val = 0.0;\n result->err = 0.0;\n return GSL_SUCCESS;\n }\n else if(x < 20.0 || x < 0.5*a) {\n /* Do the easy series cases. Robust and quick.\n */\n return gamma_inc_P_series(a, x, result);\n }\n else if(a > 1.0e+06 && (x-a)*(x-a) < a) {\n /* Crossover region. Note that Q and P are\n * roughly the same order of magnitude here,\n * so the subtraction is stable.\n */\n gsl_sf_result Q;\n int stat_Q = gamma_inc_Q_asymp_unif(a, x, &Q);\n result->val = 1.0 - Q.val;\n result->err = Q.err;\n result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);\n return stat_Q;\n }\n else if(a <= x) {\n /* Q <~ P in this area, so the\n * subtractions are stable.\n */\n gsl_sf_result Q;\n int stat_Q;\n if(a > 0.2*x) {\n stat_Q = gamma_inc_Q_CF(a, x, &Q);\n }\n else {\n stat_Q = gamma_inc_Q_large_x(a, x, &Q);\n }\n result->val = 1.0 - Q.val;\n result->err = Q.err;\n result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);\n return stat_Q;\n }\n else {\n if((x-a)*(x-a) < a) {\n /* This condition is meant to insure\n * that Q is not very close to 1,\n * so the subtraction is stable.\n */\n gsl_sf_result Q;\n int stat_Q = gamma_inc_Q_CF(a, x, &Q);\n result->val = 1.0 - Q.val;\n result->err = Q.err;\n result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);\n return stat_Q;\n }\n else {\n return gamma_inc_P_series(a, x, result);\n }\n }\n}\n\n\nint\ngsl_sf_gamma_inc_e(const double a, const double x, gsl_sf_result * result)\n{\n if(x < 0.0) {\n DOMAIN_ERROR(result);\n }\n else if(x == 0.0) {\n return gsl_sf_gamma_e(a, result);\n }\n else if(a == 0.0)\n {\n return GAMMA_INC_A_0(x, result);\n }\n else if(a > 0.0)\n {\n return gamma_inc_a_gt_0(a, x, result);\n }\n else if(x > 0.25)\n {\n /* continued fraction seems to fail for x too small; otherwise\n it is ok, independent of the value of |x/a|, because of the\n non-oscillation in the expansion, i.e. the CF is\n un-conditionally convergent for a < 0 and x > 0\n */\n return gamma_inc_CF(a, x, result);\n }\n else if(fabs(a) < 0.5)\n {\n return gamma_inc_series(a, x, result);\n }\n else\n {\n /* a = fa + da; da >= 0 */\n const double fa = floor(a);\n const double da = a - fa;\n\n gsl_sf_result g_da;\n const int stat_g_da = ( da > 0.0 ? gamma_inc_a_gt_0(da, x, &g_da)\n : GAMMA_INC_A_0(x, &g_da));\n\n double alpha = da;\n double gax = g_da.val;\n\n /* Gamma(alpha-1,x) = 1/(alpha-1) (Gamma(a,x) - x^(alpha-1) e^-x) */\n do\n {\n const double shift = exp(-x + (alpha-1.0)*log(x));\n gax = (gax - shift) / (alpha - 1.0);\n alpha -= 1.0;\n } while(alpha > a);\n\n result->val = gax;\n result->err = 2.0*(1.0 + fabs(a))*GSL_DBL_EPSILON*fabs(gax);\n return stat_g_da;\n }\n\n}\n\n\n/*-*-*-*-*-*-*-*-*-* Functions w/ Natural Prototypes *-*-*-*-*-*-*-*-*-*-*/\n\n#include \"eval.h\"\n\ndouble gsl_sf_gamma_inc_P(const double a, const double x)\n{\n EVAL_RESULT(gsl_sf_gamma_inc_P_e(a, x, &result));\n}\n\ndouble gsl_sf_gamma_inc_Q(const double a, const double x)\n{\n EVAL_RESULT(gsl_sf_gamma_inc_Q_e(a, x, &result));\n}\n\ndouble gsl_sf_gamma_inc(const double a, const double x)\n{\n EVAL_RESULT(gsl_sf_gamma_inc_e(a, x, &result));\n}\n", "meta": {"hexsha": "5ca728a56e5dad6771ac6f5bad67eb5ca5abdf46", "size": 18966, "ext": "c", "lang": "C", "max_stars_repo_path": "pkgs/libs/gsl/src/specfunc/gamma_inc.c", "max_stars_repo_name": "manggoguy/parsec-modified", "max_stars_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 64.0, "max_stars_repo_stars_event_min_datetime": "2015-03-06T00:30:56.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-24T13:26:53.000Z", "max_issues_repo_path": "pkgs/libs/gsl/src/specfunc/gamma_inc.c", "max_issues_repo_name": "manggoguy/parsec-modified", "max_issues_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 12.0, "max_issues_repo_issues_event_min_datetime": "2020-12-15T08:30:19.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-13T03:54:24.000Z", "max_forks_repo_path": "pkgs/libs/gsl/src/specfunc/gamma_inc.c", "max_forks_repo_name": "manggoguy/parsec-modified", "max_forks_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 40.0, "max_forks_repo_forks_event_min_datetime": "2015-02-26T15:31:16.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-03T23:23:37.000Z", "avg_line_length": 28.2232142857, "max_line_length": 109, "alphanum_fraction": 0.5651165243, "num_tokens": 6352, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7745833841649232, "lm_q2_score": 0.6825737408694988, "lm_q1q2_score": 0.5287102781448078}} {"text": "/* poly/zsolve.c\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n/* zsolve.c - finds the complex roots of = 0 */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n/* C-style matrix elements */\n#define MAT(m,i,j,n) ((m)[(i)*(n) + (j)])\n\n/* Fortran-style matrix elements */\n#define FMAT(m,i,j,n) ((m)[((i)-1)*(n) + ((j)-1)])\n\n#include \"companion.c\"\n#include \"balance.c\"\n#include \"qr.c\"\n\nint\ngsl_poly_complex_solve (const double *a, size_t n,\n gsl_poly_complex_workspace * w,\n gsl_complex_packed_ptr z)\n{\n int status;\n double *m;\n\n if (n == 0)\n {\n GSL_ERROR (\"number of terms must be a positive integer\", GSL_EINVAL);\n }\n\n if (n == 1)\n {\n GSL_ERROR (\"cannot solve for only one term\", GSL_EINVAL);\n }\n\n if (a[n - 1] == 0)\n {\n GSL_ERROR (\"leading term of polynomial must be non-zero\", GSL_EINVAL) ;\n }\n\n if (w->nc != n - 1)\n {\n GSL_ERROR (\"size of workspace does not match polynomial\", GSL_EINVAL);\n }\n \n m = w->matrix;\n\n set_companion_matrix (a, n - 1, m);\n\n balance_companion_matrix (m, n - 1);\n\n status = qr_companion (m, n - 1, z);\n\n if (status)\n {\n GSL_ERROR(\"root solving qr method failed to converge\", GSL_EFAILED);\n }\n\n return GSL_SUCCESS;\n}\n\n\n\n", "meta": {"hexsha": "aac231cc4c68d08557d66247665496b2022977d8", "size": 2130, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.6/poly/zsolve.c", "max_stars_repo_name": "ielomariala/Hex-Game", "max_stars_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-12-18T18:09:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-10T11:31:28.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/poly/zsolve.c", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-12-16T17:41:24.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-22T00:00:16.000Z", "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/poly/zsolve.c", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 14.0, "max_forks_repo_forks_event_min_datetime": "2015-07-21T04:47:52.000Z", "max_forks_repo_forks_event_max_datetime": "2020-03-12T12:31:25.000Z", "avg_line_length": 24.7674418605, "max_line_length": 81, "alphanum_fraction": 0.6450704225, "num_tokens": 594, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8244619350028204, "lm_q2_score": 0.640635868562172, "lm_q1q2_score": 0.5281798878269809}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\nvoid\nfastpm_horizon_init(FastPMHorizon * horizon, FastPMCosmology * cosmology)\n{\n gsl_set_error_handler_off(); // Turn off GSL error handler\n\n horizon->cosmology = cosmology;\n horizon->size = 8192;\n horizon->da = 1.0 / (horizon->size - 1);\n int i;\n for (i = 0; i < horizon->size; i ++) {\n double a = 1.0 * i / (horizon->size - 1);\n horizon->xi_a[i] = HubbleDistance * ComovingDistance(a, horizon->cosmology);\n FastPMGrowthInfo gi;\n fastpm_growth_info_init(&gi, a, horizon->cosmology);\n horizon->growthfactor_a[i] = gi.D1;\n }\n}\n\nvoid\nfastpm_horizon_destroy(FastPMHorizon * horizon)\n{\n}\n\ndouble\nHorizonDistance(double a, FastPMHorizon * horizon)\n{\n double x = a * (horizon->size - 1);\n int l = floor(x);\n int r = l + 1;\n if(r >= horizon->size) {\n return horizon->xi_a[horizon->size - 1];\n }\n if(l <= 0) {\n return horizon->xi_a[0];\n }\n return horizon->xi_a[l] * (r - x)\n + horizon->xi_a[r] * (x - l);\n}\n\ndouble\nHorizonGrowthFactor(double a, FastPMHorizon * horizon)\n{\n double x = a * (horizon->size - 1);\n int l = floor(x);\n int r = l + 1;\n if(r >= horizon->size) {\n return horizon->growthfactor_a[horizon->size - 1];\n }\n if(l <= 0) {\n return horizon->growthfactor_a[0];\n }\n return horizon->growthfactor_a[l] * (r - x)\n + horizon->growthfactor_a[r] * (x - l);\n}\n\nvoid *\nfastpm_horizon_solve_start()\n{\n const gsl_root_fsolver_type *T = gsl_root_fsolver_brent;\n return gsl_root_fsolver_alloc(T);\n}\n\nvoid\nfastpm_horizon_solve_end(void * context)\n{\n gsl_root_fsolver_free(context);\n}\n\nint\nfastpm_horizon_solve(FastPMHorizon * horizon,\n void * context,\n double * solution,\n double a_i, double a_f,\n double (*func)(double a, void * userdata),\n void * userdata)\n{\n\n int status;\n int iter = 0, max_iter;\n double r, x_lo=a_i, x_hi=a_f, eps;\n\n /* Reorganize to struct later */\n max_iter = 20;\n eps = 1e-5;\n\n gsl_function F;\n\n F.function = func;\n F.params = userdata;\n\n status = gsl_root_fsolver_set(context, &F, x_lo, x_hi);\n\n if(status == GSL_EINVAL || status == GSL_EDOM) {\n /** Error in value or out of range **/\n return 0;\n }\n\n do\n {\n iter++;\n //\n // Debug printout #1\n //if(iter == 1) {\n //fastpm_info(\"ID | [x_lo, x_hi] | r | funct(r) | x_hi - x_lo\\n\");\n //}\n //\n\n status = gsl_root_fsolver_iterate(context);\n r = gsl_root_fsolver_root(context);\n\n x_lo = gsl_root_fsolver_x_lower(context);\n x_hi = gsl_root_fsolver_x_upper(context);\n\n status = gsl_root_test_interval(x_lo, x_hi, eps, 0.0);\n //\n //Debug printout #2\n //fastpm_info(\"%5d [%.7f, %.7f] %.7f %.7f %.7f\\n\", iter, x_lo, x_hi, r, funct(r, ¶ms), x_hi - x_lo);\n //\n\n if(status == GSL_SUCCESS || iter == max_iter ) {\n *solution = r;\n //\n // Debug printout #3.1\n //fastpm_info(\"fastpm_lc_intersect() called with parameters %.7f and %.7f, returned status %d.\\n\\n\", a, b, 1);\n //\n return 1;\n }\n }\n while (status == GSL_CONTINUE);\n //\n // Debug printout #3.2\n //fastpm_info(\"fastpm_lc_intersect() called with parameters %.7f and %.7f, returned status %d.\\n\\n\", a, b, 0);\n //\n\n return 0;\n\n}\n", "meta": {"hexsha": "8a0620a8afe4aa03df702cc7b2bb2607dda1b826", "size": 3574, "ext": "c", "lang": "C", "max_stars_repo_path": "fastpm/libfastpm/horizon.c", "max_stars_repo_name": "sbird/FastPMRunner", "max_stars_repo_head_hexsha": "f38f6e69c603fb699436b645fe7b4eb418ee82c2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "fastpm/libfastpm/horizon.c", "max_issues_repo_name": "sbird/FastPMRunner", "max_issues_repo_head_hexsha": "f38f6e69c603fb699436b645fe7b4eb418ee82c2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4.0, "max_issues_repo_issues_event_min_datetime": "2021-04-19T23:01:33.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-24T05:51:04.000Z", "max_forks_repo_path": "fastpm/libfastpm/horizon.c", "max_forks_repo_name": "sbird/FastPMRunner", "max_forks_repo_head_hexsha": "f38f6e69c603fb699436b645fe7b4eb418ee82c2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2021-04-14T23:24:19.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-14T23:24:19.000Z", "avg_line_length": 24.3129251701, "max_line_length": 122, "alphanum_fraction": 0.580581981, "num_tokens": 1075, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8152324893519999, "lm_q2_score": 0.647798211152541, "lm_q1q2_score": 0.5281061482756585}} {"text": "//\n// trmm.h\n// Linear Algebra Template Library\n//\n// Created by Rodney James on 1/4/12.\n// Copyright (c) 2012 University of Colorado Denver. All rights reserved.\n//\n\n#ifndef _trmm_h\n#define _trmm_h\n\n/// @file trmm.h Performs multiplication of a triangular matrix with a rectangular matrix.\n\n#include \n#include \"latl.h\"\n\nnamespace LATL\n{ \n /// @brief Performs multiplication of a real triangular matrix with a real rectangular matrix.\n /// \n /// For a real upper or lower triangular matrix A, real rectangular matrix B and real scalar alpha,\n ///\n /// B := alpha*A*B or B := alpha*A'*B or B := alpha*B*A or B := alpha*B*A'\n /// is computed.\n /// @return 0 if success.\n /// @return -i if the ith argument is invalid.\n /// @tparam real_t Floating point type.\n /// @param side Specifies whether the matrix A appears on the left or right side as follows:\n ///\n /// if side = 'L' or 'l' then B := alpha*A*B or alpha*A'*B\n /// if side = 'R' or 'r' then C := alpha*B*A or alpha*B*A'\n /// @param uplo Specifies whether A is stored as upper or lower triangular.\n ///\n /// if uplo = 'U' or 'u' then A is upper triangular\n /// if uplo = 'L' or 'l' then A is lower triangular\n /// @param trans Specifies wheather the transpose of A is to be used or not:\n ///\n /// if trans = 'N' or 'n' then B := alpha*A*B or alpha*B*A\n /// if trans = 'T' or 't' then B := alpha*A'*B or alpha*B*A'\n /// if trans = 'C' or 'c' then B := alpha*A'*B or alpha*B*A'\n /// @param diag specifies whether or not A is unit triangular as follows:\n ///\n /// if diag = 'U' or 'u' then A is assumed to be unit triangular\n /// if diag = 'N' or 'n' then A is not assumed to be unit triangular.\n /// If A is unit triangular, the diagonal elements are assumed to be unity and are not referenced.\n /// @param m Specifies the number of rows of the matrix B. m>=0\n /// @param n Specifies the number of columns of the matrix B. n>=0\n /// @param alpha Real scalar.\n /// @param A Pointer to real triangular matrix A. The order of A is n if side = 'L' or 'l';\n /// the order of A is m is side = 'R' or 'r'.\n /// If uplo = 'U' or 'u, A is upper triangular and the lower triangular part is not referenced. \n /// If uplo = 'L' or 'l A is lower triangular and the upper triangular part is not referenced.\n /// @param ldA Column length of the matrix A. If side='L' or 'l' then ldA>=n; if side='R' or 'r' then lda>=m.\n /// @param B Pointer to real m-by-n matrix B.\n /// @param ldB Column length of the matrix B. ldB>=m.\n /// @ingroup BLAS\n\n template \n int TRMM(char side, char uplo, char trans, char diag, int_t m, int_t n, real_t alpha, real_t *A, int_t ldA, real_t *B, int_t ldB)\n {\n using std::toupper;\n \n const real_t zero(0.0);\n int_t i,j,k;\n real_t *a,*b,*bt;\n real_t t;\n \n side=toupper(side);\n uplo=toupper(uplo);\n trans=toupper(trans);\n diag=toupper(diag);\n \n if((side!='L')&&(side!='R'))\n return -1;\n else if((uplo!='U')&&(uplo!='L'))\n return -2;\n else if((trans!='N')&&(trans!='T')&&(trans!='C'))\n return -3;\n else if((diag!='U')&&(diag!='N'))\n return -4;\n else if(m<0)\n return -5;\n else if(n<0)\n return -6;\n else if(ldA<((side=='L')?m:n))\n return -9;\n else if(ldB=0;k--)\n {\n a-=ldA;\n t=alpha*b[k];\n b[k]=t;\n if(nounit)\n b[k]*=a[k];\n for(i=k+1;i=0;i--)\n {\n a-=ldA;\n t=b[i];\n if(nounit)\n t*=a[i];\n for(k=0;k=0;j--)\n {\n a-=ldA;\n b-=ldB;\n if(nounit)\n t=alpha*a[j];\n else\n t=alpha;\n for(i=0;i=0;k--)\n {\n a-=ldA;\n bt-=ldB;\n b=B+(k+1)*ldB;\n for(j=k+1;j=0\n /// @param n Specifies the number of columns of the matrix B. n>=0\n /// @param alpha Complex scalar.\n /// @param A Pointer to complex triangular matrix A. The order of A is n if side = 'L' or 'l';\n /// the order of A is m is side = 'R' or 'r'.\n /// If uplo = 'U' or 'u, A is upper triangular and the lower triangular part is not referenced. \n /// If uplo = 'L' or 'l A is lower triangular and the upper triangular part is not referenced.\n /// @param ldA Column length of the matrix A. If side='L' or 'l' then ldA>=n; if side='R' or 'r' then lda>=m.\n /// @param B Pointer to complex m-by-n matrix B.\n /// @param ldB Column length of the matrix B. ldB>=m.\n /// @ingroup BLAS\n\n template \n int TRMM(char side, char uplo, char trans, char diag, int_t m, int_t n, complex alpha, complex *A, int_t ldA, complex *B, int_t ldB)\n {\n using std::conj;\n using std::toupper;\n \n const complex zero(0.0,0.0);\n int_t i,j,k;\n complex *a,*b,*bt;\n complex t;\n \n side=toupper(side);\n uplo=toupper(uplo);\n trans=toupper(trans);\n diag=toupper(diag);\n \n if((side!='L')&&(side!='R'))\n return -1;\n else if((uplo!='U')&&(uplo!='L'))\n return -2;\n else if((trans!='N')&&(trans!='T')&&(trans!='C'))\n return -3;\n else if((diag!='U')&&(diag!='N'))\n return -4;\n else if(m<0)\n return -5;\n else if(n<0)\n return -6;\n else if(ldA<((side=='L')?m:n))\n return -9;\n else if(ldB=0;k--)\n {\n a-=ldA;\n t=alpha*b[k];\n b[k]=t;\n if(nounit)\n b[k]*=a[k];\n for(i=k+1;i=0;i--)\n {\n a-=ldA;\n t=b[i];\n if(nounit)\n t*=a[i];\n for(k=0;k=0;i--)\n {\n a-=ldA;\n t=b[i];\n if(nounit)\n t*=conj(a[i]);\n for(k=0;k=0;j--)\n {\n a-=ldA;\n b-=ldB;\n if(nounit)\n t=alpha*a[j];\n else\n t=alpha;\n for(i=0;i=0;k--)\n {\n a-=ldA;\n bt-=ldB;\n b=B+(k+1)*ldB;\n for(j=k+1;j=0;k--)\n {\n a-=ldA;\n bt-=ldB;\n b=B+(k+1)*ldB;\n for(j=k+1;j\n\n template <> int TRMM(char side, char uplo, char trans, char diag, int_t m, int_t n, float alpha, float *A, int_t ldA, float *B, int_t ldB)\n {\n using std::toupper;\n side=toupper(side);\n uplo=toupper(uplo);\n trans=toupper(trans);\n diag=toupper(diag);\n\n if((side!='L')&&(side!='R'))\n return -1;\n else if((uplo!='U')&&(uplo!='L'))\n return -2;\n else if((trans!='N')&&(trans!='T')&&(trans!='C'))\n return -3;\n else if((diag!='U')&&(diag!='N'))\n return -4;\n else if(m<0)\n return -5;\n else if(n<0)\n return -6;\n else if(ldA<((side=='L')?m:n))\n return -9;\n else if(ldB int TRMM(char side, char uplo, char trans, char diag, int_t m, int_t n, double alpha, double *A, int_t ldA, double *B, int_t ldB)\n {\n using std::toupper;\n side=toupper(side);\n uplo=toupper(uplo);\n trans=toupper(trans);\n diag=toupper(diag);\n\n if((side!='L')&&(side!='R'))\n return -1;\n else if((uplo!='U')&&(uplo!='L'))\n return -2;\n else if((trans!='N')&&(trans!='T')&&(trans!='C'))\n return -3;\n else if((diag!='U')&&(diag!='N'))\n return -4;\n else if(m<0)\n return -5;\n else if(n<0)\n return -6;\n else if(ldA<((side=='L')?m:n))\n return -9;\n else if(ldB int TRMM(char side, char uplo, char trans, char diag, int_t m, int_t n, complex alpha, complex *A, int_t ldA, complex *B, int_t ldB)\n {\n using std::toupper;\n side=toupper(side);\n uplo=toupper(uplo);\n trans=toupper(trans);\n diag=toupper(diag);\n\n if((side!='L')&&(side!='R'))\n return -1;\n else if((uplo!='U')&&(uplo!='L'))\n return -2;\n else if((trans!='N')&&(trans!='T')&&(trans!='C'))\n return -3;\n else if((diag!='U')&&(diag!='N'))\n return -4;\n else if(m<0)\n return -5;\n else if(n<0)\n return -6;\n else if(ldA<((side=='L')?m:n))\n return -9;\n else if(ldB int TRMM(char side, char uplo, char trans, char diag, int_t m, int_t n, complex alpha, complex *A, int_t ldA, complex *B, int_t ldB)\n {\n using std::toupper;\n side=toupper(side);\n uplo=toupper(uplo);\n trans=toupper(trans);\n diag=toupper(diag);\n\n if((side!='L')&&(side!='R'))\n return -1;\n else if((uplo!='U')&&(uplo!='L'))\n return -2;\n else if((trans!='N')&&(trans!='T')&&(trans!='C'))\n return -3;\n else if((diag!='U')&&(diag!='N'))\n return -4;\n else if(m<0)\n return -5;\n else if(n<0)\n return -6;\n else if(ldA<((side=='L')?m:n))\n return -9;\n else if(ldB\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n// Uncomment this to use the cminpack library for the least-squares\n// fitting, otherwise we will use the cmpfit library provided. \n//#define WITH_CMINPACK\n\n#define MM_ECHG 1.602176634e-19 // Electron charge (SI units).\n#define MM_BOLTZ 1.3806226e-23 // Boltzmann constant (SI units).\n\nusing namespace std;\n\nclass mmjco\n{\npublic:\n // Constructor/destructor.\n mmjco(double, double, double, double);\n ~mmjco();\n\n // Functions return values for arbitrary x (values x<0 obtained by\n // symmetry), not smoothed.\n\n complex Jpair(double x)\n {\n double absx = maximum(fabs(x), 1e-5);\n return (Repair(absx) + sign(x)*1j*Impair(absx));\n }\n\n complex Jqp(double x)\n {\n double absx = maximum(fabs(x), 1e-5);\n return (Reqp(absx) + sign(x)*1j*Imqp(absx));\n }\n\n // As above, but smoothed.\n\n complex Jpair_smooth(double x)\n {\n return (Jpair(x) + Jpair_correction(x));\n }\n\n complex Jqp_smooth(double x)\n {\n return (Jqp(x) + Jqp_correction(x));\n }\n\n // Utilities.\n\n static double sign(double x)\n {\n if (x > 0.0)\n return (1.0);\n if (x == 0.0)\n return (0.0);\n return (-1.0);\n }\n\n static double minimum(double x, double y) { return (x < y ? x : y); }\n static double maximum(double x, double y) { return (x > y ? x : y); }\n\n static void save_data(const char*, const double*, const complex*,\n const complex*, int);\n\n static const char *version() { return (mm_version); }\n\nprivate:\n double Repair(double);\n double Impair(double);\n double Reqp(double);\n double Imqp(double);\n\n double Repair_integrand_part1(double y, double x)\t\n {\n return (tanh(mm_b*fabs(y))/\n ( sqrt(mm_dd1-(y-x)*(y-x)) * sqrt(y*y-mm_dd2) ));\n }\n\n double Repair_integrand_part2(double y, double x)\n {\n return (tanh(mm_b*fabs(y))/\n ( sqrt(y*y-mm_dd1) * sqrt(mm_dd2-(y+x)*(y+x)) ));\n }\n\n double Impair_integrand(double y, double x)\n {\n return (( tanh(mm_b*(y+x)) - tanh(mm_b*y) )*sign(y)*sign(y+x)/(\n sqrt(y*y-mm_dd1) * sqrt((y+x)*(y+x)-mm_dd2) ));\n }\n\n double Reqp_integrand_part1(double y, double x)\n {\n return (fabs(y)*tanh(mm_b*y)*(y-x)/( sqrt(y*y-mm_dd1) *\n sqrt(mm_dd2-(y-x)*(y-x)) ));\n }\n\n double Reqp_integrand_part1b_d1_xd2(double y, double x)\n {\n return (fabs(y)*tanh(mm_b*y)*(y-x)/sqrt((y+mm_d1)*(mm_d2+y-x)));\n }\n\n double Reqp_integrand_part1b_xd2_xd2(double y, double x)\n {\n return (fabs(y)*tanh(mm_b*y)*(y-x)/sqrt(y*y-mm_dd1));\n }\n\n double Reqp_integrand_part2_xd1_d2(double y, double x)\n {\n return (fabs(y)*tanh(mm_b*y)*(y+x)/sqrt((mm_d1-y-x)*(mm_d2-y)));\n }\n\n double Reqp_integrand_part2_xd1_xd1(double y, double x)\n {\n return (fabs(y)*tanh(mm_b*y)*(y+x)/sqrt(y*y-mm_dd2));\n }\n\n double Imqp_integrand(double y, double x)\n {\n return (( tanh(mm_b*(y+x))-tanh(mm_b*y) )*fabs(y)*fabs(y+x)/\n ( sqrt((y+x)*(y+x)-mm_dd1) * sqrt(y*y-mm_dd2) ));\n }\n\n // Passed to integration functions.\n\n static double re_p_i1(double x, void *ptr)\n {\n mmjco *m = (mmjco*)ptr; \n return (m->Repair_integrand_part1(x, m->mm_arg));\n }\n\n static double re_p_i2(double x, void *ptr)\n {\n mmjco *m = (mmjco*)ptr; \n return (m->Repair_integrand_part2(x, m->mm_arg));\n }\n\n static double im_p_i(double x, void *ptr)\n {\n mmjco *m = (mmjco*)ptr; \n return (m->Impair_integrand(x, m->mm_arg));\n }\n\n static double re_q_i1(double x, void *ptr)\n {\n mmjco *m = (mmjco*)ptr; \n return (m->Reqp_integrand_part1(x, m->mm_arg));\n }\n\n static double re_q_i1b1x2(double x, void *ptr)\n {\n mmjco *m = (mmjco*)ptr; \n return (m->Reqp_integrand_part1b_d1_xd2(x, m->mm_arg));\n }\n\n static double re_q_i1bx2x2(double x, void *ptr)\n {\n mmjco *m = (mmjco*)ptr; \n return (m->Reqp_integrand_part1b_xd2_xd2(x, m->mm_arg));\n }\n\n static double re_q_i2x12(double x, void *ptr)\n {\n mmjco *m = (mmjco*)ptr; \n return (m->Reqp_integrand_part2_xd1_d2(x, m->mm_arg));\n }\n\n static double re_q_i2x1x1(double x, void *ptr)\n {\n mmjco *m = (mmjco*)ptr; \n return (m->Reqp_integrand_part2_xd1_xd1(x, m->mm_arg));\n }\n\n static double im_q_i(double x, void *ptr)\n {\n mmjco *m = (mmjco*)ptr; \n return (m->Imqp_integrand(x, m->mm_arg));\n }\n\n // Smoothing.\n\n complex Jpair_correction(double x)\n {\n if (mm_symj) {\n double absx = maximum(fabs(x),1.e-5);\n return (dRe(absx) + sign(x)*1j*(dIm(absx) + dIm_at_0(absx)));\n }\n else {\n double absx = maximum(fabs(x),1.e-5);\n return (dRe(absx) + dRe_minus(absx) + sign(x)*1j*(dIm(absx) +\n dIm_minus(absx)));\n }\n }\n\n complex Jqp_correction(double x)\n {\n\n if (mm_symj) {\n double absx = maximum(fabs(x),1.e-5);\n return (dRe(absx) + sign(x)*1j*(-dIm(absx) + dIm_at_0(absx)));\n }\n else {\n double absx = maximum(fabs(x),1.e-5);\n return (dRe(absx) - dRe_minus(absx) + sign(x)*1j*(-dIm(absx) +\n dIm_minus(absx)));\n }\n }\n\n // Smoothing for Repair, Reqp.\n double dRe(double x)\n {\n double sqpos = (x-1.0)*(x-1.0);\n double sqneg = (x+1.0)*(x+1.0);\n return (-x*(1.0/M_PI)*mm_ip0*0.5*log(\n ((sqpos+mm_dsm*mm_dsm)/sqpos)*(sqneg/(sqneg+mm_dsm*mm_dsm)) ));\n }\n\n // Smoothing for Repair, -Reqp at x=mm_d2-mm_d1. \n double dRe_minus(double x)\n {\n return (M_PI*x*sqrt(mm_d1*mm_d2)*\n (tanh(mm_b*mm_d2)-tanh(mm_b*mm_d1)) *\n 0.5*( (2.0/M_PI)*atan((x-mm_d21)/mm_dsm) \n - sign(x-mm_d21) + (2.0/M_PI)*atan((x+mm_d21)/mm_dsm) -\n sign(x+mm_d21) ) / (4.0*mm_d21));\n }\n\n // Smoothing for Impair, Imqp at x=mm_d2-mm_d1.\n double dIm_minus(double x)\n {\n double square1 = (x-mm_d21)*(x-mm_d21);\n double square2 = (x+mm_d21)*(x+mm_d21);\n return (-x*sqrt(mm_d1*mm_d2)*(tanh(mm_b*mm_d2)-tanh(mm_b*mm_d1))*\n 0.5*log((square1+mm_dsm*mm_dsm)*(square2+mm_dsm*mm_dsm)/\n (square1*square2)) / (4.0*mm_d21));\n }\n\n // Smoothing for Impair, -Imqp.\n double dIm(double x)\n {\n return (x*0.5*mm_ip0*((2.0/M_PI)*atan((1.0-x)/mm_dsm) -\n sign(1.0-x) + (2.0/M_PI)*atan((1.0+x)/mm_dsm) - sign(1.0+x)));\n }\n\n // Smoothing for Impair, Imqp at mm_d2-mm_d1=0.\n double dIm_at_0(double x)\n {\n double x2=x*x;\n return (-mm_b*x*mm_expb*0.5*log(\n (x2+mm_dsm*mm_dsm)/x2)/((mm_expb+1.0)*(mm_expb+1.0)));\n }\n\n static const char *mm_version;\n\n double mm_d1, mm_d2;\n double mm_d21;\n double mm_dd1, mm_dd2;\n double mm_b;\n double mm_arg;\n int mm_limit;\n int mm_key;\n double mm_epsabs;\n double mm_epsrel;\n gsl_integration_workspace *mm_ws;\n gsl_integration_qaws_table *mm_tbl;\n\n // Smoothing.\n double mm_expb;\n double mm_ip0;\n double mm_dsm;\n bool mm_symj;;\n};\n\n\n//\n// Class to compute optimized TCA fitting parameters.\n//\n\n// Largest acceptable fitting table.\n#define MAX_NTERMS 20\n\nclass mmjco_fit\n{\npublic:\n struct mm_adata\n {\n const double *x;\n double thr;\n const complex *Jpair_data;\n const complex *Jqp_data;\n };\n\n mmjco_fit()\n {\n mmf_pAB = 0;\n mmf_nterms = 0;\n }\n\n ~mmjco_fit()\n {\n delete [] mmf_pAB;\n }\n\n void new_fit_parameters(const double*, const complex*,\n const complex*, int, int, double);\n void save_fit_parameters(const char*);\n void load_fit_parameters(const char*);\n void tca_fit(const double*, int, complex**, complex**);\n double residual(const complex*, const complex*,\n const complex*, const complex*, int, double);\n\n const complex *params() const { return (mmf_pAB); }\n int numterms() const { return (mmf_nterms); }\n\nprivate:\n static complex *modelJpair(const complex*, int,\n const double*, int);\n static complex *modelJqp(const complex*, int,\n const double*, int);\n\n static double rep(double zeta) { return (-fabs(zeta)); }\n static double invrep(double xi) { return (-xi); }\n\n // Relative difference with threshold thr.\n static double Drel(double X, double Xref, double thr)\n {\n double axref = fabs(Xref);\n if (thr > axref)\n axref = thr;\n return (fabs(X-Xref)/axref);\n }\n\n // Flatten complex array.\n static double *realimag(complex *carray, int sz)\n {\n double *param_list = new double[2*sz];\n for (int i = 0; i < sz; i++) {\n param_list[i*2] = carray[i].real();\n param_list[i*2+1] = carray[i].imag();\n }\n return (param_list);\n }\n\n // Form complex array.\n static complex *ccombine(const double *param_list, int plsz)\n {\n complex *cpars = new complex[plsz/2];\n for (int i = 0; i < plsz; i++) {\n int n = i/2;\n if (i & 1)\n cpars[n].imag(param_list[i]);\n else\n cpars[n].real(param_list[i]);\n }\n return (cpars);\n }\n\n#ifdef WITH_CMINPACK\n static int func(void*, int, int, const double*, double*, int);\n#else\n static int func(int, int, double*, double*, double**, void*);\n#endif\n\n complex *mmf_pAB;\n int mmf_nterms;\n};\n\n#endif // MMJCO_H\n\n", "meta": {"hexsha": "39f8292bb4bda46806a0b67e46867f89e78a1d0c", "size": 11124, "ext": "h", "lang": "C", "max_stars_repo_path": "wrspice/mmjco/mmjco.h", "max_stars_repo_name": "wrcad/xictools", "max_stars_repo_head_hexsha": "f46ba6d42801426739cc8b2940a809b74f1641e2", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 73.0, "max_stars_repo_stars_event_min_datetime": "2017-10-26T12:40:24.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-02T16:59:43.000Z", "max_issues_repo_path": "wrspice/mmjco/mmjco.h", "max_issues_repo_name": "markvolkmann/xictools", "max_issues_repo_head_hexsha": "5d32ad130cfd13f4e5ecaae7701f2863b4558f4e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 12.0, "max_issues_repo_issues_event_min_datetime": "2017-11-01T10:18:22.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-20T19:35:36.000Z", "max_forks_repo_path": "wrspice/mmjco/mmjco.h", "max_forks_repo_name": "markvolkmann/xictools", "max_forks_repo_head_hexsha": "5d32ad130cfd13f4e5ecaae7701f2863b4558f4e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 34.0, "max_forks_repo_forks_event_min_datetime": "2017-10-06T17:04:21.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-18T16:22:03.000Z", "avg_line_length": 28.6701030928, "max_line_length": 79, "alphanum_fraction": 0.5249011147, "num_tokens": 3214, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8740772253241803, "lm_q2_score": 0.6039318337259584, "lm_q1q2_score": 0.5278830615081299}} {"text": "/* Implementation for next reaction method */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"ssa.h\"\n#include \"nrm.h\"\n#include \"priorityq.h\"\n#include \"depgraph.h\"\n\n\nconst gsl_rng_type *SSARNGT;\ngsl_rng *SSARNG;\n\n\nvoid update_reaction(REACTION *r, SYSTEM *s, double t)\n{\n\tdouble newp = ssa_h(s->R[r->number], s->x, s->n) * s->k[r->number];\n\tdouble oldp = s->propensities[r->number];\n\n\tif (newp > 0.0) {\n\t\tif (oldp > 0.0) {\n\t\t\tpq_update(s->pq, r, (oldp / newp) * (r->tau - t) + t);\n\t\t} else {\n\t\t\tr->tau = gsl_ran_gamma(SSARNG, s->steps[r->number], 1 / newp) + t;\n\t\t\tpq_insert(s->pq, r);\n\t\t}\n\t} else if (oldp > 0.0) {\n\t\tpq_delete(s->pq, r);\n\t}\n\n\ts->propensities[r->number] = newp;\n}\n\n\ndouble ssa_nrmstep(SYSTEM *s)\n{\n\tREACTION *r = pq_min(s->pq);\n ssa_doreaction(s->R[r->number], s->P[r->number], s->x, s->n);\n\tdouble t = r->tau;\n\t\n\ts->propensities[r->number] = ssa_h(s->R[r->number], s->x, s->n) * s->k[r->number];\n\tif (s->propensities[r->number] > 0.0)\n\t\tpq_update(s->pq, r, gsl_ran_gamma(SSARNG, s->steps[r->number], 1 / s->propensities[r->number]) + t);\n\telse\n\t\tpq_delete(s->pq, r);\n\t\n\tLLIST *head = r->affects;\n\twhile (head != NULL) {\n\t\tREACTION *update = (REACTION *) head->data;\n\t\tupdate_reaction(update, s, t);\n\t\thead = head->next;\n\t}\n\n\treturn t;\n}\n\n\nREACTION **setup_reactions(SYSTEM *s)\n{\n\tREACTION **reactions = malloc(sizeof(REACTION*) * s->m);\n\tchar **adjmat = adjacencymatrix(s->R, s->P, s->n, s->m);\n\t\n\tINDEX i, j;\n\tfor (i = 0; i < s->m; i++) {\n\t\tREACTION *reaction = reaction_make(i);\n\t\treactions[i] = reaction;\n\t}\n\t\n\tfor (i = 0; i < s->m; i++) {\n\t\tREACTION *r = reactions[i];\n\t\tfor (j = 0; j < s->m; j++)\n\t\t\tif (i != j && adjmat[i][j] != 0)\n\t\t\t\tr->affects = llist_push(r->affects, reactions[j]);\n\t}\n\n for (i = 0; i < s->m; i++) {\n\t\tREACTION *r = reactions[i];\n\t\tfor (j = 0; j < s->m; j++) {\n\t\t\tif (s->creates[i][j] != 0)\n\t\t\t\tr->creates = llist_push(r->creates, reactions[j]);\n if (s->destroys[i][j] != 0)\n r->destroys = llist_push(r->destroys, reactions[j]);\n }\n\t}\n\n\tfor (i = 0; i < s->m; i++)\n\t\tfree(adjmat[i]);\n\t\n\tfree(adjmat);\n\treturn reactions;\n}\n\n\nvoid ssa_nrm(INDEX **R, INDEX **P, INDEX n, INDEX m, double *k, COUNT *x, COUNT *steps, INDEX **creates, INDEX **destroys, double T)\n{\n\tgsl_rng_env_setup();\n\tSSARNGT = gsl_rng_default;\n\tSSARNG = gsl_rng_alloc(SSARNGT);\n\tgsl_rng_set(SSARNG, time(NULL));\n\n SYSTEM *s = malloc(sizeof(SYSTEM));\n\ts->m = m;\n s->n = n;\n s->R = R;\n s->P = P;\n s->creates = creates;\n s->destroys = destroys;\n\n\tREACTION **reactions = setup_reactions(s);\n\tdouble *propensities = malloc(sizeof(double) * m);\n\tPQ *pq = pq_make();\n\n s->pq = pq;\n s->x = x;\n s->steps = steps;\n s->k = k;\n s->propensities = propensities;\n\t\n\tINDEX i;\n\tfor (i = 0; i < m; i++) {\n\t\tREACTION *r = reactions[i];\n\t\tpropensities[i] = ssa_h(R[i], x, n) * k[i];\n\t\tif (propensities[i] > 0.0) {\n\t\t\tr->tau = gsl_ran_gamma(SSARNG, steps[i], 1 / propensities[i]);\n\t\t\tpq_insert(pq, r);\n\t\t}\n\t}\n\n\tssa_printstate(0.0, x, n);\n\t\n\twhile(!pq_isempty(pq) && pq_min(pq)->tau < T)\n\t\tssa_printstate(ssa_nrmstep(s), x, n);\n\n\tpq_free(pq);\n\tgsl_rng_free(SSARNG);\n}\n", "meta": {"hexsha": "24590755176c68344b33d7b986a4ded1f1e90108", "size": 3346, "ext": "c", "lang": "C", "max_stars_repo_path": "lib/src/nrm.c", "max_stars_repo_name": "lgrozinger/ssapy", "max_stars_repo_head_hexsha": "f8366e11609bdaa0bb7997dc4177d6e6a5eabeb9", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lib/src/nrm.c", "max_issues_repo_name": "lgrozinger/ssapy", "max_issues_repo_head_hexsha": "f8366e11609bdaa0bb7997dc4177d6e6a5eabeb9", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "lib/src/nrm.c", "max_forks_repo_name": "lgrozinger/ssapy", "max_forks_repo_head_hexsha": "f8366e11609bdaa0bb7997dc4177d6e6a5eabeb9", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 23.2361111111, "max_line_length": 132, "alphanum_fraction": 0.5660490137, "num_tokens": 1200, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.793105951184112, "lm_q2_score": 0.6654105454764747, "lm_q1q2_score": 0.5277410635980583}} {"text": "/**\n * Copyright 2019 José Manuel Abuín Mosquera \n * \n * This file is part of Matrix Market Suite.\n *\n * Matrix Market Suite is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * Matrix Market Suite is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with Matrix Market Suite. If not, see .\n */\n\n#include \n#include \n#include \n#include \n\n#include \"ConjugateGradient.h\"\n#include \"ConjugateGradientSolver.h\"\n#include \"ConjugateGradientSolverBasic.h\"\n\n/* Include redundant execution header. */\n#include \"../../../include/ourRMTlib.h\"\n\nvoid usageConjugateGradient(){\n\n\tfprintf(stderr, \"\\n\");\n\tfprintf(stderr, \"Usage: MM-Suite ConjugateGradient [options] \\n\");\n\tfprintf(stderr, \"Algorithm options:\\n\\n\");\n\tfprintf(stderr, \" -i INT Iteration number. Default: number of matrix rows * 2\\n\");\n\tfprintf(stderr, \" -b Uses basic operations instead of optimized BLAS libraries. Default: False\\n\");\n\tfprintf(stderr, \"\\nInput/output options:\\n\\n\");\n\tfprintf(stderr, \" -o STR Output file name. Default: stdout\\n\");\n\tfprintf(stderr, \" -r Input format is row per line. Default: False\\n\");\n\tfprintf(stderr, \"\\nPerformance options:\\n\\n\");\n\tfprintf(stderr, \" -t INT Number of threads to use in OpenBLAS. Default: 1\\n\");\n\tfprintf(stderr, \"\\n\");\n\n}\n\n//int ConjugateGradient(int argc, char *argv[]) {\nint main(int argc, char *argv[]) {\n\n\tint \t\t\tret_code;\n\tint \t\t\toption;\n\t\n\tunsigned long \t\t*II;\n\tunsigned long \t\t*J;\n\tdouble \t\t\t*A;\n\t\n\tunsigned long \t\tM;\n\tunsigned long \t\tN;\n\tunsigned long long \tnz;\n\t\n\t\n\tdouble \t\t\t*b;\n\tunsigned long \t\tM_Vector;\n\tunsigned long \t\tN_Vector;\n\tunsigned long long \tnz_vector;\n\t\n\tchar\t\t\t*outputFileName = NULL;\n\tint\t\t\titerationNumber = 0;\n\t\n\tchar\t\t\t*inputMatrixFile = NULL;\n\tchar\t\t\t*inputVectorFile = NULL;\n\t\n\tint\t\t\tnumThreads = 1;\n\t\n\tint\t\t\tinputFormatRow = 0;\n\tint\t\t\tbasicOps = 0;\n\tint\t\t\tF=0;\n\t\n\twhile ((option = getopt(argc, argv,\"bro:i:t:f:\")) >= 0) {\n\t\tswitch (option) {\n\t\t\tcase 'o' : \n\t\t\t\t//free(outputFileName);\n\t\t\t\t\n\t\t\t\toutputFileName = (char *) malloc(sizeof(char)*strlen(optarg)+1);\n\t\t\t\tstrcpy(outputFileName,optarg);\n\t\t\t\t\n\t\t\t\tbreak;\n\t\t\t\n\t\t\tcase 'i' :\n\t\t\t\titerationNumber = atoi(optarg);\n\t\t\t\tbreak;\n\t\t\t\t\n\t\t\tcase 'r':\n\t\t\t\tinputFormatRow = 1;\n\t\t\t\tbreak;\n\t\t\tcase 'b':\n\t\t\t\tbasicOps = 1;\n\t\t\t\tbreak;\n\t\t\t\n\t\t\tcase 't':\n\t\t\t\tnumThreads = atoi(optarg);\n\t\t\t\tbreak;\n\t\t\t\t\n\t\t\tcase 'f':\n\t\t\t\tF = atoi(optarg);\n\t\t\t\tbreak;\n\t\t\t\n\t\t\tdefault: break;\n\t\t}\n\t\n\t}\n\t\n\tif ((optind + 2 > argc) || (optind + 3 <= argc)) {\n\t\tusageConjugateGradient();\n\t\treturn -1;\n\t}\n\t\n\t//openblas_set_num_threads(numThreads);\n\t\n\tif(outputFileName == NULL) {\n\t\toutputFileName = (char *) malloc(sizeof(char)*7);\n\t\tsprintf(outputFileName,\"stdout\");\n\t}\n\t\n\tstart_timer();\n\t\n\tinputMatrixFile = (char *)malloc(sizeof(char)*strlen(argv[optind])+1);\n\tinputVectorFile = (char *)malloc(sizeof(char)*strlen(argv[optind+1])+1);\n\t\n\tstrcpy(inputMatrixFile,argv[optind]);\n\tstrcpy(inputVectorFile,argv[optind+1]);\n\t\n\t//Read matrix\n\t\n\t//Read matrix\n\tif(inputFormatRow){\n\t\n\t\tif(!readDenseCoordinateMatrixRowLine(inputMatrixFile,&II,&J,&A,&M,&N,&nz)){\n\t\t\tfprintf(stderr, \"[%s] Can not read Matrix\\n\",__func__);\n\t\t\treturn -1;\n\t\t}\n\t\t\n\t\t//writeDenseVector(\"stdout\",values,M,N,nz);\n\t\t\n\t\n\t}\n\telse {\n\t\tif(!readDenseCoordinateMatrix(inputMatrixFile,&II,&J,&A,&M,&N,&nz)){\n\t\t\tfprintf(stderr, \"[%s] Can not read Matrix\\n\",__func__);\n\t\t\treturn -1;\n\t\t}\n\t}\n\t\n\t\n\t\n\t//Read vector\n\tif(!readDenseVector(inputVectorFile, &b,&M_Vector,&N_Vector,&nz_vector)){\n\t\tfprintf(stderr, \"[%s] Can not read Vector\\n\",__func__);\n\t\treturn -1;\n\t}\n\t\n\t\n \n //double *y=(double *) malloc(nz_vector * sizeof(double));\n fprintf(stderr,\"[%s] Solving system using conjugate gradient method\\n\",__func__);\n double t_real = realtime();\n\n\t// Vector to store result\n\tdouble *x=(double *) calloc(nz_vector,sizeof(double));\n\n\tif(basicOps){\n\t\tret_code = ConjugateGradientSolverBasic(II,J,A,M,N,nz,b,M_Vector,N_Vector,nz_vector, x, iterationNumber);\n\t}\n\telse{\n\t\t# ifdef ENABLE_RMT \n\t\t\t activateRMT(\"f-L-lp-lp-2d-l-l-l-1dC-l-l-l-1dC-i-i-ipC\", &ConjugateGradientSolver, 14, II, J, A, M, N, M, N, nz , b, N, M_Vector, N_Vector, \n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t nz_vector, x, nz_vector, iterationNumber, F, &ret_code);\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\n\t\t# else \t\t\t\n\t\t\tret_code = ConjugateGradientSolver(II,J,A,M,N,nz,b,M_Vector,N_Vector,nz_vector, x, iterationNumber, F, &ret_code);\n\t\t# endif\n\t\t\n\t}\n\t\n\tfprintf(stderr, \"\\n[%s] Time spent in Conjugate Gradient: %.6f sec\\n\", __func__, realtime() - t_real);\n\t\n\tif(ret_code){\n\t\n\t\twriteDenseVector(outputFileName, x,M_Vector,N_Vector,nz_vector);\n\t\n\t}\n\telse{\n\t\tfprintf(stderr,\"[%s] Error executing ConjugateGradientSolver\\n\",__func__);\n\t\treturn -1;\n\t\n\t}\n\t\n\tend_timer();\n\t\n\treturn 0;\n}\n\n", "meta": {"hexsha": "a25b8c09483d5e78e95914b2ad8e3f3e652f9c01", "size": 5264, "ext": "c", "lang": "C", "max_stars_repo_path": "applications/others/sscg/ConjugateGradient.c", "max_stars_repo_name": "sanemarslan/RMTLib", "max_stars_repo_head_hexsha": "8e7ab9d3491e40d9e5e77f67956752cc1178b1b4", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "applications/others/sscg/ConjugateGradient.c", "max_issues_repo_name": "sanemarslan/RMTLib", "max_issues_repo_head_hexsha": "8e7ab9d3491e40d9e5e77f67956752cc1178b1b4", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "applications/others/sscg/ConjugateGradient.c", "max_forks_repo_name": "sanemarslan/RMTLib", "max_forks_repo_head_hexsha": "8e7ab9d3491e40d9e5e77f67956752cc1178b1b4", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 25.8039215686, "max_line_length": 144, "alphanum_fraction": 0.6538753799, "num_tokens": 1463, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7341195385342971, "lm_q2_score": 0.7185943985973772, "lm_q1q2_score": 0.5275341882916373}} {"text": "/* movstat/mvacc.c\n *\n * Moving window mean/variance accumulator - based on a modification\n * to Welford's algorithm, discussed here:\n *\n * https://stackoverflow.com/a/6664212\n * \n * Copyright (C) 2018 Patrick Alken\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n#include \n#include \n#include \n#include \n#include \n\ntypedef double ringbuf_type_t;\n\n#include \"ringbuf.c\"\n\ntypedef struct\n{\n size_t n; /* window size */\n size_t k; /* number of samples currently in window */\n double mean; /* current window mean */\n double M2; /* current window M2 */\n ringbuf *rbuf; /* ring buffer storing current window */\n} mvacc_state_t;\n\nstatic size_t\nmvacc_size(const size_t n)\n{\n size_t size = 0;\n\n size += sizeof(mvacc_state_t);\n size += ringbuf_size(n);\n\n return size;\n}\n\nstatic int\nmvacc_init(const size_t n, void * vstate)\n{\n mvacc_state_t * state = (mvacc_state_t *) vstate;\n\n state->n = n;\n state->k = 0;\n state->mean = 0.0;\n state->M2 = 0.0;\n\n state->rbuf = (ringbuf *) ((unsigned char *) vstate + sizeof(mvacc_state_t));\n ringbuf_init(n, state->rbuf);\n\n return GSL_SUCCESS;\n}\n\nstatic int\nmvacc_insert(const double x, void * vstate)\n{\n mvacc_state_t * state = (mvacc_state_t *) vstate;\n\n if (ringbuf_is_full(state->rbuf))\n {\n /* remove oldest window element and add new one */\n double old = ringbuf_peek_back(state->rbuf);\n double prev_mean = state->mean;\n\n state->mean += (x - old) / (double) state->n;\n state->M2 += ((old - prev_mean) + (x - state->mean)) * (x - old);\n }\n else\n {\n double delta = x - state->mean;\n\n /*\n * Welford algorithm:\n *\n * mu_new = mu_old + (x - mu_old) / n\n * M2_new = M2_old + (x - mu_old) * (x - mu_new)\n */\n\n ++(state->k);\n state->mean += delta / (double) state->k;\n state->M2 += delta * (x - state->mean);\n }\n\n /* add new element to ring buffer */\n ringbuf_insert(x, state->rbuf);\n\n return GSL_SUCCESS;\n}\n\nstatic int\nmvacc_delete(void * vstate)\n{\n mvacc_state_t * state = (mvacc_state_t *) vstate;\n\n if (!ringbuf_is_empty(state->rbuf))\n {\n if (state->k > 1)\n {\n /*\n * mu_new = mu_old + (mu_old - x_old) / (n - 1)\n * M2_new = M2_old - (mu_old - x_old) * (mu_new - x_old)\n */\n\n double old = ringbuf_peek_back(state->rbuf);\n double prev_mean = state->mean;\n double delta = prev_mean - old;\n\n state->mean += delta / (state->k - 1.0);\n state->M2 -= delta * (state->mean - old);\n }\n else if (state->k == 1)\n {\n state->mean = 0.0;\n state->M2 = 0.0;\n }\n\n ringbuf_pop_back(state->rbuf);\n --(state->k);\n }\n\n return GSL_SUCCESS;\n}\n\nstatic int\nmvacc_mean(void * params, double * result, const void * vstate)\n{\n const mvacc_state_t * state = (const mvacc_state_t *) vstate;\n (void) params;\n *result = state->mean;\n return GSL_SUCCESS;\n}\n\nstatic int\nmvacc_variance(void * params, double * result, const void * vstate)\n{\n const mvacc_state_t * state = (const mvacc_state_t *) vstate;\n\n (void) params;\n\n if (state->k < 2)\n *result = 0.0;\n else\n *result = state->M2 / (state->k - 1.0);\n\n return GSL_SUCCESS;\n}\n\nstatic int\nmvacc_sd(void * params, double * result, const void * vstate)\n{\n double variance;\n int status = mvacc_variance(params, &variance, vstate);\n *result = sqrt(variance);\n return status;\n}\n\nstatic const gsl_movstat_accum mean_accum_type =\n{\n mvacc_size,\n mvacc_init,\n mvacc_insert,\n mvacc_delete,\n mvacc_mean\n};\n\nconst gsl_movstat_accum *gsl_movstat_accum_mean = &mean_accum_type;\n\nstatic const gsl_movstat_accum variance_accum_type =\n{\n mvacc_size,\n mvacc_init,\n mvacc_insert,\n mvacc_delete,\n mvacc_variance\n};\n\nconst gsl_movstat_accum *gsl_movstat_accum_variance = &variance_accum_type;\n\nstatic const gsl_movstat_accum sd_accum_type =\n{\n mvacc_size,\n mvacc_init,\n mvacc_insert,\n mvacc_delete,\n mvacc_sd\n};\n\nconst gsl_movstat_accum *gsl_movstat_accum_sd = &sd_accum_type;\n", "meta": {"hexsha": "14f08944d25c57806824825dff45e0bf0c44c6f1", "size": 4781, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.6/movstat/mvacc.c", "max_stars_repo_name": "ielomariala/Hex-Game", "max_stars_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-06-14T11:51:37.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-14T11:51:37.000Z", "max_issues_repo_path": "gsl-2.6/movstat/mvacc.c", "max_issues_repo_name": "ielomariala/Hex-Game", "max_issues_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-12-16T17:41:24.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-22T00:00:16.000Z", "max_forks_repo_path": "test/lib/gsl-2.6/movstat/mvacc.c", "max_forks_repo_name": "karanbirsandhu/nu-sense", "max_forks_repo_head_hexsha": "83fd1fc4cbd053a4f9b673d5cd5841823ddd4d8b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-01-20T16:22:57.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-14T12:31:02.000Z", "avg_line_length": 23.2087378641, "max_line_length": 81, "alphanum_fraction": 0.6452624974, "num_tokens": 1371, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8006920020959544, "lm_q2_score": 0.658417500561683, "lm_q1q2_score": 0.5271896267397481}} {"text": "//This computes \"the\" IDCT (inverse discrete cosine transformation) along dim of matrix X.\n//This uses a CBLAS matrix multiplication by the DCT-III matrix.\n\n#include \n#include \n#include \n#include \n\n#ifndef M_PI\n #define M_PI 3.14159265358979323846\n#endif\n\n#ifndef M_SQRT1_2\n #define M_SQRT1_2 0.707106781186547524401\n#endif\n\n#ifdef __cplusplus\nnamespace codee {\nextern \"C\" {\n#endif\n\nint idct_cblas_s (float *Y, const float *X, const size_t R, const size_t C, const size_t S, const size_t H, const int iscolmajor, const size_t dim, const size_t ndct, const int sc);\nint idct_cblas_d (double *Y, const double *X, const size_t R, const size_t C, const size_t S, const size_t H, const int iscolmajor, const size_t dim, const size_t ndct, const int sc);\nint idct_cblas_c (float *Y, const float *X, const size_t R, const size_t C, const size_t S, const size_t H, const int iscolmajor, const size_t dim, const size_t ndct, const int sc);\nint idct_cblas_z (double *Y, const double *X, const size_t R, const size_t C, const size_t S, const size_t H, const int iscolmajor, const size_t dim, const size_t ndct, const int sc);\n\n\nint idct_cblas_s (float *Y, const float *X, const size_t R, const size_t C, const size_t S, const size_t H, const int iscolmajor, const size_t dim, const size_t ndct, const int sc)\n{\n if (dim>3u) { fprintf(stderr,\"error in idct_cblas_s: dim must be in [0 3]\\n\"); return 1; }\n\n const size_t N = R*C*S*H;\n const size_t Lx = (dim==0u) ? R : (dim==1u) ? C : (dim==2u) ? S : H;\n if (ndct= Lx (length of vecs in X)\\n\"); return 1; }\n\n if (ndct==0u || N==0u) {}\n else if (ndct==1u)\n {\n for (size_t n=N; n>0u; --n, ++X, ++Y) { *Y = *X; }\n }\n else\n {\n //Scaling\n const float xsc = (sc) ? (float)(2.0*M_SQRT1_2) : 1.0f;\n const float ysc = (sc) ? 2.0f/sqrtf((float)(2u*ndct)) : 2.0f/(float)(2u*ndct);\n const float dcsc = 0.5f * xsc * ysc;\n\n //Initialize DCT-III matrix\n const size_t LN = Lx * ndct;\n const float P_N = (float)(M_PI/(double)ndct);\n float *DCT, x0;\n DCT = (float *)aligned_alloc(sizeof(float),LN*sizeof(float));\n if (!DCT) { fprintf(stderr,\"error in idct_cblas_s: problem with aligned_alloc. \"); perror(\"aligned_alloc\"); return 1; }\n for (size_t n=0u; n0u; --n, ++Y) { *Y -= x0; }\n }\n else\n {\n const size_t K = (iscolmajor) ? ((dim==0u) ? 1u : (dim==1u) ? R : (dim==2u) ? R*C : R*C*S) : ((dim==0u) ? C*S*H : (dim==1u) ? S*H : (dim==2u) ? H : 1u);\n const size_t B = (iscolmajor && dim==0u) ? C*S*H : K;\n const size_t V = N/Lx, G = V/B;\n\n if (K==1u && (G==1u || B==1u))\n {\n for (size_t v=V; v>0u; --v, X+=Lx)\n {\n x0 = dcsc * *X;\n cblas_sgemv(CblasRowMajor,CblasNoTrans,(int)ndct,(int)Lx,1.0f,DCT,(int)Lx,X,1,0.0f,Y,1);\n for (size_t n=ndct; n>0u; --n, ++Y) { *Y -= x0; }\n }\n }\n else\n {\n for (size_t g=G; g>0u; --g, X+=B*(Lx-1u), Y+=B*(ndct-1u))\n {\n for (size_t b=B; b>0u; --b, ++X, Y-=K*ndct-1u)\n {\n x0 = dcsc * *X;\n cblas_sgemv(CblasRowMajor,CblasNoTrans,(int)ndct,(int)Lx,1.0f,DCT,(int)Lx,X,(int)K,0.0f,Y,(int)K);\n for (size_t n=ndct; n>0u; --n, Y+=K) { *Y -= x0; }\n }\n }\n }\n }\n free(DCT);\n }\n\n return 0;\n}\n\n\nint idct_cblas_d (double *Y, const double *X, const size_t R, const size_t C, const size_t S, const size_t H, const int iscolmajor, const size_t dim, const size_t ndct, const int sc)\n{\n if (dim>3u) { fprintf(stderr,\"error in idct_cblas_d: dim must be in [0 3]\\n\"); return 1; }\n\n const size_t N = R*C*S*H;\n const size_t Lx = (dim==0u) ? R : (dim==1u) ? C : (dim==2u) ? S : H;\n if (ndct= Lx (length of vecs in X)\\n\"); return 1; }\n\n if (ndct==0u || N==0u) {}\n else if (ndct==1u)\n {\n for (size_t n=N; n>0u; --n, ++X, ++Y) { *Y = *X; }\n }\n else\n {\n //Scaling\n const double xsc = (sc) ? 2.0*M_SQRT1_2 : 1.0;\n const double ysc = (sc) ? 2.0/sqrt((double)(2u*ndct)) : 2.0/(double)(2u*ndct);\n const double dcsc = 0.5 * xsc * ysc;\n\n //Initialize DCT-III matrix\n const size_t LN = Lx * ndct;\n const double P_N = M_PI/(double)ndct;\n double *DCT, x0;\n DCT = (double *)aligned_alloc(sizeof(double),LN*sizeof(double));\n if (!DCT) { fprintf(stderr,\"error in idct_cblas_d: problem with aligned_alloc. \"); perror(\"aligned_alloc\"); return 1; }\n for (size_t n=0u; n0u; --n, ++Y) { *Y -= x0; }\n }\n else\n {\n const size_t K = (iscolmajor) ? ((dim==0u) ? 1u : (dim==1u) ? R : (dim==2u) ? R*C : R*C*S) : ((dim==0u) ? C*S*H : (dim==1u) ? S*H : (dim==2u) ? H : 1u);\n const size_t B = (iscolmajor && dim==0u) ? C*S*H : K;\n const size_t V = N/Lx, G = V/B;\n\n if (K==1u && (G==1u || B==1u))\n {\n for (size_t v=V; v>0u; --v, X+=Lx)\n {\n x0 = dcsc * *X;\n cblas_dgemv(CblasRowMajor,CblasNoTrans,(int)ndct,(int)Lx,1.0,DCT,(int)Lx,X,1,0.0,Y,1);\n for (size_t n=ndct; n>0u; --n, ++Y) { *Y -= x0; }\n }\n }\n else\n {\n for (size_t g=G; g>0u; --g, X+=B*(Lx-1u), Y+=B*(ndct-1u))\n {\n for (size_t b=B; b>0u; --b, ++X, Y-=K*ndct-1u)\n {\n x0 = dcsc * *X;\n cblas_dgemv(CblasRowMajor,CblasNoTrans,(int)ndct,(int)Lx,1.0,DCT,(int)Lx,X,(int)K,0.0,Y,(int)K);\n for (size_t n=ndct; n>0u; --n, Y+=K) { *Y -= x0; }\n }\n }\n }\n }\n free(DCT);\n }\n\n return 0;\n}\n\n\nint idct_cblas_c (float *Y, const float *X, const size_t R, const size_t C, const size_t S, const size_t H, const int iscolmajor, const size_t dim, const size_t ndct, const int sc)\n{\n if (dim>3u) { fprintf(stderr,\"error in idct_cblas_c: dim must be in [0 3]\\n\"); return 1; }\n\n const size_t N = R*C*S*H;\n const size_t Lx = (dim==0u) ? R : (dim==1u) ? C : (dim==2u) ? S : H;\n if (ndct= Lx (length of vecs in X)\\n\"); return 1; }\n\n if (ndct==0u || N==0u) {}\n else if (ndct==1u)\n {\n for (size_t n=2u*N; n>0u; --n, ++X, ++Y) { *Y = *X; }\n }\n else\n {\n //Scaling\n const float xsc = (sc) ? (float)(2.0*M_SQRT1_2) : 1.0f;\n const float ysc = (sc) ? 2.0f/sqrtf((float)(2u*ndct)) : 2.0f/(float)(2u*ndct);\n const float dcsc = 0.5f * xsc * ysc;\n\n //Initialize DCT-III matrix\n const size_t LN = Lx * ndct;\n const float P_N = (float)(M_PI/(double)ndct);\n float *DCT, x0r, x0i;\n DCT = (float *)aligned_alloc(sizeof(float),LN*sizeof(float));\n if (!DCT) { fprintf(stderr,\"error in idct_cblas_s: problem with aligned_alloc. \"); perror(\"aligned_alloc\"); return 1; }\n for (size_t n=0u; n0u; --n, ++Y) { *Y -= x0r; *++Y -= x0i; }\n }\n else\n {\n const size_t K = (iscolmajor) ? ((dim==0u) ? 1u : (dim==1u) ? R : (dim==2u) ? R*C : R*C*S) : ((dim==0u) ? C*S*H : (dim==1u) ? S*H : (dim==2u) ? H : 1u);\n const size_t B = (iscolmajor && dim==0u) ? C*S*H : K;\n const size_t V = N/Lx, G = V/B;\n\n if (K==1u && (G==1u || B==1u))\n {\n for (size_t v=0u; v0u; --n, ++Y) { *Y -= x0r; *++Y -= x0i; }\n }\n }\n else\n {\n for (size_t g=G; g>0u; --g, X+=2u*B*(Lx-1u), Y+=2u*B*(ndct-1u))\n {\n for (size_t b=B; b>0u; --b, X+=2u, Y-=2u*K*ndct-2u)\n {\n x0r = dcsc * *X; x0i = dcsc * *(X+1);\n cblas_sgemv(CblasRowMajor,CblasNoTrans,(int)ndct,(int)Lx,1.0f,DCT,(int)Lx,X,2*(int)K,0.0f,Y,2*(int)K);\n cblas_sgemv(CblasRowMajor,CblasNoTrans,(int)ndct,(int)Lx,1.0f,DCT,(int)Lx,X+1,2*(int)K,0.0f,Y+1,2*(int)K);\n for (size_t n=ndct; n>0u; --n, Y+=2u*K) { *Y -= x0r; *(Y+1) -= x0i; }\n }\n }\n }\n }\n free(DCT);\n }\n\n return 0;\n}\n\n\nint idct_cblas_z (double *Y, const double *X, const size_t R, const size_t C, const size_t S, const size_t H, const int iscolmajor, const size_t dim, const size_t ndct, const int sc)\n{\n if (dim>3u) { fprintf(stderr,\"error in idct_cblas_z: dim must be in [0 3]\\n\"); return 1; }\n\n const size_t N = R*C*S*H;\n const size_t Lx = (dim==0u) ? R : (dim==1u) ? C : (dim==2u) ? S : H;\n if (ndct= Lx (length of vecs in X)\\n\"); return 1; }\n\n if (ndct==0u || N==0u) {}\n else if (ndct==1u)\n {\n for (size_t n=2u*N; n>0u; --n, ++X, ++Y) { *Y = *X; }\n }\n else\n {\n //Scaling\n const double xsc = (sc) ? 2.0*M_SQRT1_2 : 1.0;\n const double ysc = (sc) ? 2.0/sqrt((double)(2u*ndct)) : 2.0/(double)(2u*ndct);\n const double dcsc = 0.5 * xsc * ysc;\n\n //Initialize DCT-III matrix\n const size_t LN = Lx * ndct;\n const double P_N = M_PI/(double)ndct;\n double *DCT, x0r, x0i;\n DCT = (double *)aligned_alloc(sizeof(double),LN*sizeof(double));\n if (!DCT) { fprintf(stderr,\"error in idct_cblas_z: problem with aligned_alloc. \"); perror(\"aligned_alloc\"); return 1; }\n for (size_t n=0u; n0u; --n, ++Y) { *Y -= x0r; *++Y -= x0i; }\n }\n else\n {\n const size_t K = (iscolmajor) ? ((dim==0u) ? 1u : (dim==1u) ? R : (dim==2u) ? R*C : R*C*S) : ((dim==0u) ? C*S*H : (dim==1u) ? S*H : (dim==2u) ? H : 1u);\n const size_t B = (iscolmajor && dim==0u) ? C*S*H : K;\n const size_t V = N/Lx, G = V/B;\n\n if (K==1u && (G==1u || B==1u))\n {\n for (size_t v=0u; v0u; --n, ++Y) { *Y -= x0r; *++Y -= x0i; }\n }\n }\n else\n {\n for (size_t g=G; g>0u; --g, X+=2u*B*(Lx-1u), Y+=2u*B*(ndct-1u))\n {\n for (size_t b=B; b>0u; --b, X+=2u, Y-=2u*K*ndct-2u)\n {\n x0r = dcsc * *X; x0i = dcsc * *(X+1);\n cblas_dgemv(CblasRowMajor,CblasNoTrans,(int)ndct,(int)Lx,1.0,DCT,(int)Lx,X,2*(int)K,0.0,Y,2*(int)K);\n cblas_dgemv(CblasRowMajor,CblasNoTrans,(int)ndct,(int)Lx,1.0,DCT,(int)Lx,X+1,2*(int)K,0.0,Y+1,2*(int)K);\n for (size_t n=ndct; n>0u; --n, Y+=2u*K) { *Y -= x0r; *(Y+1) -= x0i; }\n }\n }\n }\n }\n free(DCT);\n }\n\n return 0;\n}\n\n\n#ifdef __cplusplus\n}\n}\n#endif\n", "meta": {"hexsha": "f9ba8f6e9d7965fefbc318f6fb3d474876cee468", "size": 13800, "ext": "c", "lang": "C", "max_stars_repo_path": "c/idct.cblas.c", "max_stars_repo_name": "erikedwards4/dsp", "max_stars_repo_head_hexsha": "28880ede8ca715c2a5a9b596742070f9bda9830e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2020-08-26T09:22:40.000Z", "max_stars_repo_stars_event_max_datetime": "2020-08-26T09:22:40.000Z", "max_issues_repo_path": "c/idct.cblas.c", "max_issues_repo_name": "erikedwards4/dsp", "max_issues_repo_head_hexsha": "28880ede8ca715c2a5a9b596742070f9bda9830e", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "c/idct.cblas.c", "max_forks_repo_name": "erikedwards4/dsp", "max_forks_repo_head_hexsha": "28880ede8ca715c2a5a9b596742070f9bda9830e", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2021-10-05T13:50:32.000Z", "max_forks_repo_forks_event_max_datetime": "2021-10-05T13:50:32.000Z", "avg_line_length": 39.8843930636, "max_line_length": 183, "alphanum_fraction": 0.4771014493, "num_tokens": 5113, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8519527906914788, "lm_q2_score": 0.6187804337438501, "lm_q1q2_score": 0.5271717173533568}} {"text": "/* specfunc/beta_inc.c\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n/* Author: G. Jungman */\n/* Modified for cdfs by Brian Gough, June 2003 */\n\n#include \n\nstatic double\nbeta_cont_frac (const double a, const double b, const double x,\n const double epsabs)\n{\n const unsigned int max_iter = 512; /* control iterations */\n const double cutoff = 2.0 * GSL_DBL_MIN; /* control the zero cutoff */\n unsigned int iter_count = 0;\n double cf;\n\n /* standard initialization for continued fraction */\n double num_term = 1.0;\n double den_term = 1.0 - (a + b) * x / (a + 1.0);\n\n if (fabs (den_term) < cutoff)\n den_term = GSL_NAN;\n\n den_term = 1.0 / den_term;\n cf = den_term;\n\n while (iter_count < max_iter)\n {\n const int k = iter_count + 1;\n double coeff = k * (b - k) * x / (((a - 1.0) + 2 * k) * (a + 2 * k));\n double delta_frac;\n\n /* first step */\n den_term = 1.0 + coeff * den_term;\n num_term = 1.0 + coeff / num_term;\n\n if (fabs (den_term) < cutoff)\n den_term = GSL_NAN;\n\n if (fabs (num_term) < cutoff)\n num_term = GSL_NAN;\n\n den_term = 1.0 / den_term;\n\n delta_frac = den_term * num_term;\n cf *= delta_frac;\n\n coeff = -(a + k) * (a + b + k) * x / ((a + 2 * k) * (a + 2 * k + 1.0));\n\n /* second step */\n den_term = 1.0 + coeff * den_term;\n num_term = 1.0 + coeff / num_term;\n\n if (fabs (den_term) < cutoff)\n den_term = GSL_NAN;\n\n if (fabs (num_term) < cutoff)\n num_term = GSL_NAN;\n\n den_term = 1.0 / den_term;\n\n delta_frac = den_term * num_term;\n cf *= delta_frac;\n\n if (fabs (delta_frac - 1.0) < 2.0 * GSL_DBL_EPSILON)\n break;\n\n if (cf * fabs (delta_frac - 1.0) < epsabs)\n break;\n\n ++iter_count;\n }\n\n if (iter_count >= max_iter)\n return GSL_NAN;\n\n return cf;\n}\n\n/* The function beta_inc_AXPY(A,Y,a,b,x) computes A * beta_inc(a,b,x)\n + Y taking account of possible cancellations when using the\n hypergeometric transformation beta_inc(a,b,x)=1-beta_inc(b,a,1-x).\n\n It also adjusts the accuracy of beta_inc() to fit the overall\n absolute error when A*beta_inc is added to Y. (e.g. if Y >>\n A*beta_inc then the accuracy of beta_inc can be reduced) */\n\n\n\nstatic double\nbeta_inc_AXPY (const double A, const double Y,\n const double a, const double b, const double x)\n{\n if (x == 0.0)\n {\n return A * 0 + Y;\n }\n else if (x == 1.0)\n {\n return A * 1 + Y;\n }\n else if (a > 1e5 && b < 10 && x > a / (a + b))\n {\n /* Handle asymptotic regime, large a, small b, x > peak [AS 26.5.17] */\n double N = a + (b - 1.0) / 2.0;\n return A * gsl_sf_gamma_inc_Q (b, -N * log (x)) + Y;\n }\n else if (b > 1e5 && a < 10 && x < b / (a + b))\n {\n /* Handle asymptotic regime, small a, large b, x < peak [AS 26.5.17] */\n double N = b + (a - 1.0) / 2.0;\n return A * gsl_sf_gamma_inc_P (a, -N * log1p (-x)) + Y;\n }\n else\n {\n double ln_beta = gsl_sf_lnbeta (a, b);\n double ln_pre = -ln_beta + a * log (x) + b * log1p (-x);\n\n double prefactor = exp (ln_pre);\n\n if (x < (a + 1.0) / (a + b + 2.0))\n {\n /* Apply continued fraction directly. */\n double epsabs = fabs (Y / (A * prefactor / a)) * GSL_DBL_EPSILON;\n\n double cf = beta_cont_frac (a, b, x, epsabs);\n\n return A * (prefactor * cf / a) + Y;\n }\n else\n {\n /* Apply continued fraction after hypergeometric transformation. */\n double epsabs =\n fabs ((A + Y) / (A * prefactor / b)) * GSL_DBL_EPSILON;\n double cf = beta_cont_frac (b, a, 1.0 - x, epsabs);\n double term = prefactor * cf / b;\n\n if (A == -Y)\n {\n return -A * term;\n }\n else\n {\n return A * (1 - term) + Y;\n }\n }\n }\n}\n\n/* Direct series evaluation for testing purposes only */\n\n#if 0\nstatic double\nbeta_series (const double a, const double b, const double x,\n const double epsabs)\n{\n double f = x / (1 - x);\n double c = (b - 1) / (a + 1) * f;\n double s = 1;\n double n = 0;\n\n s += c;\n\n do\n {\n n++;\n c *= -f * (2 + n - b) / (2 + n + a);\n s += c;\n }\n while (n < 512 && fabs (c) > GSL_DBL_EPSILON * fabs (s) + epsabs);\n\n s /= (1 - x);\n\n return s;\n}\n#endif\n", "meta": {"hexsha": "ac1d34032f31d23ee5580362a7ced8ec1a6a38d2", "size": 5154, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.6/cdf/beta_inc.c", "max_stars_repo_name": "ielomariala/Hex-Game", "max_stars_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-12-18T18:09:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-10T11:31:28.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/cdf/beta_inc.c", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-12-16T17:41:24.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-22T00:00:16.000Z", "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/cdf/beta_inc.c", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 14.0, "max_forks_repo_forks_event_min_datetime": "2015-07-21T04:47:52.000Z", "max_forks_repo_forks_event_max_datetime": "2020-03-12T12:31:25.000Z", "avg_line_length": 26.5670103093, "max_line_length": 81, "alphanum_fraction": 0.5568490493, "num_tokens": 1592, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7799929002541068, "lm_q2_score": 0.6757646140788308, "lm_q1q2_score": 0.5270916012244445}} {"text": "/* specfunc/bessel_i.c\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 2 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n/* Author: G. Jungman */\n\n#include \n#include \n#include \n#include \n#include \n\n#include \"error.h\"\n\n#include \"bessel.h\"\n\n\n/* i_{l+1}/i_l\n */\nstatic\nint\nbessel_il_CF1(const int l, const double x, const double threshold, double * ratio)\n{\n const int kmax = 2000;\n double tk = 1.0;\n double sum = 1.0;\n double rhok = 0.0;\n int k;\n\n for(k=1; k<=kmax; k++) {\n double ak = (x/(2.0*l+1.0+2.0*k)) * (x/(2.0*l+3.0+2.0*k));\n rhok = -ak*(1.0 + rhok)/(1.0 + ak*(1.0 + rhok));\n tk *= rhok;\n sum += tk;\n if(fabs(tk/sum) < threshold) break;\n }\n\n *ratio = x/(2.0*l+3.0) * sum;\n\n if(k == kmax)\n GSL_ERROR (\"error\", GSL_EMAXITER);\n else\n return GSL_SUCCESS;\n}\n\n\n/*-*-*-*-*-*-*-*-*-*-*-* Functions with Error Codes *-*-*-*-*-*-*-*-*-*-*-*/\n\nint gsl_sf_bessel_i0_scaled_e(const double x, gsl_sf_result * result)\n{\n double ax = fabs(x);\n\n /* CHECK_POINTER(result) */\n\n if(x == 0.0) {\n result->val = 1.0;\n result->err = 0.0;\n return GSL_SUCCESS; \n }\n else if(ax < 0.2) {\n const double eax = exp(-ax);\n const double y = ax*ax;\n const double c1 = 1.0/6.0;\n const double c2 = 1.0/120.0;\n const double c3 = 1.0/5040.0;\n const double c4 = 1.0/362880.0;\n const double c5 = 1.0/39916800.0;\n const double sum = 1.0 + y*(c1 + y*(c2 + y*(c3 + y*(c4 + y*c5))));\n result->val = eax * sum;\n result->err = 2.0 * GSL_DBL_EPSILON * result->val;\n }\n else if(ax < -0.5*GSL_LOG_DBL_EPSILON) {\n result->val = (1.0 - exp(-2.0*ax))/(2.0*ax);\n result->err = 2.0 * GSL_DBL_EPSILON * result->val;\n }\n else {\n result->val = 1.0/(2.0*ax);\n result->err = 2.0 * GSL_DBL_EPSILON * result->val;\n }\n return GSL_SUCCESS;\n}\n\n\nint gsl_sf_bessel_i1_scaled_e(const double x, gsl_sf_result * result)\n{\n double ax = fabs(x);\n\n /* CHECK_POINTER(result) */\n\n if(x == 0.0) {\n result->val = 0.0;\n result->err = 0.0;\n return GSL_SUCCESS;\n }\n else if(ax < 3.0*GSL_DBL_MIN) {\n UNDERFLOW_ERROR(result);\n }\n else if(ax < 0.25) {\n const double eax = exp(-ax);\n const double y = x*x;\n const double c1 = 1.0/10.0;\n const double c2 = 1.0/280.0;\n const double c3 = 1.0/15120.0;\n const double c4 = 1.0/1330560.0;\n const double c5 = 1.0/172972800.0;\n const double sum = 1.0 + y*(c1 + y*(c2 + y*(c3 + y*(c4 + y*c5))));\n result->val = eax * x/3.0 * sum;\n result->err = 2.0 * GSL_DBL_EPSILON * fabs(result->val);\n return GSL_SUCCESS;\n }\n else {\n double ex = exp(-2.0*ax);\n result->val = 0.5 * (ax*(1.0+ex) - (1.0-ex)) / (ax*ax);\n result->err = 2.0 * GSL_DBL_EPSILON * fabs(result->val);\n if(x < 0.0) result->val = -result->val;\n return GSL_SUCCESS;\n }\n}\n\n\nint gsl_sf_bessel_i2_scaled_e(const double x, gsl_sf_result * result)\n{\n double ax = fabs(x);\n\n /* CHECK_POINTER(result) */\n\n if(x == 0.0) {\n result->val = 0.0;\n result->err = 0.0;\n return GSL_SUCCESS; \n }\n else if(ax < 4.0*GSL_SQRT_DBL_MIN) {\n UNDERFLOW_ERROR(result);\n }\n else if(ax < 0.25) {\n const double y = x*x;\n const double c1 = 1.0/14.0;\n const double c2 = 1.0/504.0;\n const double c3 = 1.0/33264.0;\n const double c4 = 1.0/3459456.0;\n const double c5 = 1.0/518918400.0;\n const double sum = 1.0 + y*(c1 + y*(c2 + y*(c3 + y*(c4 + y*c5))));\n const double pre = exp(-ax) * x*x/15.0;\n result->val = pre * sum;\n result->err = 2.0 * GSL_DBL_EPSILON * fabs(result->val);\n return GSL_SUCCESS;\n }\n else {\n double ex = exp(-2.0*ax);\n double x2 = x*x;\n result->val = 0.5 * ((3.0+x2)*(1.0-ex) - 3.0*ax*(1.0+ex))/(ax*ax*ax);\n result->err = 2.0 * GSL_DBL_EPSILON * fabs(result->val);\n return GSL_SUCCESS;\n }\n} \n\n\nint gsl_sf_bessel_il_scaled_e(const int l, double x, gsl_sf_result * result)\n{\n double sgn = 1.0;\n double ax = fabs(x);\n\n if(x < 0.0) {\n /* i_l(-x) = (-1)^l i_l(x) */\n sgn = ( GSL_IS_ODD(l) ? -1.0 : 1.0 );\n x = -x;\n }\n\n if(l < 0) {\n DOMAIN_ERROR(result);\n }\n else if(x == 0.0) {\n result->val = ( l == 0 ? 1.0 : 0.0 );\n result->err = 0.0;\n return GSL_SUCCESS;\n }\n else if(l == 0) {\n gsl_sf_result il;\n int stat_il = gsl_sf_bessel_i0_scaled_e(x, &il);\n result->val = sgn * il.val;\n result->err = il.err;\n return stat_il;\n }\n else if(l == 1) {\n gsl_sf_result il;\n int stat_il = gsl_sf_bessel_i1_scaled_e(x, &il);\n result->val = sgn * il.val;\n result->err = il.err;\n return stat_il;\n }\n else if(l == 2) {\n gsl_sf_result il;\n int stat_il = gsl_sf_bessel_i2_scaled_e(x, &il);\n result->val = sgn * il.val;\n result->err = il.err;\n return stat_il;\n }\n else if(x*x < 10.0*(l+1.5)/M_E) {\n gsl_sf_result b;\n int stat = gsl_sf_bessel_IJ_taylor_e(l+0.5, x, 1, 50, GSL_DBL_EPSILON, &b);\n double pre = exp(-ax) * sqrt((0.5*M_PI)/x);\n result->val = sgn * pre * b.val;\n result->err = pre * b.err;\n result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);\n return stat;\n }\n else if(l < 150) {\n gsl_sf_result i0_scaled;\n int stat_i0 = gsl_sf_bessel_i0_scaled_e(ax, &i0_scaled);\n double rat;\n int stat_CF1 = bessel_il_CF1(l, ax, GSL_DBL_EPSILON, &rat);\n double iellp1 = rat * GSL_SQRT_DBL_MIN;\n double iell = GSL_SQRT_DBL_MIN;\n double iellm1;\n int ell;\n for(ell = l; ell >= 1; ell--) {\n iellm1 = iellp1 + (2*ell + 1)/x * iell;\n iellp1 = iell;\n iell = iellm1;\n }\n result->val = sgn * i0_scaled.val * (GSL_SQRT_DBL_MIN / iell);\n result->err = i0_scaled.err * (GSL_SQRT_DBL_MIN / iell);\n result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);\n return GSL_ERROR_SELECT_2(stat_i0, stat_CF1);\n }\n else if(GSL_MIN(0.29/(l*l+1.0), 0.5/(l*l+1.0+x*x)) < 0.5*GSL_ROOT3_DBL_EPSILON) {\n int status = gsl_sf_bessel_Inu_scaled_asymp_unif_e(l + 0.5, x, result);\n double pre = sqrt((0.5*M_PI)/x);\n result->val *= sgn * pre;\n result->err *= pre;\n return status;\n }\n else {\n /* recurse down from safe values */\n double rt_term = sqrt((0.5*M_PI)/x);\n const int LMAX = 2 + (int) (1.2 / GSL_ROOT6_DBL_EPSILON);\n gsl_sf_result r_iellp1;\n gsl_sf_result r_iell;\n int stat_a1 = gsl_sf_bessel_Inu_scaled_asymp_unif_e(LMAX + 1 + 0.5, x, &r_iellp1);\n int stat_a2 = gsl_sf_bessel_Inu_scaled_asymp_unif_e(LMAX + 0.5, x, &r_iell);\n double iellp1 = r_iellp1.val;\n double iell = r_iell.val;\n double iellm1 = 0.0;\n int ell;\n iellp1 *= rt_term;\n iell *= rt_term;\n for(ell = LMAX; ell >= l+1; ell--) {\n iellm1 = iellp1 + (2*ell + 1)/x * iell;\n iellp1 = iell;\n iell = iellm1;\n }\n result->val = sgn * iellm1;\n result->err = fabs(result->val)*(GSL_DBL_EPSILON + fabs(r_iellp1.err/r_iellp1.val) + fabs(r_iell.err/r_iell.val));\n result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);\n\n return GSL_ERROR_SELECT_2(stat_a1, stat_a2);\n }\n}\n\n\nint gsl_sf_bessel_il_scaled_array(const int lmax, const double x, double * result_array)\n{\n if(x == 0.0) {\n int ell;\n result_array[0] = 1.0;\n for (ell = lmax; ell >= 1; ell--) {\n result_array[ell] = 0.0;\n };\n return GSL_SUCCESS;\n } else {\n int ell;\n gsl_sf_result r_iellp1;\n gsl_sf_result r_iell;\n int stat_0 = gsl_sf_bessel_il_scaled_e(lmax+1, x, &r_iellp1);\n int stat_1 = gsl_sf_bessel_il_scaled_e(lmax, x, &r_iell);\n double iellp1 = r_iellp1.val;\n double iell = r_iell.val;\n double iellm1;\n result_array[lmax] = iell;\n for(ell = lmax; ell >= 1; ell--) {\n iellm1 = iellp1 + (2*ell + 1)/x * iell;\n iellp1 = iell;\n iell = iellm1;\n result_array[ell-1] = iellm1;\n }\n return GSL_ERROR_SELECT_2(stat_0, stat_1);\n }\n}\n\n\n/*-*-*-*-*-*-*-*-*-* Functions w/ Natural Prototypes *-*-*-*-*-*-*-*-*-*-*/\n\n#include \"eval.h\"\n\ndouble gsl_sf_bessel_i0_scaled(const double x)\n{\n EVAL_RESULT(gsl_sf_bessel_i0_scaled_e(x, &result));\n}\n\ndouble gsl_sf_bessel_i1_scaled(const double x)\n{\n EVAL_RESULT(gsl_sf_bessel_i1_scaled_e(x, &result));\n}\n\ndouble gsl_sf_bessel_i2_scaled(const double x)\n{\n EVAL_RESULT(gsl_sf_bessel_i2_scaled_e(x, &result));\n}\n\ndouble gsl_sf_bessel_il_scaled(const int l, const double x)\n{\n EVAL_RESULT(gsl_sf_bessel_il_scaled_e(l, x, &result));\n}\n\n", "meta": {"hexsha": "2d39f2cef7905c98911230d31974fdc8b6c81ca6", "size": 9023, "ext": "c", "lang": "C", "max_stars_repo_path": "pkgs/libs/gsl/src/specfunc/bessel_i.c", "max_stars_repo_name": "manggoguy/parsec-modified", "max_stars_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 64.0, "max_stars_repo_stars_event_min_datetime": "2015-03-06T00:30:56.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-24T13:26:53.000Z", "max_issues_repo_path": "pkgs/libs/gsl/src/specfunc/bessel_i.c", "max_issues_repo_name": "manggoguy/parsec-modified", "max_issues_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 12.0, "max_issues_repo_issues_event_min_datetime": "2020-12-15T08:30:19.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-13T03:54:24.000Z", "max_forks_repo_path": "pkgs/libs/gsl/src/specfunc/bessel_i.c", "max_forks_repo_name": "manggoguy/parsec-modified", "max_forks_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 40.0, "max_forks_repo_forks_event_min_datetime": "2015-02-26T15:31:16.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-03T23:23:37.000Z", "avg_line_length": 27.3424242424, "max_line_length": 119, "alphanum_fraction": 0.6036794858, "num_tokens": 3304, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7718434978390747, "lm_q2_score": 0.6825737279551494, "lm_q1q2_score": 0.5268400937179595}} {"text": "// sammlung verwendeter Funktionen\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#ifndef HEADER_FILE_UTIL\n#define HEADER_FILE_UTIL\n\n\ndouble Norm_Diff(double *vec1,double *vec2, int dim, int p); //berechnet norm von || vec1-vec2 ||_p\nvoid Lattice_Setup(double **positions,int numbertoinf,int dim, double latticespacing); // Legt Koordianten auf mxn Gittermatrix der dimension numbertoinf**dim, dim\nint ipow(int base, int exp);\nint Kahan_Sum(int N, double input[], double *ans);\nint Sign_Sum(int N, double input[], double *ans);\nint Neumaier_Sum(int N, double input[N], double *ans);\nvoid deleteSpaces(char src[], char dst[]);\n\nvoid vec_zero(double *v,int N);\nvoid vec_zero_i(int *v,int N);\n\nint Update_Lattice_Position(int * pos, const double *vec, const double lattice_spacing);\n\n// begin stepper with different external forces -------//\n\nvoid VVerlet_Step(int N, double x[N/2] , double v[N/2], double a[N/2], double *t, \n\t\t\t\t\tvoid (*deriv) (double *y, double *ans, double t,int N));\n\nvoid VVerlet_Step_Target_Square(const int N, double x[N/2] , double v[N/2], double a[N/2], double *t, \n\t\t\t\t\tvoid (*deriv) (double *y, double *ans, double t,int N));\n\nvoid VVerlet_Step_deriv(const int N, double x[N/2] , double v[N/2], double a[N/2], double *t, //mach einzelnen update Schritt nach Velocity-Verlet ohne Hinderniss\n\t\t\t\t\tvoid (*derivmethod) (double *y, double *ans, double t,int N));\n\nvoid VVerlet_Step_Yukawa(const int N, double x[N/2] , double v[N/2], double a[N/2], double *t, //mach einzelnen update Schritt nach Velocity-Verlet ohne Hinderniss\n\t\t\t\t\tvoid (*derivmethod) (double *y, double *ans, double t,int N));\n\nvoid VVerlet_Step_Pore_Rectangle(const int N, double x[N/2] , double v[N/2], double a[N/2], double *t, // wie Verlet step, aber Teilchen reflektiert stehen falls in Target (Quadrat)\n\t\t\t\t\tvoid (*derivmethod) (double *y, double *ans, double t,int N));\n\n\nvoid VVerlet_Step_Pore_Yukawa(const int N, double x[N/2] , double v[N/2], double a[N/2], double *t, //mach einzelnen update Schritt nach Velocity-Verlet ohne Hinderniss\n\t\t\t\t\tvoid (*derivmethod) (double *y, double *ans, double t,int N));\n\n// end stepper with different external forces -------//\n\nvoid VVerlet(int N, double *y, double **ans, double *t,\n\t\t\tvoid (*deriv) (double *y, double *ans, double t, int N));\n\nvoid VVerlet_parallel(const int N, const double *y, double **ans, double *t,\t\t\t\t\t\t\t\n\t\t\t\tvoid (*derivmethod) (double *y, double *ans, double t, int N));\n\nvoid VVerlet_parallel_burn(const int N, const double *y, double **ans, double *t,\t\t\t\t\t\t\t// Velocity Verlet für Start y, Ausgabe ans[LengthT][ORDER] zu Zeiten T\n\t\t\t\tvoid (*derivmethod) (double *y, double *ans, double t, int N));\n\nvoid Bath_Setup(double *y, char *label, gsl_rng * r);\n\nvoid Ommega_Setup(gsl_rng * r);\n\nvoid Gamma_Setup(double * gamma);\n\nvoid deriv(double *y, double *ans, double t, int N);\nvoid deriv_parallel(const double *yin, double *ans, double t, int N);\n\nvoid deriv_Yukawa(const double *y, double *ans, double t, int N);\n\n#endif", "meta": {"hexsha": "0b41f7d5dd1eb1f26db38626696159dd658acd12", "size": 3157, "ext": "h", "lang": "C", "max_stars_repo_path": "utility.h", "max_stars_repo_name": "nowottnm/KAC_ZWANZIG_SIM", "max_stars_repo_head_hexsha": "b8cacd50b7d307aeaa503b5a2f41cef4300f15a3", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "utility.h", "max_issues_repo_name": "nowottnm/KAC_ZWANZIG_SIM", "max_issues_repo_head_hexsha": "b8cacd50b7d307aeaa503b5a2f41cef4300f15a3", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "utility.h", "max_forks_repo_name": "nowottnm/KAC_ZWANZIG_SIM", "max_forks_repo_head_hexsha": "b8cacd50b7d307aeaa503b5a2f41cef4300f15a3", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 43.8472222222, "max_line_length": 183, "alphanum_fraction": 0.7019322141, "num_tokens": 954, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8175744761936437, "lm_q2_score": 0.6442251064863697, "lm_q1q2_score": 0.526702003986388}} {"text": "/***************************************************************************\n File : muParserScripting.h\n Project : QtiPlot\n --------------------------------------------------------------------\n\n Copyright : (C) 2006 by Ion Vasilief, Knut Franke\n Email (use @ for *) : ion_vasilief*yahoo.fr, knut.franke*gmx.de\n Description : Evaluate mathematical expressions using muParser\n\n ***************************************************************************/\n\n/***************************************************************************\n * *\n * This program is free software; you can redistribute it and/or modify *\n * it under the terms of the GNU General Public License as published by *\n * the Free Software Foundation; either version 2 of the License, or *\n * (at your option) any later version. *\n * *\n * This program is distributed in the hope that it will be useful, *\n * but WITHOUT ANY WARRANTY; without even the implied warranty of *\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *\n * GNU General Public License for more details. *\n * *\n * You should have received a copy of the GNU General Public License *\n * along with this program; if not, write to the Free Software *\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, *\n * Boston, MA 02110-1301 USA *\n * *\n ***************************************************************************/\n#ifndef MUPARSER_SCRIPTING_H\n#define MUPARSER_SCRIPTING_H\n\n#include \"ScriptingEnv.h\"\n#include \"Script.h\"\n#include \"muParserScript.h\"\n\n#include \n#include \"math.h\"\n#include \n#include \n#include \n\n//! TODO\nclass muParserScripting: public ScriptingEnv\n{\n Q_OBJECT\n\n public:\n static const char *langName;\n muParserScripting(ApplicationWindow *parent) : ScriptingEnv(parent, langName) { d_initialized=true; }\n static ScriptingEnv *constructor(ApplicationWindow *parent) { return new muParserScripting(parent); }\n\n bool isRunning() const { return true; }\n Script *newScript(const QString &code, QObject *context, const QString &name=\"\")\n {\n return new muParserScript(this, code, context, name);\n }\n\n // we do not support global variables\n bool setQObject(QObject*, const char*) { return false; }\n bool setInt(int, const char*) { return false; }\n bool setDouble(double, const char*) { return false; }\n\n const QStringList mathFunctions() const;\n const QString mathFunctionDoc (const QString &name) const;\n\n struct mathFunction\n {\n char *name;\n int numargs;\n double (*fun1)(double);\n double (*fun2)(double,double);\n double (*fun3)(double,double,double);\n char *description;\n };\n static const mathFunction math_functions[];\n\n private:\n static double mod(double x, double y)\n { return fmod(x,y); }\n static double bessel_J0(double x)\n { return gsl_sf_bessel_J0 (x); }\n static double bessel_J1(double x)\n { return gsl_sf_bessel_J1 (x); }\n static double bessel_Jn(double x, double n)\n { return gsl_sf_bessel_Jn ((int)n, x); }\n static double bessel_Yn(double x, double n)\n { return gsl_sf_bessel_Yn ((int)n, x); }\n static double bessel_Jn_zero(double n, double s)\n { return gsl_sf_bessel_zero_Jnu(n, (unsigned int) s); }\n static double bessel_Y0(double x)\n { return gsl_sf_bessel_Y0 (x); }\n static double bessel_Y1(double x)\n { return gsl_sf_bessel_Y1 (x); }\n static double beta(double a, double b)\n { return gsl_sf_beta (a,b); }\n static double erf(double x)\n { return gsl_sf_erf (x); }\n static double erfc(double x)\n { return gsl_sf_erfc (x); }\n static double erf_Z(double x)\n { return gsl_sf_erf_Z (x); }\n static double erf_Q(double x)\n { return gsl_sf_erf_Q (x); }\n static double gamma(double x)\n { return gsl_sf_gamma (x); }\n static double lngamma(double x)\n { return gsl_sf_lngamma (x); }\n static double hazard(double x)\n { return gsl_sf_hazard (x); }\n\tstatic double lambert_W0(double x)\n\t { return gsl_sf_lambert_W0(x); }\n\tstatic double lambert_Wm1(double x)\n\t { return gsl_sf_lambert_Wm1(x); }\n\tstatic double ttable(double x, double n)\n\t { return gsl_cdf_tdist_Pinv(x, n); }\n};\n\nclass EmptySourceError : public mu::ParserError\n{\n\tpublic:\n\t\tEmptySourceError() {}\n};\n\n#endif\n", "meta": {"hexsha": "065bca3355c74b7148fe396729913f8247332b19", "size": 4859, "ext": "h", "lang": "C", "max_stars_repo_path": "thirdparty/qtiplot/qtiplot/src/muParserScripting.h", "max_stars_repo_name": "hoehnp/SpaceDesignTool", "max_stars_repo_head_hexsha": "9abd34048274b2ce9dbbb685124177b02d6a34ca", "max_stars_repo_licenses": ["IJG"], "max_stars_count": 6.0, "max_stars_repo_stars_event_min_datetime": "2018-09-05T12:41:59.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-01T05:34:23.000Z", "max_issues_repo_path": "thirdparty/qtiplot/qtiplot/src/muParserScripting.h", "max_issues_repo_name": "hoehnp/SpaceDesignTool", "max_issues_repo_head_hexsha": "9abd34048274b2ce9dbbb685124177b02d6a34ca", "max_issues_repo_licenses": ["IJG"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2015-02-07T19:09:21.000Z", "max_issues_repo_issues_event_max_datetime": "2015-08-14T03:15:42.000Z", "max_forks_repo_path": "thirdparty/qtiplot/qtiplot/src/muParserScripting.h", "max_forks_repo_name": "hoehnp/SpaceDesignTool", "max_forks_repo_head_hexsha": "9abd34048274b2ce9dbbb685124177b02d6a34ca", "max_forks_repo_licenses": ["IJG"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2015-03-25T15:50:31.000Z", "max_forks_repo_forks_event_max_datetime": "2017-12-06T12:16:47.000Z", "avg_line_length": 38.5634920635, "max_line_length": 105, "alphanum_fraction": 0.5573163202, "num_tokens": 1072, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.826711776992821, "lm_q2_score": 0.6370307944803832, "lm_q1q2_score": 0.5266408601040261}} {"text": "#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n\n#include \"ccl.h\"\n\n// Analytic FT of NFW profile, from Cooray & Sheth (2002; Section 3 of https://arxiv.org/abs/astro-ph/0206508)\n// Normalised such that U(k=0)=1\nstatic double u_nfw_c(ccl_cosmology *cosmo, double rv, double c, double k, int *status) {\n\n double rs, ks;\n double f1, f2, f3, fc;\n\n // Special case to prevent numerical problems if k=0,\n // the result should be unity here because of the normalisation\n if (k==0.) {\n return 1.;\n }\n\n // The general k case\n else{\n\n // Scale radius for NFW (rs=rv/c)\n rs = rv/c;\n\n // Dimensionless wave-number variable\n ks = k*rs;\n\n // Various bits for summing together to get final result\n f1 = sin(ks)*(gsl_sf_Si(ks*(1.+c))-gsl_sf_Si(ks));\n f2 = cos(ks)*(gsl_sf_Ci(ks*(1.+c))-gsl_sf_Ci(ks));\n f3 = sin(c*ks)/(ks*(1.+c));\n fc = log(1.+c)-c/(1.+c);\n\n return (f1+f2-f3)/fc;\n\n }\n}\n\n/*----- ROUTINE: ccl_halo_concentration -----\nINPUT: cosmology, a halo mass [Msun], scale factor, halo definition, concentration model label\nTASK: Computes halo concentration; the ratio of virial raidus to scale radius for an NFW halo.\n*/\ndouble ccl_halo_concentration(ccl_cosmology *cosmo, double halomass,\n double a, double odelta, int *status) {\n\n double gz, g0, nu, delta_c, a_form;\n double Mpiv, A, B, C;\n\n switch(cosmo->config.halo_concentration_method){\n\n // Bhattacharya et al. (2011; 1005.2239; Delta = 200rho_m; Table 2)\n case ccl_bhattacharya2011:\n\n if (odelta != 200.) {\n *status = CCL_ERROR_CONC_DV;\n ccl_cosmology_set_status_message(\n cosmo,\n \"ccl_halomod.c: halo_concentration(): Bhattacharya (2011) concentration \"\n \"relation only valid for Delta_v = 200\");\n return NAN;\n }\n\n gz = ccl_growth_factor(cosmo,a,status);\n g0 = ccl_growth_factor(cosmo,1.0,status);\n delta_c = 1.686;\n nu = delta_c/ccl_sigmaM(cosmo, log10(halomass), a, status);\n return 9.*pow(nu,-0.29)*pow(gz/g0,1.15);\n\n // Duffy et al. (2008; 0804.2486; Table 1)\n case ccl_duffy2008:\n\n Mpiv = 2e12/cosmo->params.h; // Pivot mass in Msun (note in the paper units are Msun/h)\n\n if (odelta == Dv_BryanNorman(cosmo, a, status)) {\n\n // Duffy et al. (2008) for virial density haloes (second section in Table 1)\n A = 7.85;\n B = -0.081;\n C = -0.71;\n return A*pow(halomass/Mpiv,B)*pow(a,-C);\n\n } else if (odelta == 200.) {\n\n // Duffy et al. (2008) for x200 mean-matter-density haloes (third section in Table 1)\n A = 10.14;\n B = -0.081;\n C = -1.01;\n return A*pow(halomass/Mpiv,B)*pow(a,-C);\n\n } else {\n\n *status = CCL_ERROR_CONC_DV;\n ccl_cosmology_set_status_message(\n cosmo,\n \"ccl_halomod.c: halo_concentration(): Duffy (2008) virial \"\n \"concentration only valid for virial Delta_v or 200\\n\");\n return NAN;\n\n }\n\n // Constant concentration (good for tests)\n case ccl_constant_concentration:\n\n return 4.;\n\n // Something went wrong\n default:\n\n *status = CCL_ERROR_HALOCONC;\n ccl_raise_gsl_warning(*status, \"ccl_halomod.c: concentration-mass relation specified incorrectly\");\n return NAN;\n\n }\n}\n\n// Fourier Transforms of halo profiles\nstatic double window_function(ccl_cosmology *cosmo, double m, double k,\n double a, double odelta, ccl_win_label label,\n int *status) {\n double rho_matter, c, rv;\n\n switch(label){\n\n case ccl_nfw:\n\n // The mean background matter density in Msun/Mpc^3\n rho_matter = ccl_rho_x(cosmo, 1., ccl_species_m_label, 1, status);\n\n // The halo virial radius\n rv = r_delta(cosmo, m, a, odelta, status);\n\n // The halo concentration for this halo mass and at this scale factor\n c = ccl_halo_concentration(cosmo, m, a, odelta, status);\n\n // The function U is normalised to 1 for k<<1 so multiplying by M/rho turns units to overdensity\n return m*u_nfw_c(cosmo, rv, c, k, status)/rho_matter;\n\n // Something went wrong\n default:\n\n *status = CCL_ERROR_HALOWIN;\n ccl_raise_warning(*status, \"ccl_halomod.c: Window function specified incorrectly\");\n return NAN;\n\n }\n\n}\n\n// Parameters structure for the one-halo integrand\ntypedef struct{\n ccl_cosmology *cosmo;\n double k, a;\n int *status;\n} Int_one_halo_Par;\n\n// Integrand for the one-halo integral\nstatic double one_halo_integrand(double log10mass, void *params){\n\n Int_one_halo_Par *p = (Int_one_halo_Par *)params;;\n double halomass = pow(10,log10mass);\n double odelta = Dv_BryanNorman(p->cosmo, p->a, p->status); // Virial density for haloes\n\n // The normalised Fourier Transform of a halo density profile\n double wk = window_function(p->cosmo,halomass, p->k, p->a, odelta, ccl_nfw, p->status);\n\n // Fairly sure that there should be no ln(10) factor should be here since the integration is being specified in log10 range\n double dn_dlogM = ccl_massfunc(p->cosmo, halomass, p->a, odelta, p->status);\n\n return dn_dlogM*pow(wk,2);\n}\n\n// The one-halo term integral using gsl\nstatic double one_halo_integral(ccl_cosmology *cosmo, double k, double a, int *status){\n\n int one_halo_integral_status = 0, qagstatus;\n double result = 0, eresult;\n double log10mmin = log10(cosmo->gsl_params.HM_MMIN);\n double log10mmax = log10(cosmo->gsl_params.HM_MMAX);\n Int_one_halo_Par ipar;\n gsl_function F;\n gsl_integration_workspace *w = NULL;\n\n w = gsl_integration_workspace_alloc(cosmo->gsl_params.HM_LIMIT);\n if (w == NULL) {\n *status = CCL_ERROR_MEMORY;\n }\n\n if (*status == 0) {\n // Structure required for the gsl integration\n ipar.cosmo = cosmo;\n ipar.k = k;\n ipar.a = a;\n ipar.status = &one_halo_integral_status;\n F.function = &one_halo_integrand;\n F.params = &ipar;\n\n // Actually does the integration\n qagstatus = gsl_integration_qag(\n &F, log10mmin, log10mmax,\n cosmo->gsl_params.HM_EPSABS,\n cosmo->gsl_params.HM_EPSREL,\n cosmo->gsl_params.HM_LIMIT,\n cosmo->gsl_params.HM_INT_METHOD, w,\n &result, &eresult);\n\n // Check for errors\n if (qagstatus != GSL_SUCCESS) {\n ccl_raise_gsl_warning(qagstatus, \"ccl_halomod.c: one_halo_integral():\");\n *status = CCL_ERROR_ONE_HALO_INT;\n ccl_cosmology_set_status_message(cosmo, \"ccl_halomod.c: one_halo_integral(): Integration failure\\n\");\n result = NAN;\n }\n }\n\n // Clean up\n gsl_integration_workspace_free(w);\n\n return result;\n}\n\n// Parameters structure for the two-halo integrand\ntypedef struct{\n ccl_cosmology *cosmo;\n double k, a;\n int *status;\n} Int_two_halo_Par;\n\n// Integrand for the two-halo integral\nstatic double two_halo_integrand(double log10mass, void *params){\n\n Int_two_halo_Par *p = (Int_two_halo_Par *)params;\n double halomass = pow(10,log10mass);\n double odelta = Dv_BryanNorman(p->cosmo, p->a, p->status); // Virial density for haloes\n\n // The normalised Fourier Transform of a halo density profile\n double wk = window_function(p->cosmo, halomass, p->k, p->a, odelta, ccl_nfw, p->status);\n\n // Fairly sure that there should be no ln(10) factor should be here since the integration is being specified in log10 range\n double dn_dlogM = ccl_massfunc(p->cosmo, halomass, p->a, odelta, p->status);\n\n // Halo bias\n double b = ccl_halo_bias(p->cosmo, halomass, p->a, odelta, p->status);\n\n return b*dn_dlogM*wk;\n}\n\n// The two-halo term integral using gsl\nstatic double two_halo_integral(ccl_cosmology *cosmo, double k, double a, int *status){\n\n int two_halo_integral_status = 0, qagstatus;\n double result = 0, eresult;\n double log10mmin = log10(cosmo->gsl_params.HM_MMIN);\n double log10mmax = log10(cosmo->gsl_params.HM_MMAX);\n Int_two_halo_Par ipar;\n gsl_function F;\n gsl_integration_workspace *w = NULL;\n\n w = gsl_integration_workspace_alloc(cosmo->gsl_params.HM_LIMIT);\n if (w == NULL) {\n *status = CCL_ERROR_MEMORY;\n }\n\n if (*status == 0) {\n // Structure required for the gsl integration\n ipar.cosmo = cosmo;\n ipar.k = k;\n ipar.a = a;\n ipar.status = &two_halo_integral_status;\n F.function = &two_halo_integrand;\n F.params = &ipar;\n\n // Actually does the integration\n qagstatus = gsl_integration_qag(\n &F, log10mmin, log10mmax,\n cosmo->gsl_params.HM_EPSABS,\n cosmo->gsl_params.HM_EPSREL,\n cosmo->gsl_params.HM_LIMIT,\n cosmo->gsl_params.HM_INT_METHOD, w,\n &result, &eresult);\n\n // Check for errors\n if (qagstatus != GSL_SUCCESS) {\n ccl_raise_gsl_warning(qagstatus, \"ccl_halomod.c: two_halo_integral():\");\n *status = CCL_ERROR_TWO_HALO_INT;\n ccl_cosmology_set_status_message(cosmo, \"ccl_halomod.c: two_halo_integral(): Integration failure\\n\");\n result = NAN;\n }\n }\n\n // Clean up\n gsl_integration_workspace_free(w);\n\n return result;\n}\n\n/*----- ROUTINE: ccl_twohalo_matter_power -----\nINPUT: cosmology, wavenumber [Mpc^-1], scale factor\nTASK: Computes the two-halo power spectrum term in the halo model assuming NFW haloes\n*/\ndouble ccl_twohalo_matter_power(ccl_cosmology *cosmo, double k, double a, int *status){\n\n // Get the integral\n double I2h = two_halo_integral(cosmo, k, a, status);\n\n // The addative correction is the missing part of the integral below the lower-mass limit\n double A = 1.-two_halo_integral(cosmo, 0., a, status);\n\n // Virial overdensity for haloes\n double odelta = Dv_BryanNorman(cosmo, a, status);\n\n // ...multiplied by the ratio of window functions\n double W1 = window_function(cosmo, cosmo->gsl_params.HM_MMIN, k, a, odelta, ccl_nfw, status);\n double W2 = window_function(cosmo, cosmo->gsl_params.HM_MMIN, 0., a, odelta, ccl_nfw, status);\n A = A*W1/W2;\n\n // Add the additive correction to the calculated integral\n I2h = I2h+A;\n\n return ccl_linear_matter_power(cosmo, k, a, status)*I2h*I2h;\n\n}\n\n/*----- ROUTINE: ccl_onehalo_matter_power -----\nINPUT: cosmology, wavenumber [Mpc^-1], scale factor\nTASK: Computes the one-halo power spectrum term in the halo model assuming NFW haloes\n*/\ndouble ccl_onehalo_matter_power(ccl_cosmology *cosmo, double k, double a, int *status){\n\n return one_halo_integral(cosmo, k, a, status);\n\n}\n\n/*----- ROUTINE: ccl_onehalo_matter_power -----\nINPUT: cosmology, wavenumber [Mpc^-1], scale factor\nTASK: Computes the halo model power spectrum by summing the two- and one-halo terms\n*/\ndouble ccl_halomodel_matter_power(ccl_cosmology *cosmo, double k, double a, int *status){\n\n\n // This matter power spectrum method doesn't work if mu / Sigma parameterisation of modified gravity\n // Is turned on:\n if (fabs(cosmo->params.mu_0)>1e-14 || fabs(cosmo->params.sigma_0)>1e-14){\n\t *status = CCL_ERROR_NOT_IMPLEMENTED;\n\t strcpy(cosmo->status_message,\n \"ccl_halofmod.c: ccl_halomodel_matter_power(): The halo model power spectrum \"\n \"is not implemented the mu / Sigma modified gravity parameterisation.\\n\");\n\t return NAN;\n }\n\n // Standard sum of two- and one-halo terms\n return ccl_twohalo_matter_power(cosmo, k, a, status)+ccl_onehalo_matter_power(cosmo, k, a, status);\n\n}\n", "meta": {"hexsha": "659c7ae6a002267380647f758b0f08dfa0c6647a", "size": 11134, "ext": "c", "lang": "C", "max_stars_repo_path": "src/ccl_halomod.c", "max_stars_repo_name": "benediktdiemer/CCL", "max_stars_repo_head_hexsha": "3a5f9dec72c6ce602ac8b11ceed0ee6c0460a926", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/ccl_halomod.c", "max_issues_repo_name": "benediktdiemer/CCL", "max_issues_repo_head_hexsha": "3a5f9dec72c6ce602ac8b11ceed0ee6c0460a926", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/ccl_halomod.c", "max_forks_repo_name": "benediktdiemer/CCL", "max_forks_repo_head_hexsha": "3a5f9dec72c6ce602ac8b11ceed0ee6c0460a926", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2021-02-10T07:35:07.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-10T07:35:07.000Z", "avg_line_length": 30.8421052632, "max_line_length": 125, "alphanum_fraction": 0.6865457158, "num_tokens": 3408, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8705972684083608, "lm_q2_score": 0.6039318337259584, "lm_q1q2_score": 0.5257814047466717}} {"text": "//IN method.\n//Linear transformation (weights only, no biases) of Ni inputs to No outputs.\n//This version uses CBLAS\n\n//Input X has Ni neurons and output Y has No neurons.\n\n//The vecs of length Ni are always contiguous in memory, such that:\n\n//If col-major: Y[:,l] = W' * X[:,l]\n//where:\n//X has size Ni x L\n//Y has size No x L\n//W has size Ni x No\n\n//If row-major: Y[l,:] = X[l,:] * W'\n//X has size L x Ni\n//Y has size L x No\n//W has size No x Ni\n\n//For a different set-up that allows linear transformation of vecs in\n//any orientation, use the linear function from math.\n\n//I retain the for loop through L for compatibility with real-time streaming.\n\n#include \n\n#ifdef __cplusplus\nnamespace codee {\nextern \"C\" {\n#endif\n\nint linear_cblas_s (float *Y, const float *X, const float *W, const size_t Ni, const size_t No, const size_t L);\nint linear_cblas_d (double *Y, const double *X, const double *W, const size_t Ni, const size_t No, const size_t L);\nint linear_cblas_c (float *Y, const float *X, const float *W, const size_t Ni, const size_t No, const size_t L);\nint linear_cblas_z (double *Y, const double *X, const double *W, const size_t Ni, const size_t No, const size_t L);\n\n\nint linear_cblas_s (float *Y, const float *X, const float *W, const size_t Ni, const size_t No, const size_t L)\n{\n for (size_t l=L; l>0u; --l, X+=Ni, Y+=No)\n {\n cblas_sgemv(CblasRowMajor,CblasNoTrans,(int)No,(int)Ni,1.0f,W,(int)Ni,X,1,0.0f,Y,1);\n }\n\n return 0;\n}\n\n\nint linear_cblas_d (double *Y, const double *X, const double *W, const size_t Ni, const size_t No, const size_t L)\n{\n for (size_t l=L; l>0u; --l, X+=Ni, Y+=No)\n {\n cblas_dgemv(CblasRowMajor,CblasNoTrans,(int)No,(int)Ni,1.0,W,(int)Ni,X,1,0.0,Y,1);\n }\n\n return 0;\n}\n\n\nint linear_cblas_c (float *Y, const float *X, const float *W, const size_t Ni, const size_t No, const size_t L)\n{\n const float z[2] = {0.0f,0.0f}, o[2] = {1.0f,0.0f};\n\n for (size_t l=L; l>0u; --l, X+=2u*Ni, Y+=2u*No)\n {\n cblas_cgemv(CblasRowMajor,CblasNoTrans,(int)No,(int)Ni,o,W,(int)Ni,X,1,z,Y,1);\n }\n\n return 0;\n}\n\n\nint linear_cblas_z (double *Y, const double *X, const double *W, const size_t Ni, const size_t No, const size_t L)\n{\n const double z[2] = {0.0,0.0}, o[2] = {1.0,0.0};\n\n for (size_t l=L; l>0u; --l, X+=2u*Ni, Y+=2u*No)\n {\n cblas_zgemv(CblasRowMajor,CblasNoTrans,(int)No,(int)Ni,o,W,(int)Ni,X,1,z,Y,1);\n }\n\n return 0;\n}\n\n\n#ifdef __cplusplus\n}\n}\n#endif\n", "meta": {"hexsha": "f852a9a33c3875682bc438c55007e9408b43df7d", "size": 2472, "ext": "c", "lang": "C", "max_stars_repo_path": "c/linear.cblas.c", "max_stars_repo_name": "erikedwards4/nn", "max_stars_repo_head_hexsha": "c4b8317a38a72a16fd0bf905791b6c19e49c0aa7", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2020-08-26T09:28:40.000Z", "max_stars_repo_stars_event_max_datetime": "2020-08-26T09:28:40.000Z", "max_issues_repo_path": "c/linear.cblas.c", "max_issues_repo_name": "erikedwards4/nn", "max_issues_repo_head_hexsha": "c4b8317a38a72a16fd0bf905791b6c19e49c0aa7", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "c/linear.cblas.c", "max_forks_repo_name": "erikedwards4/nn", "max_forks_repo_head_hexsha": "c4b8317a38a72a16fd0bf905791b6c19e49c0aa7", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.4666666667, "max_line_length": 115, "alphanum_fraction": 0.6504854369, "num_tokens": 867, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8596637577007394, "lm_q2_score": 0.611381973294151, "lm_q1q2_score": 0.525582924552543}} {"text": "/*++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n* Program fwhm_by_modsq \n* to compute the Full Width at Half Maximum of an equivalent long exposure\n* with the power spectrum (square modulus of the FFT) \n* (by fitting a Kolmogorof law)\n*\n* JLP \n* Version 11-05-99\n-------------------------------------------------------------------*/\n/*\n#define DEBUG\n*/\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nstatic int fit_kolmo_center(float *in_image, int nx, int ny,\n float *sigx, float *sigy);\nstatic int aris_r0calc(float *modsq, int nx, int ny, float *r0);\n\nmain(argc,argv)\nint argc;\nchar *argv[];\n{\nchar in_name[61], comments[81];\nfloat *in_image, *testi;\nINT_PNTR pntr_image;\nINT4 istatus, nx, ny;\nfloat sigx, sigy; \nregister int i, j;\n\nprintf(\" Program FWHM_BY_MODSQ to compute the Full Width at Half Maximum from the power spectrum)\\n\");\nprintf(\" JLP Version 11-05-99 \\n\");\n\n/* One parameters only is allowed to run the program: */\n/* Carefull: 7 parameters always, using JLP \"runs\" */\nif(argc == 7 && *argv[3]) argc = 4;\nif(argc == 7 && *argv[2]) argc = 3;\nif(argc == 7 && *argv[1]) argc = 2;\nif(argc != 2 && argc != 1)\n {\n printf(\" Syntax: fwhm_by_modsq filename\\n\"); \n printf(\" Fatal: Syntax error: argc=%d\\n\",argc);\n exit(-1);\n }\n\n/* Interactive input of parameters: */\nif (argc == 2 )\n { \n strcpy(in_name,argv[1]);\n }\nelse\n { \n printf(\" Input file := \");scanf(\"%s\",in_name);\n }\n\n/**********************************************************/\n JLP_BEGIN();\n JLP_INQUIFMT();\n istatus = JLP_VM_READIMAG1(&pntr_image,&nx,&ny,in_name,comments);\n if(istatus != 0) exit(-1);\n\n in_image = (float *) pntr_image;\n/* Computing the power spectrum (for debug purpose) \n testi = (float *)malloc(nx * ny * sizeof(float));\n for(i = 0; i < nx * ny; i++) testi[i] = 0.;\n\n fftw_float(in_image,testi,nx,ny,1);\n for(i = 0; i < nx * ny; i++) in_image[i] = in_image[i] * in_image[i]\n + testi[i] * testi[i];\n*/\n\n fit_kolmo_center(in_image, nx, ny, &sigx, &sigy);\n\nJLP_END();\n}\n/*****************************************************************\n* To fit a Kolmogorof law to f1(xx,yy)\n*\n* f1: array of values f1(xx[i],yy[i])\n* xx, yy: arrays of coordinates x, y\n* npts: number of points\n*\n* Parameters:\n* sigx, sigy, xc, yc, rho\n* error[sigx,sigy,xc,yc,rho]\n*\n* ifail = 0 if correct\n* -3: all values are negative or null!\n*****************************************************************/\nstatic int fit_kolmo_center(float *in_image, INT4 nx, INT4 ny,\n float *sigx, float *sigy)\n{\nfloat *ff2, *gg; \nINT4 istatus, npts, ifail, nx1, ny1, istart, jstart, iw, jw;\nfloat aa, bb, r0, fwhm; \nregister int i, j;\n\nnx1 = 20; ny1 = 20; \nistart = nx/2 - nx1/2;\njstart = ny/2 - ny1/2;\nff2 = (float *) malloc(nx1 * ny1 * sizeof(float));\ngg = (float *) malloc(nx1 * ny1 * sizeof(float));\nif(ff2 == NULL || gg == NULL)\n {\n printf(\"FWHM/Fatal error alocating memory space \\n\");\n exit(-1);\n }\n#ifdef DEBUG\nprintf(\" istart=%d jstart=%d nx1=%d ny1=%d\\n\",istart,jstart,nx1,ny1);\n#endif\nfor(j = 0; j < ny1; j++)\n for(i = 0; i < nx1; i++)\n {\n iw = i + istart;\n jw = j + jstart;\n ff2[i + j * nx1] = (iw - nx/2) * (iw - nx/2) + (jw - ny/2) * (jw - ny/2); \n gg[i + j * nx1] = in_image[iw + jw * nx];\n }\nnpts = nx1 * ny1;\n\njlp_fit_kolmogorof(ff2, gg, &npts, &aa, &bb, &ifail); \n\n/* JLP99: I notice that the ratio between long exposure determination\n* and this program is about 15: */\nfwhm = pow((double)(bb/6.88),-0.6)/15.;\n/* fwhm = lambda /r0 */\nr0 = 1./fwhm;\n#ifdef DEBUG\nprintf(\" Full Kolmogorov fit: aa=%f bb=%f r0=%f fwhm~%f (10 mm)\\n\",\n aa,bb,r0,fwhm); \n#else\nprintf(\" Full Kolmogorov fit: r0=%f fwhm~%f (10 mm)\\n\",r0,fwhm); \n#endif\n\naris_r0calc(in_image, nx, ny, &r0);\n/* To make it compatible with the previous fit: */\nr0 *= 4.;\nprintf(\" Eric Aristidi approximation: r0=%f fwhm=%f\\n\",r0,1./r0);\n\nreturn(0);\n}\n\n/***************************************************************\n* fit_kolmogorof\n* To fit a Kolmogorof law to Log_intensity(|x|^2) as a function of\n* in x^2 + y^2\n*\n* g(f) = rho * exp [ -6.88 * (lambda * f / r_0)^5/3 ]\n*\n* g(f) = rho * exp [ - b * f^5/3 ] with b = 6.88 * (lambda / r_0)^5/3\n*\n* Log_Intensity(x,y) \n* G(f) = a - b f^(5/3) with f^2 = x^2 + y^2 \n*\n* where:\n* The problem is to find the coefficients (a, b)\n* which minimize the sums:\n* SUM on all the selected disk (x, y) of ( Log_intensity - G(x,y) ) **2\n*\n* The normal equation can be written as: \n*\n* n a - b SUM f^5/3 = SUM Log_g\n* a SUM f^5/3 - b SUM f^10/3 = SUM f^5/3 Log_g\n*\n* Hence:\n* a = 1/n * (SUM Log_g + b SUM f^5/3)\n* b = (SUM f^5/3 Log_g - 1/n SUM Log_g SUM f^5/3)\n* / ( 1/n * SUM f^5/3 * SUM f^5/3 - SUM f^10/3)\n*\n* where n is the number of points (SUM 1)\n*\n*\n* gg: array of values gg(xx[i],yy[i])\n*\n* ff2: arrays of x^2 + y^2\n* npts: number of points\n*\n* ifail = 0 if correct\n* -3: all values are negative or null!\n*****************************************************************/\nint jlp_fit_kolmogorof(float *ff2, float *gg, INT4 *npts,\n float *aa, float *bb, INT4 *ifail)\n{\n/* gg measured intensities */\n/* log_g log of measured intensities */\ndouble *log_g, *ff;\ndouble sum_g, sum_f1, sum_f2, sum_gf, w1;\nregister int i, j, k;\n\n*ifail = 0;\n\n if((log_g = (double *) malloc(*npts * sizeof(double))) == NULL ||\n (ff = (double *) malloc(*npts * sizeof(double))) == NULL )\n {\n printf(\"jlp_fit_gauss/Error allocating memory for array (npts=%d)\\n\",*npts);\n *ifail = -1;\n return(-1);\n }\n\n/* Transfer to double precision arrays and conversion of intensity to Log : */\ni = 0;\nfor(k = 0; k < *npts; k++)\n {\n if(gg[k] > 0) \n {\n log_g[i] = log((double)gg[k]); \n ff[i] = ff2[k]; \n i++;\n }\n }\n*npts = i;\n\nif(*npts == 0)\n {\n printf(\"jlp_fit_gauss/All input values are null!\\n\");\n *ifail = -1;\n return(-1);\n }\n\n/* Compute the sums: 5/3 = 1.667 (but 5/6=0.833 since x^2+y^2)*/\n/* Compute the sums: 10/3 = 0.833 (but 5/3=1.667 since x^2+y^2)*/\nsum_f1 = 0.; sum_f2 = 0.;\nsum_g = 0.; sum_gf = 0.;\nfor(k = 0; k < *npts; k++)\n {\n w1 = pow(ff[k],0.833);\n sum_f1 += w1; \n sum_f2 += pow(ff[k],1.667);\n sum_g += log_g[k];\n sum_gf += w1 * log_g[k];\n }\n\n#ifdef DEBUG\nprintf(\"sum_f1=%f sum_f2=%f sum_g=%f sum_gf=%f npts=%d\\n\",\n sum_f1,sum_f2,sum_g,sum_gf,*npts);\n#endif\n/* Result: \n* a = 1/n * (SUM Log_g + b SUM f^5/3)\n* b = (SUM f^5/3 Log_g - 1/n SUM Log_g SUM f^5/3)\n* / ( 1/n * SUM f^5/3 * SUM f^5/3 - SUM f^10/3)\n*/\n *bb = (sum_gf - (1. / *npts) * sum_g * sum_f1) \n / ( (1. / *npts) * sum_f1 * sum_f1 - sum_f2);\n *aa = (1. / *npts) * (sum_g + *bb * sum_f1);\n\nreturn(0);\n}\n/**********************************************************/\n/* Eric Aristidi's fit (approximation only) */\nstatic int aris_r0calc(float *modsq, int nx, int ny, float *r0)\n{\nint f12_1, f12_2, dim, ixc, iyc;\nfloat pix,lambda,x,y1,y2,r01,r02;\ndim = nx;\nixc = nx/2;\niyc = ny/2;\n\n x=modsq[ixc + iyc*dim];\n\n f12_1=4;\n y1=modsq[(ixc+f12_1) + iyc * dim] + modsq[ixc + (iyc+f12_1) * dim];\n y1/=2.;\n\n f12_2=3;\n y2=modsq[(ixc+f12_2) + iyc * dim] + modsq[ixc + (iyc+f12_2) * dim];\n y2/=2.;\n\n// Compute r0\n// ---------\n pix=0.0119/206265.;lambda=0.00000065;\n r01=pow(3.44/log(x/y1),0.6)*lambda*(float)f12_1/pix/dim;\n r02=pow(3.44/log(x/y2),0.6)*lambda*(float)f12_2/pix/dim;\n *r0=(r02+r01)/2.;\n}\n\n", "meta": {"hexsha": "cab274427daf51309424d98dc9001c0b7c3dfc2d", "size": 7543, "ext": "c", "lang": "C", "max_stars_repo_path": "fwhm_by_modsq.c", "max_stars_repo_name": "jlprieur/sourcc", "max_stars_repo_head_hexsha": "bf00cc91d9669f6e4ed51b89df357fb27eead711", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "fwhm_by_modsq.c", "max_issues_repo_name": "jlprieur/sourcc", "max_issues_repo_head_hexsha": "bf00cc91d9669f6e4ed51b89df357fb27eead711", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "fwhm_by_modsq.c", "max_forks_repo_name": "jlprieur/sourcc", "max_forks_repo_head_hexsha": "bf00cc91d9669f6e4ed51b89df357fb27eead711", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.7482269504, "max_line_length": 102, "alphanum_fraction": 0.5397056874, "num_tokens": 2731, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7981867777396212, "lm_q2_score": 0.6584175139669997, "lm_q1q2_score": 0.5255401538806515}} {"text": "#include \n#include \n#include \n#include \n#include \n\n#include \"cnn_calc.h\"\n#include \"cnn_init.h\"\n#include \"cnn_private.h\"\n\ninline void cnn_restrict(float* mat, int size, float limit)\n{\n for (int __i = 0; __i < size; __i++)\n {\n mat[__i] = fminf(mat[__i], limit);\n }\n}\n\nvoid cnn_mat_update(struct CNN_MAT* matPtr, float lRate, float limit)\n{\n int size = matPtr->rows * matPtr->cols;\n\n // Limit gradient and update weight\n#ifdef CNN_WITH_CUDA\n cnn_fminf_gpu(matPtr->grad, matPtr->grad, size, limit);\n cublasSaxpy(cnnInit.blasHandle, size, &lRate, matPtr->grad, 1, matPtr->mat,\n 1);\n#else\n cnn_restrict(matPtr->grad, size, limit);\n cblas_saxpy(size, lRate, matPtr->grad, 1, matPtr->mat, 1);\n#endif\n\n // Clear gradient\n#ifdef CNN_WITH_CUDA\n cudaMemset\n#else\n memset\n#endif\n (matPtr->grad, 0, size * sizeof(float));\n}\n\nvoid cnn_update(cnn_t cnn, float lRate, float gradLimit)\n{\n int i;\n struct CNN_CONFIG* cfgRef;\n union CNN_LAYER* layerRef;\n\n // Set reference\n layerRef = cnn->layerList;\n cfgRef = &cnn->cfg;\n\n // Update network and clear gradient\n for (i = cfgRef->layers - 1; i > 0; i--)\n {\n // Clear layer gradient\n#ifdef CNN_WITH_CUDA\n cudaMemset\n#else\n memset\n#endif\n (layerRef[i].outMat.data.grad, 0,\n sizeof(float) * layerRef[i].outMat.data.rows *\n layerRef[i].outMat.data.cols);\n\n switch (cfgRef->layerCfg[i].type)\n {\n // Fully connected\n case CNN_LAYER_FC:\n cnn_mat_update(&layerRef[i].fc.weight, lRate, gradLimit);\n cnn_mat_update(&layerRef[i].fc.bias, lRate, gradLimit);\n break;\n\n // Convolution\n case CNN_LAYER_CONV:\n cnn_mat_update(&layerRef[i].conv.kernel, lRate, gradLimit);\n\n#if defined(CNN_CONV_BIAS_FILTER) || defined(CNN_CONV_BIAS_LAYER)\n cnn_mat_update(&layerRef[i].conv.bias, lRate, gradLimit);\n#endif\n break;\n\n // Batch normalization\n case CNN_LAYER_BN:\n cnn_mat_update(&layerRef[i].bn.bnScale, lRate, gradLimit);\n cnn_mat_update(&layerRef[i].bn.bnBias, lRate, gradLimit);\n break;\n\n case CNN_LAYER_INPUT:\n case CNN_LAYER_ACTIV:\n case CNN_LAYER_POOL:\n case CNN_LAYER_DROP:\n break;\n }\n }\n}\n\nstatic inline void cnn_backward_kernel(cnn_t cnn, float* errGrad)\n{\n int i;\n\n struct CNN_CONFIG* cfgRef;\n union CNN_LAYER* layerRef;\n\n // Set reference\n layerRef = cnn->layerList;\n cfgRef = &cnn->cfg;\n\n // Backpropagation\n for (i = cfgRef->layers - 1; i > 0; i--)\n {\n switch (cfgRef->layerCfg[i].type)\n {\n // Fully connected\n case CNN_LAYER_FC:\n cnn_backward_fc(layerRef, cfgRef, i);\n break;\n\n // Activation function\n case CNN_LAYER_ACTIV:\n cnn_backward_activ(layerRef, cfgRef, i);\n break;\n\n // Convolution\n case CNN_LAYER_CONV:\n cnn_backward_conv(layerRef, cfgRef, i);\n break;\n\n // Pooling\n case CNN_LAYER_POOL:\n cnn_backward_pool(layerRef, cfgRef, i);\n break;\n\n // Dropout\n case CNN_LAYER_DROP:\n cnn_backward_drop(layerRef, cfgRef, i);\n break;\n\n // Batch normalization\n case CNN_LAYER_BN:\n cnn_backward_bn(layerRef, cfgRef, i);\n break;\n\n default:\n assert(!\"Invalid layer type\");\n }\n }\n}\n\nvoid cnn_backward(cnn_t cnn, float* errGrad)\n{\n int size;\n\n struct CNN_CONFIG* cfgRef;\n union CNN_LAYER* layerRef;\n\n // Set reference\n layerRef = cnn->layerList;\n cfgRef = &cnn->cfg;\n\n // Copy gradient vector\n size = sizeof(float) * layerRef[cfgRef->layers - 1].outMat.data.rows *\n layerRef[cfgRef->layers - 1].outMat.data.cols;\n\n#ifdef CNN_WITH_CUDA\n cudaMemcpy(layerRef[cfgRef->layers - 1].outMat.data.grad, errGrad, size,\n cudaMemcpyHostToDevice);\n#else\n memcpy(layerRef[cfgRef->layers - 1].outMat.data.grad, errGrad, size);\n#endif\n\n // Backpropagation\n cnn_backward_kernel(cnn, errGrad);\n}\n\n#ifdef CNN_WITH_CUDA\nvoid cnn_backward_gpu(cnn_t cnn, float* errGrad)\n{\n int size;\n\n struct CNN_CONFIG* cfgRef;\n union CNN_LAYER* layerRef;\n\n // Set reference\n layerRef = cnn->layerList;\n cfgRef = &cnn->cfg;\n\n // Copy gradient vector\n size = sizeof(float) * layerRef[cfgRef->layers - 1].outMat.data.rows *\n layerRef[cfgRef->layers - 1].outMat.data.cols;\n cudaMemcpy(layerRef[cfgRef->layers - 1].outMat.data.grad, errGrad, size,\n cudaMemcpyDeviceToDevice);\n\n // Backpropagation\n cnn_backward_kernel(cnn, errGrad);\n}\n#endif\n\nstatic inline void cnn_forward_kernel(cnn_t cnn, float* inputMat,\n float* outputMat)\n{\n int i;\n\n struct CNN_CONFIG* cfgRef;\n union CNN_LAYER* layerRef;\n\n // Set reference\n layerRef = cnn->layerList;\n cfgRef = &cnn->cfg;\n\n // Forward computation\n for (i = 1; i < cfgRef->layers; i++)\n {\n switch (cfgRef->layerCfg[i].type)\n {\n // Fully connected\n case CNN_LAYER_FC:\n cnn_forward_fc(layerRef, cfgRef, i);\n break;\n\n // Activation function\n case CNN_LAYER_ACTIV:\n cnn_forward_activ(layerRef, cfgRef, i);\n break;\n\n // Convolution\n case CNN_LAYER_CONV:\n cnn_forward_conv(layerRef, cfgRef, i);\n break;\n\n // Pooling\n case CNN_LAYER_POOL:\n cnn_forward_pool(layerRef, cfgRef, i);\n break;\n\n // Dropout\n case CNN_LAYER_DROP:\n if (cnn->opMode == CNN_OPMODE_TRAIN)\n {\n cnn_forward_drop(layerRef, cfgRef, i);\n }\n else\n {\n cnn_recall_drop(layerRef, cfgRef, i);\n }\n\n break;\n\n // Batch normalization\n case CNN_LAYER_BN:\n if (cnn->opMode == CNN_OPMODE_TRAIN)\n {\n cnn_forward_bn(layerRef, cfgRef, i);\n }\n else\n {\n cnn_recall_bn(layerRef, cfgRef, i);\n }\n\n break;\n\n default:\n assert(!\"Invalid layer type\");\n }\n }\n}\n\nvoid cnn_forward(cnn_t cnn, float* inputMat, float* outputMat)\n{\n int size;\n\n struct CNN_CONFIG* cfgRef;\n union CNN_LAYER* layerRef;\n\n // Set reference\n layerRef = cnn->layerList;\n cfgRef = &cnn->cfg;\n\n // Copy input\n size = sizeof(float) * layerRef[0].outMat.data.rows *\n layerRef[0].outMat.data.cols;\n#ifdef CNN_WITH_CUDA\n cudaMemcpy(layerRef[0].outMat.data.mat, inputMat, size,\n cudaMemcpyHostToDevice);\n#else\n memcpy(layerRef[0].outMat.data.mat, inputMat, size);\n#endif\n\n // Forward computation\n cnn_forward_kernel(cnn, inputMat, outputMat);\n\n // Copy output\n if (outputMat != NULL)\n {\n size = sizeof(float) * layerRef[cfgRef->layers - 1].outMat.data.rows *\n layerRef[cfgRef->layers - 1].outMat.data.cols;\n#ifdef CNN_WITH_CUDA\n cudaMemcpy(outputMat, layerRef[cfgRef->layers - 1].outMat.data.mat,\n size, cudaMemcpyDeviceToHost);\n#else\n memcpy(outputMat, layerRef[cfgRef->layers - 1].outMat.data.mat, size);\n#endif\n }\n#ifdef CNN_WITH_CUDA\n else\n {\n cudaDeviceSynchronize();\n }\n#endif\n}\n\n#ifdef CNN_WITH_CUDA\nvoid cnn_forward_gpu(cnn_t cnn, float* inputMat, float* outputMat)\n{\n int size;\n\n struct CNN_CONFIG* cfgRef;\n union CNN_LAYER* layerRef;\n\n // Set reference\n layerRef = cnn->layerList;\n cfgRef = &cnn->cfg;\n\n // Copy input\n size = sizeof(float) * layerRef[0].outMat.data.rows *\n layerRef[0].outMat.data.cols;\n cudaMemcpy(layerRef[0].outMat.data.mat, inputMat, size,\n cudaMemcpyDeviceToDevice);\n\n // Forward computation\n cnn_forward_kernel(cnn, inputMat, outputMat);\n\n // Copy output\n if (outputMat != NULL)\n {\n size = sizeof(float) * layerRef[cfgRef->layers - 1].outMat.data.rows *\n layerRef[cfgRef->layers - 1].outMat.data.cols;\n cudaMemcpy(outputMat, layerRef[cfgRef->layers - 1].outMat.data.mat,\n size, cudaMemcpyDeviceToDevice);\n }\n else\n {\n cudaDeviceSynchronize();\n }\n}\n#endif\n", "meta": {"hexsha": "2e4dc5a6d1518a14487dccadfce3dab53f21e15b", "size": 8809, "ext": "c", "lang": "C", "max_stars_repo_path": "src/cnn_calc.c", "max_stars_repo_name": "jamesljlster/cnn", "max_stars_repo_head_hexsha": "8ba35edd4516f6b46a17a1bad672e38667600630", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2020-06-15T07:47:10.000Z", "max_stars_repo_stars_event_max_datetime": "2020-06-15T07:47:10.000Z", "max_issues_repo_path": "src/cnn_calc.c", "max_issues_repo_name": "jamesljlster/cnn", "max_issues_repo_head_hexsha": "8ba35edd4516f6b46a17a1bad672e38667600630", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/cnn_calc.c", "max_forks_repo_name": "jamesljlster/cnn", "max_forks_repo_head_hexsha": "8ba35edd4516f6b46a17a1bad672e38667600630", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 25.4595375723, "max_line_length": 79, "alphanum_fraction": 0.5670337155, "num_tokens": 2164, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8244619436290699, "lm_q2_score": 0.6370308082623217, "lm_q1q2_score": 0.5252076583315511}} {"text": "/* specfunc/gsl_sf_lambert.h\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001 Gerard Jungman\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n/* Author: G. Jungman */\n\n#ifndef __GSL_SF_LAMBERT_H__\n#define __GSL_SF_LAMBERT_H__\n\n#include \n\n#undef __BEGIN_DECLS\n#undef __END_DECLS\n#ifdef __cplusplus\n# define __BEGIN_DECLS extern \"C\" {\n# define __END_DECLS }\n#else\n# define __BEGIN_DECLS /* empty */\n# define __END_DECLS /* empty */\n#endif\n\n__BEGIN_DECLS\n\n\n/* Lambert's Function W_0(x)\n *\n * W_0(x) is the principal branch of the\n * implicit function defined by W e^W = x.\n *\n * -1/E < x < \\infty\n *\n * exceptions: GSL_EMAXITER;\n */\nint gsl_sf_lambert_W0_e(double x, gsl_sf_result * result);\ndouble gsl_sf_lambert_W0(double x);\n\n\n/* Lambert's Function W_{-1}(x)\n *\n * W_{-1}(x) is the second real branch of the\n * implicit function defined by W e^W = x.\n * It agrees with W_0(x) when x >= 0.\n *\n * -1/E < x < \\infty\n *\n * exceptions: GSL_MAXITER;\n */\nint gsl_sf_lambert_Wm1_e(double x, gsl_sf_result * result);\ndouble gsl_sf_lambert_Wm1(double x);\n\n\n__END_DECLS\n\n#endif /* __GSL_SF_LAMBERT_H__ */\n", "meta": {"hexsha": "53b70a3a3f7296e9016865d8b73585404fbb2257", "size": 1813, "ext": "h", "lang": "C", "max_stars_repo_path": "315/gsltest/gsl/include/gsl/gsl_sf_lambert.h", "max_stars_repo_name": "shi-bash-cmd/qtTest", "max_stars_repo_head_hexsha": "3eb0cf4b8fcfa2c36e133e4df2b2a3e6d2d3e589", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 77.0, "max_stars_repo_stars_event_min_datetime": "2015-01-18T00:45:00.000Z", "max_stars_repo_stars_event_max_datetime": "2020-12-24T22:20:56.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/specfunc/gsl_sf_lambert.h", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 11.0, "max_issues_repo_issues_event_min_datetime": "2020-05-29T16:26:06.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-07T08:59:52.000Z", "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/specfunc/gsl_sf_lambert.h", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 30.0, "max_forks_repo_forks_event_min_datetime": "2015-02-01T15:12:21.000Z", "max_forks_repo_forks_event_max_datetime": "2021-03-30T23:53:15.000Z", "avg_line_length": 25.9, "max_line_length": 81, "alphanum_fraction": 0.7148372863, "num_tokens": 518, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7341195152660687, "lm_q2_score": 0.7154239897159439, "lm_q1q2_score": 0.5252067125399856}} {"text": "/* specfunc/beta_inc.c\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 2 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n/* Author: G. Jungman */\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"error.h\"\n#include \"check.h\"\n\nstatic\nint\nbeta_cont_frac(\n const double a,\n const double b,\n const double x,\n gsl_sf_result * result\n )\n{\n const unsigned int max_iter = 512; /* control iterations */\n const double cutoff = 2.0 * GSL_DBL_MIN; /* control the zero cutoff */\n unsigned int iter_count = 0;\n double cf;\n\n /* standard initialization for continued fraction */\n double num_term = 1.0;\n double den_term = 1.0 - (a+b)*x/(a+1.0);\n if (fabs(den_term) < cutoff) den_term = cutoff;\n den_term = 1.0/den_term;\n cf = den_term;\n\n while(iter_count < max_iter) {\n const int k = iter_count + 1;\n double coeff = k*(b-k)*x/(((a-1.0)+2*k)*(a+2*k));\n double delta_frac;\n\n /* first step */\n den_term = 1.0 + coeff*den_term;\n num_term = 1.0 + coeff/num_term;\n if(fabs(den_term) < cutoff) den_term = cutoff;\n if(fabs(num_term) < cutoff) num_term = cutoff;\n den_term = 1.0/den_term;\n\n delta_frac = den_term * num_term;\n cf *= delta_frac;\n\n coeff = -(a+k)*(a+b+k)*x/((a+2*k)*(a+2*k+1.0));\n\n /* second step */\n den_term = 1.0 + coeff*den_term;\n num_term = 1.0 + coeff/num_term;\n if(fabs(den_term) < cutoff) den_term = cutoff;\n if(fabs(num_term) < cutoff) num_term = cutoff;\n den_term = 1.0/den_term;\n\n delta_frac = den_term*num_term;\n cf *= delta_frac;\n\n if(fabs(delta_frac-1.0) < 2.0*GSL_DBL_EPSILON) break;\n\n ++iter_count;\n }\n\n result->val = cf;\n result->err = iter_count * 4.0 * GSL_DBL_EPSILON * fabs(cf);\n\n if(iter_count >= max_iter)\n GSL_ERROR (\"error\", GSL_EMAXITER);\n else\n return GSL_SUCCESS;\n}\n\n\n\n/*-*-*-*-*-*-*-*-*-*-*-* Functions with Error Codes *-*-*-*-*-*-*-*-*-*-*-*/\n\nint\ngsl_sf_beta_inc_e(\n const double a,\n const double b,\n const double x,\n gsl_sf_result * result\n )\n{\n if(a <= 0.0 || b <= 0.0 || x < 0.0 || x > 1.0) {\n DOMAIN_ERROR(result);\n }\n else if(x == 0.0) {\n result->val = 0.0;\n result->err = 0.0;\n return GSL_SUCCESS;\n }\n else if(x == 1.0) {\n result->val = 1.0;\n result->err = 0.0;\n return GSL_SUCCESS;\n }\n else {\n gsl_sf_result ln_beta;\n gsl_sf_result ln_x;\n gsl_sf_result ln_1mx;\n gsl_sf_result prefactor;\n const int stat_ln_beta = gsl_sf_lnbeta_e(a, b, &ln_beta);\n const int stat_ln_1mx = gsl_sf_log_1plusx_e(-x, &ln_1mx);\n const int stat_ln_x = gsl_sf_log_e(x, &ln_x);\n const int stat_ln = GSL_ERROR_SELECT_3(stat_ln_beta, stat_ln_1mx, stat_ln_x);\n\n const double ln_pre_val = -ln_beta.val + a * ln_x.val + b * ln_1mx.val;\n const double ln_pre_err = ln_beta.err + fabs(a*ln_x.err) + fabs(b*ln_1mx.err);\n const int stat_exp = gsl_sf_exp_err_e(ln_pre_val, ln_pre_err, &prefactor);\n\n if(stat_ln != GSL_SUCCESS) {\n result->val = 0.0;\n result->err = 0.0;\n GSL_ERROR (\"error\", GSL_ESANITY);\n }\n\n if(x < (a + 1.0)/(a+b+2.0)) {\n /* Apply continued fraction directly. */\n gsl_sf_result cf;\n const int stat_cf = beta_cont_frac(a, b, x, &cf);\n int stat;\n result->val = prefactor.val * cf.val / a;\n result->err = (fabs(prefactor.err * cf.val) + fabs(prefactor.val * cf.err))/a;\n\n stat = GSL_ERROR_SELECT_2(stat_exp, stat_cf);\n if(stat == GSL_SUCCESS) {\n CHECK_UNDERFLOW(result);\n }\n return stat;\n }\n else {\n /* Apply continued fraction after hypergeometric transformation. */\n gsl_sf_result cf;\n const int stat_cf = beta_cont_frac(b, a, 1.0-x, &cf);\n int stat;\n const double term = prefactor.val * cf.val / b;\n result->val = 1.0 - term;\n result->err = fabs(prefactor.err * cf.val)/b;\n result->err += fabs(prefactor.val * cf.err)/b;\n result->err += 2.0 * GSL_DBL_EPSILON * (1.0 + fabs(term));\n stat = GSL_ERROR_SELECT_2(stat_exp, stat_cf);\n if(stat == GSL_SUCCESS) {\n CHECK_UNDERFLOW(result);\n }\n return stat;\n }\n }\n}\n\n\n/*-*-*-*-*-*-*-*-*-* Functions w/ Natural Prototypes *-*-*-*-*-*-*-*-*-*-*/\n\n#include \"eval.h\"\n\ndouble gsl_sf_beta_inc(const double a, const double b, const double x)\n{\n EVAL_RESULT(gsl_sf_beta_inc_e(a, b, x, &result));\n}\n", "meta": {"hexsha": "bd840b61083fdc533e6f12e75ac645d7086751dc", "size": 5097, "ext": "c", "lang": "C", "max_stars_repo_path": "pkgs/libs/gsl/src/specfunc/beta_inc.c", "max_stars_repo_name": "manggoguy/parsec-modified", "max_stars_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 64.0, "max_stars_repo_stars_event_min_datetime": "2015-03-06T00:30:56.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-24T13:26:53.000Z", "max_issues_repo_path": "pkgs/libs/gsl/src/specfunc/beta_inc.c", "max_issues_repo_name": "manggoguy/parsec-modified", "max_issues_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 12.0, "max_issues_repo_issues_event_min_datetime": "2020-12-15T08:30:19.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-13T03:54:24.000Z", "max_forks_repo_path": "pkgs/libs/gsl/src/specfunc/beta_inc.c", "max_forks_repo_name": "manggoguy/parsec-modified", "max_forks_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 40.0, "max_forks_repo_forks_event_min_datetime": "2015-02-26T15:31:16.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-03T23:23:37.000Z", "avg_line_length": 28.1602209945, "max_line_length": 84, "alphanum_fraction": 0.6289974495, "num_tokens": 1570, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.757794360334681, "lm_q2_score": 0.6926419894793248, "lm_q1q2_score": 0.5248801933584257}} {"text": "/**\n * Copyright 2019 José Manuel Abuín Mosquera \n * \n * This file is part of Matrix Market Suite.\n *\n * Matrix Market Suite is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * Matrix Market Suite is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with Matrix Market Suite. If not, see .\n */\n\n#include \n#include \"ConjugateGradientSolver.h\"\n#include \n\n/* Include redundant execution header. */\n#include \"../../../include/ourRMTlib.h\"\n\n\n\nint ipow(int base, int exp)\n{\n int result = 1;\n for (;;)\n {\n if (exp & 1)\n result *= base;\n exp >>= 1;\n if (!exp)\n break;\n base *= base;\n }\n\n return result;\n}\n\n\nint ConjugateGradientSolver(unsigned long *II, unsigned long *J, double *A, unsigned long M, unsigned long N, \n\tunsigned long long nz, double *b, unsigned long M_Vector, unsigned long N_Vector, unsigned long long nz_vector, \n\tdouble *x, int iterationNumber, int F, int *ret_code) {\n\t\n\t//A*x=b\n\n double *Ap=(double *) malloc(nz_vector * sizeof(double));\n double *r=(double *) malloc(nz_vector * sizeof(double));\n double *p=(double *) malloc(nz_vector * sizeof(double));\n \n \n\t//double *x=(double *) calloc(nz_vector,sizeof(double));\n\n\t//r = b-A*x\n\t//If we take x=0 the init multiplication is avoided and r=b\n\t\n\tmemcpy(r, b, N*sizeof(double));\n\t\n\t\n\t//p=r\n\n\tmemcpy(p, r, N*sizeof(double));\n\t\n\t\n\t\n\t//rsold = r'*r\n\tdouble rsold = cblas_ddot(N,r,1,r,1);\n\tdouble rs_0 = cblas_ddot(N,r,1,r,1);\n\t\n\tint stop = 0;\n\t\t\n\tdouble alphaCG = 0.0;\n\t\t\n\tdouble rsnew = 0.0, rsnew2 = 0.0;\n\tunsigned long k = 0, selfCG_k=0;\n\t\n\tunsigned long maxIterations = M*2;\n\t\n\tif(iterationNumber != 0 ){\n\t\tmaxIterations = iterationNumber;\n\t}\n\n\tint flag=0;\n\t\n\twhile(!stop){\n\t\t\n\t\t//if( ((k+1) % F == 0) ){ //execute CG reliably\n\t\t//if(k == pow((double)F, (double)(selfCG_k+1))){\n\t\tif(k == ipow(F, (selfCG_k+1))){\n\t\t\t\t//fprintf(stderr, \"F:%d k:%lu selfCG_k:%lu \\n\",F,k, selfCG_k);\n\t\t\t\t\t\t\t\t\n\t\t\t\t//Ap=A*p\n\t\t\t\tcblas_dgemv(CblasRowMajor, CblasNoTrans, M,N , 1.0, A, N, p, 1, 0.0, Ap, 1);\n\t\t\t\t\n\t\t\t\t//r=A*x\n\t\t\t\tcblas_dgemv(CblasRowMajor, CblasNoTrans, M,N , 1.0, A, N, x, 1, 0.0, r, 1);\n\t\t\t\t\n\t\t\t\t//r=b-r\t\n\t\t\t\tcblas_dscal(N, -1, r, 1); //r = -r\n\t\t\t\tcblas_daxpy(N, 1, b, 1, r, 1); //r = r + b\n\t\t\t\t\n\t\t\t\t\n\t\t\t\t//alphaCG=r'*p /(p'*Ap)\n\t\t\t\talphaCG = cblas_ddot(N,r,1,p,1)/cblas_ddot(N,p,1,Ap,1);\n\t\t\t\t\n\t\t\t\t//x=x+alphaCG*p\n\t\t\t\tcblas_daxpy(N,alphaCG,p,1,x,1);\n\t\t\t\t\n\t\t\t\t//r=r-alphaCG*Ap\n\t\t\t\tcblas_daxpy(N,-alphaCG,Ap,1,r,1);\n\t\t\t\t\n\t\t\t\t//rsnew = r'*r\n\t\t\t\trsnew = cblas_ddot(N,r,1,r,1);\n\t\t\t\t\n\t\t\t\t//fprintf(stderr, \"k:%ld F_iteration:%ld alphaCG:%.10f error:%.10f\\n\",k,selfCG_k,alphaCG, sqrt(rsnew));\n\t\t\t\t\n\t\t\t\t// p=r+((-r'*Ap/(p'*Ap))*p) \n\t\t\t\tcblas_dscal(N, -(cblas_ddot(N,r,1,Ap,1)/cblas_ddot(N,p,1,Ap,1)), p, 1);\n\t\t\t\tcblas_daxpy(N,1.0,r,1,p,1);\n\t\t\t\t\t\t\t\t\n\t\t\t\tselfCG_k++;\n\t\t\t\tflag=0;\n\t\t\t\t\n\t\t}else{\n\t\n\t\t\t\t//Ap=A*p\n\t\t\n\t\t\t\tcblas_dgemv(CblasRowMajor, CblasNoTrans, M,N , 1.0, A, N, p, 1, 0.0, Ap, 1);\n\t\t\t\n\n\t\t\t\t//alphaCG=rsold/(p'*Ap)\n\t\t\t\talphaCG = rsold/cblas_ddot(N,p,1,Ap,1);\n\t\t\t\t\n\t\t\t\t//x=x+alphaCG*p\n\t\t\t\tcblas_daxpy(N,alphaCG,p,1,x,1);\n\n\t\t\t\t//r=r-alphaCG*Ap\n\t\t\t\tcblas_daxpy(N,-alphaCG,Ap,1,r,1);\n\t\t\t\n\t\t\t\t//rsnew = r'*r\n\t\t\t\trsnew = cblas_ddot(N,r,1,r,1);\n\t\t\t\t//fprintf(stderr, \"k:%ld alphaCG:%.10f error:%.10f\\n\",k,alphaCG, sqrt(rsnew));\n\t\t\t\t\n\t\t\t\t//p=r+rsnew/rsold*p\n\t\t\t\tcblas_dscal(N, rsnew/rsold, p, 1);\n\t\t\t\tcblas_daxpy(N,1.0,r,1,p,1);\n\t\t\t\t\n\t\t\t\trsold = rsnew;\n\t\t\t\t\n\t\t\t\tif(isnan(alphaCG)){ //checking whether alphaCG is nan!\n\t\t\t\t\tfprintf(stderr, \"!!! alphaCG:%.10f\\n\", alphaCG);\n\t\t\t\t\texit(-1);\n\t\t\t\t}\n\t\t}\n\t\tk++;\n\t\t\n\t\t//if((sqrt(rsnew)<=EPSILON)||(k == maxIterations)){\n\t\tif(sqrt(rsnew)/sqrt(rs_0)<=EPSILON){\n\t\t\tstop = 1;\n\t\t\tfprintf(stderr, \"STOPPED by CG\\n\");\n\t\t}\n\t\t\t\t\n\t}\n\t\n\t//memcpy(b, x, N*sizeof(double));\n\n free(Ap);\n free(r);\n free(p);\n\t//free(x);\n\n\tfprintf(stderr, \"[%s] Number of total iterations: %lu Number of iterations in SS step:%lu \\n\",__func__,k, selfCG_k);\n\n *ret_code=1;\n\treturn 1;\n}\n\n\n\n", "meta": {"hexsha": "dd3e06069903e82ff588cf68e0542d39926c69c2", "size": 4502, "ext": "c", "lang": "C", "max_stars_repo_path": "applications/others/sscg/ConjugateGradientSolver.c", "max_stars_repo_name": "sanemarslan/RMTLib", "max_stars_repo_head_hexsha": "8e7ab9d3491e40d9e5e77f67956752cc1178b1b4", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "applications/others/sscg/ConjugateGradientSolver.c", "max_issues_repo_name": "sanemarslan/RMTLib", "max_issues_repo_head_hexsha": "8e7ab9d3491e40d9e5e77f67956752cc1178b1b4", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "applications/others/sscg/ConjugateGradientSolver.c", "max_forks_repo_name": "sanemarslan/RMTLib", "max_forks_repo_head_hexsha": "8e7ab9d3491e40d9e5e77f67956752cc1178b1b4", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 24.3351351351, "max_line_length": 117, "alphanum_fraction": 0.5888494003, "num_tokens": 1547, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7799929002541068, "lm_q2_score": 0.6723317057447908, "lm_q1q2_score": 0.5244139570966702}} {"text": "/*\n * Copyright 2014 Marc Normandin\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/*\n * pso.h\n *\n * Created on: Jun 30, 2013\n * Author: marc\n */\n\n#ifndef PSO_H_\n#define PSO_H_\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"rng.h\"\n#include \"dim.h\"\n#include \"particle.h\"\n\ntemplate\nclass PSO\n{\npublic:\n // This routine is used by the PSO unit test\n PSO(const unsigned int numParticles, const std::vector& dim,\n const gslseed_t seed, FitnessFunction& fitnessFunction, const unsigned int maxIterations)\n : mNumParticles(numParticles), mGBest(dim), mDim(dim), mRng(seed), mFitnessFunction(fitnessFunction),\n mMaxIterations(maxIterations)\n {\n mParticles.reserve(mNumParticles);\n }\n\n unsigned int getNumParticles() const\n {\n return mNumParticles;\n }\n\n const Particle& iterate()\n {\n createRandomParticles();\n\n unsigned int numIterations = 0;\n std::vector particleFitnesses(mParticles.size());\n do\n {\n // Evaluate the fitness/objective function\n \tmFitnessFunction(mParticles, &particleFitnesses);\n\n //For each particle\n for (unsigned int i = 0; i < mParticles.size(); i++)\n {\n // Calculate fitness value\n const prob_t fitness = particleFitnesses[i]; //\n\n // If the fitness value is better than the best fitness value (pBest) in history\n // set current value as the new pBest\n mParticles[i].updateFitness( fitness );\n }\n\n // Choose the particle with the best fitness value of all the particles as the gBest\n std::vector::const_iterator best = std::max_element(mParticles.begin(), mParticles.end());\n mGBest = Particle( best->getBestPosition(), best->getBestFitness() );\n\n // Update the inertia weight\n const double inertiaWeight = computeInertiaWeight(numIterations, mMaxIterations);\n \n // For each particle\n for (unsigned int i = 0; i < mParticles.size(); i++)\n {\n mParticles[i].updatePosition( mGBest, mDim, mCognitiveWeight, mSocialWeight, mRng, inertiaWeight );\n }\n\n numIterations++;\n }\n while(numIterations < mMaxIterations);\n\n return mGBest;\n }\n\nprotected:\n PSO(const PSO&);\n void operator=(const PSO&);\n \n void createRandomParticles() {\n mParticles.clear(); // Remove previous particles in the container\n \n // For each particle\n for (unsigned int i = 0; i < mNumParticles; i++)\n {\n std::vector pos;\n \n // For each dimension\n for (unsigned int d = 0; d < mDim.size(); d++)\n {\n dim_t posd = mRng.uniform( mDim[d].min(), mDim[d].max() );\n pos.push_back(posd);\n }\n \n // Add the particle to the collection\n mParticles.push_back( Particle(pos) );\n }\n }\n\n // Compute inertia. This is based on equation 4.1 from:\n // http://www.hindawi.com/journals/ddns/2010/462145/\n double computeInertiaWeight(const unsigned int iteration, const unsigned int maxInterations) const\n {\n // Note. We add +1 because our iterations go from 0 to max-1.\n double inertiaWeight = (mOmega1 - mOmega2) * ( (maxInterations - (iteration+1.0)) / (1.0 * (iteration+1.0) ) ) + mOmega2;\n return inertiaWeight;\n }\n\nprivate:\n unsigned int mNumParticles;\n std::vector \tmParticles; // Particle positions\n Particle \t\t\t\tmGBest;\n std::vector\t\tmDim;\n\n // These values control how random the particle velocities are\n static const double \tmCognitiveWeight;\n static const double \tmSocialWeight;\n \n // These values control the rate of convergence\n static const double mOmega1;\n static const double mOmega2;\n\n RandomNumberGenerator \tmRng;\n\n FitnessFunction& mFitnessFunction;\n unsigned int mMaxIterations;\n};\n\n\n#endif /* PSO_H_ */\n", "meta": {"hexsha": "056e4cb204794070a0df4db8c1743e873c50d4e0", "size": 4844, "ext": "h", "lang": "C", "max_stars_repo_path": "pso.h", "max_stars_repo_name": "marcnormandin/ParticleSwarmOptimization", "max_stars_repo_head_hexsha": "6690fde0de155acd44ba5a3eab4224276f120ed5", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 5.0, "max_stars_repo_stars_event_min_datetime": "2015-05-28T05:27:28.000Z", "max_stars_repo_stars_event_max_datetime": "2018-04-09T21:25:19.000Z", "max_issues_repo_path": "pso.h", "max_issues_repo_name": "marcnormandin/ParticleSwarmOptimization", "max_issues_repo_head_hexsha": "6690fde0de155acd44ba5a3eab4224276f120ed5", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2015-05-27T05:48:44.000Z", "max_issues_repo_issues_event_max_datetime": "2015-06-11T20:48:15.000Z", "max_forks_repo_path": "pso.h", "max_forks_repo_name": "marcnormandin/ParticleSwarmOptimization", "max_forks_repo_head_hexsha": "6690fde0de155acd44ba5a3eab4224276f120ed5", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.8535031847, "max_line_length": 129, "alphanum_fraction": 0.6189099917, "num_tokens": 1106, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7879311956428947, "lm_q2_score": 0.6654105653819836, "lm_q1q2_score": 0.524297742374841}} {"text": "/* randist/binomial_tpe.c\n * \n * Copyright (C) 1996, 2003, 2007 James Theiler, Brian Gough\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n/* The binomial distribution has the form,\n\n f(x) = n!/(x!(n-x)!) * p^x (1-p)^(n-x) for integer 0 <= x <= n\n = 0 otherwise\n\n This implementation follows the public domain ranlib function\n \"ignbin\", the bulk of which is the BTPE (Binomial Triangle\n Parallelogram Exponential) algorithm introduced in\n Kachitvichyanukul and Schmeiser[1]. It has been translated to use\n modern C coding standards.\n\n If n is small and/or p is near 0 or near 1 (specifically, if\n n*min(p,1-p) < SMALL_MEAN), then a different algorithm, called\n BINV, is used which has an average runtime that scales linearly\n with n*min(p,1-p).\n\n But for larger problems, the BTPE algorithm takes the form of two\n functions b(x) and t(x) -- \"bottom\" and \"top\" -- for which b(x) <\n f(x)/f(M) < t(x), with M = floor(n*p+p). b(x) defines a triangular\n region, and t(x) includes a parallelogram and two tails. Details\n (including a nice drawing) are in the paper.\n\n [1] Kachitvichyanukul, V. and Schmeiser, B. W. Binomial Random\n Variate Generation. Communications of the ACM, 31, 2 (February,\n 1988) 216.\n\n Note, Bruce Schmeiser (personal communication) points out that if\n you want very fast binomial deviates, and you are happy with\n approximate results, and/or n and n*p are both large, then you can\n just use gaussian estimates: mean=n*p, variance=n*p*(1-p).\n\n This implementation by James Theiler, April 2003, after obtaining\n permission -- and some good advice -- from Drs. Kachitvichyanukul\n and Schmeiser to use their code as a starting point, and then doing\n a little bit of tweaking.\n\n Additional polishing for GSL coding standards by Brian Gough. */\n\n#define SMALL_MEAN 14 /* If n*p < SMALL_MEAN then use BINV\n algorithm. The ranlib\n implementation used cutoff=30; but\n on my computer 14 works better */\n\n#define BINV_CUTOFF 110 /* In BINV, do not permit ix too large */\n\n#define FAR_FROM_MEAN 20 /* If ix-n*p is larger than this, then\n use the \"squeeze\" algorithm.\n Ranlib used 20, and this seems to\n be the best choice on my machine as\n well */\n\n#define LNFACT(x) gsl_sf_lnfact(x)\n\ninline static double\nStirling (double y1)\n{\n double y2 = y1 * y1;\n double s =\n (13860.0 -\n (462.0 - (132.0 - (99.0 - 140.0 / y2) / y2) / y2) / y2) / y1 / 166320.0;\n return s;\n}\n\nunsigned int\ngsl_ran_binomial_tpe (const gsl_rng * rng, double p, unsigned int n)\n{\n return gsl_ran_binomial (rng, p, n);\n}\n\nunsigned int\ngsl_ran_binomial (const gsl_rng * rng, double p, unsigned int n)\n{\n int ix; /* return value */\n int flipped = 0;\n double q, s, np;\n\n if (n == 0)\n return 0;\n\n if (p > 0.5)\n {\n p = 1.0 - p; /* work with small p */\n flipped = 1;\n }\n\n q = 1 - p;\n s = p / q;\n np = n * p;\n\n /* Inverse cdf logic for small mean (BINV in K+S) */\n\n if (np < SMALL_MEAN)\n {\n double f0 = gsl_pow_uint (q, n); /* f(x), starting with x=0 */\n\n while (1)\n {\n /* This while(1) loop will almost certainly only loop once; but\n * if u=1 to within a few epsilons of machine precision, then it\n * is possible for roundoff to prevent the main loop over ix to\n * achieve its proper value. following the ranlib implementation,\n * we introduce a check for that situation, and when it occurs,\n * we just try again.\n */\n\n double f = f0;\n double u = gsl_rng_uniform (rng);\n\n for (ix = 0; ix <= BINV_CUTOFF; ++ix)\n {\n if (u < f)\n goto Finish;\n u -= f;\n /* Use recursion f(x+1) = f(x)*[(n-x)/(x+1)]*[p/(1-p)] */\n f *= s * (n - ix) / (ix + 1);\n }\n\n /* It should be the case that the 'goto Finish' was encountered\n * before this point was ever reached. But if we have reached\n * this point, then roundoff has prevented u from decreasing\n * all the way to zero. This can happen only if the initial u\n * was very nearly equal to 1, which is a rare situation. In\n * that rare situation, we just try again.\n *\n * Note, following the ranlib implementation, we loop ix only to\n * a hardcoded value of SMALL_MEAN_LARGE_N=110; we could have\n * looped to n, and 99.99...% of the time it won't matter. This\n * choice, I think is a little more robust against the rare\n * roundoff error. If n>LARGE_N, then it is technically\n * possible for ix>LARGE_N, but it is astronomically rare, and\n * if ix is that large, it is more likely due to roundoff than\n * probability, so better to nip it at LARGE_N than to take a\n * chance that roundoff will somehow conspire to produce an even\n * larger (and more improbable) ix. If n= SMALL_MEAN, we invoke the BTPE algorithm */\n\n int k;\n\n double ffm = np + p; /* ffm = n*p+p */\n int m = (int) ffm; /* m = int floor[n*p+p] */\n double fm = m; /* fm = double m; */\n double xm = fm + 0.5; /* xm = half integer mean (tip of triangle) */\n double npq = np * q; /* npq = n*p*q */\n\n /* Compute cumulative area of tri, para, exp tails */\n\n /* p1: radius of triangle region; since height=1, also: area of region */\n /* p2: p1 + area of parallelogram region */\n /* p3: p2 + area of left tail */\n /* p4: p3 + area of right tail */\n /* pi/p4: probability of i'th area (i=1,2,3,4) */\n\n /* Note: magic numbers 2.195, 4.6, 0.134, 20.5, 15.3 */\n /* These magic numbers are not adjustable...at least not easily! */\n\n double p1 = floor (2.195 * sqrt (npq) - 4.6 * q) + 0.5;\n\n /* xl, xr: left and right edges of triangle */\n double xl = xm - p1;\n double xr = xm + p1;\n\n /* Parameter of exponential tails */\n /* Left tail: t(x) = c*exp(-lambda_l*[xl - (x+0.5)]) */\n /* Right tail: t(x) = c*exp(-lambda_r*[(x+0.5) - xr]) */\n\n double c = 0.134 + 20.5 / (15.3 + fm);\n double p2 = p1 * (1.0 + c + c);\n\n double al = (ffm - xl) / (ffm - xl * p);\n double lambda_l = al * (1.0 + 0.5 * al);\n double ar = (xr - ffm) / (xr * q);\n double lambda_r = ar * (1.0 + 0.5 * ar);\n double p3 = p2 + c / lambda_l;\n double p4 = p3 + c / lambda_r;\n\n double var, accept;\n double u, v; /* random variates */\n\n TryAgain:\n\n /* generate random variates, u specifies which region: Tri, Par, Tail */\n u = gsl_rng_uniform (rng) * p4;\n v = gsl_rng_uniform (rng);\n\n if (u <= p1)\n {\n /* Triangular region */\n ix = (int) (xm - p1 * v + u);\n goto Finish;\n }\n else if (u <= p2)\n {\n /* Parallelogram region */\n double x = xl + (u - p1) / c;\n v = v * c + 1.0 - fabs (x - xm) / p1;\n if (v > 1.0 || v <= 0.0)\n goto TryAgain;\n ix = (int) x;\n }\n else if (u <= p3)\n {\n /* Left tail */\n ix = (int) (xl + log (v) / lambda_l);\n if (ix < 0)\n goto TryAgain;\n v *= ((u - p2) * lambda_l);\n }\n else\n {\n /* Right tail */\n ix = (int) (xr - log (v) / lambda_r);\n if (ix > (double) n)\n goto TryAgain;\n v *= ((u - p3) * lambda_r);\n }\n\n /* At this point, the goal is to test whether v <= f(x)/f(m) \n *\n * v <= f(x)/f(m) = (m!(n-m)! / (x!(n-x)!)) * (p/q)^{x-m}\n *\n */\n\n /* Here is a direct test using logarithms. It is a little\n * slower than the various \"squeezing\" computations below, but\n * if things are working, it should give exactly the same answer\n * (given the same random number seed). */\n\n#ifdef DIRECT\n var = log (v);\n\n accept =\n LNFACT (m) + LNFACT (n - m) - LNFACT (ix) - LNFACT (n - ix)\n + (ix - m) * log (p / q);\n\n#else /* SQUEEZE METHOD */\n\n /* More efficient determination of whether v < f(x)/f(M) */\n\n k = abs (ix - m);\n\n if (k <= FAR_FROM_MEAN)\n {\n /* \n * If ix near m (ie, |ix-m| ix)\n {\n int i;\n for (i = ix + 1; i <= m; i++)\n {\n f /= (g / i - s);\n }\n }\n\n accept = f;\n }\n else\n {\n /* If ix is far from the mean m: k=ABS(ix-m) large */\n\n var = log (v);\n\n if (k < npq / 2 - 1)\n {\n /* \"Squeeze\" using upper and lower bounds on\n * log(f(x)) The squeeze condition was derived\n * under the condition k < npq/2-1 */\n double amaxp =\n k / npq * ((k * (k / 3.0 + 0.625) + (1.0 / 6.0)) / npq + 0.5);\n double ynorm = -(k * k / (2.0 * npq));\n if (var < ynorm - amaxp)\n goto Finish;\n if (var > ynorm + amaxp)\n goto TryAgain;\n }\n\n /* Now, again: do the test log(v) vs. log f(x)/f(M) */\n\n#if USE_EXACT\n /* This is equivalent to the above, but is a little (~20%) slower */\n /* There are five log's vs three above, maybe that's it? */\n\n accept = LNFACT (m) + LNFACT (n - m)\n - LNFACT (ix) - LNFACT (n - ix) + (ix - m) * log (p / q);\n\n#else /* USE STIRLING */\n /* The \"#define Stirling\" above corresponds to the first five\n * terms in asymptoic formula for\n * log Gamma (y) - (y-0.5)log(y) + y - 0.5 log(2*pi);\n * See Abramowitz and Stegun, eq 6.1.40\n */\n\n /* Note below: two Stirling's are added, and two are\n * subtracted. In both K+S, and in the ranlib\n * implementation, all four are added. I (jt) believe that\n * is a mistake -- this has been confirmed by personal\n * correspondence w/ Dr. Kachitvichyanukul. Note, however,\n * the corrections are so small, that I couldn't find an\n * example where it made a difference that could be\n * observed, let alone tested. In fact, define'ing Stirling\n * to be zero gave identical results!! In practice, alv is\n * O(1), ranging 0 to -10 or so, while the Stirling\n * correction is typically O(10^{-5}) ...setting the\n * correction to zero gives about a 2% performance boost;\n * might as well keep it just to be pendantic. */\n\n {\n double x1 = ix + 1.0;\n double w1 = n - ix + 1.0;\n double f1 = fm + 1.0;\n double z1 = n + 1.0 - fm;\n\n accept = xm * log (f1 / x1) + (n - m + 0.5) * log (z1 / w1)\n + (ix - m) * log (w1 * p / (x1 * q))\n + Stirling (f1) + Stirling (z1) - Stirling (x1) - Stirling (w1);\n }\n#endif\n#endif\n }\n\n\n if (var <= accept)\n {\n goto Finish;\n }\n else\n {\n goto TryAgain;\n }\n }\n\nFinish:\n\n return (flipped) ? (n - ix) : (unsigned int)ix;\n}\n", "meta": {"hexsha": "d32423ccf35e78c7beb1ae3ab1c001cc076b6da7", "size": 12930, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.6/randist/binomial_tpe.c", "max_stars_repo_name": "ielomariala/Hex-Game", "max_stars_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-12-18T18:09:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-10T11:31:28.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/randist/binomial_tpe.c", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-12-16T17:41:24.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-22T00:00:16.000Z", "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/randist/binomial_tpe.c", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-01-20T16:22:57.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-14T12:31:02.000Z", "avg_line_length": 33.8481675393, "max_line_length": 81, "alphanum_fraction": 0.5205723125, "num_tokens": 3670, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7461389930307512, "lm_q2_score": 0.7025300573952052, "lm_q1q2_score": 0.5241850695986943}} {"text": "// Copyright (c) 2021 Stig Rune Sellevag\n//\n// This file is distributed under the MIT License. See the accompanying file\n// LICENSE.txt or http://www.opensource.org/licenses/mit-license.php for terms\n// and conditions.\n\n#ifndef SCILIB_LINALG_BLAS3_MATRIX_PRODUCT_H\n#define SCILIB_LINALG_BLAS3_MATRIX_PRODUCT_H\n\n#ifdef USE_MKL\n#include \n#else\n#include \n#endif\n\n#include \n#include \n#include \n#include \n#include \n\nnamespace Sci {\nnamespace Linalg {\n\nnamespace stdex = std::experimental;\n\ntemplate ::size_type nrows_a,\n stdex::extents<>::size_type ncols_a,\n class Layout_a,\n class Accessor_a,\n class T_b,\n stdex::extents<>::size_type nrows_b,\n stdex::extents<>::size_type ncols_b,\n class Layout_b,\n class Accessor_b,\n class T_c,\n stdex::extents<>::size_type nrows_c,\n stdex::extents<>::size_type ncols_c,\n class Layout_c,\n class Accessor_c>\n requires(!std::is_const_v)\ninline void matrix_product(\n stdex::mdspan, Layout_a, Accessor_a>\n a,\n stdex::mdspan, Layout_b, Accessor_b>\n b,\n stdex::mdspan, Layout_c, Accessor_c>\n c)\n{\n static_assert(a.static_extent(1) == b.static_extent(0));\n\n using size_type = stdex::extents<>::size_type;\n\n const size_type n = a.extent(0);\n const size_type m = a.extent(1);\n const size_type p = b.extent(1);\n\n for (size_type i = 0; i < n; ++i) {\n for (size_type j = 0; j < p; ++j) {\n c(i, j) = T_c{0};\n for (size_type k = 0; k < m; ++k) {\n c(i, j) += a(i, k) * b(k, j);\n }\n }\n }\n}\n\ntemplate \ninline void matrix_product(Sci::Matrix_view a,\n Sci::Matrix_view b,\n Sci::Matrix_view c)\n{\n constexpr double alpha = 1.0;\n constexpr double beta = 0.0;\n\n const BLAS_INT m = static_cast(a.extent(0));\n const BLAS_INT n = static_cast(b.extent(1));\n const BLAS_INT k = static_cast(a.extent(1));\n\n auto matrix_layout = CblasRowMajor;\n BLAS_INT lda = k;\n BLAS_INT ldb = n;\n BLAS_INT ldc = n;\n\n if constexpr (std::is_same_v) {\n matrix_layout = CblasColMajor;\n lda = m;\n ldb = k;\n ldc = m;\n }\n cblas_dgemm(matrix_layout, CblasNoTrans, CblasNoTrans, m, n, k, alpha,\n a.data(), lda, b.data(), ldb, beta, c.data(), ldc);\n}\n\ntemplate \ninline void matrix_product(Sci::Matrix_view a,\n Sci::Matrix_view b,\n Sci::Matrix_view c)\n{\n constexpr double alpha = 1.0;\n constexpr double beta = 0.0;\n\n const BLAS_INT m = static_cast(a.extent(0));\n const BLAS_INT n = static_cast(b.extent(1));\n const BLAS_INT k = static_cast(a.extent(1));\n\n auto matrix_layout = CblasRowMajor;\n BLAS_INT lda = k;\n BLAS_INT ldb = n;\n BLAS_INT ldc = n;\n\n if constexpr (std::is_same_v) {\n matrix_layout = CblasColMajor;\n lda = m;\n ldb = k;\n ldc = m;\n }\n cblas_dgemm(matrix_layout, CblasNoTrans, CblasNoTrans, m, n, k, alpha,\n a.data(), lda, b.data(), ldb, beta, c.data(), ldc);\n}\n\n#ifdef USE_MKL\ntemplate \ninline void matrix_product(Sci::Matrix_view, Layout> a,\n Sci::Matrix_view, Layout> b,\n Sci::Matrix_view, Layout> c)\n{\n constexpr std::complex alpha = {1.0, 0.0};\n constexpr std::complex beta = {0.0, 0.0};\n\n const BLAS_INT m = static_cast(a.extent(0));\n const BLAS_INT n = static_cast(b.extent(1));\n const BLAS_INT k = static_cast(a.extent(1));\n\n auto matrix_layout = CblasRowMajor;\n BLAS_INT lda = k;\n BLAS_INT ldb = n;\n BLAS_INT ldc = n;\n\n if constexpr (std::is_same_v) {\n matrix_layout = CblasColMajor;\n lda = m;\n ldb = k;\n ldc = m;\n }\n cblas_zgemm(matrix_layout, CblasNoTrans, CblasNoTrans, m, n, k, &alpha,\n a.data(), lda, b.data(), ldb, &beta, c.data(), ldc);\n}\n\ntemplate \ninline void\nmatrix_product(Sci::Matrix_view, Layout> a,\n Sci::Matrix_view, Layout> b,\n Sci::Matrix_view, Layout> c)\n{\n constexpr std::complex alpha = {1.0, 0.0};\n constexpr std::complex beta = {0.0, 0.0};\n\n const BLAS_INT m = static_cast(a.extent(0));\n const BLAS_INT n = static_cast(b.extent(1));\n const BLAS_INT k = static_cast(a.extent(1));\n\n auto matrix_layout = CblasRowMajor;\n BLAS_INT lda = k;\n BLAS_INT ldb = n;\n BLAS_INT ldc = n;\n\n if constexpr (std::is_same_v) {\n matrix_layout = CblasColMajor;\n lda = m;\n ldb = k;\n ldc = m;\n }\n cblas_zgemm(matrix_layout, CblasNoTrans, CblasNoTrans, m, n, k, &alpha,\n a.data(), lda, b.data(), ldb, &beta, c.data(), ldc);\n}\n#endif\n\ntemplate \ninline Sci::Matrix\nmatrix_product(const Sci::Matrix& a,\n const Sci::Matrix& b)\n{\n using size_type = stdex::extents<>::size_type;\n\n const size_type n = a.extent(0);\n const size_type p = b.extent(1);\n\n Sci::Matrix res(n, p);\n matrix_product(a.view(), b.view(), res.view());\n return res;\n}\n\ntemplate \ninline void matrix_product(const Sci::Matrix& a,\n const Sci::Matrix& b,\n Sci::Matrix& c)\n{\n matrix_product(a.view(), b.view(), c.view());\n}\n\n} // namespace Linalg\n} // namespace Sci\n\n#endif // SCILIB_LINALG_BLAS3_MATRIX_PRODUCT_H\n", "meta": {"hexsha": "8b86d3e2e1633718970c9e1b112787634c4a7e3f", "size": 6456, "ext": "h", "lang": "C", "max_stars_repo_path": "include/scilib/linalg_impl/blas3_matrix_product.h", "max_stars_repo_name": "stigrs/scilib", "max_stars_repo_head_hexsha": "c49f1f882bf2031a4de537e0f5701b2648af181f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "include/scilib/linalg_impl/blas3_matrix_product.h", "max_issues_repo_name": "stigrs/scilib", "max_issues_repo_head_hexsha": "c49f1f882bf2031a4de537e0f5701b2648af181f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "include/scilib/linalg_impl/blas3_matrix_product.h", "max_forks_repo_name": "stigrs/scilib", "max_forks_repo_head_hexsha": "c49f1f882bf2031a4de537e0f5701b2648af181f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.1884057971, "max_line_length": 78, "alphanum_fraction": 0.6149318463, "num_tokens": 1803, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7956581000631541, "lm_q2_score": 0.658417500561683, "lm_q1q2_score": 0.5238752175452394}} {"text": "static char help[] = \"Compute ln 2 in serial with PETSc, using random\\n\"\n\"permutation of sum order. Shows that floating-point arithmetic is not\\n\"\n\"associative.\\n\\n\";\n\n#include \n#include \n\nint main(int argc, char **args) {\n PetscErrorCode ierr;\n PetscMPIInt size;\n PetscInt i, j, n=10;\n PetscReal v, tmp, *a, sum;\n PetscRandom r;\n\n PetscInitialize(&argc,&args,NULL,help);\n\n ierr = MPI_Comm_size(PETSC_COMM_WORLD,&size); CHKERRQ(ierr);\n if (size > 1) {\n SETERRQ(PETSC_COMM_SELF,1,\"lntwo only works in serial\\n\");\n }\n\n ierr = PetscOptionsBegin(PETSC_COMM_WORLD,\"\",\"options for lntwo\",\"\"); CHKERRQ(ierr);\n ierr = PetscOptionsInt(\"-n\",\"number of terms in sum\",\n \"lntwo.c\",n,&n,NULL); CHKERRQ(ierr);\n ierr = PetscOptionsEnd(); CHKERRQ(ierr);\n\n ierr = PetscRandomCreate(PETSC_COMM_WORLD,&r); CHKERRQ(ierr);\n ierr = PetscRandomSetType(r,PETSCRAND48); CHKERRQ(ierr);\n ierr = PetscRandomSetSeed(r,(int)time(NULL)); CHKERRQ(ierr);\n ierr = PetscRandomSeed(r); CHKERRQ(ierr);\n\n // fill array with the terms (-1)^i / (i+1) for i=0 .. n\n ierr = PetscMalloc1(n,&a); CHKERRQ(ierr);\n for (i=0; i0; i--) {\n ierr = PetscRandomGetValueReal(r,&v); CHKERRQ(ierr);\n j = (int)floor(i*v);\n tmp = a[i];\n a[i] = a[j];\n a[j] = tmp;\n }\n\n // sum the terms\n sum = 0.0;\n for (i=0; i\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"cosmocalc.h\"\n\nstatic double linear_powspec_norm;\nstatic gsl_spline *cosmocalc_sigmaR_spline = NULL;\nstatic gsl_interp_accel *cosmocalc_sigmaR_acc = NULL;\nstatic gsl_spline *cosmocalc_Rsigma_spline = NULL;\nstatic gsl_interp_accel *cosmocalc_Rsigma_acc = NULL;\n\nstatic void init_cosmocalc_peakheight_table(void);\n\nstatic void init_cosmocalc_peakheight_table(void) \n{\n static int initFlag = 1;\n static int currCosmoNum;\n \n double sigmar_table[COSMOCALC_PEAKHEIGHT_TABLE_LENGTH];\n double topHatRad_table[COSMOCALC_PEAKHEIGHT_TABLE_LENGTH];\n size_t sindex[COSMOCALC_PEAKHEIGHT_TABLE_LENGTH];\n double tmpDouble[COSMOCALC_PEAKHEIGHT_TABLE_LENGTH];\n long i;\n double rad;\n \n if(initFlag == 1 || currCosmoNum != cosmoData.cosmoNum)\n {\n initFlag = 0;\n currCosmoNum = cosmoData.cosmoNum;\n \n linear_powspec_norm = cosmoData.Sigma8*cosmoData.Sigma8/tophatradnorm_linear_powspec_exact_nonorm(8.0);\n\n for(i=0;i\n#include \n#include \n#include \n#include \n\n#include \"allvars.h\"\n#include \"proto.h\"\n\n\nint main(int argc, char **argv)\n{\n MPI_Init(&argc, &argv);\n MPI_Comm_rank(MPI_COMM_WORLD, &ThisTask);\n MPI_Comm_size(MPI_COMM_WORLD, &NTask);\n\n if(argc < 2)\n {\n if(ThisTask == 0)\n\t{\n\t fprintf(stdout, \"\\nParameters are missing.\\n\");\n\t fprintf(stdout, \"Call with \\n\\n\");\n\t}\n MPI_Finalize();\n exit(0);\n }\n\n read_parameterfile(argv[1]);\n\n set_units();\n\n initialize_powerspectrum();\n\n initialize_ffts();\n\n read_glass(GlassFile);\n\n displacement_fields();\n\n write_particle_data();\n\n if(NumPart)\n free(P);\n\n free_ffts();\n\n\n if(ThisTask == 0)\n {\n printf(\"\\nIC's generated.\\n\\n\");\n printf(\"Initial scale factor = %g\\n\", InitTime);\n printf(\"\\n\");\n }\n\n MPI_Barrier(MPI_COMM_WORLD);\n print_spec();\n\n MPI_Finalize();\t\t/* clean up & finalize MPI */\n exit(0);\n}\n\n\n\n\n\nvoid displacement_fields(void)\n{\n MPI_Request request;\n MPI_Status status;\n gsl_rng *random_generator;\n int i, j, k, ii, jj, kk, axes;\n int n;\n int sendTask, recvTask;\n double fac, vel_prefac;\n double kvec[3], kmag, kmag2, p_of_k;\n double delta, phase, ampl, hubble_a;\n double u, v, w;\n double f1, f2, f3, f4, f5, f6, f7, f8;\n double dis, maxdisp, max_disp_glob;\n unsigned int *seedtable;\n\n#ifdef CORRECT_CIC\n double fx, fy, fz, ff, smth;\n#endif\n\n if(ThisTask == 0)\n {\n printf(\"\\nstart computing displacement fields...\\n\");\n fflush(stdout);\n }\n\n hubble_a =\n Hubble * sqrt(Omega / pow(InitTime, 3) + (1 - Omega - OmegaLambda) / pow(InitTime, 2) + OmegaLambda);\n\n vel_prefac = InitTime * hubble_a * F_Omega(InitTime);\n\n vel_prefac /= sqrt(InitTime);\t/* converts to Gadget velocity */\n\n if(ThisTask == 0)\n printf(\"vel_prefac= %g hubble_a=%g fom=%g \\n\", vel_prefac, hubble_a, F_Omega(InitTime));\n\n fac = pow(2 * PI / Box, 1.5);\n\n maxdisp = 0;\n\n random_generator = gsl_rng_alloc(gsl_rng_ranlxd1);\n\n gsl_rng_set(random_generator, Seed);\n\n if(!(seedtable = malloc(Nmesh * Nmesh * sizeof(unsigned int))))\n FatalError(4);\n\n for(i = 0; i < Nmesh / 2; i++)\n {\n for(j = 0; j < i; j++)\n\tseedtable[i * Nmesh + j] = 0x7fffffff * gsl_rng_uniform(random_generator);\n\n for(j = 0; j < i + 1; j++)\n\tseedtable[j * Nmesh + i] = 0x7fffffff * gsl_rng_uniform(random_generator);\n\n for(j = 0; j < i; j++)\n\tseedtable[(Nmesh - 1 - i) * Nmesh + j] = 0x7fffffff * gsl_rng_uniform(random_generator);\n\n for(j = 0; j < i + 1; j++)\n\tseedtable[(Nmesh - 1 - j) * Nmesh + i] = 0x7fffffff * gsl_rng_uniform(random_generator);\n\n for(j = 0; j < i; j++)\n\tseedtable[i * Nmesh + (Nmesh - 1 - j)] = 0x7fffffff * gsl_rng_uniform(random_generator);\n\n for(j = 0; j < i + 1; j++)\n\tseedtable[j * Nmesh + (Nmesh - 1 - i)] = 0x7fffffff * gsl_rng_uniform(random_generator);\n\n for(j = 0; j < i; j++)\n\tseedtable[(Nmesh - 1 - i) * Nmesh + (Nmesh - 1 - j)] = 0x7fffffff * gsl_rng_uniform(random_generator);\n\n for(j = 0; j < i + 1; j++)\n\tseedtable[(Nmesh - 1 - j) * Nmesh + (Nmesh - 1 - i)] = 0x7fffffff * gsl_rng_uniform(random_generator);\n }\n\n for(axes = 0; axes < 3; axes++)\n {\n if(ThisTask == 0)\n\t{\n\t printf(\"\\nstarting axes=%d...\\n\", axes);\n\t fflush(stdout);\n\t}\n\n /* first, clean the array */\n for(i = 0; i < Local_nx; i++)\n\tfor(j = 0; j < Nmesh; j++)\n\t for(k = 0; k <= Nmesh / 2; k++)\n\t {\n\t Cdata[(i * Nmesh + j) * (Nmesh / 2 + 1) + k].re = 0;\n\t Cdata[(i * Nmesh + j) * (Nmesh / 2 + 1) + k].im = 0;\n\t }\n\n for(i = 0; i < Nmesh; i++)\n\t{\n\t ii = Nmesh - i;\n\t if(ii == Nmesh)\n\t ii = 0;\n\t if((i >= Local_x_start && i < (Local_x_start + Local_nx)) ||\n\t (ii >= Local_x_start && ii < (Local_x_start + Local_nx)))\n\t {\n\t for(j = 0; j < Nmesh; j++)\n\t\t{\n\t\t gsl_rng_set(random_generator, seedtable[i * Nmesh + j]);\n\n\t\t for(k = 0; k < Nmesh / 2; k++)\n\t\t {\n\t\t phase = gsl_rng_uniform(random_generator) * 2 * PI;\n\t\t do\n\t\t\tampl = gsl_rng_uniform(random_generator);\n\t\t while(ampl == 0);\n\n\t\t if(i == Nmesh / 2 || j == Nmesh / 2 || k == Nmesh / 2)\n\t\t\tcontinue;\n\t\t if(i == 0 && j == 0 && k == 0)\n\t\t\tcontinue;\n\n\t\t if(i < Nmesh / 2)\n\t\t\tkvec[0] = i * 2 * PI / Box;\n\t\t else\n\t\t\tkvec[0] = -(Nmesh - i) * 2 * PI / Box;\n\n\t\t if(j < Nmesh / 2)\n\t\t\tkvec[1] = j * 2 * PI / Box;\n\t\t else\n\t\t\tkvec[1] = -(Nmesh - j) * 2 * PI / Box;\n\n\t\t if(k < Nmesh / 2)\n\t\t\tkvec[2] = k * 2 * PI / Box;\n\t\t else\n\t\t\tkvec[2] = -(Nmesh - k) * 2 * PI / Box;\n\n\t\t kmag2 = kvec[0] * kvec[0] + kvec[1] * kvec[1] + kvec[2] * kvec[2];\n\t\t kmag = sqrt(kmag2);\n\n\t\t if(SphereMode == 1)\n\t\t\t{\n\t\t\t if(kmag * Box / (2 * PI) > Nsample / 2)\t/* select a sphere in k-space */\n\t\t\t continue;\n\t\t\t}\n\t\t else\n\t\t\t{\n\t\t\t if(fabs(kvec[0]) * Box / (2 * PI) > Nsample / 2)\n\t\t\t continue;\n\t\t\t if(fabs(kvec[1]) * Box / (2 * PI) > Nsample / 2)\n\t\t\t continue;\n\t\t\t if(fabs(kvec[2]) * Box / (2 * PI) > Nsample / 2)\n\t\t\t continue;\n\t\t\t}\n\n\t\t p_of_k = PowerSpec(kmag);\n\n\t\t p_of_k *= -log(ampl);\n\n\t\t delta = fac * sqrt(p_of_k) / Dplus;\t/* scale back to starting redshift */\n\n#ifdef CORRECT_CIC\n\t\t /* do deconvolution of CIC interpolation */\n\t\t fx = fy = fz = 1;\n\t\t if(kvec[0] != 0)\n\t\t\t{\n\t\t\t fx = (kvec[0] * Box / 2) / Nmesh;\n\t\t\t fx = sin(fx) / fx;\n\t\t\t}\n\t\t if(kvec[1] != 0)\n\t\t\t{\n\t\t\t fy = (kvec[1] * Box / 2) / Nmesh;\n\t\t\t fy = sin(fy) / fy;\n\t\t\t}\n\t\t if(kvec[2] != 0)\n\t\t\t{\n\t\t\t fz = (kvec[2] * Box / 2) / Nmesh;\n\t\t\t fz = sin(fz) / fz;\n\t\t\t}\n\t\t ff = 1 / (fx * fy * fz);\n\t\t smth = ff * ff;\n\n\t\t delta *= smth;\n\t\t /* end deconvolution */\n#endif\n\t\t if(k > 0)\n\t\t\t{\n\t\t\t if(i >= Local_x_start && i < (Local_x_start + Local_nx))\n\t\t\t {\n\t\t\t Cdata[((i - Local_x_start) * Nmesh + j) * (Nmesh / 2 + 1) + k].re =\n\t\t\t\t-kvec[axes] / kmag2 * delta * sin(phase);\n\t\t\t Cdata[((i - Local_x_start) * Nmesh + j) * (Nmesh / 2 + 1) + k].im =\n\t\t\t\tkvec[axes] / kmag2 * delta * cos(phase);\n\t\t\t }\n\t\t\t}\n\t\t else\t/* k=0 plane needs special treatment */\n\t\t\t{\n\t\t\t if(i == 0)\n\t\t\t {\n\t\t\t if(j >= Nmesh / 2)\n\t\t\t\tcontinue;\n\t\t\t else\n\t\t\t\t{\n\t\t\t\t if(i >= Local_x_start && i < (Local_x_start + Local_nx))\n\t\t\t\t {\n\t\t\t\t jj = Nmesh - j;\t/* note: j!=0 surely holds at this point */\n\n\t\t\t\t Cdata[((i - Local_x_start) * Nmesh + j) * (Nmesh / 2 + 1) + k].re =\n\t\t\t\t\t-kvec[axes] / kmag2 * delta * sin(phase);\n\t\t\t\t Cdata[((i - Local_x_start) * Nmesh + j) * (Nmesh / 2 + 1) + k].im =\n\t\t\t\t\tkvec[axes] / kmag2 * delta * cos(phase);\n\n\t\t\t\t Cdata[((i - Local_x_start) * Nmesh + jj) * (Nmesh / 2 + 1) + k].re =\n\t\t\t\t\t-kvec[axes] / kmag2 * delta * sin(phase);\n\t\t\t\t Cdata[((i - Local_x_start) * Nmesh + jj) * (Nmesh / 2 + 1) + k].im =\n\t\t\t\t\t-kvec[axes] / kmag2 * delta * cos(phase);\n\t\t\t\t }\n\t\t\t\t}\n\t\t\t }\n\t\t\t else\t/* here comes i!=0 : conjugate can be on other processor! */\n\t\t\t {\n\t\t\t if(i >= Nmesh / 2)\n\t\t\t\tcontinue;\n\t\t\t else\n\t\t\t\t{\n\t\t\t\t ii = Nmesh - i;\n\t\t\t\t if(ii == Nmesh)\n\t\t\t\t ii = 0;\n\t\t\t\t jj = Nmesh - j;\n\t\t\t\t if(jj == Nmesh)\n\t\t\t\t jj = 0;\n\n\t\t\t\t if(i >= Local_x_start && i < (Local_x_start + Local_nx))\n\t\t\t\t {\n\t\t\t\t Cdata[((i - Local_x_start) * Nmesh + j) * (Nmesh / 2 + 1) + k].re =\n\t\t\t\t\t-kvec[axes] / kmag2 * delta * sin(phase);\n\t\t\t\t Cdata[((i - Local_x_start) * Nmesh + j) * (Nmesh / 2 + 1) + k].im =\n\t\t\t\t\tkvec[axes] / kmag2 * delta * cos(phase);\n\t\t\t\t }\n\n\t\t\t\t if(ii >= Local_x_start && ii < (Local_x_start + Local_nx))\n\t\t\t\t {\n\t\t\t\t Cdata[((ii - Local_x_start) * Nmesh + jj) * (Nmesh / 2 + 1) +\n\t\t\t\t\t k].re = -kvec[axes] / kmag2 * delta * sin(phase);\n\t\t\t\t Cdata[((ii - Local_x_start) * Nmesh + jj) * (Nmesh / 2 + 1) +\n\t\t\t\t\t k].im = -kvec[axes] / kmag2 * delta * cos(phase);\n\t\t\t\t }\n\t\t\t\t}\n\t\t\t }\n\t\t\t}\n\t\t }\n\t\t}\n\t }\n\t}\n\n\n rfftwnd_mpi(Inverse_plan, 1, Disp, Workspace, FFTW_NORMAL_ORDER);\t\t/** FFT **/\n\n /* now get the plane on the right side from neighbour on the right, \n and send the left plane */\n\n recvTask = ThisTask;\n do\n\t{\n\t recvTask--;\n\t if(recvTask < 0)\n\t recvTask = NTask - 1;\n\t}\n while(Local_nx_table[recvTask] == 0);\n\n sendTask = ThisTask;\n do\n\t{\n\t sendTask++;\n\t if(sendTask >= NTask)\n\t sendTask = 0;\n\t}\n while(Local_nx_table[sendTask] == 0);\n\n /* use non-blocking send */\n\n if(Local_nx > 0)\n\t{\n\t MPI_Isend(&Disp[0],\n\t\t sizeof(fftw_real) * Nmesh * (2 * (Nmesh / 2 + 1)),\n\t\t MPI_BYTE, recvTask, 10, MPI_COMM_WORLD, &request);\n\n\t MPI_Recv(&Disp[(Local_nx * Nmesh) * (2 * (Nmesh / 2 + 1))],\n\t\t sizeof(fftw_real) * Nmesh * (2 * (Nmesh / 2 + 1)),\n\t\t MPI_BYTE, sendTask, 10, MPI_COMM_WORLD, &status);\n\n\t MPI_Wait(&request, &status);\n\t}\n\n\n /* read-out displacements */\n\n for(n = 0; n < NumPart; n++)\n\t{\n\t {\n\t u = P[n].Pos[0] / Box * Nmesh;\n\t v = P[n].Pos[1] / Box * Nmesh;\n\t w = P[n].Pos[2] / Box * Nmesh;\n\n\t i = (int) u;\n\t j = (int) v;\n\t k = (int) w;\n\n\t if(i == (Local_x_start + Local_nx))\n\t i = (Local_x_start + Local_nx) - 1;\n\t if(i < Local_x_start)\n\t i = Local_x_start;\n\t if(j == Nmesh)\n\t j = Nmesh - 1;\n\t if(k == Nmesh)\n\t k = Nmesh - 1;\n\n\t u -= i;\n\t v -= j;\n\t w -= k;\n\n\t i -= Local_x_start;\n\t ii = i + 1;\n\t jj = j + 1;\n\t kk = k + 1;\n\n\t if(jj >= Nmesh)\n\t jj -= Nmesh;\n\t if(kk >= Nmesh)\n\t kk -= Nmesh;\n\n\t f1 = (1 - u) * (1 - v) * (1 - w);\n\t f2 = (1 - u) * (1 - v) * (w);\n\t f3 = (1 - u) * (v) * (1 - w);\n\t f4 = (1 - u) * (v) * (w);\n\t f5 = (u) * (1 - v) * (1 - w);\n\t f6 = (u) * (1 - v) * (w);\n\t f7 = (u) * (v) * (1 - w);\n\t f8 = (u) * (v) * (w);\n\n\t dis = Disp[(i * Nmesh + j) * (2 * (Nmesh / 2 + 1)) + k] * f1 +\n\t Disp[(i * Nmesh + j) * (2 * (Nmesh / 2 + 1)) + kk] * f2 +\n\t Disp[(i * Nmesh + jj) * (2 * (Nmesh / 2 + 1)) + k] * f3 +\n\t Disp[(i * Nmesh + jj) * (2 * (Nmesh / 2 + 1)) + kk] * f4 +\n\t Disp[(ii * Nmesh + j) * (2 * (Nmesh / 2 + 1)) + k] * f5 +\n\t Disp[(ii * Nmesh + j) * (2 * (Nmesh / 2 + 1)) + kk] * f6 +\n\t Disp[(ii * Nmesh + jj) * (2 * (Nmesh / 2 + 1)) + k] * f7 +\n\t Disp[(ii * Nmesh + jj) * (2 * (Nmesh / 2 + 1)) + kk] * f8;\n\n\t P[n].Vel[axes] = dis;\n\n\t if(dis > maxdisp)\n\t maxdisp = dis;\n\t }\n\t}\n }\n\n\n /* now add displacement to Lagrangian coordinates, and multiply velocities by correct factor */\n for(n = 0; n < NumPart; n++)\n {\n for(axes = 0; axes < 3; axes++)\n\t{\n\t P[n].Pos[axes] += P[n].Vel[axes];\n\t P[n].Vel[axes] *= vel_prefac;\n\t P[n].Pos[axes] = periodic_wrap(P[n].Pos[axes]);\n\t}\n }\n\n gsl_rng_free(random_generator);\n\n MPI_Reduce(&maxdisp, &max_disp_glob, 1, MPI_DOUBLE, MPI_MAX, 0, MPI_COMM_WORLD);\n\n if(ThisTask == 0)\n {\n printf(\"\\nMaximum displacement: %g kpc/h, in units of the part-spacing= %g\\n\",\n\t max_disp_glob, max_disp_glob / (Box / Nmesh));\n }\n}\n\ndouble periodic_wrap(double x)\n{\n while(x >= Box)\n x -= Box;\n\n while(x < 0)\n x += Box;\n\n return x;\n}\n\n\nvoid set_units(void)\t\t/* ... set some units */\n{\n UnitTime_in_s = UnitLength_in_cm / UnitVelocity_in_cm_per_s;\n\n G = GRAVITY / pow(UnitLength_in_cm, 3) * UnitMass_in_g * pow(UnitTime_in_s, 2);\n Hubble = HUBBLE * UnitTime_in_s;\n}\n\n\n\nvoid initialize_ffts(void)\n{\n int total_size, i, additional;\n int local_ny_after_transpose, local_y_start_after_transpose;\n int *slab_to_task_local;\n size_t bytes;\n\n\n Inverse_plan = rfftw3d_mpi_create_plan(MPI_COMM_WORLD,\n\t\t\t\t\t Nmesh, Nmesh, Nmesh, FFTW_COMPLEX_TO_REAL, FFTW_ESTIMATE);\n\n rfftwnd_mpi_local_sizes(Inverse_plan, &Local_nx, &Local_x_start,\n\t\t\t &local_ny_after_transpose, &local_y_start_after_transpose, &total_size);\n\n Local_nx_table = malloc(sizeof(int) * NTask);\n MPI_Allgather(&Local_nx, 1, MPI_INT, Local_nx_table, 1, MPI_INT, MPI_COMM_WORLD);\n\n if(ThisTask == 0)\n {\n for(i = 0; i < NTask; i++)\n\tprintf(\"Task=%d Local_nx=%d\\n\", i, Local_nx_table[i]);\n fflush(stdout);\n }\n\n\n Slab_to_task = malloc(sizeof(int) * Nmesh);\n slab_to_task_local = malloc(sizeof(int) * Nmesh);\n\n for(i = 0; i < Nmesh; i++)\n slab_to_task_local[i] = 0;\n\n for(i = 0; i < Local_nx; i++)\n slab_to_task_local[Local_x_start + i] = ThisTask;\n\n MPI_Allreduce(slab_to_task_local, Slab_to_task, Nmesh, MPI_INT, MPI_SUM, MPI_COMM_WORLD);\n\n free(slab_to_task_local);\n\n\n\n additional = (Nmesh) * (2 * (Nmesh / 2 + 1));\t/* additional plane on the right side */\n\n Disp = (fftw_real *) malloc(bytes = sizeof(fftw_real) * (total_size + additional));\n Workspace = (fftw_real *) malloc(bytes += sizeof(fftw_real) * total_size);\n\n if(Disp && Workspace)\n {\n if(ThisTask == 0)\n\tprintf(\"\\nallocated %g Mbyte on Task %d for FFT's\\n\", bytes / (1024.0 * 1024.0), ThisTask);\n }\n else\n {\n printf(\"failed to allocate %g Mbyte on Task %d\\n\", bytes / (1024.0 * 1024.0), ThisTask);\n printf(\"bailing out.\\n\");\n FatalError(1);\n }\n\n Cdata = (fftw_complex *) Disp;\t/* transformed array */\n}\n\n\n\nvoid free_ffts(void)\n{\n free(Workspace);\n free(Disp);\n free(Slab_to_task);\n rfftwnd_mpi_destroy_plan(Inverse_plan);\n}\n\n\nint FatalError(int errnum)\n{\n printf(\"FatalError called with number=%d\\n\", errnum);\n fflush(stdout);\n MPI_Abort(MPI_COMM_WORLD, errnum);\n exit(0);\n}\n\n\n\n\nstatic double A, B, alpha, beta, V, gf;\n\ndouble fnl(double x)\t\t/* Peacock & Dodds formula */\n{\n return x * pow((1 + B * beta * x + pow(A * x, alpha * beta)) /\n\t\t (1 + pow(pow(A * x, alpha) * gf * gf * gf / (V * sqrt(x)), beta)), 1 / beta);\n}\n\nvoid print_spec(void)\n{\n double k, knl, po, dl, dnl, neff, kf, kstart, kend, po2, po1, DDD;\n char buf[1000];\n FILE *fd;\n\n if(ThisTask == 0)\n {\n sprintf(buf, \"%s/inputspec_%s.txt\", OutputDir, FileBase);\n\n fd = fopen(buf, \"w\");\n\n gf = GrowthFactor(0.001, 1.0) / (1.0 / 0.001);\n\n DDD = GrowthFactor(1.0 / (Redshift + 1), 1.0);\n\n fprintf(fd, \"%12g %12g\\n\", Redshift, DDD);\t/* print actual starting redshift and \n\t\t\t\t\t\t\t linear growth factor for this cosmology */\n\n kstart = 2 * PI / (1000.0 * (3.085678e24 / UnitLength_in_cm));\t/* 1000 Mpc/h */\n kend = 2 * PI / (0.001 * (3.085678e24 / UnitLength_in_cm));\t/* 0.001 Mpc/h */\n\n for(k = kstart; k < kend; k *= 1.025)\n\t{\n\t po = PowerSpec(k);\n\t dl = 4.0 * PI * k * k * k * po;\n\n\t kf = 0.5;\n\n\t po2 = PowerSpec(1.001 * k * kf);\n\t po1 = PowerSpec(k * kf);\n\n\t if(po != 0 && po1 != 0 && po2 != 0)\n\t {\n\t neff = (log(po2) - log(po1)) / (log(1.001 * k * kf) - log(k * kf));\n\n\t if(1 + neff / 3 > 0)\n\t\t{\n\t\t A = 0.482 * pow(1 + neff / 3, -0.947);\n\t\t B = 0.226 * pow(1 + neff / 3, -1.778);\n\t\t alpha = 3.310 * pow(1 + neff / 3, -0.244);\n\t\t beta = 0.862 * pow(1 + neff / 3, -0.287);\n\t\t V = 11.55 * pow(1 + neff / 3, -0.423) * 1.2;\n\n\t\t dnl = fnl(dl);\n\t\t knl = k * pow(1 + dnl, 1.0 / 3);\n\t\t}\n\t else\n\t\t{\n\t\t dnl = 0;\n\t\t knl = 0;\n\t\t}\n\t }\n\t else\n\t {\n\t dnl = 0;\n\t knl = 0;\n\t }\n\n\t fprintf(fd, \"%12g %12g %12g %12g\\n\", k, dl, knl, dnl);\n\t}\n fclose(fd);\n }\n}\n", "meta": {"hexsha": "4807e3b72dcb381d0b78aecd26a34813e7d1b018", "size": 14969, "ext": "c", "lang": "C", "max_stars_repo_path": "testing/icgen/random_verschillende_resoluties_N-GenIC/N-GenIC/main.c", "max_stars_repo_name": "egpbos/egp", "max_stars_repo_head_hexsha": "5e82c2de9e6884795b4ee89f2b15ed5dde70388f", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "testing/icgen/random_verschillende_resoluties_N-GenIC/N-GenIC/main.c", "max_issues_repo_name": "egpbos/egp", "max_issues_repo_head_hexsha": "5e82c2de9e6884795b4ee89f2b15ed5dde70388f", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "testing/icgen/random_verschillende_resoluties_N-GenIC/N-GenIC/main.c", "max_forks_repo_name": "egpbos/egp", "max_forks_repo_head_hexsha": "5e82c2de9e6884795b4ee89f2b15ed5dde70388f", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 24.3398373984, "max_line_length": 105, "alphanum_fraction": 0.5248847618, "num_tokens": 5364, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8615382058759128, "lm_q2_score": 0.6076631698328916, "lm_q1q2_score": 0.5235250371146996}} {"text": "/*\n NAME:\n proj_gauss_mixtures_IDL\n PURPOSE:\n run the projected gaussian mixtures algorithm from IDL (or python)\n CALLING SEQUENCE:\n see IDL wrapper\n INPUT:\n from IDL wrapper\n OUTPUT:\n updated model gaussians and average loglikelihood, see IDL WRAPPER\n REVISION HISTORY:\n 2008-09-21 - Written Bovy\n 2010-03-01 Added noproj option - Bovy\n 2010-04-01 Added noweight option and logweights - Bovy\n*/\n#include \n#include \n#include \n#include \n#include \n#include \n\nint proj_gauss_mixtures_IDL(double * ydata, double * ycovar, \n\t\t\t double * projection, double * logweights,\n\t\t\t int N, int dy, \n\t\t\t double * amp, double * xmean, \n\t\t\t double * xcovar, int d, int K, \n\t\t\t char * fixamp, char * fixmean, \n\t\t\t char * fixcovar, \n\t\t\t double * avgloglikedata, double tol, \n\t\t\t int maxiter, char likeonly, double w, \n\t\t\t char * logfilename, int slen, int splitnmerge,\n\t\t\t char * convlogfilename, int convloglen,\n\t\t\t char noprojection,char diagerrors,\n\t\t\t char noweights){\n //Set up logfiles \n bool keeplog = true;\n char logname[slen+1];\n char convlogname[convloglen+1];\n int ss;\n if (*logfilename == 0 || likeonly != 0 || slen == 0)\n keeplog = false;\n else {\n for (ss = 0; ss != slen; ++ss)\n logname[ss] = (char) *(logfilename++);\n for (ss = 0; ss != convloglen; ++ss)\n convlogname[ss] = (char) *(convlogfilename++);\n logfilename -= slen;\n convlogfilename -= convloglen;\n logname[slen] = '\\0';\n convlogname[convloglen] = '\\0';\n }\n\n if (keeplog) {\n logfile = fopen(logname,\"a\");\n if (logfile == NULL) return -1;\n convlogfile = fopen(convlogname,\"w\");\n if (convlogfile == NULL) return -1;\n }\n\n\n if (keeplog){\n time_t now;\n time(&now);\n fprintf(logfile,\"#----------------------------------\\n\");\n fprintf(logfile,\"#\\n#%s\\n\",asctime(localtime(&now)));\n fprintf(logfile,\"#----------------------------------\\n\");\n fflush(logfile);\n }\n \n //Copy everything into the right formats\n struct datapoint * data = (struct datapoint *) malloc( N * sizeof (struct datapoint) );\n struct gaussian * gaussians = (struct gaussian *) malloc (K * sizeof (struct gaussian) );\n\n bool noproj= (bool) noprojection;\n bool noweight= (bool) noweights;\n bool diagerrs= (bool) diagerrors;\n int ii, jj,dd1,dd2;\n for (ii = 0; ii != N; ++ii){\n data->ww = gsl_vector_alloc(dy);\n if ( ! noweight ) data->logweight = *(logweights++);\n if ( diagerrs ) data->SS = gsl_matrix_alloc(dy,1);\n else data->SS = gsl_matrix_alloc(dy,dy);\n if ( ! noproj ) data->RR = gsl_matrix_alloc(dy,d);\n for (dd1 = 0; dd1 != dy;++dd1)\n gsl_vector_set(data->ww,dd1,*(ydata++));\n if ( diagerrs)\n for (dd1 = 0; dd1 != dy; ++dd1)\n\t gsl_matrix_set(data->SS,dd1,0,*(ycovar++));\n else\n for (dd1 = 0; dd1 != dy; ++dd1)\n\tfor (dd2 = 0; dd2 != dy; ++dd2)\n\t gsl_matrix_set(data->SS,dd1,dd2,*(ycovar++));\n if ( ! noproj )\n for (dd1 = 0; dd1 != dy; ++dd1)\n\tfor (dd2 = 0; dd2 != d; ++dd2)\n\t gsl_matrix_set(data->RR,dd1,dd2,*(projection++));\n else data->RR= NULL;\n ++data;\n }\n data -= N;\n ydata -= N*dy;\n if ( diagerrs ) ycovar -= N*dy;\n else ycovar -= N*dy*dy;\n if ( ! noproj ) projection -= N*dy*d;\n\n for (jj = 0; jj != K; ++jj){\n gaussians->mm = gsl_vector_alloc(d);\n gaussians->VV = gsl_matrix_alloc(d,d);\n gaussians->alpha = *(amp++);\n for (dd1 = 0; dd1 != d; ++dd1)\n gsl_vector_set(gaussians->mm,dd1,*(xmean++));\n for (dd1 = 0; dd1 != d; ++dd1)\n for (dd2 = 0; dd2 != d; ++dd2)\n\tgsl_matrix_set(gaussians->VV,dd1,dd2,*(xcovar++));\n ++gaussians;\n }\n gaussians -= K;\n amp -= K;\n xmean -= K*d;\n xcovar -= K*d*d;\n\n\n //Print the initial model parameters to the logfile\n int kk;\n if (keeplog){\n fprintf(logfile,\"#\\n#Using %i Gaussians and w = %f\\n\\n\",K,w);\n fprintf(logfile,\"#\\n#Initial model parameters used:\\n\\n\");\n for (kk=0; kk != K; ++kk){\n fprintf(logfile,\"#Gaussian \");\n fprintf(logfile,\"%i\",kk);\n fprintf(logfile,\"\\n\");\n fprintf(logfile,\"#amp\\t=\\t\");\n fprintf(logfile,\"%f\",(*gaussians).alpha);\n fprintf(logfile,\"\\n\");\n fprintf(logfile,\"#mean\\t=\\t\");\n for (dd1=0; dd1 != d; ++dd1){\n\tfprintf(logfile,\"%f\",gsl_vector_get(gaussians->mm,dd1));\n\tif (dd1 < d-1) fprintf(logfile,\"\\t\");\n }\n fprintf(logfile,\"\\n\");\n fprintf(logfile,\"#covar\\t=\\t\");\n for (dd1=0; dd1 != d; ++dd1)\n\tfprintf(logfile,\"%f\\t\",gsl_matrix_get(gaussians->VV,dd1,dd1));\n for (dd1=0; dd1 != d-1; ++dd1)\n\tfor (dd2=dd1+1; dd2 != d; ++dd2){\n\t fprintf(logfile,\"%f\\t\",gsl_matrix_get(gaussians->VV,dd1,dd2));\n\t}\n ++gaussians;\n fprintf(logfile,\"\\n#\\n\");\n }\n gaussians -= K;\n fflush(logfile);\n }\n\n\n\n //Then run projected_gauss_mixtures\n proj_gauss_mixtures(data,N,gaussians,K,(bool *) fixamp,\n\t\t (bool *) fixmean, (bool *) fixcovar,avgloglikedata,\n\t\t tol,(long long int) maxiter, (bool) likeonly, w,\n\t\t splitnmerge,keeplog,logfile,convlogfile,noproj,diagerrs,\n\t\t noweight);\n\n\n //Print the final model parameters to the logfile\n if (keeplog){\n fprintf(logfile,\"\\n#Final model parameters obtained:\\n\\n\");\n for (kk=0; kk != K; ++kk){\n fprintf(logfile,\"#Gaussian \");\n fprintf(logfile,\"%i\",kk);\n fprintf(logfile,\"\\n\");\n fprintf(logfile,\"#amp\\t=\\t\");\n fprintf(logfile,\"%f\",(*gaussians).alpha);\n fprintf(logfile,\"\\n\");\n fprintf(logfile,\"#mean\\t=\\t\");\n for (dd1=0; dd1 != d; ++dd1){\n\tfprintf(logfile,\"%f\",gsl_vector_get(gaussians->mm,dd1));\n\tif (dd1 < d-1) fprintf(logfile,\"\\t\");\n }\n fprintf(logfile,\"\\n\");\n fprintf(logfile,\"#covar\\t=\\t\");\n for (dd1=0; dd1 != d; ++dd1)\n\tfprintf(logfile,\"%f\\t\",gsl_matrix_get(gaussians->VV,dd1,dd1));\n for (dd1=0; dd1 != d-1; ++dd1)\n\tfor (dd2=dd1+1; dd2 != d; ++dd2){\n\t fprintf(logfile,\"%f\\t\",gsl_matrix_get(gaussians->VV,dd1,dd2));\n\t}\n ++gaussians;\n fprintf(logfile,\"\\n#\\n\");\n }\n gaussians -= K;\n fflush(logfile);\n }\n\n\n\n //Then update the arrays given to us by IDL\n for (jj = 0; jj != K; ++jj){\n *(amp++) = gaussians->alpha;\n for (dd1 = 0; dd1 != d; ++dd1)\n *(xmean++) = gsl_vector_get(gaussians->mm,dd1);\n for (dd1 = 0; dd1 != d; ++dd1)\n for (dd2 = 0; dd2 != d; ++dd2)\n\t*(xcovar++) = gsl_matrix_get(gaussians->VV,dd1,dd2);\n ++gaussians;\n }\n gaussians -= K;\n amp -= K;\n xmean -= K*d;\n xcovar -= K*d*d;\n \n //And free any memory we allocated\n for (ii = 0; ii != N; ++ii){\n gsl_vector_free(data->ww);\n gsl_matrix_free(data->SS);\n if ( ! noproj ) gsl_matrix_free(data->RR);\n ++data;\n }\n data -= N;\n free(data);\n \n for (jj = 0; jj != K; ++jj){\n gsl_vector_free(gaussians->mm);\n gsl_matrix_free(gaussians->VV);\n ++gaussians;\n }\n gaussians -= K;\n free(gaussians);\n\n if (keeplog){\n fclose(logfile);\n fclose(convlogfile);\n }\n\n return 0;\n}\n", "meta": {"hexsha": "fa0e5897c309d9794551a2db1a2d829630f1c782", "size": 6944, "ext": "c", "lang": "C", "max_stars_repo_path": "src/proj_gauss_mixtures_IDL.c", "max_stars_repo_name": "HaifengWangNAOC/Learn-Bovy-Extreme-deconvolution", "max_stars_repo_head_hexsha": "bc6d58199b17cd5329d72f6af3c7ba7e6d2ae780", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 73.0, "max_stars_repo_stars_event_min_datetime": "2015-01-22T09:22:38.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-21T01:27:34.000Z", "max_issues_repo_path": "src/proj_gauss_mixtures_IDL.c", "max_issues_repo_name": "HaifengWangNAOC/Learn-Bovy-Extreme-deconvolution", "max_issues_repo_head_hexsha": "bc6d58199b17cd5329d72f6af3c7ba7e6d2ae780", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 24.0, "max_issues_repo_issues_event_min_datetime": "2015-01-07T01:42:22.000Z", "max_issues_repo_issues_event_max_datetime": "2021-11-19T01:01:22.000Z", "max_forks_repo_path": "src/proj_gauss_mixtures_IDL.c", "max_forks_repo_name": "HaifengWangNAOC/Learn-Bovy-Extreme-deconvolution", "max_forks_repo_head_hexsha": "bc6d58199b17cd5329d72f6af3c7ba7e6d2ae780", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 26.0, "max_forks_repo_forks_event_min_datetime": "2015-02-05T22:21:22.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-13T03:37:58.000Z", "avg_line_length": 29.0543933054, "max_line_length": 91, "alphanum_fraction": 0.5799251152, "num_tokens": 2313, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7826624789529376, "lm_q2_score": 0.6688802471698041, "lm_q1q2_score": 0.5235074723725726}} {"text": "#include \n#include \n#if !defined(__APPLE__)\n#include \n#endif\n#include \n#include \n#include \n#include \n#include \n\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"../../../cosmolike_core/theory/basics.c\"\n#include \"tinker_emulator.h\"\n#include \"tinker_emulator.c\"\n\nint main(){\n //Test kernel\n double x0[7] = {0.0043*pow(0.7,2), 0.286*pow(0.7,2), -1, 1, 3.0, 70, 3.0};\n double x1[7] = {0.0043*pow(0.7,2), 0.286*pow(0.7,2), -1, 1, 3.0, 70, 5.0};\n printf(\"kernel : %e \\n\", kernel(x0, x1, emu_tinker_bias_log_lambda[0], tinkerEmuParam.tinker_bias_ncosmo));\n //Test bias emulator \n double emu_tinker_bias_param[6];\n predict_tinker_bias_parameters(0.0043*pow(0.7,2), 0.286*pow(0.7,2), -1, 1, 3.0, 70, 3.0, 0.3, emu_tinker_bias_param);\n double bias_ref[6] = {4.432419358797392, 0.32058653615384625, 1.3586846172228393, 1.347376928846154, 0.728081326923077, -1.0947315110189246}; \n printf(\"bias result:\\n\");\n printf(\"item c ref\\n\");\n for(int i=0; i\n#include \n\n#include \n#include \n#include \n\n#include \"pmpfft.h\"\n#include \n\ndouble fastpm_2pcf_eval(FastPM2PCF* self, double r)\n{\n double rMax = self->size * self->step_size;\n if(r > rMax)\n return 0.0;\n if(r == rMax)\n return self->xi[self->size];\n int i = (int)floor(r / self->step_size);\n double prev = self->xi[i], next = self->xi[i + 1];\n double deltaR = r - i * self->step_size;\n return prev + (next - prev) * deltaR / self->step_size;\n}\n\n/*\nvoid\nfastpm_generate_covariance_matrix(PM *pm, fastpm_fkfunc pkfunc, void * data, FastPMFloat *cov_x)\n{\n}\n*/\nvoid\nfastpm_2pcf_from_powerspectrum(FastPM2PCF *self, fastpm_fkfunc pkfunc, void * data, double r_max, int steps)\n{\n self->size = steps;\n self->step_size = r_max / steps;\n self->xi = malloc((steps + 1) * sizeof(double));\n\n double logKMin = -10, logKMax = 5;\n double logKSteps = 10000;\n double logKStepSize = (logKMax - logKMin) / logKSteps;\n double pi = 3.141593;\n int i, j;\n for(i = 0; i <= steps; ++i)\n {\n double r = i * self->step_size;\n double res = 0;\n double prev = 0;\n for(j = 1; j <= logKSteps; ++j)\n {\n double logK = logKMin + j * logKStepSize;\n double k = exp(logK);\n double kr = k * r;\n double func = 1;\n if(kr > 0)\n func = sin(kr) / kr;\n func *= pkfunc(k, data) * k * k * k;\n res += (prev + func) / 2;\n prev = func;\n }\n res *= logKStepSize / (2 * pi * pi);\n self->xi[i] = res;\n }\n}\n\nstatic void\n_solve(int size, double * Cij, double * dfi, double * x)\n{\n gsl_matrix_view m = gsl_matrix_view_array(Cij, size, size);\n gsl_vector_view b = gsl_vector_view_array(dfi, size);\n gsl_vector_view xx = gsl_vector_view_array(x, size);\n gsl_permutation *p = gsl_permutation_alloc(size);\n int s;\n gsl_linalg_LU_decomp(&m.matrix, p, &s);\n gsl_linalg_LU_solve(&m.matrix, p, &b.vector, &xx.vector);\n}\n\nstatic void\n_readout(FastPMConstraint * constraints, int size, PM * pm, FastPMFloat * delta_x, double * dfi)\n{\n int i;\n\n for(i = 0; i < size; ++i)\n {\n int ii[3];\n int d;\n int inBox = 1;\n int index = 0;\n for(d = 0; d < 3; ++d)\n {\n ii[d] = constraints[i].x[d] * pm->InvCellSize[d] - pm->IRegion.start[d];\n if(ii[d] < 0 || ii[d] > pm->IRegion.size[d])\n inBox = 0;\n index += ii[d] * pm->IRegion.strides[d];\n }\n\n if(inBox) {\n dfi[i] = delta_x[index];\n } else {\n dfi[i] = 0;\n }\n }\n MPI_Allreduce(MPI_IN_PLACE, dfi, size, MPI_DOUBLE, MPI_SUM, pm_comm(pm));\n}\nstatic double\n_sigma(PM * pm, FastPMFloat * delta_x)\n{\n double d2 = 0.0;\n PMXIter xiter;\n for(pm_xiter_init(pm, &xiter);\n !pm_xiter_stop(&xiter);\n pm_xiter_next(&xiter))\n {\n double od = delta_x[xiter.ind] - 1;\n d2 += od * od;\n }\n MPI_Allreduce(MPI_IN_PLACE, &d2, 1, MPI_DOUBLE, MPI_SUM, pm_comm(pm));\n /* unbiased estimator of the variance. the mean is 1. */\n d2 /= (pm_norm(pm) - 1);\n return sqrt(d2);\n}\n\nvoid\nfastpm_cg_apply_constraints(FastPMConstrainedGaussian *cg, PM * pm, FastPM2PCF *xi, FastPMFloat * delta_k)\n{\n FastPMConstraint * constraints = cg->constraints;\n\n int size;\n for(size = 0; constraints[size].x[0] >= 0; size ++)\n continue;\n\n int i;\n fastpm_info(\"Constrained Gaussian with %d constraints\\n\", size);\n double dfi[size];\n double e[size];\n double Cij[size * size];\n double sigma = 0;\n FastPMFloat * delta_x = pm_alloc(pm);\n\n pm_assign(pm, delta_k, delta_x);\n pm_c2r(pm, delta_x);\n\n sigma = _sigma(pm, delta_x);\n fastpm_info(\"Measured sigma on the grid = %g\\n\", sigma);\n\n _readout(constraints, size, pm, delta_x, dfi);\n\n for(i = 0; i < size; ++i)\n {\n dfi[i] = (1 + constraints[i].c * sigma) - dfi[i];\n\n int j;\n for(j = i; j < size; ++j)\n {\n int d;\n double r = 0;\n for(d = 0; d < 3; ++d) {\n double dx = constraints[i].x[d] - constraints[j].x[d];\n \n if(dx > 0.5*pm->BoxSize[d]){\n dx -= pm->BoxSize[d];\n }\n else if(dx < -0.5*pm->BoxSize[d]){\n dx += pm->BoxSize[d];\n }\n \n r += dx * dx;\n }\n r = sqrt(r);\n double v = fastpm_2pcf_eval(xi, r);\n Cij[i * size + j] = v;\n Cij[j * size + i] = v;\n }\n }\n\n _solve(size, Cij, dfi, e);\n\n PMXIter xiter;\n for(pm_xiter_init(pm, &xiter);\n !pm_xiter_stop(&xiter);\n pm_xiter_next(&xiter))\n {\n double v = 0;\n for(i = 0; i < size; ++i)\n {\n int d;\n\n double r = 0;\n for(d = 0; d < 3; d ++) {\n double dx = xiter.iabs[d] * pm->CellSize[d] - constraints[i].x[d];\n \n if(dx > 0.5*pm->BoxSize[d]){\n dx -= pm->BoxSize[d];\n }\n else if(dx < -0.5*pm->BoxSize[d]){\n dx += pm->BoxSize[d];\n }\n \n r += dx * dx;\n }\n r = sqrt(r);\n\n v += e[i] * fastpm_2pcf_eval(xi, r);\n }\n delta_x[xiter.ind] += v;\n }\n\n _readout(constraints, size, pm, delta_x, dfi);\n for(i = 0; i < size; i ++) {\n fastpm_info(\"After constraints, Realization x[] = %g %g %g overdensity = %g, peak-sigma= %g\\n\",\n constraints[i].x[0],\n constraints[i].x[1],\n constraints[i].x[2],\n (dfi[i] - 1.0), (dfi[i] - 1.0) / sigma);\n }\n pm_r2c(pm, delta_x, delta_k);\n pm_free(pm, delta_x);\n}\n", "meta": {"hexsha": "b4092458788fcf4eec6a9135241c676ec223b339", "size": 5954, "ext": "c", "lang": "C", "max_stars_repo_path": "fastpm/libfastpm/constrainedgaussian.c", "max_stars_repo_name": "sbird/FastPMRunner", "max_stars_repo_head_hexsha": "f38f6e69c603fb699436b645fe7b4eb418ee82c2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "fastpm/libfastpm/constrainedgaussian.c", "max_issues_repo_name": "sbird/FastPMRunner", "max_issues_repo_head_hexsha": "f38f6e69c603fb699436b645fe7b4eb418ee82c2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 4.0, "max_issues_repo_issues_event_min_datetime": "2021-04-19T23:01:33.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-24T05:51:04.000Z", "max_forks_repo_path": "fastpm/libfastpm/constrainedgaussian.c", "max_forks_repo_name": "sbird/FastPMRunner", "max_forks_repo_head_hexsha": "f38f6e69c603fb699436b645fe7b4eb418ee82c2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2021-04-14T23:24:19.000Z", "max_forks_repo_forks_event_max_datetime": "2021-04-14T23:24:19.000Z", "avg_line_length": 27.4377880184, "max_line_length": 108, "alphanum_fraction": 0.5026872691, "num_tokens": 1805, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8459424256566559, "lm_q2_score": 0.6187804337438501, "lm_q1q2_score": 0.5234526210701501}} {"text": "/* multimin/simplex.c\n * \n * Copyright (C) 2007 Brian Gough\n * Copyright (C) 2002 Tuomo Keskitalo, Ivo Alxneit\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n/*\n - Originally written by Tuomo Keskitalo \n - Corrections to nmsimplex_iterate and other functions \n by Ivo Alxneit \n - Additional help by Brian Gough \n*/\n\n/* The Simplex method of Nelder and Mead,\n also known as the polytope search alogorithm. Ref:\n Nelder, J.A., Mead, R., Computer Journal 7 (1965) pp. 308-313.\n\n This implementation uses n+1 corner points in the simplex.\n*/\n\n#include \n#include \n#include \n#include \n\ntypedef struct\n{\n gsl_matrix *x1; /* simplex corner points */\n gsl_vector *y1; /* function value at corner points */\n gsl_vector *ws1; /* workspace 1 for algorithm */\n gsl_vector *ws2; /* workspace 2 for algorithm */\n}\nnmsimplex_state_t;\n\nstatic double\nnmsimplex_move_corner (const double coeff, const nmsimplex_state_t * state,\n size_t corner, gsl_vector * xc,\n const gsl_multimin_function * f)\n{\n /* moves a simplex corner scaled by coeff (negative value represents \n mirroring by the middle point of the \"other\" corner points)\n and gives new corner in xc and function value at xc as a \n return value \n */\n\n gsl_matrix *x1 = state->x1;\n\n size_t i, j;\n double newval, mp;\n\n for (j = 0; j < x1->size2; j++)\n {\n mp = 0.0;\n for (i = 0; i < x1->size1; i++)\n {\n if (i != corner)\n {\n mp += (gsl_matrix_get (x1, i, j));\n }\n }\n mp /= (double) (x1->size1 - 1);\n newval = mp - coeff * (mp - gsl_matrix_get (x1, corner, j));\n gsl_vector_set (xc, j, newval);\n }\n\n newval = GSL_MULTIMIN_FN_EVAL (f, xc);\n\n return newval;\n}\n\nstatic int\nnmsimplex_contract_by_best (nmsimplex_state_t * state, size_t best,\n gsl_vector * xc, gsl_multimin_function * f)\n{\n\n /* Function contracts the simplex in respect to \n best valued corner. That is, all corners besides the \n best corner are moved. */\n\n /* the xc vector is simply work space here */\n\n gsl_matrix *x1 = state->x1;\n gsl_vector *y1 = state->y1;\n\n size_t i, j;\n double newval;\n\n int status = GSL_SUCCESS;\n\n for (i = 0; i < x1->size1; i++)\n {\n if (i != best)\n {\n for (j = 0; j < x1->size2; j++)\n {\n newval = 0.5 * (gsl_matrix_get (x1, i, j)\n + gsl_matrix_get (x1, best, j));\n gsl_matrix_set (x1, i, j, newval);\n }\n\n /* evaluate function in the new point */\n\n gsl_matrix_get_row (xc, x1, i);\n newval = GSL_MULTIMIN_FN_EVAL (f, xc);\n gsl_vector_set (y1, i, newval);\n\n\t /* notify caller that we found at least one bad function value.\n\t we finish the contraction (and do not abort) to allow the user\n\t to handle the situation */\n\n if(!gsl_finite(newval))\n\t {\n\t status = GSL_EBADFUNC;\n\t }\n }\n }\n\n return status;\n}\n\nstatic int\nnmsimplex_calc_center (const nmsimplex_state_t * state, gsl_vector * mp)\n{\n /* calculates the center of the simplex to mp */\n\n gsl_matrix *x1 = state->x1;\n\n size_t i, j;\n double val;\n\n for (j = 0; j < x1->size2; j++)\n {\n val = 0.0;\n for (i = 0; i < x1->size1; i++)\n {\n val += gsl_matrix_get (x1, i, j);\n }\n val /= x1->size1;\n gsl_vector_set (mp, j, val);\n }\n\n return GSL_SUCCESS;\n}\n\nstatic double\nnmsimplex_size (nmsimplex_state_t * state)\n{\n /* calculates simplex size as average sum of length of vectors \n from simplex center to corner points: \n\n ( sum ( || y - y_middlepoint || ) ) / n \n */\n\n gsl_vector *s = state->ws1;\n gsl_vector *mp = state->ws2;\n\n gsl_matrix *x1 = state->x1;\n size_t i;\n\n double ss = 0.0;\n\n /* Calculate middle point */\n nmsimplex_calc_center (state, mp);\n\n for (i = 0; i < x1->size1; i++)\n {\n gsl_matrix_get_row (s, x1, i);\n gsl_blas_daxpy (-1.0, mp, s);\n ss += gsl_blas_dnrm2 (s);\n }\n\n return ss / (double) (x1->size1);\n}\n\nstatic int\nnmsimplex_alloc (void *vstate, size_t n)\n{\n nmsimplex_state_t *state = (nmsimplex_state_t *) vstate;\n\n if (n == 0)\n {\n GSL_ERROR(\"invalid number of parameters specified\", GSL_EINVAL);\n }\n\n state->x1 = gsl_matrix_alloc (n + 1, n);\n\n if (state->x1 == NULL)\n {\n GSL_ERROR (\"failed to allocate space for x1\", GSL_ENOMEM);\n }\n\n state->y1 = gsl_vector_alloc (n + 1);\n\n if (state->y1 == NULL)\n {\n gsl_matrix_free(state->x1);\n GSL_ERROR (\"failed to allocate space for y\", GSL_ENOMEM);\n }\n\n state->ws1 = gsl_vector_alloc (n);\n\n if (state->ws1 == NULL)\n {\n gsl_matrix_free(state->x1);\n gsl_vector_free(state->y1);\n GSL_ERROR (\"failed to allocate space for ws1\", GSL_ENOMEM);\n }\n\n state->ws2 = gsl_vector_alloc (n);\n\n if (state->ws2 == NULL)\n {\n gsl_matrix_free(state->x1);\n gsl_vector_free(state->y1);\n gsl_vector_free(state->ws1);\n GSL_ERROR (\"failed to allocate space for ws2\", GSL_ENOMEM);\n }\n\n return GSL_SUCCESS;\n}\n\nstatic int\nnmsimplex_set (void *vstate, gsl_multimin_function * f,\n const gsl_vector * x,\n double *size, const gsl_vector * step_size)\n{\n int status;\n size_t i;\n double val;\n\n nmsimplex_state_t *state = (nmsimplex_state_t *) vstate;\n\n gsl_vector *xtemp = state->ws1;\n\n if (xtemp->size != x->size)\n {\n GSL_ERROR(\"incompatible size of x\", GSL_EINVAL);\n }\n\n if (xtemp->size != step_size->size)\n {\n GSL_ERROR(\"incompatible size of step_size\", GSL_EINVAL);\n }\n\n /* first point is the original x0 */\n\n val = GSL_MULTIMIN_FN_EVAL (f, x);\n \n if (!gsl_finite(val))\n {\n GSL_ERROR(\"non-finite function value encountered\", GSL_EBADFUNC);\n }\n\n gsl_matrix_set_row (state->x1, 0, x);\n gsl_vector_set (state->y1, 0, val);\n\n /* following points are initialized to x0 + step_size */\n\n for (i = 0; i < x->size; i++)\n {\n status = gsl_vector_memcpy (xtemp, x);\n\n if (status != 0)\n {\n GSL_ERROR (\"vector memcopy failed\", GSL_EFAILED);\n }\n\n val = gsl_vector_get (xtemp, i) + gsl_vector_get (step_size, i);\n gsl_vector_set (xtemp, i, val);\n val = GSL_MULTIMIN_FN_EVAL (f, xtemp);\n \n if (!gsl_finite(val))\n {\n GSL_ERROR(\"non-finite function value encountered\", GSL_EBADFUNC);\n }\n\n gsl_matrix_set_row (state->x1, i + 1, xtemp);\n gsl_vector_set (state->y1, i + 1, val);\n }\n\n /* Initialize simplex size */\n\n *size = nmsimplex_size (state);\n\n return GSL_SUCCESS;\n}\n\nstatic void\nnmsimplex_free (void *vstate)\n{\n nmsimplex_state_t *state = (nmsimplex_state_t *) vstate;\n\n gsl_matrix_free (state->x1);\n gsl_vector_free (state->y1);\n gsl_vector_free (state->ws1);\n gsl_vector_free (state->ws2);\n}\n\nstatic int\nnmsimplex_iterate (void *vstate, gsl_multimin_function * f,\n gsl_vector * x, double *size, double *fval)\n{\n\n /* Simplex iteration tries to minimize function f value */\n /* Includes corrections from Ivo Alxneit */\n\n nmsimplex_state_t *state = (nmsimplex_state_t *) vstate;\n\n /* xc and xc2 vectors store tried corner point coordinates */\n\n gsl_vector *xc = state->ws1;\n gsl_vector *xc2 = state->ws2;\n gsl_vector *y1 = state->y1;\n gsl_matrix *x1 = state->x1;\n\n size_t n = y1->size;\n size_t i;\n size_t hi, s_hi, lo;\n double dhi, ds_hi, dlo;\n int status;\n double val, val2;\n\n\n if (xc->size != x->size)\n {\n GSL_ERROR(\"incompatible size of x\", GSL_EINVAL);\n }\n\n /* get index of highest, second highest and lowest point */\n\n dhi = dlo = gsl_vector_get (y1, 0);\n hi = 0; lo = 0;\n\n ds_hi = gsl_vector_get(y1, 1);\n s_hi = 1;\n\n for (i = 1; i < n; i++)\n {\n val = (gsl_vector_get (y1, i));\n if (val < dlo)\n {\n dlo = val;\n lo = i;\n }\n else if (val > dhi)\n {\n ds_hi = dhi;\n s_hi = hi;\n dhi = val;\n hi = i;\n }\n else if (val > ds_hi)\n {\n ds_hi = val;\n s_hi = i;\n }\n }\n\n /* reflect the highest value */\n\n val = nmsimplex_move_corner (-1.0, state, hi, xc, f);\n\n if (gsl_finite(val) && val < gsl_vector_get (y1, lo))\n {\n\n /* reflected point becomes lowest point, try expansion */\n\n val2 = nmsimplex_move_corner (-2.0, state, hi, xc2, f);\n\n if (gsl_finite(val2) && val2 < gsl_vector_get (y1, lo))\n {\n gsl_matrix_set_row (x1, hi, xc2);\n gsl_vector_set (y1, hi, val2);\n }\n else\n {\n gsl_matrix_set_row (x1, hi, xc);\n gsl_vector_set (y1, hi, val);\n }\n }\n\n /* reflection does not improve things enough\n or\n we got a non-finite (illegal) function value */\n\n else if (!gsl_finite(val) || val > gsl_vector_get (y1, s_hi))\n {\n if (gsl_finite(val) && val <= gsl_vector_get (y1, hi))\n {\n\n /* if trial point is better than highest point, replace \n highest point */\n\n gsl_matrix_set_row (x1, hi, xc);\n gsl_vector_set (y1, hi, val);\n }\n\n /* try one dimensional contraction */\n\n val2 = nmsimplex_move_corner (0.5, state, hi, xc2, f);\n\n if (gsl_finite(val2) && val2 <= gsl_vector_get (y1, hi))\n {\n gsl_matrix_set_row (state->x1, hi, xc2);\n gsl_vector_set (y1, hi, val2);\n }\n\n else\n {\n\n /* contract the whole simplex in respect to the best point */\n\n status = nmsimplex_contract_by_best (state, lo, xc, f);\n if (status != GSL_SUCCESS)\n {\n GSL_ERROR (\"nmsimplex_contract_by_best failed\", GSL_EFAILED);\n }\n }\n }\n else\n {\n\n /* trial point is better than second highest point. \n Replace highest point by it */\n\n gsl_matrix_set_row (x1, hi, xc);\n gsl_vector_set (y1, hi, val);\n }\n\n /* return lowest point of simplex as x */\n\n lo = gsl_vector_min_index (y1);\n gsl_matrix_get_row (x, x1, lo);\n *fval = gsl_vector_get (y1, lo);\n\n /* Update simplex size */\n\n *size = nmsimplex_size (state);\n\n return GSL_SUCCESS;\n}\n\nstatic const gsl_multimin_fminimizer_type nmsimplex_type = \n{ \"nmsimplex\", /* name */\n sizeof (nmsimplex_state_t),\n &nmsimplex_alloc,\n &nmsimplex_set,\n &nmsimplex_iterate,\n &nmsimplex_free\n};\n\nconst gsl_multimin_fminimizer_type\n * gsl_multimin_fminimizer_nmsimplex = &nmsimplex_type;\n", "meta": {"hexsha": "0d05b1b6a9b37147eb851abd2e1092d8dc3da649", "size": 11311, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.6/multimin/simplex.c", "max_stars_repo_name": "ielomariala/Hex-Game", "max_stars_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-01-11T02:53:04.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-25T17:31:22.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/multimin/simplex.c", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-12-16T17:41:24.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-22T00:00:16.000Z", "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/multimin/simplex.c", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 14.0, "max_forks_repo_forks_event_min_datetime": "2015-07-21T04:47:52.000Z", "max_forks_repo_forks_event_max_datetime": "2020-03-12T12:31:25.000Z", "avg_line_length": 24.1688034188, "max_line_length": 81, "alphanum_fraction": 0.5971178499, "num_tokens": 3319, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7905303186696748, "lm_q2_score": 0.6619228891883799, "lm_q1q2_score": 0.5232701125248419}} {"text": "/* interpolation/linear.c\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n/* Author: G. Jungman\n */\n#include \n#include \n#include \n#include \n\nstatic int\nlinear_init (void * vstate,\n const double x_array[],\n const double y_array[],\n size_t size)\n{\n return GSL_SUCCESS;\n}\n\nstatic\nint\nlinear_eval (const void * vstate,\n const double x_array[], const double y_array[], size_t size,\n double x,\n gsl_interp_accel * a,\n double *y)\n{\n double x_lo, x_hi;\n double y_lo, y_hi;\n double dx;\n size_t index;\n \n if (a != 0)\n {\n index = gsl_interp_accel_find (a, x_array, size, x);\n }\n else\n {\n index = gsl_interp_bsearch (x_array, x, 0, size - 1);\n }\n \n /* evaluate */\n x_lo = x_array[index];\n x_hi = x_array[index + 1];\n y_lo = y_array[index];\n y_hi = y_array[index + 1];\n dx = x_hi - x_lo;\n if (dx > 0.0)\n {\n *y = y_lo + (x - x_lo) / dx * (y_hi - y_lo);\n return GSL_SUCCESS;\n }\n else\n {\n *y = 0.0;\n return GSL_EINVAL;\n }\n}\n\n\nstatic\nint\nlinear_eval_deriv (const void * vstate,\n const double x_array[], const double y_array[], size_t size,\n double x,\n gsl_interp_accel * a,\n double *dydx)\n{\n double x_lo, x_hi;\n double y_lo, y_hi;\n double dx;\n double dy;\n size_t index;\n \n if (a != 0)\n {\n index = gsl_interp_accel_find (a, x_array, size, x);\n }\n else\n {\n index = gsl_interp_bsearch (x_array, x, 0, size - 1);\n }\n \n /* evaluate */\n x_lo = x_array[index];\n x_hi = x_array[index + 1];\n y_lo = y_array[index];\n y_hi = y_array[index + 1];\n dx = x_hi - x_lo;\n dy = y_hi - y_lo;\n if (dx > 0.0)\n {\n *dydx = dy / dx;;\n return GSL_SUCCESS;\n }\n else\n {\n *dydx = 0.0;\n return GSL_EINVAL;\n }\n}\n\n\nstatic\nint\nlinear_eval_deriv2 (const void * vstate,\n const double x_array[], const double y_array[], size_t size,\n double x,\n gsl_interp_accel * a,\n double *y_pp)\n{\n *y_pp = 0.0;\n\n return GSL_SUCCESS;\n}\n\n\nstatic\nint\nlinear_eval_integ (const void * vstate,\n const double x_array[], const double y_array[], size_t size,\n gsl_interp_accel * acc,\n double a, double b,\n double * result)\n{\n size_t i, index_a, index_b;\n \n if (acc != 0)\n {\n index_a = gsl_interp_accel_find (acc, x_array, size, a);\n index_b = gsl_interp_accel_find (acc, x_array, size, b);\n }\n else\n {\n index_a = gsl_interp_bsearch (x_array, a, 0, size - 1);\n index_b = gsl_interp_bsearch (x_array, b, 0, size - 1);\n }\n \n /* endpoints span more than one interval */\n\n *result = 0.0;\n \n /* interior intervals */\n for(i=index_a; i<=index_b; i++) {\n const double x_hi = x_array[i + 1];\n const double x_lo = x_array[i];\n const double y_lo = y_array[i];\n const double y_hi = y_array[i + 1];\n const double dx = x_hi - x_lo;\n\n if(dx != 0.0) {\n if (i == index_a || i == index_b)\n {\n double x1 = (i == index_a) ? a : x_lo;\n double x2 = (i == index_b) ? b : x_hi;\n const double D = (y_hi-y_lo)/dx;\n *result += (x2-x1) * (y_lo + 0.5*D*((x2-x_lo)+(x1-x_lo)));\n }\n else\n {\n *result += 0.5 * dx * (y_lo + y_hi);\n }\n }\n }\n \n return GSL_SUCCESS;\n}\n\nstatic const gsl_interp_type linear_type = \n{\n \"linear\", \n 2,\n NULL, /* alloc, not applicable */\n &linear_init,\n &linear_eval,\n &linear_eval_deriv,\n &linear_eval_deriv2,\n &linear_eval_integ,\n NULL, /* free, not applicable */\n};\n\nconst gsl_interp_type * gsl_interp_linear = &linear_type;\n", "meta": {"hexsha": "65ca83ea50a1750ad23cbb8d2e01490e6c8eb9a6", "size": 4558, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.6/interpolation/linear.c", "max_stars_repo_name": "ielomariala/Hex-Game", "max_stars_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-12-18T18:09:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-10T11:31:28.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/interpolation/linear.c", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-12-16T17:41:24.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-22T00:00:16.000Z", "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/interpolation/linear.c", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 14.0, "max_forks_repo_forks_event_min_datetime": "2015-07-21T04:47:52.000Z", "max_forks_repo_forks_event_max_datetime": "2020-03-12T12:31:25.000Z", "avg_line_length": 22.9045226131, "max_line_length": 81, "alphanum_fraction": 0.5737165423, "num_tokens": 1311, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7217432182679956, "lm_q2_score": 0.7248702702332475, "lm_q1q2_score": 0.5231702016649357}} {"text": "/* specfunc/hyperg_2F1.c\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2004 Gerard Jungman\n * Copyright (C) 2009 Brian Gough\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n/* Author: G. Jungman */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"error.h\"\n\n#define locEPS (1000.0*GSL_DBL_EPSILON)\n\n\n/* Assumes c != negative integer.\n */\nstatic int\nhyperg_2F1_series(const double a, const double b, const double c,\n const double x, \n gsl_sf_result * result\n )\n{\n double sum_pos = 1.0;\n double sum_neg = 0.0;\n double del_pos = 1.0;\n double del_neg = 0.0;\n double del = 1.0;\n double k = 0.0;\n int i = 0;\n\n if(fabs(c) < GSL_DBL_EPSILON) {\n result->val = 0.0; /* FIXME: ?? */\n result->err = 1.0;\n GSL_ERROR (\"error\", GSL_EDOM);\n }\n\n do {\n if(++i > 30000) {\n result->val = sum_pos - sum_neg;\n result->err = del_pos + del_neg;\n result->err += 2.0 * GSL_DBL_EPSILON * (sum_pos + sum_neg);\n result->err += 2.0 * GSL_DBL_EPSILON * (2.0*sqrt(k)+1.0) * fabs(result->val);\n GSL_ERROR (\"error\", GSL_EMAXITER);\n }\n del *= (a+k)*(b+k) * x / ((c+k) * (k+1.0)); /* Gauss series */\n\n if(del > 0.0) {\n del_pos = del;\n sum_pos += del;\n }\n else if(del == 0.0) {\n /* Exact termination (a or b was a negative integer).\n */\n del_pos = 0.0;\n del_neg = 0.0;\n break;\n }\n else {\n del_neg = -del;\n sum_neg -= del;\n }\n\n k += 1.0;\n } while(fabs((del_pos + del_neg)/(sum_pos-sum_neg)) > GSL_DBL_EPSILON);\n\n result->val = sum_pos - sum_neg;\n result->err = del_pos + del_neg;\n result->err += 2.0 * GSL_DBL_EPSILON * (sum_pos + sum_neg);\n result->err += 2.0 * GSL_DBL_EPSILON * (2.0*sqrt(k) + 1.0) * fabs(result->val);\n\n return GSL_SUCCESS;\n}\n\n\n/* a = aR + i aI, b = aR - i aI */\nstatic\nint\nhyperg_2F1_conj_series(const double aR, const double aI, const double c,\n double x,\n gsl_sf_result * result)\n{\n if(c == 0.0) {\n result->val = 0.0; /* FIXME: should be Inf */\n result->err = 0.0;\n GSL_ERROR (\"error\", GSL_EDOM);\n }\n else {\n double sum_pos = 1.0;\n double sum_neg = 0.0;\n double del_pos = 1.0;\n double del_neg = 0.0;\n double del = 1.0;\n double k = 0.0;\n do {\n del *= ((aR+k)*(aR+k) + aI*aI)/((k+1.0)*(c+k)) * x;\n\n if(del >= 0.0) {\n del_pos = del;\n sum_pos += del;\n }\n else {\n del_neg = -del;\n sum_neg -= del;\n }\n\n if(k > 30000) {\n result->val = sum_pos - sum_neg;\n result->err = del_pos + del_neg;\n result->err += 2.0 * GSL_DBL_EPSILON * (sum_pos + sum_neg);\n result->err += 2.0 * GSL_DBL_EPSILON * (2.0*sqrt(k)+1.0) * fabs(result->val);\n GSL_ERROR (\"error\", GSL_EMAXITER);\n }\n\n k += 1.0;\n } while(fabs((del_pos + del_neg)/(sum_pos - sum_neg)) > GSL_DBL_EPSILON);\n\n result->val = sum_pos - sum_neg;\n result->err = del_pos + del_neg;\n result->err += 2.0 * GSL_DBL_EPSILON * (sum_pos + sum_neg);\n result->err += 2.0 * GSL_DBL_EPSILON * (2.0*sqrt(k) + 1.0) * fabs(result->val);\n\n return GSL_SUCCESS;\n }\n}\n\n\n/* Luke's rational approximation. The most accesible\n * discussion is in [Kolbig, CPC 23, 51 (1981)].\n * The convergence is supposedly guaranteed for x < 0.\n * You have to read Luke's books to see this and other\n * results. Unfortunately, the stability is not so\n * clear to me, although it seems very efficient when\n * it works.\n */\nstatic\nint\nhyperg_2F1_luke(const double a, const double b, const double c,\n const double xin, \n gsl_sf_result * result)\n{\n int stat_iter;\n const double RECUR_BIG = 1.0e+50;\n const int nmax = 20000;\n int n = 3;\n const double x = -xin;\n const double x3 = x*x*x;\n const double t0 = a*b/c;\n const double t1 = (a+1.0)*(b+1.0)/(2.0*c);\n const double t2 = (a+2.0)*(b+2.0)/(2.0*(c+1.0));\n double F = 1.0;\n double prec;\n\n double Bnm3 = 1.0; /* B0 */\n double Bnm2 = 1.0 + t1 * x; /* B1 */\n double Bnm1 = 1.0 + t2 * x * (1.0 + t1/3.0 * x); /* B2 */\n \n double Anm3 = 1.0; /* A0 */\n double Anm2 = Bnm2 - t0 * x; /* A1 */\n double Anm1 = Bnm1 - t0*(1.0 + t2*x)*x + t0 * t1 * (c/(c+1.0)) * x*x; /* A2 */\n\n while(1) {\n double npam1 = n + a - 1;\n double npbm1 = n + b - 1;\n double npcm1 = n + c - 1;\n double npam2 = n + a - 2;\n double npbm2 = n + b - 2;\n double npcm2 = n + c - 2;\n double tnm1 = 2*n - 1;\n double tnm3 = 2*n - 3;\n double tnm5 = 2*n - 5;\n double n2 = n*n;\n double F1 = (3.0*n2 + (a+b-6)*n + 2 - a*b - 2*(a+b)) / (2*tnm3*npcm1);\n double F2 = -(3.0*n2 - (a+b+6)*n + 2 - a*b)*npam1*npbm1/(4*tnm1*tnm3*npcm2*npcm1);\n double F3 = (npam2*npam1*npbm2*npbm1*(n-a-2)*(n-b-2)) / (8*tnm3*tnm3*tnm5*(n+c-3)*npcm2*npcm1);\n double E = -npam1*npbm1*(n-c-1) / (2*tnm3*npcm2*npcm1);\n\n double An = (1.0+F1*x)*Anm1 + (E + F2*x)*x*Anm2 + F3*x3*Anm3;\n double Bn = (1.0+F1*x)*Bnm1 + (E + F2*x)*x*Bnm2 + F3*x3*Bnm3;\n double r = An/Bn;\n\n prec = fabs((F - r)/F);\n F = r;\n\n if(prec < GSL_DBL_EPSILON || n > nmax) break;\n\n if(fabs(An) > RECUR_BIG || fabs(Bn) > RECUR_BIG) {\n An /= RECUR_BIG;\n Bn /= RECUR_BIG;\n Anm1 /= RECUR_BIG;\n Bnm1 /= RECUR_BIG;\n Anm2 /= RECUR_BIG;\n Bnm2 /= RECUR_BIG;\n Anm3 /= RECUR_BIG;\n Bnm3 /= RECUR_BIG;\n }\n else if(fabs(An) < 1.0/RECUR_BIG || fabs(Bn) < 1.0/RECUR_BIG) {\n An *= RECUR_BIG;\n Bn *= RECUR_BIG;\n Anm1 *= RECUR_BIG;\n Bnm1 *= RECUR_BIG;\n Anm2 *= RECUR_BIG;\n Bnm2 *= RECUR_BIG;\n Anm3 *= RECUR_BIG;\n Bnm3 *= RECUR_BIG;\n }\n\n n++;\n Bnm3 = Bnm2;\n Bnm2 = Bnm1;\n Bnm1 = Bn;\n Anm3 = Anm2;\n Anm2 = Anm1;\n Anm1 = An;\n }\n\n result->val = F;\n result->err = 2.0 * fabs(prec * F);\n result->err += 2.0 * GSL_DBL_EPSILON * (n+1.0) * fabs(F);\n\n /* FIXME: just a hack: there's a lot of shit going on here */\n result->err *= 8.0 * (fabs(a) + fabs(b) + 1.0);\n\n stat_iter = (n >= nmax ? GSL_EMAXITER : GSL_SUCCESS );\n\n return stat_iter;\n}\n\n\n/* Luke's rational approximation for the\n * case a = aR + i aI, b = aR - i aI.\n */\nstatic\nint\nhyperg_2F1_conj_luke(const double aR, const double aI, const double c,\n const double xin, \n gsl_sf_result * result)\n{\n int stat_iter;\n const double RECUR_BIG = 1.0e+50;\n const int nmax = 10000;\n int n = 3;\n const double x = -xin;\n const double x3 = x*x*x;\n const double atimesb = aR*aR + aI*aI;\n const double apb = 2.0*aR;\n const double t0 = atimesb/c;\n const double t1 = (atimesb + apb + 1.0)/(2.0*c);\n const double t2 = (atimesb + 2.0*apb + 4.0)/(2.0*(c+1.0));\n double F = 1.0;\n double prec;\n\n double Bnm3 = 1.0; /* B0 */\n double Bnm2 = 1.0 + t1 * x; /* B1 */\n double Bnm1 = 1.0 + t2 * x * (1.0 + t1/3.0 * x); /* B2 */\n \n double Anm3 = 1.0; /* A0 */\n double Anm2 = Bnm2 - t0 * x; /* A1 */\n double Anm1 = Bnm1 - t0*(1.0 + t2*x)*x + t0 * t1 * (c/(c+1.0)) * x*x; /* A2 */\n\n while(1) {\n double nm1 = n - 1;\n double nm2 = n - 2;\n double npam1_npbm1 = atimesb + nm1*apb + nm1*nm1;\n double npam2_npbm2 = atimesb + nm2*apb + nm2*nm2;\n double npcm1 = nm1 + c;\n double npcm2 = nm2 + c;\n double tnm1 = 2*n - 1;\n double tnm3 = 2*n - 3;\n double tnm5 = 2*n - 5;\n double n2 = n*n;\n double F1 = (3.0*n2 + (apb-6)*n + 2 - atimesb - 2*apb) / (2*tnm3*npcm1);\n double F2 = -(3.0*n2 - (apb+6)*n + 2 - atimesb)*npam1_npbm1/(4*tnm1*tnm3*npcm2*npcm1);\n double F3 = (npam2_npbm2*npam1_npbm1*(nm2*nm2 - nm2*apb + atimesb)) / (8*tnm3*tnm3*tnm5*(n+c-3)*npcm2*npcm1);\n double E = -npam1_npbm1*(n-c-1) / (2*tnm3*npcm2*npcm1);\n\n double An = (1.0+F1*x)*Anm1 + (E + F2*x)*x*Anm2 + F3*x3*Anm3;\n double Bn = (1.0+F1*x)*Bnm1 + (E + F2*x)*x*Bnm2 + F3*x3*Bnm3;\n double r = An/Bn;\n\n prec = fabs(F - r)/fabs(F);\n F = r;\n\n if(prec < GSL_DBL_EPSILON || n > nmax) break;\n\n if(fabs(An) > RECUR_BIG || fabs(Bn) > RECUR_BIG) {\n An /= RECUR_BIG;\n Bn /= RECUR_BIG;\n Anm1 /= RECUR_BIG;\n Bnm1 /= RECUR_BIG;\n Anm2 /= RECUR_BIG;\n Bnm2 /= RECUR_BIG;\n Anm3 /= RECUR_BIG;\n Bnm3 /= RECUR_BIG;\n }\n else if(fabs(An) < 1.0/RECUR_BIG || fabs(Bn) < 1.0/RECUR_BIG) {\n An *= RECUR_BIG;\n Bn *= RECUR_BIG;\n Anm1 *= RECUR_BIG;\n Bnm1 *= RECUR_BIG;\n Anm2 *= RECUR_BIG;\n Bnm2 *= RECUR_BIG;\n Anm3 *= RECUR_BIG;\n Bnm3 *= RECUR_BIG;\n }\n\n n++;\n Bnm3 = Bnm2;\n Bnm2 = Bnm1;\n Bnm1 = Bn;\n Anm3 = Anm2;\n Anm2 = Anm1;\n Anm1 = An;\n }\n \n result->val = F;\n result->err = 2.0 * fabs(prec * F);\n result->err += 2.0 * GSL_DBL_EPSILON * (n+1.0) * fabs(F);\n\n /* FIXME: see above */\n result->err *= 8.0 * (fabs(aR) + fabs(aI) + 1.0);\n\n stat_iter = (n >= nmax ? GSL_EMAXITER : GSL_SUCCESS );\n\n return stat_iter;\n}\n\n\n/* Do the reflection described in [Moshier, p. 334].\n * Assumes a,b,c != neg integer.\n */\nstatic\nint\nhyperg_2F1_reflect(const double a, const double b, const double c,\n const double x, gsl_sf_result * result)\n{\n const double d = c - a - b;\n const int intd = floor(d+0.5);\n const int d_integer = ( fabs(d - intd) < locEPS );\n\n if(d_integer) {\n const double ln_omx = log(1.0 - x);\n const double ad = fabs(d);\n int stat_F2 = GSL_SUCCESS;\n double sgn_2;\n gsl_sf_result F1;\n gsl_sf_result F2;\n double d1, d2;\n gsl_sf_result lng_c;\n gsl_sf_result lng_ad2;\n gsl_sf_result lng_bd2;\n int stat_c;\n int stat_ad2;\n int stat_bd2;\n\n if(d >= 0.0) {\n d1 = d;\n d2 = 0.0;\n }\n else {\n d1 = 0.0;\n d2 = d;\n }\n\n stat_ad2 = gsl_sf_lngamma_e(a+d2, &lng_ad2);\n stat_bd2 = gsl_sf_lngamma_e(b+d2, &lng_bd2);\n stat_c = gsl_sf_lngamma_e(c, &lng_c);\n\n /* Evaluate F1.\n */\n if(ad < GSL_DBL_EPSILON) {\n /* d = 0 */\n F1.val = 0.0;\n F1.err = 0.0;\n }\n else {\n gsl_sf_result lng_ad;\n gsl_sf_result lng_ad1;\n gsl_sf_result lng_bd1;\n int stat_ad = gsl_sf_lngamma_e(ad, &lng_ad);\n int stat_ad1 = gsl_sf_lngamma_e(a+d1, &lng_ad1);\n int stat_bd1 = gsl_sf_lngamma_e(b+d1, &lng_bd1);\n\n if(stat_ad1 == GSL_SUCCESS && stat_bd1 == GSL_SUCCESS && stat_ad == GSL_SUCCESS) {\n /* Gamma functions in the denominator are ok.\n * Proceed with evaluation.\n */\n int i;\n double sum1 = 1.0;\n double term = 1.0;\n double ln_pre1_val = lng_ad.val + lng_c.val + d2*ln_omx - lng_ad1.val - lng_bd1.val;\n double ln_pre1_err = lng_ad.err + lng_c.err + lng_ad1.err + lng_bd1.err + GSL_DBL_EPSILON * fabs(ln_pre1_val);\n int stat_e;\n\n /* Do F1 sum.\n */\n for(i=1; ival = 0.0;\n result->err = 0.0;\n GSL_ERROR (\"error\", GSL_EOVRFLW);\n }\n }\n stat_F2 = GSL_ERROR_SELECT_2(stat_F2, stat_dall);\n }\n else {\n /* Gamma functions in the denominator not ok.\n * So the F2 term is zero.\n */\n F2.val = 0.0;\n F2.err = 0.0;\n } /* end F2 evaluation */\n\n sgn_2 = ( GSL_IS_ODD(intd) ? -1.0 : 1.0 );\n result->val = F1.val + sgn_2 * F2.val;\n result->err = F1.err + F2. err;\n result->err += 2.0 * GSL_DBL_EPSILON * (fabs(F1.val) + fabs(F2.val));\n result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);\n return stat_F2;\n }\n else {\n /* d not an integer */\n\n gsl_sf_result pre1, pre2;\n double sgn1, sgn2;\n gsl_sf_result F1, F2;\n int status_F1, status_F2;\n\n /* These gamma functions appear in the denominator, so we\n * catch their harmless domain errors and set the terms to zero.\n */\n gsl_sf_result ln_g1ca, ln_g1cb, ln_g2a, ln_g2b;\n double sgn_g1ca, sgn_g1cb, sgn_g2a, sgn_g2b;\n int stat_1ca = gsl_sf_lngamma_sgn_e(c-a, &ln_g1ca, &sgn_g1ca);\n int stat_1cb = gsl_sf_lngamma_sgn_e(c-b, &ln_g1cb, &sgn_g1cb);\n int stat_2a = gsl_sf_lngamma_sgn_e(a, &ln_g2a, &sgn_g2a);\n int stat_2b = gsl_sf_lngamma_sgn_e(b, &ln_g2b, &sgn_g2b);\n int ok1 = (stat_1ca == GSL_SUCCESS && stat_1cb == GSL_SUCCESS);\n int ok2 = (stat_2a == GSL_SUCCESS && stat_2b == GSL_SUCCESS);\n \n gsl_sf_result ln_gc, ln_gd, ln_gmd;\n double sgn_gc, sgn_gd, sgn_gmd;\n gsl_sf_lngamma_sgn_e( c, &ln_gc, &sgn_gc);\n gsl_sf_lngamma_sgn_e( d, &ln_gd, &sgn_gd);\n gsl_sf_lngamma_sgn_e(-d, &ln_gmd, &sgn_gmd);\n \n sgn1 = sgn_gc * sgn_gd * sgn_g1ca * sgn_g1cb;\n sgn2 = sgn_gc * sgn_gmd * sgn_g2a * sgn_g2b;\n\n if(ok1 && ok2) {\n double ln_pre1_val = ln_gc.val + ln_gd.val - ln_g1ca.val - ln_g1cb.val;\n double ln_pre2_val = ln_gc.val + ln_gmd.val - ln_g2a.val - ln_g2b.val + d*log(1.0-x);\n double ln_pre1_err = ln_gc.err + ln_gd.err + ln_g1ca.err + ln_g1cb.err;\n double ln_pre2_err = ln_gc.err + ln_gmd.err + ln_g2a.err + ln_g2b.err;\n if(ln_pre1_val < GSL_LOG_DBL_MAX && ln_pre2_val < GSL_LOG_DBL_MAX) {\n gsl_sf_exp_err_e(ln_pre1_val, ln_pre1_err, &pre1);\n gsl_sf_exp_err_e(ln_pre2_val, ln_pre2_err, &pre2);\n pre1.val *= sgn1;\n pre2.val *= sgn2;\n }\n else {\n OVERFLOW_ERROR(result);\n }\n }\n else if(ok1 && !ok2) {\n double ln_pre1_val = ln_gc.val + ln_gd.val - ln_g1ca.val - ln_g1cb.val;\n double ln_pre1_err = ln_gc.err + ln_gd.err + ln_g1ca.err + ln_g1cb.err;\n if(ln_pre1_val < GSL_LOG_DBL_MAX) {\n gsl_sf_exp_err_e(ln_pre1_val, ln_pre1_err, &pre1);\n pre1.val *= sgn1;\n pre2.val = 0.0;\n pre2.err = 0.0;\n }\n else {\n OVERFLOW_ERROR(result);\n }\n }\n else if(!ok1 && ok2) {\n double ln_pre2_val = ln_gc.val + ln_gmd.val - ln_g2a.val - ln_g2b.val + d*log(1.0-x);\n double ln_pre2_err = ln_gc.err + ln_gmd.err + ln_g2a.err + ln_g2b.err;\n if(ln_pre2_val < GSL_LOG_DBL_MAX) {\n pre1.val = 0.0;\n pre1.err = 0.0;\n gsl_sf_exp_err_e(ln_pre2_val, ln_pre2_err, &pre2);\n pre2.val *= sgn2;\n }\n else {\n OVERFLOW_ERROR(result);\n }\n }\n else {\n pre1.val = 0.0;\n pre2.val = 0.0;\n UNDERFLOW_ERROR(result);\n }\n\n status_F1 = hyperg_2F1_series( a, b, 1.0-d, 1.0-x, &F1);\n status_F2 = hyperg_2F1_series(c-a, c-b, 1.0+d, 1.0-x, &F2);\n\n result->val = pre1.val*F1.val + pre2.val*F2.val;\n result->err = fabs(pre1.val*F1.err) + fabs(pre2.val*F2.err);\n result->err += fabs(pre1.err*F1.val) + fabs(pre2.err*F2.val);\n result->err += 2.0 * GSL_DBL_EPSILON * (fabs(pre1.val*F1.val) + fabs(pre2.val*F2.val));\n result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);\n\n return GSL_SUCCESS;\n }\n}\n\n\nstatic int pow_omx(const double x, const double p, gsl_sf_result * result)\n{\n double ln_omx;\n double ln_result;\n if(fabs(x) < GSL_ROOT5_DBL_EPSILON) {\n ln_omx = -x*(1.0 + x*(1.0/2.0 + x*(1.0/3.0 + x/4.0 + x*x/5.0)));\n }\n else {\n ln_omx = log(1.0-x);\n }\n ln_result = p * ln_omx;\n return gsl_sf_exp_err_e(ln_result, GSL_DBL_EPSILON * fabs(ln_result), result);\n}\n\n\n/*-*-*-*-*-*-*-*-*-*-*-* Functions with Error Codes *-*-*-*-*-*-*-*-*-*-*-*/\n\nint\ngsl_sf_hyperg_2F1_e(double a, double b, const double c,\n const double x,\n gsl_sf_result * result)\n{\n const double d = c - a - b;\n const double rinta = floor(a + 0.5);\n const double rintb = floor(b + 0.5);\n const double rintc = floor(c + 0.5);\n const int a_neg_integer = ( a < 0.0 && fabs(a - rinta) < locEPS );\n const int b_neg_integer = ( b < 0.0 && fabs(b - rintb) < locEPS );\n const int c_neg_integer = ( c < 0.0 && fabs(c - rintc) < locEPS );\n\n result->val = 0.0;\n result->err = 0.0;\n\n /* Handle x == 1.0 RJM */\n\n if (fabs (x - 1.0) < locEPS && (c - a - b) > 0 && c != 0 && !c_neg_integer) {\n gsl_sf_result lngamc, lngamcab, lngamca, lngamcb;\n double lngamc_sgn, lngamca_sgn, lngamcb_sgn;\n int status;\n int stat1 = gsl_sf_lngamma_sgn_e (c, &lngamc, &lngamc_sgn);\n int stat2 = gsl_sf_lngamma_e (c - a - b, &lngamcab);\n int stat3 = gsl_sf_lngamma_sgn_e (c - a, &lngamca, &lngamca_sgn);\n int stat4 = gsl_sf_lngamma_sgn_e (c - b, &lngamcb, &lngamcb_sgn);\n \n if (stat1 != GSL_SUCCESS || stat2 != GSL_SUCCESS\n || stat3 != GSL_SUCCESS || stat4 != GSL_SUCCESS)\n {\n DOMAIN_ERROR (result);\n }\n \n status =\n gsl_sf_exp_err_e (lngamc.val + lngamcab.val - lngamca.val - lngamcb.val,\n lngamc.err + lngamcab.err + lngamca.err + lngamcb.err,\n result);\n \n result->val *= lngamc_sgn / (lngamca_sgn * lngamcb_sgn);\n return status;\n }\n \n if(x < -1.0 || 1.0 <= x) {\n DOMAIN_ERROR(result);\n }\n\n if(c_neg_integer) {\n /* If c is a negative integer, then either a or b must be a\n negative integer of smaller magnitude than c to ensure\n cancellation of the series. */\n if(! (a_neg_integer && a > c + 0.1) && ! (b_neg_integer && b > c + 0.1)) {\n DOMAIN_ERROR(result);\n }\n }\n\n if(fabs(c-b) < locEPS || fabs(c-a) < locEPS) {\n return pow_omx(x, d, result); /* (1-x)^(c-a-b) */\n }\n\n if(a >= 0.0 && b >= 0.0 && c >=0.0 && x >= 0.0 && x < 0.995) {\n /* Series has all positive definite\n * terms and x is not close to 1.\n */\n return hyperg_2F1_series(a, b, c, x, result);\n }\n\n if(fabs(a) < 10.0 && fabs(b) < 10.0) {\n /* a and b are not too large, so we attempt\n * variations on the series summation.\n */\n if(a_neg_integer) {\n return hyperg_2F1_series(rinta, b, c, x, result);\n }\n if(b_neg_integer) {\n return hyperg_2F1_series(a, rintb, c, x, result);\n }\n\n if(x < -0.25) {\n return hyperg_2F1_luke(a, b, c, x, result);\n }\n else if(x < 0.5) {\n return hyperg_2F1_series(a, b, c, x, result);\n }\n else {\n if(fabs(c) > 10.0) {\n return hyperg_2F1_series(a, b, c, x, result);\n }\n else {\n return hyperg_2F1_reflect(a, b, c, x, result);\n }\n }\n }\n else {\n /* Either a or b or both large.\n * Introduce some new variables ap,bp so that bp is\n * the larger in magnitude.\n */\n double ap, bp; \n if(fabs(a) > fabs(b)) {\n bp = a;\n ap = b;\n }\n else {\n bp = b;\n ap = a;\n }\n\n if(x < 0.0) {\n /* What the hell, maybe Luke will converge.\n */\n return hyperg_2F1_luke(a, b, c, x, result);\n }\n\n if(GSL_MAX_DBL(fabs(ap),1.0)*fabs(bp)*fabs(x) < 2.0*fabs(c)) {\n /* If c is large enough or x is small enough,\n * we can attempt the series anyway.\n */\n return hyperg_2F1_series(a, b, c, x, result);\n }\n\n if(fabs(bp*bp*x*x) < 0.001*fabs(bp) && fabs(ap) < 10.0) {\n /* The famous but nearly worthless \"large b\" asymptotic.\n */\n int stat = gsl_sf_hyperg_1F1_e(ap, c, bp*x, result);\n result->err = 0.001 * fabs(result->val);\n return stat;\n }\n\n /* We give up. */\n result->val = 0.0;\n result->err = 0.0;\n GSL_ERROR (\"error\", GSL_EUNIMPL);\n }\n}\n\n\nint\ngsl_sf_hyperg_2F1_conj_e(const double aR, const double aI, const double c,\n const double x,\n gsl_sf_result * result)\n{\n const double ax = fabs(x);\n const double rintc = floor(c + 0.5);\n const int c_neg_integer = ( c < 0.0 && fabs(c - rintc) < locEPS );\n\n result->val = 0.0;\n result->err = 0.0;\n\n if(ax >= 1.0 || c_neg_integer || c == 0.0) {\n DOMAIN_ERROR(result);\n }\n\n if( (ax < 0.25 && fabs(aR) < 20.0 && fabs(aI) < 20.0)\n || (c > 0.0 && x > 0.0)\n ) {\n return hyperg_2F1_conj_series(aR, aI, c, x, result);\n }\n else if(fabs(aR) < 10.0 && fabs(aI) < 10.0) {\n if(x < -0.25) {\n return hyperg_2F1_conj_luke(aR, aI, c, x, result);\n }\n else {\n return hyperg_2F1_conj_series(aR, aI, c, x, result);\n }\n }\n else {\n if(x < 0.0) {\n /* What the hell, maybe Luke will converge.\n */\n return hyperg_2F1_conj_luke(aR, aI, c, x, result); \n }\n\n /* Give up. */\n result->val = 0.0;\n result->err = 0.0;\n GSL_ERROR (\"error\", GSL_EUNIMPL);\n }\n}\n\n\nint\ngsl_sf_hyperg_2F1_renorm_e(const double a, const double b, const double c,\n const double x,\n gsl_sf_result * result\n )\n{\n const double rinta = floor(a + 0.5);\n const double rintb = floor(b + 0.5);\n const double rintc = floor(c + 0.5);\n const int a_neg_integer = ( a < 0.0 && fabs(a - rinta) < locEPS );\n const int b_neg_integer = ( b < 0.0 && fabs(b - rintb) < locEPS );\n const int c_neg_integer = ( c < 0.0 && fabs(c - rintc) < locEPS );\n \n if(c_neg_integer) {\n if((a_neg_integer && a > c+0.1) || (b_neg_integer && b > c+0.1)) {\n /* 2F1 terminates early */\n result->val = 0.0;\n result->err = 0.0;\n return GSL_SUCCESS;\n }\n else {\n /* 2F1 does not terminate early enough, so something survives */\n /* [Abramowitz+Stegun, 15.1.2] */\n gsl_sf_result g1, g2, g3, g4, g5;\n double s1, s2, s3, s4, s5;\n int stat = 0;\n stat += gsl_sf_lngamma_sgn_e(a-c+1, &g1, &s1);\n stat += gsl_sf_lngamma_sgn_e(b-c+1, &g2, &s2);\n stat += gsl_sf_lngamma_sgn_e(a, &g3, &s3);\n stat += gsl_sf_lngamma_sgn_e(b, &g4, &s4);\n stat += gsl_sf_lngamma_sgn_e(-c+2, &g5, &s5);\n if(stat != 0) {\n DOMAIN_ERROR(result);\n }\n else {\n gsl_sf_result F;\n int stat_F = gsl_sf_hyperg_2F1_e(a-c+1, b-c+1, -c+2, x, &F);\n double ln_pre_val = g1.val + g2.val - g3.val - g4.val - g5.val;\n double ln_pre_err = g1.err + g2.err + g3.err + g4.err + g5.err;\n double sg = s1 * s2 * s3 * s4 * s5;\n int stat_e = gsl_sf_exp_mult_err_e(ln_pre_val, ln_pre_err,\n sg * F.val, F.err,\n result);\n return GSL_ERROR_SELECT_2(stat_e, stat_F);\n }\n }\n }\n else {\n /* generic c */\n gsl_sf_result F;\n gsl_sf_result lng;\n double sgn;\n int stat_g = gsl_sf_lngamma_sgn_e(c, &lng, &sgn);\n int stat_F = gsl_sf_hyperg_2F1_e(a, b, c, x, &F);\n int stat_e = gsl_sf_exp_mult_err_e(-lng.val, lng.err,\n sgn*F.val, F.err,\n result);\n return GSL_ERROR_SELECT_3(stat_e, stat_F, stat_g);\n }\n}\n\n\nint\ngsl_sf_hyperg_2F1_conj_renorm_e(const double aR, const double aI, const double c,\n const double x,\n gsl_sf_result * result\n )\n{\n const double rintc = floor(c + 0.5);\n const double rinta = floor(aR + 0.5);\n const int a_neg_integer = ( aR < 0.0 && fabs(aR-rinta) < locEPS && aI == 0.0);\n const int c_neg_integer = ( c < 0.0 && fabs(c - rintc) < locEPS );\n\n if(c_neg_integer) {\n if(a_neg_integer && aR > c+0.1) {\n /* 2F1 terminates early */\n result->val = 0.0;\n result->err = 0.0;\n return GSL_SUCCESS;\n }\n else {\n /* 2F1 does not terminate early enough, so something survives */\n /* [Abramowitz+Stegun, 15.1.2] */\n gsl_sf_result g1, g2;\n gsl_sf_result g3;\n gsl_sf_result a1, a2;\n int stat = 0;\n stat += gsl_sf_lngamma_complex_e(aR-c+1, aI, &g1, &a1);\n stat += gsl_sf_lngamma_complex_e(aR, aI, &g2, &a2);\n stat += gsl_sf_lngamma_e(-c+2.0, &g3);\n if(stat != 0) {\n DOMAIN_ERROR(result);\n }\n else {\n gsl_sf_result F;\n int stat_F = gsl_sf_hyperg_2F1_conj_e(aR-c+1, aI, -c+2, x, &F);\n double ln_pre_val = 2.0*(g1.val - g2.val) - g3.val;\n double ln_pre_err = 2.0 * (g1.err + g2.err) + g3.err;\n int stat_e = gsl_sf_exp_mult_err_e(ln_pre_val, ln_pre_err,\n F.val, F.err,\n result);\n return GSL_ERROR_SELECT_2(stat_e, stat_F);\n }\n }\n }\n else {\n /* generic c */\n gsl_sf_result F;\n gsl_sf_result lng;\n double sgn;\n int stat_g = gsl_sf_lngamma_sgn_e(c, &lng, &sgn);\n int stat_F = gsl_sf_hyperg_2F1_conj_e(aR, aI, c, x, &F);\n int stat_e = gsl_sf_exp_mult_err_e(-lng.val, lng.err,\n sgn*F.val, F.err,\n result);\n return GSL_ERROR_SELECT_3(stat_e, stat_F, stat_g);\n }\n}\n\n\n/*-*-*-*-*-*-*-*-*-* Functions w/ Natural Prototypes *-*-*-*-*-*-*-*-*-*-*/\n\n#include \"eval.h\"\n\ndouble gsl_sf_hyperg_2F1(double a, double b, double c, double x)\n{\n EVAL_RESULT(gsl_sf_hyperg_2F1_e(a, b, c, x, &result));\n}\n\ndouble gsl_sf_hyperg_2F1_conj(double aR, double aI, double c, double x)\n{\n EVAL_RESULT(gsl_sf_hyperg_2F1_conj_e(aR, aI, c, x, &result));\n}\n\ndouble gsl_sf_hyperg_2F1_renorm(double a, double b, double c, double x)\n{\n EVAL_RESULT(gsl_sf_hyperg_2F1_renorm_e(a, b, c, x, &result));\n}\n\ndouble gsl_sf_hyperg_2F1_conj_renorm(double aR, double aI, double c, double x)\n{\n EVAL_RESULT(gsl_sf_hyperg_2F1_conj_renorm_e(aR, aI, c, x, &result));\n}\n", "meta": {"hexsha": "65683ec8debb07e81ed394f4d2060a69900a4569", "size": 28802, "ext": "c", "lang": "C", "max_stars_repo_path": "oldjuila/juliakernel/ext_libraries/gsl/specfunc/hyperg_2F1.c", "max_stars_repo_name": "ruslankuzmin/julia", "max_stars_repo_head_hexsha": "2ad5bfb9c9684b1c800e96732a9e2f1e844b856f", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-12-18T18:09:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-10T11:31:28.000Z", "max_issues_repo_path": "oldjuila/juliakernel/ext_libraries/gsl/specfunc/hyperg_2F1.c", "max_issues_repo_name": "ruslankuzmin/julia", "max_issues_repo_head_hexsha": "2ad5bfb9c9684b1c800e96732a9e2f1e844b856f", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "oldjuila/juliakernel/ext_libraries/gsl/specfunc/hyperg_2F1.c", "max_forks_repo_name": "ruslankuzmin/julia", "max_forks_repo_head_hexsha": "2ad5bfb9c9684b1c800e96732a9e2f1e844b856f", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2020-08-30T20:40:25.000Z", "max_forks_repo_forks_event_max_datetime": "2020-08-30T20:40:25.000Z", "avg_line_length": 30.413938754, "max_line_length": 118, "alphanum_fraction": 0.5482952573, "num_tokens": 10170, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8354835452961425, "lm_q2_score": 0.6261241842048092, "lm_q1q2_score": 0.523116453215089}} {"text": "/* Copyright (c) 2014, Giuseppe Argentieri \n\n * All rights reserved.\n * \n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n * \n * 1. Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n * \n * 2. Redistributions in binary form must reproduce the above copyright notice,\n * this list of conditions and the following disclaimer in the documentation\n * and/or other materials provided with the distribution.\n * \n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n * \n */\n/*\n *\n *\n * Filename: polar.c\n *\n * Description: Cartesian <-> Polar coordinates transformation\n *\n * Version: 1.0\n * Created: 06/05/2014 14:21:40\n * Revision: none\n * License: BSD\n *\n * Author: Giuseppe Argentieri (ga), giuseppe.argentieri@ts.infn.it\n * Organization: Università degli Studi di Trieste\n *\n * \n */\n\n#include \n#include \n#include \n#include \"funcs.h\"\n\n/* \n * FUNCTION \n * Name: bloch_vector\n * Description: Return the Bloch vector corresponding to (r,theta,phi) polar coords\n * \n */\nint bloch_vector ( gsl_vector* v, double r, double theta, double phi )\n{\n\t/* Check the validity of coordinates */\n\tif ( r > 1 ) /* Non physical state */\n\t{\n\t\tv = NULL ;\n\t\treturn -1;\n\t}\n\ttheta = fmod (theta, M_PI ) ; /* Taking the modulo */\n\tphi = fmod ( phi, 2*M_PI ) ;\n\n\tgsl_vector_set ( v, 1, r*sin(theta)*cos(phi) ) ;\n\tgsl_vector_set ( v, 2, r*sin(theta)*sin(phi) ) ;\n\tgsl_vector_set ( v, 3, r*cos(theta) ) ;\n\n\treturn 0;\n}\t\t/* ----- end of function bloch_vector ----- */\n\n\n/* \n * FUNCTION \n * Name: polars\n * Description: From the Bloch vector representation to the polar coordinates\n * \n */\nint polars ( double* r, double* theta, double* phi, const gsl_vector* v )\n{\n\t*r = gsl_hypot3( VECTOR(v,1), VECTOR(v,2), VECTOR(v,3) ) ;\n\tif ( *r > 1 )\n\t\treturn -1 ;\n\n\t*theta = acos(VECTOR(v,3)) ;\n\n\tif ( gsl_fcmp(fabs(*theta),1,1e-9) )\n\t\t*phi = 0 ;\n\telse\n\t\t*phi = atan2(VECTOR(v,2),VECTOR(v,1)) ;\n\n\treturn 0;\n}\t\t/* ----- end of function polars ----- */\n", "meta": {"hexsha": "f5ed9c3ffa1b1e4e08c48f1311c12046d659c645", "size": 3019, "ext": "c", "lang": "C", "max_stars_repo_path": "polar.c", "max_stars_repo_name": "j-silver/quantum_dots", "max_stars_repo_head_hexsha": "54132a3c7dd0e83e27375f6c5f6ec154065a9695", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "polar.c", "max_issues_repo_name": "j-silver/quantum_dots", "max_issues_repo_head_hexsha": "54132a3c7dd0e83e27375f6c5f6ec154065a9695", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "polar.c", "max_forks_repo_name": "j-silver/quantum_dots", "max_forks_repo_head_hexsha": "54132a3c7dd0e83e27375f6c5f6ec154065a9695", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.1237113402, "max_line_length": 85, "alphanum_fraction": 0.665783372, "num_tokens": 804, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7981867777396212, "lm_q2_score": 0.6548947290421275, "lm_q1q2_score": 0.5227283135327981}} {"text": "/* specfunc/test_hermite.c\r\n * \r\n * Copyright (C) 2011, 2012, 2013, 2014 Konrad Griessinger\r\n * \r\n * This program is free software; you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation; either version 3 of the License, or (at\r\n * your option) any later version.\r\n * \r\n * This program is distributed in the hope that it will be useful, but\r\n * WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\r\n * General Public License for more details.\r\n * \r\n * You should have received a copy of the GNU General Public License\r\n * along with this program; if not, write to the Free Software\r\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\r\n */\r\n\r\n#include \r\n#include \r\n#include \r\n#include \r\n\r\n#include \"test_sf.h\"\r\n\r\n#define WKB_TOL (1.0e+04 * TEST_SQRT_TOL0)\r\n\r\n/*\r\n * Test the identities:\r\n *\r\n * Sum_{k=0}^n (n choose k) (2 y)^{n - k} H_k(x) = H_n(x + y)\r\n *\r\n * and\r\n *\r\n * Sum_{k=0}^n (n choose k) y^{n-k} He_k(x) = He_n(x + y)\r\n *\r\n * see: http://mathworld.wolfram.com/HermitePolynomial.html (Eq. 55)\r\n */\r\nvoid\r\ntest_hermite_id1(const int n, const double x, const double y)\r\n{\r\n double *a = malloc((n + 1) * sizeof(double));\r\n double *b = malloc((n + 1) * sizeof(double));\r\n double lhs, rhs;\r\n int k;\r\n\r\n a[0] = gsl_pow_int(2.0 * y, n);\r\n b[0] = gsl_pow_int(y, n);\r\n for (k = 1; k <= n; ++k)\r\n {\r\n double fac = (n - k + 1.0) / (k * y);\r\n a[k] = 0.5 * fac * a[k - 1];\r\n b[k] = fac * b[k - 1];\r\n }\r\n\r\n lhs = gsl_sf_hermite_phys_series(n, x, a);\r\n rhs = gsl_sf_hermite_phys(n, x + y);\r\n gsl_test_rel(lhs, rhs, TEST_TOL4, \"identity1 phys n=%d x=%g y=%g\", n, x, y);\r\n\r\n lhs = gsl_sf_hermite_prob_series(n, x, b);\r\n rhs = gsl_sf_hermite_prob(n, x + y);\r\n gsl_test_rel(lhs, rhs, TEST_TOL3, \"identity1 prob n=%d x=%g y=%g\", n, x, y);\r\n\r\n free(a);\r\n free(b);\r\n}\r\n\r\nint\r\ntest_hermite(void)\r\n{\r\n gsl_sf_result r;\r\n \r\n int s = 0;\r\n int m, n, sa;\r\n double res[256];\r\n double x;\r\n const double aizero1 = -2.3381074104597670384891972524467; /* first zero of the Airy function Ai */\r\n\r\n /* test some known identities */\r\n test_hermite_id1(10, 0.75, 0.33);\r\n test_hermite_id1(8, -0.75, 1.20);\r\n test_hermite_id1(7, 2.88, -3.2);\r\n\r\n x = 0.75;\r\n\r\n TEST_SF(s, gsl_sf_hermite_prob_e, (0, 0.75, &r), 1., TEST_TOL0, GSL_SUCCESS);\r\n\r\n TEST_SF(s, gsl_sf_hermite_prob_e, (1, 0.75, &r), x, TEST_TOL0, GSL_SUCCESS);\r\n\r\n n = 25;\r\n TEST_SF(s, gsl_sf_hermite_prob_e, (n, 0., &r), 0., TEST_TOL0, GSL_SUCCESS);\r\n n = 28;\r\n TEST_SF(s, gsl_sf_hermite_prob_e, (n, 0., &r), 213458046676875, TEST_TOL0, GSL_SUCCESS);\r\n n = 25;\r\n TEST_SF(s, gsl_sf_hermite_prob_e, (n, 0.75, &r), -1.08128685847680748265939328423e12, TEST_TOL0, GSL_SUCCESS);\r\n n = 28;\r\n TEST_SF(s, gsl_sf_hermite_prob_e, (n, 0.75, &r), -1.60620252094658918105511125135e14, TEST_TOL0, GSL_SUCCESS);\r\n\r\n#if 0\r\n n = 10025;\r\n x = ((sqrt(2*n+1.)+aizero1/pow(8.*n,1/6.))/2)*M_SQRT2;\r\n TEST_SF(s, gsl_sf_hermite_prob_e, (n, x, &r), -3.3090527852387782540121569578e18961, TEST_TOL0, GSL_SUCCESS);\r\n\r\n n = 10028;\r\n x = ((sqrt(2*n+1.)+aizero1/pow(8.*n,1/6.))/2)*M_SQRT2;\r\n TEST_SF(s, gsl_sf_hermite_prob_e, (n, x, &r), -7.515478445930242044360704363e18967, TEST_TOL0, GSL_SUCCESS);\r\n\r\n n = 10025;\r\n x = (sqrt(2*n+1.)-(aizero1/pow(8.*n,1/6.))/2)*M_SQRT2;\r\n TEST_SF(s, gsl_sf_hermite_prob_e, (n, x, &r), 4.1369269649092456235914193753e22243, TEST_TOL0, GSL_SUCCESS);\r\n\r\n n = 10028;\r\n x = (sqrt(2*n+1.)-(aizero1/pow(8.*n,1/6.))/2)*M_SQRT2;\r\n TEST_SF(s, gsl_sf_hermite_prob_e, (n, x, &r), 8.363694992558646923734666303e22250, TEST_TOL0, GSL_SUCCESS);\r\n\r\n n = 10025;\r\n x = (sqrt(2*n+1.)-2*(aizero1/pow(8.*n,1/6.)))*M_SQRT2;\r\n TEST_SF(s, gsl_sf_hermite_prob_e, (n, x, &r), 7.398863979737363164340057757e22273, TEST_TOL0, GSL_SUCCESS);\r\n\r\n n = 10028;\r\n x = (sqrt(2*n+1.)-2*(aizero1/pow(8.*n,1/6.)))*M_SQRT2;\r\n TEST_SF(s, gsl_sf_hermite_prob_e, (n, x, &r), 1.507131397474022356488976968e22281, TEST_TOL0, GSL_SUCCESS);\r\n#endif\r\n\r\n x = 0.75;\r\n\r\n n = 128;\r\n m = 225;\r\n TEST_SF(s, gsl_sf_hermite_prob_der_e, (m, n, x, &r), 0., TEST_TOL0, GSL_SUCCESS);\r\n\r\n n = 128;\r\n m = 5;\r\n TEST_SF(s, gsl_sf_hermite_prob_der_e, (m, n, x, &r), -3.0288278964712702882066404e112, TEST_TOL1, GSL_SUCCESS);\r\n\r\n sa = 0;\r\n gsl_sf_hermite_prob_array(0, x, res);\r\n TEST_SF_VAL(sa, res[0], +0.0, 1.0, TEST_TOL0);\r\n gsl_test(sa, \"gsl_sf_hermite_prob_array(0, 0.75)\");\r\n s += sa;\r\n\r\n sa = 0;\r\n gsl_sf_hermite_prob_array(1, x, res);\r\n TEST_SF_VAL(sa, res[0], +0.0, 1.0, TEST_TOL0);\r\n TEST_SF_VAL(sa, res[1], +0.0, x, TEST_TOL0);\r\n gsl_test(sa, \"gsl_sf_hermite_prob_array(1, 0.75)\");\r\n s += sa;\r\n\r\n sa = 0;\r\n gsl_sf_hermite_prob_array(100, x, res);\r\n TEST_SF_VAL(sa, res[0], +0.0, 1.0, TEST_TOL0);\r\n TEST_SF_VAL(sa, res[10], +0.0, 823.810509681701660156250, TEST_TOL0);\r\n TEST_SF_VAL(sa, res[100], +0.0, 1.03749254986255755872498e78, TEST_TOL1);\r\n gsl_test(sa, \"gsl_sf_hermite_prob_array(100, 0.75)\");\r\n s += sa;\r\n\r\n sa = 0;\r\n gsl_sf_hermite_prob_array_der(0, 100, x, res);\r\n TEST_SF_VAL(sa, res[0], +0.0, 1.0, TEST_TOL0);\r\n TEST_SF_VAL(sa, res[10], +0.0, 823.810509681701660156250, TEST_TOL0);\r\n TEST_SF_VAL(sa, res[100], +0.0, 1.03749254986255755872498e78, TEST_TOL1);\r\n gsl_test(sa, \"gsl_sf_hermite_prob_array_der(0, 100, 0.75)\");\r\n s += sa;\r\n\r\n sa = 0;\r\n gsl_sf_hermite_prob_array_der(1000, 100, x, res);\r\n TEST_SF_VAL(sa, res[0], +0.0, 0.0, TEST_TOL0);\r\n TEST_SF_VAL(sa, res[10], +0.0, 0.0, TEST_TOL0);\r\n TEST_SF_VAL(sa, res[100], +0.0, 0.0, TEST_TOL0);\r\n gsl_test(sa, \"gsl_sf_hermite_prob_array_der(1000, 100, 0.75)\");\r\n s += sa;\r\n\r\n sa = 0;\r\n gsl_sf_hermite_prob_array_der(23, 100, x, res);\r\n TEST_SF_VAL(sa, res[10], +0.0, 0.0, TEST_TOL0);\r\n TEST_SF_VAL(sa, res[37], +0.0, 2.3592417210568968566591219172e37, TEST_TOL0);\r\n TEST_SF_VAL(sa, res[100], +0.0, 2.6503570965896336273549197e100, TEST_TOL0);\r\n gsl_test(sa, \"gsl_sf_hermite_prob_array(23, 37, 0.75)\");\r\n s += sa;\r\n\r\n sa = 0;\r\n gsl_sf_hermite_prob_der_array(100, 50, x, res);\r\n TEST_SF_VAL(sa, res[0], +0.0, -3.88338863813139372375411561e31, TEST_TOL0);\r\n TEST_SF_VAL(sa, res[10], +0.0, 7.9614368698398116765703194e38, TEST_TOL0);\r\n TEST_SF_VAL(sa, res[100], +0.0, 0.0, TEST_TOL0);\r\n gsl_test(sa, \"gsl_sf_hermite_prob_der_array(100, 50, 0.75)\");\r\n s += sa;\r\n\r\n n = 128;\r\n res[0] = 1.;\r\n for(m=1; m<=n; m++){\r\n res[m] = res[m-1]/2.;\r\n }\r\n TEST_SF(s, gsl_sf_hermite_prob_series_e, (n, x, res, &r), -4.0451066556993485405907339548e68, TEST_TOL0, GSL_SUCCESS);\r\n\r\n /* phys */\r\n\r\n x = 0.75;\r\n\r\n TEST_SF(s, gsl_sf_hermite_phys_e, (0, 0.75, &r), 1., TEST_TOL0, GSL_SUCCESS);\r\n\r\n TEST_SF(s, gsl_sf_hermite_phys_e, (1, 0.75, &r), 2.*x, TEST_TOL0, GSL_SUCCESS);\r\n\r\n n = 25;\r\n TEST_SF(s, gsl_sf_hermite_phys_e, (n, 0., &r), 0., TEST_TOL0, GSL_SUCCESS);\r\n n = 28;\r\n TEST_SF(s, gsl_sf_hermite_phys_e, (n, 0., &r), 3497296636753920000, TEST_TOL0, GSL_SUCCESS);\r\n n = 25;\r\n TEST_SF(s, gsl_sf_hermite_phys_e, (n, 0.75, &r), -9.7029819451106077507781088352e15, TEST_TOL0, GSL_SUCCESS);\r\n n = 28;\r\n TEST_SF(s, gsl_sf_hermite_phys_e, (n, 0.75, &r), 3.7538457078067672096408339776e18, TEST_TOL0, GSL_SUCCESS);\r\n\r\n#if 0\r\n n = 10025;\r\n x = ((sqrt(2*n+1.)+aizero1/pow(8.*n,1/6.))/2);\r\n TEST_SF(s, gsl_sf_hermite_phys_e, (n, x, &r), -2.7074282783315424535693575770e20470, TEST_TOL0, GSL_SUCCESS);\r\n\r\n n = 10028;\r\n x = ((sqrt(2*n+1.)+aizero1/pow(8.*n,1/6.))/2);\r\n TEST_SF(s, gsl_sf_hermite_phys_e, (n, x, &r), -1.7392214893577690864150561850e20477, TEST_TOL0, GSL_SUCCESS);\r\n\r\n n = 10025;\r\n x = (sqrt(2*n+1.)-(aizero1/pow(8.*n,1/6.))/2);\r\n TEST_SF(s, gsl_sf_hermite_phys_e, (n, x, &r), 3.3847852473526979744366379542e23752, TEST_TOL0, GSL_SUCCESS);\r\n\r\n n = 10028;\r\n x = (sqrt(2*n+1.)-(aizero1/pow(8.*n,1/6.))/2);\r\n TEST_SF(s, gsl_sf_hermite_phys_e, (n, x, &r), 1.9355145738418079256435712027e23760, TEST_TOL0, GSL_SUCCESS);\r\n\r\n n = 10025;\r\n x = (sqrt(2*n+1.)-2*(aizero1/pow(8.*n,1/6.)));\r\n TEST_SF(s, gsl_sf_hermite_phys_e, (n, x, &r), 6.053663953512337293393128307e23782, TEST_TOL0, GSL_SUCCESS);\r\n\r\n n = 10028;\r\n x = (sqrt(2*n+1.)-2*(aizero1/pow(8.*n,1/6.)));\r\n TEST_SF(s, gsl_sf_hermite_phys_e, (n, x, &r), 3.487782358276961096026268141e23790, TEST_TOL0, GSL_SUCCESS);\r\n#endif\r\n\r\n x = 0.75;\r\n\r\n n = 128;\r\n m = 225;\r\n TEST_SF(s, gsl_sf_hermite_phys_der_e, (m, n, x, &r), 0., TEST_TOL0, GSL_SUCCESS);\r\n\r\n n = 128;\r\n m = 5;\r\n TEST_SF(s, gsl_sf_hermite_phys_der_e, (m, n, x, &r), 2.89461215568095657569833e132, TEST_TOL0, GSL_SUCCESS);\r\n\r\n sa = 0;\r\n gsl_sf_hermite_phys_array(0, x, res);\r\n TEST_SF_VAL(sa, res[0], +0.0, 1.0, TEST_TOL0);\r\n gsl_test(sa, \"gsl_sf_hermite_phys_array(0, 0.75)\");\r\n s += sa;\r\n\r\n sa = 0;\r\n gsl_sf_hermite_phys_array(1, x, res);\r\n TEST_SF_VAL(sa, res[0], +0.0, 1.0, TEST_TOL0);\r\n TEST_SF_VAL(sa, res[1], +0.0, 2.*x, TEST_TOL0);\r\n gsl_test(sa, \"gsl_sf_hermite_phys_array(1, 0.75)\");\r\n s += sa;\r\n\r\n sa = 0;\r\n gsl_sf_hermite_phys_array(100, x, res);\r\n TEST_SF_VAL(sa, res[0], +0.0, 1.0, TEST_TOL0);\r\n TEST_SF_VAL(sa, res[10], +0.0, 38740.4384765625, TEST_TOL0);\r\n TEST_SF_VAL(sa, res[100], +0.0, -1.4611185395125104593177790757e93, TEST_TOL0);\r\n gsl_test(sa, \"gsl_sf_hermite_phys_array(100, 0.75)\");\r\n s += sa;\r\n\r\n sa = 0;\r\n gsl_sf_hermite_phys_array_der(0, 100, x, res);\r\n TEST_SF_VAL(sa, res[0], +0.0, 1.0, TEST_TOL0);\r\n TEST_SF_VAL(sa, res[10], +0.0, 38740.4384765625, TEST_TOL0);\r\n TEST_SF_VAL(sa, res[100], +0.0, -1.4611185395125104593177790757e93, TEST_TOL0);\r\n gsl_test(sa, \"gsl_sf_hermite_phys_array_der(0, 100, 0.75)\");\r\n s += sa;\r\n\r\n sa = 0;\r\n gsl_sf_hermite_phys_array_der(1000, 100, x, res);\r\n TEST_SF_VAL(sa, res[0], +0.0, 0.0, TEST_TOL0);\r\n TEST_SF_VAL(sa, res[10], +0.0, 0.0, TEST_TOL0);\r\n TEST_SF_VAL(sa, res[100], +0.0, 0.0, TEST_TOL0);\r\n gsl_test(sa, \"gsl_sf_hermite_phys_array_der(1000, 100, 0.75)\");\r\n s += sa;\r\n\r\n sa = 0;\r\n gsl_sf_hermite_phys_array_der(23, 100, x, res);\r\n TEST_SF_VAL(sa, res[10], +0.0, 0.0, TEST_TOL0);\r\n TEST_SF_VAL(sa, res[37], +0.0, 1.930387357696033719818118732e46, TEST_TOL0);\r\n TEST_SF_VAL(sa, res[100], +0.0, 2.957966000491202678467161e118, TEST_TOL0);\r\n gsl_test(sa, \"gsl_sf_hermite_phys_array(23, 37, 0.75)\");\r\n s += sa;\r\n\r\n sa = 0;\r\n gsl_sf_hermite_phys_der_array(100, 50, x, res);\r\n TEST_SF_VAL(sa, res[0], +0.0, -8.2663221830586310072686183e38, TEST_TOL0);\r\n TEST_SF_VAL(sa, res[10], +0.0, 1.52281030265187793605875604e49, TEST_TOL0);\r\n TEST_SF_VAL(sa, res[100], +0.0, 0.0, TEST_TOL0);\r\n gsl_test(sa, \"gsl_sf_hermite_phys_der_array(100, 50, 0.75)\");\r\n s += sa;\r\n\r\n n = 128;\r\n /* arbitrary weights */\r\n res[0] = 1.;\r\n for(m=1; m<=n; m++){\r\n res[m] = res[m-1]/2.;\r\n }\r\n TEST_SF(s, gsl_sf_hermite_phys_series_e, (n, x, res, &r), 1.07772223811696567390619566842e88, TEST_TOL0, GSL_SUCCESS);\r\n\r\n x = 0.75;\r\n n = 28;\r\n TEST_SF(s, gsl_sf_hermite_func_e, (n, 0, &r), 0.290371943657199641200016132937, TEST_TOL0, GSL_SUCCESS);\r\n TEST_SF(s, gsl_sf_hermite_func_e, (n, x, &r), 0.23526280808621240649319140441, TEST_TOL0, GSL_SUCCESS);\r\n n = 100028;\r\n TEST_SF(s, gsl_sf_hermite_func_e, (n, x, &r), -0.02903467369856961147236598086, TEST_TOL4, GSL_SUCCESS);\r\n\r\n n = 10025;\r\n x = ((sqrt(2*n+1.)+aizero1/pow(8.*n,1/6.))/2.5);\r\n TEST_SF(s, gsl_sf_hermite_func_e, (n, x, &r), -0.05301278920004176459797680403, TEST_TOL4, GSL_SUCCESS);\r\n\r\n n = 10028;\r\n x = ((sqrt(2*n+1.)+aizero1/pow(8.*n,1/6.))/2.5);\r\n TEST_SF(s, gsl_sf_hermite_func_e, (n, x, &r), 0.06992968509693993526829596970, TEST_TOL3, GSL_SUCCESS);\r\n\r\n n = 10025;\r\n x = (sqrt(2*n+1.)-(aizero1/pow(8.*n,1/6.))/2.5);\r\n TEST_SF(s, gsl_sf_hermite_func_e, (n, x, &r), 0.08049000991742150521366671021, TEST_TOL4, GSL_SUCCESS);\r\n\r\n n = 10028;\r\n x = (sqrt(2*n+1.)-(aizero1/pow(8.*n,1/6.))/2.5);\r\n TEST_SF(s, gsl_sf_hermite_func_e, (n, x, &r), 0.08048800667512084252723933250, TEST_TOL4, GSL_SUCCESS);\r\n\r\n n = 10025;\r\n x = (sqrt(2*n+1.)-2.5*(aizero1/pow(8.*n,1/6.)));\r\n TEST_SF(s, gsl_sf_hermite_func_e, (n, x, &r), 7.97206830806663013555068100e-6, TEST_TOL4, GSL_SUCCESS);\r\n\r\n n = 10028;\r\n x = (sqrt(2*n+1.)-2.5*(aizero1/pow(8.*n,1/6.)));\r\n TEST_SF(s, gsl_sf_hermite_func_e, (n, x, &r), 7.97188517397786729928465829e-6, TEST_TOL4, GSL_SUCCESS);\r\n\r\n x = 0.75;\r\n\r\n sa = 0;\r\n gsl_sf_hermite_func_array(100, x, res);\r\n TEST_SF_VAL(sa, res[0], +0.0, 0.566979307027693616978839335983, TEST_TOL0);\r\n TEST_SF_VAL(sa, res[10], +0.0, 0.360329854170806945032958735574, TEST_TOL0);\r\n TEST_SF_VAL(sa, res[100], +0.0, -0.07616422890563462489003733382, TEST_TOL1);\r\n gsl_test(sa, \"gsl_sf_hermite_func_array(100, 0.75)\");\r\n s += sa;\r\n\r\n n = 128;\r\n /* arbitrary weights */\r\n res[0] = 1.;\r\n for(m=1; m<=n; m++){\r\n res[m] = res[m-1]/2.;\r\n }\r\n TEST_SF(s, gsl_sf_hermite_func_series_e, (n, x, res, &r), 0.81717103529960997134154552556, TEST_TOL0, GSL_SUCCESS);\r\n\r\n m = 5;\r\n n = 28;\r\n TEST_SF(s, gsl_sf_hermite_func_der_e, (0, n, x, &r), 0.235262808086212406493191404, TEST_TOL0, GSL_SUCCESS);\r\n TEST_SF(s, gsl_sf_hermite_func_der_e, (m, n, x, &r), 4035.32788513029308540826835, TEST_TOL1, GSL_SUCCESS);\r\n\r\n {\r\n /* positive zeros of the probabilists' Hermite polynomial of order 17 */\r\n double He17z[8] = { 0.751842600703896170737870774614, 1.50988330779674075905491513417, 2.28101944025298889535537879396,\r\n 3.07379717532819355851658337833, 3.90006571719800990903311840097, 4.77853158962998382710540812497,\r\n 5.74446007865940618125547815768,6.88912243989533223256205432938 };\r\n\r\n n = 17;\r\n for (m=1; m<=n/2; m++) {\r\n TEST_SF(s, gsl_sf_hermite_prob_zero_e, (n, m, &r), He17z[m-1], TEST_TOL0, GSL_SUCCESS);\r\n }\r\n }\r\n\r\n {\r\n /* positive zeros of the probabilists' Hermite polynomial of order 18 */\r\n double He18z[9] = { 0.365245755507697595916901619097, 1.09839551809150122773848360538, 1.83977992150864548966395498992,\r\n 2.59583368891124032910545091458, 3.37473653577809099529779309480, 4.18802023162940370448450911428,\r\n 5.05407268544273984538327527397, 6.00774591135959752029303858752, 7.13946484914647887560975631213 };\r\n\r\n n = 18;\r\n for (m=1; m<=n/2; m++) {\r\n TEST_SF(s, gsl_sf_hermite_prob_zero_e, (n, m, &r), He18z[m-1], TEST_TOL0, GSL_SUCCESS);\r\n }\r\n }\r\n\r\n {\r\n /* positive zeros of the probabilists' Hermite polynomial of order 23 */\r\n double He23z[11] = { 0.648471153534495816722576841197, 1.29987646830397886997876116860, 1.95732755293342410739100839243,\r\n 2.62432363405918177067330340783, 3.30504002175296456723204112903, 4.00477532173330406712238633738,\r\n 4.73072419745147329426707133987, 5.49347398647179412855289367747, 6.31034985444839982842886078177,\r\n 7.21465943505186138595859194492, 8.29338602741735258945596770157 };\r\n\r\n n = 23;\r\n for (m=1; m<=n/2; m++) {\r\n TEST_SF(s, gsl_sf_hermite_prob_zero_e, (n, m, &r), He23z[m-1], TEST_TOL0, GSL_SUCCESS);\r\n }\r\n }\r\n\r\n {\r\n /* positive zeros of the probabilists' Hermite polynomial of order 24 */\r\n double He24z[12] = { 0.317370096629452319318170455994, 0.953421922932109084904629632351, 1.59348042981642010695074168129,\r\n 2.24046785169175236246653790858, 2.89772864322331368932008199475, 3.56930676407356024709649151613,\r\n 4.26038360501990548884317727406, 4.97804137463912033462166468006, 5.73274717525120114834341822330,\r\n 6.54167500509863444148277523364, 7.43789066602166310850331715501, 8.50780351919525720508386233432 };\r\n\r\n n = 24;\r\n for (m=1; m<=n/2; m++) {\r\n TEST_SF(s, gsl_sf_hermite_prob_zero_e, (n, m, &r), He24z[m-1], TEST_TOL0, GSL_SUCCESS);\r\n }\r\n }\r\n\r\n {\r\n /* positive zeros of the physicists' Hermite polynomial of order 17 */\r\n double H17z[8] = { 0.531633001342654731349086553718, 1.06764872574345055363045773799, 1.61292431422123133311288254454,\r\n 2.17350282666662081927537907149, 2.75776291570388873092640349574, 3.37893209114149408338327069289,\r\n 4.06194667587547430689245559698, 4.87134519367440308834927655662 };\r\n\r\n n = 17;\r\n for (m=1; m<=n/2; m++) {\r\n TEST_SF(s, gsl_sf_hermite_phys_zero_e, (n, m, &r), H17z[m-1], TEST_TOL0, GSL_SUCCESS);\r\n }\r\n }\r\n\r\n {\r\n /* positive zeros of the physicists' Hermite polynomial of order 18 */\r\n double H18z[9] = { 0.258267750519096759258116098711, 0.776682919267411661316659462284, 1.30092085838961736566626555439,\r\n 1.83553160426162889225383944409, 2.38629908916668600026459301424, 2.96137750553160684477863254906,\r\n 3.57376906848626607950067599377, 4.24811787356812646302342016090, 5.04836400887446676837203757885 };\r\n\r\n n = 18;\r\n for (m=1; m<=n/2; m++) {\r\n TEST_SF(s, gsl_sf_hermite_phys_zero_e, (n, m, &r), H18z[m-1], TEST_TOL0, GSL_SUCCESS);\r\n }\r\n }\r\n\r\n {\r\n /* positive zeros of the physicists' Hermite polynomial of order 23 */\r\n double H23z[11] = { 0.458538350068104797757887329284, 0.919151465442563765431719239593, 1.38403958568249523732634717118,\r\n 1.85567703767137106251504753718, 2.33701621147445578644623502174, 2.83180378712615690144806140734,\r\n 3.34512715994122457247439814585, 3.88447270810610186607248760288, 4.46209117374000667673186157071,\r\n 5.10153461047667712968749766165, 5.86430949898457256538748413474 };\r\n\r\n n = 23;\r\n for (m=1; m<=n/2; m++) {\r\n TEST_SF(s, gsl_sf_hermite_phys_zero_e, (n, m, &r), H23z[m-1], TEST_TOL0, GSL_SUCCESS);\r\n }\r\n }\r\n\r\n {\r\n /* positive zeros of the physicists' Hermite polynomial of order 24 */\r\n double H24z[12] = { 0.224414547472515585151136715527, 0.674171107037212236000245923730, 1.12676081761124507213306126773,\r\n 1.58425001096169414850563336202, 2.04900357366169891178708399532, 2.52388101701142697419907602333,\r\n 3.01254613756556482565453858421, 3.52000681303452471128987227609, 4.05366440244814950394766297923,\r\n 4.62566275642378726504864923776, 5.25938292766804436743072304398, 6.01592556142573971734857350899 };\r\n\r\n n = 24;\r\n for (m=1; m<=n/2; m++) {\r\n TEST_SF(s, gsl_sf_hermite_phys_zero_e, (n, m, &r), H24z[m-1], TEST_TOL0, GSL_SUCCESS);\r\n }\r\n }\r\n\r\n n = 2121;\r\n x = -1.*n;\r\n res[0] = (double) n;\r\n sa = 0;\r\n for (m=1; m<=n/2; m++) {\r\n gsl_sf_hermite_prob_zero_e(n, m, &r);\r\n if (x>=r.val) {\r\n sa += TEST_SF_INCONS;\r\n printf(\"sanity check failed! (gsl_sf_hermite_prob_zero)\\n\");\r\n }\r\n res[0] = GSL_MIN(res[0],fabs(x-r.val));\r\n x = r.val;\r\n }\r\n gsl_test(sa, \"gsl_sf_hermite_prob_zero(n, m, r)\");\r\n\r\n n = 2121;\r\n x = -1.*n;\r\n res[0] = (double) n;\r\n sa = 0;\r\n for (m=1; m<=n/2; m++) {\r\n gsl_sf_hermite_phys_zero_e(n, m, &r);\r\n if (x>=r.val) {\r\n sa += TEST_SF_INCONS;\r\n printf(\"sanity check failed! (gsl_sf_hermite_phys_zero)\\n\");\r\n }\r\n res[0] = GSL_MIN(res[0],fabs(x-r.val));\r\n x = r.val;\r\n }\r\n gsl_test(sa, \"gsl_sf_hermite_phys_zero(n, m, r)\");\r\n\r\n return s;\r\n}\r\n", "meta": {"hexsha": "fc35a42d6812140e49afacae09fedaa4f5bf0f3b", "size": 19481, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.4/specfunc/test_hermite.c", "max_stars_repo_name": "peterahrens/FillEstimationIPDPS2017", "max_stars_repo_head_hexsha": "857b6ee8866a2950aa5721d575d2d7d0797c4302", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "gsl-2.4/specfunc/test_hermite.c", "max_issues_repo_name": "peterahrens/FillEstimationIPDPS2017", "max_issues_repo_head_hexsha": "857b6ee8866a2950aa5721d575d2d7d0797c4302", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "gsl-2.4/specfunc/test_hermite.c", "max_forks_repo_name": "peterahrens/FillEstimationIPDPS2017", "max_forks_repo_head_hexsha": "857b6ee8866a2950aa5721d575d2d7d0797c4302", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.2762096774, "max_line_length": 126, "alphanum_fraction": 0.6430368051, "num_tokens": 7920, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.785308580887758, "lm_q2_score": 0.665410558746814, "lm_q1q2_score": 0.5225526215971906}} {"text": "/*\n * applyForceToolFrame.h\n *\n * Created on: Sep 11, 2015\n * Author: mas\n */\n#ifndef APPLY_FORCE_TOOLFRAME_H_\n#define APPLY_FORCE_TOOLFRAME_H_\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include // For std::atexit()\n#include // For btsleep()\n#include // For barrett::math::saturate()\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#define BARRETT_SMF_VALIDATE_ARGS\n#include \n\nusing namespace barrett;\nusing namespace systems;\nusing systems::connect;\nBARRETT_UNITS_FIXED_SIZE_TYPEDEFS;\n\ntemplate\nclass applyForceToolFrame : public systems::System\n{\nBARRETT_UNITS_TEMPLATE_TYPEDEFS(DOF);\n\n// IO (inputs)\npublic:\nInput CpInput; // cart pos. input\nInput OrnInput; // orientation input (quaternion)\nInput FtInput; // cart force input (in tool frame)\nInput TtInput; // cart torque input (in tool frame)\n\n// IO (outputs)\npublic:\nOutput CFOutput; // output Cartesian forces (in base frame)\nOutput CTOutput; // output Cartesian torque (in base frame)\n\nprotected:\ntypename Output::Value* cfOutputValue;\ntypename Output::Value* ctOutputValue;\n\npublic:\ncf_type computedF; // can be used to display later in the program\nct_type computedT; // can be used to display later in the program\n\npublic:\napplyForceToolFrame(\n const std::string& sysName = \"applyForceToolFrame\") :\n System(sysName), CpInput(this), OrnInput(this), FtInput(this) , TtInput(this) ,\n CFOutput(this, &cfOutputValue), CTOutput(this, &ctOutputValue)\n{\n}\nvirtual ~applyForceToolFrame()\n{\nthis->mandatoryCleanUp();\n}\nprotected:\n cf_type cf;\n ct_type ct;\n\n cf_type ForceTool;\n ct_type TorqueTool;\n cp_type Xcurr;\n Eigen::Quaterniond OrnCurr;\n\nvirtual void operate()\n{\n\n Xcurr = CpInput.getValue(); // current Cart. Pose\n OrnCurr = OrnInput.getValue(); // current tool Orientation (quaternion)\n ForceTool = FtInput.getValue(); // desired tool force\n TorqueTool = TtInput.getValue(); // desired tool torque\n\n OrnCurr.x() = - OrnCurr.x(); // wam quaternion imaginary part in negative\n OrnCurr.y() = - OrnCurr.y(); // wam quaternion imaginary part in negative\n OrnCurr.z() = - OrnCurr.z(); // wam quaternion imaginary part in negative\n//****************************************\n// gsl_matrix* RotMat = gsl_matrix_alloc (3,3);\n// gsl_vector* Ft = gsl_vector_alloc(3); // Force in tool frame\n// gsl_vector* Tt = gsl_vector_alloc(3); // Torque in tool frame\n//\n// gsl_vector* Fb = gsl_vector_alloc(3); // Force in base frame\n// gsl_vector* Tb = gsl_vector_alloc(3); // Torque in base frame\n//\n// // RotMat = [ 1 - 2*( OrnCurr.y()*OrnCurr.y() + OrnCurr.z()*OrnCurr.z() ) , 2*(OrnCurr.x()*OrnCurr.y() - OrnCurr.w()*OrnCurr.z()) , 2*(OrnCurr.w()*OrnCurr.y() + OrnCurr.x()*OrnCurr.z()) ;\n// // 2*(OrnCurr.x()*OrnCurr.y() + OrnCurr.w()*OrnCurr.z()) , 1 - 2*(OrnCurr.x()^2 + OrnCurr.z()^2) , 2*(OrnCurr.y()*OrnCurr.z() - OrnCurr.w()*OrnCurr.x()) ;\n// // 2*(OrnCurr.x()*OrnCurr.z() - OrnCurr.w()*OrnCurr.y()) , 2*(OrnCurr.w()*OrnCurr.x() + OrnCurr.y()*OrnCurr.z()) , 1 - 2*(OrnCurr.x()^2 + OrnCurr.y()^2) ] ;\n//\n// gsl_matrix_set(RotMat, 0 , 0 , 1 - 2*(OrnCurr.y()*OrnCurr.y() + OrnCurr.z()*OrnCurr.z()) );\n// gsl_matrix_set(RotMat, 0 , 1 , 2*(OrnCurr.x()*OrnCurr.y() - OrnCurr.w()*OrnCurr.z()) );\n// gsl_matrix_set(RotMat, 0 , 2 , 2*(OrnCurr.w()*OrnCurr.y() + OrnCurr.x()*OrnCurr.z()) );\n//\n// gsl_matrix_set(RotMat, 1 , 0 , 2*(OrnCurr.x()*OrnCurr.y() + OrnCurr.w()*OrnCurr.z()) );\n// gsl_matrix_set(RotMat, 1 , 1 , 1 - 2*(OrnCurr.x()*OrnCurr.x() + OrnCurr.z()*OrnCurr.z()) );\n// gsl_matrix_set(RotMat, 1 , 2 , 2*(OrnCurr.y()*OrnCurr.z() - OrnCurr.w()*OrnCurr.x()) );\n//\n// gsl_matrix_set(RotMat, 2 , 0 , 2*(OrnCurr.x()*OrnCurr.z() - OrnCurr.w()*OrnCurr.y()) );\n// gsl_matrix_set(RotMat, 2 , 1 , 2*(OrnCurr.w()*OrnCurr.x() + OrnCurr.y()*OrnCurr.z()) );\n// gsl_matrix_set(RotMat, 2 , 2 , 1 - 2*(OrnCurr.x()*OrnCurr.x() + OrnCurr.y()*OrnCurr.y()) );\n//\n//\n//\n// for (int i = 0; i<3 ; i++)\n// {\n// gsl_vector_set (Ft , i , ForceTool[i] ) ;\n// gsl_vector_set (Tt , i , TorqueTool[i] ) ;\n// }\n//\n// gsl_blas_dgemv(CblasNoTrans, 1.0, RotMat, Ft, 0.0, Fb); // Fb = 1.0 * RotMat * Ft + 0.0\n// gsl_blas_dgemv(CblasNoTrans, 1.0, RotMat, Tt, 0.0, Tb); // Tb = 1.0 * RotMat * Tt + 0.0\n//\n// for (int i = 0; i<3 ; i++)\n// {\n// cf[i] = gsl_vector_get ( Fb , i );\n// ct[i] = gsl_vector_get ( Tb , i );\n// }\n//****************************************\n\n cf[0] = ( 1 - 2*(OrnCurr.y()*OrnCurr.y() + OrnCurr.z()*OrnCurr.z()) ) * ForceTool[0] +\n ( 2*(OrnCurr.x()*OrnCurr.y() - OrnCurr.w()*OrnCurr.z()) ) * ForceTool[1] +\n ( 2*(OrnCurr.w()*OrnCurr.y() + OrnCurr.x()*OrnCurr.z()) ) * ForceTool[2] ;\n\n cf[1] = ( 2*(OrnCurr.x()*OrnCurr.y() + OrnCurr.w()*OrnCurr.z()) ) * ForceTool[0] +\n ( 1 - 2*(OrnCurr.x()*OrnCurr.x() + OrnCurr.z()*OrnCurr.z()) ) * ForceTool[1] +\n ( 2*(OrnCurr.y()*OrnCurr.z() - OrnCurr.w()*OrnCurr.x()) ) * ForceTool[2] ;\n\n cf[2] = ( 2*(OrnCurr.x()*OrnCurr.z() - OrnCurr.w()*OrnCurr.y()) ) * ForceTool[0] +\n ( 2*(OrnCurr.w()*OrnCurr.x() + OrnCurr.y()*OrnCurr.z()) ) * ForceTool[1] +\n ( 1 - 2*(OrnCurr.x()*OrnCurr.x() + OrnCurr.y()*OrnCurr.y()) ) * ForceTool[2] ;\n\n//****************************************\n ct[0] = ( 1 - 2*(OrnCurr.y()*OrnCurr.y() + OrnCurr.z()*OrnCurr.z()) ) * TorqueTool[0] +\n ( 2*(OrnCurr.x()*OrnCurr.y() - OrnCurr.w()*OrnCurr.z()) ) * TorqueTool[1] +\n ( 2*(OrnCurr.w()*OrnCurr.y() + OrnCurr.x()*OrnCurr.z()) ) * TorqueTool[2] ;\n\n ct[1] = ( 2*(OrnCurr.x()*OrnCurr.y() + OrnCurr.w()*OrnCurr.z()) ) * TorqueTool[0] +\n ( 1 - 2*(OrnCurr.x()*OrnCurr.x() + OrnCurr.z()*OrnCurr.z()) ) * TorqueTool[1] +\n ( 2*(OrnCurr.y()*OrnCurr.z() - OrnCurr.w()*OrnCurr.x()) ) * TorqueTool[2] ;\n\n ct[2] = ( 2*(OrnCurr.x()*OrnCurr.z() - OrnCurr.w()*OrnCurr.y()) ) * TorqueTool[0] +\n ( 2*(OrnCurr.w()*OrnCurr.x() + OrnCurr.y()*OrnCurr.z()) ) * TorqueTool[1] +\n ( 1 - 2*(OrnCurr.x()*OrnCurr.x() + OrnCurr.y()*OrnCurr.y()) ) * TorqueTool[2] ;\n\n//****************************************\n\n computedF = cf;\n computedT = ct;\n\n cfOutputValue->setData(&cf);\n ctOutputValue->setData(&ct);\n}\n\nprivate:\nDISALLOW_COPY_AND_ASSIGN(applyForceToolFrame);\n};\n\n\n\n#endif /*APPLY_FORCE_TOOLFRAME_H_*/\n", "meta": {"hexsha": "c24232a2f194591b1638c0b5490aac298d3ce6bf", "size": 7329, "ext": "h", "lang": "C", "max_stars_repo_path": "include/wam_bringup/tool_force_application.h", "max_stars_repo_name": "ualberta-robotics/wam_bringup", "max_stars_repo_head_hexsha": "bcb5cd806ce7c796cfff27f267974c988c5f77ad", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-03-13T02:12:58.000Z", "max_stars_repo_stars_event_max_datetime": "2021-03-13T02:12:58.000Z", "max_issues_repo_path": "include/wam_bringup/tool_force_application.h", "max_issues_repo_name": "ualberta-robotics/wam_bringup", "max_issues_repo_head_hexsha": "bcb5cd806ce7c796cfff27f267974c988c5f77ad", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "include/wam_bringup/tool_force_application.h", "max_forks_repo_name": "ualberta-robotics/wam_bringup", "max_forks_repo_head_hexsha": "bcb5cd806ce7c796cfff27f267974c988c5f77ad", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 40.4917127072, "max_line_length": 206, "alphanum_fraction": 0.5879383272, "num_tokens": 2442, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8705972684083609, "lm_q2_score": 0.600188359260205, "lm_q1q2_score": 0.5225223461024304}} {"text": "/* stable/stable_fit.c\n * \n * Functions employed by different methods of estimation implemented\n * in Libstable.\n *\n * Copyright (C) 2013. Javier Royuela del Val\n * Federico Simmross Wattenberg\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; version 3 of the License.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; If not, see .\n *\n *\n * Javier Royuela del Val.\n * E.T.S.I. Telecomunicación\n * Universidad de Valladolid\n * Paseo de Belén 15, 47002 Valladolid, Spain.\n * jroyval@lpi.tel.uva.es \n */\n#include \"stable.h\"\n#include \"mcculloch.h\"\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n\nvoid stable_fft(double *data, const unsigned int length, double * y)\n{\n //int i;\n\n memcpy ( (void *)y, (const void *) data, length*sizeof(double));\n\n gsl_fft_real_radix2_transform (y, 1, length);\n\n return;\n}\n\ndouble stable_loglikelihood(StableDist *dist, double *data, const unsigned int length)\n{\n double *pdf=NULL;\n double l=0.0;\n int i;\n\n pdf=(double*)malloc(sizeof(double)*length);\n\n stable_pdf(dist,data,length,pdf,NULL);\n\n for(i=0;i0.0) l+=log(pdf[i]);\n }\n\n free(pdf);\n return l;\n}\n\ndouble stable_loglike_p(stable_like_params *params)\n{\n double *pdf;\n double l=0.0;\n int i;\n\n pdf=(double*)malloc(sizeof(double)*(params->length));\n\n stable_pdf(params->dist,params->data,params->length,pdf,NULL);\n\n for(i=0;ilength;i++)\n {\n if (pdf[i]>0.0) {l+=log(pdf[i]);}\n }\n\n free(pdf);\n\n return l;\n}\n\ndouble stable_minusloglikelihood(const gsl_vector * theta, void * p)\n{\n/* Cost function to minimize, with the estimation of sigma and mu given by McCulloch at each iteration*/\n double alpha=1, beta=0, sigma=1.0, mu=0.0;\n double minusloglike=0;\n stable_like_params * params = (stable_like_params *) p;\n\n alpha = gsl_vector_get(theta,0);\n beta = gsl_vector_get(theta,1);\n\n /* Update sigma and mu with McCulloch. It needs nu_c nu_z*/\n czab(alpha, beta, params->nu_c, params->nu_z, &sigma, &mu);\n\n /* Check that the parameters are valid */\n if(stable_setparams(params->dist, alpha, beta, sigma, mu, 0) < 0)\n {\n return GSL_NAN;\n }\n else minusloglike = -stable_loglike_p(params);\n\n if (isinf(minusloglike) || isnan(minusloglike)) minusloglike=GSL_NAN;\n\n return minusloglike;\n}\n\nint compare (const void * a, const void * b)\n{\n/* qsort compare function */\n return ((*(double *)b < *(double *)a) - (*(double *)a < *(double *)b));\n}\n\ninline void get_original(const gsl_vector *s,double *a,double *b,double *c,double *m)\n{\n *a = M_2_PI*atan(gsl_vector_get(s,0))+1.0;\n *b = M_2_PI*atan(gsl_vector_get(s,1));\n *c = exp(gsl_vector_get(s,2));\n *m = gsl_vector_get(s,3);\n}\ninline void set_expanded(gsl_vector *s,const double a,const double b,const double c,const double m)\n{\n gsl_vector_set(s,0,tan(M_PI_2*(a-1.0)));\n gsl_vector_set(s,1,tan(M_PI_2*b));\n gsl_vector_set(s,2,log(c));\n gsl_vector_set(s,3,m);\n}\n\ndouble stable_minusloglikelihood_whole(const gsl_vector * theta, void * p)\n{\n/* Whole cost function to minimize in a 4D parameter space */\n double alpha=1, beta=0, sigma=1.0, mu=0.0;\n double minusloglike=0;\n stable_like_params * params = (stable_like_params *) p;\n\n get_original(theta,&alpha,&beta,&sigma,&mu);\n\n /* Check that the parameters are valid */\n if(stable_setparams(params->dist, alpha, beta, sigma, mu, 0) < 0)\n {\n perror(\"setparams error\");\n return GSL_NAN;\n }\n else minusloglike = -stable_loglike_p(params);\n\n if (isinf(minusloglike) || isnan(minusloglike)) minusloglike=GSL_NAN;\n\n return minusloglike;\n}\n\nvoid stable_fit_init(StableDist *dist, const double * data, const unsigned int length, double *pnu_c,double *pnu_z)\n{\n /* McCulloch estimation */\n\n double *sorted=NULL;\n double alpha0, beta0, sigma0, mu0;\n\n /* We need to sort the data to get percentiles */\n sorted = (double*)malloc(length*sizeof(double));\n memcpy ( (void *)sorted, (const void *) data, length*sizeof(double));\n qsort ( sorted, length, sizeof(double), compare);\n\n /* Estimate the parameters. */\n stab((const double *) sorted,length,0,&alpha0,&beta0,&sigma0,&mu0);\n\n /* Set parameters in the distribution */\n if(stable_setparams(dist,alpha0,beta0,sigma0,mu0, 0)<0)\n {\n perror(\"INITIAL ESTIMATED PARAMETER ARE NOT VALID\");\n return;\n }\n\n /* Get pnu_c and pnu_z needed for mle2d estimation */\n cztab(sorted, length, pnu_c, pnu_z);\n\n free(sorted);\n return;\n}\n\nint stable_fit_iter(StableDist *dist, const double * data, const unsigned int length,const double nu_c,const double nu_z)\n{\n const gsl_multimin_fminimizer_type *T;\n gsl_multimin_fminimizer *s;\n\n gsl_multimin_function likelihood_func;\n\n gsl_vector *theta, *ss;\n\n unsigned int iter = 0;\n int status=0;\n double size=0;\n\n double a=1,b=0.0,c=1,m=0.0;\n stable_like_params par;\n\n par.dist=dist;\n par.data=(double *)data;\n par.length=length;\n par.nu_c=nu_c;\n par.nu_z=nu_z;\n\n /* Inicio: Debe haberse inicializado dist con alpha y beta de McCulloch */\n theta=gsl_vector_alloc(2);\n gsl_vector_set (theta, 0, dist->alpha);\n gsl_vector_set (theta, 1, dist->beta);\n\n #ifdef DEBUG\n printf(\"%lf, %lf\\n\",gsl_vector_get (theta, 0),gsl_vector_get (theta, 1));\n #endif\n\n /* Saltos iniciales */\n ss = gsl_vector_alloc (2);\n gsl_vector_set_all (ss, 0.01);\n\n /* Funcion a minimizar */\n likelihood_func.n = 2; // Dimension 2 (alpha y beta)\n likelihood_func.f = &stable_minusloglikelihood;\n likelihood_func.params = (void *) (&par); // Parametros de la funcion\n\n /* Creacion del minimizer */\n T = gsl_multimin_fminimizer_nmsimplex2rand;\n\n s = gsl_multimin_fminimizer_alloc (T, 2); /* Dimension 2*/\n\n /* Poner funcion, estimacion inicial, saltos iniciales */\n gsl_multimin_fminimizer_set (s, &likelihood_func, theta, ss);\n\n #ifdef DEBUG\n printf(\"5\\n\");\n #endif\n\n /* Iterar */\n do\n {\n iter++;\n status = gsl_multimin_fminimizer_iterate(s);\n // if (status!=GSL_SUCCESS) {\n // printf(\"Minimizer warning: %s\\n\",gsl_strerror(status));\n // fflush(stdout);\n // }\n\n size = gsl_multimin_fminimizer_size (s);\n status = gsl_multimin_test_size (size, 0.02);\n/*\n if (status == GSL_SUCCESS)\n {\n printf (\" converged to minimum at\\n\");\n }\n\n printf (\"%5d %1.5f %1.5f %1.5f %1.5f f() = %1.8e size = %.5f\\n\",\n (int)iter,\n gsl_vector_get (s->x, 0),\n gsl_vector_get (s->x, 1),\n p->dist->sigma,\n p->dist->mu_1,\n s->fval, size);\n //}\n*/\n } while (status == GSL_CONTINUE && iter < 200);\n\n// if (status!=GSL_SUCCESS)\n// {\n// printf(\"Minimizer warning: %s\\n\",gsl_strerror(status));\n// fflush(stdout);\n// }\n\n /* Se recupera la estimacion alpha y beta */\n gsl_vector_free(theta);\n/*\n theta = gsl_multimin_fminimizer_x (s);\n a = gsl_vector_get (theta, 0);\n b = gsl_vector_get (theta, 1);\n*/\n a = gsl_vector_get (s->x, 0);\n b = gsl_vector_get (s->x, 1);\n\n /* Y se estima sigma y mu para esos alpha y beta */\n czab(a, b, nu_c, nu_z, &c, &m);\n\n //printf(\"%5d %10.3e %10.3e %10.3e %10.3e\\n\",(int)iter,a,b,c,m);\n\n // Se almacena el punto estimado en la distribucion, comprobando que es valido\n if (stable_setparams(dist,a,b,c,m,0)<0)\n {\n perror(\"FINAL ESTIMATED PARAMETER ARE NOT VALID\\n\");\n }\n\n gsl_vector_free(ss);\n gsl_multimin_fminimizer_free (s);\n\n return status;\n}\n\nint stable_fit(StableDist *dist, const double *data, const unsigned int length)\n{\n double nu_c=0.0,nu_z=0.0;\n int status = 0;\n\n stable_fit_init(dist,data,length,&nu_c,&nu_z);\n status=stable_fit_iter(dist,data,length,nu_c,nu_z);\n\n return status;\n}\n\nint stable_fit_iter_whole(StableDist *dist, const double * data, const unsigned int length)\n{\n const gsl_multimin_fminimizer_type *T;\n gsl_multimin_fminimizer *s;\n\n gsl_multimin_function likelihood_func;\n\n gsl_vector *theta, *ss;\n\n unsigned int iter = 0;\n int status=0;\n double size=0;\n\n double a=1,b=0.0,c=1,m=0.0;\n stable_like_params par;\n\n par.dist=dist;\n par.data=(double *)data;\n par.length=length;\n par.nu_c=0;\n par.nu_z=0;\n\n /* Inital params (with McCulloch) */\n theta=gsl_vector_alloc(4);\n set_expanded(theta,dist->alpha,dist->beta,dist->sigma,dist->mu_1);\n\n #ifdef DEBUG\n printf(\"%lf, %lf, %lf, %lf\\n\",gsl_vector_get (theta, 0),gsl_vector_get (theta, 1),gsl_vector_get (theta, 2),gsl_vector_get (theta, 3));\n #endif\n\n /* Initial steps */\n ss = gsl_vector_alloc (4);\n gsl_vector_set_all (ss, 0.01);\n\n /* Cost function to minimize */\n likelihood_func.n = 4; // 4 Dimensions (alpha, beta, sigma, mu_0)\n likelihood_func.f = &stable_minusloglikelihood_whole;\n likelihood_func.params = (void *) (&par); // Cost function arguments\n\n /* Minimizer creation */\n T = gsl_multimin_fminimizer_nmsimplex2rand;\n\n s = gsl_multimin_fminimizer_alloc (T, 4); /* 4 dimensions */\n\n /* Set cost function, initial guess and initial steps */\n gsl_multimin_fminimizer_set (s, &likelihood_func, theta, ss);\n\n\n #ifdef DEBUG\n printf(\"5\\n\");\n #endif\n\n /* Start iterations */\n do\n {\n iter++;\n status = gsl_multimin_fminimizer_iterate(s);\n if (status!=GSL_SUCCESS) {\n perror(\"Minimizer warning:\\n\");\n }\n\n size = gsl_multimin_fminimizer_size (s);\n status = gsl_multimin_test_size (size, 0.002);\n /*\n printf(\" %03d\\t size = %f a_ = %f b_ = %f c_ = %f m_ = %f f_ = %f \\n\",iter,size,gsl_vector_get (s->x, 0),gsl_vector_get (s->x, 1),\n gsl_vector_get (s->x, 2),gsl_vector_get (s->x, 3), gsl_multimin_fminimizer_minimum(s));\n */\n\n } while (status == GSL_CONTINUE && iter < 200);\n\n\n\n if (status!=GSL_SUCCESS)\n {\n perror(\"Minimizer warning\");\n }\n\n /* Get last estimation */\n\n gsl_vector_free(theta);\n theta = gsl_multimin_fminimizer_x (s);\n get_original(theta,&a,&b,&c,&m);\n\n /* Set estimated parameters to the distribution and check if their have valid values*/\n if (stable_setparams(dist,a,b,c,m,0)<0)\n {\n perror(\"FINAL ESTIMATED PARAMETER ARE NOT VALID\\n\");\n }\n\n gsl_vector_free(ss);\n gsl_multimin_fminimizer_free (s);\n\n return status;\n}\n\nint stable_fit_whole(StableDist *dist, const double *data, const unsigned int length)\n{\n// double nu_c=0.0,nu_z=0.0;\n int status=0;\n// stable_fit_init(dist,data,length,&nu_c,&nu_z);\n// printf(\"McCulloch %d sampless: %f %f %f %f\\n\",length,dist->alpha,dist->beta,dist->sigma,dist->mu_1);\n\n status = stable_fit_iter_whole(dist,data,length);\n\n return status;\n}\n\n\n\ndouble * load_rand_data(char * filename, int N)\n{\n FILE * f_data;\n double * data;\n int i;\n\n if ((f_data = fopen(filename,\"rt\")) == NULL)\n {\n perror(\"Error when opening file with random data\");\n }\n\n data=(double*)malloc(N*sizeof(double));\n\n for(i=0;i\n#include \n\nint main() {\n printf(\"hello, world!\\n\");\n printf(\"%f\\n\", gsl_sf_gamma(1.0));\n printf(\"%f\\n\", gsl_sf_gamma(1.5));\n printf(\"%f\\n\", gsl_sf_gamma(2.0));\n printf(\"%f\\n\", gsl_sf_gamma(2.5));\n printf(\"%f\\n\", gsl_sf_gamma(3.0));\n}\n", "meta": {"hexsha": "51a471534bcd034202eac1fcee6475d5420d5649", "size": 291, "ext": "c", "lang": "C", "max_stars_repo_path": "c/test_libgsl/main.c", "max_stars_repo_name": "berquist/eg", "max_stars_repo_head_hexsha": "4c368b12eaaffcf0af8032f10348cf8bc1c3957a", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "c/test_libgsl/main.c", "max_issues_repo_name": "berquist/eg", "max_issues_repo_head_hexsha": "4c368b12eaaffcf0af8032f10348cf8bc1c3957a", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "c/test_libgsl/main.c", "max_forks_repo_name": "berquist/eg", "max_forks_repo_head_hexsha": "4c368b12eaaffcf0af8032f10348cf8bc1c3957a", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 24.25, "max_line_length": 38, "alphanum_fraction": 0.5841924399, "num_tokens": 99, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8479677660619633, "lm_q2_score": 0.6150878555160665, "lm_q1q2_score": 0.5215746747738026}} {"text": "#include \n#include \n#include \n#include \n\n#include \n\n#include \n\n\n#include \"gauss_conv.h\"\n#include \"seis_data.h\"\n\n#include \"calculate_source.h\"\n\n\nvoid calculate_source(seis_data *obs, seis_data *syn, double *syn_src, double *obs_src, int src_no)\n{\n double lambda1, lambda2; /* <---Regularization parameters for Tikhonov regularization */\n\n int npts = obs->num_samples;\n int num_rec = obs->num_rec;\n\n int N = npts; /* fft size */\n int Nfreq = N/2 +1; /* size of freq vector */\n\n int i, j; /* counters for loops */\n\n /*************************************************************************/\n\n /* allocate space for vector of sizes */\n int *nn = malloc(sizeof(*nn) * num_rec);\n\n /* allocate space for syn/obs and Fourier transforms */\n double *sd = fftw_malloc(sizeof(*sd) * N * num_rec);\n fftw_complex *SD = fftw_malloc(sizeof(*SD) * Nfreq * num_rec);\n\n /* allocate space for syn/obs source and Fourier transforms */\n double *k = fftw_malloc(sizeof(*k) * N);\n fftw_complex *K = fftw_malloc(sizeof(*K) * Nfreq);\n\n /* Allocate space for Fourier transform of Green's function (impulse response) */ \n fftw_complex *G = fftw_malloc(sizeof(*G) * Nfreq * num_rec);\n\n /* allocate some temporary working space */\n fftw_complex *temp = fftw_malloc(sizeof(*temp) * 3 * N);\n fftw_complex *num = temp + N;\n fftw_complex *den = temp + 2 * N;\n\n\n /* check memory allocations */\n if (!nn || !sd || !SD || !k || !K || !G || !temp)\n {\n fprintf(stderr,\"Error: calculate_source: memory allocation failure\\n\");\n exit(1);\n }\n\n /*************************************************************************/\n\n /* fill array of sizes - all sizes are the same */\n for (i=0;itraces[src_no*npts*num_rec + i*npts + j];\n }\n for (j=npts;jtraces[src_no*npts*num_rec + i*npts + j];\n }\n for (j=npts;j d_amp_max ? d_mag[i] : d_amp_max;\n }\n\n double wtr_use = wtr * d_amp_max;\n\n fftw_complex den_use;\n for (i=0;i\n\nvoid deconvolution_system(const double *x, double *h, const double *y, const int npts, const double lambda)\n{\n /* NOTE: This is really only practical when npts is fairly small */\n /* */\n /* the convolution problem can be formulated as a matrix multiplication */\n /* X*h = y, where the columns of X contain shifted copies of x */\n /* Therefore, the deconvolution problem is solving this overdetermined */\n /* system for h. To do this, we solve (X'*X + lambda*I)*h = X'*y */\n /* where ' denotes matrix transpose, I is the identity matrix, and */\n /* lambda is a Tikhonov regularization parameter */\n /* x and h should be length npts and y is length (2*npts-1) */\n\n int N = next_power2(2*npts);\n int freq_sz = N/2 + 1;\n int conv_sz = 2*npts -1;\n\n\n double *X = malloc(sizeof(*X) * npts * conv_sz);\n double *xx = malloc(sizeof(*xx) * 3 * npts);\n double *yy = malloc(sizeof(*yy) * conv_sz);\n double *s = malloc(sizeof(*s) * npts); /* s holds the singular values */\n\n\n /* copy data and zero pad */\n int i, j; \n for (i=0;i\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nvoid read_matrix(int** index, int** matrix, double scaling, int N_kw, char* input_fileName)\n{\n FILE *fp = fopen(input_fileName, \"r\");\n fscanf(fp, \"%*[^\\n]\\n\");\n\n for (int ii = 0; ii < N_kw; ii++)\n fscanf(fp, \"%d,\", &((*index)[ii]));\n fscanf(fp, \"%*[^\\n]\\n\");\n\n int tmp;\n for (int ii = 0; ii < N_kw; ii++)\n {\n for (int jj = 0; jj < N_kw; jj++)\n {\n fscanf(fp, \"%d,\", &tmp);\n (*matrix)[ii*N_kw + jj] = (int) (tmp * scaling);\n }\n \n fscanf(fp, \"%*[^\\n]\\n\");\n }\n fclose(fp);\n}\n\n\nvoid pad_matrix(int** matrix_padded, int** matrix, int m, double p, double q, int N_kw, int N_doc)\n{\n // Initialising RNG\n const gsl_rng_type * T;\n gsl_rng * r;\n gsl_rng_env_setup();\n T = gsl_rng_default;\n r = gsl_rng_alloc(T);\n\n // perform padding\n int ii, jj;\n #pragma omp parallel for private(ii, jj)\n for (ii = 0; ii < N_kw; ii++)\n {\n for (jj = 0; jj < N_kw; jj++)\n {\n if (ii == jj)\n (*matrix_padded)[ii*N_kw + jj] = gsl_ran_binomial(r, p, m*(*matrix)[ii*N_kw + jj]) + gsl_ran_binomial(r, q, m*(N_doc - (*matrix)[ii*N_kw + jj]));\n\n\n if (ii > jj)\n {\n int N1 = (*matrix)[ii*N_kw + jj];\n int N2 = (*matrix)[ii*N_kw + ii] + (*matrix)[jj*N_kw + jj] - 2*(*matrix)[ii*N_kw + jj];\n int N3 = N_doc - N1 - N2;\n\n int n1 = gsl_ran_binomial(r, p*p, m*N1);\n int n2 = gsl_ran_binomial(r, p*q, m*N2);\n int n3 = gsl_ran_binomial(r, q*q, m*N3);\n\n (*matrix_padded)[ii*N_kw + jj] = n1 + n2 + n3;\n (*matrix_padded)[jj*N_kw + ii] = n1 + n2 + n3;\n }\n }\n }\n gsl_rng_free(r);\n}\n \n\n\nvoid observe_matrix(gsl_matrix* matrix_obs, int** matrix_padded, int N_kw)\n{\n // perform observed count generation\n for (int ii = 0; ii < N_kw; ii++)\n for (int jj = 0; jj < N_kw; jj++)\n gsl_matrix_set(matrix_obs, ii, jj, (double) ((*matrix_padded)[ii*N_kw + jj]));\n}\n\n\n\n\nvoid solution_initial(int** permutation, gsl_matrix* matrix_obs, int** matrix, int m, double p, double q, int N_kw, int N_obs, int N_doc)\n{\n int* diff = (int*) malloc(sizeof(int) * N_kw);\n int* index = (int*) malloc(sizeof(int) * N_kw);\n int* occupied = (int*) malloc(sizeof(int) * N_kw);\n\n for (int ii = 0; ii < N_kw; ii++)\n occupied[ii] = -1;\n\n\n for (int ii = 0; ii < N_obs; ii++)\n {\n // reset index\n for (int jj = 0; jj < N_kw; jj++)\n index[jj] = jj;\n\n // compute differences\n for (int jj = 0; jj < N_kw; jj++)\n diff[jj] = abs(gsl_matrix_get(matrix_obs, ii, ii) - m * p * (*matrix)[jj*N_kw+jj] - m * q * (N_doc - (*matrix)[jj*N_kw+jj]));\n\n // sorting\n for (int jj = 0; jj < N_kw-1; jj++)\n {\n for (int kk = 0; kk < N_kw-jj-1; kk++)\n {\n if (diff[kk] > diff[kk+1])\n {\n int temp = diff[kk+1];\n diff[kk+1] = diff[kk];\n diff[kk] = temp;\n\n temp = index[kk+1];\n index[kk+1] = index[kk];\n index[kk] = temp;\n }\n }\n }\n\n // use the smallest index available\n int idx = 0;\n while (occupied[index[idx]] > 0)\n idx++;\n\n // update the data structures\n (*permutation)[ii] = index[idx];\n occupied[index[idx]] = 1;\n }\n\n //for (int ii = 200; ii < 250; ii++)\n //{\n // printf(\"%f\\n\", gsl_matrix_get(matrix_obs, ii, ii) - m * p * (*matrix)[(*permutation)[ii]*N_kw+(*permutation)[ii]] - m * q * (N_doc - (*matrix)[(*permutation)[ii]*N_kw+(*permutation)[ii]]));\n //}\n}\n\n\n\n\n\nvoid permutation_generation(int* idx1, int* idx2, int** permutation_tmp, int** permutation, int** permutation_inv, gsl_matrix* matrix_obs, int** matrix, int m, double p, double q, int N_kw, int N_obs, int N_doc)\n{\n double N1_mean, N1_var, N1_lower, N1_upper, N2_mean, N2_var, N2_lower, N2_upper;\n int check = -1;\n int count = 0;\n *idx1 = rand() % N_obs;\n *idx2 = -1;\n int idx_old = (*permutation)[*idx1];\n int idx_new = 0;\n\n do {\n idx_new = rand() % N_kw;\n count++;\n\n if ((*permutation_inv)[idx_new] >= 0)\n {\n *idx2 = (*permutation_inv)[idx_new];\n\n N1_mean = m * p * (*matrix)[idx_new*N_kw + idx_new] + m * q * (N_doc - (*matrix)[idx_new*N_kw + idx_new]);\n N1_var = (*matrix)[idx_new*N_kw + idx_new] / (double) N_doc * (N_doc - (*matrix)[idx_new*N_kw + idx_new]) * 2.0 * m;\n N1_var += m * p * (1-p) * (*matrix)[idx_new*N_kw + idx_new] + m * q * (1-q) * (N_doc - (*matrix)[idx_new*N_kw + idx_new]);\n N1_var = 3*sqrt(N1_var);\n\n N1_lower = N1_mean - N1_var;\n N1_upper = N1_mean + N1_var;\n\n N2_mean = m * p * (*matrix)[idx_old*N_kw + idx_old] + m * q * (N_doc - (*matrix)[idx_old*N_kw + idx_old]);\n N2_var = (*matrix)[idx_old*N_kw + idx_old] / (double) N_doc * (N_doc - (*matrix)[idx_old*N_kw + idx_old]) * 2.0 * m ;\n N2_var += m * p * (1-p) * (*matrix)[idx_old*N_kw + idx_old] + m * q * (1-q)* (N_doc - (*matrix)[idx_old*N_kw + idx_old]);\n N2_var = 3*sqrt(N2_var);\n\n N2_lower = N2_mean - N2_var;\n N2_upper = N2_mean + N2_var;\n\n\n if ((gsl_matrix_get(matrix_obs, *idx1, *idx1) > N1_lower) && (gsl_matrix_get(matrix_obs, *idx1, *idx1) < N1_upper))\n if ((gsl_matrix_get(matrix_obs, *idx2, *idx2) > N2_lower) && (gsl_matrix_get(matrix_obs, *idx2, *idx2) < N2_upper))\n check = 1;\n }\n else\n {\n\t *idx2 = (*permutation_inv)[idx_new];\n\n N1_mean = m * p * (*matrix)[idx_new*N_kw + idx_new] + m * q * (N_doc - (*matrix)[idx_new*N_kw + idx_new]);\n N1_var = (*matrix)[idx_new*N_kw + idx_new] / (double) N_doc * (N_doc - (*matrix)[idx_new*N_kw + idx_new]) * 2.0 * m;\n N1_var += m * p * (1-p) * (*matrix)[idx_new*N_kw + idx_new] + m * q * (1-q) * (N_doc - (*matrix)[idx_new*N_kw + idx_new]);\n N1_var = 3*sqrt(N1_var);\n\n N1_lower = N1_mean - N1_var;\n N1_upper = N1_mean + N1_var;\n\n if ((gsl_matrix_get(matrix_obs, *idx1, *idx1) > N1_lower) && (gsl_matrix_get(matrix_obs, *idx1, *idx1) < N1_upper))\n check = 1;\n\n }\n \n } while ((check < 0) && (count < 200));\n\n if (count == 200)\n *idx2 = *idx1;\n\n if (*idx1 != *idx2)\n {\n (*permutation_tmp)[*idx1] = idx_new;\n if ((*permutation_inv)[idx_new] >= 0)\n {\n *idx2 = (*permutation_inv)[idx_new];\n (*permutation_tmp)[*idx2] = idx_old;\n }\n }\n}", "meta": {"hexsha": "74444982063fa556849db2cebb2493021c085dea", "size": 6996, "ext": "c", "lang": "C", "max_stars_repo_path": "DPAP-SE/util.c", "max_stars_repo_name": "RethinkingSSE/Attacks-on-SSE", "max_stars_repo_head_hexsha": "39602b0912b21afc45e73008e598f4377ba237eb", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "DPAP-SE/util.c", "max_issues_repo_name": "RethinkingSSE/Attacks-on-SSE", "max_issues_repo_head_hexsha": "39602b0912b21afc45e73008e598f4377ba237eb", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "DPAP-SE/util.c", "max_forks_repo_name": "RethinkingSSE/Attacks-on-SSE", "max_forks_repo_head_hexsha": "39602b0912b21afc45e73008e598f4377ba237eb", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.691588785, "max_line_length": 211, "alphanum_fraction": 0.5034305317, "num_tokens": 2210, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.837619947119304, "lm_q2_score": 0.6224593312018546, "lm_q1q2_score": 0.5213843520852147}} {"text": "/*\n * MathUtils.h\n *\n * Author:\n * Oleg Kalashev\n *\n * Copyright (c) 2020 Institute for Nuclear Research, RAS\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n * THE SOFTWARE.\n */\n\n#ifndef MATHUTILS_H_\n#define MATHUTILS_H_\n\n#include \n#include \n#include \n#include \"Utils.h\"\n#include \n\nnamespace Utils {\n\n\ntemplate\nclass FunctionX\n{\npublic:\n\tvirtual X f(X _x) const = 0;\n\tvirtual X Xmin() const {return -std::numeric_limits::max();}\n\tvirtual X Xmax() const {return std::numeric_limits::max();}\n\tinline X operator()(X _x) const {return f(_x);};\n\tvirtual ~FunctionX(){};\n\n\tvirtual FunctionX* Clone() const { NOT_IMPLEMENTED; return 0; }\n\n\tinline operator gsl_function() const\n\t{\n\t\tgsl_function result = {GslProxyFunc, (void*)this};\n\t\treturn result;\n\t}\n\tvoid Print(std::ostream& aOut, int nIntervals, bool aLogScale, double aXmin=-DBL_MAX, double aXmax=DBL_MAX) const\n\t{\n\t\tif(aXminXmax())\n\t\t\taXmax = Xmax();\n\t\tASSERT(aXmin<=aXmax);\n\t\tASSERT(aXmax-DBL_MAX);\n\t\tASSERT(nIntervals>=1);\n\t\tASSERT((!aLogScale) || aXmin>0);\n\t\tdouble step = aLogScale?pow(aXmax/aXmin,1./nIntervals) : (aXmax-aXmin)/nIntervals;\n\t\tdouble x = aXmin;\n\t\tfor(int i=0; i<=nIntervals; i++, (x = aLogScale ? x*step : x+step) )\n\t\t\taOut << x << \"\\t\" << f(x) << \"\\n\";\n\t}\nprivate:\n\tstatic double GslProxyFunc (double x, void * params)\n\t{\n\t\tconst FunctionX* f = (const FunctionX*)params;\n\t\treturn f->f(x);\n\t}\n};\n\ntemplate\nclass Function2X\n{\npublic:\n\tvirtual X f(X x, X y) const = 0;\n\tvirtual X MinArg(int aArgNo) const {return std::numeric_limits::min();}\n\tvirtual X MaxArg(int aArgNo) const {return std::numeric_limits::max();}\n\n\tvirtual inline X operator()(X _x, X _y) const {return f(_x,_y);};\n\tvirtual ~Function2X(){};\n};\n\ntemplate\nclass IFunctionCallHandlerX\n{\npublic:\n\tvirtual void OnCall(const FunctionX& aFunc, X aX, X aY) const = 0;\n};\n\ntemplate\nclass DebugFunctionX : public FunctionX\n{\npublic:\n\tDebugFunctionX(const FunctionX& aOrigFunc, const IFunctionCallHandlerX& aDebugger):fOrigFunc(aOrigFunc),fDebugger(aDebugger){};\n\tvirtual X f(X _x) const\n\t{\n\t\tX y = fOrigFunc.f(_x);\n\t\tfDebugger.OnCall(fOrigFunc, _x, y);\n\t\treturn y;\n\t}\n\tvirtual ~DebugFunctionX(){};\n\tvirtual FunctionX* Clone() const { return new DebugFunctionX(fOrigFunc,fDebugger); }\nprivate:\n\tconst FunctionX&\t\t\t\tfOrigFunc;\n\tconst IFunctionCallHandlerX&\tfDebugger;\n};\n\ntemplate\nclass FunctionCallLoggerX : public IFunctionCallHandlerX\n{\npublic:\n\tFunctionCallLoggerX(std::ostream& aOutput) : fOutput(aOutput){}\n\tvirtual void OnCall(const FunctionX& aFunc, X aX, X aY) const\n\t{\n\t\t((std::ostream&)fOutput) << aX << \"\\t\" << aY << \"\\n\";\n\t}\n\tvirtual ~FunctionCallLoggerX()\n\t{\n\t\tfOutput << std::endl;\n\t}\nprivate:\n\tstd::ostream& fOutput;\n};\n\ntypedef FunctionX Function;\ntypedef Function2X Function2;\n\ntemplate\nclass ParamlessFunctionX : public FunctionX\n{\npublic:\n\tParamlessFunctionX(X (*aFunction)(X)):fFunction(aFunction){}\n\tX f(X _x) const { return fFunction(_x); }\nprivate:\n\tX (*fFunction)(X);\n};\n\ntypedef ParamlessFunctionX ParamlessFunction;\n\n\ttemplate\n\tclass ISampler {\n\tpublic:\n\t\tvirtual X sample(const FunctionX &f, X aTmin, X aTmax, X aRand,\n\t\t\t\t X &aTotRate, X aRelErr, X aAbsErr = 1e300) = 0;\n\t\tvoid UnitTest();\n\t};\n\n/// Mathematical functions\n/// Static methods are thread-safe\n/// Non-static methods are not guaranteed to be thread-safe\n\t///TODO: make implementation using boost odeint and dense output and get rid of nr library\nclass MathUtils {\npublic:\n\tMathUtils();\n\t~MathUtils();\n static inline double RelDifference(double aVal1, double aVal2){\n double meanNorm = 0.5*fabs(aVal1)+fabs(aVal2);\n return meanNorm==0. ? 0.:fabs(aVal1-aVal2)/meanNorm;\n }\n\n\tstatic double SolveEquation(\n\t\t\tdouble (*aEquation) (double, void*),\n\t\t\tdouble x_lo, double x_hi, void* aEquationPars = 0,\n\t\t\tconst double relError=1e-3, const int max_iter=100,\n\t\t\tconst gsl_root_fsolver_type *T = gsl_root_fsolver_bisection);\n\n\tstatic double SolveEquation(\n\t\t\tgsl_function f,\tdouble x_lo, double x_hi,\n\t\t\tconst double relError=1e-3, const int max_iter=100,\n\t\t\tconst gsl_root_fsolver_type *T = gsl_root_fsolver_bisection);\n\n\tdouble Integration_qag (\n\t\t\tgsl_function aFunction,\n\t\t\tdouble aXmin,\n\t\t\tdouble aXmax,\n\t\t\tdouble epsabs,\n\t\t\tdouble epsrel,\n\t\t\tsize_t limit,\n\t\t\tint key=GSL_INTEG_GAUSS15);\n\ttemplate bool SampleLogscaleDistribution(const Function& aDistrib, double aRand, X& aOutputX, X& aOutputIntegral, int nStepsS, X xMin, X xMax, double aRelError);\n\tstatic bool SampleDistribution(const Function& aDistrib, double aRand, double& aOutputX, double& aOutputIntegral, double xMin, double xMax, double aRelError);\n\tstatic bool SampleLogDistribution(const Function& aDistrib, double aRand, double& aOutputX, double& aOutputIntegral, double xMin, double xMax, double aRelError);\n\n\tstatic bool SampleLogDistributionBoost(const Function& aDistrib, double aRand, double& aOutputX, double& aOutputIntegral, double xMin, double xMax, double aRelError);\n\tstatic bool SampleLogDistributionNR(const Function& aDistrib, double aRand, double& aOutputX, double& aOutputIntegral, double xMin, double xMax, double aRelError);\n\n\ttemplate static void RelAccuracy(X& aOutput);\n\tstatic void SetLogger(IFunctionCallHandlerX* aLogger) { fLogger = aLogger; }\n\tstatic int UnitTest();\nprivate:\n\tstatic double GslProxySampleLogscaleDistributionFunc (double x, void * params)\n\t{\n\t\tx=exp(x);\n\t\tconst Function* f = (const Function*)params;\n\t\treturn x*f->f(x);\n\t}\n\tgsl_integration_workspace* gslQAGintegrator;\n\tstatic IFunctionCallHandlerX* fLogger;\n};\n\nclass GslProxyFunction : public Function\n{\npublic:\n\tGslProxyFunction(gsl_function aFunction, double aXmin=-DBL_MAX, double aXmax=DBL_MAX) :\n\t\tfFunction(aFunction),\n\t\tfXmin(aXmin),\n\t\tfXmax(aXmax){};\n\tvirtual double f(double _x) const\n\t{\n\t\treturn fFunction.function(_x,fFunction.params);\n\t}\n\tvirtual double Xmin() const {return fXmin;}\n\tvirtual double Xmax() const {return fXmax;}\n\tFunction* Clone() const\n\t{//There is no way to clone fFunction.params\n\t\tASSERT(0);\n\t\tException::Throw(\"GslProxyFunction doesn't support Clone\");\n\t\treturn 0;\n\t}\nprivate:\n\tgsl_function fFunction;\n\tdouble fXmin;\n\tdouble fXmax;\n};\n\ntemplate\nclass ConstFunctionX : public FunctionX\n{\npublic:\n\tConstFunctionX(X aValue, X aXmin=-std::numeric_limits::max(), X aXmax=std::numeric_limits::max()) :\n\t\tfValue(aValue),\n\t\tfXmin(aXmin),\n\t\tfXmax(aXmax){};\n\tvirtual X f(X _x) const\n\t{\n\t\treturn fValue;\n\t}\n\tvirtual X Xmin() const {return fXmin;}\n\tvirtual X Xmax() const {return fXmax;}\n\tFunctionX* Clone() const\n\t{\n\t\treturn new ConstFunctionX(fValue, fXmin, fXmax);\n\t}\nprivate:\n\tX fValue;\n\tX fXmin;\n\tX fXmax;\n};\n\ntypedef ConstFunctionX ConstFunction;\n\n} /* namespace Utils */\n#endif /* MATHUTILS_H_ */\n", "meta": {"hexsha": "f13823e35d28d82e7f2a60e324dd0bb45af6da6e", "size": 8079, "ext": "h", "lang": "C", "max_stars_repo_path": "src/lib/MathUtils.h", "max_stars_repo_name": "alexkorochkin/mcray", "max_stars_repo_head_hexsha": "2cfa58d2cd6f872612f6396d65781ad83211c06c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 7.0, "max_stars_repo_stars_event_min_datetime": "2020-12-16T08:23:31.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-15T22:56:26.000Z", "max_issues_repo_path": "src/lib/MathUtils.h", "max_issues_repo_name": "alexkorochkin/mcray", "max_issues_repo_head_hexsha": "2cfa58d2cd6f872612f6396d65781ad83211c06c", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/lib/MathUtils.h", "max_forks_repo_name": "alexkorochkin/mcray", "max_forks_repo_head_hexsha": "2cfa58d2cd6f872612f6396d65781ad83211c06c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2020-12-16T08:23:34.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-10T21:05:54.000Z", "avg_line_length": 30.6022727273, "max_line_length": 174, "alphanum_fraction": 0.7249659611, "num_tokens": 2264, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7490872243177518, "lm_q2_score": 0.6959583124210896, "lm_q1q2_score": 0.5213334804923807}} {"text": "/* specfunc/legendre_poly.c\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 2 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.\n */\n\n/* Author: G. Jungman */\n\n#include \n#include \n#include \n#include \"gsl_sf_bessel.h\"\n#include \"gsl_sf_exp.h\"\n#include \"gsl_sf_gamma.h\"\n#include \"gsl_sf_log.h\"\n#include \"gsl_sf_pow_int.h\"\n#include \"gsl_sf_legendre.h\"\n\n#include \"error.h\"\n\n/*-*-*-*-*-*-*-*-*-*-*-* Functions with Error Codes *-*-*-*-*-*-*-*-*-*-*-*/\n\nint\ngsl_sf_legendre_P1_e(double x, gsl_sf_result * result)\n{\n /* CHECK_POINTER(result) */\n\n {\n result->val = x;\n result->err = 0.0;\n return GSL_SUCCESS;\n }\n}\n\nint\ngsl_sf_legendre_P2_e(double x, gsl_sf_result * result)\n{\n /* CHECK_POINTER(result) */\n\n {\n result->val = 0.5*(3.0*x*x - 1.0);\n result->err = GSL_DBL_EPSILON * (fabs(3.0*x*x) + 1.0);\n return GSL_SUCCESS;\n }\n}\n\nint\ngsl_sf_legendre_P3_e(double x, gsl_sf_result * result)\n{\n /* CHECK_POINTER(result) */\n\n {\n result->val = 0.5*x*(5.0*x*x - 3.0);\n result->err = GSL_DBL_EPSILON * (fabs(result->val) + 0.5 * fabs(x) * (fabs(5.0*x*x) + 3.0));\n return GSL_SUCCESS;\n }\n}\n\n\nint\ngsl_sf_legendre_Pl_e(const int l, const double x, gsl_sf_result * result)\n{ \n /* CHECK_POINTER(result) */\n\n if(l < 0 || x < -1.0 || x > 1.0) {\n DOMAIN_ERROR(result);\n }\n else if(l == 0) {\n result->val = 1.0;\n result->err = 0.0;\n return GSL_SUCCESS;\n }\n else if(l == 1) {\n result->val = x;\n result->err = 0.0;\n return GSL_SUCCESS;\n }\n else if(l == 2) {\n result->val = 0.5 * (3.0*x*x - 1.0);\n result->err = 3.0 * GSL_DBL_EPSILON * fabs(result->val);\n return GSL_SUCCESS;\n }\n else if(x == 1.0) {\n result->val = 1.0;\n result->err = 0.0;\n return GSL_SUCCESS;\n }\n else if(x == -1.0) {\n result->val = ( GSL_IS_ODD(l) ? -1.0 : 1.0 );\n result->err = 0.0;\n return GSL_SUCCESS;\n }\n else if(l < 100000) {\n /* Compute by upward recurrence on l.\n */\n double p_mm = 1.0; /* P_0(x) */\n double p_mmp1 = x;\t /* P_1(x) */\n double p_ell = p_mmp1;\n int ell;\n\n for(ell=2; ell <= l; ell++){\n p_ell = (x*(2*ell-1)*p_mmp1 - (ell-1)*p_mm) / ell;\n p_mm = p_mmp1;\n p_mmp1 = p_ell;\n }\n\n result->val = p_ell;\n result->err = (0.5 * ell + 1.0) * GSL_DBL_EPSILON * fabs(p_ell);\n return GSL_SUCCESS;\n }\n else {\n /* Asymptotic expansion.\n * [Olver, p. 473]\n */\n double u = l + 0.5;\n double th = acos(x);\n gsl_sf_result J0;\n gsl_sf_result Jm1;\n int stat_J0 = gsl_sf_bessel_J0_e(u*th, &J0);\n int stat_Jm1 = gsl_sf_bessel_Jn_e(-1, u*th, &Jm1);\n double pre;\n double B00;\n double c1;\n\n /* B00 = 1/8 (1 - th cot(th) / th^2\n * pre = sqrt(th/sin(th))\n */\n if(th < GSL_ROOT4_DBL_EPSILON) {\n B00 = (1.0 + th*th/15.0)/24.0;\n pre = 1.0 + th*th/12.0;\n }\n else {\n double sin_th = sqrt(1.0 - x*x);\n double cot_th = x / sin_th;\n B00 = 1.0/8.0 * (1.0 - th * cot_th) / (th*th);\n pre = sqrt(th/sin_th);\n }\n\n c1 = th/u * B00;\n\n result->val = pre * (J0.val + c1 * Jm1.val);\n result->err = pre * (J0.err + fabs(c1) * Jm1.err);\n result->err += GSL_SQRT_DBL_EPSILON * fabs(result->val);\n\n return GSL_ERROR_SELECT_2(stat_J0, stat_Jm1);\n }\n}\n\n\nint\ngsl_sf_legendre_Pl_array(const int lmax, const double x, double * result_array)\n{\n /* CHECK_POINTER(result_array) */\n\n if(lmax < 0 || x < -1.0 || x > 1.0) {\n GSL_ERROR (\"domain error\", GSL_EDOM);\n }\n else if(lmax == 0) {\n result_array[0] = 1.0;\n return GSL_SUCCESS;\n }\n else if(lmax == 1) {\n result_array[0] = 1.0;\n result_array[1] = x;\n return GSL_SUCCESS;\n }\n else {\n double p_mm = 1.0; /* P_0(x) */\n double p_mmp1 = x;\t /* P_1(x) */\n double p_ell = p_mmp1;\n int ell;\n\n result_array[0] = 1.0;\n result_array[1] = x;\n\n for(ell=2; ell <= lmax; ell++){\n p_ell = (x*(2*ell-1)*p_mmp1 - (ell-1)*p_mm) / ell;\n p_mm = p_mmp1;\n p_mmp1 = p_ell;\n result_array[ell] = p_ell;\n }\n\n return GSL_SUCCESS;\n }\n}\n\n\nint\ngsl_sf_legendre_Plm_e(const int l, const int m, const double x, gsl_sf_result * result)\n{\n /* If l is large and m is large, then we have to worry\n * about overflow. Calculate an approximate exponent which\n * measures the normalization of this thing.\n */\n double dif = l-m;\n double sum = l+m;\n double exp_check = 0.5 * log(2.0*l+1.0) \n + 0.5 * dif * (log(dif)-1.0)\n - 0.5 * sum * (log(sum)-1.0);\n\n /* CHECK_POINTER(result) */\n\n if(m < 0 || l < m || x < -1.0 || x > 1.0) {\n DOMAIN_ERROR(result);\n }\n else if(exp_check < GSL_LOG_DBL_MIN + 10.0){\n /* Bail out. */\n OVERFLOW_ERROR(result);\n }\n else {\n /* Account for the error due to the\n * representation of 1-x.\n */\n const double err_amp = 1.0 / (GSL_DBL_EPSILON + fabs(1.0-fabs(x)));\n\n double p_mm; /* P_m^m(x) */\n double p_mmp1; /* P_{m+1}^m(x) */\n\n /* Calculate P_m^m from the analytic result:\n * P_m^m(x) = (-1)^m (2m-1)!! (1-x^2)^(m/2) , m > 0\n */\n p_mm = 1.0;\n if(m > 0){\n double root_factor = sqrt(1.0-x)*sqrt(1.0+x);\n double fact_coeff = 1.0;\n int i;\n for(i=1; i<=m; i++) {\n p_mm *= -fact_coeff * root_factor;\n fact_coeff += 2.0;\n }\n }\n\n /* Calculate P_{m+1}^m. */\n p_mmp1 = x * (2*m + 1) * p_mm;\n\n if(l == m){\n result->val = p_mm;\n result->err = err_amp * 2.0 * GSL_DBL_EPSILON * fabs(p_mm);\n return GSL_SUCCESS;\n }\n else if(l == m + 1) {\n result->val = p_mmp1;\n result->err = err_amp * 2.0 * GSL_DBL_EPSILON * fabs(p_mmp1);\n return GSL_SUCCESS;\n }\n else{\n double p_ell = 0.0;\n int ell;\n \n /* Compute P_l^m, l > m+1 by upward recurrence on l. */\n for(ell=m+2; ell <= l; ell++){\n p_ell = (x*(2*ell-1)*p_mmp1 - (ell+m-1)*p_mm) / (ell-m);\n p_mm = p_mmp1;\n p_mmp1 = p_ell;\n }\n\n result->val = p_ell;\n result->err = err_amp * (0.5*(l-m) + 1.0) * GSL_DBL_EPSILON * fabs(p_ell);\n\n return GSL_SUCCESS;\n }\n }\n}\n\n\nint\ngsl_sf_legendre_Plm_array(const int lmax, const int m, const double x, double * result_array)\n{\n /* If l is large and m is large, then we have to worry\n * about overflow. Calculate an approximate exponent which\n * measures the normalization of this thing.\n */\n double dif = lmax-m;\n double sum = lmax+m;\n double exp_check = 0.5 * log(2.0*lmax+1.0) \n + 0.5 * dif * (log(dif)-1.0)\n - 0.5 * sum * (log(sum)-1.0);\n\n /* CHECK_POINTER(result_array) */\n\n if(m < 0 || lmax < m || x < -1.0 || x > 1.0) {\n GSL_ERROR (\"error\", GSL_EDOM);\n }\n else if(m > 0 && (x == 1.0 || x == -1.0)) {\n int ell;\n for(ell=m; ell<=lmax; ell++) result_array[ell-m] = 0.0;\n return GSL_SUCCESS;\n }\n else if(exp_check < GSL_LOG_DBL_MIN + 10.0){\n /* Bail out.\n */\n GSL_ERROR (\"error\", GSL_EOVRFLW);\n }\n else {\n double p_mm; /* P_m^m(x) */\n double p_mmp1; /* P_{m+1}^m(x) */\n\n /* Calculate P_m^m from the analytic result:\n * P_m^m(x) = (-1)^m (2m-1)!! (1-x^2)^(m/2) , m > 0\n */\n p_mm = 1.0;\n if(m > 0){\n double root_factor = sqrt(1.0-x)*sqrt(1.0+x);\n double fact_coeff = 1.0;\n int i;\n for(i=1; i<=m; i++){\n p_mm *= -fact_coeff * root_factor;\n fact_coeff += 2.0;\n }\n }\n\n /* Calculate P_{m+1}^m. */\n p_mmp1 = x * (2*m + 1) * p_mm;\n\n if(lmax == m){\n result_array[0] = p_mm;\n return GSL_SUCCESS;\n }\n else if(lmax == m + 1) {\n result_array[0] = p_mm;\n result_array[1] = p_mmp1;\n return GSL_SUCCESS;\n }\n else{\n double p_ell;\n int ell;\n\n result_array[0] = p_mm;\n result_array[1] = p_mmp1;\n\n /* Compute P_l^m, l >= m+2, by upward recursion on l. */\n for(ell=m+2; ell <= lmax; ell++){\n p_ell = (x*(2*ell-1)*p_mmp1 - (ell+m-1)*p_mm) / (ell-m);\n p_mm = p_mmp1;\n p_mmp1 = p_ell;\n result_array[ell-m] = p_ell;\n }\n\n return GSL_SUCCESS;\n }\n }\n}\n\n\nint\ngsl_sf_legendre_sphPlm_e(const int l, int m, const double x, gsl_sf_result * result)\n{\n /* CHECK_POINTER(result) */\n\n if(m < 0 || l < m || x < -1.0 || x > 1.0) {\n DOMAIN_ERROR(result);\n }\n else if(m == 0) {\n gsl_sf_result P;\n int stat_P = gsl_sf_legendre_Pl_e(l, x, &P);\n double pre = sqrt((2.0*l + 1.0)/(4.0*M_PI));\n result->val = pre * P.val;\n result->err = pre * P.err;\n result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);\n return stat_P;\n }\n else if(x == 1.0 || x == -1.0) {\n /* m > 0 here */\n result->val = 0.0;\n result->err = 0.0;\n return GSL_SUCCESS;\n }\n else {\n /* m > 0 and |x| < 1 here */\n\n /* Starting value for recursion.\n * Y_m^m(x) = sqrt( (2m+1)/(4pi m) gamma(m+1/2)/gamma(m) ) (-1)^m (1-x^2)^(m/2) / pi^(1/4)\n */\n gsl_sf_result lncirc;\n gsl_sf_result lnpoch;\n double lnpre_val;\n double lnpre_err;\n gsl_sf_result ex_pre;\n double sr;\n const double sgn = ( GSL_IS_ODD(m) ? -1.0 : 1.0);\n const double y_mmp1_factor = x * sqrt(2.0*m + 3.0);\n double y_mm, y_mm_err;\n double y_mmp1;\n gsl_sf_log_1plusx_e(-x*x, &lncirc);\n gsl_sf_lnpoch_e(m, 0.5, &lnpoch); /* Gamma(m+1/2)/Gamma(m) */\n lnpre_val = -0.25*M_LNPI + 0.5 * (lnpoch.val + m*lncirc.val);\n lnpre_err = 0.25*M_LNPI*GSL_DBL_EPSILON + 0.5 * (lnpoch.err + fabs(m)*lncirc.err);\n gsl_sf_exp_err_e(lnpre_val, lnpre_err, &ex_pre);\n sr = sqrt((2.0+1.0/m)/(4.0*M_PI));\n y_mm = sgn * sr * ex_pre.val;\n y_mmp1 = y_mmp1_factor * y_mm;\n y_mm_err = 2.0 * GSL_DBL_EPSILON * fabs(y_mm) + sr * ex_pre.err;\n y_mm_err *= 1.0 + 1.0/(GSL_DBL_EPSILON + fabs(1.0-x));\n\n if(l == m){\n result->val = y_mm;\n result->err = y_mm_err;\n result->err += 2.0 * GSL_DBL_EPSILON * fabs(y_mm);\n return GSL_SUCCESS;\n }\n else if(l == m + 1) {\n result->val = y_mmp1;\n result->err = fabs(y_mmp1_factor) * y_mm_err;\n result->err += 2.0 * GSL_DBL_EPSILON * fabs(y_mmp1);\n return GSL_SUCCESS;\n }\n else{\n double y_ell = 0.0;\n int ell;\n\n /* Compute Y_l^m, l > m+1, upward recursion on l. */\n for(ell=m+2; ell <= l; ell++){\n const double rat1 = (double)(ell-m)/(double)(ell+m);\n\tconst double rat2 = (ell-m-1.0)/(ell+m-1.0);\n const double factor1 = sqrt(rat1*(2*ell+1)*(2*ell-1));\n const double factor2 = sqrt(rat1*rat2*(2*ell+1)/(2*ell-3));\n y_ell = (x*y_mmp1*factor1 - (ell+m-1)*y_mm*factor2) / (ell-m);\n y_mm = y_mmp1;\n y_mmp1 = y_ell;\n }\n\n result->val = y_ell;\n result->err = (0.5*(l-m) + 1.0) * GSL_DBL_EPSILON * fabs(y_ell);\n result->err += fabs(y_mm_err/y_mm) * fabs(y_ell);\n\n return GSL_SUCCESS;\n }\n }\n}\n\n\nint\ngsl_sf_legendre_sphPlm_array(const int lmax, int m, const double x, double * result_array)\n{\n /* CHECK_POINTER(result_array) */\n\n if(m < 0 || lmax < m || x < -1.0 || x > 1.0) {\n GSL_ERROR (\"error\", GSL_EDOM);\n }\n else if(m > 0 && (x == 1.0 || x == -1.0)) {\n int ell;\n for(ell=m; ell<=lmax; ell++) result_array[ell-m] = 0.0;\n return GSL_SUCCESS;\n }\n else {\n double y_mm;\n double y_mmp1;\n\n if(m == 0) {\n y_mm = 0.5/M_SQRTPI; /* Y00 = 1/sqrt(4pi) */\n y_mmp1 = x * M_SQRT3 * y_mm;\n }\n else {\n /* |x| < 1 here */\n\n gsl_sf_result lncirc;\n gsl_sf_result lnpoch;\n double lnpre;\n const double sgn = ( GSL_IS_ODD(m) ? -1.0 : 1.0);\n gsl_sf_log_1plusx_e(-x*x, &lncirc);\n gsl_sf_lnpoch_e(m, 0.5, &lnpoch); /* Gamma(m+1/2)/Gamma(m) */\n lnpre = -0.25*M_LNPI + 0.5 * (lnpoch.val + m*lncirc.val);\n y_mm = sqrt((2.0+1.0/m)/(4.0*M_PI)) * sgn * exp(lnpre);\n y_mmp1 = x * sqrt(2.0*m + 3.0) * y_mm;\n }\n\n if(lmax == m){\n result_array[0] = y_mm;\n return GSL_SUCCESS;\n }\n else if(lmax == m + 1) {\n result_array[0] = y_mm;\n result_array[1] = y_mmp1;\n return GSL_SUCCESS;\n }\n else{\n double y_ell;\n int ell;\n\n result_array[0] = y_mm;\n result_array[1] = y_mmp1;\n\n /* Compute Y_l^m, l > m+1, upward recursion on l. */\n for(ell=m+2; ell <= lmax; ell++){\n const double rat1 = (double)(ell-m)/(double)(ell+m);\n\tconst double rat2 = (ell-m-1.0)/(ell+m-1.0);\n const double factor1 = sqrt(rat1*(2*ell+1)*(2*ell-1));\n const double factor2 = sqrt(rat1*rat2*(2*ell+1)/(2*ell-3));\n y_ell = (x*y_mmp1*factor1 - (ell+m-1)*y_mm*factor2) / (ell-m);\n y_mm = y_mmp1;\n y_mmp1 = y_ell;\n\tresult_array[ell-m] = y_ell;\n }\n }\n\n return GSL_SUCCESS;\n }\n}\n\n#ifndef HIDE_INLINE_STATIC\nint\ngsl_sf_legendre_array_size(const int lmax, const int m)\n{\n return lmax-m+1;\n}\n#endif\n\n/*-*-*-*-*-*-*-*-*-* Functions w/ Natural Prototypes *-*-*-*-*-*-*-*-*-*-*/\n\n#include \"eval.h\"\n\ndouble gsl_sf_legendre_P1(const double x)\n{\n EVAL_RESULT(gsl_sf_legendre_P1_e(x, &result));\n}\n\ndouble gsl_sf_legendre_P2(const double x)\n{\n EVAL_RESULT(gsl_sf_legendre_P2_e(x, &result));\n}\n\ndouble gsl_sf_legendre_P3(const double x)\n{\n EVAL_RESULT(gsl_sf_legendre_P3_e(x, &result));\n}\n\ndouble gsl_sf_legendre_Pl(const int l, const double x)\n{\n EVAL_RESULT(gsl_sf_legendre_Pl_e(l, x, &result));\n}\n\ndouble gsl_sf_legendre_Plm(const int l, const int m, const double x)\n{\n EVAL_RESULT(gsl_sf_legendre_Plm_e(l, m, x, &result));\n}\n\ndouble gsl_sf_legendre_sphPlm(const int l, const int m, const double x)\n{\n EVAL_RESULT(gsl_sf_legendre_sphPlm_e(l, m, x, &result));\n}\n\n", "meta": {"hexsha": "5c4cdaff79d2a800f73fc45e3c68375bd4e9ac74", "size": 14209, "ext": "c", "lang": "C", "max_stars_repo_path": "code/em/treba/gsl-1.0/specfunc/legendre_poly.c", "max_stars_repo_name": "ICML14MoMCompare/spectral-learn", "max_stars_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-12-18T18:09:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-10T11:31:28.000Z", "max_issues_repo_path": "code/em/treba/gsl-1.0/specfunc/legendre_poly.c", "max_issues_repo_name": "ICML14MoMCompare/spectral-learn", "max_issues_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "code/em/treba/gsl-1.0/specfunc/legendre_poly.c", "max_forks_repo_name": "ICML14MoMCompare/spectral-learn", "max_forks_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2015-10-02T01:32:59.000Z", "max_forks_repo_forks_event_max_datetime": "2015-10-02T01:32:59.000Z", "avg_line_length": 25.6018018018, "max_line_length": 96, "alphanum_fraction": 0.5579562249, "num_tokens": 5113, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7956580903722561, "lm_q2_score": 0.6548947290421275, "lm_q1q2_score": 0.5210722895045152}} {"text": "#ifndef __CCL_CONSTANTS_H_INCLUDED__\n#define __CCL_CONSTANTS_H_INCLUDED__\n\n#include \n\n//Spline types\n#define A_SPLINE_TYPE gsl_interp_akima\n#define K_SPLINE_TYPE gsl_interp_akima\n#define L_SPLINE_TYPE gsl_interp_akima\n#define M_SPLINE_TYPE gsl_interp_akima\n#define D_SPLINE_TYPE gsl_interp_akima\n#define PNL_SPLINE_TYPE gsl_interp2d_bicubic\n#define PLIN_SPLINE_TYPE gsl_interp2d_bicubic\n#define CORR_SPLINE_TYPE gsl_interp_akima\n\n/** @file */\n\n#ifndef M_PI\n/**\n * PI (in case it's not defined from math.h)\n*/\n#define M_PI 3.14159265358979323846\n#endif\n\n/**\n * k pivot. These are in units of Mpc (no factor of h)\n*/\n#define K_PIVOT 0.05\n\n/**\n * Lightspeed / H0 in units of Mpc/h (from CODATA 2014)\n */\n#define CLIGHT_HMPC 2997.92458 //H0^-1 in Mpc/h\n\n/**\n * Newton's gravitational constant in units of m^3/Kg/s^2 \n */\n//#define GNEWT 6.6738e-11 /(from PDG 2013) in m^3/Kg/s^2\n//#define GNEWT 6.67428e-11 // CLASS VALUE\n#define GNEWT 6.67408e-11 // from CODATA 2014\n\n/**\n * Solar mass in units of kg (from GSL)\n */\n//#define SOLAR_MASS GSL_CONST_MKSA_SOLAR_MASS\n//#define SOLAR_MASS 1.9885e30 //(from PDG 2015) in Kg\n#define SOLAR_MASS 1.9884754153381438e+30 //from IAU 2015\n/**\n * Mpc to meters (from PDG 2013)\n */\n#define MPC_TO_METER 3.08567758149e22\n\n/**\n * pc to meters (from PDG 2013)\n */\n#define PC_TO_METER 3.08567758149e16\n\n/** \n * Rho critical in units of M_sun/h / (Mpc/h)^3\n */\n#define RHO_CRITICAL ((3*100*100)/(8*M_PI*GNEWT)) * (1000*1000*MPC_TO_METER/SOLAR_MASS)\n\n/**\n * Boltzmann constant in units of J/K\n*/\n//#define KBOLTZ GSL_CONST_MKSA_BOLTZMANN\n#define KBOLTZ 1.38064852e-23 //from CODATA 2014\n \n/**\n * Stefan-Boltzmann constant in units of kg/s^3 / K^4\n */\n//#define STBOLTZ GSL_CONST_MKSA_STEFAN_BOLTZMANN_CONSTANT\n#define STBOLTZ 5.670367e-8 //from CODATA 2014\n/**\n * Planck's constant in units kg m^2 / s\n */\n//#define HPLANCK GSL_CONST_MKSA_PLANCKS_CONSTANT_H \n#define HPLANCK 6.626070040e-34 //from CODATA 2014\n \n/**\n * The speed of light in m/s\n */\n//#define CLIGHT GSL_CONST_MKSA_SPEED_OF_LIGHT\n#define CLIGHT 299792458.0 //from CODATA 2014\n \n/**\n * Electron volt to Joules convestion\n */\n//#define EV_IN_J GSL_CONST_MKSA_ELECTRON_VOLT\n#define EV_IN_J 1.6021766208e-19 //from CODATA 2014\n \n/**\n * Temperature of the CMB in K\n */\n#define TCMB 2.725\n//#define TCMB 2.7255 // CLASS value\n\n/**\n * T_ncdm, as taken from CLASS, explanatory.ini\n */\n#define TNCDM 0.71611\n\n/**\n * neutrino mass splitting differences\n * See Lesgourgues and Pastor, 2012 for these values.\n * Adv. High Energy Phys. 2012 (2012) 608515, \n * arXiv:1212.6154, page 13\n*/\n#define DELTAM12_sq 7.62E-5\n#define DELTAM13_sq_pos 2.55E-3\n#define DELTAM13_sq_neg -2.43E-3\n\n\n//Precision parameters\n/**\n * Default relative precision if not otherwise specified\n */\n#define GSL_EPSREL 1E-4\n\n/**\n * Default number of iterations for integration and root-finding if not otherwise\n * specified\n */\n#define GSL_N_ITERATION 1000\n\n/**\n * Default number of Gauss-Kronrod points in QAG integration if not otherwise \n * specified\n */\n#define GSL_INTEGRATION_GAUSS_KRONROD_POINTS GSL_INTEG_GAUSS41\n\n/**\n * Absolute precision in neutrino root finding\n */\n#define GSL_EPSABS_NU 1E-7\n\n/**\n * Relative precision in neutrino root finding\n */\n#define GSL_EPSREL_NU 1E-7\n\n/**\n * Number of iterations for neutrino root finding\n */\n#define GSL_N_ITERATION_NU 1000\n\n/**\n * Relative precision in sigma_R calculations\n */\n#define GSL_EPSREL_SIGMAR 1E-5\n\n/**\n * Relative precision in distance calculations\n */\n#define GSL_EPSREL_DIST 1E-6\n\n/**\n * Relative precision in growth calculations\n */\n#define GSL_EPSREL_GROWTH 1E-6\n\n/**\n * Relative precision in dNdz calculations\n */\n#define GSL_EPSREL_DNDZ 1E-6\n\n/**\n * Absolute precision in growth calculations\n */\n#define EPS_SCALEFAC_GROWTH 1E-6\n\n\n#endif\n", "meta": {"hexsha": "33e7889f23c8f99085580d091ee459a952093296", "size": 3796, "ext": "h", "lang": "C", "max_stars_repo_path": "include/ccl_constants.h", "max_stars_repo_name": "vrastil/CCL", "max_stars_repo_head_hexsha": "b3bd184b516212b51bdf7ceacab70b2b7afeffb3", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "include/ccl_constants.h", "max_issues_repo_name": "vrastil/CCL", "max_issues_repo_head_hexsha": "b3bd184b516212b51bdf7ceacab70b2b7afeffb3", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "include/ccl_constants.h", "max_forks_repo_name": "vrastil/CCL", "max_forks_repo_head_hexsha": "b3bd184b516212b51bdf7ceacab70b2b7afeffb3", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 21.816091954, "max_line_length": 87, "alphanum_fraction": 0.7363013699, "num_tokens": 1229, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6926419831347361, "lm_q2_score": 0.752012568201972, "lm_q1q2_score": 0.5208754765816599}} {"text": "/* specfunc/gsl_sf_fermi_dirac.h\r\n * \r\n * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman\r\n * \r\n * This program is free software; you can redistribute it and/or modify\r\n * it under the terms of the GNU General Public License as published by\r\n * the Free Software Foundation; either version 3 of the License, or (at\r\n * your option) any later version.\r\n * \r\n * This program is distributed in the hope that it will be useful, but\r\n * WITHOUT ANY WARRANTY; without even the implied warranty of\r\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\r\n * General Public License for more details.\r\n * \r\n * You should have received a copy of the GNU General Public License\r\n * along with this program; if not, write to the Free Software\r\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\r\n */\r\n\r\n/* Author: G. Jungman */\r\n\r\n#ifndef __GSL_SF_FERMI_DIRAC_H__\r\n#define __GSL_SF_FERMI_DIRAC_H__\r\n\r\n#if !defined( GSL_FUN )\r\n# if !defined( GSL_DLL )\r\n# define GSL_FUN extern\r\n# elif defined( BUILD_GSL_DLL )\r\n# define GSL_FUN extern __declspec(dllexport)\r\n# else\r\n# define GSL_FUN extern __declspec(dllimport)\r\n# endif\r\n#endif\r\n\r\n#include \r\n\r\n#undef __BEGIN_DECLS\r\n#undef __END_DECLS\r\n#ifdef __cplusplus\r\n# define __BEGIN_DECLS extern \"C\" {\r\n# define __END_DECLS }\r\n#else\r\n# define __BEGIN_DECLS /* empty */\r\n# define __END_DECLS /* empty */\r\n#endif\r\n\r\n__BEGIN_DECLS\r\n\r\n\r\n/* Complete Fermi-Dirac Integrals:\r\n *\r\n * F_j(x) := 1/Gamma[j+1] Integral[ t^j /(Exp[t-x] + 1), {t,0,Infinity}]\r\n *\r\n *\r\n * Incomplete Fermi-Dirac Integrals:\r\n *\r\n * F_j(x,b) := 1/Gamma[j+1] Integral[ t^j /(Exp[t-x] + 1), {t,b,Infinity}]\r\n */\r\n\r\n\r\n/* Complete integral F_{-1}(x) = e^x / (1 + e^x)\r\n *\r\n * exceptions: GSL_EUNDRFLW\r\n */\r\nGSL_FUN int gsl_sf_fermi_dirac_m1_e(const double x, gsl_sf_result * result);\r\nGSL_FUN double gsl_sf_fermi_dirac_m1(const double x);\r\n\r\n\r\n/* Complete integral F_0(x) = ln(1 + e^x)\r\n *\r\n * exceptions: GSL_EUNDRFLW\r\n */\r\nGSL_FUN int gsl_sf_fermi_dirac_0_e(const double x, gsl_sf_result * result);\r\nGSL_FUN double gsl_sf_fermi_dirac_0(const double x);\r\n\r\n\r\n/* Complete integral F_1(x)\r\n *\r\n * exceptions: GSL_EUNDRFLW, GSL_EOVRFLW\r\n */\r\nGSL_FUN int gsl_sf_fermi_dirac_1_e(const double x, gsl_sf_result * result);\r\nGSL_FUN double gsl_sf_fermi_dirac_1(const double x);\r\n\r\n\r\n/* Complete integral F_2(x)\r\n *\r\n * exceptions: GSL_EUNDRFLW, GSL_EOVRFLW\r\n */\r\nGSL_FUN int gsl_sf_fermi_dirac_2_e(const double x, gsl_sf_result * result);\r\nGSL_FUN double gsl_sf_fermi_dirac_2(const double x);\r\n\r\n\r\n/* Complete integral F_j(x)\r\n * for integer j\r\n *\r\n * exceptions: GSL_EUNDRFLW, GSL_EOVRFLW\r\n */\r\nGSL_FUN int gsl_sf_fermi_dirac_int_e(const int j, const double x, gsl_sf_result * result);\r\nGSL_FUN double gsl_sf_fermi_dirac_int(const int j, const double x);\r\n\r\n\r\n/* Complete integral F_{-1/2}(x)\r\n *\r\n * exceptions: GSL_EUNDRFLW, GSL_EOVRFLW\r\n */\r\nGSL_FUN int gsl_sf_fermi_dirac_mhalf_e(const double x, gsl_sf_result * result);\r\nGSL_FUN double gsl_sf_fermi_dirac_mhalf(const double x);\r\n\r\n\r\n/* Complete integral F_{1/2}(x)\r\n *\r\n * exceptions: GSL_EUNDRFLW, GSL_EOVRFLW\r\n */\r\nGSL_FUN int gsl_sf_fermi_dirac_half_e(const double x, gsl_sf_result * result);\r\nGSL_FUN double gsl_sf_fermi_dirac_half(const double x);\r\n\r\n\r\n/* Complete integral F_{3/2}(x)\r\n *\r\n * exceptions: GSL_EUNDRFLW, GSL_EOVRFLW\r\n */\r\nGSL_FUN int gsl_sf_fermi_dirac_3half_e(const double x, gsl_sf_result * result);\r\nGSL_FUN double gsl_sf_fermi_dirac_3half(const double x);\r\n\r\n\r\n/* Incomplete integral F_0(x,b) = ln(1 + e^(b-x)) - (b-x)\r\n *\r\n * exceptions: GSL_EUNDRFLW, GSL_EDOM\r\n */\r\nGSL_FUN int gsl_sf_fermi_dirac_inc_0_e(const double x, const double b, gsl_sf_result * result);\r\nGSL_FUN double gsl_sf_fermi_dirac_inc_0(const double x, const double b);\r\n\r\n\r\n__END_DECLS\r\n\r\n#endif /* __GSL_SF_FERMI_DIRAC_H__ */\r\n", "meta": {"hexsha": "049c1daacd5437340518cb63eb26d54d22a0f4e6", "size": 3926, "ext": "h", "lang": "C", "max_stars_repo_path": "deps/include/gsl/gsl_sf_fermi_dirac.h", "max_stars_repo_name": "berkus/music-cs", "max_stars_repo_head_hexsha": "099b66cb1285d19955e953f916ec6c12c68f2242", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2021-01-09T05:48:44.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-09T16:18:47.000Z", "max_issues_repo_path": "deps/include/gsl/gsl_sf_fermi_dirac.h", "max_issues_repo_name": "berkus/music-cs", "max_issues_repo_head_hexsha": "099b66cb1285d19955e953f916ec6c12c68f2242", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2021-01-11T01:08:01.000Z", "max_issues_repo_issues_event_max_datetime": "2021-01-13T16:28:48.000Z", "max_forks_repo_path": "deps/include/gsl/gsl_sf_fermi_dirac.h", "max_forks_repo_name": "berkus/music-cs", "max_forks_repo_head_hexsha": "099b66cb1285d19955e953f916ec6c12c68f2242", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-01-20T16:22:57.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-14T12:31:02.000Z", "avg_line_length": 28.6569343066, "max_line_length": 100, "alphanum_fraction": 0.6996943454, "num_tokens": 1175, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7520125737597972, "lm_q2_score": 0.6926419767901476, "lm_q1q2_score": 0.5208754756600327}} {"text": "#include \n#include \n#include \n\n#include \n#include \n\n#include \n\n#include \n\n#include \"fsht.h\"\n#include \"util.h\"\n\nint fshtinit (shdata *dat, int deg, int ntheta, int nphi, int measfft) {\n\tint ierr;\n\tcomplex double *fftbuf;\n\n\t/* This is actually one more than the maximum degree. */\n\tdat->deg = deg;\n\n\t/* The number of theta samples must at least equal the SH degree. */\n\tif (ntheta < deg) dat->ntheta = deg;\n\telse dat->ntheta = ntheta;\n\n\t/* At least this many phi values are required for fast FFT evaluation. */\n\tif (2 * deg - 1 > nphi) dat->nphi = 2 * deg - 1;\n\telse dat->nphi = nphi;\n\n\t/* Allocate the theta points and weights. */\n\tdat->theta = calloc (2 * dat->ntheta, sizeof(double));\n\tdat->weights = dat->theta + dat->ntheta;\n\n\t/* Find the Legendre-Gauss quadrature points. */\n\tgauleg (dat->ntheta, dat->theta, dat->weights);\n\n\t/* Temporarily allocate an FFT data buffer for planning. */\n\tfftbuf = fftw_malloc (dat->ntheta * dat->nphi * sizeof(complex double));\n\n\t/* Plan the forward and inverse transforms. */\n\tdat->fplan = fftw_plan_many_dft (1, &(dat->nphi), dat->ntheta, fftbuf,\n\t\t\t&(dat->nphi), 1, dat->nphi, fftbuf, &(dat->nphi), 1,\n\t\t\tdat->nphi, FFTW_FORWARD, measfft ? FFTW_MEASURE : FFTW_ESTIMATE);\n\n\tdat->bplan = fftw_plan_many_dft (1, &(dat->nphi), dat->ntheta, fftbuf,\n\t\t\t&(dat->nphi), 1, dat->nphi, fftbuf, &(dat->nphi), 1,\n\t\t\tdat->nphi, FFTW_BACKWARD, measfft ? FFTW_MEASURE : FFTW_ESTIMATE);\n\n\t/* The FFT buffer is no longer necessary, and will be reallocated\n\t * on-the-fly when it is needed later. */\n\tfftw_free (fftbuf);\n\n\treturn 0;\n}\n\nint fshtfree (shdata *dat) {\n\tif (dat->theta) free (dat->theta);\n\n\tfftw_destroy_plan (dat->fplan);\n\tfftw_destroy_plan (dat->bplan);\n\n\tdat->ntheta = dat->nphi = dat->deg = 0;\n\n\treturn 0;\n}\n\n/* Scale the components of the spherical harmonic coefficients to relate the\n * far-field signature to the spherical harmonic expansion. The default (for\n * non-negative sgn) properly scales SH coefficients AFTER a forward\n * transform (angular to spherical). If sgn is negative, it scales the SH\n * coefficients BEFORE an inverse transform (spherical to angular). */\nint shscale (complex double *samp, shdata *dat, int sgn) {\n\tcomplex double cscale[4] = { I, -1.0, -I, 1.0 };\n\tint i, j, off, idx;\n\n\t/* For negative sgn, flip the signs of the imaginary multipliers. */\n\tif (sgn < 0) {\n\t\tcscale[0] = -I;\n\t\tcscale[2] = I;\n\t}\n\n\tfor (i = 0; i < dat->deg; ++i) {\n\t\tidx = i % 4;\n\t\toff = i * dat->nphi;\n\n\t\t/* Scale the zero order for all degrees. */\n\t\tsamp[off] *= cscale[idx];\n\n\t\t/* Scale the nonzero orders for all degrees. */\n\t\tfor (j = 1; j <= i; ++j) {\n\t\t\tsamp[off + j] *= cscale[idx];\n\t\t\tsamp[off + dat->nphi - j] *= cscale[idx];\n\t\t}\n\t}\n\n\treturn 0;\n}\n\n/* Forward spherical harmonic transform: take samples of the function in theta\n * and phi into SH coefficients. */\nint ffsht (complex double *samp, shdata *dat, int maxdeg) {\n\tint i, j, k, aoff, npk, dm1, deg = maxdeg;\n\tlong lgn, lgi;\n\tdouble pc, scale, *lgvals;\n\tcomplex double *beta, *fftbuf;\n\n\t/* Copy the samples to the FFT buffer and perform the FFT. */\n\tfftbuf = fftw_malloc (dat->ntheta * dat->nphi * sizeof(complex double));\n\tmemcpy (fftbuf, samp, dat->ntheta * dat->nphi * sizeof(complex double));\n\n\t/* Perform an in-place FFT of the buffer. */\n\tfftw_execute_dft (dat->fplan, fftbuf, fftbuf);\n\n\t/* Zero out the input samples, to prepare for storage of coefficients. */\n\tmemset (samp, 0, dat->ntheta * dat->nphi * sizeof(complex double));\n\n\tbeta = fftbuf;\n\n\t/* If no maximum degree is specified, use the default. */\n\tif (maxdeg < 1) deg = dat->deg;\n\n\tdm1 = deg - 1;\n\n\t/* Create storage for all Legendre polynomials. */\n\tlgn = gsl_sf_legendre_array_n (dm1);\n\tlgvals = malloc (lgn * sizeof(double));\n\n\n\tfor (i = 0; i < dat->ntheta; ++i) {\n\t\t/* The scale factor that will be required. */\n\t\tscale = 2 * M_PI * dat->weights[i] / dat->nphi;\n\n\t\t/* Build the Legendre polynomials that we need.\n\t\t * Don't use Condon-Shortley phase factor. */\n\t\tgsl_sf_legendre_array_e (GSL_SF_LEGENDRE_SPHARM, dm1, dat->theta[i], 1., lgvals);\n\n\t\t/* Handle m = 0 for all degrees. */\n\t\tfor (j = 0; j < deg; ++j) {\n\t\t\tlgi = gsl_sf_legendre_array_index(j, 0);\n\t\t\tsamp[j * dat->nphi] += scale * beta[0] * lgvals[lgi];\n\t\t}\n\n\t\t/* Handle nonzero orders for all relevant degrees. */\n\t\tfor (k = 1; k < deg; ++k) {\n\t\t\tnpk = dat->nphi - k;\n\t\t\tfor (j = k; j < deg; ++j) {\n\t\t\t\taoff = j * dat->nphi;\n\t\t\t\tlgi = gsl_sf_legendre_array_index(j, k);\n\t\t\t\tpc = scale * lgvals[lgi];\n\t\t\t\t/* The positive-order coefficient. */\n\t\t\t\tsamp[aoff + k] += pc * beta[k];\n\t\t\t\t/* The negative-order coefficient. */\n\t\t\t\tsamp[aoff + npk] += pc * beta[npk];\n\t\t\t}\n\t\t}\n\n\t\tbeta += dat->nphi;\n\t}\n\n\t/* The FFT buffer is no longer required. */\n\tfftw_free (fftbuf);\n\n\treturn deg;\n}\n\n/* Inverse spherical harmonic transform: take SH coefficients to sample of the\n * function in theta and phi. */\nint ifsht (complex double *samp, shdata *dat, int maxdeg) {\n\tint i, j, k, aoff, npk, dm1, n, deg = maxdeg;\n\tlong lgn, lgi;\n\tdouble *lgvals;\n\tcomplex double *beta, *fftbuf;\n\n\t/* The non-polar samples. */\n\tn = dat->ntheta * dat->nphi;\n\n\t/* Zero out the FFT buffer to prepare for evaluation of function. */\n\tfftbuf = fftw_malloc (n * sizeof(complex double));\n\tmemset (fftbuf, 0, n * sizeof(complex double));\n\n\tbeta = fftbuf;\n\n\t/* Use the default degree if no maximum is specified. */\n\tif (maxdeg < 1) deg = dat->deg;\n\n\tdm1 = deg - 1;\n\n\t/* Create storage for all Legendre polynomials. */\n\tlgn = gsl_sf_legendre_array_n(dm1);\n\tlgvals = malloc (lgn * sizeof(double));\n\n\tfor (i = 0; i < dat->ntheta; ++i) {\n\t\t/* Build the Legendre polynomials that we need. */\n\t\t/* Don't use the Condon-Shortley phase factor. */\n\t\tgsl_sf_legendre_array_e (GSL_SF_LEGENDRE_SPHARM, dm1, dat->theta[i], 1., lgvals);\n\n\t\tfor (j = 0; j < deg; ++j) {\n\t\t\tlgi = gsl_sf_legendre_array_index(j, 0);\n\t\t\tbeta[0] += samp[j * dat->nphi] * lgvals[lgi];\n\t\t}\n\n\t\tfor (k = 1; k < deg; ++k) {\n\t\t\tnpk = dat->nphi - k;\n\t\t\tfor (j = k; j < deg; ++j) {\n\t\t\t\taoff = j * dat->nphi;\n\t\t\t\tlgi = gsl_sf_legendre_array_index(j, k);\n\t\t\t\t/* The positive-order coefficient. */\n\t\t\t\tbeta[k] += samp[aoff + k] * lgvals[lgi];\n\t\t\t\t/* The negative-order coefficient. */\n\t\t\t\tbeta[npk] += samp[aoff + npk] * lgvals[lgi];\n\t\t\t}\n\t\t}\n\n\t\t/* Move the next theta value in the FFT array. */\n\t\tbeta += dat->nphi;\n\t}\n\n\t/* Perform the inverse FFT and copy the values to the storage area. */\n\tfftw_execute_dft (dat->bplan, fftbuf, fftbuf);\n\tmemcpy (samp, fftbuf, n * sizeof(complex double));\n\n\t/* Eliminate the FFT buffer. */\n\tfftw_free (fftbuf);\n\tfree (lgvals);\n\n\treturn deg;\n}\n", "meta": {"hexsha": "a2a365e0bd487259f5bab595415d44316abae591", "size": 6607, "ext": "c", "lang": "C", "max_stars_repo_path": "fsht.c", "max_stars_repo_name": "ahesford/fastsphere", "max_stars_repo_head_hexsha": "18d8bd2d73aaabeafe4ead48955c8d8190eddbf2", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "fsht.c", "max_issues_repo_name": "ahesford/fastsphere", "max_issues_repo_head_hexsha": "18d8bd2d73aaabeafe4ead48955c8d8190eddbf2", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "fsht.c", "max_forks_repo_name": "ahesford/fastsphere", "max_forks_repo_head_hexsha": "18d8bd2d73aaabeafe4ead48955c8d8190eddbf2", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 28.9780701754, "max_line_length": 83, "alphanum_fraction": 0.64386257, "num_tokens": 2134, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8175744761936437, "lm_q2_score": 0.6370307944803831, "lm_q1q2_score": 0.5208201181165198}} {"text": "#include \n#include \n#include /* for getopt */\n#include \n\n#include \n#include \n#include \n\n#include \"defaults.h\"\n#include \"h2ocalc.h\"\n//#include\"h2ocalc_test.h\"\n\n/* gcc h2ocalc.c -o h2ocalc -lgsl -lgslcblas -lm -Wall */\n\n/* struct ODE_param{ */\n/* int a[NEQ]; /\\* dont worry let just run with global vars for now *\\/ */\n/* float b[NEQ]; */\n/* }; */\n\nint nbprint(double x, double y[], int n) {\n int i;\n double sum = 0;\n printf(\"%6.4f \", x);\n for (i = 0; i < n; i++) {\n printf(\"%6.2f \", y[i]);\n sum += y[i];\n }\n printf(\" %6.2f\\n\",sum);\n return 0;\n}\n\n\nint nbeprint(double x, double y[], int n) {\n int i;\n double sum = 0;\n\n printf(\"%6.4e \",x);\n for (i = 0; i < n; i++) {\n printf(\"%6.2e \", y[i]);\n sum += y[i];\n }\n printf(\" %6.2e\\n\", sum);\n return 0;\n}\n\n\nint func (double t, const double y[],double f[], void *params) {\n // struct ODE_param *p = (struct ODE_params *) params;\n int i,j,k;\n double rate[NEQ];\n\n //printf(\"func\\n\");\n\n /* for each species ... */\n for (k = 0; k < NSPECIES; k++) {\n //printf(\"SPECIES %i\\n\",k);\n\n f[k] = 0;\n\n /* ...find all contributing and removing things */\n\n for (j = 0; j < NEQ; j++) {\n\n if (nmatrix[j][k] != 0) {\n\n rate[j] = nmatrix [j][k]; /* build the final equation */\n //printf(\"%3i \",nmatrix[j][k]);\n\n /* add generate I equations */\n rate[j] *= rconst[j]; /* get rate for reaction I_j */\n\n //printf(\" * k%i \",j);\n for (i = 0; i < NSPECIES; i++) {\n if (nmatrix[j][i] == -1 ) {\n rate[j] *= y[i]; /* first order kinetics */\n //printf(\"* y[%i] \",i);\n }\n if (nmatrix[j][i] == -2 ) {\n rate[j] *= y[i]*y[i]; // second order kinetics\n //printf(\"* y[%i]^2 \",i);\n }\n }\n\n f[k] += rate[j];\n //printf(\" + \\n\");\n }\n }\n\n\n //printf(\" ---- k f[k]: %i %e ---- \\n\",k,f[k]);\n\n // nbeprint(t,y,NSPECIES);\n // if (k ==8)\n // exit(0);\n }\n\n //nbeprint(t,y,NSPECIES);\n //nbeprint(t,f,NSPECIES);\n\n\n /* add function for radiation, assumed in last bin */\n //f[NEQ-1] = 0;\n\n return GSL_SUCCESS;\n}\n\n\nint main(int argc, char **argv) {\n // struct ODE_param *p = (struct ODE_params *) params;\n\n double dummy_param = 0;\n gsl_odeiv2_system sys = {func, NULL, NSPECIES, &dummy_param};\n gsl_odeiv2_driver *d = gsl_odeiv2_driver_alloc_y_new(&sys,\n gsl_odeiv2_step_rk8pd,\n 1e-6,\n 1e-6,\n 0.0);\n int i,j,status;\n double t = NSTART;\n // double t1 = NSTOP;\n //double foobar; /* trash parameter */\n double ti;\n double y[NSPECIES];\n\n double freq = FREQ;\n double doser = DOSER;\n double simtime = SIMTIME;\n double resol = RESOL;\n double period = 0;\n double dpulse = 0;\n double tick = 0;\n double ta = 1e-3; /* plotting clocks*/\n int pulse_left = 0;\n int pulse_counter = 0;\n signed long int tick_counter = 0;\n char *fname;\n int c;\n int flagp = 0, flagl = 0, flagc = 1; /* default: print each tick */\n\n /* parse options */\n opterr = 0;\n while ((c = getopt(argc, argv, \"f:d:o:r:t:\")) != -1) {\n switch(c) {\n case 'l':\n flagl = 1;\n flagp = 0;\n flagc = 0;\n break;\n case 'p':\n flagl = 0;\n flagp = 1;\n flagc = 0;\n break;\n case 'c':\n flagl = 0;\n flagp = 0;\n flagc = 1;\n break;\n case 'f':\n sscanf(optarg, \"%lf\", &freq);\n break;\n case 'd':\n sscanf(optarg, \"%lf\", &doser);\n break;\n case 'o':\n fname = optarg; /* not implemented */\n break;\n case 'r':\n sscanf(optarg, \"%lf\", &resol);\n break;\n case 't':\n sscanf(optarg, \"%lf\", &simtime);\n break;\n case '?':\n printf(\"Options:\\n\");\n printf(\" -p output per pulse\\n\");\n printf(\" -c output per tick\\n\");\n printf(\" -l only end of output\\n\");\n printf(\" -f frequency [Hz]\\n\");\n printf(\" -d dose rate [Gy/min]\\n\");\n printf(\" -o output file\\n\");\n printf(\" -r tick resolution [sec]\\n\");\n printf(\" -t simulation time [sec]\\n\");\n printf(\"\\n\");\n exit(0);\n break;\n default:\n printf (\"?? no handle ?? %i\\n\", c);\n exit(-1);\n }\n }\n\n\n period = 1 / freq;\n dpulse = (doser / 60.0) / freq * EVJ; // in eV per pulse per liter\n\n\n if (period < resol) {\n printf(\" *** Error: \");\n printf(\"Period must be larger than tick resolution.\\n\");\n exit(-1);\n }\n\n /* find ticksize closest to the requested one */\n tick = period/(round(period/ resol));\n\n /* number of pulses to be simulated */\n pulse_left = (int) ((simtime-RSTART) * freq);\n\n /* print a header */\n printf(\"# Frequency : %.3e Hz \\n\", freq);\n printf(\"# Period : %.3e sec\\n\", period);\n printf(\"#\\n\");\n printf(\"# Tick size : %.3e sec\\n\", tick);\n printf(\"# Time for sim : %.3e sec\\n\", simtime);\n printf(\"#\\n\");\n printf(\"# Dose rate : %.3e Gy/min\\n\", doser );\n printf(\"# Pulse size : %.3e eV/l/pulse\\n\", dpulse );\n printf(\"# Pulse count : %i pulses\\n\", pulse_left);\n printf(\"#\\n\");\n printf(\"# Total delivered dose for this simulation\\n\");\n printf(\"# : %.6e Gy \\n\", pulse_left * dpulse / EVJ);\n printf(\"#\\n\");\n\n /* copy start conditions into working array */\n for (i = 0; i < NSPECIES; i++)\n y[i] = ystart[i];\n\n /* Print first line with starting conditions. */\n nbeprint(t, y, NSPECIES);\n\n /* loop over all pulses */\n while (pulse_left != 0) {\n\n /* check if we are at a pulse time step */\n if (t >= ((pulse_counter * period) + RSTART)) {\n if (flagp) /* print per pulse (pre pulse) */\n nbeprint(t, y, NSPECIES);\n\n printf(\"# Pulse! %i \\n\", pulse_left);\n for (j=0; j < NSPECIES; j++)\n y[j] += dpulse * gval[j] * 0.01 / NA;\n pulse_left--;\n pulse_counter++;\n }\n\n tick_counter++;\n ti = tick_counter * tick;\n\n status = gsl_odeiv2_driver_apply(d, &t, ti, y);\n\n if (status != GSL_SUCCESS) {\n printf(\"error, return value = %d\\n\", status);\n break;\n }\n\n if (flagc) /* print per tick */\n nbeprint(t, y, NSPECIES);\n\n } /* end pulses left iterator */\n\n if (flagl) /* print last */\n nbeprint(t, y, NSPECIES);\n\n gsl_odeiv2_driver_free(d);\n return 0;\n}\n\n", "meta": {"hexsha": "59e6eeba0ada657c0b880bba90f7f1c90bcaa09e", "size": 7227, "ext": "c", "lang": "C", "max_stars_repo_path": "src/h2ocalc.c", "max_stars_repo_name": "nbassler/simwater", "max_stars_repo_head_hexsha": "3353241cce578ac5b25076c5db27044517f5c457", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/h2ocalc.c", "max_issues_repo_name": "nbassler/simwater", "max_issues_repo_head_hexsha": "3353241cce578ac5b25076c5db27044517f5c457", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/h2ocalc.c", "max_forks_repo_name": "nbassler/simwater", "max_forks_repo_head_hexsha": "3353241cce578ac5b25076c5db27044517f5c457", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.7666666667, "max_line_length": 79, "alphanum_fraction": 0.4488722845, "num_tokens": 2018, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8221891305219504, "lm_q2_score": 0.6334102567576901, "lm_q1q2_score": 0.5207830282672906}} {"text": "#include \r\n#include \r\n#include \r\n#include \r\n\r\n#define N 65536 //the final number of nodes\r\n#define I 2 // the initial number of nodes\r\n\r\n#define MI 0 //the initial trial number\r\n#define MF 33 //(the final trial number) - 1\r\n\r\n#define RS 35382 //seed of the random number generator\r\n\r\nint main()\r\n{\r\n\tFILE *fp;\r\n\t\r\n\tdouble delta=sqrt(1.5);\r\n\tint tout[]={512,1024,2048,4096,8192,16384,32768,65536,131072};\r\n\t\r\n\tint i,j,k,l,m,t,tt;\r\n\tint tmp,flag;\r\n\t\r\n\tint **nb; //neighbors of each node\r\n\t\r\n\tint x; //new node\r\n\tint vdx; //virtual degree of the node x\r\n\tint *tmparr;\r\n\t\r\n\tint z;\r\n\tint nzsize;\r\n\tint *nz;\r\n\t\r\n\tint *deg; //degree of each node\r\n\t\r\n\tdouble degav; //average degree\r\n\tdouble *knn; //average degree of the nearest neighbors of each node\r\n\tdouble *cc; //local clustering coefficient of each node\r\n\tdouble ccav; //average local clustering coefficient\r\n\t\r\n\tchar filename[100];\r\n\t\r\n\tconst gsl_rng_type * TYPE;\r\n\tgsl_rng * ran;\r\n\t\r\n\t\r\n\tgsl_rng_env_setup();\r\n\tTYPE=gsl_rng_default;\r\n\tran=gsl_rng_alloc(TYPE);\r\n\tgsl_rng_set(ran,RS);\r\n\t\r\n\ttmparr=malloc(sizeof(int)*N);\r\n\tnz=malloc(sizeof(int)*N);\r\n\t\r\n\tdeg=malloc(sizeof(int)*N);\r\n\tknn=malloc(sizeof(double)*N);\r\n\tcc=malloc(sizeof(double)*N);\r\n\t\r\n\tnb=malloc(sizeof(int*)*N);\r\n\tfor (i=0;i=nzsize){\r\n\t\t\t\tfor (i=0;i0)knn[i]/=deg[i];\r\n\t\t\t\t}\r\n\t\t\t\t\r\n\t\t\t\t//cc\r\n\t\t\t\tccav=0.0;\r\n\t\t\t\tfor (i=0;i1)cc[i]=2.0*tmp/(deg[i]*(deg[i]-1));\r\n\t\t\t\t\telse cc[i]=0.0;\r\n\t\t\t\t\t\r\n\t\t\t\t\tccav+=cc[i];\r\n\t\t\t\t}\r\n\t\t\t\tccav/=(t+1);\r\n\t\t\t\t\r\n\t\t\t\tsprintf(filename,\"id-deg-knn-cc_t%d_trial%d.txt\",t+1,m);\r\n\t\t\t\tfp=fopen(filename,\"w\");\r\n\t\t\t\tfor (i=0;i\n\n#include \n#include \n#include \n\n#include \"qdm.h\"\n\n#define TAU_RESET_L_SIZE 11\n#define TAU_RESET_M_SIZE 8\n#define TAU_RESET_H_SIZE 11\n#define TAU_RESET_SIZE (TAU_RESET_L_SIZE + TAU_RESET_M_SIZE + TAU_RESET_H_SIZE)\n\n#define TAU_RESET_STEP 0.0001\n#define TAU_RESET_GAP 0.001\n\n#define TAU_TABLE_SIZE 1048576\n\n#define TAU_INITIAL_GUESS 0.5\n#define TAU_EPS 0.001\n#define TAU_ITERATION_MAX 1000\n\nstatic\nvoid\nqdm_tau_reset_setup(\n qdm_tau *t\n)\n{\n t->reset = gsl_vector_alloc(TAU_RESET_SIZE);\n\n size_t offset = 0;\n\n gsl_vector_view view;\n\n view = gsl_vector_subvector(t->reset, offset, TAU_RESET_L_SIZE);\n qdm_vector_set_seq(&view.vector, t->low, t->low + (TAU_RESET_L_SIZE - 1) * TAU_RESET_STEP);\n offset += TAU_RESET_L_SIZE;\n\n view = gsl_vector_subvector(t->reset, offset, TAU_RESET_M_SIZE);\n qdm_vector_set_seq(&view.vector, t->low + TAU_RESET_GAP, t->high - TAU_RESET_GAP);\n offset += TAU_RESET_M_SIZE;\n\n view = gsl_vector_subvector(t->reset, offset, TAU_RESET_H_SIZE);\n qdm_vector_set_seq(&view.vector, t->high - (TAU_RESET_H_SIZE - 1) * TAU_RESET_STEP, t->high);\n offset += TAU_RESET_H_SIZE;\n}\n\nstatic\nvoid\nqdm_tau_table_setup(\n qdm_tau *t\n)\n{\n if (!t->use_table) {\n t->ispline_table = NULL;\n t->mspline_table = NULL;\n\n return;\n }\n\n t->ispline_table = gsl_matrix_alloc(TAU_TABLE_SIZE, (t->knots->size - t->spline_df) + 1);\n t->mspline_table = gsl_matrix_alloc(TAU_TABLE_SIZE, (t->knots->size - t->spline_df) + 1);\n\n double tau = 0;\n gsl_vector_view row;\n for (size_t i = 0; i < TAU_TABLE_SIZE; i++) {\n tau = (double)(i) / TAU_TABLE_SIZE;\n\n row = gsl_matrix_row(t->ispline_table, i);\n qdm_ispline_vector(\n &row.vector,\n tau,\n t->spline_df,\n t->knots\n );\n\n row = gsl_matrix_row(t->mspline_table, i);\n qdm_mspline_vector(\n &row.vector,\n tau,\n t->spline_df,\n t->knots\n );\n }\n}\n\nqdm_tau *\nqdm_tau_alloc(\n int use_table,\n\n double low,\n double high,\n\n size_t spline_df,\n const gsl_vector *knots\n)\n{\n qdm_tau *t = malloc(sizeof(qdm_tau));\n\n if (use_table == 1) {\n t->use_table = true;\n } else {\n t->use_table = false;\n }\n\n t->low = low;\n t->high = high;\n\n t->spline_df = spline_df;\n t->knots = qdm_vector_copy(knots);\n\n qdm_tau_reset_setup(t);\n qdm_tau_table_setup(t);\n\n return t;\n}\n\nvoid\nqdm_tau_free(\n qdm_tau *t\n)\n{\n if (t == NULL) {\n return;\n }\n\n t->use_table = 0;\n\n t->low = 0;\n t->high = 0;\n \n t->spline_df = 0;\n t->knots = NULL;\n\n gsl_vector_free(t->reset);\n t->reset = NULL;\n\n gsl_matrix_free(t->ispline_table);\n t->ispline_table = NULL;\n\n gsl_matrix_free(t->mspline_table);\n t->mspline_table = NULL;\n\n free(t);\n}\n\ndouble\nqdm_tau_ispline_mmm(\n const qdm_tau *t,\n const double value,\n const gsl_vector *mmm\n)\n{\n double result = 0;\n\n if (t->use_table) {\n size_t i = (size_t)fmin(floor(value * TAU_TABLE_SIZE), TAU_TABLE_SIZE - 1);\n gsl_vector_view ispline = gsl_matrix_row(t->ispline_table, i);\n\n gsl_blas_ddot(&ispline.vector, mmm, &result);\n } else {\n size_t m = (t->knots->size - t->spline_df) + 1;\n double ispline_data[m];\n gsl_vector_view ispline = gsl_vector_view_array(ispline_data, m);\n\n qdm_ispline_vector(&ispline.vector, value, t->spline_df, t->knots);\n gsl_blas_ddot(&ispline.vector, mmm, &result);\n }\n\n return result;\n}\n\ndouble\nqdm_tau_mspline_mmm(\n const qdm_tau *t,\n const double value,\n const gsl_vector *mmm\n)\n{\n double result = 0;\n\n if (t->use_table) {\n size_t i = (size_t)fmin(floor(value * TAU_TABLE_SIZE), TAU_TABLE_SIZE - 1);\n gsl_vector_view mspline = gsl_matrix_row(t->mspline_table, i);\n\n gsl_blas_ddot(&mspline.vector, mmm, &result);\n } else {\n size_t m = (t->knots->size - t->spline_df) + 1;\n double mspline_data[m];\n gsl_vector_view mspline = gsl_vector_view_array(mspline_data, m);\n\n qdm_mspline_vector(&mspline.vector, value, t->spline_df, t->knots);\n gsl_blas_ddot(&mspline.vector, mmm, &result);\n }\n\n return result;\n}\n\ndouble\nqdm_tau_find(\n const qdm_tau *t,\n const double v,\n const gsl_vector *mmm\n)\n{\n double tau = TAU_INITIAL_GUESS;\n double qi_u = 0;\n double qm_u = 0;\n\n size_t reset_i = 0;\n for (size_t i = 0; i < TAU_ITERATION_MAX; i++) {\n if (reset_i >= t->reset->size) {\n tau = TAU_INITIAL_GUESS;\n\n break;\n }\n\n /* Calculate position... */\n qi_u = qdm_tau_ispline_mmm(t, tau, mmm);\n\n /* Calculate slope... */\n qm_u = qdm_tau_mspline_mmm(t, tau, mmm);\n\n /* Check if the update is within our desired interval [0, 1]. */\n double update = tau - (qi_u - v) / qm_u;\n if (update < 0 || update > 1) {\n tau = gsl_vector_get(t->reset, reset_i);\n reset_i++;\n\n continue;\n } else {\n tau = update;\n }\n\n if (fabs(qi_u - v) <= TAU_EPS) {\n break;\n }\n }\n\n return tau;\n}\n", "meta": {"hexsha": "509c910cee385e795d77e375cf5234b41310b31d", "size": 4888, "ext": "c", "lang": "C", "max_stars_repo_path": "src/tau.c", "max_stars_repo_name": "calebcase/qdm", "max_stars_repo_head_hexsha": "2ee95bec6c8be64f69e231c78f2be5fce3509c67", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/tau.c", "max_issues_repo_name": "calebcase/qdm", "max_issues_repo_head_hexsha": "2ee95bec6c8be64f69e231c78f2be5fce3509c67", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 3.0, "max_issues_repo_issues_event_min_datetime": "2020-03-06T18:09:06.000Z", "max_issues_repo_issues_event_max_datetime": "2020-03-22T20:22:53.000Z", "max_forks_repo_path": "src/tau.c", "max_forks_repo_name": "calebcase/qdm", "max_forks_repo_head_hexsha": "2ee95bec6c8be64f69e231c78f2be5fce3509c67", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 20.1983471074, "max_line_length": 95, "alphanum_fraction": 0.6499590835, "num_tokens": 1608, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7745833737577157, "lm_q2_score": 0.6723317123102956, "lm_q1q2_score": 0.5207769660056107}} {"text": "/*\n NAME:\n minmax\n PURPOSE:\n returns the (finite) minimum and the maximum of a vector which is the row/column of a matrix\n CALLING SEQUENCE:\n minmax(gsl_matrix * q, int row, bool isrow, double * min, double * max, bool partial, int partial_indx[3])\n INPUT:\n q - matrix which holds the vector\n row - row/column which holds the vector\n isrow - is it the row or is it the column\n OUTPUT:\n min - finite minimum\n max - finite maximum\n REVISION HISTORY:\n 2008-09-21 - Written Bovy\n*/\n#include \n#include \n#include \n#include \n\nvoid minmax(gsl_matrix * q, int row, bool isrow, double * min, \n\t double * max){\n *max = -DBL_MAX;\n *min = DBL_MAX;\n int dd;\n double temp;\n if (isrow) {\n for (dd = 0; dd != q->size2; ++dd){\n\ttemp = gsl_matrix_get(q,row,dd);\n\tif (temp > *max && bovy_isfin(temp))\n\t *max = temp;\n\tif (temp < *min && bovy_isfin(temp))\n\t *min = temp;\n }\n }\n else {\n for (dd = 0; dd != q->size1; ++dd){\n\ttemp = gsl_matrix_get(q,dd,row);\n\tif (temp > *max && bovy_isfin(temp))\n\t *max = temp;\n\tif (temp < *min && bovy_isfin(temp))\n\t *min = temp;\n }\n }\n\n\n\n return ;\n}\n", "meta": {"hexsha": "03f3052a9ba55ecacbbdcd110e3a83e1a642ff48", "size": 1225, "ext": "c", "lang": "C", "max_stars_repo_path": "src/minmax.c", "max_stars_repo_name": "HaifengWangNAOC/Learn-Bovy-Extreme-deconvolution", "max_stars_repo_head_hexsha": "bc6d58199b17cd5329d72f6af3c7ba7e6d2ae780", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 73.0, "max_stars_repo_stars_event_min_datetime": "2015-01-22T09:22:38.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-21T01:27:34.000Z", "max_issues_repo_path": "src/minmax.c", "max_issues_repo_name": "HaifengWangNAOC/Learn-Bovy-Extreme-deconvolution", "max_issues_repo_head_hexsha": "bc6d58199b17cd5329d72f6af3c7ba7e6d2ae780", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 24.0, "max_issues_repo_issues_event_min_datetime": "2015-01-07T01:42:22.000Z", "max_issues_repo_issues_event_max_datetime": "2021-11-19T01:01:22.000Z", "max_forks_repo_path": "src/minmax.c", "max_forks_repo_name": "HaifengWangNAOC/Learn-Bovy-Extreme-deconvolution", "max_forks_repo_head_hexsha": "bc6d58199b17cd5329d72f6af3c7ba7e6d2ae780", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 26.0, "max_forks_repo_forks_event_min_datetime": "2015-02-05T22:21:22.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-13T03:37:58.000Z", "avg_line_length": 23.5576923077, "max_line_length": 111, "alphanum_fraction": 0.5942857143, "num_tokens": 382, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7745833841649232, "lm_q2_score": 0.672331699179286, "lm_q1q2_score": 0.5207769628316445}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \"nn.h\"\n#ifdef __APPLE__\n#include \n#else\n#include \n#endif\n\n#define AVERAGE_FISHER 10\n\n/**\n * A function for generating random numbers according to a N(mu, sigma) Gaussian\n * distribution.\n */\ndouble randn (double mu, double sigma)\n{\n double U1, U2, W, mult;\n static double X1, X2;\n static int call = 0;\n\n if (call == 1) {\n call = !call;\n return (mu + sigma * (double) X2);\n }\n do {\n U1 = -1 + ((double) rand () / RAND_MAX) * 2;\n U2 = -1 + ((double) rand () / RAND_MAX) * 2;\n W = pow (U1, 2) + pow (U2, 2);\n } while (W >= 1 || W == 0);\n\n mult = sqrt ((-2 * log (W)) / W);\n X1 = U1 * mult;\n X2 = U2 * mult;\n\n call = !call;\n\n return (mu + sigma * (double) X1);\n}\n\n/**\n * Shorthand to generate normally distributed random numbers.\n */\ndouble rand_normal()\n{\n return randn(0.0, 1.0);\n}\n\n/**\n * @brief Shuffle the index array.\n */\nvoid shuffle_index(size_t num_pattern, size_t random_idx[num_pattern])\n{\n size_t p, np, op;\n for (p = 0; p < num_pattern; ++p) {\n random_idx[p] = p;\n }\n for (p = 0; p < num_pattern; ++p) {\n np = p + ((double)rand()/((double)RAND_MAX+1)) * (num_pattern - 1 - p);\n op = random_idx[p];\n random_idx[p] = random_idx[np];\n random_idx[np] = op;\n }\n}\n\n/**\n * This function fills the input and target vector with the list of training\n * examples from automaton.\n */\nvoid fill_input_target(size_t size, double* input, uint8_t* target,\n uint8_t* automaton, int offset, int states)\n{\n size_t index;\n int counter;\n int side = 2 * offset + 1;\n int num_input = states * (side * side - 1);\n uint8_t val;\n\n for (size_t i = 0; i < size; ++i) {\n for (size_t j = 0; j < size; ++j) {\n index = i * size + j;\n counter = 1;\n\n /* Add bias in the main vector */\n input[index * (num_input + 1)] = 1.0;\n\n for (int a = -offset; a < offset + 1; ++a) {\n for (int b = -offset; b < offset + 1; ++b) {\n if (a != 0 || b != 0) { /* Don't take index i,j */\n val = automaton[((i + a + size) % size) * size\n + ((j + b + size) % size)];\n for (uint8_t s = 0; s < states; ++s) {\n input[index * (num_input + 1) + counter] = (val == s) ? 1.: 0.;\n counter++;\n }\n }\n }\n }\n\n target[index] = automaton[i * size + j];\n }\n }\n}\n\nvoid init_weights(int num_hidden, int num_input, int num_output,\n double* delta_w_ih, double* weight_ih,\n double* delta_w_ho, double* weight_ho)\n{\n int i, j, k;\n /* Initialize weights input -> hidden */\n for (j = 0; j < num_hidden; ++j) {\n delta_w_ih[j] = 0.0;\n weight_ih[j] = 0.0;\n for (i = 1; i < num_input + 1; ++i) {\n delta_w_ih[i * num_hidden + j] = 0.0;\n weight_ih[i * num_hidden + j] = rand_normal() *\n sqrt(1 / (double)(num_input));\n }\n }\n\n /* Initialize weights hidden -> output */\n for (k = 0; k < num_output; ++k) {\n delta_w_ho[k] = 0.0;\n weight_ho[k] = 0.0;\n for (j = 1; j < num_hidden + 1; ++j) {\n delta_w_ho[j * num_output + k] = 0.0;\n weight_ho[j * num_output + k] = rand_normal() *\n sqrt(1 / (double)(num_hidden));\n }\n }\n}\n\nvoid forward(double* input, double* output,\n int num_hidden, int num_pattern,\n int num_input, int num_output,\n double* hidden,\n double* hidden_bias,\n double* weight_ih,\n double* weight_ho)\n{\n int j, k, p;\n double max_out, agg_out = 0.0;\n\n /* Compute hidden activations */\n cblas_dgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans,\n num_pattern, num_hidden, num_input + 1, 1.0,\n input, num_input + 1, weight_ih, num_hidden,\n 0.0, hidden, num_hidden);\n\n /* ReLU non-linearity */\n for (p = 0; p < num_pattern; ++p) {\n hidden_bias[p * (num_hidden + 1)] = 1.0;\n for (j = 1; j < num_hidden + 1; ++j) {\n hidden_bias[p * (num_hidden + 1) + j] =\n (hidden[p * num_hidden + j - 1] > 0.0) ?\n hidden[p * num_hidden + j - 1]: 0.0;\n }\n }\n\n /* Compute output unit activations */\n cblas_dgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans,\n num_pattern, num_output, num_hidden + 1, 1.0,\n hidden_bias, num_hidden + 1, weight_ho, num_output,\n 0.0, output, num_output);\n\n /* Compute softmax of output */\n for (p = 0; p < num_pattern; ++p) {\n max_out = output[p * num_output];\n for (k = 1; k < num_output; ++k) {\n if (output[p * num_output + k] > max_out) {\n max_out = output[p * num_output + k];\n }\n }\n agg_out = 0.0;\n for (k = 0; k < num_output; ++k) {\n output[p * num_output + k] = exp(output[p * num_output + k] - max_out);\n agg_out += output[p * num_output + k];\n }\n for (k = 0; k < num_output; ++k) {\n output[p * num_output + k] /= agg_out;\n }\n }\n}\n\nvoid update_weights(int num_input, int num_hidden, int num_output,\n double eta,\n double* batch_error, double reg, double alpha,\n double* weight_ih, double* delta_w_ih,\n double* delta_w_ih_prev,\n double* weight_ho, double* delta_w_ho,\n double* delta_w_ho_prev)\n{\n int i, j, k;\n /* Update weights with average gradient */\n for (i = 0; i < num_input + 1; ++i) {\n for (j = 0; j < num_hidden; ++j) {\n if (reg > 0.) {\n *batch_error += 0.5 * reg *\n weight_ih[i * num_hidden + j] * weight_ih[i * num_hidden + j] ;\n weight_ih[i * num_hidden + j] += (1 + alpha) *\n reg * weight_ih[i * num_hidden + j];\n }\n\n weight_ih[i * num_hidden + j] -= (1 + alpha) *\n (eta * delta_w_ih[i * num_hidden + j]);\n\n if (alpha > 0.) {\n weight_ih[i * num_hidden + j] += (-alpha) *\n delta_w_ih_prev[i * num_hidden + j];\n }\n }\n }\n for (j = 0; j < num_hidden + 1; ++j) {\n for (k = 0; k < num_output; ++k) {\n if (reg > 0.) {\n *batch_error += 0.5 * reg *\n weight_ho[j * num_output + k] * weight_ho[j * num_output + k];\n weight_ho[j * num_output + k] += (1 + alpha) *\n reg * weight_ho[j * num_output + k];\n }\n\n weight_ho[j * num_output + k] -= (1 + alpha) *\n (eta * delta_w_ho[j * num_output + k]);\n\n if (alpha > 0.) {\n weight_ho[j * num_output + k] += (-alpha) *\n delta_w_ho_prev[j * num_output + k];\n }\n }\n }\n}\n\nvoid compute_batch_gradients(int base_index, double alpha,\n int batch_size, int num_input, int num_output,\n int num_hidden, size_t* random_idx,\n double* output,\n uint8_t* target, double* delta_output,\n double* delta_w_ho, double* hidden_bias,\n double* weight_ho, double* delta_h,\n double* delta_w_ih, double* input,\n double* delta_w_ih_prev,\n double* delta_w_ho_prev,\n network_opts_t* opts)\n{\n int i, j, k, p;\n\n /* Gradient initialization (Nesterov momentum) */\n if (opts->optim_type == NESTEROV) {\n memcpy(delta_w_ih_prev, delta_w_ih,\n sizeof(double) * num_hidden * (num_input + 1));\n for (i = 0; i < num_input + 1; ++i) {\n for (j = 0; j < num_hidden; ++j) {\n delta_w_ih[i * num_hidden + j] *= alpha;\n }\n }\n\n memcpy(delta_w_ho_prev, delta_w_ho,\n sizeof(double) * num_output * (num_hidden + 1));\n for (j = 0; j < num_hidden + 1; ++j) {\n for (k = 0; k < num_output; ++k) {\n delta_w_ho[j * num_output + k] *= alpha;\n }\n }\n }\n\n for (int b = 0; b < batch_size; ++b) {\n p = random_idx[(base_index + b)];\n\n /* Backpropagation */\n for (k = 0; k < num_output; ++k) {\n /* Output gradients */\n delta_output[b * num_output + k] =\n (output[b * num_output + k] - ((k == target[p])? 1.0: 0.0));\n delta_output[b * num_output + k] /= (double) batch_size;\n }\n }\n\n /* Dot product hidden_bias x delta_output stored in delta_w_ho */\n cblas_dgemm(CblasRowMajor, CblasTrans, CblasNoTrans,\n num_hidden + 1, num_output, batch_size,\n 1 , hidden_bias, num_hidden + 1,\n delta_output, num_output,\n (opts->optim_type == NESTEROV)? 1.0: 0.0,\n delta_w_ho, num_output);\n\n /* Dot product weight_ho x delta_output (we don't count the bias in\n weight_ho) stored in delta_h */\n cblas_dgemm(CblasRowMajor, CblasNoTrans, CblasTrans,\n batch_size, num_hidden, num_output,\n 1.0, delta_output, num_output,\n &weight_ho[num_output], num_output,\n 0.0, delta_h, num_hidden);\n\n /* Hidden layer non linearity gradients */\n for (int b = 0; b < batch_size; ++b) {\n for (j = 0; j < num_hidden; ++j) {\n delta_h[b * num_hidden + j] *=\n ((hidden_bias[b * (num_hidden + 1) + j + 1] > 0) ? 1.0: 0.0);\n }\n }\n\n cblas_dgemm(CblasRowMajor, CblasTrans, CblasNoTrans,\n num_input + 1, num_hidden, batch_size,\n 1 , input, num_input + 1,\n delta_h, num_hidden,\n (opts->optim_type == NESTEROV)? 1.0: 0.0,\n delta_w_ih, num_hidden);\n\n}\n\ndouble compute_loss(int base_index, int batch_size,\n size_t* random_idx,\n int num_output, double* output,\n uint8_t* target)\n{\n double batch_error = 0.0;\n int p;\n for (int b = 0; b < batch_size; ++b) {\n p = random_idx[(base_index + b)];\n /* Compute loss */\n batch_error +=\n - log((output[b * num_output + target[p]] > 0) ?\n output[b * num_output + target[p]]: DBL_MIN);\n }\n batch_error /= (double) batch_size;\n return batch_error;\n}\n\n\ndouble compute_fisher(int states, int neighbors,\n int num_pattern, int num_output,\n int num_hidden, int num_input,\n double* input,\n double* weight_ih, double* weight_ho)\n{\n double fisher_information = 0.0;\n int base, index, delta;\n\n /* Build the secondary input that will be perturbed */\n double* perturbed_input =\n (double*) malloc(sizeof(double) * num_pattern * (num_input + 1));\n\n /* Allocate placeholders in the function to make it more\n adaptable to the input dataset. */\n double* output =\n (double*) malloc(sizeof(double) * num_pattern * num_output);\n double* output_pert =\n (double*) malloc(sizeof(double) * num_pattern * num_output);\n double* hidden =\n (double*) malloc(sizeof(double) * num_pattern * num_hidden);\n double* hidden_bias =\n (double*) malloc(sizeof(double) * num_pattern * (num_hidden + 1));\n\n /* Compute the output of the network on the base dataset */\n forward(input, output, num_hidden, num_pattern, num_input, num_output,\n hidden, hidden_bias, weight_ih, weight_ho);\n\n for (int n = 0; n < AVERAGE_FISHER; ++n) {\n for (int neighbor_n = 0; neighbor_n < neighbors; ++neighbor_n) {\n\n /* Perturb second input */\n memcpy(perturbed_input, input,\n sizeof(double) * num_pattern * (num_input + 1));\n for (int i = 0; i < num_pattern; ++i) {\n /* Choose index of the input cell to perturb */\n index = i * (num_input + 1) + neighbor_n * states;\n\n for (int t = 0; t < states; ++t) {\n base = 1 + (rand() % (states - 1));\n perturbed_input[index + ((base + t) % states)] =\n input[index + t];\n }\n }\n /* Compute the output of the network on the perturbed dataset */\n forward(perturbed_input, output_pert, num_hidden, num_pattern,\n num_input, num_output, hidden, hidden_bias, weight_ih, weight_ho);\n\n for (int i = 0; i < num_pattern; ++i) {\n for (int j = 0; j < num_output; ++j) {\n if (output_pert[i * num_output + j] > 0\n && output[i * num_output + j] > 0) {\n delta = log(output[i * num_output + j]\n / output_pert[i * num_output + j]);\n fisher_information += output[i * num_output + j]\n * delta * delta;\n }\n }\n }\n\n }\n }\n\n free(output);\n free(hidden);\n free(hidden_bias);\n free(perturbed_input);\n free(output_pert);\n\n return fisher_information / (AVERAGE_FISHER * num_pattern);\n}\n\ndouble compute_error(int num_pattern, int num_output,\n int num_hidden, int num_input,\n double* input, uint8_t* target,\n double* weight_ih, double* weight_ho)\n{\n double test_error = 0.0;\n double val;\n\n /* Allocate placeholders in the function to make it more\n adaptable to the input dataset. */\n double* output =\n (double*) malloc(sizeof(double) * num_pattern * num_output);\n double* hidden =\n (double*) malloc(sizeof(double) * num_pattern * num_hidden);\n double* hidden_bias =\n (double*) malloc(sizeof(double) * num_pattern * (num_hidden + 1));\n\n /* Compute the output of the network */\n forward(input, output, num_hidden, num_pattern, num_input, num_output,\n hidden, hidden_bias, weight_ih, weight_ho);\n\n /* Compute loss */\n for (int p = 0; p < num_pattern; ++p) {\n val = output[p * num_output + target[p]];\n test_error += - log((val > 0) ? val: DBL_MIN);\n }\n test_error /= num_pattern;\n\n free(output);\n free(hidden);\n free(hidden_bias);\n\n return test_error;\n}\n\nvoid train_nn_on_automaton(size_t size, int states,\n uint8_t* train_automaton,\n uint8_t** test_automata,\n int n_tests,\n network_opts_t* opts,\n network_result_t* res)\n{\n if (opts->verbosity >= 1) {\n fprintf(stdout, \"\\nProcessing with options: h%i r%i e%i\\n\",\n opts->num_hid, opts->offset, opts->max_epoch);\n }\n\n size_t num_pattern = size * size;\n int side = 2 * opts->offset + 1;\n int num_input = states * (side * side - 1);\n int num_hidden = opts->num_hid;\n int num_output = states;\n\n double batch_error, error, eta = 1, alpha = 0.9;\n if (opts->optim_type != NESTEROV) {\n alpha = 0.;\n }\n\n const int batch_size = 8;\n /* Regression parameter */\n double reg = 0.;\n\n /* ====== Network and training variables declaration ====== */\n\n /* num_pattern x (num_input + 1) array that holds all the training set */\n double* base_input =\n (double *) malloc(num_pattern * (num_input + 1) * sizeof(double));\n /* Array that holds the training labels */\n uint8_t* target = (uint8_t *) malloc(num_pattern * sizeof(uint8_t));\n /* Fill those arrays with the automaton's content */\n fill_input_target(size, base_input, target,\n train_automaton, opts->offset, states);\n\n /* Arrays for the test data */\n double* test_input =\n (double *) malloc(num_pattern * (num_input + 1) * sizeof(double));\n uint8_t* test_target = (uint8_t *) malloc(num_pattern * sizeof(uint8_t));\n\n /* Weights of the network */\n double weight_ih[(num_input + 1) * num_hidden];\n double weight_ho[(num_hidden + 1) * num_output];\n\n /* Gradients of the output and hidden layer placeholders */\n double delta_output[batch_size * num_output];\n double delta_h[batch_size * num_hidden];\n\n /* Weight gradients and previous gradients for Nesterov momentum */\n double delta_w_ih[(num_input + 1) * num_hidden];\n double delta_w_ho[(num_input + 1) * num_hidden];\n double* delta_w_ih_prev = NULL;\n double* delta_w_ho_prev = NULL;\n\n /* Allocate only if being used later */\n if (opts->optim_type == NESTEROV) {\n delta_w_ih_prev = malloc(sizeof(double) * (num_input + 1) * num_hidden);\n delta_w_ho_prev = malloc(sizeof(double) * (num_hidden + 1) * num_output);\n }\n\n /* Allocate the arrays that will hold data for each batch */\n double input[(batch_size) * (num_input + 1)];\n double hidden[batch_size * num_hidden];\n double hidden_bias[batch_size * (num_hidden + 1)];\n double output[batch_size * num_output];\n\n int epoch;\n size_t random_idx[num_pattern];\n double test_error = 0.0;\n double test_var = 0.0;\n\n /* ===================== End declarations ====================== */\n\n /* Initialize the weights of the network */\n init_weights(num_hidden, num_input, num_output,\n delta_w_ih, weight_ih,\n delta_w_ho, weight_ho);\n\n for (epoch = 0; epoch < opts->max_epoch; ++epoch) {\n /* Initialize error */\n error = 0.0;\n\n /* Learning rate decay */\n if (epoch > 0 && epoch%10 == 0 && opts->decay == DECAY) {\n eta -= .5 * eta;\n }\n\n /* Random ordering of input patterns done at each epoch */\n shuffle_index(num_pattern, random_idx);\n\n /* Loop through every batch in the dataset */\n for (size_t s = 0; s < num_pattern; s += batch_size) {\n for (int b = 0; b < batch_size; ++b) {\n if (s + b >= num_pattern) {\n break;\n }\n /* Copy batch elements to the input array for processing */\n memcpy(input + b * (num_input + 1),\n base_input + (random_idx[(s + b)] *\n (num_input + 1)),\n sizeof(double) * (num_input + 1));\n }\n\n /* Forward pass */\n forward(input, output, num_hidden, batch_size, num_input, num_output,\n hidden, hidden_bias, weight_ih, weight_ho);\n\n batch_error = compute_loss(s, batch_size, random_idx, num_output,\n output, target);\n\n /* Compute the gradients for each weight matrix */\n compute_batch_gradients(s, alpha, batch_size, num_input, num_output,\n num_hidden,\n random_idx, output, target,\n delta_output, delta_w_ho, hidden_bias, weight_ho,\n delta_h, delta_w_ih, input,\n delta_w_ih_prev, delta_w_ho_prev, opts);\n\n /* Update the weights of the network */\n update_weights(num_input, num_hidden, num_output, eta, &batch_error, reg,\n alpha, weight_ih, delta_w_ih, delta_w_ih_prev, weight_ho,\n delta_w_ho, delta_w_ho_prev);\n\n /* Error is only updated here because it might have been changed by\n `update_weights` */\n error += batch_error * batch_size;\n }\n error /= (double)(num_pattern);\n\n if (opts-> verbosity >= 1 && epoch%5 == 0) {\n fprintf(stdout, \"\\nEpoch %d: Error = %f\", epoch, error);\n }\n }\n\n /* Compute error on the training set */\n error = compute_error(num_pattern, num_output, num_hidden,\n num_input, base_input, target,\n weight_ih, weight_ho);\n\n if (opts->verbosity >= 1) {\n fprintf(stdout, \"\\nTrain error: %f\", error);\n }\n\n /* Compute Fisher information if the flag requires it */\n if (opts->fisher == FISHER) {\n res->fisher_info = compute_fisher(states, (side*side - 1), num_pattern,\n num_output, num_hidden, num_input,\n base_input, weight_ih, weight_ho);\n }\n\n /* Was an array of states to test on provided ? */\n if (test_automata != NULL) {\n double test_errors[n_tests];\n for (int i = 0; i < n_tests; ++i) {\n /* Fill the placeholders with test data */\n fill_input_target(size, test_input, test_target,\n test_automata[i], opts->offset, states);\n\n /* Compute error on the test set */\n test_errors[i] = compute_error(num_pattern, num_output, num_hidden,\n num_input, test_input, test_target,\n weight_ih, weight_ho);\n test_error += error / test_errors[i];\n }\n\n /* Average score across all tested states */\n test_error /= n_tests;\n\n /* Compute variance of scores */\n for (int i = 0; i < n_tests; ++i) {\n test_var += (error / test_errors[i] - test_error)\n * (error / test_errors[i] - test_error);\n }\n test_var /= n_tests;\n test_var = sqrt(test_var);\n\n if (opts->verbosity >= 1) {\n fprintf(stdout, \"\\tTest error: %f\\tVar: %f\\tRatio: %f\",\n error / test_error, test_var, test_error);\n }\n }\n\n /* Log results */\n if (opts->verbosity >= 1 && opts->fisher== FISHER) {\n fprintf(stdout, \"\\tFisher: %f\\n\", res->fisher_info);\n } else if (opts->verbosity >= 1){\n fprintf(stdout, \"\\n\");\n }\n\n /* Output data */\n res->train_error = error;\n res->test_error = error / test_error;\n res->error_var = test_var;\n\n /* Cleanup allocated arrays */\n free(target);\n free(base_input);\n free(test_input);\n free(test_target);\n free(delta_w_ih_prev);\n free(delta_w_ho_prev);\n}\n", "meta": {"hexsha": "5ca10152159a91c3981587801bea7f96410044ee", "size": 20788, "ext": "c", "lang": "C", "max_stars_repo_path": "src/nn/nn.c", "max_stars_repo_name": "smearle/evolving-structures-in-complex-systems", "max_stars_repo_head_hexsha": "7e877c917f83bdd5032959205564ca06928b1a6c", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-07-12T05:38:21.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-12T05:38:21.000Z", "max_issues_repo_path": "src/nn/nn.c", "max_issues_repo_name": "smearle/evolving-structures-in-complex-systems", "max_issues_repo_head_hexsha": "7e877c917f83bdd5032959205564ca06928b1a6c", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/nn/nn.c", "max_forks_repo_name": "smearle/evolving-structures-in-complex-systems", "max_forks_repo_head_hexsha": "7e877c917f83bdd5032959205564ca06928b1a6c", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.2294573643, "max_line_length": 80, "alphanum_fraction": 0.5625841832, "num_tokens": 5759, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8128673087708698, "lm_q2_score": 0.640635868562172, "lm_q1q2_score": 0.5207519543802215}} {"text": "/// @file mlr.h\n/// @brief multiple linear regression support\n/// @author Jeff Perry \n/// @version 1.0\n/// @date 2013-06-13\n\n#ifndef MLR_H\n#define MLR_H\n\n#include \"raster_utils.h\"\n//#include \n\nnamespace horny_toad\n{\n\n /// @brief helper function\n template\n T matrix_multiply (const T &a, const T &b)\n {\n assert (a.cols () == b.rows ());\n const size_t N = a.rows ();\n const size_t M = a.cols ();\n const size_t P = b.cols ();\n T y (a.rows (), b.cols ());\n for (size_t i = 0; i < N; ++i)\n for (size_t j = 0; j < P; ++j)\n for (size_t k = 0; k < M; ++k)\n y (i, j) += a (i, k) * b (k, j);\n return y;\n }\n\n /// @brief multiple linear regression\n ///\n /// @tparam T matrix types\n /// @param y responses\n /// @param x predictors\n ///\n /// @return linear estimates of y=b*x\n template\n T mlr_inverse (const T &y, const T &x)\n {\n // add a column of 1's to x on the left\n T xx (x.rows (), x.cols () + 1);\n for (size_t i = 0; i < x.rows (); ++i)\n {\n xx (i, 0) = 1;\n for (size_t j = 0; j < x.cols (); ++j)\n {\n xx (i, j + 1) = x (i, j);\n }\n }\n // b = (x^T * x)^-1 * x^T * y\n T xt = transpose (xx);\n T tmp = matrix_multiply (xt, xx);\n tmp = invert (tmp);\n tmp = matrix_multiply (tmp, xt);\n tmp = matrix_multiply (tmp, y);\n return tmp;\n }\n\n /// @brief multiple linear regression\n ///\n /// @tparam T matrix types\n /// @param y responses\n /// @param x predictors\n ///\n /// @return linear estimates of y=b*x\n /*\n template\n T mlr_lapack (const T &y, const T &x)\n {\n assert (x.cols () <= x.rows ());\n assert (y.rows () == x.rows ());\n // result gets stored in b\n T b (y);\n // add a column of 1's to x on the left\n T xx (x.rows (), x.cols () + 1);\n for (size_t i = 0; i < x.rows (); ++i)\n {\n xx (i, 0) = 1;\n for (size_t j = 0; j < x.cols (); ++j)\n {\n xx (i, j + 1) = x (i, j);\n }\n }\n const size_t M = xx.rows ();\n const size_t N = xx.cols ();\n // solve it\n if (LAPACKE_dgels (LAPACK_ROW_MAJOR, 'N', M, N, 1, &xx[0], N, &b[0], 1) != 0)\n throw std::runtime_error (\"LAPACK error: can't solve mlr\");\n // copy result into matrix with correct dimensions\n T z (xx.cols (), 1);\n for (size_t i = 0; i < z.rows (); ++i)\n z[i] = b[i];\n return z;\n }\n */\n\n /// @brief multiple linear regression\n ///\n /// @tparam T matrix types\n /// @param y responses\n /// @param x predictors\n ///\n /// @return linear estimates of y=b*x\n template\n T mlr (const T &y, const T &x)\n {\n return mlr_inverse (y, x);\n //return mlr_lapack (y, x);\n }\n} // namespace horny_toad\n\n#endif // MLR_H\n", "meta": {"hexsha": "0d2e937d74aa91ff78d2aec8edf9d03677cdf442", "size": 3078, "ext": "h", "lang": "C", "max_stars_repo_path": "jsp/rcm_denoising/horny_toad/mlr.h", "max_stars_repo_name": "jeffsp/kaggle_denoising", "max_stars_repo_head_hexsha": "ad0e86a34c8c0c98c95e3ec3fe791a6b75154a27", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2015-06-04T14:34:01.000Z", "max_stars_repo_stars_event_max_datetime": "2015-06-04T14:34:01.000Z", "max_issues_repo_path": "jsp/rcm_denoising/horny_toad/mlr.h", "max_issues_repo_name": "jeffsp/kaggle_denoising", "max_issues_repo_head_hexsha": "ad0e86a34c8c0c98c95e3ec3fe791a6b75154a27", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "jsp/rcm_denoising/horny_toad/mlr.h", "max_forks_repo_name": "jeffsp/kaggle_denoising", "max_forks_repo_head_hexsha": "ad0e86a34c8c0c98c95e3ec3fe791a6b75154a27", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.7652173913, "max_line_length": 85, "alphanum_fraction": 0.4623131904, "num_tokens": 927, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8267118111485244, "lm_q2_score": 0.6297745935070806, "lm_q1q2_score": 0.5206420948135644}} {"text": "#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n\nint vector_float_convolve(int cs, const float* c, int as, const float* a, int rs, float* r)\n{\n int h = cs / 2;\n int li, ri;\n int i,j;\n\n for (i = 0; i < cs; i++) {\n li = i - h;\n ri = i + h;\n r[i] = 0;\n for (j = (li >= 0 ? li : 0); j < (ri < as ? ri : (as - 1)); j++) {\n r[i] += a[j]*c[j+h+1];\n }\n }\n return 0;\n}\n\nint vector_double_convolve(int cs, const double* c, int as, const double* a, int rs, double* r)\n{\n int h = cs / 2;\n int li, ri;\n int i,j;\n\n for (i = 0; i < cs; i++) {\n li = i - h;\n ri = i + h;\n r[i] = 0;\n for (j = (li >= 0 ? li : 0); j < (ri < as ? ri : (as - 1)); j++) {\n r[i] += a[j]*c[j+h+1];\n }\n }\n return 0;\n}\n\nint vector_complex_convolve(int cs, const gsl_complex* c, int as, const gsl_complex* a, int rs, gsl_complex* r)\n{\n int h = cs / 2;\n int li, ri;\n int i,j;\n\n for (i = 0; i < cs; i++) {\n li = i - h;\n ri = i + h;\n r[i].dat[0] = 0;\n r[i].dat[1] = 0;\n for (j = (li >= 0 ? li : 0); j < (ri < as ? ri : (as - 1)); j++) {\n r[i].dat[0] += a[j].dat[0]*c[j+h+1].dat[0]-a[j].dat[1]*c[j+h+1].dat[1];\n r[i].dat[1] += a[j].dat[0]*c[j+h+1].dat[1]+a[j].dat[1]*c[j+h+1].dat[0];\n }\n }\n return 0;\n}\n\nint filter_double(int ls, const double* l, int ks, const double* k, int vs, const double* v, int rs, double* r)\n{\n if (ls > vs || ks > vs) return 2000; // BAD_SIZE\n\n int i,j;\n\n double L = l[0];\n double K = k[0];\n \n int N = ls - 1;\n int M = ks - 1;\n\n for (i = 0; i < vs; i++) {\n r[i] = 0;\n for (j = 0; j < N; j++) {\n if (i - j > 0) r[i] -= (l[j+1])*v[i-j];\n }\n for (j = 0; j < M; j++) {\n if (i - j > 0) r[i] += (k[j+1])*r[i-j];\n }\n }\n return 0;\n}\n\nint filter_float(int ls, const float* l, int ks, const float* k, int vs, const float* v, int rs, float* r)\n{\n if (ls > vs || ks > vs) return 2000; // BAD_SIZE\n\n int i,j;\n\n float L = l[0];\n float K = k[0];\n \n int N = ls - 1;\n int M = ks - 1;\n\n for (i = 0; i < vs; i++) {\n r[i] = 0;\n for (j = 0; j < N; j++) {\n if (i - j > 0) r[i] -= (l[j+1])*v[i-j];\n }\n for (j = 0; j < M; j++) {\n if (i - j > 0) r[i] += (k[j+1])*r[i-j];\n }\n }\n return 0;\n}\n\nint hilbert(int rs, gsl_complex* r)\n{\n int s = rs;\n\n gsl_fft_complex_wavetable * wavetable = gsl_fft_complex_wavetable_alloc (s);\n gsl_fft_complex_workspace * workspace = gsl_fft_complex_workspace_alloc (s);\n\n // forward fourier transform\n gsl_fft_complex_forward ((double*)r, 1, s, wavetable, workspace);\n // zero negative coefficients and double positive\n\n int i;\n int m = s/2;\n for (i = 1; i < s; i++) {\n if (i <= m) {\n r[i].dat[0] *= 2;\n r[i].dat[1] *= 2;\n }\n else if (s % 2 == 0 && i == m+1) {\n }\n else {\n r[i].dat[0] = 0;\n r[i].dat[1] = 0;\n }\n }\n\n // inverse fourier transform\n gsl_fft_complex_inverse ((double*)r, 1, s, wavetable, workspace);\n\n gsl_fft_complex_wavetable_free (wavetable);\n gsl_fft_complex_workspace_free (workspace);\n\n return 0;\n}\n\nint pwelch(int w, int vs, const gsl_complex* v, int rs, double* r)\n{\n if (w > vs) return 2000; // BAD_SIZE\n\n int i,j;\n\n int fs = w;\n\n int num_windows = vs / fs; // ignore end\n\n double s[fs];\n for (i = 0; i < fs; i++) s[i] = 0;\n\n gsl_fft_complex_wavetable * wavetable = gsl_fft_complex_wavetable_alloc (fs);\n gsl_fft_complex_workspace * workspace = gsl_fft_complex_workspace_alloc (fs);\n\n gsl_complex* f = malloc(sizeof(gsl_complex)*fs);\n gsl_vector_view F = gsl_vector_view_array((double*)f, 2*fs);\n\n gsl_vector_view X;\n\n for (i = 0; i < num_windows; i++) {\n X = gsl_vector_view_array((double*)(&v[i*fs]), 2*fs); // v is gsl_complex*\n gsl_blas_dcopy(&X.vector,&F.vector);\n gsl_fft_complex_forward ((double*)f, 1, fs, wavetable, workspace);\n for (j = 0; j < fs; j++) s[j] += f[j].dat[0]*f[j].dat[0] + f[j].dat[1]*f[j].dat[1];\n }\n for (j = 0; j < rs; j++) {\n if (j == 0) r[j] = s[j];\n else if (j == (rs-1)) r[j] = s[j];\n else r[j] = s[j] + s[fs-j+1];\n \n r[j] /= num_windows;\n r[j] = sqrt(r[j]);\n }\n gsl_fft_complex_wavetable_free (wavetable);\n gsl_fft_complex_workspace_free (workspace);\n\n free(f);\n\n return 0;\n}\n\nint hamming_double(int rs, double* r)\n{\n int i;\n\n for (i = 0; i < rs; i++) r[i] = 0.54 - 0.46 * cos(2*M_PI*i/rs);\n\n return 0;\n}\n\nint hamming_float(int rs, float* r)\n{\n int i;\n\n for (i = 0; i < rs; i++) r[i] = 0.54 - 0.46 * cos(2*M_PI*i/rs);\n\n return 0;\n}\n\nint real_poly_complex_eval(int cs, const double* c, int zs, const gsl_complex* z, int rs, gsl_complex* r)\n{\n int i;\n \n for (i = 0; i < zs; i++)\n r[i] = gsl_poly_complex_eval(c,cs,z[i]);\n\n return 0;\n} \n\nint complex_power_double(int cs, const gsl_complex* c, int rs, double* r)\n{\n if (rs != cs) return 2000; // BAD_SIZE\n\n int i;\n\n for (i = 0; i < cs; i++)\n r[i] = c[i].dat[0]*c[i].dat[0] + c[i].dat[1]*c[i].dat[1];\n\n return 0;\n}\n\nint complex_power_float(int cs, const gsl_complex* c, int rs, float* r)\n{\n if (rs != cs) return 2000; // BAD_SIZE\n\n int i;\n\n for (i = 0; i < cs; i++)\n r[i] = c[i].dat[0]*c[i].dat[0] + c[i].dat[1]*c[i].dat[1];\n\n return 0;\n}\n\nint downsample_double(int n, int xs, const double* x, int rs, double* r)\n{\n if (rs != xs/n) return 2000; // BAD_SIZE\n \n int i;\n\n for (i = 0; i < rs; i++)\n r[i] = x[i*n];\n\n return 0;\n}\n\nint downsample_float(int n, int xs, const float* x, int rs, float* r)\n{\n if (rs != xs/n) return 2000; // BAD_SIZE\n \n int i;\n\n for (i = 0; i < rs; i++)\n r[i] = x[i*n];\n\n return 0;\n}\n\nint vector_diff_double(int xs, const double* x, int rs, double* r)\n{\n if (rs != xs - 1) return 2000; // BAD_SIZE\n\n int i;\n\n for (i = 0; i < rs; i++)\n r[i] = x[i+1] - x[i];\n\n return 0;\n}\n\nint vector_diff_float(int xs, const float* x, int rs, float* r)\n{\n if (rs != xs - 1) return 2000; // BAD_SIZE\n\n int i;\n\n for (i = 0; i < rs; i++)\n r[i] = x[i+1] - x[i];\n\n return 0;\n}\n\nint unwrap_double(int xs, const double* x, int rs, double* r)\n{\n if (rs != xs) return 2000; // BAD_SIZE\n\n int i;\n\n r[0] = x[0];\n\n double c = 0;\n\n int tmp;\n\n for (i = 1; i < rs; i++) {\n tmp = x[i-1] - x[i];\n if (tmp > M_PI) {\n r[i] = 2*M_PI;\n }\n else if (tmp < (-M_PI)) {\n r[i] = -2*M_PI;\n }\n else {\n r[i] = 0;\n }\n c += r[i];\n r[i] = c + x[i];\n }\n \n return 0;\n}\n\nint unwrap_float(int xs, const float* x, int rs, float* r)\n{\n if (rs != xs) return 2000; // BAD_SIZE\n\n int i;\n\n r[0] = x[0];\n\n double c = 0;\n\n int tmp;\n\n for (i = 1; i < rs; i++) {\n tmp = x[i-1] - x[i];\n if (tmp > M_PI) {\n r[i] = 2*M_PI;\n }\n else if (tmp < (-M_PI)) {\n r[i] = -2*M_PI;\n }\n else {\n r[i] = 0;\n }\n c += r[i];\n r[i] = c + x[i];\n }\n\n return 0;\n}\n\nint cross_covariance_double(int max_lag,\n\t\t\t double* sx,\n\t\t\t double* sy,\n\t\t\t int xs, const double* x,\n\t\t\t int ys, const double* y,\n\t\t\t int rs, double* r)\n{\n if (xs != ys) return 2000; // BAD_SIZE\n if (rs != 2*max_lag) return 2000; // BAD_SIZE\n\n double mx = gsl_stats_mean(x,1,xs);\n double my = gsl_stats_mean(y,1,ys);\n\n *sx = gsl_stats_sd(x,1,xs);\n *sy = gsl_stats_sd(y,1,ys);\n\n int delay;\n int i, j;\n\n double sxy;\n\n for (delay=-max_lag; delay < max_lag; delay++) {\n sxy = 0;\n for (i=0;i= xs) sxy += (x[i]-mx)*(-my);\n else sxy += (x[i]-mx)*(y[j]-my);\n /* or should it be:\n if (j < 0 || j >= xs) continue;\n else sxy += (x[i]-mx)*(y[j]-my);\n */\n }\n r[delay+max_lag] = sxy/xs;\n }\n\n return 0;\n}\n\nint cross_covariance_float(int max_lag,\n\t\t\t float* sx,\n\t\t\t float* sy,\n\t\t\t int xs, const float* x,\n\t\t\t int ys, const float* y,\n\t\t\t int rs, double* r)\n{\n if (xs != ys) return 2000; // BAD_SIZE\n if (rs != 2*max_lag) return 2000; // BAD_SIZE\n\n float mx = gsl_stats_float_mean(x,1,xs);\n float my = gsl_stats_float_mean(y,1,ys);\n\n *sx = gsl_stats_float_sd(x,1,xs);\n *sy = gsl_stats_float_sd(y,1,ys);\n\n int delay;\n int i, j;\n\n float sxy;\n\n for (delay=-max_lag; delay < max_lag; delay++) {\n sxy = 0;\n for (i=0;i= xs) sxy += (x[i]-mx)*(-my);\n else sxy += (x[i]-mx)*(y[j]-my);\n /* or should it be:\n if (j < 0 || j >= xs) continue;\n else sxy += (x[i]-mx)*(y[j]-my);\n */\n }\n r[delay+max_lag] = sxy/xs;\n }\n\n return 0;\n}\n\nint cum_sum_double(int xs, const double* x, int rs, double* r)\n{\n int i;\n\n r[0] = x[0];\n\n for (i=1;i\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\ndouble interpolate_maximum_function(double x, void *params);\ndouble interpolate_maximum_function(double x, void *params) {\n return (-interpolate((interp_info *)params, x));\n}\n\nvoid interpolate_maximum(interp_info *interp,\n double x_lo_in,\n double x_guess_in,\n double x_hi_in,\n double threshold,\n double * x_maxima,\n double * y_maxima) {\n double x_lo;\n double x_hi;\n double x_guess;\n double r_val;\n const gsl_min_fminimizer_type *T;\n gsl_min_fminimizer * s;\n gsl_function F;\n int status;\n int iter = 0;\n int max_iter;\n\n x_lo = x_lo_in;\n x_guess = x_guess_in;\n x_hi = x_hi_in;\n max_iter = GBP_MAX(100, interp->n);\n F.function = interpolate_maximum_function;\n F.params = (void *)interp;\n T = gsl_min_fminimizer_brent;\n s = gsl_min_fminimizer_alloc(T);\n gsl_min_fminimizer_set(s, &F, x_guess, x_lo, x_hi);\n\n do {\n iter++;\n status = gsl_min_fminimizer_iterate(s);\n x_lo = gsl_min_fminimizer_x_lower(s);\n x_guess = gsl_min_fminimizer_x_minimum(s);\n x_hi = gsl_min_fminimizer_x_upper(s);\n status = gsl_min_test_interval(x_lo, x_hi, 0., threshold);\n } while(status == GSL_CONTINUE && iter < max_iter);\n gsl_min_fminimizer_free(s);\n (*x_maxima) = x_guess;\n (*y_maxima) = interpolate(interp, x_guess);\n}\n", "meta": {"hexsha": "497710af990f089d6371f218f6e37365c4701f69", "size": 1956, "ext": "c", "lang": "C", "max_stars_repo_path": "src/gbpMath/gbpInterpolate/interpolate_maximum.c", "max_stars_repo_name": "gbpoole/gbpCode", "max_stars_repo_head_hexsha": "5157d2e377edbd4806258d1c16b329373186d43a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2015-10-20T11:39:53.000Z", "max_stars_repo_stars_event_max_datetime": "2015-10-20T11:39:53.000Z", "max_issues_repo_path": "src/gbpMath/gbpInterpolate/interpolate_maximum.c", "max_issues_repo_name": "gbpoole/gbpCode", "max_issues_repo_head_hexsha": "5157d2e377edbd4806258d1c16b329373186d43a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2017-07-30T11:10:49.000Z", "max_issues_repo_issues_event_max_datetime": "2019-06-18T00:40:46.000Z", "max_forks_repo_path": "src/gbpMath/gbpInterpolate/interpolate_maximum.c", "max_forks_repo_name": "gbpoole/gbpCode", "max_forks_repo_head_hexsha": "5157d2e377edbd4806258d1c16b329373186d43a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4.0, "max_forks_repo_forks_event_min_datetime": "2015-01-23T00:50:40.000Z", "max_forks_repo_forks_event_max_datetime": "2016-08-01T08:14:24.000Z", "avg_line_length": 34.9285714286, "max_line_length": 67, "alphanum_fraction": 0.536809816, "num_tokens": 458, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8311430520409024, "lm_q2_score": 0.6261241772283034, "lm_q1q2_score": 0.520398759618131}} {"text": "#include \n#include \"flow.h\"\n#include \"mesh.h\"\n\n#define DIM 2 /* Geometric dimension */\n#define NFIELDS 3\nstatic const FlowFieldDescriptor PhysicsFields[] = {{\"Density\", \"Den\",1},{\"Momentum\", \"Momentum\",DIM},{\"Energy\", \"Energy\",1},{NULL,0}};\ntypedef enum {EULER_PAR_GAMMA,EULER_PAR_RHOR,EULER_PAR_AMACH,EULER_PAR_ITANA,EULER_PAR_SIZE} EulerParamIdx;\n\ntypedef struct {\n PetscReal rho;\n PetscReal rhoU[DIM];\n PetscReal rhoE;\n} EulerNode;\ntypedef union {\n EulerNode eulernode;\n PetscReal vals[DIM+2];\n} EulerNodeUnion;\n\ntypedef struct {\n PetscReal gamma;\n PetscReal rhoL;\n PetscReal rhoR;\n PetscReal uL;\n PetscReal uR;\n PetscReal pL;\n PetscReal pR;\n PetscReal maxTime;\n PetscReal length;\n} Setup;\n\ntypedef struct {\n PetscReal pstar,ustar,rhostarL,astarL,SL,SHL,STL,rhostarR,astarR,SR,SHR,STR,gamm1,gamp1;\n} StarState;\n\ntypedef struct {\n StarState starState;\n Setup setup;\n PetscReal cfl;\n} ProblemSetup;\n\ntypedef struct{\n PetscReal f;\n PetscReal fprm;\n} PressureFunction;\n\nstatic PressureFunction f_and_fprm_rarefaction(PetscReal pstar, PetscReal pLR, PetscReal aLR, PetscReal gam, PetscReal gamm1,PetscReal gamp1) {\n // compute value of pressure function for rarefaction\n PressureFunction function;\n function.f = ((2. * aLR) / gamm1) * (pow(pstar / pLR, 0.5 * gamm1 / gam) - 1.);\n function.fprm = (aLR / pLR / gam) * pow(pstar / pLR, -0.5 * gamp1 / gam);\n return function;\n}\n\nstatic PressureFunction f_and_fprm_shock(PetscReal pstar, PetscReal pLR, PetscReal rhoLR, PetscReal gam, PetscReal gamm1, PetscReal gamp1){\n // compute value of pressure function for shock\n PetscReal A = 2./gamp1/rhoLR;\n PetscReal B = gamm1*pLR/gamp1;\n PetscReal sqrtterm = PetscSqrtReal(A/(pstar+B));\n PressureFunction function;\n function.f = (pstar-pLR)*sqrtterm;\n function.fprm = sqrtterm*(1.-0.5*(pstar-pLR)/(B+pstar));\n return function;\n}\n\n\n#define EPS 1.e-6\n#define MAXIT 100\nstatic PetscErrorCode DetermineStarState(const Setup* setup, StarState* starState){\n // compute the speed of sound\n PetscReal aL = PetscSqrtReal(setup->gamma*setup->pL/setup->rhoL);\n PetscReal aR = PetscSqrtReal(setup->gamma*setup->pR/setup->rhoR);\n\n //first guess pstar based on two-rarefacation approximation\n starState->pstar = aL+aR - 0.5*(setup->gamma-1.)*(setup->uR-setup->uL);\n starState->pstar = starState->pstar / (aL/pow(setup->pL,0.5*(setup->gamma-1.)/setup->gamma) + aR/pow(setup->pR,0.5*(setup->gamma-1.)/setup->gamma) );\n starState->pstar = pow(starState->pstar,2.*setup->gamma/(setup->gamma-1.));\n starState->gamm1 = setup->gamma-1.;\n starState->gamp1 = setup->gamma+1.;\n\n PressureFunction fL;\n if (starState->pstar <= setup->pL){\n fL = f_and_fprm_rarefaction(starState->pstar, setup->pL,aL,setup->gamma,starState->gamm1,starState->gamp1);\n }else{\n fL = f_and_fprm_shock(starState->pstar,setup->pL,setup->rhoL,setup->gamma,starState->gamm1,starState->gamp1);\n }\n\n PressureFunction fR;\n if (starState->pstar <= setup->pR) {\n fR = f_and_fprm_rarefaction(starState->pstar, setup->pR, aR, setup->gamma, starState->gamm1, starState->gamp1);\n }else {\n fR = f_and_fprm_shock(starState->pstar, setup->pR, setup->rhoR, setup->gamma, starState->gamm1, starState->gamp1);\n }\n PetscReal delu = setup->uR-setup->uL;\n\n // iterate using Newton-Rapson\n if ((fL.f+fR.f+delu)> EPS) {\n // iterate using Newton-Rapson\n for(PetscInt it =0; it < MAXIT+4; it++){\n PetscReal pold = starState->pstar;\n starState->pstar = pold - (fL.f+fR.f+delu)/(fL.fprm+fR.fprm);\n\n if(starState->pstar < 0){\n starState->pstar = EPS;\n }\n\n if(2.0*PetscAbsReal(starState->pstar - pold)/(starState->pstar + pold) < EPS){\n break;\n }else{\n if(starState->pstar < setup->pL){\n fL = f_and_fprm_rarefaction(starState->pstar, setup->pL,aL,setup->gamma,starState->gamm1,starState->gamp1);\n }else{\n fL = f_and_fprm_shock(starState->pstar,setup->pL,setup->rhoL,setup->gamma,starState->gamm1,starState->gamp1);\n }\n if (starState->pstar<=setup->pR) {\n fR = f_and_fprm_rarefaction(starState->pstar, setup->pR, aR, setup->gamma, starState->gamm1, starState->gamp1);\n }else {\n fR = f_and_fprm_shock(starState->pstar, setup->pR, setup->rhoR, setup->gamma, starState->gamm1, starState->gamp1);\n }\n }\n\n if (it>MAXIT){\n SETERRQ(PETSC_COMM_WORLD,1,\"error in Riemann.find_pstar - did not converage for pstar\" );\n }\n }\n }\n\n // determine rest of star state\n starState->ustar = 0.5*(setup->uL+setup->uR+fR.f-fL.f);\n\n // left star state\n PetscReal pratio = starState->pstar/setup->pL;\n if (starState->pstar<=setup->pL) { // rarefaction\n starState->rhostarL = setup->rhoL * PetscPowReal(pratio, 1. / setup->gamma);\n starState->astarL = aL * PetscPowReal(pratio, 0.5 * starState->gamm1 / setup->gamma);\n starState->SHL = setup->uL - aL;\n starState->STL = starState->ustar - starState->astarL;\n }else { // #shock\n starState->rhostarL = setup->rhoL * (pratio + starState->gamm1 / starState->gamp1) / (starState->gamm1 * pratio / starState->gamp1 + 1.);\n starState->SL = setup->uL - aL * PetscSqrtReal(0.5 * starState->gamp1 / setup->gamma * pratio + 0.5 * starState->gamm1 / setup->gamma);\n }\n\n // right star state\n pratio = starState->pstar/setup->pR;\n if (starState->pstar<=setup->pR) { // # rarefaction\n starState->rhostarR = setup->rhoR * PetscPowReal(pratio, 1. / setup->gamma);\n starState->astarR = aR * PetscPowReal(pratio, 0.5 * starState->gamm1 / setup->gamma);\n starState-> SHR = setup->uR + aR;\n starState->STR = starState->ustar + starState->astarR;\n }else { // shock\n starState->rhostarR = setup->rhoR * (pratio + starState->gamm1 / starState->gamp1) / (starState->gamm1 * pratio / starState->gamp1 + 1.);\n starState->SR = setup->uR + aR * PetscSqrtReal(0.5 * starState->gamp1 / setup->gamma * pratio + 0.5 * starState->gamm1 / setup->gamma);\n }\n return 0;\n}\n\nstatic void SetExactSolutionAtPoint(PetscInt dim, PetscReal xDt, const Setup* setup, const StarState* starState, EulerNode* uu){\n PetscReal p;\n // compute the speed of sound\n PetscReal aL = PetscSqrtReal(setup->gamma*setup->pL/setup->rhoL);\n PetscReal aR = PetscSqrtReal(setup->gamma*setup->pR/setup->rhoR);\n\n for(PetscInt i =0; i < dim; i++){\n uu->rhoU[i] = 0.0;\n }\n\n if (xDt <= starState->ustar) { //# left of contact surface\n if (starState->pstar <= setup->pL) { // # rarefaction\n if (xDt <= starState->SHL) {\n uu->rho = setup->rhoL;\n p = setup->pL;\n uu->rhoU[0] = setup->uL*uu->rho;\n }else if (xDt <=starState->STL) { //#SHL < x / t < STL\n PetscReal tmp = 2. / starState->gamp1 + (starState->gamm1 / starState->gamp1 / aL) * (setup->uL - xDt);\n uu->rho = setup->rhoL * pow(tmp, 2. / starState->gamm1);\n uu->rhoU[0] = uu->rho * (2. / starState->gamp1) * (aL + 0.5 * starState->gamm1 * setup->uL + xDt);\n p = setup->pL * pow(tmp, 2. * setup->gamma / starState->gamm1);\n }else { //# STL < x/t < u*\n uu->rho = starState->rhostarL;\n p = starState->pstar;\n uu->rhoU[0] = uu->rho * starState->ustar;\n }\n }else{ //# shock\n if (xDt<= starState->SL) { // # xDt < SL\n uu->rho = setup->rhoL;\n p = setup->pL;\n uu->rhoU[0] = uu->rho * setup->uL;\n }else { //# SL < xDt < ustar\n uu->rho = starState->rhostarL;\n p = starState->pstar;\n uu->rhoU[0] = uu->rho * starState->ustar;\n }\n }\n }else{//# right of contact surface\n if (starState->pstar<=setup->pR) { //# rarefaction\n if (xDt>= starState->SHR) {\n uu->rho = setup->rhoR;\n p = setup->pR;\n uu->rhoU[0] = uu->rho * setup->uR;\n }else if (xDt >= starState->STR) { // # SHR < x/t < SHR\n PetscReal tmp = 2./starState->gamp1 - (starState->gamm1/starState->gamp1/aR)*(setup->uR-xDt);\n uu->rho = setup->rhoR*PetscPowReal(tmp,2./starState->gamm1);\n uu->rhoU[0] = uu->rho * (2./starState->gamp1)*(-aR + 0.5*starState->gamm1*setup->uR+xDt);\n p = setup->pR*PetscPowReal(tmp,2.*setup->gamma/starState->gamm1);\n }else{ //# u* < x/t < STR\n uu->rho = starState->rhostarR;\n p = starState->pstar;\n uu->rhoU[0] = uu->rho * starState->ustar;\n }\n }else {//# shock\n if (xDt>= starState->SR) { // # xDt > SR\n uu->rho = setup->rhoR;\n p = setup->pR;\n uu->rhoU[0] = uu->rho * setup->uR;\n }else {//#ustar < xDt < SR\n uu->rho = starState->rhostarR;\n p = starState->pstar;\n uu->rhoU[0] = uu->rho * starState->ustar;\n }\n }\n }\n PetscReal e = p/starState->gamm1/uu->rho;\n PetscReal E = e + 0.5*(uu->rhoU[0]/uu->rho)*(uu->rhoU[0]/uu->rho);\n uu->rhoE = uu->rho*E;\n}\n\nstatic PetscErrorCode SetExactSolutionRho(PetscInt dim, PetscReal time, const PetscReal x[], PetscInt Nf, PetscScalar *u, void *ctx){\n ProblemSetup* prob = (ProblemSetup*)ctx;\n\n PetscReal xDt = (x[0]-prob->setup.length/2)/time;\n EulerNode uu;\n SetExactSolutionAtPoint(dim, xDt, &prob->setup, &prob->starState, &uu);\n\n u[0] = uu.rho;\n return 0;\n}\n\nstatic PetscErrorCode SetExactSolutionRhoU(PetscInt dim, PetscReal time, const PetscReal x[], PetscInt Nf, PetscScalar *u, void *ctx){\n ProblemSetup* prob = (ProblemSetup*)ctx;\n\n PetscReal xDt = (x[0]-prob->setup.length/2)/time;\n EulerNode uu;\n SetExactSolutionAtPoint(dim, xDt, &prob->setup, &prob->starState, &uu);\n u[0] = uu.rhoU[0];\n u[1] = uu.rhoU[1];\n return 0;\n}\n\nstatic PetscErrorCode SetExactSolutionRhoE(PetscInt dim, PetscReal time, const PetscReal x[], PetscInt Nf, PetscScalar *u, void *ctx){\n ProblemSetup* prob = (ProblemSetup*)ctx;\n\n PetscReal xDt = (x[0]-prob->setup.length/2)/time;\n EulerNode uu;\n SetExactSolutionAtPoint(dim, xDt, &prob->setup, &prob->starState, &uu);\n u[0] = uu.rhoE;\n return 0;\n}\n\nstatic PetscErrorCode PrintVector(DM dm, Vec v, PetscInt step, const char * fileName){\n Vec cellgeom;\n PetscErrorCode ierr = DMPlexGetGeometryFVM(dm, NULL, &cellgeom, NULL);CHKERRQ(ierr);\n PetscInt cStart, cEnd;\n ierr = DMPlexGetSimplexOrBoxCells(dm, 0, &cStart, &cEnd);CHKERRQ(ierr);\n DM dmCell;\n ierr = VecGetDM(cellgeom, &dmCell);CHKERRQ(ierr);\n const PetscScalar *cgeom;\n ierr = VecGetArrayRead(cellgeom, &cgeom);CHKERRQ(ierr);\n const PetscScalar *x;\n ierr = VecGetArrayRead(v, &x);CHKERRQ(ierr);\n // print the header for each file\n char filename[100];\n ierr = PetscSNPrintf(filename,sizeof(filename),\"%s.%d.txt\",fileName, step);CHKERRQ(ierr);\n\n PetscInt rank = 0;\n PetscInt size;\n ierr = MPI_Comm_rank(PetscObjectComm(dm), &rank);CHKERRMPI(ierr);\n ierr = MPI_Comm_size(PetscObjectComm(dm), &size);CHKERRMPI(ierr);\n\n for(PetscInt r =0; r < size; r++ ) {\n if(r == rank) {\n FILE *fptr;\n if(r == 0){\n fptr = fopen(filename, \"w\");\n fprintf(fptr, \"x rho u e\\n\");\n }else{\n fptr = fopen(filename, \"a\");\n }\n for (PetscInt c = cStart; c < cEnd; ++c) {\n PetscFVCellGeom *cg;\n const EulerNode *xc;\n\n ierr = DMPlexPointLocalRead(dmCell, c, cgeom, &cg);\n CHKERRQ(ierr);\n ierr = DMPlexPointGlobalFieldRead(dm, c, 0, x, &xc);\n CHKERRQ(ierr);\n if(xc) {// must be real cell and not ghost\n PetscReal u0 = xc->rhoU[0] / xc->rho;\n fprintf(fptr, \"%f %f %f %f\\n\", cg->centroid[0], xc->rho, u0, (xc->rhoE / xc->rho) - 0.5 * u0 * u0);\n }\n }\n\n fclose(fptr);\n }\n MPI_Barrier(PetscObjectComm(dm));\n }\n ierr = VecRestoreArrayRead(cellgeom, &cgeom);CHKERRQ(ierr);\n ierr = VecRestoreArrayRead(v, &x);CHKERRQ(ierr);\n return 0;\n}\n\nstatic PetscErrorCode MonitorError(TS ts, PetscInt step, PetscReal time, Vec u, void *ctx) {\n PetscFunctionBeginUser;\n PetscErrorCode ierr;\n\n // Get the DM\n DM dm;\n ierr = TSGetDM(ts, &dm);CHKERRQ(ierr);\n\n // Create a copy of the u vector\n Vec e;\n ierr = DMCreateGlobalVector(dm, &e);CHKERRQ(ierr);\n ierr = PetscObjectSetName((PetscObject)e, \"exact\");CHKERRQ(ierr);\n\n // Set the values\n PetscErrorCode (*func[3]) (PetscInt dim, PetscReal time, const PetscReal x[], PetscInt Nf, PetscScalar *u, void *ctx) = {{SetExactSolutionRho, SetExactSolutionRhoU, SetExactSolutionRhoE}};\n void* ctxs[3] ={ctx, ctx, ctx};\n ierr = DMProjectFunction(dm,time,func,ctxs,INSERT_ALL_VALUES,e);CHKERRQ(ierr);\n\n // just print to a file for now\n ierr = PrintVector(dm, e, step, \"exact\");CHKERRQ(ierr);\n ierr = PrintVector(dm, u, step, \"solution\");CHKERRQ(ierr);\n\n PetscPrintf(PETSC_COMM_WORLD, \"TS %d: %f\\n\", step, time);\n\n DMRestoreGlobalVector(dm, &e);\n PetscFunctionReturn(0);\n}\n\nstatic PetscErrorCode PhysicsBoundary_Euler_Mirror(PetscReal time, const PetscReal *c, const PetscReal *n, const PetscScalar *a_xI, PetscScalar *a_xG, void *ctx)\n{\n const EulerNode *xI = (const EulerNode*)a_xI;\n EulerNode *xG = (EulerNode*)a_xG;\n ProblemSetup* prob = (ProblemSetup*)ctx;\n PetscFunctionBeginUser;\n xG->rho = xI->rho;\n xG->rhoE = xI->rhoE;\n xG->rhoU[0] = xI->rhoU[0];\n xG->rhoU[1] = xI->rhoU[1];\n\n PetscFunctionReturn(0);\n}\n\n/* PetscReal* => EulerNode* conversion */\nstatic PetscErrorCode PhysicsBoundary_Euler_Left(PetscReal time, const PetscReal *c, const PetscReal *n, const PetscScalar *a_xI, PetscScalar *a_xG, void *ctx)\n{\n const EulerNode *xI = (const EulerNode*)a_xI;\n EulerNode *xG = (EulerNode*)a_xG;\n ProblemSetup* prob = (ProblemSetup*)ctx;\n PetscFunctionBeginUser;\n xG->rho = prob->setup.rhoL;\n PetscReal eT = prob->setup.rhoL*((prob->setup.pL /(prob->setup.gamma -1) / prob->setup.rhoL) + 0.5 * prob->setup.uL * prob->setup.uL);\n xG->rhoE = eT;\n xG->rhoU[0] = prob->setup.rhoL * prob->setup.uL;\n xG->rhoU[1] = 0.0;\n\n PetscFunctionReturn(0);\n}\n\n/* PetscReal* => EulerNode* conversion */\nstatic PetscErrorCode PhysicsBoundary_Euler_Right(PetscReal time, const PetscReal *c, const PetscReal *n, const PetscScalar *a_xI, PetscScalar *a_xG, void *ctx)\n{\n const EulerNode *xI = (const EulerNode*)a_xI;\n EulerNode *xG = (EulerNode*)a_xG;\n ProblemSetup* prob = (ProblemSetup*)ctx;\n PetscFunctionBeginUser;\n xG->rho = prob->setup.rhoR;\n PetscReal eT = prob->setup.rhoR*((prob->setup.pR /(prob->setup.gamma -1)/ prob->setup.rhoR) + 0.5 * prob->setup.uR * prob->setup.uR);\n xG->rhoE = eT;\n xG->rhoU[0] = prob->setup.rhoR * prob->setup.uR;\n xG->rhoU[1] = 0.0;\n\n PetscFunctionReturn(0);\n}\n\nstatic PetscErrorCode ComputeTimeStep(TS ts){\n DM dm;\n PetscErrorCode ierr = TSGetDM(ts, &dm);CHKERRQ(ierr);\n Vec v;\n TSGetSolution(ts, &v);\n ProblemSetup *problem;\n ierr = DMGetApplicationContext(dm, &problem);CHKERRQ(ierr);\n\n\n Vec cellgeom;\n ierr = DMPlexGetGeometryFVM(dm, NULL, &cellgeom, NULL);CHKERRQ(ierr);\n PetscInt cStart, cEnd;\n ierr = DMPlexGetSimplexOrBoxCells(dm, 0, &cStart, &cEnd);CHKERRQ(ierr);\n DM dmCell;\n ierr = VecGetDM(cellgeom, &dmCell);CHKERRQ(ierr);\n const PetscScalar *cgeom;\n ierr = VecGetArrayRead(cellgeom, &cgeom);CHKERRQ(ierr);\n const PetscScalar *x;\n ierr = VecGetArrayRead(v, &x);CHKERRQ(ierr);\n\n PetscReal dtMin = 1.0;\n\n for (PetscInt c = cStart; c < cEnd; ++c) {\n PetscFVCellGeom *cg;\n const EulerNode *xc;\n\n ierr = DMPlexPointLocalRead(dmCell, c, cgeom, &cg);CHKERRQ(ierr);\n ierr = DMPlexPointGlobalFieldRead(dm, c, 0, x, &xc);CHKERRQ(ierr);\n\n if(xc) { // must be real cell and not ghost\n\n PetscReal rho = xc->rho;\n PetscReal u = xc->rhoU[0] / rho;\n PetscReal e = (xc->rhoE / rho) - 0.5 * u * u;\n PetscReal p = (problem->setup.gamma - 1) * rho * e;\n\n PetscReal a = PetscSqrtReal(problem->setup.gamma * p / rho);\n PetscReal dt = problem->cfl * cg->volume / (a + PetscAbsReal(u));\n dtMin = PetscMin(dtMin, dt);\n }\n }\n PetscInt rank;\n MPI_Comm_rank(PetscObjectComm(ts), &rank);\n printf(\"dtMin(%d): %f\\n\", rank,dtMin );\n\n PetscReal dtMinGlobal;\n ierr = MPI_Allreduce(&dtMin, &dtMinGlobal, 1,MPIU_REAL, MPI_MIN, PetscObjectComm(ts));\n\n PetscPrintf(PetscObjectComm(ts), \"TimeStep: %f\\n\", dtMinGlobal);\n// ierr = TSSetTimeStep(ts, dtMinGlobal);CHKERRQ(ierr);\n\n ierr = VecRestoreArrayRead(cellgeom, &cgeom);CHKERRQ(ierr);\n ierr = VecRestoreArrayRead(v, &x);CHKERRQ(ierr);\n return 0;\n}\n\nstatic void ComputeFluxRho(PetscInt dim, PetscInt Nf, const PetscReal *qp, const PetscReal *n, const EulerNode *xL, const EulerNode *xR, PetscInt numConstants, const PetscScalar constants[], PetscReal *flux, void* ctx) {\n// dim\t- The spatial dimension\n// Nf\t- The number of fields\n// x\t- The coordinates at a point on the interface\n// n\t- The normal vector to the interface\n// uL\t- The state vector to the left of the interface\n// uR\t- The state vector to the right of the interface\n// flux\t- output array of flux through the interface\n// numConstants\t- number of constant parameters\n// constants\t- constant parameters\n// ctx\t- optional user context\n ProblemSetup* prob = (ProblemSetup*)ctx;\n\n // this is a hack, only add in flux from left/right\n if(PetscAbs(n[0]) > 1E-5) {\n // Setup Godunov\n Setup currentValues;\n\n currentValues.gamma = prob->setup.gamma;\n currentValues.length = prob->setup.length;\n\n if (n[0] > 0) {\n currentValues.rhoL = xL->rho;\n currentValues.uL = xL->rhoU[0] / currentValues.rhoL;\n PetscReal eL = (xL->rhoE / currentValues.rhoL) - 0.5 * currentValues.uL * currentValues.uL;\n currentValues.pL = (prob->setup.gamma - 1) * currentValues.rhoL * eL;\n\n currentValues.rhoR = xR->rho;\n currentValues.uR = xR->rhoU[0] / currentValues.rhoR;\n PetscReal eR = (xR->rhoE / currentValues.rhoR) - 0.5 * currentValues.uR * currentValues.uR;\n currentValues.pR = (prob->setup.gamma - 1) * currentValues.rhoR * eR;\n }else{\n currentValues.rhoR = xL->rho;\n currentValues.uR = xL->rhoU[0] / currentValues.rhoR;\n PetscReal eR = (xL->rhoE / currentValues.rhoR) - 0.5 * currentValues.uR * currentValues.uR;\n currentValues.pR = (prob->setup.gamma - 1) * currentValues.rhoR * eR;\n\n currentValues.rhoL = xR->rho;\n currentValues.uL = xR->rhoU[0] / currentValues.rhoL;\n PetscReal eL = (xR->rhoE / currentValues.rhoL) - 0.5 * currentValues.uL * currentValues.uL;\n currentValues.pL = (prob->setup.gamma - 1) * currentValues.rhoL * eL;\n }\n StarState result;\n DetermineStarState(¤tValues, &result);\n EulerNode exact;\n SetExactSolutionAtPoint(dim, 0.0, ¤tValues, &result, &exact);\n\n PetscReal rho = exact.rho;\n PetscReal u = exact.rhoU[0]/rho;\n PetscReal e = (exact.rhoE / rho) - 0.5 * u * u;\n PetscReal p = (prob->setup.gamma-1) * rho * e;\n\n flux[0] = rho * u * PetscSignReal(n[0]);\n printf(\"flux qp[%f]: %f n:%f rL:%f rR:%f\\n \", qp[0], flux[0], n[0], currentValues.rhoL, currentValues.rhoR);\n// flux->rhoU[0] = (rho * u * u + p)* PetscSignReal(n[0]);\n// flux->rhoU[1] = 0.0;\n// PetscReal et = e + 0.5 * u * u;\n// flux->rhoE = (rho * u * (et + p / rho))* PetscSignReal(n[0]);\n\n// printf(\"%f,%f %f %f,%f\\n\", qp[0], qp[1], flux[0], n[0], n[1]);mm\n\n }else{\n flux[0] = 0.0;\n// flux->rhoU[0] =0.0;\n// flux->rhoU[1] = 0.0;\n// flux->rhoE = 0.0;\n\n }\n\n// F[0][i]=rho[i]*u[i]\n// F[1][i]=rho[i]*u[i]*u[i]+p[i]\n// et = e[i]+0.5*u[i]*u[i]\n// F[2][i]=rho[i]*u[i]*(et+p[i]/rho[i])\n\n}\n\n\nstatic void ComputeFluxU(PetscInt dim, PetscInt Nf, const PetscReal *qp, const PetscReal *n, const EulerNode *xL, const EulerNode *xR, PetscInt numConstants, const PetscScalar constants[], PetscReal *flux, void* ctx) {\n// dim\t- The spatial dimension\n// Nf\t- The number of fields\n// x\t- The coordinates at a point on the interface\n// n\t- The normal vector to the interface\n// uL\t- The state vector to the left of the interface\n// uR\t- The state vector to the right of the interface\n// flux\t- output array of flux through the interface\n// numConstants\t- number of constant parameters\n// constants\t- constant parameters\n// ctx\t- optional user context\n ProblemSetup* prob = (ProblemSetup*)ctx;\n\n // this is a hack, only add in flux from left/right\n if(PetscAbs(n[0]) > 1E-5) {\n // Setup Godunov\n Setup currentValues;\n\n currentValues.gamma = prob->setup.gamma;\n currentValues.length = prob->setup.length;\n\n if (n[0] > 0) {\n currentValues.rhoL = xL->rho;\n currentValues.uL = xL->rhoU[0] / currentValues.rhoL;\n PetscReal eL = (xL->rhoE / currentValues.rhoL) - 0.5 * currentValues.uL * currentValues.uL;\n currentValues.pL = (prob->setup.gamma - 1) * currentValues.rhoL * eL;\n\n currentValues.rhoR = xR->rho;\n currentValues.uR = xR->rhoU[0] / currentValues.rhoR;\n PetscReal eR = (xR->rhoE / currentValues.rhoR) - 0.5 * currentValues.uR * currentValues.uR;\n currentValues.pR = (prob->setup.gamma - 1) * currentValues.rhoR * eR;\n }else{\n currentValues.rhoR = xL->rho;\n currentValues.uR = xL->rhoU[0] / currentValues.rhoR;\n PetscReal eR = (xL->rhoE / currentValues.rhoR) - 0.5 * currentValues.uR * currentValues.uR;\n currentValues.pR = (prob->setup.gamma - 1) * currentValues.rhoR * eR;\n\n currentValues.rhoL = xR->rho;\n currentValues.uL = xR->rhoU[0] / currentValues.rhoL;\n PetscReal eL = (xR->rhoE / currentValues.rhoL) - 0.5 * currentValues.uL * currentValues.uL;\n currentValues.pL = (prob->setup.gamma - 1) * currentValues.rhoL * eL;\n }\n StarState result;\n DetermineStarState(¤tValues, &result);\n EulerNode exact;\n SetExactSolutionAtPoint(dim, 0.0, ¤tValues, &result, &exact);\n\n\n PetscReal rho = exact.rho;\n PetscReal u = exact.rhoU[0]/rho;\n PetscReal e = (exact.rhoE / rho) - 0.5 * u * u;\n PetscReal p = (prob->setup.gamma-1) * rho * e;\n\n// flux[0] = (rho * u) * PetscSignReal(n[0]);\n flux[0] = (rho * u * u + p)* PetscSignReal(n[0]);\n flux[1] = 0.0;\n// PetscReal et = e + 0.5 * u * u;\n// flux->rhoE = (rho * u * (et + p / rho))* PetscSignReal(n[0]);\n\n// printf(\"%f,%f %f %f %f %f\\n\", qp[0], qp[1], flux->rho, flux->rhoU[0], flux->rhoE, n[0]);\n\n }else{\n flux[0] = 0.0;\n flux[1] = 0.0;\n// flux->rhoU[0] =0.0;\n// flux->rhoU[1] = 0.0;\n// flux->rhoE = 0.0;\n\n }\n\n// F[0][i]=rho[i]*u[i]\n// F[1][i]=rho[i]*u[i]*u[i]+p[i]\n// et = e[i]+0.5*u[i]*u[i]\n// F[2][i]=rho[i]*u[i]*(et+p[i]/rho[i])\n\n}\n\n\nstatic void ComputeFluxE(PetscInt dim, PetscInt Nf, const PetscReal *qp, const PetscReal *n, const EulerNode *xL, const EulerNode *xR, PetscInt numConstants, const PetscScalar constants[], PetscReal *flux, void* ctx) {\n// dim\t- The spatial dimension\n// Nf\t- The number of fields\n// x\t- The coordinates at a point on the interface\n// n\t- The normal vector to the interface\n// uL\t- The state vector to the left of the interface\n// uR\t- The state vector to the right of the interface\n// flux\t- output array of flux through the interface\n// numConstants\t- number of constant parameters\n// constants\t- constant parameters\n// ctx\t- optional user context\n ProblemSetup* prob = (ProblemSetup*)ctx;\n\n // this is a hack, only add in flux from left/right\n if(PetscAbs(n[0]) > 1E-5) {\n // Setup Godunov\n Setup currentValues;\n\n currentValues.gamma = prob->setup.gamma;\n currentValues.length = prob->setup.length;\n\n if (n[0] > 0) {\n currentValues.rhoL = xL->rho;\n currentValues.uL = xL->rhoU[0] / currentValues.rhoL;\n PetscReal eL = (xL->rhoE / currentValues.rhoL) - 0.5 * currentValues.uL * currentValues.uL;\n currentValues.pL = (prob->setup.gamma - 1) * currentValues.rhoL * eL;\n\n currentValues.rhoR = xR->rho;\n currentValues.uR = xR->rhoU[0] / currentValues.rhoR;\n PetscReal eR = (xR->rhoE / currentValues.rhoR) - 0.5 * currentValues.uR * currentValues.uR;\n currentValues.pR = (prob->setup.gamma - 1) * currentValues.rhoR * eR;\n }else{\n currentValues.rhoR = xL->rho;\n currentValues.uR = xL->rhoU[0] / currentValues.rhoR;\n PetscReal eR = (xL->rhoE / currentValues.rhoR) - 0.5 * currentValues.uR * currentValues.uR;\n currentValues.pR = (prob->setup.gamma - 1) * currentValues.rhoR * eR;\n\n currentValues.rhoL = xR->rho;\n currentValues.uL = xR->rhoU[0] / currentValues.rhoL;\n PetscReal eL = (xR->rhoE / currentValues.rhoL) - 0.5 * currentValues.uL * currentValues.uL;\n currentValues.pL = (prob->setup.gamma - 1) * currentValues.rhoL * eL;\n }\n StarState result;\n DetermineStarState(¤tValues, &result);\n EulerNode exact;\n SetExactSolutionAtPoint(dim, 0.0, ¤tValues, &result, &exact);\n\n\n PetscReal rho = exact.rho;\n PetscReal u = exact.rhoU[0]/rho;\n PetscReal e = (exact.rhoE / rho) - 0.5 * u * u;\n PetscReal p = (prob->setup.gamma-1) * rho * e;\n\n// flux[0] = (rho * u) * PetscSignReal(n[0]);\n// flux[0] = (rho * u * u + p)* PetscSignReal(n[0]);\n// flux[1] = 0.0;\n PetscReal et = e + 0.5 * u * u;\n flux[0] = (rho * u * (et + p / rho))* PetscSignReal(n[0]);\n\n// printf(\"%f,%f %f %f %f %f\\n\", qp[0], qp[1], flux->rho, flux->rhoU[0], flux->rhoE, n[0]);\n\n }else{\n flux[0] = 0.0;\n// flux[1] = 0.0;\n// flux->rhoU[0] =0.0;\n// flux->rhoU[1] = 0.0;\n// flux->rhoE = 0.0;\n\n }\n\n// F[0][i]=rho[i]*u[i]\n// F[1][i]=rho[i]*u[i]*u[i]+p[i]\n// et = e[i]+0.5*u[i]*u[i]\n// F[2][i]=rho[i]*u[i]*(et+p[i]/rho[i])\n\n}\n\nint main(int argc, char **argv)\n{\n PetscErrorCode ierr;\n // create the mesh\n // setup the ts\n DM dm; /* problem definition */\n TS ts; /* timestepper */\n\n // initialize petsc and mpi\n PetscInitialize(&argc, &argv, NULL, \"HELP\");\n\n // Setup the problem\n ProblemSetup problem;\n\n // case 1 - Sod problem\n problem.setup.rhoL=1.0;\n problem.setup.uL=0.0;\n problem.setup.pL=1.0;\n problem.setup.rhoR=0.125;\n problem.setup.uR=0.0;\n problem.setup.pR=0.1;\n problem.setup.maxTime = 0.25;\n problem.setup.length = 1;\n problem.setup.gamma = 1.4;\n problem.cfl = .5;\n\n // case 2 - 123 problem - expansion left and expansion right\n// problem.setup.rhoL=1.0;\n// problem.setup.uL=-2.0;\n// problem.setup.pL=0.4;\n// problem.setup.rhoR=1.0;\n// problem.setup.uR=2.0;\n// problem.setup.pR=0.4;\n// problem.setup.maxTime = 0.15;\n// problem.setup.length = 1;\n// problem.setup.gamma = 1.4;\n// problem.cfl = 0.4;\n\n ierr = TSCreate(PETSC_COMM_WORLD, &ts);\n CHKERRABORT(PETSC_COMM_WORLD, ierr);\n ierr = TSSetType(ts, TSEULER);CHKERRQ(ierr);\n\n //PetscErrorCode DMPlexCreateBoxMesh(MPI_Comm comm, PetscInt dim, PetscBool simplex, const PetscInt faces[], const PetscReal lower[], const PetscReal upper[], const DMBoundaryType periodicity[], PetscBool interpolate, DM *dm)\n PetscReal start[] = {0.0, 0.0};\n PetscReal end[] = {problem.setup.length, 1};\n PetscInt nx[] = {100, 1};\n DMBoundaryType bcType[] = {DM_BOUNDARY_NONE, DM_BOUNDARY_NONE};\n ierr = DMPlexCreateBoxMesh(PETSC_COMM_WORLD, DIM, PETSC_FALSE, nx, start, end, bcType, PETSC_TRUE, &dm);CHKERRQ(ierr);\n\n {\n DM dmDist;\n\n// ierr = DMSetBasicAdjacency(dm, PETSC_TRUE, PETSC_FALSE);CHKERRQ(ierr);\n ierr = DMPlexDistribute(dm, 1, NULL, &dmDist);CHKERRQ(ierr);\n if (dmDist) {\n ierr = DMDestroy(&dm);CHKERRQ(ierr);\n dm = dmDist;\n }\n }\n\n ierr = DMSetFromOptions(dm);CHKERRQ(ierr);\n\n {\n DM gdm;\n ierr = DMPlexConstructGhostCells(dm, NULL, NULL, &gdm);CHKERRQ(ierr);\n ierr = DMDestroy(&dm);CHKERRQ(ierr);\n dm = gdm;\n }\n\n// DMLabel label;\n// ierr = DMGetLabel(dm, \"marker\", &label );CHKERRQ(ierr);\n// ierr = DMLabelView(label, PETSC_VIEWER_STDOUT_WORLD);;CHKERRQ(ierr);\n\n CHKERRABORT(PETSC_COMM_WORLD, ierr);\n ierr = TSSetDM(ts, dm);\n CHKERRABORT(PETSC_COMM_WORLD, ierr);\n ierr = TSSetExactFinalTime(ts, TS_EXACTFINALTIME_MATCHSTEP);\n CHKERRABORT(PETSC_COMM_WORLD, ierr);\n\n // setup the FV\n\n {// Setup the fields\n PetscInt f, dof;\n for (f=0,dof=0; f < 3; f++) {\n PetscInt newDof = PhysicsFields[f].components;\n\n// if (newDof == 1) {\n PetscFV fvm;\n ierr = PetscFVCreate(PETSC_COMM_WORLD, &fvm);CHKERRQ(ierr);\n\n ierr = PetscFVSetFromOptions(fvm);CHKERRQ(ierr);\n ierr = PetscFVSetNumComponents(fvm, newDof);CHKERRQ(ierr);\n ierr = PetscFVSetSpatialDimension(fvm, DIM);CHKERRQ(ierr);\n ierr = PetscObjectSetName((PetscObject) fvm,PhysicsFields[f].fieldName);CHKERRQ(ierr);\n\n /* FV is now structured with one field having all physics as components */\n ierr = DMAddField(dm, NULL, (PetscObject) fvm);CHKERRQ(ierr);\n// }\n// else {\n// PetscInt j;\n//\n// for (j = 0; j < newDof; j++) {\n// char compName[256] = \"Unknown\";\n//\n// ierr = PetscSNPrintf(compName,sizeof(compName),\"%s_%d\",PhysicsFields[f].fieldName,j);CHKERRQ(ierr);\n// ierr = PetscFVSetComponentName(fvm,dof+j,compName);CHKERRQ(ierr);\n// }\n// }\n// dof += newDof;\n }\n }\n\n // Compute the star state\n ierr = DetermineStarState(&problem.setup, &problem.starState);CHKERRQ(ierr);\n\n\n\n PetscDS prob;\n ierr = DMCreateDS(dm);CHKERRQ(ierr);\n ierr = DMGetDS(dm, &prob);CHKERRQ(ierr);\n ierr = DMSetApplicationContext(dm, &problem);CHKERRQ(ierr);\n\n //TODO: Add flux\n ierr = PetscDSSetRiemannSolver(prob, 0,ComputeFluxRho);CHKERRQ(ierr);\n ierr = PetscDSSetContext(prob, 0, &problem);CHKERRQ(ierr);\n ierr = PetscDSSetRiemannSolver(prob, 1,ComputeFluxU);CHKERRQ(ierr);\n ierr = PetscDSSetContext(prob, 1, &problem);CHKERRQ(ierr);\n ierr = PetscDSSetRiemannSolver(prob, 2,ComputeFluxE);CHKERRQ(ierr);\n ierr = PetscDSSetContext(prob, 2, &problem);CHKERRQ(ierr);\n ierr = PetscDSSetFromOptions(prob);CHKERRQ(ierr);\n //TODO: Apply boundary\n\n // setup the solution vector, this olds everything\n Vec X;\n ierr = DMCreateGlobalVector(dm, &X);CHKERRQ(ierr);\n ierr = PetscObjectSetName((PetscObject) X, \"solution\");CHKERRQ(ierr);\n\n\n// ierr = DMTSSetBoundaryLocal(dm, DMPlexTSComputeBoundary, NULL);CHKERRQ(ierr);\n// ierr = DMTSSetIFunctionLocal(dm, DMPlexTSComputeIFunctionFEM, NULL);CHKERRQ(ierr);\n// ierr = DMTSSetIJacobianLocal(dm, DMPlexTSComputeIJacobianFEM, NULL);CHKERRQ(ierr);\n// ierr = DMTSSetRHSFunctionLocal(dm, DMPlexTSComputeRHSFunctionFVM, NULL);CHKERRQ(ierr);//TODO: This is were we set the RHS function\n\n const PetscInt idsLeft[]= {4};\n ierr = PetscDSAddBoundary(prob, DM_BC_NATURAL_RIEMANN, \"wall left\", \"Face Sets\", 0, 0, NULL, (void (*)(void)) PhysicsBoundary_Euler_Left, NULL, 1, idsLeft, &problem);CHKERRQ(ierr);\n const PetscInt idsRight[]= {2};\n ierr = PetscDSAddBoundary(prob, DM_BC_NATURAL_RIEMANN, \"wall right\", \"Face Sets\", 0, 0, NULL, (void (*)(void)) PhysicsBoundary_Euler_Right, NULL, 1, idsRight, &problem);CHKERRQ(ierr);\n\n const PetscInt mirror[]= {1, 3};\n ierr = PetscDSAddBoundary(prob, DM_BC_NATURAL_RIEMANN, \"mirrorWall\", \"Face Sets\", 0, 0, NULL, (void (*)(void)) PhysicsBoundary_Euler_Mirror, NULL, 2, mirror, &problem);CHKERRQ(ierr);\n\n\n// ierr = DMTSSetBoundaryLocal(dm, DMPlexTSComputeBoundary, NULL);CHKERRQ(ierr);\n ierr = DMTSSetRHSFunctionLocal(dm, DMPlexTSComputeRHSFunctionFVM, NULL);CHKERRQ(ierr);//TODO: This is were we set the RHS function\n ierr = TSSetMaxTime(ts,problem.setup.maxTime);CHKERRQ(ierr);\n ierr = TSMonitorSet(ts, MonitorError, &problem, NULL);CHKERRQ(ierr);\n ierr = TSSetTimeStep(ts, 0.0008);CHKERRQ(ierr);\n ierr = TSSetFromOptions(ts);CHKERRQ(ierr);\n ierr = TSSetPostStep(ts, ComputeTimeStep);CHKERRQ(ierr);\n\n // set the initial conditions\n PetscErrorCode (*func[3]) (PetscInt dim, PetscReal time, const PetscReal x[], PetscInt Nf, PetscScalar *u, void *ctx) = {SetExactSolutionRho, SetExactSolutionRhoU, SetExactSolutionRhoE};\n void* ctxs[3] ={&problem, &problem, &problem};\n ierr = DMProjectFunction(dm,0.0,func,ctxs,INSERT_ALL_VALUES,X);CHKERRQ(ierr);\n\n\n// PetscInt rank, size;\n// MPI_Comm_rank(PetscObjectComm(dm), &rank);\n// MPI_Comm_size(PetscObjectComm(dm), &size);\n// for(int r =0; r < size; r++) {\n// if(r == rank) {\n// printf(\"Rank: %d\\n\", r);\n// ierr = DMView(dm, PETSC_VIEWER_STDOUT_SELF);\n// CHKERRQ(ierr);\n//// ierr = DMViewFromOptions(dm, NULL, \"-dm_view\");\n//// CHKERRQ(ierr);\n// }\n// MPI_Barrier(PetscObjectComm(dm));\n// }\n// TSSetMaxSteps(ts, 1);\n ierr = TSSolve(ts,X);CHKERRQ(ierr);\n// ierr = TSGetSolveTime(ts,&ftime);CHKERRQ(ierr);\n// ierr = TSGetStepNumber(ts,&nsteps);\n // CHKERRQ(ierr);\n\n\n return PetscFinalize();\n\n}", "meta": {"hexsha": "e8a9a9e24efde6d1c0fcb1859ff732c1aca5b494", "size": 34659, "ext": "c", "lang": "C", "max_stars_repo_path": "euler.c", "max_stars_repo_name": "mmcgurn/MattFlowCases", "max_stars_repo_head_hexsha": "1ef7ca77b447a07fdd14d1e2e902abe3e281b651", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "euler.c", "max_issues_repo_name": "mmcgurn/MattFlowCases", "max_issues_repo_head_hexsha": "1ef7ca77b447a07fdd14d1e2e902abe3e281b651", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "euler.c", "max_forks_repo_name": "mmcgurn/MattFlowCases", "max_forks_repo_head_hexsha": "1ef7ca77b447a07fdd14d1e2e902abe3e281b651", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 40.2543554007, "max_line_length": 229, "alphanum_fraction": 0.6001327217, "num_tokens": 10856, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8670357529306639, "lm_q2_score": 0.600188359260205, "lm_q1q2_score": 0.5203847659713916}} {"text": "//\n// hemm.h\n// Linear Algebra Template Library\n//\n// Created by Rodney James on 1/6/12.\n// Copyright (c) 2012 University of Colorado Denver. All rights reserved.\n//\n\n#ifndef _hemm_h\n#define _hemm_h\n\n/// @file hemm.h Performs general Hermitian complex matrix-matrix multiplication.\n\n#include \n#include \"latl.h\"\n\nnamespace LATL\n{\n /// @brief Performs general Hermitian complex matrix-matrix multiplication.\n ///\n /// For complex matrices B and C, Hermitian matrix A, and complex scalars alpha and beta,\n ///\n /// C := alpha*A*B + beta*C or C := alpha*B*A + beta*C \n /// is computed.\n /// @return 0 if success.\n /// @return -i if the ith argument is invalid.\n /// @tparam real_t Floating point type.\n /// @param side Specifies whether the matrix A appears on the left or right side as follows:\n ///\n /// if side = 'L' or 'l' then C := alpha*A*B + beta*C,\n /// if side = 'R' or 'r' then C := alpha*B*A + beta*C.\n /// @param uplo Specifies whether the upper or lower triangular part of the Hermitian matrix A\n /// is to be referenced: \n ///\n /// if uplo = 'U' or 'u' then A is upper triangular,\n /// if uplo = 'L' or 'l' then A is lower triangular.\n /// @param m Specifies the number of rows of the matrices B and C. m>=0\n /// @param n Specifies the number of columns of the matrices B and C. n>=0\n /// @param alpha Complex scalar.\n /// @param A Pointer to complex Hermitian matrix A. If side = 'L' or 'l', then A is m-by-m;\n /// if side = 'R' or 'r', then A is n-by-n.\n /// @param ldA Column length of the matrix A. If side = 'L' or 'l', ldA>=m. If side = 'R' or 'r', ldA>=n.\n /// @param B Pointer to complex m-by-n matrix B.\n /// @param ldB Column length of the matrix B. ldB>=m.\n /// @param beta Complex scalar.\n /// @param C Pointer to complex m-by-n matrix C.\n /// @param ldC Column length of the matrix C. ldC>=m.\n /// @ingroup BLAS\n\n template \n int HEMM(char side, char uplo, int_t m, int_t n, complex alpha, complex *A, int_t ldA, complex *B, int_t ldB, complex beta, complex *C, int_t ldC)\n {\n using std::conj;\n using std::real;\n using std::toupper;\n \n const complex zero(0.0,0.0);\n const complex one(1.0,0.0);\n int_t i,j,k;\n complex *a,*b,*c,*at,*bt;\n complex s,t;\n\n side=toupper(side);\n uplo=toupper(uplo);\n\n if((side!='L')&&(side!='R'))\n return -1;\n else if((uplo!='U')&&(uplo!='L'))\n return -2;\n else if(m<0)\n return -3;\n else if(n<0)\n return -4;\n else if(ldA<((side=='L')?m:n))\n return -7;\n else if(ldB=0;i--)\n {\n a-=ldA;\n t=alpha*b[i];\n s=zero;\n for(k=i+1;k\n\n template <> int HEMM(char side, char uplo, int_t m, int_t n, complex alpha, complex *A, int_t ldA, complex *B, int_t ldB, complex beta, complex *C, int_t ldC)\n {\n using std::toupper;\n side=toupper(side);\n uplo=toupper(uplo);\n if((side!='L')&&(side!='R'))\n return -1;\n else if((uplo!='U')&&(uplo!='L'))\n return -2;\n else if(m<0)\n return -3;\n else if(n<0)\n return -4;\n else if(ldA<((side=='L')?m:n))\n return -7;\n else if(ldB int HEMM(char side, char uplo, int_t m, int_t n, complex alpha, complex *A, int_t ldA, complex *B, int_t ldB, complex beta, complex *C, int_t ldC)\n {\n using std::toupper;\n side=toupper(side);\n uplo=toupper(uplo);\n if((side!='L')&&(side!='R'))\n return -1;\n else if((uplo!='U')&&(uplo!='L'))\n return -2;\n else if(m<0)\n return -3;\n else if(n<0)\n return -4;\n else if(ldA<((side=='L')?m:n))\n return -7;\n else if(ldB\n\n#include \n#include \n#include \n#include \"bessel_amp_phase.h\"\n\n/* chebyshev expansions for amplitude and phase\n functions used in bessel evaluations\n\n These are the same for J0,Y0 and for J1,Y1, so\n they sit outside those functions.\n*/\n \nstatic double bm0_data[21] = {\n 0.09284961637381644,\n -0.00142987707403484,\n 0.00002830579271257,\n -0.00000143300611424,\n 0.00000012028628046,\n -0.00000001397113013,\n 0.00000000204076188,\n -0.00000000035399669,\n 0.00000000007024759,\n -0.00000000001554107,\n 0.00000000000376226,\n -0.00000000000098282,\n 0.00000000000027408,\n -0.00000000000008091,\n 0.00000000000002511,\n -0.00000000000000814,\n 0.00000000000000275,\n -0.00000000000000096,\n 0.00000000000000034,\n -0.00000000000000012,\n 0.00000000000000004\n}; \nconst cheb_series _gsl_sf_bessel_amp_phase_bm0_cs = {\n bm0_data,\n 20,\n -1, 1,\n 10\n};\n \nstatic double bth0_data[24] = {\n -0.24639163774300119,\n 0.001737098307508963,\n -0.000062183633402968,\n 0.000004368050165742,\n -0.000000456093019869,\n 0.000000062197400101,\n -0.000000010300442889,\n 0.000000001979526776,\n -0.000000000428198396,\n 0.000000000102035840,\n -0.000000000026363898,\n 0.000000000007297935,\n -0.000000000002144188,\n 0.000000000000663693,\n -0.000000000000215126,\n 0.000000000000072659,\n -0.000000000000025465,\n 0.000000000000009229,\n -0.000000000000003448,\n 0.000000000000001325,\n -0.000000000000000522,\n 0.000000000000000210,\n -0.000000000000000087,\n 0.000000000000000036\n};\nconst cheb_series _gsl_sf_bessel_amp_phase_bth0_cs = {\n bth0_data,\n 23,\n -1, 1,\n 12\n};\n\n\nstatic double bm1_data[21] = {\n 0.1047362510931285, \n 0.00442443893702345,\n -0.00005661639504035,\n 0.00000231349417339,\n -0.00000017377182007,\n 0.00000001893209930,\n -0.00000000265416023,\n 0.00000000044740209,\n -0.00000000008691795,\n 0.00000000001891492,\n -0.00000000000451884,\n 0.00000000000116765,\n -0.00000000000032265,\n 0.00000000000009450,\n -0.00000000000002913,\n 0.00000000000000939,\n -0.00000000000000315,\n 0.00000000000000109,\n -0.00000000000000039,\n 0.00000000000000014,\n -0.00000000000000005,\n}; \nconst cheb_series _gsl_sf_bessel_amp_phase_bm1_cs = {\n bm1_data,\n 20,\n -1, 1,\n 10\n};\n\nstatic double bth1_data[24] = {\n 0.74060141026313850, \n -0.004571755659637690,\n 0.000119818510964326,\n -0.000006964561891648,\n 0.000000655495621447,\n -0.000000084066228945,\n 0.000000013376886564,\n -0.000000002499565654,\n 0.000000000529495100,\n -0.000000000124135944,\n 0.000000000031656485,\n -0.000000000008668640,\n 0.000000000002523758,\n -0.000000000000775085,\n 0.000000000000249527,\n -0.000000000000083773,\n 0.000000000000029205,\n -0.000000000000010534,\n 0.000000000000003919,\n -0.000000000000001500,\n 0.000000000000000589,\n -0.000000000000000237,\n 0.000000000000000097,\n -0.000000000000000040,\n};\nconst cheb_series _gsl_sf_bessel_amp_phase_bth1_cs = {\n bth1_data,\n 23,\n -1, 1,\n 12\n};\n\n\nint\ngsl_sf_bessel_asymp_Mnu_e(const double nu, const double x, double * result)\n{\n const double r = 2.0*nu/x;\n const double r2 = r*r;\n const double x2 = x*x;\n const double term1 = (r2-1.0/x2)/8.0;\n const double term2 = (r2-1.0/x2)*(r2-9.0/x2)*3.0/128.0;\n const double Mnu2_c = 2.0/(M_PI) * (1.0 + term1 + term2);\n *result = sqrt(Mnu2_c)/sqrt(x); /* will never underflow this way */\n return GSL_SUCCESS;\n}\n\n\nint\ngsl_sf_bessel_asymp_thetanu_corr_e(const double nu, const double x, double * result)\n{\n const double r = 2.0*nu/x;\n const double r2 = r*r;\n const double x2 = x*x;\n const double term1 = x*(r2 - 1.0/x2)/8.0;\n const double term2 = x*(r2 - 1.0/x2)*(r2 - 25.0/x2)/384.0;\n *result = (-0.25*M_PI + term1 + term2);\n return GSL_SUCCESS;\n}\n", "meta": {"hexsha": "b1099b559ef42a751ae041c4abff0c6640e4e74c", "size": 4651, "ext": "c", "lang": "C", "max_stars_repo_path": "pkgs/libs/gsl/src/specfunc/bessel_amp_phase.c", "max_stars_repo_name": "manggoguy/parsec-modified", "max_stars_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 64.0, "max_stars_repo_stars_event_min_datetime": "2015-03-06T00:30:56.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-24T13:26:53.000Z", "max_issues_repo_path": "pkgs/libs/gsl/src/specfunc/bessel_amp_phase.c", "max_issues_repo_name": "manggoguy/parsec-modified", "max_issues_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 12.0, "max_issues_repo_issues_event_min_datetime": "2020-12-15T08:30:19.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-13T03:54:24.000Z", "max_forks_repo_path": "pkgs/libs/gsl/src/specfunc/bessel_amp_phase.c", "max_forks_repo_name": "manggoguy/parsec-modified", "max_forks_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 40.0, "max_forks_repo_forks_event_min_datetime": "2015-02-26T15:31:16.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-03T23:23:37.000Z", "avg_line_length": 24.6084656085, "max_line_length": 84, "alphanum_fraction": 0.7202752096, "num_tokens": 1805, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8774767810736692, "lm_q2_score": 0.5926665999540698, "lm_q1q2_score": 0.5200511803775731}} {"text": "#pragma once\n\n/*** mathematics.h:\n\n Mathematical and statistical functions. ***/\n\n/** Avoid including this file twice. **/\n\n#ifndef MATHEMATICS_H\n#define MATHEMATICS_H\n\n/** Libraries. **/\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n/** Constants. **/\n\n#define MATH_PI 3.1415926535897932385 /* Pi. */\n#define MATH_2PI 6.2831853071795864770 /* 2 pi. */\n#define MATH_PI_2 1.57079632679489661925 /* Pi / 2. */\n\n/* Coordinates / axes. */\n\n#define MATH_X 0 /* Castesian. */\n#define MATH_Y 1\n#define MATH_Z 2\n#define MATH_RADIUS 0 /* Spherical. */\n#define MATH_POLAR 1\n#define MATH_AZIMUTH 2\n#define MATH_MU 1 /* Pseudospherical (mu = cos(polar) replacing polar). */\n\n/** Variables. **/\n\n/* Random numbers. */\n\ngsl_rng *RandomNumberGenerator; /* Random number generator. */\nunsigned RandomSeed; /* Random seed. */\nunsigned SortComponent = 0; /* Component used for sorting vectors. */\n\n/** Function prototypes. **/\n\nint SortAscending(const void *, const void *);\nint SortIndexesAscending(const void *, const void *);\ndouble ScalarProduct(double *, double *, unsigned);\ndouble Norm(double *, unsigned);\ndouble NormSquared(double *, unsigned);\ndouble AngleCosine(double *, double *);\n\nvoid SphericalToCartesian(double *, double *);\nvoid PseudoSphericalToCartesian(double *, double *);\nvoid CartesianToSpherical(double *, double *);\nvoid CartesianToPseudoSpherical(double *, double *);\nvoid Rotate(double *, double *, unsigned, double);\nunsigned GetRandomSeed();\nint InitialiseRandom(const gsl_rng_type *);\nint FinaliseRandom();\ndouble MetropolisHastings(double *, double *, double *, double *, unsigned, unsigned, unsigned, unsigned, double *, double *, double *,\n void (*)(double *, double *, double *, double *, double *, unsigned), double (*)(double *, double *, double *, double *, double *, unsigned),\n double (*)(double *));\ndouble ParallelTempering(double *, double *, double *, double *, unsigned, unsigned, unsigned, unsigned, double *, double *, double *,\n void (*)(double *, double *, double *, double *, double *, unsigned), double (*)(double *, double *, double *, double *, double *, unsigned),\n double (*)(double *), unsigned, double *, double);\nvoid TanWeights(double *, double *, double *, double *, unsigned, unsigned, unsigned, double *, double *, double *,\n double (*)(double *, double *, double *, double *, double *, unsigned), unsigned);\ndouble TanNormalisation(double *, unsigned, double *);\ndouble WeightAndSum(double *, double *, unsigned);\nvoid UniformTransition(double *, double *, double *, double *, double *, unsigned);\ndouble UniformTransitionPDF(double *, double *, double *, double *, double *, unsigned);\ndouble PowerLawDeviate(double, double, double);\nvoid IsotropicDirection(double, double *);\nvoid StandardGaussianDeviates(double *);\nvoid GaussianDeviates(double *, double, double);\ncomplex ComplexGaussianDeviates(complex, complex);\n\n/** SortAscending.\n\n - Function designed to be an argument of qsort().\n - Sorts the elements of a vector in ascending order. The vector elements are reorganised. **/\n\nint SortAscending(const void *x, const void *y)\n{\n double difference;\n\n difference = *((double *)x) - *((double *)y);\n if (difference > 0.0)\n return 1;\n else if (difference < 0.0)\n return -1;\n else\n return 0;\n}\n\n/** SortIndexesAscending.\n\n - Function designed to be an argument of qsort().\n - Sorts the indexes of a vector, in such a way that its elements are arranged in ascending order. The vector remains unchanged.\n - 'SortComponent' indicates the component used to sort, in the case that the vector elements have more than one dimension. **/\n\nint SortIndexesAscending(const void *x, const void *y)\n{\n double difference;\n\n difference = *(*(double **)x + SortComponent) - *(*(double **)y + SortComponent);\n if (difference > 0.0)\n return 1;\n else if (difference < 0.0)\n return -1;\n else\n return 0;\n}\n\n/** ScalarProduct.\n\n - Computes the scalar product between two vectors. **/\n\ndouble ScalarProduct(double *vector_1, double *vector_2, unsigned vector_size)\n{\n unsigned i;\n double product;\n\n /* Compute components product and sum. */\n\n product = 0.0;\n for (i = 0; i < vector_size; i++)\n product += vector_1[i] * vector_2[i];\n return product;\n}\n\n/** Norm.\n\n - Computes the norm of a vector. **/\n\ndouble Norm(double *vector, unsigned vector_size)\n{\n unsigned i;\n double *component_sq, max_component_sq, norm;\n\n /* Generate an auxiliary vector of component squares, in ascending order. */\n\n component_sq = malloc(vector_size * sizeof(double));\n for (i = 0; i < vector_size; i++)\n component_sq[i] = vector[i] * vector[i];\n qsort(component_sq, vector_size, sizeof(double), SortAscending);\n\n /* Divide component squares by the largest one to avoid overflow. */\n\n max_component_sq = component_sq[vector_size-1];\n if (max_component_sq <= 0.0) /* All components are null. */\n return 0.0;\n vector_size--;\n for (i = 0; i < vector_size; i++)\n component_sq[i] /= max_component_sq;\n\n /* Sum component squares in ascending order, to avoid loss of significance. */\n\n norm = 0.0;\n for (i = 0; i < vector_size; i++)\n norm += component_sq[i];\n norm += 1.0;\n\n /* Renormalise. */\n\n norm = sqrt(max_component_sq * norm);\n free(component_sq);\n return norm;\n}\n\n/** NormSquared.\n\n - Computes the square of the norm of a vector. **/\n\ndouble NormSquared(double *vector, unsigned vector_size)\n{\n unsigned i;\n double *component_sq, max_component_sq, norm;\n\n /* Generate an auxiliary vector of component squares, in ascending order. */\n\n component_sq = malloc(vector_size * sizeof(double));\n for (i = 0; i < vector_size; i++)\n component_sq[i] = vector[i] * vector[i];\n qsort(component_sq, vector_size, sizeof(double), SortAscending);\n\n /* Divide component squares by the largest one to avoid overflow. */\n\n max_component_sq = component_sq[vector_size-1];\n if (max_component_sq <= 0.0) /* All components are null. */\n return 0.0;\n vector_size--;\n for (i = 0; i < vector_size; i++)\n component_sq[i] /= max_component_sq;\n\n /* Sum component squares in ascending order, to avoid loss of significance. */\n\n norm = 0.0;\n for (i = 0; i < vector_size; i++)\n norm += component_sq[i];\n norm += 1.0;\n\n /* Renormalise. */\n\n norm *= max_component_sq;\n free(component_sq);\n return norm;\n}\n\n/** AngleCosine.\n\n - Computes the cosine of the angle between two 3D vectors. **/\n\ndouble AngleCosine(double *vector_1, double *vector_2)\n{\n double norm_1, norm_2, cosine;\n\n norm_1 = Norm(vector_1, 3);\n norm_2 = Norm(vector_2, 3);\n if (norm_1 <= 0.0 || norm_2 <= 0.0) /* At least one vector is null. */\n return 0.0;\n cosine = ScalarProduct(vector_1, vector_2, 3) / (norm_1 * norm_2);\n if (cosine > 1.0) /* Correct eventual round-off errors. */\n cosine = 1.0;\n else if (cosine < -1.0)\n cosine = -1.0;\n return cosine;\n}\n\n/** SphericalToCartesian.\n\n - Converts a 3D vector from spherical (radius, polar angle, azimuth) to Cartesian form.\n - Initial and final vectors may be the same. **/\n\nvoid SphericalToCartesian(double *vec_in, double *vec_out)\n{\n double sin_polar, cos_polar, radius, azimuth;\n\n radius = vec_in[MATH_RADIUS];\n sin_polar = sin(vec_in[MATH_POLAR]);\n cos_polar = cos(vec_in[MATH_POLAR]);\n azimuth = vec_in[MATH_AZIMUTH];\n vec_out[MATH_X] = radius * sin_polar * cos(azimuth);\n vec_out[MATH_Y] = radius * sin_polar * sin(azimuth);\n vec_out[MATH_Z] = radius * cos_polar;\n}\n\n/** PseudoSphericalToCartesian.\n\n - Converts a 3D vector from pseudo spherical (radius, polar angle cosine, azimuth) to Cartesian form.\n - Initial and final vectors may be the same. **/\n\nvoid PseudoSphericalToCartesian(double *vec_in, double *vec_out)\n{\n double cos_polar, sin_polar, radius, azimuth;\n\n radius = vec_in[MATH_RADIUS];\n azimuth = vec_in[MATH_AZIMUTH];\n cos_polar = vec_in[MATH_MU];\n sin_polar = 1.0 - cos_polar * cos_polar;\n if (sin_polar <= 0.0) /* Correct eventual round-off errors. */\n sin_polar = 0.0;\n else\n sin_polar = sqrt(sin_polar);\n vec_out[MATH_X] = radius * sin_polar * cos(azimuth);\n vec_out[MATH_Y] = radius * sin_polar * sin(azimuth);\n vec_out[MATH_Z] = radius * cos_polar;\n}\n\n/** CartesianToSpherical.\n\n - Converts a 3D vector from Cartesian to spherical (radius, polar angle, azimuth) form.\n - Initial and final vectors may be the same. **/\n\nvoid CartesianToSpherical(double *vec_in, double *vec_out)\n{\n double radius, azimuth, polar;\n\n radius = Norm(vec_in, 3);\n if (radius > 0.0)\n polar = acos(vec_in[MATH_Z] / radius);\n else\n polar = 0.0;\n azimuth = atan2(vec_in[MATH_Y], vec_in[MATH_X]);\n vec_out[MATH_RADIUS] = radius;\n vec_out[MATH_POLAR] = polar;\n vec_out[MATH_AZIMUTH] = azimuth;\n}\n\n/** CartesianToPseudoSpherical.\n\n - Converts a 3D vector from Cartesian to pseudo spherical (radius, polar angle cosine, azimuth) form.\n - Initial and final vectors may be the same. **/\n\nvoid CartesianToPseudoSpherical(double *vec_in, double *vec_out)\n{\n double radius, cos_polar, azimuth;\n\n radius = Norm(vec_in, 3);\n if (radius > 0.0)\n cos_polar = vec_in[MATH_Z] / radius;\n else\n cos_polar = 1.0;\n azimuth = atan2(vec_in[MATH_Y], vec_in[MATH_X]);\n vec_out[MATH_RADIUS] = radius;\n vec_out[MATH_MU] = cos_polar;\n vec_out[MATH_AZIMUTH] = azimuth;\n}\n\n/** Rotate.\n\n - Rotates a vector.\n - Vector is rotated counterclockwise (or axes clockwise) as seen from the tip of the rotation axis specified by argument 'axis'.\n - Initial and final vectors may be the same. **/\n\nvoid Rotate(double *vec_in, double *vec_out, unsigned axis, double angle)\n{\n unsigned i, j;\n double cos_angle, sin_angle, x, y;\n\n cos_angle = cos(angle);\n sin_angle = sin(angle);\n axis %= 3;\n vec_out[axis] = vec_in[axis];\n i = (axis + 1) % 3;\n j = (axis + 2) % 3;\n x = vec_in[i];\n y = vec_in[j];\n vec_out[i] = x * cos_angle - y * sin_angle;\n vec_out[j] = x * sin_angle + y * cos_angle;\n}\n\n/** GetRandomSeed.\n\n - Provides a random seed by reading garbage from /dev/urandom. **/\n\nunsigned GetRandomSeed()\n{\n FILE *random_file;\n unsigned seed;\n int error;\n\n seed = 0;\n random_file = fopen(\"/dev/urandom\", \"rb\");\n if (!random_file)\n return 0;\n do\n {\n error = fread(&seed, 1, sizeof(unsigned int), random_file);\n if (error != sizeof(unsigned int))\n return 0;\n }\n while (!seed);\n fclose(random_file);\n return seed;\n}\n\n/** InitialiseRandom.\n\n - Initialises the random number generator. **/\n\nint InitialiseRandom(const gsl_rng_type *random_generator)\n{\n RandomSeed = GetRandomSeed();\n if (!RandomSeed)\n return EXIT_FAILURE;\n RandomNumberGenerator = gsl_rng_alloc(random_generator);\n if (!RandomNumberGenerator)\n return EXIT_FAILURE;\n gsl_rng_set(RandomNumberGenerator, RandomSeed);\n return EXIT_SUCCESS;\n}\n\n/** FinaliseRandom.\n\n - Finalises the random number generator. **/\n\nint FinaliseRandom()\n{\n /* Release random number generator memory. */\n\n if (RandomNumberGenerator)\n {\n gsl_rng_free(RandomNumberGenerator);\n return EXIT_SUCCESS;\n }\n return EXIT_FAILURE;\n}\n\n/** MetropolisHastings.\n\n - Constructs a Markov chain using Metropolis-Hastings sampling from a given PDF ('sampling_pdf').\n - 'states' contains the actual Markov chain, comprising 'chain_size' elements. Each element contains 'state_size' doubles. The initial state must be stored in\n the first element of 'states'. 'states' must be allocated by the calling function.\n - 'proposals' is the chain of proposals derived from each state (same length and element size as 'states'). It must be allocated by the calling function.\n - 'lower_bound' and 'upper_bound' must contain the absolute bounds for the variables defining the state.\n - 'step' must contain the parameter defining the size of the transition step.\n - 'sampling_pdf' must point to a function computing the PDF sampled by the Markov chain. Its only argument is a state of the chain; any other parameter must be\n passed through global variables.\n - 'transition_pdf' must point to a function computing the PDF of a Metropolis-Hastings transition, given a Markov chain state. Its arguments are the final and\n initial states of the transition, in this order. Any other parameter must be passed through global variables.\n - 'transition' must point to a function computing the proposed final state of a Metropolis-Hastings transition, given a Markov chain state. Its arguments are the\n final and initial states of the transition, in this order. Any other parameter must be passed through global variables.\n - 'proposals_PDF' is an array of doubles of the same length of the Markov chain. It must be allocated by the calling function if storage of sampling PDF values\n for the proposals is desired, or set to NULL otherwise.\n - 'states_PDF' is an array of doubles of the same length of the Markov chain. It must be allocated by the calling function if storage of sampling PDF values\n for the states is desired, or set to NULL otherwise.\n - If the initial state set in 'states' has a null value of the sampling PDF, the first transition probability is set to unity. Once a state with a non-null value\n of the sampling PDF is reached, the sampling PDF values do not vanish over the rest of the Markov chain by construction.\n - The order of the state and proposal chains is the following: any element of 'proposals' is sampled from the corresponding element of 'states', whereas any\n element of 'states' (except the first one) is the previous element of either 'states' or 'proposals'.\n - If 'save_states' is set to null, only the final state and proposal are given. Otherwise, the full chains are saved.\n - If 'log_flag' is non null, 'sampling_pdf' is assumed to give the natural logarithm of the PDF.\n - Returns the acceptance ratio of the chain. **/\n\ndouble MetropolisHastings(double *states, double *proposals, double *proposals_pdf, double *states_pdf, unsigned state_size, unsigned chain_size, unsigned save_states,\n unsigned log_flag, double *lower_bound, double *upper_bound, double *step,\n\t\t\t void (*transition)(double *, double *, double *, double *, double *, unsigned),\n double (*transition_pdf)(double *, double *, double *, double *, double *, unsigned), double (*sampling_pdf)(double *))\n{\n unsigned i, accepted_transitions, state_size_bytes;\n double direct_transition_pdf, inverse_transition_pdf, pdf_ratio, state_pdf, proposal_pdf, *proposal, *state, *old_state, acceptance_ratio;\n\n /* Set initial stuff. */\n\n state_size_bytes = state_size * sizeof(double);\n proposal = proposals;\n state = states;\n state_pdf = sampling_pdf(state);\n if (states_pdf)\n states_pdf[0] = state_pdf;\n\n /* Construct the Markov chain. */\n\n accepted_transitions = 0;\n chain_size--;\n for (i = 0; i < chain_size; i++)\n {\n /* Set new proposal. */\n\n transition(proposal, state, lower_bound, upper_bound, step, state_size);\n proposal_pdf = sampling_pdf(proposal);\n if (proposals_pdf && save_states)\n proposals_pdf[i] = proposal_pdf;\n\n /* Compute transition probabilities. */\n\n direct_transition_pdf = transition_pdf(proposal, state, lower_bound, upper_bound, step, state_size);\n inverse_transition_pdf = transition_pdf(state, proposal, lower_bound, upper_bound, step, state_size);\n if (!log_flag && state_pdf <= 0.0)\n pdf_ratio = 1.1;\n else if (direct_transition_pdf <= 0.0)\n pdf_ratio = -0.1;\n else if (log_flag)\n pdf_ratio = exp(proposal_pdf - state_pdf) * inverse_transition_pdf / direct_transition_pdf;\n else\n pdf_ratio = proposal_pdf * inverse_transition_pdf / (state_pdf * direct_transition_pdf);\n\n /* Accept of reject transition. */\n\n if (save_states)\n {\n old_state = state;\n state += state_size;\n }\n if (gsl_rng_uniform(RandomNumberGenerator) < pdf_ratio)\n {\n memcpy(state, proposal, state_size_bytes);\n state_pdf = proposal_pdf;\n accepted_transitions++;\n }\n else if (save_states)\n memcpy(state, old_state, state_size_bytes);\n if (save_states)\n {\n proposal += state_size;\n if (states_pdf)\n states_pdf[i+1] = state_pdf;\n }\n }\n\n /* Compute final stuff. */\n\n transition(proposal, state, lower_bound, upper_bound, step, state_size);\n acceptance_ratio = accepted_transitions / (double) chain_size;\n if (proposals_pdf && save_states)\n proposals_pdf[chain_size] = sampling_pdf(proposal);\n return acceptance_ratio;\n}\n\n/** ParallelTempering.\n\n - Constructs a Markov chain using Metropolis-Hastings sampling from a given PDF ('sampling_pdf'), with parallel tempering.\n - 'states' contains the cold Markov chain, comprising 'chain_size' elements. Each element contains 'state_size' doubles. The initial state must be stored in\n the first element of 'states'. 'states' must be allocated by the calling function.\n - 'proposals' is the chain of proposals derived from each state (same length and element size as 'states'). It must be allocated by the calling function.\n - 'lower_bound' and 'upper_bound' must contain the absolute bounds for the variables defining the state.\n - 'step' must contain the parameter defining the size of the transition step.\n - 'sampling_pdf' must point to a function computing the PDF sampled by the cold Markov chain. Its only argument is a state of the chain; any other parameter must\n be passed through global variables.\n - 'transition_pdf' must point to a function computing the PDF of a Metropolis-Hastings transition, given a Markov chain state. Its arguments are the final and\n initial states of the transition, in this order. Any other parameter must be passed through global variables.\n - 'transition' must point to a function computing the proposed final state of a Metropolis-Hastings transition, given a Markov chain state. Its arguments are the\n final and initial states of the transition, in this order. Any other parameter must be passed through global variables.\n - 'proposals_PDF' is an array of doubles of the same length of the Markov chain. It must be allocated by the calling function if storage of sampling PDF values\n for the proposals is desired, or set to NULL otherwise.\n - 'states_PDF' is an array of doubles of the same length of the Markov chain. It must be allocated by the calling function if storage of sampling PDF values\n for the states is desired, or set to NULL otherwise.\n - If the initial state set in 'states' has a null value of the sampling PDF, the first transition probability is set to unity. Once a state with a non-null value\n of the sampling PDF is reached, the sampling PDF values do not vanish over the rest of the Markov chain by construction.\n - The order of the state and proposal chains is the following: any element of 'proposals' is sampled from the corresponding element of 'states', whereas any\n element of 'states' (except the first one) is the previous element of either 'states' or 'proposals'.\n - If 'save_states' is set to null, only the final state and proposal are given. Otherwise, the full chains are saved.\n - If 'log_flag' is non null, 'sampling_pdf' is assumed to give the natural logarithm of the PDF.\n - The number of hot chains in the parallel-tempering scheme is 'hot_chains_count', which have tempering factors given by 'tempering_factors'.\n - 'exchange_probability' gives the probability that two chains are interchanged in a given step.\n - Returns the acceptance ratio of the chain. **/\n\ndouble ParallelTempering(double *states, double *proposals, double *proposals_pdf, double *states_pdf, unsigned state_size, unsigned chain_size, unsigned save_states,\n unsigned log_flag, double *lower_bound, double *upper_bound, double *step,\n void (*transition)(double *, double *, double *, double *, double *, unsigned),\n double (*transition_pdf)(double *, double *, double *, double *, double *, unsigned), double (*sampling_pdf)(double *),\n unsigned hot_chains_count, double *tempering_factors, double exchange_probability)\n{\n unsigned i, j, accepted_transitions, state_size_bytes;\n double direct_transition_pdf, inverse_transition_pdf, pdf_ratio, state_pdf, proposal_pdf, *proposal, *state, *old_state, acceptance_ratio, x, *aux_state;\n double *cool_state, hot_proposals_pdf, factor, *hot_proposals, *hot_states, *hot_states_pdf, *cool_state_pdf;\n\n /* Set initial stuff. */\n\n state_size_bytes = state_size * sizeof(double);\n proposal = proposals;\n state = states;\n state_pdf = sampling_pdf(state);\n if (states_pdf)\n states_pdf[0] = state_pdf;\n hot_proposals = malloc(hot_chains_count * state_size_bytes);\n hot_states = malloc(hot_chains_count * state_size_bytes);\n aux_state = malloc(state_size_bytes);\n for (i = 0; i < hot_chains_count; i++)\n memcpy(hot_states + i * state_size, state, state_size_bytes); /* Copy initial state of cold chain to all hot chains. */\n hot_states_pdf = malloc(hot_chains_count * sizeof(double));\n for (i = 0; i < hot_chains_count; i++)\n {\n if (log_flag)\n hot_states_pdf[i] = state_pdf * tempering_factors[i];\n else\n hot_states_pdf[i] = pow(state_pdf, tempering_factors[i]);\n }\n\n /* Construct the Markov chains. */\n\n accepted_transitions = 0;\n chain_size--;\n for (i = 0; i < chain_size; i++)\n {\n /* Set new proposal for cold chain. */\n\n transition(proposal, state, lower_bound, upper_bound, step, state_size);\n proposal_pdf = sampling_pdf(proposal);\n if (proposals_pdf && save_states)\n proposals_pdf[i] = proposal_pdf;\n\n /* Compute transition probabilities for cold chain. */\n\n direct_transition_pdf = transition_pdf(proposal, state, lower_bound, upper_bound, step, state_size);\n inverse_transition_pdf = transition_pdf(state, proposal, lower_bound, upper_bound, step, state_size);\n if (!log_flag && state_pdf <= 0.0)\n pdf_ratio = 1.1;\n else if (direct_transition_pdf <= 0.0)\n pdf_ratio = -0.1;\n else if (log_flag)\n pdf_ratio = exp(proposal_pdf - state_pdf) * inverse_transition_pdf / direct_transition_pdf;\n else\n pdf_ratio = proposal_pdf * inverse_transition_pdf / (state_pdf * direct_transition_pdf);\n\n /* Accept of reject transition for cold chain. */\n\n if (save_states)\n {\n old_state = state;\n state += state_size;\n }\n if (gsl_rng_uniform(RandomNumberGenerator) < pdf_ratio)\n {\n memcpy(state, proposal, state_size_bytes);\n state_pdf = proposal_pdf;\n accepted_transitions++;\n }\n else if (save_states)\n memcpy(state, old_state, state_size_bytes);\n if (save_states)\n {\n proposal += state_size;\n if (states_pdf)\n states_pdf[i+1] = state_pdf;\n }\n\n /* Hot chains. */\n\n for (j = 0; j < hot_chains_count; j++)\n {\n /* Set new proposal. */\n\n transition(hot_proposals + j * state_size, hot_states + j * state_size, lower_bound, upper_bound, step, state_size);\n hot_proposals_pdf = sampling_pdf(hot_proposals + j * state_size);\n if (log_flag)\n hot_proposals_pdf *= tempering_factors[j];\n else\n hot_proposals_pdf = pow(hot_proposals_pdf, tempering_factors[j]);\n\n /* Compute transition probabilities. */\n\n direct_transition_pdf = transition_pdf(hot_proposals + j * state_size, hot_states + j * state_size, lower_bound, upper_bound, step, state_size);\n inverse_transition_pdf = transition_pdf(hot_states + j * state_size, hot_proposals + j * state_size, lower_bound, upper_bound, step, state_size);\n if (!log_flag && hot_states_pdf[j] <= 0.0)\n pdf_ratio = 1.1;\n else if (direct_transition_pdf <= 0.0)\n pdf_ratio = -0.1;\n else if (log_flag)\n pdf_ratio = exp(hot_proposals_pdf - hot_states_pdf[j]) * inverse_transition_pdf / direct_transition_pdf;\n else\n pdf_ratio = hot_proposals_pdf * inverse_transition_pdf / (hot_states_pdf[j] * direct_transition_pdf);\n\n /* Accept of reject transition. */\n\n if (gsl_rng_uniform(RandomNumberGenerator) < pdf_ratio)\n {\n memcpy(hot_states + j * state_size, hot_proposals + j * state_size, state_size_bytes);\n hot_states_pdf[j] = hot_proposals_pdf;\n }\n }\n\n /* Exchange chain states. */\n\n if (gsl_rng_uniform(RandomNumberGenerator) < exchange_probability)\n {\n j = gsl_rng_uniform_int(RandomNumberGenerator, hot_chains_count);\n factor = tempering_factors[j];\n if (j)\n {\n factor /= tempering_factors[j-1];\n cool_state_pdf = hot_states_pdf + j - 1;\n cool_state = hot_states + (j - 1) * state_size;\n }\n else\n {\n cool_state_pdf = &state_pdf;\n cool_state = state;\n }\n if (log_flag)\n pdf_ratio = exp(*cool_state_pdf * (factor - 1.0) + hot_states_pdf[j] * (1.0 / factor - 1.0));\n else\n pdf_ratio = pow(*cool_state_pdf, factor - 1.0) * pow(hot_states_pdf[j], 1.0 / factor - 1.0);\n if (gsl_rng_uniform(RandomNumberGenerator) < pdf_ratio)\n {\n if (log_flag)\n {\n x = hot_states_pdf[j];\n hot_states_pdf[j] = *cool_state_pdf * factor;\n *cool_state_pdf = x / factor;\n }\n else\n {\n x = hot_states_pdf[j];\n hot_states_pdf[j] = pow(*cool_state_pdf, factor);\n *cool_state_pdf = pow(x, 1.0 / factor);\n }\n memcpy(aux_state, hot_states + j * state_size, state_size_bytes);\n memcpy(hot_states + j * state_size, cool_state, state_size_bytes);\n memcpy(cool_state, aux_state, state_size_bytes);\n }\n }\n }\n transition(proposal, state, lower_bound, upper_bound, step, state_size);\n acceptance_ratio = accepted_transitions / (double) chain_size;\n if (proposals_pdf && save_states)\n proposals_pdf[chain_size] = sampling_pdf(proposal);\n free(hot_proposals);\n free(hot_states);\n free(hot_states_pdf);\n free(aux_state);\n return acceptance_ratio;\n}\n\n/** TanWeights.\n\n - Computes the weights proposed by Tan (2006, J.Comp.Graph.Stat., 15, 735) to use Metropolis-Hastings sampling for the evaluation of integrals via the Monte\n Carlo method.\n - 'states' contains the actual Markov chain, comprising 'chain_size' elements. Each element contains 'state_size' doubles.\n - 'proposals' contains the chain of proposals derived from each state (same length and element size as 'states').\n - 'proposals_pdf' is an array of doubles of the same length of the Markov chain, containing the sampling PDF values for the proposals.\n - If the present chain is an extension of an old one, 'old_chain_size' is the size of the latter.\n - 'weights' is an array of 'chain_size' elements for storing the resulting weights. It must be allocated by the calling function. Elements of 'weights' between\n 'old_chain_size' and 'chain_size' are erased before computing.\n - 'lower_bound' and 'upper_bound' must contain the absolute bounds for the variables defining the state.\n - 'step' must contain the parameter defining the size of the transition step.\n - 'sort_component' indicates the component of the state used for sorting them, to reduce the computational cost if the PDF is bound.\n - 'transition_pdf' must point to a function computing the PDF of a Metropolis-Hastings transition, given a Markov chain state. Its arguments are the final and\n initial states of the transition, in this order. Any other parameter must be passed through global variables. **/\n\nvoid TanWeights(double *states, double *proposals, double *proposals_pdf, double *weights, unsigned state_size, unsigned chain_size, unsigned old_chain_size,\n double *lower_bound, double *upper_bound, double *step, double (*transition_pdf)(double *, double *, double *, double *, double *, unsigned),\n unsigned sort_component)\n{\n unsigned i, j, k, m, n;\n double *proposal, **pointers, pdf;\n\n if (sort_component >= state_size)\n SortComponent = 0;\n else\n SortComponent = sort_component;\n memset(weights + old_chain_size, 0, (chain_size - old_chain_size) * sizeof(double));\n pointers = malloc(chain_size * sizeof(double *));\n for (i = 0; i < chain_size; i++)\n pointers[i] = states + i * state_size;\n qsort(pointers, chain_size, sizeof(double *), SortIndexesAscending);\n for (i = 0; i < chain_size; i++)\n {\n k = pointers[i] - states;\n m = k / state_size;\n proposal = proposals + k;\n for (j = i; j < chain_size; j++)\n {\n n = (pointers[j] - states) / state_size;\n if (m < old_chain_size && n < old_chain_size)\n continue; /* Avoid re-computation of weights already computed. */\n pdf = transition_pdf(proposal, pointers[j], lower_bound, upper_bound, step, state_size);\n if (pdf <= 0.0)\n break;\n weights[m] += pdf;\n }\n for (j = 1; j <= i; j++)\n {\n n = (pointers[i-j] - states) / state_size;\n if (m < old_chain_size && n < old_chain_size)\n continue;\n pdf = transition_pdf(proposal, pointers[i-j], lower_bound, upper_bound, step, state_size);\n if (pdf <= 0.0)\n break;\n weights[m] += pdf;\n }\n if (weights[m] > 0.0)\n weights[m] = proposals_pdf[m] / weights[m];\n }\n free(pointers);\n}\n\n/** TanNormalisation.\n\n - Computes the PDF normalisation proposed by Tan (2006, J.Comp.Graph.Stat., 15, 735), together with an estimate of its undertainty ('error').\n - 'weights' is the array of weights (of size 'element_count') computed by 'TanWeights'. **/\n\ndouble TanNormalisation(double *weights, unsigned element_count, double *error)\n{\n unsigned i;\n double norm, **pointers, x;\n\n /* Perform weighted sum. */\n\n pointers = malloc(element_count * sizeof(double *));\n for (i = 0; i < element_count; i++)\n pointers[i] = weights + i;\n qsort(pointers, element_count, sizeof(double *), SortIndexesAscending);\n norm = 0.0;\n *error = 0.0;\n for (i = 0; i < element_count; i++)\n {\n x = pointers[i][0];\n norm += x;\n *error += x * x;\n }\n *error = sqrt(*error - norm * norm / element_count);\n free(pointers);\n return norm;\n}\n\n/** TanMean.\n\n - Computes the mean of a function as proposed by Tan (2006, J.Comp.Graph.Stat., 15, 735), together with an estimate of its undertainty ('error').\n - 'weights' is the array of weights (of size 'element_count') computed by 'TanWeights'.\n - 'norm' is the PDF normalisation computed by 'TanNormalisation'.\n - 'function' is the array of function values (of size 'element_count') at the proposal states. **/\n\ndouble TanMean(double *weights, double *function, double norm, unsigned element_count, double *error)\n{\n unsigned i;\n double mean, x;\n\n /* Perform weighted sum. */\n\n mean = 0.0;\n *error = 0.0;\n for (i = 0; i < element_count; i++)\n mean += weights[i] * function[i];\n mean /= norm;\n for (i = 0; i < element_count; i++)\n {\n x = (function[i] - mean) * weights[i];\n *error += x * x;\n }\n *error = sqrt(*error) / norm;\n return mean;\n}\n\n/** UniformTransition.\n\n - Samples an n-dimensional transition in a Markov chain, from a uniform PDF.\n - 'state' contains the present state of the Markov chain, comprising 'state_size' doubles.\n - 'proposal' will store the resulting proposed state (same size as 'state').\n - 'lower_bound' and 'upper_bound' must contain the absolute bounds for the variables defining the state.\n - 'step' must contain the parameter defining the size of the transition step. **/\n\nvoid UniformTransition(double *proposal, double *state, double *lower_bound, double *upper_bound, double *step, unsigned state_size)\n{\n unsigned i;\n double min, max;\n\n for (i = 0; i < state_size; i++)\n {\n if (step[i] <= 0.0)\n proposal[i] = state[i];\n else\n {\n min = state[i] - 0.5 * step[i];\n max = min + step[i];\n if (min < lower_bound[i])\n min = lower_bound[i];\n if (max > upper_bound[i])\n max = upper_bound[i];\n proposal[i] = min + (max - min) * gsl_rng_uniform(RandomNumberGenerator);\n }\n }\n}\n\n/** UniformTransitionPDF.\n\n - Computes the n-dimensional PDF value of a Markov chain transition, using a uniform PDF.\n - 'state' contains the state of the Markov chain from which the transition occurs, comprising 'state_size' doubles.\n - 'proposal' contains the proposed state of the chain after the transition (same size as 'state').\n - 'lower_bound' and 'upper_bound' must contain the absolute bounds for the variables defining the state.\n - 'step' must contain the parameter defining the size of the transition step. **/\n\ndouble UniformTransitionPDF(double *proposal, double *state, double *lower_bound, double *upper_bound, double *step, unsigned state_size)\n{\n unsigned i;\n double min, max, density;\n\n density = 1.0;\n for (i = 0; i < state_size; i++)\n {\n if (step[i] <= 0.0)\n continue;\n min = state[i] - 0.5 * step[i];\n max = min + step[i];\n if (min < lower_bound[i])\n min = lower_bound[i];\n if (max > upper_bound[i])\n max = upper_bound[i];\n if (proposal[i] < min || proposal[i] > max)\n return 0.0;\n density /= max - min;\n }\n return density;\n}\n\n/** PowerLawDeviate.\n\n - Generates a power-law deviate with an index 'index' in any closed interval ['min', 'max']. **/\n\ndouble PowerLawDeviate(double min, double max, double index)\n{\n double deviate, std_deviate;\n\n std_deviate = gsl_rng_uniform(RandomNumberGenerator);\n if (index == -1.0)\n deviate = min * exp(std_deviate * log(max / min));\n else if (index == 0.0)\n deviate = min + (max - min) * std_deviate;\n else\n {\n index += 1.0;\n min = pow(min, index);\n max = pow(max, index);\n deviate = pow(min + (max - min) * std_deviate, 1.0 / index);\n }\n return deviate;\n}\n\n/** IsotropicDirection.\n\n - Generates a random direction isotropically distributed within a cone of a given semi-aperture 'semi_aperture'.\n - The output direction has unit norm, by construction.\n - Relies on the fact that, for an isotropic distribution of directions in three dimensions, the projection onto any axis is distributed uniformly in [-1,1]. **/\n\nvoid IsotropicDirection(double semi_aperture, double *direction)\n{\n double cos_polar, sin_polar, azimuth, cos_polar_max;\n\n /* Sample polar angle cosine with uniform PDF in [cos_polar_max, 1]. */\n\n cos_polar_max = cos(semi_aperture);\n cos_polar = cos_polar_max + gsl_rng_uniform(RandomNumberGenerator) * (1.0 - cos_polar_max);\n sin_polar = 1.0 - cos_polar * cos_polar;\n if (sin_polar > 0.0) /* Correct eventual round-off errors. */\n sin_polar = sqrt(sin_polar);\n else\n sin_polar = 0.0;\n\n /* Sample azimuth with uniform PDF in [0, 2 pi). */\n\n azimuth = MATH_2PI * gsl_rng_uniform(RandomNumberGenerator);\n\n /* Compute direction. */\n\n direction[MATH_X] = sin_polar * cos(azimuth);\n direction[MATH_Y] = sin_polar * sin(azimuth);\n direction[MATH_Z] = cos_polar;\n}\n\n/** StandardGaussianDeviates.\n\n - Generates a couple of standard gaussian deviates.\n - Deviates are stored in 'deviates', which must be allocated by the calling program. **/\n\nvoid StandardGaussianDeviates(double *deviates)\n{\n double x, y, r;\n\n y = 2.0 * gsl_rng_uniform(RandomNumberGenerator) - 1.0;\n do\n {\n x = y;\n y = 2.0 * gsl_rng_uniform(RandomNumberGenerator) - 1.0;\n r = x * x + y * y;\n }\n while (r == 0.0 || r >= 1.0);\n r = sqrt(-2.0 * log(r) / r);\n deviates[0] = x * r;\n deviates[1] = y * r;\n}\n\n/** GaussianDeviates.\n\n - Generates a couple of gaussian deviates with mean 'mean' and standard deviation 'std_dev'.\n - Deviates are stored in 'deviates', which must be allocated by the calling program. **/\n\nvoid GaussianDeviates(double *deviates, double mean, double std_dev)\n{\n double x, y, r;\n\n y = 2.0 * gsl_rng_uniform(RandomNumberGenerator) - 1.0;\n do\n {\n x = y;\n y = 2.0 * gsl_rng_uniform(RandomNumberGenerator) - 1.0;\n r = x * x + y * y;\n }\n while (r == 0.0 || r >= 1.0);\n r = sqrt(-2.0 * log(r) / r) * std_dev;\n deviates[0] = x * r + mean;\n deviates[1] = y * r + mean;\n}\n\n/** ComplexGaussianDeviates.\n\n - Generates a gaussian deviate with mean 'mean' and standard deviation 'std_dev' in the complex plane. **/\n\ncomplex ComplexGaussianDeviates(complex mean, complex std_dev)\n{\n double x, y, r;\n complex deviate;\n\n y = 2.0 * gsl_rng_uniform(RandomNumberGenerator) - 1.0;\n do\n {\n x = y;\n y = 2.0 * gsl_rng_uniform(RandomNumberGenerator) - 1.0;\n r = x * x + y * y;\n }\n while (r == 0.0 || r >= 1.0);\n r = sqrt(-2.0 * log(r) / r);\n deviate = mean + r * (x * creal(std_dev) + I * y * cimag(std_dev));\n return deviate;\n}\n\n#endif\n\n/*** End of 'mathematics.h'. ***/\n", "meta": {"hexsha": "32f3cf1c0ec8ca27053d3f8245143b0c190c85aa", "size": 36811, "ext": "h", "lang": "C", "max_stars_repo_path": "src/lib/nrMath/mathematics.h", "max_stars_repo_name": "eduardomgutierrez/RIAF_radproc", "max_stars_repo_head_hexsha": "0e4166f04cce27fed2cbd2c7078023c10e0e8d12", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-08-30T06:56:03.000Z", "max_stars_repo_stars_event_max_datetime": "2021-08-30T06:56:03.000Z", "max_issues_repo_path": "src/lib/nrMath/mathematics.h", "max_issues_repo_name": "eduardomgutierrez/RIAF_radproc", "max_issues_repo_head_hexsha": "0e4166f04cce27fed2cbd2c7078023c10e0e8d12", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/lib/nrMath/mathematics.h", "max_forks_repo_name": "eduardomgutierrez/RIAF_radproc", "max_forks_repo_head_hexsha": "0e4166f04cce27fed2cbd2c7078023c10e0e8d12", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.0704934542, "max_line_length": 167, "alphanum_fraction": 0.6834913477, "num_tokens": 9415, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7981867777396212, "lm_q2_score": 0.6513548714339145, "lm_q1q2_score": 0.5199028459948414}} {"text": "#pragma once\n#include \"utility/scope_guard.h\"\n#include \"utility/types.h\"\n#include \n#include \n#include \n\n#define scoped_fesetround(mode) \\\n int SCOPE_GUARD_PP_UNIQUE(_rounding_mode) = fegetround(); \\\n int SCOPE_GUARD_PP_UNIQUE(_rounding_ret) = fesetround(mode); \\\n (void)SCOPE_GUARD_PP_UNIQUE(_rounding_ret); \\\n assert(SCOPE_GUARD_PP_UNIQUE(_rounding_ret) == 0); \\\n SCOPE(exit) { fesetround(SCOPE_GUARD_PP_UNIQUE(_rounding_mode)); }\n\ntemplate inline T square(T a) { return a * a; }\n\ntemplate inline T cube(T a) { return a * a * a; }\n\ntemplate inline T clamp(T x, T min, T max)\n{\n x = (x < min) ? min : x;\n x = (x > max) ? max : x;\n return x;\n}\n\n// linear interpolator\ntemplate R itp_linear(const R y[], R mu)\n{\n return y[0] * (1 - mu) + y[1] * mu;\n}\n\n// Catmull-Rom interpolator\ntemplate R itp_catmull(const R y[], R mu)\n{\n R mu2 = mu * mu;\n R mu3 = mu2 * mu;\n R a[] = {-R(0.5) * y[0] + R(1.5) * y[1] - R(1.5) * y[2] + R(0.5) * y[3],\n y[0] - R(2.5) * y[1] + R(2) * y[2] - R(0.5) * y[3],\n -R(0.5) * y[0] + R(0.5) * y[2], y[1]};\n return a[0] * mu3 + a[1] * mu2 + a[2] * mu + a[3];\n}\n\n//------------------------------------------------------------------------------\n// Fixed point routines\n// suffix 'xN', N = bit size of the integer part\n// prefix 'l' = 64-bit operation, 32-bit otherwise\n//\n// 'fx' number to fixed\n// 'ix' integer part, 'rx' fractional part\n// 'ffx' fixed to f32, 'dfx' fixed to f64\n\n// number to Q32,32\ntemplate inline constexpr i64 lfx32(R x)\n{\n return i64(x * (i64)4294967296);\n}\n// number to Q16,16\ntemplate inline constexpr i32 fx16(R x)\n{\n return i32(x * (i32)65536);\n}\n// number to Q16,48\ntemplate inline constexpr i64 lfx16(R x)\n{\n return i64(x * (i64)281474976710656);\n}\n// number to Q8,24\ntemplate inline constexpr i32 fx8(R x)\n{\n return i32(x * (i32)16777216);\n}\n// number to Q8,56\ntemplate inline constexpr i64 lfx8(R x)\n{\n return i64(x * (i64)72057594037927936);\n}\n\n// Q32,32 integer part\ninline constexpr i64 lix32(i64 x) { return x / 4294967296; }\ninline constexpr u64 lix32(u64 x) { return x / 4294967296; }\ntemplate T lix32(T) = delete;\n// Q16,16 integer part\ninline constexpr i32 ix16(i32 x) { return x / 65536; }\ninline constexpr u32 ix16(u32 x) { return x / 65536; }\ntemplate T ix16(T) = delete;\n// Q16,48 integer part\ninline constexpr i64 lix16(i64 x) { return x / 281474976710656; }\ninline constexpr u64 lix16(u64 x) { return x / 281474976710656; }\ntemplate T lix16(T) = delete;\n// Q8,24 integer part\ninline constexpr i32 ix8(i32 x) { return x / 16777216; }\ninline constexpr u32 ix8(u32 x) { return x / 16777216; }\ntemplate T ix8(T) = delete;\n// Q8,56 integer part\ninline constexpr i64 lix8(i64 x) { return x / 72057594037927936; }\ninline constexpr u64 lix8(u64 x) { return x / 72057594037927936; }\ntemplate T lix8(T) = delete;\n\n// Q32,32 fractional part\ninline constexpr u64 lrx32(i64 x) { return x & 4294967295; }\ninline constexpr u64 lrx32(u64 x) { return x & 4294967295; }\ntemplate T lrx32(T) = delete;\n// Q16,16 fractional part\ninline constexpr u32 rx16(i32 x) { return x & 65535; }\ninline constexpr u32 rx16(u32 x) { return x & 65535; }\ntemplate T rx16(T) = delete;\n// Q16,48 fractional part\ninline constexpr u64 lrx16(i64 x) { return x & 281474976710655; }\ninline constexpr u64 lrx16(u64 x) { return x & 281474976710655; }\ntemplate T lrx16(T) = delete;\n// Q8,24 fractional part\ninline constexpr u32 rx8(i32 x) { return x & 16777215; }\ninline constexpr u32 rx8(u32 x) { return x & 16777215; }\ntemplate T rx8(T) = delete;\n// Q8,56 fractional part\ninline constexpr u64 lrx8(i64 x) { return x & 72057594037927935; }\ninline constexpr u64 lrx8(u64 x) { return x & 72057594037927935; }\ntemplate T lrx8(T) = delete;\n\n// Q32,32 number to real\ninline constexpr f32 lffx32(i64 x) { return x / 4294967296.0f; }\ninline constexpr f32 lffx32(u64 x) { return x / 4294967296.0f; }\ntemplate f32 lffx32(T x) = delete;\ninline constexpr f64 ldfx32(i64 x) { return x / 4294967296.0; }\ninline constexpr f64 ldfx32(u64 x) { return x / 4294967296.0; }\ntemplate f64 ldfx32(T x) = delete;\n// Q16,16 number to real\ninline constexpr f32 ffx16(i32 x) { return x / 65536.0f; }\ninline constexpr f32 ffx16(u32 x) { return x / 65536.0f; }\ntemplate f32 ffx16(T x) = delete;\ninline constexpr f64 dfx16(i32 x) { return x / 65536.0; }\ninline constexpr f64 dfx16(u32 x) { return x / 65536.0; }\ntemplate f64 dfx16(T x) = delete;\n// Q16,48 number to real\ninline constexpr f32 lffx16(i64 x) { return x / 281474976710656.0f; }\ninline constexpr f32 lffx16(u64 x) { return x / 281474976710656.0f; }\ntemplate f32 lffx16(T x) = delete;\ninline constexpr f64 ldfx16(i64 x) { return x / 281474976710656.0; }\ninline constexpr f64 ldfx16(u64 x) { return x / 281474976710656.0; }\ntemplate f64 ldfx16(T x) = delete;\n// Q8,24 number to real\ninline constexpr f32 ffx8(i32 x) { return x / 16777216.0f; }\ninline constexpr f32 ffx8(u32 x) { return x / 16777216.0f; }\ntemplate f32 ffx8(T x) = delete;\ninline constexpr f64 dfx8(i32 x) { return x / 16777216.0; }\ninline constexpr f64 dfx8(u32 x) { return x / 16777216.0; }\ntemplate f64 dfx8(T x) = delete;\n// Q8,56 number to real\ninline constexpr f32 lffx8(i64 x) { return x / 72057594037927936.0f; }\ninline constexpr f32 lffx8(u64 x) { return x / 72057594037927936.0f; }\ntemplate f32 lffx8(T x) = delete;\ninline constexpr f64 ldfx8(i64 x) { return x / 72057594037927936.0; }\ninline constexpr f64 ldfx8(u64 x) { return x / 72057594037927936.0; }\ntemplate f64 ldfx8(T x) = delete;\n", "meta": {"hexsha": "d7546179aba8344d6086b1ce00d438d76d73dd47", "size": 5888, "ext": "h", "lang": "C", "max_stars_repo_path": "sources/utility/arithmetic.h", "max_stars_repo_name": "jpcima/cws80", "max_stars_repo_head_hexsha": "ce37a49caed50a4b7baccfed288c2f5555af91c7", "max_stars_repo_licenses": ["BSL-1.0"], "max_stars_count": 4.0, "max_stars_repo_stars_event_min_datetime": "2019-05-20T19:27:09.000Z", "max_stars_repo_stars_event_max_datetime": "2019-11-03T04:21:53.000Z", "max_issues_repo_path": "sources/utility/arithmetic.h", "max_issues_repo_name": "jpcima/cws80", "max_issues_repo_head_hexsha": "ce37a49caed50a4b7baccfed288c2f5555af91c7", "max_issues_repo_licenses": ["BSL-1.0"], "max_issues_count": 5.0, "max_issues_repo_issues_event_min_datetime": "2019-05-21T12:56:22.000Z", "max_issues_repo_issues_event_max_datetime": "2019-06-23T21:33:33.000Z", "max_forks_repo_path": "sources/utility/arithmetic.h", "max_forks_repo_name": "jpcima/cws80", "max_forks_repo_head_hexsha": "ce37a49caed50a4b7baccfed288c2f5555af91c7", "max_forks_repo_licenses": ["BSL-1.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 37.9870967742, "max_line_length": 80, "alphanum_fraction": 0.6569293478, "num_tokens": 2114, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7577943712746406, "lm_q2_score": 0.6859494485880928, "lm_q1q2_score": 0.5198086311190002}} {"text": "/* Implementation for Gillespie's direct method */\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"ssa.h\"\n#include \"dm.h\"\n\n\nconst gsl_rng_type *SSARNGT;\ngsl_rng *SSARNG;\n\n\nINDEX nextreaction(double *propensities, INDEX m)\n{\n\tdouble r1 = gsl_ran_flat(SSARNG, 0.0, 1.0) * propensities[m - 1];\n\tINDEX i = 0;\n\tfor(i = 0; i < m; i++)\n\t\tif(r1 <= propensities[i])\n\t\t\treturn i;\n\treturn -1;\n}\n\n\n/* \nPerform one step of the Gillespie direct method, selecting a\nreaction to perform and altering molecule counts and time\naccordingly.\n*/\nvoid ssa_dmstep(INDEX n, INDEX m, double *propensities, INDEX **R, INDEX **P, double *k, COUNT *x, double *t)\n{\n\tpropensities[0] = ssa_h(R[0], x, n) * k[0];\n\tINDEX i;\n\tfor (i = 1; i < m; i++)\n\t\tpropensities[i] = ssa_h(R[i], x, n) * k[i] + propensities[i - 1];\n\n\n\tif (propensities[m - 1] > 0.0) {\n\t\t*t += gsl_ran_exponential(SSARNG, 1 / propensities[m - 1]);\n\t\tINDEX next = nextreaction(propensities, m);\n\t\tssa_doreaction(R[next], P[next], x, n);\n\t}\n}\n\n\nvoid ssa_dm(INDEX **R, INDEX **P, INDEX n, INDEX m, double *k, COUNT *x, double T)\n{\n\tgsl_rng_env_setup();\n\tSSARNGT = gsl_rng_default;\n\tSSARNG = gsl_rng_alloc(SSARNGT);\n\tgsl_rng_set(SSARNG, time(NULL));\n\n double t = 0.0;\n double *propensities = malloc(sizeof(double) * m);\n\t\n\tdo {\n\t\tssa_dmstep(n, m, propensities, R, P, k, x, &t);\n\t\tssa_printstate(t, x, n);\n\t} while(t < T && propensities[m - 1] > 0.0);\n\n\tfree(propensities);\n}\n", "meta": {"hexsha": "abd13f506beb9f0c6bb12454d6760407ea6a9d62", "size": 1513, "ext": "c", "lang": "C", "max_stars_repo_path": "lib/src/dm.c", "max_stars_repo_name": "lgrozinger/ssapy", "max_stars_repo_head_hexsha": "f8366e11609bdaa0bb7997dc4177d6e6a5eabeb9", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lib/src/dm.c", "max_issues_repo_name": "lgrozinger/ssapy", "max_issues_repo_head_hexsha": "f8366e11609bdaa0bb7997dc4177d6e6a5eabeb9", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "lib/src/dm.c", "max_forks_repo_name": "lgrozinger/ssapy", "max_forks_repo_head_hexsha": "f8366e11609bdaa0bb7997dc4177d6e6a5eabeb9", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 22.5820895522, "max_line_length": 109, "alphanum_fraction": 0.6457369465, "num_tokens": 528, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7690802370707281, "lm_q2_score": 0.6757646010190477, "lm_q1q2_score": 0.5197171995557353}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#define _USE_MATH_DEFINES\n\n// global variables\nint n = 10;\n\ndouble incident(double x);\ndouble green_function(double r1[n][3], double r2[n][3]);\n\nint main()\n{\n\tint i, j, k;\n\tdouble x, y, z;\n\tdouble scatterers[n][3];\n\t\n\tgsl_matrix * mmat = gsl_matrix_alloc (n,n);\n\n\tsrand((unsigned)time(NULL));\n\tfor (i = 1; i < n; i++)\n\t{\n\t\tx = 20*(double)rand()/RAND_MAX;\n\t\ty = 50*(double)rand()/RAND_MAX;\n\t\tz = 30*(double)rand()/RAND_MAX;\n\t\t\n\t\tscatterers[i][0] = x;\n\t\tscatterers[i][1] = y;\n\t\tscatterers[i][2] = z;\n\n\t\tprintf(\"Scatterer %d position: %lf %lf %lf \\n\", i, scatterers[i][0], scatterers[i][1], scatterers[i][2]);\n\t\n\n\t//double field_scatterer = incident(scatterers[i][0]);\n\n\t//printf(\"Incident field at scatterer %d: %lf\\n\", i, field_scatterer);\n\t\n\t// fixed below\n\t\tdouble field_scatterer = incident(scatterers[i][0]);\t\n\t\n\t// solving the matrix equation\n\t\t\n\t\tgsl_matrix_set (mmat, i,i, field_scatterer);\n\t\t// continue rewriting this part\n\n\t//\tgsl_vector_view b\n\t//\t\t= gsl_vector_view_array (field_scatterer, n);\n\t// gsl vector set instead\n\t\t\t\n\t//\tgsl_vector *total_field = gsl_vector_alloc (n);\n\t}\n\tdouble green = green_function(scatterers, scatterers);\n\tint s;\n\t//gsl_permutation * p = gsl_permutation_alloc (n);\n\t//gsl_linalg_LU_decomp (&green.matrix, p, &s);\n\t//gsl_linalg_LU_solve (&green.matrix, p, &b.vector, total_field);\n\t\n\t//printf(\"Total field = \\n\");\n\t//gsl_vector_fprintf (stdout, total_field, \"%g\");\n\n\t//gsl_permutation_free (p);\n\n\t// defining surface of sphere\n\tdouble phi[150];\n\tdouble theta[150];\n\tint r = 500;\n\n\tfor (i=(M_PI-2); i < (M_PI+2); i++)\n\t{\n\t\tphi[i] =(double)(i)/((M_PI-2) - (M_PI+2));\n\n\t}\n\tfor (i=(M_PI/2 - 2); i < (M_PI/2 +2); i++)\n\t{\n\t\ttheta[i] = (double)(i)/((M_PI/2 - 2) - (M_PI/2 +2));\n\t}\n\n\treturn 0;\t\n}\n\ndouble incident(double x)\n{\n\tdouble E_0 = 1.0;\n\n\treturn E_0*cexp(1*I*2*M_PI*x);\n}\n\ndouble green_function(double r1[n][3], double r2[n][3])\n{\n\tint i, j;\n\tgsl_matrix * m = gsl_matrix_alloc (n,n);\n\t\n\tdouble r[n], g[n];\n\tfor (i = 0; i < n; i++)\n\t{\n\t\tfor (j = 0; j < n; j++)\n\t\t{\t\n\t\t\tr[n] = sqrt((r1[i][1]-r2[j][1])*(r1[i][1]-r2[j][1]) + (r1[i][2]-r2[j][2])*(r1[i][2]-r2[j][2]) + (r1[i][3] - r2[j][3])*(r1[i][3] - r2[j][3]));\n\n\t\t\tif (r[n] == 0.0)\n\t\t\t{\n\t\t\t\tg[n] = 1.0;\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tg[n] = exp(1*I*2*M_PI*r[n])/(4*M_PI*r[n]);\n\t\t\t}\n\n\t\t\tgsl_matrix_set (m, i, j, g[n]);\n\t\t}\n\t}\n\t\n\tfor (i = 0; i < 100; i++)\n\t{\n\t\tfor (j = 0; j < n; j++)\n\t\t{\n\t\t\tprintf (\"m(%d,%d) = %g\\n\", i, j,\n\t\t\t\t\tgsl_matrix_get (m, i, j));\n\t\t}\n\t}\n\tgsl_matrix_free (m);\n}\n\n", "meta": {"hexsha": "2d0cb023b56d803ecc42b9ce3a378a2683c0212c", "size": 2621, "ext": "c", "lang": "C", "max_stars_repo_path": "c_rewrite.c", "max_stars_repo_name": "alula-borealis/gravitational_waves", "max_stars_repo_head_hexsha": "e058aefe639baf7ab8721707b94c7204b38d7462", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-11-25T12:45:47.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-25T12:45:47.000Z", "max_issues_repo_path": "c_rewrite.c", "max_issues_repo_name": "alula-borealis/gravitational_waves", "max_issues_repo_head_hexsha": "e058aefe639baf7ab8721707b94c7204b38d7462", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "c_rewrite.c", "max_forks_repo_name": "alula-borealis/gravitational_waves", "max_forks_repo_head_hexsha": "e058aefe639baf7ab8721707b94c7204b38d7462", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 20.3178294574, "max_line_length": 144, "alphanum_fraction": 0.5841281953, "num_tokens": 997, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.882427872638409, "lm_q2_score": 0.588889130767832, "lm_q1q2_score": 0.5196521828833399}} {"text": "/* specfunc/bessel_Y0.c\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 2 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.\n */\n\n/* Author: G. Jungman */\n\n#include \n#include \n#include \n#include \"gsl_sf_trig.h\"\n#include \"gsl_sf_bessel.h\"\n\n#include \"error.h\"\n\n#include \"bessel.h\"\n#include \"bessel_amp_phase.h\"\n#include \"cheb_eval.c\"\n\n/*-*-*-*-*-*-*-*-*-*-*-* Private Section *-*-*-*-*-*-*-*-*-*-*-*/\n\n/* based on SLATEC besy0, 1980 version, w. fullerton */\n\n/* chebyshev expansions\n\n series for by0 on the interval 0.\t to 1.60000d+01\n\t\t\t\t\twith weighted error 1.20e-17\n\t\t\t\t\t log weighted error 16.92\n\t\t\t significant figures required 16.15\n\t\t\t\t decimal places required 17.48\n*/\n\nstatic double by0_data[13] = {\n -0.011277839392865573,\n -0.128345237560420350,\n -0.104378847997942490,\n 0.023662749183969695,\n -0.002090391647700486,\n 0.000103975453939057,\n -0.000003369747162423,\n 0.000000077293842676,\n -0.000000001324976772,\n 0.000000000017648232,\n -0.000000000000188105,\n 0.000000000000001641,\n -0.000000000000000011\n};\nstatic cheb_series by0_cs = {\n by0_data,\n 12,\n -1, 1,\n 8\n};\n\n\n/*-*-*-*-*-*-*-*-*-*-*-* Functions with Error Codes *-*-*-*-*-*-*-*-*-*-*-*/\n\nint gsl_sf_bessel_Y0_e(const double x, gsl_sf_result * result)\n{\n const double two_over_pi = 2.0/M_PI;\n const double xmax = 1.0/GSL_DBL_EPSILON;\n\n /* CHECK_POINTER(result) */\n\n if (x <= 0.0) {\n DOMAIN_ERROR(result);\n }\n else if(x < 4.0) {\n gsl_sf_result J0;\n gsl_sf_result c;\n int stat_J0 = gsl_sf_bessel_J0_e(x, &J0);\n cheb_eval_e(&by0_cs, 0.125*x*x-1.0, &c);\n result->val = two_over_pi*(-M_LN2 + log(x))*J0.val + 0.375 + c.val;\n result->err = 2.0 * GSL_DBL_EPSILON * fabs(result->val) + c.err;\n return stat_J0;\n }\n else if(x < xmax) {\n /* Leading behaviour of phase is x, which is exact,\n * so the error is bounded.\n */\n const double z = 32.0/(x*x) - 1.0;\n gsl_sf_result c1;\n gsl_sf_result c2;\n gsl_sf_result sp;\n const int stat_c1 = cheb_eval_e(&_gsl_sf_bessel_amp_phase_bm0_cs, z, &c1);\n const int stat_c2 = cheb_eval_e(&_gsl_sf_bessel_amp_phase_bth0_cs, z, &c2);\n const int stat_sp = gsl_sf_bessel_sin_pi4_e(x, c2.val/x, &sp);\n const double sqrtx = sqrt(x);\n const double ampl = (0.75 + c1.val) / sqrtx;\n result->val = ampl * sp.val;\n result->err = fabs(sp.val) * c1.err/sqrtx + fabs(ampl) * sp.err;\n result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);\n return GSL_ERROR_SELECT_3(stat_sp, stat_c1, stat_c2);\n }\n else {\n UNDERFLOW_ERROR(result);\n }\n}\n\n\n/*-*-*-*-*-*-*-*-*-* Functions w/ Natural Prototypes *-*-*-*-*-*-*-*-*-*-*/\n\n#include \"eval.h\"\n\ndouble gsl_sf_bessel_Y0(const double x)\n{\n EVAL_RESULT(gsl_sf_bessel_Y0_e(x, &result));\n}\n", "meta": {"hexsha": "9f29aadf156d6b0ed13ea2370f722300e0bfc622", "size": 3465, "ext": "c", "lang": "C", "max_stars_repo_path": "code/em/treba/gsl-1.0/specfunc/bessel_Y0.c", "max_stars_repo_name": "ICML14MoMCompare/spectral-learn", "max_stars_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-12-18T18:09:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-10T11:31:28.000Z", "max_issues_repo_path": "code/em/treba/gsl-1.0/specfunc/bessel_Y0.c", "max_issues_repo_name": "ICML14MoMCompare/spectral-learn", "max_issues_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "code/em/treba/gsl-1.0/specfunc/bessel_Y0.c", "max_forks_repo_name": "ICML14MoMCompare/spectral-learn", "max_forks_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2015-10-02T01:32:59.000Z", "max_forks_repo_forks_event_max_datetime": "2015-10-02T01:32:59.000Z", "avg_line_length": 28.1707317073, "max_line_length": 79, "alphanum_fraction": 0.6551226551, "num_tokens": 1147, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7799929002541068, "lm_q2_score": 0.6654105521116443, "lm_q1q2_score": 0.5190155064012479}} {"text": "/* multifit/fdjac.c\n * \n * Copyright (C) 2013 Patrick Alken\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n *\n *\n * This module contains routines for approximating the Jacobian with finite\n * differences for nonlinear least-squares fitting.\n */\n\n#include \n#include \n#include \n#include \n#include \n\nstatic int fdjac(const gsl_vector *x, const gsl_vector *wts,\n gsl_multifit_function_fdf *fdf,\n const gsl_vector *f, gsl_matrix *J);\n\n/*\nfdjac()\n Compute approximate Jacobian using forward differences\n\nInputs: x - parameter vector\n wts - data weights\n fdf - fdf struct\n f - (input) vector of function values f_i(x)\n J - (output) Jacobian matrix\n\nReturn: success or error\n*/\n\nstatic int\nfdjac(const gsl_vector *x, const gsl_vector *wts,\n gsl_multifit_function_fdf *fdf, const gsl_vector *f, gsl_matrix *J)\n{\n int status = 0;\n size_t i, j;\n double h;\n const double epsfcn = 0.0;\n double eps = sqrt(GSL_MAX(epsfcn, GSL_DBL_EPSILON));\n\n for (j = 0; j < fdf->p; ++j)\n {\n double xj = gsl_vector_get(x, j);\n\n /* use column j of J as temporary storage for f(x + dx) */\n gsl_vector_view v = gsl_matrix_column(J, j);\n\n h = eps * fabs(xj);\n if (h == 0.0)\n h = eps;\n\n /* perturb x_j to compute forward difference */\n gsl_vector_set((gsl_vector *) x, j, xj + h);\n\n status += gsl_multifit_eval_wf (fdf, x, wts, &v.vector);\n if (status)\n return status;\n\n /* restore x_j */\n gsl_vector_set((gsl_vector *) x, j, xj);\n\n h = 1.0 / h;\n for (i = 0; i < fdf->n; ++i)\n {\n double fnext = gsl_vector_get(&v.vector, i);\n double fi = gsl_vector_get(f, i);\n\n gsl_matrix_set(J, i, j, (fnext - fi) * h);\n }\n }\n\n return status;\n} /* fdjac() */\n\n/*\ngsl_multifit_fdfsolver_dif_df()\n Compute approximate Jacobian using finite differences\n\nInputs: x - parameter vector\n wts - data weights (set to NULL if not needed)\n fdf - fdf\n f - (input) function values f_i(x)\n J - (output) approximate Jacobian matrix\n\nReturn: success or error\n*/\n\nint\ngsl_multifit_fdfsolver_dif_df(const gsl_vector *x, const gsl_vector *wts,\n gsl_multifit_function_fdf *fdf,\n const gsl_vector *f, gsl_matrix *J)\n{\n return fdjac(x, wts, fdf, f, J);\n} /* gsl_multifit_fdfsolver_dif_df() */\n\n#ifndef GSL_DISABLE_DEPRECATED\n\n/*\ngsl_multifit_fdfsolver_dif_fdf()\n Compute function values (analytic) and approximate Jacobian using finite\ndifferences\n\nInputs: x - parameter vector\n fdf - fdf\n f - (output) function values f_i(x)\n J - (output) approximate Jacobian matrix\n\nReturn: success or error\n*/\n\nint\ngsl_multifit_fdfsolver_dif_fdf(const gsl_vector *x,\n gsl_multifit_function_fdf *fdf,\n gsl_vector *f, gsl_matrix *J)\n{\n int status = 0;\n\n status = gsl_multifit_eval_wf(fdf, x, NULL, f);\n if (status)\n return status;\n\n status = fdjac(x, NULL, fdf, f, J);\n if (status)\n return status;\n\n return status;\n} /* gsl_multifit_fdfsolver_dif_fdf() */\n\n#endif /* !GSL_DISABLE_DEPRECATED */\n", "meta": {"hexsha": "f00881e60d1fbf01b93df16c26f770e7929b12b4", "size": 3982, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.6/multifit/fdjac.c", "max_stars_repo_name": "ielomariala/Hex-Game", "max_stars_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-06-14T11:51:37.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-14T11:51:37.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/multifit/fdjac.c", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-12-16T17:41:24.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-22T00:00:16.000Z", "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/multifit/fdjac.c", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-01-20T16:22:57.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-14T12:31:02.000Z", "avg_line_length": 27.2739726027, "max_line_length": 81, "alphanum_fraction": 0.6418884982, "num_tokens": 1088, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7248702880639791, "lm_q2_score": 0.7154240018510026, "lm_q1q2_score": 0.518589602309621}} {"text": "#include \"asf.h\"\n#include \"ceos.h\"\n\n#include \n#include \n#include \n#include \n\nstruct pp_erfin_params {\n int npixels,nlines;\n double satellite_height; /* earth center to satellite height (PP \"rsc\") */\n double slant_first; /* slant range to first pixel */\n double slant_last; /* slant range to last pixel */\n double nominal_pixsize_range;\n};\n\nstatic double getObjective(double R, void *params)\n{\n struct pp_erfin_params *p =\n (struct pp_erfin_params *)params;\n\n double H=p->satellite_height;\n double sf=p->slant_first;\n double HHRR=H*H + R*R;\n /* Convert slant_first to ground range */\n double g=R*acos( (HHRR - sf*sf) / (2*H*R));\n /* Add width of CEOS image in ground range */\n g += (p->npixels-1) * p->nominal_pixsize_range;\n /* Compute slant range to last pixel */\n double slant_last_R=sqrt(HHRR - 2*H*R*cos(g/R));\n /* Compare with slant_last from CEOS */\n return slant_last_R-p->slant_last;\n}\n\nvoid pp_get_corrected_vals(char *sarName, double *corrected_earth_radius,\n double *corrected_azimuth_time_per_pixel)\n{\n int status;\n int iter = 0, max_iter = 100;\n const gsl_root_fsolver_type *T;\n gsl_root_fsolver *s;\n gsl_function F;\n gsl_error_handler_t *prev;\n struct pp_erfin_params params;\n\n double nominal_pixsize_azimuth;\n double nadir_radius; /* earth radius at nadir */\n double pp_earth_radius; /* f'd up PP Earth radius from start of swath */\n double seconds_per_azimuth_line; /* PP's real azimuth resolution */\n double lo, hi; /* starting points for the bisection algorithm */\n struct VFDRECV facdr;\n\n get_asf_facdr(sarName, &facdr);\n\n /* Find the PP's earth radius with an iterative search */\n F.function = &getObjective;\n F.params = ¶ms;\n\n params.npixels=facdr.npixels;\n params.nlines=facdr.nlines;\n params.nominal_pixsize_range=facdr.rapixspc;\n nominal_pixsize_azimuth=facdr.azpixspc;\n nadir_radius=1.0e3*facdr.eradnadr;\n params.satellite_height=1.0e3*(facdr.scalt+facdr.eradnadr);\n params.slant_first=1.0e3*facdr.sltrngfp;\n params.slant_last=1.0e3*facdr.sltrnglp;\n\n prev = gsl_set_error_handler_off();\n\n lo = nadir_radius - 2000;\n hi = nadir_radius + 2000;\n\n T = gsl_root_fsolver_brent;\n s = gsl_root_fsolver_alloc (T);\n gsl_root_fsolver_set (s, &F, lo, hi);\n\n do {\n ++iter;\n status = gsl_root_fsolver_iterate(s);\n pp_earth_radius = gsl_root_fsolver_root(s);\n status = gsl_root_test_residual(\n getObjective(pp_earth_radius, (void*)¶ms), 1.0e-4);\n } while (status == GSL_CONTINUE && iter < max_iter);\n\n if (status == GSL_SUCCESS) {\n //printf(\"Converged after %d iterations.\\n\", iter);\n //printf(\"PP Earth Radius: %.3f m\\n\",pp_earth_radius);\n //printf(\" (for comparison) Nadir Earth Radius: %.3f m\\n\",nadir_radius);\n *corrected_earth_radius = pp_earth_radius;\n } else {\n asfPrintWarning(\"Failed to determine PP earth radius!\\n\"\n \"iter: %d, pp_earth_radius=%.3f, res=%.5f\\n\"\n \"Proceeding using the nadir radius: %.3f m\\n\"\n \"Starting points were: lo: %.3f -> %.4f\\n\"\n \" hi: %.3f -> %.4f\\n\",\n iter, pp_earth_radius,\n getObjective(pp_earth_radius, (void*)¶ms),\n nadir_radius,\n lo, getObjective(lo, (void*)¶ms),\n hi, getObjective(hi, (void*)¶ms));\n *corrected_earth_radius = nadir_radius;\n }\n\n gsl_set_error_handler(prev);\n\n // Find the PP's per-second azimuth pixel spacing\n seconds_per_azimuth_line=nominal_pixsize_azimuth/facdr.swathvel;\n //printf(\"PP seconds per azimuth line: %.9f s/line\\n\",seconds_per_azimuth_line);\n //printf(\" (for comparison) PP interpolated lines per second: %.3f lines/s\\n\",1.0/seconds_per_azimuth_line);\n //printf(\" (for comparison) FACDR swath velocity: %.3f m/s\\n\",facdr.swathvel);\n\n //double R=pp_earth_radius;\n //double H=params.satellite_height;\n //double HHRR=H*H + R*R;\n //double slant=0.5*(params.slant_first+params.slant_last);\n //double rg_center=R*acos( (HHRR - slant*slant) / (2*H*R));\n //double vs=sqrt(facdr.scxvel*facdr.scxvel + facdr.scyvel*facdr.scyvel + facdr.sczvel*facdr.sczvel);\n //double vsg = vs * pp_earth_radius/params.satellite_height*cos(rg_center/pp_earth_radius);\n\n //printf(\" (for comparison) PP-style recalc velocity: %.3f m/s\\n\",vsg);\n\n *corrected_azimuth_time_per_pixel = seconds_per_azimuth_line;\n\n // Free the solver\n gsl_root_fsolver_free(s);\n}\n", "meta": {"hexsha": "110ea7f2b49f2b5e6885a350d866f215fd39665d", "size": 4753, "ext": "c", "lang": "C", "max_stars_repo_path": "src/asf_meta/pp_corrected_vals.c", "max_stars_repo_name": "glshort/MapReady", "max_stars_repo_head_hexsha": "c9065400a64c87be46418ab32e3a251ca2f55fd5", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2017-12-31T05:33:28.000Z", "max_stars_repo_stars_event_max_datetime": "2021-07-28T01:51:22.000Z", "max_issues_repo_path": "src/asf_meta/pp_corrected_vals.c", "max_issues_repo_name": "glshort/MapReady", "max_issues_repo_head_hexsha": "c9065400a64c87be46418ab32e3a251ca2f55fd5", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/asf_meta/pp_corrected_vals.c", "max_forks_repo_name": "glshort/MapReady", "max_forks_repo_head_hexsha": "c9065400a64c87be46418ab32e3a251ca2f55fd5", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 7.0, "max_forks_repo_forks_event_min_datetime": "2017-04-26T18:18:33.000Z", "max_forks_repo_forks_event_max_datetime": "2020-05-15T08:01:09.000Z", "avg_line_length": 37.4251968504, "max_line_length": 114, "alphanum_fraction": 0.6473806017, "num_tokens": 1333, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8479677583778258, "lm_q2_score": 0.611381973294151, "lm_q1q2_score": 0.518432201406853}} {"text": " /** \n * File: utils.h \n * \n * Author: Vishal R (vishalr@pesu.pes.edu or vishalramesh01@gmail.com) \n * \n * Summary of File: \n * Matrix operation library required for cdnn. Contains all the header files for matrix operations. \n */ \n\n#ifndef UTILS_H\n#define UTILS_H\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#ifdef __cplusplus\nextern \"C\"{\n#endif\n\n typedef struct array{\n float * matrix;\n int shape[2];\n }dARRAY;\n\n dARRAY * zeros(int * dims);\n dARRAY * ones(int * dims);\n dARRAY * eye(int * dims);\n dARRAY * randn(int * dims);\n dARRAY * add(dARRAY * MatrixA, dARRAY * MatrixB);\n dARRAY * addScalar(dARRAY * matrix, float scalar);\n dARRAY * subtract(dARRAY * MatrixA, dARRAY * MatrixB);\n dARRAY * subScalar(dARRAY * matrix, float scalar);\n dARRAY * sum(dARRAY * matrix, int axis);\n dARRAY * transpose(dARRAY * Matrix);\n dARRAY * dot(dARRAY * MatrixA, dARRAY * MatrixB);\n dARRAY * multiply(dARRAY * MatrixA, dARRAY * MatrixB);\n dARRAY * mulScalar(dARRAY * matrix, float scalar);\n dARRAY * divison(dARRAY * MatrixA, dARRAY * MatrixB);\n dARRAY * divScalar(dARRAY * matrix, float scalar);\n dARRAY * power(dARRAY * matrix, float power);\n dARRAY * squareroot(dARRAY * matrix);\n dARRAY * exponentional(dARRAY * matrix);\n dARRAY * b_cast(dARRAY * MatrixA, dARRAY * MatrixB);\n dARRAY * reshape(dARRAY * matrix, int * dims);\n\n int * permutation(int length);\n float mean(dARRAY * matrix);\n float var(dARRAY * matrix, char * type);\n float std(dARRAY * matrix, char * type);\n float gaussGenerator(float * cache, int * return_cache);\n float gaussRandom();\n float rand_norm(float mu, float std);\n\n float frobenius_norm(dARRAY * matrix);\n float Manhattan_distance(dARRAY * matrix);\n\n int size(dARRAY * A);\n void shape(dARRAY * A);\n void free2d(dARRAY * matrix);\n void sleep_my(int milliseconds);\n void cleanSTDIN();\n void get_safe_nn_threads();\n#ifdef __cplusplus\n}\n#endif\n#endif //UTILS_H", "meta": {"hexsha": "6b979ae217171a1516bee9914c51ba91b2d4443a", "size": 2143, "ext": "h", "lang": "C", "max_stars_repo_path": "include/cdnn/utils.h", "max_stars_repo_name": "adimehta03/cDNN", "max_stars_repo_head_hexsha": "75425e01d7948c51b9dcae0524a80d6e3ccdd424", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 12.0, "max_stars_repo_stars_event_min_datetime": "2021-04-17T06:29:03.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-14T04:51:12.000Z", "max_issues_repo_path": "include/cdnn/utils.h", "max_issues_repo_name": "adimehta03/cDNN", "max_issues_repo_head_hexsha": "75425e01d7948c51b9dcae0524a80d6e3ccdd424", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "include/cdnn/utils.h", "max_forks_repo_name": "adimehta03/cDNN", "max_forks_repo_head_hexsha": "75425e01d7948c51b9dcae0524a80d6e3ccdd424", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4.0, "max_forks_repo_forks_event_min_datetime": "2021-04-17T06:38:42.000Z", "max_forks_repo_forks_event_max_datetime": "2021-08-15T12:46:42.000Z", "avg_line_length": 27.8311688312, "max_line_length": 103, "alphanum_fraction": 0.6822211853, "num_tokens": 606, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7520125737597972, "lm_q2_score": 0.689305616785446, "lm_q1q2_score": 0.5183664909859077}} {"text": "#include \n\n#include \n\n#include \"qdm.h\"\n\n#define TAU_INITIAL_GUESS 0.5\n#define TAU_EPS 0.001\n#define TAU_ITERATION_MAX 1000\n\n#define RESET_SIZE 30\nconst double RESET_VALUES[RESET_SIZE] = {\n 0.010000000000000000,\n 0.010100000000000000,\n 0.010200000000000001,\n 0.010300000000000000,\n 0.010400000000000000,\n 0.010500000000000001,\n 0.010600000000000000,\n 0.010699999999999999,\n 0.010800000000000001,\n 0.010900000000000000,\n 0.010999999999999999,\n 0.010999999999999999,\n 0.150714285714285717,\n 0.290428571428571425,\n 0.430142857142857160,\n 0.569857142857142840,\n 0.709571428571428520,\n 0.849285714285714310,\n 0.988999999999999990,\n 0.988999999999999990,\n 0.989099999999999979,\n 0.989199999999999968,\n 0.989299999999999957,\n 0.989399999999999946,\n 0.989500000000000046,\n 0.989600000000000035,\n 0.989700000000000024,\n 0.989800000000000013,\n 0.989900000000000002,\n 0.989999999999999991,\n};\n\n/* Helper: Compute ispline by mmm dot product. */\nstatic\nint\nispline_mmm(\n double *result,\n\n double tau,\n size_t spline_df,\n const gsl_vector *knots,\n const gsl_vector *mmm\n)\n{\n int status = 0;\n\n size_t m = (knots->size - spline_df) + 1;\n gsl_vector *ispline = gsl_vector_alloc(m);\n\n qdm_ispline_vector(ispline, tau, spline_df, knots);\n status = gsl_blas_ddot(ispline, mmm, result);\n if (status != 0) {\n goto cleanup;\n }\n\ncleanup:\n gsl_vector_free(ispline);\n\n return status;\n}\n\n/* Helper: Compute mspline by mmm dot product. */\nstatic\nint\nmspline_mmm(\n double *result,\n\n double tau,\n size_t spline_df,\n const gsl_vector *knots,\n const gsl_vector *mmm\n)\n{\n int status = 0;\n\n size_t m = (knots->size - spline_df) + 1;\n gsl_vector *mspline = gsl_vector_alloc(m);\n\n qdm_mspline_vector(mspline, tau, spline_df, knots);\n status = gsl_blas_ddot(mspline, mmm, result);\n if (status != 0) {\n goto cleanup;\n }\n\ncleanup:\n gsl_vector_free(mspline);\n\n return status;\n}\n\n\nint\nqdm_find_tau(\n double *result,\n\n double v,\n size_t spline_df,\n const gsl_vector *knots,\n const gsl_vector *mmm\n)\n{\n int status = 0;\n\n double tau = TAU_INITIAL_GUESS;\n double qi_u = 0;\n double qm_u = 0;\n\n size_t reset_i = 0;\n for (size_t i = 0; i < TAU_ITERATION_MAX; i++) {\n if (reset_i >= RESET_SIZE) {\n tau = TAU_INITIAL_GUESS;\n\n break;\n }\n\n /* Calculate position... */\n status = ispline_mmm(&qi_u, tau, spline_df, knots, mmm);\n if (status != 0) {\n goto cleanup;\n }\n\n /* Calculate slope... */\n status = mspline_mmm(&qm_u, tau, spline_df, knots, mmm);\n if (status != 0) {\n goto cleanup;\n }\n\n /* Check if the update is within our desired interval [0, 1]. */\n double update = tau - (qi_u - v) / qm_u;\n if (update < 0 || update > 1) {\n tau = RESET_VALUES[reset_i];\n reset_i++;\n\n continue;\n } else {\n tau = update;\n }\n\n if (fabs(qi_u - v) <= TAU_EPS) {\n break;\n }\n }\n\n *result = tau;\n\ncleanup:\n\n return status;\n}\n\nint\nqdm_logl(\n double *log_likelihood,\n double *tau,\n\n double v,\n size_t spline_df,\n const gsl_vector *knots,\n const gsl_vector *mmm,\n\n double tau_low,\n double tau_high,\n double xi_low,\n double xi_high\n)\n{\n int status = 0;\n\n double low_threshold = 0;\n double high_threshold = 0;\n\n status = ispline_mmm(&low_threshold, tau_low, spline_df, knots, mmm);\n if (status != 0) {\n goto cleanup;\n }\n\n status = ispline_mmm(&high_threshold, tau_high, spline_df, knots, mmm);\n if (status != 0) {\n goto cleanup;\n }\n\n if (v <= low_threshold) {\n double sigma_low = 0;\n\n status = mspline_mmm(&sigma_low, tau_low, spline_df, knots, mmm);\n if (status != 0) {\n goto cleanup;\n }\n\n sigma_low *= tau_low;\n\n double z = low_threshold - v;\n\n *log_likelihood = log(tau_low / sigma_low * pow(1 + (xi_low * z) / sigma_low, -1 / xi_low - 1));\n *tau = (1 - (1 - pow(1 + xi_low * z / sigma_low, -1 / xi_low))) * tau_low;\n } else if (v >= high_threshold) {\n double sigma_high = 0;\n\n status = mspline_mmm(&sigma_high, tau_high, spline_df, knots, mmm);\n if (status != 0) {\n goto cleanup;\n }\n\n sigma_high *= (1 - tau_high);\n\n double z = v - high_threshold;\n\n *log_likelihood = log((1 - tau_high) / sigma_high * pow(1 + (xi_high * z) / sigma_high, -1 / xi_high - 1));\n *tau = (1 - pow(1 + xi_high * z / sigma_high, -1 / xi_high)) * (1 - tau_high) + tau_high;\n } else {\n double d = 0;\n\n status = qdm_find_tau(tau, v, spline_df, knots, mmm);\n if (status != 0) {\n goto cleanup;\n }\n\n status = mspline_mmm(&d, *tau, spline_df, knots, mmm);\n if (status != 0) {\n goto cleanup;\n }\n\n *log_likelihood = log(1 / d);\n }\n\ncleanup:\n\n return status;\n}\n\nint\nqdm_logl_2(\n double *log_likelihood,\n double *tau,\n\n double x,\n double y,\n\n double tau_low,\n double tau_high,\n\n double xi_low,\n double xi_high,\n\n size_t spline_df,\n\n const gsl_matrix *theta,\n const gsl_vector *knots\n)\n{\n int status = 0;\n\n double xi_data[2] = {1, x};\n gsl_vector_view xi = gsl_vector_view_array(xi_data, 2);\n\n double mmm_data[theta->size2];\n gsl_vector_view mmm = gsl_vector_view_array(mmm_data, theta->size2);\n\n status = gsl_blas_dgemv(CblasTrans, 1, theta, &xi.vector, 0, &mmm.vector);\n if (status != 0) {\n return status;\n }\n\n status = qdm_logl(\n log_likelihood,\n tau,\n\n y,\n spline_df,\n knots,\n &mmm.vector,\n\n tau_low,\n tau_high,\n xi_low,\n xi_high\n );\n if (status != 0) {\n return status;\n }\n\n return status;\n}\n\nvoid\nqdm_logl_3(\n double *log_likelihood,\n double *tau,\n\n double x,\n double y,\n\n const qdm_tau *t,\n const gsl_vector *xi,\n\n const gsl_matrix *theta\n)\n{\n double xi_intercept_data[2] = {1, x};\n gsl_vector_view xi_intercept = gsl_vector_view_array(xi_intercept_data, 2);\n\n double mmm_data[theta->size2];\n gsl_vector_view mmm = gsl_vector_view_array(mmm_data, theta->size2);\n\n gsl_blas_dgemv(CblasTrans, 1, theta, &xi_intercept.vector, 0, &mmm.vector);\n\n double low_threshold = qdm_tau_ispline_mmm(t, t->low, &mmm.vector);\n double high_threshold = qdm_tau_ispline_mmm(t, t->high, &mmm.vector);\n\n /*\n fprintf(stderr, \"x : %f\\n\", x);\n fprintf(stderr, \"y : %f\\n\", y);\n\n fprintf(stderr, \"tl : %f\\n\", t->low);\n fprintf(stderr, \"th : %f\\n\", t->high);\n\n fprintf(stderr, \"low : %f\\n\", low_threshold);\n fprintf(stderr, \"high : %f\\n\", high_threshold);\n\n qdm_matrix_csv_fwrite(stderr, theta);\n */\n\n double xi_low = gsl_vector_get(xi, 0);\n double xi_high = gsl_vector_get(xi, 1);\n\n if (y <= low_threshold) {\n double sigma_low = qdm_tau_mspline_mmm(t, t->low, &mmm.vector) * t->low;\n double z = low_threshold - y;\n\n *log_likelihood = log(t->low / sigma_low * pow(1 + (xi_low * z) / sigma_low, -1 / xi_low - 1));\n *tau = (1 - (1 - pow(1 + xi_low * z / sigma_low, -1 / xi_low))) * t->low;\n } else if (y >= high_threshold) {\n double sigma_high = qdm_tau_mspline_mmm(t, t->high, &mmm.vector) * (1 - t->high);\n double z = y - high_threshold;\n\n *log_likelihood = log((1 - t->high) / sigma_high * pow(1 + (xi_high * z) / sigma_high, -1 / xi_high - 1));\n *tau = (1 - pow(1 + xi_high * z / sigma_high, -1 / xi_high)) * (1 - t->high) + t->high;\n } else {\n *tau = qdm_tau_find(t, y, &mmm.vector);\n *log_likelihood = log(1 / qdm_tau_mspline_mmm(t, *tau, &mmm.vector));\n }\n\n /*\n fprintf(stderr, \"ll : %f\\n\", *log_likelihood);\n fprintf(stderr, \"tau : %f\\n\", *tau);\n */\n}\n", "meta": {"hexsha": "0f59d37a59e4b5676b920fff0ce5522a2698ce42", "size": 7491, "ext": "c", "lang": "C", "max_stars_repo_path": "src/logl.c", "max_stars_repo_name": "calebcase/qdm", "max_stars_repo_head_hexsha": "2ee95bec6c8be64f69e231c78f2be5fce3509c67", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/logl.c", "max_issues_repo_name": "calebcase/qdm", "max_issues_repo_head_hexsha": "2ee95bec6c8be64f69e231c78f2be5fce3509c67", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 3.0, "max_issues_repo_issues_event_min_datetime": "2020-03-06T18:09:06.000Z", "max_issues_repo_issues_event_max_datetime": "2020-03-22T20:22:53.000Z", "max_forks_repo_path": "src/logl.c", "max_forks_repo_name": "calebcase/qdm", "max_forks_repo_head_hexsha": "2ee95bec6c8be64f69e231c78f2be5fce3509c67", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 20.8083333333, "max_line_length": 111, "alphanum_fraction": 0.6288879989, "num_tokens": 2483, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8376199633332891, "lm_q2_score": 0.6187804337438501, "lm_q1q2_score": 0.5183028442238804}} {"text": "/* interpolation/bicubic.c\n * \n * Copyright 2012 David Zaslavsky\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#define IDX2D(i, j, w) ((j) * ((w)->xsize) + (i))\n\ntypedef struct\n{\n double * zx;\n double * zy;\n double * zxy;\n size_t xsize;\n size_t ysize;\n} bicubic_state_t;\n\nstatic void bicubic_free (void * vstate);\n\nstatic void *\nbicubic_alloc(size_t xsize, size_t ysize)\n{\n bicubic_state_t *state;\n \n state = calloc(1, sizeof (bicubic_state_t));\n\n if (state == NULL)\n {\n GSL_ERROR_NULL(\"failed to allocate space for state\", GSL_ENOMEM);\n }\n\n state->zx = (double *) malloc (xsize * ysize * sizeof (double));\n if (state->zx == NULL)\n {\n bicubic_free(state);\n GSL_ERROR_NULL(\"failed to allocate space for zx\", GSL_ENOMEM);\n }\n\n state->zy = (double *) malloc (xsize * ysize * sizeof (double));\n if (state->zy == NULL)\n {\n bicubic_free(state);\n GSL_ERROR_NULL(\"failed to allocate space for zy\", GSL_ENOMEM);\n }\n\n state->zxy = (double *) malloc (xsize * ysize * sizeof (double));\n if (state->zxy == NULL)\n {\n bicubic_free(state);\n GSL_ERROR_NULL(\"failed to allocate space for zxy\", GSL_ENOMEM);\n }\n\n state->xsize = xsize;\n state->ysize = ysize;\n\n return state;\n} /* bicubic_alloc() */\n\nstatic void\nbicubic_free (void * vstate)\n{\n bicubic_state_t *state = (bicubic_state_t *) vstate;\n\n RETURN_IF_NULL(state);\n\n if (state->zx)\n free (state->zx);\n\n if (state->zy)\n free (state->zy);\n\n if (state->zxy)\n free (state->zxy);\n\n free (state);\n} /* bicubic_free() */\n\nstatic int\nbicubic_init(void * vstate, const double xa[], const double ya[],\n const double za[], size_t xsize, size_t ysize)\n{\n bicubic_state_t *state = (bicubic_state_t *) vstate;\n\n gsl_interp_accel *acc = gsl_interp_accel_alloc();\n gsl_spline *spline;\n gsl_vector *x;\n gsl_vector *y;\n size_t i, j;\n\n x = gsl_vector_alloc(xsize);\n y = gsl_vector_alloc(xsize);\n spline = gsl_spline_alloc(gsl_interp_cspline, xsize);\n for (j = 0; j <= ysize - 1; j++)\n {\n for (i = 0; i <= xsize - 1; i++)\n {\n gsl_vector_set(x, i, xa[i]);\n gsl_vector_set(y, i, za[IDX2D(i, j, state)]);\n }\n gsl_spline_init(spline, x->data, y->data, xsize);\n for (i = 0; i <= xsize - 1; i++)\n {\n state->zx[IDX2D(i, j, state)] = gsl_spline_eval_deriv(spline, xa[i], acc);\n }\n }\n gsl_vector_free(x);\n gsl_vector_free(y);\n gsl_spline_free(spline);\n gsl_interp_accel_reset(acc);\n\n x = gsl_vector_alloc(ysize);\n y = gsl_vector_alloc(ysize);\n spline = gsl_spline_alloc(gsl_interp_cspline, ysize);\n for (i = 0; i <= xsize - 1; i++)\n {\n for (j = 0; j <= ysize - 1; j++)\n {\n gsl_vector_set(x, j, ya[j]);\n gsl_vector_set(y, j, za[IDX2D(i, j, state)]);\n }\n gsl_spline_init(spline, x->data, y->data, ysize);\n for (j = 0; j <= ysize - 1; j++)\n {\n state->zy[IDX2D(i, j, state)] = gsl_spline_eval_deriv(spline, ya[j], acc);\n }\n }\n gsl_vector_free(x);\n gsl_vector_free(y);\n gsl_spline_free(spline);\n gsl_interp_accel_reset(acc);\n\n x = gsl_vector_alloc(xsize);\n y = gsl_vector_alloc(xsize);\n spline = gsl_spline_alloc(gsl_interp_cspline, xsize);\n for (j = 0; j <= ysize - 1; j++)\n {\n for (i = 0; i <= xsize - 1; i++)\n {\n gsl_vector_set(x, i, xa[i]);\n gsl_vector_set(y, i, state->zy[IDX2D(i, j, state)]);\n }\n gsl_spline_init(spline, x->data, y->data, xsize);\n for (i = 0; i <= xsize - 1; i++)\n {\n state->zxy[IDX2D(i, j, state)] = gsl_spline_eval_deriv(spline, xa[i], acc);\n }\n }\n gsl_vector_free(x);\n gsl_vector_free(y);\n gsl_spline_free(spline);\n gsl_interp_accel_free(acc);\n\n return GSL_SUCCESS;\n} /* bicubic_init() */\n\n\nstatic int\nbicubic_eval(const void * vstate, const double xarr[], const double yarr[],\n const double zarr[], size_t xsize, size_t ysize,\n double x, double y, gsl_interp_accel * xa,\n gsl_interp_accel * ya, double * z)\n{\n bicubic_state_t *state = (bicubic_state_t *) vstate;\n\n double xmin, xmax, ymin, ymax;\n double zminmin, zminmax, zmaxmin, zmaxmax;\n double zxminmin, zxminmax, zxmaxmin, zxmaxmax;\n double zyminmin, zyminmax, zymaxmin, zymaxmax;\n double zxyminmin, zxyminmax, zxymaxmin, zxymaxmax;\n\n double dx, dy; /* size of the grid cell */\n double dt, du;\n\n /*\n * t and u are the positions within the grid cell at which we are computing\n * the interpolation, in units of grid cell size\n */\n double t, u;\n double t0, t1, t2, t3, u0, u1, u2, u3;\n double v;\n size_t xi, yi;\n\n /* first compute the indices into the data arrays where we are interpolating */\n if (xa != NULL)\n xi = gsl_interp_accel_find(xa, xarr, xsize, x);\n else\n xi = gsl_interp_bsearch(xarr, x, 0, xsize - 1);\n\n if (ya != NULL)\n yi = gsl_interp_accel_find(ya, yarr, ysize, y);\n else\n yi = gsl_interp_bsearch(yarr, y, 0, ysize - 1);\n\n /* find the minimum and maximum values on the grid cell in each dimension */\n xmin = xarr[xi];\n xmax = xarr[xi + 1];\n ymin = yarr[yi];\n ymax = yarr[yi + 1];\n zminmin = zarr[IDX2D(xi, yi, state)];\n zminmax = zarr[IDX2D(xi, yi + 1, state)];\n zmaxmin = zarr[IDX2D(xi + 1, yi, state)];\n zmaxmax = zarr[IDX2D(xi + 1, yi + 1, state)];\n /* Get the width and height of the grid cell */\n dx = xmax - xmin;\n dy = ymax - ymin;\n t = (x - xmin)/dx;\n u = (y - ymin)/dy;\n dt = 1./dx; /* partial t / partial x */\n du = 1./dy; /* partial u / partial y */\n zxminmin = state->zx[IDX2D(xi, yi, state)]/dt;\n zxminmax = state->zx[IDX2D(xi, yi + 1, state)]/dt;\n zxmaxmin = state->zx[IDX2D(xi + 1, yi, state)]/dt;\n zxmaxmax = state->zx[IDX2D(xi + 1, yi + 1, state)]/dt;\n zyminmin = state->zy[IDX2D(xi, yi, state)]/du;\n zyminmax = state->zy[IDX2D(xi, yi + 1, state)]/du;\n zymaxmin = state->zy[IDX2D(xi + 1, yi, state)]/du;\n zymaxmax = state->zy[IDX2D(xi + 1, yi + 1, state)]/du;\n zxyminmin = state->zxy[IDX2D(xi, yi, state)]/(dt*du);\n zxyminmax = state->zxy[IDX2D(xi, yi + 1, state)]/(dt*du);\n zxymaxmin = state->zxy[IDX2D(xi + 1, yi, state)]/(dt*du);\n zxymaxmax = state->zxy[IDX2D(xi + 1, yi + 1, state)]/(dt*du);\n t0 = 1;\n t1 = t;\n t2 = t*t;\n t3 = t*t2;\n u0 = 1;\n u1 = u;\n u2 = u*u;\n u3 = u*u2;\n\n *z = 0;\n v = zminmin;\n *z += v*t0*u0;\n v = zyminmin;\n *z += v*t0*u1;\n v = -3*zminmin + 3*zminmax - 2*zyminmin - zyminmax;\n *z += v*t0*u2;\n v = 2*zminmin - 2*zminmax + zyminmin + zyminmax;\n *z += v*t0*u3;\n v = zxminmin;\n *z += v*t1*u0;\n v = zxyminmin;\n *z += v*t1*u1;\n v = -3*zxminmin + 3*zxminmax - 2*zxyminmin - zxyminmax;\n *z += v*t1*u2;\n v = 2*zxminmin - 2*zxminmax + zxyminmin + zxyminmax;\n *z += v*t1*u3;\n v = -3*zminmin + 3*zmaxmin - 2*zxminmin - zxmaxmin;\n *z += v*t2*u0;\n v = -3*zyminmin + 3*zymaxmin - 2*zxyminmin - zxymaxmin;\n *z += v*t2*u1;\n v = 9*zminmin - 9*zmaxmin + 9*zmaxmax - 9*zminmax + 6*zxminmin + 3*zxmaxmin - 3*zxmaxmax - 6*zxminmax + 6*zyminmin - 6*zymaxmin - 3*zymaxmax + 3*zyminmax + 4*zxyminmin + 2*zxymaxmin + zxymaxmax + 2*zxyminmax;\n *z += v*t2*u2;\n v = -6*zminmin + 6*zmaxmin - 6*zmaxmax + 6*zminmax - 4*zxminmin - 2*zxmaxmin + 2*zxmaxmax + 4*zxminmax - 3*zyminmin + 3*zymaxmin + 3*zymaxmax - 3*zyminmax - 2*zxyminmin - zxymaxmin - zxymaxmax - 2*zxyminmax;\n *z += v*t2*u3;\n v = 2*zminmin - 2*zmaxmin + zxminmin + zxmaxmin;\n *z += v*t3*u0;\n v = 2*zyminmin - 2*zymaxmin + zxyminmin + zxymaxmin;\n *z += v*t3*u1;\n v = -6*zminmin + 6*zmaxmin - 6*zmaxmax + 6*zminmax - 3*zxminmin - 3*zxmaxmin + 3*zxmaxmax + 3*zxminmax - 4*zyminmin + 4*zymaxmin + 2*zymaxmax - 2*zyminmax - 2*zxyminmin - 2*zxymaxmin - zxymaxmax - zxyminmax;\n *z += v*t3*u2;\n v = 4*zminmin - 4*zmaxmin + 4*zmaxmax - 4*zminmax + 2*zxminmin + 2*zxmaxmin - 2*zxmaxmax - 2*zxminmax + 2*zyminmin - 2*zymaxmin - 2*zymaxmax + 2*zyminmax + zxyminmin + zxymaxmin + zxymaxmax + zxyminmax;\n *z += v*t3*u3;\n\n return GSL_SUCCESS;\n} /* bicubic_eval() */\n\nstatic int\nbicubic_deriv_x(const void * vstate, const double xarr[], const double yarr[],\n const double zarr[], size_t xsize, size_t ysize,\n double x, double y,\n gsl_interp_accel * xa, gsl_interp_accel * ya, double * z_p)\n{\n bicubic_state_t *state = (bicubic_state_t *) vstate;\n\n double xmin, xmax, ymin, ymax;\n double zminmin, zminmax, zmaxmin, zmaxmax;\n double zxminmin, zxminmax, zxmaxmin, zxmaxmax;\n double zyminmin, zyminmax, zymaxmin, zymaxmax;\n double zxyminmin, zxyminmax, zxymaxmin, zxymaxmax;\n double dx, dy; /* size of the grid cell */\n double dt, du;\n\n /*\n * t and u are the positions within the grid cell at which we are computing\n * the interpolation, in units of grid cell size\n */\n double t, u;\n double t0, t1, t2, u0, u1, u2, u3;\n double v;\n size_t xi, yi;\n\n /* first compute the indices into the data arrays where we are interpolating */\n if (xa != NULL)\n xi = gsl_interp_accel_find(xa, xarr, xsize, x);\n else\n xi = gsl_interp_bsearch(xarr, x, 0, xsize - 1);\n\n if (ya != NULL)\n yi = gsl_interp_accel_find(ya, yarr, ysize, y);\n else\n yi = gsl_interp_bsearch(yarr, y, 0, ysize - 1);\n\n /* find the minimum and maximum values on the grid cell in each dimension */\n xmin = xarr[xi];\n xmax = xarr[xi + 1];\n ymin = yarr[yi];\n ymax = yarr[yi + 1];\n zminmin = zarr[IDX2D(xi, yi, state)];\n zminmax = zarr[IDX2D(xi, yi + 1, state)];\n zmaxmin = zarr[IDX2D(xi + 1, yi, state)];\n zmaxmax = zarr[IDX2D(xi + 1, yi + 1, state)];\n\n /* get the width and height of the grid cell */\n dx = xmax - xmin;\n dy = ymax - ymin;\n t = (x - xmin)/dx;\n u = (y - ymin)/dy;\n dt = 1./dx; /* partial t / partial x */\n du = 1./dy; /* partial u / partial y */\n\n zxminmin = state->zx[IDX2D(xi, yi, state)]/dt;\n zxminmax = state->zx[IDX2D(xi, yi + 1, state)]/dt;\n zxmaxmin = state->zx[IDX2D(xi + 1, yi, state)]/dt;\n zxmaxmax = state->zx[IDX2D(xi + 1, yi + 1, state)]/dt;\n zyminmin = state->zy[IDX2D(xi, yi, state)]/du;\n zyminmax = state->zy[IDX2D(xi, yi + 1, state)]/du;\n zymaxmin = state->zy[IDX2D(xi + 1, yi, state)]/du;\n zymaxmax = state->zy[IDX2D(xi + 1, yi + 1, state)]/du;\n zxyminmin = state->zxy[IDX2D(xi, yi, state)]/(dt*du);\n zxyminmax = state->zxy[IDX2D(xi, yi + 1, state)]/(dt*du);\n zxymaxmin = state->zxy[IDX2D(xi + 1, yi, state)]/(dt*du);\n zxymaxmax = state->zxy[IDX2D(xi + 1, yi + 1, state)]/(dt*du);\n\n t0 = 1;\n t1 = t;\n t2 = t*t;\n u0 = 1;\n u1 = u;\n u2 = u*u;\n u3 = u*u2;\n\n *z_p = 0;\n v = zxminmin;\n *z_p += v*t0*u0;\n v = zxyminmin;\n *z_p += v*t0*u1;\n v = -3*zxminmin + 3*zxminmax - 2*zxyminmin - zxyminmax;\n *z_p += v*t0*u2;\n v = 2*zxminmin - 2*zxminmax + zxyminmin + zxyminmax;\n *z_p += v*t0*u3;\n v = -3*zminmin + 3*zmaxmin - 2*zxminmin - zxmaxmin;\n *z_p += 2*v*t1*u0;\n v = -3*zyminmin + 3*zymaxmin - 2*zxyminmin - zxymaxmin;\n *z_p += 2*v*t1*u1;\n v = 9*zminmin - 9*zmaxmin + 9*zmaxmax - 9*zminmax + 6*zxminmin + 3*zxmaxmin - 3*zxmaxmax - 6*zxminmax + 6*zyminmin - 6*zymaxmin - 3*zymaxmax + 3*zyminmax + 4*zxyminmin + 2*zxymaxmin + zxymaxmax + 2*zxyminmax;\n *z_p += 2*v*t1*u2;\n v = -6*zminmin + 6*zmaxmin - 6*zmaxmax + 6*zminmax - 4*zxminmin - 2*zxmaxmin + 2*zxmaxmax + 4*zxminmax - 3*zyminmin + 3*zymaxmin + 3*zymaxmax - 3*zyminmax - 2*zxyminmin - zxymaxmin - zxymaxmax - 2*zxyminmax;\n *z_p += 2*v*t1*u3;\n v = 2*zminmin - 2*zmaxmin + zxminmin + zxmaxmin;\n *z_p += 3*v*t2*u0;\n v = 2*zyminmin - 2*zymaxmin + zxyminmin + zxymaxmin;\n *z_p += 3*v*t2*u1;\n v = -6*zminmin + 6*zmaxmin - 6*zmaxmax + 6*zminmax - 3*zxminmin - 3*zxmaxmin + 3*zxmaxmax + 3*zxminmax - 4*zyminmin + 4*zymaxmin + 2*zymaxmax - 2*zyminmax - 2*zxyminmin - 2*zxymaxmin - zxymaxmax - zxyminmax;\n *z_p += 3*v*t2*u2;\n v = 4*zminmin - 4*zmaxmin + 4*zmaxmax - 4*zminmax + 2*zxminmin + 2*zxmaxmin - 2*zxmaxmax - 2*zxminmax + 2*zyminmin - 2*zymaxmin - 2*zymaxmax + 2*zyminmax + zxyminmin + zxymaxmin + zxymaxmax + zxyminmax;\n *z_p += 3*v*t2*u3;\n *z_p *= dt;\n\n return GSL_SUCCESS;\n} /* bicubic_deriv_x() */\n\nstatic int\nbicubic_deriv_y(const void * vstate, const double xarr[], const double yarr[],\n const double zarr[], size_t xsize, size_t ysize,\n double x, double y,\n gsl_interp_accel * xa, gsl_interp_accel * ya, double * z_p)\n{\n bicubic_state_t *state = (bicubic_state_t *) vstate;\n\n double xmin, xmax, ymin, ymax;\n double zminmin, zminmax, zmaxmin, zmaxmax;\n double zxminmin, zxminmax, zxmaxmin, zxmaxmax;\n double zyminmin, zyminmax, zymaxmin, zymaxmax;\n double zxyminmin, zxyminmax, zxymaxmin, zxymaxmax;\n /* dx and dy are the size of the grid cell */\n double dx, dy;\n double dt, du;\n /* t and u are the positions within the grid cell at which we are\n * computing the interpolation, in units of grid cell size */\n double t, u;\n double t0, t1, t2, t3, u0, u1, u2;\n double v;\n size_t xi, yi;\n\n /* first compute the indices into the data arrays where we are interpolating */\n if (xa != NULL)\n xi = gsl_interp_accel_find(xa, xarr, xsize, x);\n else\n xi = gsl_interp_bsearch(xarr, x, 0, xsize - 1);\n\n if (ya != NULL)\n yi = gsl_interp_accel_find(ya, yarr, ysize, y);\n else\n yi = gsl_interp_bsearch(yarr, y, 0, ysize - 1);\n\n /* find the minimum and maximum values on the grid cell in each dimension */\n xmin = xarr[xi];\n xmax = xarr[xi + 1];\n ymin = yarr[yi];\n ymax = yarr[yi + 1];\n zminmin = zarr[IDX2D(xi, yi, state)];\n zminmax = zarr[IDX2D(xi, yi + 1, state)];\n zmaxmin = zarr[IDX2D(xi + 1, yi, state)];\n zmaxmax = zarr[IDX2D(xi + 1, yi + 1, state)];\n\n /* get the width and height of the grid cell */\n dx = xmax - xmin;\n dy = ymax - ymin;\n t = (x - xmin)/dx;\n u = (y - ymin)/dy;\n dt = 1./dx; /* partial t / partial x */\n du = 1./dy; /* partial u / partial y */\n\n zxminmin = state->zx[IDX2D(xi, yi, state)]/dt;\n zxminmax = state->zx[IDX2D(xi, yi + 1, state)]/dt;\n zxmaxmin = state->zx[IDX2D(xi + 1, yi, state)]/dt;\n zxmaxmax = state->zx[IDX2D(xi + 1, yi + 1, state)]/dt;\n zyminmin = state->zy[IDX2D(xi, yi, state)]/du;\n zyminmax = state->zy[IDX2D(xi, yi + 1, state)]/du;\n zymaxmin = state->zy[IDX2D(xi + 1, yi, state)]/du;\n zymaxmax = state->zy[IDX2D(xi + 1, yi + 1, state)]/du;\n zxyminmin = state->zxy[IDX2D(xi, yi, state)]/(dt*du);\n zxyminmax = state->zxy[IDX2D(xi, yi + 1, state)]/(dt*du);\n zxymaxmin = state->zxy[IDX2D(xi + 1, yi, state)]/(dt*du);\n zxymaxmax = state->zxy[IDX2D(xi + 1, yi + 1, state)]/(dt*du);\n\n t0 = 1;\n t1 = t;\n t2 = t*t;\n t3 = t*t2;\n u0 = 1;\n u1 = u;\n u2 = u*u;\n\n *z_p = 0;\n v = zyminmin;\n *z_p += v*t0*u0;\n v = -3*zminmin + 3*zminmax - 2*zyminmin - zyminmax;\n *z_p += 2*v*t0*u1;\n v = 2*zminmin-2*zminmax + zyminmin + zyminmax;\n *z_p += 3*v*t0*u2;\n v = zxyminmin;\n *z_p += v*t1*u0;\n v = -3*zxminmin + 3*zxminmax - 2*zxyminmin - zxyminmax;\n *z_p += 2*v*t1*u1;\n v = 2*zxminmin - 2*zxminmax + zxyminmin + zxyminmax;\n *z_p += 3*v*t1*u2;\n v = -3*zyminmin + 3*zymaxmin - 2*zxyminmin - zxymaxmin;\n *z_p += v*t2*u0;\n v = 9*zminmin - 9*zmaxmin + 9*zmaxmax - 9*zminmax + 6*zxminmin + 3*zxmaxmin - 3*zxmaxmax - 6*zxminmax + 6*zyminmin - 6*zymaxmin - 3*zymaxmax + 3*zyminmax + 4*zxyminmin + 2*zxymaxmin + zxymaxmax + 2*zxyminmax;\n *z_p += 2*v*t2*u1;\n v = -6*zminmin + 6*zmaxmin - 6*zmaxmax + 6*zminmax - 4*zxminmin - 2*zxmaxmin + 2*zxmaxmax + 4*zxminmax - 3*zyminmin + 3*zymaxmin + 3*zymaxmax - 3*zyminmax - 2*zxyminmin - zxymaxmin - zxymaxmax - 2*zxyminmax;\n *z_p += 3*v*t2*u2;\n v = 2*zyminmin - 2*zymaxmin + zxyminmin + zxymaxmin;\n *z_p += v*t3*u0;\n v = -6*zminmin + 6*zmaxmin - 6*zmaxmax + 6*zminmax - 3*zxminmin - 3*zxmaxmin + 3*zxmaxmax + 3*zxminmax - 4*zyminmin + 4*zymaxmin + 2*zymaxmax - 2*zyminmax - 2*zxyminmin - 2*zxymaxmin - zxymaxmax - zxyminmax;\n *z_p += 2*v*t3*u1;\n v = 4*zminmin - 4*zmaxmin + 4*zmaxmax - 4*zminmax + 2*zxminmin + 2*zxmaxmin - 2*zxmaxmax - 2*zxminmax + 2*zyminmin - 2*zymaxmin - 2*zymaxmax + 2*zyminmax + zxyminmin + zxymaxmin + zxymaxmax + zxyminmax;\n *z_p += 3*v*t3*u2;\n *z_p *= du;\n\n return GSL_SUCCESS;\n}\n\nstatic int\nbicubic_deriv_xx(const void * vstate, const double xarr[], const double yarr[],\n const double zarr[], size_t xsize, size_t ysize,\n double x, double y,\n gsl_interp_accel * xa, gsl_interp_accel * ya, double * z_pp)\n{\n bicubic_state_t *state = (bicubic_state_t *) vstate;\n\n double xmin, xmax, ymin, ymax;\n double zminmin, zminmax, zmaxmin, zmaxmax;\n double zxminmin, zxminmax, zxmaxmin, zxmaxmax;\n double zyminmin, zyminmax, zymaxmin, zymaxmax;\n double zxyminmin, zxyminmax, zxymaxmin, zxymaxmax;\n\n double dx, dy; /* size of the grid cell */\n double dt, du;\n\n /*\n * t and u are the positions within the grid cell at which we are computing\n * the interpolation, in units of grid cell size\n */\n double t, u;\n double t0, t1, u0, u1, u2, u3;\n double v;\n size_t xi, yi;\n\n /* first compute the indices into the data arrays where we are interpolating */\n if (xa != NULL)\n xi = gsl_interp_accel_find(xa, xarr, xsize, x);\n else\n xi = gsl_interp_bsearch(xarr, x, 0, xsize - 1);\n\n if (ya != NULL)\n yi = gsl_interp_accel_find(ya, yarr, ysize, y);\n else\n yi = gsl_interp_bsearch(yarr, y, 0, ysize - 1);\n\n /* find the minimum and maximum values on the grid cell in each dimension */\n xmin = xarr[xi];\n xmax = xarr[xi + 1];\n ymin = yarr[yi];\n ymax = yarr[yi + 1];\n zminmin = zarr[IDX2D(xi, yi, state)];\n zminmax = zarr[IDX2D(xi, yi + 1, state)];\n zmaxmin = zarr[IDX2D(xi + 1, yi, state)];\n zmaxmax = zarr[IDX2D(xi + 1, yi + 1, state)];\n\n /* get the width and height of the grid cell */\n dx = xmax - xmin;\n dy = ymax - ymin;\n t = (x - xmin)/dx;\n u = (y - ymin)/dy;\n dt = 1./dx; /* partial t / partial x */\n du = 1./dy; /* partial u / partial y */\n\n zxminmin = state->zx[IDX2D(xi, yi, state)]/dt;\n zxminmax = state->zx[IDX2D(xi, yi + 1, state)]/dt;\n zxmaxmin = state->zx[IDX2D(xi + 1, yi, state)]/dt;\n zxmaxmax = state->zx[IDX2D(xi + 1, yi + 1, state)]/dt;\n zyminmin = state->zy[IDX2D(xi, yi, state)]/du;\n zyminmax = state->zy[IDX2D(xi, yi + 1, state)]/du;\n zymaxmin = state->zy[IDX2D(xi + 1, yi, state)]/du;\n zymaxmax = state->zy[IDX2D(xi + 1, yi + 1, state)]/du;\n zxyminmin = state->zxy[IDX2D(xi, yi, state)]/(dt*du);\n zxyminmax = state->zxy[IDX2D(xi, yi + 1, state)]/(dt*du);\n zxymaxmin = state->zxy[IDX2D(xi + 1, yi, state)]/(dt*du);\n zxymaxmax = state->zxy[IDX2D(xi + 1, yi + 1, state)]/(dt*du);\n\n t0 = 1;\n t1 = t;\n u0 = 1;\n u1 = u;\n u2 = u*u;\n u3 = u*u2;\n\n *z_pp = 0;\n v = -3*zminmin + 3*zmaxmin - 2*zxminmin - zxmaxmin;\n *z_pp += 2*v*t0*u0;\n v = -3*zyminmin + 3*zymaxmin - 2*zxyminmin - zxymaxmin;\n *z_pp += 2*v*t0*u1;\n v = 9*zminmin - 9*zmaxmin + 9*zmaxmax - 9*zminmax + 6*zxminmin + 3*zxmaxmin - 3*zxmaxmax - 6*zxminmax + 6*zyminmin - 6*zymaxmin - 3*zymaxmax + 3*zyminmax + 4*zxyminmin + 2*zxymaxmin + zxymaxmax + 2*zxyminmax;\n *z_pp += 2*v*t0*u2;\n v = -6*zminmin + 6*zmaxmin - 6*zmaxmax + 6*zminmax - 4*zxminmin - 2*zxmaxmin + 2*zxmaxmax + 4*zxminmax - 3*zyminmin + 3*zymaxmin + 3*zymaxmax - 3*zyminmax - 2*zxyminmin - zxymaxmin - zxymaxmax - 2*zxyminmax;\n *z_pp += 2*v*t0*u3;\n v = 2*zminmin - 2*zmaxmin + zxminmin + zxmaxmin;\n *z_pp += 6*v*t1*u0;\n v = 2*zyminmin - 2*zymaxmin + zxyminmin + zxymaxmin;\n *z_pp += 6*v*t1*u1;\n v = -6*zminmin + 6*zmaxmin - 6*zmaxmax + 6*zminmax - 3*zxminmin - 3*zxmaxmin + 3*zxmaxmax + 3*zxminmax - 4*zyminmin + 4*zymaxmin + 2*zymaxmax - 2*zyminmax - 2*zxyminmin - 2*zxymaxmin - zxymaxmax - zxyminmax;\n *z_pp += 6*v*t1*u2;\n v = 4*zminmin - 4*zmaxmin + 4*zmaxmax - 4*zminmax + 2*zxminmin + 2*zxmaxmin - 2*zxmaxmax - 2*zxminmax + 2*zyminmin - 2*zymaxmin - 2*zymaxmax + 2*zyminmax + zxyminmin + zxymaxmin + zxymaxmax + zxyminmax;\n *z_pp += 6*v*t1*u3;\n *z_pp *= dt*dt;\n\n return GSL_SUCCESS;\n}\n\nstatic int\nbicubic_deriv_xy(const void * vstate, const double xarr[], const double yarr[],\n const double zarr[], size_t xsize, size_t ysize,\n double x, double y,\n gsl_interp_accel * xa, gsl_interp_accel * ya, double * z_pp)\n{\n bicubic_state_t *state = (bicubic_state_t *) vstate;\n\n double xmin, xmax, ymin, ymax;\n double zminmin, zminmax, zmaxmin, zmaxmax;\n double zxminmin, zxminmax, zxmaxmin, zxmaxmax;\n double zyminmin, zyminmax, zymaxmin, zymaxmax;\n double zxyminmin, zxyminmax, zxymaxmin, zxymaxmax;\n\n double dx, dy; /* size of the grid cell */\n double dt, du;\n\n /*\n * t and u are the positions within the grid cell at which we are computing\n * the interpolation, in units of grid cell size\n */\n double t, u;\n double t0, t1, t2, u0, u1, u2;\n double v;\n size_t xi, yi;\n\n /* first compute the indices into the data arrays where we are interpolating */\n if (xa != NULL)\n xi = gsl_interp_accel_find(xa, xarr, xsize, x);\n else\n xi = gsl_interp_bsearch(xarr, x, 0, xsize - 1);\n\n if (ya != NULL)\n yi = gsl_interp_accel_find(ya, yarr, ysize, y);\n else\n yi = gsl_interp_bsearch(yarr, y, 0, ysize - 1);\n\n /* find the minimum and maximum values on the grid cell in each dimension */\n xmin = xarr[xi];\n xmax = xarr[xi + 1];\n ymin = yarr[yi];\n ymax = yarr[yi + 1];\n zminmin = zarr[IDX2D(xi, yi, state)];\n zminmax = zarr[IDX2D(xi, yi + 1, state)];\n zmaxmin = zarr[IDX2D(xi + 1, yi, state)];\n zmaxmax = zarr[IDX2D(xi + 1, yi + 1, state)];\n\n /* get the width and height of the grid cell */\n dx = xmax - xmin;\n dy = ymax - ymin;\n t = (x - xmin)/dx;\n u = (y - ymin)/dy;\n dt = 1./dx; /* partial t / partial x */\n du = 1./dy; /* partial u / partial y */\n\n zxminmin = state->zx[IDX2D(xi, yi, state)]/dt;\n zxminmax = state->zx[IDX2D(xi, yi + 1, state)]/dt;\n zxmaxmin = state->zx[IDX2D(xi + 1, yi, state)]/dt;\n zxmaxmax = state->zx[IDX2D(xi + 1, yi + 1, state)]/dt;\n zyminmin = state->zy[IDX2D(xi, yi, state)]/du;\n zyminmax = state->zy[IDX2D(xi, yi + 1, state)]/du;\n zymaxmin = state->zy[IDX2D(xi + 1, yi, state)]/du;\n zymaxmax = state->zy[IDX2D(xi + 1, yi + 1, state)]/du;\n zxyminmin = state->zxy[IDX2D(xi, yi, state)]/(dt*du);\n zxyminmax = state->zxy[IDX2D(xi, yi + 1, state)]/(dt*du);\n zxymaxmin = state->zxy[IDX2D(xi + 1, yi, state)]/(dt*du);\n zxymaxmax = state->zxy[IDX2D(xi + 1, yi + 1, state)]/(dt*du);\n\n t0 = 1;\n t1 = t;\n t2 = t*t;\n u0 = 1;\n u1 = u;\n u2 = u*u;\n\n *z_pp = 0;\n v = zxyminmin;\n *z_pp += v*t0*u0;\n v = -3*zxminmin + 3*zxminmax - 2*zxyminmin - zxyminmax;\n *z_pp += 2*v*t0*u1;\n v = 2*zxminmin - 2*zxminmax + zxyminmin + zxyminmax;\n *z_pp += 3*v*t0*u2;\n v = -3*zyminmin + 3*zymaxmin - 2*zxyminmin - zxymaxmin;\n *z_pp += 2*v*t1*u0;\n v = 9*zminmin - 9*zmaxmin + 9*zmaxmax - 9*zminmax + 6*zxminmin + 3*zxmaxmin - 3*zxmaxmax - 6*zxminmax + 6*zyminmin - 6*zymaxmin - 3*zymaxmax + 3*zyminmax + 4*zxyminmin + 2*zxymaxmin + zxymaxmax + 2*zxyminmax;\n *z_pp += 4*v*t1*u1;\n v = -6*zminmin + 6*zmaxmin - 6*zmaxmax + 6*zminmax - 4*zxminmin - 2*zxmaxmin + 2*zxmaxmax + 4*zxminmax - 3*zyminmin + 3*zymaxmin + 3*zymaxmax - 3*zyminmax - 2*zxyminmin - zxymaxmin - zxymaxmax - 2*zxyminmax;\n *z_pp += 6*v*t1*u2;\n v = 2*zyminmin - 2*zymaxmin + zxyminmin + zxymaxmin;\n *z_pp += 3*v*t2*u0;\n v = -6*zminmin + 6*zmaxmin - 6*zmaxmax + 6*zminmax - 3*zxminmin - 3*zxmaxmin + 3*zxmaxmax + 3*zxminmax - 4*zyminmin + 4*zymaxmin + 2*zymaxmax - 2*zyminmax - 2*zxyminmin - 2*zxymaxmin - zxymaxmax - zxyminmax;\n *z_pp += 6*v*t2*u1;\n v = 4*zminmin - 4*zmaxmin + 4*zmaxmax - 4*zminmax + 2*zxminmin + 2*zxmaxmin - 2*zxmaxmax - 2*zxminmax + 2*zyminmin - 2*zymaxmin - 2*zymaxmax + 2*zyminmax + zxyminmin + zxymaxmin + zxymaxmax + zxyminmax;\n *z_pp += 9*v*t2*u2;\n *z_pp *= dt*du;\n\n return GSL_SUCCESS;\n}\n\nstatic int\nbicubic_deriv_yy(const void * vstate, const double xarr[], const double yarr[],\n const double zarr[], size_t xsize, size_t ysize,\n double x, double y,\n gsl_interp_accel * xa, gsl_interp_accel * ya, double * z_pp)\n{\n bicubic_state_t *state = (bicubic_state_t *) vstate;\n\n double xmin, xmax, ymin, ymax;\n double zminmin, zminmax, zmaxmin, zmaxmax;\n double zxminmin, zxminmax, zxmaxmin, zxmaxmax;\n double zyminmin, zyminmax, zymaxmin, zymaxmax;\n double zxyminmin, zxyminmax, zxymaxmin, zxymaxmax;\n\n double dx, dy; /* size of the grid cell */\n double dt, du;\n\n /*\n * t and u are the positions within the grid cell at which we are computing\n * the interpolation, in units of grid cell size\n */\n double t, u;\n double t0, t1, t2, t3, u0, u1;\n double v;\n size_t xi, yi;\n\n /* first compute the indices into the data arrays where we are interpolating */\n if (xa != NULL)\n xi = gsl_interp_accel_find(xa, xarr, xsize, x);\n else\n xi = gsl_interp_bsearch(xarr, x, 0, xsize - 1);\n\n if (ya != NULL)\n yi = gsl_interp_accel_find(ya, yarr, ysize, y);\n else\n yi = gsl_interp_bsearch(yarr, y, 0, ysize - 1);\n\n /* find the minimum and maximum values on the grid cell in each dimension */\n xmin = xarr[xi];\n xmax = xarr[xi + 1];\n ymin = yarr[yi];\n ymax = yarr[yi + 1];\n zminmin = zarr[IDX2D(xi, yi, state)];\n zminmax = zarr[IDX2D(xi, yi + 1, state)];\n zmaxmin = zarr[IDX2D(xi + 1, yi, state)];\n zmaxmax = zarr[IDX2D(xi + 1, yi + 1, state)];\n\n /* get the width and height of the grid cell */\n dx = xmax - xmin;\n dy = ymax - ymin;\n t = (x - xmin)/dx;\n u = (y - ymin)/dy;\n dt = 1./dx; /* partial t / partial x */\n du = 1./dy; /* partial u / partial y */\n\n zxminmin = state->zx[IDX2D(xi, yi, state)]/dt;\n zxminmax = state->zx[IDX2D(xi, yi + 1, state)]/dt;\n zxmaxmin = state->zx[IDX2D(xi + 1, yi, state)]/dt;\n zxmaxmax = state->zx[IDX2D(xi + 1, yi + 1, state)]/dt;\n zyminmin = state->zy[IDX2D(xi, yi, state)]/du;\n zyminmax = state->zy[IDX2D(xi, yi + 1, state)]/du;\n zymaxmin = state->zy[IDX2D(xi + 1, yi, state)]/du;\n zymaxmax = state->zy[IDX2D(xi + 1, yi + 1, state)]/du;\n zxyminmin = state->zxy[IDX2D(xi, yi, state)]/(dt*du);\n zxyminmax = state->zxy[IDX2D(xi, yi + 1, state)]/(dt*du);\n zxymaxmin = state->zxy[IDX2D(xi + 1, yi, state)]/(dt*du);\n zxymaxmax = state->zxy[IDX2D(xi + 1, yi + 1, state)]/(dt*du);\n\n t0 = 1;\n t1 = t;\n t2 = t*t;\n t3 = t*t2;\n u0 = 1;\n u1 = u;\n\n *z_pp = 0;\n v = -3*zminmin + 3*zminmax - 2*zyminmin - zyminmax;\n *z_pp += 2*v*t0*u0;\n v = 2*zminmin-2*zminmax + zyminmin + zyminmax;\n *z_pp += 6*v*t0*u1;\n v = -3*zxminmin + 3*zxminmax - 2*zxyminmin - zxyminmax;\n *z_pp += 2*v*t1*u0;\n v = 2*zxminmin - 2*zxminmax + zxyminmin + zxyminmax;\n *z_pp += 6*v*t1*u1;\n v = 9*zminmin - 9*zmaxmin + 9*zmaxmax - 9*zminmax + 6*zxminmin + 3*zxmaxmin - 3*zxmaxmax - 6*zxminmax + 6*zyminmin - 6*zymaxmin - 3*zymaxmax + 3*zyminmax + 4*zxyminmin + 2*zxymaxmin + zxymaxmax + 2*zxyminmax;\n *z_pp += 2*v*t2*u0;\n v = -6*zminmin + 6*zmaxmin - 6*zmaxmax + 6*zminmax - 4*zxminmin - 2*zxmaxmin + 2*zxmaxmax + 4*zxminmax - 3*zyminmin + 3*zymaxmin + 3*zymaxmax - 3*zyminmax - 2*zxyminmin - zxymaxmin - zxymaxmax - 2*zxyminmax;\n *z_pp += 6*v*t2*u1;\n v = -6*zminmin + 6*zmaxmin - 6*zmaxmax + 6*zminmax - 3*zxminmin - 3*zxmaxmin + 3*zxmaxmax + 3*zxminmax - 4*zyminmin + 4*zymaxmin + 2*zymaxmax - 2*zyminmax - 2*zxyminmin - 2*zxymaxmin - zxymaxmax - zxyminmax;\n *z_pp += 2*v*t3*u0;\n v = 4*zminmin - 4*zmaxmin + 4*zmaxmax - 4*zminmax + 2*zxminmin + 2*zxmaxmin - 2*zxmaxmax - 2*zxminmax + 2*zyminmin - 2*zymaxmin - 2*zymaxmax + 2*zyminmax + zxyminmin + zxymaxmin + zxymaxmax + zxyminmax;\n *z_pp += 6*v*t3*u1;\n *z_pp *= du*du;\n\n return GSL_SUCCESS;\n}\n\nstatic const gsl_interp2d_type bicubic_type = {\n \"bicubic\",\n 4,\n &bicubic_alloc,\n &bicubic_init,\n &bicubic_eval,\n &bicubic_deriv_x,\n &bicubic_deriv_y,\n &bicubic_deriv_xx,\n &bicubic_deriv_xy,\n &bicubic_deriv_yy,\n &bicubic_free\n};\n\nconst gsl_interp2d_type * gsl_interp2d_bicubic = &bicubic_type;\n\n#undef IDX2D\n", "meta": {"hexsha": "7db14feee0a05b106360de1a6186f28411a2fb0f", "size": 28399, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.6/interpolation/bicubic.c", "max_stars_repo_name": "ielomariala/Hex-Game", "max_stars_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-06-14T11:51:37.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-14T11:51:37.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/interpolation/bicubic.c", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-12-16T17:41:24.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-22T00:00:16.000Z", "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/interpolation/bicubic.c", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-01-20T16:22:57.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-14T12:31:02.000Z", "avg_line_length": 35.2344913151, "max_line_length": 210, "alphanum_fraction": 0.6206556569, "num_tokens": 11335, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8128673269042767, "lm_q2_score": 0.6370307944803831, "lm_q1q2_score": 0.5178215190649766}} {"text": "/* randist/wishart.c\n *\n * Copyright (C) 2017 Timothée Flutre\n *\n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n *\n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n\n/* Generate a random matrix from a Wishart distribution using the Bartlett\n * decomposition, following Smith and Hocking, Journal of the Royal Statistical\n * Society. Series C (Applied Statistics), Vol. 21, No. 3 (1972), pp. 341-345.\n *\n * df degrees of freedom\n * L matrix resulting from the Cholesky decomposition of\n * the scale matrix V = L L^T (dimension d x d)\n * result output matrix (dimension d x d)\n * work matrix used for intermediate computations (dimension d x d)\n */\nint\ngsl_ran_wishart (const gsl_rng * r,\n const double df,\n const gsl_matrix * L,\n gsl_matrix * result,\n gsl_matrix * work)\n{\n if (L->size1 != L->size2)\n {\n GSL_ERROR(\"L should be a square matrix\", GSL_ENOTSQR);\n }\n else if (result->size1 != result->size2)\n {\n GSL_ERROR(\"result should be a square matrix\", GSL_ENOTSQR);\n }\n else if (work->size1 != work->size2)\n {\n GSL_ERROR(\"work should be a square matrix\", GSL_ENOTSQR);\n }\n else if (result->size1 != L->size1)\n {\n GSL_ERROR(\"incompatible dimensions of result matrix\", GSL_EBADLEN);\n }\n else if (work->size1 != L->size1)\n {\n GSL_ERROR(\"incompatible dimensions of work matrix\", GSL_EBADLEN);\n }\n else if (df <= L->size1 - 1)\n {\n GSL_ERROR(\"incompatible degrees of freedom\", GSL_EDOM);\n }\n else\n {\n /* result: X = L A A^T L^T */\n\n size_t d = L->size1, i, j;\n\n /* insure the upper part of A is zero before filling its lower part */\n gsl_matrix_set_zero(work);\n for (i = 0; i < d; ++i)\n {\n gsl_matrix_set(work, i, i, sqrt(gsl_ran_chisq(r, df - i)));\n\n for (j = 0; j < i; ++j)\n {\n gsl_matrix_set(work, i, j, gsl_ran_ugaussian(r));\n }\n }\n\n /* compute L * A */\n gsl_blas_dtrmm(CblasLeft, CblasLower, CblasNoTrans, CblasNonUnit, 1.0,\n L, work);\n\n /* compute (L * A) * (L * A)^T */\n gsl_blas_dsyrk(CblasUpper, CblasNoTrans, 1.0, work, 0.0, result);\n for (i = 0; i < d; ++i)\n {\n for (j = 0; j < i; ++j)\n {\n gsl_matrix_set(result, i, j, gsl_matrix_get(result, j, i));\n }\n }\n\n return GSL_SUCCESS;\n }\n}\n\n/* Compute the log of the probability density function at a given quantile\n * matrix for a Wishart distribution using the Cholesky decomposition of the\n * scale matrix.\n *\n * X quantile matrix at which to evaluate the PDF (dimension d x d)\n * L_X matrix resulting from the Cholesky decomposition of\n * of the quantile matrix at which to evaluate the PDF\n * X = L_X L_X^T (dimension d x d)\n * df degrees of freedom\n * L matrix resulting from the Cholesky decomposition of\n * the scale matrix V = L L^T (dimension d x d)\n * result output of the density (dimension 1)\n * work matrix used for intermediate computations (dimension d x d)\n */\nint\ngsl_ran_wishart_log_pdf (const gsl_matrix * X,\n const gsl_matrix * L_X,\n const double df,\n const gsl_matrix * L,\n double * result,\n gsl_matrix * work)\n{\n if (L->size1 != L->size2)\n {\n GSL_ERROR(\"L should be a square matrix\", GSL_ENOTSQR);\n }\n else if (X->size1 != X->size2)\n {\n GSL_ERROR(\"X should be a square matrix\", GSL_ENOTSQR);\n }\n else if (L_X->size1 != L_X->size2)\n {\n GSL_ERROR(\"L_X should be a square matrix\", GSL_ENOTSQR);\n }\n else if (X->size1 != L->size1)\n {\n GSL_ERROR(\"incompatible dimensions of X matrix\", GSL_EBADLEN);\n }\n else if (L_X->size1 != L->size1)\n {\n GSL_ERROR(\"incompatible dimensions of L_X matrix\", GSL_EBADLEN);\n }\n else if (df <= L->size1 - 1)\n {\n GSL_ERROR(\"incompatible degrees of freedom\", GSL_EDOM);\n }\n else\n {\n size_t d = L->size1, i;\n int status;\n double log_mv_Ga, log_det_V, log_det_X, tr_Vinv_X;\n\n /* compute the log of the multivariate Gamma */\n log_mv_Ga = d * (d-1) * 0.25 * log(M_PI);\n for (i = 0; i < d; ++i)\n {\n log_mv_Ga += gsl_sf_lngamma((df - i + 1) * 0.5);\n }\n\n /* compute the log of the determinant of the scale matrix */\n log_det_V = log(gsl_matrix_get(L, 0, 0));\n for (i = 1; i < d; ++i)\n {\n log_det_V += log(gsl_matrix_get(L, i, i));\n }\n log_det_V = 2 * log_det_V;\n\n /* compute the log of the determinant of the quantile matrix */\n log_det_X = log(gsl_matrix_get(L_X, 0, 0));\n for (i = 1; i < d; ++i)\n {\n log_det_X += log(gsl_matrix_get(L_X, i, i));\n }\n log_det_X = 2 * log_det_X;\n\n /* compute the trace of V^(-1) X */\n status = gsl_linalg_cholesky_solve_mat(L, X, work);\n if (status)\n return status;\n tr_Vinv_X = gsl_matrix_get(work, 0, 0);\n for (i = 1; i < d; ++i)\n {\n tr_Vinv_X += gsl_matrix_get(work, i, i);\n }\n\n /* add all to get the log of the PDF */\n *result = - (0.5 * df * d) * log(2.0)\n - (0.5 * df) * log_det_V\n - log_mv_Ga\n + 0.5 * (df - d - 1) * log_det_X\n - 0.5 * tr_Vinv_X;\n\n return GSL_SUCCESS;\n }\n}\n\nint\ngsl_ran_wishart_pdf (const gsl_matrix * X,\n const gsl_matrix * L_X,\n const double df,\n const gsl_matrix * L,\n double * result,\n gsl_matrix * work)\n{\n double logpdf;\n int status = gsl_ran_wishart_log_pdf(X, L_X, df, L, &logpdf, work);\n\n if (status == GSL_SUCCESS)\n *result = exp(logpdf);\n\n return status;\n}\n", "meta": {"hexsha": "70facdf4b951fc5bd5e1c241cdaa12d805f38be7", "size": 6784, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.6/randist/wishart.c", "max_stars_repo_name": "ielomariala/Hex-Game", "max_stars_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-06-14T11:51:37.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-14T11:51:37.000Z", "max_issues_repo_path": "gsl-2.6/randist/wishart.c", "max_issues_repo_name": "ielomariala/Hex-Game", "max_issues_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-12-16T17:41:24.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-22T00:00:16.000Z", "max_forks_repo_path": "test/lib/gsl-2.6/randist/wishart.c", "max_forks_repo_name": "karanbirsandhu/nu-sense", "max_forks_repo_head_hexsha": "83fd1fc4cbd053a4f9b673d5cd5841823ddd4d8b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-01-20T16:22:57.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-14T12:31:02.000Z", "avg_line_length": 30.6968325792, "max_line_length": 81, "alphanum_fraction": 0.5782724057, "num_tokens": 1911, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8221891305219505, "lm_q2_score": 0.6297746074044134, "lm_q1q2_score": 0.5177938368866374}} {"text": "#ifndef DBJ_VARIOUS_SIMPLE_MATMULS_INC\n#define DBJ_VARIOUS_SIMPLE_MATMULS_INC\n\n// not using any kind of \"matrix framework\"\n\n#include \"../dbj_matmul_common.h\" // DBJ_MATRIX_DATA_TYPE\n\n#include \n#include // #define __SSE__ 1\n#ifdef HAVE_CBLAS\n#include \n#endif\n\n#undef DBJ_API\n#define DBJ_API\n\n//////////////////////////////////////////////////////////////////////\n#ifndef DBJ_SANITY_MAX_ROW_COUNT\n#define DBJ_SANITY_MAX_ROW_COUNT 0xFFFF\n#endif\n\n#ifndef DBJ_SANITY_MAX_COL_COUNT\n#define DBJ_SANITY_MAX_COL_COUNT 0xFFFF\n#endif\n//////////////////////////////////////////////////////////////////////\n\ntypedef void* (*simple_mat_mul_function)(\n\tconst unsigned, const unsigned, const unsigned,\n\tDBJ_MATRIX_DATA_TYPE[][*],\n\tDBJ_MATRIX_DATA_TYPE[][*],\n\tDBJ_MATRIX_DATA_TYPE[][*] /* the result */\n\t);\n\ntypedef struct\n{\n\tconst char* description;\n\tsimple_mat_mul_function function;\n} simple_description_function_pair;\n\n#define DF_PAIR(D_, F_) \\\n\t(simple_description_function_pair) { .description = D_, .function = F_ }\n\n//////////////////////////////////////////////////////////////////////\n\nDBJ_API DBJ_MATRIX_DATA_TYPE* new_simple_matrix(const unsigned, const unsigned);\n\nDBJ_API DBJ_MATRIX_DATA_TYPE* make_simple_matrix(\n\tconst unsigned, const unsigned, DBJ_MATRIX_DATA_TYPE(*)(void));\n\nDBJ_API void* simple_mat_transpose(\n\tconst unsigned, const unsigned, DBJ_MATRIX_DATA_TYPE[][*], DBJ_MATRIX_DATA_TYPE[][*]);\n\nDBJ_API void* simple_mat_mul_null(\n\tconst unsigned n_a_rows, const unsigned n_a_cols, const unsigned n_b_cols,\n\tDBJ_MATRIX_DATA_TYPE a[static n_a_rows][n_a_cols], DBJ_MATRIX_DATA_TYPE b[static n_a_rows][n_b_cols], DBJ_MATRIX_DATA_TYPE m[static n_a_rows][n_b_cols])\n{\n\t// used for when algorithms are not implemented yet\n\t(void)a;\n\t(void)b;\n\t(void)m;\n\treturn NULL;\n}\n\nDBJ_API void* simple_mat_mul_0_0(\n\tconst unsigned n_a_rows, const unsigned n_a_cols, const unsigned n_b_cols,\n\tDBJ_MATRIX_DATA_TYPE(*ax)[n_a_cols],\n\tDBJ_MATRIX_DATA_TYPE(*bx)[n_a_cols],\n\tDBJ_MATRIX_DATA_TYPE(*mx)[n_a_cols]);\n\nDBJ_API void* simple_mat_mul_0(const unsigned /*n_a_rows*/, const unsigned /*n_a_cols*/, const unsigned /*n_b_cols*/,\n\tDBJ_MATRIX_DATA_TYPE[/*n_a_rows*/][* /*n_a_cols*/], DBJ_MATRIX_DATA_TYPE[/*n_a_rows*/][* /*n_b_cols*/], DBJ_MATRIX_DATA_TYPE[/*n_a_rows*/][* /*n_b_cols*/]);\n\nDBJ_API void* simple_mat_mul_1(const unsigned /*n_a_rows*/, const unsigned /*n_a_cols*/, const unsigned /*n_b_cols*/,\n\tDBJ_MATRIX_DATA_TYPE[/*n_a_rows*/][* /*n_a_cols*/], DBJ_MATRIX_DATA_TYPE[/*n_a_rows*/][* /*n_b_cols*/], DBJ_MATRIX_DATA_TYPE[/*n_a_rows*/][* /*n_b_cols*/]);\n\nDBJ_API void* simple_mat_mul_3(const unsigned /*n_a_rows*/, const unsigned /*n_a_cols*/, const unsigned /*n_b_cols*/,\n\tDBJ_MATRIX_DATA_TYPE[/*n_a_rows*/][* /*n_a_cols*/], DBJ_MATRIX_DATA_TYPE[/*n_a_rows*/][* /*n_b_cols*/], DBJ_MATRIX_DATA_TYPE[/*n_a_rows*/][* /*n_b_cols*/]);\n\nDBJ_API void* simple_mat_mul_4(const unsigned /*n_a_rows*/, const unsigned /*n_a_cols*/, const unsigned /*n_b_cols*/,\n\tDBJ_MATRIX_DATA_TYPE[/*n_a_rows*/][* /*n_a_cols*/], DBJ_MATRIX_DATA_TYPE[/*n_a_rows*/][* /*n_b_cols*/], DBJ_MATRIX_DATA_TYPE[/*n_a_rows*/][* /*n_b_cols*/]);\n\n#if __SSE__\n\nDBJ_API void* simple_mat_mul_2(const unsigned /*n_a_rows*/, const unsigned /*n_a_cols*/, const unsigned /*n_b_cols*/,\n\tDBJ_MATRIX_DATA_TYPE a[/*n_a_rows*/][* /*n_a_cols*/], DBJ_MATRIX_DATA_TYPE b[/*n_a_rows*/][* /*n_b_cols*/], DBJ_MATRIX_DATA_TYPE m[/*n_a_rows*/][* /*n_b_cols*/]);\n\nDBJ_API void* simple_mat_mul_7(const unsigned /*n_a_rows*/, const unsigned /*n_a_cols*/, const unsigned /*n_b_cols*/,\n\tDBJ_MATRIX_DATA_TYPE a[/*n_a_rows*/][* /*n_a_cols*/], DBJ_MATRIX_DATA_TYPE b[/*n_a_rows*/][* /*n_b_cols*/], DBJ_MATRIX_DATA_TYPE m[/*n_a_rows*/][* /*n_b_cols*/]);\n\n#endif // __SSE__\n\n#ifdef HAVE_CBLAS\nDBJ_API void* simple_mat_mul_5(const unsigned /*n_a_rows*/, const unsigned /*n_a_cols*/, const unsigned /*n_b_cols*/,\n\tDBJ_MATRIX_DATA_TYPE a[/*n_a_rows*/][* /*n_a_cols*/], DBJ_MATRIX_DATA_TYPE b[/*n_a_rows*/][* /*n_b_cols*/], DBJ_MATRIX_DATA_TYPE m[/*n_a_rows*/][* /*n_b_cols*/]);\n\nDBJ_API void* simple_mat_mul_6(const unsigned /*n_a_rows*/, const unsigned /*n_a_cols*/, const unsigned /*n_b_cols*/,\n\tDBJ_MATRIX_DATA_TYPE a[/*n_a_rows*/][* /*n_a_cols*/], DBJ_MATRIX_DATA_TYPE b[/*n_a_rows*/][* /*n_b_cols*/], DBJ_MATRIX_DATA_TYPE m[/*n_a_rows*/][* /*n_b_cols*/]);\n#endif // HAVE_CBLAS\n\nconst simple_description_function_pair dbj_simple_matmuls_algo_table[] =\n{\n\tDF_PAIR(\"0: MAX optimization\", simple_mat_mul_0_0),\n\tDF_PAIR(\"1: simple naive - no optimization\", simple_mat_mul_0),\n\tDF_PAIR(\"2: simple transposing the second matrix\", simple_mat_mul_1),\n\tDF_PAIR(\"3: simple explicitly vectorized sdot() with SSE\", simple_mat_mul_2), /* requires __SSE__ */\n\tDF_PAIR(\"4: simple explicitly SSE sdot() plus loop tiling\", simple_mat_mul_7) , /* requires __SSE__ */\n\tDF_PAIR(\"5: simple implicitly vectorized sdot()\", simple_mat_mul_3),\n\tDF_PAIR(\"6: simple no vectorization hints\", simple_mat_mul_4),\n#ifdef HAVE_CBLAS\n\tDF_PAIR(\"7: simple with sdot() from an external CBLAS library\", simple_mat_mul_5),\n\tDF_PAIR(\"8: simple with sgemm() from an external CBLAS library\", simple_mat_mul_6),\n#endif\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t// ! HAVE_CBLAS\n};\n\nstatic const unsigned dbj_simple_matmuls_algo_table_size = (sizeof(dbj_simple_matmuls_algo_table) / sizeof(dbj_simple_matmuls_algo_table[0]));\n\n//////////////////////////////////////////////////////////////////////\n#ifdef DBJ_VARIOUS_SIMPLE_MATMULS_IMPLEMENTATION\n//////////////////////////////////////////////////////////////////////\n\nDBJ_API DBJ_MATRIX_DATA_TYPE* new_simple_matrix(const unsigned n_rows, const unsigned n_cols)\n{\n\tDBJ_MATRIX_DATA_TYPE* retval = calloc(n_rows * n_cols, sizeof(DBJ_MATRIX_DATA_TYPE));\n\n\tif (!retval)\n\t{\n\t\tfprintf(stderr, \"\\n%s(%d) new_simple_matrix() failed?\\n\", __FILE__, __LINE__);\n\t\tperror(\" \");\n\t\texit(1);\n\t}\n\treturn retval;\n}\n\nDBJ_API DBJ_MATRIX_DATA_TYPE* make_simple_matrix(\n\tconst unsigned n_rows, const unsigned n_cols, DBJ_MATRIX_DATA_TYPE(*value_provider)(void))\n{\n\tDBJ_MATRIX_DATA_TYPE* rezult = new_simple_matrix(n_rows, n_cols);\n\n\ttypedef DBJ_MATRIX_DATA_TYPE(*matrix)[n_cols];\n\tmatrix mx = (matrix)rezult;\n\n\tfor (unsigned i = 0; i < n_rows; ++i)\n\t\tfor (unsigned j = 0; j < n_cols; ++j)\n\t\t\tmx[i][j] = value_provider(); //\n\treturn rezult;\n}\n\nDBJ_API void* simple_mat_transpose(\n\tconst unsigned n_rows, const unsigned n_cols,\n\tDBJ_MATRIX_DATA_TYPE a[static n_rows][n_cols], DBJ_MATRIX_DATA_TYPE m[static n_cols][n_rows])\n{\n\tfor (unsigned i = 0; i < n_rows; ++i)\n\t\tfor (unsigned j = 0; j < n_cols; ++j)\n\t\t\tm[j][i] = a[i][j];\n\treturn m;\n}\n\nDBJ_API DBJ_MATRIX_DATA_TYPE simple_sdot_1(int n, const DBJ_MATRIX_DATA_TYPE x[static n], const DBJ_MATRIX_DATA_TYPE y[static n])\n{\n\tDBJ_MATRIX_DATA_TYPE s = 0.0f;\n\tfor (int i = 0; i < n; ++i)\n\t\ts += x[i] * y[i];\n\treturn s;\n}\n\nDBJ_API DBJ_MATRIX_DATA_TYPE simple_sdot_8(int n, const DBJ_MATRIX_DATA_TYPE x[static n], const DBJ_MATRIX_DATA_TYPE y[static n])\n{\n\tint i, n8 = n >> 3 << 3;\n\tDBJ_MATRIX_DATA_TYPE s = 0.0f, t[8] = { 0.0f };\n\t// t[0] = t[1] = t[2] = t[3] = t[4] = t[5] = t[6] = t[7] = 0.0f;\n\tfor (i = 0; i < n8; i += 8)\n\t{\n\t\tt[0] += x[i + 0] * y[i + 0];\n\t\tt[1] += x[i + 1] * y[i + 1];\n\t\tt[2] += x[i + 2] * y[i + 2];\n\t\tt[3] += x[i + 3] * y[i + 3];\n\t\tt[4] += x[i + 4] * y[i + 4];\n\t\tt[5] += x[i + 5] * y[i + 5];\n\t\tt[6] += x[i + 6] * y[i + 6];\n\t\tt[7] += x[i + 7] * y[i + 7];\n\t}\n\tfor (s = 0.0f; i < n; ++i)\n\t\ts += x[i] * y[i];\n\ts += t[0] + t[1] + t[2] + t[3] + t[4] + t[5] + t[6] + t[7];\n\treturn s;\n}\n\n#ifdef __SSE__\n\nDBJ_API DBJ_MATRIX_DATA_TYPE simple_sdot_sse(int n, const DBJ_MATRIX_DATA_TYPE x[static n], const DBJ_MATRIX_DATA_TYPE y[static n])\n{\n\tint i, n8 = n >> 3 << 3;\n\t__m128 vs1, vs2;\n\tDBJ_MATRIX_DATA_TYPE s, t[4];\n\tvs1 = _mm_setzero_ps();\n\tvs2 = _mm_setzero_ps();\n\tfor (i = 0; i < n8; i += 8)\n\t{\n\t\t__m128 vx1, vx2, vy1, vy2;\n\t\tvx1 = _mm_loadu_ps(&x[i]);\n\t\tvx2 = _mm_loadu_ps(&x[i + 4]);\n\t\tvy1 = _mm_loadu_ps(&y[i]);\n\t\tvy2 = _mm_loadu_ps(&y[i + 4]);\n\t\tvs1 = _mm_add_ps(vs1, _mm_mul_ps(vx1, vy1));\n\t\tvs2 = _mm_add_ps(vs2, _mm_mul_ps(vx2, vy2));\n\t}\n\tfor (s = 0.0f; i < n; ++i)\n\t\ts += x[i] * y[i];\n\t_mm_storeu_ps(t, vs1);\n\ts += t[0] + t[1] + t[2] + t[3];\n\t_mm_storeu_ps(t, vs2);\n\ts += t[0] + t[1] + t[2] + t[3];\n\treturn s;\n}\n#endif // __SSE__\n\n/**************************************************\n\n Various Matrix multiplication algorithms\n\n NOTE: check and choose for your RT Env\n\t there are differences but are *very* dependant on\n\t compiler, OS and hardware\n\n */\n\nDBJ_API void* simple_mat_mul_0_0(\n\tconst unsigned n_a_rows, const unsigned n_a_cols, const unsigned n_b_cols,\n\tDBJ_MATRIX_DATA_TYPE(*ax)[n_a_cols],\n\tDBJ_MATRIX_DATA_TYPE(*bx)[n_a_cols],\n\tDBJ_MATRIX_DATA_TYPE(*mx)[n_a_cols])\n{\n\t// runtime casting takes time\n\tconst unsigned n_b_rows = n_a_cols;\n\t// DBJ_MATRIX_DATA_TYPE(*ax)[n_a_cols] = a;\n\t// DBJ_MATRIX_DATA_TYPE(*bx)[n_b_cols] = b;\n\t// DBJ_MATRIX_DATA_TYPE(*mx)[n_b_rows] = m;\n\n\tfor (unsigned i = 0; i < n_a_rows; ++i)\n\t{\n\t\tfor (unsigned j = 0; j < n_b_cols; ++j)\n\t\t{\n\t\t\tDBJ_MATRIX_DATA_TYPE t = 0.0;\n\t\t\tfor (unsigned k = 0; k < n_a_cols; ++k)\n\t\t\t\tt += ax[i][k] * bx[k][j];\n\t\t\tmx[i][j] = t;\n\t\t}\n\t}\n\treturn mx;\n}\n\nDBJ_API void* simple_mat_mul_0(\n\tconst unsigned n_a_rows, const unsigned n_a_cols, const unsigned n_b_cols,\n\tDBJ_MATRIX_DATA_TYPE a[static n_a_rows][n_a_cols], DBJ_MATRIX_DATA_TYPE b[static n_a_rows][n_b_cols], DBJ_MATRIX_DATA_TYPE m[static n_a_rows][n_b_cols])\n{\n\tfor (unsigned i = 0; i < n_a_rows; ++i)\n\t{\n\t\tfor (unsigned j = 0; j < n_b_cols; ++j)\n\t\t{\n\t\t\tDBJ_MATRIX_DATA_TYPE t = 0.0;\n\t\t\tfor (unsigned k = 0; k < n_a_cols; ++k)\n\t\t\t\tt += a[i][k] * b[k][j];\n\t\t\tm[i][j] = t;\n\t\t}\n\t}\n\treturn m;\n}\n\nDBJ_API void* simple_mat_mul_1(\n\tconst unsigned n_a_rows, const unsigned n_a_cols, const unsigned n_b_cols,\n\tDBJ_MATRIX_DATA_TYPE a[static n_a_rows][n_a_cols], DBJ_MATRIX_DATA_TYPE b[static n_a_rows][n_b_cols], DBJ_MATRIX_DATA_TYPE m[static n_a_rows][n_b_cols])\n{\n\tconst unsigned n_b_rows = n_a_cols;\n\n\tDBJ_MATRIX_DATA_TYPE* Temp = new_simple_matrix(n_b_cols, n_b_rows);\n\t// Temp rows and cols are inverted !\n\ttypedef DBJ_MATRIX_DATA_TYPE(*matrix)[n_b_rows];\n\tmatrix bT = (matrix)Temp;\n\t(void)simple_mat_transpose(n_b_rows, n_b_cols, b, bT);\n\n\tfor (unsigned i = 0; i < n_a_rows; ++i)\n\t{\n\t\tconst DBJ_MATRIX_DATA_TYPE* ai = a[i];\n\t\tDBJ_MATRIX_DATA_TYPE* mi = m[i];\n\t\tfor (unsigned j = 0; j < n_b_cols; ++j)\n\t\t{\n\t\t\tDBJ_MATRIX_DATA_TYPE t = 0.0f, * bTj = bT[j];\n\t\t\tfor (unsigned k = 0; k < n_a_cols; ++k)\n\t\t\t\tt += ai[k] * bTj[k];\n\t\t\tmi[j] = t;\n\t\t}\n\t}\n\n\tfree(Temp);\n\n\treturn m;\n}\n\nDBJ_API void* simple_mat_mul_2(\n\tconst unsigned n_a_rows, const unsigned n_a_cols, const unsigned n_b_cols,\n\tDBJ_MATRIX_DATA_TYPE a[static n_a_rows][n_a_cols], DBJ_MATRIX_DATA_TYPE b[static n_a_rows][n_b_cols], DBJ_MATRIX_DATA_TYPE m[static n_a_rows][n_b_cols])\n{\n#ifndef __SSE__\n#error __SEE__ is required here\n#endif\n\n\tconst unsigned n_b_rows = n_a_cols;\n\n\tDBJ_MATRIX_DATA_TYPE* Temp = new_simple_matrix(n_b_cols, n_b_rows);\n\t// Temp rows and cols are inverted !\n\ttypedef DBJ_MATRIX_DATA_TYPE(*matrix)[n_b_rows];\n\tmatrix bT = (matrix)Temp;\n\t(void)simple_mat_transpose(n_b_rows, n_b_cols, b, bT);\n\n\tfor (unsigned i = 0; i < n_a_rows; ++i)\n\t\tfor (unsigned j = 0; j < n_b_cols; ++j)\n\t\t\tm[i][j] = simple_sdot_sse(n_a_cols, a[i], bT[j]);\n\tfree(Temp);\n\treturn m;\n}\n\nDBJ_API void* simple_mat_mul_7(\n\tconst unsigned n_a_rows, const unsigned n_a_cols, const unsigned n_b_cols,\n\tDBJ_MATRIX_DATA_TYPE a[static n_a_rows][n_a_cols], DBJ_MATRIX_DATA_TYPE b[static n_a_rows][n_b_cols], DBJ_MATRIX_DATA_TYPE m[static n_a_rows][n_b_cols])\n{\n#ifndef __SSE__\n#error __SEE__ is required here\n#endif\n\n\tconst unsigned x = 16, n_b_rows = n_a_cols;\n\n\tDBJ_MATRIX_DATA_TYPE* Temp = new_simple_matrix(n_b_cols, n_b_rows);\n\t// Temp rows and cols are inverted !\n\ttypedef DBJ_MATRIX_DATA_TYPE(*matrix)[n_b_rows];\n\tmatrix bT = (matrix)Temp;\n\t(void)simple_mat_transpose(n_b_rows, n_b_cols, b, bT);\n\n\tfor (unsigned i = 0; i < n_a_rows; i += x)\n\t{\n\t\tfor (unsigned j = 0; j < n_b_cols; j += x)\n\t\t{\n\t\t\tunsigned je = n_b_cols < j + x ? n_b_cols : j + x;\n\t\t\tunsigned ie = n_a_rows < i + x ? n_a_rows : i + x;\n\t\t\tfor (unsigned ii = i; ii < ie; ++ii)\n\t\t\t\tfor (unsigned jj = j; jj < je; ++jj)\n\t\t\t\t\tm[ii][jj] += simple_sdot_sse(n_a_cols, a[ii], bT[jj]);\n\t\t}\n\t}\n\tfree(Temp);\n\treturn m;\n}\n\n/////////////////////////////////////////////////////////////////////////////////////\n\nDBJ_API void* simple_mat_mul_3(\n\tconst unsigned n_a_rows, const unsigned n_a_cols, const unsigned n_b_cols,\n\tDBJ_MATRIX_DATA_TYPE a[static n_a_rows][n_a_cols], DBJ_MATRIX_DATA_TYPE b[static n_a_rows][n_b_cols], DBJ_MATRIX_DATA_TYPE m[static n_a_rows][n_b_cols])\n{\n\tint n_b_rows = n_a_cols;\n\n\tDBJ_MATRIX_DATA_TYPE* Temp = new_simple_matrix(n_b_cols, n_b_rows);\n\t// Temp rows and cols are inverted !\n\ttypedef DBJ_MATRIX_DATA_TYPE(*matrix)[n_b_rows];\n\tmatrix bT = (matrix)Temp;\n\t(void)simple_mat_transpose(n_b_rows, n_b_cols, b, bT);\n\n\tfor (unsigned i = 0; i < n_a_rows; ++i)\n\t\tfor (unsigned j = 0; j < n_b_cols; ++j)\n\t\t\tm[i][j] = simple_sdot_8(n_a_cols, a[i], bT[j]);\n\tfree(Temp);\n\treturn m;\n}\n\nDBJ_API void* simple_mat_mul_4(\n\tconst unsigned n_a_rows, const unsigned n_a_cols, const unsigned n_b_cols,\n\tDBJ_MATRIX_DATA_TYPE a[static n_a_rows][n_a_cols], DBJ_MATRIX_DATA_TYPE b[static n_a_rows][n_b_cols], DBJ_MATRIX_DATA_TYPE m[static n_a_rows][n_b_cols])\n{\n\tint n_b_rows = n_a_cols;\n\n\tDBJ_MATRIX_DATA_TYPE* Temp = new_simple_matrix(n_b_cols, n_b_rows);\n\t// Temp rows and cols are inverted !\n\ttypedef DBJ_MATRIX_DATA_TYPE(*matrix)[n_b_rows];\n\tmatrix bT = (matrix)Temp;\n\t(void)simple_mat_transpose(n_b_rows, n_b_cols, b, bT);\n\n\tfor (unsigned i = 0; i < n_a_rows; ++i)\n\t\tfor (unsigned j = 0; j < n_b_cols; ++j)\n\t\t\tm[i][j] = simple_sdot_1(n_a_cols, a[i], bT[j]);\n\tfree(Temp);\n\treturn m;\n}\n\n#ifdef HAVE_CBLAS\n\nDBJ_API void* simple_mat_mul_5(\n\tconst unsigned n_a_rows, const unsigned n_a_cols, const unsigned n_b_cols,\n\tDBJ_MATRIX_DATA_TYPE a[static n_a_rows][n_a_cols], DBJ_MATRIX_DATA_TYPE b[static n_a_rows][n_b_cols], DBJ_MATRIX_DATA_TYPE m[static n_a_rows][n_b_cols])\n{\n\tconst unsigned n_b_rows = n_a_cols;\n\n\tDBJ_MATRIX_DATA_TYPE* Temp = new_simple_matrix(n_rows, n_cols);\n\t// Temp rows and cols are inverted !\n\ttypedef DBJ_MATRIX_DATA_TYPE(*matrix)[n_rows];\n\tmatrix bT = (matrix)Temp;\n\t(void)simple_mat_transpose(n_b_rows, n_b_cols, b, bT);\n\n\tfor (unsigned i = 0; i < n_a_rows; ++i)\n\t\tfor (unsigned j = 0; j < n_b_cols; ++j)\n\t\t\tm[i][j] = cblas_sdot(n_a_cols, a[i], 1, bT[j], 1); // clas_sdot() ???\n\tfree(Temp);\n\treturn m;\n}\n\nDBJ_API void* simple_mat_mul_6(\n\tconst unsigned n_a_rows, const unsigned n_a_cols, const unsigned n_b_cols,\n\tDBJ_MATRIX_DATA_TYPE a[static n_a_rows][n_a_cols], DBJ_MATRIX_DATA_TYPE b[static n_a_rows][n_b_cols], DBJ_MATRIX_DATA_TYPE m[static n_a_rows][n_b_cols])\n{\n\tcblas_sgemm(CblasRowMajor, CblasNoTrans, CblasNoTrans, n_a_rows, n_b_cols, n_a_cols, 1.0f, a[0], n_a_rows, b[0], n_b_rows, 0.0f, m[0], n_a_rows);\n\treturn m;\n}\n#endif // HAVE_CBLAS\n\n//////////////////////////////////////////////////////////////////////\n#endif // DBJ_VARIOUS_SIMPLE_MATMULS_IMPLEMENTATION\n//////////////////////////////////////////////////////////////////////\n\n#undef DF_PAIR\n\n#endif // DBJ_VARIOUS_SIMPLE_MATMULS_INC", "meta": {"hexsha": "db4362cb1894d2c795fd39ee8901e5dfae1b04f8", "size": 15131, "ext": "h", "lang": "C", "max_stars_repo_path": "r_and_d/simple_matmuls.h", "max_stars_repo_name": "DBJDBJ/dbj_matmul", "max_stars_repo_head_hexsha": "e1f1c6ce0724afa3afb8d38bcc63e4772b9f2866", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "r_and_d/simple_matmuls.h", "max_issues_repo_name": "DBJDBJ/dbj_matmul", "max_issues_repo_head_hexsha": "e1f1c6ce0724afa3afb8d38bcc63e4772b9f2866", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "r_and_d/simple_matmuls.h", "max_forks_repo_name": "DBJDBJ/dbj_matmul", "max_forks_repo_head_hexsha": "e1f1c6ce0724afa3afb8d38bcc63e4772b9f2866", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.2703962704, "max_line_length": 163, "alphanum_fraction": 0.679201639, "num_tokens": 4823, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7401743505760728, "lm_q2_score": 0.6992544273261175, "lm_q1q2_score": 0.5175701916335528}} {"text": "\n/*****************************************************************************\n*\n* Copyright (c) 2003-2018 by The University of Queensland\n* http://www.uq.edu.au\n*\n* Primary Business: Queensland, Australia\n* Licensed under the Apache License, version 2.0\n* http://www.apache.org/licenses/LICENSE-2.0\n*\n* Development until 2012 by Earth Systems Science Computational Center (ESSCC)\n* Development 2012-2013 by School of Earth Sciences\n* Development from 2014 by Centre for Geoscience Computing (GeoComp)\n*\n*****************************************************************************/\n\n#ifndef __PASO_BLOCKOPS_H__\n#define __PASO_BLOCKOPS_H__\n\n#include \"Paso.h\"\n#include \"PasoException.h\"\n\n#include // memcpy\n\n#ifdef ESYS_HAVE_LAPACK\n #ifdef ESYS_MKL_LAPACK\n #include \n #include \n #else\n extern \"C\" {\n #include \n #include \n }\n #endif\n#endif\n\nnamespace paso {\n\ninline void BlockOps_Cpy_N(dim_t N, double* R, const double* V)\n{\n memcpy((void*)R, (void*)V, N*sizeof(double));\n}\n\n/// performs operation R=R-mat*V (V and R are not overlapping) - 2x2\ninline void BlockOps_SMV_2(double* R, const double* mat, const double* V)\n{\n const double S1 = V[0];\n const double S2 = V[1];\n const double A11 = mat[0];\n const double A12 = mat[2];\n const double A21 = mat[1];\n const double A22 = mat[3];\n R[0] -= A11 * S1 + A12 * S2;\n R[1] -= A21 * S1 + A22 * S2;\n}\n\n/// performs operation R=R-mat*V (V and R are not overlapping) - 3x3\ninline void BlockOps_SMV_3(double* R, const double* mat, const double* V)\n{\n const double S1 = V[0];\n const double S2 = V[1];\n const double S3 = V[2];\n const double A11 = mat[0];\n const double A21 = mat[1];\n const double A31 = mat[2];\n const double A12 = mat[3];\n const double A22 = mat[4];\n const double A32 = mat[5];\n const double A13 = mat[6];\n const double A23 = mat[7];\n const double A33 = mat[8];\n R[0] -= A11 * S1 + A12 * S2 + A13 * S3;\n R[1] -= A21 * S1 + A22 * S2 + A23 * S3;\n R[2] -= A31 * S1 + A32 * S2 + A33 * S3;\n}\n\n#define PASO_MISSING_CLAPACK throw PasoException(\"You need to install a LAPACK version to enable operations on block sizes > 3.\")\n\n/// performs operation R=R-mat*V (V and R are not overlapping) - NxN\ninline void BlockOps_SMV_N(dim_t N, double* R, const double* mat, const double* V)\n{\n#ifdef ESYS_HAVE_LAPACK\n cblas_dgemv(CblasColMajor,CblasNoTrans, N, N, -1., mat, N, V, 1, 1., R, 1);\n#else\n PASO_MISSING_CLAPACK;\n#endif\n}\n\ninline void BlockOps_MV_N(dim_t N, double* R, const double* mat, const double* V)\n{\n#ifdef ESYS_HAVE_LAPACK\n cblas_dgemv(CblasColMajor,CblasNoTrans, N, N, 1., mat, N, V, 1, 0., R, 1);\n#else\n PASO_MISSING_CLAPACK;\n#endif\n}\n\ninline void BlockOps_invM_2(double* invA, const double* A, int* failed)\n{\n const double A11 = A[0];\n const double A12 = A[2];\n const double A21 = A[1];\n const double A22 = A[3];\n double D = A11*A22-A12*A21;\n if (std::abs(D) > 0) {\n D = 1./D;\n invA[0] = A22*D;\n invA[1] = -A21*D;\n invA[2] = -A12*D;\n invA[3] = A11*D;\n } else {\n *failed = 1;\n }\n}\n\ninline void BlockOps_invM_3(double* invA, const double* A, int* failed)\n{\n const double A11 = A[0];\n const double A21 = A[1];\n const double A31 = A[2];\n const double A12 = A[3];\n const double A22 = A[4];\n const double A32 = A[5];\n const double A13 = A[6];\n const double A23 = A[7];\n const double A33 = A[8];\n double D = A11*(A22*A33-A23*A32) +\n A12*(A31*A23-A21*A33) +\n A13*(A21*A32-A31*A22);\n if (std::abs(D) > 0) {\n D = 1./D;\n invA[0] = (A22*A33-A23*A32)*D;\n invA[1] = (A31*A23-A21*A33)*D;\n invA[2] = (A21*A32-A31*A22)*D;\n invA[3] = (A13*A32-A12*A33)*D;\n invA[4] = (A11*A33-A31*A13)*D;\n invA[5] = (A12*A31-A11*A32)*D;\n invA[6] = (A12*A23-A13*A22)*D;\n invA[7] = (A13*A21-A11*A23)*D;\n invA[8] = (A11*A22-A12*A21)*D;\n } else {\n *failed = 1;\n }\n}\n\n/// LU factorization of NxN matrix mat with partial pivoting\ninline void BlockOps_invM_N(dim_t N, double* mat, index_t* pivot, int* failed)\n{\n#ifdef ESYS_HAVE_LAPACK\n#ifdef ESYS_MKL_LAPACK\n int res = 0;\n dgetrf(&N, &N, mat, &N, pivot, &res);\n if (res != 0)\n *failed = 1;\n#else\n int res = clapack_dgetrf(CblasColMajor, N, N, mat, N, pivot);\n if (res != 0)\n *failed = 1;\n#endif // ESYS_MKL_LAPACK\n#else\n PASO_MISSING_CLAPACK;\n#endif\n}\n\n/// solves system of linear equations A*X=B\ninline void BlockOps_solve_N(dim_t N, double* X, double* mat, index_t* pivot, int* failed)\n{\n#ifdef ESYS_HAVE_LAPACK\n#ifdef ESYS_MKL_LAPACK\n int res = 0;\n int ONE = 1;\n dgetrs(\"N\", &N, &ONE, mat, &N, pivot, X, &N, &res);\n if (res != 0)\n *failed = 1;\n#else\n int res = clapack_dgetrs(CblasColMajor, CblasNoTrans, N, 1, mat, N, pivot, X, N);\n if (res != 0)\n *failed = 1;\n#endif // ESYS_MKL_LAPACK\n#else\n PASO_MISSING_CLAPACK;\n#endif\n}\n\n/// inplace matrix vector product - order 2\ninline void BlockOps_MViP_2(const double* mat, double* V)\n{\n const double S1 = V[0];\n const double S2 = V[1];\n const double A11 = mat[0];\n const double A12 = mat[2];\n const double A21 = mat[1];\n const double A22 = mat[3];\n V[0] = A11 * S1 + A12 * S2;\n V[1] = A21 * S1 + A22 * S2;\n}\n\n/// inplace matrix vector product - order 3\ninline void BlockOps_MViP_3(const double* mat, double* V)\n{\n const double S1 = V[0];\n const double S2 = V[1];\n const double S3 = V[2];\n const double A11 = mat[0];\n const double A21 = mat[1];\n const double A31 = mat[2];\n const double A12 = mat[3];\n const double A22 = mat[4];\n const double A32 = mat[5];\n const double A13 = mat[6];\n const double A23 = mat[7];\n const double A33 = mat[8];\n V[0] = A11 * S1 + A12 * S2 + A13 * S3;\n V[1] = A21 * S1 + A22 * S2 + A23 * S3;\n V[2] = A31 * S1 + A32 * S2 + A33 * S3;\n}\n\ninline void BlockOps_solveAll(dim_t n_block, dim_t n, double* D,\n index_t* pivot, double* x)\n{\n if (n_block == 1) {\n#pragma omp parallel for\n for (dim_t i=0; i 0) {\n throw PasoException(\"BlockOps_solveAll: solution failed.\");\n }\n }\n}\n\n} // namespace paso\n\n#endif // __PASO_BLOCKOPS_H__\n\n", "meta": {"hexsha": "15d576e9d00c880f6c272aa581899ea179dbe745", "size": 6937, "ext": "h", "lang": "C", "max_stars_repo_path": "paso/src/BlockOps.h", "max_stars_repo_name": "svn2github/Escript", "max_stars_repo_head_hexsha": "9c616a3b164446c65d4b8564ecd04fafd7dcf0d2", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "paso/src/BlockOps.h", "max_issues_repo_name": "svn2github/Escript", "max_issues_repo_head_hexsha": "9c616a3b164446c65d4b8564ecd04fafd7dcf0d2", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2019-01-14T03:07:43.000Z", "max_issues_repo_issues_event_max_datetime": "2019-01-14T03:07:43.000Z", "max_forks_repo_path": "paso/src/BlockOps.h", "max_forks_repo_name": "svn2github/Escript", "max_forks_repo_head_hexsha": "9c616a3b164446c65d4b8564ecd04fafd7dcf0d2", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.748, "max_line_length": 129, "alphanum_fraction": 0.5769064437, "num_tokens": 2380, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8031737963569014, "lm_q2_score": 0.6442251064863697, "lm_q1q2_score": 0.5174247244850866}} {"text": "#ifndef CIMPLE_POLYTOPE_LIBRARY_CIMPLE_H\n#define CIMPLE_POLYTOPE_LIBRARY_CIMPLE_H\n\n#include \n#include \n#include \n#include \"cimple_gsl_library_extension.h\"\n#include \n#include \"setoper.h\"\n#include \n#include \"cimple_auxiliary_functions.h\"\n#include \"cimple_minksum_wrapper.h\"\n\n\n/**\n * H left side of polytope (sometimes noted A or L)\n * G right side of polytope (sometimes noted b or M)\n *\n * H.x <= G\n *\n * Chebyshev center is a possible definition of the \"center\" of the polytope.\n */\ntypedef struct polytope{\n\n gsl_matrix * H;\n gsl_vector * G;\n double *chebyshev_center;\n\n}polytope;\n\n\n/**\n * @brief \"Constructor\" Dynamically allocates the space a polytope needs\n * @param k H.size1 == G.size\n * @param n H.size2\n * @return\n */\nstruct polytope *polytope_alloc(size_t k, size_t n);\n\n/**\n * @brief \"Destructor\" Deallocates the dynamically allocated memory of the polytope\n * @param polytope\n */\nvoid polytope_free(polytope *polytope);\n\n\n/**\n * Subdivision of abstract state containing additionally to the polytope also safe mode instructions\n * The array of polytopes \"polytope **safe_mode\" contains N polytopes the system has to go through to reach the invariant set\n */\ntypedef struct cell{\n\n polytope **safe_mode;\n polytope *polytope_description;\n\n}cell;\n\n/**\n * @brief \"Constructor\" Dynamically allocates the space a cell needs\n * @param k cell.polytope.H.size1 == G.size\n * @param n cell.polytope.HH.size2\n * @return\n */\nstruct cell *cell_alloc(size_t k,\n size_t n,\n int time_horizon);\n\n/**\n * @brief \"Destructor\" Deallocates the dynamically allocated memory of the cell\n * @param cell\n */\nvoid cell_free(cell *cell);\n\n\n/**\n * Convex region of several (cells_count) polytopes (array of polytopes**)\n * hull_over_polytopes is the convex hull of polytopes in that abstract state\n * hull.A = NULL if only one polytope exists in that region\n */\ntypedef struct abstract_state{\n\n polytope *convex_hull;\n\n int cells_count;\n cell **cells;\n\n int transitions_in_count;\n struct abstract_state** transitions_in;\n int transitions_out_count;\n struct abstract_state** transitions_out;\n\n int distance_invariant_set;\n struct abstract_state * next_state;\n cell *invariant_set;\n\n\n}abstract_state;\n\n/**\n * @brief \"Constructor\" Dynamically allocates the space a region of polytope needs\n *\n * Allocates memory space according to the cells_count and their respective sizes\n *\n * @param k Array with the number of rows of each polytope dim([cells_count])\n * @param k_hull number of rows of convex hull polytope of the region\n * @param n system_dynamics size (e.g. s_dyn.A.size1)\n * @param cells_count\n * @return\n */\nstruct abstract_state *abstract_state_alloc(size_t *k,\n size_t k_hull,\n size_t n,\n int transitions_in_count,\n int transitions_out_count,\n int cells_count,\n int time_horizon);\n\n/**\n * @brief \"Destructor\" Deallocates the dynamically allocated memory of the region of polytopes\n * @param abstract_state\n */\nvoid abstract_state_free(abstract_state * abstract_state);\n\n/**\n * @brief Converts two C arrays to a polytope consistent of a left side matrix (i.e. H) and right side vector (i.e. G)\n * @param polytope empty polytope with allocated memory\n * @param k number of rows of polytope (H.size1 or G.size)\n * @param n dimension of polytope = system_dynamics size (e.g. s_dyn.A.size1)\n * @param left_side C array to be converted to left side matrix\n * @param right_side C array to be converted to right side vector\n * @param name name of polytope, will be displayed to user terminal to inform about successfull initialization\n */\nvoid polytope_from_arrays(polytope *polytope,\n double *left_side,\n double *right_side,\n double *cheby,\n char*name);\n\n/**\n * @brief Converts a polytope in gsl form to cdd constraint form\n * @param original\n * @param err\n * @return\n */\ndd_PolyhedraPtr polytope_to_cdd(polytope *original,\n dd_ErrorType *err);\n\n/**\n * @brief Converts a polytope in cdd constraint form to gsl form\n * @param original\n * @return\n */\npolytope* cdd_to_polytope(dd_PolyhedraPtr *original);\n\n/**\n * @brief Generate a polytope representing a scaled unit cube\n * @param scale\n * @param dimensions\n * @return gsl polytope\n */\npolytope * polytope_scaled_unit_cube(double scale,\n int dimensions);\n\n/**\n * @brief Checks whether a state is in a certain polytope\n * @param polytope\n * @param x state to be checked\n * @return 0 if state is not in polytope or 1 if it is\n */\nbool polytope_check_state(polytope *polytope, gsl_vector *x);\n\n/**\n * @brief Check whether P1 \\ subset P2\n * @param P1\n * @param P2\n * @return\n */\nbool polytope_is_subset(polytope *P1,\n polytope *P2);\n\n/**\n * @brief Unite inequalities of P1 and P2 in new polytope and remove redundancies\n * @param P1\n * @param P2\n * @return\n */\npolytope * polytope_unite_inequalities(polytope *P1,\n polytope *P2);\n\n\n/**\n * @brief Project gsl polytope of n+ dimensions to the first n dimensions\n * @param original\n * @param n\n * @return gsl polytope\n */\npolytope* polytope_projection(polytope * original,\n size_t n);\n/**\n * @brief Multiplication of a polytope with a matrix\n * @param original\n * @param scale\n * @return gsl polytope\n */\npolytope * polytope_linear_transform(polytope *original,\n gsl_matrix *scale);\n\n/**\n * @brief Remove redundancies from gsl polytope inequalities\n * @param original\n * @return\n */\npolytope * polytope_minimize(polytope *original);\n\n/**\n * @brief Compute Minkowski sum of two polytopes\n * @param P1\n * @param P2\n * @return\n */\npolytope * polytope_minkowski(polytope *P1,\n polytope *P2);\n\n/**\n * @brief Compute Pontryagin difference of two polytopes C=A-B s.t.:\n * A-B = {c \\in A-B| c+b \\in A, \\forall b \\in B}\n * @param P1\n * @param P2\n * @return\n */\npolytope * polytope_pontryagin(polytope* P1,\n polytope* P2);\n\n/**\n * @brief Set up constraints in quadratic problem for GUROBI\n * @param constraints\n * @param model\n * @param N\n * @return\n */\nint polytope_to_constraints_gurobi(polytope *constraints,\n GRBmodel *model,\n size_t N);\n\n/**\n * @brief Generate a polytope representing a scaled unit cube\n * @param scale\n * @param dimensions\n * @return cdd polytope\n */\ndd_PolyhedraPtr cdd_scaled_unit_cube(double scale,\n int dimensions);\n\n\n/**\n * @brief Project cdd polytope of n+ dimensions to the first n dimensions\n * @param original\n * @param n\n * @return cdd polytope\n */\nvoid cdd_projection(dd_PolyhedraPtr *original,\n dd_PolyhedraPtr *new,\n size_t n,\n dd_ErrorType *err);\n\n/**\n * @brief Remove redundancies from cdd polytope inequalities\n * @param original\n * @return cdd polytope\n */\ndd_PolyhedraPtr cdd_minimize(dd_PolyhedraPtr *original,\n dd_ErrorType *err);\n\n\n#endif //CIMPLE_POLYTOPE_LIBRARY_CIMPLE_H\n", "meta": {"hexsha": "c9c3218f7fb77d93ba149cc46b1b00ea9576db6b", "size": 7547, "ext": "h", "lang": "C", "max_stars_repo_path": "Interface/Cimple/cimple_polytope_library.h", "max_stars_repo_name": "shaesaert/TuLiPXML", "max_stars_repo_head_hexsha": "56cf4d58a9d7e17b6f6aebe6de8d5a1231035671", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-05-28T23:44:28.000Z", "max_stars_repo_stars_event_max_datetime": "2021-05-28T23:44:28.000Z", "max_issues_repo_path": "Interface/Cimple/cimple_polytope_library.h", "max_issues_repo_name": "shaesaert/TuLiPXML", "max_issues_repo_head_hexsha": "56cf4d58a9d7e17b6f6aebe6de8d5a1231035671", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2017-10-03T18:54:08.000Z", "max_issues_repo_issues_event_max_datetime": "2018-08-21T09:50:09.000Z", "max_forks_repo_path": "Interface/Cimple/cimple_polytope_library.h", "max_forks_repo_name": "shaesaert/TuLiPXML", "max_forks_repo_head_hexsha": "56cf4d58a9d7e17b6f6aebe6de8d5a1231035671", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2018-10-06T12:58:52.000Z", "max_forks_repo_forks_event_max_datetime": "2018-10-06T12:58:52.000Z", "avg_line_length": 27.3442028986, "max_line_length": 125, "alphanum_fraction": 0.6478070757, "num_tokens": 1891, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8459424295406088, "lm_q2_score": 0.6113819732941511, "lm_q1q2_score": 0.5171939518657859}} {"text": "#include \n#include \n#include \n#include \n#include \n\n#ifdef SPECTRIM\n#include \"FBSpectrim.h\"\n#else\n#include \"fbus.h\"\n#endif\n\ntypedef struct _Box {\n double x;\n double y;\n double fwhm;\n double cenx;\n double ceny;\n double counts;\n double background;\n double noise;\n double sigmaxythresh;\n double sigmaxy;\n double sigmafwhmthresh;\n double sigmafwhm;\n int r;\n} Box;\n\ntypedef struct _Back {\n double x;\n double y;\n double background;\n double sigma;\n int r;\n int width;\n} Back;\n\nBox box[4];\nBack back;\nlong nelements, naxes[2], fpixel;\nint boxsize = 13;\n\ndouble stardist(int i, int j) {\n return( sqrt( (box[i].cenx-box[j].cenx)*(box[i].cenx-box[j].cenx) +\n\t\t(box[i].ceny-box[j].ceny)*(box[i].ceny-box[j].ceny) ) );\n}\n\ndouble seeing(double var, double d, double r) {\n double lambda;\n double b, K, seeing;\n\n lambda = 0.65e-6;\n b = r/d;\n\n /* pixel scale of 0.78 \"/pixel, convert to rad */\n var = var*pow(0.78/206265.0,2);\n\n K = 0.364*(1.0 - 0.532*pow(b, -1/3) - 0.024*pow(b, -7/3));\n\n seeing = 206265.0*0.98*pow(d/lambda, 0.2)*pow(var/K, 0.6);\n\n return seeing;\n}\n\ndouble old_seeing(double var, double d, double r) {\n double lambda;\n double r0;\n\n lambda = 0.55e-6;\n\n /* pixel scale of 0.78 \"/pixel, convert to rad */\n var = var*pow(0.78/206265.0,2);\n\n r0 = pow(2.0*(lambda*lambda)*( \n\t\t\t\t( 0.1790*pow(d, (-1.0/3.0)) - \n\t\t\t\t 0.0968*pow(r, (-1.0/3.0)) )/var \n\t\t\t\t), 0.6);\n\n return 206265.0*0.98*lambda/r0;\n}\n\nint background(char *image) {\n\n int i, j, backpix;\n int low_y, up_y, low_x, up_x;\n double dist, sum, sumsq;\n\n backpix = 0;\n sum = 0.0;\n sumsq = 0.0;\n\n low_y = back.y - back.r - back.width;\n up_y = back.y + back.r + back.width;\n low_x = back.x - back.r - back.width;\n up_x = back.x + back.r + back.width;\n if (low_y < 0) {\n low_y = 0;\n }\n if (up_y >= 480) {\n up_y = 479;\n }\n if (low_x < 0) {\n low_x = 0;\n }\n if (up_x >= 640) {\n up_x = 639;\n }\n\n for (i=low_y; i= back.r && dist <= back.r+back.width) {\n\tsum += image[i*naxes[0]+j];\n\tbackpix++;\n }\n }\n }\n\n back.background = sum/backpix;\n\n for (i=low_y; i= back.r && dist <= back.r+back.width) {\n\tsumsq += (image[i*naxes[0]+j]-back.background)*\n\t (image[i*naxes[0]+j]-back.background);\n }\n }\n }\n\n back.sigma = sqrt(sumsq/backpix);\n\n return 1;\n\n}\n\nint centroid(char *image, int num) {\n\n int i, j;\n double sum = 0.0;\n double sumx = 0.0;\n double sumxx = 0.0;\n double sumy = 0.0;\n double sumyy = 0.0;\n double val = 0.0;\n double rmom;\n double dist;\n int low_y, up_y, low_x, up_x;\n int sourcepix = 0;\n\n low_y = box[num].y - box[num].r;\n up_y = box[num].y + box[num].r;\n low_x = box[num].x - box[num].r;\n up_x = box[num].x + box[num].r;\n if (low_y < 0) {\n low_y = 0;\n }\n if (up_y >= 480) {\n up_y = 479;\n }\n if (low_x < 0) {\n low_x = 0;\n }\n if (up_x >= 640) {\n up_x = 639;\n }\n\n for (i=low_y; i\n#include \n//#include \n#include \n#include \n#include \"specfunc.h\"\n\n/*\n * to compile as a library (that can be used by specfunc.py):\n *\n * cc -fPIC -c -O2 specfunc.c -o specfunc.o\n * cc --shared specfunc.o -o libspecfunc.so \n *\n * if the gamma-function stuff an dthe parabolic cylinder function is commented\n * in, you need\n *\n * cc --shared specfunc.o -o libspecfunc.so -lgslcblas -lgsl\n *\n * instead\n *\n * hyp2f1 and hyp1f1 seem to work well, the parabolic cylinder functions pcfd \n * are problematic for anything but small arguments\n *\n * felix, june 2014\n */\n\n#define PREC_WARN_LIMIT 1e99 // warn if individual terms in the series are larger than this\n// XXX 4. 12. 14: set to high value because contrary to what I thought I had \n// understood, there seem to be many perfectly fine cases where individual\n// terms in the sum are higher than 10^15\n\n\n// hypergeometric function for |z| < 1\ndouble complex hyp2f1(const double complex a, const double complex b,\n const double complex c, const double complex z, sf_prms_and_info_t* p)\n{\n double frac = p->tol;\n double complex n = 0;\n double complex summand = a*b/c * z;\n double complex sum = 1. + summand;\n\n p->prec_warning = 0;\n for (n = 2; (creal(n) < p->max_iter) && (frac >= p->tol); n++)\n {\n summand *= (a+n-1)*(b+n-1)/(c+n-1) * z/n;\n p->prec_warning = p->prec_warning | (creal(summand) > PREC_WARN_LIMIT) \n | (cimag(summand) > PREC_WARN_LIMIT);\n sum += summand;\n frac = fabs(creal(summand/sum)) + fabs(cimag((summand/sum)));\n }\n p->iters_needed = (int)creal(n);\n p->tol_achieved = frac;\n return sum;\n}\n\n// confluent hypergeometric function\ndouble complex hyp1f1(const double complex a, const double complex b, \n const double complex z, sf_prms_and_info_t* p)\n{\n double frac = p->tol;\n double complex n = 0;\n double complex summand = a/b * z;\n double complex sum = 1. + summand;\n p->prec_warning = 0;\n for (n = 2; (creal(n) < p->max_iter) && (frac >= p->tol) ; n++)\n {\n summand = summand/(b+n-1) * (a+n-1) * (z/n);\n p->prec_warning = p->prec_warning | (creal(summand) > PREC_WARN_LIMIT) \n | (cimag(summand) > PREC_WARN_LIMIT);\n sum += summand;\n frac = fabs(creal(summand/sum)) + fabs(cimag((summand/sum)));\n }\n p->iters_needed = (int)creal(n);\n p->tol_achieved = frac;\n return sum;\n}\n\nvoid hyp1f1_a_arr(const double complex* a, const double complex b, \n const double complex z, double complex* out,\n size_t n_arr, sf_prms_and_info_t* p)\n{\n double complex f = 0.;\n double frac = 0.;\n double maxfrac = p->tol;\n double complex n = 0;\n double complex* summand = \n (double complex*)malloc(sizeof(double complex) * n_arr);\n int i = 0;\n \n for (i = 0; i < n_arr; i++)\n {\n summand[i] = a[i]/b * z;\n out[i] = 1. + summand[i];\n }\n\n p->prec_warning = 0;\n for (n = 2; (creal(n) < p->max_iter) && (maxfrac >= p->tol) ; n++)\n {\n maxfrac = 0;\n f = 1./(b+n-1) * z / n; // same for all a\n for (i = 0; i < n_arr; i++)\n {\n summand[i] *= f * (a[i]+n-1);\n p->prec_warning = p->prec_warning | (creal(summand[i]) > PREC_WARN_LIMIT) \n | (cimag(summand[i]) > PREC_WARN_LIMIT);\n out[i] += summand[i];\n frac = fabs(creal(summand[i]/out[i])) \n + fabs(cimag((summand[i]/out[i])));\n maxfrac = frac > maxfrac ? frac : maxfrac; \n }\n }\n p->iters_needed = (int)creal(n);\n p->tol_achieved = maxfrac;\n free(summand); \n}\n\nvoid hyp1f1_b_arr(const double complex a, const double complex* b, \n const double complex z, double complex* out,\n size_t n_arr, sf_prms_and_info_t* p)\n{\n double complex f = 0.;\n double frac = 0.;\n double maxfrac = p->tol;\n double complex n = 0;\n double complex* summand = \n (double complex*)malloc(sizeof(double complex) * n_arr);\n int i = 0;\n \n for (i = 0; i < n_arr; i++)\n {\n summand[i] = a/b[i] * z;\n out[i] = 1. + summand[i];\n }\n\n p->prec_warning = 0;\n for (n = 2; (creal(n) < p->max_iter) && (maxfrac >= p->tol) ; n++)\n {\n maxfrac = 0;\n f = (a+n-1) * z / n; // same for all b\n for (i = 0; i < n_arr; i++)\n {\n summand[i] *= f / (b[i]+n-1);\n p->prec_warning = p->prec_warning | (creal(summand[i]) > PREC_WARN_LIMIT) \n | (cimag(summand[i]) > PREC_WARN_LIMIT);\n out[i] += summand[i];\n frac = fabs(creal(summand[i]/out[i])) \n + fabs(cimag((summand[i]/out[i])));\n maxfrac = frac > maxfrac ? frac : maxfrac; \n }\n }\n p->iters_needed = (int)creal(n);\n p->tol_achieved = maxfrac;\n free(summand); \n}\n\nvoid hyp1f1_z_arr(const double complex a, const double complex b, \n const double complex* z, double complex* out,\n size_t n_arr, sf_prms_and_info_t* p)\n{\n double complex f = 0.;\n double frac = 0.;\n double maxfrac = p->tol;\n double complex n = 0;\n double complex* summand = \n (double complex*)malloc(sizeof(double complex) * n_arr);\n int i = 0;\n \n for (i = 0; i < n_arr; i++)\n {\n summand[i] = a/b * z[i];\n out[i] = 1. + summand[i];\n }\n\n p->prec_warning = 0;\n for (n = 2; (creal(n) < p->max_iter) && (maxfrac >= p->tol) ; n++)\n {\n maxfrac = 0;\n f = (a+n-1)/(b+n-1) / n; // same for all z\n for (i = 0; i < n_arr; i++)\n {\n summand[i] *= f * z[i];\n p->prec_warning = p->prec_warning | (creal(summand[i]) > PREC_WARN_LIMIT) \n | (cimag(summand[i]) > PREC_WARN_LIMIT);\n out[i] += summand[i];\n frac = fabs(creal(summand[i]/out[i])) \n + fabs(cimag((summand[i]/out[i])));\n maxfrac = frac > maxfrac ? frac : maxfrac; \n }\n }\n p->iters_needed = (int)creal(n);\n p->tol_achieved = maxfrac;\n free(summand); \n}\n\nvoid hyp1f1_all_arr(const double complex* a, const double complex* b, \n const double complex* z, double complex* out,\n size_t n_arr, sf_prms_and_info_t* p)\n{\n int i = 0;\n for (i = 0; i < n_arr; i++)\n out[i] = hyp1f1(a[i], b[i], z[i], p);\n}\n\n/*\ndouble complex cgamma(const double complex z)\n{\n gsl_sf_result lnabs = {0, 0};\n gsl_sf_result arg = {0, 0};\n gsl_sf_lngamma_complex_e(creal(z), cimag(z), &lnabs, &arg);\n return cexp(lnabs.val+1j*arg.val);\n}\n\n// parabolic cylinder function -- this is only ok for small parameters\ndouble complex pcfd(const double complex nu, const double complex z,\n sf_prms_and_info_t* p)\n{\n return cpow(2, nu/2)*cexp(-z*z/4) * csqrt(M_PI) * \n (1./cgamma((1-nu)/2) * hyp1f1(-nu/2, 1./2, z*z/2, p)\n - csqrt(2.)*z/cgamma(-nu/2) \n * hyp1f1((1-nu)/2, 3./2, z*z/2, p)); \n}\n\nvoid pcfd_nu_arr(const double complex* nu, const double complex z, \n double complex* out, size_t n_arr, sf_prms_and_info_t* p) \n{\n int i = 0;\n for (i = 0; i < n_arr; i++)\n {\n out[i] = pcfd(nu[i], z, p);\n }\n}\n\nvoid pcfd_z_arr(const double complex nu, const double complex* z, \n double complex* out, size_t n_arr, sf_prms_and_info_t* p) \n{\n int i = 0;\n for (i = 0; i < n_arr; i++)\n {\n out[i] = pcfd(nu, z[i], p);\n }\n}\n*/\n\nvoid hyp2f1_a_arr(const double complex* a, const double complex b, \n const double complex c, const double complex z, double complex* out,\n size_t n_arr, sf_prms_and_info_t* p)\n{\n double complex f = 0.;\n double frac = 0.;\n double maxfrac = p->tol;\n double complex n = 0;\n double complex* summand = \n (double complex*)malloc(sizeof(double complex) * n_arr);\n int i = 0;\n \n for (i = 0; i < n_arr; i++)\n {\n summand[i] = a[i]*b/c * z;\n out[i] = 1. + summand[i];\n }\n\n p->prec_warning = 0;\n for (n = 2; (creal(n) < p->max_iter) && (maxfrac >= p->tol) ; n++)\n {\n maxfrac = 0;\n f = (b+n-1)/(c+n-1) * z / n; // same for all a\n for (i = 0; i < n_arr; i++)\n {\n summand[i] *= f * (a[i]+n-1);\n p->prec_warning = p->prec_warning | (creal(summand[i]) > PREC_WARN_LIMIT) \n | (cimag(summand[i]) > PREC_WARN_LIMIT);\n out[i] += summand[i];\n frac = fabs(creal(summand[i]/out[i])) \n + fabs(cimag((summand[i]/out[i])));\n maxfrac = frac > maxfrac ? frac : maxfrac; \n }\n }\n p->iters_needed = (int)creal(n);\n p->tol_achieved = maxfrac;\n free(summand); \n}\n\nvoid hyp2f1_b_arr(const double complex a, const double complex* b, \n const double complex c, const double complex z, double complex* out,\n size_t n_arr, sf_prms_and_info_t* p)\n{\n hyp2f1_a_arr(b, a, c, z, out, n_arr, p);\n}\n\nvoid hyp2f1_c_arr(const double complex a, const double complex b, \n const double complex* c, const double complex z, double complex* out,\n size_t n_arr, sf_prms_and_info_t* p)\n{\n double complex f = 0.;\n double frac = 0.;\n double maxfrac = p->tol;\n double complex n = 0;\n double complex* summand = \n (double complex*)malloc(sizeof(double complex) * n_arr);\n int i = 0;\n \n for (i = 0; i < n_arr; i++)\n {\n summand[i] = a*b/c[i] * z;\n out[i] = 1. + summand[i];\n }\n\n p->prec_warning = 0;\n for (n = 2; (creal(n) < p->max_iter) && (maxfrac >= p->tol) ; n++)\n {\n maxfrac = 0;\n f = (a+n-1)*(b+n-1) * z / n; // same for all a\n for (i = 0; i < n_arr; i++)\n {\n summand[i] *= f / (c[i]+n-1);\n p->prec_warning = p->prec_warning | (creal(summand[i]) > PREC_WARN_LIMIT) \n | (cimag(summand[i]) > PREC_WARN_LIMIT);\n out[i] += summand[i];\n frac = fabs(creal(summand[i]/out[i])) \n + fabs(cimag((summand[i]/out[i])));\n maxfrac = frac > maxfrac ? frac : maxfrac; \n }\n }\n p->iters_needed = (int)creal(n);\n p->tol_achieved = maxfrac;\n free(summand); \n}\n\n\n// hyp2d1 for an array of z values\nvoid hyp2f1_z_arr(const double complex a, const double complex b, \n const double complex c, const double complex* z, double complex* out,\n size_t n_arr, sf_prms_and_info_t* p)\n{\n double complex f = 0.;\n double frac = 0.;\n double maxfrac = p->tol;\n double complex n = 0;\n double complex* summand = \n (double complex*)malloc(sizeof(double complex) * n_arr);\n int i = 0;\n \n for (i = 0; i < n_arr; i++)\n {\n summand[i] = a*b/c * z[i];\n out[i] = 1. + summand[i];\n }\n\n p->prec_warning = 0;\n for (n = 2; (creal(n) < p->max_iter) && (maxfrac >= p->tol) ; n++)\n {\n maxfrac = 0;\n f = (a+n-1)*(b+n-1)/(c+n-1) / n; // same for all zs\n for (i = 0; i < n_arr; i++)\n {\n summand[i] *= f * z[i];\n p->prec_warning = p->prec_warning | (creal(summand[i]) > PREC_WARN_LIMIT) \n | (cimag(summand[i]) > PREC_WARN_LIMIT);\n out[i] += summand[i];\n frac = fabs(creal(summand[i]/out[i])) \n + fabs(cimag((summand[i]/out[i])));\n maxfrac = frac > maxfrac ? frac : maxfrac; \n }\n }\n p->iters_needed = (int)creal(n);\n p->tol_achieved = maxfrac;\n free(summand); \n}\n\nvoid hyp2f1_all_arr(const double complex* a, const double complex* b, \n const double complex* c, const double complex* z, double complex* out,\n size_t n_arr, sf_prms_and_info_t* p)\n{\n int i = 0;\n for (i = 0; i < n_arr; i++)\n out[i] = hyp2f1(a[i], b[i], c[i], z[i], p);\n}\n\n", "meta": {"hexsha": "10bdcfe23b6da02e88fdf2bc01a2645f1bf591cb", "size": 12030, "ext": "c", "lang": "C", "max_stars_repo_path": "analytics/specfunc/specfunc.c", "max_stars_repo_name": "ModelDBRepository/228604", "max_stars_repo_head_hexsha": "8f641f73bcac2700b476663fe656fcad7d63470d", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "analytics/specfunc/specfunc.c", "max_issues_repo_name": "ModelDBRepository/228604", "max_issues_repo_head_hexsha": "8f641f73bcac2700b476663fe656fcad7d63470d", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "analytics/specfunc/specfunc.c", "max_forks_repo_name": "ModelDBRepository/228604", "max_forks_repo_head_hexsha": "8f641f73bcac2700b476663fe656fcad7d63470d", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.7414248021, "max_line_length": 91, "alphanum_fraction": 0.5295095594, "num_tokens": 3738, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.798186768138228, "lm_q2_score": 0.6477982179521103, "lm_q1q2_score": 0.5170639659928984}} {"text": "/*\nPerforming approximate Bayesian computation sequential Monte Carlo (Toni et al.\n2009) for linear regression.\n\nSynthetic data is generated by `ground_truth_and_analysis.ipynb`.\n\nThis script writes particles.csv, where each row corresponds to a particle and\neach column corresponds to a round of SMC.\n\nDefining #DEBUG_MODE will silence all writing to stdout. One may then add\nprintf statements in the code, and perhaps write the output to file as:\n`./run.sh > output.txt`\n\nParameter ordering convention:\n0 - gradient\n1 - intercept\n2 - standard deviation\n\nAuthor: Juvid Aryaman\n*/\n\n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n\n\n#define N_DATA 30\n#define N_PARAMETERS 3\n\n#define N_PARTICLES 20000\n\n#define RND gsl_rng_uniform(r)\n#define SEED 1\n\n#define X_DATA_FILENAME \"x.csv\"\n#define Y_DATA_FILENAME \"y.csv\"\n\n// Global variables\n/*Define the distance threshold for every round of SMC*/\ndouble distance_threshold_schedule[] = {7.0, 6.375, 5.75, 5.125, 4.5, 3.875,\n\t3.25, 2.625, 2.0};\nint N_ROUNDS_SMC = (int)(sizeof(distance_threshold_schedule) / sizeof(double));\n\n\n#include \"smc.h\"\n#include \"lin_reg.h\"\n\n//#define DEBUG_MODE\n\nint main(int argc, char *argv[]) {\n\n#ifndef DEBUG_MODE\n\tprintf(\"Threshold schedule:\\n\");\n\tprint_double_array(distance_threshold_schedule, N_ROUNDS_SMC);\n\tprintf(\"\\n\");\n#endif\n\n/* set up GSL RNG */\ngsl_rng *r = gsl_rng_alloc(gsl_rng_mt19937);\n/* end of GSL setup */\n\ngsl_rng_set(r, SEED);\n\n/////////////////////////\n/*Read data*/\n/////////////////////////\n\nFILE *data_pointer_x, *data_pointer_y;\n\ndata_pointer_x = fopen(X_DATA_FILENAME, \"r\");\ndata_pointer_y = fopen(Y_DATA_FILENAME, \"r\");\n\ndouble data_x[N_DATA];\ndouble data_y[N_DATA];\nint i, j, read_error_status_x, read_error_status_y;\nfor (i=0; i < N_DATA; i++){\n\tread_error_status_x = fscanf(data_pointer_x, \"%lf\\n\", &data_x[i]);\n\tread_error_status_y = fscanf(data_pointer_y, \"%lf\\n\", &data_y[i]);\n}\nif (read_error_status_x != 1){printf(\"Error reading X data\\n\"); return 0;}\nif (read_error_status_y != 1){printf(\"Error reading Y data\\n\"); return 0;}\n\n/////////////////////////\n/*Initialise variables*/\n/////////////////////////\n\n/*Fit a linear model to the data, which will be used as summary statistics of\nthe data*/\ndouble gradient_fit_data, intercept_fit_data, sigma_fit_data, cov00, cov01, cov11, sumsq;\nint gsl_fit_return_value;\ngsl_fit_return_value = gsl_fit_linear(data_x, 1, data_y, 1, N_DATA,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t&intercept_fit_data, &gradient_fit_data,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t&cov00, &cov01, &cov11, &sumsq);\nif (gsl_fit_return_value != 0) {printf(\"Fit failed.\\n\"); return -1;}\nsigma_fit_data = sqrt(sumsq/(N_DATA-2));\n\n#ifndef DEBUG_MODE\n\tprintf(\"gradient ML = %.8f\\n\", gradient_fit_data);\n\tprintf(\"intercept ML = %.8f\\n\", intercept_fit_data);\n\tprintf(\"sigma ML = %.8f\\n\", sigma_fit_data);\n#endif\n\n\n\n/*Make a (N_PARAMETERS X N_ROUNDS_SMC X N_PARTICLES) array to store all\nparticles at all rounds of SMC*/\ndouble*** theta_particle;\ntheta_particle = (double***) malloc(N_PARAMETERS * sizeof(double**));\nfor (i = 0; i < N_PARAMETERS; i++){\n\ttheta_particle[i] = (double**) malloc(N_ROUNDS_SMC * sizeof(double*));\n}\nfor (i = 0; i < N_PARAMETERS; i++){\n\tfor (j = 0; j < N_ROUNDS_SMC; j++){\n\t\ttheta_particle[i][j] = (double*) malloc(N_PARTICLES * sizeof(double));\n\t}\n}\n\ndouble *simulated_data = (double*) malloc(N_DATA * sizeof(double));\ndouble *distance = malloc(N_PARTICLES * sizeof(double));\ndouble **weight;\nweight = (double**) malloc(N_ROUNDS_SMC * sizeof(double*));\nfor (i = 0; i < N_ROUNDS_SMC; i++) {\n\tweight[i] = (double*) malloc(N_PARTICLES * sizeof(double));\n}\n\n\ndouble weight_normalizer = 0.0;\n\nint time_smc=0; // an index of each round of SMC\nint param_index_chosen, prior_violated;\nint particle_index;\n/////////////////////////\n/*Perform ABC SMC*/\n/////////////////////////\n\n/*For every round of SMC*/\nfor (time_smc = 0; time_smc < N_ROUNDS_SMC; time_smc++) {\n\t#ifndef DEBUG_MODE\n\t\tprintf(\"Round %d of SMC\\n\", time_smc);\n\t#endif\n\n\t/*Draw or perturb a particle and compute distance*/\n\tfor (particle_index = 0; particle_index < N_PARTICLES; particle_index++) {\n\t\t// reset distance of particle\n\t\tdistance[particle_index] = distance_threshold_schedule[time_smc] + 1.0;\n\n\t\twhile (distance[particle_index] > distance_threshold_schedule[time_smc]) {\n\t\t\tif (time_smc == 0) {\n\t\t\t\t// Sample from the prior\n\t\t\t\tsample_prior(r, theta_particle, particle_index);\n\t\t\t}\n\t\t\telse{\n\t\t\t\t/*Sample from the old weights*/\n\t\t\t\tparam_index_chosen = weighted_choice(r, weight[time_smc-1]);\n\t\t\t\tif ((param_index_chosen < 0)||(param_index_chosen >= N_PARTICLES)) {\n\t\t\t\t\tprintf(\"Error in param_index_chosen\\n\");\n\t\t\t\t\tprintf(\"time_smc = %d\\n\", time_smc);\n\t\t\t\t\treturn -1;\n\t\t\t\t}\n\n\t\t\t\tperturb_particle(r, theta_particle, time_smc, param_index_chosen,\n\t\t\t\t\t\t\t\t\t\t\t\t particle_index);\n\n\t\t\t\t// Check if prior support is 0\n\t\t\t\tprior_violated = check_prior_violated(theta_particle, time_smc,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tparticle_index);\n\t\t\t\tif(prior_violated == 1) continue;\n\t\t\t}\n\n\t\t\tsimulate_dataset(r, theta_particle, data_x, simulated_data, time_smc,\n\t\t\t\t\t\t\t\t\t\t\t particle_index);\n\n\t\t\tdistance[particle_index] = distance_metric_sum_abs_res(simulated_data, data_y);\n\t\t}\n\t}\n\n\t#ifndef DEBUG_MODE\n\t\tprintf(\"Particles sampled.\\n\");\n\t#endif\n\n\n\n\t/*Compute & Normalise weights. For uniform priors, and a uniform perturbation\n\tkernel, all surviving particles are weighted identically as 1/N_PARTICLES.\n\tWhilst seemingly inefficient, I keep this code here for clarity/generality.\n\tThe bottleneck in computation time is the while loop above.*/\n\tif (time_smc==0){ for (i = 0; i < N_PARTICLES; i++) weight[0][i] = 1.0;}\n\telse{\n\t\tweight_normalizer = 0.0;\n\t\tfor (particle_index = 0; particle_index < N_PARTICLES; particle_index++) {\n\t\t\t// kernel_pdf is uniform, so is independent of the parameters\n\t\t\tweight_normalizer += weight[time_smc-1][particle_index]*kernel_pdf();\n\t\t}\n\t\tfor (particle_index = 0; particle_index < N_PARTICLES; particle_index++) {\n\t\t\tweight[time_smc][particle_index] = prior_pdf(theta_particle, time_smc,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t particle_index)/weight_normalizer;\n\t\t}\n\t}\n\tweight_normalizer = 0.0;\n\tfor (i = 0; i < N_PARTICLES; i++)\tweight_normalizer += weight[time_smc][i];\n\tfor (i = 0; i < N_PARTICLES; i++){\n\t\tweight[time_smc][i] = weight[time_smc][i]/weight_normalizer;\n\t}\n\n\n}\n\n#ifndef DEBUG_MODE\n\tprintf(\"Writing particles to file\\n\");\n#endif\n\twrite_particles_to_csv(theta_particle);\n\nchar weight_filename[] = \"weights.csv\";\nwrite_2d_double_array_to_csv(weight, N_ROUNDS_SMC, N_PARTICLES, weight_filename);\n\n#ifndef DEBUG_MODE\n\tprintf(\"Done!\\n\");\n#endif\n\nreturn 0; //return from main\n} //close main\n", "meta": {"hexsha": "710b08b3d975e8bb4988b219b1b13a7b3eadb0f1", "size": 6714, "ext": "c", "lang": "C", "max_stars_repo_path": "Notebooks/ABC_SMC/Linear_regression/smc.c", "max_stars_repo_name": "jaryaman/ML_demos", "max_stars_repo_head_hexsha": "df270b58d35d1248079e4651988ded4074237bfc", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2018-07-28T18:14:12.000Z", "max_stars_repo_stars_event_max_datetime": "2018-07-31T16:51:10.000Z", "max_issues_repo_path": "Notebooks/ABC_SMC/Linear_regression/smc.c", "max_issues_repo_name": "jaryaman/ML_demos", "max_issues_repo_head_hexsha": "df270b58d35d1248079e4651988ded4074237bfc", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3.0, "max_issues_repo_issues_event_min_datetime": "2020-06-21T18:23:19.000Z", "max_issues_repo_issues_event_max_datetime": "2020-09-28T14:21:39.000Z", "max_forks_repo_path": "Notebooks/ABC_SMC/Linear_regression/smc.c", "max_forks_repo_name": "jaryaman/ML_demos", "max_forks_repo_head_hexsha": "df270b58d35d1248079e4651988ded4074237bfc", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2018-07-02T14:25:20.000Z", "max_forks_repo_forks_event_max_datetime": "2018-07-02T14:25:20.000Z", "avg_line_length": 29.4473684211, "max_line_length": 89, "alphanum_fraction": 0.6991361335, "num_tokens": 1849, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7853085909370422, "lm_q2_score": 0.658417500561683, "lm_q1q2_score": 0.5170609196143845}} {"text": "/* min/bracketing.c\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000 Fabrice Rossi\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 2 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.\n */\n\n/* bracketing.c -- find an initial bracketing interval for a function to minimize */\n\n#include \n#include \n#include \n#include \n#include \n\n#include \"min.h\"\n\nint \ngsl_min_find_bracket(gsl_function *f,double *minimum,double * f_minimum,\n\t\t double * x_lower, double * f_lower, \n double * x_upper, double * f_upper,\n\t\t size_t eval_max)\n{\n /* The three following variables must be declared volatile to avoid storage\n in extended precision registers available on some architecture. The code\n relies on the ability to compare double values. As the values will be\n store in regular memory, the extended precision will then be lost and\n values that are different in extended precision might have equal\n representation in double precision. This behavior might break the\n algorithm. \n */\n volatile double f_left = *f_lower;\n volatile double f_right = *f_upper;\n volatile double f_center;\n double x_left = *x_lower;\n double x_right= *x_upper; \n double x_center;\n const double golden = 0.3819660;\t/* golden = (3 - sqrt(5))/2 */\n size_t nb_eval = 0;\n \n \n if (f_right >= f_left) \n {\n x_center = (x_right - x_left) * golden + x_left;\n nb_eval++;\n SAFE_FUNC_CALL (f, x_center, &f_center);\n }\n else\n {\n x_center = x_right ;\n f_center = f_right ;\n x_right = (x_center - x_left) / golden + x_left;\n nb_eval++;\n SAFE_FUNC_CALL (f, x_right, &f_right);\n }\n \n do\n {\n if (f_center < f_left )\n\t{\n\t if (f_center < f_right)\n\t {\n\t *x_lower = x_left;\n\t *x_upper = x_right;\n\t *minimum = x_center;\n\t *f_lower = f_left;\n\t *f_upper = f_right;\n\t *f_minimum = f_center;\n/*\t gsl_ieee_printf_double (&f_left);\n\t printf(\" \");\n\t gsl_ieee_printf_double (&f_center);\n\t printf(\"\\n\");*/\n\t return GSL_SUCCESS;\n\t }\n\t else if (f_center > f_right)\n\t {\n\t x_left = x_center;\n\t f_left = f_center;\n\t x_center = x_right;\n\t f_center = f_right;\n\t x_right = (x_center - x_left) / golden + x_left;\n\t nb_eval++;\n\t SAFE_FUNC_CALL (f, x_right, &f_right);\n\t }\n\t else /* f_center == f_right */\n\t {\n\t x_right = x_center;\n\t f_right = f_center;\n\t x_center = (x_right - x_left) * golden + x_left;\n\t nb_eval++;\n\t SAFE_FUNC_CALL (f, x_center, &f_center);\n\t }\n\t}\n else /* f_center >= f_left */\n\t{\n\t x_right = x_center;\n\t f_right = f_center;\n\t x_center = (x_right - x_left) * golden + x_left;\n\t nb_eval++;\n\t SAFE_FUNC_CALL (f, x_center, &f_center);\n\t}\n }\n while (nb_eval < eval_max \n\t && (x_right - x_left) > GSL_SQRT_DBL_EPSILON * ( (x_right + x_left) * 0.5 ) + GSL_SQRT_DBL_EPSILON);\n *x_lower = x_left;\n *x_upper = x_right;\n *minimum = x_center;\n *f_lower = f_left;\n *f_upper = f_right;\n *f_minimum = f_center;\n return GSL_FAILURE;\n}\n\n", "meta": {"hexsha": "de869d4b94d3a159f2818f2d03fc7d8d474852cc", "size": 3721, "ext": "c", "lang": "C", "max_stars_repo_path": "code/em/treba/gsl-1.0/min/bracketing.c", "max_stars_repo_name": "ICML14MoMCompare/spectral-learn", "max_stars_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-12-18T18:09:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-10T11:31:28.000Z", "max_issues_repo_path": "code/em/treba/gsl-1.0/min/bracketing.c", "max_issues_repo_name": "ICML14MoMCompare/spectral-learn", "max_issues_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "code/em/treba/gsl-1.0/min/bracketing.c", "max_forks_repo_name": "ICML14MoMCompare/spectral-learn", "max_forks_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2015-10-02T01:32:59.000Z", "max_forks_repo_forks_event_max_datetime": "2015-10-02T01:32:59.000Z", "avg_line_length": 29.5317460317, "max_line_length": 102, "alphanum_fraction": 0.6436441817, "num_tokens": 1014, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7461389817407016, "lm_q2_score": 0.6926419831347361, "lm_q1q2_score": 0.5168071840070122}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n\nint\nmain (void)\n{\n int i;\n double xi, yi;\n double x[10], y[10];\n\n printf (\"#m=0,S=2\\n\");\n\n for (i = 0; i < 10; i++)\n {\n x[i] = i + 0.5 * sin (i);\n y[i] = i + cos (i * i);\n printf (\"%g %g\\n\", x[i], y[i]);\n }\n\n printf (\"#m=1,S=0\\n\");\n\n {\n gsl_interp_accel *acc = gsl_interp_accel_alloc ();\n gsl_spline *spline = gsl_spline_alloc (gsl_interp_cspline, 10);\n gsl_spline_init (spline, x, y, 10);\n\n for (xi = x[0]; xi < x[9]; xi += 0.01)\n {\n double yi = gsl_spline_eval (spline, xi, acc);\n printf (\"%g %g\\n\", xi, yi);\n }\n gsl_spline_free (spline);\n gsl_interp_accel_free(acc);\n }\n}\n", "meta": {"hexsha": "39aec03f5f812915b6bceff8ca08e6b4a1c831eb", "size": 779, "ext": "c", "lang": "C", "max_stars_repo_path": "Chimera/3rd_Party/GSL_MSVC/interpolation/demo.c", "max_stars_repo_name": "zzpwahaha/Chimera-Control-Trim", "max_stars_repo_head_hexsha": "df1bbf6bea0b87b8c7c9a99dce213fdc249118f2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-06-14T11:51:37.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-14T11:51:37.000Z", "max_issues_repo_path": "Chimera/3rd_Party/GSL_MSVC/interpolation/demo.c", "max_issues_repo_name": "zzpwahaha/Chimera-Control-Trim", "max_issues_repo_head_hexsha": "df1bbf6bea0b87b8c7c9a99dce213fdc249118f2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Chimera/3rd_Party/GSL_MSVC/interpolation/demo.c", "max_forks_repo_name": "zzpwahaha/Chimera-Control-Trim", "max_forks_repo_head_hexsha": "df1bbf6bea0b87b8c7c9a99dce213fdc249118f2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-01-20T16:22:57.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-14T12:31:02.000Z", "avg_line_length": 19.475, "max_line_length": 67, "alphanum_fraction": 0.5365853659, "num_tokens": 277, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8499711604559846, "lm_q2_score": 0.6076631698328916, "lm_q1q2_score": 0.516496169629225}} {"text": "/* multiroots/fdjac.c\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000 Brian Gough\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 2 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.\n */\n\n#include \n#include \n\nint\ngsl_multiroot_fdjacobian (gsl_multiroot_function * F,\n const gsl_vector * x, const gsl_vector * f,\n double epsrel, gsl_matrix * jacobian)\n{\n const size_t n = x->size;\n const size_t m = f->size;\n const size_t n1 = jacobian->size1;\n const size_t n2 = jacobian->size2;\n\n if (m != n1 || n != n2)\n {\n GSL_ERROR (\"function and jacobian are not conformant\", GSL_EBADLEN);\n }\n\n {\n size_t i,j;\n gsl_vector *x1, *f1;\n\n x1 = gsl_vector_alloc (n);\n\n if (x1 == 0)\n {\n\tGSL_ERROR (\"failed to allocate space for x1 workspace\", GSL_ENOMEM);\n }\n\n f1 = gsl_vector_alloc (m);\n\n if (f1 == 0)\n {\n\tgsl_vector_free (x1);\n\n\tGSL_ERROR (\"failed to allocate space for f1 workspace\", GSL_ENOMEM);\n }\n\n gsl_vector_memcpy (x1, x);\t/* copy x into x1 */\n\n for (j = 0; j < n; j++)\n {\n\tdouble xj = gsl_vector_get (x, j);\n\tdouble dx = epsrel * fabs (xj);\n\n\tif (dx == 0)\n\t {\n\t dx = epsrel;\n\t }\n\n\tgsl_vector_set (x1, j, xj + dx);\n \n {\n int status = GSL_MULTIROOT_FN_EVAL (F, x1, f1);\n\n if (status != GSL_SUCCESS) \n {\n return GSL_EBADFUNC;\n }\n }\n\n\tgsl_vector_set (x1, j, xj);\n\n\tfor (i = 0; i < m; i++)\n\t {\n\t double g1 = gsl_vector_get (f1, i);\n\t double g0 = gsl_vector_get (f, i);\n\t gsl_matrix_set (jacobian, i, j, (g1 - g0) / dx);\n\t }\n }\n\n gsl_vector_free (x1);\n gsl_vector_free (f1);\n }\n \n return GSL_SUCCESS;\n}\n", "meta": {"hexsha": "acb773fe05fdfff3fd6c4865e97c103be2228201", "size": 2346, "ext": "c", "lang": "C", "max_stars_repo_path": "code/em/treba/gsl-1.0/multiroots/fdjac.c", "max_stars_repo_name": "ICML14MoMCompare/spectral-learn", "max_stars_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-12-18T18:09:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-10T11:31:28.000Z", "max_issues_repo_path": "code/em/treba/gsl-1.0/multiroots/fdjac.c", "max_issues_repo_name": "ICML14MoMCompare/spectral-learn", "max_issues_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "code/em/treba/gsl-1.0/multiroots/fdjac.c", "max_forks_repo_name": "ICML14MoMCompare/spectral-learn", "max_forks_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2015-10-02T01:32:59.000Z", "max_forks_repo_forks_event_max_datetime": "2015-10-02T01:32:59.000Z", "avg_line_length": 24.1855670103, "max_line_length": 74, "alphanum_fraction": 0.6065643649, "num_tokens": 683, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7154239957834733, "lm_q2_score": 0.7217432182679956, "lm_q1q2_score": 0.5163524171429129}} {"text": "#include \n#include \n#include \n#include \n\ndouble f1(double x, void *p) {\n (void) (p); /* avoid unused parameter warning */\n return exp(pow(x, 2));\n}\n\ndouble f2(double x, void *p) {\n (void) (p); /* avoid unused parameter warning */\n return fabs(x + pow(x, 3));\n}\n\ndouble f3(double x, void *p) {\n (void) (p); /* avoid unused parameter warning */\n return x <= 0 ? -1 : 1;\n}\n\ndouble (*f[])(double, void *) = {f1, f2, f3};\n\nchar *a[] = {\"pierwsze1.dat\", \"pierwsze2.dat\", \"pierwsze3.dat\"};\n\nint main(void) {\n int i, n = 10000;\n gsl_cheb_series *cs = gsl_cheb_alloc(40);\n gsl_function F;\n FILE *file;\n for (int j = 0; j < 3; j++) {\n file = fopen(a[j], \"w\");\n F.function = f[j];\n F.params = 0;\n gsl_cheb_init(cs, &F, -1.0, 1.0);\n for (i = -n; i < n; i++) {\n double x = i / (double) n;\n double r10 = gsl_cheb_eval_n(cs, 10, x);\n double r40 = gsl_cheb_eval(cs, x);\n fprintf(file, \"%g %g %g %g\\n\",\n x, GSL_FN_EVAL (&F, x), r10, r40);\n }\n fclose(file);\n }\n gsl_cheb_free(cs);\n return EXIT_SUCCESS;\n}\n", "meta": {"hexsha": "bb15481ccccb5625f0c419da41614bd0481e87ff", "size": 1197, "ext": "c", "lang": "C", "max_stars_repo_path": "lab3/pierwsze.c", "max_stars_repo_name": "mistyfiky/agh-mownit", "max_stars_repo_head_hexsha": "d88c21308b863942497c111d044e359ce220d421", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lab3/pierwsze.c", "max_issues_repo_name": "mistyfiky/agh-mownit", "max_issues_repo_head_hexsha": "d88c21308b863942497c111d044e359ce220d421", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "lab3/pierwsze.c", "max_forks_repo_name": "mistyfiky/agh-mownit", "max_forks_repo_head_hexsha": "d88c21308b863942497c111d044e359ce220d421", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 25.4680851064, "max_line_length": 64, "alphanum_fraction": 0.5204678363, "num_tokens": 397, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7879311956428947, "lm_q2_score": 0.6548947290421275, "lm_q1q2_score": 0.5160119868743931}} {"text": "/* specfunc/bessel_k.c\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n/* Author: G. Jungman */\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"error.h\"\n#include \"check.h\"\n\n#include \"bessel.h\"\n\n/*-*-*-*-*-*-*-*-*-*-*-* Private Section *-*-*-*-*-*-*-*-*-*-*-*/\n\n/* [Abramowitz+Stegun, 10.2.4 + 10.2.6]\n * with lmax=15, precision ~ 15D for x < 3\n *\n * assumes l >= 1\n */\nstatic int bessel_kl_scaled_small_x(int l, const double x, gsl_sf_result * result)\n{\n gsl_sf_result num_fact;\n double den = gsl_sf_pow_int(x, l+1);\n int stat_df = gsl_sf_doublefact_e((unsigned int) (2*l-1), &num_fact);\n\n if(stat_df != GSL_SUCCESS || den == 0.0) {\n OVERFLOW_ERROR(result);\n }\n else {\n const int lmax = 50;\n gsl_sf_result ipos_term;\n double ineg_term;\n double sgn = (GSL_IS_ODD(l) ? -1.0 : 1.0);\n double ex = exp(x);\n double t = 0.5*x*x;\n double sum = 1.0;\n double t_coeff = 1.0;\n double t_power = 1.0;\n double delta;\n int stat_il;\n int i;\n\n for(i=1; ival = -sgn * 0.5*M_PI * (ex*ipos_term.val - ineg_term);\n result->val *= ex;\n result->err = 2.0 * GSL_DBL_EPSILON * fabs(result->val);\n return stat_il;\n }\n}\n\n\n/*-*-*-*-*-*-*-*-*-*-*-* Functions with Error Codes *-*-*-*-*-*-*-*-*-*-*-*/\n\nint gsl_sf_bessel_k0_scaled_e(const double x, gsl_sf_result * result)\n{\n /* CHECK_POINTER(result) */\n\n if(x <= 0.0) {\n DOMAIN_ERROR(result);\n }\n else {\n result->val = M_PI/(2.0*x);\n result->err = 2.0 * GSL_DBL_EPSILON * fabs(result->val);\n CHECK_UNDERFLOW(result);\n return GSL_SUCCESS;\n }\n}\n\n\nint gsl_sf_bessel_k1_scaled_e(const double x, gsl_sf_result * result)\n{\n /* CHECK_POINTER(result) */\n\n if(x <= 0.0) {\n DOMAIN_ERROR(result);\n }\n else if(x < (M_SQRTPI+1.0)/(M_SQRT2*GSL_SQRT_DBL_MAX)) {\n OVERFLOW_ERROR(result);\n }\n else {\n result->val = M_PI/(2.0*x) * (1.0 + 1.0/x);\n result->err = 2.0 * GSL_DBL_EPSILON * fabs(result->val);\n CHECK_UNDERFLOW(result);\n return GSL_SUCCESS;\n }\n}\n\n\nint gsl_sf_bessel_k2_scaled_e(const double x, gsl_sf_result * result)\n{\n /* CHECK_POINTER(result) */\n\n if(x <= 0.0) {\n DOMAIN_ERROR(result);\n }\n else if(x < 2.0/GSL_ROOT3_DBL_MAX) {\n OVERFLOW_ERROR(result);\n }\n else {\n result->val = M_PI/(2.0*x) * (1.0 + 3.0/x * (1.0 + 1.0/x));\n result->err = 2.0 * GSL_DBL_EPSILON * fabs(result->val);\n CHECK_UNDERFLOW(result);\n return GSL_SUCCESS;\n }\n}\n\n\nint gsl_sf_bessel_kl_scaled_e(int l, const double x, gsl_sf_result * result)\n{\n if(l < 0 || x <= 0.0) {\n DOMAIN_ERROR(result);\n }\n else if(l == 0) {\n return gsl_sf_bessel_k0_scaled_e(x, result);\n }\n else if(l == 1) {\n return gsl_sf_bessel_k1_scaled_e(x, result);\n }\n else if(l == 2) {\n return gsl_sf_bessel_k2_scaled_e(x, result);\n }\n else if(x < 3.0) {\n return bessel_kl_scaled_small_x(l, x, result);\n }\n else if(GSL_ROOT3_DBL_EPSILON * x > (l*l + l + 1)) {\n int status = gsl_sf_bessel_Knu_scaled_asympx_e(l + 0.5, x, result);\n double pre = sqrt((0.5*M_PI)/x);\n result->val *= pre;\n result->err *= pre;\n return status;\n }\n else if(GSL_MIN(0.29/(l*l+1.0), 0.5/(l*l+1.0+x*x)) < GSL_ROOT3_DBL_EPSILON) {\n int status = gsl_sf_bessel_Knu_scaled_asymp_unif_e(l + 0.5, x, result);\n double pre = sqrt((0.5*M_PI)/x);\n result->val *= pre;\n result->err *= pre;\n return status;\n }\n else {\n /* recurse upward */\n gsl_sf_result r_bk;\n gsl_sf_result r_bkm;\n int stat_1 = gsl_sf_bessel_k1_scaled_e(x, &r_bk);\n int stat_0 = gsl_sf_bessel_k0_scaled_e(x, &r_bkm);\n double bkp;\n double bk = r_bk.val;\n double bkm = r_bkm.val;\n int j;\n for(j=1; jval = bk;\n result->err = fabs(bk) * (fabs(r_bk.err/r_bk.val) + fabs(r_bkm.err/r_bkm.val));\n result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);\n\n return GSL_ERROR_SELECT_2(stat_1, stat_0);\n }\n}\n\nint \ngsl_sf_bessel_kl_scaled_array(const int lmax, const double x, double * result_array)\n{\n if(lmax < 0 || x <= 0.0) {\n GSL_ERROR(\"domain error\", GSL_EDOM);\n } else if (lmax == 0) {\n gsl_sf_result result;\n int stat = gsl_sf_bessel_k0_scaled_e(x, &result);\n result_array[0] = result.val;\n return stat;\n } else {\n int ell;\n double kellp1, kell, kellm1;\n gsl_sf_result r_kell;\n gsl_sf_result r_kellm1;\n gsl_sf_bessel_k1_scaled_e(x, &r_kell);\n gsl_sf_bessel_k0_scaled_e(x, &r_kellm1);\n kell = r_kell.val;\n kellm1 = r_kellm1.val;\n result_array[0] = kellm1;\n result_array[1] = kell;\n for(ell = 1; ell < lmax; ell++) {\n kellp1 = (2*ell+1)/x * kell + kellm1;\n result_array[ell+1] = kellp1;\n kellm1 = kell;\n kell = kellp1;\n }\n return GSL_SUCCESS;\n }\n}\n\n\n/*-*-*-*-*-*-*-*-*-* Functions w/ Natural Prototypes *-*-*-*-*-*-*-*-*-*-*/\n\n#include \"eval.h\"\n\ndouble gsl_sf_bessel_k0_scaled(const double x)\n{\n EVAL_RESULT(gsl_sf_bessel_k0_scaled_e(x, &result));\n}\n\ndouble gsl_sf_bessel_k1_scaled(const double x)\n{\n EVAL_RESULT(gsl_sf_bessel_k1_scaled_e(x, &result));\n}\n\ndouble gsl_sf_bessel_k2_scaled(const double x)\n{\n EVAL_RESULT(gsl_sf_bessel_k2_scaled_e(x, &result));\n}\n\ndouble gsl_sf_bessel_kl_scaled(const int l, const double x)\n{\n EVAL_RESULT(gsl_sf_bessel_kl_scaled_e(l, x, &result));\n}\n\n\n", "meta": {"hexsha": "d206c0353655e8be1206df9663e9a932d80b34e9", "size": 6443, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.6/specfunc/bessel_k.c", "max_stars_repo_name": "ielomariala/Hex-Game", "max_stars_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-12-18T18:09:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-10T11:31:28.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/specfunc/bessel_k.c", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-12-16T17:41:24.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-22T00:00:16.000Z", "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/specfunc/bessel_k.c", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 14.0, "max_forks_repo_forks_event_min_datetime": "2015-07-21T04:47:52.000Z", "max_forks_repo_forks_event_max_datetime": "2020-03-12T12:31:25.000Z", "avg_line_length": 25.875502008, "max_line_length": 84, "alphanum_fraction": 0.6301412386, "num_tokens": 2154, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7879312056025699, "lm_q2_score": 0.6548947155710234, "lm_q1q2_score": 0.5160119827826286}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"growthfactor.h\"\n\n//Code to calculate the linear growth factor D, and linear growth rate, f. Where a linear perturbation delta grows as\n//delta(a') = delta(a)*(D(a')/D(a))^2 and f = dlnD/dlna\n//Note anyone using Komatsu's CRL library should note: growth_factor_crl = D *(1+z) and growth_rate_crl = f/(1+z)\n\ndouble D;\ndouble linear_f;\ndouble w0,wa;\ndouble omega_m,omega_lambda;\n\n#define LIMIT_SIZE 1000\n\nint get_growthfactor(double a,double om, double w, double w2, double *gf)\n{\n\tw0 = w;\n\twa = w2;\n\tomega_m = om;\n\tomega_lambda = 1.0 - omega_m;\n growth_de(a,gf);\n\treturn 0;\n}\n\n// 2 parameter dark energy equation of state\n\ndouble w (double a)\n{\nreturn w0 + (1.0-a)*wa;\n}\n\ndouble w_int(double z, void *param)\n{\n\treturn (1. + w(1./(z+1)) )/( 1. + z);\n}\n\n\ndouble Xde_int (double a,void *params )\n{\n if (a == 0.) a = 1e-3;\n double Xde_int = w(a)/a;\n return Xde_int;\n}\n\ndouble Xde (double a)\n{\n gsl_integration_workspace * worksp = gsl_integration_workspace_alloc (LIMIT_SIZE);\n gsl_function F;\n F.function = &Xde_int;\n F.params =0;\n double integral,error;\n if (a == 0.) \n\t\ta = 1e-3;\n gsl_integration_qags (&F, a, 1, 1.0e-20, 1.0e-10, LIMIT_SIZE,worksp, &integral, &error); \n gsl_integration_workspace_free (worksp);\n\t\n return omega_m/(1.-omega_m)*exp(-3.*integral);\n}\n\nint func (double t, const double y[], double f[], void *params)\n{\n\tdouble mu = *(double *)params;\n\tf[0] = y[1];\n\tf[1] = -( 3.5 - 1.5 * w(t)/( 1 + Xde(t) ) )*y[1]/t - 1.5 * ( 1 - w(t) )/( 1 + Xde(t))*(y[0]/t/t);\n\treturn GSL_SUCCESS;\n}\n \nint jac (double t, const double y[], double *dfdy, double dfdt[], void *params)\n{\n\tdouble mu = *(double *)params;\n\tgsl_matrix_view dfdy_mat = gsl_matrix_view_array (dfdy, 2, 2); \n\tgsl_matrix * m = &dfdy_mat.matrix; \n\tgsl_matrix_set (m, 0, 0, 0.0); //dy1/dx1\n\tgsl_matrix_set (m, 0, 1, 1.0);\n\tgsl_matrix_set (m, 1, 0, - 1.5 * ( 1 - w(t) )/( 1 + Xde(t))*(1./t/t));\n\tgsl_matrix_set (m, 1, 1, -( 3.5 - 1.5 * w(t)/( 1 + Xde(t) ) )/t);\n\tdfdt[0] = 0.0;\n\tdfdt[1] = 0.0;\n\treturn GSL_SUCCESS;\n}\n \ndouble growth_de (double a, double *gf)\n{\n\tconst gsl_odeiv_step_type * T \n\t\t= gsl_odeiv_step_rk4;\n \n\tgsl_odeiv_step * s \n = gsl_odeiv_step_alloc (T, 2);\n\tgsl_odeiv_control * c \n = gsl_odeiv_control_y_new (1e-6, 0.0);\n\tgsl_odeiv_evolve * e \n = gsl_odeiv_evolve_alloc (2);\n \n\tdouble mu = 10;\n\tgsl_odeiv_system sys = {func, jac, 2, &mu};\n \n\tdouble t =1.e-3, t1 = a;\n\tdouble h = 1e-6;\n\tdouble y[2] = {1.,0.}; \n \n\twhile (t < t1)\n\t{\n\t\tint status = gsl_odeiv_evolve_apply (e, c, s, &sys, &t, t1, &h, y);\n\t\tif (status != GSL_SUCCESS)\n\t\t\tbreak;\n\t}\n\tgsl_odeiv_evolve_free (e);\n\tgsl_odeiv_control_free (c);\n\tgsl_odeiv_step_free (s);\n\n//\treturn y[0]*a; //D growth factor\n//\treturn y[1]*a*a/(y[0]*a) +1.; // f = d ln D/ d ln a\n\tgf[0] = y[0]*a;\n\tgf[1] = y[1]*a*a/(y[0]*a) +1.;\n\treturn y[0]*a;\n\n}\n\n\n\n", "meta": {"hexsha": "ba43b19a0dd76b205c65886c96b7d9899733effd", "size": 3072, "ext": "c", "lang": "C", "max_stars_repo_path": "cosmosis-standard-library/structure/growth_factor/growthfactor.c", "max_stars_repo_name": "ktanidis2/Modified_CosmoSIS_for_galaxy_number_count_angular_power_spectra", "max_stars_repo_head_hexsha": "07e5d308c6a8641a369a3e0b8d13c4104988cd2b", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-09-15T10:10:26.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-15T10:10:26.000Z", "max_issues_repo_path": "cosmosis-standard-library/structure/growth_factor/growthfactor.c", "max_issues_repo_name": "ktanidis2/Modified_CosmoSIS_for_galaxy_number_count_angular_power_spectra", "max_issues_repo_head_hexsha": "07e5d308c6a8641a369a3e0b8d13c4104988cd2b", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "cosmosis-standard-library/structure/growth_factor/growthfactor.c", "max_forks_repo_name": "ktanidis2/Modified_CosmoSIS_for_galaxy_number_count_angular_power_spectra", "max_forks_repo_head_hexsha": "07e5d308c6a8641a369a3e0b8d13c4104988cd2b", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2021-06-11T15:29:43.000Z", "max_forks_repo_forks_event_max_datetime": "2021-06-11T15:29:43.000Z", "avg_line_length": 24.0, "max_line_length": 117, "alphanum_fraction": 0.6145833333, "num_tokens": 1155, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8596637433190938, "lm_q2_score": 0.600188359260205, "lm_q1q2_score": 0.5159601716181729}} {"text": "/* eigen/jacobi.c\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 2 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.\n */\n\n/* Author: G. Jungman\n */\n/* Simple linear algebra operations, operating directly\n * on the gsl_vector and gsl_matrix objects. These are\n * meant for \"generic\" and \"small\" systems. Anyone\n * interested in large systems will want to use more\n * sophisticated methods, presumably involving native\n * BLAS operations, specialized data representations,\n * or other optimizations.\n */\n#include \n#include \n#include \n#include \n#include \n#include \n#include \"gsl_eigen.h\"\n\n#define REAL double\n\ninline static void\njac_rotate(gsl_matrix * a,\n unsigned int i, unsigned int j, unsigned int k, unsigned int l,\n double * g, double * h,\n double s, double tau)\n{\n *g = gsl_matrix_get(a, i, j);\n *h = gsl_matrix_get(a, k, l);\n gsl_matrix_set(a, i, j, (*g) - s*((*h) + (*g)*tau));\n gsl_matrix_set(a, k, l, (*h) + s*((*g) - (*h)*tau));\n}\n\nint\ngsl_eigen_jacobi(gsl_matrix * a,\n gsl_vector * eval,\n gsl_matrix * evec,\n unsigned int max_rot, \n unsigned int * nrot)\n{\n if(a->size1 != a->size2) {\n GSL_ERROR (\"eigenproblem requires square matrix\", GSL_ENOTSQR);\n }\n else if(a->size1 != evec->size1 || a->size1 != evec->size2) {\n GSL_ERROR (\"eigenvector matrix must match input matrix\", GSL_EBADLEN);\n }\n else if(a->size1 != eval->size) {\n GSL_ERROR (\"eigenvalue vector must match input matrix\", GSL_EBADLEN);\n }\n else {\n const unsigned int n = a->size1;\n unsigned int i, j, iq, ip;\n double t, s;\n\n REAL * b = (REAL *) malloc(n * sizeof(REAL));\n REAL * z = (REAL *) malloc(n * sizeof(REAL));\n if(b == 0 || z == 0) {\n if(b != 0) free(b);\n if(z != 0) free(z);\n GSL_ERROR (\"could not allocate memory for workspace\", GSL_ENOMEM);\n }\n\n /* Set eigenvectors to coordinate basis. */\n for(ip=0; ip 4\n && fabs(d_ip)+g == fabs(d_ip)\n && fabs(d_iq)+g == fabs(d_iq)\n\t ) {\n gsl_matrix_set(a, ip, iq, 0.0);\n }\n else if(fabs(a_ipiq) > thresh) {\n h = d_iq - d_ip;\n if(fabs(h) + g == fabs(h)) {\n t = a_ipiq/h;\n }\n else {\n REAL theta = 0.5*h/a_ipiq;\n t = 1.0/(fabs(theta) + sqrt(1.0 + theta*theta));\n if(theta < 0.0) t = -t;\n }\n\n c = 1.0/sqrt(1.0+t*t);\n s = t*c;\n tau = s/(1.0+c);\n h = t * a_ipiq;\n z[ip] -= h;\n z[iq] += h;\n\t gsl_vector_set(eval, ip, d_ip - h);\n\t gsl_vector_set(eval, iq, d_iq + h);\n\t gsl_matrix_set(a, ip, iq, 0.0);\n\n for(j=0; jsize1 != a->size2 || ainv->size1 != ainv->size2) {\n return GSL_ENOTSQR;\n }\n else if(a->size1 != ainv->size2) {\n return GSL_EBADLEN;\n }\n else {\n const unsigned int n = a->size1;\n unsigned int nrot;\n unsigned int i,j,k,l;\n\n /* This is annoying because I do not want\n * the error handling in these functions.\n * But there are no \"impl\"-like versions\n * of these allocators... sigh.\n */\n gsl_vector * eval = gsl_vector_alloc(n);\n gsl_matrix * evec = gsl_matrix_alloc(n, n);\n gsl_matrix * inv_diag = gsl_matrix_alloc(n, n);\n\n if(eval == 0 || evec == 0 || inv_diag == 0) {\n if(eval != 0) gsl_vector_free(eval);\n if(evec != 0) gsl_matrix_free(evec);\n if(inv_diag != 0) gsl_matrix_free(inv_diag);\n return GSL_ENOMEM;\n }\n\n memcpy(ainv->data, a->data, n*n*sizeof(REAL));\n\n gsl_eigen_jacobi(ainv, eval, evec, max_rot, &nrot);\n\n for(i=0; i\n#include \n#include \n#include \n#include \n#include \n\ngsl_rstat_workspace *\ngsl_rstat_alloc(void)\n{\n gsl_rstat_workspace *w;\n\n w = calloc(1, sizeof(gsl_rstat_workspace));\n\n if (w == 0)\n {\n GSL_ERROR_NULL (\"failed to allocate space for workspace\", GSL_ENOMEM);\n }\n\n w->median_workspace_p = gsl_rstat_quantile_alloc(0.5);\n\n if (w->median_workspace_p == 0)\n {\n GSL_ERROR_NULL (\"failed to allocate space for median workspace\",\n GSL_ENOMEM);\n }\n\n gsl_rstat_reset(w);\n\n return w;\n} /* gsl_rstat_alloc() */\n\nvoid\ngsl_rstat_free(gsl_rstat_workspace *w)\n{\n if (w->median_workspace_p)\n gsl_rstat_quantile_free(w->median_workspace_p);\n\n free(w);\n} /* gsl_rstat_free() */\n\nsize_t\ngsl_rstat_n(const gsl_rstat_workspace *w)\n{\n return w->n;\n} /* gsl_rstat_n() */\n\n/* add a data point to the running totals */\nint\ngsl_rstat_add(const double x, gsl_rstat_workspace *w)\n{\n double delta = x - w->mean;\n double delta_n, delta_nsq, term1, n;\n\n /* update min and max */\n if (w->n == 0)\n {\n w->min = x;\n w->max = x;\n }\n else\n {\n if (x < w->min)\n w->min = x;\n if (x > w->max)\n w->max = x;\n }\n\n /* update mean and variance */\n n = (double) ++(w->n);\n delta_n = delta / n;\n delta_nsq = delta_n * delta_n;\n term1 = delta * delta_n * (n - 1.0);\n w->mean += delta_n;\n w->M4 += term1 * delta_nsq * (n * n - 3.0 * n + 3.0) +\n 6.0 * delta_nsq * w->M2 - 4.0 * delta_n * w->M3;\n w->M3 += term1 * delta_n * (n - 2.0) - 3.0 * delta_n * w->M2;\n w->M2 += term1;\n\n /* update median */\n gsl_rstat_quantile_add(x, w->median_workspace_p);\n\n return GSL_SUCCESS;\n} /* gsl_rstat_add() */\n\ndouble\ngsl_rstat_min(const gsl_rstat_workspace *w)\n{\n return w->min;\n} /* gsl_rstat_min() */\n\ndouble\ngsl_rstat_max(const gsl_rstat_workspace *w)\n{\n return w->max;\n} /* gsl_rstat_max() */\n\ndouble\ngsl_rstat_mean(const gsl_rstat_workspace *w)\n{\n return w->mean;\n} /* gsl_rstat_mean() */\n\ndouble\ngsl_rstat_variance(const gsl_rstat_workspace *w)\n{\n if (w->n > 1)\n {\n double n = (double) w->n;\n return (w->M2 / (n - 1.0));\n }\n else\n return 0.0;\n} /* gsl_rstat_variance() */\n\ndouble\ngsl_rstat_sd(const gsl_rstat_workspace *w)\n{\n double var = gsl_rstat_variance(w);\n\n return (sqrt(var));\n} /* gsl_rstat_sd() */\n\ndouble\ngsl_rstat_rms(const gsl_rstat_workspace *w)\n{\n double rms = 0.0;\n\n if (w->n > 0)\n {\n double mean = gsl_rstat_mean(w);\n double sigma = gsl_rstat_sd(w);\n double n = (double) w->n;\n double a = sqrt((n - 1.0) / n);\n rms = gsl_hypot(mean, a * sigma);\n }\n\n return rms;\n}\n\n/* standard deviation of the mean: sigma / sqrt(n) */\ndouble\ngsl_rstat_sd_mean(const gsl_rstat_workspace *w)\n{\n if (w->n > 0)\n {\n double sd = gsl_rstat_sd(w);\n return (sd / sqrt((double) w->n));\n }\n else\n return 0.0;\n} /* gsl_rstat_sd_mean() */\n\ndouble\ngsl_rstat_median(gsl_rstat_workspace *w)\n{\n return gsl_rstat_quantile_get(w->median_workspace_p);\n}\n\ndouble\ngsl_rstat_skew(const gsl_rstat_workspace *w)\n{\n if (w->n > 0)\n {\n double n = (double) w->n;\n double fac = pow(n - 1.0, 1.5) / n;\n return ((fac * w->M3) / pow(w->M2, 1.5));\n }\n else\n return 0.0;\n} /* gsl_rstat_skew() */\n\ndouble\ngsl_rstat_kurtosis(const gsl_rstat_workspace *w)\n{\n if (w->n > 0)\n {\n double n = (double) w->n;\n double fac = ((n - 1.0) / n) * (n - 1.0);\n return ((fac * w->M4) / (w->M2 * w->M2) - 3.0);\n }\n else\n return 0.0;\n} /* gsl_rstat_kurtosis() */\n\nint\ngsl_rstat_reset(gsl_rstat_workspace *w)\n{\n int status;\n\n w->min = 0.0;\n w->max = 0.0;\n w->mean = 0.0;\n w->M2 = 0.0;\n w->M3 = 0.0;\n w->M4 = 0.0;\n w->n = 0;\n\n status = gsl_rstat_quantile_reset(w->median_workspace_p);\n\n return status;\n} /* gsl_rstat_reset() */\n", "meta": {"hexsha": "0808622876e1a4cc955857022f6d080826e61666", "size": 4655, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.6/rstat/rstat.c", "max_stars_repo_name": "ielomariala/Hex-Game", "max_stars_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-06-14T11:51:37.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-14T11:51:37.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/rstat/rstat.c", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-12-16T17:41:24.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-22T00:00:16.000Z", "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/rstat/rstat.c", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-01-20T16:22:57.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-14T12:31:02.000Z", "avg_line_length": 20.9684684685, "max_line_length": 81, "alphanum_fraction": 0.619763695, "num_tokens": 1535, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7520125848754472, "lm_q2_score": 0.6859494485880928, "lm_q1q2_score": 0.5158426179266193}} {"text": "/*\r\n * Copyright (c) 2008-2011 Zhang Ming (M. Zhang), zmjerry@163.com\r\n *\r\n * This program is free software; you can redistribute it and/or modify it\r\n * under the terms of the GNU General Public License as published by the\r\n * Free Software Foundation, either version 2 or any later version.\r\n *\r\n * Redistribution and use in source and binary forms, with or without\r\n * modification, are permitted provided that the following conditions are met:\r\n *\r\n * 1. Redistributions of source code must retain the above copyright notice,\r\n * this list of conditions and the following disclaimer.\r\n *\r\n * 2. Redistributions in binary form must reproduce the above copyright\r\n * notice, this list of conditions and the following disclaimer in the\r\n * documentation and/or other materials provided with the distribution.\r\n *\r\n * This program is distributed in the hope that it will be useful, but WITHOUT\r\n * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or\r\n * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for\r\n * more details. A copy of the GNU General Public License is available at:\r\n * http://www.fsf.org/licensing/licenses\r\n */\r\n\r\n\r\n/*****************************************************************************\r\n * dgt_usefftw.h\r\n *\r\n * Discrete Gabor Transform by Using FFTW.\r\n *\r\n * These routines are designed for calculating discrete Gabor transform and\r\n * its inversion of 1D signals. In order to eliminate the border effect, the\r\n * input signal(\"signal\") is extended by three forms: zeros padded(\"zpd\"),\r\n * periodized extension(\"ppd\") and symetric extension(\"sym\").\r\n *\r\n * The analysis/synthesis function is given by users, and it's daul\r\n * (synthesis/analysis) function can be computed by \"daul\" routine. The over\r\n * sampling rate is equal to N/dM, where N denotes frequency sampling numbers\r\n * and dM denotes the time sampling interval.\r\n *\r\n * N and dM should can be devided evenly by the window length \"Lw\". The\r\n * recovered signal just has the elements from 1 to dM*floor(Ls/dM) of the\r\n * original signal. So you'd better let dM can be deviede evenly by the\r\n * original signal length \"Ls\".\r\n *\r\n * Zhang Ming, 2010-03, Xi'an Jiaotong University.\r\n *****************************************************************************/\r\n\r\n\r\n#ifndef DGT_USEFFTW_H\r\n#define DGT_USEFFTW_H\r\n\r\n\r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n//#include \r\n#include \r\n\r\n\r\nnamespace splab\r\n{\r\n\r\n\r\n template Vector\r\n daulFFTW( const Vector&, int, int );\r\n\r\n template\r\n Matrix< complex > dgtFFTW( const Vector&,\r\n const Vector&,\r\n int, int,\r\n const string &mode = \"zpd\" );\r\n template\r\n Vector idgtFFTW( const Matrix< complex >&,\r\n const Vector&,\r\n int, int );\r\n\r\n\r\n #include \r\n\r\n}\r\n// namespace splab\r\n\r\n\r\n#endif\r\n// DGT_USEFFTW_H\r\n", "meta": {"hexsha": "92858272fa9226ef1708822ade0bc8c279ab6cba", "size": 3193, "ext": "h", "lang": "C", "max_stars_repo_path": "motioncorr_v2.1/src/SP++3/include/dgt_usefftw.h", "max_stars_repo_name": "cianfrocco-lab/Motion-correction", "max_stars_repo_head_hexsha": "c77ee034bba2ef184837e070dde43f75d8a4e1e7", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 11.0, "max_stars_repo_stars_event_min_datetime": "2015-12-21T19:47:53.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-21T02:58:43.000Z", "max_issues_repo_path": "src/SP++3/include/dgt_usefftw.h", "max_issues_repo_name": "wjiang/motioncorr", "max_issues_repo_head_hexsha": "14ed37d1cc72e55d1592e78e3dda758cd46a3698", "max_issues_repo_licenses": ["Naumen", "Condor-1.1", "MS-PL"], "max_issues_count": 5.0, "max_issues_repo_issues_event_min_datetime": "2016-05-24T10:55:18.000Z", "max_issues_repo_issues_event_max_datetime": "2016-06-10T01:07:42.000Z", "max_forks_repo_path": "src/SP++3/include/dgt_usefftw.h", "max_forks_repo_name": "wjiang/motioncorr", "max_forks_repo_head_hexsha": "14ed37d1cc72e55d1592e78e3dda758cd46a3698", "max_forks_repo_licenses": ["Naumen", "Condor-1.1", "MS-PL"], "max_forks_count": 9.0, "max_forks_repo_forks_event_min_datetime": "2016-04-26T10:14:20.000Z", "max_forks_repo_forks_event_max_datetime": "2020-10-14T07:34:59.000Z", "avg_line_length": 35.8764044944, "max_line_length": 80, "alphanum_fraction": 0.6320075164, "num_tokens": 687, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7341195269001831, "lm_q2_score": 0.7025300698514777, "lm_q1q2_score": 0.5157410425125194}} {"text": "#include \n#include \n#include \n#include \"userFunc.h\"\n\n#define G 6.67384e-8 /* 2010 CODATA value in CGS units */\n#define QCRIT 1.0 /* Q value at which GI turns on */\n#define QDAMP 10.0 /* Rate of damping of alpha above Qcrit */\n#define ALPHAMIN 1.0e-6 /* Minimum allowed alpha value */\n\n/**************************************************************************/\n/* This defines userFunc routines for the Krumholz & Burkert (2010) GI */\n/* disk problem. */\n/**************************************************************************/\n\nvoid\nuserEOS(const double t, const double dt, const grid *grd, \n\tconst double *col, const double *pres, const double *eInt,\n\tvoid *params,\n\tdouble *gamma, double *delta) {\n fprintf(stderr, \n\t \"Warning: userEOS function called but not implemented!\\n\");\n return;\n}\n\nvoid\nuserAlpha(const double t, const double dt, const grid *grd, \n\t const double *col, const double *pres, const double *eInt,\n\t const double *gamma, const double *delta,\n\t void *params,\n\t double *alpha) {\n\n static int nr = 0;\n static double rmin = -1.0, rmax = -1.0;\n static double *x = NULL;\n static double *h1 = NULL;\n static double *h0 = NULL;\n static double *H = NULL;\n static double *Q = NULL;\n static gsl_vector *ud_g = NULL;\n static gsl_vector *ld_g = NULL;\n static gsl_vector *diag_g = NULL;\n static gsl_vector *rhs_g = NULL;\n static gsl_vector *tau_g = NULL;\n double eta = ((double *) params)[0];\n double chi = ((double *) params)[1];\n double tQ = ((double *) params)[2];\n double u, dlnx, sL, s, sR, dsdx, beta, dbetadx;\n double mdot;\n double dlnQdlnt;\n int i;\n\n /* Allocate memory if necessary */\n if (grd->nr != nr) {\n nr = grd->nr;\n rmin = -1.0;\n rmax = -1.0;\n /* If previously allocated, free */\n if (x != NULL) free(x);\n if (h1 != NULL) free(h1);\n if (h0 != NULL) free(h0);\n if (H != NULL) free(H);\n if (Q != NULL) free(Q);\n if (ud_g != NULL) gsl_vector_free(ud_g);\n if (ld_g != NULL) gsl_vector_free(ld_g);\n if (diag_g != NULL) gsl_vector_free(diag_g);\n if (rhs_g != NULL) gsl_vector_free(rhs_g);\n if (tau_g != NULL) gsl_vector_free(tau_g);\n /* Allocate new memory */\n if (!(x = calloc(grd->nr, sizeof(double)))) {\n fprintf(stderr, \"Error: unable to allocate memory in userAlpha!\\n\");\n exit(1);\n }\n if (!(h1 = calloc(grd->nr, sizeof(double)))) {\n fprintf(stderr, \"Error: unable to allocate memory in userAlpha!\\n\");\n exit(1);\n }\n if (!(h0 = calloc(grd->nr, sizeof(double)))) {\n fprintf(stderr, \"Error: unable to allocate memory in userAlpha!\\n\");\n exit(1);\n }\n if (!(H = calloc(grd->nr, sizeof(double)))) {\n fprintf(stderr, \"Error: unable to allocate memory in userAlpha!\\n\");\n exit(1);\n }\n if (!(Q = calloc(grd->nr, sizeof(double)))) {\n fprintf(stderr, \"Error: unable to allocate memory in userAlpha!\\n\");\n exit(1);\n }\n if (!(ud_g = gsl_vector_alloc(grd->nr+1))) {\n fprintf(stderr, \"Error: unable to allocate memory in userAlpha!\\n\");\n exit(1);\n }\n if (!(ld_g = gsl_vector_alloc(grd->nr+1))) {\n fprintf(stderr, \"Error: unable to allocate memory in userAlpha!\\n\");\n exit(1);\n }\n if (!(diag_g = gsl_vector_alloc(grd->nr+2))) {\n fprintf(stderr, \"Error: unable to allocate memory in userAlpha!\\n\");\n exit(1);\n }\n if (!(rhs_g = gsl_vector_alloc(grd->nr+2))) {\n fprintf(stderr, \"Error: unable to allocate memory in userAlpha!\\n\");\n exit(1);\n }\n if (!(tau_g = gsl_vector_alloc(grd->nr+2))) {\n fprintf(stderr, \"Error: unable to allocate memory in userAlpha!\\n\");\n exit(1);\n }\n }\n /* Initailize x if necessary */\n if ((rmin != grd->r_h[0]) || (rmax != grd->r_h[grd->nr+1])) {\n for (i=0; inr; i++) x[i] = grd->r_g[i+1]/grd->r_h[grd->nr];\n rmin = grd->r_h[0];\n rmax = grd->r_h[grd->nr+1];\n }\n\n /* Compute coefficients of torque equation */\n dlnx = log(grd->r_g[1]/grd->r_g[0]);\n for (i=0; inr; i++) {\n\n /* Define dimensionless velocity */\n u = grd->vphi_g[i+1] / grd->vphi_h[grd->nr];\n\n /* Note: compute derivatives of s using one-sided differences at\n edge cells, centered-limited differences elsewhere. */\n if (i==0) {\n s = sL = sqrt(pres[0]/col[0])/grd->vphi_h[grd->nr];\n sR = sqrt(pres[1]/col[1])/grd->vphi_h[grd->nr];\n dsdx = (sR - sL) / (x[i]*dlnx);\n } else if (i==grd->nr-1) {\n sL = sqrt(pres[grd->nr-2]/col[grd->nr-2])/grd->vphi_h[grd->nr];\n s = sR = sqrt(pres[grd->nr-1]/col[grd->nr-1])/grd->vphi_h[grd->nr];\n dsdx = (sR - sL) / (x[i]*dlnx);\n } else {\n sL = sqrt(pres[i+1]/col[i+1])/grd->vphi_h[grd->nr];\n s = sqrt(pres[i]/col[i])/grd->vphi_h[grd->nr];\n sR = sqrt(pres[i-1]/col[i-1])/grd->vphi_h[grd->nr];\n dsdx = ((sL-s)*(s-sR)) > 0 ? (sL-sR)/(2.0*x[i]*dlnx) : 0;\n }\n\n /* Compute derivative of beta using centered difference */\n beta = grd->beta_g[i+1];\n dbetadx = (grd->beta_h[i+1] - grd->beta_h[i]) / (x[i]*dlnx);\n\n /* Compute torque equation coefficients */\n h1[i] = -(5.0*(beta+1)*x[i]*dsdx + 2.0*s*(beta+SQR(beta)+x[i]*dbetadx)) /\n (2.0*(beta+1)*s*x[i]);\n h0[i] = (SQR(beta)-1) * SQR(u/(x[i]*s)) / 2.0;\n Q[i] = sqrt(2.0*(1+beta))*grd->vphi_g[i+1]/grd->r_g[i+1] * \n s*grd->vphi_h[grd->nr]/(M_PI*G*col[i]);\n dlnQdlnt = Q[i] < QCRIT ? -(exp(QCRIT/Q[i]) - exp(1.0))*u/x[i] : 0.0;\n H[i] = G*grd->r_h[grd->nr]*u*(1+beta)*col[i] *\n (2*M_PI*u*eta - 3*dlnQdlnt/tQ) / (2.0*SQR(grd->vphi_h[grd->nr])*chi);\n }\n\n /* Load matrix elements for tridiagonal solve */\n for (i=0; inr; i++) {\n gsl_vector_set(ld_g, i, 1.0/SQR(x[i]*dlnx) + \n\t\t 1.0/(2.0*SQR(x[i])*dlnx) - h1[i]/(2.0*x[i]*dlnx));\n gsl_vector_set(diag_g, i+1, -2.0/SQR(x[i]*dlnx) + h0[i]);\n gsl_vector_set(ud_g, i+1, 1.0/SQR(x[i]*dlnx) - \n\t\t 1.0/(2.0*SQR(x[i])*dlnx) + h1[i]/(2.0*x[i]*dlnx));\n gsl_vector_set(rhs_g, i+1, H[i]);\n }\n\n /* Load boundary conditions into matrix */\n /* Inner BC: tau = -x in ghost cell */\n gsl_vector_set(diag_g, 0, 1);\n gsl_vector_set(ud_g, 0, 0);\n gsl_vector_set(rhs_g, 0, -grd->r_g[0]/grd->r_h[grd->nr]);\n /* Outer BC: tau' = -beta-1 */\n gsl_vector_set(ld_g, grd->nr, -1.0/dlnx);\n gsl_vector_set(diag_g, grd->nr+1, 1.0/dlnx);\n gsl_vector_set(rhs_g, grd->nr+1, -grd->beta_g[grd->nr+1]-1);\n\n /* Solve matrix equation to get dimensionless torque */\n gsl_linalg_solve_tridiag(diag_g, ud_g, ld_g, rhs_g, tau_g);\n\n /* Use torque to compute alpha */\n mdot = chi*SQR(grd->vphi_h[grd->nr])*grd->vphi_h[grd->nr] / G;\n for (i=0; inr; i++) {\n alpha[i] = -gsl_vector_get(tau_g, i+1)*mdot*grd->vphi_h[grd->nr] *\n grd->r_h[grd->nr] /\n (2.0*M_PI*SQR(grd->r_g[i+1])*pres[i]);\n if (Q[i] > QCRIT) alpha[i] *= exp(-QDAMP*(Q[i]-QCRIT));\n if (alpha[i] < 0.0) alpha[i] = ALPHAMIN;\n }\n}\n\nvoid\nuserMassSrc(const double t, const double dt, const grid *grd,\n\t const double *col, const double *pres, const double *eInt,\n\t const double *gamma, const double *delta,\n\t void *params,\n\t double *massSrc) {\n fprintf(stderr, \n\t \"Warning: userMassSrc function called but not implemented!\\n\");\n return;\n}\n\nvoid\nuserIntEnSrc(const double t, const double dt, const grid *grd,\n\t const double *col, const double *pres, const double *eInt,\n\t const double *gamma, const double *delta,\n\t void *params, \n\t double *intEnSrc) {\n /* Cooling rate = eta Sigma sigma^2 Omega = eta P vphi/r */\n int i;\n double eta = ((double *) params)[0];\n\n for (i=0; inr; i++)\n intEnSrc[i] = -eta * pres[i] * grd->vphi_g[i+1] / grd->r_g[i+1];\n}\n\nvoid\nuserIBC(const double t, const double dt, const grid *grd,\n\tconst double *col, const double *pres, const double *eInt,\n\tconst double *gamma, const double *delta,\n\tconst pres_bc_type ibc_pres, const enth_bc_type ibc_enth,\n\tvoid *params, \n\tdouble *ibc_pres_val, double *ibc_enth_val) {\n\n /* Set torque. If Q <= QCRIT in innermost cell, so that disk is\n gravitationally unstable at the center, dimensionless torque =\n -x, dimensional torque = -(r_in/R) Mdot vphi/R. If Q > QCRIT in\n innermost cell, scale down torque in the same way as in\n userAlpha. */\n double chi = ((double *) params)[1];\n double x, mdot, s, Q;\n\n s = sqrt(pres[0]/col[0])/grd->vphi_h[grd->nr];\n Q = sqrt(2.0*(1+grd->beta_g[1]))*grd->vphi_g[1]/grd->r_g[1] * \n s*grd->vphi_h[grd->nr]/(M_PI*G*col[0]);\n mdot = chi*SQR(grd->vphi_h[grd->nr])*grd->vphi_h[grd->nr] / G;\n x = grd->r_g[0] / grd->r_h[grd->nr];\n *ibc_pres_val = -x * mdot * grd->vphi_g[0] * grd->r_h[grd->nr];\n if (Q > QCRIT) *ibc_pres_val *= exp(-QDAMP*(Q-QCRIT));\n *ibc_enth_val = gamma[0]/(gamma[0]-1.0)*pres[0]/col[0];\n}\n\nvoid\nuserOBC(const double t, const double dt, const grid *grd,\n\tconst double *col, const double *pres, const double *eInt,\n\tconst double *gamma, const double *delta,\n\tconst pres_bc_type obc_pres, const enth_bc_type obc_enth,\n\tvoid *params, \n\tdouble *obc_pres_val, double *obc_enth_val) {\n fprintf(stderr, \n\t \"Warning: userOBC function called but not implemented!\\n\");\n return;\n}\n\n\nvoid\nuserPreTimestep(const double t, const double dt,\n\t\tconst grid *grd, double *col, double *pres,\n\t\tdouble *eInt, double *mBnd, double *eBnd,\n\t\tdouble *mSrc, double *eSrc,\n\t\tvoid *params, const unsigned long nUserOut,\n\t\tdouble *userOut) {\n fprintf(stderr,\n\t \"Warning: userPreTimestep function called but not implemented!\\n\");\n return;\n}\n\nvoid\nuserCheckRead(\n\t FILE *fp, grid *grd, const unsigned long nOut,\n\t double *tOut, double *colOut,\n\t double *presOut, double *eIntOut, double *mBndOut,\n\t double *eBndOut, double *mSrcOut, double *eSrcOut,\n\t const unsigned long nUserOut, double *userOut,\n\t void *params\n\t ) {\n fprintf(stderr,\n\t \"Warning: userCheckRead function called but not implemented!\\n\");\n return;\n}\n\nvoid\nuserCheckWrite(\n\t FILE *fp,\n\t const grid *grd, const unsigned long nOut,\n\t const double *tOut, const double *colOut,\n\t const double *presOut, const double *eIntOut,\n\t const double *mBndOut, const double *eBndOut,\n\t const double *mSrcOut, const double *eSrcOut,\n\t const unsigned long nUserOut, const double *userOut,\n\t const void *params\n\t ) {\n fprintf(stderr,\n\t \"Warning: userCheckWrite function called but not implemented!\\n\");\n return;\n}\n", "meta": {"hexsha": "c3f86c23cf44ec453f4a046deab096488f8b96a7", "size": 10412, "ext": "c", "lang": "C", "max_stars_repo_path": "src/amuse/community/vader/src/prob/userFunc_gidisk.c", "max_stars_repo_name": "franciscaconcha/amuse-vader", "max_stars_repo_head_hexsha": "646b3136c39da7152c82a032f8151555ec1e3d44", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/amuse/community/vader/src/prob/userFunc_gidisk.c", "max_issues_repo_name": "franciscaconcha/amuse-vader", "max_issues_repo_head_hexsha": "646b3136c39da7152c82a032f8151555ec1e3d44", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/amuse/community/vader/src/prob/userFunc_gidisk.c", "max_forks_repo_name": "franciscaconcha/amuse-vader", "max_forks_repo_head_hexsha": "646b3136c39da7152c82a032f8151555ec1e3d44", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-11-19T04:41:37.000Z", "max_forks_repo_forks_event_max_datetime": "2021-11-20T02:11:17.000Z", "avg_line_length": 35.1756756757, "max_line_length": 77, "alphanum_fraction": 0.5968113715, "num_tokens": 3552, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8872045966995027, "lm_q2_score": 0.5813030906443133, "lm_q1q2_score": 0.5157347740952625}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nvoid compute_MCMC_chain_stats(double **x,\n int n_x,\n int n_avg,\n double * x_min,\n double * x_bar_in,\n double * x_max,\n double * x_sigma,\n double **auto_cor,\n double * slopes,\n double * dP_sub,\n double * ln_Pr_in,\n double * ln_Pr_min,\n double * ln_Pr_avg,\n double * ln_Pr_max) {\n int i_P;\n int i_avg;\n double *x_bar;\n double *s_temp;\n double c0, c1, cov00, cov01, cov11, sumsq;\n double covar;\n double var;\n\n // Allocate a temporary array for the mean if it hasn't been given/isn't requested but is needed\n if((x_sigma != NULL || auto_cor != NULL || slopes != NULL) && x_bar_in == NULL)\n x_bar = (double *)SID_malloc(sizeof(double) * n_x);\n else\n x_bar = x_bar_in;\n\n // Compute the mean (if it's requested/needed)\n if(x_bar != NULL) {\n for(i_P = 0; i_P < n_x; i_P++) {\n x_bar[i_P] = 0.;\n for(i_avg = 0; i_avg < n_avg; i_avg++)\n x_bar[i_P] += x[i_P][i_avg];\n x_bar[i_P] /= (double)n_avg;\n }\n }\n\n // Compute the std deviation (if it's requested/needed)\n if(x_sigma != NULL) {\n for(i_P = 0; i_P < n_x; i_P++) {\n x_sigma[i_P] = 0.;\n for(i_avg = 0; i_avg < n_avg; i_avg++)\n x_sigma[i_P] += pow(x[i_P][i_avg] - x_bar[i_P], 2.);\n x_sigma[i_P] = sqrt(x_sigma[i_P] / (double)n_avg);\n }\n }\n\n // Compute the slope across the interval (if it's requested/needed)\n if(slopes != NULL) {\n s_temp = (double *)SID_malloc(sizeof(double) * n_avg);\n for(i_avg = 0; i_avg < n_avg; i_avg++)\n s_temp[i_avg] = (double)i_avg;\n for(i_P = 0; i_P < n_x; i_P++) {\n gsl_fit_linear(s_temp, 1, x[i_P], 1, n_avg, &c0, &c1, &cov00, &cov01, &cov11, &sumsq);\n slopes[i_P] = c1;\n if(dP_sub != NULL)\n dP_sub[i_P] = sqrt(sumsq / (double)n_avg);\n }\n SID_free(SID_FARG s_temp);\n }\n\n // Compute the auto correlation function (if it's requested/needed)\n if(auto_cor != NULL) {\n for(i_P = 0; i_P < n_x; i_P++) {\n for(i_P = 1; i_P < n_avg; i_P++) {\n for(i_avg = 0, var = 0., covar = 0.; i_avg < (n_avg - i_P); i_avg++) {\n covar += (x[i_P][i_avg] - x_bar[i_P]) * (x[i_P][i_avg + i_P] - x_bar[i_P]);\n var += (x[i_P][i_avg] - x_bar[i_P]) * (x[i_P][i_avg] - x_bar[i_P]);\n }\n auto_cor[i_P][i_P - 1] = covar / var;\n }\n }\n }\n\n // Compute ln_Pr statistics\n if(ln_Pr_in != NULL) {\n (*ln_Pr_min) = ln_Pr_in[0];\n (*ln_Pr_avg) = ln_Pr_in[0];\n (*ln_Pr_max) = ln_Pr_in[0];\n for(i_avg = 1; i_avg < n_avg; i_avg++) {\n (*ln_Pr_min) = GBP_MIN((*ln_Pr_min), ln_Pr_in[i_avg]);\n (*ln_Pr_avg) += ln_Pr_in[i_avg];\n (*ln_Pr_max) = GBP_MAX((*ln_Pr_max), ln_Pr_in[i_avg]);\n }\n (*ln_Pr_avg) /= (double)n_avg;\n }\n\n if(x_bar != x_bar_in)\n SID_free(SID_FARG x_bar);\n}\n", "meta": {"hexsha": "3f0460c59ece413b4ed5d15a2208def99e3f79c7", "size": 3619, "ext": "c", "lang": "C", "max_stars_repo_path": "src/gbpMath/gbpMCMC/compute_MCMC_chain_stats.c", "max_stars_repo_name": "gbpoole/gbpCode", "max_stars_repo_head_hexsha": "5157d2e377edbd4806258d1c16b329373186d43a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2015-10-20T11:39:53.000Z", "max_stars_repo_stars_event_max_datetime": "2015-10-20T11:39:53.000Z", "max_issues_repo_path": "src/gbpMath/gbpMCMC/compute_MCMC_chain_stats.c", "max_issues_repo_name": "gbpoole/gbpCode", "max_issues_repo_head_hexsha": "5157d2e377edbd4806258d1c16b329373186d43a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2017-07-30T11:10:49.000Z", "max_issues_repo_issues_event_max_datetime": "2019-06-18T00:40:46.000Z", "max_forks_repo_path": "src/gbpMath/gbpMCMC/compute_MCMC_chain_stats.c", "max_forks_repo_name": "gbpoole/gbpCode", "max_forks_repo_head_hexsha": "5157d2e377edbd4806258d1c16b329373186d43a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4.0, "max_forks_repo_forks_event_min_datetime": "2015-01-23T00:50:40.000Z", "max_forks_repo_forks_event_max_datetime": "2016-08-01T08:14:24.000Z", "avg_line_length": 35.1359223301, "max_line_length": 100, "alphanum_fraction": 0.4744404532, "num_tokens": 1036, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7956581097540519, "lm_q2_score": 0.6477982315512489, "lm_q1q2_score": 0.5154259164180843}} {"text": "/*! \\file grid_fft.c\n * \\brief Function definitions for dealing with FFT's on grids.\n *\n * Note that FFTW3 fftws are unnormalized, and are therefore multiplied by N \n * In fftw3, plans are apparently intended to be local. They will be created\n * and destroyed within the functions that perform the forward and reverse transforms.\n * Real arrays have n elements, while complex arrays have n/2+1 (rounded down) elements \n * for out of place transforms. For inplace transforms, real arrays have 2*(n/2+1) elements.\n *\n * An nx x ny x nz array (in row major order) array will have an output array of size\n * nx x ny x (nz/2+1) after an r2c transform. For an inplace transform, the input array\n * must be padded to size nx x ny x 2*(nz/2+1) \n *\n * Section 4.8 of the fftw3 manual has what FFTW3 really computes.*/\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \"grid_fft.h\"\n\n\n/*! \\fn void Copy_FFTW_Grid_Info(FFTW_Grid_Info source, FFTW_Grid_Info *dest)\n * \\brief Copy an FFTW_Grid_info struct. */\nvoid Copy_FFTW_Grid_Info(FFTW_Grid_Info source, FFTW_Grid_Info *dest)\n{\n\n\t//save grid dimensions\n\t(*dest).nx = source.nx;\n\t(*dest).ny = source.ny;\n\t(*dest).nz = source.nz;\n\t(*dest).nz_complex = source.nz_complex;\n\n\t//save this process's local sizes\n\t(*dest).nx_local = source.nx_local;\n\t(*dest).nx_local_start = source.nx_local_start;\n\t(*dest).n_local_real_size = source.n_local_real_size;\n\t(*dest).n_local_complex_size = source.n_local_complex_size;\n\n\t//save physical grid info\n\t(*dest).BoxSize = source.BoxSize;\n\t(*dest).dx = source.dx;\n\t(*dest).dy = source.dy;\n\t(*dest).dz = source.dz;\n\t(*dest).dV = source.dV;\n\t(*dest).dVk = source.dVk;\n\n\t//save number of dimensions\n\t(*dest).ndim = source.ndim;\n\n\t//save fftw3 plans\n\t(*dest).plan = source.plan;\n\t(*dest).iplan = source.iplan;\n}\n\n/*! \\fn int grid_ijk(int i, int j, int k, FFTW_Grid_Info grid_info)\n * \\brief Array index for fftw grid based on coordinates i,j,k. */\nint grid_ijk(int i, int j, int k, FFTW_Grid_Info grid_info)\n{\n\tint jj;\t//wrap safe y index\n\tint kk;\t//wrap safe z index\n\tint ijk;\n\n\t//wrap safely in y and z\n\tjj = j;\n\tif(jj<0)\n\t\tjj += grid_info.ny;\n\tif(jj>(grid_info.ny-1))\n\t\tjj -= grid_info.ny;\n\n\tkk = k;\n\tif(kk<0)\n\t\tkk += grid_info.nz;\n\tif(kk>(grid_info.nz-1))\n\t\tkk -= grid_info.nz;\n\n\tswitch(grid_info.ndim)\n\t{\n\t\tcase 2: ijk = i*(2*(grid_info.ny/2+1)) + jj;\n\t\t\t\tbreak;\n\t\tcase 3: ijk = (i*grid_info.ny + jj)*(2*(grid_info.nz/2+1)) + kk;\n\t}\n\n\t//see page 61 of fftw3 manual\n\t//checked 04/27/2016\n\treturn ijk;\n\n}\n\n/*! \\fn int grid_complex_ijk(int i, int j, int k, FFTW_Grid_Info grid_info)\n * \\brief Array index for complex fftw grid based on coordinates i,j,k. */\nint grid_complex_ijk(int i, int j, int k, FFTW_Grid_Info grid_info)\n{\n\t//complex data is stored as n_0 x n_1 x (n_d-1/2+1)\n\tint ijk;\n\tint jj = j;\n\tint kk = k;\n\tint nx = grid_info.nx;\n\tint ny = grid_info.ny;\n\tint nz = grid_info.nz;\n\tswitch(grid_info.ndim)\n\t{\n\t\tcase 2: if(j>ny/2)\n\t\t\t\t\tj -= ny/2;\n\t\t\t\tijk = i*(grid_info.ny/2 +1) + jj;;\n\t\t\t\tbreak;\n\t\tcase 3:\tif(k>nz/2)\n\t\t\t\t\tk -= nz/2;\n\t\t\t\tijk = (i*grid_info.ny + jj)*(grid_info.nz/2 +1) + kk;\n\n\t}\n\treturn ijk;\n}\n\n/*! \\fn int grid_transposed_ijk(int i, int j, int k, FFTW_Grid_Info grid_info)\n * \\brief Array index for fftw grid based on coordinates i,j,k. */\nint grid_transposed_ijk(int i, int j, int k, FFTW_Grid_Info grid_info)\n{\n\t//#error fix this\n\tint jj;\t//wrap safe y index\n\tint kk;\t//wrap safe z index\n\n\tif(grid_info.ndim==2)\n\t{\n\n\t}else{\n\t\t\n\t}\n\n\t/*\n\t//wrap safely in y and z\n\tjj = j;\n\tif(jj<0)\n\t\tjj += grid_info.ny;\n\tif(jj>(grid_info.ny-1))\n\t\tjj -= grid_info.ny;\n\n\tkk = k;\n\tif(kk<0)\n\t\tkk += grid_info.nz;\n\tif(kk>(grid_info.nz-1))\n\t\tkk -= grid_info.nz;\n\n\t//see page 61 of fftw3 manual\n\treturn (i*grid_info.ny + jj)*(2*(grid_info.nz/2+1)) + kk;\n\t*/\n\n\treturn 0;\n}\n\n\n/*! \\fn int grid_index(double x, double y, double z, FFTW_Grid_Info grid_info)\n * \\brief Given a position, return the grid index. */\nint grid_index(double x, double y, double z, FFTW_Grid_Info grid_info)\n{\n\tint i = (int) (x/grid_info.dx) - grid_info.nx_local_start;\t//integer index along x direction\n\tint j = (int) (y/grid_info.dy);\t\t\t\t\t//integer index along y direction\n\tint k = (int) (z/grid_info.dz);\t\t\t\t\t//integer index along z direction\n\n\t//if the position is not within this slab, then\n\t//return -1\n\tif(i < 0 || i >= grid_info.nx_local)\n\t\treturn -1;\n\n\t//return the ijk of this position\n\treturn grid_ijk(i,j,k,grid_info);\t\n}\n\n\n\n\n/*! \\fn int grid_complex_from_real_ijk(int i, int j, int k, FFTW_Grid_Info grid_info)\n * \\brief Array index for complex fftw grid created from r2c based on coordinates i,j,k. */\nint grid_complex_from_real_ijk(int i, int j, int k, FFTW_Grid_Info grid_info)\n{\n\t//no wrapping, p60 of fftw3 manual\n\t//complex are nx x ny x (nz/2 +1)\n\treturn (i*grid_info.ny + j)*(grid_info.nz/2+1) + k;\n}\n\n/*! \\fn void initialize_mpi_local_sizes(FFTW_Grid_Info *grid_info, MPI_Comm world);\n * \\brief Function to determine local grid sizes for parallel FFT. */\nvoid initialize_mpi_local_sizes(FFTW_Grid_Info *grid_info, MPI_Comm world)\n{\n\tptrdiff_t nx_local;\t\n\tptrdiff_t nx_local_start;\t\n\t//ptrdiff_t ny_local;\t\n\t//ptrdiff_t ny_local_start;\n\t//ptrdiff_t nx_local_transposed;\t\n\t//ptrdiff_t nx_local_start_transposed;\t\n\t//ptrdiff_t ny_local_transposed;\t\n\t//ptrdiff_t ny_local_start_transposed;\n\t//ptrdiff_t n_local_complex_size;\t\n\tptrdiff_t n_local_size;\n\n\n\t//find the local sizes for *****complex arrays******\n\tswitch(grid_info->ndim)\n\t{\n\t\tcase 2:\tn_local_size = fftw_mpi_local_size_2d(grid_info->nx, grid_info->ny/2+1, world, &nx_local, &nx_local_start);\n\t\t\t\tbreak;\n\t\tcase 3:\tn_local_size = fftw_mpi_local_size_3d(grid_info->nx, grid_info->ny, grid_info->nz/2+1, world, &nx_local, &nx_local_start);\n\t\t\t\tbreak;\n\t\tdefault: printf(\"Only 2 or 3 dimensions\\n\");\n\t\t\t\t MPI_Abort(world,-1);\n\t\t\t\t exit(-1);\n\t}\n\n\t//remember the size\n\tgrid_info->nx_local = nx_local;\n\tgrid_info->nx_local_start = nx_local_start;\n\tgrid_info->n_local_complex_size = n_local_size;\n\t//grid_info->nx_local_transposed = nx_local_transposed;\n\t//grid_info->nx_local_start_transposed = nx_local_start_transposed;\n\t//grid_info->ny_local_transposed = ny_local_transposed;\n\t//grid_info->ny_local_start_transposed = ny_local_start_transposed;\n\tgrid_info->n_local_real_size = 2*grid_info->n_local_complex_size;\n\n\tprintf(\"nx_local %ld (nx_local) %ld\\n\",nx_local,(nx_local));\n\tif(nx_local<=0)\n\t{\n\t printf(\"A*****************************************\\n\");\n\t printf(\"WARNING!\\n\");\n\t printf(\"nx_local = %ld on at least 1 processor\\n\",(ptrdiff_t) nx_local);\n\t printf(\"Many functions implicitly assume nx_local>0\\n\");\n\t printf(\"Try a different (lower) nprocs if possible.\\n\");\n\t printf(\"*****************************************\\n\");\n\t fflush(stdout);\n\t}\n}\n\n/*! \\fn double *allocate_real_fftw_grid_sized(int n_size)\n * \\brief Allocates a pre-sized 3-d real grid for use with fftw.*/\ndouble *allocate_real_fftw_grid_sized(int n_size)\n{\n\tdouble *data;\n\n\t//allocate data\n\tdata = fftw_alloc_real(n_size);\n\n\t//return data\n\treturn data;\n}\n\n/*! \\fn double *allocate_real_fftw_grid(FFTW_Grid_Info grid_info)\n * \\brief Allocates a 3-d real grid for use with fftw.*/\ndouble *allocate_real_fftw_grid(FFTW_Grid_Info grid_info)\n{\n\tdouble *data;\n\n\t//allocate data\n\tdata = fftw_alloc_real(grid_info.n_local_real_size);\n\n\t//return data\n\treturn data;\n}\n\n/*! \\fn fftw_complex *allocate_complex_fftw_grid(FFTW_Grid_Info grid_info)\n * \\brief Allocates a 3-d complex grid for use with fftw.*/\nfftw_complex *allocate_complex_fftw_grid(FFTW_Grid_Info grid_info)\n{\n\tfftw_complex *cdata;\n\n\t//allocate data\n\tcdata = fftw_alloc_complex(grid_info.n_local_complex_size);\n\n\t//return data\t\n\treturn cdata;\n}\n\n\n/*! \\fn double **allocate_field_fftw_grid(int nd, FFTW_Grid_Info grid_info);\n * \\brief Allocates a field[ndim][n_local_real_size] (of dimension ndim) of 3-d real grids for use with fftw.*/\ndouble **allocate_field_fftw_grid(int nd, FFTW_Grid_Info grid_info)\n{\n\tdouble **data;\n\n\t//allocate the field\n\tdata = new double *[nd];\n\n\t//each field element is an fftw grid\n\tfor(int i=0;inx)\n\t\tixmax = nx;\n\tif(iymax>ny)\n\t\tiymax = ny;\n\tif(izmax>nz)\n\t\tizmax = nz;\n\n\tif(ixmin<0)\n\t\tixmin = 0;\n\tif(iymin<0)\n\t\tiymin = 0;\n\tif(izmin<0)\n\t\tizmin = 0;\n\n\n\t//restrict the output to the data available on each process\n\n\tnx_min = ixmin;\n\tnx_max = ixmax;\n\n\tif(nx_minnx_local)\n\t{\n\t\tnx_max = nx_local + nx_local_start;\n\t}\n\t\n\n\t//each process should have the complete y and z range\n\n\tny_min = iymin;\n\tny_max = iymax;\n\n\tnz_min = izmin;\n\tnz_max = izmax;\n\n\n\tnx_out = nx_max - nx_min;\n\tny_out = ny_max - ny_min;\n\tnz_out = nz_max - nz_min;\n\n\tif( (ixmin=nx_local_start) )\n\t\tyes_flag = 1;\n\n\n\n\t//loop over number of processors\n\tfor(int ip=0;ip=nx_local_start)&&(ip==myid) )\n\t\t{\n\n\t\t\tif(!initial_flag)\n\t\t\t{\n\n\t\t\t\t//printf(\"processor %d initiated for file %s\\n\",myid,output_fname);\n\t\t\t\t//fflush(stdout);\n\t\t\t\t//this processor is the first \n\t\t\t\t//to write to the file\n\t\n\t\t\t\tinitial_flag = 1;\n\n\t\t\t\t//open a new file\n\n\t\t\t\tif(!(fp = fopen(output_fname,\"w\")))\n\t\t\t\t{\n\t\t\t\t\tprintf(\"Error opening %s by process %d\\n\",output_fname,myid);\n\t\t\t\t\tfflush(stdout);\n\n\t\t\t\t\terror_flag = 1;\n\t\t\t\t}else{\n\t\t\t\t\t//printf(\"File %s opened by %d.\\n\",output_fname,myid);\n\t\t\t\t\t//printf(\"nx %d ny %d nz %d\\n\",nx,ny,nz);\n\t\t\t\t\t//printf(\"ixmin %d ixmax %d\\n\",ixmin,ixmax);\n\t\t\t\t\t//printf(\"iymin %d iymax %d\\n\",iymin,iymax);\n\t\t\t\t\t//printf(\"izmin %d izmax %d\\n\",izmin,izmax);\n\t\t\t\t\t//printf(\"nxmin %d nxmax %d\\n\",nx_min,nx_max);\n\t\t\t\t\t//printf(\"nymin %d nymax %d\\n\",ny_min,ny_max);\n\t\t\t\t\t//printf(\"nzmin %d nzmax %d\\n\",nz_min,nz_max);\n\t\t\t\t\t//printf(\"nxout %d nyout %d nzyout %d\\n\",nx_out,ny_out,nz_out);\n\t\t\t\t\t//fflush(stdout);\n\t\t\t\t}\n\n\n\t\t\t\t//the data file has opened correctly, so continue\n\n\t\t\t\tif(!error_flag)\n\t\t\t\t{\n\n\t\t\t\t\t//write the grid dimensions\n\n\t\t\t\t\tfwrite(&nx,1,sizeof(int),fp);\n\t\t\t\t\tfwrite(&ny,1,sizeof(int),fp);\n\t\t\t\t\tfwrite(&nz,1,sizeof(int),fp);\n\n\t\t\t\t\t//write the restricted grid dimensions\n\n\t\t\t\t\tfwrite(&ixmin,1,sizeof(int),fp);\n\t\t\t\t\tfwrite(&ixmax,1,sizeof(int),fp);\n\t\t\t\t\tfwrite(&iymin,1,sizeof(int),fp);\n\t\t\t\t\tfwrite(&iymax,1,sizeof(int),fp);\n\t\t\t\t\tfwrite(&izmin,1,sizeof(int),fp);\n\t\t\t\t\tfwrite(&izmax,1,sizeof(int),fp);\n\n\t\t\t\t\t//write this process's data to file\n\n\n\t\t\t\t\t//allocate the output buffer\n\t\t\t\t\tif(!(xout = (double *) malloc(nx_out*ny_out*nz_out*sizeof(double))))\n\t\t\t\t\t{\n\t\t\t\t\t\tprintf(\"Error allocating output array xout on process %d (nx_out %d ny_out %d nz_out %d).\\n\",myid,nx_out,ny_out,nz_out);\n\t\t\t\t\t\tfflush(stdout);\n\t\t\t\t\t\terror_flag = 1;\n\t\t\t\t\t}\n\t\n\t\t\t\t\tif(!error_flag)\n\t\t\t\t\t{\n\t\t\t\t\t\tfor(int i=nx_min;i=(nx_out*ny_out*nz_out))\n\t\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\t\tprintf(\"error here i %d j %d k %d nx_min %d nx_max %d ny_min %d ny_max %d nz_min %d nz_max %d ijk %d max %d\\n\",i,j,k,nx_min,nx_max,ny_min,ny_max,nz_min,nz_max,ijk_out,nx_out*ny_out*nz_out);\n\t\t\t\t\t\t\t\t\t\tfflush(stdout);\n\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\tif(ijk>=n_local_size)\n\t\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\t\tprintf(\"second error here i %d j %d k %d nx_min %d nx_max %d ny_min %d ny_max %d nz_min %d nz_max %d ijk %d max %d\\n\",i,j,k,nx_min,nx_max,ny_min,ny_max,nz_min,nz_max,ijk,nx_local*ny*nz);\n\t\t\t\t\t\t\t\t\t\tfflush(stdout);\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\txout[ijk_out] = data[ijk]; \n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\t//write the data\n\n\t\t\t\t\t\tfwrite(xout,nx_out*ny_out*nz_out,sizeof(double),fp);\n\n\t\t\t\t\t\t//close the data file\n\t\n\t\t\t\t\t\tfclose(fp);\n\t\n\t\t\t\t\t\t//free the output buffer\n\n\t\t\t\t\t\tfree(xout);\n\t\t\t\t\t}\n\t\t\t\t\t\n\t\t\t\t}\n\n\t\t\t}else{\n\n\t\t\t\t//printf(\"processor %d continuing for file %s\\n\",myid,output_fname);\n\t\t\t\t//fflush(stdout);\n\t\t\t\t//here, we're not the first processsor to output our data\n\t\t\t\t//so the file should be appended, not created\n\n\t\t\t\t//open the file to append\n\n\t\t\t\tif(!(fp = fopen(output_fname,\"a\")))\n\t\t\t\t{\n\t\t\t\t\tprintf(\"Error opening %s by process %d\\n\",output_fname,myid);\n\t\t\t\t\tfflush(stdout);\n\n\t\t\t\t\terror_flag = 1;\n\t\t\t\t}else{\n\t\t\t\t\t//printf(\"File %s appended by %d.\\n\",output_fname,myid);\n\t\t\t\t\t//printf(\"nx %d ny %d nz %d\\n\",nx,ny,nz);\n\t\t\t\t\t//printf(\"ixmin %d ixmax %d\\n\",ixmin,ixmax);\n\t\t\t\t\t//printf(\"iymin %d iymax %d\\n\",iymin,iymax);\n\t\t\t\t\t//printf(\"izmin %d izmax %d\\n\",izmin,izmax);\n\t\t\t\t\t//printf(\"nxmin %d nxmax %d\\n\",nx_min,nx_max);\n\t\t\t\t\t//printf(\"nymin %d nymax %d\\n\",ny_min,ny_max);\n\t\t\t\t\t//printf(\"nzmin %d nzmax %d\\n\",nz_min,nz_max);\n\t\t\t\t\t//printf(\"nxout %d nyout %d nzyout %d\\n\",nx_out,ny_out,nz_out);\n\t\t\t\t\t//fflush(stdout);\n\t\t\t\t}\n\n\t\t\t\t//the data file has opened correctly, so continue\n\n\t\t\t\tif(!error_flag)\n\t\t\t\t{\n\t\t\t\t\t//write this process's data to file\n\n\t\t\t\t\tnx_out = nx_max - nx_min;\n\t\t\t\t\tny_out = ny_max - ny_min;\n\t\t\t\t\tnz_out = nz_max - nz_min;\n\n\t\t\t\t\t//allocate the output buffer\n\t\t\t\t\tif(!(xout = (double *) malloc(nx_out*ny_out*nz_out*sizeof(double))))\n\t\t\t\t\t{\n\t\t\t\t\t\tprintf(\"Error allocating alt output array xout on process %d (nx %d ny %d nz %d).\\n\",myid,nx_out,ny_out,nz_out);\n\t\t\t\t\t\tfflush(stdout);\n\t\t\t\t\t\terror_flag = 1;\n\t\t\t\t\t}\n\t\n\t\t\t\t\tif(!error_flag)\n\t\t\t\t\t{\n\t\t\t\t\t\tfor(int i=nx_min;i=(nx_out*ny_out*nz_out))\n\t\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\t\tprintf(\"alt error here i %d j %d k %d nx_min %d nx_max %d ny_min %d ny_max %d nz_min %d nz_max %d ijk %d max %d\\n\",i,j,k,nx_min,nx_max,ny_min,ny_max,nz_min,nz_max,ijk_out,nx_out*ny_out*nz_out);\n\t\t\t\t\t\t\t\t\t\tfflush(stdout);\n\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\tif(ijk>=n_local_size)\n\t\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\t\tprintf(\"alt second error here i %d j %d k %d nx_min %d nx_max %d ny_min %d ny_max %d nz_min %d nz_max %d ijk %d max %d\\n\",i,j,k,nx_min,nx_max,ny_min,ny_max,nz_min,nz_max,ijk,nx_local*ny*nz);\n\t\t\t\t\t\t\t\t\t\tfflush(stdout);\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\txout[ijk_out] = data[ijk]; \n\t\t\t\t\t\t\t\t}\n\n\n\t\t\t\t\t\t//write the data\n\n\t\t\t\t\t\tfwrite(xout,nx_out*ny_out*nz_out,sizeof(double),fp);\n\n\t\t\t\t\t\t//close the data file\n\t\n\t\t\t\t\t\tfclose(fp);\n\t\n\t\t\t\t\t\t//free the output buffer\n\n\t\t\t\t\t\tfree(xout);\n\t\t\t\t\t}\n\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\n\n\t\t//Check to see if previous processors wrote some data\n\t\t//and created the output file\n\n\t\tMPI_Allreduce(&initial_flag,&total_initial,1,MPI_INT,MPI_SUM,world);\n\t\tinitial_flag = total_initial;\n\t\tif(initial_flag>0)\n\t\t{\n\t\t\tinitial_flag = 1;\n\t\t\ttotal_initial = 1;\n\t\t}\n\n\n\n\t\t//Check for errors, and if there is an error abort\n\n\t\t//AllCheckError(error_flag,myid,numprocs,world);\n\t\tMPI_Barrier(world);\n\t}\n}\n\n/*\nvoid convolve_complex_fftw_grid(fftw_complex *C_transposed, fftw_complex *A_transposed, fftw_complex *B_transposed, FFTW_Grid_Info grid_info, int local_ny_after_transpose, int nx, int ny, int nzi, int myid, int numprocs, MPI_Comm world)\n{\n\tint ijk;\n\n\t//transform normalization\n\t//is handled in forward_transform_fftw_grid\n\n\tdouble scale = 1.;\n\n\tint nz = nzi;\n\tint nzl = nz/2+1;\n\tif(grid_info.ndim==2)\n\t{\n\t\tnz=1;\n\t\tnzl=1;\n\t}\n\tfor(int j=0;jnx)\n\t\tixmax = nx;\n\tif(iymax>ny)\n\t\tiymax = ny;\n\tif(izmax>nz)\n\t\tizmax = nz;\n\n\tif(ixmin<0)\n\t\tixmin = 0;\n\tif(iymin<0)\n\t\tiymin = 0;\n\tif(izmin<0)\n\t\tizmin = 0;\n\n\n\t//restrict the output to the data available on each process\n\n\tnx_min = ixmin;\n\tnx_max = ixmax;\n\n\t//if(nx_min>=nx_local_start)\n\tif(nx_minnx_local)\n\t{\n\t\t//nx_max = nx_local;\n\t\tnx_max = nx_local + nx_local_start;\n\t}\n\t\n\n\t//each process should have the complete y and z range\n\n\tny_min = iymin;\n\tny_max = iymax;\n\n\tnz_min = izmin;\n\tnz_max = izmax;\n\n\n\tnx_out = nx_max - nx_min;\n\tny_out = ny_max - ny_min;\n\tnz_out = nz_max - nz_min;\n\n\tif( (ixmin=nx_local_start) )\n\t\tyes_flag = 1;\n\n\tif(myid==0)\n\t\tprintf(\"testing output\\n\");\n\tfflush(stdout);\n\n\tfor(int ip=0;ip=nx_local_start)&&(ip==myid) )\n\t\t{\n\n\t\t\tif(!initial_flag)\n\t\t\t{\n\n\t\t\t\t//this processor is the first \n\t\t\t\t//to write to the file\n\t\n\t\t\t\tinitial_flag = 1;\n\n\t\t\t\t//open a new file\n\n\t\t\t\tif(!(fp = fopen(output_fname,\"w\")))\n\t\t\t\t{\n\t\t\t\t\tprintf(\"Error opening %s by process %d\\n\",output_fname,myid);\n\t\t\t\t\tfflush(stdout);\n\n\t\t\t\t\terror_flag = 1;\n\t\t\t\t}else{\n\t\t\t\t\t//printf(\"File %s opened by %d.\\n\",output_fname,myid);\n\t\t\t\t\t//printf(\"nx %d ny %d nz %d\\n\",nx,ny,nz);\n\t\t\t\t\t//printf(\"ixmin %d ixmax %d\\n\",ixmin,ixmax);\n\t\t\t\t\t//printf(\"iymin %d iymax %d\\n\",iymin,iymax);\n\t\t\t\t\t//printf(\"izmin %d izmax %d\\n\",izmin,izmax);\n\t\t\t\t\t//printf(\"nxmin %d nxmax %d\\n\",nx_min,nx_max);\n\t\t\t\t\t//printf(\"nymin %d nymax %d\\n\",ny_min,ny_max);\n\t\t\t\t\t//printf(\"nzmin %d nzmax %d\\n\",nz_min,nz_max);\n\t\t\t\t\t//printf(\"nxout %d nyout %d nzyout %d\\n\",nx_out,ny_out,nz_out);\n\t\t\t\t\t//fflush(stdout);\n\t\t\t\t}\n\n\n\t\t\t\t//the data file has opened correctly, so continue\n\n\t\t\t\tif(!error_flag)\n\t\t\t\t{\n\n\t\t\t\t\t//write the grid dimensions\n\n\t\t\t\t\tfwrite(&nx,1,sizeof(int),fp);\n\t\t\t\t\tfwrite(&ny,1,sizeof(int),fp);\n\t\t\t\t\tfwrite(&nz,1,sizeof(int),fp);\n\n\t\t\t\t\t//write the restricted grid dimensions\n\n\t\t\t\t\tfwrite(&ixmin,1,sizeof(int),fp);\n\t\t\t\t\tfwrite(&ixmax,1,sizeof(int),fp);\n\t\t\t\t\tfwrite(&iymin,1,sizeof(int),fp);\n\t\t\t\t\tfwrite(&iymax,1,sizeof(int),fp);\n\t\t\t\t\tfwrite(&izmin,1,sizeof(int),fp);\n\t\t\t\t\tfwrite(&izmax,1,sizeof(int),fp);\n\n\t\t\t\t\t//write this process's data to file\n\n\n\t\t\t\t\t//allocate the output buffer\n\t\t\t\t\tif(!(xout = (double *) malloc(nx_out*ny_out*nz_out*sizeof(double))))\n\t\t\t\t\t{\n\t\t\t\t\t\tprintf(\"Error allocating output array xout on process %d (nx_out %d ny_out %d nz_out %d).\\n\",myid,nx_out,ny_out,nz_out);\n\t\t\t\t\t\tfflush(stdout);\n\t\t\t\t\t\terror_flag = 1;\n\t\t\t\t\t}\n\t\n\t\t\t\t\tif(!error_flag)\n\t\t\t\t\t{\n\t\t\t\t\t\tfor(int i=nx_min;i=(nx_out*ny_out*nz_out))\n\t\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\t\tprintf(\"error here i %d j %d k %d nx_min %d nx_max %d ny_min %d ny_max %d nz_min %d nz_max %d ijk %d max %d\\n\",i,j,k,nx_min,nx_max,ny_min,ny_max,nz_min,nz_max,ijk_out,nx_out*ny_out*nz_out);\n\t\t\t\t\t\t\t\t\t\tfflush(stdout);\n\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\tif(ijk>=n_local_size)\n\t\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\t\tprintf(\"second error here i %d j %d k %d nx_min %d nx_max %d ny_min %d ny_max %d nz_min %d nz_max %d ijk %d max %d\\n\",i,j,k,nx_min,nx_max,ny_min,ny_max,nz_min,nz_max,ijk,nx_local*ny*nz);\n\t\t\t\t\t\t\t\t\t\tfflush(stdout);\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\txout[ijk_out] = data[ijk]; \n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t//write the data\n\n\t\t\t\t\t\tfwrite(xout,nx_out*ny_out*nz_out,sizeof(double),fp);\n\n\t\t\t\t\t\t//close the data file\n\t\n\t\t\t\t\t\tfclose(fp);\n\t\n\t\t\t\t\t\t//free the output buffer\n\n\t\t\t\t\t\tfree(xout);\n\t\t\t\t\t}\n\t\t\t\t\t\n\t\t\t\t}\n\n\t\t\t}else{\n\n\t\t\t\t//here, we're not the first processsor to output our data\n\t\t\t\t//so the file should be appended, not created\n\n\t\t\t\t//open the file to append\n\n\t\t\t\tif(!(fp = fopen(output_fname,\"a\")))\n\t\t\t\t{\n\t\t\t\t\tprintf(\"Error opening %s by process %d\\n\",output_fname,myid);\n\t\t\t\t\tfflush(stdout);\n\n\t\t\t\t\terror_flag = 1;\n\t\t\t\t}else{\n\t\t\t\t\t//printf(\"File %s appended by %d.\\n\",output_fname,myid);\n\t\t\t\t\t//printf(\"nx %d ny %d nz %d\\n\",nx,ny,nz);\n\t\t\t\t\t//printf(\"ixmin %d ixmax %d\\n\",ixmin,ixmax);\n\t\t\t\t\t//printf(\"iymin %d iymax %d\\n\",iymin,iymax);\n\t\t\t\t\t//printf(\"izmin %d izmax %d\\n\",izmin,izmax);\n\t\t\t\t\t//printf(\"nxmin %d nxmax %d\\n\",nx_min,nx_max);\n\t\t\t\t\t//printf(\"nymin %d nymax %d\\n\",ny_min,ny_max);\n\t\t\t\t\t//printf(\"nzmin %d nzmax %d\\n\",nz_min,nz_max);\n\t\t\t\t\t//printf(\"nxout %d nyout %d nzyout %d\\n\",nx_out,ny_out,nz_out);\n\t\t\t\t\t//fflush(stdout);\n\t\t\t\t}\n\n\t\t\t\t//the data file has opened correctly, so continue\n\n\t\t\t\tif(!error_flag)\n\t\t\t\t{\n\n\t\t\t\t\t//write this process's data to file\n\n\t\t\t\t\tnx_out = nx_max - nx_min;\n\t\t\t\t\tny_out = ny_max - ny_min;\n\t\t\t\t\tnz_out = nz_max - nz_min;\n\n\t\t\t\t\t//allocate the output buffer\n\t\t\t\t\tif(!(xout = (double *) malloc(nx_out*ny_out*nz_out*sizeof(double))))\n\t\t\t\t\t{\n\t\t\t\t\t\tprintf(\"Error allocating alt output array xout on process %d (nx %d ny %d nz %d).\\n\",myid,nx_out,ny_out,nz_out);\n\t\t\t\t\t\tfflush(stdout);\n\t\t\t\t\t\terror_flag = 1;\n\t\t\t\t\t}\n\t\n\t\t\t\t\tif(!error_flag)\n\t\t\t\t\t{\n\t\t\t\t\t\tfor(int i=nx_min;i=(nx_out*ny_out*nz_out))\n\t\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\t\tprintf(\"alt error here i %d j %d k %d nx_min %d nx_max %d ny_min %d ny_max %d nz_min %d nz_max %d ijk %d max %d\\n\",i,j,k,nx_min,nx_max,ny_min,ny_max,nz_min,nz_max,ijk_out,nx_out*ny_out*nz_out);\n\t\t\t\t\t\t\t\t\t\tfflush(stdout);\n\t\t\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\t\t\tif(ijk>=n_local_size)\n\t\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\t\tprintf(\"alt second error here i %d j %d k %d nx_min %d nx_max %d ny_min %d ny_max %d nz_min %d nz_max %d ijk %d max %d\\n\",i,j,k,nx_min,nx_max,ny_min,ny_max,nz_min,nz_max,ijk,nx_local*ny*nz);\n\t\t\t\t\t\t\t\t\t\tfflush(stdout);\n\t\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\t\txout[ijk_out] = data[ijk]; \n\t\t\t\t\t\t\t\t}\n\n\n\t\t\t\t\t\t//write the data\n\n\t\t\t\t\t\tfwrite(xout,nx_out*ny_out*nz_out,sizeof(double),fp);\n\n\t\t\t\t\t\t//close the data file\n\t\n\t\t\t\t\t\tfclose(fp);\n\t\n\t\t\t\t\t\t//free the output buffer\n\n\t\t\t\t\t\tfree(xout);\n\t\t\t\t\t}\n\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\n\n\t\t//Check to see if previous processors wrote some data\n\t\t//and created the output file\n\n\t\tMPI_Allreduce(&initial_flag,&total_initial,1,MPI_INT,MPI_SUM,world);\n\t\tinitial_flag = total_initial;\n\n\n\n\t\t//Check for errors, and if there is an error abort\n\n\t\tAllCheckError(error_flag,myid,numprocs,world);\n\t}\n}\n\nvoid output_fft_grid_complex(char *output_fname, fftw_complex *data, int nx, int ny, int nz, int ixmin, int ixmax, int iymin, int iymax, int izmin, int izmax, int local_y_start_after_transpose, int local_ny_after_transpose, int n_local_size, int myid, int numprocs, MPI_Comm world)\n{\n\n\n\t//output the complex data\n\t//but remember that the data is transposed\n\t//and that the slabs are split across the\n\t//y dimension\n\n\n\t// Also remember that we performed\n\t// a transform of real data.\n\t// For real data, F(-k) = F(k)*\n\t// and the nz/2 element is the\n\t// same as the -nz/2 element\n\n\n\t// the format of the gridded complex\n\t// data will be\n\t//\n\t// nx \n\t// {\n\t// re(ny,nz)\n\t// im(ny,nz)\n\t// }\n\n\t// the duplicative information in\n\t// the z-direction *will be included*\n\n\n\t// and note that for simplicity\n\t// izmin = 0;\n\t// izmax = nz;\n\t// always\n\n\tFILE *fp;\n\n\tMPI_Status status;\n\n\tint jk;\n\tint jk_out;\n\tint jtot;\n\n\tdouble *xout_imaginary, *xout_real;\n\n\tdouble *y_block_imaginary, *y_block_real;\n\n\tint initial_flag = 0;\n\tint total_initial = 0;\n\n\n\tint error_flag = 0;\n\n\n\tint nx_max;\n\tint nx_min;\n\n\tint ny_max;\n\tint ny_min;\n\n\tint nz_max;\n\tint nz_min;\n\n\tint nx_out;\n\tint ny_out;\n\tint nz_out;\n\n\tint *all_local_ny, *all_local_y_start;\n\n\tint yes_flag = 0;\n\n\t//some simple array boundary checks\n\n\tif(ixmax>nx)\n\t\tixmax = nx;\n\tif(iymax>ny)\n\t\tiymax = ny;\n\n\tif(ixmin<0)\n\t\tixmin = 0;\n\tif(iymin<0)\n\t\tiymin = 0;\n\n\n\t//enforce full z coverage\n\tizmin = 0;\n\tizmax = nz;\n\n\t//each process should have the complete x and z range\n\n\t//we will pretend the whole y range is available\n\n\tny_min = iymin;\n\tny_max = iymax;\n\n\tnx_min = ixmin;\n\tnx_max = ixmax;\n\n\tnx_out = nx_max - nx_min;\n\tny_out = ny_max - ny_min;\n\n\n\n\t//The data is transposed and is complex, so the output method differs from that for real data:\n\n\n\t//First, the root process opens a new file and outputs the essential \n\t//info about the data\n\n\n\n\tif(myid==0)\n\t{\n\t\t//open a new file\n\n\t\tif(!(fp = fopen(output_fname,\"w\")))\n\t\t{\n\t\t\tprintf(\"Error opening %s by process %d\\n\",output_fname,myid);\n\t\t\tfflush(stdout);\n\n\t\t\terror_flag = 1;\n\t\t}\n\n\t\tif(!error_flag)\n\t\t{\n\n\t\t\t//the data file has opened correctly, so continue\n\n\t\t\t//write the grid dimensions\n\n\t\t\tfwrite(&nx,1,sizeof(int),fp);\n\t\t\tfwrite(&ny,1,sizeof(int),fp);\n\t\t\tfwrite(&nz,1,sizeof(int),fp);\n\n\t\t\t//write the restricted grid dimensions\n\n\t\t\tfwrite(&ixmin,1,sizeof(int),fp);\n\t\t\tfwrite(&ixmax,1,sizeof(int),fp);\n\t\t\tfwrite(&iymin,1,sizeof(int),fp);\n\t\t\tfwrite(&iymax,1,sizeof(int),fp);\n\t\t\tfwrite(&izmin,1,sizeof(int),fp);\n\t\t\tfwrite(&izmax,1,sizeof(int),fp);\n\n\n\t\t\tfclose(fp);\n\t\t}\n\t}\n\n\n\t//Check for errors, and if there is an error abort\n\n\tAllCheckError(error_flag,myid,numprocs,world);\n\n\n\t//The data is transposed, so to output\n\t//in row-major format with the x-direction \n\t//as primary, we're gonna do some funky outputing\n\n\n\t//First, figure out the y-direction extent of each\n\t//processor and share that with the other processes\n\n\n\t//allocate arrays to hold local y extent info\n\n\n\tif(!(all_local_ny = (int *) malloc(numprocs*sizeof(int))))\n\t{\n\t\tprintf(\"Error allocating all_local_y on process %d.\\n\",myid);\n\t\terror_flag = 1;\n\t}\n\n\tif(!(all_local_y_start = (int *) malloc(numprocs*sizeof(int))))\n\t{\n\t\tprintf(\"Error allocating all_local_y_start on process %d.\\n\",myid);\n\t\terror_flag = 1;\n\t}\n\n\t//Check for errors, and if there is an error abort\n\n\tAllCheckError(error_flag,myid,numprocs,world);\n\n\t//Share local y extent info\n\n\n\tMPI_Allgather(&local_ny_after_transpose,1,MPI_INT,all_local_ny,1,MPI_INT,world);\t\n\n\tMPI_Allgather(&local_y_start_after_transpose,1,MPI_INT,all_local_y_start,1,MPI_INT,world);\t\n\n\n\tif(myid==0)\n\t{\n\t\tfor(int i=0;i=all_local_y_start[ip]) )\n\t\t\t{\n\t\t\t\t//printf(\"i %d j %d ip %d processor %d entered\\n\",i,jtot,ip,myid);\n\t\t\t\t//fflush(stdout);\n\n\t\t\t\t//This processor contributes to the y-direction extent of the output\n\n\t\t\t\tif(ip==0)\n\t\t\t\t{\n\n\t\t\t\t\tif(ip==myid)\n\t\t\t\t\t{\n\t\t\t\t\t\t//it is time for the root process\n\t\t\t\t\t\t//to copy its y-direction info\n\t\t\t\t\t\t//into the xout page\n\n\t\t\t\t\t\tfor(int j=0;(j=numprocs)\n\t\tu_dest-=numprocs;\n\tif(u_source<0)\n\t\tu_source+=numprocs;\n\n\tif(l_dest<0)\n\t\tl_dest+=numprocs;\n\tif(l_source>=numprocs)\n\t\tl_source-=numprocs;\n\n\t//first, initialize the grid to zero\n\tfor(i=0;i=nx_local_start)&&(i<(nx_local_start+nx_local)) )\n\t\t{\n\t\t\twrap_particle(&i,&j,&k,nx,ny,nz,&xp,&yp,&zp);\n\n\n\t\t\t// cell centers\n\n\t\t\txc = ((double) i);\n\t\t\tyc = ((double) j);\n\t\t\tzc = ((double) k);\n\n\t\t\tdx = xp - xc;\n\n\t\t\tdy = yp - yc;\n\n\t\t\tdz = zp - zc;\n\n\t\t\ttx = 1 - dx;\n\n\t\t\tty = 1 - dy;\n\n\t\t\ttz = 1 - dz;\n\n\t\n\t\t\t//first do cell containing particle\n\n\t\t\tic = i-nx_local_start;\n\t\t\tjc = j;\n\t\t\tkc = k;\n\n\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\tif(ijk>=n_local_size)\n\t\t\t{\n\t\t\t\tprintf(\"Error A on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nx_local,ijk,n_local_size);\n\t\t\t\tfflush(stdout);\n\t\t\t\terror_flag = 1;\n\t\t\t}\n\n\t\t\tvalue = tx*ty*tz;\n\n\t\t\tif(fabs(value)>=3.0)\n\t\t\t{\n\t\t\t\tprintf(\"Error AA on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d tx %e ty %e tz %e value %e.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nx_local,ijk,n_local_size,tx,ty,tz,value);\n\t\t\t\tfflush(stdout);\n\t\t\t\terror_flag = 1;\n\t\t\t}\n\n\t\t\tdata[ijk] += value;\n\n\t\n\t\t\t//do i,j+1,k\n\n\t\t\tjc = j+1;\n\t\t\tkc = k;\n\n\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\tif(ijk>=n_local_size)\n\t\t\t{\n\t\t\t\tprintf(\"Error B on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nx_local,ijk,n_local_size);\n\t\t\t\tfflush(stdout);\n\t\t\t\terror_flag = 1;\n\t\t\t}\n\n\t\t\tvalue = tx*dy*tz;\n\n\t\t\tif(fabs(value)>=3.0)\n\t\t\t{\n\t\t\t\tprintf(\"Error AB on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d tx %e dy %e tz %e value %e.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nx_local,ijk,n_local_size,tx,dy,tz,value);\n\t\t\t\tfflush(stdout);\n\t\t\t\terror_flag = 1;\n\t\t\t}\n\n\t\t\tdata[ijk] += value;\n\n\t\n\t\t\t//do i,j,k+1\n\n\t\t\tjc = j;\n\t\t\tkc = k+1;\n\n\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\tif(ijk>=n_local_size)\n\t\t\t{\n\t\t\t\tprintf(\"Error C on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nx_local,ijk,n_local_size);\n\t\t\t\tfflush(stdout);\n\t\t\t\terror_flag = 1;\n\t\t\t}\n\n\t\t\tvalue = tx*ty*dz;\n\n\t\t\tif(fabs(value)>=3.0)\n\t\t\t{\n\t\t\t\tprintf(\"Error AC on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d tx %e dy %e tz %e value %e.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nx_local,ijk,n_local_size,tx,dy,tz,value);\n\t\t \t\tfflush(stdout);\n\t\t\t\terror_flag = 1;\n\t\t\t}\n\n\t\t\tdata[ijk] += value;\n\n\n\t\t\t//do i,j+1,k+1\n\n\t\t\tjc = j+1;\n\t\t\tkc = k+1;\n\n\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\tif(ijk>=n_local_size)\n\t\t\t{\n\t\t\t\tprintf(\"Error D on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nx_local,ijk,n_local_size);\n\t\t\t\tfflush(stdout);\n\t\t\t\terror_flag = 1;\n\t\t\t}\n\n\t\t\tvalue = tx*dy*dz;\n\n\t\t\tif(fabs(value)>=3.0)\n\t\t\t{\n\t\t\t\tprintf(\"Error AD on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d tx %e dy %e dz %e value %e.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nx_local,ijk,n_local_size,tx,dy,dz,value);\n\t\t\t\tfflush(stdout);\n\t\t\t\terror_flag = 1;\n\t\t\t}\n\n\t\t\tdata[ijk] += value;\n\n\n\t\t\tif(i+1=n_local_size)\n\t\t\t\t{\n\t\t\t\t\tprintf(\"Error E on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nx_local,ijk,n_local_size);\n\t\t\t\t\tfflush(stdout);\n\t\t\t\t\terror_flag = 1;\n\t\t\t\t}\n\n\t\t\t\tvalue = dx*ty*tz;\n\t\t\t\tdata[ijk] += value;\n\n\n\t\t\t\t//do i+1,j+1,k\n\n\t\t\t\tjc = j+1;\n\t\t\t\tkc = k;\n\n\t\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\t\tif(ijk>=n_local_size)\n\t\t\t\t{\n\t\t\t\t\tprintf(\"Error F on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nx_local,ijk,n_local_size);\n\t\t\t\t\tfflush(stdout);\n\t\t\t\t\terror_flag = 1;\n\t\t\t\t}\n\n\t\t\t\tvalue = dx*dy*tz;\n\t\t\t\tdata[ijk] += value;\n\n\t\t\t\t//do i+1,j,k+1\n\n\t\t\t\tjc = j;\n\t\t\t\tkc = k+1;\n\n\t\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\t\tif(ijk>=n_local_size)\n\t\t\t\t{\n\t\t\t\t\tprintf(\"Error G on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nx_local,ijk,n_local_size);\n\t\t\t\t\tfflush(stdout);\n\t\t\t\t\terror_flag = 1;\n\t\t\t\t}\n\n\t\t\t\tvalue = dx*ty*dz;\n\t\t\t\tdata[ijk] += value;\n\n\n\t\t\t\t//do i+1,j+1,k+1\n\n\t\t\t\tjc = j+1;\n\t\t\t\tkc = k+1;\n\n\t\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\t\tif(ijk>=n_local_size)\n\t\t\t\t{\n\t\t\t\t\tprintf(\"Error H on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nx_local,ijk,n_local_size);\n\t\t\t\t\tfflush(stdout);\n\t\t\t\t\terror_flag = 1;\n\t\t\t\t}\n\n\t\t\t\tvalue = dx*dy*dz;\n\t\t\t\tdata[ijk] += value;\n\n\n\t\t\t}else{\n\t\t\t\t//particle is shared between processors\n\t\t\t\t//so add it to the x_u grid\n\n\t\t\t\t//do i+1,j,k\n\n\t\t\t\tic = i+1-nx_local_start-nx_local;\n\t\t\t\tjc = j;\n\t\t\t\tkc = k;\n\n\t\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\t\tvalue = dx*ty*tz;\n\t\t\t\tx_u[ijk] += value;\n\n\n\t\t\t\t//do i+1,j+1,k\n\n\t\t\t\tjc = j+1;\n\t\t\t\tkc = k;\n\n\t\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\t\tvalue = dx*dy*tz;\n\t\t\t\tx_u[ijk] += value;\n\n\n\t\t\t\t//do i+1,j,k+1\n\n\t\t\t\tjc = j;\n\t\t\t\tkc = k+1;\n\n\t\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\t\tvalue = dx*ty*dz;\n\t\t\t\tx_u[ijk] += value;\n\t\n\n\t\t\t\t//do i+1,j+1,k+1\n\n\t\t\t\tjc = j+1;\n\t\t\t\tkc = k+1;\n\n\t\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\t\tvalue = dx*dy*dz;\n\t\t\t\tx_u[ijk] += value;\n\t\t\t}\n\t\n\t\t}else{\n\n\n\t\t\t//OK this particle isn't actually on the slab\n\t\t\t//so we need to place it in one of the grid buffers\n\n\t\t\t//but, if it's i coordinate is nx_local_start-1, then it will still be partially on\n\t\t\t//this slab. So check for that case first\n\n\t\t\twrap_particle(&i,&j,&k,nx,ny,nz,&xp,&yp,&zp);\n\n\n\t\t\t// cell centers\n\n\t\t\txc = ((double) i);\n\t\t\tyc = ((double) j);\n\t\t\tzc = ((double) k);\n\n\t\t\tdx = xp - xc;\n\n\t\t\tdy = yp - yc;\n\n\t\t\tdz = zp - zc;\n\n\t\t\ttx = 1 - dx;\n\n\t\t\tty = 1 - dy;\n\n\t\t\ttz = 1 - dz;\n\n\t\t\tif(i==(nx_local_start-1))\n\t\t\t{\n\t\t\t\t//particle is split between the previous slab and this slab\n\n\t\t\t\t//do i,j,k, which are on the previous slab\n\n\t\t\t\tic = nxb-1;\n\t\t\t\tjc = j;\n\t\t\t\tkc = k;\n\n\t\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\t\tif(ijk>=sbuf_size)\n\t\t\t\t{\n\t\t\t\t\tprintf(\"Error BA on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nxb,ijk,sbuf_size);\n\t\t\t\t\tfflush(stdout);\n\t\t\t\t\terror_flag = 1;\n\t\t\t\t}\n\n\t\t\t\tvalue = tx*ty*tz;\n\t\t\t\tx_l[ijk] += value;\n\n\n\t\t\t\t//do i,j+1,k\n\n\t\t\t\tjc = j+1;\n\t\t\t\tkc = k;\n\n\t\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\t\tif(ijk>=sbuf_size)\n\t\t\t\t{\n\t\t\t\t\tprintf(\"Error BB on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nxb,ijk,sbuf_size);\n\t\t\t\t\tfflush(stdout);\n\t\t\t\t\terror_flag = 1;\n\t\t\t\t}\n\n\t\t\t\tvalue = tx*dy*tz;\n\t\t\t\tx_l[ijk] += value;\n\n\t\t\t\t//do i,j,k+1\n\n\t\t\t\tjc = j;\n\t\t\t\tkc = k+1;\n\n\t\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\t\tif(ijk>=sbuf_size)\n\t\t\t\t{\n\t\t\t\t\tprintf(\"Error BC on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nxb,ijk,sbuf_size);\n\t\t\t\t\tfflush(stdout);\n\t\t\t\t\terror_flag = 1;\n\t\t\t\t}\n\n\t\t\t\tvalue = tx*ty*dz;\n\t\t\t\tx_l[ijk] += value;\n\n\n\t\t\t\t//do i,j+1,k+1\n\n\t\t\t\tjc = j+1;\n\t\t\t\tkc = k+1;\n\n\t\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\t\tif(ijk>=sbuf_size)\n\t\t\t\t{\n\t\t\t\t\tprintf(\"Error BD on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nxb,ijk,sbuf_size);\n\t\t\t\t\tfflush(stdout);\n\t\t\t\t\terror_flag = 1;\n\t\t\t\t}\n\n\t\t\t\tvalue = tx*dy*dz;\n\t\t\t\tx_l[ijk] += value;\n\n\t\t\t\t//do the i+1,j,k values, which are on this slab\n\n\n\t\t\t\tic = 0;\n\t\t\t\tjc = j;\n\t\t\t\tkc = k;\n\n\t\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\t\tif(ijk>=n_local_size)\n\t\t\t\t{\n\t\t\t\t\tprintf(\"Error BE on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nx_local,ijk,n_local_size);\n\t\t\t\t\tfflush(stdout);\n\t\t\t\t\terror_flag = 1;\n\t\t\t\t}\n\n\t\t\t\tvalue = dx*ty*tz;\n\t\t\t\tdata[ijk] += value;\n\n\t\t\t\t//do i+1,j+1,k\n\n\t\t\t\tjc = j+1;\n\t\t\t\tkc = k;\n\n\t\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\t\tif(ijk>=n_local_size)\n\t\t\t\t{\n\t\t\t\t\tprintf(\"Error BF on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nx_local,ijk,n_local_size);\n\t\t\t\t\tfflush(stdout);\n\t\t\t\t\terror_flag = 1;\n\t\t\t\t}\n\n\t\t\t\tvalue = dx*dy*tz;\n\t\t\t\tdata[ijk] += value;\n\n\t\t\t\t//do i+1,j,k+1\n\n\t\t\t\tjc = j;\n\t\t\t\tkc = k+1;\n\n\t\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\t\tif(ijk>=n_local_size)\n\t\t\t\t{\n\t\t\t\t\tprintf(\"Error BG on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nx_local,ijk,n_local_size);\n\t\t\t\t\tfflush(stdout);\n\t\t\t\t\terror_flag = 1;\n\t\t\t\t}\n\n\t\t\t\tvalue = dx*ty*dz;\n\t\t\t\tdata[ijk] += value;\n\n\n\t\t\t\t//do i+1,j+1,k+1\n\n\t\t\t\tjc = j+1;\n\t\t\t\tkc = k+1;\n\n\t\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\t\tif(ijk>=n_local_size)\n\t\t\t\t{\n\t\t\t\t\tprintf(\"Error BH on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nx_local,ijk,n_local_size);\n\t\t\t\t\tfflush(stdout);\n\t\t\t\t\terror_flag = 1;\n\t\t\t\t}\n\n\t\t\t\tvalue = dx*dy*dz;\n\t\t\t\tdata[ijk] += value;\n\n\n\t\t\t}else{\n\t\t\t\t//particle is completely on another slab \n\n\n\t\t\t\t//if the particle is at i>=nx_local_start+nx_local\t\n\t\t\t\t//then it belongs in x_u\n\n\n\t\t\t\tif(i>=(nx_local_start+nx_local))\t\n\t\t\t\t{\n\t\t\t\t\t//particle belongs in x_u\n\n\n\t\t\t\t\t//do i,j,k\n\n\t\t\t\t\tic = i-nx_local-nx_local_start;\n\t\t\t\t\tjc = j;\n\t\t\t\t\tkc = k;\n\n\t\t\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\t\t\tif(ijk>=sbuf_size)\n\t\t\t\t\t{\n\t\t\t\t\t\tprintf(\"Error CA on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d BS %e.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nxb,ijk,sbuf_size,BoxSize);\n\t\t\t\t\t\tprintf(\"nx %d ny %d nz %d local_x %d nx_local_start %d\\n\",nx,ny,nz,nx_local, nx_local_start);\n\t\t\t\t\t\tfflush(stdout);\n\t\t\t\t\t\terror_flag = 1;\n\t\t\t\t\t}\n\n\t\t\t\t\tvalue = tx*ty*tz;\n\t\t\t\t\tx_u[ijk] += value;\n\n\n\t\t\t\t\t//do i,j+1,k\n\n\t\t\t\t\tjc = j+1;\n\t\t\t\t\tkc = k;\n\n\t\t\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\t\t\tif(ijk>=sbuf_size)\n\t\t\t\t\t{\n\t\t\t\t\t\tprintf(\"Error CB on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nxb,ijk,sbuf_size);\n\t\t\t\t\t\tfflush(stdout);\n\t\t\t\t\t\terror_flag = 1;\n\t\t\t\t\t}\n\n\t\t\t\t\tvalue = tx*dy*tz;\n\t\t\t\t\tx_u[ijk] += value;\n\n\t\t\t\t\t//do i,j,k+1\n\n\t\t\t\t\tjc = j;\n\t\t\t\t\tkc = k+1;\n\n\t\t\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\t\t\tif(ijk>=sbuf_size)\n\t\t\t\t\t{\n\t\t\t\t\t\tprintf(\"Error CC on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nxb,ijk,sbuf_size);\n\t\t\t\t\t\tfflush(stdout);\n\t\t\t\t\t\terror_flag = 1;\n\t\t\t\t\t}\n\n\t\t\t\t\tvalue = tx*ty*dz;\n\t\t\t\t\tx_u[ijk] += value;\n\n\n\t\t\t\t\t//do i,j+1,k+1\n\n\t\t\t\t\tjc = j+1;\n\t\t\t\t\tkc = k+1;\n\n\t\t\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\t\t\tif(ijk>=sbuf_size)\n\t\t\t\t\t{\n\t\t\t\t\t\tprintf(\"Error CD on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nxb,ijk,sbuf_size);\n\t\t\t\t\t\tfflush(stdout);\n\t\t\t\t\t\terror_flag = 1;\n\t\t\t\t\t}\n\n\t\t\t\t\tvalue = tx*dy*dz;\n\t\t\t\t\tx_u[ijk] += value;\n\n\n\t\t\t\t\t//do i+1,j,k\n\n\t\t\t\t\tic = i+1-nx_local-nx_local_start;\n\t\t\t\t\tjc = j;\n\t\t\t\t\tkc = k;\n\n\t\t\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\t\t\tif(ijk>=sbuf_size)\n\t\t\t\t\t{\n\t\t\t\t\t\tprintf(\"Error CE on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d i %d j %d k %d lxs %d nx %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nxb,ijk,sbuf_size,i,j,k,nx_local_start,nx_local);\n\t\t\t\t\t\tfflush(stdout);\n\t\t\t\t\t\terror_flag = 1;\n\t\t\t\t\t}\n\n\t\t\t\t\tvalue = dx*ty*tz;\n\t\t\t\t\tx_u[ijk] += value;\n\n\n\t\t\t\t\t//do i,j+1,k\n\n\t\t\t\t\tjc = j+1;\n\t\t\t\t\tkc = k;\n\n\t\t\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\t\t\tif(ijk>=sbuf_size)\n\t\t\t\t\t{\n\t\t\t\t\t\tprintf(\"Error CF on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nxb,ijk,sbuf_size);\n\t\t\t\t\t\tfflush(stdout);\n\t\t\t\t\t\terror_flag = 1;\n\t\t\t\t\t}\n\n\t\t\t\t\tvalue = dx*dy*tz;\n\t\t\t\t\tx_u[ijk] += value;\n\n\t\t\t\t\t//do i,j,k+1\n\n\t\t\t\t\tjc = j;\n\t\t\t\t\tkc = k+1;\n\n\t\t\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\t\t\tif(ijk>=sbuf_size)\n\t\t\t\t\t{\n\t\t\t\t\t\tprintf(\"Error CG on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nxb,ijk,sbuf_size);\n\t\t\t\t\t\tfflush(stdout);\n\t\t\t\t\t\terror_flag = 1;\n\t\t\t\t\t}\n\n\t\t\t\t\tvalue = dx*ty*dz;\n\t\t\t\t\tx_u[ijk] += value;\n\n\n\t\t\t\t\t//do i,j+1,k+1\n\n\t\t\t\t\tjc = j+1;\n\t\t\t\t\tkc = k+1;\n\n\t\t\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\t\t\tif(ijk>=sbuf_size)\n\t\t\t\t\t{\n\t\t\t\t\t\tprintf(\"Error CH on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nxb,ijk,sbuf_size);\n\t\t\t\t\t\tfflush(stdout);\n\t\t\t\t\t\terror_flag = 1;\n\t\t\t\t\t}\n\n\t\t\t\t\tvalue = dx*dy*dz;\n\t\t\t\t\tx_u[ijk] += value;\n\n\n\t\t\t\t}else{\n\t\t\t\t\t//particle belongs in x_l\n\n\n\t\t\t\t\t//do i,j,k\n\n\t\t\t\t\tic = nxb+(i-nx_local_start);\n\t\t\t\t\tjc = j;\n\t\t\t\t\tkc = k;\n\n\t\t\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\t\t\tif(ijk>=sbuf_size)\n\t\t\t\t\t{\n\t\t\t\t\t\tprintf(\"Error DA on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nxb,ijk,sbuf_size);\n\t\t\t\t\t\tfflush(stdout);\n\t\t\t\t\t\terror_flag = 1;\n\t\t\t\t\t}\n\n\t\t\t\t\tvalue = tx*ty*tz;\n\t\t\t\t\tx_l[ijk] += value;\n\n\t\t\t\t\t//do i,j+1,k\n\n\t\t\t\t\tjc = j+1;\n\t\t\t\t\tkc = k;\n\n\t\t\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\t\t\tif(ijk>=sbuf_size)\n\t\t\t\t\t{\n\t\t\t\t\t\tprintf(\"Error DB on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nxb,ijk,sbuf_size);\n\t\t\t\t\t\tfflush(stdout);\n\t\t\t\t\t\terror_flag = 1;\n\t\t\t\t\t}\n\n\t\t\t\t\tvalue = tx*dy*tz;\n\t\t\t\t\tx_l[ijk] += value;\n\n\t\t\t\t\t//do i,j,k+1\n\n\t\t\t\t\tjc = j;\n\t\t\t\t\tkc = k+1;\n\n\t\t\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\t\t\tif(ijk>=sbuf_size)\n\t\t\t\t\t{\n\t\t\t\t\t\tprintf(\"Error DC on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nxb,ijk,sbuf_size);\n\t\t\t\t\t\tfflush(stdout);\n\t\t\t\t\t\terror_flag = 1;\n\t\t\t\t\t}\n\n\t\t\t\t\tvalue = tx*ty*dz;\n\t\t\t\t\tx_l[ijk] += value;\n\n\n\t\t\t\t\t//do i,j+1,k+1\n\n\t\t\t\t\tjc = j+1;\n\t\t\t\t\tkc = k+1;\n\n\t\t\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\t\t\tif(ijk>=sbuf_size)\n\t\t\t\t\t{\n\t\t\t\t\t\tprintf(\"Error DD on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nxb,ijk,sbuf_size);\n\t\t\t\t\t\tfflush(stdout);\n\t\t\t\t\t\terror_flag = 1;\n\t\t\t\t\t}\n\n\t\t\t\t\tvalue = tx*dy*dz;\n\t\t\t\t\tx_l[ijk] += value;\n\n\n\t\t\t\t\t//do i+1,j,k\n\n\t\t\t\t\tic = nxb+1+(i-nx_local_start);\n\t\t\t\t\tjc = j;\n\t\t\t\t\tkc = k;\n\n\t\t\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\t\t\tif(ijk>=sbuf_size)\n\t\t\t\t\t{\n\t\t\t\t\t\tprintf(\"Error DE on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nxb,ijk,sbuf_size);\n\t\t\t\t\t\tfflush(stdout);\n\t\t\t\t\t\terror_flag = 1;\n\t\t\t\t\t}\n\n\t\t\t\t\tvalue = dx*ty*tz;\n\t\t\t\t\tx_l[ijk] += value;\n\n\n\t\t\t\t\t//do i,j+1,k\n\n\t\t\t\t\tjc = j+1;\n\t\t\t\t\tkc = k;\n\n\t\t\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\t\t\tif(ijk>=sbuf_size)\n\t\t\t\t\t{\n\t\t\t\t\t\tprintf(\"Error DF on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nxb,ijk,sbuf_size);\n\t\t\t\t\t\tfflush(stdout);\n\t\t\t\t\t\terror_flag = 1;\n\t\t\t\t\t}\n\n\t\t\t\t\tvalue = dx*dy*tz;\n\t\t\t\t\tx_l[ijk] += value;\n\n\t\t\t\t\t//do i,j,k+1\n\n\t\t\t\t\tjc = j;\n\t\t\t\t\tkc = k+1;\n\n\t\t\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\t\t\tif(ijk>=sbuf_size)\n\t\t\t\t\t{\n\t\t\t\t\t\tprintf(\"Error DG on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nxb,ijk,sbuf_size);\n\t\t\t\t\t\tfflush(stdout);\n\t\t\t\t\t\terror_flag = 1;\n\t\t\t\t\t}\n\n\t\t\t\t\tvalue = dx*ty*dz;\n\t\t\t\t\tx_l[ijk] += value;\n\n\n\t\t\t\t\t//do i,j+1,k+1\n\n\t\t\t\t\tjc = j+1;\n\t\t\t\t\tkc = k+1;\n\n\t\t\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\t\t\tif(ijk>=sbuf_size)\n\t\t\t\t\t{\n\t\t\t\t\t\tprintf(\"Error DH on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nxb,ijk,sbuf_size);\n\t\t\t\t\t\tfflush(stdout);\n\t\t\t\t\t\terror_flag = 1;\n\t\t\t\t\t}\n\n\t\t\t\t\tvalue = dx*dy*dz;\n\t\t\t\t\tx_l[ijk] += value;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\tMPI_Isend(x_u, nxb*ny*(2*(nz/2+1))*sizeof(double), MPI_BYTE, u_dest, myid, world, &requests[0]);\n\n\tMPI_Irecv(x_ur, nxb*ny*(2*(nz/2+1))*sizeof(double), MPI_BYTE, u_source, u_source, world, &requests[1]);\n\n\tMPI_Isend(x_l, nxb*ny*(2*(nz/2+1))*sizeof(double), MPI_BYTE, l_dest, myid, world, &requests[2]);\n\n\tMPI_Irecv(x_lr, nxb*ny*(2*(nz/2+1))*sizeof(double), MPI_BYTE, l_source, l_source, world, &requests[3]);\n\n\tMPI_Waitall(4, &requests[0], &statuses[0]);\n\n\tMPI_Barrier(world);\n\n\tif(myid==0)\n\t{\n\t\tprintf(\"Done with grid overlap buffer exchange.\\n\");\n\t\tfflush(stdout);\n\t}\n\n\n\t//add exchanged particles to grid\n\n\t//do x_ur\n\n\tfor(i=0;i=numprocs)\n\t\tu_dest-=numprocs;\n\tif(u_source<0)\n\t\tu_source+=numprocs;\n\n\tif(l_dest<0)\n\t\tl_dest+=numprocs;\n\tif(l_source>=numprocs)\n\t\tl_source-=numprocs;\n\n\t//we need to allocate the x-direction grid buffers\n\n\tif(myid==0)\n\t{\n\t\tprintf(\"\\n\");\n\t\tfflush(stdout);\n\t}\n\n\t//allocate interpolated values\n\n\tsprintf(variable_name,\"answer\");\n\tanswer = allocate_double_array(npart, variable_name, myid, numprocs, world, 0);\n\tsprintf(variable_name,\"total_answer\");\n\ttotal_answer = allocate_double_array(npart, variable_name, myid, numprocs, world, 0);\n\n\tsprintf(variable_name,\"count\");\n\tcount = allocate_double_array(npart, variable_name, myid, numprocs, world, 0);\n\tsprintf(variable_name,\"total_count\");\n\ttotal_count = allocate_double_array(npart, variable_name, myid, numprocs, world, 0);\n\n\n\t//initialize interpolated values\n\tfor(i=0;i=nx_local_start)&&(i<(nx_local_start+nx_local)) )\n\t\t\tyes_flag = 1;\n\n\n#ifdef SIGMA_CORRECTION\n\n\t\tsigma_correction = 0;\n#endif\n\n\t\tif(yes_flag)\n\t\t{\n\t\t\tcount[ip]+=1.0;\n\n\t\t\t// cell centers\n\n\t\t\txc = ((double) i);\n\t\t\tyc = ((double) j);\n\t\t\tzc = ((double) k);\n\n\t\t\tdx = xp - xc;\n\n\t\t\tdy = yp - yc;\n\n\t\t\tdz = zp - zc;\n\n\t\t\ttx = 1 - dx;\n\n\t\t\tty = 1 - dy;\n\n\t\t\ttz = 1 - dz;\n\n\t\n\t\t\t//first do cell containing particle\n\n\t\t\tic = i-nx_local_start;\n\t\t\tjc = j;\n\t\t\tkc = k;\n\n\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\tif(ijk>=n_local_size)\n\t\t\t{\n\t\t\t\tprintf(\"Error A on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nx_local,ijk,n_local_size);\n\t\t\t\tfflush(stdout);\n\t\t\t\terror_flag = 1;\n\t\t\t}\n\n#ifndef SIGMA_CORRECTION\n\t\t\tvalue = tx*ty*tz*data[ijk];\n#else //SIGMA_CORRECTION\n\n\t\t\tif(condition[ijk]>=threshold)\n\t\t\t{\t\t\n\t\t\t\tvalue = 0;\n\t\t\t}else{\n\t\t\t\tsigma_correction += tx*ty*tz;\n\t\t\t\tvalue = tx*ty*tz*data[ijk];\n\t\t\t}\n\n#endif //SIGMA_CORRECTION\n\n\t\t\tanswer[ip] += value;\n\n\n\n\n\t\n\t\t\t//do i,j+1,k\n\n\t\t\tjc = j+1;\n\t\t\tkc = k;\n\n\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\tif(ijk>=n_local_size)\n\t\t\t{\n\t\t\t\tprintf(\"Error B on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nx_local,ijk,n_local_size);\n\t\t\t\tfflush(stdout);\n\t\t\t\terror_flag = 1;\n\t\t\t}\n\n#ifndef SIGMA_CORRECTION\n\t\t\tvalue = tx*dy*tz*data[ijk];\n#else //SIGMA_CORRECTION\n\n\t\t\tif(condition[ijk]>=threshold)\n\t\t\t{\t\t\n\t\t\t\tvalue = 0;\n\t\t\t}else{\n\t\t\t\tsigma_correction += tx*dy*tz;\n\t\t\t\tvalue = tx*dy*tz*data[ijk];\n\t\t\t}\n\n#endif //SIGMA_CORRECTION\n\n\t\t\tanswer[ip] += value;\n\n\n\n\n\t\n\t\t\t//do i,j,k+1\n\n\t\t\tjc = j;\n\t\t\tkc = k+1;\n\n\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\tif(ijk>=n_local_size)\n\t\t\t{\n\t\t\t\tprintf(\"Error C on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nx_local,ijk,n_local_size);\n\t\t\t\tfflush(stdout);\n\t\t\t\terror_flag = 1;\n\t\t\t}\n\n#ifndef SIGMA_CORRECTION\n\t\t\tvalue = tx*ty*dz*data[ijk];\n#else //SIGMA_CORRECTION\n\n\t\t\tif(condition[ijk]>=threshold)\n\t\t\t{\t\t\n\t\t\t\tvalue = 0;\n\t\t\t}else{\n\t\t\t\tsigma_correction += tx*ty*dz;\n\t\t\t\tvalue = tx*ty*dz*data[ijk];\n\t\t\t}\n\n#endif //SIGMA_CORRECTION\n\n\t\t\tanswer[ip] += value;\n\n\n\n\n\n\t\t\t//do i,j+1,k+1\n\n\t\t\tjc = j+1;\n\t\t\tkc = k+1;\n\n\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\tif(ijk>=n_local_size)\n\t\t\t{\n\t\t\t\tprintf(\"Error D on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nx_local,ijk,n_local_size);\n\t\t\t\tfflush(stdout);\n\t\t\t\terror_flag = 1;\n\t\t\t}\n\n#ifndef SIGMA_CORRECTION\n\t\t\tvalue = tx*dy*dz*data[ijk];\n#else //SIGMA_CORRECTION\n\n\t\t\tif(condition[ijk]>=threshold)\n\t\t\t{\t\t\n\t\t\t\tvalue = 0;\n\t\t\t}else{\n\t\t\t\tsigma_correction += tx*dy*dz;\n\t\t\t\tvalue = tx*dy*dz*data[ijk];\n\t\t\t}\n\n#endif //SIGMA_CORRECTION\n\n\t\t\tanswer[ip] += value;\n\t\t}\n\n\n\n\t\t//check the i+1 values in the CIC interpolation\n\n\t\tyes_flag = 0;\n\t\tif( ((i+1)>=nx_local_start)&&((i+1)<(nx_local_start+nx_local)) )\n\t\t\tyes_flag = 1;\n\t\tif((i+1==nx)&&(nx_local_start==0))\n\t\t\tyes_flag = 1;\n\t\tif((i+1==nx)&&(nx_local_start!=0))\n\t\t\tyes_flag = 0;\n\n\t\tif(yes_flag)\n\t\t{\n\t\t\tcount[ip]+=1.0;\n\n\t\t\tif((i+1)==nx)\n\t\t\t{\n\t\t\t\txp -= ((double) nx);\n\t\t\t\ti = -1;\n\t\t\t}\n\n\n\t\t\t// cell centers\n\n\t\t\txc = ((double) i);\n\t\t\tyc = ((double) j);\n\t\t\tzc = ((double) k);\n\n\t\t\tdx = xp - xc;\n\n\t\t\tdy = yp - yc;\n\n\t\t\tdz = zp - zc;\n\n\t\t\ttx = 1 - dx;\n\n\t\t\tty = 1 - dy;\n\n\t\t\ttz = 1 - dz;\n\n\t\n\t\t\t//first do cell containing particle\n\n\t\t\tic = (i+1)-nx_local_start;\n\t\t\tjc = j;\n\t\t\tkc = k;\n\n\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\tif(ijk>=n_local_size)\n\t\t\t{\n\t\t\t\tprintf(\"Error BA on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nx_local,ijk,n_local_size);\n\t\t\t\tfflush(stdout);\n\t\t\t\terror_flag = 1;\n\t\t\t}\n\n#ifndef SIGMA_CORRECTION\n\t\t\tvalue = dx*ty*tz*data[ijk];\n#else //SIGMA_CORRECTION\n\n\t\t\tif(condition[ijk]>=threshold)\n\t\t\t{\t\t\n\t\t\t\tvalue = 0;\n\t\t\t}else{\n\t\t\t\tsigma_correction += dx*ty*tz;\n\t\t\t\tvalue = dx*ty*tz*data[ijk];\n\t\t\t}\n\n#endif //SIGMA_CORRECTION\n\n\n\t\t\tanswer[ip] += value;\n\n\n\n\n\t\n\t\t\t//do i,j+1,k\n\n\t\t\tjc = j+1;\n\t\t\tkc = k;\n\n\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\tif(ijk>=n_local_size)\n\t\t\t{\n\t\t\t\tprintf(\"Error BB on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nx_local,ijk,n_local_size);\n\t\t\t\tfflush(stdout);\n\t\t\t\terror_flag = 1;\n\t\t\t}\n\n#ifndef SIGMA_CORRECTION\n\t\t\tvalue = dx*dy*tz*data[ijk];\n#else //SIGMA_CORRECTION\n\n\t\t\tif(condition[ijk]>=threshold)\n\t\t\t{\t\t\n\t\t\t\tvalue = 0;\n\t\t\t}else{\n\t\t\t\tsigma_correction += dx*dy*tz;\n\t\t\t\tvalue = dx*dy*tz*data[ijk];\n\t\t\t}\n\n#endif //SIGMA_CORRECTION\n\n\n\t\t\tanswer[ip] += value;\n\n\n\n\n\t\n\t\t\t//do i,j,k+1\n\n\t\t\tjc = j;\n\t\t\tkc = k+1;\n\n\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\tif(ijk>=n_local_size)\n\t\t\t{\n\t\t\t\tprintf(\"Error BC on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nx_local,ijk,n_local_size);\n\t\t\t\tfflush(stdout);\n\t\t\t\terror_flag = 1;\n\t\t\t}\n\n#ifndef SIGMA_CORRECTION\n\t\t\tvalue = dx*ty*dz*data[ijk];\n#else //SIGMA_CORRECTION\n\n\t\t\tif(condition[ijk]>=threshold)\n\t\t\t{\t\t\n\t\t\t\tvalue = 0;\n\t\t\t}else{\n\t\t\t\tsigma_correction += dx*ty*dz;\n\t\t\t\tvalue = dx*ty*dz*data[ijk];\n\t\t\t}\n\n#endif //SIGMA_CORRECTION\n\n\n\t\t\tanswer[ip] += value;\n\n\n\n\n\n\t\t\t//do i,j+1,k+1\n\n\t\t\tjc = j+1;\n\t\t\tkc = k+1;\n\n\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\tif(ijk>=n_local_size)\n\t\t\t{\n\t\t\t\tprintf(\"Error BD on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nx_local,ijk,n_local_size);\n\t\t\t\tfflush(stdout);\n\t\t\t\terror_flag = 1;\n\t\t\t}\n\n#ifndef SIGMA_CORRECTION\n\t\t\tvalue = dx*dy*dz*data[ijk];\n#else //SIGMA_CORRECTION\n\n\t\t\tif(condition[ijk]>=threshold)\n\t\t\t{\t\t\n\t\t\t\tvalue = 0;\n\t\t\t}else{\n\t\t\t\tsigma_correction += dx*dy*dz;\n\t\t\t\tvalue = dx*dy*dz*data[ijk];\n\t\t\t}\n\n#endif //SIGMA_CORRECTION\n\n\n\t\t\tanswer[ip] += value;\n\t\t}\n\n#ifdef\tSIGMA_CORRECTION\n\t\tif(sigma_correction!=0.0)\n\t\t{\n\t\t\tanswer[ip]/=(sigma_correction);\n\t\t}else{\n\t\t\tanswer[ip]=0.0;\n\t\t}\n#endif //SIGMA_CORRECTION\n\n\t}//end loop over npart\n\n\n\t//Check for errors\n\n\tAllCheckError(error_flag,myid,numprocs,world);\n\n\n\t//now sum up all contributions to each particle\n\n\tMPI_Allreduce(answer,total_answer,npart,MPI_DOUBLE,MPI_SUM,world);\n\n\n\t//now sum up all contributions to each particle\n\n\tMPI_Allreduce(count,total_count,npart,MPI_DOUBLE,MPI_SUM,world);\n\n\tfor(int ip=0;ip=3)\n\t\t\tif(myid==0)\n\t\t\t{\n\t\t\t\tprintf(\"Error XX on proc %d in x direction ip %d count %e x %e y %e z %e i %d j %d k %d.\\n\",myid,ip,total_count[ip],xp,yp,zp,i,j,k);\n\t\t\t\tfflush(stdout);\n\t\t\t\t\n\t\t\t}\n\t}\n\n\n\n\t//free processor slab data\n\n\tfree(answer);\n\tfree(total_count);\n\tfree(count);\n\n\treturn total_answer;\n}\n#ifdef PARTICLE_FLOAT\ndouble *interpolate_grid_data_cloud_in_cell(int npart, float *pos, double *data, int nx_local_start, int nx_local, int n_local_size, int nx, int ny, int nz, int npart_total, double BoxSize, int myid, int numprocs, MPI_Comm world)\n#else\ndouble *interpolate_grid_data_cloud_in_cell(int npart, double *pos, double *data, int nx_local_start, int nx_local, int n_local_size, int nx, int ny, int nz, int npart_total, double BoxSize, int myid, int numprocs, MPI_Comm world)\n#endif\n{\n\n\n\t//grid particle data using the cloud in cell method\n\n\t//need to adjust CIC to deal with different grid sizes\n\n\tint error_flag = 0;\n\tint i,j,k;\n\n\tint ic, jc, kc;\n\n\tint ijk;\n\n\tdouble xc, yc, zc;\n\n\tdouble xp, yp, zp;\n\n\tdouble dx;\n\tdouble dy;\n\tdouble dz;\n\n\tdouble tx;\n\tdouble ty;\n\tdouble tz;\n\n\tdouble value;\n\n\tdouble *answer; //array containing interpolated values\n\tdouble *total_answer; //array containing interpolated values\n\n\tint u_dest = myid+1;\n\tint u_source = myid-1;\n\tint l_dest = myid-1;\n\tint l_source = myid+1;\n\n\tint yes_flag;\n\n\n\t//this buffer allows for imperfect CIC\n\t//assignments for varying grid cells\n\n\tint nxb = 10;\n\tint sbuf_size = nxb*ny*(2*(nz/2+1));\n\n\tchar variable_name[200];\n\n\tMPI_Request requests[4];\n\n\tMPI_Status statuses[4];\n\n\t//wrap destinations and sources\n\n\tif(u_dest>=numprocs)\n\t\tu_dest-=numprocs;\n\tif(u_source<0)\n\t\tu_source+=numprocs;\n\n\tif(l_dest<0)\n\t\tl_dest+=numprocs;\n\tif(l_source>=numprocs)\n\t\tl_source-=numprocs;\n\n\t//we need to allocate the x-direction grid buffers\n\n\tif(myid==0)\n\t{\n\t\tprintf(\"\\n\");\n\t\tfflush(stdout);\n\t}\n\n\t//allocate interpolated values\n\n\tsprintf(variable_name,\"answer\");\n\tanswer = allocate_double_array(npart, variable_name, myid, numprocs, world, 0);\n\tsprintf(variable_name,\"total_answer\");\n\ttotal_answer = allocate_double_array(npart, variable_name, myid, numprocs, world, 0);\n\n\n\n\t//initialize interpolated values\n\tfor(i=0;i=nx_local_start)&&(i<(nx_local_start+nx_local)) )\n\t\t\tyes_flag = 1;\n\n\n\t\tif(yes_flag)\n\t\t{\n\t\t\t// cell centers\n\n\t\t\txc = ((double) i);\n\t\t\tyc = ((double) j);\n\t\t\tzc = ((double) k);\n\n\t\t\tdx = xp - xc;\n\n\t\t\tdy = yp - yc;\n\n\t\t\tdz = zp - zc;\n\n\t\t\ttx = 1 - dx;\n\n\t\t\tty = 1 - dy;\n\n\t\t\ttz = 1 - dz;\n\n\t\n\t\t\t//first do cell containing particle\n\n\t\t\tic = i-nx_local_start;\n\t\t\tjc = j;\n\t\t\tkc = k;\n\n\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\tif(ijk>=n_local_size)\n\t\t\t{\n\t\t\t\tprintf(\"Error A on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nx_local,ijk,n_local_size);\n\t\t\t\tfflush(stdout);\n\t\t\t\terror_flag = 1;\n\t\t\t}\n\n\t\t\tvalue = tx*ty*tz*data[ijk];\n\t\t\tanswer[ip] += value;\n\n\n\n\n\t\n\t\t\t//do i,j+1,k\n\n\t\t\tjc = j+1;\n\t\t\tkc = k;\n\n\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\tif(ijk>=n_local_size)\n\t\t\t{\n\t\t\t\tprintf(\"Error B on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nx_local,ijk,n_local_size);\n\t\t\t\tfflush(stdout);\n\t\t\t\terror_flag = 1;\n\t\t\t}\n\n\t\t\tvalue = tx*dy*tz*data[ijk];\n\t\t\tanswer[ip] += value;\n\n\n\n\n\t\n\t\t\t//do i,j,k+1\n\n\t\t\tjc = j;\n\t\t\tkc = k+1;\n\n\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\tif(ijk>=n_local_size)\n\t\t\t{\n\t\t\t\tprintf(\"Error C on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nx_local,ijk,n_local_size);\n\t\t\t\tfflush(stdout);\n\t\t\t\terror_flag = 1;\n\t\t\t}\n\n\t\t\tvalue = tx*ty*dz*data[ijk];\n\t\t\tanswer[ip] += value;\n\n\n\n\n\n\t\t\t//do i,j+1,k+1\n\n\t\t\tjc = j+1;\n\t\t\tkc = k+1;\n\n\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\tif(ijk>=n_local_size)\n\t\t\t{\n\t\t\t\tprintf(\"Error D on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nx_local,ijk,n_local_size);\n\t\t\t\tfflush(stdout);\n\t\t\t\terror_flag = 1;\n\t\t\t}\n\n\t\t\tvalue = tx*dy*dz*data[ijk];\n\t\t\tanswer[ip] += value;\n\t\t}\n\n\n\n\t\t//check the i+1 values in the CIC interpolation\n\n\t\tyes_flag = 0;\n\t\tif( ((i+1)>=nx_local_start)&&((i+1)<(nx_local_start+nx_local)) )\n\t\t\tyes_flag = 1;\n\t\tif((i+1==nx)&&(nx_local_start==0))\n\t\t\tyes_flag = 1;\n\t\tif((i+1==nx)&&(nx_local_start!=0))\n\t\t\tyes_flag = 0;\n\n\t\tif(yes_flag)\n\t\t{\n\t\t\tif((i+1)==nx)\n\t\t\t{\n\t\t\t\txp -= ((double) nx);\n\t\t\t\ti = -1;\n\t\t\t}\n\n\t\t\t// cell centers\n\n\t\t\txc = ((double) i);\n\t\t\tyc = ((double) j);\n\t\t\tzc = ((double) k);\n\n\t\t\tdx = xp - xc;\n\n\t\t\tdy = yp - yc;\n\n\t\t\tdz = zp - zc;\n\n\t\t\ttx = 1 - dx;\n\n\t\t\tty = 1 - dy;\n\n\t\t\ttz = 1 - dz;\n\n\t\n\t\t\t//first do cell containing particle\n\n\t\t\tic = (i+1)-nx_local_start;\n\t\t\tjc = j;\n\t\t\tkc = k;\n\n\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\tif(ijk>=n_local_size)\n\t\t\t{\n\t\t\t\tprintf(\"Error BA on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nx_local,ijk,n_local_size);\n\t\t\t\tfflush(stdout);\n\t\t\t\terror_flag = 1;\n\t\t\t}\n\n\t\t\tvalue = dx*ty*tz*data[ijk];\n\t\t\tanswer[ip] += value;\n\n\n\n\n\t\n\t\t\t//do i,j+1,k\n\n\t\t\tjc = j+1;\n\t\t\tkc = k;\n\n\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\tif(ijk>=n_local_size)\n\t\t\t{\n\t\t\t\tprintf(\"Error BB on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nx_local,ijk,n_local_size);\n\t\t\t\tfflush(stdout);\n\t\t\t\terror_flag = 1;\n\t\t\t}\n\n\t\t\tvalue = dx*dy*tz*data[ijk];\n\t\t\tanswer[ip] += value;\n\n\n\n\n\t\n\t\t\t//do i,j,k+1\n\n\t\t\tjc = j;\n\t\t\tkc = k+1;\n\n\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\tif(ijk>=n_local_size)\n\t\t\t{\n\t\t\t\tprintf(\"Error BC on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nx_local,ijk,n_local_size);\n\t\t\t\tfflush(stdout);\n\t\t\t\terror_flag = 1;\n\t\t\t}\n\n\t\t\tvalue = dx*ty*dz*data[ijk];\n\t\t\tanswer[ip] += value;\n\n\n\n\n\n\t\t\t//do i,j+1,k+1\n\n\t\t\tjc = j+1;\n\t\t\tkc = k+1;\n\n\t\t\twrap_indices(&ic,&jc,&kc,nx,ny,nz);\n\n\t\t\tijk = (ic*ny + jc) * (2*(nz/2+1)) + kc;\n\n\t\t\tif(ijk>=n_local_size)\n\t\t\t{\n\t\t\t\tprintf(\"Error BD on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d ijk %d tls %d.\\n\",myid,ip,xp,yp,zp,ic,jc,kc,nx_local,ijk,n_local_size);\n\t\t\t\tfflush(stdout);\n\t\t\t\terror_flag = 1;\n\t\t\t}\n\n\t\t\tvalue = dx*dy*dz*data[ijk];\n\t\t\tanswer[ip] += value;\n\t\t}\n\n\t}//end loop over npart\n\n\n\t//Check for errors\n\n\tAllCheckError(error_flag,myid,numprocs,world);\n\n\n\t//now sum up all contributions to each particle\n\n\tMPI_Allreduce(answer,total_answer,npart,MPI_DOUBLE,MPI_SUM,world);\n\n\n\t//free processor slab data\n\n\tfree(answer);\n\n\treturn total_answer;\n}\nvoid grid_particle_data_nearest_grid(int npart, float *pos, double *data, int nx_local_start, int nx_local, int n_local_size, int nx, int ny, int nz, int npart_total, double BoxSize, int myid, int numprocs, MPI_Comm world)\n{\n\n\n\t//grid particle data using nearest grid point method\n\n\tint error_flag = 0;\n\tint i,j,k;\n\tint ijk;\n\n\tdouble x, y, z;\n\n\t//first, initialize the grid to zero\n\tfor(i=0;i=nx_local))\n\t\t{\n\t\t\tprintf(\"Error on proc %d in x direction ip %d x %e y %e z %e i %d j %d k %d nxl %d.\\n\",myid,ip,x,y,z,i,j,k,nx_local);\n\t\t\tfflush(stdout);\n\t\t\terror_flag = 1;\n\t\t}\n\n\t\tijk = (i*ny + j) * (2*(nz/2+1)) + k;\n\t\tif(!error_flag)\n\t\t\tif(ijk>n_local_size)\n\t\t\t{\n\t\t\t\tprintf(\"Error on proc %d ip %d x %e y %e z %e i %d j %d k %d nxl %d.\\n\",myid,ip,x,y,z,i,j,k,nx_local);\n\t\t\t\tfflush(stdout);\n\t\t\t\terror_flag = 1;\n\t\t\t}else{\n\t\t\t\tdata[ijk] += 1.0;\n\t\t\t}\n\t}\n\n\t//Check for errors\n\n\tAllCheckError(error_flag,myid,numprocs,world);\n\n\t//done\n}\nvoid grid_to_overdensity(double *data, int total_npart, int nx, int ny, int nz, int nx_local_start, int nx_local)\n{\n\tdouble rho_mean = ((double) total_npart)/( ((double) nx) * ((double) ny) * ((double) nz) );\n\n\tfor(int i=0;i=ny)\n \t\t*jj-=ny;\n\t}\n if(*kk<0)\n\t{\n *kk+=nz;\n\t}else{\n \tif(*kk>=nz)\n\t\t{\n \t*kk-=nz;\n \t\t//printf(\"wi ii %d jj %d kk %d nx %d ny %d nz %d\\n\",*ii,*jj,*kk,nx,ny,nz);\n\t\t\t//fflush(stdout);\n\t\t}\n\t}\n}\n\nvoid wrap_position(int *ii, int *jj, int *kk, int nx, int ny, int nz, double *xp, double *yp, double *zp)\n{\n if(*ii<0)\n\t{\n *ii+=nx;\n\t\t*xp+=((double) nx);\n\t}else{\n \tif(*ii>=nx)\n\t\t{\n \t\t*ii-=nx;\n\t\t\t*xp-=((double) nx);\n\t\t}\n\t}\n if(*jj<0)\n\t{\n *jj+=ny;\n\t\t*yp+=((double) ny);\n\t}else{\n \tif(*jj>=ny)\n\t\t{\n \t\t*jj-=ny;\n\t\t\t*yp-=((double) ny);\n\t\t}\n\t}\n if(*kk<0)\n\t{\n *kk+=nz;\n\t\t*zp+=((double) nz);\n\t}else{\n \tif(*kk>=nz)\n\t\t{\n \t*kk-=nz;\n\t\t\t*zp-=((double) nz);\n \t\t//printf(\"wi ii %d jj %d kk %d nx %d ny %d nz %d\\n\",*ii,*jj,*kk,nx,ny,nz);\n\t\t\t//fflush(stdout);\n\t\t}\n\t}\n}\nvoid wrap_particle(int *ii, int *jj, int *kk, int nx, int ny, int nz, double *xp, double *yp, double *zp)\n{\n //printf(\"wi ii %d jj %d kk %d N %d\\n\",*ii,*jj,*kk,N);\n if(*jj<0)\n\t{\n *jj+=ny;\n\t\t*yp+=((double) ny);\n\t}else{\n \tif(*jj>=ny)\n\t\t{\n \t\t*jj-=ny;\n\t\t\t*yp-=((double) ny);\n\t\t}\n\t}\n if(*kk<0)\n\t{\n *kk+=nz;\n\t\t*zp+=((double) nz);\n\t}else{\n \tif(*kk>=nz)\n\t\t{\n \t*kk-=nz;\n\t\t\t*zp-=((double) nz);\n \t\t//printf(\"wi ii %d jj %d kk %d nx %d ny %d nz %d\\n\",*ii,*jj,*kk,nx,ny,nz);\n\t\t\t//fflush(stdout);\n\t\t}\n\t}\n}\n\nfloat *get_particle_data(char *fname_particle_data, int *npart, int *total_npart, int myid, int numprocs, MPI_Comm world)\n{\n\tFILE *fp_particle_data;\n\n\tfloat *pos;\n\n\tint error_flag = 0;\n\tint flag_tot = 0;\n\n\t//printf(\"myid %d particle data %s\\n\",myid,fname_particle_data);\n\t//fflush(stdout);\n\n\tif(!(fp_particle_data = fopen(fname_particle_data,\"r\")))\n\t{\n\t\tprintf(\"Error opening %s on process %d.\\n\",fname_particle_data,myid);\n\t\tfflush(stdout);\n\t\terror_flag=1;\n\t}\n\tAllCheckError(error_flag,myid,numprocs,world);\n\n\tfread(npart,sizeof(int),1,fp_particle_data);\n\n\tif(!(pos = (float *) malloc(3*(*npart)*sizeof(float))))\n\t{\n\t\tprintf(\"Error allocating pos on process %d.\\n\",myid);\n\t\terror_flag = 1;\n\t}\n\n\n\t//check for errors\n\n\tAllCheckError(error_flag,myid,numprocs,world);\n\n\tfread(pos,sizeof(float),3*(*npart),fp_particle_data);\n\t\n\tfclose(fp_particle_data);\n\n\tMPI_Allreduce(npart,total_npart,1,MPI_INT,MPI_SUM,world);\n\n\treturn pos;\n}\n\nvoid AllCheckError(int error_flag, int myid, int numprocs, MPI_Comm world)\n{\n\tint total_error = 0;\n\n\tMPI_Allreduce(&error_flag,&total_error,1,MPI_INT,MPI_SUM,world);\n\n\tif(total_error)\n\t{\n\t\tif(myid==0)\n\t\t{\n\t\t\tprintf(\"Aborting...\\n\");\n\t\t\tfflush(stdout);\n\t\t}\n\t\tMPI_Abort(world,total_error);\n\t\texit(-1);\n\t}\n}\n\nvoid check_window_function(char *window_function_fname, double *window_data, fftw_complex *cwindow_data, double *work, double BoxSize, double R, int nx, int ny, int nz, int ixmin, int ixmax, int iymin, int iymax, int izmin, int izmax, int nx_local_start, int nx_local, int n_local_size, int local_ny_after_transpose, int myid, int numprocs, MPI_Comm world)\n{\n\n\tFFTW_Grid_Info grid_info;\n\n\tint x, y, z;\n\n\t//make the units easy\n\n\tBoxSize = 120.0;\t\n\tR = 10.0;\n\n\t//initialize window function\n\tfor(x=0;xnx/2)\n\t{\n\t\tdx = (double) (x-nx);\n\t}else{\n\t\tdx = (double) x;\n\t}\n\n\tif(y>ny/2)\n\t{\n\t\tdy = (double) (y-ny);\n\t}else{\n\t\tdy = (double) y;\n\t}\n\n\tif(z>nz/2)\n\t{\n\t\tdz = (double) (z-nz);\n\t}else{\n\t\tdz = (double) z;\n\t}\n\n\tdx*=BoxSize/((double) nx);\n\tdy*=BoxSize/((double) ny);\n\tdz*=BoxSize/((double) nz);\n\n\n\tR = sqrt( dx*dx + dy*dy + dz*dz);\n\n\tif(R<=Rw)\n\t{\n#ifdef TEST_ONE_DIMENSION\n\t\tW = 1.0/(2.*Rw);\n#else //TEST_ONE_DIMENSION\n\t\tW = 1.0/(4.*M_PI*Rw*Rw*Rw/3.0);\n#endif //TEST_ONE_DIMENSION\n\t}else{\n\t\tW = 0.0;\n\t}\t\n\n\treturn W;\n}\ndouble gaussian_window(double Rw, double BoxSize, int x, int y, int z, int nx, int ny, int nz)\n{\n\tdouble R;\n\tdouble dx;\n\tdouble dy;\n\tdouble dz;\n\n\tdouble W;\n\n\tif(x>nx/2)\n\t{\n\t\tdx = (double) (x-nx);\n\t}else{\n\t\tdx = (double) x;\n\t}\n\n\tif(y>ny/2)\n\t{\n\t\tdy = (double) (y-ny);\n\t}else{\n\t\tdy = (double) y;\n\t}\n\n\tif(z>nz/2)\n\t{\n\t\tdz = (double) (z-nz);\n\t}else{\n\t\tdz = (double) z;\n\t}\n\n\tdx*=BoxSize/((double) nx );\n\tdy*=BoxSize/((double) ny );\n\tdz*=BoxSize/((double) nz );\n\n\n\tR = sqrt( dx*dx + dy*dy + dz*dz);\n\n#ifdef TEST_ONE_DIMENSION\n\tW = exp(-R*R/(2*Rw*Rw))/sqrt(2*C.pi*Rw*Rw);\n#else //TEST_ONE_DIMENSION \n\tW = exp(-R*R/(2*Rw*Rw))/pow(2*M_PI*Rw*Rw,1.5);\n#endif //TEST_ONE_DIMENSION \n\n\n\treturn W;\n}\n\n\ndouble vector_magnitude(double *x, int ndim)\n{\n\tdouble dp = 0.;\n\tfor(int i=0;i\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"cosmocalc.h\"\n\nstatic double gaussiannorm_linear_powspec_exact_lnk_integ_funct(double lnk, void *p);\nstatic double onederiv_gaussiannorm_linear_powspec_exact_lnk_integ_funct(double lnk, void *p);\nstatic double twoderiv_gaussiannorm_linear_powspec_exact_lnk_integ_funct(double lnk, void *p);\nstatic double nonlinear_gaussnorm_scale_funct(double gaussR, void *p);\n\nstatic double gaussiannorm_linear_powspec_exact_lnk_integ_funct(double lnk, void *p)\n{\n double gaussRad = (*(double*)p);\n double k = exp(lnk);\n return linear_powspec(k,1.0)*k*k*k/2.0/M_PI/M_PI*exp(-1.0*k*k*gaussRad*gaussRad);\n}\n\nstatic double onederiv_gaussiannorm_linear_powspec_exact_lnk_integ_funct(double lnk, void *p)\n{\n double gaussRad = (*(double*)p);\n double k = exp(lnk);\n return linear_powspec(k,1.0)*k*k*k/2.0/M_PI/M_PI*exp(-1.0*k*k*gaussRad*gaussRad)*(-1.0*k*k*2.0*gaussRad);\n}\n\nstatic double twoderiv_gaussiannorm_linear_powspec_exact_lnk_integ_funct(double lnk, void *p)\n{\n double gaussRad = (*(double*)p);\n double k = exp(lnk);\n return linear_powspec(k,1.0)*k*k*k/2.0/M_PI/M_PI*exp(-1.0*k*k*gaussRad*gaussRad)*(-2.0*k*k + 4.0*k*k*k*k*gaussRad*gaussRad);\n}\n\n//uses Takahashi et al. (2012) arXiv:1208.2701 unless macro below is set to use true Smith+03\n//#define SMITH03\n\ndouble nonlinear_powspec(double k, double a) \n{\n static int initFlag = 1;\n static int currCosmoNum;\n static gsl_spline *spline[4];\n static gsl_interp_accel *accel[4];\n int i;\n double xtab[COSMOCALC_NONLINEAR_POWSPEC_TABLE_LENGTH],ytab[COSMOCALC_NONLINEAR_POWSPEC_TABLE_LENGTH];\n double Rsigma,C,neff,ksigma,sigma2;\n double an,bn,cn,alphan,gamman,betan,mun,nun;\n double f1,f2,f3;\n double DeltakNL,dsigma2dR,d2sigma2d2R,PkNL,PkL;\n double y,DeltakL,fy,DeltakQ,DeltakHprime,DeltakH;\n //double t;\n double I0,I1;\n double abserr;\n gsl_integration_workspace *workspace;\n gsl_function F;\n double gaussRad;\n \n#define WORKSPACE_NUM 10000000\n#define ABSERR 1e-6\n#define RELERR 0.0\n \n if(initFlag == 1 || currCosmoNum != cosmoData.cosmoNum)\n {\n currCosmoNum = cosmoData.cosmoNum;\n \n if(initFlag)\n\t{\n\t for(i=0;i<4;++i)\n\t spline[i] = gsl_spline_alloc(gsl_interp_akima,(size_t) (COSMOCALC_NONLINEAR_POWSPEC_TABLE_LENGTH));\n\t for(i=0;i<4;++i)\n\t accel[i] = gsl_interp_accel_alloc();\n \n\t initFlag = 0;\n\t}\n else\n\t{\n\t for(i=0;i<4;++i)\n\t gsl_spline_free(spline[i]);\n\t for(i=0;i<4;++i)\n\t spline[i] = gsl_spline_alloc(gsl_interp_akima,(size_t) (COSMOCALC_NONLINEAR_POWSPEC_TABLE_LENGTH));\n\t for(i=0;i<4;++i)\n\t gsl_interp_accel_reset(accel[i]);\n\t}\n \n //t = -wtime();\n \n for(i=0;i\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n/* parameters for functions */\nstruct model_params\n{\n double alpha;\n gsl_spmatrix *J;\n};\n\n/* penalty function */\nint\npenalty_f (const gsl_vector * x, void *params, gsl_vector * f)\n{\n struct model_params *par = (struct model_params *) params;\n const double sqrt_alpha = sqrt(par->alpha);\n const size_t p = x->size;\n size_t i;\n double sum = 0.0;\n\n for (i = 0; i < p; ++i)\n {\n double xi = gsl_vector_get(x, i);\n\n gsl_vector_set(f, i, sqrt_alpha*(xi - 1.0));\n\n sum += xi * xi;\n }\n\n gsl_vector_set(f, p, sum - 0.25);\n\n return GSL_SUCCESS;\n}\n\nint\npenalty_df (CBLAS_TRANSPOSE_t TransJ, const gsl_vector * x,\n const gsl_vector * u, void * params, gsl_vector * v,\n gsl_matrix * JTJ)\n{\n struct model_params *par = (struct model_params *) params;\n const size_t p = x->size;\n size_t j;\n\n /* store 2*x in last row of J */\n for (j = 0; j < p; ++j)\n {\n double xj = gsl_vector_get(x, j);\n gsl_spmatrix_set(par->J, p, j, 2.0 * xj);\n }\n\n /* compute v = op(J) u */\n if (v)\n gsl_spblas_dgemv(TransJ, 1.0, par->J, u, 0.0, v);\n\n if (JTJ)\n {\n gsl_vector_view diag = gsl_matrix_diagonal(JTJ);\n\n /* compute J^T J = [ alpha*I_p + 4 x x^T ] */\n gsl_matrix_set_zero(JTJ);\n\n /* store 4 x x^T in lower half of JTJ */\n gsl_blas_dsyr(CblasLower, 4.0, x, JTJ);\n\n /* add alpha to diag(JTJ) */\n gsl_vector_add_constant(&diag.vector, par->alpha);\n }\n\n return GSL_SUCCESS;\n}\n\nint\npenalty_fvv (const gsl_vector * x, const gsl_vector * v,\n void *params, gsl_vector * fvv)\n{\n const size_t p = x->size;\n double normv = gsl_blas_dnrm2(v);\n\n gsl_vector_set_zero(fvv);\n gsl_vector_set(fvv, p, 2.0 * normv * normv);\n\n (void)params; /* avoid unused parameter warning */\n\n return GSL_SUCCESS;\n}\n\nvoid\nsolve_system(const gsl_vector *x0, gsl_multilarge_nlinear_fdf *fdf,\n gsl_multilarge_nlinear_parameters *params)\n{\n const gsl_multilarge_nlinear_type *T = gsl_multilarge_nlinear_trust;\n const size_t max_iter = 200;\n const double xtol = 1.0e-8;\n const double gtol = 1.0e-8;\n const double ftol = 1.0e-8;\n const size_t n = fdf->n;\n const size_t p = fdf->p;\n gsl_multilarge_nlinear_workspace *work =\n gsl_multilarge_nlinear_alloc(T, params, n, p);\n gsl_vector * f = gsl_multilarge_nlinear_residual(work);\n gsl_vector * x = gsl_multilarge_nlinear_position(work);\n int info;\n double chisq0, chisq, rcond, xsq;\n struct timeval tv0, tv1;\n\n gettimeofday(&tv0, NULL);\n\n /* initialize solver */\n gsl_multilarge_nlinear_init(x0, fdf, work);\n\n /* store initial cost */\n gsl_blas_ddot(f, f, &chisq0);\n\n /* iterate until convergence */\n gsl_multilarge_nlinear_driver(max_iter, xtol, gtol, ftol,\n NULL, NULL, &info, work);\n\n gettimeofday(&tv1, NULL);\n\n /* store final cost */\n gsl_blas_ddot(f, f, &chisq);\n\n /* compute final ||x||^2 */\n gsl_blas_ddot(x, x, &xsq);\n\n /* store cond(J(x)) */\n gsl_multilarge_nlinear_rcond(&rcond, work);\n\n /* print summary */\n fprintf(stderr, \"%-25s %-5zu %-4zu %-5zu %-6zu %-4zu %-10.4e %-10.4e %-7.2f %-11.4e %.2f\\n\",\n gsl_multilarge_nlinear_trs_name(work),\n gsl_multilarge_nlinear_niter(work),\n fdf->nevalf,\n fdf->nevaldfu,\n fdf->nevaldf2,\n fdf->nevalfvv,\n chisq0,\n chisq,\n 1.0 / rcond,\n xsq,\n (tv1.tv_sec - tv0.tv_sec) + 1.0e-6 * (tv1.tv_usec - tv0.tv_usec));\n\n gsl_multilarge_nlinear_free(work);\n}\n\nint\nmain (void)\n{\n const size_t p = 2000;\n const size_t n = p + 1;\n gsl_vector *f = gsl_vector_alloc(n);\n gsl_vector *x = gsl_vector_alloc(p);\n\n /* allocate sparse Jacobian matrix with 2*p non-zero elements in triplet format */\n gsl_spmatrix *J = gsl_spmatrix_alloc_nzmax(n, p, 2 * p, GSL_SPMATRIX_TRIPLET);\n\n gsl_multilarge_nlinear_fdf fdf;\n gsl_multilarge_nlinear_parameters fdf_params =\n gsl_multilarge_nlinear_default_parameters();\n struct model_params params;\n size_t i;\n\n params.alpha = 1.0e-5;\n params.J = J;\n\n /* define function to be minimized */\n fdf.f = penalty_f;\n fdf.df = penalty_df;\n fdf.fvv = penalty_fvv;\n fdf.n = n;\n fdf.p = p;\n fdf.params = ¶ms;\n\n for (i = 0; i < p; ++i)\n {\n /* starting point */\n gsl_vector_set(x, i, i + 1.0);\n\n /* store sqrt(alpha)*I_p in upper p-by-p block of J */\n gsl_spmatrix_set(J, i, i, sqrt(params.alpha));\n }\n\n fprintf(stderr, \"%-25s %-4s %-4s %-5s %-6s %-4s %-10s %-10s %-7s %-11s %-10s\\n\",\n \"Method\", \"NITER\", \"NFEV\", \"NJUEV\", \"NJTJEV\", \"NAEV\", \"Init Cost\",\n \"Final cost\", \"cond(J)\", \"Final |x|^2\", \"Time (s)\");\n \n fdf_params.scale = gsl_multilarge_nlinear_scale_levenberg;\n\n fdf_params.trs = gsl_multilarge_nlinear_trs_lm;\n solve_system(x, &fdf, &fdf_params);\n\n fdf_params.trs = gsl_multilarge_nlinear_trs_lmaccel;\n solve_system(x, &fdf, &fdf_params);\n\n fdf_params.trs = gsl_multilarge_nlinear_trs_dogleg;\n solve_system(x, &fdf, &fdf_params);\n\n fdf_params.trs = gsl_multilarge_nlinear_trs_ddogleg;\n solve_system(x, &fdf, &fdf_params);\n\n fdf_params.trs = gsl_multilarge_nlinear_trs_subspace2D;\n solve_system(x, &fdf, &fdf_params);\n\n fdf_params.trs = gsl_multilarge_nlinear_trs_cgst;\n solve_system(x, &fdf, &fdf_params);\n\n gsl_vector_free(f);\n gsl_vector_free(x);\n gsl_spmatrix_free(J);\n\n return 0;\n}\n", "meta": {"hexsha": "558c72f25d5488c8c4d4897c70ba9e7b93ad7d0a", "size": 5567, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.6/doc/examples/nlfit4.c", "max_stars_repo_name": "ielomariala/Hex-Game", "max_stars_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-06-14T11:51:37.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-14T11:51:37.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/doc/examples/nlfit4.c", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-12-16T17:41:24.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-22T00:00:16.000Z", "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/doc/examples/nlfit4.c", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-01-20T16:22:57.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-14T12:31:02.000Z", "avg_line_length": 25.3045454545, "max_line_length": 94, "alphanum_fraction": 0.6441530447, "num_tokens": 1825, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7905303285397349, "lm_q2_score": 0.6513548782017745, "lm_q1q2_score": 0.5149157858608079}} {"text": "/*System includes*/\n#include \n#include \n#include \n#include \n#include \n#include \n\n/*GSL includes*/\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n/*User includes*/\n#include \"c_vbgmm_fit.h\"\n\nvoid readInputData(const char *szFile, t_Data *ptData);\n\nvoid c_vbgmm_fit (double* adX, int nN, int nD, int nK, int* anAssign, int debug, int bAssign);\n\nvoid readAssigns(const char *szFile, int *anAssign, int nN);\n\nint main()\n{\n t_Data tData;\n int *anAssign = NULL;\n int i = 0, j = 0, nN = -1, nD = -1, nK = 0;\n double* adX = NULL;\n const gsl_rng_type * T;\n gsl_rng * r;\n\n gsl_rng_env_setup();\n\n T = gsl_rng_default;\n r = gsl_rng_alloc (T); \n \n \n readInputData(\"PCA_transformed_data_gt2000.csv\", &tData);\n \n nN = tData.nN;\n nD = tData.nD;\n \n adX = (double *) malloc(nN*nD*sizeof(double));\n anAssign = (int *) malloc(nN*sizeof(int));\n \n readAssigns(\"clustering_gt2000.csv\", anAssign, nN);\n \n for(i = 0; i < nN; i++){\n if(anAssign[i] > nK){\n nK = anAssign[i];\n }\n for(j = 0; j < nD; j++){\n adX[i*nD + j] = tData.aadX[i][j]; \n }\n }\n \n nK = nK + 1;\n fprintf(stderr,\"Run c_vbgmm_fit with %d clusters\\n\",nK);\n fflush(stderr);\n \n c_vbgmm_fit (adX, nN, nD, nK, anAssign, FALSE, TRUE);\n for(i = 0; i < nN; i++){\n printf(\"%d,%d\\n\",i,anAssign[i]);\n }\n free(adX);\n free(anAssign);\n return 0;\n}\n\nvoid readInputData(const char *szFile, t_Data *ptData)\n{\n double **aadX = NULL;\n int i = 0, j = 0, nD = 0, nN = 0;\n char *szLine = (char *) malloc(sizeof(char)*MAX_LINE_LENGTH);\n FILE* ifp = NULL;\n\n if(!szLine)\n goto memoryError;\n\n ifp = fopen(szFile, \"r\");\n\n if(ifp){\n char* szTok = NULL;\n char* pcError = NULL;\n\n if(fgets(szLine, MAX_LINE_LENGTH, ifp) == NULL)\n goto formatError;\n\n szTok = strtok(szLine, DELIM);\n /*count dimensions*/\n while(strtok(NULL, DELIM) != NULL){\n \n nD++;\n }\n /*count data points*/\n while(fgets(szLine, MAX_LINE_LENGTH, ifp) != NULL){\n \tnN++;\n }\n fclose(ifp);\n\n /*reopen input file*/\n ifp = fopen(szFile, \"r\");\t\n\n if(fgets(szLine, MAX_LINE_LENGTH, ifp) == NULL)\n goto formatError;\n\n\n /*allocate memory for dimension names*/\n //ptData->aszDimNames = (char **) malloc(nD*sizeof(char*));\n //if(!ptData->aszDimNames)\n //goto memoryError;\n\n szTok = strtok(szLine, DELIM);\n /*read in dim names*/\n for(i = 0; i < nD; i++){\n szTok = strtok(NULL, DELIM);\n // ptData->aszDimNames[i] = strdup(szTok);\n }\n\t\n /*allocate memory for data matrix*/\n aadX = (double **) malloc(nN*sizeof(double*));\n if(!aadX)\n goto memoryError;\n for(i = 0; i < nN; i++){\n aadX[i] = (double *) malloc(nD*sizeof(double));\n if(!aadX[i])\n\tgoto memoryError;\n }\n\n /*read in input data*/\n //ptData->aszSampleNames = (char **) malloc(nN*sizeof(char*));\n //if(!ptData->aszSampleNames)\n //goto memoryError;\n\n for(i = 0; i < nN; i++){\n \n if(fgets(szLine, MAX_LINE_LENGTH, ifp) == NULL)\n\tgoto formatError;\n\n szTok = strtok(szLine, DELIM);\n // ptData->aszSampleNames[i] = strdup(szTok);\n for(j = 0; j < nD; j++){\n\tszTok = strtok(NULL, DELIM);\n\n\taadX[i][j] = strtod(szTok,&pcError);\n\n\tif(*pcError != '\\0'){\n\t goto formatError;\n\t}\n }\n }\n }\n else{\n fprintf(stderr, \"Failed to open abundance data file %s aborting\\n\", szFile);\n fflush(stderr);\n exit(EXIT_FAILURE);\n }\n\n free(szLine);\n ptData->nD = nD;\n ptData->nN = nN;\n ptData->aadX = aadX;\n return;\n\n memoryError:\n fprintf(stderr, \"Failed allocating memory in readInputData\\n\");\n fflush(stderr);\n exit(EXIT_FAILURE);\n\n formatError:\n fprintf(stderr, \"Incorrectly formatted abundance data file\\n\");\n fflush(stderr);\n exit(EXIT_FAILURE);\n}\n\nvoid readAssigns(const char *szFile, int *anAssign, int nN)\n{\n int i = 0;\n char *szLine = (char *) malloc(sizeof(char)*MAX_LINE_LENGTH);\n FILE* ifp = NULL;\n\n if(!szLine)\n goto memoryError;\n\n ifp = fopen(szFile, \"r\");\n\n if(ifp){\n char* szTok = NULL;\n char* pcError = NULL;\n\n if(fgets(szLine, MAX_LINE_LENGTH, ifp) == NULL)\n goto formatError;\n\n for(i = 0; i < nN; i++){ \n if(fgets(szLine, MAX_LINE_LENGTH, ifp) == NULL)\n goto formatError;\n\n szTok = strtok(szLine, DELIM);\n szTok = strtok(NULL, DELIM);\n \tanAssign[i] = strtod(szTok,&pcError);\n\n\t if(*pcError != '\\0'){\n\t goto formatError;\n\t }\n }\n }\n else{\n fprintf(stderr, \"Failed to open abundance data file %s aborting\\n\", szFile);\n fflush(stderr);\n exit(EXIT_FAILURE);\n }\n\n free(szLine);\n\n return;\n\n memoryError:\n fprintf(stderr, \"Failed allocating memory in readInputData\\n\");\n fflush(stderr);\n exit(EXIT_FAILURE);\n\n formatError:\n fprintf(stderr, \"Incorrectly formatted abundance data file\\n\");\n fflush(stderr);\n exit(EXIT_FAILURE);\n}\n", "meta": {"hexsha": "3cc3769032954e5564f1ce8a4e6da7647f746e0f", "size": 5485, "ext": "c", "lang": "C", "max_stars_repo_path": "c-concoct/test_vbgmm_fit.c", "max_stars_repo_name": "merenlab/CONCOCT", "max_stars_repo_head_hexsha": "78068456416934daea22fa19531b16cdecda6a39", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 79.0, "max_stars_repo_stars_event_min_datetime": "2015-01-16T15:08:51.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-18T03:12:15.000Z", "max_issues_repo_path": "c-concoct/test_vbgmm_fit.c", "max_issues_repo_name": "merenlab/CONCOCT", "max_issues_repo_head_hexsha": "78068456416934daea22fa19531b16cdecda6a39", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": 156.0, "max_issues_repo_issues_event_min_datetime": "2015-01-07T07:51:10.000Z", "max_issues_repo_issues_event_max_datetime": "2022-02-09T03:26:12.000Z", "max_forks_repo_path": "c-concoct/test_vbgmm_fit.c", "max_forks_repo_name": "merenlab/CONCOCT", "max_forks_repo_head_hexsha": "78068456416934daea22fa19531b16cdecda6a39", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": 47.0, "max_forks_repo_forks_event_min_datetime": "2015-06-03T18:30:50.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-22T08:31:46.000Z", "avg_line_length": 22.4795081967, "max_line_length": 94, "alphanum_fraction": 0.6021877849, "num_tokens": 1697, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8519528019683105, "lm_q2_score": 0.6039318337259584, "lm_q1q2_score": 0.5145214179406901}} {"text": "#include \n#include \n#include \n#include \n\nstruct data\n{\n double x;\n double y;\n double z;\n};\n\nint sel_func (void *ntuple_data, void *params);\ndouble val_func (void *ntuple_data, void *params);\n\nint\nmain (void)\n{\n struct data ntuple_row;\n int i;\n\n gsl_ntuple *ntuple = gsl_ntuple_open (\"test.dat\", &ntuple_row,\n sizeof (ntuple_row));\n\n gsl_histogram *h = gsl_histogram_calloc_uniform (100, 0., 10.);\n\n gsl_ntuple_select_fn S;\n gsl_ntuple_value_fn V;\n\n double scale = 1.5;\n\n S.function = &sel_func;\n S.params = &scale;\n\n V.function = &val_func;\n V.params = 0;\n\n gsl_ntuple_project (h, ntuple, &V, &S);\n\n gsl_histogram_fprintf (stdout, h, \"%f\", \"%f\");\n\n gsl_histogram_free (h);\n\n gsl_ntuple_close (ntuple);\n}\n\nint\nsel_func (void *ntuple_data, void *params)\n{\n double x, y, z, E, scale;\n scale = *(double *) params;\n\n x = ((struct data *) ntuple_data)->x;\n y = ((struct data *) ntuple_data)->y;\n z = ((struct data *) ntuple_data)->z;\n\n E = x * x + y * y + z * z;\n\n return E / scale > 1;\n}\n\ndouble\nval_func (void *ntuple_data, void *params)\n{\n double x, y, z;\n\n x = ((struct data *) ntuple_data)->x;\n y = ((struct data *) ntuple_data)->y;\n z = ((struct data *) ntuple_data)->z;\n\n return x * x + y * y + z * z;\n}\n", "meta": {"hexsha": "a59ef85f3f5a371e3ab5b19903829d8d05ee0948", "size": 1331, "ext": "c", "lang": "C", "max_stars_repo_path": "Chimera/3rd_Party/GSL_MSVC/ntuple/demo1.c", "max_stars_repo_name": "zzpwahaha/Chimera-Control-Trim", "max_stars_repo_head_hexsha": "df1bbf6bea0b87b8c7c9a99dce213fdc249118f2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-06-14T11:51:37.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-14T11:51:37.000Z", "max_issues_repo_path": "Chimera/3rd_Party/GSL_MSVC/ntuple/demo1.c", "max_issues_repo_name": "zzpwahaha/Chimera-Control-Trim", "max_issues_repo_head_hexsha": "df1bbf6bea0b87b8c7c9a99dce213fdc249118f2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Chimera/3rd_Party/GSL_MSVC/ntuple/demo1.c", "max_forks_repo_name": "zzpwahaha/Chimera-Control-Trim", "max_forks_repo_head_hexsha": "df1bbf6bea0b87b8c7c9a99dce213fdc249118f2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-01-20T16:22:57.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-14T12:31:02.000Z", "avg_line_length": 18.2328767123, "max_line_length": 65, "alphanum_fraction": 0.6130728775, "num_tokens": 424, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8519528019683105, "lm_q2_score": 0.6039318337259583, "lm_q1q2_score": 0.51452141794069}} {"text": "/* rng/fishman2x.c\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 2 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n/*\n * This generator is taken from\n *\n * Donald E. Knuth\n * The Art of Computer Programming\n * Volume 2\n * Third Edition\n * Addison-Wesley\n * Page 108\n *\n * It is called \"Fishman - L'Ecuyer\"\n *\n * This implementation copyright (C) 2001 Carlo Perassi\n * and (C) 2003 Heiko Bauke.\n */\n\n#include \n#include \n#include \n\n/* Fishman */\n#define AAA_F 48271UL\n#define MMM_F 0x7fffffffUL /* 2 ^ 31 - 1 */\n#define QQQ_F 44488UL\n#define RRR_F 3399UL\n\n/* L'Ecuyer */\n#define AAA_L 40692UL\n#define MMM_L 0x7fffff07UL /* 2 ^ 31 - 249 */\n#define QQQ_L 52774UL\n#define RRR_L 3791UL\n\nstatic inline unsigned long int ran_get (void *vstate);\nstatic double ran_get_double (void *vstate);\nstatic void ran_set (void *state, unsigned long int s);\n\ntypedef struct\n{\n unsigned long int x;\n unsigned long int y;\n unsigned long int z;\n}\nran_state_t;\n\nstatic inline unsigned long int\nran_get (void *vstate)\n{\n ran_state_t *state = (ran_state_t *) vstate;\n\n long int y, r;\n\n r = RRR_F * (state->x / QQQ_F);\n y = AAA_F * (state->x % QQQ_F) - r;\n if (y < 0)\n y += MMM_F;\n state->x = y;\n\n r = RRR_L * (state->y / QQQ_L);\n y = AAA_L * (state->y % QQQ_L) - r;\n if (y < 0)\n y += MMM_L;\n state->y = y;\n\n state->z = (state->x > state->y) ? (state->x - state->y) :\n MMM_F + state->x - state->y;\n\n return state->z;\n}\n\nstatic double\nran_get_double (void *vstate)\n{\n ran_state_t *state = (ran_state_t *) vstate;\n\n return ran_get (state) / 2147483647.0;\n}\n\nstatic void\nran_set (void *vstate, unsigned long int s)\n{\n ran_state_t *state = (ran_state_t *) vstate;\n\n if ((s % MMM_F) == 0 || (s % MMM_L) == 0)\n s = 1; /* default seed is 1 */\n\n state->x = s % MMM_F;\n state->y = s % MMM_L;\n state->z = (state->x > state->y) ? (state->x - state->y) :\n MMM_F + state->x - state->y;\n\n return;\n}\n\nstatic const gsl_rng_type ran_type = {\n \"fishman2x\", /* name */\n MMM_F - 1, /* RAND_MAX */\n 0, /* RAND_MIN */\n sizeof (ran_state_t),\n &ran_set,\n &ran_get,\n &ran_get_double\n};\n\nconst gsl_rng_type *gsl_rng_fishman2x = &ran_type;\n", "meta": {"hexsha": "afe0c2794ad603fe1ef18e0cdeb5453a93ff5ddc", "size": 2893, "ext": "c", "lang": "C", "max_stars_repo_path": "pkgs/libs/gsl/src/rng/fishman2x.c", "max_stars_repo_name": "manggoguy/parsec-modified", "max_stars_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 64.0, "max_stars_repo_stars_event_min_datetime": "2015-03-06T00:30:56.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-24T13:26:53.000Z", "max_issues_repo_path": "pkgs/libs/gsl/src/rng/fishman2x.c", "max_issues_repo_name": "manggoguy/parsec-modified", "max_issues_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 12.0, "max_issues_repo_issues_event_min_datetime": "2020-12-15T08:30:19.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-13T03:54:24.000Z", "max_forks_repo_path": "pkgs/libs/gsl/src/rng/fishman2x.c", "max_forks_repo_name": "manggoguy/parsec-modified", "max_forks_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 40.0, "max_forks_repo_forks_event_min_datetime": "2015-02-26T15:31:16.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-03T23:23:37.000Z", "avg_line_length": 23.7131147541, "max_line_length": 81, "alphanum_fraction": 0.6380919461, "num_tokens": 900, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7772998611746911, "lm_q2_score": 0.6619228691808011, "lm_q1q2_score": 0.5145125543225899}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"cosmocalc.h\"\n\ndouble fourierTransformTopHat(double y);\ndouble tophatradnorm_linear_powspec_exact_nonorm_lnk_integ_funct_I0(double lnk, void *p);\ndouble tophatradnorm_linear_powspec_exact_nonorm_k_integ_funct_I0(double k, void *p);\n\ndouble convert_cmbnorm2sigma8_k_integ_funct_I0(double k, void *p)\n{\n //k is in units of 1/Mpc\n //to get to units of h/Mpc\n // k -> k/h\n double ft = fourierTransformTopHat(k*8.0/cosmoData.h);\n double tf = transfer_function(k/cosmoData.h);\n\n /*\n fprintf(stderr,\"Tf^2 = %g, W(k)^2 = %g (2/5/OmegaM)^2 = %g (k/H0)^4/k = %g, nspow = %g\\n\",\n\t tf*tf,ft*ft,4.0/25.0/cosmoData.OmegaM/cosmoData.OmegaM,\n\t pow(k/100.0,4.0)/k,pow(k*cosmoData.h/cosmoData.As_pivot,cosmoData.SpectralIndex-1.0)\n\t );\n */\n return cosmoData.As*4.0/25.0/cosmoData.OmegaM/cosmoData.OmegaM\n *pow(k/cosmoData.h*DH,4.0)/k*pow(k/cosmoData.As_pivot,cosmoData.SpectralIndex-1.0)\n *ft*ft*tf*tf;\n}\n\ndouble convert_cmbnorm2sigma8(void)\n{\n double I0,I1;\n double abserr;\n double epsrel,epsabs;\n gsl_integration_workspace *workspace;\n gsl_function F;\n\n#define WORKSPACE_NUM 10000000\n#define ABSERR 1e-8\n#define RELERR 0.0\n workspace = gsl_integration_workspace_alloc((size_t) WORKSPACE_NUM);\n\n epsabs = 1e-20;\n epsrel = 1e-6;\n F.function = &convert_cmbnorm2sigma8_k_integ_funct_I0;\n gsl_integration_qags(&F,0.0,2.0*M_PI/8.0,epsabs,epsrel,(size_t) WORKSPACE_NUM,workspace,&I0,&abserr);\n gsl_integration_qagiu(&F,2.0*M_PI/8.0,epsabs,epsrel,(size_t) WORKSPACE_NUM,workspace,&I1,&abserr);\n\n gsl_integration_workspace_free(workspace);\n#undef ABSERR\n#undef RELERR\n#undef WORKSPACE_NUM\n\n //fprintf(stderr,\"I0 = %g, I1 = %g, g = %g\\n\",I0,I1,growth_function_exact_nonorm(1.0));\n\n return sqrt(I0 + I1)*growth_function_exact_nonorm(1.0);\n}\n\ndouble fourierTransformTopHat(double y)\n{\n if(y < 1e-3)\n return 1.0;\n else\n return 3.0/y/y/y*(sin(y) - y*cos(y));\n}\n\ndouble tophatradnorm_linear_powspec_exact_nonorm_lnk_integ_funct_I0(double lnk, void *p)\n{\n // topHatRad = (*((double*)p));\n double k = exp(lnk);\n double ft = fourierTransformTopHat(k*(*((double*)p)));\n double tf = transfer_function(k);\n return ft*ft*tf*tf*pow(k,cosmoData.SpectralIndex)*k*k/2.0/M_PI/M_PI*k;\n}\n\ndouble tophatradnorm_linear_powspec_exact_nonorm_k_integ_funct_I0(double k, void *p)\n{\n // topHatRad = (*((double*)p));\n double ft = fourierTransformTopHat(k*(*((double*)p)));\n double tf = transfer_function(k);\n return ft*ft*tf*tf*pow(k,cosmoData.SpectralIndex)*k*k/2.0/M_PI/M_PI;\n}\n\ndouble tophatradnorm_linear_powspec_exact_nonorm(double topHatRad)\n{\n double I0,I1;\n double abserr;\n double epsrel,epsabs;\n gsl_integration_workspace *workspace;\n gsl_function F;\n\n#define WORKSPACE_NUM 10000000\n#define ABSERR 1e-8\n#define RELERR 0.0\n workspace = gsl_integration_workspace_alloc((size_t) WORKSPACE_NUM);\n\n F.params = &(topHatRad);\n if(topHatRad > 1e-4)\n {\n epsabs = 1e-20;\n epsrel = 1e-6;\n F.function = &tophatradnorm_linear_powspec_exact_nonorm_k_integ_funct_I0;\n gsl_integration_qags(&F,0.0,2.0*M_PI/topHatRad,epsabs,epsrel,(size_t) WORKSPACE_NUM,workspace,&I0,&abserr);\n gsl_integration_qagiu(&F,2.0*M_PI/topHatRad,epsabs,epsrel,(size_t) WORKSPACE_NUM,workspace,&I1,&abserr);\n }\n else\n {\n F.function = &tophatradnorm_linear_powspec_exact_nonorm_lnk_integ_funct_I0;\n gsl_integration_qagil(&F,log(2.0*M_PI/topHatRad),ABSERR,RELERR,(size_t) WORKSPACE_NUM,workspace,&I0,&abserr);\n gsl_integration_qagiu(&F,log(2.0*M_PI/topHatRad),ABSERR,RELERR,(size_t) WORKSPACE_NUM,workspace,&I1,&abserr);\n }\n\n gsl_integration_workspace_free(workspace);\n#undef ABSERR\n#undef RELERR\n#undef WORKSPACE_NUM\n\n return I0 + I1;\n}\n\ndouble linear_powspec_exact(double k, double a)\n{\n static int initFlag = 1;\n static int currCosmoNum;\n static double linear_powspec_norm = 1.0;\n double gf = growth_function(a);\n double tf = transfer_function(k);\n\n if(initFlag == 1 || currCosmoNum != cosmoData.cosmoNum)\n {\n initFlag = 0;\n currCosmoNum = cosmoData.cosmoNum;\n\n linear_powspec_norm = cosmoData.Sigma8*cosmoData.Sigma8/tophatradnorm_linear_powspec_exact_nonorm(8.0);\n }\n\n return tf*tf*pow(k,cosmoData.SpectralIndex)*gf*gf*linear_powspec_norm;\n}\n\ndouble linear_powspec(double k, double a)\n{\n static int initFlag = 1;\n static int currCosmoNum;\n static double linear_powspec_norm = 1.0;\n static gsl_spline *cosmocalc_linear_powspec_spline = NULL;\n static gsl_interp_accel *cosmocalc_linear_powspec_acc = NULL;\n static double c0,c1;\n\n double linear_powspec_table[COSMOCALC_LINEAR_POWSPEC_TABLE_LENGTH];\n double k_table[COSMOCALC_LINEAR_POWSPEC_TABLE_LENGTH];\n long i;\n double gf,cov00,cov01,cov11,sumsq,tf;\n\n if(initFlag == 1 || currCosmoNum != cosmoData.cosmoNum)\n {\n initFlag = 0;\n currCosmoNum = cosmoData.cosmoNum;\n\n for(i=0;i 1e-4)\n\t {\n\t epsabs = 1e-20;\n\t epsrel = 1e-6;\n\t F.function = &tophatradnorm_linear_powspec_exact_nonorm_k_integ_funct_I0;\n\t gsl_integration_qags(&F,0.0,2.0*M_PI/topHatRad,epsabs,epsrel,(size_t) WORKSPACE_NUM,workspace,&I0,&abserr);\n\t gsl_integration_qagiu(&F,2.0*M_PI/topHatRad,epsabs,epsrel,(size_t) WORKSPACE_NUM,workspace,&I1,&abserr);\n\t }\n\t else\n\t {\n\t F.function = &tophatradnorm_linear_powspec_exact_nonorm_lnk_integ_funct_I0;\n\t gsl_integration_qagil(&F,log(2.0*M_PI/topHatRad),ABSERR,RELERR,(size_t) WORKSPACE_NUM,workspace,&I0,&abserr);\n\t gsl_integration_qagiu(&F,log(2.0*M_PI/topHatRad),ABSERR,RELERR,(size_t) WORKSPACE_NUM,workspace,&I1,&abserr);\n\t }\n\n xtab[i] = lnr;\n ytab[i] = log(I0+I1);\n }\n\n gsl_integration_workspace_free(workspace);\n\n if(spline != NULL)\n gsl_spline_free(spline);\n spline = gsl_spline_alloc(GSL_SPLINE_TYPE,(size_t) (COSMOCALC_LINEAR_POWSPEC_NORM_TABLE_LENGTH));\n gsl_spline_init(spline,xtab,ytab,(size_t) (COSMOCALC_LINEAR_POWSPEC_NORM_TABLE_LENGTH));\n if(accel != NULL)\n gsl_interp_accel_reset(accel);\n else\n accel = gsl_interp_accel_alloc();\n\n linear_powspec_norm = cosmoData.Sigma8*cosmoData.Sigma8/exp(gsl_spline_eval(spline,log(8.0),accel));\n\n#undef ABSERR\n#undef RELERR\n#undef WORKSPACE_NUM\n#undef NL_RTOPHAT_MIN\n#undef NL_RTOPHAT_MAX\n }\n\n return exp(gsl_spline_eval(spline,log(topHatRad),accel))*linear_powspec_norm;\n}\n\ndouble linear_tophatnorm_scale_funct(double rad, void *p)\n{\n double gf = ((double*)p)[0];\n\n return tophatnorm_linear_powspec(rad)*gf*gf-1.0;\n}\n\ndouble get_linear_tophatnorm_scale(double a)\n{\n double gf = growth_function(a);\n double Rsigma,Rlow=0.001,Rhigh=10.0;\n int itr,maxItr=1000,status;\n\n //fprintf(stderr,\"sigma2(Rlow) = %f, sigma2(Rhigh) = %f\\n\",tophatnorm_linear_powspec(Rlow)*gf*gf,tophatnorm_linear_powspec(Rhigh)*gf*gf);\n\n#define ABSERR 1e-6\n#define RELERR 1e-6\n const gsl_root_fsolver_type *T;\n gsl_root_fsolver *s;\n gsl_function F;\n\n F.function = &linear_tophatnorm_scale_funct;\n F.params = &gf;\n\n T = gsl_root_fsolver_brent;\n s = gsl_root_fsolver_alloc(T);\n gsl_root_fsolver_set(s,&F,Rlow,Rhigh);\n itr = 0;\n\n do\n {\n itr++;\n status = gsl_root_fsolver_iterate(s);\n Rsigma = gsl_root_fsolver_root(s);\n Rlow = gsl_root_fsolver_x_lower(s);\n Rhigh = gsl_root_fsolver_x_upper(s);\n status = gsl_root_test_interval(Rlow,Rhigh,ABSERR,RELERR);\n }\n while(status == GSL_CONTINUE && itr < maxItr);\n\n#undef ABSERR\n#undef RELERR\n\n gsl_root_fsolver_free(s);\n\n return Rsigma;\n}\n", "meta": {"hexsha": "fbc0b3aa1b2ef39474d0f79a87bf8ec0576f142b", "size": 10511, "ext": "c", "lang": "C", "max_stars_repo_path": "src/linear_powspec.c", "max_stars_repo_name": "beckermr/cosmocalc", "max_stars_repo_head_hexsha": "aa7d7cb58f05a36d446e02b45a9117d93eb16556", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/linear_powspec.c", "max_issues_repo_name": "beckermr/cosmocalc", "max_issues_repo_head_hexsha": "aa7d7cb58f05a36d446e02b45a9117d93eb16556", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2016-04-05T19:10:45.000Z", "max_issues_repo_issues_event_max_datetime": "2016-04-05T19:36:21.000Z", "max_forks_repo_path": "src/linear_powspec.c", "max_forks_repo_name": "beckermr/cosmocalc", "max_forks_repo_head_hexsha": "aa7d7cb58f05a36d446e02b45a9117d93eb16556", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2017-07-14T12:17:31.000Z", "max_forks_repo_forks_event_max_datetime": "2017-08-11T17:31:51.000Z", "avg_line_length": 31.5645645646, "max_line_length": 139, "alphanum_fraction": 0.7338026829, "num_tokens": 3462, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8615382200964034, "lm_q2_score": 0.5964331462646255, "lm_q1q2_score": 0.5138499512393233}} {"text": " // MIT License\n\n // Copyright (c) [2017] [Vinay Yuvashankar]\n\n // Permission is hereby granted, free of charge, to any person obtaining a copy\n // of this software and associated documentation files (the \"Software\"), to deal\n // in the Software without restriction, including without limitation the rights\n // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n // copies of the Software, and to permit persons to whom the Software is\n // furnished to do so, subject to the following conditions:\n\n // The above copyright notice and this permission notice shall be included in all\n // copies or substantial portions of the Software.\n\n // THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n // SOFTWARE.\n/**\n\t\\file \"Wavelet.cc\"\n\t\\brief This file contains all of the functions that support the ERSP and CWT functions\n*/\n#include \"wavelet.h\"\n#include \n#include \n#include \n\n#define TEST 0.00001\n#define SETTLING_PERCENTAGE 0.02\n#define NORMALIZATION_FACTOR 0.375402913609157562\n\nint Wavelet(double* raw_data, double* scales, \n\tdouble sampling_frequency, int n, int J,\n\tdouble* result)\n{\n\t//Variable Declarations\n\tint i, j;\n\tfftw_complex *data_in, *fft_data;\n\tfftw_plan plan_forward;\n\n\n\t//Calculate Padding Required\n // const int PADDED_SIZE = CalculatePaddingSize(n, 1);\n const int PADDED_SIZE = n;\n\n const double dw = (2 * M_PI * sampling_frequency)/(PADDED_SIZE); //NOT IN RAD/SAMPLE in RAD/SEC\n\n data_in = (fftw_complex *) fftw_malloc( sizeof( fftw_complex ) * PADDED_SIZE );\n\tfft_data = (fftw_complex *) fftw_malloc( sizeof( fftw_complex ) * PADDED_SIZE );\n\n\n\t//populate the FFTW data vector\n\tfor (i = 0; i < n; ++i)\n {\n \tdata_in[i][0] = raw_data[i];\n \t// data_in[i + n][0] = raw_data[i];\n\n \t// data_in[i + n][1] = 0.0;\n \tdata_in[i ][1] = 0.0;\n }\n\n // //Force the rest of the data vector to zero just in case\n // for (int i = n; i < PADDED_SIZE; ++i)\n // {\n // \tdata_in[i][0] = 0.0;\n // \tdata_in[i][1] = 0.0;\n // }\n\n double *temp = (double*) malloc(n * sizeof(double));\n FILE* debug_file = fopen(\"debug.log\", \"w\");\n\n\t//Calculate the FFT of the data and store it in fft_data\n\tplan_forward = fftw_plan_dft_1d(PADDED_SIZE, data_in, fft_data, \n\t\t\t\t\t\t\t\t\tFFTW_FORWARD, FFTW_ESTIMATE);\n\tfftw_execute(plan_forward);\n\n\t// #pragma omp parallel num_threads(1) private(i, j) shared (result, sampling_frequency, J, n, scales, fft_data) default(none)\n\t// {\n\t\tdouble value;\n\n\t\tfftw_plan plan_backward;\n\t\tfftw_complex *filter_convolution, *fftw_result;\n\n\t\tfilter_convolution = (fftw_complex *) fftw_malloc( sizeof( fftw_complex )* PADDED_SIZE );\n\t\tfftw_result = \t\t (fftw_complex *) fftw_malloc( sizeof( fftw_complex )* PADDED_SIZE );\n\n\t\t// #pragma omp critical (make_plan)\n\t\t// {\n\t\t\t//Preapre for the plan backwards\n\t\t\tplan_backward = fftw_plan_dft_1d(PADDED_SIZE, filter_convolution, fftw_result, \n\t\t\t\tFFTW_BACKWARD, FFTW_ESTIMATE);\n\t\t// }\n\t\t\n\t // #pragma omp for\n\t\tfor (i = 0; i < J; ++i)\n\t\t{\n\t\t\t//Force the arrays to zero\n\t\t\tmemset(filter_convolution, 0.0, sizeof( fftw_complex ) * PADDED_SIZE);\n\t\t\tmemset(fftw_result, 0.0, sizeof( fftw_complex ) * PADDED_SIZE);\n\n\t\t\t//Compute the Fourier Morlet at 0 and N/2\n\t\t\tdouble norm = sqrt(scales[i]);\n\n\t\t\tvalue = CompleteFourierMorlet(0.0, scales[i], norm);\n\n\t\t\tfilter_convolution[0][0] = ( fft_data[0][0] / PADDED_SIZE ) * value;\n\t\t\tfilter_convolution[0][1] = ( fft_data[0][1] / PADDED_SIZE ) * value;\n\t\t\t\n\t\t\tfilter_convolution[PADDED_SIZE/2][0] = 0.0;\n\t\t\tfilter_convolution[PADDED_SIZE/2][1] = 0.0;\n\n\t\t\t//Compute the Fourier Morlet Convolution in between\n\t\t\tfor (j = 1; j < PADDED_SIZE/2 - 1; ++j)\n\t\t\t{\n\t\t\t\tvalue = CompleteFourierMorlet( j * dw , scales[i], norm);\n\n\t\t\t\tfilter_convolution[j][0] = ( fft_data[j][0] / PADDED_SIZE ) * value;\n\t\t\t\tfilter_convolution[j][1] = ( fft_data[j][1] / PADDED_SIZE ) * value;\n\n\t\t\t\tfilter_convolution[PADDED_SIZE- j][0] = 0.0;\n\t\t\t\tfilter_convolution[PADDED_SIZE- j][1] = 0.0;\n\t\t\t}\n\n\t\t\t//Take the inverse FFT. \n\t\t\tfftw_execute(plan_backward);\n\t\t \n\t\t\t//Calculate the power and store it in result\n\t\t\tfor (j = 0; j < n; ++j)\n\t\t\t{\n\t\t\t\tresult[i * n + j] = MAGNITUDE(fftw_result[j][0], fftw_result[j][1]) / ( NORMALIZATION_FACTOR * sqrt(scales[i]) );\n\t\t\t\ttemp[j] = result[i * n + j];\n\t\t\t}\n\t\t\t\n\t\t\tdouble total = 0;\n\t\t\tfor (int j = 0; j < n; ++j)\n\t\t\t{\n\t\t\t\ttotal += temp[j];\n\t\t\t}\n\n\t\t\tdouble variance = gsl_stats_variance(temp, 1, n);\n\t\t\tfprintf(debug_file, \"%.16f\\t%.16f\\t%.16f\\n\", SCALE_TO_FREQ(scales[i]), variance, total);\n\n\t\t}\n\n\t\tfree(temp);\n\t\tfclose(debug_file);\n\n\t\t//FFTW sanitation engineering. \n\t\tfftw_destroy_plan(plan_backward);\n\t fftw_free(fftw_result);\n\t fftw_free(filter_convolution);\n\t// }\n\t//Sanitation Engineering\n\tfftw_destroy_plan(plan_forward); \n\tfftw_free(fft_data); fftw_free(data_in);\n return(0);\n} /*Wavelet */\n\n\ndouble* ShortTimeFourierTransform(double * raw_data, double sampling_frequency, int n, int window_size)\n{\n\t//Variable Declarations\n\tint i, j;\n\tfftw_complex *data_in, *fft_data;\n\tfftw_plan plan_forward;\n\tdouble* result;\n\n\t// FILE * STFT_FILE = fopen(\"STFT_Result.log\", \"w\");\n\n\tint num_windows = ceil((double) n / window_size); \n\tassert(num_windows > 0);\n\n\t// const int PADDED_SIZE = CalculatePaddingSize(window_size, 1);\n\tconst int PADDED_SIZE = window_size;\n\n\n\tresult = (double*) malloc(num_windows * PADDED_SIZE * sizeof(double));\n\tdata_in = (fftw_complex *) fftw_malloc( sizeof( fftw_complex ) * PADDED_SIZE );\n\tfft_data = (fftw_complex *) fftw_malloc( sizeof( fftw_complex ) * PADDED_SIZE );\n\n\t//Calculate the FFT of the data and store it in fft_data\n\tplan_forward = fftw_plan_dft_1d(PADDED_SIZE, data_in, fft_data, \n\t\t\t\t\t\t\t\t\tFFTW_FORWARD, FFTW_ESTIMATE);\n\n\tfor (i = 0; i < num_windows; ++i)\n\t{\n\t\tmemset(data_in, 0.0, sizeof( fftw_complex ) * PADDED_SIZE);\n\t\tmemset(fft_data, 0.0, sizeof( fftw_complex ) * PADDED_SIZE);\n\n\t\t//Fill Data into FFT Array\n\t\tfor (j = 0; j < window_size; ++j)\n\t\t{\n\t\t\tif (i * window_size + j < n)\n\t\t\t{\n\t\t\t\tdata_in[j][0] = raw_data[i * window_size + j];\n\t\t\t\tdata_in[j][1] = 0.0;\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tdata_in[j][0] = 0.0;\n\t\t\t\tdata_in[j][1] = 0.0;\n\t\t\t}\n\t\t}\n\t\t\n\t\tfftw_execute(plan_forward);\n\n\t\tfor (j = 0; j < window_size / 2; ++j)\n\t\t{\n\t\t\tresult[j * num_windows + i] = MAGNITUDE(fft_data[j][0], fft_data[j][1]);\n\t\t\t// fprintf(STFT_FILE, \"%d\\t%f\\t%d\\n\", j, result[j * num_windows + i], j * num_windows + i);\n\t\t}\n\n\t}\n\n\t// fclose(STFT_FILE);\n\tfftw_destroy_plan(plan_forward); \n\tfftw_free(data_in); fftw_free(fft_data);\n\n\treturn(result);\n}\n\n\nint Find_Peaks(double* array, double* frequency, int n, int J)\n{\n\tFILE* maximum_file = fopen(\"maximum.log\", \"w\");\n\tARRAY_DATA *maximum_array = (ARRAY_DATA*) malloc (J * sizeof(ARRAY_DATA));\n\tint local_maximum_location[J];\n\tdouble* temp = (double*) malloc(n * sizeof(double));\n\n\t//Find the local maximum at every frequency\n\tfor (int i = 0; i < J; ++i)\n\t{\n\t\tARRAY_DATA max;\n\t\tmax.value = array[i * n];\n\t\tmax.index = i * n;\n\n\t\tfor (int j = 0; j < n; ++j)\n\t\t{\n\t\t\tif (array[i * n + j] > max.value)\n\t\t\t{\n\t\t\t\tmax.value = array[i * n + j];\n\t\t\t\tmax.index = i * n + j;\n\t\t\t}\n\t\t}\n\n\t\tmaximum_array[i] = max;\n\t\tfprintf(maximum_file, \"%f\\t%f\\n\", frequency[i], maximum_array[i].value);\n\t}\n\n\t//Calculate the deravitive of the signal and isolate the peaks\n\tdouble sign = (maximum_array[1].value - maximum_array[0].value) / (frequency[1] - frequency[0]);\n\tint max_count = 0;\n\tfor (int i = 0; i < J - 1; ++i)\n\t{\n\t\tdouble slope = (maximum_array[i + 1].value - maximum_array[i].value) / (frequency[i + 1] - frequency[i]);\n\t\tif (signbit(slope) != signbit(sign) && sign < 0)\n\t\t{\n\t\t\tlocal_maximum_location[max_count] = i;\n\t\t\tmax_count++;\n\t\t}\n\n\t\tsign = slope;\n\t}\n\n\t\n\tfor (int i = 0; i < max_count; ++i)\n\t{\n\t\tint arr_index = local_maximum_location[i];\n\n\t\t//Copy data into memory block\n\t\tfor (int j = 0; j < n; ++j)\n\t\t{\n\t\t\ttemp[j] = array[arr_index * n + j];\n\t\t\t// if (i == 1)\n\t\t\t// \tfprintf(maximum_file, \"%f\\t%.16f\\n\", (double) j/FS, array[arr_index * n + j]);\n\t\t\t\n\t\t}\n\n\t\tARRAY_DATA impact_site = Max(temp, n);\n\n\t\tint system_setteled = 0;\n\t\tint setteled_index = 0;\n\t\tfor (int j = impact_site.index; j < n; ++j)\n\t\t{\n\t\t\tif (temp[j] < SETTLING_PERCENTAGE * impact_site.value && system_setteled == 0)\n\t\t\t{\n\t\t\t\tsetteled_index = j;\n\t\t\t\tdouble setteled_time = (double) (setteled_index - impact_site.index)/FS;\n\t\t\t\tprintf(\"Frequency[%d]: %f, Settled Time = %f\\n\", i, frequency[arr_index], setteled_time);\n\t\t\t\tsystem_setteled = 1;\n\t\t\t}\n\t\t}\n\t}\n\n\n\tfclose(maximum_file);\n\tfree(maximum_array);\n\tfree(temp);\n\treturn(0);\n}\n\n\n\nint CalculatePaddingSize(const int array_size, const int pad_flag)\n{\n\tconst int pad = ceil(log2(array_size));\n\tint out = array_size;\n\tswitch(pad_flag)\n\t{\n\t\tcase 0: //No Padding what so ever. \n\t\t\tout = array_size;\n\t\t\tbreak;\n\t\tcase 1: //Zero - Padding and preforming a Radix-2 Operation\n\t\t\tout = (int) pow(2, pad + 1);\n \t\tbreak;\n \tcase 2: //Duplicate array and ramp up and ramp down output\n \t\tout = 2 * array_size;\n \t\tbreak;\n\n \tcase 3: //Repeat the array once. \n \t\tout = 2 * array_size;\n \t\tbreak;\n\n \tdefault: //Else return the array size\n \t\tout = array_size;\n \t\tbreak;\n\t}\n\treturn(out);\n}\n\nvoid GenerateScalesAndFrequency(const int min_i, const int max_i, const double s_0, \n\tdouble* scales, double* frequency)\n{\n\tint count = ( max_i - min_i ) + 1;\n\n\t//Populate the scales array\n\tfor (int i = 0; i < count; ++i)\n\t{\n\t\tint counterVariable = min_i + i;\n\t\tscales[i] = s_0 * pow(2, counterVariable * D_J);\n\t}\n\n\tIdentifyFrequencies(scales, count, frequency);\n\n}\n\nvoid IdentifyFrequencies(double* scales, int count, double* frequency)\n{\n\t// double * frequency = (double*) malloc( count * sizeof(double) );\n\n\tfor (int i = 0; i < count; ++i)\n\t{\n\t\tfrequency[i] = (W_0)/(scales[i] * 2 * M_PI);\n\t}\n\n}\n\ndouble CompleteFourierMorlet(double w, const double scale, double norm)\n{\n\t// double norm = 1.0/sqrt(scale);\n\t// double norm = sqrt(scale);\n\t\n\tw = w * scale; \n\tdouble out = exp( -0.5 * ( W_0 - w ) * (W_0 - w) )\n - K_SIGMA * (exp ( -0.5 * w * w));\n\n\tout = norm * C_SIGMA * QUAD_ROOT_PI * out;\n\treturn(out);\n}\n\nvoid TestCases(double *data, const int flag, double freq, double sampling_frequency, int data_size)\n{\n\t// Fit a freq signal at two points\n\t// double DT = 1./sampling_frequency;\n\tdouble fsig = freq/sampling_frequency;\n\tdouble dw = 2 * M_PI * fsig;\n\tdouble w0 = 0.001; // A SMALL PHASE SHIFT SO ITS NOT ALL INTERGER ALIGNED\n\tint one_peri = (int)1./fsig;\n\n\tdouble frequency_increment = (MAX_FREQUENCY - MIN_FREQUENCY)/ 3.0; //3.0 seconds. \n\t\n\tint t = 2 * sampling_frequency; //At 2 seconds. \n\n\tswitch(flag)\n\t{\n\t\t//Impulse at T = 2 seconds\n\t\tcase 1:\t\t\n\t\t\tfor (int i = 0; i < data_size; ++i)\n\t\t\t{\n\t\t\t\tdata[i] = 0.0;\n\t\t\t}\n\n\t\t\tdata[t] = 1.0;\n\t\t\tbreak;\n\t\t\n\t\t//Multiple Sines at t = 1500\n\t\tcase 2:\n\t\t\tfor (int i = data_size/2; i < data_size/2 + 2*one_peri; ++i)\n\t\t\t{\n\t\t\t\tdata[i] = sin((i - data_size/2)* dw + w0) + sin((i - data_size/2)* 2* dw + w0);\n\t\t\t}\n\t\t\tbreak;\n\n\t\t//Multiple Sines at all times\n\t\tcase 3:\n\t\t\tfor (int i = 0; i < data_size; ++i)\n\t\t\t{\n\t\t\t\tdata[i] = sin(i*dw + w0) + sin(i*2*dw + w0);\n\t\t\t}\n\t\t\tbreak;\n\n\t\t//Single sine at t = 1.0s;\n\t\tcase 4: \n\t\t\tfor (int i = data_size/3; i < data_size/3 + 2 * one_peri; ++i)\n\t\t\t{\n\t\t\t\tdata[i] = sin( (i - data_size/2) * dw + w0 );\n\t\t\t}\n\t\t\tbreak;\n\n\t\t\n\t\tcase 5:\n\t\t\tfor (int i = 0; i < data_size; ++i)\n\t\t\t{\n\t\t\t\tdata[i] = cos( i * dw + w0 );\n\t\t\t\t\n\t\t\t\tif (i >= data_size/2 && i <= 2 * (data_size)/3)\n\t\t\t\t{\n\t\t\t\t\tdata[i] = 2 * cos(i * dw + w0);\n\t\t\t\t}\n\t\t\t}\n\t\t\tbreak;\n\n\t\tcase 6:\n\t\t\tfor (int i = 0; i < data_size; ++i)\n\t\t\t{\n\t\t\t\tdata[i] = cos(i * dw + w0 );\n\t\t\t\tif (i >= data_size/3 && i <= data_size/2)\n\t\t\t\t{\n\t\t\t\t\tdata[i] = cos(i * (dw - 0.005) + w0);\n\t\t\t\t}\n\t\t\t}\n\t\t\tbreak;\n\n\t\t//Frequency Sweep\n\t\tcase 7:\n\t\t\tfor (int i = 0; i < data_size; ++i)\n\t\t\t{\n\t\t\t\t// fsig = frequency/sampling_frequency;\n\t\t\t\t// dw = 2*M_PI*fsig;\n\n\t\t\t\tdata[i] = sin(w0 + 2 * M_PI * (MIN_FREQUENCY + (frequency_increment/2) * pow(i/sampling_frequency, 2)) );\n\n\t\t\t\t// frequency += frequency_increment; \n\t\t\t}\n\t\t\tbreak;\n\t\t\t\n\t\t//Single sine all the way through. \n\t\tcase 8:\n\t\t\tfor (int i = 0; i < data_size; ++i)\n\t\t\t{\n\t\t\t\tdata[i] = cos(i*dw + w0);\n\t\t\t}\n\t\t\tbreak;\n\t}\n}\n\nint WriteDebug(const double *data, const int length, const int sampling_frequency,\n\tconst char* filename)\n{\n\tFILE* out_file=fopen(filename,\"w\");\n if (out_file == NULL) return -1;\n\n double t = 0.0;\n double dt = 1.0/sampling_frequency;\n\n\tfor (int i = 0; i < length; ++i)\n {\n \t// double value = (double) i/length;\n \tfprintf(out_file, \"%f\\t%.16e\\n\", t, data[i]);\n \tt += dt;\n }\n \n fclose(out_file);\n return 0;\n}\n\nvoid FillData(double * data)\n{\n\t// Fit a FREQ signal at two points\n\t// double DT = 1./FS;\n\tdouble fsig = FREQ/FS;\n\tdouble dw = 2*M_PI*fsig;\n\tdouble w0 = 0.01; // A SMALL PHASE SHIFT SO ITS NOT ALL INTERGER ALIGNED\n\tint one_peri = (int)1./fsig;\n\t// printf(\"FS %.2d Pitch %.f Discrete Period = %d \\n\",FS,FREQ,one_peri);\n\n\tfor (int i = 0; i < DATA_SIZE; ++i)\n\t{\n\t\tdata[i] = 0.0;\n\t}\n\n\t// //Impulse Sample\n\t// data[2000] = 1.0;\n\tint i;\n\t// double t=0;\n\tfor(i=0;i200)&(i<400))data[i]=sin( (i-200)*dw+w0);\n\t\tif((i>0.25*DATA_SIZE)&(i<0.25*DATA_SIZE+one_peri)) data[i]=sin( (i-200)*dw+w0);\n\t\tif((i>0.5*DATA_SIZE)&(i<0.5*DATA_SIZE+2*one_peri))data[i]=sin( (i-1000)*dw+w0);\n\t\tif((i>0.75*DATA_SIZE)&(i<0.75*DATA_SIZE+3*one_peri))data[i]=sin( (i-2000)*dw+w0);\n\t}\n}\n\nint GetFileSize(char filename[])\n{\n\tFILE* signalFile = fopen(filename, \"r\");\n\tassert(signalFile != NULL);\n\t// obtain file size:\n\tfseek (signalFile , 0 , SEEK_END);\n\tlong lSize = ftell (signalFile);\n\trewind (signalFile);\n\n\tchar * buffer = (char*) malloc(sizeof(char)*lSize);\n\tassert(buffer != NULL);\n\n\tint result = fread (buffer, 1, lSize, signalFile);\n\tassert(result == lSize);\n\n\tchar * token = strtok(buffer, \"\\n\");\n\t\n //Get input from text.\n\tint counterVariable = 0;\n\twhile (token !=NULL)\n {\n \t// data[counterVariable] = atof(token);\n \tcounterVariable++;\n token = strtok (NULL, \"\\n\");\n\n }\n fclose(signalFile);\n\n return (counterVariable);\n}\n\n\nint ReadFile(double data[], char filename[])\n{\n\tFILE* signalFile = fopen(filename, \"r\");\n\tassert(signalFile != NULL);\n\t// obtain file size:\n\tfseek (signalFile , 0 , SEEK_END);\n\tlong lSize = ftell (signalFile);\n\trewind (signalFile);\n\n\tchar * buffer = (char*) malloc(sizeof(char)*lSize);\n\tassert(buffer != NULL);\n\n\tint result = fread (buffer, 1, lSize, signalFile);\n\tassert(result == lSize);\n\t// puts(buffer);\n\n\n\tchar * token = strtok(buffer, \"\\n\");\n\t\n //Get input from text.\n\tint counterVariable = 0;\n\twhile (token !=NULL)\n {\n \tdata[counterVariable] = atof(token);\n \tcounterVariable++;\n token = strtok (NULL, \"\\n\");\n\n }\n fclose(signalFile);\n\n return (counterVariable);\n}\n\n\ndouble CWT_Cosine_Real(double time, double scale)\n{\n double norm = sqrt(scale);\n double w_o = FREQ * 2 * M_PI;\n w_o *= scale;\n double mor = exp( - 0.5 * (W_0 - w_o) * (W_0 - w_o) ) + K_SIGMA * exp( -0.5 * w_o * w_o );\n double cosine = cos(w_o * time);\n\n double out = 0.5 * C_SIGMA * QUAD_ROOT_PI * norm * mor * cosine;\n return(out);\n}\n\ndouble CWT_Cosine_Complex(double time, double scale)\n{\n double norm = sqrt(scale);\n double w_o = FREQ * 2 * M_PI;\n w_o *= scale;\n double mor = exp( - 0.5 * (W_0 - w_o) * (W_0 - w_o) ) + K_SIGMA * exp( -0.5 * w_o * w_o );\n double sine = sin(w_o * time);\n\n double out = 0.5 * C_SIGMA * QUAD_ROOT_PI * norm * mor * sine;\n return(out);\n}\n\ndouble CWT_Dirac_Real(double time, double scale)\n{\n double impulse = 2.0;\n time = (impulse - time )/scale;\n double norm = 1.0/sqrt(scale);\n double out = exp( - 0.5 * time * time ) * ( cos( W_0 * time ) - K_SIGMA );\n\n out = norm * C_SIGMA * QUAD_ROOT_PI * out;\n return(out);\n}\n\ndouble CWT_Dirac_Complex(double time, double scale)\n{\n double impulse = 2.0;\n time = (impulse - time )/scale;\n double norm = 1.0/sqrt(scale);\n double out = exp( - 0.5 * time * time ) * ( sin( W_0 * time ) - K_SIGMA );\n out = norm * C_SIGMA * QUAD_ROOT_PI * out;\n return(out);\n}\n\nARRAY_DATA Max(double * array, int size)\n{\n\tdouble max = array[0];\n\tint array_index = 0;\n\n\tARRAY_DATA out;\n\n\tfor (int i = 0; i < size; ++i)\n\t{\n\t\tif (array[i] > max)\n\t\t{\n\t\t\tmax = array[i];\n\t\t\t// if (max != max)\n\t\t\t// {\n\t\t\t// \tprintf(\"Naan Alert!\\n\");\n\t\t\t// }\n\t\t\tarray_index = i;\n\t\t}\n\t}\n\n\tout.value = max;\n\tout.index = array_index;\n\n\t// printf(\"Max: Array[%d] = %.17f\\n\", array_index, array[array_index]);\n\treturn(out);\n}\n\n/**\n \\fn int OpenFile(const char* fileName, struct edf_hdr_struct *header)\n \n \\brief Openes a .BDF file and allocates it to an edf_hdr_struct.\n\n \\param fileName The name and location of the file to be opened\n \\param header The pointer to the edf header structure\n\n \\return 0 if file is opened successfully\n \\return -1 if there is an error\n\n*/\nint OpenFile(const char* fileName, struct edf_hdr_struct *header)\n{\n if(edfopen_file_readonly(fileName, header, EDFLIB_READ_ALL_ANNOTATIONS))\n {\n switch(header->filetype)\n {\n case EDFLIB_MALLOC_ERROR : printf(\"\\nmalloc error\\n\\n\");\n break;\n case EDFLIB_NO_SUCH_FILE_OR_DIRECTORY : printf(\"\\ncan not open file, no such file or directory\\n\\n\");\n break;\n case EDFLIB_FILE_CONTAINS_FORMAT_ERRORS : printf(\"\\nthe file is not EDF(+) or BDF(+) compliant\\n\"\n \"(it contains format errors)\\n\\n\");\n break;\n case EDFLIB_MAXFILES_REACHED : printf(\"\\nto many files opened\\n\\n\");\n break;\n case EDFLIB_FILE_READ_ERROR : printf(\"\\na read error occurred\\n\\n\");\n break;\n case EDFLIB_FILE_ALREADY_OPENED : printf(\"\\nfile has already been opened\\n\\n\");\n break;\n default : printf(\"\\nunknown error\\n\\n\");\n break;\n }\n\n return(-1);\n }\n return(0);\n}\n\n/**\n \\fn int64_t FindTriggers(const int * statusInput, const int64_t numberOfRecords,\n int64_t * outputBuffer)\n\n \\brief This function should take an array input and return the rising and falling edges of the triggers. \n\n \\param statusInput: The Status Channel Input from the BDF or EDF flie. use the edfread_digital_samples\n \\param numberOfRecords: The size of statusInput\n \\param outputBuffer: a 1 x 2 * MAXIMUM_TRIGGERS int64_t array with the odd entries being the\n rising edge and the even entries being the falling edges. \n\n \\return counterVariable The number of triggers that were found. \n*/\n\n\nint FindTriggers(const int * statusInput, const int64_t numberOfRecords,\n int64_t * outputBuffer)\n{\n int64_t counterVariable = 0;\n int counterVariable_int = 0;\n //int i needs to be int64_t because we are recording it into a int64_t arrray. \n int edge = 0;\n for (int64_t i = 0; i < numberOfRecords; ++i)\n {\n //Bit and the lower 16 bits to see if any of the triggers have been triggered to on. \n if ( ((statusInput[i] & 0x0000FFFF) > 0) && (edge == 0) && (statusInput[i-1] != statusInput[i]) ) //Rising Edge Detected.\n {\n outputBuffer[counterVariable] = i;\n // printf(\"outputBuffer[%\" PRId64 \"] = %\" PRId64\"\\n\", counterVariable, outputBuffer[counterVariable]);\n \n counterVariable++;\n counterVariable_int++;\n edge = 1;\n }\n\n if (statusInput[i-1] != statusInput[i] && edge == 1) //Falling Edge Detected.\n {\n edge = 0;\n }\n\n if (counterVariable > MAXIMUM_TRIGGERS)\n return -1;\n }\n\n return(counterVariable_int);\n}\n\n/**\n \\fn int FilterTriggers(const int code, const int button, const int numberOfRecords, \n const int64_t * triggerList,\n const int * readBuffer, \n int * outputBuffer)\n\n \\brief Filteres the triggers coming in, and finds the specified events\n\n \\param code The code of the trigger list that is needed \n Possible Inputs: 1, or 2\n \\param button The code of the button that is needed\n Possible Inputs 1, or 2\n \\param triggerList The list of all of the possible triggers\n \\param readBuffer The Status Channel input from the file\n \n \\param outputBuffer The buffer that FilterTriggers will populate with the location of the location of the triggers that we're looking for\n\n \\return counterVariable The number of triggers found.\n*/\n\nint FilterTriggers(const int code, \n const int button, \n const int numberOfRecords, \n const int64_t * triggerList,\n const int * readBuffer, \n int * outputBuffer)\n{\n int readCode;\n int buttonCode;\n int counterVariable = 0;\n for (int i = 0; i < numberOfRecords; ++i)\n {\n readCode = readBuffer[i] & 255;\n buttonCode = (readBuffer[i] >> 8) & 3;\n\n if ( (readCode == code) && (buttonCode == button) )\n {\n outputBuffer[counterVariable] = triggerList[i];\n counterVariable++;\n }\n }\n return counterVariable;\n}\n\nvoid CleanData(double * data, double n)\n{\n double mean = gsl_stats_mean(data, 1, n);\n double sDeviation = gsl_stats_sd_m(data, 1, n, mean);\n // printf(\"Mean: %f, SD: %f\\n\", mean, sDeviation);\n\n //Compute the Z-Score or Standard Score\n for (int i = 0; i < n; ++i)\n {\n data[i] = (data[i] - mean)/sDeviation;\n }\n}\n\nint WriteFile(const double *data, const double *frequency, const int x, const int y, int sampling_frequency,\n const char filename[])\n{\n\n FILE* out_file=fopen(filename,\"w\");\n if (out_file == NULL) return -1;\n\n //Xticks\n fprintf(out_file, \"%d\\t\", x);\n for (int i = 0; i < y; ++i)\n {\n fprintf(out_file, \"%f\\t\", (double) i/sampling_frequency);\n }\n fprintf(out_file, \"\\n\");\n\n // double small_eps = 0.00001; //Add a small eps so that logs of zero don't happen. \n for (int i = 0; i < x; ++i)\n {\n //Feed Frequency\n fprintf(out_file, \"%f\\t\", frequency[i]);\n\n //Feed Data\n for (int j = 0; j < y; ++j)\n {\n // value = Magnitude(result[i*n + j], result[i*n + j]);\n fprintf(out_file, \"%.16e\\t\", data[i*y + j]);\n }\n //Ready for the next line.\n fprintf(out_file, \"\\n\");\n\n }\n\n fclose(out_file);\n return(0);\n}\n\nint WriteGnuplotScript(const char graph_title[], const char filename[])\n{\n FILE* gnuplot_file = fopen(\"script.gplot\", \"w\");\n if (gnuplot_file == NULL) return -1;\n \n // fprintf(gnuplot_file, \"set term x11\\n\");\n \n // fprintf(gnuplot_file, \"set logscale z 10\\n\");\n\n fprintf(gnuplot_file, \"set term pngcairo enhanced font 'arial,12'\\n\");\n fprintf(gnuplot_file, \"%s%s%s\",\"set output '\", graph_title, \".png' \\n\");\n fprintf(gnuplot_file, \"set pm3d map\\n\");\n fprintf(gnuplot_file, \"set logscale y 2\\n\");\n fprintf(gnuplot_file, \"set ticslevel 0\\n\");\n fprintf(gnuplot_file, \"set xlabel \\\"time (s)\\\"\\n\");\n fprintf(gnuplot_file, \"set ylabel \\\"Frequency (Hz)\\\"\\n\");\n\n //Input Graph Title\n fprintf(gnuplot_file, \"%s%s%s\\n\", \"set title \\\"\", graph_title, \"\\\"\");\n //Plot filename\n // plot \"DATA.log\" matrix nonuniform with pm3d t ''\n fprintf(gnuplot_file, \"%s%s%s\\n\", \"splot \\\"\", filename, \"\\\" matrix nonuniform with pm3d t ''\");\n // fprintf(gnuplot_file, \"pause -1 \\\"Hit Return to continue\\\"\");\n\n return(0);\n}", "meta": {"hexsha": "3a15538b5fbee523ab89dab74697303ab28bb470", "size": 24222, "ext": "c", "lang": "C", "max_stars_repo_path": "src/wavelet.c", "max_stars_repo_name": "yuvashankar/Research", "max_stars_repo_head_hexsha": "bc96cd74939a7022d64dbea86483fb4a579dd24d", "max_stars_repo_licenses": ["Unlicense"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/wavelet.c", "max_issues_repo_name": "yuvashankar/Research", "max_issues_repo_head_hexsha": "bc96cd74939a7022d64dbea86483fb4a579dd24d", "max_issues_repo_licenses": ["Unlicense"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/wavelet.c", "max_forks_repo_name": "yuvashankar/Research", "max_forks_repo_head_hexsha": "bc96cd74939a7022d64dbea86483fb4a579dd24d", "max_forks_repo_licenses": ["Unlicense"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 28.0997679814, "max_line_length": 141, "alphanum_fraction": 0.6082074147, "num_tokens": 7264, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7279754489059775, "lm_q2_score": 0.7057850216484838, "lm_q1q2_score": 0.51379416796567}} {"text": "/*\n * projcl_run.c\n * Magic Maps\n *\n * Created by Evan Miller on 2/12/11.\n * Copyright 2011 __MyCompanyName__. All rights reserved.\n *\n */\n\n#include \n#include \n#include \"projcl_run.h\"\n#include \"projcl_kernel.h\"\n#include \"projcl_util.h\"\n#include \"projcl_spheroid.h\"\n\n#include \n#include \n#include \n#ifdef __APPLE__\n#include \n#endif\n#ifdef __linux__\n#include \ntypedef int __CLPK_integer;\ntypedef double __CLPK_doublereal;\nextern int dgetrf_(__CLPK_integer *, __CLPK_integer *, __CLPK_doublereal *, __CLPK_integer *, __CLPK_integer *, __CLPK_integer *);\nextern int dgetri_(__CLPK_integer *, __CLPK_doublereal *, __CLPK_integer *, __CLPK_integer *, __CLPK_doublereal *, __CLPK_integer *, __CLPK_integer *);\n#endif\n\n#define EPS7 1.e-7\n\n#define SEC_TO_RAD 4.84813681109535993589914102357e-6\n\nstatic cl_int pl_enqueue_kernel_albers_equal_area(PLContext *pl_ctx, cl_kernel kernel,\n PLProjectionParams *params, cl_mem xy_in, cl_mem xy_out, size_t count);\nstatic cl_int pl_enqueue_kernel_american_polyconic(PLContext *pl_ctx, cl_kernel kernel,\n PLProjectionParams *params, cl_mem xy_in, cl_mem xy_out, size_t count);\nstatic cl_int pl_enqueue_kernel_lambert_azimuthal_equal_area(PLContext *pl_ctx, cl_kernel kernel,\n PLProjectionParams *params, cl_mem xy_in, cl_mem xy_out, size_t count);\nstatic cl_int pl_enqueue_kernel_lambert_conformal_conic(PLContext *pl_ctx, cl_kernel kernel,\n PLProjectionParams *params, cl_mem xy_in, cl_mem xy_out, size_t count);\nstatic cl_int pl_enqueue_kernel_mercator(PLContext *pl_ctx, cl_kernel kernel,\n PLProjectionParams *params, cl_mem xy_in, cl_mem xy_out, size_t count);\nstatic cl_int pl_enqueue_kernel_oblique_stereographic(PLContext *pl_ctx, cl_kernel kernel,\n PLProjectionParams *params, cl_mem xy_in, cl_mem xy_out, size_t count);\nstatic cl_int pl_enqueue_kernel_robinson(PLContext *pl_ctx, cl_kernel kernel,\n PLProjectionParams *params, cl_mem xy_in, cl_mem xy_out, size_t count);\nstatic cl_int pl_enqueue_kernel_transverse_mercator(PLContext *pl_ctx, cl_kernel kernel,\n PLProjectionParams *params, cl_mem xy_in, cl_mem xy_out, size_t count);\nstatic cl_int pl_enqueue_kernel_winkel_tripel(PLContext *pl_ctx, cl_kernel kernel,\n PLProjectionParams *params, cl_mem xy_in, cl_mem xy_out, size_t count);\n\nstruct pl_projection_info {\n PLProjection proj;\n char name[80];\n cl_int (*func)(PLContext *pl_ctx,\n cl_kernel kernel,\n PLProjectionParams *params,\n cl_mem xy_in,\n cl_mem xy_out,\n size_t count);\n};\n\nstatic struct pl_projection_info _pl_projection_info[] = {\n {\n .proj = PL_PROJECT_ALBERS_EQUAL_AREA,\n .name = \"albers_equal_area\",\n .func = &pl_enqueue_kernel_albers_equal_area,\n },\n {\n .proj = PL_PROJECT_AMERICAN_POLYCONIC,\n .name = \"american_polyconic\",\n .func = &pl_enqueue_kernel_american_polyconic,\n },\n {\n .proj = PL_PROJECT_LAMBERT_AZIMUTHAL_EQUAL_AREA,\n .name = \"lambert_azimuthal_equal_area\",\n .func = &pl_enqueue_kernel_lambert_azimuthal_equal_area,\n },\n {\n .proj = PL_PROJECT_LAMBERT_CONFORMAL_CONIC,\n .name = \"lambert_conformal_conic\",\n .func = &pl_enqueue_kernel_lambert_conformal_conic,\n },\n {\n .proj = PL_PROJECT_MERCATOR,\n .name = \"mercator\",\n .func = &pl_enqueue_kernel_mercator,\n },\n {\n .proj = PL_PROJECT_OBLIQUE_STEREOGRAPHIC,\n .name = \"oblique_stereographic\",\n .func = &pl_enqueue_kernel_oblique_stereographic,\n },\n {\n .proj = PL_PROJECT_ROBINSON,\n .name = \"robinson\",\n .func = &pl_enqueue_kernel_robinson,\n },\n {\n .proj = PL_PROJECT_TRANSVERSE_MERCATOR,\n .name = \"transverse_mercator\",\n .func = &pl_enqueue_kernel_transverse_mercator,\n },\n {\n .proj = PL_PROJECT_WINKEL_TRIPEL,\n .name = \"winkel_tripel\",\n .func = &pl_enqueue_kernel_winkel_tripel,\n }\n};\n\nstruct pl_datum_info {\n double dx;\n double dy;\n double dz;\n double ex;\n double ey;\n double ez;\n double ppm;\n};\n\n/* Source: \"WGS 84 Implementation Manual\" */\nstatic struct pl_datum_info pl_datum_params[] = {\n /* Dx Dy Dz Ex Ey Ez m */\n \n { /* PL_DATUM_WGS_84 */\n 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 },\n { /* PL_DATUM_WGS_72 */\n 0.0, 0.0, 4.5, 0.0, 0.0, -0.554, 0.22 },\n { /* PL_DATUM_ED_50 */\n -87.0, -98.0, -121.0, 0.0, 0.0, 0.0, 0.0 },\n { /* PL_DATUM_ED_79 */\n -86.0, -98.0, -119.0, 0.0, 0.0, 0.0, 0.0 },\n { /* PL_DATUM_ED_87 */\n -82.5, -91.7, -117.7, 0.1338, -0.0625, -0.047, 0.045 },\n { /* PL_DATUM_AUSTRIA_NS */\n 595.6, 87.3, 473.3, 4.7994, 0.0671, 5.7850, 2.555 },\n { /* PL_DATUM_BELGIUM_50 */\n -55.0, 49.0, -158.0, 0.0, 0.0, 0.0, 0.0 },\n { /* PL_DATUM_BERNE_1873 */\n 649.0, 9.0, 376.0, 0.0, 0.0, 0.0, 0.0 },\n { /* PL_DATUM_CH_1903 */\n 660.1, 13.1, 369.2, 0.8048, 0.5777, 0.9522, 5.660 },\n { /* PL_DATUM_DANISH_GI_1934 */\n 662.0, 18.0, 734.0, 0.0, 0.0, 0.0, 0.0 },\n { /* PL_DATUM_NOUV_TRIG_DE_FRANCE_GREENWICH */\n -168.0, -60.0, 320.0, 0.0, 0.0, 0.0, 0.0 },\n { /* PL_DATUM_NOUV_TRIG_DE_FRANCE_PARIS */\n -168.0, -60.0, 320.0, 0.0, 0.0, 8414.03, 0.0 },\n { /* PL_DATUM_POTSDAM */\n 587.0, 16.0, 393.0, 0.0, 0.0, 0.0, 0.0 },\n { /* PL_DATUM_GGRS_87 */\n 199.6, -75.1, -246.3, 0.0202, 0.0034, 0.0135, -0.015 },\n { /* PL_DATUM_HJORSEY_55 */\n -73.0, 46.0, -86.0, 0.0, 0.0, 0.0, 0.0 },\n { /* PL_DATUM_IRELAND_65 */\n 506.0, -122.0, 611.0, 0.0, 0.0, 0.0, 0.0 },\n { /* PL_DATUM_ITALY_1940 */\n -133.0, -50.0, 97.0, 0.0, 0.0, 44828.40, 0.0 },\n { /* PL_DATUM_NOUV_TRIG_DE_LUX */\n -262.0, 75.0, 25.0, 0.0, 0.0, 0.0, 0.0 },\n { /* PL_DATUM_NETHERLANDS_1921 */\n 719.0, 47.0, 640.0, 0.0, 0.0, 0.0, 0.0 },\n { /* PL_DATUM_OSGB_36 */\n 375.0, -111.0, 431.0, 0.0, 0.0, 0.0, 0.0 },\n { /* PL_DATUM_PORTUGAL_DLX */\n 504.1, -220.9, 563.0, 0.0, 0.0, -0.554, 0.220 },\n { /* PL_DATUM_PORTUGAL_1973 */\n 227.0, 97.5, 35.4, 0.0, 0.0, -0.554, 0.220 },\n { /* PL_DATUM_RNB_72 */\n -104.0, 80.0, -75.0, 0.0, 0.0, 0.0, 0.0 },\n { /* PL_DATUM_RT_90 */\n 424.3, -80.5, 613.1, 4.3965, -1.9866, 5.1846, 0.0 },\n { /* PL_DATUM_NAD_27 */\n -8.0, 160.0, 176.0, 0.0, 0.0, 0.0, 0.0 },\n { /* PL_DATUM_NAD_83 */\n 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 },\n { /* PL_DATUM_ETRS_89 */\n 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 }\n};\n\nstruct pl_matrix {\n double elements[4][4];\n};\n\nstatic struct pl_matrix pl_affine_transform_make(\n double Rx, double Ry, double Rz, double M,\n double Dx, double Dy, double Dz) {\n /* store in column-major order */\n struct pl_matrix matrix = {\n .elements = {\n { M, M * Rz, -M * Ry, 0.f },\n {-M * Rz, M, M * Rx, 0.f },\n { M * Ry, -M * Rx, M, 0.f },\n { Dx, Dy, Dz, 1.f }\n }\n };\n return matrix;\n}\n\nstatic const char *_pl_proj_name(PLProjection proj) {\n int i=0;\n const char *name = NULL;\n for (i=0; itag)) {\n error |= pl_set_kernel_arg_float(ctx, kernel, offset++, info->ecc);\n error |= pl_set_kernel_arg_float(ctx, kernel, offset++, info->ecc2);\n error |= pl_set_kernel_arg_float(ctx, kernel, offset++, info->one_ecc2);\n\t}\n\t\n\t*offset_ptr = offset;\n\t\n\treturn error;\n}\n\ncl_kernel pl_find_projection_kernel(PLContext *pl_ctx, PLProjection proj, int fwd, PLSpheroid ell) {\n\tchar requested_name[128];\n\tif (fwd) {\n\t\tsprintf(requested_name, \"pl_project_%s_%c\", _pl_proj_name(proj), _pl_spheroid_is_spherical(ell) ? 's' : 'e');\n\t} else {\n\t\tsprintf(requested_name, \"pl_unproject_%s_%c\", _pl_proj_name(proj), _pl_spheroid_is_spherical(ell) ? 's' : 'e');\n\t}\n\treturn pl_find_kernel(pl_ctx, requested_name);\n}\n\n\nstatic cl_int _pl_enqueue_kernel_1d(cl_command_queue queue, cl_kernel kernel, size_t dim_count) {\n cl_int error = CL_SUCCESS;\n\terror = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, &dim_count, NULL, 0, NULL, NULL);\n return error;\n}\n\ncl_int pl_read_buffer(cl_command_queue queue, cl_mem xy_out_buf, float *xy_out, size_t out_count) {\n cl_int error;\n\n error = clEnqueueReadBuffer(queue, xy_out_buf, CL_TRUE, 0, out_count, xy_out, 0, NULL, NULL);\n\tif (error != CL_SUCCESS)\n\t\treturn error;\n\t\n\terror = clFinish(queue);\n\tif (error != CL_SUCCESS)\n\t\treturn error;\n\t\n\treturn CL_SUCCESS;\n}\n\nstatic cl_int _pl_enqueue_projection_kernel(PLContext *pl_ctx, cl_kernel kernel, PLProjection proj, PLProjectionParams *params,\n cl_mem xy_in, cl_mem xy_out, size_t count) {\n cl_int error = CL_SUCCESS;\n int i;\n for (i=0; ixy_in, pl_buf->xy_out, pl_buf->count);\n}\n\ncl_int pl_enqueue_projection_kernel_grid(PLContext *pl_ctx, cl_kernel kernel, PLProjection proj, PLProjectionParams *params,\n PLPointGridBuffer *src, PLPointGridBuffer *dst) {\n return _pl_enqueue_projection_kernel(pl_ctx, kernel, proj, params, src->grid, dst->grid, src->width * src->height);\n}\n\ncl_int pl_enqueue_kernel_albers_equal_area(PLContext *pl_ctx, cl_kernel kernel,\n PLProjectionParams *params, cl_mem xy_in, cl_mem xy_out, size_t count) {\n\tcl_int error = CL_SUCCESS;\n\tcl_int argc = 0;\n\tsize_t vec_count = ck_padding(count, PL_FLOAT_VECTOR_SIZE) / PL_FLOAT_VECTOR_SIZE;\n\tPLSpheroidInfo info = _pl_get_spheroid_info(params->spheroid);\n\terror = _pl_set_projection_kernel_args(pl_ctx, kernel, xy_in, xy_out, count, &info, &argc);\n\t\n\tdouble phi1 = params->rlat1 * DEG_TO_RAD;\n\tdouble phi2 = params->rlat2 * DEG_TO_RAD;\n\tdouble phi0 = params->lat0 * DEG_TO_RAD;\n \n\tdouble rho0;\n\tdouble c, n;\n double sinphi, cosphi;\n\t\n\tn = sinphi = sin(phi1);\n\tcosphi = cos(phi1);\n\t\n\tif (_pl_spheroid_is_spherical(params->spheroid)) {\n n = .5 * (sinphi + sin(phi2));\n c = 1.0 + sin(phi2) * sinphi;\n rho0 = sqrt(c - 2.f * n * sin(phi0));\n\t} else {\n\t\tdouble ml1, m1;\n\t\t\n\t\tm1 = _pl_msfn(sinphi, cosphi, info.ecc2);\n\t\tml1 = _pl_qsfn(sinphi, info.ecc, info.one_ecc2);\n\t\tif (fabs(phi1 - phi2) >= EPS7) {\n\t\t\tdouble ml2, m2;\n\t\t\t\n\t\t\tsinphi = sin(phi2);\n\t\t\tcosphi = cos(phi2);\n\t\t\tm2 = _pl_msfn(sinphi, cosphi, info.ecc2);\n\t\t\tml2 = _pl_qsfn(sinphi, info.ecc, info.one_ecc2);\n\t\t\tn = (m1 * m1 - m2 * m2) / (ml2 - ml1);\n\t\t}\n \n\t\tc = m1 * m1 + ml1 * n;\n\t\trho0 = sqrt(c - n * _pl_qsfn(sin(phi0), info.ecc, info.one_ecc2));\n\t}\n\t\n\tif (!_pl_spheroid_is_spherical(params->spheroid)) {\n\t\terror |= pl_set_kernel_arg_float(pl_ctx, kernel, argc++, info.ec);\n\t}\n error |= pl_set_kernel_arg_float(pl_ctx, kernel, argc++, params->scale * info.major_axis / n);\n error |= pl_set_kernel_arg_float(pl_ctx, kernel, argc++, params->x0);\n error |= pl_set_kernel_arg_float(pl_ctx, kernel, argc++, params->y0);\n\terror |= pl_set_kernel_arg_float(pl_ctx, kernel, argc++, params->lon0 * DEG_TO_RAD);\n\terror |= pl_set_kernel_arg_float(pl_ctx, kernel, argc++, rho0);\n\terror |= pl_set_kernel_arg_float(pl_ctx, kernel, argc++, c);\n\terror |= pl_set_kernel_arg_float(pl_ctx, kernel, argc++, n);\n \n\tif (error != CL_SUCCESS)\n\t\treturn error;\n\t\n\treturn _pl_enqueue_kernel_1d(pl_ctx->queue, kernel, vec_count);\n}\n\ncl_int pl_enqueue_kernel_american_polyconic(PLContext *pl_ctx,cl_kernel kernel,\n PLProjectionParams *params, cl_mem xy_in, cl_mem xy_out, size_t count) {\n\tcl_int error;\n\tcl_int offset = 0;\n\tsize_t vec_count = ck_padding(count, PL_FLOAT_VECTOR_SIZE) / PL_FLOAT_VECTOR_SIZE;\n\tPLSpheroidInfo info = _pl_get_spheroid_info(params->spheroid);\n\terror = _pl_set_projection_kernel_args(pl_ctx, kernel, xy_in, xy_out, count, &info, &offset);\n\t\n\tdouble phi0 = params->lat0 * DEG_TO_RAD;\n\t\n\tdouble ml0 = _pl_mlfn(phi0, sin(phi0), cos(phi0), info.en);\n\t\n\terror |= pl_set_kernel_arg_float(pl_ctx, kernel, offset++, params->scale * info.major_axis);\n error |= pl_set_kernel_arg_float(pl_ctx, kernel, offset++, params->x0);\n error |= pl_set_kernel_arg_float(pl_ctx, kernel, offset++, params->y0);\n\terror |= pl_set_kernel_arg_float(pl_ctx, kernel, offset++, phi0);\n\terror |= pl_set_kernel_arg_float(pl_ctx, kernel, offset++, params->lon0 * DEG_TO_RAD);\n if (!_pl_spheroid_is_spherical(params->spheroid)) {\n error |= pl_set_kernel_arg_float(pl_ctx, kernel, offset++, ml0);\n error |= pl_set_kernel_arg_float8(pl_ctx, kernel, offset++, info.en);\n }\n\tif (error != CL_SUCCESS) {\n\t\treturn error;\n\t}\n\t\n\treturn _pl_enqueue_kernel_1d(pl_ctx->queue, kernel, vec_count);\n}\n\ncl_int pl_enqueue_kernel_lambert_azimuthal_equal_area(PLContext *pl_ctx, cl_kernel kernel,\n PLProjectionParams *params, cl_mem xy_in, cl_mem xy_out, size_t count) {\n cl_int error;\n cl_int offset = 0;\n size_t vec_count = ck_padding(count, PL_FLOAT_VECTOR_SIZE) / PL_FLOAT_VECTOR_SIZE;\n\tPLSpheroidInfo info = _pl_get_spheroid_info(params->spheroid);\n\terror = _pl_set_projection_kernel_args(pl_ctx, kernel, xy_in, xy_out, count, &info, &offset);\n \n\tdouble phi0 = params->lat0 * DEG_TO_RAD;\n\n\terror |= pl_set_kernel_arg_float(pl_ctx, kernel, offset++, params->scale * info.major_axis);\n error |= pl_set_kernel_arg_float(pl_ctx, kernel, offset++, params->x0);\n error |= pl_set_kernel_arg_float(pl_ctx, kernel, offset++, params->y0);\n error |= pl_set_kernel_arg_float(pl_ctx, kernel, offset++, phi0);\n error |= pl_set_kernel_arg_float(pl_ctx, kernel, offset++, params->lon0 * DEG_TO_RAD);\n if (_pl_spheroid_is_spherical(params->spheroid)) {\n error |= pl_set_kernel_arg_float(pl_ctx, kernel, offset++, sin(phi0));\n error |= pl_set_kernel_arg_float(pl_ctx, kernel, offset++, cos(phi0));\n } else {\n double qp = _pl_qsfn(1.0, info.ecc, info.one_ecc2);\n double sinPhi = sin(phi0);\n double sinB1 = _pl_qsfn(sinPhi, info.ecc, info.one_ecc2) / qp;\n double cosB1 = sqrt(1.0 - sinB1 * sinB1);\n\n double rq = sqrt(0.5 * qp);\n double dd = cos(phi0) / (sqrt(1.0 - info.ecc2 * sinPhi * sinPhi) * rq * cosB1);\n double ymf = rq / dd;\n double xmf = rq * dd;\n\n error |= pl_set_kernel_arg_float(pl_ctx, kernel, offset++, qp);\n error |= pl_set_kernel_arg_float(pl_ctx, kernel, offset++, sinB1);\n error |= pl_set_kernel_arg_float(pl_ctx, kernel, offset++, cosB1);\n\n error |= pl_set_kernel_arg_float(pl_ctx, kernel, offset++, rq);\n error |= pl_set_kernel_arg_float4(pl_ctx, kernel, offset++, info.apa);\n\n error |= pl_set_kernel_arg_float(pl_ctx, kernel, offset++, dd);\n error |= pl_set_kernel_arg_float(pl_ctx, kernel, offset++, xmf);\n error |= pl_set_kernel_arg_float(pl_ctx, kernel, offset++, ymf);\n }\n if (error != CL_SUCCESS) {\n\t\treturn error;\n\t}\n \n return _pl_enqueue_kernel_1d(pl_ctx->queue, kernel, vec_count);\n}\n\ncl_int pl_enqueue_kernel_lambert_conformal_conic(PLContext *pl_ctx, cl_kernel kernel,\n PLProjectionParams *params, cl_mem xy_in, cl_mem xy_out, size_t count) {\n cl_int error;\n cl_int offset = 0;\n \n size_t vec_count = ck_padding(count, PL_FLOAT_VECTOR_SIZE) / PL_FLOAT_VECTOR_SIZE;\n PLSpheroidInfo info = _pl_get_spheroid_info(params->spheroid);\n error = _pl_set_projection_kernel_args(pl_ctx, kernel, xy_in, xy_out, count, &info, &offset);\n \n double phi0 = params->lat0 * DEG_TO_RAD;\n double phi1 = params->rlat1 * DEG_TO_RAD;\n double phi2 = params->rlat2 * DEG_TO_RAD;\n \n double rho0, c, n, sinphi1, cosphi1, sinphi2;\n int secant = 0;\n \n sinphi1 = sin(phi1);\n cosphi1 = cos(phi1);\n if (fabs(phi1 - phi2) < 1.e-7) {\n n = sinphi1;\n } else {\n secant = 1;\n }\n \n if (_pl_spheroid_is_spherical(params->spheroid)) {\n if (secant)\n n = log(cosphi1 / cos(phi2)) / (asinh(tan(phi2)) - asinh(tan(phi1)));\n c = cosphi1 * pow(tan(M_PI_4 + .5 * phi1), n) / n;\n rho0 = c * pow(tan(M_PI_4 + .5 * phi0), -n);\n } else {\n double m1, ml1;\n \n m1 = _pl_msfn(sinphi1, cosphi1, info.ecc2);\n ml1 = _pl_tsfn(phi1, sinphi1, info.ecc);\n if (secant) {\n sinphi2 = sin(phi2);\n n = log(m1 / _pl_msfn(sinphi2, cos(phi2), info.ecc2));\n n /= log(ml1 / _pl_tsfn(phi2, sinphi2, info.ecc));\n }\n c = m1 * pow(ml1, -n) / n;\n rho0 = c * pow(_pl_tsfn(phi0, sin(phi0), info.ecc), n);\n }\n \n error |= pl_set_kernel_arg_float(pl_ctx, kernel, offset++, params->scale * info.major_axis);\n error |= pl_set_kernel_arg_float(pl_ctx, kernel, offset++, params->x0);\n error |= pl_set_kernel_arg_float(pl_ctx, kernel, offset++, params->y0);\n error |= pl_set_kernel_arg_float(pl_ctx, kernel, offset++, params->lon0 * DEG_TO_RAD);\n error |= pl_set_kernel_arg_float(pl_ctx, kernel, offset++, rho0);\n error |= pl_set_kernel_arg_float(pl_ctx, kernel, offset++, c);\n error |= pl_set_kernel_arg_float(pl_ctx, kernel, offset++, n);\n \n if (error != CL_SUCCESS) {\n\t\treturn error;\n\t}\n \n return _pl_enqueue_kernel_1d(pl_ctx->queue, kernel, vec_count);\n}\n\ncl_int pl_enqueue_kernel_mercator(PLContext *pl_ctx, cl_kernel kernel,\n PLProjectionParams *params, cl_mem xy_in, cl_mem xy_out, size_t count) {\n\tcl_int error;\n\tcl_int offset = 0;\n\tsize_t vec_count = ck_padding(count, PL_FLOAT_VECTOR_SIZE) / PL_FLOAT_VECTOR_SIZE;\n\t\n\tPLSpheroidInfo info = _pl_get_spheroid_info(params->spheroid);\n\terror = _pl_set_projection_kernel_args(pl_ctx, kernel, xy_in, xy_out, count, &info, &offset);\n\t\n\terror |= pl_set_kernel_arg_float(pl_ctx, kernel, offset++, params->scale * info.major_axis);\n error |= pl_set_kernel_arg_float(pl_ctx, kernel, offset++, params->x0);\n error |= pl_set_kernel_arg_float(pl_ctx, kernel, offset++, params->y0);\n\tif (error != CL_SUCCESS) {\n\t\treturn error;\n\t}\n\treturn _pl_enqueue_kernel_1d(pl_ctx->queue, kernel, vec_count);\n}\n\ncl_int pl_enqueue_kernel_oblique_stereographic(PLContext *pl_ctx, cl_kernel kernel,\n PLProjectionParams *params, cl_mem xy_in, cl_mem xy_out, size_t count) {\n\tcl_int error = CL_SUCCESS;\n\tcl_int argc = 0;\n\tsize_t vec_count = ck_padding(count, PL_FLOAT_VECTOR_SIZE) / PL_FLOAT_VECTOR_SIZE;\n\tPLSpheroidInfo info = _pl_get_spheroid_info(params->spheroid);\n\n\terror = _pl_set_projection_kernel_args(pl_ctx, kernel, xy_in, xy_out, count, &info, &argc);\n\n double phi0 = params->lat0 * DEG_TO_RAD;\n\n double sinPhi0, cosPhi0;\n sinPhi0 = sin(phi0);\n cosPhi0 = cos(phi0);\n\n double sinPhiC0, cosPhiC0;\n double scale_r2 = 2.0 * params->scale * info.major_axis * sqrt(info.one_ecc2) / (1.0 - info.ecc2 * sinPhi0 * sinPhi0);\n\n\terror |= pl_set_kernel_arg_float(pl_ctx, kernel, argc++, scale_r2);\n\terror |= pl_set_kernel_arg_float(pl_ctx, kernel, argc++, params->x0);\n\terror |= pl_set_kernel_arg_float(pl_ctx, kernel, argc++, params->y0);\n\n\tif (!_pl_spheroid_is_spherical(params->spheroid)) {\n double c0 = sqrt(1.0 + info.ecc2 * cosPhi0 * cosPhi0 * cosPhi0 * cosPhi0 / info.one_ecc2);\n double phiC0 = asin(sinPhi0 / c0);\n sinPhiC0 = sin(phiC0);\n cosPhiC0 = cos(phiC0);\n\n double k0 = tan(0.5 * phiC0 + M_PI_4) / (\n pow(tan(0.5 * phi0 + M_PI_4), c0) *\n pow((1.-info.ecc * sinPhi0)/(1.+info.ecc*sinPhi0), 0.5 * c0 * info.ecc) );\n\n\t\terror |= pl_set_kernel_arg_float(pl_ctx, kernel, argc++, c0);\n\t\terror |= pl_set_kernel_arg_float(pl_ctx, kernel, argc++, log(k0));\n\t} else {\n sinPhiC0 = sinPhi0;\n cosPhiC0 = cosPhi0;\n }\n\n\terror |= pl_set_kernel_arg_float(pl_ctx, kernel, argc++, params->lon0 * DEG_TO_RAD);\n\terror |= pl_set_kernel_arg_float(pl_ctx, kernel, argc++, sinPhiC0);\n\terror |= pl_set_kernel_arg_float(pl_ctx, kernel, argc++, cosPhiC0);\n\tif (error != CL_SUCCESS)\n\t\treturn error;\n\t\n\treturn _pl_enqueue_kernel_1d(pl_ctx->queue, kernel, vec_count);\n}\n\ncl_int pl_enqueue_kernel_robinson(PLContext *pl_ctx, cl_kernel kernel,\n PLProjectionParams *params, cl_mem xy_in, cl_mem xy_out, size_t count) {\n\tcl_int error = CL_SUCCESS;\n\tcl_int argc = 0;\n\t\n\tPLSpheroidInfo info = _pl_get_spheroid_info(PL_SPHEROID_SPHERE);\n\n\terror |= pl_set_kernel_arg_mem(pl_ctx, kernel, argc++, xy_in);\n\terror |= pl_set_kernel_arg_mem(pl_ctx, kernel, argc++, xy_out);\n\terror |= pl_set_kernel_arg_uint(pl_ctx, kernel, argc++, count);\n\n\terror |= pl_set_kernel_arg_float(pl_ctx, kernel, argc++, params->scale * info.major_axis);\n\terror |= pl_set_kernel_arg_float(pl_ctx, kernel, argc++, params->x0);\n\terror |= pl_set_kernel_arg_float(pl_ctx, kernel, argc++, params->y0);\n\tif (error != CL_SUCCESS)\n\t\treturn error;\n\t\n\treturn _pl_enqueue_kernel_1d(pl_ctx->queue, kernel, count);\n}\n\ncl_int pl_enqueue_kernel_transverse_mercator(PLContext *pl_ctx, cl_kernel kernel,\n PLProjectionParams *params, cl_mem xy_in, cl_mem xy_out, size_t count) {\n cl_int error = CL_SUCCESS;\n cl_int argc = 0;\n size_t vec_count = ck_padding(count, PL_FLOAT_VECTOR_SIZE) / PL_FLOAT_VECTOR_SIZE;\n \n PLSpheroidInfo info = _pl_get_spheroid_info(params->spheroid);\n error = _pl_set_projection_kernel_args(pl_ctx, kernel, xy_in, xy_out, count, &info, &argc);\n \n error |= pl_set_kernel_arg_float(pl_ctx, kernel, argc++, params->scale * info.major_axis * info.krueger_A);\n error |= pl_set_kernel_arg_float(pl_ctx, kernel, argc++, params->x0);\n error |= pl_set_kernel_arg_float(pl_ctx, kernel, argc++, params->y0);\n error |= pl_set_kernel_arg_float(pl_ctx, kernel, argc++, params->lon0 * DEG_TO_RAD);\n if (!_pl_spheroid_is_spherical(params->spheroid)) {\n error |= pl_set_kernel_arg_float8(pl_ctx, kernel, argc++, info.krueger_alpha);\n error |= pl_set_kernel_arg_float8(pl_ctx, kernel, argc++, info.krueger_beta);\n }\n if (error != CL_SUCCESS)\n return error;\n \n return _pl_enqueue_kernel_1d(pl_ctx->queue, kernel, vec_count);\n}\n\ncl_int pl_enqueue_kernel_winkel_tripel(PLContext *pl_ctx, cl_kernel kernel,\n PLProjectionParams *params, cl_mem xy_in, cl_mem xy_out, size_t count) {\n cl_int error = CL_SUCCESS;\n int argc = 0;\n \n size_t vec_count = ck_padding(count, PL_FLOAT_VECTOR_SIZE) / PL_FLOAT_VECTOR_SIZE;\n \n PLSpheroidInfo info = _pl_get_spheroid_info(PL_SPHEROID_SPHERE);\n \n double cosphi1 = isnan(params->rlat1) ? M_2_PI : cos(params->rlat1 * DEG_TO_RAD);\n\n error |= pl_set_kernel_arg_mem(pl_ctx, kernel, argc++, xy_in);\n\terror |= pl_set_kernel_arg_mem(pl_ctx, kernel, argc++, xy_out);\n\terror |= pl_set_kernel_arg_uint(pl_ctx, kernel, argc++, vec_count);\n error |= pl_set_kernel_arg_float(pl_ctx, kernel, argc++, params->scale * info.major_axis);\n error |= pl_set_kernel_arg_float(pl_ctx, kernel, argc++, params->x0);\n error |= pl_set_kernel_arg_float(pl_ctx, kernel, argc++, params->y0);\n error |= pl_set_kernel_arg_float(pl_ctx, kernel, argc++, params->lon0 * DEG_TO_RAD);\n error |= pl_set_kernel_arg_float(pl_ctx, kernel, argc++, cosphi1);\n \n if (error != CL_SUCCESS)\n return error;\n \n return _pl_enqueue_kernel_1d(pl_ctx->queue, kernel, vec_count);\n}\n\ncl_int pl_run_kernel_inverse_geodesic( PLContext *pl_ctx, cl_kernel inv_kernel,\n PLInverseGeodesicBuffer *pl_buf, float *dist_out, PLSpheroid pl_ell, double scale) {\n\tint argc = 0;\n\tcl_int error = CL_SUCCESS;\n\tPLSpheroidInfo info = _pl_get_spheroid_info(pl_ell);\n\t\n\tsize_t xy2VecCount = ck_padding(pl_buf->xy2_count, PL_FLOAT_VECTOR_SIZE) / PL_FLOAT_VECTOR_SIZE;\n\t\n\terror |= pl_set_kernel_arg_mem(pl_ctx, inv_kernel, argc++, pl_buf->xy1_in);\n\terror |= pl_set_kernel_arg_mem(pl_ctx, inv_kernel, argc++, pl_buf->xy2_in);\n\terror |= pl_set_kernel_arg_mem(pl_ctx, inv_kernel, argc++, pl_buf->dist_out);\n\terror |= pl_set_kernel_arg_float(pl_ctx, inv_kernel, argc++, info.major_axis);\n\t\n\tif (error != CL_SUCCESS) {\n\t\treturn error;\n\t}\n\t\n\tconst size_t dim[2] = { pl_buf->xy1_count, xy2VecCount };\n\t\n\terror = clEnqueueNDRangeKernel(pl_ctx->queue, inv_kernel, 2, NULL, dim, NULL, 0, NULL, NULL);\n\tif (error != CL_SUCCESS) {\n\t\treturn error;\n\t}\n\t\n\tfloat *dist_pad_out;\n\tsize_t pad_count = 2 * pl_buf->xy1_count * ck_padding(pl_buf->xy2_count, PL_FLOAT_VECTOR_SIZE);\n\tif ((dist_pad_out = malloc(sizeof(float) * pad_count)) == NULL) {\n\t\treturn CL_OUT_OF_HOST_MEMORY;\n\t}\n\t\n\terror = clEnqueueReadBuffer(pl_ctx->queue, pl_buf->dist_out, CL_TRUE, 0, pad_count * sizeof(cl_float),\n\t\t\t\t\t\t\t\tdist_pad_out, 0, NULL, NULL);\n\tif (error != CL_SUCCESS) {\n\t\tfree(dist_pad_out);\n\t\treturn error;\n\t}\n\t\n\terror = clFinish(pl_ctx->queue);\n\tif (error != CL_SUCCESS) {\n\t\tfree(dist_pad_out);\n\t\treturn error;\n\t}\n\t\n\tint j_size = ck_padding(pl_buf->xy2_count, PL_FLOAT_VECTOR_SIZE);\n int i, j;\n\t\n\tfor (i=0; ixy1_count; i++) {\n\t\tfor (j=0; jxy2_count; j++) {\n\t\t\tdist_out[i*pl_buf->xy2_count+j] = dist_pad_out[i*j_size+j] * scale;\n\t\t}\n\t}\n\t\n\tfree(dist_pad_out);\n\t\n\treturn CL_SUCCESS;\n}\n\ncl_int pl_run_kernel_forward_geodesic_fixed_distance(PLContext *pl_ctx, cl_kernel fwd_kernel, \n PLForwardGeodesicFixedDistanceBuffer *pl_buf, float *xy_out, PLSpheroid pl_ell, double distance) {\n\tPLSpheroidInfo info = _pl_get_spheroid_info(pl_ell);\n\t\n\tint argc = 0;\n\t\n\tcl_int error = CL_SUCCESS;\n\t\n\tdouble D, sinD, cosD;\n\t\n\tD = distance / info.major_axis;\n\tsinD = sin(D);\n\tcosD = cos(D);\n\t\n\terror |= pl_set_kernel_arg_mem(pl_ctx, fwd_kernel, argc++, pl_buf->xy_in);\n\terror |= pl_set_kernel_arg_mem(pl_ctx, fwd_kernel, argc++, pl_buf->phi_sincos);\n\terror |= pl_set_kernel_arg_mem(pl_ctx, fwd_kernel, argc++, pl_buf->az_sincos);\n\terror |= pl_set_kernel_arg_mem(pl_ctx, fwd_kernel, argc++, pl_buf->xy_out);\n\terror |= pl_set_kernel_arg_float(pl_ctx, fwd_kernel, argc++, D);\n\terror |= pl_set_kernel_arg_float(pl_ctx, fwd_kernel, argc++, sinD);\n\terror |= pl_set_kernel_arg_float(pl_ctx, fwd_kernel, argc++, cosD);\n\tif (!_pl_spheroid_is_spherical(pl_ell)) {\n\t\tdouble flattening = 1.f/info.inverse_flattening;\n\t\terror |= pl_set_kernel_arg_float(pl_ctx, fwd_kernel, argc++, flattening);\n\t}\n\tif (error != CL_SUCCESS) {\n\t\treturn error;\n\t}\n\t\n\tconst size_t dim[2] = { pl_buf->xy_count, \n\t\tck_padding(pl_buf->az_count, PL_FLOAT_VECTOR_SIZE)/PL_FLOAT_VECTOR_SIZE };\n\t\n\terror = clEnqueueNDRangeKernel(pl_ctx->queue, fwd_kernel, 2, NULL, \n\t\t\t\t\t\t\t\t dim, NULL, 0, NULL, NULL);\n\tif (error != CL_SUCCESS) {\n\t\treturn error;\n\t}\n\t\n\terror = clEnqueueReadBuffer(pl_ctx->queue, pl_buf->xy_out, CL_TRUE, 0, \n\t\t\t\t\t\t\t\t2 * pl_buf->xy_count * pl_buf->az_count * sizeof(cl_float),\n\t\t\t\t\t\t\t\txy_out, 0, NULL, NULL);\n\tif (error != CL_SUCCESS) {\n\t\treturn error;\n\t}\n\t\n\terror = clFinish(pl_ctx->queue);\n\tif (error != CL_SUCCESS) {\n\t\treturn error;\n\t}\n\t\n\treturn CL_SUCCESS;\n}\n\ncl_int pl_run_kernel_forward_geodesic_fixed_angle(PLContext *pl_ctx, cl_kernel fwd_kernel, \n PLForwardGeodesicFixedAngleBuffer *pl_buf, double xy_in[2], float *xy_out, PLSpheroid pl_ell, double angle) {\n int argc = 0;\n \n size_t distVecCount = ck_padding(pl_buf->dist_count, PL_FLOAT_VECTOR_SIZE) / PL_FLOAT_VECTOR_SIZE;\n \n cl_int error = CL_SUCCESS;\n \n double sinAzimuth = sin(angle);\n double cosAzimuth = cos(angle);\n \n error |= pl_set_kernel_arg_float2(pl_ctx, fwd_kernel, argc++, xy_in);\n error |= pl_set_kernel_arg_mem(pl_ctx, fwd_kernel, argc++, pl_buf->dist_in);\n error |= pl_set_kernel_arg_mem(pl_ctx, fwd_kernel, argc++, pl_buf->xy_out);\n error |= pl_set_kernel_arg_float(pl_ctx, fwd_kernel, argc++, angle);\n error |= pl_set_kernel_arg_float(pl_ctx, fwd_kernel, argc++, sinAzimuth);\n error |= pl_set_kernel_arg_float(pl_ctx, fwd_kernel, argc++, cosAzimuth);\n if (error != CL_SUCCESS) {\n return error;\n }\n \n error = clEnqueueNDRangeKernel(pl_ctx->queue, fwd_kernel, 1, NULL, &distVecCount,\n NULL, 0, NULL, NULL);\n if (error != CL_SUCCESS) {\n return error;\n }\n \n error = clEnqueueReadBuffer(pl_ctx->queue, pl_buf->xy_out, CL_TRUE, 0, \n 2 * pl_buf->dist_count * sizeof(cl_float), \n xy_out, 0, NULL, NULL);\n if (error != CL_SUCCESS) {\n return error;\n }\n \n error = clFinish(pl_ctx->queue);\n if (error != CL_SUCCESS) {\n return error;\n }\n \n return CL_SUCCESS;\n}\n\ncl_int pl_run_kernel_geodesic_to_cartesian(PLContext *pl_ctx, cl_kernel g2c_kernel,\n PLDatumShiftBuffer *pl_buf, PLSpheroid pl_ell) {\n PLSpheroidInfo info = _pl_get_spheroid_info(pl_ell);\n\n int argc = 0;\n cl_int error = CL_SUCCESS;\n size_t vec_count = ck_padding(pl_buf->count, PL_FLOAT_VECTOR_SIZE) / PL_FLOAT_VECTOR_SIZE;\n \n error |= pl_set_kernel_arg_mem(pl_ctx, g2c_kernel, argc++, pl_buf->xy_in);\n error |= pl_set_kernel_arg_mem(pl_ctx, g2c_kernel, argc++, pl_buf->x_rw);\n error |= pl_set_kernel_arg_mem(pl_ctx, g2c_kernel, argc++, pl_buf->y_rw);\n error |= pl_set_kernel_arg_mem(pl_ctx, g2c_kernel, argc++, pl_buf->z_rw);\n \n error |= pl_set_kernel_arg_float(pl_ctx, g2c_kernel, argc++, info.ecc);\n error |= pl_set_kernel_arg_float(pl_ctx, g2c_kernel, argc++, info.ecc2);\n error |= pl_set_kernel_arg_float(pl_ctx, g2c_kernel, argc++, info.one_ecc2);\n \n error |= pl_set_kernel_arg_float(pl_ctx, g2c_kernel, argc++, info.major_axis);\n error |= pl_set_kernel_arg_float(pl_ctx, g2c_kernel, argc++, info.minor_axis);\n \n if (error != CL_SUCCESS)\n return error;\n \n error = clEnqueueNDRangeKernel(pl_ctx->queue, g2c_kernel, 1, NULL, &vec_count, NULL, 0, NULL, NULL);\n if (error != CL_SUCCESS)\n return error;\n \n error = clFinish(pl_ctx->queue);\n if (error != CL_SUCCESS)\n return error;\n \n return CL_SUCCESS;\n}\n\n/* We cut the computations in half by doing some matrix algebra beforehand.\n * Each datum shift is essentially an affine transformation in 3D cartesian\n * coordinates. So to get from on datum to another, instead of transforming\n * to/from WGS 84, we concatenate the transformation matrix of the source\n * datum to the inverse transformation matrix of the destination matrix, and\n * then just do a single matrix multiplication on each point instead of two\n * in order to transform it.\n */\ncl_int pl_run_kernel_transform_cartesian(PLContext *pl_ctx, cl_kernel transform_kernel, \n PLDatumShiftBuffer *pl_buf, PLDatum src_datum, PLDatum dst_datum) {\n double Rx1, Ry1, Rz1, M1, Dx1, Dy1, Dz1;\n double Rx2, Ry2, Rz2, M2, Dx2, Dy2, Dz2;\n \n cl_int error = CL_SUCCESS;\n int argc = 0;\n size_t vec_count = ck_padding(pl_buf->count, PL_FLOAT_VECTOR_SIZE) / PL_FLOAT_VECTOR_SIZE;\n \n Dx1 = pl_datum_params[src_datum].dx;\n Dy1 = pl_datum_params[src_datum].dy;\n Dz1 = pl_datum_params[src_datum].dz;\n M1 = pl_datum_params[src_datum].ppm*1.e-6 + 1;\n Rx1 = pl_datum_params[src_datum].ex * SEC_TO_RAD;\n Ry1 = pl_datum_params[src_datum].ey * SEC_TO_RAD;\n Rz1 = pl_datum_params[src_datum].ez * SEC_TO_RAD;\n \n Dx2 = pl_datum_params[dst_datum].dx;\n Dy2 = pl_datum_params[dst_datum].dy;\n Dz2 = pl_datum_params[dst_datum].dz;\n M2 = pl_datum_params[dst_datum].ppm*1.e-6 + 1;\n Rx2 = pl_datum_params[dst_datum].ex * SEC_TO_RAD;\n Ry2 = pl_datum_params[dst_datum].ey * SEC_TO_RAD;\n Rz2 = pl_datum_params[dst_datum].ez * SEC_TO_RAD;\n \n struct pl_matrix matrix1 = pl_affine_transform_make(Rx1, Ry1, Rz1, M1, Dx1, Dy1, Dz1);\n struct pl_matrix matrix2 = pl_affine_transform_make(Rx2, Ry2, Rz2, M2, Dx2, Dy2, Dz2);\n \n /* Invert the destination matrix */\n __CLPK_integer n = 4;\n __CLPK_integer info;\n \n __CLPK_integer ipiv[4];\n __CLPK_doublereal work[4];\n __CLPK_integer work_n = 4;\n \n dgetrf_(&n, &n, &matrix2.elements[0][0], &n, ipiv, &info);\n if (info != 0) {\n return info;\n }\n \n dgetri_(&n, &matrix2.elements[0][0], &n, ipiv, work, &work_n, &info);\n if (info != 0) {\n return info;\n }\n \n __CLPK_doublereal alpha = 1.0;\n __CLPK_doublereal beta = 0.0;\n __CLPK_doublereal result_matrix[4][4];\n \n /* Multiply the source matrix with the inverse destination matrix */\n cblas_dgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, n, n, n, alpha,\n &matrix2.elements[0][0], n,\n &matrix1.elements[0][0], n,\n beta, &result_matrix[0][0], n);\n \n /* transpose the result and store single-precision */\n double tmatrix[4][4];\n int i, j;\n for (i=0; i<4; i++) {\n for (j=0; j<4; j++) {\n tmatrix[i][j] = result_matrix[j][i];\n }\n }\n \n error |= pl_set_kernel_arg_mem(pl_ctx, transform_kernel, argc++, pl_buf->x_rw);\n error |= pl_set_kernel_arg_mem(pl_ctx, transform_kernel, argc++, pl_buf->y_rw);\n error |= pl_set_kernel_arg_mem(pl_ctx, transform_kernel, argc++, pl_buf->z_rw);\n error |= pl_set_kernel_arg_float16(pl_ctx, transform_kernel, argc++, &tmatrix[0][0]);\n if (error != CL_SUCCESS)\n return error;\n \n error = clEnqueueNDRangeKernel(pl_ctx->queue, transform_kernel, 1, NULL, \n &vec_count, NULL, 0, NULL, NULL);\n if (error != CL_SUCCESS)\n return error;\n \n return error;\n}\n\ncl_int pl_run_kernel_cartesian_to_geodesic(PLContext *pl_ctx, cl_kernel c2g_kernel, \n PLDatumShiftBuffer *pl_buf, float *xy_out, PLSpheroid pl_ell) {\n PLSpheroidInfo info = _pl_get_spheroid_info(pl_ell);\n \n int argc = 0;\n cl_int error = CL_SUCCESS;\n size_t vec_count = ck_padding(pl_buf->count, PL_FLOAT_VECTOR_SIZE) / PL_FLOAT_VECTOR_SIZE;\n \n error |= pl_set_kernel_arg_mem(pl_ctx, c2g_kernel, argc++, pl_buf->x_rw);\n error |= pl_set_kernel_arg_mem(pl_ctx, c2g_kernel, argc++, pl_buf->y_rw);\n error |= pl_set_kernel_arg_mem(pl_ctx, c2g_kernel, argc++, pl_buf->z_rw);\n error |= pl_set_kernel_arg_mem(pl_ctx, c2g_kernel, argc++, pl_buf->xy_out);\n \n error |= pl_set_kernel_arg_float(pl_ctx, c2g_kernel, argc++, info.ecc);\n error |= pl_set_kernel_arg_float(pl_ctx, c2g_kernel, argc++, info.ecc2);\n error |= pl_set_kernel_arg_float(pl_ctx, c2g_kernel, argc++, info.one_ecc2);\n \n error |= pl_set_kernel_arg_float(pl_ctx, c2g_kernel, argc++, info.major_axis);\n error |= pl_set_kernel_arg_float(pl_ctx, c2g_kernel, argc++, info.minor_axis);\n if (error != CL_SUCCESS)\n return error;\n \n error = clEnqueueNDRangeKernel(pl_ctx->queue, c2g_kernel, 1, NULL,\n &vec_count, NULL, 0, NULL, NULL);\n if (error != CL_SUCCESS)\n return error;\n \n if (xy_out != NULL) {\n error = clEnqueueReadBuffer(pl_ctx->queue, pl_buf->xy_out, CL_TRUE, 0, \n 2 * pl_buf->count * sizeof(cl_float), xy_out, 0, NULL, NULL);\n if (error != CL_SUCCESS)\n return error;\n }\n \n error = clFinish(pl_ctx->queue);\n if (error != CL_SUCCESS)\n return error;\n \n return CL_SUCCESS;\n}\n", "meta": {"hexsha": "59a9b28c67bbaa395586e5d74ef3974b408fc516", "size": 37274, "ext": "c", "lang": "C", "max_stars_repo_path": "src/projcl_run.c", "max_stars_repo_name": "evanmiller/ProjCL", "max_stars_repo_head_hexsha": "d5f06df59bb6814a1c2742eb5f4e9692390dbf1b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 50.0, "max_stars_repo_stars_event_min_datetime": "2015-01-08T19:38:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-12-29T05:04:56.000Z", "max_issues_repo_path": "src/projcl_run.c", "max_issues_repo_name": "evanmiller/ProjCL", "max_issues_repo_head_hexsha": "d5f06df59bb6814a1c2742eb5f4e9692390dbf1b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 14.0, "max_issues_repo_issues_event_min_datetime": "2015-04-09T19:25:03.000Z", "max_issues_repo_issues_event_max_datetime": "2020-09-04T15:58:31.000Z", "max_forks_repo_path": "src/projcl_run.c", "max_forks_repo_name": "evanmiller/ProjCL", "max_forks_repo_head_hexsha": "d5f06df59bb6814a1c2742eb5f4e9692390dbf1b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 8.0, "max_forks_repo_forks_event_min_datetime": "2015-03-13T20:42:42.000Z", "max_forks_repo_forks_event_max_datetime": "2020-09-22T00:23:34.000Z", "avg_line_length": 39.1945320715, "max_line_length": 151, "alphanum_fraction": 0.6579385094, "num_tokens": 11465, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8558511579973931, "lm_q2_score": 0.600188359260205, "lm_q1q2_score": 0.5136719022894018}} {"text": "/* wavelet/haar.c\n * \n * Copyright (C) 2004 Ivo Alxneit\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 2 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n#include \n#include \n#include \n#include \n\nstatic const double ch_2[2] = { M_SQRT1_2, M_SQRT1_2 };\nstatic const double cg_2[2] = { M_SQRT1_2, -(M_SQRT1_2) };\n\nstatic int\nhaar_init (const double **h1, const double **g1, const double **h2,\n const double **g2, size_t * nc, size_t * offset,\n const size_t member)\n{\n if (member != 2)\n {\n return GSL_FAILURE;\n }\n\n *h1 = ch_2;\n *g1 = cg_2;\n *h2 = ch_2;\n *g2 = cg_2;\n\n *nc = 2;\n *offset = 0;\n\n return GSL_SUCCESS;\n}\n\nstatic int\nhaar_centered_init (const double **h1, const double **g1, const double **h2,\n const double **g2, size_t * nc, size_t * offset,\n const size_t member)\n{\n if (member != 2)\n {\n return GSL_FAILURE;\n }\n\n *h1 = ch_2;\n *g1 = cg_2;\n *h2 = ch_2;\n *g2 = cg_2;\n\n *nc = 2;\n *offset = 1;\n\n return GSL_SUCCESS;\n}\n\nstatic const gsl_wavelet_type haar_type = {\n \"haar\",\n &haar_init\n};\n\nstatic const gsl_wavelet_type haar_centered_type = {\n \"haar-centered\",\n &haar_centered_init\n};\n\nconst gsl_wavelet_type *gsl_wavelet_haar = &haar_type;\nconst gsl_wavelet_type *gsl_wavelet_haar_centered = &haar_centered_type;\n", "meta": {"hexsha": "8591cfda5bdc601a046fc214269e68b5df7e9b27", "size": 2008, "ext": "c", "lang": "C", "max_stars_repo_path": "pkgs/libs/gsl/src/wavelet/haar.c", "max_stars_repo_name": "manggoguy/parsec-modified", "max_stars_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 64.0, "max_stars_repo_stars_event_min_datetime": "2015-03-06T00:30:56.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-24T13:26:53.000Z", "max_issues_repo_path": "pkgs/libs/gsl/src/wavelet/haar.c", "max_issues_repo_name": "manggoguy/parsec-modified", "max_issues_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 12.0, "max_issues_repo_issues_event_min_datetime": "2020-12-15T08:30:19.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-13T03:54:24.000Z", "max_forks_repo_path": "pkgs/libs/gsl/src/wavelet/haar.c", "max_forks_repo_name": "manggoguy/parsec-modified", "max_forks_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 40.0, "max_forks_repo_forks_event_min_datetime": "2015-02-26T15:31:16.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-03T23:23:37.000Z", "avg_line_length": 24.487804878, "max_line_length": 81, "alphanum_fraction": 0.6698207171, "num_tokens": 607, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7718435083355186, "lm_q2_score": 0.6654105653819836, "lm_q1q2_score": 0.5135928252679512}} {"text": "// Copyright (c) 2021 Stig Rune Sellevag\n//\n// This file is distributed under the MIT License. See the accompanying file\n// LICENSE.txt or http://www.opensource.org/licenses/mit-license.php for terms\n// and conditions.\n\n#ifndef SCILIB_LINALG_MATRIX_NORM_H\n#define SCILIB_LINALG_MATRIX_NORM_H\n\n#ifdef USE_MKL\n#include \n#else\n#include \n#endif\n\n#include \n#include \n#include \n\nnamespace Sci {\nnamespace Linalg {\n\nnamespace stdex = std::experimental;\n\n// Matrix norm of a general rectangular matrix:\n//\n// Types of matrix norms:\n// - M, m: largest absolute value of the matrix\n// - 1, O, o: 1-norm of the matrix (maximum column sum)\n// - I, i: infinity norm of the matrix (maximum row sum)\n// - F, f, E, e: Frobenius norm of the matrix (square root of sum of squares)\n//\ntemplate \n requires(std::is_same_v, double>)\ninline auto matrix_norm(Sci::Matrix_view a, char norm)\n{\n static_assert(a.is_contiguous());\n\n assert(norm == 'M' || norm == 'm' || norm == '1' || norm == 'O' ||\n norm == 'o' || norm == 'I' || norm == 'i' || norm == 'F' ||\n norm == 'f' || norm == 'E' || norm == 'e');\n\n auto matrix_layout = LAPACK_ROW_MAJOR;\n BLAS_INT m = static_cast(a.extent(0));\n BLAS_INT n = static_cast(a.extent(1));\n BLAS_INT lda = n;\n\n if constexpr (std::is_same_v) {\n matrix_layout = LAPACK_COL_MAJOR;\n lda = m;\n }\n return LAPACKE_dlange(matrix_layout, norm, m, n, a.data(), lda);\n}\n\ntemplate \ninline double matrix_norm(const Sci::Matrix& a,\n char norm)\n{\n return matrix_norm(a.view(), norm);\n}\n\n} // namespace Linalg\n} // namespace Sci\n\n#endif // SCILIB_LINALG_MATRIX_NORM_H\n", "meta": {"hexsha": "ccb0d32f925fa934cc000a67d530b1f74f1ada4c", "size": 1912, "ext": "h", "lang": "C", "max_stars_repo_path": "include/scilib/linalg_impl/matrix_norm.h", "max_stars_repo_name": "stigrs/scilib", "max_stars_repo_head_hexsha": "c49f1f882bf2031a4de537e0f5701b2648af181f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "include/scilib/linalg_impl/matrix_norm.h", "max_issues_repo_name": "stigrs/scilib", "max_issues_repo_head_hexsha": "c49f1f882bf2031a4de537e0f5701b2648af181f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "include/scilib/linalg_impl/matrix_norm.h", "max_forks_repo_name": "stigrs/scilib", "max_forks_repo_head_hexsha": "c49f1f882bf2031a4de537e0f5701b2648af181f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 28.9696969697, "max_line_length": 78, "alphanum_fraction": 0.6563807531, "num_tokens": 527, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7718435083355187, "lm_q2_score": 0.6654105653819835, "lm_q1q2_score": 0.5135928252679512}} {"text": "/* permutation/permutation.c\n * \n * Copyright (C) 2001, 2002 Nicolas Darnis\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 2 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n/* Modified for GSL by Brian Gough.\n * Use in-place algorithms, no need for workspace\n * Use conventions for canonical form given in Knuth (opposite of Sedgewick)\n */\n\n#include \n#include \n#include \n\nint\ngsl_permutation_linear_to_canonical (gsl_permutation * q,\n const gsl_permutation * p)\n{\n const size_t n = p->size;\n size_t i, k, s;\n size_t t = n;\n\n const size_t *const pp = p->data;\n size_t *const qq = q->data;\n\n if (q->size != p->size)\n {\n GSL_ERROR (\"size of q does not match size of p\", GSL_EINVAL);\n }\n\n for (i = 0; i < n; i++)\n {\n\n k = pp[i];\n s = 1;\n\n while (k > i)\n {\n k = pp[k];\n s++;\n }\n\n if (k < i)\n continue;\n\n /* Now have k == i, i.e the least in its cycle, and s == cycle length */\n\n t -= s;\n\n qq[t] = i;\n\n k = pp[i];\n s = 1;\n\n while (k > i)\n {\n qq[t + s] = k;\n k = pp[k];\n s++;\n }\n\n if (t == 0)\n break;\n }\n\n return GSL_SUCCESS;\n}\n\nint\ngsl_permutation_canonical_to_linear (gsl_permutation * p,\n const gsl_permutation * q)\n{\n size_t i, k, kk, first;\n const size_t n = p->size;\n\n size_t *const pp = p->data;\n const size_t *const qq = q->data;\n\n if (q->size != p->size)\n {\n GSL_ERROR (\"size of q does not match size of p\", GSL_EINVAL);\n }\n\n for (i = 0; i < n; i++)\n {\n pp[i] = i;\n }\n\n k = qq[0];\n first = pp[k];\n\n for (i = 1; i < n; i++)\n {\n kk = qq[i];\n\n if (kk > first)\n {\n pp[k] = pp[kk];\n k = kk;\n }\n else\n {\n pp[k] = first;\n k = kk;\n first = pp[kk];\n }\n }\n\n pp[k] = first;\n\n return GSL_SUCCESS;\n}\n\n\nsize_t\ngsl_permutation_inversions (const gsl_permutation * p)\n{\n size_t count = 0;\n size_t i, j;\n const size_t size = p->size;\n\n for (i = 0; i < size - 1; i++)\n {\n for (j = i + 1; j < size; j++)\n {\n if (p->data[i] > p->data[j])\n {\n count++;\n }\n }\n }\n\n return count;\n}\n\nsize_t\ngsl_permutation_linear_cycles (const gsl_permutation * p)\n{\n size_t i, k;\n size_t count = 0;\n const size_t size = p->size;\n\n for (i = 0; i < size; i++)\n {\n\n k = p->data[i];\n\n while (k > i)\n {\n k = p->data[k];\n }\n\n if (k < i)\n continue;\n\n count++;\n }\n\n return count;\n}\n\nsize_t\ngsl_permutation_canonical_cycles (const gsl_permutation * p)\n{\n size_t i;\n size_t count = 1;\n size_t min = p->data[0];\n\n for (i = 0; i < p->size; i++)\n {\n if (p->data[i] < min)\n {\n min = p->data[i];\n count++;\n }\n }\n\n return count;\n}\n\n", "meta": {"hexsha": "080c8eebc09254cc69d1878db29cf0afa734950d", "size": 3608, "ext": "c", "lang": "C", "max_stars_repo_path": "pkgs/libs/gsl/src/permutation/canonical.c", "max_stars_repo_name": "manggoguy/parsec-modified", "max_stars_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 64.0, "max_stars_repo_stars_event_min_datetime": "2015-03-06T00:30:56.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-24T13:26:53.000Z", "max_issues_repo_path": "pkgs/libs/gsl/src/permutation/canonical.c", "max_issues_repo_name": "manggoguy/parsec-modified", "max_issues_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 12.0, "max_issues_repo_issues_event_min_datetime": "2020-12-15T08:30:19.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-13T03:54:24.000Z", "max_forks_repo_path": "pkgs/libs/gsl/src/permutation/canonical.c", "max_forks_repo_name": "manggoguy/parsec-modified", "max_forks_repo_head_hexsha": "d14edfb62795805c84a4280d67b50cca175b95af", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 40.0, "max_forks_repo_forks_event_min_datetime": "2015-02-26T15:31:16.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-03T23:23:37.000Z", "avg_line_length": 18.5025641026, "max_line_length": 81, "alphanum_fraction": 0.5210643016, "num_tokens": 1056, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.6825737344123242, "lm_q2_score": 0.7520125737597972, "lm_q1q2_score": 0.5133040307962482}} {"text": "/*\n # This file is part of the Astrometry.net suite.\n # Licensed under a 3-clause BSD style license - see LICENSE\n */\n\n#include \n#include \n#include \n#include \n\n#include \n#include \n\n#include \"sip-utils.h\"\n#include \"tweak.h\"\n#include \"healpix.h\"\n#include \"dualtree_rangesearch.h\"\n#include \"kdtree_fits_io.h\"\n#include \"mathutil.h\"\n#include \"log.h\"\n#include \"permutedsort.h\"\n#include \"gslutils.h\"\n#include \"errors.h\"\n#include \"fit-wcs.h\"\n\n// TODO:\n//\n// 1. Write the document which explains every step of tweak in detail with\n// comments relating exactly to the code.\n// 2. Implement polynomial terms - use order parameter to zero out A matrix\n// 3. Make it robust to outliers\n// - Make jitter evolve as fit evolves\n// - Sigma clipping\n// 4. Need test image with non-trivial rotation to test CD transpose problem\n//\n//\n// - Put CD inverse into its own function\n//\n// BUG? transpose of CD matrix is similar to CD matrix!\n// BUG? inverse when computing sx/sy (i.e. same transpose issue)\n// Ability to fit without re-doing correspondences\n// Split fit x/y (i.e. two fits one for x one for y)\n\n#define KERNEL_SIZE 5\n#define KERNEL_MARG ((KERNEL_SIZE-1)/2)\n\nsip_t* tweak_just_do_it(const tan_t* wcs, const starxy_t* imagexy,\n const double* starxyz,\n const double* star_ra, const double* star_dec,\n const double* star_radec,\n int nstars, double jitter_arcsec,\n int order, int inverse_order, int iterations,\n anbool weighted, anbool skip_shift) {\n tweak_t* twee = NULL;\n sip_t* sip = NULL;\n\n twee = tweak_new();\n twee->jitter = jitter_arcsec;\n twee->sip->a_order = twee->sip->b_order = order;\n twee->sip->ap_order = twee->sip->bp_order = inverse_order;\n twee->weighted_fit = weighted;\n if (skip_shift)\n tweak_skip_shift(twee);\n\n tweak_push_image_xy(twee, imagexy);\n if (starxyz)\n tweak_push_ref_xyz(twee, starxyz, nstars);\n else if (star_ra && star_dec)\n tweak_push_ref_ad(twee, star_ra, star_dec, nstars);\n else if (star_radec)\n tweak_push_ref_ad_array(twee, star_radec, nstars);\n else {\n logerr(\"Need starxyz, (star_ra and star_dec), or star_radec\");\n return NULL;\n }\n tweak_push_wcs_tan(twee, wcs);\n tweak_iterate_to_order(twee, order, iterations);\n\n // Steal the resulting SIP structure\n sip = twee->sip;\n twee->sip = NULL;\n\n tweak_free(twee);\n return sip;\n}\n\nstatic void get_dydx_range(double* ximg, double* yimg, int nimg,\n double* xcat, double* ycat, int ncat,\n double *mindx, double *mindy,\n double *maxdx, double *maxdy) {\n int i, j;\n *maxdx = -1e100;\n *mindx = 1e100;\n *maxdy = -1e100;\n *mindy = 1e100;\n\n for (i = 0; i < nimg; i++) {\n for (j = 0; j < ncat; j++) {\n double dx = ximg[i] - xcat[j];\n double dy = yimg[i] - ycat[j];\n *maxdx = MAX(dx, *maxdx);\n *maxdy = MAX(dy, *maxdy);\n *mindx = MIN(dx, *mindx);\n *mindy = MIN(dy, *mindy);\n }\n }\n}\n\nstatic void get_shift(double* ximg, double* yimg, int nimg,\n double* xcat, double* ycat, int ncat,\n double mindx, double mindy, double maxdx, double maxdy,\n double* xshift, double* yshift) {\n int i, j;\n int themax, themaxind, ys, xs;\n\n // hough transform\n int hsz = 1000; // hough histogram size (per side)\n int *hough = calloc(hsz * hsz, sizeof(int)); // allocate bins\n int kern[] = {0, 2, 3, 2, 0, // approximate gaussian smoother\n 2, 7, 12, 7, 2, // should be KERNEL_SIZE x KERNEL_SIZE\n 3, 12, 20, 12, 3,\n 2, 7, 12, 7, 2,\n 0, 2, 3, 2, 0};\n\n assert(sizeof(kern) == KERNEL_SIZE * KERNEL_SIZE * sizeof(int));\n\n for (i = 0; i < nimg; i++) { // loop over all pairs of source-catalog objs\n for (j = 0; j < ncat; j++) {\n double dx = ximg[i] - xcat[j];\n double dy = yimg[i] - ycat[j];\n int hszi = hsz - 1;\n int iy = hszi * ( (dy - mindy) / (maxdy - mindy) ); // compute deltay using implicit floor\n int ix = hszi * ( (dx - mindx) / (maxdx - mindx) ); // compute deltax using implicit floor\n\n // check to make sure the point is in the box\n if (KERNEL_MARG <= iy && iy < hsz - KERNEL_MARG &&\n KERNEL_MARG <= ix && ix < hsz - KERNEL_MARG) {\n int kx, ky;\n for (ky = -2; ky <= 2; ky++)\n for (kx = -2; kx <= 2; kx++)\n hough[(iy - ky)*hsz + (ix - kx)] += kern[(ky + 2) * 5 + (kx + 2)];\n }\n }\n }\n\n // find argmax in hough\n themax = 0;\n themaxind = -1;\n for (i = 0; i < hsz*hsz; i++) {\n if (themax < hough[i]) {\n themaxind = i;\n themax = hough[i];\n }\n }\n // which hough bin is the max?\n ys = themaxind / hsz;\n xs = themaxind % hsz;\n\n\n *yshift = (ys / (double)hsz) * (maxdy - mindy) + mindy;\n *xshift = (xs / (double)hsz) * (maxdx - mindx) + mindx;\n debug(\"xs = %d, ys = %d\\n\", xs, ys);\n debug(\"get_shift: mindx=%g, maxdx=%g, mindy=%g, maxdy=%g\\n\", mindx, maxdx, mindy, maxdy);\n debug(\"get_shift: xs=%g, ys=%g\\n\", *xshift, *yshift);\n\n free(hough);\n}\n\nstatic sip_t* do_entire_shift_operation(tweak_t* t, double rho) {\n get_shift(t->x, t->y, t->n,\n t->x_ref, t->y_ref, t->n_ref,\n rho*t->mindx, rho*t->mindy, rho*t->maxdx, rho*t->maxdy,\n &t->xs, &t->ys);\n wcs_shift(&(t->sip->wcstan), t->xs, t->ys);\n return NULL;\n}\n\n/* This function is intended only for initializing newly allocated tweak\n * structures, NOT for operating on existing ones.*/\nvoid tweak_init(tweak_t* t) {\n memset(t, 0, sizeof(tweak_t));\n t->sip = sip_create();\n}\n\ntweak_t* tweak_new() {\n tweak_t* t = malloc(sizeof(tweak_t));\n tweak_init(t);\n return t;\n}\n\nvoid tweak_iterate_to_order(tweak_t* t, int maxorder, int iterations) {\n int order;\n int k;\n\n for (order=1; order<=maxorder; order++) {\n logverb(\"\\n\");\n logverb(\"--------------------------------\\n\");\n logverb(\"Order %i\\n\", order);\n logverb(\"--------------------------------\\n\");\n\n t->sip->a_order = t->sip->b_order = order;\n //t->sip->ap_order = t->sip->bp_order = order;\n tweak_go_to(t, TWEAK_HAS_CORRESPONDENCES);\n\n for (k=0; kstate &= ~TWEAK_HAS_LINEAR_CD;\n tweak_go_to(t, TWEAK_HAS_LINEAR_CD);\n tweak_clear_correspondences(t);\n }\n }\n}\n\n#define CHECK_STATE(x) if (state & x) sl_append(s, #x)\n\nstatic char* state_string(unsigned int state) {\n sl* s = sl_new(4);\n char* str;\n CHECK_STATE(TWEAK_HAS_SIP);\n CHECK_STATE(TWEAK_HAS_IMAGE_XY);\n CHECK_STATE(TWEAK_HAS_IMAGE_XYZ);\n CHECK_STATE(TWEAK_HAS_IMAGE_AD);\n CHECK_STATE(TWEAK_HAS_REF_XY);\n CHECK_STATE(TWEAK_HAS_REF_XYZ);\n CHECK_STATE(TWEAK_HAS_REF_AD);\n CHECK_STATE(TWEAK_HAS_CORRESPONDENCES);\n CHECK_STATE(TWEAK_HAS_COARSLY_SHIFTED);\n CHECK_STATE(TWEAK_HAS_FINELY_SHIFTED);\n CHECK_STATE(TWEAK_HAS_REALLY_FINELY_SHIFTED);\n CHECK_STATE(TWEAK_HAS_LINEAR_CD);\n str = sl_join(s, \" \");\n sl_free2(s);\n return str;\n}\n\nchar* tweak_get_state_string(const tweak_t* t) {\n return state_string(t->state);\n}\n\n#undef CHECK_STATE\n\nvoid tweak_clear_correspondences(tweak_t* t) {\n if (t->state & TWEAK_HAS_CORRESPONDENCES) {\n // our correspondences are also now toast\n assert(t->image);\n assert(t->ref);\n assert(t->dist2);\n il_free(t->image);\n il_free(t->ref);\n dl_free(t->dist2);\n if (t->weight)\n dl_free(t->weight);\n t->image = NULL;\n t->ref = NULL;\n t->dist2 = NULL;\n t->weight = NULL;\n t->state &= ~TWEAK_HAS_CORRESPONDENCES;\n }\n assert(!t->image);\n assert(!t->ref);\n assert(!t->dist2);\n assert(!t->weight);\n}\n\nvoid tweak_clear_on_sip_change(tweak_t* t) {\n // tweak_clear_correspondences(t);\n tweak_clear_image_ad(t);\n tweak_clear_ref_xy(t);\n tweak_clear_image_xyz(t);\n}\n\n// ref_xy are the catalog star positions in image coordinates\nvoid tweak_clear_ref_xy(tweak_t* t) {\n if (t->state & TWEAK_HAS_REF_XY) {\n //assert(t->x_ref);\n free(t->x_ref);\n //assert(t->y_ref);\n t->x_ref = NULL;\n free(t->y_ref);\n t->y_ref = NULL;\n t->state &= ~TWEAK_HAS_REF_XY;\n }\n assert(!t->x_ref);\n assert(!t->y_ref);\n}\n\n// radec of catalog stars\nvoid tweak_clear_ref_ad(tweak_t* t) {\n if (t->state & TWEAK_HAS_REF_AD) {\n assert(t->a_ref);\n free(t->a_ref);\n t->a_ref = NULL;\n assert(t->d_ref);\n free(t->d_ref);\n t->d_ref = NULL;\n t->n_ref = 0;\n tweak_clear_correspondences(t);\n tweak_clear_ref_xy(t);\n t->state &= ~TWEAK_HAS_REF_AD;\n }\n assert(!t->a_ref);\n assert(!t->d_ref);\n}\n\n// image objs in ra,dec according to current tweak\nvoid tweak_clear_image_ad(tweak_t* t) {\n if (t->state & TWEAK_HAS_IMAGE_AD) {\n assert(t->a);\n free(t->a);\n t->a = NULL;\n assert(t->d);\n free(t->d);\n t->d = NULL;\n t->state &= ~TWEAK_HAS_IMAGE_AD;\n }\n assert(!t->a);\n assert(!t->d);\n}\n\nvoid tweak_clear_image_xyz(tweak_t* t) {\n if (t->state & TWEAK_HAS_IMAGE_XYZ) {\n assert(t->xyz);\n free(t->xyz);\n t->xyz = NULL;\n t->state &= ~TWEAK_HAS_IMAGE_XYZ;\n }\n assert(!t->xyz);\n}\n\nvoid tweak_clear_image_xy(tweak_t* t) {\n if (t->state & TWEAK_HAS_IMAGE_XY) {\n assert(t->x);\n free(t->x);\n t->x = NULL;\n assert(t->y);\n free(t->y);\n t->y = NULL;\n t->state &= ~TWEAK_HAS_IMAGE_XY;\n }\n assert(!t->x);\n assert(!t->y);\n}\n\n// tell us (from outside tweak) where the catalog stars are\nvoid tweak_push_ref_ad(tweak_t* t, const double* a, const double *d, int n) {\n assert(a);\n assert(d);\n assert(n);\n tweak_clear_ref_ad(t);\n assert(!t->a_ref);\n assert(!t->d_ref);\n t->a_ref = malloc(sizeof(double) * n);\n t->d_ref = malloc(sizeof(double) * n);\n memcpy(t->a_ref, a, n*sizeof(double));\n memcpy(t->d_ref, d, n*sizeof(double));\n t->n_ref = n;\n t->state |= TWEAK_HAS_REF_AD;\n}\n\nvoid tweak_push_ref_ad_array(tweak_t* t, const double* ad, int n) {\n int i;\n assert(ad);\n assert(n);\n tweak_clear_ref_ad(t);\n assert(!t->a_ref);\n assert(!t->d_ref);\n t->a_ref = malloc(sizeof(double) * n);\n t->d_ref = malloc(sizeof(double) * n);\n for (i=0; ia_ref[i] = ad[2*i + 0];\n t->d_ref[i] = ad[2*i + 1];\n }\n t->n_ref = n;\n t->state |= TWEAK_HAS_REF_AD;\n}\n\nstatic void ref_xyz_from_ad(tweak_t* t) {\n int i;\n assert(t->state & TWEAK_HAS_REF_AD);\n assert(!t->xyz_ref);\n t->xyz_ref = malloc(sizeof(double) * 3 * t->n_ref);\n assert(t->xyz_ref);\n for (i = 0; i < t->n_ref; i++)\n radecdeg2xyzarr(t->a_ref[i], t->d_ref[i], t->xyz_ref + 3 * i);\n t->state |= TWEAK_HAS_REF_XYZ;\n}\n\nstatic void ref_ad_from_xyz(tweak_t* t) {\n int i, n;\n assert(t->state & TWEAK_HAS_REF_XYZ);\n assert(!t->a_ref);\n assert(!t->d_ref);\n n = t->n_ref;\n t->a_ref = malloc(sizeof(double) * n);\n t->d_ref = malloc(sizeof(double) * n);\n assert(t->a_ref);\n assert(t->d_ref);\n for (i=0; ixyz_ref + 3*i, t->a_ref + i, t->d_ref + i);\n t->state |= TWEAK_HAS_REF_XYZ;\n}\n\n// tell us (from outside tweak) where the catalog stars are\nvoid tweak_push_ref_xyz(tweak_t* t, const double* xyz, int n) {\n assert(xyz);\n assert(n);\n tweak_clear_ref_ad(t);\n assert(!t->xyz_ref);\n t->xyz_ref = malloc(sizeof(double) * 3 * n);\n assert(t->xyz_ref);\n memcpy(t->xyz_ref, xyz, 3*n*sizeof(double));\n t->n_ref = n;\n t->state |= TWEAK_HAS_REF_XYZ;\n}\n\nvoid tweak_push_image_xy(tweak_t* t, const starxy_t* xy) {\n tweak_clear_image_xy(t);\n t->x = starxy_copy_x(xy);\n t->y = starxy_copy_y(xy);\n t->n = starxy_n(xy);\n t->state |= TWEAK_HAS_IMAGE_XY;\n}\n\nvoid tweak_skip_shift(tweak_t* t) {\n t->state |= (TWEAK_HAS_COARSLY_SHIFTED | TWEAK_HAS_FINELY_SHIFTED |\n TWEAK_HAS_REALLY_FINELY_SHIFTED);\n}\n\n// DualTree RangeSearch callback. We want to keep track of correspondences.\n// Potentially the matching could be many-to-many; we allow this and hope the\n// optimizer can take care of it.\nstatic void dtrs_match_callback(void* extra, int image_ind, int ref_ind, double dist2) {\n tweak_t* t = extra;\n image_ind = kdtree_permute(t->kd_image, image_ind);\n ref_ind = kdtree_permute(t->kd_ref, ref_ind);\n il_append(t->image, image_ind);\n il_append(t->ref, ref_ind);\n dl_append(t->dist2, dist2);\n if (t->weight)\n dl_append(t->weight, exp(-dist2 / (2.0 * t->jitterd2)));\n}\n\nvoid tweak_push_correspondence_indices(tweak_t* t, il* image, il* ref, dl* distsq, dl* weight) {\n t->image = image;\n t->ref = ref;\n t->dist2 = distsq;\n t->weight = weight;\n t->state |= TWEAK_HAS_CORRESPONDENCES;\n}\n\n// The jitter is in radians\nstatic void find_correspondences(tweak_t* t, double jitter) {\n double dist;\n double* data_image = malloc(sizeof(double) * t->n * 3);\n double* data_ref = malloc(sizeof(double) * t->n_ref * 3);\n\n assert(t->state & TWEAK_HAS_IMAGE_XYZ);\n assert(t->state & TWEAK_HAS_REF_XYZ);\n tweak_clear_correspondences(t);\n\n memcpy(data_image, t->xyz, 3*t->n*sizeof(double));\n memcpy(data_ref, t->xyz_ref, 3*t->n_ref*sizeof(double));\n\n t->kd_image = kdtree_build(NULL, data_image, t->n, 3, 4, KDTT_DOUBLE,\n KD_BUILD_BBOX);\n\n t->kd_ref = kdtree_build(NULL, data_ref, t->n_ref, 3, 4, KDTT_DOUBLE,\n KD_BUILD_BBOX);\n\n // Storage for correspondences\n t->image = il_new(600);\n t->ref = il_new(600);\n t->dist2 = dl_new(600);\n if (t->weighted_fit)\n t->weight = dl_new(600);\n\n dist = rad2dist(jitter);\n\n logverb(\"search radius = %g arcsec\\n\", rad2arcsec(jitter));\n\n // Find closest neighbours\n dualtree_rangesearch(t->kd_image, t->kd_ref,\n RANGESEARCH_NO_LIMIT, dist, FALSE, NULL,\n dtrs_match_callback, t,\n NULL, NULL);\n\n kdtree_free(t->kd_image);\n kdtree_free(t->kd_ref);\n t->kd_image = NULL;\n t->kd_ref = NULL;\n free(data_image);\n free(data_ref);\n\n logverb(\"Number of correspondences: %zu\\n\", il_size(t->image));\n}\n\nstatic double correspondences_rms_arcsec(tweak_t* t, int weighted) {\n double err2 = 0.0;\n int i;\n double totalweight = 0.0;\n for (i=0; iimage); i++) {\n double imgxyz[3];\n double refxyz[3];\n double weight;\n int refi, imgi;\n if (weighted && t->weight)\n weight = dl_get(t->weight, i);\n else\n weight = 1.0;\n totalweight += weight;\n\n imgi = il_get(t->image, i);\n sip_pixelxy2xyzarr(t->sip, t->x[imgi], t->y[imgi], imgxyz);\n\n refi = il_get(t->ref, i);\n radecdeg2xyzarr(t->a_ref[refi], t->d_ref[refi], refxyz);\n\n err2 += weight * distsq(imgxyz, refxyz, 3);\n }\n return distsq2arcsec( err2 / totalweight );\n}\n\n#if 0\n// in arcseconds^2 on the sky (chi-sq)\nstatic double figure_of_merit(tweak_t* t, double *rmsX, double *rmsY) {\n double sqerr = 0.0;\n int i;\n for (i = 0; i < il_size(t->image); i++) {\n double a, d;\n double xyzpt[3];\n double xyzpt_ref[3];\n sip_pixelxy2radec(t->sip, t->x[il_get(t->image, i)],\n t->y[il_get(t->image, i)], &a, &d);\n\n // xref and yref should be intermediate WC's not image x and y!\n radecdeg2xyzarr(a, d, xyzpt);\n radecdeg2xyzarr(t->a_ref[il_get(t->ref, i)],\n t->d_ref[il_get(t->ref, i)], xyzpt_ref);\n sqerr += distsq(xyzpt, xyzpt_ref, 3);\n }\n return rad2arcsec(1)*rad2arcsec(1)*sqerr;\n}\n\nstatic double figure_of_merit2(tweak_t* t) {\n // find error in pixels^2\n double sqerr = 0.0;\n int i;\n for (i = 0; i < il_size(t->image); i++) {\n double x, y, dx, dy;\n Unused anbool ok;\n ok = sip_radec2pixelxy(t->sip, t->a_ref[il_get(t->ref, i)], t->d_ref[il_get(t->ref, i)], &x, &y);\n assert(ok);\n dx = t->x[il_get(t->image, i)] - x;\n dy = t->y[il_get(t->image, i)] - y;\n sqerr += dx * dx + dy * dy;\n }\n // convert to arcsec^2\n return sqerr * square(sip_pixel_scale(t->sip));\n}\n#endif\n\n// FIXME: adapt this function to take as input the correspondences to use VVVVV\n// wic is World Intermediate Coordinates, either along ra or dec\n// i.e. canonical image coordinates\n// wic_corr is the list of corresponding indexes for wip\n// pix_corr is the list of corresponding indexes for pixels\n// pix is raw image pixels (either u or v)\n// siporder is the sip order up to MAXORDER (defined in sip.h)\n// the correspondences are passed so that we can stick RANSAC around the whole\n// thing for better estimation.\n\n// Run a polynomial tweak\nstatic void do_sip_tweak(tweak_t* t) {\n sip_t sipout;\n size_t i, M;\n\n // a_order and b_order should be the same!\n assert(t->sip->a_order == t->sip->b_order);\n\n debug(\"do_sip_tweak starting.\\n\");\n logverb(\"RMS error of correspondences: %g arcsec\\n\",\n correspondences_rms_arcsec(t, 0));\n if (t->weighted_fit)\n logverb(\"Weighted RMS error of correspondences: %g arcsec\\n\",\n correspondences_rms_arcsec(t, 1));\n\n M = il_size(t->image);\n double* starxyz = malloc(M * 3 * sizeof(double));\n double* fieldxy = malloc(M * 2 * sizeof(double));\n double* weights = NULL;\n if (t->weighted_fit)\n weights = malloc(M * sizeof(double));\n \n int result;\n for (i=0; iimage, i);\n fieldxy[2*i + 0] = t->x[imi];\n fieldxy[2*i + 1] = t->y[imi];\n refi = il_get(t->ref, i);\n radecdeg2xyzarr(t->a_ref[refi], t->d_ref[refi], starxyz + i*3);\n if (t->weighted_fit)\n weights[i] = dl_get(t->weight, i);\n }\n\n int doshift = 1;\n result = fit_sip_wcs(starxyz, fieldxy, weights, M,\n &(t->sip->wcstan), t->sip->a_order, t->sip->ap_order, doshift,\n &sipout);\n free(starxyz);\n free(fieldxy);\n free(weights);\n if (result) {\n ERROR(\"fit_sip_wcs failed\\n\");\n return;\n }\n memcpy(t->sip, &sipout, sizeof(sip_t));\n\n // recalc using new SIP\n tweak_clear_on_sip_change(t);\n tweak_go_to(t, TWEAK_HAS_IMAGE_AD);\n tweak_go_to(t, TWEAK_HAS_REF_XY);\n\n logverb(\"RMS error of correspondences: %g arcsec\\n\",\n correspondences_rms_arcsec(t, 0));\n if (t->weighted_fit)\n logverb(\"Weighted RMS error of correspondences: %g arcsec\\n\",\n correspondences_rms_arcsec(t, 1));\n}\n\n// Really what we want is some sort of fancy dependency system... DTDS!\n// Duct-tape dependencey system (DTDS)\n#define done(x) t->state |= x; return x;\n#define want(x) \\\n if (flag == x && t->state & x) \\\n return x; \\\n else if (flag == x)\n#define ensure(x) \\\n if (!(t->state & x)) { \\\n return tweak_advance_to(t, x); \\\n }\n\nunsigned int tweak_advance_to(tweak_t* t, unsigned int flag) {\n want(TWEAK_HAS_IMAGE_AD) {\n int jj;\n ensure(TWEAK_HAS_SIP);\n ensure(TWEAK_HAS_IMAGE_XY);\n debug(\"Satisfying TWEAK_HAS_IMAGE_AD\\n\");\n // Convert to ra dec\n assert(!t->a);\n assert(!t->d);\n t->a = malloc(sizeof(double) * t->n);\n t->d = malloc(sizeof(double) * t->n);\n for (jj = 0; jj < t->n; jj++)\n sip_pixelxy2radec(t->sip, t->x[jj], t->y[jj], t->a + jj, t->d + jj);\n done(TWEAK_HAS_IMAGE_AD);\n }\n\n want(TWEAK_HAS_REF_AD) {\n if (!(t->a_ref && t->d_ref)) {\n ensure(TWEAK_HAS_REF_XYZ);\n debug(\"Satisfying TWEAK_HAS_REF_AD\\n\");\n ref_ad_from_xyz(t);\n }\n assert(t->a_ref && t->d_ref);\n done(TWEAK_HAS_REF_AD);\n }\n\n want(TWEAK_HAS_REF_XYZ) {\n if (!t->xyz_ref) {\n ensure(TWEAK_HAS_REF_AD);\n debug(\"Satisfying TWEAK_HAS_REF_XYZ\\n\");\n ref_xyz_from_ad(t);\n }\n assert(t->xyz_ref);\n done(TWEAK_HAS_REF_XYZ);\n }\n\n want(TWEAK_HAS_REF_XY) {\n int jj;\n ensure(TWEAK_HAS_REF_AD);\n debug(\"Satisfying TWEAK_HAS_REF_XY\\n\");\n assert(t->state & TWEAK_HAS_REF_AD);\n assert(t->n_ref);\n assert(!t->x_ref);\n assert(!t->y_ref);\n t->x_ref = malloc(sizeof(double) * t->n_ref);\n t->y_ref = malloc(sizeof(double) * t->n_ref);\n for (jj = 0; jj < t->n_ref; jj++) {\n Unused anbool ok;\n ok = sip_radec2pixelxy(t->sip, t->a_ref[jj], t->d_ref[jj],\n t->x_ref + jj, t->y_ref + jj);\n assert(ok);\n }\n done(TWEAK_HAS_REF_XY);\n }\n\n want(TWEAK_HAS_IMAGE_XYZ) {\n int i;\n ensure(TWEAK_HAS_IMAGE_AD);\n debug(\"Satisfying TWEAK_HAS_IMAGE_XYZ\\n\");\n assert(!t->xyz);\n t->xyz = malloc(3 * t->n * sizeof(double));\n for (i = 0; i < t->n; i++)\n radecdeg2xyzarr(t->a[i], t->d[i], t->xyz + 3*i);\n done(TWEAK_HAS_IMAGE_XYZ);\n }\n\n want(TWEAK_HAS_COARSLY_SHIFTED) {\n ensure(TWEAK_HAS_REF_XY);\n ensure(TWEAK_HAS_IMAGE_XY);\n debug(\"Satisfying TWEAK_HAS_COARSLY_SHIFTED\\n\");\n get_dydx_range(t->x, t->y, t->n, t->x_ref, t->y_ref, t->n_ref,\n &t->mindx, &t->mindy, &t->maxdx, &t->maxdy);\n do_entire_shift_operation(t, 1.0);\n tweak_clear_image_ad(t);\n tweak_clear_ref_xy(t);\n done(TWEAK_HAS_COARSLY_SHIFTED);\n }\n\n want(TWEAK_HAS_FINELY_SHIFTED) {\n ensure(TWEAK_HAS_REF_XY);\n ensure(TWEAK_HAS_IMAGE_XY);\n ensure(TWEAK_HAS_COARSLY_SHIFTED);\n debug(\"Satisfying TWEAK_HAS_FINELY_SHIFTED\\n\");\n // Shrink size of hough box\n do_entire_shift_operation(t, 0.3);\n tweak_clear_image_ad(t);\n tweak_clear_ref_xy(t);\n done(TWEAK_HAS_FINELY_SHIFTED);\n }\n\n want(TWEAK_HAS_REALLY_FINELY_SHIFTED) {\n ensure(TWEAK_HAS_REF_XY);\n ensure(TWEAK_HAS_IMAGE_XY);\n ensure(TWEAK_HAS_FINELY_SHIFTED);\n debug(\"Satisfying TWEAK_HAS_REALLY_FINELY_SHIFTED\\n\");\n // Shrink size of hough box\n do_entire_shift_operation(t, 0.03);\n tweak_clear_image_ad(t);\n tweak_clear_ref_xy(t);\n done(TWEAK_HAS_REALLY_FINELY_SHIFTED);\n }\n\n want(TWEAK_HAS_CORRESPONDENCES) {\n ensure(TWEAK_HAS_REF_XYZ);\n ensure(TWEAK_HAS_IMAGE_XYZ);\n debug(\"Satisfying TWEAK_HAS_CORRESPONDENCES\\n\");\n t->jitterd2 = arcsec2distsq(t->jitter);\n find_correspondences(t, 6.0 * arcsec2rad(t->jitter));\n done(TWEAK_HAS_CORRESPONDENCES);\n }\n\n want(TWEAK_HAS_LINEAR_CD) {\n ensure(TWEAK_HAS_SIP);\n ensure(TWEAK_HAS_REALLY_FINELY_SHIFTED);\n ensure(TWEAK_HAS_REF_XY);\n ensure(TWEAK_HAS_REF_AD);\n ensure(TWEAK_HAS_IMAGE_XY);\n ensure(TWEAK_HAS_CORRESPONDENCES);\n debug(\"Satisfying TWEAK_HAS_LINEAR_CD\\n\");\n do_sip_tweak(t);\n tweak_clear_on_sip_change(t);\n done(TWEAK_HAS_LINEAR_CD);\n }\n\n // small memleak -- but it's a major bug if this happens, so suck it up.\n logerr(\"die for dependence: %s\\n\", state_string(flag));\n assert(0);\n return -1;\n}\n\nvoid tweak_push_wcs_tan(tweak_t* t, const tan_t* wcs) {\n memcpy(&(t->sip->wcstan), wcs, sizeof(tan_t));\n t->state |= TWEAK_HAS_SIP;\n}\n\nvoid tweak_go_to(tweak_t* t, unsigned int dest_state) {\n while (!(t->state & dest_state))\n tweak_advance_to(t, dest_state);\n}\n\n#define SAFE_FREE(xx) {free((xx)); xx = NULL;}\nvoid tweak_clear(tweak_t* t) {\n if (!t)\n return ;\n SAFE_FREE(t->a);\n SAFE_FREE(t->d);\n SAFE_FREE(t->x);\n SAFE_FREE(t->y);\n SAFE_FREE(t->xyz);\n SAFE_FREE(t->a_ref);\n SAFE_FREE(t->d_ref);\n SAFE_FREE(t->x_ref);\n SAFE_FREE(t->y_ref);\n SAFE_FREE(t->xyz_ref);\n if (t->sip) {\n sip_free(t->sip);\n t->sip = NULL;\n }\n il_free(t->image);\n il_free(t->ref);\n dl_free(t->dist2);\n if (t->weight)\n dl_free(t->weight);\n t->image = NULL;\n t->ref = NULL;\n t->dist2 = NULL;\n t->weight = NULL;\n kdtree_free(t->kd_image);\n kdtree_free(t->kd_ref);\n}\n\nvoid tweak_free(tweak_t* t) {\n tweak_clear(t);\n free(t);\n}\n", "meta": {"hexsha": "9082b3ad7a8c3fe1550ca63a2adbfb6caabebc9e", "size": 25178, "ext": "c", "lang": "C", "max_stars_repo_path": "solver/tweak.c", "max_stars_repo_name": "juandesant/astrometry.net", "max_stars_repo_head_hexsha": "47849f0443b890c4a875360f881d2e60d1cba630", "max_stars_repo_licenses": ["Net-SNMP", "Xnet"], "max_stars_count": 460.0, "max_stars_repo_stars_event_min_datetime": "2015-01-06T13:20:04.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-29T00:37:55.000Z", "max_issues_repo_path": "solver/tweak.c", "max_issues_repo_name": "juandesant/astrometry.net", "max_issues_repo_head_hexsha": "47849f0443b890c4a875360f881d2e60d1cba630", "max_issues_repo_licenses": ["Net-SNMP", "Xnet"], "max_issues_count": 208.0, "max_issues_repo_issues_event_min_datetime": "2015-01-08T20:26:38.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-25T15:21:34.000Z", "max_forks_repo_path": "solver/tweak.c", "max_forks_repo_name": "juandesant/astrometry.net", "max_forks_repo_head_hexsha": "47849f0443b890c4a875360f881d2e60d1cba630", "max_forks_repo_licenses": ["Net-SNMP", "Xnet"], "max_forks_count": 173.0, "max_forks_repo_forks_event_min_datetime": "2015-01-08T18:01:54.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-27T07:27:04.000Z", "avg_line_length": 30.6674786845, "max_line_length": 105, "alphanum_fraction": 0.5739534514, "num_tokens": 7575, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8056321843145404, "lm_q2_score": 0.6370307944803831, "lm_q1q2_score": 0.5132125104328581}} {"text": "#include \n#include \n#include \n#ifdef _MSC_VER\t\t\t\t/* identifies this as a Microsoft compiler */\n#define _USE_MATH_DEFINES\t/* added RX2011 */\n#endif\n#include \n#include \n#include \n#include \n//#include \"/Users/tischler/dev/GNU/include/gsl/gsl_multimin.h\"\n#include \"Euler.h\"\n\n#ifdef DEBUG_ON\n#define DEBUG 1\t\t\t\t/* a value of 5 gets everything */\n#endif\n\n#define MIN(A,B)\t( (A)<(B)?(A):(B) )\n#define MAX(A,B)\t( (A)>(B)?(A):(B) )\n\ndouble my_f (const gsl_vector *v, void *params);\n\n\n\n\n/******************************************************************************************\n * return the error between a lattice rotated by Euler angles and the measured spots\n * thus the returned value is a minimum for the optimimal Euler angles\n */\ndouble my_f(\nconst gsl_vector *v,\t/* vector with current value of Euler angles */\nvoid\t*pattern)\t\t/* pointer to the parameters, in this case a pointer to the pattern structure */\n{\n\tdouble G[3];\t\t\t\t\t\t/* calculated G vector for each hkl */\n\tdouble recip[3][3];\t\t\t\t/* reciprocal space */\n\tdouble M_Euler[3][3];\t\t\t\t/* an Euler matrix */\n\tsize_t N;\t\t\t\t\t\t\t/* local copy of number of measured spots to check */\n\tdouble a,b,g;\t\t\t\t\t\t/* local copy of the Euler angles */\n\tstruct patternOfOneGrain *p;\t\t/* local value of pattern */\n\tdouble rms;\t\t\t\t\t\t/* rms value of error, the returned value */\n\tsize_t i;\t\t\t\t\t\t\t/* loop index */\n\tdouble hkl[3];\t\t\t\t\t\t/* float value of hkl */\n\tdouble dot;\n\n\t/* p = pattern; */\n\tp = (struct patternOfOneGrain *)pattern;\n\tN = p->Ni;\t\t\t\t\t\t\t\t\t\t\t/* local value for convenience */\n\ta = gsl_vector_get(v,0);\t\t\t\t\t\t\t/* the Euler angles */\n\tb = gsl_vector_get(v,1);\n\tg = gsl_vector_get(v,2);\n\tMatrixCopy33(recip,p->xtal.recip);\t\t\t\t\t/* copy unrotated reciprocal lattice into recip */\n\n\tEulerMatrix(a,b,g,M_Euler);\t\t\t\t\t\t\t/* make the rotation matrix M_Euler from Euler angles */\n\tMatrixMultiply33(M_Euler,recip,recip);\t\t\t\t/* rotate recip by Euler angles */\n\tfor (i=0,rms=0.0;ihkls[i]);\t\t\t\t\t/* convert integer hkl to float for following MatrixMultiply31 */\nif (hkl[0]!=hkl[0]) {\nfprintf(stderr,\"hkl[0] is NaN\\n\");\n}\n\t\tMatrixMultiply31(recip,hkl,G);\nif (G[0]!=G[0]) {\nfprintf(stderr,\"G[0] is NaN\\n\");\n}\n\t\tnormalize3(G);\t\t\t\t\t\t\t\t\t/* normalized gvec of hkl[i] rotated by Euler angles */\n\t\tdot = dot3(G,p->Ghat[i]);\n\t\tdot = MIN(dot,1.0);\n\t\trms += 1. - dot;\t\t\t\t\t\t\t\t/* (1-dot) ~ 0.5*(delta angle)^2*/\n\t}\n\trms = sqrt(rms/(double)N);\t\t\t\t\t\t\t/* rms of angle errors */\n\treturn rms;\n}\n\n\n\n\n\n/* When calling optimizeEulerAngles(), be sure to set pattern.xtal:\n\n\te.g.\n\tpattern.xtal.a = pattern.xtal.b = pattern.xtal.c = 4.05;\t\t// just default to Al for now\n\tpattern.xtal.alpha = pattern.xtal.beta = pattern.xtal.gamma = M_PI/2.0;\n\n\tthen call:\n\t\tFillRecipInLattice(&(pattern.lattice));\n\tto set the reciprocal lattice in the lattice structure\n*/\n/* this routine optimizes approximate Euler angles using the gsl simplex method. */\nint optimizeEulerAngles(\ndouble startStep,\t\t\t\t\t/* starting step size (radians), make this a bit larger than the error */\ndouble epsAbs,\t\t\t\t\t\t/* tolerance on the answer (=0.001) */\nlong\tmaxIter,\t\t\t\t\t/* maximum number of iterations, stop after this many regardless, perhaps 100 */\nstruct\tpatternOfOneGrain *pattern) /* provides G^'s and hkl's for one fitted pattern, and the lattice parameters */\n{\n\tsize_t np = 3;\t\t\t\t\t/* number of dimensions of the function, 3 Euler angles */\n\n\t/* T tells what kind of minimizer we are using, select the simplex method */\n\tconst gsl_multimin_fminimizer_type *T = gsl_multimin_fminimizer_nmsimplex;\n\tgsl_multimin_fminimizer *s = NULL;\t\t/* this is the minimizer */\n\tgsl_vector *ss, *x;\t\t\t\t\t\t/* pointers to vectors, ss is stepsize, x is point */\n\tgsl_multimin_function minex_func;\t\t/* struct defining parts needed for minimizing */\n\tsize_t iter=0, i;\n\tint status;\t\t\t\t\t\t\t\t/* status of returned gsl function, 0 is OK */\n\tdouble size;\t\t\t\t\t\t\t/* size of minimizer, sort of maximum error */\n\n\tdouble G[3];\t\t\t\t\t\t\t/* calculated G vector for each hkl */\n\tdouble recip[3][3];\t\t\t\t\t/* reciprocal space */\n\tdouble M_Euler[3][3];\t\t\t\t\t/* an Euler matrix */\n\tdouble hkl[3];\t\t\t\t\t\t\t/* float value of hkl */\n\tdouble dot;\n\n\tif (!pattern) { fprintf(stderr,\"pattern in NULL on entry to optimizeEulerAngles()\\n\"); return 1; }\n\tif (pattern->Ni<3) { fprintf(stderr,\"less than 3 pairs of Ghat & hkls on entry to optimizeEulerAngles()\\n\"); return 1; }\n\tif (!(pattern->Ghat) || !(pattern->hkls)) { fprintf(stderr,\"Ghat or hkls are NULL on entry to optimizeEulerAngles()\\n\"); return 1; }\n\tif ((pattern->xtal.a)<=0 || (pattern->xtal.b)<=0 || (pattern->xtal.c)<=0) { fprintf(stderr,\"invalid lattice in optimizeEulerAngles()\\n\"); return 1; }\n\n\t/* Initial vertex step size vector */\n\tss = gsl_vector_alloc(np);\t\t\t\t/* step sizes in x and y */\n\n\t/* Set all step sizes to startStep, the starting step size */\n\tgsl_vector_set_all(ss, startStep);\t\t/* set ss[0] = ss[1] = ss[2] = startStep (radian) */\n\n\t/* Starting point */\n\tx = gsl_vector_alloc(np);\t\t\t\t/* allocate space for a vector of length 3 */\n\tgsl_vector_set(x, 0, pattern->alpha); /* set to starting guess, input (alpha,beta,gamma) */\n\tgsl_vector_set(x, 1, pattern->beta);\n\tgsl_vector_set(x, 2, pattern->gamma);\n\n\t/* Initialize the minimizer */\n\tminex_func.f = &my_f;\t\t\t\t\t/* the function that returns the value */\n\tminex_func.n = np;\t\t\t\t\t\t/* number of parameters */\n\tminex_func.params = (void *)pattern;\t/* a generic pointer that points to something with info for my_f() */\n\t/* Note: my_func.df, and my_func.fdf are not needed since simplex method does not use derivatives */\n\n\ts = gsl_multimin_fminimizer_alloc(T, np);\t/* allocate for a 2d simplex minimizer named 's' */\n\n\t/* Set starting point for the minimizer:\n\t\tfor the minimizer 's',\n\t\tworking on a function 'minex_func'\n\t\tstarting from the initial guess x[2]\n\t\tusing step sizes of ss[2] */\n\tgsl_multimin_fminimizer_set(s, &minex_func, x, ss);\n\n#if (DEBUG)\t\t/******************************************************************************/\n\tfprintf(fout, \"start minimization with Euler angles (%15.10f, %15.10f, %15.10f) (deg.)\\n\", \\\n\t\tpattern->alpha*180/M_PI,pattern->beta*180/M_PI,pattern->gamma*180/M_PI);\n#endif\t\t\t/******************************************************************************/\n\n\t/* Iterate the minimizer. This looop iterates the minimization method until it is good enough */\n\titer = 0;\n\tdo {\n\t\titer++;\n\t\tstatus = gsl_multimin_fminimizer_iterate(s);\t/* do one iteration of the minimizer */\n\t\tif (status) break;\t\t\t\t\t\t\t\t/* status=0 is OK, check here for an error */\n\n\t\tsize = gsl_multimin_fminimizer_size (s); \t\t/* get 'size' of minimizer */\n\t\tstatus = gsl_multimin_test_size (size, epsAbs);\t/* test size against epsAbs */\n\n#if (DEBUG>1)\t\t/******************************************************************************/\n\t\tfprintf(fout,\"%5ld f(\", iter);\n\t\tfor (i=0; ix, i));\n\t\t\tif (ifval, size);\n#endif\t\t\t/******************************************************************************/\n\t} while (status == GSL_CONTINUE && iter < (size_t)maxIter); /* stop after maxIter regardless of size */\n\n#if (DEBUG)\t\t/******************************************************************************/\n\tif (status == GSL_SUCCESS) fprintf(fout,\"converged to minimum successfully\\n\");\n\telse fprintf(fout,\"did not converge successfully, status = %d\\n\",status);\n\tfprintf(fout, \" optimization changed Euler angles by (%15.10f, %15.10f, %15.10f) (deg.)\\n\", \\\n\t\t(gsl_vector_get(s->x,0)-pattern->alpha)*180/M_PI, (gsl_vector_get(s->x,1)-pattern->beta)*180/M_PI, \\\n\t\t(gsl_vector_get(s->x,2)-pattern->gamma)*180/M_PI);\n#endif\t\t\t/******************************************************************************/\n\n\tpattern->alpha = gsl_vector_get(s->x,0);\t\t\t/* set to final values, resultant (alpha,beta,gamma) returned */\n\tpattern->beta = gsl_vector_get(s->x,1);\n\tpattern->gamma = gsl_vector_get(s->x,2);\n\n#if (DEBUG)\t\t/******************************************************************************/\n\tfprintf(fout, \"after minimization, Euler angles are (%15.10f, %15.10f, %15.10f) (deg.)\\n\", \\\n\t\tpattern->alpha*180/M_PI,pattern->beta*180/M_PI,pattern->gamma*180/M_PI);\n#endif\t\t\t/******************************************************************************/\n\n\t/* recalculate the err[] list in pattern */\n\tMatrixCopy33(recip,pattern->xtal.recip);\t\t/* copy unrotated reciprocal lattice into recip */\n\tEulerMatrix(pattern->alpha,pattern->beta,pattern->gamma,M_Euler);/* rotation matrix from Euler angles */\n\tMatrixMultiply33(M_Euler,recip,recip);\t\t\t/* rotate recip by Euler angles */\n\tfor (i=0;i<(size_t)(pattern->Ni);i++) {\n\t\tVECTOR_COPY3(hkl,pattern->hkls[i]);\t\t\t/* convert integer hkl to float for following MatrixMultiply31 */\n\t\tMatrixMultiply31(recip,hkl,G);\n\t\tnormalize3(G);\t\t\t\t\t\t\t\t/* normalized gvec of hkl[i] rotated by Euler angles */\n\t\tdot = dot3(G,pattern->Ghat[i]);\t\t\t\t/* note, Ghat here is the measured, not calculated G */\n\t\t(pattern->err)[i] = acos(MIN(dot,1.0));\n\t}\n\n\tgsl_vector_free(x);\t\t\t\t\t\t\t\t\t/* free vector of x,y positions */\n\tgsl_vector_free(ss);\t\t\t\t\t\t\t\t/* free vector of step sizes */\n\tgsl_multimin_fminimizer_free (s);\t\t\t\t\t/* free the minimizer */\n\treturn status;\n}\n\n\n\n\n\n\n\n", "meta": {"hexsha": "eae7205bce48cc7a5caeafe76854a6322096eee4", "size": 9300, "ext": "c", "lang": "C", "max_stars_repo_path": "legacy/Euler3/source/optimize.c", "max_stars_repo_name": "carterbox/cold", "max_stars_repo_head_hexsha": "2738e6e9ccfd13007ac4fd987bf1a75656d358bd", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "legacy/Euler3/source/optimize.c", "max_issues_repo_name": "carterbox/cold", "max_issues_repo_head_hexsha": "2738e6e9ccfd13007ac4fd987bf1a75656d358bd", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2022-01-21T17:14:55.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-31T10:34:20.000Z", "max_forks_repo_path": "legacy/Euler3/source/optimize.c", "max_forks_repo_name": "carterbox/cold", "max_forks_repo_head_hexsha": "2738e6e9ccfd13007ac4fd987bf1a75656d358bd", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2022-01-21T17:48:28.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-21T17:48:28.000Z", "avg_line_length": 44.4976076555, "max_line_length": 150, "alphanum_fraction": 0.6159139785, "num_tokens": 2536, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8244619263765707, "lm_q2_score": 0.6224593452091672, "lm_q1q2_score": 0.5131940308422488}} {"text": "#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n\n#include \"ccl.h\"\n\n\n/*----- ROUTINE: dc_NakamuraSuto -----\nINPUT: cosmology, scale factor\nTASK: Computes the peak threshold: delta_c(z) assuming LCDM.\nCosmology dependence of the critical linear density according to the spherical-collapse model.\nFitting function from Nakamura & Suto (1997; arXiv:astro-ph/9710107).\n*/\ndouble dc_NakamuraSuto(ccl_cosmology *cosmo, double a, int *status){\n\n double Om_mz = ccl_omega_x(cosmo, a, ccl_species_m_label, status);\n double dc0 = (3./20.)*pow(12.*M_PI,2./3.);\n double dc = dc0*(1.+0.012299*log10(Om_mz));\n\n return dc;\n\n}\n\n/*----- ROUTINE: Dv_BryanNorman -----\nINPUT: cosmology, scale factor\nTASK: Computes the virial collapse density contrast with respect to the matter density assuming LCDM.\nCosmology dependence of the virial collapse density according to the spherical-collapse model\nFitting function from Bryan & Norman (1998; arXiv:astro-ph/9710107)\n*/\ndouble Dv_BryanNorman(ccl_cosmology *cosmo, double a, int *status){\n\n double Om_mz = ccl_omega_x(cosmo, a, ccl_species_m_label, status);\n double x = Om_mz-1.;\n double Dv0 = 18.*pow(M_PI,2);\n double Dv = (Dv0+82.*x-39.*pow(x,2))/Om_mz;\n\n return Dv;\n}\n\nstatic double sigmaM_m2r(ccl_cosmology *cosmo, double halomass, int *status)\n{\n double rho_m, smooth_radius;\n\n // Comoving matter density\n rho_m = ccl_rho_x(cosmo, 1., ccl_species_m_label, 1, status);\n\n smooth_radius = pow((3.0*halomass) / (4*M_PI*rho_m), (1.0/3.0));\n\n return smooth_radius;\n}\n\nvoid ccl_cosmology_compute_sigma(ccl_cosmology *cosmo, ccl_f2d_t *psp, int *status)\n{\n if(cosmo->computed_sigma)\n return;\n\n int na = cosmo->spline_params.A_SPLINE_NA_SM + cosmo->spline_params.A_SPLINE_NLOG_SM - 1;\n int nm = cosmo->spline_params.LOGM_SPLINE_NM;\n double *m = NULL;\n double *y = NULL;\n double *aa = NULL;\n\n // create linearly-spaced values of log-mass.\n m = ccl_linear_spacing(cosmo->spline_params.LOGM_SPLINE_MIN,\n cosmo->spline_params.LOGM_SPLINE_MAX, nm);\n if (m == NULL ||\n (fabs(m[0]-cosmo->spline_params.LOGM_SPLINE_MIN)>1e-5) ||\n (fabs(m[nm-1]-cosmo->spline_params.LOGM_SPLINE_MAX)>1e-5) ||\n (m[nm-1]>10E17)) {\n *status = CCL_ERROR_MEMORY;\n ccl_cosmology_set_status_message(cosmo,\n \"ccl_massfunc.c: ccl_cosmology_compute_sigma(): \"\n \"Error creating linear spacing in m\\n\");\n }\n\n // create scale factor array\n if (*status == 0) {\n aa = ccl_linlog_spacing(cosmo->spline_params.A_SPLINE_MINLOG_SM,\n cosmo->spline_params.A_SPLINE_MIN_SM,\n cosmo->spline_params.A_SPLINE_MAX,\n cosmo->spline_params.A_SPLINE_NLOG_SM,\n cosmo->spline_params.A_SPLINE_NA_SM);\n if (aa == NULL) {\n *status = CCL_ERROR_MEMORY;\n ccl_cosmology_set_status_message(cosmo,\n \"ccl_massfunc.c: ccl_cosmology_compute_sigma(): \"\n \"Error creating scale factor array\\n\");\n }\n }\n\n // create space for y, to be filled with sigma\n if (*status == 0) {\n y = malloc(sizeof(double)*nm*na);\n if (y == NULL) {\n *status = CCL_ERROR_MEMORY;\n ccl_cosmology_set_status_message(cosmo,\n \"ccl_massfunc.c: ccl_cosmology_compute_sigma(): \"\n \"memory allocation\\n\");\n }\n }\n\n // fill in sigma, if no errors have been triggered at this time.\n if (*status == 0) {\n #pragma omp parallel shared(na, aa, nm, m, y, status, cosmo, psp) \\\n default(none)\n {\n int i, j;\n double a_sf, smooth_radius;\n int local_status = *status;\n\n #pragma omp for\n for (j=0; jcomputed_sigma = true;\n cosmo->data.logsigma = lsM;\n }\n else\n gsl_spline2d_free(lsM);\n\n free(aa);\n free(m);\n free(y);\n}\n\n/*----- ROUTINE: ccl_sigma_M -----\nINPUT: ccl_cosmology * cosmo, double halo mass in units of Msun, double scale factor\nTASK: returns sigma from the sigmaM interpolation. Also computes the sigma interpolation if\nnecessary.\n*/\ndouble ccl_sigmaM(ccl_cosmology *cosmo, double log_halomass, double a, int *status)\n{\n // Check if sigma has already been calculated\n if (!cosmo->computed_sigma) {\n *status = CCL_ERROR_SIGMA_INIT;\n ccl_cosmology_set_status_message(cosmo,\n \"ccl_massfunc.c: ccl_sigmaM(): \"\n \"sigma(M) spline has not been computed!\");\n return NAN;\n }\n\n double lgsigmaM;\n int gslstatus = gsl_spline2d_eval_e(cosmo->data.logsigma, log_halomass,\n a, NULL, NULL, &lgsigmaM);\n\n if(gslstatus != GSL_SUCCESS) {\n ccl_raise_gsl_warning(gslstatus, \"ccl_massfunc.c: ccl_sigmaM():\");\n *status |= gslstatus;\n }\n\n return exp(lgsigmaM);\n}\n\n/*----- ROUTINE: ccl_dlnsigM_dlogM -----\nINPUT: ccl_cosmology *cosmo, double halo mass in units of Msun\nTASK: returns the value of the derivative of ln(sigma^-1) with respect to log10 in halo mass.\n*/\ndouble ccl_dlnsigM_dlogM(ccl_cosmology *cosmo, double log_halomass, double a, int *status)\n{\n // Check if sigma has already been calculated\n if (!cosmo->computed_sigma) {\n *status = CCL_ERROR_SIGMA_INIT;\n ccl_cosmology_set_status_message(cosmo,\n \"ccl_massfunc.c: ccl_dlnsigM_dlogM(): \"\n \"sigma(M) spline has not been computed!\");\n return NAN;\n }\n\n double dlsdlgm;\n int gslstatus = gsl_spline2d_eval_deriv_x_e(cosmo->data.logsigma,\n log_halomass, a,\n NULL, NULL, &dlsdlgm);\n if(gslstatus) { \n ccl_raise_gsl_warning(gslstatus, \"ccl_massfunc.c: ccl_dlnsigM_dlogM():\");\n *status |= gslstatus;\n }\n return -dlsdlgm;\n}\n", "meta": {"hexsha": "47fac82ba3738ff586f1c3e711528bf571b6469f", "size": 7243, "ext": "c", "lang": "C", "max_stars_repo_path": "src/ccl_massfunc.c", "max_stars_repo_name": "Jappenn/CCL", "max_stars_repo_head_hexsha": "a37cad61f060f3928fa5d47b1e2670db3e9bce6f", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 91.0, "max_stars_repo_stars_event_min_datetime": "2017-07-14T02:45:59.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-28T08:55:54.000Z", "max_issues_repo_path": "src/ccl_massfunc.c", "max_issues_repo_name": "Jappenn/CCL", "max_issues_repo_head_hexsha": "a37cad61f060f3928fa5d47b1e2670db3e9bce6f", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 703.0, "max_issues_repo_issues_event_min_datetime": "2017-07-07T16:27:17.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-30T14:40:10.000Z", "max_forks_repo_path": "src/ccl_massfunc.c", "max_forks_repo_name": "Jappenn/CCL", "max_forks_repo_head_hexsha": "a37cad61f060f3928fa5d47b1e2670db3e9bce6f", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 54.0, "max_forks_repo_forks_event_min_datetime": "2017-07-12T13:08:25.000Z", "max_forks_repo_forks_event_max_datetime": "2022-02-06T13:12:10.000Z", "avg_line_length": 33.0730593607, "max_line_length": 101, "alphanum_fraction": 0.6098301809, "num_tokens": 2048, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8539127641048443, "lm_q2_score": 0.600188359260205, "lm_q1q2_score": 0.512508500839433}} {"text": "/**\n * \\brief Function Definition Library to implement Sensor Fusion Algorithm\n * \\author jaspalsingh@cmail.carleton.ca\n * \\version 1.0\n * \\date 2019-12-01\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \"sensor_fusion.h\"\n\n/**\n * \\brief Structure pointer for computed support degree matrix\n * \\details Structure pointer for calculating support degree matrix\n * \\param[in] sensor_readings array of sensor readings\n * \\return Success: pointer to the structure support_degree_matrix\n * \\return Failure: NULL\n */\nstruct support_degree_matrix *compute_support_degree_matrix(double *sensor_readings) {\n struct support_degree_matrix *spd;\n spd = (struct support_degree_matrix *)malloc(sizeof(struct support_degree_matrix));\n // count the number of sensor readings\n int length = sizeof(sensor_readings) / sizeof(sensor_readings[0]);\n spd->sensor_count = length;\n double **arrptr = (double **)malloc(length * sizeof(double *));\n int count = 0;\n for (int i = 0; i < length; i++) {\n arrptr[i] = (double *)malloc(length * sizeof(double));\n }\n // allocate memory space for support degree matrix structure\n spd->sd_matrix = (double *)malloc(sizeof(double) * length * length);\n if (arrptr == NULL || spd == NULL || spd->sd_matrix == NULL) {\n printf(\"ERROR: Failed to allocate memory at %s\\n\", __func__);\n return NULL;\n }\n // compute support degree matrix\n for (int i = 0; i < length; i++) {\n for (int j = 0; j < length; j++) {\n arrptr[i][j] = exp(-1 * fabs(sensor_readings[i] - sensor_readings[j]));\n spd->sd_matrix[count] = arrptr[i][j];\n count++;\n }\n }\n printf(\"INFO : Computed support degree matrix\\n\");\n for (int i = 0; i < length * length; i++) {\n printf(\"DEBUG: Value => %f\\n\", spd->sd_matrix[i]);\n }\n free(arrptr);\n return spd;\n}\n\n/**\n * \\brief Structure pointer calculate eigen value and eigen vector\n * \\details Structure pointer for calculating eigen value and eigen vector\n * \\param[in] support_degree_matrix pointer to structure support degree matrix\n * \\return Success: pointer to structure eigen_value_vector\n * \\return Failure: NULL\n */\nstruct eigen_value_vector *compute_eigen(struct support_degree_matrix *spd) {\n if ((spd->sd_matrix == NULL) || (spd->sensor_count == 0)) {\n printf(\"ERROR: Invalid param passed at %s\\n\", __func__);\n return NULL;\n }\n int length = spd->sensor_count;\n struct eigen_value_vector *eigen;\n // allocation memory space for eigen value vector structure\n eigen = (struct eigen_value_vector *)malloc(sizeof(struct eigen_value_vector));\n eigen->eigen_value = (double *)malloc(sizeof(double) * length);\n eigen->eigen_vector = (double **)malloc(length * sizeof(double *));\n for (int i = 0; i < length; i++) {\n eigen->eigen_vector[i] = (double *)malloc(length * sizeof(double));\n }\n if (eigen == NULL || eigen->eigen_vector == NULL || eigen->eigen_value == NULL) {\n printf(\"ERROR: Failed to allocate memory at %s\\n\", __func__);\n return NULL;\n }\n //Refer: https://www.gnu.org/software/gsl/doc/html/eigen.html\n // compute eigen values\n gsl_matrix_view m = gsl_matrix_view_array(spd->sd_matrix, length, length);\n gsl_vector *eval = gsl_vector_alloc(length);\n gsl_matrix *evec = gsl_matrix_alloc(length, length);\n gsl_eigen_symmv_workspace *w = gsl_eigen_symmv_alloc(length);\n gsl_eigen_symmv(&m.matrix, eval, evec, w);\n gsl_eigen_symmv_free(w);\n gsl_eigen_symmv_sort(eval, evec, GSL_EIGEN_SORT_VAL_DESC);\n {\n int i;\n for (i = 0; i < length; i++) {\n eigen->eigen_value[i] = gsl_vector_get(eval, i);\n gsl_vector_view evec_i = gsl_matrix_column(evec, i);\n for (int j = 0; j < length; j++) {\n eigen->eigen_vector[i][j] = *(*(&evec_i.vector.data) + j * length);\n }\n }\n }\n for (int i = 0; i < length; i++) {\n printf(\"DEBUG: Eigen Value => %g\\n\", eigen->eigen_value[i]);\n printf(\"DEBUG: Eigen Vector => \\n\");\n for (int j = 0; j < length; j++) {\n printf(\"%g\\n\", eigen->eigen_vector[i][j]);\n }\n }\n gsl_vector_free(eval);\n gsl_matrix_free(evec);\n return eigen;\n}\n\n/**\n * \\brief Function to calculate the contribution rate of principal component\n * \\details Compute the contribution rate of kth and mth principal components\n * \\param[in] eigen_value_vector pointer to structure of eigen_value_vector\n * \\param[in] sensor_count total count of sensors\n * \\return Success: pointer to contribution_rate of type double\n * \\return Failure: NULL\n */\ndouble *compute_contribution_rate(struct eigen_value_vector *eigen,\n int sensor_count) {\n if ((sensor_count == 0) || (eigen->eigen_value == NULL) || (eigen->eigen_vector == NULL)) {\n printf(\"ERROR: Invalid param passed at %s\\n\", __func__);\n return NULL;\n }\n double *contribution_rate = (double *)malloc(sensor_count * sizeof(double));\n if (contribution_rate == NULL) {\n printf(\"ERROR: Failed to allocate memory at %s\\n\", __func__);\n return NULL;\n }\n double sum = 0;\n for (int i = 0; i < sensor_count; i++) {\n sum += eigen->eigen_value[i];\n }\n printf(\"INFO : Compute contribution rate\\n\");\n for (int j = 0; j < sensor_count; j++) {\n contribution_rate[j] = eigen->eigen_value[j] / sum;\n printf(\"DEBUG: Rate => %g\\n\", contribution_rate[j]);\n }\n return contribution_rate;\n}\n\n/**\n * \\brief Function to compute contribution rate\n * \\details Compute the count of contribution rates to be used for sensors\n * \\param[in] contribution_rate\n * \\param[in] threshold\n * \\param[in] sensor_count number of sensors to be used\n * \\return Success: contribution rate count, \n * \\return Failure: -1\n */\nint compute_contrib_rate_count(double *contribution_rate,\n float threshold,\n int sensor_count) {\n if ((contribution_rate == NULL) || (threshold == 0) || (sensor_count == 0)) {\n printf(\"ERROR: Invalid param passed at %s\\n\", __func__);\n return -1;\n }\n double sum = 0;\n int m;\n for (int k = 0; k < sensor_count; k++) {\n for (int j = 0; j <= k; j++) {\n sum += contribution_rate[j];\n }\n if (sum <= threshold) {\n m = k - 1;\n printf(\"DEBUG: Contribution rate to use %d\\n\", m);\n return m;\n }\n }\n printf(\"DEBUG: Count of Contribution rates => %d\\n\", sensor_count);\n return sensor_count;\n}\n\n/**\n * \\brief Function to compute principal component\n * \\details Computed principal component for each of eigen vector\n * \\param[in] support_degree_matrix pointer to structure support degree matrix\n * \\param[in] eigen_vector pointer to pointer of eigen vector of type double\n * \\param[in] contrib_rate_count number of contribution rate to be used\n * \\return Success: principal of support degree matrix, \n * \\return Failure: NULL\n */\ndouble **compute_principal_component(struct support_degree_matrix *spd,\n double **eigen_vector,\n int contrib_rate_count) {\n if ((spd->sensor_count == 0) || (contrib_rate_count == 0) || (spd->sd_matrix == NULL) || (eigen_vector == NULL)) {\n printf(\"ERROR: Invalid param passed at %s\\n\", __func__);\n return NULL;\n }\n int n = spd->sensor_count;\n int m = contrib_rate_count;\n int count = 0;\n double **arrptr = (double **)malloc(n * sizeof(double *));\n for (int i = 0; i < n; i++) {\n arrptr[i] = (double *)malloc(n * sizeof(double));\n }\n if (arrptr == NULL) {\n printf(\"ERROR: Failed to allocate memory at %s\\n\", __func__);\n return NULL;\n }\n printf(\"INFO : Compute support degree matrix\\n\");\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n arrptr[i][j] = spd->sd_matrix[count];\n printf(\"%f\\n\", arrptr[i][j]);\n count++;\n }\n }\n double **principal_components_matrix = (double **)malloc(m * sizeof(double *));\n for (int i = 0; i < n; i++) {\n principal_components_matrix[i] = (double *)malloc(n * sizeof(double));\n }\n if (principal_components_matrix == NULL) {\n printf(\"ERROR: Failed to allocate memory at %s\\n\", __func__);\n return NULL;\n }\n for (int i = 0; i < m; i++) {\n for (int j = 0; j < n; j++) {\n principal_components_matrix[i][j] = 0;\n for (int k = 0; k < n; k++) {\n principal_components_matrix[i][j] += eigen_vector[i][k] * arrptr[k][j];\n }\n }\n }\n free(arrptr);\n return principal_components_matrix;\n}\n\n/**\n * \\brief Function to compute integrated support degree\n * \\details Computed support degree matrix for each of the sensors\n * \\param[in] principle_components pointer to pointer of principle component of type double\n * \\param[in] contribution_rate pointer to contribution rate of type double\n * \\param[in] contrib_rate_count number of contribution rate to be used\n * \\param[in] sensor_count number of sensors\n * \\return Success: array of support degree matrix, \n * \\return Failure: NULL\n */\ndouble *compute_integrated_support_degree(double **principle_components,\n double *contribution_rate,\n int contrib_rate_count,\n int sensor_count) {\n if ((sensor_count == 0) || (contrib_rate_count == 0) || (principle_components == NULL) || (contribution_rate == NULL)) {\n printf(\"ERROR: Invalid param passed at %s\\n\", __func__);\n return NULL;\n }\n double *arr = (double *)malloc(sensor_count * sizeof(double));\n if (arr == NULL) {\n printf(\"ERROR: Failed to allocate memory at %s\\n\", __func__);\n return NULL;\n }\n // Calculate integrated support degree matrix\n for (int i = 0; i < sensor_count; i++) {\n for (int j = 0; j < contrib_rate_count; j++) {\n printf(\"INFO: Principal Component => %d-%f, Contribution Rate => %d-%f\\n\", i, principle_components[i][j], j, contribution_rate[i]);\n arr[i] += principle_components[i][j] * contribution_rate[i];\n }\n }\n return arr;\n}\n\n/**\n * \\brief Function to eliminate invalid sensor readings\n * \\details Discard the faulty sensor readings from the support degree matrix\n * \\param[in,out] integrated_support_degree_matrix pointer to integrated support degree matrix\n * \\param[in] fault_tolerance_threshold threshold value to cut off invalid readings\n * \\param[in] sensor_count total count of sensors\n * \\return Success: 0, \n * \\return Failure: -1\n */\nint eliminate_incorrect_data(double *integrated_support_degree_matrix,\n double fault_tolerance_threshold,\n int sensor_count) {\n int i;\n double mean = 0;\n double sum = 0;\n double *arr = integrated_support_degree_matrix;\n if ((sensor_count == 0) || (arr == NULL)) {\n printf(\"ERROR: Invalid param passed at %s\\n\", __func__);\n return -1;\n }\n for (i = 0; i < sensor_count; i++) {\n sum += arr[i];\n }\n mean = sum / (i + 1);\n for (i = 0; i < sensor_count; i++) {\n if (fabs(arr[i]) < fabs(fault_tolerance_threshold * mean)) {\n arr[i] = 0;\n }\n }\n return 0;\n}\n\n/**\n * \\brief Function to compute weight coefficient for each sensor\n * \\details Compute weighted coefficients for each sensors from the support degree matrix\n * \\param[in] integrated_support_degree_matrix pointer to integrated support degree matrix\n * \\param[in] sensor_count total count of sensors\n * \\return Success: array of weighted coefficients, \n * \\return Failure: NULL\n */\ndouble *compute_weight_coefficient(double *integrated_support_degree_matrix,\n int sensor_count) {\n double sum_weight_coefficient = 0;\n if ((sensor_count == 0) || (integrated_support_degree_matrix == NULL)) {\n printf(\"ERROR: Invalid param passed at %s\\n\", __func__);\n return NULL;\n }\n double *arr = (double *)malloc(sensor_count * sizeof(double));\n if (arr == NULL) {\n printf(\"ERROR: Failed to allocate memory at %s\\n\", __func__);\n return NULL;\n }\n memset(arr, 0, sensor_count * sizeof(double));\n for (int i = 0; i < sensor_count; i++) {\n sum_weight_coefficient += integrated_support_degree_matrix[i];\n }\n for (int i = 0; i < sensor_count; i++) {\n arr[i] = integrated_support_degree_matrix[i] / sum_weight_coefficient;\n }\n return arr;\n}\n\n/**\n * \\brief Function to compute fused output\n * \\details Compute the aggregated value of sensors from the weighted coefficients\n * \\param[in] weight_coefficient pointer to weighted coefficient of sensors\n * \\param[in] sensor_data pointer to data of sensors\n * \\param[in] sensor_count total count of sensors\n * \\return Success: fused value of sensor data\n * \\return Failure: -1\n */\ndouble compute_fused_output(double *weight_coefficient,\n double *sensor_data,\n int sensor_count) {\n double fused_output = 0;\n if ((sensor_count == 0) || (weight_coefficient == NULL) || (sensor_data == NULL)) {\n printf(\"ERROR: Invalid param passed at %s\\n\", __func__);\n return -1;\n }\n for (int i = 0; i < sensor_count; i++) {\n fused_output += weight_coefficient[i] * sensor_data[i];\n }\n return fused_output;\n}", "meta": {"hexsha": "ff720195666c5b745497873c4ca25270bf5e9854", "size": 13617, "ext": "c", "lang": "C", "max_stars_repo_path": "src/sensor_fusion.c", "max_stars_repo_name": "jaspal-carleton/SensorFusionAlgorithm", "max_stars_repo_head_hexsha": "25b78e48d4bc6737c61c599026e1943348b91fcc", "max_stars_repo_licenses": ["RSA-MD"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/sensor_fusion.c", "max_issues_repo_name": "jaspal-carleton/SensorFusionAlgorithm", "max_issues_repo_head_hexsha": "25b78e48d4bc6737c61c599026e1943348b91fcc", "max_issues_repo_licenses": ["RSA-MD"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-12-08T18:40:17.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-18T14:59:30.000Z", "max_forks_repo_path": "src/sensor_fusion.c", "max_forks_repo_name": "jaspal-carleton/SensorFusionAlgorithm", "max_forks_repo_head_hexsha": "25b78e48d4bc6737c61c599026e1943348b91fcc", "max_forks_repo_licenses": ["RSA-MD"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 39.3554913295, "max_line_length": 143, "alphanum_fraction": 0.6222369097, "num_tokens": 3299, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.743167997235783, "lm_q2_score": 0.6893056104028797, "lm_q1q2_score": 0.512269869966497}} {"text": "/* BalSelSims.c \n\nSimulation of balancing selection simulation with sampling (finite population effects)\nSelection; reproduction; mutation based on deterministic recursions, then sampling\nRepeats for 'Length' generations\n\nSimulation uses routines found with the GNU Scientific Library (GSL)\n(http://www.gnu.org/software/gsl/)\nSince GSL is distributed under the GNU General Public License \n(http://www.gnu.org/copyleft/gpl.html), you must download it \nseparately from this file.\n\nThis program can be compiled in e.g. GCC using a command like:\ngcc BalSelSims -lm -lgsl -lgslcblas -I/usr/local/include -L/usr/local/lib BalSelSims.c\n\nThen run by executing:\n./BalSelSims N s rec sex self gc reps\nWhere:\n- N is the population size\n- s is the fitness disadvantage of homozygotes\n- rec is recombination rate\n- sex is rate of sex (a value between 0 = obligate asex, and 1 = obligate sex)\n- self is selfing rate\n- gc is gene conversion\n- reps is how many times to introduce linked neutral allele\n\nNote that haplotypes are defined as:\nx1 = ab\nx2 = Ab\nx3 = aB\nx4 = AB\n\nGenotypes defined as:\ng11 = g1 = ab/ab\ng12 = g2 = Ab/ab\ng13 = g3 = aB/ab\ng14 = g4 = AB/ab\ng22 = g5 = Ab/Ab\ng23 = g6 = Ab/aB\ng24 = g7 = Ab/AB\ng33 = g8 = aB/aB\ng34 = g9 = aB/AB\ng44 = g10 = AB/AB\n\n*/\n\n/* Preprocessor statements */\n#include \n#include \n#include \n#include \n#include \n#include \n\n/* Function prototypes */\nvoid geninit(double *geninit);\nvoid selection(double *geninit);\nvoid reproduction(double *geninit);\nvoid gconv(double *geninit);\nvoid neutinit(double *geninit,const gsl_rng *r);\ndouble ncheck(double *geninit);\ndouble pcheck(double *geninit);\n\n/* Global variable declaration */\nunsigned int N = 0;\t\t/* Pop size */\ndouble s = 0;\t\t\t/* Fitness disadvantage of homozyogtes */\ndouble rec = 0;\t\t\t/* Recombination rate */\ndouble sex = 0;\t\t\t/* Rate of sexual reproduction */\ndouble self = 0;\t\t/* Rate of self-fertilisation */\ndouble gc = 0;\t\t\t/* Rate of gene conversion */\n\n/* Main program */\nint main(int argc, char *argv[]){\n\tunsigned int g, i; \t\t\t\t/* Counters. Reps counter, geno counter */\n\tunsigned int reps;\t\t\t\t/* Length of simulation (no. of introductions of neutral site) */\n\tdouble Bcheck = 0;\t\t\t\t/* Frequency of B after each reproduction */\n\tdouble Acheck = 0;\t\t\t\t/* Frequency of polymorphism */\n\tdouble Hsum = 0;\t\t\t\t/* Summed heterozygosity over transit time of neutral allele */\n\t\n\t/* GSL random number definitions */\n\tconst gsl_rng_type * T; \n\tgsl_rng * r;\n\t\n\t/* This reads in data from command line. */\n\tif(argc != 8){\n\t\tfprintf(stderr,\"Invalid number of input values.\\n\");\n\t\texit(1);\n\t}\n\tN = strtod(argv[1],NULL);\n\ts = strtod(argv[2],NULL);\n\trec = strtod(argv[3],NULL);\n\tsex = strtod(argv[4],NULL);\n\tself = strtod(argv[5],NULL);\n\tgc = strtod(argv[6],NULL);\n\treps = strtod(argv[7],NULL);\n\t\n\t/* Arrays definition and memory assignment */\n\tdouble *genotype = calloc(10,sizeof(double));\t\t\t\t/* Genotype frequencies */\n\tunsigned int *gensamp = calloc(10,sizeof(unsigned int));\t/* New population samples */\n\t \n\t/* create a generator chosen by the \n environment variable GSL_RNG_TYPE */\n \n\tgsl_rng_env_setup();\n\tif (!getenv(\"GSL_RNG_SEED\")) gsl_rng_default_seed = time(0);\n\tT = gsl_rng_default;\n\tr = gsl_rng_alloc(T);\n\t\n\t/* Initialising genotypes */\n\tgeninit(genotype);\n \n /* Run simulation for 2000 generations to create a burn in */\n for(g = 0; g < 2000; g++){\n\n \t/* Selection routine */\n \tselection(genotype);\n \t\n \t/* Reproduction routine */\n \treproduction(genotype);\n \t\n \t/* Gene conversion routine */\n \tgconv(genotype);\n \t\n \t/* Sampling based on new frequencies */\n \tgsl_ran_multinomial(r,10,N,genotype,gensamp);\n \tfor(i = 0; i < 10; i++){\n\t\t\t*(genotype + i) = (*(gensamp + i))/(1.0*N);\n \t}\n \t\n \t/* Printing out results (for testing) */\n\t\t/*\n\t \tfor(i = 0; i < 10; i++){\n\t\t\tprintf(\"%.10lf \", *(genotype + i));\n\t\t}\n\t\tprintf(\"\\n\");\n\t\t*/\n }\n \n\t/* Reintroducing neutral genotype, resetting hap sum */\t\n\tneutinit(genotype,r);\n Bcheck = ncheck(genotype);\n Hsum = Bcheck*(1-Bcheck);\n /* printf(\"%.10lf %.10lf\\n\",Bcheck,Hsum); */\n \n /* Introduce and track neutral mutations 'reps' times */\n g = 0;\n while(g < reps){\n\n \t/* Selection routine */\n \tselection(genotype);\n \t\n \t/* Reproduction routine */\n \treproduction(genotype);\n \t\n \t/* Gene conversion routine */\n \tgconv(genotype);\n \t\n \t/* Sampling based on new frequencies */\n \tgsl_ran_multinomial(r,10,N,genotype,gensamp);\n \tfor(i = 0; i < 10; i++){\n \t\t*(genotype + i) = (*(gensamp + i))/(1.0*N);\n \t}\n \t\n \t/* Checking state of haplotypes: if B fixed reset so can start fresh next time */\n\t\tBcheck = ncheck(genotype);\n\t\tHsum += Bcheck*(1-Bcheck);\n\t\t/* printf(\"%.10lf %.10lf\\n\",Bcheck,Hsum); */\n\t\t\n\t\t/* If polymorphism fixed then abandon simulation */\n \tAcheck = pcheck(genotype);\n \tif(Acheck == 0){\n \t\tg = reps;\n \t}\n \t\n \tif(Bcheck == 0 || Bcheck == 1){\n \t\tprintf(\"%.10lf\\n\",Hsum);\n \t\tg++;\n \t\t/* printf(\"Rep Number %d\\n\",g); */\n \t\t\n \t\tif(Bcheck == 1){\n \t\t\t/* Reset genotypes so B becomes ancestral allele */\n \t\t\t*(genotype + 0) = *(genotype + 7);\n \t\t\t*(genotype + 1) = *(genotype + 8);\n \t\t\t*(genotype + 4) = *(genotype + 9);\n \t\t\t*(genotype + 7) = 0;\n \t\t\t*(genotype + 8) = 0;\n \t\t\t*(genotype + 9) = 0; \t\t\t\n \t\t}\n \t\t \n \t\t/* Reintroducing neutral genotype, resetting hap sum */ \t\t\n\t \tneutinit(genotype,r);\n\t\t\tBcheck = ncheck(genotype);\n \t\tHsum = Bcheck*(1-Bcheck);\n \t}\n \n\t}\t/* End of simulation */\n\t\n\t\n\t/* Freeing memory and wrapping up */\n \tgsl_rng_free(r);\n \tfree(gensamp);\n\tfree(genotype);\n\t/* printf(\"The End!\\n\"); */\n\treturn 0;\n}\n\n/* Initialising genotypes */\nvoid geninit(double *geninit){\n\t\t\n\t/* Basic idea: before neutral mutation introduced, g0 = 1/4; g1 = 1/2; g4 = 1/4. Deterministic frequencies. */\n\n\t*(geninit + 0) = 0.25;\n\t*(geninit + 1) = 0.50;\n\t*(geninit + 2) = 0;\n\t*(geninit + 3) = 0;\n\t*(geninit + 4) = 0.25;\n\t*(geninit + 5) = 0;\n\t*(geninit + 6) = 0;\n\t*(geninit + 7) = 0;\n\t*(geninit + 8) = 0;\n\t*(geninit + 9) = 0;\n\n}\t/* End of gen initiation routine */\n\n/* Initialising NEUTRAL allele */\nvoid neutinit(double *geninit, const gsl_rng *r){\n\n\tdouble *probin = calloc(4,sizeof(double));\t\t\t\t\t/* Probability inputs, determine location of neutral allele */\n\tunsigned int *probout = calloc(4,sizeof(unsigned int));\t\t/* Output from multinomial sampling */\n\t\n\t/* Basic idea: g11 at freq p^2; g12 at freq 2pq; g22 at freq q^2.\n\tSo weighted sampling to determine which genotype the neutral allele arises on\n\t*/\n\t\n\t/* Prob definitions */\n\t*(probin + 0) = *(geninit + 0);\n\t*(probin + 1) = (*(geninit + 1))/2.0;\n\t*(probin + 2) = (*(geninit + 1))/2.0;\n\t*(probin + 3) = *(geninit + 4);\n\t\n\tgsl_ran_multinomial(r,4,1,probin,probout);\n\t\n\t/* Redefining genotypes depending on outcome */\n\tif(*(probout + 0) == 1){\n\t\t*(geninit + 0) = (*(geninit + 0)) - 1/(1.0*N);\n\t\t*(geninit + 2) = (*(geninit + 2)) + 1/(1.0*N);\n\t}\n\telse if(*(probout + 1) == 1){\n\t\t*(geninit + 1) = (*(geninit + 1)) - 1/(1.0*N);\n\t\t*(geninit + 3) = (*(geninit + 3)) + 1/(1.0*N);\t\n\t}\n\telse if(*(probout + 2) == 1){\n\t\t*(geninit + 1) = (*(geninit + 1)) - 1/(1.0*N);\n\t\t*(geninit + 5) = (*(geninit + 5)) + 1/(1.0*N);\t\n\t}\n\telse if(*(probout + 3) == 1){\n\t\t*(geninit + 4) = (*(geninit + 4)) - 1/(1.0*N);\n\t\t*(geninit + 6) = (*(geninit + 6)) + 1/(1.0*N);\t\n\t}\n\t\n \tfree(probout);\n\tfree(probin);\n\t\n}\t/* End of gen initiation routine */\n\n/* Selection routine */\nvoid selection(double *geninit){\n\tdouble Waa, WAa, WAA;\t\t/* Fitness of locus A (bal sel locus) */\n\tdouble Wmean;\t\t\t\t/* Mean fitness */\n\t\n\tWaa = 1-s;\n\tWAa = 1;\n\tWAA = 1-s;\n\t\n\t/* Mean fitness calculation */\n\tWmean = ((*(geninit + 0))*Waa) + ((*(geninit + 1))*WAa) + ((*(geninit + 2))*Waa) + ((*(geninit + 3))*WAa) + ((*(geninit + 4))*WAA) + ((*(geninit + 5))*WAa) + ((*(geninit + 6))*WAA) + ((*(geninit + 7))*Waa) + ((*(geninit + 8))*WAa) + ((*(geninit + 9))*WAA);\n\t\n\t/* Changing frequencies by selection */\n\t*(geninit + 0) = ((*(geninit + 0))*Waa)/Wmean;\n\t*(geninit + 1) = ((*(geninit + 1))*WAa)/Wmean;\n\t*(geninit + 2) = ((*(geninit + 2))*Waa)/Wmean;\n\t*(geninit + 3) = ((*(geninit + 3))*WAa)/Wmean;\n\t*(geninit + 4) = ((*(geninit + 4))*WAA)/Wmean;\n\t*(geninit + 5) = ((*(geninit + 5))*WAa)/Wmean;\n\t*(geninit + 6) = ((*(geninit + 6))*WAA)/Wmean;\n\t*(geninit + 7) = ((*(geninit + 7))*Waa)/Wmean;\n\t*(geninit + 8) = ((*(geninit + 8))*WAa)/Wmean;\n\t*(geninit + 9) = ((*(geninit + 9))*WAA)/Wmean;\n\t\n}\t/* End of selection routine */\n\n/* Reproduction routine */\nvoid reproduction(double *geninit){\n\t/* Fed-in genotype frequencies (for ease of programming) */\n\tdouble g11s, g12s, g13s, g14s, g22s, g23s, g24s, g33s, g34s, g44s;\n\t/* Genotype frequencies after sex (outcross and selfing) */\t\n\tdouble g11SX, g12SX, g13SX, g14SX, g22SX, g23SX, g24SX, g33SX, g34SX, g44SX;\n\t/* Genotype frequencies after ASEX */\t\n\tdouble g11AS, g12AS, g13AS, g14AS, g22AS, g23AS, g24AS, g33AS, g34AS, g44AS;\t\n\t/* Haplotypes */\n\tdouble x1, x2, x3, x4;\n\t\n\t/* Initial definition of genotypes */\n\tg11s = *(geninit + 0);\n\tg12s = *(geninit + 1);\n\tg13s = *(geninit + 2);\n\tg14s = *(geninit + 3);\n\tg22s = *(geninit + 4);\n\tg23s = *(geninit + 5);\n\tg24s = *(geninit + 6);\n\tg33s = *(geninit + 7);\n\tg34s = *(geninit + 8);\n\tg44s = *(geninit + 9);\n\t\n\t/* Baseline change in haplotype frequencies */\n\tx1 = g11s + (g12s + g13s + g14s)/2.0 - ((g14s - g23s)*rec)/2.0;\n\tx2 = g22s + (g12s + g23s + g24s)/2.0 + ((g14s - g23s)*rec)/2.0;\n\tx3 = g33s + (g13s + g23s + g34s)/2.0 + ((g14s - g23s)*rec)/2.0;\n\tx4 = g44s + (g14s + g24s + g34s)/2.0 - ((g14s - g23s)*rec)/2.0;\n\t\n\t/* Change in SEXUAL frequencies (both outcrossing and selfing) */\n\tg11SX = (g11s + (g12s + g13s + g14s*pow((1 - rec),2) + g23s*pow(rec,2))/4.0)*self*sex + (1 - self)*pow(x1,2)*sex;\n\tg22SX = (g22s + (g12s + g24s + g23s*pow((1 - rec),2) + g14s*pow(rec,2))/4.0)*self*sex + (1 - self)*pow(x2,2)*sex;\n\tg33SX = (g33s + (g13s + g34s + g23s*pow((1 - rec),2) + g14s*pow(rec,2))/4.0)*self*sex + (1 - self)*pow(x3,2)*sex;\n\tg44SX = (g44s + (g24s + g34s + g14s*pow((1 - rec),2) + g23s*pow(rec,2))/4.0)*self*sex + (1 - self)*pow(x4,2)*sex;\n\tg12SX = ((g12s + (g14s + g23s)*(1 - rec)*rec)*self*sex)/2.0 + 2.0*(1 - self)*x1*x2*sex;\n\tg13SX = ((g13s + (g14s + g23s)*(1 - rec)*rec)*self*sex)/2.0 + 2.0*(1 - self)*x1*x3*sex;\n\tg14SX = ((g14s*pow((1 - rec),2) + g23s*pow(rec,2))*self*sex)/2.0 + 2.0*(1 - self)*x1*x4*sex;\n\tg23SX = ((g23s*pow((1 - rec),2) + g14s*pow(rec,2))*self*sex)/2.0 + 2.0*(1 - self)*x2*x3*sex;\n\tg24SX = ((g24s + (g14s + g23s)*(1 - rec)*rec)*self*sex)/2.0 + 2.0*(1 - self)*x2*x4*sex;\n\tg34SX = ((g34s + (g14s + g23s)*(1 - rec)*rec)*self*sex)/2.0 + 2.0*(1 - self)*x3*x4*sex;\n\t\n\t/* Change in ASEXUAL frequencies */\n\tg11AS = g11s*(1 - sex);\n\tg12AS = g12s*(1 - sex);\n\tg13AS = g13s*(1 - sex);\n\tg14AS = g14s*(1 - sex);\n\tg22AS = g22s*(1 - sex);\n\tg23AS = g23s*(1 - sex);\n\tg24AS = g24s*(1 - sex);\t\n\tg33AS = g33s*(1 - sex);\t\n\tg34AS = g34s*(1 - sex);\t\n\tg44AS = g44s*(1 - sex);\n\t\n\t/* Combining to give overall frequency change following reproduction */\n\t*(geninit + 0) = g11AS + g11SX;\n\t*(geninit + 1) = g12AS + g12SX;\n\t*(geninit + 2) = g13AS + g13SX;\n\t*(geninit + 3) = g14AS + g14SX;\n\t*(geninit + 4) = g22AS + g22SX;\n\t*(geninit + 5) = g23AS + g23SX;\n\t*(geninit + 6) = g24AS + g24SX;\n\t*(geninit + 7) = g33AS + g33SX;\n\t*(geninit + 8) = g34AS + g34SX;\n\t*(geninit + 9) = g44AS + g44SX;\n\t\n}\t/* End of reproduction routine */\n\n/* Gene conversion routine */\nvoid gconv(double *geninit){\n\t\n\t/* Fed-in genotype frequencies (for ease of programming) */\n\tdouble g11r, g12r, g13r, g14r, g22r, g23r, g24r, g33r, g34r, g44r;\n\t/* Frequencies after gene conversion */\n\tdouble g11gc, g12gc, g13gc, g14gc, g22gc, g23gc, g24gc, g33gc, g34gc, g44gc;\n\t\n\t/* Initial definition of genotypes */\n\tg11r = *(geninit + 0);\n\tg12r = *(geninit + 1);\n\tg13r = *(geninit + 2);\n\tg14r = *(geninit + 3);\n\tg22r = *(geninit + 4);\n\tg23r = *(geninit + 5);\n\tg24r = *(geninit + 6);\n\tg33r = *(geninit + 7);\n\tg34r = *(geninit + 8);\n\tg44r = *(geninit + 9);\n\t\n\t/* Gene conversion equations */\n\tg11gc = g11r + (gc*g12r)/4.0 + (gc*g13r)/4.0;\n\tg12gc = g12r*(1 - gc/2.0) + ((g14r + g23r)*gc)/4.0;\n\tg13gc = g13r*(1 - gc/2.0) + ((g14r + g23r)*gc)/4.0;\n\tg14gc = (1-gc)*g14r;\n\tg22gc = g22r + (g12r*gc)/4.0 + (g24r*gc)/4.0;\n\tg23gc = (1-gc)*g23r;\n\tg24gc = g24r*(1 - gc/2.0) + ((g14r + g23r)*gc)/4.0;\n\tg33gc = g33r + (g13r*gc)/4.0 + (g34r*gc)/4.0;\n\tg34gc = g34r*(1 - gc/2.0) + ((g14r + g23r)*gc)/4.0;\n\tg44gc = g44r + (g24r*gc)/4.0 + (g34r*gc)/4.0;\n\t\n\t/* Output */\n\t*(geninit + 0) = g11gc;\n\t*(geninit + 1) = g12gc;\n\t*(geninit + 2) = g13gc;\n\t*(geninit + 3) = g14gc;\n\t*(geninit + 4) = g22gc;\n\t*(geninit + 5) = g23gc;\n\t*(geninit + 6) = g24gc;\n\t*(geninit + 7) = g33gc;\n\t*(geninit + 8) = g34gc;\n\t*(geninit + 9) = g44gc;\n}\t\t/* End of gene conversion routine */\n\n/* Has neutral allele fixed or not? Measuring freq of B */\ndouble ncheck(double *geninit){\n\t/* Fed-in genotype frequencies (for ease of programming) */\n\tdouble g11s, g12s, g13s, g14s, g22s, g23s, g24s, g33s, g34s, g44s;\n\t/* Haplotypes ONLY CONTAINING B */\n\tdouble x3, x4;\n\tdouble Btot = 0; /* Total frequency of B */\n\t\n\t/* Initial definition of genotypes */\n\tg11s = *(geninit + 0);\n\tg12s = *(geninit + 1);\n\tg13s = *(geninit + 2);\n\tg14s = *(geninit + 3);\n\tg22s = *(geninit + 4);\n\tg23s = *(geninit + 5);\n\tg24s = *(geninit + 6);\n\tg33s = *(geninit + 7);\n\tg34s = *(geninit + 8);\n\tg44s = *(geninit + 9);\n\t\n\t/* Calculation of haplotypes containing B */\n\t\n\tx3 = g33s + (g13s + g23s + g34s)/2.0;\n\tx4 = g44s + (g14s + g24s + g34s)/2.0;\n\t\n\t/* Checking */\n\tBtot = x3 + x4;\n\treturn Btot;\n\t\n}\t/* End of B check routine */\n\n/* Checking if balancing polymorphism lost or not */\ndouble pcheck(double *geninit){\n\t/* Fed-in genotype frequencies (for ease of programming) */\n\tdouble g11s, g12s, g13s, g14s, g22s, g23s, g24s, g33s, g34s, g44s;\n\tdouble x2, x4;\n\tdouble Atot = 0; /* Total frequency of A */\n\t\n\t/* Initial definition of genotypes */\n\tg11s = *(geninit + 0);\n\tg12s = *(geninit + 1);\n\tg13s = *(geninit + 2);\n\tg14s = *(geninit + 3);\n\tg22s = *(geninit + 4);\n\tg23s = *(geninit + 5);\n\tg24s = *(geninit + 6);\n\tg33s = *(geninit + 7);\n\tg34s = *(geninit + 8);\n\tg44s = *(geninit + 9);\n\t\n\t/* Calculation of haplotypes containing B */\n\t\n\tx2 = g22s + (g12s + g23s + g24s)/2.0;\n\tx4 = g44s + (g14s + g24s + g34s)/2.0;\n\t\n\t/* Checking */\n\tAtot = x2 + x4;\n\treturn Atot;\n\t\n}\t/* End of A check routine */\n\n/* End of program */\n", "meta": {"hexsha": "6b728f8e74a4fd8093f06005a0f80bffc5791f0f", "size": 14526, "ext": "c", "lang": "C", "max_stars_repo_path": "BalSelSims.c", "max_stars_repo_name": "MattHartfield/BalSelSims", "max_stars_repo_head_hexsha": "9df64092397e1c043ecadde0f4bd86ada180fe60", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "BalSelSims.c", "max_issues_repo_name": "MattHartfield/BalSelSims", "max_issues_repo_head_hexsha": "9df64092397e1c043ecadde0f4bd86ada180fe60", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "BalSelSims.c", "max_forks_repo_name": "MattHartfield/BalSelSims", "max_forks_repo_head_hexsha": "9df64092397e1c043ecadde0f4bd86ada180fe60", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.1716738197, "max_line_length": 257, "alphanum_fraction": 0.5877048052, "num_tokens": 5464, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8479677660619633, "lm_q2_score": 0.6039318337259583, "lm_q1q2_score": 0.5121147278983059}} {"text": "#include \n#define FORCE_OPENBLAS_COMPLEX_STRUCT\n#include \n#include \n#include \n#include \n\n\ntypedef int MKL_INT;\ntypedef openblas_complex_double MKL_Complex16;\n\n#define AVX512_ALIGN 64\n\n#include \"gene_bruit_rayleigh_scalaire.c\"\n\nint main(void) \n{\n\n int val;\n int \t M, N, K;\n int \t lda, ldb, ldc;\n int kboucle;\n float charge;\n char *p;\n \n FILE *fichier1;\n fichier1 = fopen(\"../results/results_openblas_gemm_fp64.dat\", \"w\");\n\n int has_param_m = 0, has_param_n = 0, has_param_k = 0;\n char transa = CblasNoTrans, transb = CblasNoTrans;\n \n if ((p = getenv(\"MATMUL_M\"))) {\n M = atoi(p);\n has_param_m=1;\n }\n if ((p = getenv(\"MATMUL_N\"))) {\n N = atoi(p);\n has_param_n=1;\n } \n if ((p = getenv(\"MATMUL_K\"))) {\n K = atoi(p);\n has_param_k=1;\n }\n \n if ((p = getenv(\"TRANSA\"))) {\n if(*p == 'T')\n\t\ttransa = CblasTrans;\n }\n if ((p = getenv(\"TRANSB\"))) {\n if(*p == 'T')\n\t\ttransb = CblasTrans;\n }\n\n /* Begin huge loop */\n for (kboucle = 1; kboucle < 31; kboucle++) {\n\n val = 100 * kboucle;\n M = has_param_m?M:val;\n N = has_param_n?N:val;\n\tK = has_param_k?K:val;\n\t\n\tlda = (transa == CblasNoTrans)?M:K;\n ldb = (transb == CblasNoTrans)?K:N;\n ldc = M;\n\t\n printf(\">>>>> Matrix size %dx%d (K=%d, TransA=%d TransB=%d) <<<<<<\\n\", M, N, K,\\\n\t\ttransa - CblasNoTrans, transb - CblasNoTrans);\n\n int iboucle, jboucle;\n int param = 20;\n float *mat_real, *mat_imag;\n\n // Timers\n struct timespec tpdeb, tpfin, tpcour;\n clockid_t clock_id = CLOCK_REALTIME;\n int status2;\n\n double dureeloc, dureetot;\n dureetot = 0.0;\n\n // BLAS\n MKL_Complex16 alpha, beta;\n MKL_Complex16 *A, *B, *C;\n\n alpha.real = 1.0;\n alpha.imag = 0.0;\n beta.real = 0.0;\n beta.imag = 0.0;\n\n mat_real = (float *)aligned_alloc(AVX512_ALIGN, val * val * sizeof(float));\n mat_imag = (float *)aligned_alloc(AVX512_ALIGN, val * val * sizeof(float));\n\n A = (MKL_Complex16 *)aligned_alloc(AVX512_ALIGN, M * K * sizeof(MKL_Complex16));\n B = (MKL_Complex16 *)aligned_alloc(AVX512_ALIGN, K * N * sizeof(MKL_Complex16));\n C = (MKL_Complex16 *)aligned_alloc(AVX512_ALIGN, M * N * sizeof(MKL_Complex16));\n\n for (iboucle = 0; iboucle < val * val; iboucle++) {\n gene_bruit_rayleigh_scalaire(param, mat_real + iboucle,\n mat_imag + iboucle);\n }\n\n // Force hermitian matrix\n for (iboucle = 0; iboucle < K; iboucle++) {\n for (jboucle = 0; jboucle < N; jboucle++) {\n B[(iboucle * N) + jboucle].real = (double)(*(mat_real + (jboucle * K) + iboucle));\n\n B[(iboucle * N) + jboucle].imag =\n -1.0 * (double)(*(mat_imag + (jboucle * K) + iboucle));\n }\n }\n\n for (iboucle = 0; iboucle < M * K; iboucle++) {\n A[iboucle].real = (double)mat_real[iboucle];\n A[iboucle].imag = (double)mat_imag[iboucle];\n }\n\n status2 = clock_gettime(clock_id, &tpdeb); // start timer;\n\n cblas_zgemm(CblasColMajor, transa, transb, \\\n M, N, K, \\\n &alpha, A, lda, \\\n B, ldb, &beta, C, ldc);\n\n status2 = clock_gettime(clock_id, &tpfin); // stop timer\n\n dureeloc = (float)(tpfin.tv_sec - tpdeb.tv_sec) +\n (float)(tpfin.tv_nsec - tpdeb.tv_nsec) * 1.e-9;\n dureetot = dureetot + dureeloc;\n\n printf(\"execution time = %f ms\\n\", dureeloc * 1000);\n charge = (float)M;\n charge = 8.0f * charge * charge * charge;\n charge = charge / dureeloc;\n printf(\"%f GFLOPS\\n\", charge / 1e9);\n fprintf(fichier1, \"%5.2f\\n\", charge / 1e9);\n\n free(mat_real);\n free(mat_imag);\n\n free(A);\n free(B);\n free(C);\n }\n fclose(fichier1);\n\n return 0;\n}\n", "meta": {"hexsha": "9b68b9f4bc7e1b6a075e1287b1f0fe75a3ae684b", "size": 3683, "ext": "c", "lang": "C", "max_stars_repo_path": "src/mulmat/zgemm_OPENBLAS.c", "max_stars_repo_name": "JishinMaster/scientific_benchmarks", "max_stars_repo_head_hexsha": "1ec81d2475a857fbb81474036af98080b5c1875e", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/mulmat/zgemm_OPENBLAS.c", "max_issues_repo_name": "JishinMaster/scientific_benchmarks", "max_issues_repo_head_hexsha": "1ec81d2475a857fbb81474036af98080b5c1875e", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/mulmat/zgemm_OPENBLAS.c", "max_forks_repo_name": "JishinMaster/scientific_benchmarks", "max_forks_repo_head_hexsha": "1ec81d2475a857fbb81474036af98080b5c1875e", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 3.0, "max_forks_repo_forks_event_min_datetime": "2017-10-07T16:47:16.000Z", "max_forks_repo_forks_event_max_datetime": "2020-11-19T18:13:08.000Z", "avg_line_length": 24.8851351351, "max_line_length": 90, "alphanum_fraction": 0.5840347543, "num_tokens": 1281, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8221891130942472, "lm_q2_score": 0.6224593312018546, "lm_q1q2_score": 0.5117792854580911}} {"text": "/* multifit_nlinear/mcholesky.c\n * \n * Copyright (C) 2015, 2016 Patrick Alken\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n/*\n * This module calculates the solution of the normal equations least squares\n * system:\n *\n * [ J~^T J~ + mu D~^T D~ ] p~ = -J~^T f\n *\n * using the modified Cholesky decomposition. Quantities are scaled\n * according to:\n *\n * J~ = J S\n * D~ = D S\n * p~ = S^{-1} p\n *\n * where S is a diagonal matrix and S_jj = || J_j || and J_j is column\n * j of the Jacobian. This balancing transformation seems to be more\n * numerically stable for some Jacobians.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"common.c\"\n\ntypedef struct\n{\n gsl_matrix *JTJ; /* J^T J */\n gsl_matrix *work_JTJ; /* copy of J^T J */\n gsl_vector *rhs; /* -J^T f, size p */\n gsl_permutation *perm; /* permutation matrix for modified Cholesky */\n gsl_vector *work3p; /* workspace, size 3*p */\n double mu; /* current regularization parameter */\n} mcholesky_state_t;\n\nstatic void *mcholesky_alloc (const size_t n, const size_t p);\nstatic int mcholesky_init(const void * vtrust_state, void * vstate);\nstatic int mcholesky_presolve(const double mu, const void * vtrust_state, void * vstate);\nstatic int mcholesky_solve(const gsl_vector * f, gsl_vector *x,\n const void * vtrust_state, void *vstate);\nstatic int mcholesky_solve_rhs(const gsl_vector * b, gsl_vector *x, mcholesky_state_t *state);\nstatic int mcholesky_regularize(const double mu, const gsl_vector * diag, gsl_matrix * A,\n mcholesky_state_t * state);\n\nstatic void *\nmcholesky_alloc (const size_t n, const size_t p)\n{\n mcholesky_state_t *state;\n\n (void)n;\n \n state = calloc(1, sizeof(mcholesky_state_t));\n if (state == NULL)\n {\n GSL_ERROR_NULL (\"failed to allocate mcholesky state\", GSL_ENOMEM);\n }\n\n state->JTJ = gsl_matrix_alloc(p, p);\n if (state->JTJ == NULL)\n {\n GSL_ERROR_NULL (\"failed to allocate space for JTJ\", GSL_ENOMEM);\n }\n\n state->work_JTJ = gsl_matrix_alloc(p, p);\n if (state->work_JTJ == NULL)\n {\n GSL_ERROR_NULL (\"failed to allocate space for JTJ workspace\",\n GSL_ENOMEM);\n }\n\n state->rhs = gsl_vector_alloc(p);\n if (state->rhs == NULL)\n {\n GSL_ERROR_NULL (\"failed to allocate space for rhs\", GSL_ENOMEM);\n }\n\n state->perm = gsl_permutation_alloc(p);\n if (state->perm == NULL)\n {\n GSL_ERROR_NULL (\"failed to allocate space for perm\", GSL_ENOMEM);\n }\n\n state->work3p = gsl_vector_alloc(3 * p);\n if (state->work3p == NULL)\n {\n GSL_ERROR_NULL (\"failed to allocate space for work3p\", GSL_ENOMEM);\n }\n\n state->mu = -1.0;\n\n return state;\n}\n\nstatic void\nmcholesky_free(void *vstate)\n{\n mcholesky_state_t *state = (mcholesky_state_t *) vstate;\n\n if (state->JTJ)\n gsl_matrix_free(state->JTJ);\n\n if (state->work_JTJ)\n gsl_matrix_free(state->work_JTJ);\n\n if (state->rhs)\n gsl_vector_free(state->rhs);\n\n if (state->perm)\n gsl_permutation_free(state->perm);\n\n if (state->work3p)\n gsl_vector_free(state->work3p);\n\n free(state);\n}\n\nstatic int\nmcholesky_init(const void * vtrust_state, void * vstate)\n{\n const gsl_multifit_nlinear_trust_state *trust_state =\n (const gsl_multifit_nlinear_trust_state *) vtrust_state;\n mcholesky_state_t *state = (mcholesky_state_t *) vstate;\n\n /* compute J^T J */\n gsl_blas_dsyrk(CblasLower, CblasTrans, 1.0, trust_state->J, 0.0, state->JTJ);\n\n return GSL_SUCCESS;\n}\n\n/*\nmcholesky_presolve()\n Compute the modified Cholesky decomposition of J^T J + mu D^T D.\nModified Cholesky is used in case mu = 0 and there are rounding\nerrors in forming J^T J which could lead to an indefinite matrix.\n\nInputs: mu - LM parameter\n vstate - workspace\n\nNotes:\n1) On output, state->work_JTJ contains the Cholesky decomposition of\nJ^T J + mu D^T D\n*/\n\nstatic int\nmcholesky_presolve(const double mu, const void * vtrust_state, void * vstate)\n{\n const gsl_multifit_nlinear_trust_state *trust_state =\n (const gsl_multifit_nlinear_trust_state *) vtrust_state;\n mcholesky_state_t *state = (mcholesky_state_t *) vstate;\n gsl_matrix *JTJ = state->work_JTJ;\n const gsl_vector *diag = trust_state->diag;\n int status;\n\n /* copy lower triangle of A to workspace */\n gsl_matrix_tricpy(CblasLower, CblasNonUnit, JTJ, state->JTJ);\n\n /* augment normal equations: A -> A + mu D^T D */\n status = mcholesky_regularize(mu, diag, JTJ, state);\n if (status)\n return status;\n\n /* compute modified Cholesky decomposition */\n status = gsl_linalg_mcholesky_decomp(JTJ, state->perm, NULL);\n if (status)\n return status;\n\n state->mu = mu;\n\n return GSL_SUCCESS;\n}\n\n/*\nmcholesky_solve()\n Compute (J^T J + mu D^T D) x = -J^T f\n\nInputs: f - right hand side vector f\n x - (output) solution vector\n vstate - mcholesky workspace\n*/\n\nstatic int\nmcholesky_solve(const gsl_vector * f, gsl_vector *x,\n const void * vtrust_state, void *vstate)\n{\n const gsl_multifit_nlinear_trust_state *trust_state =\n (const gsl_multifit_nlinear_trust_state *) vtrust_state;\n mcholesky_state_t *state = (mcholesky_state_t *) vstate;\n int status;\n\n /* compute rhs = -J^T f */\n gsl_blas_dgemv(CblasTrans, -1.0, trust_state->J, f, 0.0, state->rhs);\n\n status = mcholesky_solve_rhs(state->rhs, x, state);\n if (status)\n return status;\n\n return GSL_SUCCESS;\n}\n\nstatic int\nmcholesky_rcond(double * rcond, void * vstate)\n{\n int status;\n mcholesky_state_t *state = (mcholesky_state_t *) vstate;\n double rcond_JTJ;\n\n if (state->mu != 0)\n {\n /*\n * Cholesky decomposition hasn't been computed yet, or was computed\n * with mu > 0 - recompute Cholesky decomposition of J^T J\n */\n\n /* copy lower triangle of JTJ to workspace */\n gsl_matrix_tricpy(CblasLower, CblasNonUnit, state->work_JTJ, state->JTJ);\n\n /* compute modified Cholesky decomposition */\n status = gsl_linalg_mcholesky_decomp(state->work_JTJ, state->perm, NULL);\n if (status)\n return status;\n }\n\n status = gsl_linalg_mcholesky_rcond(state->work_JTJ, state->perm, &rcond_JTJ, state->work3p);\n if (status == GSL_SUCCESS)\n *rcond = sqrt(rcond_JTJ);\n\n return status;\n}\n\n/* solve: (J^T J + mu D^T D) x = b */\nstatic int\nmcholesky_solve_rhs(const gsl_vector * b, gsl_vector *x, mcholesky_state_t *state)\n{\n int status;\n gsl_matrix *JTJ = state->work_JTJ;\n\n status = gsl_linalg_mcholesky_solve(JTJ, state->perm, b, x);\n if (status)\n return status;\n\n return GSL_SUCCESS;\n}\n\n/* A <- A + mu D^T D */\nstatic int\nmcholesky_regularize(const double mu, const gsl_vector * diag, gsl_matrix * A,\n mcholesky_state_t * state)\n{\n (void) state;\n\n if (mu != 0.0)\n {\n size_t i;\n\n for (i = 0; i < diag->size; ++i)\n {\n double di = gsl_vector_get(diag, i);\n double *Aii = gsl_matrix_ptr(A, i, i);\n *Aii += mu * di * di;\n }\n }\n\n return GSL_SUCCESS;\n}\n\nstatic const gsl_multifit_nlinear_solver mcholesky_type =\n{\n \"mcholesky\",\n mcholesky_alloc,\n mcholesky_init,\n mcholesky_presolve,\n mcholesky_solve,\n mcholesky_rcond,\n mcholesky_free\n};\n\nconst gsl_multifit_nlinear_solver *gsl_multifit_nlinear_solver_mcholesky = &mcholesky_type;\n", "meta": {"hexsha": "6f9d1b6a74af844503a7544e024b1142e1a36674", "size": 8164, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.6/multifit_nlinear/mcholesky.c", "max_stars_repo_name": "ielomariala/Hex-Game", "max_stars_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-06-14T11:51:37.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-14T11:51:37.000Z", "max_issues_repo_path": "gsl-2.6/multifit_nlinear/mcholesky.c", "max_issues_repo_name": "ielomariala/Hex-Game", "max_issues_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-12-16T17:41:24.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-22T00:00:16.000Z", "max_forks_repo_path": "test/lib/gsl-2.6/multifit_nlinear/mcholesky.c", "max_forks_repo_name": "karanbirsandhu/nu-sense", "max_forks_repo_head_hexsha": "83fd1fc4cbd053a4f9b673d5cd5841823ddd4d8b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-01-20T16:22:57.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-14T12:31:02.000Z", "avg_line_length": 27.0331125828, "max_line_length": 95, "alphanum_fraction": 0.6772415483, "num_tokens": 2408, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8031737963569016, "lm_q2_score": 0.6370307944803831, "lm_q1q2_score": 0.5116464415990625}} {"text": "/*\n NAME:\n splitnmergegauss\n PURPOSE:\n split one gaussian and merge two other gaussians\n CALLING SEQUENCE:\n splitnmergegauss(struct gaussian * gaussians,int K, gsl_matrix * qij, \n int j, int k, int l)\n INPUT:\n gaussians - model gaussians\n K - number of gaussians\n qij - matrix of log(posterior likelihoods)\n j,k - gaussians that need to be merged\n l - gaussian that needs to be split\n OUTPUT:\n updated gaussians\n REVISION HISTORY:\n 2008-09-21 - Written Bovy\n*/\n#include \n#include \n#include \n#include \n#include \"proj_gauss_mixtures.h\"\n\nvoid splitnmergegauss(struct gaussian * gaussians,int K, \n\t\t gsl_matrix * qij, int j, int k, int l){\n //get the gaussians to be split 'n' merged\n int d = (gaussians->VV)->size1;//dim of mm\n //int partial_indx[]= {-1,-1,-1};/* dummy argument for logsum */\n //bool * dummy_allfixed = (bool *) calloc(K,sizeof(bool));\n //j,k,l gaussians\n struct gaussian gaussianj, gaussiank, gaussianl;\n gaussianj.mm = gsl_vector_alloc(d);\n gaussianj.VV = gsl_matrix_alloc(d,d);\n gaussiank.mm = gsl_vector_alloc(d);\n gaussiank.VV = gsl_matrix_alloc(d,d);\n gaussianl.mm = gsl_vector_alloc(d);\n gaussianl.VV = gsl_matrix_alloc(d,d);\n \n gsl_matrix * unitm = gsl_matrix_alloc(d,d);\n gsl_matrix_set_identity(unitm);\n gsl_vector * eps = gsl_vector_alloc(d);\n double qjj,qjk,detVVjl;\n int kk;\n for (kk = 0; kk != K; ++kk){\n if (kk == j){\n gaussianj.alpha = gaussians->alpha;\n gsl_vector_memcpy(gaussianj.mm,gaussians->mm);\n gsl_matrix_memcpy(gaussianj.VV,gaussians->VV);\n qjj = exp(logsum(qij,j,false));//,dummy_allfixed));\n }\n if (kk == k){\n gaussiank.alpha = gaussians->alpha;\n gsl_vector_memcpy(gaussiank.mm,gaussians->mm);\n gsl_matrix_memcpy(gaussiank.VV,gaussians->VV);\n qjk = exp(logsum(qij,k,false));//,dummy_allfixed));\n }\n if (kk == l){\n gaussianl.alpha = gaussians->alpha;\n gsl_vector_memcpy(gaussianl.mm,gaussians->mm);\n gsl_matrix_memcpy(gaussianl.VV,gaussians->VV);\n }\n ++gaussians;\n }\n gaussians -= K;\n\n //merge j & k\n gaussianj.alpha += gaussiank.alpha;\n if (qjk == 0. && qjj == 0){\n gsl_vector_add(gaussianj.mm,gaussiank.mm);\n gsl_vector_scale(gaussianj.mm,0.5);\n gsl_matrix_add(gaussianj.VV,gaussiank.VV);\n gsl_matrix_scale(gaussianj.VV,0.5);\n }\n else{\n gsl_vector_scale(gaussianj.mm,qjj/(qjj+qjk));\n gsl_vector_scale(gaussiank.mm,qjk/(qjj+qjk));\n gsl_vector_add(gaussianj.mm,gaussiank.mm);\n gsl_matrix_scale(gaussianj.VV,qjj/(qjj+qjk));\n gsl_matrix_scale(gaussiank.VV,qjk/(qjj+qjk));\n gsl_matrix_add(gaussianj.VV,gaussiank.VV);\n }\n\n //split l\n gaussianl.alpha /= 2.;\n gaussiank.alpha = gaussianl.alpha;\n detVVjl = bovy_det(gaussianl.VV);\n detVVjl= pow(detVVjl,1./d);\n gsl_matrix_scale(unitm,detVVjl);\n gsl_matrix_memcpy(gaussiank.VV,unitm);\n gsl_matrix_memcpy(gaussianl.VV,unitm);\n gsl_vector_memcpy(gaussiank.mm,gaussianl.mm);\n bovy_randvec(eps,d,sqrt(detVVjl));\n gsl_vector_add(gaussiank.mm,eps);\n bovy_randvec(eps,d,sqrt(detVVjl));\n gsl_vector_add(gaussianl.mm,eps);\n \n //copy everything back into the right gaussians\n for (kk = 0; kk != K; ++kk){\n if (kk == j){\n gaussians->alpha = gaussianj.alpha;\n gsl_vector_memcpy(gaussians->mm,gaussianj.mm);\n gsl_matrix_memcpy(gaussians->VV,gaussianj.VV);\n }\n if (kk == k){\n gaussians->alpha = gaussiank.alpha;\n gsl_vector_memcpy(gaussians->mm,gaussiank.mm);\n gsl_matrix_memcpy(gaussians->VV,gaussiank.VV);\n }\n if (kk == l){\n gaussians->alpha = gaussianl.alpha;\n gsl_vector_memcpy(gaussians->mm,gaussianl.mm);\n gsl_matrix_memcpy(gaussians->VV,gaussianl.VV);\n }\n ++gaussians;\n }\n gaussians -= K;\n\n //cleanup\n gsl_matrix_free(unitm);\n gsl_vector_free(eps);\n //free(dummy_allfixed);\n\n return ;\n}\n", "meta": {"hexsha": "5cb737322f5c4f6616adb92b903dadb3dd7ffec2", "size": 3940, "ext": "c", "lang": "C", "max_stars_repo_path": "src/splitnmergegauss.c", "max_stars_repo_name": "surbut/mashr", "max_stars_repo_head_hexsha": "b66d2af16503bc46d785ac9c9ba447ecc29b6fae", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/splitnmergegauss.c", "max_issues_repo_name": "surbut/mashr", "max_issues_repo_head_hexsha": "b66d2af16503bc46d785ac9c9ba447ecc29b6fae", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/splitnmergegauss.c", "max_forks_repo_name": "surbut/mashr", "max_forks_repo_head_hexsha": "b66d2af16503bc46d785ac9c9ba447ecc29b6fae", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 31.0236220472, "max_line_length": 75, "alphanum_fraction": 0.6672588832, "num_tokens": 1203, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8577681195338728, "lm_q2_score": 0.5964331462646254, "lm_q1q2_score": 0.5116013382990791}} {"text": "/* randist/gauss.c\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000 James Theiler, Brian Gough\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 2 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.\n */\n\n#include \n#include \n#include \n#include \n#include \n\n/* Of the two methods provided below, I think the Polar method is more\n * efficient, but only when you are actually producing two random\n * deviates. We don't produce two, because then we'd have to save one\n * in a static variable for the next call, and that would screws up\n * re-entrant or threaded code, so we only produce one. This makes\n * the Ratio method suddenly more appealing. There are further tests\n * one can make if the log() is slow. See Knuth for details */\n\n/* Both methods pass the statistical tests; but the polar method\n * seems to be a touch faster on my home Pentium, EVEN though we\n * are only using half of the available random deviates!\n */\n\n/* Polar (Box-Mueller) method; See Knuth v2, 3rd ed, p122 */\n\ndouble\ngsl_ran_gaussian (const gsl_rng * r, const double sigma)\n{\n double x, y, r2;\n\n do\n {\n /* choose x,y in uniform square (-1,-1) to (+1,+1) */\n\n x = -1 + 2 * gsl_rng_uniform (r);\n y = -1 + 2 * gsl_rng_uniform (r);\n\n /* see if it is in the unit circle */\n r2 = x * x + y * y;\n }\n while (r2 > 1.0 || r2 == 0);\n\n /* Box-Muller transform */\n return sigma * y * sqrt (-2.0 * log (r2) / r2);\n}\n\n/* Ratio method (Kinderman-Monahan); see Knuth v2, 3rd ed, p130 */\n/* K+M, ACM Trans Math Software 3 (1977) 257-260. */\n\ndouble\ngsl_ran_gaussian_ratio_method (const gsl_rng * r, const double sigma)\n{\n double u, v, x;\n\n do\n {\n v = gsl_rng_uniform (r);\n do\n\t{\n\t u = gsl_rng_uniform (r);\n\t}\n while (u == 0);\n /* Const 1.715... = sqrt(8/e) */\n x = 1.71552776992141359295 * (v - 0.5) / u;\n }\n while (x * x > -4.0 * log (u));\n\n return sigma * x;\n}\n\ndouble\ngsl_ran_gaussian_pdf (const double x, const double sigma)\n{\n double u = x / fabs (sigma);\n double p = (1 / (sqrt (2 * M_PI) * fabs (sigma))) * exp (-u * u / 2);\n return p;\n}\n\ndouble\ngsl_ran_ugaussian (const gsl_rng * r)\n{\n return gsl_ran_gaussian (r, 1.0);\n}\n\ndouble\ngsl_ran_ugaussian_ratio_method (const gsl_rng * r)\n{\n return gsl_ran_gaussian_ratio_method (r, 1.0);\n}\n\ndouble\ngsl_ran_ugaussian_pdf (const double x)\n{\n return gsl_ran_gaussian_pdf (x, 1.0);\n}\n", "meta": {"hexsha": "f30c14273405dec6c77b0f08b5dda9f6e5ddfe1d", "size": 3037, "ext": "c", "lang": "C", "max_stars_repo_path": "code/em/treba/gsl-1.0/randist/gauss.c", "max_stars_repo_name": "ICML14MoMCompare/spectral-learn", "max_stars_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-12-18T18:09:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-10T11:31:28.000Z", "max_issues_repo_path": "code/em/treba/gsl-1.0/randist/gauss.c", "max_issues_repo_name": "ICML14MoMCompare/spectral-learn", "max_issues_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "code/em/treba/gsl-1.0/randist/gauss.c", "max_forks_repo_name": "ICML14MoMCompare/spectral-learn", "max_forks_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2015-10-02T01:32:59.000Z", "max_forks_repo_forks_event_max_datetime": "2015-10-02T01:32:59.000Z", "avg_line_length": 27.3603603604, "max_line_length": 72, "alphanum_fraction": 0.6644715179, "num_tokens": 923, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7025300573952054, "lm_q2_score": 0.7279754548076477, "lm_q1q2_score": 0.5114246380483175}} {"text": "#include \n#include \n#include \n#include \ntypedef struct{\n double g;//gravity\n double M;//mass of the car\n double m;//mass of the load\n double r;//length of the rope\n double C;//damping coefficient\n double k;//spring constang\n\n double F;//input force\n double T;//tension to the rope\n // double FF;//Fictitious force\n\n double x,x0;//x position of the load\n double y,y0;//y position of the load\n double X;//X position of the car\n double a;//angle (theta)\n\n double dx,dx0;\n double dy,dy0;\n double dX,dX0;\n double dr;\n double da,da0;\n double dXmax;\n double ddXmax;\n double Fmax;\n\n double ddx;\n double ddy;\n double ddX;\n double ddr;\n double dda;\n double h;\n int nh;\n double _h;\n int _dim;\n double *_y;\n double *_y_err;\n double *_dydt_in;\n double *_dydt_out;\n const gsl_odeiv_step_type *_T;\n gsl_odeiv_step *_s;\n gsl_odeiv_system _sys;\n double _t;\n} CRANE;\n\n#define dim_crane 4\nint cranefunc (double t, const double y[], double f[], void *params)\n{\n CRANE *c = (CRANE *)params;\n\n#ifdef ICONIP2014 //wrong dynamics\n f[0] = y[1];\n f[1] = -c->k*(y[0]-y[2])/c->m - c->C*(y[1]-y[3])/c->m;//iconip2014\n f[2] = y[3]; \n f[3] = (c->k*(y[0]-y[2]) + c->F)/c->M;//iconip2014\n// f[0] = y[1];\n// f[1] = -c->k*(y[0]-y[2])/c->m - c->C*(y[1]-y[3])/c->m;\n// f[2] = y[3]; \n// f[3] = (c->k*(y[0]-y[2]) + c->C*(y[1]-y[3] + c->F)/c->M;\n#else //corrected dynamics\n f[0] = y[1];\n f[1] = (-c->k*(y[0]-y[2]) - c->C*(y[1]-y[3]) )/c->m;//iconip2014\n f[2] = y[3]; \n f[3] = ( c->k*(y[0]-y[2]) + c->C*(y[1]-y[3]) + c->F)/c->M;//iconip2014\n#endif\n\n// f[0] = y[1];\n// f[1] = -c->k*y[0]/c->m - c->C*y[1]/c->m - c->ddX;\n// f[2] = y[3]; \n// f[3] = (c->k*y[0] + c->F)/c->M;\n//\n// f[0] = y[1];\n// f[1] = (-(2*c->dr+c->C)*y[1] -c->ddX*cos(y[0]) -c->g*sin(y[0]))/c->r;\n// f[2] = y[3]; \n// f[3] = (c->F+c->T*sin(y[0]))/c->M;\n return GSL_SUCCESS;\n}\n////////////////\n#define square(x) ((x)*(x))\nCRANE crane;\nint initialize()\n{\n crane.g=9.8;\n crane.M=100;\n crane.m=20;//10;//20\n crane.r=5;//5;\n crane.C=10;//5;\n crane.k=15;//\n crane.dr=crane.ddr=0;\n crane.x0=0;\n crane.y0=crane.r;\n crane.dx0=crane.dy0=crane.da0=0;\n crane.dXmax=1.;//??ddXmax=(dXmax-dX)/dt;//??\n crane.ddXmax=0.2;//??ddXmax=(dXmax-dX)/dt;//??\n crane.Fmax=30.0;//check// crane.Fmax=30;//check\n#ifdef CRANESUB\n crane.h=AP_tS;\n crane.m=_crane_m;\n crane.r=_crane_r;\n crane.C=_crane_C;\n crane.k=_crane_k;//\n crane.dXmax=_crane_dXmax;\n if(_AP_umax>0) AP_u_max=crane.ddXmax=_AP_umax;\n else AP_u_max=crane.ddXmax;\n AP_u_min=-AP_u_max;\n // starttime=0;\n // totaltime=50;\n rr=AP_r=_AP_r;//10\n rr_kyoyou=_rr_kyoyou;\n // p=(double *)malloc(buffsize*sizeof(double));\n C_MODE=11;\n // iteration=_iteration;\n#else\n crane.h=0.01;\n // crane.h=0.0001;\n#endif\n crane.nh=10;\n crane._h=crane.h/crane.nh;//0.001\n crane._dim=4;\n if(crane._y==NULL){\n crane._y=(double*)malloc(crane._dim*sizeof(double));\n crane._y_err=(double*)malloc(crane._dim*sizeof(double));\n crane._dydt_in=(double*)malloc(crane._dim*sizeof(double));\n crane._dydt_out=(double*)malloc(crane._dim*sizeof(double));\n }\n crane._T= gsl_odeiv_step_rk4;\n crane._s= gsl_odeiv_step_alloc (crane._T, crane._dim);\n crane._sys= (gsl_odeiv_system){cranefunc, NULL, crane._dim, &crane};\n // crane._sys[0]=cranefunc;\n // crane._sys[1]=NULL;\n // crane._sys[2]=crane._dim;\n // crane._sys[3]=&crane;\n //initialize variables\n crane._t=crane._y[0]=crane._y[1]=crane._y[2]=crane._y[3]=0;\n // crane.FF=0;\n int i;for(i=0;icrane.ddXmax) uu=crane.ddXmax; \n else if(uu<-crane.ddXmax) uu=-crane.ddXmax;\n\n int n;\n for(n=0;n=crane.dXmax && crane.ddX>0) crane.ddX=0;\n else if(crane.dX<=-crane.dXmax && crane.ddX<0) crane.ddX=0;\n\n int status = gsl_odeiv_step_apply (crane._s, crane._t, crane._h, \n\t\t\t\t crane._y, crane._y_err, \n\t\t\t\t crane._dydt_in, \n\t\t\t\t crane._dydt_out, \n\t\t\t\t &crane._sys);\n if (status != GSL_SUCCESS) {fprintf(stderr,\"### failure of plant calc.\\n\"); break;}\n \n int i;for(i=0;i rt in [0,1]\n}\n#ifndef CRANESUB\nint main(int argc,char **argv)\n{\n ////////////////////////////////////////////////////\n /// method 1 ///\n /// input ddX ///\n /// output a,x,y,F ///\n ////////////////////////////////////////////////////\n // double h = 0.001;//,hh=0.1; h = 0.0001;//,hh=0.1;\n double T=5;\n double t0=0; //stationary \n double t1=T+t0;//accelerate(speed up)\n double t2=T+t1;//free run\n double t3=T+t2;//decelerate(slow down)\n double t4=t0+50; //free run\n\n initialize();\n int M=(t4/crane.h)+1;\n double *ddX=(double*)malloc(sizeof(double)*M);\n // double *F =(double*)malloc(sizeof(double)*M);\n double Vmax=1;//dX/dt=1[m/s]\n //C:10;K:15;M:100;m:10;TS:0.5;/*数式処理の場合、この行を実行しない.m=10,40,70,100にして行う*/\n /* crane.M=100;\n crane.C=10;\n crane.k=15;\n crane.m=10;*/\n int i;\n for(i=1;i\n#include \n#include \n#include /* printf */\n#include \n#include \n#include \n#include \n#include \n#include \n//#include \"cmd_line.h\"\n\n\n//This class implements the method LADMM\n\n/*\nThe optimization problem to solve is:\n\nmin \\sum_i f^i(A_ix)+ \\sum_i h^i(y^i)+ g(x) \ns.t. Mx= y\nAssumption 1: For each i, f_i is smooth, g(x) is seperable\n*/\n\ntemplate\nclass LADMM\n{\nprivate:\n\n std::vector Ax;\n std::vector old_Ax;\n \n std::vector Mx;\n std::vector old_Mx;\n \n std::vector Mty;\n std::vector old_Mty;\n \n std::vector Mtlambda;\n std::vector old_Mtlambda;\n \n std::vector gradient;\n \n std::vector MtMx;\n\nprotected:\n Matrix data_A;\n\t\n Matrix data_M;\n\n std::vector x;\n\n std::vector old_x;\n \n std::vector y;\n\n std::vector old_y;\n\n std::vector lambda;\n\n std::vector old_lambda;\n\n\n D beta;\n\n L m_1;\n\n L m_2;\n \n L m_3;\n\n D rho;\n\n D tau;\n \n D sigma;\n\n D L_phi;\n\n D function_value;\n \n D infeas;\n\n L print_every_N_ADMM;\n\n D running_time_ADMM;\n\n L nb_outer_iters;\n\n ofstream samp_ADMM;\n\n\npublic:\n D lambda_f;\n\n D mu_g;\n \n D lambda1;\n \n D lambda2;\n \n D L_h;\n\n \n virtual inline D value_of_f_j(D, L){return D(NULL);}\n virtual inline D value_of_h_j(D, L){return D(NULL);}\n virtual inline D gradient_of_f_j(D, L){return D(NULL);}\n virtual inline D prox_of_h_j(D,D, L){return D(NULL);}\n virtual inline D value_of_g_j(D, L){return D(NULL);}\n virtual inline D prox_of_g_j(D, D, L){return D(NULL);}\n virtual inline void set_matrix_M(){}\n virtual inline void set_matrix_A(){}\n\n\n/*\n LADMM(const char* matrix_file, const char* matrix_file2)\n : Primal_Dual_LOOPLESS_Katyusha0(),data_A(matrix_file), data_M(matrix_file2)\n {\n \tthis->matrix_merge(data_A,data_M);\n this->gamma=1;\n }\n */ \n inline void set_L_phi(){\n \tif (data_A.nsamples== 0){\n \t\tL_phi= 0;\n\t }\n\telse{\n \t\tL_phi= compute_lambda_max_A(10);\n \t}\n }\n \n D compute_lambda_max_A(L K){\n\n std::vector bk(data_A.nfeatures);\n for (L j=0;j yk(data_A.nsamples);\n D normk;\n D tmp;\n for(L kk=0;kk bk2(data_A.nfeatures);\n for (L j=0;j bk(data_M.nfeatures);\n for (L j=0;j yk(data_M.nsamples);\n D normk;\n D tmp;\n for(L kk=0;kk bk2(data_M.nfeatures);\n for (L j=0;j & x0,vector & y0, vector & lambda0){\n cout<<\"start initializing\"< & x0,vector & y0, vector & lambda0, L max_nb_outer, L p_N_1, string filename1, D time){\n Initialize(beta_0,val_rho, x0, y0, lambda0);\n nb_outer_iters=0;\n //string sampname2= ALGparam.data_dir +\"/results/L_Katyusha_\"+filename2;\n //filename1= ALGparam.data_dir +\"/results/ADMM_\"+filename1;\n filename1= \"results/ADMM_\"+filename1;\n samp_ADMM.open(filename1.c_str());\n running_time_ADMM=0;\n print_every_N_ADMM=p_N_1;\n compute_and_record_res();\n D start;\n D res_x, res_y, res_l;\n /*\n for(L i=0;i time){\n break;\n }\n }\n\n}\n};\n\n#endif /* MIN_SMOOTH_CONVEX_H */\n", "meta": {"hexsha": "1e42c801399a8f17b690fe0eb72ac2d72c6e1f77", "size": 10715, "ext": "h", "lang": "C", "max_stars_repo_path": "IPALM/LADMM.h", "max_stars_repo_name": "lifei16/supplementary_code", "max_stars_repo_head_hexsha": "3d5d8c281411fdfd6379480429a1fbb9b21464ff", "max_stars_repo_licenses": ["BSD-Source-Code"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "IPALM/LADMM.h", "max_issues_repo_name": "lifei16/supplementary_code", "max_issues_repo_head_hexsha": "3d5d8c281411fdfd6379480429a1fbb9b21464ff", "max_issues_repo_licenses": ["BSD-Source-Code"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "IPALM/LADMM.h", "max_forks_repo_name": "lifei16/supplementary_code", "max_forks_repo_head_hexsha": "3d5d8c281411fdfd6379480429a1fbb9b21464ff", "max_forks_repo_licenses": ["BSD-Source-Code"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2021-01-15T04:23:24.000Z", "max_forks_repo_forks_event_max_datetime": "2021-01-15T04:23:24.000Z", "avg_line_length": 21.092519685, "max_line_length": 162, "alphanum_fraction": 0.5470835278, "num_tokens": 3732, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7799929002541068, "lm_q2_score": 0.6548947290421276, "lm_q1q2_score": 0.5108132390666966}} {"text": "/* ode-initval/rk4.c\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n/* Runge-Kutta 4th order, Classical */\n\n/* Author: G. Jungman\n */\n\n/* Reference: Abramowitz & Stegun, section 25.5. equation 25.5.10 \n\n Error estimation by step doubling, see eg. Ascher, U.M., Petzold,\n L.R., Computer methods for ordinary differential and\n differential-algebraic equations, SIAM, Philadelphia, 1998.\n*/\n\n#include \n#include \n#include \n#include \n#include \n\n#include \"odeiv_util.h\"\n\ntypedef struct\n{\n double *k;\n double *k1;\n double *y0;\n double *ytmp;\n double *y_onestep;\n}\nrk4_state_t;\n\nstatic void *\nrk4_alloc (size_t dim)\n{\n rk4_state_t *state = (rk4_state_t *) malloc (sizeof (rk4_state_t));\n\n if (state == 0)\n {\n GSL_ERROR_NULL (\"failed to allocate space for rk4_state\", GSL_ENOMEM);\n }\n\n state->k = (double *) malloc (dim * sizeof (double));\n\n if (state->k == 0)\n {\n free (state);\n GSL_ERROR_NULL (\"failed to allocate space for k\", GSL_ENOMEM);\n }\n\n state->k1 = (double *) malloc (dim * sizeof (double));\n\n if (state->k1 == 0)\n {\n free (state->k);\n free (state);\n GSL_ERROR_NULL (\"failed to allocate space for k1\", GSL_ENOMEM);\n }\n\n state->y0 = (double *) malloc (dim * sizeof (double));\n\n if (state->y0 == 0)\n {\n free (state->k);\n free (state->k1);\n free (state);\n GSL_ERROR_NULL (\"failed to allocate space for y0\", GSL_ENOMEM);\n }\n\n state->ytmp = (double *) malloc (dim * sizeof (double));\n\n if (state->ytmp == 0)\n {\n free (state->y0);\n free (state->k);\n free (state->k1);\n free (state);\n GSL_ERROR_NULL (\"failed to allocate space for ytmp\", GSL_ENOMEM);\n }\n\n state->y_onestep = (double *) malloc (dim * sizeof (double));\n\n if (state->y_onestep == 0)\n {\n free (state->ytmp);\n free (state->y0);\n free (state->k);\n free (state->k1);\n free (state);\n GSL_ERROR_NULL (\"failed to allocate space for ytmp\", GSL_ENOMEM);\n }\n\n return state;\n}\n\nstatic int\nrk4_step (double *y, const rk4_state_t *state,\n\t const double h, const double t, const size_t dim,\n\t const gsl_odeiv_system *sys)\n{\n /* Makes a Runge-Kutta 4th order advance with step size h. */\n \n /* initial values of variables y. */\n const double *y0 = state->y0;\n \n /* work space */\n double *ytmp = state->ytmp;\n\n /* Runge-Kutta coefficients. Contains values of coefficient k1\n in the beginning \n */\n double *k = state->k;\n\n size_t i;\n\n /* k1 step */\n\n for (i = 0; i < dim; i++)\n {\n y[i] += h / 6.0 * k[i];\n ytmp[i] = y0[i] + 0.5 * h * k[i];\n }\n\n /* k2 step */\n {\n int s = GSL_ODEIV_FN_EVAL (sys, t + 0.5 * h, ytmp, k);\n\n if (s != GSL_SUCCESS)\n {\n\treturn s;\n }\n }\n\n for (i = 0; i < dim; i++)\n {\n y[i] += h / 3.0 * k[i];\n ytmp[i] = y0[i] + 0.5 * h * k[i];\n }\n\n /* k3 step */\n {\n int s = GSL_ODEIV_FN_EVAL (sys, t + 0.5 * h, ytmp, k);\n\n if (s != GSL_SUCCESS)\n {\n\treturn s;\n }\n }\n\n for (i = 0; i < dim; i++)\n {\n y[i] += h / 3.0 * k[i];\n ytmp[i] = y0[i] + h * k[i];\n }\n\n /* k4 step */\n {\n int s = GSL_ODEIV_FN_EVAL (sys, t + h, ytmp, k);\n\n if (s != GSL_SUCCESS)\n {\n\treturn s;\n }\n }\n\n for (i = 0; i < dim; i++)\n {\n y[i] += h / 6.0 * k[i];\n }\n\n return GSL_SUCCESS;\n}\n\n\nstatic int\nrk4_apply (void *vstate,\n size_t dim,\n double t,\n double h,\n double y[],\n double yerr[],\n const double dydt_in[],\n double dydt_out[], \n const gsl_odeiv_system * sys)\n{\n rk4_state_t *state = (rk4_state_t *) vstate;\n\n size_t i;\n\n double *const k = state->k;\n double *const k1 = state->k1;\n double *const y0 = state->y0;\n double *const y_onestep = state->y_onestep;\n\n DBL_MEMCPY (y0, y, dim);\n\n if (dydt_in != NULL)\n {\n DBL_MEMCPY (k, dydt_in, dim);\n }\n else\n {\n int s = GSL_ODEIV_FN_EVAL (sys, t, y0, k);\n\n if (s != GSL_SUCCESS)\n\t{\n\t return s;\n\t}\n }\n\n /* Error estimation is done by step doubling procedure */\n\n /* Save first point derivatives*/\n \n DBL_MEMCPY (k1, k, dim);\n\n /* First traverse h with one step (save to y_onestep) */\n\n DBL_MEMCPY (y_onestep, y, dim);\n\n {\n int s = rk4_step (y_onestep, state, h, t, dim, sys);\n\n if (s != GSL_SUCCESS) \n {\n return s;\n }\n }\n\n /* Then with two steps with half step length (save to y) */ \n\n DBL_MEMCPY (k, k1, dim);\n\n {\n int s = rk4_step (y, state, h/2.0, t, dim, sys);\n\n if (s != GSL_SUCCESS)\n {\n\t/* Restore original values */\n\tDBL_MEMCPY (y, y0, dim);\n\treturn s;\n }\n }\n\n /* Update before second step */\n {\n int s = GSL_ODEIV_FN_EVAL (sys, t + h/2.0, y, k);\n\n if (s != GSL_SUCCESS)\n {\n\t/* Restore original values */\n\tDBL_MEMCPY (y, y0, dim);\n\treturn s;\n }\n }\n \n /* Save original y0 to k1 for possible failures */\n DBL_MEMCPY (k1, y0, dim);\n\n /* Update y0 for second step */\n DBL_MEMCPY (y0, y, dim);\n\n {\n int s = rk4_step (y, state, h/2.0, t + h/2.0, dim, sys);\n\n if (s != GSL_SUCCESS)\n {\n\t/* Restore original values */\n\tDBL_MEMCPY (y, k1, dim);\n\treturn s;\n }\n }\n\n /* Derivatives at output */\n\n if (dydt_out != NULL) {\n int s = GSL_ODEIV_FN_EVAL (sys, t + h, y, dydt_out);\n\n if (s != GSL_SUCCESS)\n {\n\t/* Restore original values */\n\tDBL_MEMCPY (y, k1, dim);\n\treturn s;\n }\n }\n \n /* Error estimation\n\n yerr = C * 0.5 * | y(onestep) - y(twosteps) | / (2^order - 1)\n\n constant C is approximately 8.0 to ensure 90% of samples lie within\n the error (assuming a gaussian distribution with prior p(sigma)=1/sigma.)\n\n */\n\n for (i = 0; i < dim; i++)\n {\n yerr[i] = 4.0 * (y[i] - y_onestep[i]) / 15.0;\n }\n\n return GSL_SUCCESS;\n}\n\nstatic int\nrk4_reset (void *vstate, size_t dim)\n{\n rk4_state_t *state = (rk4_state_t *) vstate;\n\n DBL_ZERO_MEMSET (state->k, dim);\n DBL_ZERO_MEMSET (state->k1, dim);\n DBL_ZERO_MEMSET (state->y0, dim);\n DBL_ZERO_MEMSET (state->ytmp, dim);\n DBL_ZERO_MEMSET (state->y_onestep, dim);\n\n return GSL_SUCCESS;\n}\n\nstatic unsigned int\nrk4_order (void *vstate)\n{\n rk4_state_t *state = (rk4_state_t *) vstate;\n state = 0; /* prevent warnings about unused parameters */\n return 4;\n}\n\nstatic void\nrk4_free (void *vstate)\n{\n rk4_state_t *state = (rk4_state_t *) vstate;\n free (state->k);\n free (state->k1);\n free (state->y0);\n free (state->ytmp);\n free (state->y_onestep);\n free (state);\n}\n\nstatic const gsl_odeiv_step_type rk4_type = { \"rk4\", /* name */\n 1, /* can use dydt_in */\n 1, /* gives exact dydt_out */\n &rk4_alloc,\n &rk4_apply,\n &rk4_reset,\n &rk4_order,\n &rk4_free\n};\n\nconst gsl_odeiv_step_type *gsl_odeiv_step_rk4 = &rk4_type;\n", "meta": {"hexsha": "fda74361883c9741faed4e3a03a9d70433b1df03", "size": 7549, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.6/ode-initval/rk4.c", "max_stars_repo_name": "ielomariala/Hex-Game", "max_stars_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-01-11T02:53:04.000Z", "max_stars_repo_stars_event_max_datetime": "2021-11-25T17:31:22.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/ode-initval/rk4.c", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-12-16T17:41:24.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-22T00:00:16.000Z", "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/ode-initval/rk4.c", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 14.0, "max_forks_repo_forks_event_min_datetime": "2015-07-21T04:47:52.000Z", "max_forks_repo_forks_event_max_datetime": "2020-03-12T12:31:25.000Z", "avg_line_length": 20.6256830601, "max_line_length": 81, "alphanum_fraction": 0.5808716386, "num_tokens": 2443, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7520125848754471, "lm_q2_score": 0.6791787056691698, "lm_q1q2_score": 0.5107509340426328}} {"text": "/* ode-initval/gear1.c\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n/* Gear 1. This is the implicit Euler a.k.a backward Euler method. */\n\n/* Author: G. Jungman\n */\n\n/* Error estimation by step doubling, see eg. Ascher, U.M., Petzold,\n L.R., Computer methods for ordinary differential and\n differential-algebraic equations, SIAM, Philadelphia, 1998.\n The method is also described in eg. this reference.\n*/\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"odeiv_util.h\"\n\ntypedef struct\n{\n double *k;\n double *y0;\n double *y0_orig;\n double *y_onestep;\n}\ngear1_state_t;\n\nstatic void *\ngear1_alloc (size_t dim)\n{\n gear1_state_t *state = (gear1_state_t *) malloc (sizeof (gear1_state_t));\n\n if (state == 0)\n {\n GSL_ERROR_NULL (\"failed to allocate space for gear1_state\", GSL_ENOMEM);\n }\n\n state->k = (double *) malloc (dim * sizeof (double));\n\n if (state->k == 0)\n {\n free (state);\n GSL_ERROR_NULL (\"failed to allocate space for k\", GSL_ENOMEM);\n }\n\n state->y0 = (double *) malloc (dim * sizeof (double));\n\n if (state->y0 == 0)\n {\n free (state->k);\n free (state);\n GSL_ERROR_NULL (\"failed to allocate space for y0\", GSL_ENOMEM);\n }\n\n state->y0_orig = (double *) malloc (dim * sizeof (double));\n\n if (state->y0_orig == 0)\n {\n free (state->y0);\n free (state->k);\n free (state);\n GSL_ERROR_NULL (\"failed to allocate space for y0_orig\", GSL_ENOMEM);\n }\n\n state->y_onestep = (double *) malloc (dim * sizeof (double));\n\n if (state->y_onestep == 0)\n {\n free (state->y0_orig);\n free (state->y0);\n free (state->k);\n free (state);\n GSL_ERROR_NULL (\"failed to allocate space for y_onestep\", GSL_ENOMEM);\n }\n\n return state;\n}\n\nstatic int\ngear1_step (double *y, gear1_state_t *state, \n\t const double h, const double t, \n\t const size_t dim, const gsl_odeiv_system *sys)\n{\n /* Makes an implicit Euler advance with step size h.\n y0 is the initial values of variables y. \n\n The implicit matrix equations to solve are:\n\n k = y0 + h * f(t + h, k)\n\n y = y0 + h * f(t + h, k)\n */\n\n const int iter_steps = 3;\n int nu;\n size_t i;\n double *y0 = state->y0;\n double *k = state->k;\n\n /* Iterative solution of k = y0 + h * f(t + h, k)\n\n Note: This method does not check for convergence of the\n iterative solution! \n */\n\n for (nu = 0; nu < iter_steps; nu++) \n {\n int s = GSL_ODEIV_FN_EVAL(sys, t + h, y, k);\n\n if (s != GSL_SUCCESS)\n\t{\n\t return s;\n\t} \n\n for (i=0; iy0;\n double *y0_orig = state->y0_orig;\n double *y_onestep = state->y_onestep;\n\n /* initialization */\n DBL_MEMCPY(y0, y, dim);\n\n /* Save initial values for possible failures */\n DBL_MEMCPY (y0_orig, y, dim);\n\n /* First traverse h with one step (save to y_onestep) */\n DBL_MEMCPY (y_onestep, y, dim);\n\n {\n int s = gear1_step (y_onestep, state, h, t, dim, sys);\n\n if (s != GSL_SUCCESS) \n {\n return s;\n }\n } \n\n /* Then with two steps with half step length (save to y) */ \n {\n int s = gear1_step (y, state, h / 2.0, t, dim, sys);\n\n if (s != GSL_SUCCESS) \n {\n /* Restore original y vector */\n DBL_MEMCPY (y, y0_orig, dim);\n return s;\n }\n }\n\n DBL_MEMCPY (y0, y, dim);\n\n {\n int s = gear1_step (y, state, h / 2.0, t + h / 2.0, dim, sys);\n\n if (s != GSL_SUCCESS) \n {\n /* Restore original y vector */\n DBL_MEMCPY (y, y0_orig, dim);\n return s;\n }\n }\n \n /* Cleanup update */\n\n if (dydt_out != NULL) \n {\n int s = GSL_ODEIV_FN_EVAL (sys, t + h, y, dydt_out);\n \n if (s != GSL_SUCCESS)\n {\n /* Restore original y vector */\n DBL_MEMCPY (y, y0_orig, dim);\n return s;\n } \n }\n \n /* Error estimation */\n\n for (i = 0; i < dim; i++) \n {\n yerr[i] = 4.0 * (y[i] - y_onestep[i]);\n }\n\n return GSL_SUCCESS;\n}\n\nstatic int\ngear1_reset (void *vstate, size_t dim)\n{\n gear1_state_t *state = (gear1_state_t *) vstate;\n\n DBL_ZERO_MEMSET (state->y_onestep, dim);\n DBL_ZERO_MEMSET (state->y0_orig, dim);\n DBL_ZERO_MEMSET (state->y0, dim);\n DBL_ZERO_MEMSET (state->k, dim);\n return GSL_SUCCESS;\n}\n\nstatic unsigned int\ngear1_order (void *vstate)\n{\n gear1_state_t *state = (gear1_state_t *) vstate;\n state = 0; /* prevent warnings about unused parameters */\n return 1;\n}\n\nstatic void\ngear1_free (void *vstate)\n{\n gear1_state_t *state = (gear1_state_t *) vstate;\n free (state->y_onestep);\n free (state->y0_orig);\n free (state->y0);\n free (state->k);\n free (state);\n}\n\nstatic const gsl_odeiv_step_type gear1_type = { \"gear1\", /* name */\n 0, /* can use dydt_in? */\n 1, /* gives exact dydt_out? */\n &gear1_alloc,\n &gear1_apply,\n &gear1_reset,\n &gear1_order,\n &gear1_free\n};\n\nconst gsl_odeiv_step_type *gsl_odeiv_step_gear1 = &gear1_type;\n", "meta": {"hexsha": "1111bd3fdc1cec328910ecc167ec572606215c5e", "size": 6177, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.6/ode-initval/gear1.c", "max_stars_repo_name": "ielomariala/Hex-Game", "max_stars_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-12-18T18:09:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-10T11:31:28.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/ode-initval/gear1.c", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-12-16T17:41:24.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-22T00:00:16.000Z", "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/ode-initval/gear1.c", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 14.0, "max_forks_repo_forks_event_min_datetime": "2015-07-21T04:47:52.000Z", "max_forks_repo_forks_event_max_datetime": "2020-03-12T12:31:25.000Z", "avg_line_length": 22.6263736264, "max_line_length": 81, "alphanum_fraction": 0.6030435486, "num_tokens": 1868, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7520125737597972, "lm_q2_score": 0.6791786926816161, "lm_q1q2_score": 0.5107509167263166}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n\nvoid init_interpolate(double *x, double *y, size_t n, const gsl_interp_type *T, interp_info **interp) {\n size_t i;\n (*interp) = (interp_info *)malloc(sizeof(interp_info));\n (*interp)->n = n;\n (*interp)->x = (double *)malloc(sizeof(double) * n);\n (*interp)->y = (double *)malloc(sizeof(double) * n);\n (*interp)->T = T;\n // If the x-array is not in ascending order, switch it\n if(x[0] < x[n - 1]) {\n for(i = 0; i < n; i++) {\n (*interp)->x[i] = x[i];\n (*interp)->y[i] = y[i];\n }\n } else {\n for(i = 0; i < n; i++) {\n (*interp)->x[i] = x[n - 1 - i];\n (*interp)->y[i] = y[n - 1 - i];\n }\n }\n (*interp)->accel = gsl_interp_accel_alloc();\n (*interp)->interp = gsl_interp_alloc(T, n);\n gsl_interp_init((*interp)->interp, (const double *)(*interp)->x, (const double *)(*interp)->y, (*interp)->n);\n}\n", "meta": {"hexsha": "62f2339c5f3cd4f03b7f7e4c3ccbed04604f5efb", "size": 1044, "ext": "c", "lang": "C", "max_stars_repo_path": "src/gbpMath/gbpInterpolate/init_interpolate.c", "max_stars_repo_name": "gbpoole/gbpCode", "max_stars_repo_head_hexsha": "5157d2e377edbd4806258d1c16b329373186d43a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2015-10-20T11:39:53.000Z", "max_stars_repo_stars_event_max_datetime": "2015-10-20T11:39:53.000Z", "max_issues_repo_path": "src/gbpMath/gbpInterpolate/init_interpolate.c", "max_issues_repo_name": "gbpoole/gbpCode", "max_issues_repo_head_hexsha": "5157d2e377edbd4806258d1c16b329373186d43a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2017-07-30T11:10:49.000Z", "max_issues_repo_issues_event_max_datetime": "2019-06-18T00:40:46.000Z", "max_forks_repo_path": "src/gbpMath/gbpInterpolate/init_interpolate.c", "max_forks_repo_name": "gbpoole/gbpCode", "max_forks_repo_head_hexsha": "5157d2e377edbd4806258d1c16b329373186d43a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4.0, "max_forks_repo_forks_event_min_datetime": "2015-01-23T00:50:40.000Z", "max_forks_repo_forks_event_max_datetime": "2016-08-01T08:14:24.000Z", "avg_line_length": 33.6774193548, "max_line_length": 113, "alphanum_fraction": 0.5287356322, "num_tokens": 318, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.787931185683219, "lm_q2_score": 0.6477982315512489, "lm_q1q2_score": 0.510420428669668}} {"text": "/*\n NAME:\n read_IC\n PURPOSE:\n read the initial conditions file\n CALLING SEQUENCE:\n read_IC(char ICfilename[])\n INPUT:\n ICfilename - initial conditions filename\n OUTPUT:\n sets the options and the initial conditions\n REVISION HISTORY:\n 2008-09-21 - Written Bovy\n*/\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nbool read_IC(char ICfilename[]){\n \n FILE *ICfile;\n if ( (ICfile= fopen(ICfilename,\"r\")) == NULL){\n printf (\"Opening the initial conditions file failed...\\n\");\n return false;\n }\n char line[100];\n printf(\"Reading the options section of the initial conditions file...\\n\");\n while (fgets(line,100,ICfile) != NULL){\n if (line[0] != '#'){\n if (line[0] == '\\n') break;\n if (parse_option(line) == false){\n\tprintf(\"One of the lines in the options section of the initial conditions file is corrupted\\n\");\n\tprintf(\"Please check the initial conditions file and try again\\n\");\n\treturn false;\n }\n }\n }\n \n printf(\"Successfully read the options\\n\");\n\n printf(\"Reading the initial model parameters...\\n\");\n \n\n //Read first block, establish the dimension d of the modeled quantities\n int countd=0;\n double *mmtemp = (double *) malloc (1000000 * sizeof (double));\n while (fgets(line,100,ICfile) != NULL){\n if (line[0] != '#'){\n if (line[0] == '\\n') break;\n *(mmtemp++) = atof(line);\n ++countd;\n }\n }\n //now determine d\n d = (int) (-3 + sqrt(9 + 8 * (countd-1)))/2 ; \n dV = (int) (d*(d+1)/2);\n\n //allocate the alpha, mm and VV matrices\n int kk;\n for (kk=0; kk != K; ++kk){\n gaussians->mm = gsl_vector_alloc (d);\n gaussians->VV = gsl_matrix_alloc (d,d);;\n ++gaussians;\n }\n gaussians -= K;\n \n //first map the mmtemp values on the right alpha, mm, VV\n mmtemp -= countd;\n (*gaussians).alpha = *(mmtemp++);\n int dd;\n for (dd=0; dd != d; ++dd)\n gsl_vector_set(gaussians->mm,dd,*(mmtemp++));\n int dd1,dd2;\n for (dd1=0; dd1 != d; ++dd1)\n gsl_matrix_set(gaussians->VV,dd1,dd1,*(mmtemp++));\n for (dd1=0; dd1 != d-1; ++dd1)\n for (dd2=dd1+1; dd2 != d; ++dd2){\n gsl_matrix_set(gaussians->VV,dd1,dd2,*mmtemp);\n gsl_matrix_set(gaussians->VV,dd2,dd1,*mmtemp);\n mmtemp++;\n }\n\n ++gaussians;\n \n //reallocate mmtemp\n mmtemp -= countd;\n mmtemp = (double *) realloc (mmtemp,countd * sizeof (double) );\n if (mmtemp == NULL){\n printf(\"Error reallocating memory\\n\");\n printf(\"Returning\\n\");\n return false;\n }\n\n //Then read the rest of the Gaussians.\n for (kk=1; kk != K; ++kk){\n while (fgets(line,100,ICfile) != NULL){\n if (line[0] != '#'){\n\tif (line[0] == '\\n') break;\n\t*(mmtemp++) = atof(line);\n }\n }\n mmtemp -=countd;\n (*gaussians).alpha = *(mmtemp++);\n for (dd=0; dd != d; ++dd)\n gsl_vector_set(gaussians->mm,dd,*(mmtemp++));\n for (dd1=0; dd1 != d; ++dd1)\n gsl_matrix_set(gaussians->VV,dd1,dd1,*(mmtemp++));\n for (dd1=0; dd1 != d-1; ++dd1)\n for (dd2=dd1+1; dd2 != d; ++dd2){\n\tgsl_matrix_set(gaussians->VV,dd1,dd2,*mmtemp);\n\tgsl_matrix_set(gaussians->VV,dd2,dd1,*mmtemp);\n\tmmtemp++;\n }\n ++gaussians;\n mmtemp -= countd;\n }\n gaussians -= K;\n \n free(mmtemp);\n\n fclose(ICfile);\n\n printf(\"Successfully read initial model parameters from the initial conditions file\\n\");\n\n\n //Print options\n printf(\"\\nThe options are set to:\\n\");\n printf(\"K\\t\\t=\\t\");\n printf(\"%i\",K);\n printf(\"\\n\");\n printf(\"maxiter\\t\\t=\\t\");\n printf(\"%lli\",maxiter);\n printf(\"\\n\");\n printf(\"tol\\t\\t=\\t\");\n printf(\"%f\",tol);\n printf(\"\\n\");\n printf(\"splitnmerge\\t=\\t\");\n printf(\"%i\",splitnmerge);\n printf(\"\\n\");\n printf(\"likeonly\\t=\\t\");\n printf(\"%i\",likeonly);\n printf(\"\\n\");\n printf(\"w\\t\\t=\\t\");\n printf(\"%f\",w);\n printf(\"\\n\");\n printf(\"fixamp\\t\\t=\\t\");\n int ii;\n for (ii=0; ii != K; ++ii){\n printf(\"%i\",*fixampP);\n if (ii < K-1) printf(\"\\t\");\n fixampP++;\n }\n fixampP -= K;\n printf(\"\\n\");\n printf(\"fixmean\\t\\t=\\t\");\n for (ii=0; ii != K; ++ii){\n printf(\"%i\",*fixmeanP);\n if (ii < K-1) printf(\"\\t\");\n fixmeanP++;\n }\n fixmeanP -= K;\n printf(\"\\n\");\n printf(\"fixcovar\\t=\\t\");\n for (ii=0; ii != K; ++ii){\n printf(\"%i\",*fixcovarP);\n if (ii < K-1) printf(\"\\t\");\n fixcovarP++;\n }\n fixcovarP -= K;\n printf(\"\\n\");\n\n\n //Print the initial model parameters\n printf(\"\\nInitial model parameters used:\\n\\n\");\n for (kk=0; kk != K; ++kk){\n printf(\"Gaussian \");\n printf(\"%i\",kk);\n printf(\"\\n\");\n printf(\"amp\\t=\\t\");\n printf(\"%f\",(*gaussians).alpha);\n printf(\"\\n\");\n printf(\"mean\\t=\\t\");\n for (dd=0; dd != d; ++dd){\n printf(\"%f\",gsl_vector_get(gaussians->mm,dd));\n if (dd < d-1) printf(\"\\t\");\n }\n printf(\"\\n\");\n printf(\"covar\\t=\\t\");\n for (dd1=0; dd1 != d; ++dd1)\n printf(\"%f\\t\",gsl_matrix_get(gaussians->VV,dd1,dd1));\n for (dd1=0; dd1 != d-1; ++dd1)\n for (dd2=dd1+1; dd2 != d; ++dd2){\n\tprintf(\"%f\\t\",gsl_matrix_get(gaussians->VV,dd1,dd2));\n }\n ++gaussians;\n printf(\"\\n\\n\");\n }\n gaussians -= K;\n\n return true;\n \n}\n", "meta": {"hexsha": "00a6d18180c9de40345608cd0133c741452bd32b", "size": 5126, "ext": "c", "lang": "C", "max_stars_repo_path": "src/read_IC.c", "max_stars_repo_name": "HaifengWangNAOC/Learn-Bovy-Extreme-deconvolution", "max_stars_repo_head_hexsha": "bc6d58199b17cd5329d72f6af3c7ba7e6d2ae780", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 73.0, "max_stars_repo_stars_event_min_datetime": "2015-01-22T09:22:38.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-21T01:27:34.000Z", "max_issues_repo_path": "src/read_IC.c", "max_issues_repo_name": "HaifengWangNAOC/Learn-Bovy-Extreme-deconvolution", "max_issues_repo_head_hexsha": "bc6d58199b17cd5329d72f6af3c7ba7e6d2ae780", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 24.0, "max_issues_repo_issues_event_min_datetime": "2015-01-07T01:42:22.000Z", "max_issues_repo_issues_event_max_datetime": "2021-11-19T01:01:22.000Z", "max_forks_repo_path": "src/read_IC.c", "max_forks_repo_name": "HaifengWangNAOC/Learn-Bovy-Extreme-deconvolution", "max_forks_repo_head_hexsha": "bc6d58199b17cd5329d72f6af3c7ba7e6d2ae780", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 26.0, "max_forks_repo_forks_event_min_datetime": "2015-02-05T22:21:22.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-13T03:37:58.000Z", "avg_line_length": 24.7632850242, "max_line_length": 97, "alphanum_fraction": 0.5708154506, "num_tokens": 1704, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7879311956428946, "lm_q2_score": 0.6477982043529716, "lm_q1q2_score": 0.5104204136911571}} {"text": "#include \n#include \n#include \n#include \n\n#include \"viaio/Vlib.h\"\n#include \"viaio/VImage.h\"\n#include \"viaio/mu.h\"\n#include \"viaio/option.h\"\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n\n/* two-pass formula, correct for round-off error */\nvoid VNormalize(gsl_vector *vec)\n{\n double ave,var,sd,nx,s,u,tiny=1.0e-6;\n size_t j,nt = vec->size;\n\n nx = (double)nt;\n ave = 0;\n for (j=0; jdata[j];\n ave /= nx;\n\n var = u = 0;\n for (j=0; jdata[j]-ave;\n u += s;\n var += s*s;\n }\n var=(var-u*u/nx)/(nx-1);\n sd = sqrt(var);\n if (sd < tiny) {\n for (j=0; jdata[j] = 0;\n }\n else {\n for (j=0; jdata[j];\n vec->data[j] = (u-ave)/sd;\n }\n }\n}\n\n\n/* convert to ranks for spearman correlation */\nvoid GetRank(gsl_vector *vec,gsl_permutation *perm,gsl_permutation *rank)\n{\n size_t i;\n size_t n = vec->size;\n gsl_sort_vector_index (perm, vec);\n gsl_permutation_inverse (rank, perm);\n for (i=0; idata[i] = (float)rank->data[i];\n}\n\n\nsize_t NumVoxels(VImage src)\n{\n int b,r,c;\n size_t n=0;\n for (b=0; b 0.01) n++;\n }\n }\n }\n return n;\n}\n\ngsl_matrix_float *DataMatrix(VImage *src,int nslices,VImage roi,int metric)\n{\n int b,r,c;\n float u=0;\n size_t nt = VImageNBands(src[0]);\n size_t nvox = NumVoxels(roi);\n gsl_matrix_float *X = gsl_matrix_float_calloc(nvox,nt);\n if (X==NULL) VError(\" error allocating data matrix, size: %lu x %lu\\n\",nvox,nt);\n\n gsl_vector *vec = gsl_vector_calloc(nt);\n gsl_permutation *perm = NULL;\n gsl_permutation *rank = NULL;\n\n if (metric == 1) { /* only needed for spearman correlation */\n perm = gsl_permutation_alloc(nt);\n rank = gsl_permutation_alloc(nt);\n }\n\n\n size_t i=0,j=0;\n for (b=0; bdata[j] = u;\n\t}\n\n\tif (metric == 0) { /* linear correlation */\n\t VNormalize(vec);\n\t}\n\telse if (metric == 1) { /* convert to ranks for Spearman corr */\n\t GetRank(vec,perm,rank);\n\t}\n\telse {\n\t VError(\" unknown metric %d\",metric);\n\t}\n\n\tfor (j=0; jdata[j]);\n\t}\n\n\ti++;\n }\n }\n }\n\n gsl_vector_free(vec);\n if (metric==1) {\n gsl_permutation_free (perm);\n gsl_permutation_free (rank);\n }\n return X;\n}\n\n\n/* new voxel map */\nVImage VoxelMap(VImage roi)\n{\n size_t nvox = NumVoxels(roi);\n VImage map = VCreateImage(1,4,nvox,VShortRepn);\n if (map == NULL) VError(\" error allocating addr map\");\n VFillImage(map,VAllBands,0); \n int nslices = VImageNBands(roi);\n int nrows = VImageNRows(roi);\n int ncols = VImageNColumns(roi);\n VSetAttr(VImageAttrList(map),\"nvoxels\",NULL,VLongRepn,(VLong)nvox);\n VSetAttr(VImageAttrList(map),\"nslices\",NULL,VLongRepn,(VLong)nslices);\n VSetAttr(VImageAttrList(map),\"nrows\",NULL,VLongRepn,(VLong)nrows);\n VSetAttr(VImageAttrList(map),\"ncols\",NULL,VLongRepn,(VLong)ncols);\n VPixel(map,0,3,0,VShort) = nslices;\n VPixel(map,0,3,1,VShort) = nrows;\n VPixel(map,0,3,2,VShort) = ncols;\n\n int b,r,c;\n size_t i = 0;\n for (b=0; b\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#define M_EULER_MASCHERONI 0.5772156649015328606065120\n\n/*\nThis file contains the definition of functions used by Fortran module\npoisson_cutoff_m. There are four functions to be defined:\n\nc_poisson_cutoff_3d_1d_finite: For the cutoff of 3D/0D cases, in which however\n we want the region of the cutoff to be a cylinder.\nc_poisson_cutoff_2d_0d:\n\nc_poisson_cutoff_2d_1d:\n\n*/\n\n\n\n/************************************************************************/\n/************************************************************************/\n/* C_POISSON_CUTOFF_3D_1D_FINITE */\n/************************************************************************/\n/************************************************************************/\n\nstruct parameters\n{ \n double kx; \n double kr; \n double x0; \n double r0; \n int index; \n}; \n\n/* the index is the type of integral. This is necessary because depending of the value of k the\n the integral needs to be performed in different ways */\n#define PFC_F_0 0\n#define PFC_F_KX 1\n#define PFC_F_KR 2\n\nstatic const double tol = 1e-7;\nstatic double zero = 1e-100;\n\nstatic double f(double w, void *p)\n{\n struct parameters *params = (struct parameters *)p;\n const double kx = (params->kx);\n double kr = (params->kr);\n double x0 = (params->x0);\n double r0 = (params->r0);\n int index = (params->index);\n double result;\n\n if (w == 0) w = zero;\n\n if (fabs(kx - w) > tol){ \n result = sin((kx - w)*x0)/(kx - w)*\n sqrt(pow(w, 2.0*index)*pow(r0, 2.0*index))/(kr*kr + w*w)\n *gsl_sf_bessel_Kn(index, r0*fabs(w));\n }\n else{\n result = x0*sqrt(pow(w, 2.0*index))/(kr*kr + w*w)*gsl_sf_bessel_Kn(index, r0*fabs(w));\n }\n return result;\n}\n\n\nstatic double f_kx_zero(double w, void *p)\n{\n struct parameters *params = (struct parameters *)p;\n double kr = (params->kr);\n double x0 = (params->x0);\n double result;\n \n if (w == 0.0) w = zero;\n \n result = 2.0*M_PI*w*gsl_sf_bessel_J0(kr*w)*\n (log(x0 + sqrt(w*w + x0*x0)) - log(-x0 + sqrt(w*w + x0*x0)));\n return result;\n}\n\n\nstatic double f_kr_zero(double w, void *p)\n{\n struct parameters *params = (struct parameters *)p;\n double kx = (params->kx);\n double r0 = (params->r0);\n double result;\n\n result = 4.0*M_PI*cos(kx*w)*(sqrt(r0*r0 + w*w) - fabs(w));\n return result;\n}\n\n\nstatic double int_aux(int index, double kx, double kr, double x0, double r0, int which_int)\n{\n /*variables*/\n double result, error;\n double xinf = 100.0/r0;\n struct parameters params;\n\n /*pass the given parameters to program*/\n const size_t wrk_size = 5000;\n /* I believe that 1e-6 is over-killing, a substantial gain in time\n is obtained by setting this threshold to 1e-3 */\n /* const double epsilon_abs = 1e-6; */\n /* const double epsilon_rel = 1e-6; */\n const double epsilon_abs = 1e-3;\n const double epsilon_rel = 1e-3;\n\n /*creating the workspace*/\n gsl_integration_workspace * ws = gsl_integration_workspace_alloc (wrk_size);\n\n /*create the function*/\n gsl_function F;\n\n assert(which_int == PFC_F_0 || which_int == PFC_F_KR || which_int == PFC_F_KX);\n\n params.kx = kx;\n params.kr = kr;\n params.x0 = x0;\n params.r0 = r0;\n params.index = index;\n\n F.params = ¶ms;\n \n /*select the integration method*/\n switch(which_int){\n case PFC_F_0:\n F.function = &f;\n gsl_integration_qag(&F, -xinf, xinf, epsilon_abs, epsilon_rel, \n\t\t\twrk_size, 3, ws, &result, &error);\n break;\n case PFC_F_KX:\n F.function = &f_kx_zero;\n gsl_integration_qag (&F, 0.0, r0, epsilon_abs, epsilon_rel, \n\t\t\t wrk_size, 3, ws, &result, &error);\n break;\n case PFC_F_KR:\n F.function = &f_kr_zero;\n gsl_integration_qag (&F, 0.0, x0, epsilon_abs, epsilon_rel, \n\t\t\t wrk_size, 3, ws, &result, &error);\n break;\n }\n\n /*free the integration workspace*/\n gsl_integration_workspace_free (ws);\n \n /*return*/\n return result;\n}\n\n\ndouble poisson_finite_cylinder(double kx, double kr, double x0,double r0) {\n double result;\n\n if ((kx>=tol) & (kr>=tol)) {\n result = 4.0*kr*r0*gsl_sf_bessel_Jn(1, kr*r0)*int_aux(0, kx, kr, x0, r0, PFC_F_0)\n - 4.0*gsl_sf_bessel_Jn(0, kr*r0)*int_aux(1, kx, kr, x0, r0, PFC_F_0)\n + 4.0*M_PI/(kx*kx + kr*kr)*(1.0 + exp(-kr*x0)*(kx/kr*sin(kx*x0) - cos(kx*x0)));\n }\n else if ((kx < tol) & (kr >= tol)){\n result = int_aux(0, kx, kr, x0, r0, PFC_F_KX);\n }\n else if ((kx >= tol) & (kr < tol)){\n result = int_aux(0, kx, kr, x0, r0, PFC_F_KR);\n }\n else \n result = -2.0*M_PI*( log(r0/(x0 + sqrt(r0*r0 + x0*x0)))\n\t\t\t *r0*r0 + x0*(x0 - sqrt(r0*r0 + x0*x0)));\n \n /* the 1/(4pi) factor is due to the factor on the poissonsolver3d (end)*/\n return result/(4.0*M_PI);\n}\n\n/* --------------------- Interface to Fortran ---------------------- */\ndouble FC_FUNC_(c_poisson_cutoff_3d_1d_finite, C_POISSON_CUTOFF_3D_1D_FINITE)\n (double *gx, double *gperp, double *xsize, double *rsize)\n{\n return poisson_finite_cylinder(*gx, *gperp, *xsize, *rsize);\n}\n\n\n\n\n\n/************************************************************************/\n/************************************************************************/\n/* C_POISSON_CUTOFF_2D_0D */\n/************************************************************************/\n/************************************************************************/\nstatic double bessel_J0(double w, void *p)\n{\n return gsl_sf_bessel_J0(w);\n}\n\n/* --------------------- Interface to Fortran ---------------------- */\ndouble FC_FUNC_(c_poisson_cutoff_2d_0d, C_POISSON_CUTOFF_2D_0D)\n (double *x, double *y)\n{\n double result, error;\n const size_t wrk_size = 500;\n const double epsilon_abs = 1e-3;\n const double epsilon_rel = 1e-3;\n\n gsl_integration_workspace * ws = gsl_integration_workspace_alloc (wrk_size);\n gsl_function F;\n\n F.function = &bessel_J0;\n gsl_integration_qag(&F, *x, *y, epsilon_abs, epsilon_rel, \n \t\t\twrk_size, 3, ws, &result, &error);\n gsl_integration_workspace_free(ws);\n\n return result;\n}\n\n\n\n\n\n/************************************************************************/\n/************************************************************************/\n/* INTCOSLOG */\n/************************************************************************/\n/************************************************************************/\n/* Int_0^mu dy cos(a*y) log(abs(b*y)) = \n (1/a) * (log(|b*mu|)*sin(a*mu) - Si(a*mu) ) */\ndouble FC_FUNC(intcoslog, INTCOSLOG)(double *mu, double *a, double *b)\n{\n if(fabs(*a)>0.0){\n return (1.0/(*a)) * (log((*b)*(*mu))*sin((*a)*(*mu)) - gsl_sf_Si((*a)*(*mu)) );\n }else{\n return (*mu)*(log((*mu)*(*b)) - 1.0);\n }\n}\n\n\n\n\n\n/************************************************************************/\n/************************************************************************/\n/* C_POISSON_CUTOFF_2D_1D */\n/************************************************************************/\n/************************************************************************/\nstruct parameters_2d_1d\n{ \n double gx;\n double gy;\n double rc; \n}; \n\nstatic double cutoff_2d_1d(double w, void *p)\n{\n double k0arg, k0;\n struct parameters_2d_1d *params = (struct parameters_2d_1d *)p;\n double gx = (params->gx);\n double gy = (params->gy);\n\n k0arg = fabs(w*gx);\n if(k0arg < 0.05){\n k0 = - (log(k0arg/2) + M_EULER_MASCHERONI);\n }\n else if(k0arg < 50.0 ){\n k0 = gsl_sf_bessel_K0(k0arg);\n }else{\n k0 = sqrt(2.0*M_PI/k0arg)*exp(-k0arg);\n }\n return 4.0*cos(w*gy)*k0;\n}\n\n\n/* --------------------- Interface to Fortran ---------------------- */\ndouble FC_FUNC_(c_poisson_cutoff_2d_1d, C_POISSON_CUTOFF_2D_1D)\n (double *gy, double *gx, double *rc)\n{\n double result, error, res, b;\n struct parameters_2d_1d params;\n const size_t wrk_size = 5000;\n const double epsilon_abs = 1e-3;\n const double epsilon_rel = 1e-3;\n\n double mu;\n gsl_integration_workspace * ws = gsl_integration_workspace_alloc (wrk_size);\n gsl_function F;\n\n mu = 0.1/(*gx);\n b = fabs((*gx))/2.0;\n\n params.gx = *gx;\n params.gy = *gy;\n params.rc = *rc;\n\n F.function = &cutoff_2d_1d;\n F.params = ¶ms;\n\n res = -4.0 * FC_FUNC(intcoslog, INTCOSLOG)(&mu, gy, &b);\n\n if( fabs(*gy) > 0.0) {\n res = res - (4.0 * M_EULER_MASCHERONI / (*gy)) * sin( (*gy)*mu );\n }else{\n res = res - 4.0 * M_EULER_MASCHERONI * mu;\n }\n \n gsl_integration_qag(&F, mu, (*rc), epsilon_abs, epsilon_rel, \n \t\t\twrk_size, 3, ws, &result, &error);\n res = res + result;\n\n gsl_integration_workspace_free (ws);\n return res;\n}\n\n\n\n\n/************************************************************************/\n/************************************************************************/\n/* C_POISSON_CUTOFF_1D_0D */\n/************************************************************************/\n/************************************************************************/\n\nstruct parameters_1d_0d\n{\n double g;\n double a;\n};\n\nstatic double cutoff_1d_0d(double w, void *p)\n{\n struct parameters_1d_0d *params = (struct parameters_1d_0d *)p;\n double g = (params->g);\n double a = (params->a);\n return 2.0*(cos(w)/sqrt(w*w+a*a*g*g));\n}\n\n\n\n/* --------------------- Interface to Fortran ---------------------- */\ndouble FC_FUNC_(c_poisson_cutoff_1d_0d, C_POISSON_CUTOFF_1D_0D)\n (double *g, double *a, double *rc)\n{\n double result, error;\n struct parameters_1d_0d params;\n const size_t wrk_size = 5000;\n const double epsilon_abs = 1e-3;\n const double epsilon_rel = 1e-3;\n int status;\n gsl_integration_workspace * ws;\n gsl_function F;\n\n if((*g) <= 0.0){return 2.0*asinh((*rc)/(*a));};\n if((*g)*(*rc) > 100.0*M_PI){return 2.0*gsl_sf_bessel_K0((*a)*(*g));};\n\n gsl_set_error_handler_off();\n\n ws = gsl_integration_workspace_alloc (wrk_size);\n\n params.g = *g;\n params.a = *a;\n\n F.function = &cutoff_1d_0d;\n F.params = ¶ms;\n\n status = gsl_integration_qag(&F, 0.0, (*rc)*(*g), epsilon_abs, epsilon_rel, \n wrk_size, 3, ws, &result, &error);\n\n gsl_integration_workspace_free (ws);\n\n if(status){\n return 0.0;\n }else{\n return result;\n }\n\n}\n", "meta": {"hexsha": "0871f593349a1d15bc3684a30f87142c80f03f9e", "size": 10927, "ext": "c", "lang": "C", "max_stars_repo_path": "src/poisson/poisson_cutoffs.c", "max_stars_repo_name": "gimunu/octopus-metric", "max_stars_repo_head_hexsha": "baabccd5402922a2f62f5cf6030d15e7ea76dc9b", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/poisson/poisson_cutoffs.c", "max_issues_repo_name": "gimunu/octopus-metric", "max_issues_repo_head_hexsha": "baabccd5402922a2f62f5cf6030d15e7ea76dc9b", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/poisson/poisson_cutoffs.c", "max_forks_repo_name": "gimunu/octopus-metric", "max_forks_repo_head_hexsha": "baabccd5402922a2f62f5cf6030d15e7ea76dc9b", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.1141439206, "max_line_length": 95, "alphanum_fraction": 0.5555962295, "num_tokens": 3288, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7549149868676284, "lm_q2_score": 0.6757645879592642, "lm_q1q2_score": 0.5101448150448762}} {"text": "/* integration/qawf.c\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000 Brian Gough\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 2 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"initialise.c\"\n#include \"append.c\"\n#include \"qelg.c\"\n\nint\ngsl_integration_qawf (gsl_function * f,\n\t\t const double a,\n\t\t const double epsabs,\n\t\t const size_t limit,\n\t\t gsl_integration_workspace * workspace,\n\t\t gsl_integration_workspace * cycle_workspace,\n\t\t gsl_integration_qawo_table * wf,\n\t\t double *result, double *abserr)\n{\n double area, errsum;\n double res_ext, err_ext;\n double correc, total_error = 0.0, truncation_error;\n\n size_t ktmin = 0;\n size_t iteration = 0;\n\n struct extrapolation_table table;\n\n double cycle;\n double omega = wf->omega;\n\n const double p = 0.9;\n double factor = 1;\n double initial_eps, eps;\n int error_type = 0;\n\n /* Initialize results */\n\n initialise (workspace, a, a);\n\n *result = 0;\n *abserr = 0;\n\n if (limit > workspace->limit)\n {\n GSL_ERROR (\"iteration limit exceeds available workspace\", GSL_EINVAL) ;\n }\n\n /* Test on accuracy */\n\n if (epsabs <= 0)\n {\n GSL_ERROR (\"absolute tolerance epsabs must be positive\", GSL_EBADTOL) ;\n }\n\n if (omega == 0.0)\n {\n if (wf->sine == GSL_INTEG_SINE)\n\t{\n\t /* The function sin(w x) f(x) is always zero for w = 0 */\n\n\t *result = 0;\n\t *abserr = 0;\n\n\t return GSL_SUCCESS;\n\t}\n else\n\t{\n\t /* The function cos(w x) f(x) is always f(x) for w = 0 */\n\n\t int status = gsl_integration_qagiu (f, a, epsabs, 0.0,\n\t\t\t\t\t cycle_workspace->limit,\n\t\t\t\t\t cycle_workspace,\n\t\t\t\t\t result, abserr);\n\t return status;\n\t}\n }\n\n if (epsabs > GSL_DBL_MIN / (1 - p))\n {\n eps = epsabs * (1 - p);\n }\n else\n {\n eps = epsabs;\n }\n\n initial_eps = eps;\n\n area = 0;\n errsum = 0;\n\n res_ext = 0;\n err_ext = GSL_DBL_MAX;\n correc = 0;\n\n cycle = (2 * floor (fabs (omega)) + 1) * M_PI / fabs (omega);\n\n gsl_integration_qawo_table_set_length (wf, cycle);\n\n initialise_table (&table);\n\n for (iteration = 0; iteration < limit; iteration++)\n {\n double area1, error1, reseps, erreps;\n\n double a1 = a + iteration * cycle;\n double b1 = a1 + cycle;\n\n double epsabs1 = eps * factor;\n\n int status = gsl_integration_qawo (f, a1, epsabs1, 0.0, limit,\n\t\t\t\t\t cycle_workspace, wf,\n\t\t\t\t\t &area1, &error1);\n\n append_interval (workspace, a1, b1, area1, error1);\n\n factor *= p;\n\n area = area + area1;\n errsum = errsum + error1;\n\n /* estimate the truncation error as 50 times the final term */\n\n truncation_error = 50 * fabs (area1);\n\n total_error = errsum + truncation_error;\n\n if (total_error < epsabs && iteration > 4)\n\t{\n\t goto compute_result;\n\t}\n\n if (error1 > correc)\n\t{\n\t correc = error1;\n\t}\n\n if (status)\n\t{\n\t eps = GSL_MAX_DBL (initial_eps, correc * (1.0 - p));\n\t}\n\n if (status && total_error < 10 * correc && iteration > 3)\n\t{\n\t goto compute_result;\n\t}\n\n append_table (&table, area);\n\n if (table.n < 2)\n\t{\n\t continue;\n\t}\n\n qelg (&table, &reseps, &erreps);\n\n ktmin++;\n\n if (ktmin >= 15 && err_ext < 0.001 * total_error)\n\t{\n\t error_type = 4;\n\t}\n\n if (erreps < err_ext)\n\t{\n\t ktmin = 0;\n\t err_ext = erreps;\n\t res_ext = reseps;\n\n\t if (err_ext + 10 * correc <= epsabs)\n\t break;\n\t if (err_ext <= epsabs && 10 * correc >= epsabs)\n\t break;\n\t}\n\n }\n\n if (iteration == limit)\n error_type = 1;\n\n if (err_ext == GSL_DBL_MAX)\n goto compute_result;\n\n err_ext = err_ext + 10 * correc;\n\n *result = res_ext;\n *abserr = err_ext;\n\n if (error_type == 0)\n {\n return GSL_SUCCESS ;\n }\n\n if (res_ext != 0.0 && area != 0.0)\n {\n if (err_ext / fabs (res_ext) > errsum / fabs (area))\n\tgoto compute_result;\n }\n else if (err_ext > errsum)\n {\n goto compute_result;\n }\n else if (area == 0.0)\n {\n goto return_error;\n }\n\n if (error_type == 4)\n {\n err_ext = err_ext + truncation_error;\n }\n\n goto return_error;\n\ncompute_result:\n\n *result = area;\n *abserr = total_error;\n\nreturn_error:\n\n if (error_type > 2)\n error_type--;\n\n if (error_type == 0)\n {\n return GSL_SUCCESS;\n }\n else if (error_type == 1)\n {\n GSL_ERROR (\"number of iterations was insufficient\", GSL_EMAXITER);\n }\n else if (error_type == 2)\n {\n GSL_ERROR (\"cannot reach tolerance because of roundoff error\",\n\t\t GSL_EROUND);\n }\n else if (error_type == 3)\n {\n GSL_ERROR (\"bad integrand behavior found in the integration interval\",\n\t\t GSL_ESING);\n }\n else if (error_type == 4)\n {\n GSL_ERROR (\"roundoff error detected in the extrapolation table\",\n\t\t GSL_EROUND);\n }\n else if (error_type == 5)\n {\n GSL_ERROR (\"integral is divergent, or slowly convergent\",\n\t\t GSL_EDIVERGE);\n }\n else\n {\n GSL_ERROR (\"could not integrate function\", GSL_EFAILED);\n }\n\n}\n\n", "meta": {"hexsha": "134fd8c5f0a9807e8ccf16168566bd5f5645c486", "size": 5668, "ext": "c", "lang": "C", "max_stars_repo_path": "code/em/treba/gsl-1.0/integration/qawf.c", "max_stars_repo_name": "ICML14MoMCompare/spectral-learn", "max_stars_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-12-18T18:09:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-10T11:31:28.000Z", "max_issues_repo_path": "code/em/treba/gsl-1.0/integration/qawf.c", "max_issues_repo_name": "ICML14MoMCompare/spectral-learn", "max_issues_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "code/em/treba/gsl-1.0/integration/qawf.c", "max_forks_repo_name": "ICML14MoMCompare/spectral-learn", "max_forks_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2015-10-02T01:32:59.000Z", "max_forks_repo_forks_event_max_datetime": "2015-10-02T01:32:59.000Z", "avg_line_length": 20.0992907801, "max_line_length": 77, "alphanum_fraction": 0.609738885, "num_tokens": 1651, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7662936430859597, "lm_q2_score": 0.665410558746814, "lm_q1q2_score": 0.5098998812099601}} {"text": "//This does CELL (~soma) stage of LSTM (long short-term memory) model.\n//This requires each neuron to have 4 input time series, Xc, Xi, Xf, Xo,\n//where Xc is the usual (or \"cellular\") input and Xi, Xf, Xo the inputs for the input, forget, output gates.\n//Xc, Xi, Xf, Xo are the output of separate linear IN stages (weights and baises).\n\n//For dim=0, C[:,t] = tanh{Xc[:,t] + Uc*Y[:,t-1]} \\n\";\n// I[:,t] = sig{Xi[:,t] + Ui*Y[:,t-1]} \\n\";\n// F[:,t] = sig{Xf[:,t] + Uf*Y[:,t-1]} \\n\";\n// O[:,t] = sig{Xo[:,t] + Uo*Y[:,t-1]} \\n\";\n// H[:,t] = I[:,t].*C[:,t] + F[:,t].*H[:,t-1] \\n\";\n// Y[:,t] = O[:,t].*tanh{H[:,t]} \\n\";\n//with sizes Xc, Xi, Xf, Xo: N x T \\n\";\n// Uc, Ui, Uf, Uo: N x N \\n\";\n// Y : N x T \\n\";\n//\n//For dim=1, C[t,:] = tanh{Xc[t,:] + Y[t-1,:]*Uc} \\n\";\n// I[t,:] = sig{Xi[t,:] + Y[t-1,:]*Ui} \\n\";\n// F[t,:] = sig{Xf[t,:] + Y[t-1,:]*Uf} \\n\";\n// O[t,:] = sig{Xo[t,:] + Y[t-1,:]*Uo} \\n\";\n// H[t,:] = I[t,:].*C[t,:] + F[t,:].*H[t-1,:] \\n\";\n// Y[t,:] = O[t,:].*tanh{H[t,:]} \\n\";\n//with sizes Xc, Xi, Xf, Xo: T x N \\n\";\n// Uc, Ui, Uf, Uo: N x N \\n\";\n// Y : T x N \\n\";\n//\n//where sig is the logistic (sigmoid) nonlinearity = 1/(1+exp(-x)),\n//I is the input gate, F is the forget gate, O is the output gate,\n//C is the \"cell input activation vector\",\n//H is an intermediate (hidden) vector (sometimes called the \"cell state vector\"),\n//Uc, Ui, Uf, Uo are NxN matrices, and Y is the final output (sometimes called the \"hidden state vector\").\n\n//Note that, the neurons of a layer are independent only if Uc, Ui, Uf, Uo are diagonal matrices.\n//This is only really a CELL (~soma) stage in that case.\n\n#include \n#include \n#include \n#include \n\n#ifdef I\n #undef I\n#endif\n\n#ifdef __cplusplus\nnamespace codee {\nextern \"C\" {\n#endif\n\nint lstm4_s (float *Y, const float *Xc, const float *Xi, const float *Xf, const float *Xo, const float *Uc, const float *Ui, const float *Uf, const float *Uo, const size_t N, const size_t T, const char iscolmajor, const size_t dim);\nint lstm4_d (double *Y, const double *Xc, const double *Xi, const double *Xf, const double *Xo, const double *Uc, const double *Ui, const double *Uf, const double *Uo, const size_t N, const size_t T, const char iscolmajor, const size_t dim);\n\nint lstm4_inplace_s (float *Xc, const float *Xi, const float *Xf, const float *Xo, const float *Uc, const float *Ui, const float *Uf, const float *Uo, const size_t N, const size_t T, const char iscolmajor, const size_t dim);\nint lstm4_inplace_d (double *Xc, const double *Xi, const double *Xf, const double *Xo, const double *Uc, const double *Ui, const double *Uf, const double *Uo, const size_t N, const size_t T, const char iscolmajor, const size_t dim);\n\n\nint lstm4_s (float *Y, const float *Xc, const float *Xi, const float *Xf, const float *Xo, const float *Uc, const float *Ui, const float *Uf, const float *Uo, const size_t N, const size_t T, const char iscolmajor, const size_t dim)\n{\n const float o = 1.0f;\n size_t nT, tN;\n\n float *C, *I, *F, *O, *H;\n if (!(C=(float *)malloc(N*sizeof(float)))) { fprintf(stderr,\"error in lstm4_s: problem with malloc. \"); perror(\"malloc\"); return 1; }\n if (!(I=(float *)malloc(N*sizeof(float)))) { fprintf(stderr,\"error in lstm4_s: problem with malloc. \"); perror(\"malloc\"); return 1; }\n if (!(F=(float *)malloc(N*sizeof(float)))) { fprintf(stderr,\"error in lstm4_s: problem with malloc. \"); perror(\"malloc\"); return 1; }\n if (!(O=(float *)malloc(N*sizeof(float)))) { fprintf(stderr,\"error in lstm4_s: problem with malloc. \"); perror(\"malloc\"); return 1; }\n if (!(H=(float *)malloc(N*sizeof(float)))) { fprintf(stderr,\"error in lstm4_s: problem with malloc. \"); perror(\"malloc\"); return 1; }\n\n if (N==1u)\n {\n //C[0] = tanhf(Xc[0]);\n //I[0] = 1.0f / (1.0f+expf(-Xi[0]));\n //F[0] = 1.0f / (1.0f+expf(-Xf[0]));\n //O[0] = 1.0f / (1.0f+expf(-Xo[0]));\n //H[0] = I[0] * C[0];\n //Y[0] = O[0] * tanhf(H[0]);\n H[0] = tanhf(Xc[0]) / (1.0f+expf(-Xi[0]));\n Y[0] = tanhf(H[0]) / (1.0f+expf(-Xo[0]));\n for (size_t t=1; t\n#include \n#include \n\nusing namespace std;\n\nnamespace openworld {\n class BayesianMerge {\n public:\n // modifies means in-place to assure maximum likelihood\n static void mergeGaussianHierarchy(vector lows, GaussianDistribution* high) {\n vector A, b;\n for (unsigned ii = 0; ii < lows.size(); ii++) {\n for (unsigned jj = 0; jj < lows.size(); jj++) {\n if (ii == jj)\n A.push_back(1 / lows[ii]->getVariance() + 1 / high->getVariance());\n else\n A.push_back(1 / high->getVariance());\n }\n\n b.push_back(lows[ii]->getMean() / lows[ii]->getVariance() + high->getMean() / high->getVariance());\n }\n\n gsl_matrix_view Amat = gsl_matrix_view_array(A.data(), lows.size(), lows.size());\n gsl_vector_view bmat = gsl_vector_view_array(b.data(), lows.size());\n gsl_vector* x = gsl_vector_alloc(lows.size());\n\n int s;\n \n gsl_permutation* p = gsl_permutation_alloc(lows.size());\n \n gsl_linalg_LU_decomp(&Amat.matrix, p, &s);\n gsl_linalg_LU_solve(&Amat.matrix, p, &bmat.vector, x);\n \n double meansum = 0;\n for (unsigned ii = 0; ii < lows.size(); ii++) {\n meansum += gsl_vector_get(x, ii);\n lows[ii]->setMean(gsl_vector_get(x, ii));\n }\n\n high->setMean(meansum);\n \n gsl_permutation_free(p);\n gsl_vector_free(x);\n }\n };\n}\n\n#endif\n", "meta": {"hexsha": "afaba62567f9b9374ec8de2a2e49207435706c2d", "size": 1531, "ext": "h", "lang": "C", "max_stars_repo_path": "multi/BayesianMerge.h", "max_stars_repo_name": "jrising/openworld", "max_stars_repo_head_hexsha": "fcd51a705f3a57100680b911347cbf189998d264", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "multi/BayesianMerge.h", "max_issues_repo_name": "jrising/openworld", "max_issues_repo_head_hexsha": "fcd51a705f3a57100680b911347cbf189998d264", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2015-12-05T00:33:30.000Z", "max_issues_repo_issues_event_max_datetime": "2015-12-05T00:33:30.000Z", "max_forks_repo_path": "multi/BayesianMerge.h", "max_forks_repo_name": "jrising/openworld", "max_forks_repo_head_hexsha": "fcd51a705f3a57100680b911347cbf189998d264", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 28.8867924528, "max_line_length": 107, "alphanum_fraction": 0.6126714566, "num_tokens": 405, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8887587993853654, "lm_q2_score": 0.5736784074525096, "lm_q1q2_score": 0.5098617326408009}} {"text": "/**\n *\n * @file core_dpotrf.c\n *\n * PLASMA core_blas kernel\n * PLASMA is a software package provided by Univ. of Tennessee,\n * Univ. of California Berkeley and Univ. of Colorado Denver\n *\n * @version 2.6.0\n * @author Hatem Ltaief\n * @author Mathieu Faverge\n * @author Jakub Kurzak\n * @date 2010-11-15\n * @generated d Tue Jan 7 11:44:45 2014\n *\n **/\n#include \n#include \"common.h\"\n\n/***************************************************************************//**\n *\n * @ingroup CORE_double\n *\n * CORE_dpotrf - Computes the Cholesky factorization of a symmetric positive definite\n * (or Hermitian positive definite in the complex case) matrix A.\n * The factorization has the form\n *\n * \\f[ A = \\{_{L\\times L^H, if uplo = PlasmaLower}^{U^H\\times U, if uplo = PlasmaUpper} \\f]\n *\n * where U is an upper triangular matrix and L is a lower triangular matrix.\n *\n *******************************************************************************\n *\n * @param[in] uplo\n * = PlasmaUpper: Upper triangle of A is stored;\n * = PlasmaLower: Lower triangle of A is stored.\n *\n * @param[in] N\n * The order of the matrix A. N >= 0.\n *\n\n * @param[in,out] A\n * On entry, the symmetric positive definite (or Hermitian) matrix A.\n * If uplo = PlasmaUpper, the leading N-by-N upper triangular part of A\n * contains the upper triangular part of the matrix A, and the strictly\n * lower triangular part of A is not referenced.\n * If UPLO = 'L', the leading N-by-N lower triangular part of A\n * contains the lower triangular part of the matrix A, and the strictly\n * upper triangular part of A is not referenced.\n * On exit, if return value = 0, the factor U or L from the Cholesky\n * factorization A = U**T*U or A = L*L**T.\n *\n * @param[in] LDA\n * The leading dimension of the array A. LDA >= max(1,N).\n *\n * @param[out] info\n * - 0 on successful exit\n * - <0 if -i, the i-th argument had an illegal value\n * - >0 if i, the leading minor of order i of A is not positive\n * definite, so the factorization could not be completed, and the\n * solution has not been computed.\n *\n ******************************************************************************/\n#if defined(PLASMA_HAVE_WEAK)\n#pragma weak CORE_dpotrf = PCORE_dpotrf\n#define CORE_dpotrf PCORE_dpotrf\n#endif\nvoid CORE_dpotrf(PLASMA_enum uplo, int N, double *A, int LDA, int *info)\n{\n *info = LAPACKE_dpotrf_work(\n LAPACK_COL_MAJOR,\n lapack_const(uplo),\n N, A, LDA );\n}\n", "meta": {"hexsha": "8c16a7735cac30daafa7060de3e125d6f2939fff", "size": 2617, "ext": "c", "lang": "C", "max_stars_repo_path": "core_blas/core_dpotrf.c", "max_stars_repo_name": "zhuangsc/Plasma-ompss1", "max_stars_repo_head_hexsha": "bcc99c164a256bc7df7c936b9c43afd38c12aea2", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "core_blas/core_dpotrf.c", "max_issues_repo_name": "zhuangsc/Plasma-ompss1", "max_issues_repo_head_hexsha": "bcc99c164a256bc7df7c936b9c43afd38c12aea2", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "core_blas/core_dpotrf.c", "max_forks_repo_name": "zhuangsc/Plasma-ompss1", "max_forks_repo_head_hexsha": "bcc99c164a256bc7df7c936b9c43afd38c12aea2", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 34.8933333333, "max_line_length": 94, "alphanum_fraction": 0.576614444, "num_tokens": 682, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7956581049086031, "lm_q2_score": 0.6406358479787609, "lm_q1q2_score": 0.5097271047392969}} {"text": "// Copyright (c) 2013-2017 Anton Kozhevnikov, Thomas Schulthess\n// All rights reserved.\n// \n// Redistribution and use in source and binary forms, with or without modification, are permitted provided that \n// the following conditions are met:\n// \n// 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the \n// following disclaimer.\n// 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions \n// and the following disclaimer in the documentation and/or other materials provided with the distribution.\n// \n// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND ANY EXPRESS OR IMPLIED \n// WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A \n// PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR \n// ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, \n// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER \n// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR \n// OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n\n/** \\file sht.h\n * \n * \\brief Contains declaration and particular implementation of sirius::SHT class.\n */\n\n#ifndef __SHT_H__\n#define __SHT_H__\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \"typedefs.h\"\n#include \"utils.h\"\n#include \"linalg.hpp\"\n#include \"LebedevLaikov.h\"\n\nnamespace sirius\n{\n\n/// Spherical harmonics transformation.\nclass SHT // TODO: better name\n{\n private:\n\n int lmax_;\n\n int lmmax_;\n\n int num_points_;\n\n mdarray coord_;\n\n mdarray tp_;\n\n std::vector w_;\n\n /// backward transformation from Ylm to spherical coordinates\n mdarray ylm_backward_;\n \n /// forward transformation from spherical coordinates to Ylm\n mdarray ylm_forward_;\n \n /// backward transformation from Rlm to spherical coordinates\n mdarray rlm_backward_;\n\n /// forward transformation from spherical coordinates to Rlm\n mdarray rlm_forward_;\n\n int mesh_type_;\n\n public:\n \n /// Default constructor.\n SHT(int lmax__) \n : lmax_(lmax__), mesh_type_(0)\n {\n lmmax_ = (lmax_ + 1) * (lmax_ + 1);\n \n if (mesh_type_ == 0) num_points_ = Lebedev_Laikov_npoint(2 * lmax_);\n if (mesh_type_ == 1) num_points_ = lmmax_;\n \n std::vector x(num_points_);\n std::vector y(num_points_);\n std::vector z(num_points_);\n \n coord_ = mdarray(3, num_points_);\n \n tp_ = mdarray(2, num_points_);\n \n w_.resize(num_points_);\n \n if (mesh_type_ == 0) Lebedev_Laikov_sphere(num_points_, &x[0], &y[0], &z[0], &w_[0]);\n if (mesh_type_ == 1) uniform_coverage();\n \n ylm_backward_ = mdarray(lmmax_, num_points_);\n \n ylm_forward_ = mdarray(num_points_, lmmax_);\n \n rlm_backward_ = mdarray(lmmax_, num_points_);\n \n rlm_forward_ = mdarray(num_points_, lmmax_);\n \n for (int itp = 0; itp < num_points_; itp++)\n {\n if (mesh_type_ == 0)\n {\n coord_(0, itp) = x[itp];\n coord_(1, itp) = y[itp];\n coord_(2, itp) = z[itp];\n \n auto vs = spherical_coordinates(vector3d(x[itp], y[itp], z[itp]));\n spherical_harmonics(lmax_, vs[1], vs[2], &ylm_backward_(0, itp));\n spherical_harmonics(lmax_, vs[1], vs[2], &rlm_backward_(0, itp));\n for (int lm = 0; lm < lmmax_; lm++)\n {\n ylm_forward_(itp, lm) = conj(ylm_backward_(lm, itp)) * w_[itp] * fourpi;\n rlm_forward_(itp, lm) = rlm_backward_(lm, itp) * w_[itp] * fourpi;\n }\n }\n if (mesh_type_ == 1)\n {\n double t = tp_(0, itp);\n double p = tp_(1, itp);\n \n coord_(0, itp) = sin(t) * cos(p);\n coord_(1, itp) = sin(t) * sin(p);\n coord_(2, itp) = cos(t);\n \n spherical_harmonics(lmax_, t, p, &ylm_backward_(0, itp));\n spherical_harmonics(lmax_, t, p, &rlm_backward_(0, itp));\n \n for (int lm = 0; lm < lmmax_; lm++)\n {\n ylm_forward_(lm, itp) = ylm_backward_(lm, itp);\n rlm_forward_(lm, itp) = rlm_backward_(lm, itp);\n }\n }\n }\n \n if (mesh_type_ == 1)\n {\n linalg::geinv(lmmax_, ylm_forward_);\n linalg::geinv(lmmax_, rlm_forward_);\n }\n \n #if (__VERIFICATION > 0)\n {\n double dr = 0;\n double dy = 0;\n \n for (int lm = 0; lm < lmmax_; lm++)\n {\n for (int lm1 = 0; lm1 < lmmax_; lm1++)\n {\n double t = 0;\n double_complex zt(0, 0);\n for (int itp = 0; itp < num_points_; itp++)\n {\n zt += ylm_forward_(itp, lm) * ylm_backward_(lm1, itp);\n t += rlm_forward_(itp, lm) * rlm_backward_(lm1, itp);\n }\n \n if (lm == lm1) \n {\n zt -= 1.0;\n t -= 1.0;\n }\n dr += std::abs(t);\n dy += std::abs(zt);\n }\n }\n dr = dr / lmmax_ / lmmax_;\n dy = dy / lmmax_ / lmmax_;\n \n if (dr > 1e-15 || dy > 1e-15)\n {\n std::stringstream s;\n s << \"spherical mesh error is too big\" << std::endl\n << \" real spherical integration error \" << dr << std::endl\n << \" complex spherical integration error \" << dy;\n WARNING(s.str())\n }\n \n std::vector flm(lmmax_);\n std::vector ftp(num_points_);\n for (int lm = 0; lm < lmmax_; lm++)\n {\n std::memset(&flm[0], 0, lmmax_ * sizeof(double));\n flm[lm] = 1.0;\n backward_transform(lmmax_, &flm[0], 1, lmmax_, &ftp[0]);\n forward_transform(&ftp[0], 1, lmmax_, lmmax_, &flm[0]);\n flm[lm] -= 1.0;\n \n double t = 0.0;\n for (int lm1 = 0; lm1 < lmmax_; lm1++) t += std::abs(flm[lm1]);\n \n t /= lmmax_;\n \n if (t > 1e-15) \n {\n std::stringstream s;\n s << \"test of backward / forward real SHT failed\" << std::endl\n << \" total error \" << t;\n WARNING(s.str());\n }\n }\n }\n #endif\n }\n\n /// Perform a backward transformation from spherical harmonics to spherical coordinates.\n /** \\f[\n * f(\\theta, \\phi, r) = \\sum_{\\ell m} f_{\\ell m}(r) Y_{\\ell m}(\\theta, \\phi)\n * \\f]\n *\n * \\param [in] ld Size of leading dimension of flm.\n * \\param [in] flm Raw pointer to \\f$ f_{\\ell m}(r) \\f$.\n * \\param [in] nr Number of radial points.\n * \\param [in] lmmax Maximum number of lm- harmonics to take into sum.\n * \\param [out] ftp Raw pointer to \\f$ f(\\theta, \\phi, r) \\f$.\n */\n template \n void backward_transform(int ld, T const* flm, int nr, int lmmax, T* ftp);\n \n /// Perform a forward transformation from spherical coordinates to spherical harmonics.\n /** \\f[\n * f_{\\ell m}(r) = \\iint f(\\theta, \\phi, r) Y_{\\ell m}^{*}(\\theta, \\phi) \\sin \\theta d\\phi d\\theta = \n * \\sum_{i} f(\\theta_i, \\phi_i, r) Y_{\\ell m}^{*}(\\theta_i, \\phi_i) w_i\n * \\f]\n *\n * \\param [in] ftp Raw pointer to \\f$ f(\\theta, \\phi, r) \\f$.\n * \\param [in] nr Number of radial points.\n * \\param [in] lmmax Maximum number of lm- coefficients to generate.\n * \\param [in] ld Size of leading dimension of flm.\n * \\param [out] flm Raw pointer to \\f$ f_{\\ell m}(r) \\f$.\n */\n template \n void forward_transform(T const* ftp, int nr, int lmmax, int ld, T* flm);\n \n /// Convert form Rlm to Ylm representation.\n static void convert(int lmax__, double const* f_rlm__, double_complex* f_ylm__);\n\n /// Convert from Ylm to Rlm representation.\n static void convert(int lmax__, double_complex const* f_ylm__, double* f_rlm__);\n\n //void rlm_forward_iterative_transform(double *ftp__, int lmmax, int ncol, double* flm)\n //{\n // Timer t(\"sirius::SHT::rlm_forward_iterative_transform\");\n // \n // assert(lmmax <= lmmax_);\n\n // mdarray ftp(ftp__, num_points_, ncol);\n // mdarray ftp1(num_points_, ncol);\n // \n // blas::gemm(1, 0, lmmax, ncol, num_points_, 1.0, &rlm_forward_(0, 0), num_points_, &ftp(0, 0), num_points_, 0.0, \n // flm, lmmax);\n // \n // for (int i = 0; i < 2; i++)\n // {\n // rlm_backward_transform(flm, lmmax, ncol, &ftp1(0, 0));\n // double tdiff = 0.0;\n // for (int ir = 0; ir < ncol; ir++)\n // {\n // for (int itp = 0; itp < num_points_; itp++) \n // {\n // ftp1(itp, ir) = ftp(itp, ir) - ftp1(itp, ir);\n // //tdiff += fabs(ftp1(itp, ir));\n // }\n // }\n // \n // for (int itp = 0; itp < num_points_; itp++) \n // {\n // tdiff += fabs(ftp1(itp, ncol - 1));\n // }\n // std::cout << \"iter : \" << i << \" avg. MT diff = \" << tdiff / num_points_ << std::endl;\n // blas::gemm(1, 0, lmmax, ncol, num_points_, 1.0, &rlm_forward_(0, 0), num_points_, &ftp1(0, 0), num_points_, 1.0, \n // flm, lmmax);\n // }\n //}\n\n /// Transform Cartesian coordinates [x,y,z] to spherical coordinates [r,theta,phi]\n static vector3d spherical_coordinates(vector3d vc);\n\n /// Generate complex spherical harmonics Ylm\n static void spherical_harmonics(int lmax, double theta, double phi, double_complex* ylm);\n \n /// Generate real spherical harmonics Rlm\n /** Mathematica code:\n * \\verbatim\n * R[l_, m_, th_, ph_] := \n * If[m > 0, std::sqrt[2]*ComplexExpand[Re[SphericalHarmonicY[l, m, th, ph]]], \n * If[m < 0, std::sqrt[2]*ComplexExpand[Im[SphericalHarmonicY[l, m, th, ph]]], \n * If[m == 0, ComplexExpand[Re[SphericalHarmonicY[l, 0, th, ph]]]]]]\n * \\endverbatim\n */\n static void spherical_harmonics(int lmax, double theta, double phi, double* rlm);\n \n /// Compute element of the transformation matrix from complex to real spherical harmonics. \n /** Real spherical harmonic can be written as a linear combination of complex harmonics:\n *\n * \\f[\n * R_{\\ell m}(\\theta, \\phi) = \\sum_{m'} a^{\\ell}_{m' m}Y_{\\ell m'}(\\theta, \\phi)\n * \\f]\n * where \n * \\f[\n * a^{\\ell}_{m' m} = \\langle Y_{\\ell m'} | R_{\\ell m} \\rangle\n * \\f]\n *\n * Transformation from real to complex spherical harmonics is conjugate transpose:\n * \n * \\f[\n * Y_{\\ell m}(\\theta, \\phi) = \\sum_{m'} a^{\\ell*}_{m m'}R_{\\ell m'}(\\theta, \\phi)\n * \\f]\n *\n * Mathematica code:\n * \\verbatim\n * b[m1_, m2_] := \n * If[m1 == 0, 1, \n * If[m1 < 0 && m2 < 0, -I/std::sqrt[2], \n * If[m1 > 0 && m2 < 0, (-1)^m1*I/std::sqrt[2], \n * If[m1 < 0 && m2 > 0, (-1)^m2/std::sqrt[2], \n * If[m1 > 0 && m2 > 0, 1/std::sqrt[2]]]]]]\n * \n * a[m1_, m2_] := If[Abs[m1] == Abs[m2], b[m1, m2], 0]\n * \n * R[l_, m_, t_, p_] := Sum[a[m1, m]*SphericalHarmonicY[l, m1, t, p], {m1, -l, l}]\n * \\endverbatim\n */\n static inline double_complex ylm_dot_rlm(int l, int m1, int m2)\n {\n const double isqrt2 = 0.70710678118654752440;\n\n assert(l >= 0 && std::abs(m1) <= l && std::abs(m2) <= l);\n\n if (!((m1 == m2) || (m1 == -m2))) {\n return double_complex(0, 0);\n }\n\n if (m1 == 0) {\n return double_complex(1, 0);\n }\n\n if (m1 < 0) {\n if (m2 < 0) {\n return -double_complex(0, isqrt2);\n } else {\n return std::pow(-1.0, m2) * double_complex(isqrt2, 0);\n }\n } else {\n if (m2 < 0) {\n return pow(-1.0, m1) * double_complex(0, isqrt2);\n } else {\n return double_complex(isqrt2, 0);\n }\n }\n }\n\n static inline double_complex rlm_dot_ylm(int l, int m1, int m2)\n {\n return std::conj(ylm_dot_rlm(l, m2, m1));\n }\n\n /// Gaunt coefficent of three complex spherical harmonics.\n /** \n * \\f[\n * \\langle Y_{\\ell_1 m_1} | Y_{\\ell_2 m_2} | Y_{\\ell_3 m_3} \\rangle\n * \\f]\n */\n static double gaunt_ylm(int l1, int l2, int l3, int m1, int m2, int m3);\n\n /// Gaunt coefficent of three real spherical harmonics.\n /** \n * \\f[\n * \\langle R_{\\ell_1 m_1} | R_{\\ell_2 m_2} | R_{\\ell_3 m_3} \\rangle\n * \\f]\n */\n static double gaunt_rlm(int l1, int l2, int l3, int m1, int m2, int m3);\n\n /// Gaunt coefficent of two complex and one real spherical harmonics.\n /** \n * \\f[\n * \\langle Y_{\\ell_1 m_1} | R_{\\ell_2 m_2} | Y_{\\ell_3 m_3} \\rangle\n * \\f]\n */\n static double_complex gaunt_hybrid(int l1, int l2, int l3, int m1, int m2, int m3);\n\n void uniform_coverage();\n\n /// Return Clebsch-Gordan coefficient.\n /** Clebsch-Gordan coefficients arise when two angular momenta are combined into a\n * total angular momentum. \n */\n static inline double clebsch_gordan(int l1, int l2, int l3, int m1, int m2, int m3)\n {\n assert(l1 >= 0);\n assert(l2 >= 0);\n assert(l3 >= 0);\n assert(m1 >= -l1 && m1 <= l1);\n assert(m2 >= -l2 && m2 <= l2);\n assert(m3 >= -l3 && m3 <= l3);\n\n return pow(-1, l1 - l2 + m3) * sqrt(double(2 * l3 + 1)) * \n gsl_sf_coupling_3j(2 * l1, 2 * l2, 2 * l3, 2 * m1, 2 * m2, -2 * m3);\n }\n\n inline double_complex ylm_backward(int lm, int itp)\n {\n return ylm_backward_(lm, itp);\n }\n \n inline double rlm_backward(int lm, int itp)\n {\n return rlm_backward_(lm, itp);\n }\n\n inline double coord(int x, int itp)\n {\n return coord_(x, itp);\n }\n\n inline int num_points()\n {\n return num_points_;\n }\n\n inline int lmax()\n {\n return lmax_;\n }\n\n inline int lmmax()\n {\n return lmmax_;\n }\n\n static void wigner_d_matrix(int l, double beta, mdarray& d_mtrx__)\n {\n long double cos_b2 = std::cos((long double)beta / 2.0L);\n long double sin_b2 = std::sin((long double)beta / 2.0L);\n \n for (int m1 = -l; m1 <= l; m1++)\n {\n for (int m2 = -l; m2 <= l; m2++)\n {\n long double d = 0;\n for (int j = 0; j <= std::min(l + m1, l - m2); j++)\n {\n if ((l - m2 - j) >= 0 && (l + m1 - j) >= 0 && (j + m2 - m1) >= 0)\n {\n long double g = (std::sqrt(Utils::factorial(l + m1)) / Utils::factorial(l - m2 - j)) *\n (std::sqrt(Utils::factorial(l - m1)) / Utils::factorial(l + m1 - j)) * \n (std::sqrt(Utils::factorial(l - m2)) / Utils::factorial(j + m2 - m1)) * \n (std::sqrt(Utils::factorial(l + m2)) / Utils::factorial(j));\n d += g * std::pow(-1, j) * std::pow(cos_b2, 2 * l + m1 - m2 - 2 * j) * std::pow(sin_b2, 2 * j + m2 - m1);\n }\n }\n d_mtrx__(m1 + l, m2 + l) = (double)d;\n }\n }\n }\n\n static void rotation_matrix_l(int l, vector3d euler_angles, int proper_rotation, \n double_complex* rot_mtrx__, int ld)\n {\n mdarray rot_mtrx(rot_mtrx__, ld, 2 * l + 1);\n\n mdarray d_mtrx(2 * l + 1, 2 * l + 1);\n wigner_d_matrix(l, euler_angles[1], d_mtrx);\n\n for (int m1 = -l; m1 <= l; m1++)\n {\n for (int m2 = -l; m2 <= l; m2++)\n {\n rot_mtrx(m1 + l, m2 + l) = std::exp(double_complex(0, -euler_angles[0] * m1 - euler_angles[2] * m2)) * \n d_mtrx(m1 + l, m2 + l) * std::pow(proper_rotation, l);\n }\n }\n }\n\n static void rotation_matrix_l(int l, vector3d euler_angles, int proper_rotation, \n double* rot_mtrx__, int ld)\n {\n mdarray rot_mtrx_rlm(rot_mtrx__, ld, 2 * l + 1);\n mdarray rot_mtrx_ylm(2 * l + 1, 2 * l + 1);\n\n mdarray d_mtrx(2 * l + 1, 2 * l + 1);\n wigner_d_matrix(l, euler_angles[1], d_mtrx);\n\n for (int m1 = -l; m1 <= l; m1++)\n {\n for (int m2 = -l; m2 <= l; m2++)\n {\n rot_mtrx_ylm(m1 + l, m2 + l) = std::exp(double_complex(0, -euler_angles[0] * m1 - euler_angles[2] * m2)) * \n d_mtrx(m1 + l, m2 + l) * std::pow(proper_rotation, l);\n }\n }\n for (int m1 = -l; m1 <= l; m1++)\n {\n auto i13 = (m1 == 0) ? std::vector({0}) : std::vector({-m1, m1});\n\n for (int m2 = -l; m2 <= l; m2++)\n {\n auto i24 = (m2 == 0) ? std::vector({0}) : std::vector({-m2, m2});\n\n for (int m3: i13)\n {\n for (int m4: i24)\n {\n rot_mtrx_rlm(m1 + l, m2 + l) += std::real(rlm_dot_ylm(l, m1, m3) *\n rot_mtrx_ylm(m3 + l, m4 + l) *\n ylm_dot_rlm(l, m4, m2));\n }\n }\n }\n }\n }\n\n static void rotation_matrix(int lmax, vector3d euler_angles, int proper_rotation, \n mdarray& rotm)\n {\n rotm.zero();\n\n for (int l = 0; l <= lmax; l++)\n {\n rotation_matrix_l(l, euler_angles, proper_rotation, &rotm(l * l, l * l), rotm.ld());\n }\n }\n\n static void rotation_matrix(int lmax, vector3d euler_angles, int proper_rotation, \n mdarray& rotm)\n {\n rotm.zero();\n\n for (int l = 0; l <= lmax; l++)\n {\n rotation_matrix_l(l, euler_angles, proper_rotation, &rotm(l * l, l * l), rotm.ld());\n }\n }\n\n /// Compute derivative of real-spherical harmonic with respect to theta angle.\n static double dRlm_dtheta(int lm, double theta, double phi)\n {\n switch (lm) {\n case 0: return 0;\n \n case 1: return -(std::sqrt(3/pi)*std::cos(theta)*std::sin(phi))/2.;\n \n case 2: return -(std::sqrt(3/pi)*std::sin(theta))/2.;\n \n case 3: return -(std::sqrt(3/pi)*std::cos(phi)*std::cos(theta))/2.;\n \n case 4: return -(std::sqrt(15/pi)*std::cos(phi)*std::cos(theta)*std::sin(phi)*std::sin(theta));\n \n case 5: return -(std::sqrt(15/pi)*std::cos(2*theta)*std::sin(phi))/2.;\n \n case 6: return (-3*std::sqrt(5/pi)*std::cos(theta)*std::sin(theta))/2.;\n \n case 7: return -(std::sqrt(15/pi)*std::cos(phi)*std::cos(2*theta))/2.;\n \n case 8: return (std::sqrt(15/pi)*std::cos(2*phi)*std::sin(2*theta))/4.;\n \n case 9: return (-3*std::sqrt(35/(2.*pi))*std::cos(theta)*std::sin(3*phi)*std::pow(std::sin(theta),2))/4.;\n \n case 10: return (std::sqrt(105/pi)*std::sin(2*phi)*(std::sin(theta) - 3*std::sin(3*theta)))/16.;\n \n case 11: return (std::sqrt(21/(2.*pi))*std::cos(theta)*(7 - 15*std::cos(2*theta))*std::sin(phi))/8.;\n \n case 12: return (-3*std::sqrt(7/pi)*(3 + 5*std::cos(2*theta))*std::sin(theta))/8.;\n \n case 13: return (std::sqrt(21/(2.*pi))*std::cos(phi)*std::cos(theta)*(7 - 15*std::cos(2*theta)))/8.;\n \n case 14: return (std::sqrt(105/pi)*std::cos(2*phi)*(1 + 3*std::cos(2*theta))*std::sin(theta))/8.;\n \n case 15: return (-3*std::sqrt(35/(2.*pi))*std::cos(3*phi)*std::cos(theta)*std::pow(std::sin(theta),2))/4.;\n \n case 16: return (-3*std::sqrt(35/pi)*std::cos(theta)*std::sin(4*phi)*std::pow(std::sin(theta),3))/4.;\n \n case 17: return (-3*std::sqrt(35/(2.*pi))*(1 + 2*std::cos(2*theta))*std::sin(3*phi)*std::pow(std::sin(theta),2))/4.;\n \n case 18: return (3*std::sqrt(5/pi)*(1 - 7*std::cos(2*theta))*std::sin(2*phi)*std::sin(2*theta))/8.;\n \n case 19: return (-3*std::sqrt(5/(2.*pi))*(std::cos(2*theta) + 7*std::cos(4*theta))*std::sin(phi))/8.;\n \n case 20: return (15*std::cos(theta)*(3 - 7*std::pow(std::cos(theta),2))*std::sin(theta))/(4.*std::sqrt(pi));\n \n case 21: return (-3*std::sqrt(5/(2.*pi))*std::cos(phi)*(std::cos(2*theta) + 7*std::cos(4*theta)))/8.;\n \n case 22: return (3*std::sqrt(5/pi)*std::cos(2*phi)*(-2*std::sin(2*theta) + 7*std::sin(4*theta)))/16.;\n \n case 23: return (-3*std::sqrt(35/(2.*pi))*std::cos(3*phi)*(1 + 2*std::cos(2*theta))*std::pow(std::sin(theta),2))/4.;\n \n case 24: return (3*std::sqrt(35/pi)*std::cos(4*phi)*std::cos(theta)*std::pow(std::sin(theta),3))/4.;\n\n default: {\n TERMINATE_NOT_IMPLEMENTED\n }\n }\n return 0; // make compiler happy\n }\n \n /// Compute derivative of real-spherical harmonic with respect to phi angle and divide by sin(theta).\n static double dRlm_dphi_sin_theta(int lm, double theta, double phi)\n {\n switch (lm) {\n case 0: return 0;\n \n case 1: return -(std::sqrt(3/pi)*std::cos(phi))/2.;\n \n case 2: return 0;\n \n case 3: return (std::sqrt(3/pi)*std::sin(phi))/2.;\n \n case 4: return -(std::sqrt(15/pi)*std::cos(2*phi)*std::sin(theta))/2.;\n \n case 5: return -(std::sqrt(15/pi)*std::cos(phi)*std::cos(theta))/2.;\n \n case 6: return 0;\n \n case 7: return (std::sqrt(15/pi)*std::cos(theta)*std::sin(phi))/2.;\n \n case 8: return -(std::sqrt(15/pi)*std::cos(phi)*std::sin(phi)*std::sin(theta));\n \n case 9: return (-3*std::sqrt(35/(2.*pi))*std::cos(3*phi)*std::pow(std::sin(theta),2))/4.;\n \n case 10: return -(std::sqrt(105/pi)*std::cos(2*phi)*std::sin(2*theta))/4.;\n \n case 11: return -(std::sqrt(21/(2.*pi))*std::cos(phi)*(3 + 5*std::cos(2*theta)))/8.;\n \n case 12: return 0;\n \n case 13: return (std::sqrt(21/(2.*pi))*(3 + 5*std::cos(2*theta))*std::sin(phi))/8.;\n \n case 14: return -(std::sqrt(105/pi)*std::cos(phi)*std::cos(theta)*std::sin(phi)*std::sin(theta));\n \n case 15: return (3*std::sqrt(35/(2.*pi))*std::sin(3*phi)*std::pow(std::sin(theta),2))/4.;\n \n case 16: return (-3*std::sqrt(35/pi)*std::cos(4*phi)*std::pow(std::sin(theta),3))/4.;\n \n case 17: return (-9*std::sqrt(35/(2.*pi))*std::cos(3*phi)*std::cos(theta)*std::pow(std::sin(theta),2))/4.;\n \n case 18: return (-3*std::sqrt(5/pi)*std::cos(2*phi)*(3*std::sin(theta) + 7*std::sin(3*theta)))/16.;\n \n case 19: return (-3*std::sqrt(5/(2.*pi))*std::cos(phi)*(9*std::cos(theta) + 7*std::cos(3*theta)))/16.;\n \n case 20: return 0;\n \n case 21: return (3*std::sqrt(5/(2.*pi))*std::cos(theta)*(1 + 7*std::cos(2*theta))*std::sin(phi))/8.;\n \n case 22: return (-3*std::sqrt(5/pi)*std::sin(2*phi)*(3*std::sin(theta) + 7*std::sin(3*theta)))/16.;\n \n case 23: return (9*std::sqrt(35/(2.*pi))*std::cos(theta)*std::sin(3*phi)*std::pow(std::sin(theta),2))/4.;\n \n case 24: return (-3*std::sqrt(35/pi)*std::sin(4*phi)*std::pow(std::sin(theta),3))/4.;\n\n default: {\n TERMINATE_NOT_IMPLEMENTED\n }\n }\n return 0; // make compiler happy\n }\n};\n\ntemplate <>\ninline void SHT::backward_transform(int ld, double const* flm, int nr, int lmmax, double* ftp)\n{\n assert(lmmax <= lmmax_);\n assert(ld >= lmmax);\n linalg::gemm(1, 0, num_points_, nr, lmmax, &rlm_backward_(0, 0), lmmax_, flm, ld, ftp, num_points_);\n}\n\ntemplate <>\ninline void SHT::backward_transform(int ld, double_complex const* flm, int nr, int lmmax, double_complex* ftp)\n{\n assert(lmmax <= lmmax_);\n assert(ld >= lmmax);\n linalg::gemm(1, 0, num_points_, nr, lmmax, &ylm_backward_(0, 0), lmmax_, flm, ld, ftp, num_points_);\n}\n\ntemplate <>\ninline void SHT::forward_transform(double const* ftp, int nr, int lmmax, int ld, double* flm)\n{\n assert(lmmax <= lmmax_);\n assert(ld >= lmmax);\n linalg::gemm(1, 0, lmmax, nr, num_points_, &rlm_forward_(0, 0), num_points_, ftp, num_points_, flm, ld);\n}\n\ntemplate <>\ninline void SHT::forward_transform(double_complex const* ftp, int nr, int lmmax, int ld, double_complex* flm)\n{\n assert(lmmax <= lmmax_);\n assert(ld >= lmmax);\n linalg::gemm(1, 0, lmmax, nr, num_points_, &ylm_forward_(0, 0), num_points_, ftp, num_points_, flm, ld);\n}\n\ninline double SHT::gaunt_ylm(int l1, int l2, int l3, int m1, int m2, int m3)\n{\n assert(l1 >= 0);\n assert(l2 >= 0);\n assert(l3 >= 0);\n assert(m1 >= -l1 && m1 <= l1);\n assert(m2 >= -l2 && m2 <= l2);\n assert(m3 >= -l3 && m3 <= l3);\n \n return std::pow(-1.0, std::abs(m1)) * std::sqrt(double(2 * l1 + 1) * double(2 * l2 + 1) * double(2 * l3 + 1) / fourpi) * \n gsl_sf_coupling_3j(2 * l1, 2 * l2, 2 * l3, 0, 0, 0) *\n gsl_sf_coupling_3j(2 * l1, 2 * l2, 2 * l3, -2 * m1, 2 * m2, 2 * m3);\n}\n\ninline double SHT::gaunt_rlm(int l1, int l2, int l3, int m1, int m2, int m3)\n{\n assert(l1 >= 0);\n assert(l2 >= 0);\n assert(l3 >= 0);\n assert(m1 >= -l1 && m1 <= l1);\n assert(m2 >= -l2 && m2 <= l2);\n assert(m3 >= -l3 && m3 <= l3);\n \n double d = 0;\n for (int k1 = -l1; k1 <= l1; k1++)\n {\n for (int k2 = -l2; k2 <= l2; k2++)\n {\n for (int k3 = -l3; k3 <= l3; k3++)\n {\n d += std::real(std::conj(SHT::ylm_dot_rlm(l1, k1, m1)) *\n SHT::ylm_dot_rlm(l2, k2, m2) *\n SHT::ylm_dot_rlm(l3, k3, m3)) * SHT::gaunt_ylm(l1, l2, l3, k1, k2, k3);\n }\n }\n }\n return d;\n}\n\ninline double_complex SHT::gaunt_hybrid(int l1, int l2, int l3, int m1, int m2, int m3)\n{\n assert(l1 >= 0);\n assert(l2 >= 0);\n assert(l3 >= 0);\n assert(m1 >= -l1 && m1 <= l1);\n assert(m2 >= -l2 && m2 <= l2);\n assert(m3 >= -l3 && m3 <= l3);\n\n if (m2 == 0) \n {\n return double_complex(gaunt_ylm(l1, l2, l3, m1, m2, m3), 0.0);\n }\n else \n {\n return (ylm_dot_rlm(l2, m2, m2) * gaunt_ylm(l1, l2, l3, m1, m2, m3) + \n ylm_dot_rlm(l2, -m2, m2) * gaunt_ylm(l1, l2, l3, m1, -m2, m3));\n }\n}\n\n\ninline vector3d SHT::spherical_coordinates(vector3d vc)\n{\n vector3d vs;\n\n double eps = 1e-12;\n\n vs[0] = vc.length();\n\n if (vs[0] <= eps)\n {\n vs[1] = 0.0;\n vs[2] = 0.0;\n } \n else\n {\n vs[1] = std::acos(vc[2] / vs[0]); // theta = cos^{-1}(z/r)\n\n if (std::abs(vc[0]) > eps || std::abs(vc[1]) > eps)\n {\n vs[2] = std::atan2(vc[1], vc[0]); // phi = tan^{-1}(y/x)\n if (vs[2] < 0.0) vs[2] += twopi;\n }\n else\n {\n vs[2] = 0.0;\n }\n }\n\n return vs;\n}\n\ninline void SHT::spherical_harmonics(int lmax, double theta, double phi, double_complex* ylm)\n{\n double x = std::cos(theta);\n std::vector result_array(lmax + 1);\n\n for (int l = 0; l <= lmax; l++)\n {\n for (int m = 0; m <= l; m++)\n {\n double_complex z = std::exp(double_complex(0.0, m * phi)); \n ylm[Utils::lm_by_l_m(l, m)] = gsl_sf_legendre_sphPlm(l, m, x) * z;\n if (m % 2) \n {\n ylm[Utils::lm_by_l_m(l, -m)] = -std::conj(ylm[Utils::lm_by_l_m(l, m)]);\n }\n else\n {\n ylm[Utils::lm_by_l_m(l, -m)] = std::conj(ylm[Utils::lm_by_l_m(l, m)]); \n }\n }\n }\n}\n\ninline void SHT::spherical_harmonics(int lmax, double theta, double phi, double* rlm)\n{\n int lmmax = (lmax + 1) * (lmax + 1);\n std::vector ylm(lmmax);\n spherical_harmonics(lmax, theta, phi, &ylm[0]);\n \n double t = std::sqrt(2.0);\n \n rlm[0] = y00;\n\n for (int l = 1; l <= lmax; l++)\n {\n for (int m = -l; m < 0; m++) \n rlm[Utils::lm_by_l_m(l, m)] = t * ylm[Utils::lm_by_l_m(l, m)].imag();\n \n rlm[Utils::lm_by_l_m(l, 0)] = ylm[Utils::lm_by_l_m(l, 0)].real();\n \n for (int m = 1; m <= l; m++) \n rlm[Utils::lm_by_l_m(l, m)] = t * ylm[Utils::lm_by_l_m(l, m)].real();\n }\n}\n \ninline void SHT::uniform_coverage()\n{\n tp_(0, 0) = pi;\n tp_(1, 0) = 0;\n\n for (int k = 1; k < num_points_ - 1; k++)\n {\n double hk = -1.0 + double(2 * k) / double(num_points_ - 1);\n tp_(0, k) = acos(hk);\n double t = tp_(1, k - 1) + 3.80925122745582 / sqrt(double(num_points_)) / sqrt(1 - hk * hk);\n tp_(1, k) = fmod(t, twopi);\n }\n \n tp_(0, num_points_ - 1) = 0;\n tp_(1, num_points_ - 1) = 0;\n}\n\ninline void SHT::convert(int lmax__, double const* f_rlm__, double_complex* f_ylm__)\n{\n int lm = 0;\n for (int l = 0; l <= lmax__; l++)\n {\n for (int m = -l; m <= l; m++)\n {\n if (m == 0)\n {\n f_ylm__[lm] = f_rlm__[lm];\n }\n else \n {\n int lm1 = Utils::lm_by_l_m(l, -m);\n f_ylm__[lm] = ylm_dot_rlm(l, m, m) * f_rlm__[lm] + ylm_dot_rlm(l, m, -m) * f_rlm__[lm1];\n }\n lm++;\n }\n }\n}\n\ninline void SHT::convert(int lmax__, double_complex const* f_ylm__, double* f_rlm__)\n{\n int lm = 0;\n for (int l = 0; l <= lmax__; l++)\n {\n for (int m = -l; m <= l; m++)\n {\n if (m == 0)\n {\n f_rlm__[lm] = std::real(f_ylm__[lm]);\n }\n else \n {\n int lm1 = Utils::lm_by_l_m(l, -m);\n f_rlm__[lm] = std::real(rlm_dot_ylm(l, m, m) * f_ylm__[lm] + rlm_dot_ylm(l, m, -m) * f_ylm__[lm1]);\n }\n lm++;\n }\n }\n}\n\n};\n\n#endif // __SHT_H__\n", "meta": {"hexsha": "cb60d6ea1547ef8d83b5272daa38e97003c6e8c6", "size": 34203, "ext": "h", "lang": "C", "max_stars_repo_path": "src/sht.h", "max_stars_repo_name": "cocteautwins/SIRIUS-develop", "max_stars_repo_head_hexsha": "8ab09ca7cc69e9a7dc76475b7b562b20d56deea3", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/sht.h", "max_issues_repo_name": "cocteautwins/SIRIUS-develop", "max_issues_repo_head_hexsha": "8ab09ca7cc69e9a7dc76475b7b562b20d56deea3", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/sht.h", "max_forks_repo_name": "cocteautwins/SIRIUS-develop", "max_forks_repo_head_hexsha": "8ab09ca7cc69e9a7dc76475b7b562b20d56deea3", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.2156424581, "max_line_length": 136, "alphanum_fraction": 0.4591994854, "num_tokens": 10090, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8596637361282706, "lm_q2_score": 0.5926665999540698, "lm_q1q2_score": 0.5094939835949548}} {"text": "/* multifit_nlinear/svd.c\n * \n * Copyright (C) 2016 Patrick Alken\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n/*\n * This module handles the solution of the linear least squares\n * system:\n *\n * [ J ] dx = - [ f ]\n * [ sqrt(mu)*D ] [ 0 ]\n *\n * using an SVD approach. The system above is transformed to \"standard form\"\n * via:\n *\n * J~ = J D^{-1}\n * dx~ = D dx\n *\n * so that\n *\n * [ J~ ] dx~ = - [ f ]\n * [ sqrt(mu)*I ] [ 0 ]\n *\n * can be solved with a standard SVD method, and then dx is recovered\n * from dx~ via: dx = D^{-1} dx~\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\ntypedef struct\n{\n size_t n; /* number of residuals */\n size_t p; /* number of parameters */\n gsl_matrix *U; /* U factor of J, n-by-p */\n gsl_matrix *V; /* V factor of J, p-by-p */\n gsl_vector *S; /* singular values, size p */\n gsl_vector *workp; /* workspace, length p */\n double mu; /* LM parameter */\n} svd_state_t;\n\nstatic int svd_init(const void * vtrust_state, void * vstate);\nstatic int svd_presolve(const double mu, const void * vtrust_state, void * vstate);\nstatic int svd_solve(const gsl_vector * f, gsl_vector *x,\n const void * vtrust_state, void *vstate);\nstatic int svd_rcond(double * rcond, void * vstate);\n\nstatic void *\nsvd_alloc (const size_t n, const size_t p)\n{\n svd_state_t *state;\n\n (void)n;\n \n state = calloc(1, sizeof(svd_state_t));\n if (state == NULL)\n {\n GSL_ERROR_NULL (\"failed to allocate svd state\", GSL_ENOMEM);\n }\n\n state->U = gsl_matrix_alloc(n, p);\n if (state->U == NULL)\n {\n GSL_ERROR_NULL (\"failed to allocate space for U\", GSL_ENOMEM);\n }\n\n state->V = gsl_matrix_alloc(p, p);\n if (state->V == NULL)\n {\n GSL_ERROR_NULL (\"failed to allocate space for V\", GSL_ENOMEM);\n }\n\n state->S = gsl_vector_alloc(p);\n if (state->S == NULL)\n {\n GSL_ERROR_NULL (\"failed to allocate space for S\",\n GSL_ENOMEM);\n }\n\n state->workp = gsl_vector_alloc(p);\n if (state->workp == NULL)\n {\n GSL_ERROR_NULL (\"failed to allocate space for workp\",\n GSL_ENOMEM);\n }\n\n state->mu = 0.0;\n state->n = n;\n state->p = p;\n\n return state;\n}\n\nstatic void\nsvd_free(void *vstate)\n{\n svd_state_t *state = (svd_state_t *) vstate;\n\n if (state->U)\n gsl_matrix_free(state->U);\n\n if (state->V)\n gsl_matrix_free(state->V);\n\n if (state->S)\n gsl_vector_free(state->S);\n\n if (state->workp)\n gsl_vector_free(state->workp);\n\n free(state);\n}\n\n/* compute svd of J */\nstatic int\nsvd_init(const void * vtrust_state, void * vstate)\n{\n int status;\n const gsl_multifit_nlinear_trust_state *trust_state =\n (const gsl_multifit_nlinear_trust_state *) vtrust_state;\n svd_state_t *state = (svd_state_t *) vstate;\n size_t i;\n\n gsl_matrix_set_zero(state->U);\n\n /* compute U = J D^{-1} */\n for (i = 0; i < state->p; ++i)\n {\n gsl_vector_const_view Ji = gsl_matrix_const_column(trust_state->J, i);\n gsl_vector_view ui = gsl_matrix_column(state->U, i);\n double di = gsl_vector_get(trust_state->diag, i);\n\n gsl_blas_daxpy(1.0 / di, &Ji.vector, &ui.vector);\n }\n\n status = gsl_linalg_SV_decomp(state->U, state->V, state->S, state->workp);\n\n return status;\n}\n\nstatic int\nsvd_presolve(const double mu, const void * vtrust_state, void * vstate)\n{\n svd_state_t *state = (svd_state_t *) vstate;\n\n state->mu = mu;\n\n (void)vtrust_state;\n\n return GSL_SUCCESS;\n}\n\nstatic int\nsvd_solve(const gsl_vector * f, gsl_vector *x,\n const void * vtrust_state, void *vstate)\n{\n int status = GSL_SUCCESS;\n const gsl_multifit_nlinear_trust_state *trust_state =\n (const gsl_multifit_nlinear_trust_state *) vtrust_state;\n svd_state_t *state = (svd_state_t *) vstate;\n const size_t p = state->p;\n const double tol = GSL_DBL_EPSILON;\n const double s0 = gsl_vector_get(state->S, 0);\n size_t j;\n\n /* compute workp = - U^T f */\n gsl_blas_dgemv(CblasTrans, -1.0, state->U, f, 0.0, state->workp);\n\n /*\n * compute:\n *\n * workp = sum_i s_i / (s_i^2 + mu) (-u_i^T f)\n */\n\n if (state->mu == 0.0)\n {\n /*\n * compute Gauss-Newton direction by solving\n * J x = -f\n */\n\n for (j = 0; j < p; ++j)\n {\n double sj = gsl_vector_get(state->S, j);\n double *ptr = gsl_vector_ptr(state->workp, j);\n double alpha;\n\n if (sj <= tol * s0)\n alpha = 0.0;\n else\n alpha = 1.0 / sj;\n\n *ptr *= alpha;\n }\n }\n else\n {\n /*\n * solve:\n *\n * [ J D^{-1} ] (D x) = -[ f ]\n * [ sqrt(mu) I ] [ 0 ]\n *\n * using SVD factorization of J D^{-1}\n */\n\n for (j = 0; j < p; ++j)\n {\n double sj = gsl_vector_get(state->S, j);\n double *ptr = gsl_vector_ptr(state->workp, j);\n\n *ptr *= sj / (sj*sj + state->mu);\n }\n }\n\n /* compute: x = V * workp */\n gsl_blas_dgemv(CblasNoTrans, 1.0, state->V, state->workp, 0.0, x);\n\n /* compute D^{-1} x */\n gsl_vector_div(x, trust_state->diag);\n\n return status;\n}\n\nstatic int\nsvd_rcond(double * rcond, void * vstate)\n{\n int status = GSL_SUCCESS;\n svd_state_t *state = (svd_state_t *) vstate;\n double smax = gsl_vector_get(state->S, 0);\n double smin = gsl_vector_get(state->S, state->p - 1);\n\n *rcond = smin / smax;\n\n return status;\n}\n\nstatic const gsl_multifit_nlinear_solver svd_type =\n{\n \"svd\",\n svd_alloc,\n svd_init,\n svd_presolve,\n svd_solve,\n svd_rcond,\n svd_free\n};\n\nconst gsl_multifit_nlinear_solver *gsl_multifit_nlinear_solver_svd = &svd_type;\n", "meta": {"hexsha": "6c2131bb505437b51e9366e3a329354570f4a8bc", "size": 6520, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.6/multifit_nlinear/svd.c", "max_stars_repo_name": "ielomariala/Hex-Game", "max_stars_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-06-14T11:51:37.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-14T11:51:37.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/multifit_nlinear/svd.c", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-12-16T17:41:24.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-22T00:00:16.000Z", "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/multifit_nlinear/svd.c", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-01-20T16:22:57.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-14T12:31:02.000Z", "avg_line_length": 24.1481481481, "max_line_length": 83, "alphanum_fraction": 0.607208589, "num_tokens": 1946, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7905303186696747, "lm_q2_score": 0.6442251133170357, "lm_q1q2_score": 0.5092794841255235}} {"text": "#ifndef LA_WRAPPER\n#define LA_WRAPPER\n\n// #include \n#include \n#include \n#include \n\nnamespace blas_wrapper\n{\n\n//! @param n : Anzahl Elemente.\n//! @param x : Quellvektor x.\n//! @param incx : Speicher Abstand zwischen Elemente in Vector x.\n//! @param y : Zielvektor (y= alpha*x+y).\n//! @param incy: Speicher Abstand zwischen Elemente in Vector y.\n\nstatic void\ncopy(int n, const float *x, int incx, float *y, int incy)\n{\n cblas_scopy(n, x, incx, y, incy);\n}\n\nstatic void\ncopy(int n, const double *x, int incx, double *y, int incy)\n{\n cblas_dcopy(n, x, incx, y, incy);\n}\n\nstatic void\ncopy(int n, const std::complex *x, int incx, std::complex *y, int incy)\n{\n cblas_zcopy(n, reinterpret_cast(x), incx, reinterpret_cast(y), incy);\n}\n\nstatic void\ncopy(int n, const std::complex *x, int incx, std::complex *y, int incy)\n{\n cblas_ccopy(n, reinterpret_cast(x), incx, reinterpret_cast(y), incy);\n}\n\n\nstatic void\ncopy(int n, const int *x, int incx, int *y, int incy)\n{\n for(int i=0; i alpha, std::complex *x, int incx)\n{\n cblas_cscal(n, reinterpret_cast(&alpha), reinterpret_cast(x), incx);\n}\n\nstatic void\nscal (int n, std::complex alpha, std::complex *x, int incx)\n{\n cblas_zscal(n, reinterpret_cast(&alpha), reinterpret_cast(x), incx);\n}\n\n\n//! @param trans : gibt an ob A transponiert ist oder nicht. Sei trans = 'N' oder 'n' so ist op(A)= A, sei trans = 'T', 't','C' oder 'c' so ist op(A)= trans(A)\n//! @param m : Anzahl Zeilen in Matrix A.\n//! @param n : Anzahl Spalten in Matrix A.\n//! @param alpha: Skalar fuer A.\n//! @param A : Matrix A\n//! @param lda : leading dimension von A.\n//! @param x : Vektor mit der laenge von mindestens (1+(n-1)*abs(incx)) falls trans = 'N' oder 'n', sonst mindestens der laenge (1+(m-1)*abs(incx)).\n//! @param incx : Speicher Abstand zwischen Elemente in Vector x.\n//! @param beta : Skalar fuer Vektor y.\n//! @param y : Vektor mit der laenge von mindestens (1+(n-1)*abs(incy)) falls trans = 'N' oder 'n', sonst mindestens der laenge (1+(m-1)*abs(incy)).\n//! @param incy: Speicher Abstand zwischen Elemente in Vector y.\n\nstatic void gemv (char trans, int m, int n, float alpha,\n const float * const A, int lda,\n const float * const x, int incx, float beta,\n float *y, int incy)\n{\n CBLAS_TRANSPOSE tr = ( ( (trans == 't') || (trans == 'T') ) ? CblasTrans : CblasNoTrans );\n cblas_sgemv (CblasColMajor, tr, m, n, alpha, A, lda, x, incx, beta, y, incy);\n}\n\nstatic void gemv (char trans, int m, int n, double alpha,\n const double * const A, int lda,\n const double * const x, int incx, double beta,\n double *y, int incy)\n{\n CBLAS_TRANSPOSE tr = ( ( (trans == 't') || (trans == 'T') ) ? CblasTrans : CblasNoTrans );\n cblas_dgemv (CblasColMajor, tr, m, n, alpha, A, lda, x, incx, beta, y, incy);\n}\n\nstatic void gemv (char trans, int m, int n, std::complex & alpha,\n const std::complex * const A, int lda,\n const std::complex * const x, int incx, std::complex & beta,\n std::complex *y, int incy)\n{\n CBLAS_TRANSPOSE tr = ( ( (trans == 't') || (trans == 'T') ) ? CblasTrans : CblasNoTrans );\n cblas_cgemv (CblasColMajor, tr, m, n, &alpha, A, lda, x, incx, &beta, y, incy);\n}\n\nstatic void gemv (char trans, int m, int n, std::complex & alpha,\n const std::complex * const A, int lda,\n const std::complex * const x, int incx, std::complex & beta,\n std::complex *y, int incy)\n{\n CBLAS_TRANSPOSE tr = ( ( (trans == 't') || (trans == 'T') ) ? CblasTrans : CblasNoTrans );\n cblas_zgemv (CblasColMajor, tr, m, n, &alpha, A, lda, x, incx, &beta, y, incy);\n}\n\n\n//! @param transa : gibt an ob A transponiert ist oder nicht. Sei transa = 'N' oder 'n' so ist op(A)= A, sei transa = 'T' oder 't' so ist op(A)= trans(A), sei transa = 'C' oder 'c' so ist op(A)=adjoint(A)\n//! @param transb : gibt an ob B transponiert ist oder nicht. Sei transb = 'N' oder 'n' so ist op(B)= A, sei transb = 'T' oder 't' so ist op(B)= trans(B), sei transb = 'C' oder 'c' so ist op(B)=adjoint(B)\n//! @param m : Anzahl Zeilen in Matrix A und Matrix C.\n//! @param n : Anzahl Spalten in Matrix B und Matrix C.\n//! @param k : Anzahl Spalten in Matrix A und Zeilen in Matrix B.\n//! @param alpha: Skalar fuer op(A)*op(B).\n//! @param A : Matrix A\n//! @param lda : leading dimension von A.\n//! @param B : Matrix B.\n//! @param ldb : leading dimension von B.\n//! @param beta : Skalar fuer Matrix C.\n//! @param C : Matrix C.\n//! @param ldc : leading dimension von C.\nstatic void gemm(char transa, char transb, int m, int n, int k, float alpha,\n const float * const A, int lda, const float * const B, int ldb,\n float beta, float * C, int ldc)\n{\n CBLAS_TRANSPOSE tr_a = ( ( (transa == 't') || (transa == 'T') ) ? CblasTrans : ( (transa == 'c') || (transa == 'C') ) ? CblasTrans : CblasNoTrans );\n CBLAS_TRANSPOSE tr_b = ( ( (transb == 't') || (transb == 'T') ) ? CblasTrans : ( (transb == 'c') || (transb == 'C') ) ? CblasTrans : CblasNoTrans );\n\n\n cblas_sgemm(CblasColMajor,\n tr_a, tr_b,\n m, n, k,\n alpha,\n A, lda,\n B, ldb,\n beta,\n C, ldc);\n}\n\n\nstatic void gemm(char transa, char transb, int m, int n, int k, double alpha,\n const double * const A, int lda, const double * const B, int ldb,\n double beta, double * C, int ldc)\n{\n CBLAS_TRANSPOSE tr_a = ( ( (transa == 't') || (transa == 'T') ) ? CblasTrans : ( (transa == 'c') || (transa == 'C') ) ? CblasTrans : CblasNoTrans );\n CBLAS_TRANSPOSE tr_b = ( ( (transb == 't') || (transb == 'T') ) ? CblasTrans : ( (transb == 'c') || (transb == 'C') ) ? CblasTrans : CblasNoTrans );\n\n cblas_dgemm(CblasColMajor, tr_a, tr_b, m, n, k, alpha,\n A, lda, B, ldb,\n beta, C, ldc);\n}\n\nstatic void gemm(char transa, char transb, int m, int n, int k, const std::complex alpha,\n const std::complex * const A, int lda, const std::complex * const B, int ldb,\n const std::complex beta, std::complex * C, int ldc)\n{\n CBLAS_TRANSPOSE tr_a = ( ( (transa == 't') || (transa == 'T') ) ? CblasTrans : ( (transa == 'c') || (transa == 'C') ) ? CblasConjTrans : CblasNoTrans );\n CBLAS_TRANSPOSE tr_b = ( ( (transb == 't') || (transb == 'T') ) ? CblasTrans : ( (transb == 'c') || (transb == 'C') ) ? CblasConjTrans : CblasNoTrans );\n\n cblas_cgemm(CblasColMajor,\n tr_a, tr_b,\n m, n, k,\n reinterpret_cast(&alpha),\n reinterpret_cast(A), lda,\n reinterpret_cast(B), ldb,\n reinterpret_cast(&beta),\n reinterpret_cast(C), ldc);\n}\n\n\nstatic void gemm(char transa, char transb, int m, int n, int k, const std::complex alpha,\n const std::complex * const A, int lda, const std::complex * const B, int ldb,\n const std::complex beta, std::complex * C, int ldc)\n{\n CBLAS_TRANSPOSE tr_a = ( ( (transa == 't') || (transa == 'T') ) ? CblasTrans : ( (transa == 'c') || (transa == 'C') ) ? CblasConjTrans : CblasNoTrans );\n CBLAS_TRANSPOSE tr_b = ( ( (transb == 't') || (transb == 'T') ) ? CblasTrans : ( (transb == 'c') || (transb == 'C') ) ? CblasConjTrans : CblasNoTrans );\n\n cblas_zgemm(CblasColMajor,\n tr_a, tr_b,\n m, n, k,\n reinterpret_cast(&alpha),\n reinterpret_cast(A), lda,\n reinterpret_cast(B), ldb,\n reinterpret_cast(&beta),\n reinterpret_cast(C), ldc);\n}\n\n\n} // END NAMESPACE blas_wrapper\n\nnamespace lapack_wrapper\n{\n\n// @sect5{Lapack function wrappers}\n// @sect6{Wrapper: SVD lapack-wrapper}\n// Wraps the general matrix svd lapack function for the four types s, d, c and z.\n// Lapack doc: http://www.netlib.org/lapack/explore-html/d8/d49/sgesvd_8f.html\ninline static void gesvd(char * JOBU, char * JOBVT, const LAPACK_INT * M, const LAPACK_INT * N, float * A, const LAPACK_INT * LDA, float * S, float * U, const LAPACK_INT * LDU, float * VT, const LAPACK_INT * LDVT, float * WORK, const LAPACK_INT * LWORK, float * /*RWORK*/, LAPACK_INT * INFO)\n{\n sgesvd_(JOBU, JOBVT, M, N, A, LDA, S, U, LDU, VT, LDVT, WORK, LWORK, INFO);\n}\n\ninline static void gesvd(char * JOBU, char * JOBVT, const LAPACK_INT * M, const LAPACK_INT * N, double * A, const LAPACK_INT * LDA, double * S, double * U, const LAPACK_INT * LDU, double * VT, const LAPACK_INT * LDVT, double * WORK, const LAPACK_INT * LWORK, double * /*RWORK*/, LAPACK_INT * INFO)\n{\n dgesvd_(JOBU, JOBVT, M, N, A, LDA, S, U, LDU, VT, LDVT, WORK, LWORK, INFO);\n}\n\ninline static void gesvd(char * JOBU, char * JOBVT, const LAPACK_INT * M, const LAPACK_INT * N, std::complex * A, const LAPACK_INT * LDA, float * S, std::complex * U, const LAPACK_INT * LDU, std::complex * VT, const LAPACK_INT * LDVT, std::complex * WORK, const LAPACK_INT * LWORK, float * RWORK, LAPACK_INT * INFO)\n{\n cgesvd_(JOBU, JOBVT, M, N, A, LDA, S, U, LDU, VT, LDVT, WORK, LWORK, RWORK, INFO);\n}\n\ninline static void gesvd(char * JOBU, char * JOBVT, const LAPACK_INT * M, const LAPACK_INT * N, std::complex * A, const LAPACK_INT * LDA, double * S, std::complex * U, const LAPACK_INT * LDU, std::complex * VT, const LAPACK_INT * LDVT, std::complex * WORK, const LAPACK_INT * LWORK, double * RWORK, LAPACK_INT * INFO)\n{\n zgesvd_(JOBU, JOBVT, M, N, A, LDA, S, U, LDU, VT, LDVT, WORK, LWORK, RWORK, INFO);\n}\n\n// @sect6{Wrapper: SVD divide and conquer lapack-wrapper}\n// Wraps the general matrix sdd lapack function for the four types s, d, c and z.\n// Lapack doc: http://www.netlib.org/lapack/explore-html/d1/d7e/group__double_g_esing_ga76f797b6a9e278ad7b21aae2b4a55d76.html#ga76f797b6a9e278ad7b21aae2b4a55d76\ninline static void gesdd(char * JOBZ, const LAPACK_INT * M, const LAPACK_INT * N, float * A, const LAPACK_INT * LDA, float * S, float * U, const LAPACK_INT * LDU, float * VT, const LAPACK_INT * LDVT, float * WORK, const LAPACK_INT * LWORK, float * /*RWORK*/, LAPACK_INT * IWORK, LAPACK_INT * INFO)\n{\n return sgesdd_(JOBZ, M, N, A, LDA, S, U, LDU, VT, LDVT, WORK, LWORK, IWORK, INFO);\n}\ninline static void gesdd(char * JOBZ, const LAPACK_INT * M, const LAPACK_INT * N, double * A, const LAPACK_INT * LDA, double * S, double * U, const LAPACK_INT * LDU, double * VT, const LAPACK_INT * LDVT, double * WORK, const LAPACK_INT * LWORK, double * /*RWORK*/, LAPACK_INT * IWORK, LAPACK_INT * INFO)\n{\n return dgesdd_(JOBZ, M, N, A, LDA, S, U, LDU, VT, LDVT, WORK, LWORK, IWORK, INFO);\n}\ninline static void gesdd(char * JOBZ, const LAPACK_INT * M, const LAPACK_INT * N, std::complex * A, const LAPACK_INT * LDA, float * S, std::complex * U, const LAPACK_INT * LDU, std::complex * VT, const LAPACK_INT * LDVT, std::complex * WORK, const LAPACK_INT * LWORK, float * RWORK, LAPACK_INT * IWORK, LAPACK_INT * INFO)\n{\n return cgesdd_(JOBZ, M, N, A, LDA, S, U, LDU, VT, LDVT, WORK, LWORK, RWORK, IWORK, INFO);\n}\ninline static void gesdd(char * JOBZ, const LAPACK_INT * M, const LAPACK_INT * N, std::complex * A, const LAPACK_INT * LDA, double * S, std::complex * U, const LAPACK_INT * LDU, std::complex * VT, const LAPACK_INT * LDVT, std::complex * WORK, const LAPACK_INT * LWORK, double * RWORK, LAPACK_INT * IWORK, LAPACK_INT * INFO)\n{\n return zgesdd_(JOBZ, M, N, A, LDA, S, U, LDU, VT, LDVT, WORK, LWORK, RWORK, IWORK, INFO);\n}\n\n// @sect6{Wrapper: LUD lapack-wrapper}\n// Wraps the general matrix LU decomposition lapack function for the four types s, d, c and z.\n// Lapack doc: http://www.netlib.org/lapack/explore-html/de/de2/sgetrf_8f.html\ninline static void getrf(const LAPACK_INT * M, const LAPACK_INT * N, float * A, const LAPACK_INT * LDA, LAPACK_INT * IPIV, LAPACK_INT * INFO)\n{\n sgetrf_(M, N, A, LDA, IPIV, INFO);\n}\ninline static void getrf(const LAPACK_INT * M, const LAPACK_INT * N, double * A, const LAPACK_INT * LDA, LAPACK_INT * IPIV, LAPACK_INT * INFO)\n{\n dgetrf_(M, N, A, LDA, IPIV, INFO);\n}\ninline static void getrf(const LAPACK_INT * M, const LAPACK_INT * N, std::complex * A, const LAPACK_INT * LDA, LAPACK_INT * IPIV, LAPACK_INT * INFO)\n{\n cgetrf_(M, N, A, LDA, IPIV, INFO);\n}\ninline static void getrf(const LAPACK_INT * M, const LAPACK_INT * N, std::complex * A, const LAPACK_INT * LDA, LAPACK_INT * IPIV, LAPACK_INT * INFO)\n{\n zgetrf_(M, N, A, LDA, IPIV, INFO);\n}\n\n// @sect6{Wrapper: LU-Inverse lapack-wrapper}\n// Wraps the general matrix inversion lapack function for the two types s, d.\n // Lapack doc: http://www.netlib.org/lapack/explore-html/de/de2/sgetri_8f.html\ninline static void getri (const LAPACK_INT * N, float * A, const LAPACK_INT * LDA, const LAPACK_INT * IPIV, float * WORK, const LAPACK_INT * LWORK, LAPACK_INT * INFO)\n{\n sgetri_(N, A, LDA, IPIV, WORK, LWORK, INFO);\n}\ninline static void getri (const LAPACK_INT * N, double * A, const LAPACK_INT * LDA, const LAPACK_INT * IPIV, double * WORK, const LAPACK_INT * LWORK, LAPACK_INT * INFO)\n{\n dgetri_(N, A, LDA, IPIV, WORK, LWORK, INFO);\n}\n\n// @sect6{Wrapper: QRF lapack-wrapper}\n// Wraps the general matrix QR factorization lapack function for the four types s, d, c and z.\n// Lapack doc: http://www.netlib.org/lapack/explore-html/df/d97/sgeqrf_8f.html\ninline static void geqrf(const LAPACK_INT * M, const LAPACK_INT * N, float * A, const LAPACK_INT * LDA, float * TAU, float * WORK, const LAPACK_INT * LWORK, LAPACK_INT * INFO)\n{\n sgeqrf_(M, N, A, LDA, TAU, WORK, LWORK, INFO);\n}\ninline static void geqrf(const LAPACK_INT * M, const LAPACK_INT * N, double * A, const LAPACK_INT * LDA, double * TAU, double * WORK, const LAPACK_INT * LWORK, LAPACK_INT * INFO)\n{\n dgeqrf_(M, N, A, LDA, TAU, WORK, LWORK, INFO);\n}\ninline static void geqrf(const LAPACK_INT * M, const LAPACK_INT * N, std::complex * A, const LAPACK_INT * LDA, std::complex * TAU, std::complex * WORK, const LAPACK_INT * LWORK, LAPACK_INT * INFO)\n{\n cgeqrf_(M, N, A, LDA, TAU, WORK, LWORK, INFO);\n}\ninline static void geqrf(const LAPACK_INT * M, const LAPACK_INT * N, std::complex * A, const LAPACK_INT * LDA, std::complex * TAU, std::complex * WORK, const LAPACK_INT * LWORK, LAPACK_INT * INFO)\n{\n zgeqrf_(M, N, A, LDA, TAU, WORK, LWORK, INFO);\n}\n\n// @sect6{Wrapper: MQR lapack-wrapper}\n// Wraps the lapack function of the product of elementary reflectors from the QR factorization for the four types s, d, c and z.\n// Lapack doc: http://www.netlib.org/lapack/explore-html/d0/d98/sormqr_8f.html\ninline static void xxmqr(char * SIDE, char * TRANS, const LAPACK_INT * M, const LAPACK_INT * N, const LAPACK_INT * K, float * A, const LAPACK_INT * LDA, float * TAU, float * C, const LAPACK_INT * LDC, float * WORK, const LAPACK_INT * LWORK, LAPACK_INT * INFO)\n{\n sormqr_(SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC, WORK, LWORK, INFO);\n}\ninline static void xxmqr(char * SIDE, char * TRANS, const LAPACK_INT * M, const LAPACK_INT * N, const LAPACK_INT * K, double * A, const LAPACK_INT * LDA, double * TAU, double * C, const LAPACK_INT * LDC, double * WORK, const LAPACK_INT * LWORK, LAPACK_INT * INFO)\n{\n dormqr_(SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC, WORK, LWORK, INFO);\n}\ninline static void xxmqr(char * SIDE, char * TRANS, const LAPACK_INT * M, const LAPACK_INT * N, const LAPACK_INT * K, std::complex * A, const LAPACK_INT * LDA, std::complex * TAU, std::complex * C, const LAPACK_INT * LDC, std::complex * WORK, const LAPACK_INT * LWORK, LAPACK_INT * INFO)\n{\n cunmqr_(SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC, WORK, LWORK, INFO);\n}\ninline static void xxmqr(char * SIDE, char * TRANS, const LAPACK_INT * M, const LAPACK_INT * N, const LAPACK_INT * K, std::complex * A, const LAPACK_INT * LDA, std::complex * TAU, std::complex * C, const LAPACK_INT * LDC, std::complex * WORK, const LAPACK_INT * LWORK, LAPACK_INT * INFO)\n{\n zunmqr_(SIDE, TRANS, M, N, K, A, LDA, TAU, C, LDC, WORK, LWORK, INFO);\n}\n\n// @sect6{Wrapper: EV lapack-wrapper}\n// Wraps the lapack function for computing the eigenvalues and, optionally, the left and/or right eigenvectors for the four types s, d, c and z.\n// Lapack doc: http://www.netlib.org/lapack/explore-html/d1/d74/group__eigen_s_y.html and http://www.netlib.org/lapack/explore-html/df/db2/cheev_8f.html\ninline static void xxev(char * JOBZ, char * UPLO, const LAPACK_INT * N, float * A, const LAPACK_INT * LDA, float * W, float * WORK, const LAPACK_INT * LWORK, float * /*RWORK*/, LAPACK_INT * INFO)\n{\n return ssyev_(JOBZ, UPLO, N, A, LDA, W, WORK, LWORK, INFO);\n}\ninline static void xxev(char * JOBZ, char * UPLO, const LAPACK_INT * N, double * A, const LAPACK_INT * LDA, double * W, double * WORK, const LAPACK_INT * LWORK, double * /*RWORK*/, LAPACK_INT * INFO)\n{\n return dsyev_(JOBZ, UPLO, N, A, LDA, W, WORK, LWORK, INFO);\n}\ninline static void xxev(char * JOBZ, char * UPLO, const LAPACK_INT * N, std::complex * A, const LAPACK_INT * LDA, float * W, std::complex * WORK, const LAPACK_INT * LWORK, float * RWORK, LAPACK_INT * INFO)\n{\n return cheev_(JOBZ, UPLO, N, A, LDA, W, WORK, LWORK, RWORK, INFO);\n}\ninline static void xxev(char * JOBZ, char * UPLO, const LAPACK_INT * N, std::complex * A, const LAPACK_INT * LDA, double * W, std::complex * WORK, const LAPACK_INT * LWORK, double * RWORK, LAPACK_INT * INFO)\n{\n return zheev_(JOBZ, UPLO, N, A, LDA, W, WORK, LWORK, RWORK, INFO);\n}\n\n// @sect6{Wrapper: EV lapack-wrapper}\n// Wraps the lapack function for computing the eigenvalues and, optionally, the left and/or right eigenvectors for the two real types s and d.\n// Lapack doc: http://www.netlib.org/lapack/explore-html/d1/d74/group__eigen_s_y.html and http://www.netlib.org/lapack/explore-html/df/db2/cheev_8f.html\ninline static void xtev(char * JOBZ, const LAPACK_INT * N, float * D, float * E, float * Z, const LAPACK_INT * LDZ, float * WORK, LAPACK_INT * INFO)\n{\n return sstev_(JOBZ, N, D, E, Z, LDZ, WORK, INFO);\n}\ninline static void xtev(char * JOBZ, const LAPACK_INT * N, double * D, double * E, double * Z, const LAPACK_INT * LDZ, double * WORK, LAPACK_INT * INFO)\n{\n dstev_(JOBZ, N, D, E, Z, LDZ, WORK, INFO);\n}\n\n// @sect6{Wrapper: Matrix norm lapack-wrapper}\n// Wraps the lapack function for computing the eigenvalues and, optionally, the left and/or right eigenvectors for the two real types s and d.\n// Lapack doc: http://www.netlib.org/lapack/explore-html/d1/d74/group__eigen_s_y.html and http://www.netlib.org/lapack/explore-html/df/db2/cheev_8f.html\ninline static float lange(char * NORM, const LAPACK_INT * M, const LAPACK_INT * N, const float * A, const LAPACK_INT * LDA, float * WORK)\n{\n return slange_( NORM, M, N, A, LDA, WORK );\n}\ninline static double lange(char * NORM, const LAPACK_INT * M, const LAPACK_INT * N, const double * A, const LAPACK_INT * LDA, double * WORK)\n{\n return dlange_( NORM, M, N, A, LDA, WORK );\n}\ninline static float lange(char * NORM, const LAPACK_INT * M, const LAPACK_INT * N, const std::complex * A, const LAPACK_INT * LDA, float * WORK)\n{\n return clange_( NORM, M, N, A, LDA, WORK );\n}\ninline static double lange(char * NORM, const LAPACK_INT * M, const LAPACK_INT * N, const std::complex * A, const LAPACK_INT * LDA, double * WORK)\n{\n return zlange_( NORM, M, N, A, LDA, WORK );\n}\n\n} // END NAMESPACE LAPACK_WRAPPER\n\n#endif // LA_WRAPPER\n\n", "meta": {"hexsha": "fe541f76c720e2947c04843f6ddbbe2f81910995", "size": 20554, "ext": "h", "lang": "C", "max_stars_repo_path": "la_wrapper.h", "max_stars_repo_name": "Migelo/standard_matrix_class", "max_stars_repo_head_hexsha": "172fd4b373a410435f2a3045318c5d32ad2ba55a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "la_wrapper.h", "max_issues_repo_name": "Migelo/standard_matrix_class", "max_issues_repo_head_hexsha": "172fd4b373a410435f2a3045318c5d32ad2ba55a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "la_wrapper.h", "max_forks_repo_name": "Migelo/standard_matrix_class", "max_forks_repo_head_hexsha": "172fd4b373a410435f2a3045318c5d32ad2ba55a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 52.7025641026, "max_line_length": 355, "alphanum_fraction": 0.6486815218, "num_tokens": 6681, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7606506526772884, "lm_q2_score": 0.6688802603710086, "lm_q1q2_score": 0.5087842066141622}} {"text": "// Author: Samuel D. Relton\n#include \n#include \n#include \"sgemm_batched.h\"\n\nfloat A1[] = {\n3, 1, 3,\n1, 5, 9,\n2, 6, 5\n};\n\nfloat B1[] = {\n3, 1, 3,\n1, 5, 9,\n2, 6, 5\n};\n\nfloat C1[] = {\n0, 0, 0,\n0, 0, 0,\n0, 0, 0\n};\n\nfloat A2[] = {\n3, 1, 3,\n1, 5, 9,\n2, 6, 5\n};\n\nfloat B2[] = {\n3, 1, 3,\n1, 5, 9,\n2, 6, 5\n};\n\nfloat C2[] = {\n0, 0, 0,\n0, 0, 0,\n0, 0, 0\n};\n\nfloat ALPHA[] = {1.0, 1.0};\nfloat BETA[] = {0.0, 0.0};\n\nint LDA[] = {3, 3};\nint LDB[] = {3, 3};\nint LDC[] = {3, 3};\n\nbblas_trans_t TRANSA[] = {CblasNoTrans, CblasNoTrans};\nbblas_trans_t TRANSB[] = {CblasNoTrans, CblasNoTrans};\n\nint M[] = {3, 3};\nint N[] = {3, 3};\nint K[] = {3, 3};\n\nint BATCHCOUNT = 2;\nbblas_batch_type_t BATCH_TYPE = BBLASFixed;\n\nint INFO[] = {0, 0};\n\nfloat *arrayA[] = {A1, A2};\nfloat *arrayB[] = {B1, B2};\nfloat *arrayC[] = {C1, C2};\n\nint main()\n{\n\tint i, j, k;\n\n\tsgemm_batched(TRANSA, TRANSB, M, N, K, ALPHA, arrayA,\n\t\t LDA, arrayB, LDB, BETA, arrayC, LDC, BATCHCOUNT,\n\t\t BATCH_TYPE, INFO);\n\t\n\n\tfor (k = 0; k < BATCHCOUNT; k++) {\n\t\tputchar('\\n');\n\t\tfor (i=0; i<3; ++i) {\n\t\t\tfor (j=0; j<3; ++j) {\n\t\t\t\tprintf(\"%5.1f\", arrayC[k][i*3+j]);\n\n\t\t\t}\n\t\t\tputchar('\\n');\n\t\t}\n\t}\n\n return 0;\n}\n", "meta": {"hexsha": "5461bc4e2e6571c681269fd71fbcaf780b05a409", "size": 1180, "ext": "c", "lang": "C", "max_stars_repo_path": "src/test_sgemm.c", "max_stars_repo_name": "NLAFET/BBLAS-ref", "max_stars_repo_head_hexsha": "7f3bef184d4d7a9a8b5685185e16f77e5d317e6d", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/test_sgemm.c", "max_issues_repo_name": "NLAFET/BBLAS-ref", "max_issues_repo_head_hexsha": "7f3bef184d4d7a9a8b5685185e16f77e5d317e6d", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/test_sgemm.c", "max_forks_repo_name": "NLAFET/BBLAS-ref", "max_forks_repo_head_hexsha": "7f3bef184d4d7a9a8b5685185e16f77e5d317e6d", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 13.5632183908, "max_line_length": 56, "alphanum_fraction": 0.5076271186, "num_tokens": 566, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7853085808877581, "lm_q2_score": 0.6477982179521103, "lm_q1q2_score": 0.5087214992415904}} {"text": "\n#ifdef GSLODE1\n\n////////////////////////////// ODE V1 //////////////////////////////////////////\n\n#include \n\ntypedef struct {int n; int (*f)(double,int, const double*, int, double *); int (*j)(double,int, const double*, int, int, double*);} Tode;\n\nint odefunc (double t, const double y[], double f[], void *params) { \n Tode * P = (Tode*) params;\n (P->f)(t,P->n,y,P->n,f);\n return GSL_SUCCESS;\n}\n\nint odejac (double t, const double y[], double *dfdy, double dfdt[], void *params) {\n Tode * P = ((Tode*) params);\n (P->j)(t,P->n,y,P->n,P->n,dfdy);\n int j;\n for (j=0; j< P->n; j++)\n dfdt[j] = 0.0;\n return GSL_SUCCESS;\n}\n\n\nint ode(int method, double h, double eps_abs, double eps_rel,\n int f(double, int, const double*, int, double*),\n int jac(double, int, const double*, int, int, double*),\n KRVEC(xi), KRVEC(ts), RMAT(sol)) {\n\n const gsl_odeiv_step_type * T;\n\n switch(method) {\n case 0 : {T = gsl_odeiv_step_rk2; break; }\n case 1 : {T = gsl_odeiv_step_rk4; break; }\n case 2 : {T = gsl_odeiv_step_rkf45; break; }\n case 3 : {T = gsl_odeiv_step_rkck; break; }\n case 4 : {T = gsl_odeiv_step_rk8pd; break; }\n case 5 : {T = gsl_odeiv_step_rk2imp; break; }\n case 6 : {T = gsl_odeiv_step_rk4imp; break; }\n case 7 : {T = gsl_odeiv_step_bsimp; break; }\n case 8 : { printf(\"Sorry: ODE rk1imp not available in this GSL version\\n\"); exit(0); }\n case 9 : { printf(\"Sorry: ODE msadams not available in this GSL version\\n\"); exit(0); }\n case 10: { printf(\"Sorry: ODE msbdf not available in this GSL version\\n\"); exit(0); }\n default: ERROR(BAD_CODE);\n }\n\n gsl_odeiv_step * s = gsl_odeiv_step_alloc (T, xin);\n gsl_odeiv_control * c = gsl_odeiv_control_y_new (eps_abs, eps_rel);\n gsl_odeiv_evolve * e = gsl_odeiv_evolve_alloc (xin);\n\n Tode P;\n P.f = f;\n P.j = jac;\n P.n = xin;\n\n gsl_odeiv_system sys = {odefunc, odejac, xin, &P};\n\n double t = tsp[0];\n\n double* y = (double*)calloc(xin,sizeof(double));\n int i,j;\n for(i=0; i< xin; i++) {\n y[i] = xip[i];\n solp[i] = xip[i];\n }\n\n for (i = 1; i < tsn ; i++)\n {\n double ti = tsp[i];\n while (t < ti)\n {\n gsl_odeiv_evolve_apply (e, c, s,\n &sys,\n &t, ti, &h,\n y);\n // if (h < hmin) h = hmin;\n }\n for(j=0; j\n\ntypedef struct {int n; int (*f)(double,int, const double*, int, double *); int (*j)(double,int, const double*, int, int, double*);} Tode;\n\nint odefunc (double t, const double y[], double f[], void *params) { \n Tode * P = (Tode*) params;\n (P->f)(t,P->n,y,P->n,f);\n return GSL_SUCCESS;\n}\n\nint odejac (double t, const double y[], double *dfdy, double dfdt[], void *params) {\n Tode * P = ((Tode*) params);\n (P->j)(t,P->n,y,P->n,P->n,dfdy);\n int j;\n for (j=0; j< P->n; j++)\n dfdt[j] = 0.0;\n return GSL_SUCCESS;\n}\n\n\nint ode(int method, double h, double eps_abs, double eps_rel,\n int f(double, int, const double*, int, double*),\n int jac(double, int, const double*, int, int, double*),\n KRVEC(xi), KRVEC(ts), RMAT(sol)) {\n\n const gsl_odeiv2_step_type * T;\n\n switch(method) {\n case 0 : {T = gsl_odeiv2_step_rk2; break; }\n case 1 : {T = gsl_odeiv2_step_rk4; break; }\n case 2 : {T = gsl_odeiv2_step_rkf45; break; }\n case 3 : {T = gsl_odeiv2_step_rkck; break; }\n case 4 : {T = gsl_odeiv2_step_rk8pd; break; }\n case 5 : {T = gsl_odeiv2_step_rk2imp; break; }\n case 6 : {T = gsl_odeiv2_step_rk4imp; break; }\n case 7 : {T = gsl_odeiv2_step_bsimp; break; }\n case 8 : {T = gsl_odeiv2_step_rk1imp; break; }\n case 9 : {T = gsl_odeiv2_step_msadams; break; }\n case 10: {T = gsl_odeiv2_step_msbdf; break; }\n default: ERROR(BAD_CODE);\n }\n\n Tode P;\n P.f = f;\n P.j = jac;\n P.n = xin;\n\n gsl_odeiv2_system sys = {odefunc, odejac, xin, &P};\n\n gsl_odeiv2_driver * d =\n gsl_odeiv2_driver_alloc_y_new (&sys, T, h, eps_abs, eps_rel);\n\n double t = tsp[0];\n\n double* y = (double*)calloc(xin,sizeof(double));\n int i,j;\n int status;\n for(i=0; i< xin; i++) {\n y[i] = xip[i];\n solp[i] = xip[i];\n }\n\n for (i = 1; i < tsn ; i++)\n {\n double ti = tsp[i];\n \n status = gsl_odeiv2_driver_apply (d, &t, ti, y);\n \n if (status != GSL_SUCCESS) {\n \t printf (\"error in ode, return value=%d\\n\", status);\n \t break;\n \t}\n\n// printf (\"%.5e %.5e %.5e\\n\", t, y[0], y[1]);\n \n for(j=0; j\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n/* function for sfs generation */\ndouble my_f(double q, void * p){\n struct my_f_params * params = (struct my_f_params *) p;\n double beta = params->beta;\n int i = params->i;\n int n = params->n;\n\t\n return ((1.0 - exp(-2.0 * beta * (1.0 - q))) / (1.0 - exp(-2.0 * beta))) * (2.0 / (q * (1.0 - q))) * gsl_ran_binomial_pdf(i, q, n);\n}\n\n\n\n/* integral of f over allele freq */\ndouble my_F(double beta, void * p){\n struct my_F_params * params = (struct my_F_params *) p;\n struct my_f_params fParams;\n gsl_function f;\n gsl_integration_workspace * w = gsl_integration_workspace_alloc (100000);\n double result,error;\n \n if (beta == 0){\n gsl_integration_workspace_free(w);\n return 1.0 / params->i;\n }\n else{\n fParams.beta = beta;\n fParams.i = params->i;\n fParams.n = params->n;\n f.function = &(my_f);\n f.params = &fParams;\n gsl_integration_qags(&f,0.0,1.0,1e-5,1e-5, 100000,w, &result,&error);\n gsl_integration_workspace_free(w);\n return result;\n }\n}\n\n/* integral of f over allele freq using numerical recipes integration */\ndouble my_F2(double beta, void * p){\n struct my_F_params * params = (struct my_F_params *) p;\n struct my_f_params fParams;\n double result;\n \n if (beta == 0){\n return 1.0 / params->i;\n }\n else{\n fParams.beta = beta;\n fParams.i = params->i;\n fParams.n = params->n;\n result = d_qromb2(&my_f, 0.0, 1.0, &fParams);\n return result;\n }\n}\n\n/* this returns the prob of SNP freq i given n and beta */\ndouble snpProb(double beta, void * p){\t\t\t\n struct my_F_params * params = (struct my_F_params *) p;\n struct my_F_params tempParams;\n long double tot;\n int i;\n gsl_function F;\n \n /* add up total prob space */\n tot = 0.0;\n tempParams.n = params->n;\n\n for(i = 1; i < params->n ; i++){\n tempParams.i = i;\n F.function = &my_F;\n F.params = &tempParams;\n tot += GSL_FN_EVAL(&F, beta);\n }\n \n /* reset parameters */\t\n F.function = &my_F;\n F.params = params;\n \n return GSL_FN_EVAL(&F, beta) / tot ;\n}\t\t\n\n/* trying to speedup the snpProb routine with a lookup of the denominators (in snpProb_params) */\ndouble snpProbDenomLookup(double beta, void * p){\t\t\t\n struct my_snpProb_params * params = (struct my_snpProb_params *) p;\n struct my_F_params tempParams;\n gsl_function F;\n \n /* set parameters */\t\n tempParams.n = params->n;\n tempParams.i = params->i;\n F.function = &my_F;\n F.params = &tempParams;\n \n return GSL_FN_EVAL(&F, beta) / params->denom ;\n}\t\n\n/* sampleSize vector - returns a vector of 1s or 0s depending on sample sizes in the data */\ngsl_vector *sampleSizeVector(struct snp data[], int snpNumber, int maxSampleSize){\n gsl_vector *bools;\n int i;\n\n //alloc and initialize bools vector\n bools = gsl_vector_alloc(maxSampleSize + 1);\n gsl_vector_set_zero(bools);\n\n //go through data, set each sampleSize value to 1\n for(i = 0; i < snpNumber; i++){\n gsl_vector_set(bools,data[i].n, 1);\n }\n return(bools);\n}\n\n\n\n/* returns a vector of snpProbDenominators from i = 2 to n, 1 indexed */\ngsl_vector *makeSnpProbDenomVector(double beta, int maxSampleSize, gsl_vector *sampleSizeVector){\n gsl_vector *probs;\n int i, j, test;\n double tot;\n struct my_F_params tempParams;\n gsl_function F;\n\n probs = gsl_vector_alloc(maxSampleSize + 1);\n\n /* go from n = 2 to maxSampleSize, calc total prob space for each, put in vector probs */\n for(j = 2; j < maxSampleSize + 1; j++){\n //check if sampleSize is included\n test = gsl_vector_get(sampleSizeVector,j);\n if (test){\n tot = 0.0;\n tempParams.n = j;\n for(i = 1; i < j ; i++){\n\ttempParams.i = i;\n\tF.function = &my_F;\n\tF.params = &tempParams;\n\ttot += GSL_FN_EVAL(&F, beta);\n }\n gsl_vector_set(probs, j, tot);\n }\n }\n return probs;\n}\n \n/* snpProbDenom - returns denom for snpProb */\ndouble snpProbDenom(double beta, int sampleSize){\n int i;\n double tot;\n struct my_F_params tempParams;\n gsl_function F;\n\n tot = 0.0;\n tempParams.n = sampleSize;\n for(i = 1; i < sampleSize ; i++){\n\ttempParams.i = i;\n\tF.function = &my_F;\n\tF.params = &tempParams;\n\ttot += GSL_FN_EVAL(&F, beta);\n }\n return(tot);\n}\n\n\n/* snpProbMatrix- returns a matrix of log snpProbs. matrix is maxSampleSize+1 by maxSampleSize. rows represent\n variable sampleSizes (2 to max), columns represent freqs (1 to max -1) */\ngsl_matrix *snpProbMatrix(double beta, int maxSampleSize, gsl_vector *sampleSizeVector, gsl_matrix *sfsBools){\n gsl_vector *denoms;\n gsl_matrix *probs;\n struct my_snpProb_params FParams;\n gsl_function f;\n int i, j;\n \n //alloc probs\n probs = gsl_matrix_alloc(maxSampleSize + 1, maxSampleSize);\n gsl_matrix_set_zero(probs);\n //get denoms\n denoms = makeSnpProbDenomVector(beta,maxSampleSize, sampleSizeVector);\n\n //go through sampleSizes\n for(i = 2; i <= maxSampleSize; i++){\n //have sample size i?\n if (gsl_vector_get(sampleSizeVector, i)){\n //go through freqs\n for(j = 1; j < maxSampleSize; j++){\n\t//have freq j?\n\tif(gsl_matrix_get(sfsBools, i, j)){\n\t //calc prob\n\t FParams.i = j;\n\t FParams.n = i;\n\t FParams.denom = gsl_vector_get(denoms,i);\n\t f.function = &snpProbDenomLookup;\n\t f.params = &FParams;\n\t gsl_matrix_set(probs, i, j, log(GSL_FN_EVAL(&f, beta)));\n\t}\n }\n }\n }\n gsl_vector_free(denoms);\n return(probs);\n}\n/* snpProbMatrix- returns a matrix of snpProbs. matrix is maxSampleSize+1 by maxSampleSize. rows represent\n variable sampleSizes (2 to max), columns represent freqs (1 to max -1) */\ngsl_matrix *snpProbMatrixNotLog(double beta, int maxSampleSize, gsl_vector *sampleSizeVector, gsl_matrix *sfsBools){\n gsl_vector *denoms;\n gsl_matrix *probs;\n struct my_snpProb_params FParams;\n gsl_function f;\n int i, j;\n \n //alloc probs\n probs = gsl_matrix_alloc(maxSampleSize + 1, maxSampleSize);\n gsl_matrix_set_zero(probs); \n //get denoms\n denoms = makeSnpProbDenomVector(beta,maxSampleSize, sampleSizeVector);\n\n //go through sampleSizes\n for(i = 2; i <= maxSampleSize; i++){\n //have sample size i?\n if (gsl_vector_get(sampleSizeVector, i)){\n //go through freqs\n for(j = 1; j < maxSampleSize; j++){\n\t//have freq j?\n\tif(gsl_matrix_get(sfsBools, i, j)){\n\t //calc prob\n\t FParams.i = j;\n\t FParams.n = i;\n\t FParams.denom = gsl_vector_get(denoms,i);\n\t f.function = &snpProbDenomLookup;\n\t f.params = &FParams;\n\t gsl_matrix_set(probs, i, j, GSL_FN_EVAL(&f, beta));\n\t}\n }\n }\n }\n gsl_vector_free(denoms);\n return(probs);\n}\n/* snpProbMatrixNotLogFull- returns a matrix of snpProbs. matrix is maxSampleSize+1 by maxSampleSize. rows represent\n variable sampleSizes (2 to max), columns represent freqs (1 to max -1). All freqs/samplesizes included */\ngsl_matrix *snpProbMatrixNotLogFull(double beta, int maxSampleSize, gsl_vector *sampleSizeVector){\n gsl_vector *denoms;\n gsl_matrix *probs;\n struct my_snpProb_params FParams;\n gsl_function f;\n int i, j;\n \n //alloc probs\n probs = gsl_matrix_alloc(maxSampleSize + 1, maxSampleSize);\n gsl_matrix_set_zero(probs); \n\n //get denoms\n\n denoms = makeSnpProbDenomVector(beta,maxSampleSize, sampleSizeVector);\n\n //go through sampleSizes\n for(i = 2; i <= maxSampleSize; i++){\n //check for sampleSize\n if (gsl_vector_get(sampleSizeVector,i)){\n //go through freqs\n for(j = 1; j < maxSampleSize; j++){\n\t//calc prob\n\tFParams.i = j;\n\tFParams.n = i;\n\tFParams.denom = gsl_vector_get(denoms,i);\n\tf.function = &snpProbDenomLookup;\n\tf.params = &FParams;\n\tgsl_matrix_set(probs, i, j, GSL_FN_EVAL(&f, beta));\n }\n }\n }\n gsl_vector_free(denoms);\n return(probs);\n}\n\n\n/* snpProbVectorNotLog- returns a vector of log snpProbs at specified sampleSize columns represent freqs (1 to max -1) */\ngsl_vector *snpProbVectorNotLog(double beta, int sampleSize){\n double denom;\n gsl_vector *probs;\n struct my_snpProb_params FParams;\n gsl_function f;\n int i;\n \n //alloc probs\n probs = gsl_vector_alloc(sampleSize);\n gsl_vector_set_zero(probs);\n //get denoms\n denom = snpProbDenom(beta, sampleSize);\n\n //go through freqs\n for(i = 1; i < sampleSize; i++){\n FParams.i = i;\n FParams.n = sampleSize;\n FParams.denom = denom;\n f.function = &snpProbDenomLookup;\n f.params = &FParams;\n gsl_vector_set(probs, i, GSL_FN_EVAL(&f, beta));\n }\n return(probs);\n}\n\n/* likelihood function for SFS given the data; p here contains the data and the weights */\ndouble my_lik(double beta, void * p){\n\tstruct my_lik_params * params = (struct my_lik_params *) p;\n\tstruct my_F_params FParams;\n\tgsl_function f;\n\tdouble lik;\n\tint i;\n\t\n\tlik = 0;\n\tfor(i = 0; i < params->snpNumber; i++){\n\t\tFParams.i = params->data[i].i;\n\t\tFParams.n = params->data[i].n;\n\t\tf.function = &snpProb;\n\t\tf.params = &FParams;\n\t\tlik += log(GSL_FN_EVAL(&f, beta));\n\t\t}\n\treturn -lik;\n}\n\n/* likelihood function for SFS where each SNP has independent selection coeff */\ndouble sfsLikBetaVector(gsl_vector *betas, void * p){\n\tstruct my_lik_params * params = (struct my_lik_params *) p;\n\tstruct my_F_params FParams;\n\tgsl_function f;\n\tdouble lik;\n\tint i;\n\t\n\tlik = 0;\n\tfor(i = 0; i < params->snpNumber; i++){\n\t\tFParams.i = params->data[i].i;\n\t\tFParams.n = params->data[i].n;\n\t\tf.function = &snpProb;\n\t\tf.params = &FParams;\n\t\tlik += log(GSL_FN_EVAL(&f, gsl_vector_get(betas, i)));\n\t\t}\n\treturn -lik;\n}\n\n/* weighted likelihood function for SFS given the data; here contains the data and the weights */\ndouble weightedLik(double beta, void * p){\n struct my_lik_params * params = (struct my_lik_params *) p;\n struct my_F_params FParams;\n gsl_function f;\n double lik;\n int i;\n\t\n lik = 0;\n for(i = 0; i < params->snpNumber; i++){\n FParams.i = params->data[i].i;\n FParams.n = params->data[i].n;\n f.function = &snpProb;\n f.params = &FParams;\n lik += gsl_vector_get(params->weights, i) * log(GSL_FN_EVAL(&f, beta)); \n }\n return -lik;\n}\n\n/* weighted likelihood function for SFS given the data; here contains the data and the weights and uses the snpProbLookup routine */\ndouble weightedLikLook(double beta, void * p){\n struct my_lik_params * params = (struct my_lik_params *) p;\n double lik;\n int i;\n gsl_matrix *probs;\n \n //make prob matrix (note this is in logs)\n probs = snpProbMatrix(beta, params->maxSampleSize, params->sampleSizeVector, params->sfsBools);\n //now go and tally likelihood\n lik = 0;\n for(i = 0; i < params->snpNumber; i++){\n lik += gsl_matrix_get(probs,params->data[i].n,params->data[i].i) * gsl_vector_get(params->weights,i);\n }\n gsl_matrix_free(probs);\n return -lik;\n}\n \ndouble weightedLikLookCI(double beta, void * p){\n struct my_likCI_params *params = (struct my_likCI_params *) p;\n struct my_lik_params likParams;\n gsl_function l;\n double result;\n\n likParams.data = params->data;\n likParams.snpNumber = params->snpNumber;\n likParams.sampleSizeVector = params->sampleSizeVector;\n likParams.maxSampleSize = params->maxSampleSize;\n likParams.weights = params->weights;\n likParams.sfsBools = params->sfsBools;\n l.function = &weightedLikLook;\n l.params = &likParams;\n result = GSL_FN_EVAL(&l, beta) - (params->lMax) - (params->logUnits) ;\n // printf(\"%f\\t%f\\t%f\\n\",params->lMax,GSL_FN_EVAL(&l, beta),result);\n return result;\n}\n\n\n/* wrapper for my_lik for use in mnbrak */\ndouble likWrap(double beta){\n\tgsl_function f;\n\t\n\tf.function = &my_lik;\n\tf.params = NULL;\n\treturn GSL_FN_EVAL(&f, beta);\n}\n\n/* wrapper for my_lik for use in mnbrak */\ndouble wlikWrap(double beta, void * p){\n\tgsl_function f;\n\tstruct my_lik_params * params = (struct my_lik_params *) p;\n\t\n\tf.function = &weightedLik;\n\tf.params = params;\n\treturn GSL_FN_EVAL(&f, beta);\n}\n\n/* wrapper for my_lik for use in mnbrak */\ndouble wlikWrapLook(double beta, void * p){\n\tgsl_function f;\n\tstruct my_lik_params * params = (struct my_lik_params *) p;\n\t\n\tf.function = &weightedLikLook;\n\tf.params = params;\n\treturn GSL_FN_EVAL(&f, beta);\n}\n\ndouble wlikCIWrapLook(double beta, void * p){\n\tgsl_function f;\n\tstruct my_likCI_params * params = (struct my_likCI_params *) p;\n\t\n\tf.function = &weightedLikLookCI;\n\tf.params = params;\n\treturn GSL_FN_EVAL(&f, beta);\n}\n \n\n/*error checking function for likelihood function */\nvoid printProfile(double min, double max, void * p){\n gsl_function f;\n struct my_lik_params *params = (struct my_lik_params *) p;\n int i;\n\n f.function = &weightedLikLook;\n f.params = params;\n for(i = min; i < max; i++){\n printf(\"%d\\t%f\\n\",i, GSL_FN_EVAL(&f, i));\n }\n \n}\n \n/* get ML estimate of beta using likelihood function; BRENT method for gsl */\ndouble ml_est(double * lik_beta_hat){\n\tint status;\n\tint iter = 0;\n\tint max_iter = 100;\n\tconst gsl_min_fminimizer_type *T;\n\tgsl_min_fminimizer *s;\n\tdouble m, a, b, ax, bx, cx, fa, fb, fc;\n\tgsl_function L;\n\t\n\t\n\t\n\t/* get minimum bracket */\n\tax = -10.0;\n\tbx = 0.0;\n\tcx = 10.0;\n\t\n\tmnbrak(&ax, &bx, &cx, &fa, &fb, &fc, &my_lik);\n\t\n\t/* check if there is a minimum, if not return inf */\n\tif (fa == fb || fc == fb || ax > cx){\n\t\t*lik_beta_hat = fa;\n\t\treturn 666.0;\n\t\t}\n\telse{\n\t\t\n\t\t/* do mimization */\n\t\t\n\t\tL.function = &my_lik;\n\t\t//should have param line here but no params....\n\t\t\n\t\tT = gsl_min_fminimizer_brent;\n\t\ts = gsl_min_fminimizer_alloc(T);\n\t\tgsl_min_fminimizer_set(s, &L, bx, ax, cx);\n\t\t\n\t\tdo{\n\t\t\titer++;\n\t\t\tstatus = gsl_min_fminimizer_iterate(s);\n\t\t\t m = gsl_min_fminimizer_x_minimum (s);\n\t\t\t a = gsl_min_fminimizer_x_lower (s);\n\t\t\t b = gsl_min_fminimizer_x_upper (s);\n\t\t\n\t\t\t status = gsl_min_test_interval (a, b, 0.001, 0.0);\n\t\t\n\t\t}\n\t while (status == GSL_CONTINUE && iter < max_iter);\n\t gsl_min_fminimizer_free(s);\n\t \n\t return m;\n\t}\n}\n\n/* get weighted ML estimate of beta using likelihood function; BRENT method for gsl */\ndouble weighted_ml_est(double * lik_beta_hat, void * p){\n\tint status;\n\tint iter = 0;\n\tint max_iter = 100;\n\tconst gsl_min_fminimizer_type *T;\n\tgsl_min_fminimizer *s;\n\tdouble m, a, b, ax, bx, cx, fa, fb, fc, min;\n\tgsl_function L;\n\tstruct my_lik_params * params = (struct my_lik_params *) p;\t\n\t\n\t\n\t// get minimum bracket \n\tax = -10.0;\n\tbx = 1.0;\n\tcx = 10;\n\tL.function = &weightedLik;\n\tL.params = params;\n\tmnbrak2(&ax, &bx, &cx, &fa, &fb, &fc, &wlikWrap, bx, params);\n\n\t//check if there is a minimum, if not return 666\n\tif (fa == fb || fc == fb || ax > cx){\n\t min = fa;\n\t if(fb < min){\n\t min = fb;\n\t }\n\t if(fc < min){\n\t min = fc;\n\t }\n\t *lik_beta_hat = min;\n \t\n\t return 666.0;\n\t}\n\telse{\n\t // do mimization \n\t\t\n\t //initialize lik function\n\t L.function = &weightedLik;\n\t L.params = params;\n\t \n\t //min routine\n\t T = gsl_min_fminimizer_brent;\n\t s = gsl_min_fminimizer_alloc(T);\n\t gsl_min_fminimizer_set(s, &L, bx, ax, cx);\n\t do{\n\t iter++;\n\t status = gsl_min_fminimizer_iterate(s);\n\t m = gsl_min_fminimizer_x_minimum (s);\n\t a = gsl_min_fminimizer_x_lower (s);\n\t b = gsl_min_fminimizer_x_upper (s);\n\t status = gsl_min_test_interval (a, b, 0.001, 0.0);\n\t }\n\t while (status == GSL_CONTINUE && iter < max_iter);\n\t *lik_beta_hat = gsl_min_fminimizer_f_minimum(s);\n\t gsl_min_fminimizer_free(s);\n\t return m;\n\t}\n}\n\ndouble weighted_ml_est_lookup(double * lik_beta_hat, void * p){\n\tint status;\n\tint iter = 0;\n\tint max_iter = 100;\n\tconst gsl_min_fminimizer_type *T;\n\tgsl_min_fminimizer *s;\n\tdouble m, a, b, ax, bx, cx, fa, fb, fc, dummy;\n\tgsl_function L;\n\tstruct my_lik_params * params = (struct my_lik_params *) p;\t\n\t\n\t\n\t// get minimum bracket \n\tax = -20.0;\n\tbx = -1.0;\n\tcx = 20;\n\tL.function = &weightedLikLook;\n\tL.params = params;\n\tmnbrak2(&ax, &bx, &cx, &fa, &fb, &fc, &wlikWrapLook, bx, params);\n\t//swap bounds if needed\n\tif (cx < ax){\n\t dummy = cx;\n\t cx = ax;\n\t ax = dummy;\n\t}\n\n\t// do mimization \n\t\t\n\t//initialize lik function\n\tL.function = &weightedLikLook;\n\tL.params = params;\n\t \n\t//min routine\n\tT = gsl_min_fminimizer_brent;\n\ts = gsl_min_fminimizer_alloc(T);\n\tgsl_min_fminimizer_set(s, &L, bx, ax, cx);\n\tdo{\n\t iter++;\n\t status = gsl_min_fminimizer_iterate(s);\n\t m = gsl_min_fminimizer_x_minimum (s);\n\t a = gsl_min_fminimizer_x_lower (s);\n\t b = gsl_min_fminimizer_x_upper (s);\n\t status = gsl_min_test_interval (a, b, 0.001, 0.0);\n\t}\n\twhile (status == GSL_CONTINUE && iter < max_iter);\n\t*lik_beta_hat = gsl_min_fminimizer_f_minimum(s);\n\tgsl_min_fminimizer_free(s);\n\treturn m;\n}\n\n/* same as above but outputs 666 on minimization error */\ndouble weighted_ml_est_lookup_errReport(double * lik_beta_hat, void * p){\n\tint status;\n\tint iter = 0;\n\tint max_iter = 100;\n\tconst gsl_min_fminimizer_type *T;\n\tgsl_min_fminimizer *s;\n\tdouble m, a, b, ax, bx, cx, fa, fb, fc, dummy;\n\tgsl_function L;\n\tstruct my_lik_params * params = (struct my_lik_params *) p;\t\n\t\n\t\n\t// get minimum bracket \n\tax = -20.0;\n\tbx = -1.0;\n\tcx = 20;\n\tL.function = &weightedLikLook;\n\tL.params = params;\n\tmnbrak2(&ax, &bx, &cx, &fa, &fb, &fc, &wlikWrapLook, bx, params);\n\t//swap bounds if needed\n\tif (cx < ax){\n\t dummy = cx;\n\t cx = ax;\n\t ax = dummy;\n\t}\n\t//check for error\n\tif (fb >= fc || fb >= fa){\n\t return(666.0);\n\t}\n\t\n\t// do mimization \n\t\t\n\t//initialize lik function\n\tL.function = &weightedLikLook;\n\tL.params = params;\n\t \n\t//min routine\n\tT = gsl_min_fminimizer_brent;\n\ts = gsl_min_fminimizer_alloc(T);\n\tgsl_set_error_handler_off ();\n\tstatus = gsl_min_fminimizer_set(s, &L, bx, ax, cx);\n\tif (status == GSL_EINVAL){\n\t return(666);\n\t}\n\tdo{\n\t iter++;\n\t status = gsl_min_fminimizer_iterate(s);\n\t m = gsl_min_fminimizer_x_minimum (s);\n\t a = gsl_min_fminimizer_x_lower (s);\n\t b = gsl_min_fminimizer_x_upper (s);\n\t status = gsl_min_test_interval (a, b, 0.001, 0.0);\n\t}\n\twhile (status == GSL_CONTINUE && iter < max_iter);\n\t*lik_beta_hat = gsl_min_fminimizer_f_minimum(s);\n\tgsl_min_fminimizer_free(s);\n\treturn m;\n}\n\n/* get weighted ML lower CI beta using weightedLikLookCI method; BRENT method for gsl */\ndouble weighted_ml_CILower_lookup(double * lik_beta_hat, void * p){\n\tint status;\n\tint iter = 0;\n\tint max_iter = 100;\n\tconst gsl_root_fsolver_type *T;\n\tgsl_root_fsolver *s;\n\tdouble m, a, b, ax, cx;\n\tgsl_function L;\n\tstruct my_likCI_params * params = (struct my_likCI_params *) p;\t\n\t\n\t\n\t// get minimum bracket \n\tax = -50.0;\n\tcx = params->beta_hat;\n\t \n\t// do root finding \t\t\n\t//initialize lik function\n\tL.function = &weightedLikLookCI;\n\tL.params = params;\n\t \n\t//min routine\n\tT = gsl_root_fsolver_brent;\n\ts = gsl_root_fsolver_alloc(T);\n\tgsl_root_fsolver_set(s, &L, ax, cx);\n\tdo{\n\t iter++;\n\t status = gsl_root_fsolver_iterate(s);\n\t m = gsl_root_fsolver_root(s);\n\t a = gsl_root_fsolver_x_lower(s);\n\t b = gsl_root_fsolver_x_upper(s);\n\t status = gsl_min_test_interval (a, b, 0.001, 0.0);\n\t}\n\twhile (status == GSL_CONTINUE && iter < max_iter);\n\tgsl_root_fsolver_free(s);\n\treturn m;\n}\n\n/* get weighted ML upper CI beta using weightedLikLookCI method; BRENT method for gsl */\ndouble weighted_ml_CIUpper_lookup(double * lik_beta_hat, void * p){\n\tint status;\n\tint iter = 0;\n\tint max_iter = 100;\n\tconst gsl_root_fsolver_type *T;\n\tgsl_root_fsolver *s;\n\tdouble m, a, b, ax, cx;\n\tgsl_function L;\n\tstruct my_likCI_params * params = (struct my_likCI_params *) p;\t\n\t\n\t\n\t// get minimum bracket \n\tcx = 100.0;\n\tax = params->beta_hat;\n\t \n\t// do root finding \t\t\n\t//initialize lik function\n\tL.function = &weightedLikLookCI;\n\tL.params = params;\n\t \n\t//min routine\n\tT = gsl_root_fsolver_brent;\n\ts = gsl_root_fsolver_alloc(T);\n\tgsl_root_fsolver_set(s, &L, ax, cx);\n\tdo{\n\t iter++;\n\t status = gsl_root_fsolver_iterate(s);\n\t m = gsl_root_fsolver_root(s);\n\t a = gsl_root_fsolver_x_lower(s);\n\t b = gsl_root_fsolver_x_upper(s);\n\t status = gsl_min_test_interval (a, b, 0.001, 0.0);\n\t}\n\twhile (status == GSL_CONTINUE && iter < max_iter);\n\tgsl_root_fsolver_free(s);\n\treturn m;\n}\n\n/* summarizeSFS- returns a matrix of counts which summarize the SFS conditional\n upon sampleSize. rows = sampleSize, column = freqs */\n\ngsl_matrix *summarizeSFS(int maxSampleSize, struct snp data[], int snpNumber){\n gsl_matrix *counts;\n int i;\n\n //alloc matrix of size maxSampleSize by maxSampleSize\n counts = gsl_matrix_alloc(maxSampleSize + 1, maxSampleSize + 1);\n gsl_matrix_set_zero(counts);\n assert(counts != NULL);\n \n gsl_matrix_set_zero(counts);\n \n //go through data, fill up matrix\n for(i = 0; i < snpNumber; i++){\n gsl_matrix_set(counts, data[i].n, data[i].i, gsl_matrix_get(counts, data[i].n, data[i].i) + 1);\n }\n return(counts);\n\n}\n\n\n/* summarizeSFS- returns a matrix of booleans which summarize the SFS conditional\n upon sampleSize. rows = sampleSize, column = freqs */\n\ngsl_matrix *summarizeSFSBool(int maxSampleSize, struct snp data[], int snpNumber){\n gsl_matrix *counts;\n int i;\n\n //alloc matrix of size maxSampleSize by maxSampleSize\n counts = gsl_matrix_alloc(maxSampleSize + 1, maxSampleSize + 1);\n gsl_matrix_set_zero(counts);\n assert(counts != NULL);\n \n gsl_matrix_set_zero(counts);\n \n //go through data, fill up matrix\n for(i = 0; i < snpNumber; i++){\n gsl_matrix_set(counts, data[i].n, data[i].i, 1);\n }\n return(counts);\n\n}\n\n\n\n/* simulateSiteFreq- returns an int representing the frequency of\n of a site (unfolded), i, in sampleSize n, conditional on sel. \n coeff. beta , also needs a pointer to a gsl random number generator */\n\nint simulateSiteFreq(int sampleSize, double alpha, void *r){\n int i;\n double sum, probs[sampleSize - 1], rand;\n gsl_function p;\n struct my_F_params simParams;\n gsl_rng * rn = (gsl_rng *) r;\n \n simParams.n = sampleSize;\n /* put probs in vector */\n for(i = 0; i < sampleSize - 1; i++){\n simParams.i = i + 1;\n p.function = &snpProb;\n p.params = &simParams;\n probs[i] = GSL_FN_EVAL(&p, alpha); \n }\n\n /* choose frequency */\n rand = gsl_rng_uniform(rn);\n sum = 0;\n for(i = 0; i < sampleSize - 1; i++){\n sum += probs[i];\n if (rand <= sum){\n return(i+1);\n }\n }\n return(666);\n}\n\n/* ascertainment stuff -- following Nielsen et al. 2004 */\n\n/* simpleAscertain-- Nielsen et al. 2004 eqn 2 *, returns the prob of ascertainment \ngiven a sample freq */\ndouble simpleAscertain(double sampleFreq, void * p){\n struct my_F_params * params = (struct my_F_params *) p;\n double sampleSize, ascSize,tmpSampleFreq;\n double num1 = 0.0;\n double num2 = 0.0;\n \n sampleSize = params->n;\n ascSize = params->ascSize;\n tmpSampleFreq = (int) sampleFreq;\n\n //test for weirdness\n \n if (sampleFreq < ascSize){\n num1 = 0;\n }\n else{\n num1 = gsl_sf_choose(sampleFreq, ascSize);\n }\n\n if ((sampleSize -sampleFreq) < ascSize){\n num2 = 0;\n }\n else{\n num2 = gsl_sf_choose(sampleSize - sampleFreq, ascSize);\n }\n\n return(1.0 - ((num1 + num2) / gsl_sf_choose(sampleSize, ascSize)));\n}\n\n/* outgroupAscertain-- equivalent to Nielsen et al. 2004 eqn 2,\n returns the prob of ascertainment given a sample freq, but\nis for use when ascertainment was based on single outgroup comparisons\n(e.g. divergence between reference genomes). specifically this\ncalculates the prob of sampling only ancestral alleles.\nIMPORTANT- sampleFreq here is derived allele freq */\ndouble outgroupAscertain(double sampleFreq, void * p){\n struct my_F_params * params = (struct my_F_params *) p;\n double sampleSize, ascSize;\n double num = 0.0;\n \n sampleSize = params->n;\n ascSize = params->ascSize;\n \n //test for weirdness\n if ((sampleSize - sampleFreq) < ascSize){\n num = 0;\n }\n else{\n num = gsl_sf_choose((sampleSize - sampleFreq), ascSize);\n }\n\n return(num / gsl_sf_choose(sampleSize, ascSize));\n}\n\n/* probAscertainmentGivenModel-- Nielsen et al. 2005 eqn 8\n returns the prob of ascertainment given the model */\ndouble probAscertainmentGivenModel(double beta, void *p){\n struct my_F_params * params = (struct my_F_params *) p;\n struct my_F_params tempParams;\n \n long double tot, tmpres, tmpres2;\n int i=1;\n gsl_function F, G;\n \n /* add up total prob space */\n tot = 0.0;\n tempParams.n = params->n;\n tempParams.ascSize = params->ascSize;\n \n for(i = 1; i < params->n ; i++){\n tempParams.i = i;\n \n F.function = &(snpProb);\n F.params = &tempParams;\n tmpres = 0.0;\n tmpres = GSL_FN_EVAL(&F, beta);\n G.function = &simpleAscertain;\n G.params = &tempParams;\n tmpres2 = GSL_FN_EVAL(&G, i) ;\n tot += tmpres * tmpres2;\n \n }\n \n \n return(tot) ;\n}\n\n/* probAscertainmentGivenModel-- Nielsen et al. 2005 eqn 8\n returns the prob of ascertainment given the model */\ndouble probOutgroupAscertainmentGivenModel(double beta, void *p){\n struct my_F_params * params = (struct my_F_params *) p;\n struct my_F_params tempParams;\n \n long double tot, tmpres, tmpres2;\n int i=1;\n gsl_function F, G;\n \n /* add up total prob space */\n tot = 0.0;\n tempParams.n = params->n;\n tempParams.ascSize = params->ascSize;\n \n for(i = 1; i < params->n ; i++){\n tempParams.i = i;\n \n F.function = &(snpProb);\n F.params = &tempParams;\n tmpres = 0.0;\n tmpres = GSL_FN_EVAL(&F, beta);\n G.function = &outgroupAscertain;\n G.params = &tempParams;\n tmpres2 = GSL_FN_EVAL(&G, i) ;\n tot += tmpres * tmpres2;\n \n }\n \n \n return(tot) ;\n}\n\n/* probAscertainmentGivenModelLookup-- Nielsen et al. 2005 eqn 8\n returns the prob of ascertainment given the model, lookup version\n requires snpProb matrix and ascProb matrix */\ndouble probAscertainmentGivenModelLookup(double beta, int sampSize, gsl_matrix *snpProbs, gsl_matrix *ascProbs){\n \n long double tot;\n int i=1;\n \n /* add up total prob space */\n tot = 0.0;\n \n for(i = 1; i < sampSize ; i++){\n tot += gsl_matrix_get(snpProbs, sampSize, i) * gsl_matrix_get(ascProbs, sampSize, i);\n }\n return(tot) ;\n}\n\n/* probAscertainmentGivenModelHemiLookup-- same\n as above but expects vector not matrix of snpProbs */\ndouble probAscertainmentGivenModelHemiLookup(double beta, int sampSize, gsl_vector *snpProbs, gsl_matrix *ascProbs){\n \n long double tot;\n int i=1;\n \n /* add up total prob space */\n tot = 0.0;\n \n for(i = 1; i < sampSize ; i++){\n tot += gsl_vector_get(snpProbs, i) * gsl_matrix_get(ascProbs, sampSize, i);\n }\n return(tot) ;\n}\n\n\n/* ascSize vector - returns a vector of 1s or 0s depending on ascertainment sample sizes in the data */\ngsl_vector *ascSizeVector(struct snp data[], int snpNumber, int maxSampleSize){\n gsl_vector *bools;\n int i;\n\n //alloc and initialize bools vector\n bools = gsl_vector_alloc(maxSampleSize + 1);\n gsl_vector_set_zero(bools);\n\n //go through data, set each sampleSize value to 1\n for(i = 0; i < snpNumber; i++){\n gsl_vector_set(bools,data[i].ascSize, 1);\n }\n return(bools);\n}\n\n/* snpAscMatrix- returns a matrix of simpleAscertainment probs. matrix is maxSampleSize+1 by maxSampleSize. rows represent\n variable sampleSizes (2 to max), columns represent freqs (1 to max -1). Currently this only supports a single ascertainment size */\ngsl_matrix *snpAscMatrix(int maxSampleSize, gsl_vector *sampleSizeVector, gsl_matrix *sfsBools, \\\n\t\t int ascSize){\n gsl_matrix *probs;\n struct my_F_params FParams;\n gsl_function f;\n int i, j;\n \n //alloc probs\n probs = gsl_matrix_alloc(maxSampleSize + 1, maxSampleSize);\n gsl_matrix_set_zero(probs);\n //go through sampleSizes\n for(i = 2; i <= maxSampleSize; i++){\n //have sample size i?\n if (gsl_vector_get(sampleSizeVector, i)){\n //go through freqs\n for(j = 1; j < maxSampleSize; j++){\n\t//have freq j?\n\tif(gsl_matrix_get(sfsBools, i, j)){\n\t //calc prob\n\t FParams.i = j;\n\t FParams.n = i;\n\t FParams.ascSize = ascSize;\n\t f.function = &simpleAscertain;\n\t f.params = &FParams;\n\t gsl_matrix_set(probs, i, j, GSL_FN_EVAL(&f, j));\n\t}\n }\n }\n }\n return(probs);\n}\n\n/* snpOutgroupAscMatrix- returns a matrix of outgroupAscertainment probs. matrix is maxSampleSize+1 by maxSampleSize. rows represent\n variable sampleSizes (2 to max), columns represent freqs (1 to max -1). Currently this only supports a single ascertainment size */\ngsl_matrix *snpOutgroupAscMatrix(int maxSampleSize, gsl_vector *sampleSizeVector, int ascSize){\n gsl_matrix *probs;\n struct my_F_params FParams;\n gsl_function f;\n int i, j;\n \n //alloc probs\n probs = gsl_matrix_alloc(maxSampleSize + 1, maxSampleSize);\n gsl_matrix_set_zero(probs);\n //go through sampleSizes\n for(i = 2; i <= maxSampleSize; i++){\n //have sample size i?\n if (gsl_vector_get(sampleSizeVector, i)){\n //go through freqs\n for(j = 1; j < i; j++){\n\t//calc prob\n\tFParams.i = j;\n\tFParams.n = i;\n\tFParams.ascSize = ascSize;\n\tf.function = &outgroupAscertain;\n\tf.params = &FParams;\n\tgsl_matrix_set(probs, i, j, GSL_FN_EVAL(&f, j));\n }\n }\n }\n return(probs);\n}\n\n\n/*estimateAscSFS-- ML estimates of SFS, given ascertainment. returns \n a matrix of probs. matrix is maxSampleSize+1 by maxSampleSize. rows represent\nvariable sampleSizes (2 to max), columns represent freqs (1 to max -1). Currently this only supports a single ascertainment size */\n\ngsl_matrix *estimateAscSFS(int maxSampleSize, gsl_vector *sampleSizeVector, gsl_matrix *sfsBools, \\\n\t\t\t int ascSize, gsl_matrix *sfsSummary){\n gsl_matrix *probs, *ascProbs;\n int i, j;\n double ssTmp, p_hat; \n double xij;\n\n //alloc probs\n probs = gsl_matrix_alloc(maxSampleSize + 1, maxSampleSize);\n gsl_matrix_set_zero(probs);\n //calculate ascProbs\n ascProbs = snpAscMatrix(maxSampleSize, sampleSizeVector, sfsBools, \\\n\t\t\t ascSize);\n \n\n //go through sampleSizes \n for(i = 2; i <= maxSampleSize; i++){\n //have sample size i?\n if (gsl_vector_get(sampleSizeVector, i)){\n //go through freqs to tally up denom at sampleSize\n ssTmp = 0.0;\n for(j = 1; j < maxSampleSize; j++){\n\txij = gsl_matrix_get(sfsSummary, i, j);\n\tif (xij > 0){\n\t ssTmp += xij / gsl_matrix_get(ascProbs, i, j);\n\t}\n }\n //go back through freqs to assign p_hats at sampleSize\n for(j = 1; j < maxSampleSize; j++){\n\txij = gsl_matrix_get(sfsSummary, i, j);\n\tp_hat = (double) xij / gsl_matrix_get(ascProbs, i, j);\n\tgsl_matrix_set(probs, i, j, p_hat / ssTmp);\n }\n }\n }\n return(probs);\n}\n\n/* weighted likelihood function for SFS given the data and ascertainment; here contains the data and the weights and uses the snpProbLookup routine */\ndouble weightedLikLookAsc(double beta, void * p){\n struct my_lik_params * params = (struct my_lik_params *) p;\n double lik, num;\n int i;\n gsl_matrix *probs, *ascProbs;\n gsl_vector *ascDenoms;\n\n \n //make prob matrix (note this is in logs)\n probs = snpProbMatrix(beta, params->maxSampleSize, params->sampleSizeVector, params->sfsBools);\n //make ascProb matrix (NOT in logs!)\n ascProbs = snpAscMatrix(params->maxSampleSize, params->sampleSizeVector, params->sfsBools, params->ascSize);\n\n //make vector of denoms\n ascDenoms = gsl_vector_alloc(params->maxSampleSize + 1);\n gsl_vector_set_zero(ascDenoms);\n for(i = params->ascSize; i <= params->maxSampleSize; i++){\n gsl_vector_set(ascDenoms,i,probAscertainmentGivenModelLookup(beta, i, probs, ascProbs));\n }\n\n //now go and tally likelihood\n lik = 0;\n num = 0;\n for(i = 0; i < params->snpNumber; i++){\n lik += gsl_matrix_get(probs,params->data[i].n,params->data[i].i)\t\\\n + log(gsl_matrix_get(ascProbs,params->data[i].n,params->data[i].i)) \\\n - log(gsl_vector_get(ascDenoms, params->data[i].n));\n }\n gsl_matrix_free(probs);\n gsl_matrix_free(ascProbs);\n gsl_vector_free(ascDenoms);\n \n return -lik;\n}\n \n\n/* weighted likelihood function for SFS given the data and outgroup ascertainment; here contains the data and the weights and uses the snpProbLookup routine */\ndouble weightedLikLookOutgroupAsc(double beta, void * p){\n struct my_lik_params * params = (struct my_lik_params *) p;\n double lik, num;\n int i;\n gsl_matrix *probs, *ascProbs;\n gsl_vector *ascDenoms;\n\n \n //make prob matrix \n probs = snpProbMatrixNotLogFull(beta, params->maxSampleSize, params->sampleSizeVector);\n //make ascProb matrix \n ascProbs = snpOutgroupAscMatrix(params->maxSampleSize, params->sampleSizeVector, params->ascSize);\n\n //make vector of denoms\n ascDenoms = gsl_vector_alloc(params->maxSampleSize + 1);\n gsl_vector_set_zero(ascDenoms);\n for(i = params->ascSize; i <= params->maxSampleSize; i++){\n gsl_vector_set(ascDenoms,i,probAscertainmentGivenModelLookup(beta, i, probs, ascProbs));\n }\n\n //now go and tally likelihood\n lik = 0;\n num = 0;\n for(i = 0; i < params->snpNumber; i++){\n num = (gsl_matrix_get(probs,params->data[i].n,params->data[i].i) * gsl_matrix_get(ascProbs,params->data[i].n,params->data[i].i)) \\\n / gsl_vector_get(ascDenoms, params->data[i].n); \n lik += log(num);\n //printf(\"first: %f\\t second: %f\\t third: %f\\n\",gsl_matrix_get(probs,params->data[i].n,params->data[i].i),gsl_matrix_get(ascProbs,params->data[i].n,params->data[i].i),gsl_vector_get(ascDenoms, params->data[i].n));\n }\n \n gsl_matrix_free(probs);\n gsl_matrix_free(ascProbs);\n gsl_vector_free(ascDenoms);\n \n return -lik;\n}\n\n\n/* wrapper for my_lik for use in mnbrak */\ndouble wlikWrapLookAsc(double beta, void * p){\n\tgsl_function f;\n\tstruct my_lik_params * params = (struct my_lik_params *) p;\n\t\n\tf.function = &weightedLikLookAsc;\n\tf.params = params;\n\treturn GSL_FN_EVAL(&f, beta);\n}\n\n/* wrapper for my_lik for use in mnbrak */\ndouble wlikWrapLookOutgroupAsc(double beta, void * p){\n\tgsl_function f;\n\tstruct my_lik_params * params = (struct my_lik_params *) p;\n\t\n\tf.function = &weightedLikLookOutgroupAsc;\n\tf.params = params;\n\treturn GSL_FN_EVAL(&f, beta);\n}\n\n/* get weighted ML estimate of beta using likelihood function (lookup) conditional on ascertainment\n; BRENT method for gsl */\ndouble weighted_ml_est_lookup_asc(double * lik_beta_hat, void * p){\n\tint status;\n\tint iter = 0;\n\tint max_iter = 100;\n\tconst gsl_min_fminimizer_type *T;\n\tgsl_min_fminimizer *s;\n\tdouble m, a, b, ax, bx, cx, fa, fb, fc, dummy;\n\tgsl_function L;\n\tstruct my_lik_params * params = (struct my_lik_params *) p;\t\n\t\n\t\n\t// get minimum bracket \n\tax = -20.0;\n\tbx = -1.0;\n\tcx = 20;\n\tL.function = &weightedLikLookAsc;\n\tL.params = params;\n\tmnbrak2(&ax, &bx, &cx, &fa, &fb, &fc, &wlikWrapLookAsc, bx, params);\n\t//swap bounds if needed\n\tif (cx < ax){\n\t dummy = cx;\n\t cx = ax;\n\t ax = dummy;\n\t}\n\t// do mimization \n\t\t\n\t//initialize lik function\n\tL.function = &weightedLikLookAsc;\n\tL.params = params;\n\t \n\t//min routine\n\tT = gsl_min_fminimizer_brent;\n\ts = gsl_min_fminimizer_alloc(T);\n\tgsl_min_fminimizer_set(s, &L, bx, ax, cx);\n\tdo{\n\t iter++;\n\t status = gsl_min_fminimizer_iterate(s);\n\t m = gsl_min_fminimizer_x_minimum (s);\n\t a = gsl_min_fminimizer_x_lower (s);\n\t b = gsl_min_fminimizer_x_upper (s);\n\t status = gsl_min_test_interval (a, b, 0.001, 0.0);\n\t}\n\twhile (status == GSL_CONTINUE && iter < max_iter);\n\t*lik_beta_hat = gsl_min_fminimizer_f_minimum(s);\n\tgsl_min_fminimizer_free(s);\n\treturn m;\n}\n\n/* get weighted ML estimate of beta using likelihood function (lookup) conditional on outgroup ascertainment\n; BRENT method for gsl */\ndouble weighted_ml_est_lookup_outgroup_asc(double * lik_beta_hat, void * p){\n\tint status;\n\tint iter = 0;\n\tint max_iter = 100;\n\tconst gsl_min_fminimizer_type *T;\n\tgsl_min_fminimizer *s;\n\tdouble m, a, b, ax, bx, cx, fa, fb, fc, dummy;\n\tgsl_function L;\n\tstruct my_lik_params * params = (struct my_lik_params *) p;\t\n\t\n\t\n\t// get minimum bracket \n\tax = -20.0;\n\tbx = -1.0;\n\tcx = 20;\n\tL.function = &weightedLikLookOutgroupAsc;\n\tL.params = params;\n\tmnbrak2(&ax, &bx, &cx, &fa, &fb, &fc, &wlikWrapLookOutgroupAsc, bx, params);\n\t//swap bounds if needed\n\tif (cx < ax){\n\t dummy = cx;\n\t cx = ax;\n\t ax = dummy;\n\t}\n\t// do mimization \n\t\t\n\t//initialize lik function\n\tL.function = &weightedLikLookOutgroupAsc;\n\tL.params = params;\n\t \n\t//min routine\n\tT = gsl_min_fminimizer_brent;\n\ts = gsl_min_fminimizer_alloc(T);\n\tgsl_min_fminimizer_set(s, &L, bx, ax, cx);\n\tdo{\n\t iter++;\n\t status = gsl_min_fminimizer_iterate(s);\n\t m = gsl_min_fminimizer_x_minimum (s);\n\t a = gsl_min_fminimizer_x_lower (s);\n\t b = gsl_min_fminimizer_x_upper (s);\n\t status = gsl_min_test_interval (a, b, 0.001, 0.0);\n\t}\n\twhile (status == GSL_CONTINUE && iter < max_iter);\n\t*lik_beta_hat = gsl_min_fminimizer_f_minimum(s);\n\tgsl_min_fminimizer_free(s);\n\treturn m;\n}\n\n/* likelihood function for SFS where each SNP has\n independent selection coeff and outgroup ascertainment */\ndouble sfsLikBetaVectorOutgroupAsc(gsl_vector *betas, void * p){\n struct my_lik_params * params = (struct my_lik_params *) p;\n double pSNP, pAsc, pAscModel,lik, tmp;\n int i;\n gsl_matrix *ascProbs;\n gsl_vector *snpProbs;\n\t\n lik = 0;\n //make ascProb matrix \n ascProbs = snpOutgroupAscMatrix(params->maxSampleSize, params->sampleSizeVector, \\\n\t\t\t\t params->ascSize);\n //go through snps\n for(i = 0; i < params->snpNumber; i++){\n //create vector of snpProbs, find pSNP_i\n snpProbs = snpProbVectorNotLog(gsl_vector_get(betas, i), params->data[i].n);\n pSNP = gsl_vector_get(snpProbs, params->data[i].i);\n\n //lookup pAsc_i\n pAsc = gsl_matrix_get(ascProbs, params->data[i].n, params->data[i].i);\n \n //get pAscModel\n pAscModel = probAscertainmentGivenModelHemiLookup(gsl_vector_get(betas, i),params->data[i].n, \\\n\t\t\t\t\t\t snpProbs, ascProbs);\n tmp = pSNP * pAsc / pAscModel;\n lik += log(tmp);\n gsl_vector_free(snpProbs);\n }\n gsl_matrix_free(ascProbs);\n return -lik;\n}\n", "meta": {"hexsha": "71b0bcff1d74893f69ca40a52abebccddb298536", "size": 37252, "ext": "c", "lang": "C", "max_stars_repo_path": "hmm/popGenTools.c", "max_stars_repo_name": "andrewkern/segSiteHMM", "max_stars_repo_head_hexsha": "ad97da6f6bc94f91e72d75f37fa33ca949d9bb60", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "hmm/popGenTools.c", "max_issues_repo_name": "andrewkern/segSiteHMM", "max_issues_repo_head_hexsha": "ad97da6f6bc94f91e72d75f37fa33ca949d9bb60", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "hmm/popGenTools.c", "max_forks_repo_name": "andrewkern/segSiteHMM", "max_forks_repo_head_hexsha": "ad97da6f6bc94f91e72d75f37fa33ca949d9bb60", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.5328898744, "max_line_length": 217, "alphanum_fraction": 0.6796950499, "num_tokens": 11352, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8418256472515684, "lm_q2_score": 0.6039318337259583, "lm_q1q2_score": 0.5084053068221814}} {"text": "/** Fit a set of points to a model that is subject to rotation and translation.\n *\n * The model is defined by a set of primitive faces such as plane, cylinder, sphere, etc.\n * The measured points are first translated by (xt, yt, zt),\n * then rotated about x-y-z axes by g, b, a angles in sequence,\n *\n * These 6 parameters are the output of the fit.\n *\n * Author: Yuan Mei\n */\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#ifdef LINE_MAX\n#undef LINE_MAX\n#define LINE_MAX 4096\n#endif\n\n#ifndef LINE_MAX\n#define LINE_MAX 4096\n#endif\n\n/** Check if the character is a field separator. */\n#ifndef sepq\n#define sepq(a) ((a)==' ' || (a)=='\\t')\n#endif\n\n#define NDIM 3 /**< number of dimensions */\n\nenum {\n FACE_PLANE=1,\n FACE_CYLINDER=2,\n FACE_SPHERE=3,\n FACE_LINE=12,\n FACE_POINT=13\n};\n\nstruct face {\n int ftype; /**< type of face: plane, cylinder etc... */\n double x0; /**< origin */\n double y0;\n double z0;\n double nx; /**< normal vector */\n double ny;\n double nz;\n double r; /**< radius */\n};\n\nstruct data {\n double pr; /**< probe radius */\n const struct face *faces;\n size_t n; /**< number of measured data points */\n size_t *fid; /**< idx of face in the registered faces */\n double *x; /**< measured point */\n double *y;\n double *z;\n double *w; /**< weights */\n double *x1; /**< after transformation */\n double *y1;\n double *z1;\n};\n\n/** Distance from measured point to face. */\nint dist_f(const gsl_vector *p, void *data, gsl_vector *f)\n{\n double pr = ((struct data *)data)->pr;\n const struct face *faces = ((struct data *)data)->faces;\n size_t n = ((struct data *)data)->n;\n size_t *fid = ((struct data *)data)->fid;\n double *x = ((struct data *)data)->x;\n double *y = ((struct data *)data)->y;\n double *z = ((struct data *)data)->z;\n\n double a = gsl_vector_get(p, 0), Ca = cos(a), Sa = sin(a);\n double b = gsl_vector_get(p, 1), Cb = cos(b), Sb = sin(b);\n double g = gsl_vector_get(p, 2), Cg = cos(g), Sg = sin(g);\n double xt = gsl_vector_get(p, 3);\n double yt = gsl_vector_get(p, 4);\n double zt = gsl_vector_get(p, 5);\n\n size_t i;\n for (i = 0; i < n; i++) {\n int ftype = faces[fid[i]].ftype;\n double x0 = faces[fid[i]].x0;\n double y0 = faces[fid[i]].y0;\n double z0 = faces[fid[i]].z0;\n double nx = faces[fid[i]].nx;\n double ny = faces[fid[i]].ny;\n double nz = faces[fid[i]].nz;\n double r = faces[fid[i]].r;\n\n double x1, y1, z1;\n x1 = Ca*Cb * (x[i]+xt) + (Ca*Sb*Sg-Sa*Cg) * (y[i]+yt) + (Ca*Sb*Cg+Sa*Sg) * (z[i]+zt);\n y1 = Sa*Cb * (x[i]+xt) + (Sa*Sb*Sg+Ca*Cg) * (y[i]+yt) + (Sa*Sb*Cg-Ca*Sg) * (z[i]+zt);\n z1 = - Sb * (x[i]+xt) + Cb*Sg * (y[i]+yt) + Cb*Cg * (z[i]+zt);\n\n ((struct data *)data)->x1[i] = x1;\n ((struct data *)data)->y1[i] = y1;\n ((struct data *)data)->z1[i] = z1;\n\n double d, dist=0.0;\n switch (ftype) {\n case FACE_PLANE:\n d = -(nx*x0 + ny*y0 + nz*z0);\n dist = fabs(nx*x1 + ny*y1 + nz*z1 + d)\n / sqrt(nx*nx + ny*ny + nz*nz);\n dist -= pr;\n break;\n case FACE_CYLINDER:\n case FACE_LINE:\n {\n double dx = x1 - x0, dy = y1 - y0, dz = z1 - z0;\n double s1 = dy * nz - dz * ny, s2 = dz*nx - dx*nz, s3 = dx*ny - dy*nx;\n dist = fabs(sqrt((s1*s1 + s2*s2 + s3*s3)/(nx*nx + ny*ny + nz*nz)) - r);\n if (ftype == FACE_CYLINDER)\n dist -= pr;\n }\n break;\n case FACE_SPHERE:\n case FACE_POINT:\n dist = fabs(sqrt((x1-x0)*(x1-x0) + (y1-y0)*(y1-y0) + (z1-z0)*(z1-z0)) - r);\n if (ftype == FACE_SPHERE)\n dist -= pr;\n break;\n default:\n dist = 0.0;\n break;\n }\n gsl_vector_set(f, i, dist);\n }\n\n return GSL_SUCCESS;\n}\n\nvoid callback(const size_t iter, void *params,\n const gsl_multifit_nlinear_workspace *w)\n{\n gsl_vector *f = gsl_multifit_nlinear_residual(w);\n gsl_vector *x = gsl_multifit_nlinear_position(w);\n double rcond=0;\n\n /* compute reciprocal condition number of J(x) */\n /* cond(J) = %8.4f, 1.0 / rcond */\n gsl_multifit_nlinear_rcond(&rcond, w);\n\n fprintf(stderr, \"iter %2zu: a = %7.4f, b = %7.4f, g = %7.4f, xt = %7.4f, yt = %7.4f, zt = %7.4f, |f(x)| = %.4f\\n\",\n iter,\n gsl_vector_get(x, 0),\n gsl_vector_get(x, 1),\n gsl_vector_get(x, 2),\n gsl_vector_get(x, 3),\n gsl_vector_get(x, 4),\n gsl_vector_get(x, 5),\n gsl_blas_dnrm2(f));\n}\n\n/** Read a long line from file.\n * @param[inout] s string of the line, is allocated when s==NULL and n==0 and grown as needed.\n * @param[inout] n current size of s\n * @return s\n */\nstatic char *file_read_long_line(char **s, size_t *n, FILE *fp)\n{\n const int bufsz = LINE_MAX;\n char *p;\n size_t cnt, sz;\n\n if ( *s == NULL && *n == 0 ) {\n *n = bufsz;\n if ( (*s = calloc(*n, sizeof(char))) == NULL ) exit(-1);\n }\n p = *s;\n sz = *n;\n while ( 1 ) {\n if ( fgets(p, sz, fp) == NULL ) return NULL;\n cnt = strlen(*s);\n if ( (*s)[cnt-1] == '\\n' ) {\n break;\n } else { /* line too long, expand the buffer */\n *n += bufsz;\n if ( (*s = realloc(*s, (*n)*sizeof(char))) == NULL ) exit(-1);\n p = *s + cnt;\n sz = bufsz;\n }\n }\n\n return *s;\n}\n\n/** Read face definition file.\n *\n * @param[inout] n number of faces read from file. If the given value\n * *n > 0, *n is interpreted as the number of elements in the faces\n * array and only up to *n faces will be read from file. However, if\n * the file contains less than *n faces, *n will be updated to reflect\n * the available number of elements.\n *\n * @param[inout] faces array of faces. If *faces != NULL, *faces will\n * be used rather than allocated.\n */\nint read_faces(const char *fname, size_t *n, struct face **faces)\n{\n char *linebuf = NULL;\n size_t linen = 0;\n FILE *fp;\n if ((fp = fopen(fname, \"r\"))==NULL) {\n perror(fname);\n return -1;\n }\n struct face fc;\n int fid;\n size_t lid = 0;\n ssize_t nelem = -1;\n if (*faces == NULL) {\n /* get number of elements in the file */\n while (file_read_long_line(&linebuf, &linen, fp)) {\n lid++;\n if (linebuf[0] == '#' || linebuf[0] == '\\n') continue;\n int ret = sscanf(linebuf, \"%d %d %lf %lf %lf %lf %lf %lf %lf\", &fid, &fc.ftype,\n &fc.x0, &fc.y0, &fc.z0, &fc.nx, &fc.ny, &fc.nz, &fc.r);\n if (ret < 9 || fid < 0 || fc.ftype <= 0) {\n fprintf(stderr, \"Malformatted face at line %zd\\n\", lid);\n } else {\n if (fid > nelem) nelem = fid;\n }\n }\n nelem++;\n if (nelem == 0) {\n fprintf(stderr, \"No valid face in file.\\n\");\n return -1;\n } else {\n fprintf(stderr, \"%zd faces available in file.\\n\", nelem);\n }\n *n = nelem;\n if ((*faces = calloc(nelem, sizeof(struct face))) == NULL) {\n perror(\"calloc *faces\");\n return -1;\n }\n }\n rewind(fp);\n nelem = 0;\n lid = 0;\n while (file_read_long_line(&linebuf, &linen, fp) && (nelem < *n)) {\n lid++;\n if (linebuf[0] == '#' || linebuf[0] == '\\n') continue;\n int ret = sscanf(linebuf, \"%d %d %lf %lf %lf %lf %lf %lf %lf\", &fid, &fc.ftype,\n &fc.x0, &fc.y0, &fc.z0, &fc.nx, &fc.ny, &fc.nz, &fc.r);\n if (ret < 9 || fid < 0 || fc.ftype <= 0) {\n fprintf(stderr, \"Malformatted face at line %zd, skipped.\\n\", lid);\n } else {\n if (fid >= *n) break;\n struct face *fc1 = *faces;\n memcpy(&fc1[fid], &fc, sizeof(fc));\n nelem++;\n }\n }\n\n fprintf(stderr, \"%zd faces constructed.\\n\", nelem);\n free(linebuf);\n fclose(fp);\n return 0;\n}\n\nint read_points(const char *fname, size_t *n, struct data *data)\n{\n char *linebuf = NULL;\n size_t linen = 0;\n FILE *fp;\n if ((fp = fopen(fname, \"r\"))==NULL) {\n perror(fname);\n return -1;\n }\n\n int fidmax = -1;\n *n = 0;\n size_t lid = 0;\n while (file_read_long_line(&linebuf, &linen, fp)) {\n lid++;\n if (linebuf[0] == '#' || linebuf[0] == '\\n') continue;\n int ret = 0;\n for (int i=0; i fidmax) fidmax = fid;\n }\n }\n fprintf(stderr, \"%zd points in file. fidmax = %d\\n\", *n, fidmax);\n data->n = *n;\n data->fid = calloc(data->n, sizeof(size_t));\n data->x = calloc(data->n, sizeof(double));\n data->y = calloc(data->n, sizeof(double));\n data->z = calloc(data->n, sizeof(double));\n data->w = calloc(data->n, sizeof(double));\n data->x1 = calloc(data->n, sizeof(double));\n data->y1 = calloc(data->n, sizeof(double));\n data->z1 = calloc(data->n, sizeof(double));\n\n rewind(fp);\n\n lid = 0;\n size_t idx = 0;\n while (file_read_long_line(&linebuf, &linen, fp)) {\n lid++;\n if (linebuf[0] == '#' || linebuf[0] == '\\n') continue;\n int fid = 0, ret = 0;\n double x, y, z, s;\n // ret = sscanf(linebuf, \"%*d;%d;%*s ;%*d;%lf;%lf;%lf;;%lf\", &fid, &x, &y, &z, &s);\n char *buf = linebuf, *endptr;\n for (; *buf != ';' ; buf++){;} buf++; /* find the next character past a ';' */\n fid = strtol(buf, &endptr, 0); if (endptr > buf) ret++; buf = endptr++;\n for (; *buf != ';' ; buf++){;} buf++;\n for (; *buf != ';' ; buf++){;} buf++;\n for (; *buf != ';' ; buf++){;} buf++;\n x = strtod(buf, &endptr); if (endptr > buf) ret++; buf = endptr++;\n for (; *buf != ';' ; buf++){;} buf++;\n y = strtod(buf, &endptr); if (endptr > buf) ret++; buf = endptr++;\n for (; *buf != ';' ; buf++){;} buf++;\n z = strtod(buf, &endptr); if (endptr > buf) ret++; buf = endptr++;\n for (; *buf != ';' ; buf++){;} buf++;\n for (; *buf != ';' ; buf++){;} buf++;\n s = strtod(buf, &endptr); if (endptr > buf) ret++; buf = endptr++;\n\n if (ret < 5 || fid < 0) {\n fprintf(stderr, \"Malformatted point at line %zd, skipped.\\n\", lid);\n } else {\n data->fid[idx] = fid;\n data->x[idx] = x;\n data->y[idx] = y;\n data->z[idx] = z;\n data->w[idx] = (fabs(s)>1e-8) ? (1.0/(s*s)) : 1.0;\n idx++;\n }\n }\n\n fprintf(stderr, \"%zd points read.\\n\", idx);\n free(linebuf);\n fclose(fp);\n return 0;\n}\n\nint main(int argc, char **argv)\n{\n if (argc != 10) {\n fprintf(stderr,\n \"Usage: %s faces_file points_file pr a b g xt yt zt\\n\\n\"\n \" pr is the probe radius.\\n\"\n \" The last 6 parameters are initial guesses.\\n\"\n \" Points are first translated, then rotated about x(g), y(b), z(a).\\n\"\n \" The 2nd column in points_file shall be faceid,\\n\"\n \" which is the first column of faces_file.\\n\"\n \" The last column in points_file shall be measurement sigma.\\n\", argv[0]);\n return EXIT_FAILURE;\n }\n size_t nfaces=0;\n struct face *faces=NULL;\n read_faces(argv[1], &nfaces, &faces);\n\n size_t nd=0;\n struct data data;\n read_points(argv[2], &nd, &data);\n data.faces = faces;\n\n data.pr = atof(argv[3]);\n\n #define np 6\n double p_init[np] = {0}; /* starting values */\n for (int i=0; ix, i)\n#define ERR(i) sqrt(gsl_matrix_get(covar,i,i))\n\n fprintf(stderr, \"summary from method '%s/%s'\\n\",\n gsl_multifit_nlinear_name(w),\n gsl_multifit_nlinear_trs_name(w));\n fprintf(stderr, \"number of iterations: %zu\\n\",\n gsl_multifit_nlinear_niter(w));\n fprintf(stderr, \"function evaluations: %zu\\n\", fdf.nevalf);\n fprintf(stderr, \"Jacobian evaluations: %zu\\n\", fdf.nevaldf);\n fprintf(stderr, \"reason for stopping: %s\\n\",\n (info == 1) ? \"small step size\" : \"small gradient\");\n fprintf(stderr, \"initial |f(x)| = %f\\n\", sqrt(chisq0));\n fprintf(stderr, \"final |f(x)| = %f\\n\", sqrt(chisq));\n\n {\n double dof = nd - np;\n double c = GSL_MAX_DBL(1, sqrt(chisq / dof));\n\n fprintf(stderr, \"chisq/dof = %g\\n\", chisq / dof);\n\n fprintf(stderr, \"a = %16g +/- %g\\n\", FIT(0), c*ERR(0));\n fprintf(stderr, \"b = %16g +/- %g\\n\", FIT(1), c*ERR(1));\n fprintf(stderr, \"g = %16g +/- %g\\n\", FIT(2), c*ERR(2));\n fprintf(stderr, \"xt = %16g +/- %g\\n\", FIT(3), c*ERR(3));\n fprintf(stderr, \"yt = %16g +/- %g\\n\", FIT(4), c*ERR(4));\n fprintf(stderr, \"zt = %16g +/- %g\\n\", FIT(5), c*ERR(5));\n }\n\n fprintf(stderr, \"status = %s\\n\", gsl_strerror(status));\n\n /* compute residual of every point */\n dist_f(w->x, &data, f); // pure distance, no weights.\n printf(\"# fid ftype distance x1 y1 z1\\n\");\n for (int i=0; i\n#include\n#include \n#include\n#include\n#include\n#include\n#include\n#include\n#include\n#include\n#include\n#include\n#include\n#include \n#include \n#include \n#include \n\n// GLOBAL FILE FOR OUTPUT\nFILE * FOUT;\n\n// Structure needed for numerical integration\nstruct myP { double nlm1; double nl; double nr; double nrp1; double n; double beta;};\n\n// UTILITIES\nint PrintAdjMat(gsl_matrix * X, int a){\n int i,j;\n for (i=0;inlm1);\n double nl=(params->nl);\n double nr=(params->nr);\n double nrp1=(params->nrp1);\n double n=(params->n);\n double beta=(params->beta);\n double res=0;\n res=gsl_ran_beta_pdf(x,1.0,beta);\n //fprintf(stderr,\"Pdf %f\\n\",res);\n // Difference\n double c0,c1;\n double r2=(double )x*n/2.;\n if (x*n<=GSL_MIN_DBL(nr-nlm1,nrp1-nl)){\n // case '\n c0=GSL_MIN_DBL(n,nr-r2);\n c1=GSL_MIN_DBL(n,nl+r2);\n }\n else{\n if (x*n<=GSL_MAX_DBL(nr-nlm1,nrp1-nl)){\n // case ''\n if ((nr-nlm1)<=(nrp1-nl)){\n\t// a<=b\n\tc0=GSL_MIN_DBL(n,nlm1+r2);\n\tc1=GSL_MIN_DBL(n,nl+r2);\n }\n else{\n\t// bnlm1);\n double nrp1=(params->nrp1);\n double n=(params->n);\n double beta=(params->beta);\n double res=0;\n res=gsl_ran_beta_pdf(x,1.0,beta);\n double r2=(double )x*n/2.;\n double c1=nrp1-r2;\n double c0=nlm1+r2;\n res*=(c1-c0);\n //fprintf(stderr,\"Center %f (%f)\\n\",res,(c1-c0));\n // Normalization\n if ((n+r2)<1.0){\n res/=(n-r2);\n }\n else{\n res/=(1.0-2.0*r2);\n }\n return (res);\n}\n\ndouble IntegrateBasal(double GapLeft, double GapRight, double n, double Beta){\n double error;\n double result;\n double low,upp;\n gsl_function F;\n struct myP params = { 0., 0., 0., 0., 0., 0.}; \n // setup the environment\n gsl_integration_workspace * w= gsl_integration_workspace_alloc (10000);\n params.beta=Beta;\n params.nlm1=GapLeft;\n params.nl=0.0;\n params.n=n;\n params.nr=0.0;\n params.nrp1=GapRight;\n \n F.function = &InteBasal;\n F.params = ¶ms;\n low=GSL_MIN_DBL(0.0,1.0);\n upp=GSL_MIN_DBL((GapRight-GapLeft)/n,1.0);\n gsl_integration_qags(&F,low,upp,0,1e-4,10000,w,&result, &error);\n //fprintf(stderr,\"Prob %f\\n\",result);\n if (result==0.0) {\n fprintf(FOUT,\"The diet is incompatible with the niche model!!\\n\");\n return -10000000.0; // The diet is impossible!\n }\n return (result);\n}\n\n// COMPUTE THE LIKELIHOOD OF A MATRIX PERFECTLY COMPATIBLE WITH THE NICHE MODEL\ndouble ComputeLikelihood(gsl_matrix *A, gsl_vector *Pos, int N, double Beta){\n double Prob=0.0;\n int i,j;\n double nlm1, nl, n, nr, nrp1;\n double TmpProb;\n for (i=0;i-1.0) fprintf(FOUT,\"First Sp 0, LogLikelihood Diet 0.0 (1.0)\\n\");\n for (i=1;i0){\n\t nlm1=gsl_vector_get(Pos,j-1);\n\t}\n\tbreak;\n }\n }\n if (nl>0.0){\n // i is a predator\n // Find the last prey\n for (j=N-1;j>=0;j--){\n\tif (gsl_matrix_get(A,j,i)==1){\n\t nr=gsl_vector_get(Pos,j);\n\t if (j<(N-1)){\n\t nrp1=gsl_vector_get(Pos,j+1);\n\t }\n\t break;\n\t}\n }\n // Now compute the probability\n TmpProb=0.0;\n //fprintf(stderr,\"Computing probability of %d (%f %f %f %f %f) Beta: %f\\n\", i, nlm1, nl, n, nr, nrp1, Beta);\n TmpProb=Integrate(nlm1, nl, n, nr, nrp1, Beta);\n fprintf(FOUT,\"Consumer Sp %d, LogLikelihood Diet %f (%f)\\n\",i,TmpProb,exp(TmpProb));\n Prob+=TmpProb;\n }\n else{\n TmpProb=0.0;\n // for each species compute the probability that the species is not eating any one in between\n double GapLeft, GapRight;\n for (j=0;j<=i;j++){\n\tif (j==0){\n\t GapLeft=0.0;\n\t}\n\telse{\n\t GapLeft=gsl_vector_get(Pos,j-1);\n\t}\n\tGapRight=gsl_vector_get(Pos,j);\n\t//fprintf(stderr,\"Left: %f Right:%f Cumulative: %f\\n\",GapLeft,GapRight,TmpProb);\n\tTmpProb+=IntegrateBasal(GapLeft,GapRight, n,Beta);\n }\n fprintf(FOUT,\"Basal Sp %d, LogLikelihood Diet %f (%f)\\n\",i,log(TmpProb),TmpProb); \n // now that you have summed across all possibilities take the log and sum it \n Prob+=log(TmpProb);\n }\n }\n return Prob;\n}\n\n// READ THE MATRIX AND RUN THE PROBABILITY\n// Main\nint main(int argc, char *argv[]){\n // First argument: number of species\n int Sp=atoi(argv[1]);\n char * FileMat=(argv[2]);\n char * FilePos=(argv[3]);\n // Read the matrix\n FILE * F;\n // matrix\n gsl_matrix * A =gsl_matrix_calloc(Sp,Sp);\n F=fopen(FileMat,\"rb\");\n gsl_matrix_fscanf(F,A);\n fclose(F);\n int i,j;\n double C,Beta;\n C=Beta=0.0;\n // compute the C and Beta\n for (i=0;i\n#include \n#include \n#include \n\n#ifndef M_PI\n #define M_PI 3.14159265358979323846\n#endif\n\n#ifdef __cplusplus\nnamespace codee {\nextern \"C\" {\n#endif\n\nint idft_cblas_s (float *Y, const float *X, const size_t R, const size_t C, const size_t S, const size_t H, const int iscolmajor, const size_t dim, const size_t ndft, const int sc);\nint idft_cblas_d (double *Y, const double *X, const size_t R, const size_t C, const size_t S, const size_t H, const int iscolmajor, const size_t dim, const size_t ndft, const int sc);\nint idft_cblas_c (float *Y, const float *X, const size_t R, const size_t C, const size_t S, const size_t H, const int iscolmajor, const size_t dim, const size_t ndft, const int sc);\nint idft_cblas_z (double *Y, const double *X, const size_t R, const size_t C, const size_t S, const size_t H, const int iscolmajor, const size_t dim, const size_t ndft, const int sc);\n\n\nint idft_cblas_s (float *Y, const float *X, const size_t R, const size_t C, const size_t S, const size_t H, const int iscolmajor, const size_t dim, const size_t ndft, const int sc)\n{\n if (dim>3u) { fprintf(stderr,\"error in idft_cblas_s: dim must be in [0 3]\\n\"); return 1; }\n\n const size_t N = R*C*S*H;\n const size_t Lx = (dim==0u) ? R : (dim==1u) ? C : (dim==2u) ? S : H;\n if (ndft= Lx (length of vecs in X)\\n\"); return 1; }\n\n //Scaling\n const float s = sc ? 2.0f*sqrtf(0.5f*(float)ndft)/(float)ndft : 1.0f/(float)ndft;\n\n if (N==0u || ndft==0u) {}\n else if (ndft==1u)\n {\n for (size_t n=N; n>0u; --n, ++X, ++Y) { *Y = *X; }\n }\n else\n {\n //Init IDFT matrix\n const size_t NN = ndft * ndft;\n const float P2_N = (float)(2.0*M_PI/(double)ndft);\n float *IDFT;\n IDFT = (float *)aligned_alloc(sizeof(float),2u*NN*sizeof(float));\n if (!IDFT) { fprintf(stderr,\"error in idft_cblas_s: problem with aligned_alloc. \"); perror(\"aligned_alloc\"); return 1; }\n for (size_t l=0u; l0u; --nf) { *Xc++ = *X++; *Xc++ = *X++; }\n if (ndft%2u==0u) { X -= 2; }\n for (size_t nf=ndft-ndft/2u; nf>1u; --nf) { X-=2; *Xc++ = *X; *Xc++ = -*(X+1); }\n Xc -= 2u*ndft;\n\n //Matrix multiply\n cblas_cgemv(CblasRowMajor,CblasNoTrans,(int)ndft,(int)ndft,o,IDFT,(int)ndft,Xc,1,z,Yc,1);\n \n //Output real part only\n cblas_scopy((int)ndft,Yc,2,Y,1);\n }\n else\n {\n const size_t K = (iscolmajor) ? ((dim==0u) ? 1u : (dim==1u) ? R : (dim==2u) ? R*C : R*C*S) : ((dim==0u) ? C*S*H : (dim==1u) ? S*H : (dim==2u) ? H : 1u);\n const size_t B = (iscolmajor && dim==0u) ? C*S*H : K;\n const size_t V = N/Lx, G = V/B;\n\n if (K==1u && (G==1u || B==1u))\n {\n for (size_t v=0u; v0u; --nf) { *Xc++ = *X++; *Xc++ = *X++; }\n if (ndft%2u==0u) { X -= 2; }\n for (size_t nf=ndft-ndft/2u; nf>1u; --nf) { X-=2; *Xc++ = *X; *Xc++ = -*(X+1); }\n Xc -= 2u*ndft;\n X += 2u*(ndft-ndft/2u-ndft%2u);\n\n //Matrix multiply\n cblas_cgemv(CblasRowMajor,CblasNoTrans,(int)ndft,(int)ndft,o,IDFT,(int)ndft,Xc,1,z,Yc,1);\n\n //Output real part only\n cblas_scopy((int)ndft,Yc,2,Y,1);\n }\n }\n else\n {\n for (size_t g=G; g>0u; --g, X+=2u*B*(Lx-1u), Y+=B*(ndft-1u))\n {\n for (size_t b=B; b>0u; --b, X+=2u*K*(ndft-ndft/2u-ndft%2u-Lx)+2u, ++Y)\n {\n //Copy into Xc\n for (size_t nf=Lx; nf>0u; --nf, X+=2u*K) { *Xc++ = *X; *Xc++ = *(X+1); }\n if (ndft%2u==0u) { X -= 2u*K; }\n for (size_t nf=ndft-ndft/2u; nf>1u; --nf) { X-=2u*K; *Xc++ = *X; *Xc++ = -*(X+1); }\n Xc -= 2u*ndft;\n\n //Matrix multiply\n cblas_cgemv(CblasRowMajor,CblasNoTrans,(int)ndft,(int)ndft,o,IDFT,(int)ndft,Xc,1,z,Yc,1);\n\n //Output real part only\n cblas_scopy((int)ndft,Yc,2,Y,(int)K);\n }\n }\n }\n }\n free(IDFT); free(Xc); free(Yc);\n }\n\n return 0;\n}\n\n\nint idft_cblas_d (double *Y, const double *X, const size_t R, const size_t C, const size_t S, const size_t H, const int iscolmajor, const size_t dim, const size_t ndft, const int sc)\n{\n if (dim>3u) { fprintf(stderr,\"error in idft_cblas_d: dim must be in [0 3]\\n\"); return 1; }\n\n const size_t N = R*C*S*H;\n const size_t Lx = (dim==0u) ? R : (dim==1u) ? C : (dim==2u) ? S : H;\n if (ndft= Lx (length of vecs in X)\\n\"); return 1; }\n\n //Scaling\n const double s = sc ? 2.0*sqrt(0.5*(double)ndft)/(double)ndft : 1.0/(double)ndft;\n\n if (N==0u || ndft==0u) {}\n else if (ndft==1u)\n {\n for (size_t n=N; n>0u; --n, ++X, ++Y) { *Y = *X; }\n }\n else\n {\n //Init IDFT matrix\n const size_t NN = ndft * ndft;\n const double P2_N = 2.0*M_PI/(double)ndft;\n double *IDFT;\n IDFT = (double *)aligned_alloc(sizeof(double),2u*NN*sizeof(double));\n if (!IDFT) { fprintf(stderr,\"error in idft_cblas_d: problem with aligned_alloc. \"); perror(\"aligned_alloc\"); return 1; }\n for (size_t l=0u; l0u; --nf) { *Xc++ = *X++; *Xc++ = *X++; }\n if (ndft%2u==0u) { X -= 2; }\n for (size_t nf=ndft-ndft/2u; nf>1u; --nf) { X-=2; *Xc++ = *X; *Xc++ = -*(X+1); }\n Xc -= 2u*ndft;\n\n //Matrix multiply\n cblas_zgemv(CblasRowMajor,CblasNoTrans,(int)ndft,(int)ndft,o,IDFT,(int)ndft,Xc,1,z,Yc,1);\n \n //Output real part only\n cblas_dcopy((int)ndft,Yc,2,Y,1);\n }\n else\n {\n const size_t K = (iscolmajor) ? ((dim==0u) ? 1u : (dim==1u) ? R : (dim==2u) ? R*C : R*C*S) : ((dim==0u) ? C*S*H : (dim==1u) ? S*H : (dim==2u) ? H : 1u);\n const size_t B = (iscolmajor && dim==0u) ? C*S*H : K;\n const size_t V = N/Lx, G = V/B;\n\n if (K==1u && (G==1u || B==1u))\n {\n for (size_t v=0u; v0u; --nf) { *Xc++ = *X++; *Xc++ = *X++; }\n if (ndft%2u==0u) { X -= 2; }\n for (size_t nf=ndft-ndft/2u; nf>1u; --nf) { X-=2; *Xc++ = *X; *Xc++ = -*(X+1); }\n Xc -= 2u*ndft;\n X += 2u*(ndft-ndft/2u-ndft%2u);\n\n //Matrix multiply\n cblas_zgemv(CblasRowMajor,CblasNoTrans,(int)ndft,(int)ndft,o,IDFT,(int)ndft,Xc,1,z,Yc,1);\n\n //Output real part only\n cblas_dcopy((int)ndft,Yc,2,Y,1);\n }\n }\n else\n {\n for (size_t g=G; g>0u; --g, X+=2u*B*(Lx-1u), Y+=B*(ndft-1u))\n {\n for (size_t b=B; b>0u; --b, X+=2u*K*(ndft-ndft/2u-ndft%2u-Lx)+2u, ++Y)\n {\n //Copy into Xc\n for (size_t nf=Lx; nf>0u; --nf, X+=2u*K) { *Xc++ = *X; *Xc++ = *(X+1); }\n if (ndft%2u==0u) { X -= 2u*K; }\n for (size_t nf=ndft-ndft/2u; nf>1u; --nf) { X-=2u*K; *Xc++ = *X; *Xc++ = -*(X+1); }\n Xc -= 2u*ndft;\n\n //Matrix multiply\n cblas_zgemv(CblasRowMajor,CblasNoTrans,(int)ndft,(int)ndft,o,IDFT,(int)ndft,Xc,1,z,Yc,1);\n\n //Output real part only\n cblas_dcopy((int)ndft,Yc,2,Y,(int)K);\n }\n }\n }\n }\n free(IDFT); free(Xc); free(Yc);\n }\n\n return 0;\n}\n\n\nint idft_cblas_c (float *Y, const float *X, const size_t R, const size_t C, const size_t S, const size_t H, const int iscolmajor, const size_t dim, const size_t ndft, const int sc)\n{\n if (dim>3u) { fprintf(stderr,\"error in idft_cblas_c: dim must be in [0 3]\\n\"); return 1; }\n\n const size_t N = R*C*S*H;\n const size_t Lx = (dim==0u) ? R : (dim==1u) ? C : (dim==2u) ? S : H;\n if (ndft= Lx (length of vecs in X)\\n\"); return 1; }\n\n //Scaling\n const float s = sc ? 2.0f*sqrtf(0.5f*(float)ndft)/(float)ndft : 1.0f/(float)ndft;\n\n if (N==0u || ndft==0u) {}\n else if (ndft==1u)\n {\n for (size_t n=2u*N; n>0u; --n, ++X, ++Y) { *Y = *X * s; }\n }\n else\n {\n //Init IDFT matrix\n const size_t LN = Lx * ndft;\n const float P2_N = (float)(2.0*M_PI/(double)ndft);\n float *IDFT;\n IDFT = (float *)aligned_alloc(sizeof(float),2u*LN*sizeof(float));\n if (!IDFT) { fprintf(stderr,\"error in idft_cblas_c: problem with aligned_alloc. \"); perror(\"aligned_alloc\"); return 1; }\n for (size_t l=0u; l0u; --g, X+=2u*B*(Lx-1u), Y+=2u*B*(ndft-1u))\n {\n for (size_t b=B; b>0u; --b, X+=2, Y+=2)\n {\n //Matrix multiply\n cblas_cgemv(CblasRowMajor,CblasNoTrans,(int)ndft,(int)Lx,o,IDFT,(int)Lx,X,(int)K,z,Y,(int)K);\n }\n }\n }\n }\n free(IDFT);\n }\n\n return 0;\n}\n\n\nint idft_cblas_z (double *Y, const double *X, const size_t R, const size_t C, const size_t S, const size_t H, const int iscolmajor, const size_t dim, const size_t ndft, const int sc)\n{\n if (dim>3u) { fprintf(stderr,\"error in idft_cblas_z: dim must be in [0 3]\\n\"); return 1; }\n\n const size_t N = R*C*S*H;\n const size_t Lx = (dim==0u) ? R : (dim==1u) ? C : (dim==2u) ? S : H;\n if (ndft= Lx (length of vecs in X)\\n\"); return 1; }\n\n //Scaling\n const double s = sc ? 2.0*sqrt(0.5*(double)ndft)/(double)ndft : 1.0/(double)ndft;\n\n if (N==0u || ndft==0u) {}\n else if (ndft==1u)\n {\n for (size_t n=2u*N; n>0u; --n, ++X, ++Y) { *Y = *X * s; }\n }\n else\n {\n //Init IDFT matrix\n const size_t LN = Lx * ndft;\n const double P2_N = 2.0*M_PI/(double)ndft;\n double *IDFT;\n IDFT = (double *)aligned_alloc(sizeof(double),2u*LN*sizeof(double));\n if (!IDFT) { fprintf(stderr,\"error in idft_cblas_z: problem with aligned_alloc. \"); perror(\"aligned_alloc\"); return 1; }\n for (size_t l=0u; l0u; --g, X+=2u*B*(Lx-1u), Y+=2u*B*(ndft-1u))\n {\n for (size_t b=B; b>0u; --b, X+=2, Y+=2)\n {\n //Matrix multiply\n cblas_zgemv(CblasRowMajor,CblasNoTrans,(int)ndft,(int)Lx,o,IDFT,(int)Lx,X,(int)K,z,Y,(int)K);\n }\n }\n }\n }\n free(IDFT);\n }\n\n return 0;\n}\n\n\n#ifdef __cplusplus\n}\n}\n#endif\n", "meta": {"hexsha": "e2aa546df06a4b39222fe55c69b41f3532f2f8a1", "size": 16375, "ext": "c", "lang": "C", "max_stars_repo_path": "c/idft.cblas.c", "max_stars_repo_name": "erikedwards4/dsp", "max_stars_repo_head_hexsha": "28880ede8ca715c2a5a9b596742070f9bda9830e", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2020-08-26T09:22:40.000Z", "max_stars_repo_stars_event_max_datetime": "2020-08-26T09:22:40.000Z", "max_issues_repo_path": "c/idft.cblas.c", "max_issues_repo_name": "erikedwards4/dsp", "max_issues_repo_head_hexsha": "28880ede8ca715c2a5a9b596742070f9bda9830e", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "c/idft.cblas.c", "max_forks_repo_name": "erikedwards4/dsp", "max_forks_repo_head_hexsha": "28880ede8ca715c2a5a9b596742070f9bda9830e", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2021-10-05T13:50:32.000Z", "max_forks_repo_forks_event_max_datetime": "2021-10-05T13:50:32.000Z", "avg_line_length": 39.9390243902, "max_line_length": 183, "alphanum_fraction": 0.481221374, "num_tokens": 5714, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.84594244507642, "lm_q2_score": 0.600188359260205, "lm_q1q2_score": 0.5077248081389826}} {"text": "#include \n#include \n#include \n#include \n\n#include \"timer.c\"\n#include \"timer.h\"\n\nextern double g (double *t, size_t dim, void *params);\n\ndouble dipole_approx (double r);\n\ndouble gaussian (double *x, int dim);\n\nint main (void)\n{\n double res, err;\n\n size_t dim = 6;\n double x1[] = { 0., 0., 0., 0., 0., 0., };\n double xu[] = { 1., 1., 1., 1., 1., 1., };\n double distmin = 1.001;\n double distmax = 4.;\n double dist;\n int np = 20;\n double nt = (distmax - distmin) / (np - 1);\n double vegas[20], dipole[20], distance[20];\n\n gsl_rng *r = gsl_rng_alloc (gsl_rng_taus2);\n unsigned long seed = 1UL;\n\n gsl_rng_set (r, seed);\n\n size_t calls = 1000000;\n \n dist = distmin;\n\n gsl_monte_function G = { &g, dim, &dist };\n\n gsl_monte_vegas_state *sv = gsl_monte_vegas_alloc (dim);\n\n gsl_monte_vegas_init (sv);\n\n // Vegas Integration\n /*commented so does not output in order to create a proper res \n printf (\"# Stat Dist E(r) ErrEst Dipolapprox\\n\"); */\n \n timer_start ();\n\n for (int i = 0; i < np; i++) {\n gsl_monte_vegas_integrate (&G, x1, xu, dim, calls / 5, r, sv, &res, &err);\n do\n {\n gsl_monte_vegas_integrate (&G, x1, xu, dim, calls, r, sv, &res, &err); }\n while (fabs (gsl_monte_vegas_chisq (sv) - 1.0) > 0.2);\n \n fflush (stdout);\n dist += nt;\n vegas[i] = res;\n distance[i] = dist;\n dipole[i] = -2. / pow (dist, 3.);\n }\n\n timer_stop();\n\n gsl_monte_vegas_free (sv);\n\n\n double sum;\n double x[6];\n\n long i, j, nn;\n\n\n nn = 1000000;\n\n timer_start ();\n double home[20];\n \n dist = distmin;\n for (j = 0; j < np; j++)\n {\n sum = 0.;\n for (i = 0; i < nn; i++)\n {\n\n for (int k = 0; k < (int) dim; k++)\n {\n x[k] = gsl_rng_uniform (r);\n }\n sum += g (x, dim, &dist);\n }\n res = sum/nn;\n dist += nt;\n home[j] = res;\n } \n\n timer_stop ();\n\n gsl_rng_free (r);\n\n double homeerr = 0.0;\n\n for (int e = 0; e < np; e++)\n {\n homeerr += fabs(home[e] - vegas[e]);\n }\n printf(\"# Dist Vegas Home Dipolapprox\\n\");\n for( int l = 0; l < np; l++)\n {\n double dd = distance[l];\n double vv = fabs(vegas[l]);\n double hh = fabs(home[l]);\n double di = fabs(dipole[l]);\n printf(\" %.6f %.6f %.6f %.6f\\n\", dd, vv, hh, di);\n }\n\n return 0;\n}\n", "meta": {"hexsha": "8bb5abd328999908d32ad62315868ed45cd7e0a9", "size": 2524, "ext": "c", "lang": "C", "max_stars_repo_path": "main.c", "max_stars_repo_name": "basantrk/fin2", "max_stars_repo_head_hexsha": "2e3d329923c49728e9c86f503266777f44fe0eaf", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "main.c", "max_issues_repo_name": "basantrk/fin2", "max_issues_repo_head_hexsha": "2e3d329923c49728e9c86f503266777f44fe0eaf", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "main.c", "max_forks_repo_name": "basantrk/fin2", "max_forks_repo_head_hexsha": "2e3d329923c49728e9c86f503266777f44fe0eaf", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 21.0333333333, "max_line_length": 84, "alphanum_fraction": 0.5039619651, "num_tokens": 836, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8459424256566558, "lm_q2_score": 0.600188359260205, "lm_q1q2_score": 0.5077247964834661}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nvoid set_NFW_params(double M, double z, int mode, cosmo_info **cosmo, double *c_vir, double *R_vir) {\n if(mode != NFW_MODE_DEFAULT)\n SID_exit_error(\"Unknown mode (%d) in set_NFW_params()\", SID_ERROR_LOGIC, mode);\n\n switch(ADaPS_exist(*cosmo, \"M_WDM\")) {\n case GBP_FALSE: {\n double Omega_M = ((double *)ADaPS_fetch(*cosmo, \"Omega_M\"))[0];\n double h_Hubble = ((double *)ADaPS_fetch(*cosmo, \"h_Hubble\"))[0];\n\n // Mass-concentration from Munoz-Cuartas et al 2010\n double w = 0.029;\n double m = 0.097;\n double alpha = -110.001;\n double beta = 2469.720;\n double gamma = 16.885;\n double a_z = w * z - m;\n double b_z = alpha / (z + gamma) + beta / pow(z + gamma, 2.);\n double Delta = Delta_vir(z, *cosmo);\n Delta = 200.;\n\n (*c_vir) = take_alog10(a_z * take_log10(M / (M_SOL / h_Hubble)) + b_z);\n (*R_vir) = R_Delta_z(M, Delta, z, *cosmo); // Bullock et al '01\n } break;\n case GBP_TRUE:\n SID_exit_error(\"ENS not working.\", SID_ERROR_LOGIC);\n //(*c_vir)=c_ENS(M,z,*cosmo); // Eke, Navarro and Steinmetz\n //(*R_vir)=R_Delta_z(M,200.,z,*cosmo); // R_200\n break;\n }\n}\n", "meta": {"hexsha": "14afb97a0feffd044bed945a05c378f03218da14", "size": 1507, "ext": "c", "lang": "C", "max_stars_repo_path": "src/gbpAstro/gbpCosmo/NFW_etc/set_NFW_params.c", "max_stars_repo_name": "gbpoole/gbpCode", "max_stars_repo_head_hexsha": "5157d2e377edbd4806258d1c16b329373186d43a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2015-10-20T11:39:53.000Z", "max_stars_repo_stars_event_max_datetime": "2015-10-20T11:39:53.000Z", "max_issues_repo_path": "src/gbpAstro/gbpCosmo/NFW_etc/set_NFW_params.c", "max_issues_repo_name": "gbpoole/gbpCode", "max_issues_repo_head_hexsha": "5157d2e377edbd4806258d1c16b329373186d43a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2017-07-30T11:10:49.000Z", "max_issues_repo_issues_event_max_datetime": "2019-06-18T00:40:46.000Z", "max_forks_repo_path": "src/gbpAstro/gbpCosmo/NFW_etc/set_NFW_params.c", "max_forks_repo_name": "gbpoole/gbpCode", "max_forks_repo_head_hexsha": "5157d2e377edbd4806258d1c16b329373186d43a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4.0, "max_forks_repo_forks_event_min_datetime": "2015-01-23T00:50:40.000Z", "max_forks_repo_forks_event_max_datetime": "2016-08-01T08:14:24.000Z", "avg_line_length": 37.675, "max_line_length": 101, "alphanum_fraction": 0.5534173855, "num_tokens": 464, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8791467738423873, "lm_q2_score": 0.5774953651858118, "lm_q1q2_score": 0.5077031872120378}} {"text": "#ifndef SIGNAL_H_\n#define SIGNAL_H_\n\n#include \n#include \n#include \n#include \n#include \n#include \"fourier_transform.h\"\n#include \"array.h\"\n#include \"rng.h\"\n#include \n\n// this is slowly turning into sth that should maybe rather be called\n// \"stochastic processes\" rather than signal\n\nnamespace neurophys {\n\nclass SpectrumDescriptor\n{\npublic:\n virtual double get(const double f) const = 0;\n};\n\nclass WhiteSpectrum: public SpectrumDescriptor\n{\npublic:\n WhiteSpectrum(const double s0): s0_(s0) {}\n virtual double get(const double f) const { return s0_; }\nprivate:\n const double s0_;\n};\n\nclass BandLimitedFlatSpectrum: public SpectrumDescriptor\n{\npublic:\n BandLimitedFlatSpectrum(const double s0, const double f0, const double f1):\n s0_(s0), f0_(f0), f1_(f1) \n {}\n virtual double get(const double f) const \n { \n return (f >= f0_ && f < f1_) ? s0_ : 0.; \n } \nprivate:\n const double s0_;\n const double f0_;\n const double f1_;\n};\n\nclass PowerLawSpectrum: public SpectrumDescriptor\n{\npublic:\n PowerLawSpectrum(const double expo, const double f0, const double f1): \n expo_(expo), f0_(f0), f1_(f1), A_(0)\n {\n // normalization, so that variance = 1\n A_ = 1./2 * (1.-expo) / (pow(f1,1.-expo) - expo*pow(f0,1.-expo));\n }\n virtual double get(const double f) const \n {\n if (f < f0_) return A_ * pow(f0_, -expo_);\n else if (f < f1_) return A_ * pow(f, -expo_);\n else return 0.;\n }\nprivate:\n const double expo_;\n const double f0_;\n const double f1_;\n double A_;\n};\n\nnamespace signal {\n\nArray generate_gaussian(RNG& rng, \n const C2RFourierTransform& c2rft, const SpectrumDescriptor& spec, \n const size_t N, const double T);\n\n};\n\n}\n\n#endif /* SIGNAL_H */\n", "meta": {"hexsha": "1957d114e26d4f81c9b789f390f2b9cb22ebf5a1", "size": 1856, "ext": "h", "lang": "C", "max_stars_repo_path": "simulation/neurophys/signal.h", "max_stars_repo_name": "ModelDBRepository/228604", "max_stars_repo_head_hexsha": "8f641f73bcac2700b476663fe656fcad7d63470d", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "simulation/neurophys/signal.h", "max_issues_repo_name": "ModelDBRepository/228604", "max_issues_repo_head_hexsha": "8f641f73bcac2700b476663fe656fcad7d63470d", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "simulation/neurophys/signal.h", "max_forks_repo_name": "ModelDBRepository/228604", "max_forks_repo_head_hexsha": "8f641f73bcac2700b476663fe656fcad7d63470d", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 22.3614457831, "max_line_length": 79, "alphanum_fraction": 0.6546336207, "num_tokens": 517, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8354835371034368, "lm_q2_score": 0.6076631698328916, "lm_q1q2_score": 0.5076925744994707}} {"text": "#include \n#include \n#if BLAS_IMPL == openblas\n#include \n#else\n#include \n#endif\n#include \"attrib.h\"\n#include \"math.h\"\n\n#define CLEANUP \\\n return err; \\\n error: \\\n if (ctx->err == 0) \\\n \tstrcpy(ctx->err_msg, \"Unexpected math.\"); \\\n ctx->err = err; \\\n return err;\n\n#define CHECK(expr) \\\n if ((err = (expr))) goto error;\n\nVIO_CONST\nuint32_t vmaxui(uint32_t a, uint32_t b) {\n return a > b ? a : b;\n}\n\n#define OP_IMPL(name) \\\n vio_err_t generic_##name(vio_ctx *ctx, vio_val *a, vio_val *b) { \\\n vio_err_t err = 0; \\\n vio_val *va, *vb; \\\n if (a->what == vv_str || b->what == vv_str || a->what == vv_quot || b->what == vv_quot || \\\n a->what == vv_tagword || b->what == vv_tagword) { \\\n err = vio_raise(ctx, VE_WRONG_TYPE, \\\n \"Function '\" #name \"' expects numeric types or vectors; received '%s' and '%s' operands.\", \\\n vio_val_type_name(a->what), vio_val_type_name(b->what));\\\n goto error; \\\n }\n\n#define END_OP(_name) \\\n CLEANUP \\\n}\n\n#define GIVEN_VECF \\\n if (a->what == vv_vecf && b->what == vv_vecf && a->vlen == b->vlen) {\n\n#define DONE_VECF }\n\n#define GIVEN_NUMERIC \\\n else if (vio_is_numeric(a) && vio_is_numeric(b)) { \\\n CHECK(vio_coerce(ctx, b, &vb, a->what)) \\\n if (vb == NULL) { \\\n CHECK(vio_coerce(ctx, a, &va, b->what)) \\\n if (va == NULL) { \\\n err = VE_NUMERIC_CONVERSION_FAIL; \\\n goto error; \\\n } \\\n a = b; \\\n b = va; \\\n } \\\n else \\\n b = vb; \\\n switch (a->what) {\n\n#define DONE_NUMERIC \\\n default: err = VE_WRONG_TYPE; goto error; \\\n } \\\n }\n\n#define STANDARD_NUMERIC(op, fop) \\\n GIVEN_NUMERIC \\\n case vv_int: CHECK(vio_push_int(ctx, b->i32 op a->i32)) break; \\\n case vv_float: CHECK(vio_push_float(ctx, b->f32 op a->f32)) break; \\\n case vv_num: { mpf_t c; mpf_init(c); mpf_##fop(c, b->n, a->n); CHECK(vio_push_num(ctx, c)) break; } \\\n DONE_NUMERIC\n\n#define GIVEN_VEC \\\n else CHECK(vio_coerce(ctx, a, &va, vv_vec)) \\\n else CHECK(vio_coerce(ctx, b, &vb, vv_vec)) \\\n else if (va && vb) { \\\n\n#define DONE_VEC }\n\n#define AUTO_VECTORIZE(name) \\\n GIVEN_VEC \\\n uint32_t maxl = vmaxui(va->vlen, vb->vlen); \\\n for (uint32_t i = 0; i < maxl; ++i) \\\n CHECK(generic_##name(ctx, va->vv[i % va->vlen], vb->vv[i % vb->vlen])) \\\n CHECK(vio_push_vec(ctx, maxl)) \\\n DONE_VEC\n\nOP_IMPL(add)\n GIVEN_VECF\n cblas_daxpy(b->vlen, 1, a->vf32, 1, b->vf32, 1);\n CHECK(vio_push_vecf32(ctx, b->vlen, b->vf32))\n DONE_VECF\n STANDARD_NUMERIC(+, add)\n AUTO_VECTORIZE(add)\nEND_OP(add)\n\nOP_IMPL(sub)\n GIVEN_VECF\n cblas_daxpy(b->vlen, -1.0, a->vf32, 1, b->vf32, 1);\n CHECK(vio_push_vecf32(ctx, b->vlen, b->vf32))\n DONE_VECF\n STANDARD_NUMERIC(-, sub)\n AUTO_VECTORIZE(sub)\nEND_OP(sub)\n\nOP_IMPL(mul)\n if (b->what == vv_vecf && a->what == vv_float) {\n va = a;\n a = b;\n b = va;\n }\n if (a->what == vv_vecf && b->what == vv_float) {\n cblas_dscal(a->vlen, b->f32, a->vf32, 1);\n CHECK(vio_push_vecf32(ctx, a->vlen, a->vf32))\n }\n else GIVEN_VECF\n for (uint32_t i = 0; i < a->vlen; ++i)\n a->vf32[i] *= b->vf32[i];\n CHECK(vio_push_vecf32(ctx, a->vlen, a->vf32))\n DONE_VECF\n STANDARD_NUMERIC(*, mul)\n AUTO_VECTORIZE(mul)\nEND_OP(mul)\n\nOP_IMPL(div)\n if (b->what == vv_vecf && a->what == vv_float) {\n va = a;\n a = b;\n b = va;\n }\n if (a->what == vv_vecf && b->what == vv_float) {\n cblas_dscal(a->vlen, 1.0 / b->f32, a->vf32, 1);\n CHECK(vio_push_vecf32(ctx, a->vlen, a->vf32))\n }\n else GIVEN_VECF\n for (uint32_t i = 0; i < a->vlen; ++i)\n a->vf32[i] /= b->vf32[i];\n CHECK(vio_push_vecf32(ctx, a->vlen, a->vf32))\n DONE_VECF\n STANDARD_NUMERIC(/, div)\n AUTO_VECTORIZE(div)\nEND_OP(div)\n\n#define BIN_OP(name) \\\n vio_err_t vio_##name(vio_ctx *ctx) { \\\n vio_err_t err = 0; \\\n VIO__ENSURE_ATLEAST(2) \\\n\\\n vio_val *a = ctx->stack[--ctx->sp], *b; \\\n b = ctx->stack[--ctx->sp]; \\\n err = generic_##name(ctx, a, b); \\\n\\\n CLEANUP \\\n }\n\nBIN_OP(add)\nBIN_OP(sub)\nBIN_OP(mul)\nBIN_OP(div)\n\n#define UN_IMPL(f) \\\n vio_err_t vio_##f(vio_ctx *ctx) { \\\n vio_err_t err = 0; \\\n vio_float x, y; \\\n VIO__CHECK(vio_pop_float(ctx, &x)); \\\n y = f(x); \\\n VIO__CHECK(vio_push_float(ctx, y)); \\\n return 0; \\\n error: \\\n return err; \\\n }\n\nLIST_MATH_UNARY(UN_IMPL)\n", "meta": {"hexsha": "699dfa5a8c09e0eda53f26179b4ae85906ab4824", "size": 4716, "ext": "c", "lang": "C", "max_stars_repo_path": "src/math.c", "max_stars_repo_name": "alpha123/vio", "max_stars_repo_head_hexsha": "1c1bb0e27a27d0e65e92ea8ae8badb44e877047f", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 16.0, "max_stars_repo_stars_event_min_datetime": "2015-11-19T04:36:31.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-05T18:20:21.000Z", "max_issues_repo_path": "src/math.c", "max_issues_repo_name": "alpha123/vio", "max_issues_repo_head_hexsha": "1c1bb0e27a27d0e65e92ea8ae8badb44e877047f", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2015-12-15T18:31:47.000Z", "max_issues_repo_issues_event_max_datetime": "2017-07-17T12:09:20.000Z", "max_forks_repo_path": "src/math.c", "max_forks_repo_name": "alpha123/vio", "max_forks_repo_head_hexsha": "1c1bb0e27a27d0e65e92ea8ae8badb44e877047f", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.6440677966, "max_line_length": 120, "alphanum_fraction": 0.5332909245, "num_tokens": 1541, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8104789178257655, "lm_q2_score": 0.6261241772283034, "lm_q1q2_score": 0.5074604455845432}} {"text": "/* ode-initval2/rk1imp.c\n * \n * Copyright (C) 2009, 2010 Tuomo Keskitalo\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n/* Implicit Euler a.k.a backward Euler method. */\n\n/* Reference: Ascher, U.M., Petzold, L.R., Computer methods for\n ordinary differential and differential-algebraic equations, SIAM,\n Philadelphia, 1998.\n*/\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"odeiv_util.h\"\n#include \"rksubs.c\"\n#include \"modnewton1.c\"\n\n/* Stage of method */\n#define RK1IMP_STAGE 1\n\ntypedef struct\n{\n gsl_matrix *A; /* Runge-Kutta coefficients */\n double *y_onestep; /* Result with one step */\n double *y_twostep; /* Result with two half steps */\n double *ytmp; /* Temporary work space */\n double *y_save; /* Backup space */\n double *YZ; /* Runge-Kutta points */\n double *fYZ; /* Derivatives at YZ */\n gsl_matrix *dfdy; /* Jacobian matrix */\n double *dfdt; /* time derivative of f */\n modnewton1_state_t *esol; /* nonlinear equation solver */\n double *errlev; /* desired error level of y */\n const gsl_odeiv2_driver *driver; /* pointer to driver object */\n}\nrk1imp_state_t;\n\nstatic void *\nrk1imp_alloc (size_t dim)\n{\n rk1imp_state_t *state = (rk1imp_state_t *) malloc (sizeof (rk1imp_state_t));\n\n if (state == 0)\n {\n GSL_ERROR_NULL (\"failed to allocate space for rk1imp_state\",\n GSL_ENOMEM);\n }\n\n state->A = gsl_matrix_alloc (RK1IMP_STAGE, RK1IMP_STAGE);\n\n if (state->A == 0)\n {\n free (state);\n GSL_ERROR_NULL (\"failed to allocate space for A\", GSL_ENOMEM);\n }\n\n state->y_onestep = (double *) malloc (dim * sizeof (double));\n\n if (state->y_onestep == 0)\n {\n gsl_matrix_free (state->A);\n free (state);\n GSL_ERROR_NULL (\"failed to allocate space for y_onestep\", GSL_ENOMEM);\n }\n\n state->y_twostep = (double *) malloc (dim * sizeof (double));\n\n if (state->y_twostep == 0)\n {\n free (state->y_onestep);\n gsl_matrix_free (state->A);\n free (state);\n GSL_ERROR_NULL (\"failed to allocate space for y_onestep\", GSL_ENOMEM);\n }\n\n state->ytmp = (double *) malloc (dim * sizeof (double));\n\n if (state->ytmp == 0)\n {\n free (state->y_twostep);\n free (state->y_onestep);\n gsl_matrix_free (state->A);\n free (state);\n GSL_ERROR_NULL (\"failed to allocate space for ytmp\", GSL_ENOMEM);\n }\n\n state->y_save = (double *) malloc (dim * sizeof (double));\n\n if (state->y_save == 0)\n {\n free (state->ytmp);\n free (state->y_twostep);\n free (state->y_onestep);\n gsl_matrix_free (state->A);\n free (state);\n GSL_ERROR_NULL (\"failed to allocate space for y_save\", GSL_ENOMEM);\n }\n\n state->YZ = (double *) malloc (dim * RK1IMP_STAGE * sizeof (double));\n\n if (state->YZ == 0)\n {\n free (state->y_save);\n free (state->ytmp);\n free (state->y_twostep);\n free (state->y_onestep);\n gsl_matrix_free (state->A);\n free (state);\n GSL_ERROR_NULL (\"failed to allocate space for YZ\", GSL_ENOMEM);\n }\n\n state->fYZ = (double *) malloc (dim * RK1IMP_STAGE * sizeof (double));\n\n if (state->fYZ == 0)\n {\n free (state->YZ);\n free (state->y_save);\n free (state->ytmp);\n free (state->y_twostep);\n free (state->y_onestep);\n gsl_matrix_free (state->A);\n free (state);\n GSL_ERROR_NULL (\"failed to allocate space for fYZ\", GSL_ENOMEM);\n }\n\n state->dfdt = (double *) malloc (dim * sizeof (double));\n\n if (state->dfdt == 0)\n {\n free (state->fYZ);\n free (state->YZ);\n free (state->y_save);\n free (state->ytmp);\n free (state->y_twostep);\n free (state->y_onestep);\n gsl_matrix_free (state->A);\n free (state);\n GSL_ERROR_NULL (\"failed to allocate space for dfdt\", GSL_ENOMEM);\n }\n\n state->dfdy = gsl_matrix_alloc (dim, dim);\n\n if (state->dfdy == 0)\n {\n free (state->dfdt);\n free (state->fYZ);\n free (state->YZ);\n free (state->y_save);\n free (state->ytmp);\n free (state->y_twostep);\n free (state->y_onestep);\n gsl_matrix_free (state->A);\n free (state);\n GSL_ERROR_NULL (\"failed to allocate space for dfdy\", GSL_ENOMEM);\n }\n\n state->esol = modnewton1_alloc (dim, RK1IMP_STAGE);\n\n if (state->esol == 0)\n {\n gsl_matrix_free (state->dfdy);\n free (state->dfdt);\n free (state->fYZ);\n free (state->YZ);\n free (state->y_save);\n free (state->ytmp);\n free (state->y_twostep);\n free (state->y_onestep);\n gsl_matrix_free (state->A);\n free (state);\n GSL_ERROR_NULL (\"failed to allocate space for esol\", GSL_ENOMEM);\n }\n\n state->errlev = (double *) malloc (dim * sizeof (double));\n\n if (state->errlev == 0)\n {\n modnewton1_free (state->esol);\n gsl_matrix_free (state->dfdy);\n free (state->dfdt);\n free (state->fYZ);\n free (state->YZ);\n free (state->y_save);\n free (state->ytmp);\n free (state->y_twostep);\n free (state->y_onestep);\n gsl_matrix_free (state->A);\n free (state);\n GSL_ERROR_NULL (\"failed to allocate space for errlev\", GSL_ENOMEM);\n }\n\n state->driver = NULL;\n\n return state;\n}\n\nstatic int\nrk1imp_apply (void *vstate, size_t dim, double t, double h,\n double y[], double yerr[],\n const double dydt_in[], double dydt_out[],\n const gsl_odeiv2_system * sys)\n{\n /* Makes an implicit Euler step with size h and estimates the local\n error of the step by step doubling.\n */\n\n rk1imp_state_t *state = (rk1imp_state_t *) vstate;\n\n double *const y_onestep = state->y_onestep;\n double *const y_twostep = state->y_twostep;\n double *const ytmp = state->ytmp;\n double *const y_save = state->y_save;\n double *const YZ = state->YZ;\n double *const fYZ = state->fYZ;\n gsl_matrix *const dfdy = state->dfdy;\n double *const dfdt = state->dfdt;\n double *const errlev = state->errlev;\n\n const modnewton1_state_t *esol = state->esol;\n\n /* Runge-Kutta coefficients */\n\n gsl_matrix *A = state->A;\n const double b[] = { 1.0 };\n const double c[] = { 1.0 };\n gsl_matrix_set (A, 0, 0, 1.0);\n\n if (esol == NULL)\n {\n GSL_ERROR (\"no non-linear equation solver speficied\", GSL_EINVAL);\n }\n\n /* Get desired error levels via gsl_odeiv2_control object through driver\n object, which is a requirement for this stepper.\n */\n\n if (state->driver == NULL)\n {\n return GSL_EFAULT;\n }\n else\n {\n size_t i;\n\n for (i = 0; i < dim; i++)\n {\n if (dydt_in != NULL)\n {\n gsl_odeiv2_control_errlevel (state->driver->c, y[i],\n dydt_in[i], h, i, &errlev[i]);\n }\n else\n {\n gsl_odeiv2_control_errlevel (state->driver->c, y[i],\n 0.0, h, i, &errlev[i]);\n }\n }\n }\n\n /* Evaluate Jacobian for modnewton1 */\n\n {\n int s = GSL_ODEIV_JA_EVAL (sys, t, y, dfdy->data, dfdt);\n\n if (s != GSL_SUCCESS)\n {\n return s;\n }\n }\n\n /* Calculate a single step with size h */\n\n {\n int s = modnewton1_init ((void *) esol, A, h, dfdy, sys);\n\n if (s != GSL_SUCCESS)\n {\n return s;\n }\n }\n\n {\n int s = modnewton1_solve ((void *) esol, A, c, t, h, y,\n sys, YZ, errlev);\n\n if (s != GSL_SUCCESS)\n {\n return s;\n }\n }\n\n {\n int s = GSL_ODEIV_FN_EVAL (sys, t + c[0] * h, YZ, fYZ);\n\n if (s != GSL_SUCCESS)\n {\n return s;\n }\n }\n\n {\n int s = rksubs (y_onestep, h, y, fYZ, b, RK1IMP_STAGE, dim);\n\n if (s != GSL_SUCCESS)\n return s;\n }\n\n /* Error estimation by step doubling */\n\n {\n int s = modnewton1_init ((void *) esol, A, h / 2.0, dfdy, sys);\n\n if (s != GSL_SUCCESS)\n {\n return s;\n }\n }\n\n /* 1st half step */\n\n {\n int s = modnewton1_solve ((void *) esol, A, c, t, h / 2.0, y,\n sys, YZ, errlev);\n\n if (s != GSL_SUCCESS)\n {\n return s;\n }\n }\n\n {\n int s = GSL_ODEIV_FN_EVAL (sys, t + c[0] * h / 2.0, YZ, fYZ);\n if (s != GSL_SUCCESS)\n {\n return s;\n }\n }\n\n {\n int s = rksubs (ytmp, h / 2.0, y, fYZ, b, RK1IMP_STAGE, dim);\n\n if (s != GSL_SUCCESS)\n return s;\n }\n\n /* Save original y values in case of error */\n\n DBL_MEMCPY (y_save, y, dim);\n\n /* 2nd half step */\n\n {\n int s = modnewton1_solve ((void *) esol, A, c, t + h / 2.0, h / 2.0,\n ytmp, sys, YZ, errlev);\n\n if (s != GSL_SUCCESS)\n {\n return s;\n }\n }\n\n {\n int s = GSL_ODEIV_FN_EVAL (sys, t + h / 2.0 + c[0] * h / 2.0, YZ, fYZ);\n if (s != GSL_SUCCESS)\n {\n return s;\n }\n }\n\n {\n /* Note: rk1imp returns y using the results from two half steps\n instead of the single step since the results are freely\n available and more precise.\n */\n\n int s = rksubs (y_twostep, h / 2.0, ytmp, fYZ, b, RK1IMP_STAGE, dim);\n\n if (s != GSL_SUCCESS)\n {\n DBL_MEMCPY (y, y_save, dim);\n return s;\n }\n }\n\n DBL_MEMCPY (y, y_twostep, dim);\n\n /* Error estimation */\n\n {\n size_t i;\n for (i = 0; i < dim; i++)\n {\n yerr[i] = ODEIV_ERR_SAFETY * 0.5 * fabs (y_twostep[i] - y_onestep[i]);\n }\n }\n\n /* Derivatives at output */\n\n if (dydt_out != NULL)\n {\n int s = GSL_ODEIV_FN_EVAL (sys, t + h, y, dydt_out);\n\n if (s != GSL_SUCCESS)\n {\n /* Restore original values */\n DBL_MEMCPY (y, y_save, dim);\n\n return s;\n }\n }\n\n return GSL_SUCCESS;\n}\n\nstatic int\nrk1imp_set_driver (void *vstate, const gsl_odeiv2_driver * d)\n{\n rk1imp_state_t *state = (rk1imp_state_t *) vstate;\n\n state->driver = d;\n\n return GSL_SUCCESS;\n}\n\nstatic int\nrk1imp_reset (void *vstate, size_t dim)\n{\n rk1imp_state_t *state = (rk1imp_state_t *) vstate;\n\n DBL_ZERO_MEMSET (state->y_onestep, dim);\n DBL_ZERO_MEMSET (state->y_twostep, dim);\n DBL_ZERO_MEMSET (state->ytmp, dim);\n DBL_ZERO_MEMSET (state->y_save, dim);\n DBL_ZERO_MEMSET (state->YZ, dim);\n DBL_ZERO_MEMSET (state->fYZ, dim);\n\n return GSL_SUCCESS;\n}\n\nstatic unsigned int\nrk1imp_order (void *vstate)\n{\n rk1imp_state_t *state = (rk1imp_state_t *) vstate;\n state = 0; /* prevent warnings about unused parameters */\n return 1;\n}\n\nstatic void\nrk1imp_free (void *vstate)\n{\n rk1imp_state_t *state = (rk1imp_state_t *) vstate;\n\n free (state->errlev);\n modnewton1_free (state->esol);\n gsl_matrix_free (state->dfdy);\n free (state->dfdt);\n free (state->fYZ);\n free (state->YZ);\n free (state->y_save);\n free (state->ytmp);\n free (state->y_twostep);\n free (state->y_onestep);\n gsl_matrix_free (state->A);\n free (state);\n}\n\nstatic const gsl_odeiv2_step_type rk1imp_type = {\n \"rk1imp\", /* name */\n 1, /* can use dydt_in? */\n 1, /* gives exact dydt_out? */\n &rk1imp_alloc,\n &rk1imp_apply,\n &rk1imp_set_driver,\n &rk1imp_reset,\n &rk1imp_order,\n &rk1imp_free\n};\n\nconst gsl_odeiv2_step_type *gsl_odeiv2_step_rk1imp = &rk1imp_type;\n", "meta": {"hexsha": "a0a8b1f2864f1e9bd0f3bab95e4c9bde9e6b611e", "size": 12040, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.6/ode-initval2/rk1imp.c", "max_stars_repo_name": "ielomariala/Hex-Game", "max_stars_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-12-18T18:09:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-10T11:31:28.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/ode-initval2/rk1imp.c", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-12-16T17:41:24.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-22T00:00:16.000Z", "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/ode-initval2/rk1imp.c", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-01-20T16:22:57.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-14T12:31:02.000Z", "avg_line_length": 24.08, "max_line_length": 81, "alphanum_fraction": 0.5758305648, "num_tokens": 3598, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7745833841649233, "lm_q2_score": 0.6548947155710233, "lm_q1q2_score": 0.5072705650587281}} {"text": "/* linalg/condest.c\n * \n * Copyright (C) 2016 Patrick Alken\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n/*\n * This module contains routines for estimating the condition number\n * of matrices in the 1-norm. The algorithm is based on the paper,\n *\n * [1] N. J. Higham, \"FORTRAN codes for estimating the one-norm of\n * a real or complex matrix, with applications to condition estimation\",\n * ACM Trans. Math. Soft., vol. 14, no. 4, pp. 381-396, December 1988.\n */\n\nstatic double condest_tri_norm1(CBLAS_UPLO_t Uplo, const gsl_matrix * A);\nstatic int condest_tri_rcond(CBLAS_UPLO_t Uplo, const gsl_matrix * A,\n double * rcond, gsl_vector * work);\nstatic int condest_same_sign(const gsl_vector * x, const gsl_vector * y);\nstatic int condest_invtriu(CBLAS_TRANSPOSE_t TransA, gsl_vector * x, void * params);\nstatic int condest_invtril(CBLAS_TRANSPOSE_t TransA, gsl_vector * x, void * params);\n\n/*\ngsl_linalg_tri_upper_rcond()\n Estimate reciprocal condition number of upper triangular matrix\n\nInputs: A - upper triangular matrix, N-by-N\n rcond - (output) reciprocal condition number estimate\n work - workspace, length 3*N\n\nReturn: success/error\n*/\n\nint\ngsl_linalg_tri_upper_rcond(const gsl_matrix * A, double * rcond, gsl_vector * work)\n{\n int status = condest_tri_rcond(CblasUpper, A, rcond, work);\n return status;\n}\n\n/*\ngsl_linalg_tri_lower_rcond()\n Estimate reciprocal condition number of lower triangular matrix\n\nInputs: A - lower triangular matrix, N-by-N\n rcond - (output) reciprocal condition number estimate\n work - workspace, length 3*N\n\nReturn: success/error\n*/\n\nint\ngsl_linalg_tri_lower_rcond(const gsl_matrix * A, double * rcond, gsl_vector * work)\n{\n int status = condest_tri_rcond(CblasLower, A, rcond, work);\n return status;\n}\n\n/*\ngsl_linalg_invnorm1()\n Estimate the 1-norm of ||A^{-1}||, where A is a square\nN-by-N matrix\n\nInputs: N - size of matrix\n Ainvx - pointer to function which calculates:\n x := A^{-1} x or x := A^{-t} x\n params - parameters to pass to Ainvx\n Ainvnorm - (output) estimate of ||A^{-1}||_1\n work - workspace, length 3*N\n*/\n\nint\ngsl_linalg_invnorm1(const size_t N,\n int (* Ainvx)(CBLAS_TRANSPOSE_t TransA, gsl_vector * x, void * params),\n void * params, double * Ainvnorm, gsl_vector * work)\n{\n if (work->size != 3 * N)\n {\n GSL_ERROR (\"work vector must have length 3*N\", GSL_EBADLEN);\n }\n else\n {\n const size_t maxit = 5;\n gsl_vector_view x = gsl_vector_subvector(work, 0, N);\n gsl_vector_view v = gsl_vector_subvector(work, N, N);\n gsl_vector_view xi = gsl_vector_subvector(work, 2*N, N);\n double gamma, gamma_old, temp;\n size_t i, k;\n\n for (i = 0; i < N; ++i)\n gsl_vector_set(&x.vector, i, 1.0 / (double) N);\n\n /* compute v = A^{-1} x */\n gsl_vector_memcpy(&v.vector, &x.vector);\n (*Ainvx)(CblasNoTrans, &v.vector, params);\n\n /* gamma = ||v||_1 */\n gamma = gsl_blas_dasum(&v.vector);\n\n /* xi = sign(v) */\n for (i = 0; i < N; ++i)\n {\n double vi = gsl_vector_get(&v.vector, i);\n gsl_vector_set(&xi.vector, i, GSL_SIGN(vi));\n }\n\n /* x = A^{-t} xi */\n gsl_vector_memcpy(&x.vector, &xi.vector);\n (*Ainvx)(CblasTrans, &x.vector, params);\n\n for (k = 0; k < maxit; ++k)\n {\n size_t j = (size_t) gsl_blas_idamax(&x.vector);\n\n /* v := A^{-1} e_j */\n gsl_vector_set_zero(&v.vector);\n gsl_vector_set(&v.vector, j, 1.0);\n (*Ainvx)(CblasNoTrans, &v.vector, params);\n\n gamma_old = gamma;\n gamma = gsl_blas_dasum(&v.vector);\n\n /* check for repeated sign vector (algorithm has converged) */\n if (condest_same_sign(&v.vector, &xi.vector) || (gamma < gamma_old))\n break;\n\n /* xi = sign(v) */\n for (i = 0; i < N; ++i)\n {\n double vi = gsl_vector_get(&v.vector, i);\n gsl_vector_set(&xi.vector, i, GSL_SIGN(vi));\n }\n\n /* x = A^{-t} sign(v) */\n gsl_vector_memcpy(&x.vector, &xi.vector);\n (*Ainvx)(CblasTrans, &x.vector, params);\n }\n\n temp = 1.0; /* (-1)^i */\n for (i = 0; i < N; ++i)\n {\n double term = 1.0 + (double) i / (N - 1.0);\n gsl_vector_set(&x.vector, i, temp * term);\n temp = -temp;\n }\n\n /* x := A^{-1} x */\n (*Ainvx)(CblasNoTrans, &x.vector, params);\n\n temp = 2.0 * gsl_blas_dasum(&x.vector) / (3.0 * N);\n if (temp > gamma)\n {\n gsl_vector_memcpy(&v.vector, &x.vector);\n gamma = temp;\n }\n\n *Ainvnorm = gamma;\n\n return GSL_SUCCESS;\n }\n}\n\nstatic int\ncondest_tri_rcond(CBLAS_UPLO_t Uplo, const gsl_matrix * A, double * rcond, gsl_vector * work)\n{\n const size_t M = A->size1;\n const size_t N = A->size2;\n\n if (M != N)\n {\n GSL_ERROR (\"matrix must be square\", GSL_ENOTSQR);\n }\n else if (work->size != 3 * N)\n {\n GSL_ERROR (\"work vector must have length 3*N\", GSL_EBADLEN);\n }\n else\n {\n int status;\n double Anorm = condest_tri_norm1(Uplo, A); /* ||A||_1 */\n double Ainvnorm; /* ||A^{-1}||_1 */\n\n *rcond = 0.0;\n\n /* don't continue if matrix is singular */\n if (Anorm == 0.0)\n return GSL_SUCCESS;\n\n /* estimate ||A^{-1}||_1 */\n if (Uplo == CblasUpper)\n status = gsl_linalg_invnorm1(N, condest_invtriu, (void *) A, &Ainvnorm, work);\n else\n status = gsl_linalg_invnorm1(N, condest_invtril, (void *) A, &Ainvnorm, work);\n\n if (status)\n return status;\n\n if (Ainvnorm != 0.0)\n *rcond = (1.0 / Anorm) / Ainvnorm;\n\n return GSL_SUCCESS;\n }\n}\n\n/* calculate 1 norm of triangular matrix */\nstatic double\ncondest_tri_norm1(CBLAS_UPLO_t Uplo, const gsl_matrix * A)\n{\n const size_t N = A->size2;\n double max = 0.0;\n size_t i, j;\n\n if (Uplo == CblasUpper)\n {\n for (j = 0; j < N; ++j)\n {\n double sum = 0.0;\n for (i = 0; i <= j; ++i)\n {\n double Aij = gsl_matrix_get(A, i, j);\n sum += fabs(Aij);\n }\n\n max = GSL_MAX(max, sum);\n }\n }\n else\n {\n for (j = 0; j < N; ++j)\n {\n double sum = 0.0;\n for (i = j; i < N; ++i)\n {\n double Aij = gsl_matrix_get(A, i, j);\n sum += fabs(Aij);\n }\n\n max = GSL_MAX(max, sum);\n }\n }\n\n return max;\n}\n\n/* return 1 if sign(x) = sign(y), 0 otherwise */\nstatic int\ncondest_same_sign(const gsl_vector * x, const gsl_vector * y)\n{\n const size_t n = x->size;\n size_t i;\n\n for (i = 0; i < n; ++i)\n {\n double xi = gsl_vector_get(x, i);\n double yi = gsl_vector_get(y, i);\n if (GSL_SIGN(xi) != GSL_SIGN(yi))\n return 0;\n }\n\n return 1;\n}\n\n/* x := A^{-1} x, A upper triangular */\nstatic int\ncondest_invtriu(CBLAS_TRANSPOSE_t TransA, gsl_vector * x, void * params)\n{\n gsl_matrix * A = (gsl_matrix *) params;\n return gsl_blas_dtrsv(CblasUpper, TransA, CblasNonUnit, A, x);\n}\n\n/* x := A^{-1} x, A lower triangular */\nstatic int\ncondest_invtril(CBLAS_TRANSPOSE_t TransA, gsl_vector * x, void * params)\n{\n gsl_matrix * A = (gsl_matrix *) params;\n return gsl_blas_dtrsv(CblasLower, TransA, CblasNonUnit, A, x);\n}\n", "meta": {"hexsha": "eb50a30f4ede148da8d382a70d5165167c32a904", "size": 8319, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.4/linalg/condest.c", "max_stars_repo_name": "peterahrens/FillEstimationIPDPS2017", "max_stars_repo_head_hexsha": "857b6ee8866a2950aa5721d575d2d7d0797c4302", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-01-13T05:01:59.000Z", "max_stars_repo_stars_event_max_datetime": "2021-01-13T05:01:59.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/linalg/condest.c", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/linalg/condest.c", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.73, "max_line_length": 93, "alphanum_fraction": 0.587330208, "num_tokens": 2435, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7431680086124812, "lm_q2_score": 0.6825737279551494, "lm_q1q2_score": 0.5072669581356258}} {"text": "#include \n#include \n#include \n#include \"2d_array.h\"\n#include \"const.h\"\n#include \"input.h\"\n#include \"utilities.h\"\n#include \"misc.h\"\n\n/******************************************************************************\nMODULE: greenband_test\n\nPURPOSE: Multitemporal cloud, cloud shadow, & snow masks (global version)\n\nRETURN VALUE:\nType = int\nERROR error out due to memory allocation\nSUCCESS no error encounted\n\nHISTORY:\nDate Programmer Reason\n-------- --------------- -------------------------------------\n05282019 Su Ye\n\nNOTES:\n******************************************************************************/\nint greenband_test\n(\n int *clrx,\n float **clry,\n int start,\n int end,\n float rmse,\n float n_t,\n int *bl_ids,\n float *C0,\n float *C1\n)\n{\n char FUNC_NAME[] = \"greenband_test\";\n int i;\n float **x;\n float pred;\n int nums;\n float coefs[ROBUST_COEFFS];\n\n nums = end - start + 1;\n /* Allocate memory */\n x = (float **)allocate_2d_array(nums, ROBUST_COEFFS - 1, sizeof(float));\n if (x == NULL)\n {\n RETURN_ERROR(\"ERROR allocating x memory\", FUNC_NAME, ERROR);\n }\n\n for (i = 0; i < nums; i++)\n {\n x[i][0] = (float)clrx[i+start];\n }\n\n /******************************************************************/\n /* */\n /* Do robust fitting for band 2 */\n /* */\n /******************************************************************/\n\n auto_robust_fit(x, clry, nums, start, 1, coefs);\n\n *C0 = coefs[0];\n *C1 = coefs[1];\n\n /******************************************************************/\n /* */\n /* predict band 2 and band 4 refs, bl_ids value of 0 is clear and */\n /* 1 otherwise */\n /* */\n /******************************************************************/\n\n for (i = 0; i < nums; i++)\n {\n pred = coefs[0] + coefs[1] * (float)clrx[i+start];\n if (clry[1][i+start]-pred > (n_t * rmse))\n {\n // int testy = clry[1][i+start];\n // int testx = clrx[i+start];\n bl_ids[i] = 1;\n }\n else\n {\n bl_ids[i] = 0;\n }\n }\n\n /* Free allocated memory */\n if (free_2d_array ((void **) x) != SUCCESS)\n {\n RETURN_ERROR (\"Freeing memory: x\\n\", FUNC_NAME, ERROR);\n }\n x = NULL;\n\n return (SUCCESS);\n}\n\n/******************************************************************************\nMODULE: nirband_test\n\nPURPOSE: nirband_test used to filter out shadow\n\nRETURN VALUE:\nType = int\nERROR error out due to memory allocation\nSUCCESS no error encounted\n\nHISTORY:\nDate Programmer Reason\n-------- --------------- -------------------------------------\n05282019 Su Ye\n\nNOTES:\n******************************************************************************/\nint nirband_test\n(\n int *clrx,\n float **clry,\n int start,\n int end,\n float rmse,\n float n_t,\n int *bl_ids,\n float *C0,\n float *C1\n)\n{\n char FUNC_NAME[] = \"nirband_test\";\n int i;\n float **x;\n float pred;\n int nums;\n float coefs[ROBUST_COEFFS];\n\n nums = end - start + 1;\n /* Allocate memory */\n x = (float **)allocate_2d_array(nums, ROBUST_COEFFS - 1, sizeof(float));\n if (x == NULL)\n {\n RETURN_ERROR(\"ERROR allocating x memory\", FUNC_NAME, ERROR);\n }\n\n for (i = 0; i < nums; i++)\n {\n x[i][0] = (float)clrx[i+start];\n }\n\n /******************************************************************/\n /* */\n /* Do robust fitting for band 4 */\n /* */\n /******************************************************************/\n\n auto_robust_fit(x, clry, nums, start, 3, coefs);\n\n *C0 = coefs[0];\n *C1 = coefs[1];\n\n /******************************************************************/\n /* */\n /* predict band 2 and band 4 refs, bl_ids value of 0 is clear and */\n /* 1 otherwise */\n /* */\n /******************************************************************/\n\n for (i = 0; i < nums; i++)\n {\n pred = coefs[0] + coefs[1] * (float)clrx[i+start];\n if (clry[3][i+start]-pred < -(n_t * rmse))\n {\n bl_ids[i] = 1;\n }\n else\n {\n bl_ids[i] = 0;\n }\n }\n\n /* Free allocated memory */\n if (free_2d_array ((void **) x) != SUCCESS)\n {\n RETURN_ERROR (\"Freeing memory: x\\n\", FUNC_NAME, ERROR);\n }\n x = NULL;\n\n return (SUCCESS);\n}\n\n/******************************************************************************\nMODULE: average_compositing\n\nPURPOSE: Running average compositing for pixel-based time series\n\nRETURN VALUE:\nType = int (SUCCESS, ERROR or FAILURE)\n\nHISTORY:\nDate Programmer Reason\n-------- --------------- -------------------------------------\n06/02/2019 Su Ye Original Development\n******************************************************************************/\n\nint average_compositing\n(\n short int **buf, /* I: pixel-based time series */\n int *valid_date_array, /* I: valid date time series */\n int valid_date_count, /* I: the number of valid dates */\n int lower_ordinal,\n int upper_ordinal,\n int i_col,\n short int **out_compositing /* O: outputted compositing results for four bands */\n)\n{\n int i, j;\n double index_sum[TOTAL_IMAGE_BANDS];\n int valid_count_window= 0;\n for(i = 0; i < TOTAL_IMAGE_BANDS; i++)\n index_sum[i] = 0;\n\n\n for(i = 0; i < valid_date_count; i++)\n {\n if((valid_date_array[i] > lower_ordinal - 1) && (valid_date_array[i] < upper_ordinal + 1))\n {\n for(j = 0; j < TOTAL_IMAGE_BANDS; j++)\n {\n index_sum[j] = index_sum[j] + buf[j][i];\n }\n valid_count_window++;\n\n }\n\n }\n\n if(valid_count_window==0)\n {\n for(i = 0; i < TOTAL_IMAGE_BANDS; i++)\n {\n out_compositing[i][i_col] = -9999;\n }\n return SUCCESS;\n }\n\n\n for(j = 0; j < TOTAL_IMAGE_BANDS; j++)\n {\n out_compositing[j][i_col] = (short int)(index_sum[j] / valid_count_window);\n }\n}\n\n/******************************************************************************\nMODULE: average_compositing\n\nPURPOSE: Running average compositing for pixel-based time series\n\nRETURN VALUE:\nType = int (SUCCESS, ERROR or FAILURE)\n\nHISTORY:\nDate Programmer Reason\n-------- --------------- -------------------------------------\n06/03/2019 Su Ye Original Development\n******************************************************************************/\n\nint median_compositing\n(\n short int **buf, /* I: pixel-based time series */\n int *valid_date_array, /* I: valid date time series */\n int valid_date_count, /* I: the number of valid dates */\n int i_col,\n short int **out_compositing /* O: outputted compositing results for four bands */\n)\n{\n char FUNC_NAME[] = \"median_compositing\";\n short int *var; /* pointer for allocation variable memory */\n int i, j, m;\n\n if (valid_date_count == 1)\n {\n for (i = 0; i < TOTAL_IMAGE_BANDS; i++)\n out_compositing[i][i_col] = buf[i][0];\n return SUCCESS;\n }\n\n var = malloc(valid_date_count * sizeof(short int));\n if (var == NULL)\n {\n RETURN_ERROR (\"Allocating var memory\", FUNC_NAME, ERROR);\n }\n\n for (i = 0; i < TOTAL_IMAGE_BANDS; i++)\n {\n for (j = 0; j < valid_date_count; j++)\n {\n var[j] = buf[i][j];\n\n }\n quick_sort_float(var, 0, valid_date_count-1);\n// for (j = 0; j < dim2_end; j++)\n// {\n// printf(\"%f\\n\", var[j]);\n// }\n m = (valid_date_count) / 2;\n if (valid_date_count % 2 == 0)\n {\n //printf(\"%f\\n\", var[m-1]);\n //printf(\"%f\\n\", var[m]);\n out_compositing[i][i_col] = (short int)(var[m-1] + var[m]) / 2.0;\n }\n else\n out_compositing[i][i_col] = var[m];\n\n }\n\n free(var);\n return SUCCESS;\n\n}\n\n/******************************************************************************\nMODULE: hot_compositing\n\nPURPOSE: Running compositing for pixel-based time series\n\nRETURN VALUE:\nType = int (SUCCESS, ERROR or FAILURE)\n\nHISTORY:\nDate Programmer Reason\n-------- --------------- -------------------------------------\n05/02/2019 Su Ye Original Development\n******************************************************************************/\nint hot_compositing\n(\n short int **buf, /* I: pixel-based time series */\n int *valid_date_array, /* I: valid date time series */\n int valid_date_count, /* I: the number of valid dates */\n int lower_ordinal,\n int upper_ordinal,\n int i_col,\n short int **out_compositing /* O: outputted compositing results for four bands */\n)\n{\n int i, j;\n double wt;\n double index_sum[TOTAL_IMAGE_BANDS];\n for(i = 0; i < TOTAL_IMAGE_BANDS; i++)\n index_sum[i] = 0;\n double wt_sum = 0;\n int valid_count_window = 0;\n\n for(i = 0; i < valid_date_count; i++)\n {\n if((valid_date_array[i] > lower_ordinal - 1) && (valid_date_array[i] < upper_ordinal + 1))\n {\n wt = (double)1.0/((buf[BLUE_INDEX][i] - 0.5 * buf[RED_INDEX][i]) * (buf[BLUE_INDEX][i] - 0.5 * buf[RED_INDEX][i]));\n //wt = (float)1/(abs(buf[BLUE_INDEX][i] - 0.5 * buf[RED_INDEX][i]));\n for(j = 0; j < TOTAL_IMAGE_BANDS; j++)\n {\n index_sum[j] = index_sum[j] + buf[j][i] * wt;\n }\n wt_sum = wt_sum + wt;\n valid_count_window++;\n }\n }\n\n /********************************************/\n /* condition 1: zero valid observation */\n /********************************************/\n if(valid_count_window==0)\n {\n for(i = 0; i < TOTAL_IMAGE_BANDS; i++)\n {\n out_compositing[i][i_col] = -9999;\n }\n return SUCCESS;\n }\n\n /********************************************/\n /* condition 2: standard procedures */\n /********************************************/\n\n for(j = 0; j < TOTAL_IMAGE_BANDS; j++)\n {\n out_compositing[j][i_col] = (short int)(index_sum[j] / wt_sum);\n //out_compositing[j][i_col] = (short int)valid_count_window;\n }\n\n return SUCCESS;\n\n}\n\n\n/******************************************************************************\nMODULE: modified_hot_compositing\n\nPURPOSE: Running compositing for pixel-based time series by adding shadow consideration\n\nRETURN VALUE:\nType = int (SUCCESS, ERROR or FAILURE)\n\nHISTORY:\nDate Programmer Reason\n-------- --------------- -------------------------------------\n06/22/2019 Su Ye Original Development\n******************************************************************************/\nint modified_hot_compositing\n(\n short int **buf, /* I: pixel-based time series */\n int *valid_date_array, /* I: valid date time series */\n int valid_date_count, /* I: the number of valid dates */\n int lower_ordinal,\n int upper_ordinal,\n int i_col,\n short int **out_compositing /* O: outputted compositing results for four bands */\n)\n{\n int i, j;\n int status;\n double wt;\n double wt_shadow;\n double wt_cloud;\n double index_sum[TOTAL_IMAGE_BANDS];\n for(i = 0; i < TOTAL_IMAGE_BANDS; i++)\n index_sum[i] = 0;\n double wt_sum = 0;\n int valid_count_window = 0;\n short int** ts_subset;\n short int* ts_subset_selected_shadow;\n short int* ts_subset_selected_blue;\n short int variogram_shadow;\n short int medium_shadow;\n\n char FUNC_NAME[] = \"modified_hot_compositing\";\n\n ts_subset = (short int**)allocate_2d_array(TOTAL_IMAGE_BANDS, valid_date_count, sizeof(short int));\n if(ts_subset == NULL)\n {\n RETURN_ERROR (\"Allocating ts_subset memory\", FUNC_NAME, ERROR);\n }\n\n ts_subset_selected_shadow = (short int*)malloc(valid_date_count*sizeof(short int));\n if(ts_subset_selected_shadow == NULL)\n {\n RETURN_ERROR (\"Allocating ts_subset_selected_shadow memory\", FUNC_NAME, ERROR);\n }\n\n ts_subset_selected_blue = (short int*)malloc(valid_date_count*sizeof(short int));\n if(ts_subset_selected_blue == NULL)\n {\n RETURN_ERROR (\"Allocating ts_subset_selected_blue memory\", FUNC_NAME, ERROR);\n }\n\n\n for(i = 0; i < valid_date_count; i++)\n {\n if((valid_date_array[i] > lower_ordinal - 1) && (valid_date_array[i] < upper_ordinal + 1))\n {\n for(j = 0; j < TOTAL_IMAGE_BANDS; j++)\n {\n ts_subset[j][valid_count_window] = buf[j][i];\n if(j == NIR_INDEX)\n {\n //ts_subset_selected_shadow[valid_count_window] = (buf[BLUE_INDEX][i] + buf[RED_INDEX][i] + buf[GREEN_INDEX][i])/3;\n\t\t ts_subset_selected_shadow[valid_count_window] = buf[NIR_INDEX][i];\n //printf(\"%i\\n\", ts_subset_selected[valid_count_window]);\n }\n if(j == BLUE_INDEX)\n {\n ts_subset_selected_blue[valid_count_window] = buf[BLUE_INDEX][i];\n //printf(\"%i\\n\", ts_subset_selected[valid_count_window]);\n }\n }\n\n valid_count_window++;\n\n }\n }\n\n\n /********************************************/\n /* condition 1: zero valid observation */\n /********************************************/\n if(valid_count_window < 3)\n {\n for(i = 0; i < TOTAL_IMAGE_BANDS; i++)\n {\n out_compositing[i][i_col] = -9999;\n }\n return SUCCESS;\n }\n\n\n //single_mean_rmse(ts_subset_selected, 0, valid_count_window - 1, &rmse, &mean);\n //quick_sort_shortint(ts_subset_selected, 0, valid_count_window - 1);\n\n //m = valid_count_window / 2;\n\n //medium_shadow = (ts_subset_selected[m] + ts_subset_selected[m - 1] + ts_subset_selected[m + 1])/3;\n single_median_variogram(ts_subset_selected_shadow, 0, valid_count_window - 1, &variogram_shadow, &medium_shadow);\n //single_median_quantile(ts_subset_selected_blue, 0, valid_count_window - 1, &quantile_blue, &medium_blue);\n //single_median_variogram(ts_subset_selected_hot, 0, valid_count_window - 1, &variogram_hot, &medium_hot);\n //penalty_slope = - 9.0 / (1000.0 * variogram);\n// penalty_slope = - 33.0 / (50.0 * variogram);\n// penalty_intercept = PENALTY_INTERCEPT;\n\n// for(i = 0; i < valid_count_window; i++)\n// {\n\n// if (ts_subset_selected[i] - medium < - 1.5 * variogram)\n// {\n// ts_subset_id[i] = 1;\n// }\n// else if (ts_subset_selected[i] - medium < - 2 * variogram)\n// {\n// ts_subset_id[i] = 2;\n// }\n// else if (ts_subset_selected[i] - medium < - 3 * variogram)\n// {\n// ts_subset_id[i] = 3;\n// }\n// else\n// {\n// ts_subset_id[i] = 0;\n// }\n\n// }\n// for(i = 0; i < valid_count_window; i++)\n// {\n\n// if (ts_subset_selected[i] - medium < - 1.5 * variogram)\n// {\n// ts_subset_id[i] = 1;\n// }\n// else\n// {\n// ts_subset_id[i] = 0;\n// }\n\n// }\n\n /********************************************/\n /* condition 2: standard procedures */\n /********************************************/\n double ratio;\n for(i = 0; i < valid_count_window; i++)\n {\n wt_cloud = (double) 1.0 / (ts_subset_selected_blue[i] * ts_subset_selected_blue[i]);\n\n if (ts_subset_selected_shadow[i] < medium_shadow)\n {\n ratio = (double)ts_subset_selected_shadow[i] / medium_shadow;\n wt_shadow = ratio * ratio * ratio * ratio;\n }\n else\n wt_shadow = 1.0;\n\n wt = wt_cloud * wt_shadow;\n //wt = (float)1/(abs(buf[BLUE_INDEX][i] - 0.5 * buf[RED_INDEX][i]));\n for(j = 0; j < TOTAL_IMAGE_BANDS; j++)\n {\n index_sum[j] = index_sum[j] + ts_subset[j][i] * wt;\n }\n wt_sum = wt_sum + wt;\n }\n\n\n for(j = 0; j < TOTAL_IMAGE_BANDS; j++)\n {\n out_compositing[j][i_col] = (short int)(index_sum[j] / wt_sum);\n //out_compositing[j][i_col] = (short int)valid_count_window;\n }\n\n /* free memory*/\n status = free_2d_array(ts_subset);\n if (status != SUCCESS)\n {\n RETURN_ERROR (\"Freeing memory: ts_subset\\n\",\n FUNC_NAME, FAILURE);\n }\n free(ts_subset_selected_shadow);\n free(ts_subset_selected_blue);\n\n return SUCCESS;\n\n}\n\n/******************************************************************************\nMODULE: valid_obs_count\n\nPURPOSE: count valid observation for each pixels\n\nRETURN VALUE:\nType = int (SUCCESS, ERROR or FAILURE)\n\nHISTORY:\nDate Programmer Reason\n-------- --------------- -------------------------------------\n06/22/2019 Su Ye Original Development\n******************************************************************************/\nint valid_obs_count\n(\n short int **buf, /* I: pixel-based time series */\n int *valid_date_array, /* I: valid date time series */\n int valid_date_count, /* I: the number of valid dates */\n int lower_ordinal,\n int upper_ordinal,\n int i_col,\n short int **out_compositing /* O: outputted compositing results for four bands */\n)\n{\n int index_sum[TOTAL_IMAGE_BANDS];\n int i, j, status;\n for(i = 0; i < TOTAL_IMAGE_BANDS; i++)\n index_sum[i] = 0;\n int valid_count_window = 0;\n short int** ts_subset;\n short int* ts_subset_selected;\n\n\n char FUNC_NAME[] = \"modified_hot_compositing\";\n\n ts_subset = (short int**)allocate_2d_array(TOTAL_IMAGE_BANDS, valid_date_count, sizeof(short int));\n if(ts_subset == NULL)\n {\n RETURN_ERROR (\"Allocating ts_subset memory\", FUNC_NAME, ERROR);\n }\n\n ts_subset_selected = (short int*)malloc(valid_date_count*sizeof(short int));\n if(ts_subset_selected == NULL)\n {\n RETURN_ERROR (\"Allocating ts_subset_selected memory\", FUNC_NAME, ERROR);\n }\n\n for(i = 0; i < valid_date_count; i++)\n {\n if((valid_date_array[i] > lower_ordinal - 1) && (valid_date_array[i] < upper_ordinal + 1))\n {\n for(j = 0; j < TOTAL_IMAGE_BANDS; j++)\n {\n ts_subset[j][valid_count_window] = buf[j][i];\n if(j == NIR_INDEX)\n {\n ts_subset_selected[valid_count_window] = buf[NIR_INDEX][i];\n //printf(\"%i\\n\", ts_subset_selected[valid_count_window]);\n }\n }\n valid_count_window++;\n\n }\n }\n\n\n\n\n for(j = 0; j < TOTAL_IMAGE_BANDS; j++)\n {\n\n out_compositing[j][i_col] = (short int)valid_count_window;\n }\n\n status = free_2d_array((void **)ts_subset);\n if (status != SUCCESS)\n {\n RETURN_ERROR (\"Freeing memory: ts_subset\\n\",\n FUNC_NAME, FAILURE);\n }\n free(ts_subset_selected);\n\n return SUCCESS;\n\n}\n\n\n/******************************************************************************\nMODULE: medium_compositing\n\nPURPOSE: Running compositing for pixel-based time series by adding shadow consideration\n\nRETURN VALUE:\nType = int (SUCCESS, ERROR or FAILURE)\n\nHISTORY:\nDate Programmer Reason\n-------- --------------- -------------------------------------\n06/22/2019 Su Ye Original Development\n******************************************************************************/\nint medium_compositing\n(\n short int **buf, /* I: pixel-based time series */\n int *valid_date_array, /* I: valid date time series */\n int valid_date_count, /* I: the number of valid dates */\n int lower_ordinal,\n int upper_ordinal,\n int i_col,\n short int **out_compositing /* O: outputted compositing results for four bands */\n)\n{\n int i, j, m;\n int status;\n double wt;\n double index_sum[TOTAL_IMAGE_BANDS];\n for(i = 0; i < TOTAL_IMAGE_BANDS; i++)\n index_sum[i] = 0;\n double wt_sum = 0;\n int valid_count_window = 0;\n short int** ts_subset;\n short int* ts_subset_selected;\n int* ts_subset_selected_index;\n char FUNC_NAME[] = \"medium_compositing\";\n\n ts_subset = (short int*)allocate_2d_array(TOTAL_IMAGE_BANDS, valid_date_count, sizeof(short int));\n if(ts_subset == NULL)\n {\n RETURN_ERROR (\"Allocating ts_subset memory\", FUNC_NAME, ERROR);\n }\n\n for(i = 0; i < valid_date_count; i++)\n {\n if((valid_date_array[i] > lower_ordinal - 1) && (valid_date_array[i] < upper_ordinal + 1))\n {\n for(j = 0; j < TOTAL_IMAGE_BANDS; j++)\n {\n ts_subset[j][valid_count_window] = buf[j][i];\n }\n valid_count_window++;\n }\n }\n\n\n ts_subset_selected = (short int*)malloc(valid_count_window*sizeof(short int));\n if(ts_subset_selected == NULL)\n {\n RETURN_ERROR (\"Allocating ts_subset_selected memory\", FUNC_NAME, ERROR);\n }\n\n ts_subset_selected_index = (int*)malloc(valid_count_window*sizeof(int));\n if(ts_subset_selected == NULL)\n {\n RETURN_ERROR (\"Allocating ts_subset_selected_index memory\", FUNC_NAME, ERROR);\n }\n\n for(i = 0; i < valid_count_window; i++)\n {\n\n ts_subset_selected[i] = ts_subset[NIR_INDEX][i];\n ts_subset_selected_index[i] = i;\n //printf(\"%i\\n\", ts_subset_selected[valid_count_window]);\n }\n\n\n\n /********************************************/\n /* condition 1: zero valid observation */\n /********************************************/\n if(valid_count_window == 0)\n {\n for(i = 0; i < TOTAL_IMAGE_BANDS; i++)\n {\n out_compositing[i][i_col] = -9999;\n }\n return SUCCESS;\n }\n\n\n quick_sort_shortint_index(ts_subset_selected, ts_subset_selected_index,\n 0, valid_count_window - 1);\n// for (j = 0; j < valid_count_window; j++)\n// {\n// printf(\"%i %i\\n\", ts_subset_selected[j], ts_subset_selected_index[j]);\n// }\n\n m = valid_count_window / 2;\n if (valid_count_window % 2 == 0)\n {\n //printf(\"%f\\n\", var[m-1]);\n //printf(\"%f\\n\", var[m]);\n for(i = 0; i < TOTAL_IMAGE_BANDS; i++)\n {\n out_compositing[i][i_col] = (short int)((ts_subset[i][ts_subset_selected_index[m-1]] +\n ts_subset[i][ts_subset_selected_index[m]]) / 2);\n }\n\n }\n else\n {\n for(i = 0; i < TOTAL_IMAGE_BANDS; i++)\n {\n out_compositing[i][i_col] = (short int)(ts_subset[i][ts_subset_selected_index[m]]);\n }\n //printf(\"%i\\n\", out_compositing[i][i_col]);\n }\n\n\n status = free_2d_array((void**)ts_subset);\n if (status != SUCCESS)\n {\n RETURN_ERROR (\"Freeing memory: ts_subset\\n\",\n FUNC_NAME, FAILURE);\n }\n free(ts_subset_selected);\n\n return SUCCESS;\n\n}\n\n/******************************************************************************\nMODULE: compositing_scanline\n\nPURPOSE: Running compositing for scanline-based time series\n\nRETURN VALUE:\nType = int (SUCCESS, ERROR or FAILURE)\n\nHISTORY:\nDate Programmer Reason\n-------- --------------- -------------------------------------\n05/02/2019 Su Ye Original Development\n******************************************************************************/\nint compositing_scanline\n(\n short int **buf, /* I: scanline-based time series */\n int **valid_datearray_scanline, /* I: valid date time series */\n int *valid_datecount_scanline, /* I: the number of valid dates */\n int lower_ordinal, /* I: lower ordinal date */\n int upper_ordinal, /* I: upper_ordinal for temporal range of composition */\n int num_samples, /* I: the pixel number in a row */\n int num_scenes, /* I: the number of scenes */\n short int **out_compositing, /* O: outputted compositing results for four bands */\n int method /* I: the compositing method{1 - fitting-weighted; 2 - fitting-normal; 3 - hot; 4 - average} */\n)\n{\n int j;\n int i_col;\n short int **tmp_buf; /* This is the image bands buffer, valid pixel only*/\n char FUNC_NAME[] = \"compositing_scanline\";\n int b_diagnosis = FALSE;\n Output_t* rec_c;\n\n tmp_buf = (short int **) allocate_2d_array (TOTAL_IMAGE_BANDS, num_scenes, sizeof (short int));\n if(tmp_buf == NULL)\n {\n RETURN_ERROR(\"ERROR allocating tmp_buf memory\", FUNC_NAME, FAILURE);\n }\n\n rec_c = malloc(sizeof(Output_t));\n if(rec_c == NULL)\n {\n RETURN_ERROR(\"ERROR allocating rec_c memory\", FUNC_NAME, FAILURE);\n }\n\n for(i_col = 0; i_col < num_samples; i_col++)\n {\n for(j = 0; j < TOTAL_IMAGE_BANDS; j++)\n {\n tmp_buf[j] = buf[j] + i_col * num_scenes;\n }\n\n /*weighted fitting*/\n if (1==method)\n {\n fitting_compositing(tmp_buf, valid_datearray_scanline[i_col],\n valid_datecount_scanline[i_col], lower_ordinal,\n upper_ordinal, i_col, out_compositing, TRUE, TRUE, b_diagnosis, rec_c);\n }\n /*normal fitting*/\n else if (2==method)\n {\n fitting_compositing(tmp_buf, valid_datearray_scanline[i_col],\n valid_datecount_scanline[i_col], lower_ordinal,\n upper_ordinal, i_col, out_compositing, TRUE, FALSE, b_diagnosis, rec_c);\n }\n else if (3==method)\n {\n hot_compositing(tmp_buf, valid_datearray_scanline[i_col],\n valid_datecount_scanline[i_col], lower_ordinal,\n upper_ordinal, i_col, out_compositing);\n }\n else if (4==method)\n {\n average_compositing(tmp_buf, valid_datearray_scanline[i_col],\n valid_datecount_scanline[i_col], lower_ordinal,\n upper_ordinal, i_col, out_compositing);\n }\n else if (5==method)\n {\n fitting_compositing(tmp_buf, valid_datearray_scanline[i_col],\n valid_datecount_scanline[i_col], lower_ordinal,\n upper_ordinal, i_col, out_compositing, FALSE, FALSE, b_diagnosis, rec_c);\n }\n else if (6==method)\n {\n modified_hot_compositing(tmp_buf, valid_datearray_scanline[i_col],\n valid_datecount_scanline[i_col], lower_ordinal,\n upper_ordinal, i_col, out_compositing);\n }\n\n else if (7==method)\n {\n medium_compositing(tmp_buf, valid_datearray_scanline[i_col],\n valid_datecount_scanline[i_col], lower_ordinal,\n upper_ordinal, i_col, out_compositing);\n }\n else if (8==method)\n {\n valid_obs_count(tmp_buf, valid_datearray_scanline[i_col],\n valid_datecount_scanline[i_col], lower_ordinal,\n upper_ordinal, i_col, out_compositing);\n }\n }\n\n free(rec_c);\n free_2d_array((void **)tmp_buf);\n\n return SUCCESS;\n}\n\n/******************************************************************************\nMODULE: fitting_compositing\n\nPURPOSE: Running compositing for pixel-based time series\n\nRETURN VALUE:\nType = int (SUCCESS, ERROR or FAILURE)\n\nHISTORY:\nDate Programmer Reason\n-------- --------------- -------------------------------------\n05/02/2019 Su Ye Original Development\n******************************************************************************/\nint fitting_compositing\n(\n short int **buf, /* I: pixel-based time series */\n int *valid_date_array, /* I: valid date time series */\n int valid_date_count, /* I: the number of valid dates */\n int lower_ordinal,\n int upper_ordinal,\n int i_col,\n short int **out_compositing, /* O: outputted compositing results for four bands */\n int bfit,\n int bweighted,\n int b_diagnosis,\n Output_t* rec_c\n)\n{\n char FUNC_NAME[] = \"fitting_compositing\";\n int status;\n float date_vario; /* I: median date */\n float max_date_difference; /* I: maximum difference between two neighbor dates */\n float adj_rmse[TOTAL_IMAGE_BANDS]; /* Adjusted RMSE for all bands */\n int *bl_ids;\n int n_clr;\n int n_clr_1;\n int n_outlier_1;\n int n_clr_2;\n int n_outlier_2;\n int k, b;\n int* clrx;\n float **clry;\n int* clrx_1;\n float **clry_1;\n int* clrx_2;\n float **clry_2;\n int i;\n float C0; // intercept from each test output\n float C1; // slope from each test output\n\n clrx = (int*)calloc(valid_date_count, sizeof(int));\n clry = (float **) allocate_2d_array (TOTAL_IMAGE_BANDS, valid_date_count,\n sizeof (float));\n if (clry == NULL)\n {\n RETURN_ERROR (\"Allocating clry memory\", FUNC_NAME, FAILURE);\n }\n\n /**************************************************************/\n /* */\n /* select observations in the observation window */\n /* */\n /**************************************************************/\n n_clr = 0;\n for(i = 0; i < valid_date_count; i++)\n {\n if((valid_date_array[i] > lower_ordinal - 1) && (valid_date_array[i] < upper_ordinal + 1))\n {\n clrx[n_clr] = valid_date_array[i];\n for(b = 0; b < TOTAL_IMAGE_BANDS; b++)\n {\n clry[b][n_clr] = (float)buf[b][i];\n }\n n_clr++;\n }\n }\n\n /********************************************/\n /* condition 1: zero valid observation */\n /********************************************/\n if(n_clr==0)\n {\n for(i = 0; i < TOTAL_IMAGE_BANDS; i++)\n {\n out_compositing[i][i_col] = -9999;\n }\n\n if(TRUE == b_diagnosis)\n {\n rec_c->condition = NOOBS_CONDITION;\n }\n\n free(clrx);\n status = free_2d_array((void **)clry);\n if (status != SUCCESS)\n {\n RETURN_ERROR (\"Freeing memory: clry\\n\",\n FUNC_NAME, FAILURE);\n }\n\n return SUCCESS;\n }\n\n /**********************************************/\n /* condition 2: inefficient observations */\n /**********************************************/\n else if (n_clr < MIN_SAMPLE)\n {\n median_compositing(buf, valid_date_array, valid_date_count,\n i_col, out_compositing);\n\n if(TRUE == b_diagnosis)\n {\n rec_c->condition = INEFFICIENT_CONDITION;\n }\n\n free(clrx);\n status = free_2d_array((void **)clry);\n if (status != SUCCESS)\n {\n RETURN_ERROR (\"Freeing memory: clry\\n\",\n FUNC_NAME, FAILURE);\n }\n\n return SUCCESS;\n }\n else\n {\n if(TRUE == b_diagnosis)\n {\n rec_c->condition = NORMAL_CONDITION;\n }\n }\n\n /**********************************************/\n /* condition 3: standard procedure */\n /**********************************************/\n\n bl_ids = (int *)calloc(n_clr, sizeof(int));\n if (bl_ids == NULL)\n {\n RETURN_ERROR(\"ERROR allocating bl_ids memory\", FUNC_NAME, FAILURE);\n }\n\n\n clrx_1 = (int *)calloc(n_clr, sizeof(int));\n clry_1 = (float **) allocate_2d_array (TOTAL_IMAGE_BANDS, n_clr,\n sizeof (float));\n if (clry_1 == NULL)\n {\n RETURN_ERROR (\"Allocating clry_1 memory\", FUNC_NAME, FAILURE);\n }\n\n clrx_2 = (int *)calloc(n_clr, sizeof(int));\n clry_2 = (float **) allocate_2d_array (TOTAL_IMAGE_BANDS, n_clr,\n sizeof (float));\n if (clry_2 == NULL)\n {\n RETURN_ERROR (\"Allocating clry_2 memory\", FUNC_NAME, FAILURE);\n }\n\n /**************************************************************/\n /* */\n /* calculate variogram for each band and dates. */\n /* */\n /**************************************************************/\n status = adjust_median_variogram(clrx, clry, TOTAL_IMAGE_BANDS,\n 0, n_clr-1, &date_vario,\n &max_date_difference, adj_rmse);\n if (status != SUCCESS)\n {\n RETURN_ERROR(\"ERROR calling median_variogram routine\", FUNC_NAME,\n FAILURE);\n }\n\n\n status = greenband_test(clrx, clry, 0, n_clr-1, adj_rmse[1], T_CONST_SINGLETAIL_9999,\n bl_ids, &C0, &C1);\n\n if (status != SUCCESS)\n {\n RETURN_ERROR(\"ERROR calling greenband_test\",\n FUNC_NAME, FAILURE);\n }\n\n if(TRUE == b_diagnosis)\n {\n rec_c->C0_green = C0;\n rec_c->C1_green = C1;\n }\n\n /**************************************************/\n /* */\n /* remove outliers. */\n /* */\n /**************************************************/\n n_clr_1 = 0;\n n_outlier_1 = 0;\n for(i = 0; i < n_clr; i++)\n {\n if(bl_ids[i] == 0)\n {\n clrx_1[n_clr_1] = clrx[i];\n for (b = 0; b < TOTAL_IMAGE_BANDS; b++)\n {\n clry_1[b][n_clr_1] = clry[b][i];\n }\n n_clr_1 = n_clr_1 + 1;\n }\n else\n {\n if(TRUE == b_diagnosis)\n {\n rec_c->outlier_dates_green[n_outlier_1] = clrx[i];\n n_outlier_1 = n_outlier_1 + 1;\n }\n }\n }\n\n rec_c->n_outlier_green = n_outlier_1;\n\n /* if n_clr_1 < MIN_SAMPLE, means that green test failed, need to reset*/\n if (n_clr_1 < MIN_SAMPLE)\n {\n n_clr_1 = 0;\n for(i = 0; i < n_clr; i++)\n {\n\n clrx_1[n_clr_1] = clrx[i];\n for (b = 0; b < TOTAL_IMAGE_BANDS; b++)\n {\n clry_1[b][n_clr_1] = (float)clry[b][i];\n }\n n_clr_1 = n_clr_1 + 1;\n\n }\n if(TRUE == b_diagnosis)\n rec_c->b_success_green = FAILURE;\n }\n else{\n if(TRUE == b_diagnosis)\n rec_c->b_success_green = SUCCESS;\n }\n\n\n /**************************************************/\n /* */\n /* nir band test */\n /* */\n /**************************************************/\n\n for (k = 0; k < n_clr_1; k++)\n bl_ids[k] = 0;\n\n status = nirband_test(clrx_1, clry_1, 0, n_clr_1-1, adj_rmse[3], T_CONST_SINGLETAIL_9999,\n bl_ids, &C0, &C1);\n\n if (status != SUCCESS)\n {\n RETURN_ERROR(\"ERROR calling nirband_test\",\n FUNC_NAME, FAILURE);\n }\n\n if(TRUE == b_diagnosis)\n {\n rec_c->C0_nir = C0;\n rec_c->C1_nir = C1;\n }\n\n /**************************************************/\n /* */\n /* remove outliers. */\n /* */\n /**************************************************/\n n_clr_2 = 0;\n n_outlier_2 = 0;\n for(i = 0; i < n_clr_1; i++)\n {\n if(bl_ids[i] == 0)\n {\n clrx_2[n_clr_2] = clrx_1[i];\n for (b = 0; b < TOTAL_IMAGE_BANDS; b++)\n {\n clry_2[b][n_clr_2] = clry_1[b][i];\n }\n n_clr_2 = n_clr_2 + 1;\n }\n else\n {\n if(TRUE == b_diagnosis)\n {\n rec_c->outlier_dates_nir[n_outlier_2] = clrx_1[i];\n n_outlier_2 = n_outlier_2 + 1;\n }\n }\n }\n\n rec_c->n_outlier_nir = n_outlier_2;\n\n /* if n_clr_1 < MIN_SAMPLE, means that nir test failed, reset*/\n if (n_clr_2 < MIN_SAMPLE)\n {\n for(i = 0; i < n_clr_1; i++)\n {\n n_clr_2 = 0;\n clrx_2[n_clr_2] = clrx_1[i];\n for (b = 0; b < TOTAL_IMAGE_BANDS; b++)\n {\n clry_2[b][n_clr_2] = clry_1[b][i];\n }\n n_clr_2 = n_clr_2 + 1;\n }\n\n if(TRUE == b_diagnosis)\n rec_c->b_success_nir = FAILURE;\n }\n else{\n if(TRUE == b_diagnosis)\n rec_c->b_success_nir = SUCCESS;\n }\n\n\n if(bfit == TRUE)\n linear_fit_centerdate(clrx_2, clry_2, n_clr_2, 0, (lower_ordinal + upper_ordinal)/2,i_col,\n out_compositing, bweighted, rec_c->C0_final, rec_c->C1_final);\n else\n {\n float wt;\n int j;\n double index_sum[TOTAL_IMAGE_BANDS];\n for(i = 0; i < TOTAL_IMAGE_BANDS; i++)\n index_sum[i] = 0;\n float wt_sum = 0;\n\n\n for(i = 0; i < n_clr_2; i++)\n {\n wt = (float)1/((clry_2[BLUE_INDEX][i] - 0.5 * clry_2[RED_INDEX][i]) * (clry_2[BLUE_INDEX][i] - 0.5 * clry_2[RED_INDEX][i]));\n for(j = 0; j < TOTAL_IMAGE_BANDS; j++)\n {\n index_sum[j] = index_sum[j] + clry_2[j][i] * wt;\n }\n wt_sum = wt_sum + wt;\n }\n\n /********************************************/\n /* condition 2: standard procedures */\n /********************************************/\n\n for(j = 0; j < TOTAL_IMAGE_BANDS; j++)\n {\n out_compositing[j][i_col] = (short int)(index_sum[j] / wt_sum);\n }\n\n }\n\n\n free(bl_ids);\n free(clrx);\n status = free_2d_array((void **)clry);\n if (status != SUCCESS)\n {\n RETURN_ERROR (\"Freeing memory: clry\\n\",\n FUNC_NAME, FAILURE);\n }\n\n free(clrx_1);\n status = free_2d_array((void **)clry_1);\n if (status != SUCCESS)\n {\n RETURN_ERROR (\"Freeing memory: clry_1\\n\",\n FUNC_NAME, FAILURE);\n }\n\n free(clrx_2);\n status = free_2d_array((void **)clry_2);\n if (status != SUCCESS)\n {\n RETURN_ERROR (\"Freeing memory: clry_2\\n\",\n FUNC_NAME, FAILURE);\n }\n\n return SUCCESS;\n\n}\n\n//int fitting_compositing_scanline\n//(\n// short int **buf, /* I: scanline-based time series */\n// int **valid_datearray_scanline, /* I: valid date time series */\n// int *valid_datecount_scanline, /* I: the number of valid dates */\n// int lower_ordinal, /* I: lower ordinal dates */\n// int upper_ordinal, /* I: upper_ordinal for temporal range of composition */\n// int num_samples, /* I: the pixel number in a row */\n// int num_scenes, /* I: the number of scenes */\n// short int **out_compositing /* O: outputted compositing results for four bands */\n//)\n//{\n// int i, j;\n// int i_col;\n// short int **tmp_buf; /* This is the image bands buffer, valid pixel only*/\n// int result;\n// char FUNC_NAME[] = \"compositing_scanline\";\n// tmp_buf = (short int **) allocate_2d_array (TOTAL_IMAGE_BANDS, num_scenes, sizeof (short int));\n// if(tmp_buf == NULL)\n// {\n// RETURN_ERROR(\"ERROR allocating tmp_buf memory\", FUNC_NAME, FAILURE);\n// }\n\n// for(i_col = 0; i_col < num_samples; i_col++)\n// {\n// for(j = 0; j < TOTAL_IMAGE_BANDS; j++)\n// {\n// tmp_buf[j] = buf[j] + i_col * num_scenes;\n// }\n\n// fitting_compositing(tmp_buf, valid_datearray_scanline[i_col],\n// valid_datecount_scanline[i_col], lower_ordinal,\n// upper_ordinal, i_col, out_compositing);\n// }\n\n// free_2d_array((void **)tmp_buf);\n\n// return SUCCESS;\n//}\n", "meta": {"hexsha": "5ff1972e57c0244546f56bc21c3958c9c103783b", "size": 41400, "ext": "c", "lang": "C", "max_stars_repo_path": "C/AFMapTSComposite/compositing.c", "max_stars_repo_name": "agroimpacts/imager", "max_stars_repo_head_hexsha": "0fe8819a51e069c1e010cea0975c51a2a8794c42", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-09-01T18:48:12.000Z", "max_stars_repo_stars_event_max_datetime": "2021-09-01T18:48:12.000Z", "max_issues_repo_path": "C/AFMapTSComposite/compositing.c", "max_issues_repo_name": "agroimpacts/imager", "max_issues_repo_head_hexsha": "0fe8819a51e069c1e010cea0975c51a2a8794c42", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "C/AFMapTSComposite/compositing.c", "max_forks_repo_name": "agroimpacts/imager", "max_forks_repo_head_hexsha": "0fe8819a51e069c1e010cea0975c51a2a8794c42", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 30.7121661721, "max_line_length": 136, "alphanum_fraction": 0.468115942, "num_tokens": 9795, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8006920020959544, "lm_q2_score": 0.6334102636778401, "lm_q1q2_score": 0.5071665321723362}} {"text": "/* linalg/gsl_linalg.h\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2006, 2007 Gerard Jungman, Brian Gough, Patrick Alken\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n#ifndef __GSL_LINALG_H__\n#define __GSL_LINALG_H__\n\n#include \n#include \n#include \n#include \n\n#undef __BEGIN_DECLS\n#undef __END_DECLS\n#ifdef __cplusplus\n#define __BEGIN_DECLS extern \"C\" {\n#define __END_DECLS }\n#else\n#define __BEGIN_DECLS /* empty */\n#define __END_DECLS /* empty */\n#endif\n\n__BEGIN_DECLS\n\ntypedef enum\n {\n GSL_LINALG_MOD_NONE = 0,\n GSL_LINALG_MOD_TRANSPOSE = 1,\n GSL_LINALG_MOD_CONJUGATE = 2\n }\ngsl_linalg_matrix_mod_t;\n\n\n/* Note: You can now use the gsl_blas_dgemm function instead of matmult */\n\n/* Simple implementation of matrix multiply.\n * Calculates C = A.B\n *\n * exceptions: GSL_EBADLEN\n */\nint gsl_linalg_matmult (const gsl_matrix * A,\n const gsl_matrix * B,\n gsl_matrix * C);\n\n\n/* Simple implementation of matrix multiply.\n * Allows transposition of either matrix, so it\n * can compute A.B or Trans(A).B or A.Trans(B) or Trans(A).Trans(B)\n *\n * exceptions: GSL_EBADLEN\n */\nint gsl_linalg_matmult_mod (const gsl_matrix * A,\n gsl_linalg_matrix_mod_t modA,\n const gsl_matrix * B,\n gsl_linalg_matrix_mod_t modB,\n gsl_matrix * C);\n\n/* Calculate the matrix exponential by the scaling and\n * squaring method described in Moler + Van Loan,\n * SIAM Rev 20, 801 (1978). The mode argument allows\n * choosing an optimal strategy, from the table\n * given in the paper, for a given precision.\n *\n * exceptions: GSL_ENOTSQR, GSL_EBADLEN\n */\nint gsl_linalg_exponential_ss(\n const gsl_matrix * A,\n gsl_matrix * eA,\n gsl_mode_t mode\n );\n\n\n/* Householder Transformations */\n\ndouble gsl_linalg_householder_transform (gsl_vector * v);\ngsl_complex gsl_linalg_complex_householder_transform (gsl_vector_complex * v);\n\nint gsl_linalg_householder_hm (double tau, \n const gsl_vector * v, \n gsl_matrix * A);\n\nint gsl_linalg_householder_mh (double tau, \n const gsl_vector * v, \n gsl_matrix * A);\n\nint gsl_linalg_householder_hv (double tau, \n const gsl_vector * v, \n gsl_vector * w);\n\nint gsl_linalg_householder_hm1 (double tau, \n gsl_matrix * A);\n\nint gsl_linalg_complex_householder_hm (gsl_complex tau, \n const gsl_vector_complex * v, \n gsl_matrix_complex * A);\n\nint gsl_linalg_complex_householder_mh (gsl_complex tau,\n const gsl_vector_complex * v,\n gsl_matrix_complex * A);\n\nint gsl_linalg_complex_householder_hv (gsl_complex tau, \n const gsl_vector_complex * v, \n gsl_vector_complex * w);\n\n/* Hessenberg reduction */\n\nint gsl_linalg_hessenberg_decomp(gsl_matrix *A, gsl_vector *tau);\nint gsl_linalg_hessenberg_unpack(gsl_matrix * H, gsl_vector * tau,\n gsl_matrix * U);\nint gsl_linalg_hessenberg_unpack_accum(gsl_matrix * H, gsl_vector * tau,\n gsl_matrix * U);\nint gsl_linalg_hessenberg_set_zero(gsl_matrix * H);\nint gsl_linalg_hessenberg_submatrix(gsl_matrix *M, gsl_matrix *A,\n size_t top, gsl_vector *tau);\n\n/* To support gsl-1.9 interface: DEPRECATED */\nint gsl_linalg_hessenberg(gsl_matrix *A, gsl_vector *tau);\n\n\n/* Hessenberg-Triangular reduction */\n\nint gsl_linalg_hesstri_decomp(gsl_matrix * A, gsl_matrix * B,\n gsl_matrix * U, gsl_matrix * V,\n gsl_vector * work);\n\n/* Singular Value Decomposition\n\n * exceptions: \n */\n\nint\ngsl_linalg_SV_decomp (gsl_matrix * A,\n gsl_matrix * V,\n gsl_vector * S,\n gsl_vector * work);\n\nint\ngsl_linalg_SV_decomp_mod (gsl_matrix * A,\n gsl_matrix * X,\n gsl_matrix * V,\n gsl_vector * S,\n gsl_vector * work);\n\nint gsl_linalg_SV_decomp_jacobi (gsl_matrix * A,\n gsl_matrix * Q,\n gsl_vector * S);\n\nint\ngsl_linalg_SV_solve (const gsl_matrix * U,\n const gsl_matrix * Q,\n const gsl_vector * S,\n const gsl_vector * b,\n gsl_vector * x);\n\nint gsl_linalg_SV_leverage(const gsl_matrix *U, gsl_vector *h);\n\n\n/* LU Decomposition, Gaussian elimination with partial pivoting\n */\n\nint gsl_linalg_LU_decomp (gsl_matrix * A, gsl_permutation * p, int *signum);\n\nint gsl_linalg_LU_solve (const gsl_matrix * LU,\n const gsl_permutation * p,\n const gsl_vector * b,\n gsl_vector * x);\n\nint gsl_linalg_LU_svx (const gsl_matrix * LU,\n const gsl_permutation * p,\n gsl_vector * x);\n\nint gsl_linalg_LU_refine (const gsl_matrix * A,\n const gsl_matrix * LU,\n const gsl_permutation * p,\n const gsl_vector * b,\n gsl_vector * x,\n gsl_vector * residual);\n\nint gsl_linalg_LU_invert (const gsl_matrix * LU,\n const gsl_permutation * p,\n gsl_matrix * inverse);\n\ndouble gsl_linalg_LU_det (gsl_matrix * LU, int signum);\ndouble gsl_linalg_LU_lndet (gsl_matrix * LU);\nint gsl_linalg_LU_sgndet (gsl_matrix * lu, int signum);\n\n/* Complex LU Decomposition */\n\nint gsl_linalg_complex_LU_decomp (gsl_matrix_complex * A, \n gsl_permutation * p, \n int *signum);\n\nint gsl_linalg_complex_LU_solve (const gsl_matrix_complex * LU,\n const gsl_permutation * p,\n const gsl_vector_complex * b,\n gsl_vector_complex * x);\n\nint gsl_linalg_complex_LU_svx (const gsl_matrix_complex * LU,\n const gsl_permutation * p,\n gsl_vector_complex * x);\n\nint gsl_linalg_complex_LU_refine (const gsl_matrix_complex * A,\n const gsl_matrix_complex * LU,\n const gsl_permutation * p,\n const gsl_vector_complex * b,\n gsl_vector_complex * x,\n gsl_vector_complex * residual);\n\nint gsl_linalg_complex_LU_invert (const gsl_matrix_complex * LU,\n const gsl_permutation * p,\n gsl_matrix_complex * inverse);\n\ngsl_complex gsl_linalg_complex_LU_det (gsl_matrix_complex * LU,\n int signum);\n\ndouble gsl_linalg_complex_LU_lndet (gsl_matrix_complex * LU);\n\ngsl_complex gsl_linalg_complex_LU_sgndet (gsl_matrix_complex * LU,\n int signum);\n\n/* QR decomposition */\n\nint gsl_linalg_QR_decomp (gsl_matrix * A,\n gsl_vector * tau);\n\nint gsl_linalg_QR_solve (const gsl_matrix * QR,\n const gsl_vector * tau,\n const gsl_vector * b,\n gsl_vector * x);\n\nint gsl_linalg_QR_svx (const gsl_matrix * QR,\n const gsl_vector * tau,\n gsl_vector * x);\n\nint gsl_linalg_QR_lssolve (const gsl_matrix * QR, \n const gsl_vector * tau, \n const gsl_vector * b, \n gsl_vector * x, \n gsl_vector * residual);\n\n\nint gsl_linalg_QR_QRsolve (gsl_matrix * Q,\n gsl_matrix * R,\n const gsl_vector * b,\n gsl_vector * x);\n\nint gsl_linalg_QR_Rsolve (const gsl_matrix * QR,\n const gsl_vector * b,\n gsl_vector * x);\n\nint gsl_linalg_QR_Rsvx (const gsl_matrix * QR,\n gsl_vector * x);\n\nint gsl_linalg_QR_update (gsl_matrix * Q,\n gsl_matrix * R,\n gsl_vector * w,\n const gsl_vector * v);\n\nint gsl_linalg_QR_QTvec (const gsl_matrix * QR,\n const gsl_vector * tau,\n gsl_vector * v);\n\nint gsl_linalg_QR_Qvec (const gsl_matrix * QR,\n const gsl_vector * tau,\n gsl_vector * v);\n\nint gsl_linalg_QR_QTmat (const gsl_matrix * QR,\n const gsl_vector * tau,\n gsl_matrix * A);\n\nint gsl_linalg_QR_unpack (const gsl_matrix * QR,\n const gsl_vector * tau,\n gsl_matrix * Q,\n gsl_matrix * R);\n\nint gsl_linalg_R_solve (const gsl_matrix * R,\n const gsl_vector * b,\n gsl_vector * x);\n\nint gsl_linalg_R_svx (const gsl_matrix * R,\n gsl_vector * x);\n\n\n/* Q R P^T decomposition */\n\nint gsl_linalg_QRPT_decomp (gsl_matrix * A,\n gsl_vector * tau,\n gsl_permutation * p,\n int *signum,\n gsl_vector * norm);\n\nint gsl_linalg_QRPT_decomp2 (const gsl_matrix * A, \n gsl_matrix * q, gsl_matrix * r, \n gsl_vector * tau, \n gsl_permutation * p, \n int *signum,\n gsl_vector * norm);\n\nint gsl_linalg_QRPT_solve (const gsl_matrix * QR,\n const gsl_vector * tau,\n const gsl_permutation * p,\n const gsl_vector * b,\n gsl_vector * x);\n\n\nint gsl_linalg_QRPT_svx (const gsl_matrix * QR,\n const gsl_vector * tau,\n const gsl_permutation * p,\n gsl_vector * x);\n\nint gsl_linalg_QRPT_QRsolve (const gsl_matrix * Q,\n const gsl_matrix * R,\n const gsl_permutation * p,\n const gsl_vector * b,\n gsl_vector * x);\n\nint gsl_linalg_QRPT_Rsolve (const gsl_matrix * QR,\n const gsl_permutation * p,\n const gsl_vector * b,\n gsl_vector * x);\n\nint gsl_linalg_QRPT_Rsvx (const gsl_matrix * QR,\n const gsl_permutation * p,\n gsl_vector * x);\n\nint gsl_linalg_QRPT_update (gsl_matrix * Q,\n gsl_matrix * R,\n const gsl_permutation * p,\n gsl_vector * u,\n const gsl_vector * v);\n\n/* LQ decomposition */\n\nint gsl_linalg_LQ_decomp (gsl_matrix * A, gsl_vector * tau);\n\nint gsl_linalg_LQ_solve_T (const gsl_matrix * LQ, const gsl_vector * tau, \n\t\t\t const gsl_vector * b, gsl_vector * x);\n\nint gsl_linalg_LQ_svx_T (const gsl_matrix * LQ, const gsl_vector * tau, \n gsl_vector * x);\n\nint gsl_linalg_LQ_lssolve_T (const gsl_matrix * LQ, const gsl_vector * tau, \n\t\t\t const gsl_vector * b, gsl_vector * x, \n\t\t\t gsl_vector * residual);\n\nint gsl_linalg_LQ_Lsolve_T (const gsl_matrix * LQ, const gsl_vector * b, \n\t\t\t gsl_vector * x);\n\nint gsl_linalg_LQ_Lsvx_T (const gsl_matrix * LQ, gsl_vector * x);\n\nint gsl_linalg_L_solve_T (const gsl_matrix * L, const gsl_vector * b, \n\t\t\tgsl_vector * x);\n\nint gsl_linalg_LQ_vecQ (const gsl_matrix * LQ, const gsl_vector * tau, \n\t\t\tgsl_vector * v);\n\nint gsl_linalg_LQ_vecQT (const gsl_matrix * LQ, const gsl_vector * tau, \n\t\t\t gsl_vector * v);\n\nint gsl_linalg_LQ_unpack (const gsl_matrix * LQ, const gsl_vector * tau, \n\t\t\t gsl_matrix * Q, gsl_matrix * L);\n\nint gsl_linalg_LQ_update (gsl_matrix * Q, gsl_matrix * R,\n\t\t\t const gsl_vector * v, gsl_vector * w);\nint gsl_linalg_LQ_LQsolve (gsl_matrix * Q, gsl_matrix * L, \n\t\t\t const gsl_vector * b, gsl_vector * x);\n\n/* P^T L Q decomposition */\n\nint gsl_linalg_PTLQ_decomp (gsl_matrix * A, gsl_vector * tau, \n\t\t\t gsl_permutation * p, int *signum, \n\t\t\t gsl_vector * norm);\n\nint gsl_linalg_PTLQ_decomp2 (const gsl_matrix * A, gsl_matrix * q, \n\t\t\t gsl_matrix * r, gsl_vector * tau, \n\t\t\t gsl_permutation * p, int *signum, \n\t\t\t gsl_vector * norm);\n\nint gsl_linalg_PTLQ_solve_T (const gsl_matrix * QR,\n\t\t\t const gsl_vector * tau,\n\t\t\t const gsl_permutation * p,\n\t\t\t const gsl_vector * b,\n\t\t\t gsl_vector * x);\n\nint gsl_linalg_PTLQ_svx_T (const gsl_matrix * LQ,\n const gsl_vector * tau,\n const gsl_permutation * p,\n gsl_vector * x);\n\nint gsl_linalg_PTLQ_LQsolve_T (const gsl_matrix * Q, const gsl_matrix * L,\n\t\t\t const gsl_permutation * p,\n\t\t\t const gsl_vector * b,\n\t\t\t gsl_vector * x);\n\nint gsl_linalg_PTLQ_Lsolve_T (const gsl_matrix * LQ,\n\t\t\t const gsl_permutation * p,\n\t\t\t const gsl_vector * b,\n\t\t\t gsl_vector * x);\n\nint gsl_linalg_PTLQ_Lsvx_T (const gsl_matrix * LQ,\n\t\t\t const gsl_permutation * p,\n\t\t\t gsl_vector * x);\n\nint gsl_linalg_PTLQ_update (gsl_matrix * Q, gsl_matrix * L,\n\t\t\t const gsl_permutation * p,\n\t\t\t const gsl_vector * v, gsl_vector * w);\n\n/* Cholesky Decomposition */\n\nint gsl_linalg_cholesky_decomp (gsl_matrix * A);\n\nint gsl_linalg_cholesky_solve (const gsl_matrix * cholesky,\n const gsl_vector * b,\n gsl_vector * x);\n\nint gsl_linalg_cholesky_svx (const gsl_matrix * cholesky,\n gsl_vector * x);\n\nint gsl_linalg_cholesky_invert(gsl_matrix * cholesky);\n\n/* Cholesky decomposition with unit-diagonal triangular parts.\n * A = L D L^T, where diag(L) = (1,1,...,1).\n * Upon exit, A contains L and L^T as for Cholesky, and\n * the diagonal of A is (1,1,...,1). The vector Dis set\n * to the diagonal elements of the diagonal matrix D.\n */\nint gsl_linalg_cholesky_decomp_unit(gsl_matrix * A, gsl_vector * D);\n\n/* Complex Cholesky Decomposition */\n\nint gsl_linalg_complex_cholesky_decomp (gsl_matrix_complex * A);\n\nint gsl_linalg_complex_cholesky_solve (const gsl_matrix_complex * cholesky,\n const gsl_vector_complex * b,\n gsl_vector_complex * x);\n\nint gsl_linalg_complex_cholesky_svx (const gsl_matrix_complex * cholesky,\n gsl_vector_complex * x);\n\nint gsl_linalg_complex_cholesky_invert(gsl_matrix_complex * cholesky);\n\n\n/* Symmetric to symmetric tridiagonal decomposition */\n\nint gsl_linalg_symmtd_decomp (gsl_matrix * A, \n gsl_vector * tau);\n\nint gsl_linalg_symmtd_unpack (const gsl_matrix * A, \n const gsl_vector * tau,\n gsl_matrix * Q, \n gsl_vector * diag, \n gsl_vector * subdiag);\n\nint gsl_linalg_symmtd_unpack_T (const gsl_matrix * A,\n gsl_vector * diag, \n gsl_vector * subdiag);\n\n/* Hermitian to symmetric tridiagonal decomposition */\n\nint gsl_linalg_hermtd_decomp (gsl_matrix_complex * A, \n gsl_vector_complex * tau);\n\nint gsl_linalg_hermtd_unpack (const gsl_matrix_complex * A, \n const gsl_vector_complex * tau,\n gsl_matrix_complex * U, \n gsl_vector * diag, \n gsl_vector * sudiag);\n\nint gsl_linalg_hermtd_unpack_T (const gsl_matrix_complex * A, \n gsl_vector * diag, \n gsl_vector * subdiag);\n\n/* Linear Solve Using Householder Transformations\n\n * exceptions: \n */\n\nint gsl_linalg_HH_solve (gsl_matrix * A, const gsl_vector * b, gsl_vector * x);\nint gsl_linalg_HH_svx (gsl_matrix * A, gsl_vector * x);\n\n/* Linear solve for a symmetric tridiagonal system.\n\n * The input vectors represent the NxN matrix as follows:\n *\n * diag[0] offdiag[0] 0 ...\n * offdiag[0] diag[1] offdiag[1] ...\n * 0 offdiag[1] diag[2] ...\n * 0 0 offdiag[2] ...\n * ... ... ... ...\n */\nint gsl_linalg_solve_symm_tridiag (const gsl_vector * diag,\n const gsl_vector * offdiag,\n const gsl_vector * b,\n gsl_vector * x);\n\n/* Linear solve for a nonsymmetric tridiagonal system.\n\n * The input vectors represent the NxN matrix as follows:\n *\n * diag[0] abovediag[0] 0 ...\n * belowdiag[0] diag[1] abovediag[1] ...\n * 0 belowdiag[1] diag[2] ...\n * 0 0 belowdiag[2] ...\n * ... ... ... ...\n */\nint gsl_linalg_solve_tridiag (const gsl_vector * diag,\n const gsl_vector * abovediag,\n const gsl_vector * belowdiag,\n const gsl_vector * b,\n gsl_vector * x);\n\n\n/* Linear solve for a symmetric cyclic tridiagonal system.\n\n * The input vectors represent the NxN matrix as follows:\n *\n * diag[0] offdiag[0] 0 ..... offdiag[N-1]\n * offdiag[0] diag[1] offdiag[1] .....\n * 0 offdiag[1] diag[2] .....\n * 0 0 offdiag[2] .....\n * ... ...\n * offdiag[N-1] ...\n */\nint gsl_linalg_solve_symm_cyc_tridiag (const gsl_vector * diag,\n const gsl_vector * offdiag,\n const gsl_vector * b,\n gsl_vector * x);\n\n/* Linear solve for a nonsymmetric cyclic tridiagonal system.\n\n * The input vectors represent the NxN matrix as follows:\n *\n * diag[0] abovediag[0] 0 ..... belowdiag[N-1]\n * belowdiag[0] diag[1] abovediag[1] .....\n * 0 belowdiag[1] diag[2]\n * 0 0 belowdiag[2] .....\n * ... ...\n * abovediag[N-1] ...\n */\nint gsl_linalg_solve_cyc_tridiag (const gsl_vector * diag,\n const gsl_vector * abovediag,\n const gsl_vector * belowdiag,\n const gsl_vector * b,\n gsl_vector * x);\n\n\n/* Bidiagonal decomposition */\n\nint gsl_linalg_bidiag_decomp (gsl_matrix * A, \n gsl_vector * tau_U, \n gsl_vector * tau_V);\n\nint gsl_linalg_bidiag_unpack (const gsl_matrix * A, \n const gsl_vector * tau_U, \n gsl_matrix * U, \n const gsl_vector * tau_V,\n gsl_matrix * V,\n gsl_vector * diag, \n gsl_vector * superdiag);\n\nint gsl_linalg_bidiag_unpack2 (gsl_matrix * A, \n gsl_vector * tau_U, \n gsl_vector * tau_V,\n gsl_matrix * V);\n\nint gsl_linalg_bidiag_unpack_B (const gsl_matrix * A, \n gsl_vector * diag, \n gsl_vector * superdiag);\n\n/* Balancing */\n\nint gsl_linalg_balance_matrix (gsl_matrix * A, gsl_vector * D);\nint gsl_linalg_balance_accum (gsl_matrix * A, gsl_vector * D);\nint gsl_linalg_balance_columns (gsl_matrix * A, gsl_vector * D);\n\n\n__END_DECLS\n\n#endif /* __GSL_LINALG_H__ */\n", "meta": {"hexsha": "9e2710d7658a75d2ff07f9c7b4efc493fb99c7c7", "size": 21060, "ext": "h", "lang": "C", "max_stars_repo_path": "gsl-an/gsl/gsl_linalg.h", "max_stars_repo_name": "juandesant/astrometry.net", "max_stars_repo_head_hexsha": "47849f0443b890c4a875360f881d2e60d1cba630", "max_stars_repo_licenses": ["Net-SNMP", "Xnet"], "max_stars_count": 460.0, "max_stars_repo_stars_event_min_datetime": "2015-01-06T13:20:04.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-29T00:37:55.000Z", "max_issues_repo_path": "gsl-an/gsl/gsl_linalg.h", "max_issues_repo_name": "juandesant/astrometry.net", "max_issues_repo_head_hexsha": "47849f0443b890c4a875360f881d2e60d1cba630", "max_issues_repo_licenses": ["Net-SNMP", "Xnet"], "max_issues_count": 208.0, "max_issues_repo_issues_event_min_datetime": "2015-01-08T20:26:38.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-25T15:21:34.000Z", "max_forks_repo_path": "gsl-an/gsl/gsl_linalg.h", "max_forks_repo_name": "juandesant/astrometry.net", "max_forks_repo_head_hexsha": "47849f0443b890c4a875360f881d2e60d1cba630", "max_forks_repo_licenses": ["Net-SNMP", "Xnet"], "max_forks_count": 173.0, "max_forks_repo_forks_event_min_datetime": "2015-01-08T18:01:54.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-27T07:27:04.000Z", "avg_line_length": 35.3949579832, "max_line_length": 100, "alphanum_fraction": 0.5412155745, "num_tokens": 4700, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7577943712746406, "lm_q2_score": 0.6688802669716107, "lm_q1q2_score": 0.5068737013677654}} {"text": "/* siman/siman.c\n * \n * Copyright (C) 2007 Brian Gough\n * Copyright (C) 1996, 1997, 1998, 1999, 2000 Mark Galassi\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n\nstatic inline double\nboltzmann(double E, double new_E, double T, gsl_siman_params_t *params)\n{\n double x = -(new_E - E) / (params->k * T);\n /* avoid underflow errors for large uphill steps */\n return (x < GSL_LOG_DBL_MIN) ? 0.0 : exp(x);\n}\n\nstatic inline void\ncopy_state(void *src, void *dst, size_t size, gsl_siman_copy_t copyfunc)\n{\n if (copyfunc) {\n copyfunc(src, dst);\n } else {\n memcpy(dst, src, size);\n }\n}\n \n/* implementation of a basic simulated annealing algorithm */\n\nvoid \ngsl_siman_solve (const gsl_rng * r, void *x0_p, gsl_siman_Efunc_t Ef,\n gsl_siman_step_t take_step,\n gsl_siman_metric_t distance,\n gsl_siman_print_t print_position,\n gsl_siman_copy_t copyfunc,\n gsl_siman_copy_construct_t copy_constructor,\n gsl_siman_destroy_t destructor,\n size_t element_size,\n gsl_siman_params_t params)\n{\n void *x, *new_x, *best_x;\n double E, new_E, best_E;\n int i;\n double T, T_factor;\n int n_evals = 1, n_iter = 0, n_accepts, n_rejects, n_eless;\n\n /* this function requires that either the dynamic functions (copy,\n copy_constructor and destrcutor) are passed, or that an element\n size is given */\n assert((copyfunc != NULL && copy_constructor != NULL && destructor != NULL)\n || (element_size != 0));\n\n distance = 0 ; /* This parameter is not currently used */\n E = Ef(x0_p);\n\n if (copyfunc) {\n x = copy_constructor(x0_p);\n new_x = copy_constructor(x0_p);\n best_x = copy_constructor(x0_p);\n } else {\n x = (void *) malloc (element_size);\n memcpy (x, x0_p, element_size);\n new_x = (void *) malloc (element_size);\n best_x = (void *) malloc (element_size);\n memcpy (best_x, x0_p, element_size);\n }\n\n best_E = E;\n\n T = params.t_initial;\n T_factor = 1.0 / params.mu_t;\n\n if (print_position) {\n printf (\"#-iter #-evals temperature position energy\\n\");\n }\n\n while (1) {\n\n n_accepts = 0;\n n_rejects = 0;\n n_eless = 0;\n\n for (i = 0; i < params.iters_fixed_T; ++i) {\n\n copy_state(x, new_x, element_size, copyfunc);\n\n take_step (r, new_x, params.step_size);\n new_E = Ef (new_x);\n\n if(new_E <= best_E){\n if (copyfunc) {\n copyfunc(new_x,best_x);\n } else {\n memcpy (best_x, new_x, element_size);\n }\n best_E=new_E;\n }\n\n ++n_evals; /* keep track of Ef() evaluations */\n /* now take the crucial step: see if the new point is accepted\n or not, as determined by the boltzmann probability */\n if (new_E < E) {\n\n\tif (new_E < best_E) {\n\t copy_state(new_x, best_x, element_size, copyfunc);\n\t best_E = new_E;\n\t}\n\n /* yay! take a step */\n\tcopy_state(new_x, x, element_size, copyfunc);\n E = new_E;\n ++n_eless;\n\n } else if (gsl_rng_uniform(r) < boltzmann(E, new_E, T, ¶ms)) {\n /* yay! take a step */\n\tcopy_state(new_x, x, element_size, copyfunc);\n E = new_E;\n ++n_accepts;\n\n } else {\n ++n_rejects;\n }\n }\n\n if (print_position) {\n /* see if we need to print stuff as we go */\n /* printf(\"%5d %12g %5d %3d %3d %3d\", n_iter, T, n_evals, */\n /* 100*n_eless/n_steps, 100*n_accepts/n_steps, */\n /* 100*n_rejects/n_steps); */\n printf (\"%5d %7d %12g\", n_iter, n_evals, T);\n print_position (x);\n printf (\" %12g %12g\\n\", E, best_E);\n }\n\n /* apply the cooling schedule to the temperature */\n /* FIXME: I should also introduce a cooling schedule for the iters */\n T *= T_factor;\n ++n_iter;\n if (T < params.t_min) {\n break;\n }\n }\n\n /* at the end, copy the result onto the initial point, so we pass it\n back to the caller */\n copy_state(best_x, x0_p, element_size, copyfunc);\n\n if (copyfunc) {\n destructor(x);\n destructor(new_x);\n destructor(best_x);\n } else {\n free (x);\n free (new_x);\n free (best_x);\n }\n}\n\n/* implementation of a simulated annealing algorithm with many tries */\n\nvoid \ngsl_siman_solve_many (const gsl_rng * r, void *x0_p, gsl_siman_Efunc_t Ef,\n gsl_siman_step_t take_step,\n gsl_siman_metric_t distance,\n gsl_siman_print_t print_position,\n size_t element_size,\n gsl_siman_params_t params)\n{\n /* the new set of trial points, and their energies and probabilities */\n void *x, *new_x;\n double *energies, *probs, *sum_probs;\n double Ex; /* energy of the chosen point */\n double T, T_factor; /* the temperature and a step multiplier */\n int i;\n double u; /* throw the die to choose a new \"x\" */\n int n_iter;\n\n if (print_position) {\n printf (\"#-iter temperature position\");\n printf (\" delta_pos energy\\n\");\n }\n\n x = (void *) malloc (params.n_tries * element_size);\n new_x = (void *) malloc (params.n_tries * element_size);\n energies = (double *) malloc (params.n_tries * sizeof (double));\n probs = (double *) malloc (params.n_tries * sizeof (double));\n sum_probs = (double *) malloc (params.n_tries * sizeof (double));\n\n T = params.t_initial;\n T_factor = 1.0 / params.mu_t;\n\n memcpy (x, x0_p, element_size);\n\n n_iter = 0;\n while (1)\n {\n Ex = Ef (x);\n for (i = 0; i < params.n_tries - 1; ++i)\n { /* only go to N_TRIES-2 */\n /* center the new_x[] around x, then pass it to take_step() */\n sum_probs[i] = 0;\n memcpy ((char *)new_x + i * element_size, x, element_size);\n take_step (r, (char *)new_x + i * element_size, params.step_size);\n energies[i] = Ef ((char *)new_x + i * element_size);\n probs[i] = boltzmann(Ex, energies[i], T, ¶ms);\n }\n /* now add in the old value of \"x\", so it is a contendor */\n memcpy ((char *)new_x + (params.n_tries - 1) * element_size, x, element_size);\n energies[params.n_tries - 1] = Ex;\n probs[params.n_tries - 1] = boltzmann(Ex, energies[i], T, ¶ms);\n\n /* now throw biased die to see which new_x[i] we choose */\n sum_probs[0] = probs[0];\n for (i = 1; i < params.n_tries; ++i)\n {\n sum_probs[i] = sum_probs[i - 1] + probs[i];\n }\n u = gsl_rng_uniform (r) * sum_probs[params.n_tries - 1];\n for (i = 0; i < params.n_tries; ++i)\n {\n if (u < sum_probs[i])\n {\n memcpy (x, (char *) new_x + i * element_size, element_size);\n break;\n }\n }\n if (print_position)\n {\n printf (\"%5d\\t%12g\\t\", n_iter, T);\n print_position (x);\n printf (\"\\t%12g\\t%12g\\n\", distance (x, x0_p), Ex);\n }\n T *= T_factor;\n ++n_iter;\n if (T < params.t_min)\n\t{\n\t break;\n }\n }\n\n /* now return the value via x0_p */\n memcpy (x0_p, x, element_size);\n\n /* printf(\"the result is: %g (E=%g)\\n\", x, Ex); */\n\n free (x);\n free (new_x);\n free (energies);\n free (probs);\n free (sum_probs);\n}\n", "meta": {"hexsha": "65b9177fe074f08ea0082ddbfe7908b39c6a3404", "size": 8151, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.6/siman/siman.c", "max_stars_repo_name": "ielomariala/Hex-Game", "max_stars_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-12-18T18:09:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-10T11:31:28.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/siman/siman.c", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-12-16T17:41:24.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-22T00:00:16.000Z", "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/siman/siman.c", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 14.0, "max_forks_repo_forks_event_min_datetime": "2015-07-21T04:47:52.000Z", "max_forks_repo_forks_event_max_datetime": "2020-03-12T12:31:25.000Z", "avg_line_length": 29.7481751825, "max_line_length": 84, "alphanum_fraction": 0.5871672187, "num_tokens": 2288, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.746138993030751, "lm_q2_score": 0.679178699175393, "lm_q1q2_score": 0.5067617106906631}} {"text": "/* Copyright (c) 2014, Giuseppe Argentieri \n\n * All rights reserved.\n * \n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n * \n * 1. Redistributions of source code must retain the above copyright notice,\n * this list of conditions and the following disclaimer.\n * \n * 2. Redistributions in binary form must reproduce the above copyright notice,\n * this list of conditions and the following disclaimer in the documentation\n * and/or other materials provided with the distribution.\n * \n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE\n * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE\n * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n * POSSIBILITY OF SUCH DAMAGE.\n * \n */\n\n/*\n * =====================================================================================\n *\n * Filename: Img_ss.c\n *\n * Description: \n *\n * Version: 1.0\n * Created: 15/04/2013 16:44:51\n * Revision: none\n * Compiler: gcc\n *\n * Author: Giuseppe Argentieri (), argenti@ts.infn.it\n * Organization: \n *\n * =====================================================================================\n */\n\n#include \"funcs.h\"\n/* #include */\n\nint im_gss ( void* params, double* val, double* error )\n{\n\tstruct f_params* pars = (struct f_params*) params ;\n\tdouble o_c, b, O, o_1, alpha ;\n\tassign_p ( pars, &o_c, &b, &O, &o_1 ) ;\n\talpha = pars->alpha ;\n\n\tdouble e1, e2, E1, E2 ;\n\tdouble err1, err2, ERR1, ERR2 ;\n\t\n\tdouble beta1 = O + o_1 ;\n\tdouble beta2 = o_1 - O ;\n\tdouble mu = 1/o_c ;\n\n\texpi ( beta1*mu, &e1, &err1 ) ;\n\texpi_plus ( beta1*mu, &E1, &ERR1 ) ;\n\texpi_plus ( beta2*mu, &E2, &ERR2 ) ;\n\texpi ( beta2*mu, &e2, &err2 ) ;\n\t\n/* \te1 = - gsl_sf_expint_E1 ( beta1*mu ) ;\n * \te2 = - gsl_sf_expint_E1 ( beta2*mu ) ;\n * \tE1 = gsl_sf_expint_Ei ( beta1*mu ) ;\n * \tE2 = gsl_sf_expint_Ei ( beta2*mu ) ;\n */\n\n\tdouble imgss = (alpha/4)*(beta1*(e1*exp(beta1*mu)-E1*exp(-beta1*mu)) +\n\t\t\t\t beta2*(E2*exp(-beta2*mu)-e2*exp(beta2*mu))) ;\n\t*val = imgss ;\n\n\tdouble err = (alpha/4)*(beta1*(err1*exp(beta1*mu))+ERR1*exp(-beta1*mu) +\n\t\t\t\t beta2*(ERR2*exp(-beta2*mu)+err2*exp(beta2*mu))) ;\n\t*error = err ;\t\n\n\treturn 0;\n}\n\n\n\n", "meta": {"hexsha": "f2597b41f268615c9c37c868d98d5c3c15399825", "size": 2882, "ext": "c", "lang": "C", "max_stars_repo_path": "Img_ss.c", "max_stars_repo_name": "j-silver/quantum_dots", "max_stars_repo_head_hexsha": "54132a3c7dd0e83e27375f6c5f6ec154065a9695", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Img_ss.c", "max_issues_repo_name": "j-silver/quantum_dots", "max_issues_repo_head_hexsha": "54132a3c7dd0e83e27375f6c5f6ec154065a9695", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Img_ss.c", "max_forks_repo_name": "j-silver/quantum_dots", "max_forks_repo_head_hexsha": "54132a3c7dd0e83e27375f6c5f6ec154065a9695", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 32.75, "max_line_length": 88, "alphanum_fraction": 0.6311589174, "num_tokens": 810, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7905303186696747, "lm_q2_score": 0.640635854839898, "lm_q1q2_score": 0.5064420664778041}} {"text": "#ifdef USE_MKL\n#include \n#else\n#include \n#endif\n\n// contains all calls to C-interface BLAS functions\n// e.g. http://www.netlib.org/lapack/explore-html/d1/dff/cblas__example1_8c_source.html\n\n// returns the dot product of x and y\n// http://www.netlib.org/lapack/explore-html/d5/df6/ddot_8f_source.html\ndouble specex_dot(int n, const double *x, const double *y){\n return cblas_ddot(n, x, 1, y, 1);\n}\n\n// y += alpha*x\n// http://www.netlib.org/lapack/explore-html/d9/dcd/daxpy_8f_source.html\nvoid specex_axpy(int n, const double *alpha, const double *x, const double *y){\n cblas_daxpy(n, *alpha, x, 1, y, 1); \n}\n\n// A += alpha*x*x**T, where A is a symmetric matrx (only lower half is filled)\n// http://www.netlib.org/lapack/explore-html/d3/d60/dsyr_8f_source.html\nvoid specex_syr(int n, const double *alpha, const double *x, const double *A){\n cblas_dsyr(CblasColMajor, CblasLower, n, *alpha, x, 1, A, n); \n}\n\n// C = alpha*A**T + beta*C, where A is a symmetric matrx \n// http://www.netlib.org/lapack/explore-html/dc/d05/dsyrk_8f_source.html\nvoid specex_syrk(int n, int k, const double *alpha, const double *A, const double *beta,\n\t\t const double *C){\n cblas_dsyrk(CblasColMajor, CblasLower, CblasNoTrans, n, k, *alpha, A, n, *beta, C, n); \n}\n\n// y = alpha*A*x + beta*y\n// http://www.netlib.org/lapack/explore-html/dc/da8/dgemv_8f_source.html\nvoid specex_gemv(int m, int n, const double *alpha, const double *A, const double *x,\n\t\t const double *beta, const double *y){\n cblas_dgemv(CblasColMajor, CblasNoTrans, m, n, *alpha, A, m, x, 1, *beta, y, 1);\n \n}\n\n// C = alpha*A*B + beta*C\n// http://www.netlib.org/lapack/explore-html/d7/d2b/dgemm_8f_source.html\nvoid specex_gemm(int m, int n, int k, const double *alpha, const double *A, const double *B,\n\t\t const double *beta, const double *C){\n cblas_dgemm(CblasColMajor, CblasNoTrans, CblasNoTrans, m, n, k, *alpha, A, m, B, k, *beta, C, m); \n}\n\n", "meta": {"hexsha": "3bb4edbe7a95f9f693ea9b586dee99d695c6647b", "size": 1914, "ext": "c", "lang": "C", "max_stars_repo_path": "src/specex_blas.c", "max_stars_repo_name": "tskisner/specex", "max_stars_repo_head_hexsha": "c5ae74a85305395cdd3cb4a3ac966bef4eacd8b2", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/specex_blas.c", "max_issues_repo_name": "tskisner/specex", "max_issues_repo_head_hexsha": "c5ae74a85305395cdd3cb4a3ac966bef4eacd8b2", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 39.0, "max_issues_repo_issues_event_min_datetime": "2016-06-17T19:58:17.000Z", "max_issues_repo_issues_event_max_datetime": "2022-01-07T00:11:25.000Z", "max_forks_repo_path": "src/specex_blas.c", "max_forks_repo_name": "tskisner/specex", "max_forks_repo_head_hexsha": "c5ae74a85305395cdd3cb4a3ac966bef4eacd8b2", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 4.0, "max_forks_repo_forks_event_min_datetime": "2016-06-16T17:43:38.000Z", "max_forks_repo_forks_event_max_datetime": "2021-07-18T16:32:34.000Z", "avg_line_length": 38.28, "max_line_length": 101, "alphanum_fraction": 0.6959247649, "num_tokens": 672, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8539127529517044, "lm_q2_score": 0.5926665999540698, "lm_q1q2_score": 0.5060855679493063}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"allvars.h\"\n#include \"proto.h\" \n\n#define SNR (120.0)\nint n_con_sim=301, n_line_sim=301;\ndouble sim_error=10.0*1.0/SNR, sim_rel_error=1.0/SNR;\n\ndouble *PQmat, *PSmat, *Peigens, *Peigens_mat, *Peigens_vecs;\n\ngsl_rng_type const * gsl_T_sim;\ngsl_rng * gsl_r_sim;\ngsl_interp_accel *gsl_acc, *gsl_acc_error;\ngsl_interp *gsl_linear, *gsl_linear_error;\n\nvoid simulate_con(double sigma, double tau, double alpha, double ave_con)\n{\n FILE *fscon_out;\n\n double *Py, *Prandvec;\n int i, info;\n\n Py = array_malloc(n_con_sim);\n Prandvec = array_malloc(n_con_sim);\n\n simulate_con_init();\n\n\n set_covar_Simmat(sigma, tau, alpha);\n memcpy(PQmat, PSmat, n_con_sim*n_con_sim*sizeof(double));\n \n/* eigen_sym_mat(PQmat, n_con_sim, Peigens, &info);\n memcpy(Peigens_vecs, PQmat, n_con_sim*n_con_sim*sizeof(double));\n\n for(i=0; i150.0)\n fprintf(fscon_out, \"%f\\t%f\\t%f\\n\", Tcon[i], Fcon[i], Fcerrs[i]);\n }\n\n gsl_interp_init(gsl_linear, Tcon, Fcon, n_con_sim);\n gsl_interp_init(gsl_linear_error, Tcon, Fcerrs, n_con_sim);\n\n fclose(fscon_out);\n}\n\nvoid simulate_con_init()\n{\n int i;\n double Tcon_min, Tcon_max, Tline_min, Tline_max, dTs;\n\n PSmat = array_malloc(n_con_sim*n_con_sim);\n PQmat = array_malloc(n_con_sim*n_con_sim);\n Peigens = array_malloc(n_con_sim);\n Peigens_vecs = array_malloc(n_con_sim*n_con_sim);\n Peigens_mat = array_malloc(n_con_sim*n_con_sim); \n\n Tcon = array_malloc(n_con_sim);\n Fcon = array_malloc(n_con_sim);\n Fcerrs = array_malloc(n_con_sim);\n\n Tcon_min = 0.0;\n Tcon_max = 300.0;\n dTs = (Tcon_max - Tcon_min) / (n_con_sim-1.0);\n for(i=0; i=Tcon[0] && tcon <= Tcon[n_con_sim-1])\n {\n fcon = gsl_interp_eval(gsl_linear, Tcon, Fcon, tcon, gsl_acc);\n fcon_err = gsl_interp_eval(gsl_linear_error, Tcon, Fcerrs, tcon, gsl_acc_error);\n flux += fcon * TF[j];\n err += pow(fcon_err *TF[j] * dtau, 2);\n }\n }\n flux *= dtau;\n err = sqrt(err);\n Fline[i] = flux;\n Flerrs[i] = sim_error;\n }\n\n gsl_rng_set(gsl_r_sim, time(NULL)); // reset the seed of the random generator\n for(i=0; i170.0)\n fprintf(fp, \"%f %f %f\\n\", Tline[i], Fline[i] + Flerrs[i]*gsl_ran_gaussian(gsl_r_sim, 1.0), Flerrs[i]);\n }\n fclose(fp);\n}", "meta": {"hexsha": "10e73ab9f18ceb423136a79dbdc69fc56eed8881", "size": 5561, "ext": "c", "lang": "C", "max_stars_repo_path": "src/sim.c", "max_stars_repo_name": "LiyrAstroph/MICA", "max_stars_repo_head_hexsha": "2592b8ad3011880898f557a69b22cad63fcd47e0", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2016-10-25T06:32:33.000Z", "max_stars_repo_stars_event_max_datetime": "2016-10-25T06:32:33.000Z", "max_issues_repo_path": "src/sim.c", "max_issues_repo_name": "LiyrAstroph/MICA", "max_issues_repo_head_hexsha": "2592b8ad3011880898f557a69b22cad63fcd47e0", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/sim.c", "max_forks_repo_name": "LiyrAstroph/MICA", "max_forks_repo_head_hexsha": "2592b8ad3011880898f557a69b22cad63fcd47e0", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 3.0, "max_forks_repo_forks_event_min_datetime": "2016-12-29T06:04:13.000Z", "max_forks_repo_forks_event_max_datetime": "2020-04-12T11:48:42.000Z", "avg_line_length": 23.764957265, "max_line_length": 108, "alphanum_fraction": 0.6169753641, "num_tokens": 2045, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8376199511728003, "lm_q2_score": 0.6039318337259583, "lm_q1q2_score": 0.5058653530772369}} {"text": "/*\n * Module that implements in c a Bayesian network trained with probabilistic\n * backpropagation (PBP).\n *\n * Author: Jose Miguel Hernandez Lobato\n * Date: 10 March 2015\n *\n */\n\n#include \n#include \n#include \n#include \n#include \n\n#include \"network.h\"\n#include \"pnorm.h\"\n\n/* Prototipes of private functions */\n\nvoid refine_prior(NETWORK *network);\nvoid do_ADF_update(NETWORK * network, double *x, double y);\ndouble randn(double mu, double sigma);\n\n/**\n * Generates a sample from a Gaussian distribution\n * @param mu Mean of the Gaussian.\n * @param sigma Standard deviation of the Gaussian\n *\n */\n\ndouble randn(double mu, double sigma) {\n\n double U1, U2, W, mult;\n static double X1, X2;\n static int call = 0;\n\n if (call == 1)\n {\n call = !call;\n return (mu + sigma * (double) X2);\n }\n\n do\n {\n U1 = -1 + ((double) rand () / RAND_MAX) * 2;\n U2 = -1 + ((double) rand () / RAND_MAX) * 2;\n W = pow (U1, 2) + pow (U2, 2);\n }\n while (W >= 1 || W == 0);\n\n mult = sqrt ((-2 * log (W)) / W);\n X1 = U1 * mult;\n X2 = U2 * mult;\n\n call = !call;\n\n return (mu + sigma * (double) X1);\n}\n\n/**\n * Constructor for a network.\n *\n * @param size_hidden_layers The size of each hidden layer.\n * @param n_hidden_layers The number of hidden layers.\n * @param d The input dimensionality.\n * @param random_noise Random noise for the initialization of the\n * posterior means.\n *\n */\n\nNETWORK *init_network(int *size_hidden_layers, int n_hidden_layers, int d,double *random_noise) {\n\n NETWORK *ret;\n int n, i, j, k;\n\n /* We save memory for the structure */\n \n ret = malloc(sizeof(NETWORK));\n\n /* We initialize the number of hidden layers */\n\n ret->n_hidden_layers = n_hidden_layers;\n\n /* We refine the prior on the noise variance and on the prior variance */\n\n ret->a_noise = 2.0 * 3;\n ret->b_noise = 2.0 * 3;\n ret->a_prior = 2.0 * 3;\n ret->b_prior = 2.0 * 3;\n\n /* We save memory for the array with the number of neurons per layer,\n * the activation type, the scaling of the activation per layer,\n and he starting position for the different arrays */\n\n ret->neurons_per_layer = malloc(sizeof(int) * (n_hidden_layers + 3));\n ret->linear = malloc(sizeof(int) * (n_hidden_layers + 3));\n ret->scaling_a = malloc(sizeof(double) * (n_hidden_layers + 3));\n ret->start_w = malloc(sizeof(int) * (n_hidden_layers + 3));\n ret->start_z = malloc(sizeof(int) * (n_hidden_layers + 3));\n ret->start_a = malloc(sizeof(int) * (n_hidden_layers + 3));\n\n /* We initialize the number of neurons per layer, the activation type and\n * compute the size of the auxiliary variables */\n\n /* The input layer */\n\n ret->start_w[ 0 ] = -1;\n ret->start_z[ 0 ] = 0;\n ret->start_a[ 0 ] = 0;\n\n ret->neurons_per_layer[ 0 ] = d;\n ret->linear[ 0 ] = 0;\n ret->scaling_a[ 0 ] = 1.0;\n\n ret->size_w = 0;\n ret->size_a = d;\n ret->size_z = d + 1;\n\n /* The hidden layers */\n\n for (i = 1 ; i < n_hidden_layers + 1 ; i ++) {\n ret->start_w[ i ] = ret->size_w;\n ret->start_z[ i ] = ret->size_z;\n ret->start_a[ i ] = ret->size_a;\n\n ret->neurons_per_layer[ i ] = size_hidden_layers[ i - 1 ];\n ret->linear[ i ] = 0;\n ret->scaling_a[ i ] = 1.0 / (ret->neurons_per_layer[ i - 1 ] + 1);\n\n ret->size_w += (ret->neurons_per_layer[ i - 1 ] + 1) * ret->neurons_per_layer[ i ];\n ret->size_a += ret->neurons_per_layer[ i ];\n ret->size_z += ret->neurons_per_layer[ i ] + 1;\n }\n\n /* The output layer */\n\n ret->start_w[ i ] = ret->size_w;\n ret->start_z[ i ] = ret->size_z;\n ret->start_a[ i ] = ret->size_a;\n\n ret->neurons_per_layer[ i ] = 1;\n ret->linear[ i ] = 1;\n ret->scaling_a[ i ] = 1.0 / (ret->neurons_per_layer[ i - 1 ] + 1);\n\n ret->size_w += (ret->neurons_per_layer[ i - 1 ] + 1) * ret->neurons_per_layer[ i ];\n ret->size_a += ret->neurons_per_layer[ i ];\n ret->size_z += ret->neurons_per_layer[ i ] + 1;\n \n /* The fake output layer */\n\n i++;\n ret->start_w[ i ] = ret->size_w;\n ret->start_z[ i ] = ret->size_z;\n ret->start_a[ i ] = ret->size_a;\n\n ret->neurons_per_layer[ i ] = 1;\n ret->linear[ i ] = 1;\n ret->scaling_a[ i ] = 1.0;\n\n ret->size_w += (ret->neurons_per_layer[ i - 1 ] + 1) * ret->neurons_per_layer[ i ];\n ret->size_a += ret->neurons_per_layer[ i ];\n ret->size_z += ret->neurons_per_layer[ i ] + 1;\n \n /* We save memory for the auxiliary variables */\n\n ret->sample_w = (double *) malloc(sizeof(double) * ret->size_w);\n ret->m_w = (double *) malloc(sizeof(double) * ret->size_w);\n ret->m_w_new = (double *) malloc(sizeof(double) * ret->size_w);\n ret->m_w_squared = (double *) malloc(sizeof(double) * ret->size_w);\n ret->v_w = (double *) malloc(sizeof(double) * ret->size_w);\n ret->v_w_new = (double *) malloc(sizeof(double) * ret->size_w);\n ret->m_z = (double *) malloc(sizeof(double) * ret->size_z);\n ret->m_z_scaled = (double *) malloc(sizeof(double) * ret->size_z);\n ret->m_z_squared = (double *) malloc(sizeof(double) * ret->size_z);\n ret->v_z = (double *) malloc(sizeof(double) * ret->size_z);\n ret->v_z_scaled = (double *) malloc(sizeof(double) * ret->size_z);\n ret->m_a = (double *) malloc(sizeof(double) * ret->size_a);\n ret->v_a = (double *) malloc(sizeof(double) * ret->size_a);\n ret->alpha = (double *) malloc(sizeof(double) * ret->size_a);\n ret->gamma = (double *) malloc(sizeof(double) * ret->size_a);\n ret->delta_m = (double *) malloc(sizeof(double) * ret->size_z);\n ret->delta_v = (double *) malloc(sizeof(double) * ret->size_z);\n\n ret->dm_z_d_m_a = (double *) malloc(sizeof(double) * ret->size_z);\n ret->dv_z_d_m_a = (double *) malloc(sizeof(double) * ret->size_z);\n ret->dm_z_d_v_a = (double *) malloc(sizeof(double) * ret->size_z);\n ret->dv_z_d_v_a = (double *) malloc(sizeof(double) * ret->size_z);\n ret->dm_a_d_m_a = (double *) malloc(sizeof(double) * ret->size_w);\n ret->dv_a_d_m_a = (double *) malloc(sizeof(double) * ret->size_w);\n ret->dm_a_d_v_a = (double *) malloc(sizeof(double) * ret->size_w);\n ret->dv_a_d_v_a = (double *) malloc(sizeof(double) * ret->size_w);\n ret->dm_a_d_m_z = (double *) malloc(sizeof(double) * ret->size_w);\n ret->dv_a_d_m_z = (double *) malloc(sizeof(double) * ret->size_w);\n ret->dm_a_d_v_z = (double *) malloc(sizeof(double) * ret->size_w);\n ret->dv_a_d_v_z = (double *) malloc(sizeof(double) * ret->size_w);\n ret->dm_a_d_m_w = (double *) malloc(sizeof(double) * ret->size_w);\n ret->dv_a_d_m_w = (double *) malloc(sizeof(double) * ret->size_w);\n ret->dm_a_d_v_w = (double *) malloc(sizeof(double) * ret->size_w);\n ret->dv_a_d_v_w = (double *) malloc(sizeof(double) * ret->size_w);\n ret->grad_m_w = (double *) malloc(sizeof(double) * ret->size_w);\n ret->grad_v_w = (double *) malloc(sizeof(double) * ret->size_w);\n\n ret->m_w_hat_nat = (double *) malloc(sizeof(double) * ret->size_w);\n ret->v_w_hat_nat = (double *) malloc(sizeof(double) * ret->size_w);\n ret->a_w_hat_nat = (double *) malloc(sizeof(double) * ret->size_w);\n ret->b_w_hat_nat = (double *) malloc(sizeof(double) * ret->size_w);\n\n ret->m_w_old = (double *) malloc(sizeof(double) * ret->size_w);\n ret->v_w_old = (double *) malloc(sizeof(double) * ret->size_w);\n\n /* We initialize the posterior approximation */\n \n k = 0;\n for (i = 1 ; i < n_hidden_layers + 3 ; i ++) {\n n = (ret->neurons_per_layer[ i - 1 ] + 1) * ret->neurons_per_layer[ i ];\n for (j = 0 ; j < n ; j++) {\n ret->m_w[ k ] = 1.0 / sqrt(ret->neurons_per_layer[ i - 1 ] + 1) * random_noise[ k ];\n ret->v_w[ k ] = ret->b_prior / (ret->a_prior - 1);\n ret->m_w_hat_nat[ k ] = 0;\n ret->v_w_hat_nat[ k ] = (ret->a_prior - 1) / ret->b_prior;\n ret->a_w_hat_nat[ k ] = 0;\n ret->b_w_hat_nat[ k ] = 0;\n k++;\n }\n }\n\n /* We initialize the weights of the fake ouput layer */\n\n ret->m_w[ ret->start_w[ n_hidden_layers + 2 ] ] = 1.0;\n ret->m_w[ ret->start_w[ n_hidden_layers + 2 ] + 1 ] = 0.0;\n ret->v_w[ ret->start_w[ n_hidden_layers + 2 ] ] = 0.0;\n ret->v_w[ ret->start_w[ n_hidden_layers + 2 ] + 1 ] = 0.0;\n\n return ret;\n}\n\n/**\n * Constructor for a network.\n *\n * @param network Pointer to the network to destroy.\n *\n */\n\nvoid destroy_network(NETWORK *n) {\n\n free(n->neurons_per_layer);\n free(n->linear);\n free(n->scaling_a);\n free(n->start_w);\n free(n->start_a);\n free(n->start_z);\n free(n->sample_w);\n free(n->m_w);\n free(n->m_w_new);\n free(n->m_w_squared);\n free(n->v_w);\n free(n->v_w_new);\n free(n->m_z);\n free(n->m_z_squared);\n free(n->m_z_scaled);\n free(n->v_z);\n free(n->m_a);\n free(n->v_a);\n free(n->alpha);\n free(n->gamma);\n free(n->delta_m);\n free(n->delta_v);\n free(n->dm_z_d_m_a);\n free(n->dv_z_d_m_a);\n free(n->dm_z_d_v_a);\n free(n->dv_z_d_v_a);\n free(n->dm_a_d_m_a);\n free(n->dv_a_d_m_a);\n free(n->dm_a_d_v_a);\n free(n->dv_a_d_v_a);\n free(n->dm_a_d_m_z);\n free(n->dv_a_d_m_z);\n free(n->dm_a_d_v_z);\n free(n->dv_a_d_v_z);\n free(n->dm_a_d_m_w);\n free(n->dv_a_d_m_w);\n free(n->dm_a_d_v_w);\n free(n->dv_a_d_v_w);\n free(n->grad_m_w);\n free(n->grad_v_w);\n free(n->m_w_hat_nat);\n free(n->v_w_hat_nat);\n free(n->a_w_hat_nat);\n free(n->b_w_hat_nat);\n free(n->m_w_old);\n free(n->v_w_old);\n\n return;\n}\n\n/**\n * Deterministic forward propagation of the data.\n *\n */\n\nvoid deterministc_forward_PBP(NETWORK *n, int index_layer) {\n\n int i;\n double sqrt_aux;\n\n /* Auxiliary pointers */\n\n double * __restrict__ sample_w;\n double * __restrict__ m_z;\n double * __restrict__ m_z_previous_layer;\n double * __restrict__ m_a;\n\n /* Auxiliary variables */\n\n double scaling_a;\n int n_neurons;\n int input_size;\n int linear;\n \n /* We initialize the pointers */\n\n sample_w = n->sample_w + n->start_w[ index_layer ];\n m_z = n->m_z + n->start_z[ index_layer ];\n m_z_previous_layer = n->m_z + n->start_z[ index_layer - 1 ];\n m_a = n->m_a + n->start_a[ index_layer ];\n\n /* We update the number of neurons, input size, type of activation and scaling constant */\n\n n_neurons = n->neurons_per_layer[ index_layer ];\n input_size = n->neurons_per_layer[ index_layer - 1 ] + 1;\n linear = n->linear[ index_layer ];\n scaling_a = n->scaling_a[ index_layer ];\n\n /* We compute the scaled activation mean: sqrt_aux * sample_w x m_z */\n\n sqrt_aux = sqrt(scaling_a);\n cblas_dgemv(CblasRowMajor, CblasNoTrans, n_neurons, input_size, sqrt_aux, sample_w, input_size, m_z_previous_layer, 1, 0.0, m_a, 1);\n\n /* We apply the non-linearity or compute a linear activation function */\n\n if (linear) {\n for (i = 0 ; i < n_neurons ; i++) {\n m_z[ i ] = m_a[ i ];\n }\n } else {\n for (i = 0 ; i < n_neurons ; i++) {\n m_z[ i ] = (m_a[ i ] > 0) ? m_a[ i ] : 0;\n }\n }\n\n /* We add the bias if we are not in the two last layers */\n\n if (index_layer < n->n_hidden_layers + 1) {\n m_z[ n_neurons ] = 1.0;\n }\n}\n\n/**\n * Forward propagation of probabilities.\n *\n */\n\nvoid forward_PBP(NETWORK *n, int index_layer) {\n\n int i, limit;\n double a, a2, p, g, sqrt_aux;\n\n /* Auxiliary pointers */\n\n double * __restrict__ m_w;\n double * __restrict__ m_w_squared;\n double * __restrict__ v_w;\n double * __restrict__ m_z;\n double * __restrict__ v_z;\n double * __restrict__ m_a;\n double * __restrict__ v_a;\n double * __restrict__ m_z_previous_layer;\n double * __restrict__ m_z_previous_layer_squared;\n double * __restrict__ v_z_previous_layer;\n double * __restrict__ alpha;\n double * __restrict__ gamma;\n\n /* Auxiliary variables */\n\n double scaling_a;\n int n_neurons;\n int input_size;\n int linear;\n \n /* We initialize the pointers */\n\n m_w = n->m_w + n->start_w[ index_layer ];\n m_w_squared = n->m_w_squared + n->start_w[ index_layer ];\n v_w = n->v_w + n->start_w[ index_layer ];\n m_z = n->m_z + n->start_z[ index_layer ];\n v_z = n->v_z + n->start_z[ index_layer ];\n m_a = n->m_a + n->start_a[ index_layer ];\n v_a = n->v_a + n->start_a[ index_layer ];\n m_z_previous_layer = n->m_z + n->start_z[ index_layer - 1 ];\n v_z_previous_layer = n->v_z + n->start_z[ index_layer - 1 ];\n m_z_previous_layer_squared = n->m_z_squared + n->start_z[ index_layer - 1 ];\n alpha = n->alpha + n->start_a[ index_layer ];\n gamma = n->gamma + n->start_a[ index_layer ];\n\n /* We update the number of neurons, input size, type of activation and scaling constant */\n\n n_neurons = n->neurons_per_layer[ index_layer ];\n input_size = n->neurons_per_layer[ index_layer - 1 ] + 1;\n linear = n->linear[ index_layer ];\n scaling_a = n->scaling_a[ index_layer ];\n\n /* We compute the m_z_previous_layer_squared and the m_w_squared */\n\n limit = n_neurons * input_size;\n for (i = 0 ; i < limit ; i++)\n m_w_squared[ i ] = m_w[ i ] * m_w[ i ];\n for (i = 0 ; i < input_size ; i++)\n m_z_previous_layer_squared[ i ] = m_z_previous_layer[ i ] * m_z_previous_layer[ i ];\n\n /* We compute the scaled activation mean: sqrt_aux * m_w x m_z */\n\n sqrt_aux = sqrt(scaling_a);\n cblas_dgemv(CblasRowMajor, CblasNoTrans, n_neurons, input_size, sqrt_aux, m_w, input_size, m_z_previous_layer, 1, 0.0, m_a, 1);\n\n /* We compute the scaled activation variance: (m_w_squared x v_z_previous_layer +\n v_w x m_z_previous_layer_squared + v_w x v_z_previous_layer) */\n\n cblas_dgemv(CblasRowMajor, CblasNoTrans, n_neurons, input_size, scaling_a, m_w_squared, input_size, v_z_previous_layer, 1, 0, v_a, 1);\n cblas_dgemv(CblasRowMajor, CblasNoTrans, n_neurons, input_size, scaling_a, v_w, input_size, m_z_previous_layer_squared, 1, 1.0, v_a, 1);\n cblas_dgemv(CblasRowMajor, CblasNoTrans, n_neurons, input_size, scaling_a, v_w, input_size, v_z_previous_layer, 1, 1.0, v_a, 1);\n\n /* We apply the non-linearity or compute a linear activation function */\n\n if (linear) {\n for (i = 0 ; i < n_neurons ; i++) {\n m_z[ i ] = m_a[ i ];\n v_z[ i ] = v_a[ i ];\n }\n } else {\n for (i = 0 ; i < n_neurons ; i++) {\n\n sqrt_aux = sqrt(v_a[ i ]);\n a = m_a[ i ] / sqrt_aux;\n a2 = a * a;\n p = pnorm(a);\n g = (a < -30) ? -a - 1.0 / a + 2.0 / (a * a2) : 0.398942280401432677939946059 * exp(-0.5 * a2) / p;\n\n /* We compute the output mean and variance */\n\n m_z[ i ] = p * (m_a[ i ] + sqrt_aux * g);\n v_z[ i ] = m_z[ i ] * (m_a[ i ] + sqrt_aux * g) * (1 - p) + p * v_a[ i ] * (1 - g * g - g * a);\n\n alpha[ i ] = a;\n gamma[ i ] = g;\n }\n }\n\n /* We add the bias if we are not in the two last layers */\n\n if (index_layer < n->n_hidden_layers + 1) {\n m_z[ n_neurons ] = 1.0;\n v_z[ n_neurons ] = 0.0;\n }\n}\n\n/**\n * Backward computation of gradients.\n *\n */\n\nvoid backward_PBP(NETWORK *n, int index_layer) {\n\n double g, a, da_dm_a, da_dv_a, dg_dm_a, dg_dv_a, d, p;\n int i, j, k, limit_1, limit_2;\n\n /* Auxiliary pointers */\n\n double * __restrict__ m_w;\n double * __restrict__ m_w_layer_above;\n double * __restrict__ v_w_layer_above;\n double * __restrict__ m_z;\n double * __restrict__ m_z_scaled;\n double * __restrict__ m_a;\n double * __restrict__ v_a;\n double * __restrict__ m_z_layer_below;\n double * __restrict__ m_z_layer_below_scaled;\n double * __restrict__ v_z_layer_below;\n double * __restrict__ v_z_layer_below_scaled;\n double * __restrict__ alpha;\n double * __restrict__ gamma;\n double * __restrict__ delta_m_layer_above;\n double * __restrict__ delta_v_layer_above;\n double * __restrict__ delta_m;\n double * __restrict__ delta_v;\n double * __restrict__ dm_z_d_m_a;\n double * __restrict__ dv_z_d_m_a;\n double * __restrict__ dm_z_d_v_a;\n double * __restrict__ dv_z_d_v_a;\n double * __restrict__ dm_a_d_m_a;\n double * __restrict__ dv_a_d_m_a;\n double * __restrict__ dm_a_d_v_a;\n double * __restrict__ dv_a_d_v_a;\n double * __restrict__ dm_a_d_m_z;\n double * __restrict__ dv_a_d_m_z;\n double * __restrict__ dm_a_d_v_z;\n double * __restrict__ dv_a_d_v_z;\n double * __restrict__ dm_a_d_m_w;\n double * __restrict__ dv_a_d_m_w;\n double * __restrict__ dm_a_d_v_w;\n double * __restrict__ dv_a_d_v_w;\n double * __restrict__ grad_m_w;\n double * __restrict__ grad_v_w;\n\n /* Auxiliary variables */\n\n double scaling_a, scaling_a_layer_above, sqrt_aux, sqrt_v_a;\n double *p_aux_1, *p_aux_2, *p_aux_3, *p_aux_4;\n double *p_aux_1_2, *p_aux_2_2, *p_aux_3_2, *p_aux_4_2;\n int n_neurons;\n int linear;\n\n /* We initialize the auxiliary pointers */\n\n m_w = n->m_w + n->start_w[ index_layer ];\n m_w_layer_above = n->m_w + n->start_w[ index_layer + 1 ];\n v_w_layer_above = n->v_w + n->start_w[ index_layer + 1 ];\n m_z = n->m_z + n->start_z[ index_layer ];\n m_z_scaled = n->m_z_scaled + n->start_z[ index_layer ];\n m_a = n->m_a + n->start_a[ index_layer ];\n v_a = n->v_a + n->start_a[ index_layer ];\n m_z_layer_below = n->m_z + n->start_z[ index_layer - 1 ];\n v_z_layer_below = n->v_z + n->start_z[ index_layer - 1 ];\n m_z_layer_below_scaled = n->m_z_scaled + n->start_z[ index_layer - 1 ];\n v_z_layer_below_scaled = n->v_z_scaled + n->start_z[ index_layer - 1 ];\n alpha = n->alpha + n->start_a[ index_layer ];\n gamma = n->gamma + n->start_a[ index_layer ];\n delta_m_layer_above = n->delta_m + n->start_z[ index_layer + 1 ];\n delta_v_layer_above = n->delta_v + n->start_z[ index_layer + 1 ];\n delta_m = n->delta_m + n->start_z[ index_layer ];\n delta_v = n->delta_v + n->start_z[ index_layer ];\n\n dm_z_d_m_a = n->dm_z_d_m_a + n->start_z[ index_layer ];\n dv_z_d_m_a = n->dv_z_d_m_a + n->start_z[ index_layer ];\n dm_z_d_v_a = n->dm_z_d_v_a + n->start_z[ index_layer ];\n dv_z_d_v_a = n->dv_z_d_v_a + n->start_z[ index_layer ];\n dm_a_d_m_a = n->dm_a_d_m_a + n->start_w[ index_layer ];\n dv_a_d_m_a = n->dv_a_d_m_a + n->start_w[ index_layer ];\n dm_a_d_v_a = n->dm_a_d_v_a + n->start_w[ index_layer ];\n dv_a_d_v_a = n->dv_a_d_v_a + n->start_w[ index_layer ];\n dm_a_d_m_z = n->dm_a_d_m_z + n->start_w[ index_layer ];\n dv_a_d_m_z = n->dv_a_d_m_z + n->start_w[ index_layer ];\n dm_a_d_v_z = n->dm_a_d_v_z + n->start_w[ index_layer ];\n dv_a_d_v_z = n->dv_a_d_v_z + n->start_w[ index_layer ];\n dm_a_d_m_w = n->dm_a_d_m_w + n->start_w[ index_layer ];\n dv_a_d_m_w = n->dv_a_d_m_w + n->start_w[ index_layer ];\n dm_a_d_v_w = n->dm_a_d_v_w + n->start_w[ index_layer ];\n dv_a_d_v_w = n->dv_a_d_v_w + n->start_w[ index_layer ];\n grad_m_w = n->grad_m_w + n->start_w[ index_layer ];\n grad_v_w = n->grad_v_w + n->start_w[ index_layer ];\n\n /* We update the number of neurons, input size, type of activation and scaling constant */\n\n n_neurons = n->neurons_per_layer[ index_layer ];\n linear = n->linear[ index_layer ];\n scaling_a = n->scaling_a[ index_layer ];\n scaling_a_layer_above = n->scaling_a[ index_layer + 1 ];\n\n /* We compute the gradient of the non-linear activations with respect to the activations */\n\n if (linear) {\n for (i = 0 ; i < n_neurons ; i++) {\n dm_z_d_m_a[ i ] = 1.0;\n dm_z_d_v_a[ i ] = 0.0;\n dv_z_d_m_a[ i ] = 0.0;\n dv_z_d_v_a[ i ] = 1.0;\n\n }\n } else {\n for (i = 0 ; i < n_neurons ; i++) {\n g = gamma[ i ];\n a = alpha[ i ];\n da_dm_a = 1.0 / sqrt(v_a[ i ]);\n da_dv_a = m_a[ i ] / (2 * v_a[ i ]) * da_dm_a;\n if (a < -30) {\n g = -a - 1.0 / a + 2.0 / (a * a * a);\n dg_dm_a = -da_dm_a + 1.0 / (a * a) * da_dm_a - 6.0 / (a * a * a * a) * da_dm_a;\n dg_dv_a = -da_dv_a + 1.0 / (a * a) * da_dv_a - 6.0 / (a * a * a * a) * da_dv_a;\n } else {\n dg_dm_a = -(g * a + g * g) * da_dm_a;\n dg_dv_a = -(g * a + g * g) * da_dv_a;\n }\n d = 0.398942280401432677939946059 * exp(-0.5 * a * a);\n p = pnorm(a);\n sqrt_v_a = sqrt(v_a[ i ]);\n dm_z_d_m_a[ i ] = da_dm_a * d * (m_a[ i ] + sqrt_v_a * g) + p * (1 + sqrt_v_a * dg_dm_a);\n dm_z_d_v_a[ i ] = da_dv_a * d * (m_a[ i ] + sqrt_v_a * g) + p * (g / (2 * sqrt_v_a) + sqrt_v_a * dg_dv_a);\n dv_z_d_m_a[ i ] = dm_z_d_m_a[ i ] * (m_a[ i ] + sqrt_v_a * g) * (1 - p) + m_z[ i ] * ((1 + sqrt_v_a * dg_dm_a) * (1 - p) -\n (m_a[ i ] + sqrt_v_a * g) * d * da_dm_a) + d * da_dm_a * v_a[ i ] * (1 - g * g - g * a) - p * v_a[ i ] *\n (2 * g * dg_dm_a + dg_dm_a * a + g * da_dm_a);\n dv_z_d_v_a[ i ] = dm_z_d_v_a[ i ] * (m_a[ i ] + sqrt_v_a * g) * (1 - p) + m_z[ i ] * ((0.5 / sqrt_v_a * g + dg_dv_a * sqrt_v_a) * (1 - p) -\n (m_a[ i ]+ sqrt_v_a * g) * d * da_dv_a) + d * da_dv_a * v_a[ i ] * (1 - g * g - g * a) + p * ((1 - g * g - g * a) + v_a[ i ] *\n (-2 * g * dg_dv_a - dg_dv_a * a - g * da_dv_a));\n }\n }\n\n /* We scale m_z */\n\n limit_1 = n_neurons + 1;\n for (i = 0 ; i < limit_1 ; i++) {\n m_z_scaled[ i ] = m_z[ i ] * scaling_a_layer_above;\n }\n\n /* We initialize the rows of dv_a_dm_z to m_z_scaled */\n\n limit_1 = n->neurons_per_layer[ index_layer + 1 ];\n limit_2 = n_neurons + 1;\n for (i = 0 ; i < limit_1 ; i++) {\n p_aux_1 = dv_a_d_m_z + i * limit_2;\n for (j = 0 ; j < limit_2 ; j++) {\n p_aux_1[ j ] = m_z_scaled[ j ];\n }\n }\n\n /* We compute the gradient of the activation of the layer above with respect to the non-linear activations in this layer */\n\n sqrt_aux = sqrt(scaling_a_layer_above);\n limit_1 = n->neurons_per_layer[ index_layer + 1 ] * (n_neurons + 1);\n for (i = 0 ; i < limit_1 ; i++) {\n dm_a_d_m_z[ i ] = m_w_layer_above[ i ] * sqrt_aux;\n dm_a_d_v_z[ i ] = 0;\n dv_a_d_m_z[ i ] = dv_a_d_m_z[ i ] * 2 * v_w_layer_above[ i ];\n dv_a_d_v_z[ i ] = (m_w_layer_above[ i ] * m_w_layer_above[ i ] + v_w_layer_above[ i ]) * scaling_a_layer_above;\n }\n\n /* We scale the activatons from the layer below */\n\n sqrt_aux = sqrt(scaling_a);\n limit_1 = n->neurons_per_layer[ index_layer - 1 ] + 1;\n for (i = 0 ; i < limit_1 ; i++) {\n m_z_layer_below_scaled[ i ] = m_z_layer_below[ i ] * sqrt_aux;\n v_z_layer_below_scaled[ i ] = v_z_layer_below[ i ] * scaling_a;\n }\n\n /* We initialize dm_a_dm_w, dv_a_dm_w and dv_a_dv_w */\n\n limit_1 = n_neurons;\n limit_2 = n->neurons_per_layer[ index_layer - 1 ] + 1;\n for (i = 0 ; i < limit_1 ; i++) {\n p_aux_1 = dm_a_d_m_w + i * limit_2;\n p_aux_2 = dv_a_d_m_w + i * limit_2;\n p_aux_3 = dv_a_d_v_w + i * limit_2;\n for (j = 0 ; j < limit_2 ; j++) {\n p_aux_1[ j ] = m_z_layer_below_scaled[ j ];\n p_aux_2[ j ] = v_z_layer_below_scaled[ j ];\n p_aux_3[ j ] = (m_z_layer_below_scaled[ j ] * m_z_layer_below_scaled[ j ] + v_z_layer_below_scaled[ j ]);\n }\n }\n\n limit_1 = n_neurons * (n->neurons_per_layer[ index_layer - 1 ] + 1);\n for (i = 0 ; i < limit_1 ; i++) {\n dm_a_d_v_w[ i ] = 0;\n dv_a_d_m_w[ i ] = 2 * dv_a_d_m_w[ i ] * m_w[ i ];\n }\n\n /* We compute the gradient of the activations of the top layer with respect to the activations of the current layer */\n\n limit_1 = n->neurons_per_layer[ index_layer + 1 ];\n limit_2 = n_neurons + 1;\n k = 0;\n for (i = 0 ; i < limit_1 ; i++) {\n p_aux_1 = dm_a_d_m_a + i * limit_2;\n p_aux_2 = dv_a_d_m_a + i * limit_2;\n p_aux_3 = dm_a_d_v_a + i * limit_2;\n p_aux_4 = dv_a_d_v_a + i * limit_2;\n p_aux_1_2 = dm_a_d_m_z + i * limit_2;\n p_aux_2_2 = dm_a_d_v_z + i * limit_2;\n p_aux_3_2 = dv_a_d_m_z + i * limit_2;\n p_aux_4_2 = dv_a_d_v_z + i * limit_2;\n for (j = 0 ; j < limit_2 - 1 ; j++) {\n p_aux_1[ j ] = p_aux_1_2[ j ] * dm_z_d_m_a[ j ] + p_aux_2_2[ j ] * dv_z_d_m_a[ j ];\n p_aux_2[ j ] = p_aux_3_2[ j ] * dm_z_d_m_a[ j ] + p_aux_4_2[ j ] * dv_z_d_m_a[ j ];\n p_aux_3[ j ] = p_aux_1_2[ j ] * dm_z_d_v_a[ j ] + p_aux_2_2[ j ] * dv_z_d_v_a[ j ];\n p_aux_4[ j ] = p_aux_3_2[ j ] * dm_z_d_v_a[ j ] + p_aux_4_2[ j ] * dv_z_d_v_a[ j ];\n }\n }\n\n /* We compute the deltas */\n \n limit_1 = n->neurons_per_layer[ index_layer + 1 ];\n cblas_dgemv(CblasRowMajor, CblasTrans, limit_1, n_neurons + 1, 1.0, dm_a_d_m_a, n_neurons + 1, delta_m_layer_above, 1, 0.0, delta_m, 1);\n cblas_dgemv(CblasRowMajor, CblasTrans, limit_1, n_neurons + 1, 1.0, dv_a_d_m_a, n_neurons + 1, delta_v_layer_above, 1, 1.0, delta_m, 1);\n cblas_dgemv(CblasRowMajor, CblasTrans, limit_1, n_neurons + 1, 1.0, dm_a_d_v_a, n_neurons + 1, delta_m_layer_above, 1, 0.0, delta_v, 1);\n cblas_dgemv(CblasRowMajor, CblasTrans, limit_1, n_neurons + 1, 1.0, dv_a_d_v_a, n_neurons + 1, delta_v_layer_above, 1, 1.0, delta_v, 1);\n\n /* We compute the gradients */\n\n limit_1 = n_neurons;\n limit_2 = n->neurons_per_layer[ index_layer - 1 ] + 1;\n k = 0;\n for (i = 0 ; i < limit_1 ; i++) {\n for (j = 0 ; j < limit_2 ; j++) {\n grad_m_w[ k ] = delta_m[ i ] * dm_a_d_m_w[ k ] + delta_v[ i ] * dv_a_d_m_w[ k ];\n grad_v_w[ k ] = delta_m[ i ] * dm_a_d_v_w[ k ] + delta_v[ i ] * dv_a_d_v_w[ k ];\n k++;\n }\n }\n}\n\n/**\n * Function that performs an ADF update.\n *\n * @param network Pointer to the network.\n * @param x Pointer to the input features.\n * @param y Pointer to the target.\n *\n */\n\nvoid do_ADF_update(NETWORK * n, double *x, double y) {\n\n int i, limit_1;\n\n double * __restrict__ m_z;\n double * __restrict__ v_z;\n double * __restrict__ delta_m;\n double * __restrict__ delta_v;\n\n double * __restrict__ m_w;\n double * __restrict__ v_w;\n double * __restrict__ grad_m_w;\n double * __restrict__ grad_v_w;\n\n double m, v, v1, v2, logZ, logZ1, logZ2, d_logZ_d_m, d_logZ_d_v, a_new, b_new, m_aux, v_aux;\n\n /* We initialize the non-linear activations of the input layer with the data */\n\n limit_1 = n->start_a[ 1 ];\n m_z = n->m_z;\n v_z = n->v_z;\n for (i = 0 ; i < limit_1 ; i++) {\n m_z[ i ] = x[ i ];\n v_z[ i ] = 0.0;\n }\n m_z[ i ] = 1.0;\n v_z[ i ] = 0.0;\n\n /* We do a forward pass */\n\n limit_1 = n->n_hidden_layers + 2;\n for (i = 1 ; i < limit_1 ; i++)\n forward_PBP(n, i);\n\n /* We obtain logZ, logZ1 and logZ2 and the updates for a and b */\n\n m_z = n->m_z + n->start_z[ n->n_hidden_layers + 1 ];\n v_z = n->v_z + n->start_z[ n->n_hidden_layers + 1 ];\n\n m = m_z[ 0 ];\n v = v_z[ 0 ] + n->b_noise / (n->a_noise - 1);\n v1 = v_z[ 0 ] + n->b_noise / (n->a_noise - 0);\n v2 = v_z[ 0 ] + n->b_noise / (n->a_noise + 1);\n logZ = -0.5 * (log(v) + (m - y) * (m - y) / v);\n logZ1 = -0.5 * (log(v1) + (m - y) * (m - y) / v1);\n logZ2 = -0.5 * (log(v2) + (m - y) * (m - y) / v2);\n\n a_new = 1.0 / (exp(logZ2 - 2 * logZ1 + logZ) * (n->a_noise + 1.0) / n->a_noise - 1.0);\n b_new = 1.0 / (exp(logZ2 - logZ1) * (n->a_noise + 1) / n->b_noise - exp(logZ1 - logZ) * n->a_noise / n->b_noise);\n\n /* We initialize the deltas for the output layer */\n\n d_logZ_d_m = -(m - y) / v;\n d_logZ_d_v = -0.5 / v + 0.5 * (m - y) * (m - y) / (v * v);\n delta_m = n->delta_m + n->start_z[ n->n_hidden_layers + 2 ];\n delta_v = n->delta_v + n->start_z[ n->n_hidden_layers + 2 ];\n delta_m[ 0 ] = d_logZ_d_m;\n delta_v[ 0 ] = d_logZ_d_v;\n\n /* We do a backward pass */\n\n limit_1 = n->n_hidden_layers + 1;\n for (i = limit_1 ; i >= 1 ; i--)\n backward_PBP(n, i);\n\n /* We update the mean and variance parameters, except those in the fake output layer */\n\n m_w = n->m_w;\n v_w = n->v_w;\n grad_m_w = n->grad_m_w;\n grad_v_w = n->grad_v_w;\n \n limit_1 = n->size_w - 2;\n for (i = 0 ; i < limit_1 ; i++) {\n v_aux = v_w[ i ] - v_w[ i ] * v_w[ i ] * (grad_m_w[ i ] * grad_m_w[ i ] - 2 * grad_v_w[ i ]);\n m_aux = m_w[ i ] + v_w[ i ] * grad_m_w[ i ];\n if (v_aux > 1e-100 && m_aux != NAN && v_aux != NAN) {\n m_w[ i ] = m_aux;\n v_w[ i ] = v_aux;\n }\n }\n\n /* We update the noise variables */\n\n n->b_noise = b_new;\n n->a_noise = a_new;\n}\n\n/**\n * Function that refines the approximate factor for the prior.\n *\n * @param network Pointer to the network.\n *\n */\n\nvoid refine_prior(NETWORK *n) {\n\n int i;\n\n double v_w_nat, m_w_nat, v_w_cav_nat, m_w_cav_nat, v_w_cav, m_w_cav,\n a_w_nat, b_w_nat, a_w_cav_nat, b_w_cav_nat, a_w_cav, b_w_cav,\n v, v1, v2, logZ, logZ1, logZ2, d_logZ_d_m_w_cav, d_logZ_d_v_w_cav,\n m_w_new, v_w_new, a_w_new, b_w_new, v_w_new_nat, m_w_new_nat,\n a_w_new_nat, b_w_new_nat;\n\n /* We iterate over the layers refining the prior */\n \n for (i = 0 ; i < n->size_w - 2 ; i++) {\n v_w_nat = 1.0 / n->v_w[ i ];\n m_w_nat = n->m_w[ i ] / n->v_w[ i ];\n v_w_cav_nat = v_w_nat - n->v_w_hat_nat[ i ];\n m_w_cav_nat = m_w_nat - n->m_w_hat_nat[ i ];\n\n v_w_cav = 1.0 / v_w_cav_nat;\n m_w_cav = m_w_cav_nat / v_w_cav_nat;\n a_w_nat = n->a_prior - 1;\n b_w_nat = -n->b_prior;\n a_w_cav_nat = a_w_nat - n->a_w_hat_nat[ i ];\n b_w_cav_nat = b_w_nat - n->b_w_hat_nat[ i ];\n a_w_cav = a_w_cav_nat + 1;\n b_w_cav = -b_w_cav_nat;\n\n if (v_w_cav > 0 && b_w_cav > 0 && a_w_cav > 1 && v_w_cav < 1e6) {\n\n v = v_w_cav + b_w_cav / (a_w_cav - 1);\n v1 = v_w_cav + b_w_cav / a_w_cav;\n v2 = v_w_cav + b_w_cav / (a_w_cav + 1);\n logZ = -0.5 * log(v) - 0.5 * m_w_cav * m_w_cav / v;\n logZ1 = -0.5 * log(v1) - 0.5 * m_w_cav * m_w_cav / v1;\n logZ2 = -0.5 * log(v2) - 0.5 * m_w_cav * m_w_cav / v2;\n d_logZ_d_m_w_cav = -m_w_cav / v;\n d_logZ_d_v_w_cav = -0.5 / v + 0.5 * m_w_cav * m_w_cav / (v * v);\n m_w_new = m_w_cav + v_w_cav * d_logZ_d_m_w_cav;\n v_w_new = v_w_cav - v_w_cav * v_w_cav * (d_logZ_d_m_w_cav * d_logZ_d_m_w_cav - 2 * d_logZ_d_v_w_cav) ;\n a_w_new = 1.0 / (exp(logZ2 - 2 * logZ1 + logZ) * (a_w_cav + 1) / a_w_cav - 1.0);\n b_w_new = 1.0 / (exp(logZ2 - logZ1) * (a_w_cav + 1) / (b_w_cav) - exp(logZ1 - logZ) * a_w_cav / b_w_cav);\n v_w_new_nat = 1.0 / v_w_new;\n m_w_new_nat = m_w_new / v_w_new;\n a_w_new_nat = a_w_new - 1;\n b_w_new_nat = -b_w_new;\n\n n->m_w_hat_nat[ i ] = m_w_new_nat - m_w_cav_nat;\n n->v_w_hat_nat[ i ] = v_w_new_nat - v_w_cav_nat;\n n->a_w_hat_nat[ i ] = a_w_new_nat - a_w_cav_nat;\n n->b_w_hat_nat[ i ] = b_w_new_nat - b_w_cav_nat;\n\n n->m_w[ i ] = m_w_new;\n n->v_w[ i ] = v_w_new;\n\n n->a_prior = a_w_new;\n n->b_prior = b_w_new;\n }\n }\n}\n\n/**\n * Function that performs one learning epoch.\n *\n * @param network Pointer to the network.\n * @param x Pointer to the input feature matrix.\n * @param y Pointer to the target vector.\n * @param n_datapoints Number of data points in the training set.\n * @param d Dimensionality of the training data.\n * @param permutation A random permuation of the input data.\n *\n */\n\nNETWORK *one_learning_epoch(NETWORK *n, double *x, double *y, int n_datapoints, int d, int *permutation) {\n\n int i, index;\n\n /* We do one ADF upte for each datapoint */\n\n for (i = 0 ; i < n_datapoints ; i++) {\n index = permutation[ i ] * d;\n do_ADF_update(n, x + index, y[ permutation[ i ] ]);\n \n if (i % 1000 == 0) {\n printf(\".\");\n fflush(stdout);\n }\n }\n printf(\"\\n\");\n fflush(stdout);\n\n /* We refine the prior */\n\n refine_prior(n);\n\n /* We are done */\n\n return n;\n}\n\n/**\n * Function that predicts deterministically.\n *\n * @param network Pointer to the network.\n * @param x_test Pointer to the input feature matrix.\n * @param y_test Pointer to store the predictions.\n * @param n_datapoints Number of data points in the test set.\n * @param d Dimensionality of the test data.\n *\n */\n\nNETWORK *predict_deterministic(NETWORK *n, double *x_test, double *y_test, int n_datapoints, int d) {\n\n int i, j, index, limit_1;\n\n double *m_z;\n\n for (i = 0 ; i < n_datapoints ; i++) {\n\n /* We initialize the non-linear activations of the input layer with the data */\n\n limit_1 = n->start_a[ 1 ];\n m_z = n->m_z;\n for (j = 0 ; j < limit_1 ; j++) {\n index = i * d + j;\n m_z[ j ] = x_test[ index ];\n }\n m_z[ j ] = 1.0;\n\n /* We do a forward pass */\n\n limit_1 = n->n_hidden_layers + 2;\n for (j = 1 ; j < limit_1 ; j++)\n deterministc_forward_PBP(n, j);\n\n /* We store the results */\n\n m_z = n->m_z + n->start_z[ n->n_hidden_layers + 1 ];\n\n y_test[ i ] = m_z[ 0 ];\n }\n \n /* We are done */\n\n return n;\n}\n\n/**\n * Function that predicts.\n *\n * @param network Pointer to the network.\n * @param x_test Pointer to the input feature matrix.\n * @param m_test Pointer to store the predictive mean.\n * @param v_test Pointer to store the predictive variance.\n * @param v_noise Pointer to store the noise variance.\n * @param n_datapoints Number of data points in the test set.\n * @param d Dimensionality of the test data.\n *\n */\n\nNETWORK *predict(NETWORK *n, double *x_test, double *m_test, double *v_test, double *v_noise, int n_datapoints, int d) {\n\n int i, j, index, limit_1;\n\n double *m_z, *v_z;\n\n for (i = 0 ; i < n_datapoints ; i++) {\n\n /* We initialize the non-linear activations of the input layer with the data */\n\n limit_1 = n->start_a[ 1 ];\n m_z = n->m_z;\n v_z = n->v_z;\n for (j = 0 ; j < limit_1 ; j++) {\n index = i * d + j;\n m_z[ j ] = x_test[ index ];\n v_z[ j ] = 0.0;\n }\n m_z[ j ] = 1.0;\n v_z[ j ] = 0.0;\n\n /* We do a forward pass */\n\n limit_1 = n->n_hidden_layers + 2;\n for (j = 1 ; j < limit_1 ; j++)\n forward_PBP(n, j);\n\n /* We store the results */\n\n m_z = n->m_z + n->start_z[ n->n_hidden_layers + 1 ];\n v_z = n->v_z + n->start_z[ n->n_hidden_layers + 1 ];\n\n m_test[ i ] = m_z[ 0 ];\n v_test[ i ] = v_z[ 0 ];\n }\n \n /* We store the noise value */\n\n *v_noise = n->b_noise / (n->a_noise - 1);\n \n /* We are done */\n\n return n;\n}\n\n/* Function that returns the parameters of the network */\n\nvoid get_params(NETWORK *n, double *sample_w_out, double *m_w_out, double *v_w_out, double *m_w_hat_nat_out, double *v_w_hat_nat_out,\n double *a_w_hat_nat_out, double *b_w_hat_nat_out, double *a_noise_out, double *b_noise_out, double *a_prior_out,\n double *b_prior_out, int *neurons_per_layer_out) {\n\n int i, limit_1;\n\n /* We copy the parameters */\n\n limit_1 = n->size_w - 2;\n for (i = 0 ; i < limit_1 ; i++) {\n sample_w_out[ i ] = n->sample_w[ i ];\n m_w_out[ i ] = n->m_w[ i ];\n v_w_out[ i ] = n->v_w[ i ];\n m_w_hat_nat_out[ i ] = n->m_w_hat_nat[ i ];\n v_w_hat_nat_out[ i ] = n->v_w_hat_nat[ i ];\n a_w_hat_nat_out[ i ] = n->a_w_hat_nat[ i ];\n b_w_hat_nat_out[ i ] = n->b_w_hat_nat[ i ];\n }\n \n *a_noise_out = n->a_noise;\n *b_noise_out = n->b_noise;\n *a_prior_out = n->a_prior;\n *b_prior_out = n->b_prior;\n\n limit_1 = n->n_hidden_layers + 2;\n for (i = 0 ; i < limit_1 ; i++) {\n neurons_per_layer_out[ i ] = n->neurons_per_layer[ i ];\n }\n}\n\n/* Function that returns the sizes of the parameters of the network */\n\nvoid get_size_params(NETWORK *n, int *size_weihts, int *n_layers) {\n\n *size_weihts = n->size_w - 2;\n *n_layers = n->n_hidden_layers + 2;\n}\n\n/* Function that sets the parameters of the network */\n\nvoid set_params(NETWORK *n, double *sample_w_in, double *m_w_in, double *v_w_in, double *m_w_hat_nat_in, double *v_w_hat_nat_in,\n double *a_w_hat_nat_in, double *b_w_hat_nat_in, double a_noise_in, double b_noise_in, double a_prior_in, double b_prior_in) {\n\n int i, limit_1;\n\n /* We copy the parameters */\n\n limit_1 = n->size_w - 2;\n for (i = 0 ; i < limit_1 ; i++) {\n n->sample_w[ i ] = sample_w_in[ i ];\n n->m_w[ i ] = m_w_in[ i ];\n n->v_w[ i ] = v_w_in[ i ];\n n->m_w_hat_nat[ i ] = m_w_hat_nat_in[ i ];\n n->v_w_hat_nat[ i ] = v_w_hat_nat_in[ i ];\n n->a_w_hat_nat[ i ] = a_w_hat_nat_in[ i ];\n n->b_w_hat_nat[ i ] = b_w_hat_nat_in[ i ];\n }\n \n n->a_noise = a_noise_in;\n n->b_noise = b_noise_in;\n n->a_prior = a_prior_in;\n n->b_prior = b_prior_in;\n}\n", "meta": {"hexsha": "395db3833ad261af1335d397543c447c28515838", "size": 37140, "ext": "c", "lang": "C", "max_stars_repo_path": "c/PBP_net/network.c", "max_stars_repo_name": "DoktorBotti/Probabilistic-Backpropagation", "max_stars_repo_head_hexsha": "56c9ca818f88fd11e4c38585eefaceb3c28e2184", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 200.0, "max_stars_repo_stars_event_min_datetime": "2015-03-18T20:23:41.000Z", "max_stars_repo_stars_event_max_datetime": "2022-02-16T15:13:01.000Z", "max_issues_repo_path": "c/PBP_net/network.c", "max_issues_repo_name": "DoktorBotti/Probabilistic-Backpropagation", "max_issues_repo_head_hexsha": "56c9ca818f88fd11e4c38585eefaceb3c28e2184", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 1.0, "max_issues_repo_issues_event_min_datetime": "2018-07-09T11:55:07.000Z", "max_issues_repo_issues_event_max_datetime": "2018-07-09T11:55:07.000Z", "max_forks_repo_path": "c/PBP_net/network.c", "max_forks_repo_name": "DoktorBotti/Probabilistic-Backpropagation", "max_forks_repo_head_hexsha": "56c9ca818f88fd11e4c38585eefaceb3c28e2184", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 74.0, "max_forks_repo_forks_event_min_datetime": "2015-03-25T16:17:38.000Z", "max_forks_repo_forks_event_max_datetime": "2021-12-28T11:25:41.000Z", "avg_line_length": 34.2936288089, "max_line_length": 151, "alphanum_fraction": 0.5787829833, "num_tokens": 12422, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8031738057795402, "lm_q2_score": 0.6297745935070806, "lm_q1q2_score": 0.5058184570503449}} {"text": "#define MAIN_FILE\n\n#include \n#include \n#include \n#include \n#include \n#include \"global.h\"\n#include \"eos_pres.h\"\n#include \"eos_rho.h\"\n#include \"param.h\"\n\nint\nmain (void)\n{\n spline = NULL;\n acc = NULL;\n int i, status;\n double r, r1, y[2];\n // bounds for making grid of m(R) vs. rho(0)\n const double rho_min = 1.0e+13, rho_max = 9.0e+14;\n const int MAX = 100;\n // pressure/density arrays from tabulated EOS data\n int n_eos_pts;\n FILE *fp = NULL;\n double (*pres) (double, void *);\t// EOS pressure pointer\n double (*rho) (double, void *);\t// EOS density pointer\n double tmp;\n // pointers to tabulated EOS data\n double *eos_tab_pres = NULL, *eos_tab_dens = NULL;\n\n /* this is the \"third arm\" of the EOS inversion routine. GSL calls\n the function whose root is being found several times during\n initialization and if we leave the pressure here uninitialized,\n it might be 0 or something crazy, which will be out of bounds of\n the \"forward\" EOS, and since the forward EOS uses interpolation,\n an out-of-bounds value of pressure will make it crash. */\n tmp_pres = 1.0e+25;\n\n pres = &eos_pres;\n rho = &eos_rho;\n\n // fp = fopen(\"bck.eos\", \"r\");\n // fp = fopen(\"eosC\", \"r\");\n // fp = fopen(\"timmes.eos\", \"r\");\n fp = fopen (\"../EOS/helmholtz.eos\", \"r\");\n\n if (fp == NULL)\n {\n fprintf (stderr, \"Can't open file!\\n\");\n exit (1);\n }\n\n // read in # of EOS data points\n fscanf (fp, \"%i\", &n_eos_pts);\n\n eos_tab_dens = (double *) malloc (n_eos_pts * sizeof (double));\n eos_tab_pres = (double *) malloc (n_eos_pts * sizeof (double));\n\n // read in density and pressure data\n for (i = 0; i < n_eos_pts; i++)\n {\n fscanf (fp, \"%le %le\", &eos_tab_dens[i], &eos_tab_pres[i]);\n }\n fclose (fp);\n\n // set up interpolation machinery for EOS\n acc = gsl_interp_accel_alloc ();\n spline = gsl_spline_alloc (gsl_interp_cspline, n_eos_pts);\n gsl_spline_init (spline, eos_tab_dens, eos_tab_pres, n_eos_pts);\n\n // now make grid\n r = 1.0;\t\t\t// the integrator will go nuts if we start right at r=0\n r1 = 1.0e+10;\t\t\t// some final 'radius' (much larger than actual radius)\n\n printf (\"%12s %12s %12s\\n\", \"R\", \"M(r=R)\", \"rho(r=0)\");\n\n params.single_star = 1;\n for (i = 0; i < MAX; i++)\n {\n // rho(0) evenly spaced in log\n params.rho_init = log10 (rho_min) +\n\t(double) i *((log10 (rho_max) - log10 (rho_min)) / (double) MAX);\n params.rho_init = pow (10.0, params.rho_init);\n\n y[1] = pres (params.rho_init, ¶ms);\n y[0] = (4.0 / 3.0) * M_PI * pow (r, 3.0) * rho (y[1], ¶ms);\n\n params.pinit = y[1];\n // This function is useful if you want to plot, e.g., central\n // pressure vs. total mass. You can also hang onto the run of\n // pressure with radius, which can be interesting when compared to\n // the Newtonian case.\n status = make_grid (params, r, r1, y);\n }\n\n/*\n params.single_star = 0;\n printf(\"\\nnow for a single star!\\n\");\n printf(\"%12s %12s %12s %12s\\n\", \"r\", \"M(r)\", \"P(r)\", \"rho(r)\");\n // print P and M vs r for Chandrasekhar-mass star\n params.rho_init = 1.0e+13;\n\n y[1] = pres(params.rho_init, ¶ms); // rho(0) (roughly) for maximum mass\n y[0] = (4.0/3.0) * M_PI * pow(r, 3.0) * rho(y[1], ¶ms);\n\n params.pinit = y[1];\n status = make_grid(params, r, r1, y);\n*/\n\n gsl_spline_free (spline);\n gsl_interp_accel_free (acc);\n\n free (eos_tab_pres);\n free (eos_tab_dens);\n\n eos_tab_dens = NULL;\n eos_tab_pres = NULL;\n fp = NULL;\n pres = NULL;\n rho = NULL;\n return 0;\n}\n", "meta": {"hexsha": "e35615534acdcbf59eaac735dd3a399e1eec8c4c", "size": 3569, "ext": "c", "lang": "C", "max_stars_repo_path": "src/main.c", "max_stars_repo_name": "bcfriesen/TOV_solver", "max_stars_repo_head_hexsha": "5288ad6972b47143e1ce57e282f516143f07b158", "max_stars_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2015-11-14T02:27:58.000Z", "max_stars_repo_stars_event_max_datetime": "2015-11-14T02:27:58.000Z", "max_issues_repo_path": "src/main.c", "max_issues_repo_name": "bcfriesen/TOV_solver", "max_issues_repo_head_hexsha": "5288ad6972b47143e1ce57e282f516143f07b158", "max_issues_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/main.c", "max_forks_repo_name": "bcfriesen/TOV_solver", "max_forks_repo_head_hexsha": "5288ad6972b47143e1ce57e282f516143f07b158", "max_forks_repo_licenses": ["BSD-2-Clause-FreeBSD"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 28.7822580645, "max_line_length": 77, "alphanum_fraction": 0.6203418324, "num_tokens": 1168, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8479677468516188, "lm_q2_score": 0.5964331462646255, "lm_q1q2_score": 0.5057560711856365}} {"text": "#include \n#include \n#include \n#include \n\n#include \n\nvoid normalizeBySum(double* data, int n)\n{\n int sum = 0;\n for(int i=0; i(n,n));\n \n double* data = new double [n * n];\n if(cgi::NoError != m.getTile(0, 0, data))\n {\n std::cout << \"getTile failed\" << std::endl;\n return 3;\n }\n\n gsl_wavelet *w;\n gsl_wavelet_workspace *work;\n \n w = gsl_wavelet_alloc (gsl_wavelet_daubechies, 4);\n work = gsl_wavelet_workspace_alloc (n);\n \n if(GSL_SUCCESS != gsl_wavelet2d_transform_forward (w, data, n, n, n, work))\n {\n std::cout << \"Transform failed\" << std::endl;\n return 4;\n }\n\n /////////////////////////////////////////\n cgi::Mosaic moDwt;\n moDwt.create(\"dwt.tif\", \"GTiff\", cgi::core::Size2d(n,n), 1, cgi::Depth64F);\n moDwt.setTileSize(cgi::core::Size2d(n,n));\n moDwt.putTile(data, 0, 0);\n moDwt.close();\n\n /////////////////////////////////////////\n // normalization\n normalizeBySum(data, n);\n\n /////////////////////////////////////////\n // do the inverse and reconstruct the image\n\n if(GSL_SUCCESS != gsl_wavelet2d_transform_inverse (w, data, n, n, n, work))\n {\n std::cout << \"Transform failed\" << std::endl;\n return 5;\n }\n\n\n /////////////////////////////////////////\n // convert the reconstructed image to unsigned short\n unsigned short* recData = new unsigned short [n * n];\n int i;\n for(i=0; i<(n*n); ++i)\n {\n recData[i] = static_cast(std::max(std::min(data[i], 65535.0), 0.0));\n }\n\n cgi::Mosaic moRec;\n moRec.create(\"rec.tif\", \"GTiff\", cgi::core::Size2d(n,n), 1, cgi::Depth16U);\n moRec.setTileSize(cgi::core::Size2d(n,n));\n moRec.putTile(recData, 0, 0);\n moRec.close();\n \n /////////////////////////////////////////\n gsl_wavelet_free (w);\n gsl_wavelet_workspace_free (work);\n\n delete [] recData;\n delete [] data;\n\n return 0;\n}\n", "meta": {"hexsha": "2f1a9ca889a5f242e23ca1189a9a9b809baea598", "size": 2367, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl_wavelet/dwt2.c", "max_stars_repo_name": "klaricmn/snippets", "max_stars_repo_head_hexsha": "a1ae04c13a2209dee013284358d2d987bb0fb4fc", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "gsl_wavelet/dwt2.c", "max_issues_repo_name": "klaricmn/snippets", "max_issues_repo_head_hexsha": "a1ae04c13a2209dee013284358d2d987bb0fb4fc", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "gsl_wavelet/dwt2.c", "max_forks_repo_name": "klaricmn/snippets", "max_forks_repo_head_hexsha": "a1ae04c13a2209dee013284358d2d987bb0fb4fc", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 22.7596153846, "max_line_length": 90, "alphanum_fraction": 0.5441487114, "num_tokens": 740, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7981867681382279, "lm_q2_score": 0.6334102567576901, "lm_q1q2_score": 0.5055796857470258}} {"text": "/* linalg/lu.c\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007, 2009 Gerard Jungman, Brian Gough\n * Copyright (C) 2019 Patrick Alken\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"recurse.h\"\n\nstatic int LU_decomp_L2 (gsl_matrix * A, gsl_vector_uint * ipiv);\nstatic int LU_decomp_L3 (gsl_matrix * A, gsl_vector_uint * ipiv);\nstatic int singular (const gsl_matrix * LU);\nstatic int apply_pivots(gsl_matrix * A, const gsl_vector_uint * ipiv);\n\n/* Factorise a general N x N matrix A into,\n *\n * P A = L U\n *\n * where P is a permutation matrix, L is unit lower triangular and U\n * is upper triangular.\n *\n * L is stored in the strict lower triangular part of the input\n * matrix. The diagonal elements of L are unity and are not stored.\n *\n * U is stored in the diagonal and upper triangular part of the\n * input matrix. \n * \n * P is stored in the permutation p. Column j of P is column k of the\n * identity matrix, where k = permutation->data[j]\n *\n * signum gives the sign of the permutation, (-1)^n, where n is the\n * number of interchanges in the permutation. \n *\n * See Golub & Van Loan, Matrix Computations, Algorithm 3.4.1 (Gauss\n * Elimination with Partial Pivoting).\n */\n\nint\ngsl_linalg_LU_decomp (gsl_matrix * A, gsl_permutation * p, int *signum)\n{\n const size_t M = A->size1;\n\n if (p->size != M)\n {\n GSL_ERROR (\"permutation length must match matrix size1\", GSL_EBADLEN);\n }\n else\n {\n int status;\n const size_t N = A->size2;\n const size_t minMN = GSL_MIN(M, N);\n gsl_vector_uint * ipiv = gsl_vector_uint_alloc(minMN);\n gsl_matrix_view AL = gsl_matrix_submatrix(A, 0, 0, M, minMN);\n size_t i;\n\n status = LU_decomp_L3 (&AL.matrix, ipiv);\n\n /* process remaining right matrix */\n if (M < N)\n {\n gsl_matrix_view AR = gsl_matrix_submatrix(A, 0, M, M, N - M);\n\n /* apply pivots to AR */\n apply_pivots(&AR.matrix, ipiv);\n\n /* AR = AL^{-1} AR */\n gsl_blas_dtrsm(CblasLeft, CblasLower, CblasNoTrans, CblasUnit, 1.0, &AL.matrix, &AR.matrix);\n }\n\n /* convert ipiv array to permutation */\n\n gsl_permutation_init(p);\n *signum = 1;\n\n for (i = 0; i < minMN; ++i)\n {\n unsigned int pivi = gsl_vector_uint_get(ipiv, i);\n\n if (p->data[pivi] != p->data[i])\n {\n size_t tmp = p->data[pivi];\n p->data[pivi] = p->data[i];\n p->data[i] = tmp;\n *signum = -(*signum);\n }\n }\n\n gsl_vector_uint_free(ipiv);\n\n return status;\n }\n}\n\n/*\nLU_decomp_L2\n LU decomposition with partial pivoting using Level 2 BLAS\n\nInputs: A - on input, matrix to be factored; on output, L and U factors\n ipiv - (output) array containing row swaps\n\nNotes:\n1) Based on LAPACK DGETF2\n*/\n\nstatic int\nLU_decomp_L2 (gsl_matrix * A, gsl_vector_uint * ipiv)\n{\n const size_t M = A->size1;\n const size_t N = A->size2;\n const size_t minMN = GSL_MIN(M, N);\n\n if (ipiv->size != minMN)\n {\n GSL_ERROR (\"ipiv length must equal MIN(M,N)\", GSL_EBADLEN);\n }\n else\n {\n size_t i, j;\n\n for (j = 0; j < minMN; ++j)\n {\n /* find maximum in the j-th column */\n gsl_vector_view v = gsl_matrix_subcolumn(A, j, j, M - j);\n size_t j_pivot = j + gsl_blas_idamax(&v.vector);\n gsl_vector_view v1, v2;\n\n gsl_vector_uint_set(ipiv, j, j_pivot);\n\n if (j_pivot != j)\n {\n /* swap rows j and j_pivot */\n v1 = gsl_matrix_row(A, j);\n v2 = gsl_matrix_row(A, j_pivot);\n gsl_blas_dswap(&v1.vector, &v2.vector);\n }\n\n if (j < M - 1)\n {\n double Ajj = gsl_matrix_get(A, j, j);\n\n if (fabs(Ajj) >= GSL_DBL_MIN)\n {\n v1 = gsl_matrix_subcolumn(A, j, j + 1, M - j - 1);\n gsl_blas_dscal(1.0 / Ajj, &v1.vector);\n }\n else\n {\n for (i = 1; i < M - j; ++i)\n {\n double * ptr = gsl_matrix_ptr(A, j + i, j);\n *ptr /= Ajj;\n }\n }\n }\n\n if (j < minMN - 1)\n {\n gsl_matrix_view A22 = gsl_matrix_submatrix(A, j + 1, j + 1, M - j - 1, N - j - 1);\n v1 = gsl_matrix_subcolumn(A, j, j + 1, M - j - 1);\n v2 = gsl_matrix_subrow(A, j, j + 1, N - j - 1);\n\n gsl_blas_dger(-1.0, &v1.vector, &v2.vector, &A22.matrix);\n }\n }\n\n return GSL_SUCCESS;\n }\n}\n\n/*\nLU_decomp_L3\n LU decomposition with partial pivoting using Level 3 BLAS\n\nInputs: A - on input, matrix to be factored; on output, L and U factors\n ipiv - (output) array containing row swaps\n\nNotes:\n1) Based on ReLAPACK DGETRF\n*/\n\nstatic int\nLU_decomp_L3 (gsl_matrix * A, gsl_vector_uint * ipiv)\n{\n const size_t M = A->size1;\n const size_t N = A->size2;\n\n if (M < N)\n {\n GSL_ERROR (\"matrix must have M >= N\", GSL_EBADLEN);\n }\n else if (ipiv->size != GSL_MIN(M, N))\n {\n GSL_ERROR (\"ipiv length must equal MIN(M,N)\", GSL_EBADLEN);\n }\n else if (N <= CROSSOVER_LU)\n {\n /* use Level 2 algorithm */\n return LU_decomp_L2(A, ipiv);\n }\n else\n {\n /*\n * partition matrix:\n *\n * N1 N2\n * N1 [ A11 A12 ]\n * M2 [ A21 A22 ]\n *\n * and\n * N1 N2\n * M [ AL AR ]\n */\n int status;\n const size_t N1 = GSL_LINALG_SPLIT(N);\n const size_t N2 = N - N1;\n const size_t M2 = M - N1;\n gsl_matrix_view A11 = gsl_matrix_submatrix(A, 0, 0, N1, N1);\n gsl_matrix_view A12 = gsl_matrix_submatrix(A, 0, N1, N1, N2);\n gsl_matrix_view A21 = gsl_matrix_submatrix(A, N1, 0, M2, N1);\n gsl_matrix_view A22 = gsl_matrix_submatrix(A, N1, N1, M2, N2);\n\n gsl_matrix_view AL = gsl_matrix_submatrix(A, 0, 0, M, N1);\n gsl_matrix_view AR = gsl_matrix_submatrix(A, 0, N1, M, N2);\n\n /*\n * partition ipiv = [ ipiv1 ] N1\n * [ ipiv2 ] N2\n */\n gsl_vector_uint_view ipiv1 = gsl_vector_uint_subvector(ipiv, 0, N1);\n gsl_vector_uint_view ipiv2 = gsl_vector_uint_subvector(ipiv, N1, N2);\n\n size_t i;\n\n /* recursion on (AL, ipiv1) */\n status = LU_decomp_L3(&AL.matrix, &ipiv1.vector);\n if (status)\n return status;\n\n /* apply ipiv1 to AR */\n apply_pivots(&AR.matrix, &ipiv1.vector);\n\n /* A12 = A11^{-1} A12 */\n gsl_blas_dtrsm(CblasLeft, CblasLower, CblasNoTrans, CblasUnit, 1.0, &A11.matrix, &A12.matrix);\n\n /* A22 = A22 - A21 * A12 */\n gsl_blas_dgemm(CblasNoTrans, CblasNoTrans, -1.0, &A21.matrix, &A12.matrix, 1.0, &A22.matrix);\n\n /* recursion on (A22, ipiv2) */\n status = LU_decomp_L3(&A22.matrix, &ipiv2.vector);\n if (status)\n return status;\n\n /* apply pivots to A21 */\n apply_pivots(&A21.matrix, &ipiv2.vector);\n\n /* shift pivots */\n for (i = 0; i < N2; ++i)\n {\n unsigned int * ptr = gsl_vector_uint_ptr(&ipiv2.vector, i);\n *ptr += N1;\n }\n\n return GSL_SUCCESS;\n }\n}\n\nint\ngsl_linalg_LU_solve (const gsl_matrix * LU, const gsl_permutation * p, const gsl_vector * b, gsl_vector * x)\n{\n if (LU->size1 != LU->size2)\n {\n GSL_ERROR (\"LU matrix must be square\", GSL_ENOTSQR);\n }\n else if (LU->size1 != p->size)\n {\n GSL_ERROR (\"permutation length must match matrix size\", GSL_EBADLEN);\n }\n else if (LU->size1 != b->size)\n {\n GSL_ERROR (\"matrix size must match b size\", GSL_EBADLEN);\n }\n else if (LU->size2 != x->size)\n {\n GSL_ERROR (\"matrix size must match solution size\", GSL_EBADLEN);\n }\n else if (singular (LU)) \n {\n GSL_ERROR (\"matrix is singular\", GSL_EDOM);\n }\n else\n {\n int status;\n\n /* copy x <- b */\n gsl_vector_memcpy (x, b);\n\n /* solve for x */\n status = gsl_linalg_LU_svx (LU, p, x);\n\n return status;\n }\n}\n\n\nint\ngsl_linalg_LU_svx (const gsl_matrix * LU, const gsl_permutation * p, gsl_vector * x)\n{\n if (LU->size1 != LU->size2)\n {\n GSL_ERROR (\"LU matrix must be square\", GSL_ENOTSQR);\n }\n else if (LU->size1 != p->size)\n {\n GSL_ERROR (\"permutation length must match matrix size\", GSL_EBADLEN);\n }\n else if (LU->size1 != x->size)\n {\n GSL_ERROR (\"matrix size must match solution/rhs size\", GSL_EBADLEN);\n }\n else if (singular (LU)) \n {\n GSL_ERROR (\"matrix is singular\", GSL_EDOM);\n }\n else\n {\n /* apply permutation to RHS */\n gsl_permute_vector (p, x);\n\n /* solve for c using forward-substitution, L c = P b */\n gsl_blas_dtrsv (CblasLower, CblasNoTrans, CblasUnit, LU, x);\n\n /* perform back-substitution, U x = c */\n gsl_blas_dtrsv (CblasUpper, CblasNoTrans, CblasNonUnit, LU, x);\n\n return GSL_SUCCESS;\n }\n}\n\n\nint\ngsl_linalg_LU_refine (const gsl_matrix * A, const gsl_matrix * LU, const gsl_permutation * p, const gsl_vector * b, gsl_vector * x, gsl_vector * work)\n{\n if (A->size1 != A->size2)\n {\n GSL_ERROR (\"matrix a must be square\", GSL_ENOTSQR);\n }\n else if (LU->size1 != LU->size2)\n {\n GSL_ERROR (\"LU matrix must be square\", GSL_ENOTSQR);\n }\n else if (A->size1 != LU->size2)\n {\n GSL_ERROR (\"LU matrix must be decomposition of a\", GSL_ENOTSQR);\n }\n else if (LU->size1 != p->size)\n {\n GSL_ERROR (\"permutation length must match matrix size\", GSL_EBADLEN);\n }\n else if (LU->size1 != b->size)\n {\n GSL_ERROR (\"matrix size must match b size\", GSL_EBADLEN);\n }\n else if (LU->size1 != x->size)\n {\n GSL_ERROR (\"matrix size must match solution size\", GSL_EBADLEN);\n }\n else if (LU->size1 != work->size)\n {\n GSL_ERROR (\"matrix size must match workspace size\", GSL_EBADLEN);\n }\n else if (singular (LU)) \n {\n GSL_ERROR (\"matrix is singular\", GSL_EDOM);\n }\n else\n {\n int status;\n\n /* compute residual = (A * x - b) */\n gsl_vector_memcpy (work, b);\n gsl_blas_dgemv (CblasNoTrans, 1.0, A, x, -1.0, work);\n\n /* find correction, delta = - (A^-1) * residual, and apply it */\n status = gsl_linalg_LU_svx (LU, p, work);\n gsl_blas_daxpy (-1.0, work, x);\n\n return status;\n }\n}\n\nint\ngsl_linalg_LU_invert (const gsl_matrix * LU, const gsl_permutation * p, gsl_matrix * inverse)\n{\n if (LU->size1 != LU->size2)\n {\n GSL_ERROR (\"LU matrix must be square\", GSL_ENOTSQR);\n }\n else if (LU->size1 != p->size)\n {\n GSL_ERROR (\"permutation length must match matrix size\", GSL_EBADLEN);\n }\n else if (inverse->size1 != LU->size1 || inverse->size2 != LU->size2)\n {\n GSL_ERROR (\"inverse matrix must match LU matrix dimensions\", GSL_EBADLEN);\n }\n else\n {\n gsl_matrix_memcpy(inverse, LU);\n return gsl_linalg_LU_invx (inverse, p);\n }\n}\n\nint\ngsl_linalg_LU_invx (gsl_matrix * LU, const gsl_permutation * p)\n{\n if (LU->size1 != LU->size2)\n {\n GSL_ERROR (\"LU matrix must be square\", GSL_ENOTSQR);\n }\n else if (LU->size1 != p->size)\n {\n GSL_ERROR (\"permutation length must match matrix size\", GSL_EBADLEN);\n }\n else if (singular (LU)) \n {\n GSL_ERROR (\"matrix is singular\", GSL_EDOM);\n }\n else\n {\n int status;\n const size_t N = LU->size1;\n size_t i;\n\n /* compute U^{-1} */\n status = gsl_linalg_tri_invert(CblasUpper, CblasNonUnit, LU);\n if (status)\n return status;\n\n /* compute L^{-1} */\n status = gsl_linalg_tri_invert(CblasLower, CblasUnit, LU);\n if (status)\n return status;\n\n /* compute U^{-1} L^{-1} */\n status = gsl_linalg_tri_UL(LU);\n if (status)\n return status;\n\n /* apply permutation to columns of A^{-1} */\n for (i = 0; i < N; ++i)\n {\n gsl_vector_view v = gsl_matrix_row(LU, i);\n gsl_permute_vector_inverse(p, &v.vector);\n }\n\n return GSL_SUCCESS;\n }\n}\n\ndouble\ngsl_linalg_LU_det (gsl_matrix * LU, int signum)\n{\n size_t i, n = LU->size1;\n\n double det = (double) signum;\n\n for (i = 0; i < n; i++)\n {\n det *= gsl_matrix_get (LU, i, i);\n }\n\n return det;\n}\n\n\ndouble\ngsl_linalg_LU_lndet (gsl_matrix * LU)\n{\n size_t i, n = LU->size1;\n\n double lndet = 0.0;\n\n for (i = 0; i < n; i++)\n {\n lndet += log (fabs (gsl_matrix_get (LU, i, i)));\n }\n\n return lndet;\n}\n\nint\ngsl_linalg_LU_sgndet (gsl_matrix * LU, int signum)\n{\n size_t i, n = LU->size1;\n\n int s = signum;\n\n for (i = 0; i < n; i++)\n {\n double u = gsl_matrix_get (LU, i, i);\n\n if (u < 0)\n {\n s *= -1;\n }\n else if (u == 0)\n {\n s = 0;\n break;\n }\n }\n\n return s;\n}\n\nstatic int\nsingular (const gsl_matrix * LU)\n{\n size_t i, n = LU->size1;\n\n for (i = 0; i < n; i++)\n {\n double u = gsl_matrix_get (LU, i, i);\n if (u == 0) return 1;\n }\n \n return 0;\n}\n\nstatic int\napply_pivots(gsl_matrix * A, const gsl_vector_uint * ipiv)\n{\n if (A->size1 < ipiv->size)\n {\n GSL_ERROR(\"matrix does not match pivot vector\", GSL_EBADLEN);\n }\n else\n {\n size_t i;\n\n for (i = 0; i < ipiv->size; ++i)\n {\n size_t pi = gsl_vector_uint_get(ipiv, i);\n\n if (i != pi)\n {\n /* swap rows i and pi */\n gsl_vector_view v1 = gsl_matrix_row(A, i);\n gsl_vector_view v2 = gsl_matrix_row(A, pi);\n gsl_blas_dswap(&v1.vector, &v2.vector);\n }\n }\n\n return GSL_SUCCESS;\n }\n}\n", "meta": {"hexsha": "e3bf04aea17ed9055b58a6453c733cb146a72a7e", "size": 14524, "ext": "c", "lang": "C", "max_stars_repo_path": "Chimera/3rd_Party/GSL_MSVC/linalg/lu.c", "max_stars_repo_name": "zzpwahaha/Chimera-Control-Trim", "max_stars_repo_head_hexsha": "df1bbf6bea0b87b8c7c9a99dce213fdc249118f2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-06-14T11:51:37.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-14T11:51:37.000Z", "max_issues_repo_path": "Chimera/3rd_Party/GSL_MSVC/linalg/lu.c", "max_issues_repo_name": "zzpwahaha/Chimera-Control-Trim", "max_issues_repo_head_hexsha": "df1bbf6bea0b87b8c7c9a99dce213fdc249118f2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Chimera/3rd_Party/GSL_MSVC/linalg/lu.c", "max_forks_repo_name": "zzpwahaha/Chimera-Control-Trim", "max_forks_repo_head_hexsha": "df1bbf6bea0b87b8c7c9a99dce213fdc249118f2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-01-20T16:22:57.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-14T12:31:02.000Z", "avg_line_length": 25.0413793103, "max_line_length": 150, "alphanum_fraction": 0.56947122, "num_tokens": 4379, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7799929104825006, "lm_q2_score": 0.6477982247516797, "lm_q1q2_score": 0.5052780227294598}} {"text": "/* ————————————————————————————————————————————————————————————————————————————————————————————————\nBackwards elimination algorithm using Bidiag2.\n———————————————————————————————————————————————————————————————————————————————————————————————————\nThis is a MEX function which uses the Bidiag2 PLS algorithm to estimate the cross-validated root-\nmean-squared-error, RMSEcv, of an initial design matrix X, regressed upon y, together with every\npossible single inactivation of a column. The function returns a matrix with RMSEcv as a function\nof variable selection and PLS component where the first row corresponds to the initial variable \nselection and every following row corresponds to the inactivation of variable 1 to n.\n\nThe function takes 5 inputs:\n* Input 1: a [m x n] design matrix with observations as rows and variables as columns.\n* Input 2: a [m x 1] vector with response values (multiple responses is not supported).\n* Input 3: a [1 x 1] scalar 'A' specifying the maximum number of PLS components to calculate.\n* Input 4: a [1 x 1] scalar 'MaxIter' specifying how many MonteCarlo CV iterations should be done.\n* Input 5: a [1 x 1] scalar 'NoValObs' specifying how many unique responses should be in one validation fold.\n\nThe function outputs 1 variable:\n* Output 1: a [(n+1) x A] matrix with RMSEcv. Variable selection along rows and components\nalong columns.\n\nExample on how to compile and run from Matlab:\n% Compile .C to .mexw64\n>> mex -largeArrayDims -lmwblas BackwardsSelectionBidag2.c\n\n% Run from Matlab when compiled:\n>> X = rand(10000, 256);\n>> y = rand(10000, 1);\n>> A = 10;\n>> MaxIters = 10;\n>> Valobs = round(length(unique(y))/4);\n\n>> [ RMSEcv ] = BackwardsSelectionBidag2( X , y, A, MaxIters, Valobs );\n\nExample of compatible C compilers:\n* Microsoft Visual C++ 2013 Professional (C)\n* Microsoft Visual C++ 2015 Professional (C)\n* Intel Parallel Studio XE 2017\n\nWritten 2017-08-14 by\npetter.stefansson@nmbu.no\n———————————————————————————————————————————————————————————————————————————————————————————————— */\n\n#include \t// Needed to communicate with matlab\n#include \t// Needed for blas functions\n#include // Needed to avoid compiler warning due to memcpy when using old compilers\n#include // Needed to take the square-root (sqrt)\n#include // Needed for counting CPU clock cycle which is used to set seed for rand()\n\n/* ——————————————————————————————————— Function declarations ——————————————————————————————————— */\nvoid PLS(const double *X, const double *y, int A, size_t m, size_t n, size_t p, double *beta, \n\tdouble *B, double *w, double *wn, double *W, double *rho, double *rhoi, double *d, double *tty, \n\tdouble *Xt, double *Ww, double *WWw, double *theta, double *thetai, double *Tt);\n\nint randr(unsigned int min, unsigned int max);\n\nvoid MarkAsVal(bool *IsVal, int NoValObs, size_t m, size_t *valm, size_t *trainm, const double *y);\n\nvoid ExtractXandY(const double *X, const double *y, double *Xtrain, double *Xval, double *ytrain,\n\tdouble *yval, size_t m, size_t n, bool *IsVal);\n\nvoid Pred(double *Xval, double *beta, double *yval, size_t n, size_t valm, int A, double *yhat, \n\tdouble *RMSEcv, int cvIter, int MaxIters, int ShavingIndex);\n\nvoid SwapCols(double *Xtrain, double *Xval, size_t trainm, size_t valm, size_t n, int ColToShave);\n\n/* ——————————————————————————————————— Matlab gateway start ———————————————————————————————————— */\nvoid mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[])\n{\n\t/* —————————————————————————— Variable type and name declaration ——————————————————————————— */\n\tconst double *X, *y;\n\tdouble *Xtrain, *Xval, *ytrain, *yval, *beta, *yhat, *B, *w, *wn, *W, *rho, *rhoi, *d, *tty,\n\t\t *Xt, *Ww, *WWw, *theta, *thetai, *Tt;\n\n\tint cvIter, NoValObs, MaxIters, A, ColToShave;\n\tbool *IsVal;\n\tsize_t m, n, p, trainm, valm;\n\n\t/* ———————————————————— Get pointers to the input variables from Matlab ——————————————————— */\n\tX = mxGetPr(prhs[0]);\t\t\t // First input (X matrix).\n\ty = mxGetPr(prhs[1]);\t\t\t // Second input (Y vector).\n\n\t/* ———————————————————— Get input scalar values containing PLS settings ——————————————————— */\n\tA = (int)mxGetScalar(prhs[2]); // Third input (max number of components to calculate)\n\tMaxIters = (int)mxGetScalar(prhs[3]); // Fourth input (Max cv-iters)\n\tNoValObs = (int)mxGetScalar(prhs[4]); // Fifth input (Number of validation observations)\n\n\t/* ——————————————————————— Get the dimensions of the input variables ——————————————————————— */\n\tm = mxGetM(prhs[0]); // Number of rows in X.\n\tn = mxGetN(prhs[0]); // Number of columns in X.\n\tp = mxGetN(prhs[1]); // Number of columns in y.\n\n\t/* ——————————————————————————— If input A is larger than n, let A = n —————————————————————— */\n\tif ((A > n) || (A < 1)) { A = n; }\n\n\t/* ——————————————————————————————— Specify Matlab outputs —————————————————————————————————— */\n\tdouble *RMSEcv;\n\tplhs[0] = mxCreateDoubleMatrix(n + 1, A, mxREAL);\n\tRMSEcv = mxGetPr(plhs[0]);\n\n\t/* ———— Allocate space for variables that are used multiple times and can be overwritten ——— */\n\tIsVal = (bool*)malloc(sizeof(bool) * m ); // [m-by-1]\n\tXtrain = (double*)malloc(sizeof(double) * m * n ); // [m-by-n] (overallocated)\n\tXval = (double*)malloc(sizeof(double) * m * n ); // [m-by-n] (overallocated)\n\tytrain = (double*)malloc(sizeof(double) * m ); // [m-by-1] (overallocated)\n\tyval = (double*)malloc(sizeof(double) * m ); // [m-by-1] (overallocated)\n\tbeta = (double*)malloc(sizeof(double) * n * A ); // [n-by-A]\n\tyhat = (double*)malloc(sizeof(double) * m * A ); // [m-by-A] (overallocated)\n\tB = (double*)malloc(sizeof(double) * A * 2 ); // [A-by-2]\n\tw = (double*)malloc(sizeof(double) * n ); // [n-by-1]\n\twn = (double*)malloc(sizeof(double) ); // [1-by-1]\n\tW = (double*)malloc(sizeof(double) * n * A ); // [n-by-A]\n rho = (double*)malloc(sizeof(double) ); // [1-by-1]\n\trhoi = (double*)malloc(sizeof(double) ); // [1-by-1]\n\td = (double*)malloc(sizeof(double) * n ); // [n-by-1]\n\ttty = (double*)malloc(sizeof(double) ); // [1-by-1]\n\tXt = (double*)malloc(sizeof(double) * n ); // [n-by-1]\n\tWw = (double*)malloc(sizeof(double) * A ); // [A-by-1] (overallocated)\n\tWWw = (double*)malloc(sizeof(double) * n ); // [n-by-1] \n\ttheta = (double*)malloc(sizeof(double) ); // [1-by-1]\n\tthetai = (double*)malloc(sizeof(double) ); // [1-by-1]\n\tTt = (double*)malloc(sizeof(double) * A ); // [A-by-1] (overallocated)\n\n\t\n\t/* Before starting set the seed of the RNG to the number of clock cycles since start.\t\t */\n\tsrand(clock());\n\n\t/* CV-loop starts here\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t */\n\tfor (cvIter = 0; cvIter < MaxIters; cvIter++) {\n\n\t\t/* ————————————— Mark rows of X as either validation rows or training rows ————————————— */\n\t\tMarkAsVal(IsVal, NoValObs, m, &valm, &trainm, y);\n\n\t\t/* —————————— Extract data from X and y and place in Xtrain/Xval/ytrain/yval ——————————— */\n\t\tExtractXandY(X, y, Xtrain, Xval, ytrain, yval, m, n, IsVal);\n\n\t\t/* ————————————————————————————————————————————————————————————————————————————————————— */\n\t\t/* Shaving step 1. Evaluate matrix with all variables included.\t\t\t\t\t\t\t */\n\t\t/* ————————— Call PLS function to estimate Beta using Xtrain & ytrain —————————————————— */\n\t\tPLS( Xtrain, ytrain, A, trainm, n, p, beta, B, w, wn, W, rho, rhoi, d, tty, Xt, Ww, WWw, theta, thetai, Tt);\n\t\t/* ——————— Use beta to estimate error when predicting yval using Xval —————————————————— */\n\t\tPred( Xval, beta, yval, n, valm, A, yhat, RMSEcv, cvIter, MaxIters, 0);\n\n\t\t/* ————————————————————————————————————————————————————————————————————————————————————— */\n\t\t/* Shaving step 2. Evaluate matrix with all except the last variable included.\t\t\t */\n\t\t/* ————————— Call PLS function to estimate Beta using Xtrain & ytrain —————————————————— */\n\t\tPLS(Xtrain, ytrain, A, trainm, n - 1, p, beta, B, w, wn, W, rho, rhoi, d, tty, Xt, Ww, WWw, theta, thetai, Tt);\n\t\t/* ——————— Use beta to estimate error when predicting yval using Xval —————————————————— */\n\t\tPred(Xval, beta, yval, n - 1, valm, A, yhat, RMSEcv, cvIter, MaxIters, n);\n\t\t/* ————————————————————————————————————————————————————————————————————————————————————— */\n\n\t\t/* ————————————————————————————————————————————————————————————————————————————————————— */\n\t\t/* Shaving step 3. Keep last column inactive and swap it one by one with cols 0 : n-1 */\n\t\tfor (ColToShave = 0; ColToShave < (n - 1); ColToShave++) {\n\n\t\t\t/* Place ColToShave at the end, effectecly inactivating it.\t\t\t\t\t\t\t */\n\t\t\tSwapCols(Xtrain, Xval, trainm, valm, n, ColToShave + 1);\n\t\t\t/* ———————— Call PLS function to estimate Beta using Xtrain & ytrain ——————————————— */\n\t\t\tPLS(Xtrain, ytrain, A, trainm, n - 1, p, beta, B, w, wn, W, rho, rhoi, d, tty, Xt, Ww, WWw, theta, thetai, Tt);\n\t\t\t/* —————— Use beta to estimate error when predicting yval using Xval ——————————————— */\n\t\t\tPred(Xval, beta, yval, n - 1, valm, A, yhat, RMSEcv, cvIter, MaxIters, ColToShave + 1);\n\t\t}\n\t}\n\t\n\t/* —————————————————————————————————— Free allocated memory ———————————————————————————————— */\n\tfree(IsVal);\n\tfree(Xtrain);\n\tfree(Xval);\n\tfree(ytrain);\n\tfree(yval);\n\tfree(beta);\n\tfree(yhat);\n\tfree(B);\n\tfree(w);\n\tfree(wn);\n\tfree(W);\n\tfree(rho);\n\tfree(rhoi);\n\tfree(d);\n\tfree(tty);\n\tfree(Xt);\n\tfree(Ww);\n\tfree(WWw);\n\tfree(theta);\n\tfree(thetai);\n\tfree(Tt);\n}\n\n/* ————————————————————————————————————————————————————————————————————————————————————————————— */\n/* Function for estimating Beta using the bidag2 algorithm\t\t\t\t\t\t\t\t\t\t */\nvoid PLS(const double *X, const double *y, int A, size_t m, size_t n, size_t p, double *beta,\n\tdouble *B, double *w, double *wn, double *W, double *rho, double *rhoi, double *d,\n\tdouble *tty, double *Xt, double *Ww, double *WWw, double *theta, double *thetai, double *Tt){\n\t\n\t/* —————————————————————————— Variable type and name declaration —————————————————————————— */\n\tdouble *t;\n\tdouble *T;\n\tdouble *Xw;\n\tdouble *TTt;\n\n\tint a, row;\n\tsize_t st_a;\n\n\tmwSignedIndex IntConstOne = 1;\n\tdouble one = 1.0, zero = 0.0, none = -1.0;\n\n\t/* ————————————————— Allocate memory for variables used in the calculation ————————————————— */\n\tt = (double*)malloc(sizeof(double) * m ); // [m-by-1]\n\tT = (double*)malloc(sizeof(double) * m * A ); // [m-by-A]\n\tXw = (double*)malloc(sizeof(double) * m ); // [m-by-1]\n\tTTt = (double*)malloc(sizeof(double) * m ); // [m-by-1]\n\n\t\n\t/* ————————————————————————————————————————————————————————————————————————————————————————— */\n\t/* ——————————————————————————————— Start of calculation part ——————————————————————————————— */\n\t/* ——————————————————————————————————————————————————————————————————————————————————————————\n\tStep 1: w = X'*y; \t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t */\n\t/// X = [m-by-n]\n\t/// y = [m-by-1]\n\t/// w = [n-by-1]\n\n\t// Matrix-Vector multiplication -> dgemv.\n\tdgemv(\"T\", &m, &n, &one, X, &m, y, &IntConstOne, &zero, w,&IntConstOne);\n\n\t/*—————————————————————————————————————————————————————————————————————————————————————————————\n\tStep 2: w = w / norm(w); \t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t */\n\t/// w = [n-by-1]\n\t/// wn = [1-by-1]\n\t\n\t// Vector norm -> dnrm2.\n\t*wn = dnrm2(&n, w, &IntConstOne);\n\t// Inverse resulting scalar to enable multiplication instead of division.\n\t*wn = 1 / (*wn);\n\t// Vector-scalar multiplication -> dscal.\n\tdscal(&n, wn, w, &IntConstOne);\n\n\t/*—————————————————————————————————————————————————————————————————————————————————————————————\n\tStep 3: W(:,CurrentComp) = w;\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t */\n\t/// W = [n-by-A]\n\t/// w = [n-by-1]\n\n\t// Copy n doubles from w to W.\n\tmemcpy(W, w, sizeof(double) * n);\n\n\t/*—————————————————————————————————————————————————————————————————————————————————————————————\n\tStep 4: t = X*w;\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t */\n\t/// X = [m-by-n]\n\t/// w = [n-by-1]\n\t/// t = [m-by-1]\n\n\t// Matrix-Vector multiplication -> dgemv.\n\tdgemv(\"N\", &m, &n, &one, X, &m, w, &IntConstOne, &zero, t, &IntConstOne);\n\n\t/*—————————————————————————————————————————————————————————————————————————————————————————————\n\tStep 5: rho = norm(t);\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t */\n\t/// t = [m-by-1] \n\t/// rho = [1-by-1]\n\n\t// Vector norm->dnrm2.\n\t*rho = dnrm2(&m, t, &IntConstOne);\n\n\t/*—————————————————————————————————————————————————————————————————————————————————————————————\n\tStep 6: t = t / rho;\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t */\n\t/// t = [m-by-1] \n\t/// rho = [1-by-1]\n\t/// rhoi = [1-by-1]\n\n\t// Create inverse rho (rhoi) scalar to enable multiplication instead of division.\n\t*rhoi = 1 / (*rho);\n\t// Vector-scalar multiplication ->dscal.\n\tdscal(&m, rhoi, t, &IntConstOne);\n\n\t/*—————————————————————————————————————————————————————————————————————————————————————————————\n\tStep 7: T(:,CurrentComp) = t;\t\t\t\t\t\t\t\t\t\t\t\t\t\t */\n\t/// T = [m-by-A] \n\t/// t = [m-by-p] \n\n\t// Copy m doubles from t to T.\n\tmemcpy(T, t, sizeof(double) * m);\n\t\n\t/*—————————————————————————————————————————————————————————————————————————————————————————————\n\tStep 8: B(1, 1) = rho;\t\t\t\t\t\t\t\t\t\t\t\t\t\t */\n\t/// B = [A-by-2] \n\t/// rho = [1-by-1] \n\t\n\tB[0] = *rho;\n\n\t/*—————————————————————————————————————————————————————————————————————————————————————————————\n\tStep 9: d = w / rho;\t\t\t\t\t\t\t\t\t\t\t\t\t */\n\t/// w = [n-by-1] \n\t/// rho = [1-by-1]\n\t/// rhoi = [1-by-1] \n\t/// d = [n-by-1] \n\n\t// Make d = w\n\tmemcpy(d, w, sizeof(double) * n);\n\n\t// Then scale it with the inversed version of rho to make it w/rho.\n\tdscal(&n, rhoi, d, &IntConstOne);\n\n\t/*—————————————————————————————————————————————————————————————————————————————————————————————\n\tStep 9: beta(:, 1) = (t'*y)*d;\t\t\t\t\t\t\t\t\t\t\t\t\t */\n\t/// t = [m-by-1] \n\t/// d = [n-by-1] \n\t/// y = [m-by-1]\n\t/// tty = [1-by-1]\n\t/// beta(:,1) = [n-by-1]\n\n\t// (t'*y) vector-vector product -> ddot.\n\t*tty = ddot(&m, t, &IntConstOne, y, &IntConstOne);\n\n\t// (d*tty) vector-scalar product. (Here treated as matrix-matrix).\n\tdgemm(\"N\", \"N\", &n, &p, &p, &one, d, &n, tty, &p, &zero, beta, &n);\n\t\n\t//* Start of component loop.\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t */\n\tfor (a = 1; a < A; a++) {\n\t\t/* size_t version of a (preferred by BLAS instead of int). \t\t\t\t\t\t\t\t */\n\t\tst_a = (size_t)a;\n\n\t\t/*—————————————————————————————————————————————————————————————————————————————————————————\n\t\tStep 10: w = X'*t - rho*w;\t\t\t\t\t\t\t\t\t\t\t\t\t */\n\t\t/// w = [n-by-1] \n\t\t/// rho = [1-by-1] \n\t\t/// X = [m-by-n]\n\t\t/// t = [m-by-1] \n\t\t/// Xt = [n-by-1]\n\n\t\t// Xt = X'*t matrix-vector multiplication -> dgemv.\n\t\tdgemv(\"T\", &m, &n, &one, X, &m, t, &IntConstOne, &zero, Xt, &IntConstOne);\n\t\t\n\t\t// The value of rho wont be used again, overwrite with -1*rho.\n\t\t*rho = -1 * (*rho);\n\n\t\t// w = rho*w scalar-vector multiplication -> dscal.\n\t\tdscal(&n, rho, w, &IntConstOne);\n\n\t\t// w = 1*Xt + w vector times constant plus vector -> daxpy.\n\t\tdaxpy(&n, &one, Xt, &IntConstOne, w, &IntConstOne);\n\n\t\n\t\t/*—————————————————————————————————————————————————————————————————————————————————————————\n\t\tStep 11: w = w - W(:,1:a)*(W(:,1:a)'*w);\t\t\t\t\t\t\t\t\t\t\t */\n\t\t/// W(:,1:a) = [n-by-a]\n\t\t/// w = [n-by-1] \n\t\t/// Ww = [a-by-1] \n\t\t/// WWw = [n-by-1]\n\n\t\t// Ww = (W(:,1:a)'*w) matrix-vector multiplication -> dgemm.\n\t\tdgemv(\"T\", &n, &st_a, &one, W, &n, w, &IntConstOne, &zero, Ww, &IntConstOne);\n\n\t\t// WWw = W(:,1:a)*(W(:,1:a)'*w) matrix-vector multiplication -> dgemm.\n\t\tdgemv(\"N\", &n, &st_a, &one, W, &n, Ww, &IntConstOne, &zero, WWw, &IntConstOne);\n\n\t\t// w ← w + -1 * WWw constant times a vector plus a vector -> daxpy.\n\t\tdaxpy(&n, &none, WWw, &IntConstOne, w, &IntConstOne);\n\n\t\t/*—————————————————————————————————————————————————————————————————————————————————————————\n\t\tStep 12: theta = norm(w);\t\t\t\t\t\t\t\t\t\t\t\t\t */\n\t\t/// w = [n-by-1] \n\t\t/// theta = [1-by-1] \n\n\t\t// Vector norm -> dnrm2.\n\t\t*theta = dnrm2(&n, w, &IntConstOne);\n\n\t\t/*—————————————————————————————————————————————————————————————————————————————————————————\n\t\tStep 13: w = w / theta;\t\t\t\t\t\t\t\t\t\t\t\t\t */\n\t\t/// w = [n-by-1] \n\t\t/// theta = [1-by-1] \n\n\t\t// w = w * (1/theta) scalar-vector multiplication -> dscal.\n\t\t*thetai = 1 / (*theta);\n\t\tdscal(&n, thetai, w, &IntConstOne);\n\n\t\t/*—————————————————————————————————————————————————————————————————————————————————————————\n\t\tStep 14: W(:,a) = w;\t\t\t\t\t\t\t\t\t\t\t\t\t */\n\t\t/// w = [n-by-1] \n\t\t/// W = [n-by-A] \n\t\t\n\t\t// Copy n elemments from w into W at offset n * a.\n\t\tmemcpy(W + n * a, w, sizeof(double) * n);\n\n\t\t/*—————————————————————————————————————————————————————————————————————————————————————————\n\t\tStep 15: t = X*w - theta*t;\t\t\t\t\t\t\t\t\t\t\t\t\t */\n\t\t/// X = [m-by-n] \n\t\t/// w = [n-by-1] \n\t\t/// theta = [1-by-1] \n\t\t/// t = [m-by-1] \n\t\t/// Xw = [m-by-1]\n\n\t\t// Xw = X*w = matrix vector multiplication -> dgemv.\n\t\tdgemv(\"N\", &m, &n, &one, X, &m, w, &IntConstOne, &zero, Xw, &IntConstOne);\n\n\t\t// t = Xw - theta*t Better to solve with daxpy?\n\t\t//for (row = 0; row < m; row++){\n\t //\tt[row] = Xw[row] - (*theta) * t[row];\n\t\t//}\n\t\tdscal(&m, theta, t, &IntConstOne);\n\t\tdscal(&m, &none, t, &IntConstOne);\n\t\tdaxpy(&m, &one, Xw, &IntConstOne, t, &IntConstOne);\n\n\t\t/*—————————————————————————————————————————————————————————————————————————————————————————\n\t\tStep 16: t = t - T(:,1:a)*(T(:,1:a)'*t);\t\t\t\t\t\t\t\t\t\t\t\t */ \n\t\t/// t = [m-by-1] \n\t\t/// T(:,1:a) = [m-by-a]\n\t\t/// Tt = [a-by-1]\n\t\t/// TTt = [m-by-1]\n\n\t\t// Tt = (T(:,1:a)'*t) matrix-vector multiplication -> dgemv. \n\t\tdgemv(\"T\", &m, &st_a, &one, T, &m, t, &IntConstOne, &zero, Tt, &IntConstOne);\n\n\t\t// TTt = T(:,1:a)*(T(:,1:a)'*t) matrix-vector multiplication -> dgemv.\n\t\tdgemv(\"N\", &m, &st_a, &one, T, &m, Tt, &IntConstOne, &zero, TTt, &IntConstOne);\n\n\t\t// t ← t + -1 * TTt constant times a vector plus a vector -> daxpy.\n\t\tdaxpy(&m, &none, TTt, &IntConstOne, t, &IntConstOne);\n\n\t\t/*—————————————————————————————————————————————————————————————————————————————————————————\n\t\tStep 17: rho = norm(t);\t\t\t\t\t\t\t\t\t\t\t\t\t */\n\t\t/// t = [m-by-1] \n\t\t/// rho = [1-by-1]\n\n\t\t// Vector norm -> dnrm2.\n\t\t*rho = dnrm2(&m, t, &IntConstOne);\n\t\t\n\t\t/*—————————————————————————————————————————————————————————————————————————————————————————\n\t\tStep 18: t = t/rho;\t\t\t\t\t\t\t\t\t\t\t\t\t */\n\t\t/// t = [m-by-1] \n\t\t/// rho = [1-by-1]\n\t\t\n\t\t// Update inverse version of rho.\n\t\t*rhoi = 1 / (*rho);\n\n\t\t// t = t * (1/rho) scalar-vector multiplication -> dscal\n\t\tdscal(&m, rhoi, t, &IntConstOne);\n\n\t\t/*—————————————————————————————————————————————————————————————————————————————————————————\n\t\tStep 19: T(:, a) = t;\t\t\t\t\t\t\t\t\t\t\t\t\t */\n\t\t/// T = [m-by-A] \n\t\t/// t = [m-by-1] \n\n\t\t// Copy m elemments from t into T at offset m * a\n\t\tmemcpy(T + m * a, t, sizeof(double) * m);\n\n\t\t/*—————————————————————————————————————————————————————————————————————————————————————————\n\t\tStep 20: B(a, 1) = rho;\t\t\t\t\t\t\t\t\t\t\t\t\t */\n\t\t/// B = [A-by-2] \n\t\t/// rho = [1-by-1] \n\t\n\t\tB[a] = *rho;\n\n\t\t/*—————————————————————————————————————————————————————————————————————————————————————————\n\t\tStep 21: B(a - 1, 2) = theta;\t\t\t\t\t\t\t\t\t\t\t\t\t */\n\t\t/// B = [A-by-2] \n\t\t/// theta = [1-by-1] \n\n\t\tB[(a-1) + A] = *theta;\n\n\t\t/*—————————————————————————————————————————————————————————————————————————————————————————\n\t\tStep 22: d = (w - theta*d) / rho;\t\t\t\t\t\t\t\t\t\t\t\t\t */\n\t\t/// d = [n-by-1] \n\t\t/// rho = [1-by-1] \n\t\t/// theta = [1-by-1] \n\t\t/// w = [n-by-1] \n\t\n\t\tfor (row = 0; row < n; row++){\n\t\t\t d[row] = ( w[row] - (*theta) * d[row] ) / (*rho);\n\t\t}\n\n\t\t/*—————————————————————————————————————————————————————————————————————————————————————————\n\t\tStep 23: beta(:, a) = beta(:, a - 1) + (t'*y)*d;\t\t\t\t\t\t\t\t\t */\n\t\t/// beta = [n-by-A] \n\t\t/// t = [m-by-1] \n\t\t/// y = [m-by-1] \n\t\t/// d = [n-by-1] \n\n\t\t// (t'*y) vector-vector product -> ddot\n\t\t*tty = ddot(&m, t, &IntConstOne, y, &IntConstOne);\n\t\t\n\t\t// (tty*d) = scalar-vector product. (Here treated as matrix-matrix).\n\t\tdgemm(\"N\", \"N\", &n, &p, &p, &one, d, &n, tty, &p, &zero, beta + n * a , &n);\n\n\t\t// beta(:, a) ← beta(:, a) + 1 * beta(:, a - 1) -> daxpy\n\t\tdaxpy(&n, &one, beta + n * (a-1), &IntConstOne, beta + n * a, &IntConstOne);\n\n\t\t//for (row = 0; row < n; row++) {\n\t\t\t//beta[row + n * a] = beta[row + n * a] + beta[row + n * (a - 1)];\n\t\t\t//beta[row + n * a] = beta[row + n * (a - 1)];\n\t\t//}\n\n /* End of component loop.\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t */\n\t}\n\n\tfree(t);\n\tfree(T);\n\tfree(Xw);\n\tfree(TTt);\n}\n/* ————————————————————————————————————————————————————————————————————————————————————————————— */\n\n/* ————————————————————————————————————————————————————————————————————————————————————————————— */\n/* Function for drawing a random integer that lies within range.\t\t\t\t\t\t\t\t */\nint randr(unsigned int min, unsigned int max) {\n\treturn min + rand() / (RAND_MAX / (max - min + 1) + 1);\n}\n/* ————————————————————————————————————————————————————————————————————————————————————————————— */\n\n/* ————————————————————————————————————————————————————————————————————————————————————————————— */\n/* Function for marking rows in the data as validation or not during CV\t\t\t\t\t\t\t */\nvoid MarkAsVal(bool *IsVal, int NoValObs, size_t m, size_t *valm, size_t *trainm, const double *y) {\n\tint activeobs, row, index;\n\tbool alreadyactive;\n\n\t/* Initialize all IsVal elements to false */\n\tfor (row = 0; row < m; row++) {\n\t\tIsVal[row] = false;\n\t}\n\n\tactiveobs = 0;\n\twhile (activeobs < NoValObs) { // NOTE! this needs a check aginst input NoValObs larger than unique(y)! \n\t\t\t\t\t\t\t\t /* Draw random rownumber between 0 and m */\n\t\tindex = randr(0, m);\n\t\talreadyactive = false;\n\t\t/* Mark all the rows with the same response as validation to keep replicates together */\n\t\tfor (row = 0; row < m; row++) {\n\t\t\tif (y[row] == y[index]) {\n\t\t\t\t/* If IsVal was 0 it means this is a newly found observation. */\n\t\t\t\tif (IsVal[row] == false & alreadyactive == false) {\n\t\t\t\t\tactiveobs += 1;\n\t\t\t\t\talreadyactive = true;\n\t\t\t\t}\n\t\t\t\t/* If IsVal is already 1 stop looping and pick a new observation to save time */\n\t\t\t\telse if (IsVal[row] == true) {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\tIsVal[row] = true;\n\t\t\t}\n\t\t}\n\t}\n\n\t/* Calculate the number of rows in Xval/yval and Xtrain/ytrain so they can be allocated */\n\t*valm = 0;\n\tfor (row = 0; row < m; row++) {\n\t\tif (IsVal[row] == true) {\n\t\t\t*valm += 1;\n\t\t}\n\t}\n\t*trainm = m - (*valm);\n}\n/* ————————————————————————————————————————————————————————————————————————————————————————————— */\n\n/* ————————————————————————————————————————————————————————————————————————————————————————————— */\n/* Function for populating Xtrain Xval ytrain yval given known IsVal vector\t\t\t\t\t */\nvoid ExtractXandY(const double *X, const double *y, double *Xtrain, double *Xval, double *ytrain,\n\tdouble *yval, size_t m, size_t n, bool *IsVal) {\n\t\n\tint col, row, xte, xve, yve, yte;\n\n\txte = xve = 0;\n\tyte = yve = 0;\n\n\t/* Outer loop over all columns of X */\n\tfor (col = 0; col < n; col++) {\n\t\t/* Inner loop over all rows of X */\n\t\tfor (row = 0; row < m; row++) {\n\n\t\t\tif (IsVal[row] == true) {\n\t\t\t\tXval[xve] = X[row + col * m];\n\t\t\t\txve += 1;\n\t\t\t\tif (col == 0) {\n\t\t\t\t\tyval[yve] = y[row];\n\t\t\t\t\tyve += 1;\n\t\t\t\t}\n\t\t\t}\n\t\t\telse {\n\t\t\t\tXtrain[xte] = X[row + col * m];\n\t\t\t\txte += 1;\n\t\t\t\tif (col == 0) {\n\t\t\t\t\tytrain[yte] = y[row];\n\t\t\t\t\tyte += 1;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n/* ————————————————————————————————————————————————————————————————————————————————————————————— */\n\n/* ————————————————————————————————————————————————————————————————————————————————————————————— */\n/* Function for calculating validation error using Xval and beta\t\t\t\t\t\t\t\t */\nvoid Pred(double *Xval, double *beta, double *yval, size_t n, size_t valm, int A, double *yhat, double *RMSEcv, int cvIter, int MaxIters, int ShavingIndex) {\n\n\tsize_t st_A;\n\tint col;\n\tdouble one = 1.0, zero = 0.0, none = -1.0;\n\tmwSignedIndex IntConstOne = 1;\n\tst_A = (size_t)A;\n\n\t/* yhat = Xval*beta\t\t\t\t\t\t\t\t\t\t\t\t\t\t */\n\tdgemm(\"N\", \"N\", &valm, &st_A, &n, &one, Xval, &valm, beta, &n, &zero, yhat, &valm);\n\n\t/* Loop the columns of yhat and calulate the error for each component.\t\t\t\t\t\t */\n\tfor (col = 0; col < A; col++) {\n\n\t\t/* yhat is here overwritten and becomes epsilon\twhere epsilon = yhat + (-Yval).\t */\n\t\tdaxpy(&valm, &none, yval, &IntConstOne, yhat + col * valm, &IntConstOne);\n\n\t\t/* Calculate the Mean Squared Error by taking the dot product of each error column with\n\t\titself and then dividing by the number of observations (valm). At the same time, add it\n\t\tto the\texisting value of the RMSE vector, thereby performing a summation of the errors\n\t\tof each cross-validation iteration at the same time (prevents the need of a 2D matrix).\t */\n\t\tif (ShavingIndex == 0) {\n\t\t\tRMSEcv[ShavingIndex + col*(n + 1)] += ddot(&valm, yhat + col * valm, &IntConstOne, yhat + col * valm, &IntConstOne) / valm;\n\t\t}\n\t\telse {\n\t\t\tRMSEcv[ShavingIndex + col*(n + 2)] += ddot(&valm, yhat + col * valm, &IntConstOne, yhat + col * valm, &IntConstOne) / valm;\n\t\t}\n\t\t/* If its the last cross-validation iteration, finalize RMSEcv (which right now\n\t\trepresents sum(MSE,1) [folds-by-components] ) by dividing by the number of cv iterations\n\t\tand taking the square-root of the currently squared errors.\t\t\t\t\t\t\t\t */\n\t\tif (cvIter == MaxIters - 1) {\n\t\t\tif (ShavingIndex == 0) {\n\t\t\t\tRMSEcv[ShavingIndex + col*(n + 1)] = sqrt(RMSEcv[ShavingIndex + col*(n + 1)] / MaxIters);\n\t\t\t}\n\t\t\telse {\n\t\t\t\tRMSEcv[ShavingIndex + col*(n + 2)] = sqrt(RMSEcv[ShavingIndex + col*(n + 2)] / MaxIters);\n\t\t\t}\n\t\t}\n\n\t}\n\n}\n/* ————————————————————————————————————————————————————————————————————————————————————————————— */\n\n/* ————————————————————————————————————————————————————————————————————————————————————————————— */\n/* Function for placing a column at the and of a matrix (swapping it with the last column) */\nvoid SwapCols(double *Xtrain, double *Xval, size_t trainm, size_t valm, size_t n, int ColToShave) {\n\n\tmwSignedIndex IntConstOne = 1;\n\n\t/* Use dswap to swap location of two column vectors in Xtrain.\t\t\t\t\t\t\t\t */\n\tdswap(&trainm, Xtrain + (n - 1) * trainm, &IntConstOne,\tXtrain + ColToShave * trainm, &IntConstOne);\n\n\t/* Use dswap to swap location of two column vectors in Xval.\t\t\t\t\t\t\t\t */\n\tdswap(&valm, Xval + (n - 1) * valm, &IntConstOne, Xval + ColToShave * valm, &IntConstOne);\n}\n/* ————————————————————————————————————————————————————————————————————————————————————————————— */", "meta": {"hexsha": "8195e61e56b4bd008489e95544415dbc3533b431", "size": 27227, "ext": "c", "lang": "C", "max_stars_repo_path": "PLS/VariableSelection/BackwardsSelectionBidag2.c", "max_stars_repo_name": "Petter-s/RegressionFunctions", "max_stars_repo_head_hexsha": "adcee85c172fdb1fe305f0bde7480f043566703b", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "PLS/VariableSelection/BackwardsSelectionBidag2.c", "max_issues_repo_name": "Petter-s/RegressionFunctions", "max_issues_repo_head_hexsha": "adcee85c172fdb1fe305f0bde7480f043566703b", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "PLS/VariableSelection/BackwardsSelectionBidag2.c", "max_forks_repo_name": "Petter-s/RegressionFunctions", "max_forks_repo_head_hexsha": "adcee85c172fdb1fe305f0bde7480f043566703b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 42.2779503106, "max_line_length": 157, "alphanum_fraction": 0.4403349616, "num_tokens": 8064, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8418256313782276, "lm_q2_score": 0.600188359260205, "lm_q1q2_score": 0.5052539444800845}} {"text": "/* specfunc/clausen.c\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n/* Author: G. Jungman */\n\n#include \n#include \n#include \n#include \n#include \n\n#include \"chebyshev.h\"\n#include \"cheb_eval.c\"\n\nstatic double aclaus_data[15] = {\n 2.142694363766688447e+00,\n 0.723324281221257925e-01,\n 0.101642475021151164e-02,\n 0.3245250328531645e-04,\n 0.133315187571472e-05,\n 0.6213240591653e-07,\n 0.313004135337e-08,\n 0.16635723056e-09,\n 0.919659293e-11,\n 0.52400462e-12,\n 0.3058040e-13,\n 0.18197e-14,\n 0.1100e-15,\n 0.68e-17,\n 0.4e-18\n};\nstatic cheb_series aclaus_cs = {\n aclaus_data,\n 14,\n -1, 1,\n 8 /* FIXME: this is a guess, correct value needed here BJG */\n};\n\n\n/*-*-*-*-*-*-*-*-*-*-*-* Functions with Error Codes *-*-*-*-*-*-*-*-*-*-*-*/\n\nint gsl_sf_clausen_e(double x, gsl_sf_result *result)\n{\n const double x_cut = M_PI * GSL_SQRT_DBL_EPSILON;\n\n double sgn = 1.0;\n int status_red;\n\n if(x < 0.0) {\n x = -x;\n sgn = -1.0;\n }\n\n /* Argument reduction to [0, 2pi) */\n status_red = gsl_sf_angle_restrict_pos_e(&x);\n\n /* Further reduction to [0,pi) */\n if(x > M_PI) {\n /* simulated extra precision: 2PI = p0 + p1 */\n const double p0 = 6.28125;\n const double p1 = 0.19353071795864769253e-02;\n x = (p0 - x) + p1;\n sgn = -sgn;\n }\n\n if(x == 0.0) {\n result->val = 0.0;\n result->err = 0.0;\n }\n else if(x < x_cut) {\n result->val = x * (1.0 - log(x));\n result->err = x * GSL_DBL_EPSILON;\n }\n else {\n const double t = 2.0*(x*x / (M_PI*M_PI) - 0.5);\n gsl_sf_result result_c;\n cheb_eval_e(&aclaus_cs, t, &result_c);\n result->val = x * (result_c.val - log(x));\n result->err = x * (result_c.err + GSL_DBL_EPSILON);\n }\n\n result->val *= sgn;\n\n return status_red;\n}\n\n\n/*-*-*-*-*-*-*-*-*-* Functions w/ Natural Prototypes *-*-*-*-*-*-*-*-*-*-*/\n\n#include \"eval.h\"\n\ndouble gsl_sf_clausen(const double x)\n{\n EVAL_RESULT(gsl_sf_clausen_e(x, &result));\n}\n", "meta": {"hexsha": "ebaebbd62e2263107d1c5ed03d2a3a76585b708b", "size": 2738, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.6/specfunc/clausen.c", "max_stars_repo_name": "ielomariala/Hex-Game", "max_stars_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-12-18T18:09:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-10T11:31:28.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/specfunc/clausen.c", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-12-16T17:41:24.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-22T00:00:16.000Z", "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/specfunc/clausen.c", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 14.0, "max_forks_repo_forks_event_min_datetime": "2015-07-21T04:47:52.000Z", "max_forks_repo_forks_event_max_datetime": "2020-03-12T12:31:25.000Z", "avg_line_length": 24.4464285714, "max_line_length": 81, "alphanum_fraction": 0.6431701972, "num_tokens": 961, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7401743620390162, "lm_q2_score": 0.6825737344123242, "lm_q1q2_score": 0.505223578413231}} {"text": "/* linalg/ldlt_band.c\n * \n * Copyright (C) 2018 Patrick Alken\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n/* L D L^T decomposition of a symmetric banded positive semi-definite matrix */\n\n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n\nstatic double symband_norm1(const gsl_matrix * A);\nstatic int ldlt_band_Ainv(CBLAS_TRANSPOSE_t TransA, gsl_vector * x, void * params);\n\n/*\ngsl_linalg_ldlt_band_decomp()\n L D L^T decomposition of a square symmetric positive semi-definite banded\nmatrix\n\nInputs: A - matrix in symmetric banded format, N-by-ndiag where N is the size of\n the matrix and ndiag is the number of nonzero diagonals.\n\nNotes:\n1) The matrix D is stored in the first column of A;\nthe first subdiagonal of L in the second column and so on.\n\n2) If ndiag > 1, the 1-norm of A is stored in A(N,ndiag) on output\n\n3) At each diagonal element, the matrix is factored as\n\nA(j:end,j:end) = [ A11 A21^T ] = [ 1 0 ] [ alpha 0 ] [ 1 v^T ]\n [ A21 A22 ] [ v L ] [ 0 D ] [ 0 L^T ]\n\nwhere:\n\nalpha = A(j,j)\nv = A(j+1:end, j) / alpha\nA22 = L D L^T + alpha v v^T\n\nSo we start at A(1,1) and work right. Pseudo-code is:\n\nloop j = 1, ..., N\n alpha = A(j,j)\n A(j+1:end, j) := A(j+1:end, j) / alpha (DSCAL)\n A(j+1:end, j+1:end) -= alpha v v^T (DSYR)\n\nDue to the banded structure, v has at most p non-zero elements, where\np is the lower bandwidth\n*/\n\nint\ngsl_linalg_ldlt_band_decomp(gsl_matrix * A)\n{\n const size_t N = A->size1; /* size of matrix */\n const size_t ndiag = A->size2; /* number of diagonals in band, including main diagonal */\n\n if (ndiag > N)\n {\n GSL_ERROR (\"invalid matrix dimensions\", GSL_EBADLEN);\n }\n else\n {\n const size_t p = ndiag - 1; /* lower bandwidth */\n const int kld = (int) GSL_MAX(1, p);\n double Anorm;\n size_t j;\n\n /* check for quick return */\n if (ndiag == 1)\n return GSL_SUCCESS;\n\n /*\n * calculate 1-norm of A and store in lower right of matrix, which is not accessed\n * by rest of routine. gsl_linalg_ldlt_band_rcond() will use this later. If\n * A is diagonal, there is no empty slot to store the 1-norm, so the rcond routine\n * will have to compute it.\n */\n Anorm = symband_norm1(A);\n gsl_matrix_set(A, N - 1, p, Anorm);\n\n for (j = 0; j < N - 1; ++j)\n {\n double ajj = gsl_matrix_get(A, j, 0);\n size_t lenv;\n\n if (ajj == 0.0)\n {\n GSL_ERROR(\"matrix is singular\", GSL_EDOM);\n }\n\n /* number of elements in v, which will normally be p, unless we\n * are in lower right corner of matrix */\n lenv = GSL_MIN(p, N - j - 1);\n\n if (lenv > 0)\n {\n gsl_vector_view v = gsl_matrix_subrow(A, j, 1, lenv);\n gsl_matrix_view m = gsl_matrix_submatrix(A, j + 1, 0, lenv, lenv);\n\n gsl_blas_dscal(1.0 / ajj, &v.vector);\n\n m.matrix.tda = kld;\n gsl_blas_dsyr(CblasUpper, -ajj, &v.vector, &m.matrix);\n }\n }\n\n return GSL_SUCCESS;\n }\n}\n\nint\ngsl_linalg_ldlt_band_solve (const gsl_matrix * LDLT,\n const gsl_vector * b,\n gsl_vector * x)\n{\n if (LDLT->size1 != b->size)\n {\n GSL_ERROR (\"matrix size must match b size\", GSL_EBADLEN);\n }\n else if (LDLT->size1 != x->size)\n {\n GSL_ERROR (\"matrix size must match solution size\", GSL_EBADLEN);\n }\n else\n {\n int status;\n\n /* copy x <- b */\n gsl_vector_memcpy (x, b);\n\n status = gsl_linalg_ldlt_band_svx(LDLT, x);\n\n return status;\n }\n}\n\nint\ngsl_linalg_ldlt_band_svx (const gsl_matrix * LDLT, gsl_vector * x)\n{\n if (LDLT->size1 != x->size)\n {\n GSL_ERROR (\"matrix size must match solution size\", GSL_EBADLEN);\n }\n else\n {\n gsl_vector_const_view diag = gsl_matrix_const_column(LDLT, 0);\n\n /* solve for z using forward-substitution, L z = b */\n cblas_dtbsv(CblasColMajor, CblasLower, CblasNoTrans, CblasUnit,\n (int) LDLT->size1, (int) (LDLT->size2 - 1), LDLT->data, LDLT->tda,\n x->data, x->stride);\n\n /* solve for y, D y = z */\n gsl_vector_div(x, &diag.vector);\n\n /* perform back-substitution, L^T x = y */\n cblas_dtbsv(CblasColMajor, CblasLower, CblasTrans, CblasUnit,\n (int) LDLT->size1, (int) (LDLT->size2 - 1), LDLT->data, LDLT->tda,\n x->data, x->stride);\n\n return GSL_SUCCESS;\n }\n}\n\n/*\ngsl_linalg_ldlt_band_unpack()\n Unpack symmetric banded format matrix LDLT into\nlarger matrix L and diagonal vector D\n*/\n\nint\ngsl_linalg_ldlt_band_unpack (const gsl_matrix * LDLT, gsl_matrix * L, gsl_vector * D)\n{\n const size_t N = LDLT->size1;\n\n if (N != L->size1)\n {\n GSL_ERROR(\"L matrix does not match LDLT dimensions\", GSL_EBADLEN);\n }\n else if (L->size1 != L->size2)\n {\n GSL_ERROR(\"L matrix is not square\", GSL_ENOTSQR);\n }\n else if (N != D->size)\n {\n GSL_ERROR(\"D vector does not match LDLT dimensions\", GSL_EBADLEN);\n }\n else\n {\n const size_t p = LDLT->size2 - 1; /* lower bandwidth */\n gsl_vector_const_view diag = gsl_matrix_const_column(LDLT, 0);\n gsl_vector_view diagL = gsl_matrix_diagonal(L);\n size_t i;\n\n /* copy diagonal entries */\n gsl_vector_memcpy(D, &diag.vector);\n\n /* copy subdiagonals into L */\n for (i = 1; i <= p; ++i)\n {\n gsl_vector_const_view v = gsl_matrix_const_subcolumn(LDLT, i, 0, N - i);\n gsl_vector_view w = gsl_matrix_subdiagonal(L, i);\n gsl_vector_memcpy(&w.vector, &v.vector);\n }\n\n /* set main diagonal of L */\n gsl_vector_set_all(&diagL.vector, 1.0);\n\n /* zero out remaining subdiagonals */\n for (i = p + 1; i < N; ++i)\n {\n gsl_vector_view w = gsl_matrix_subdiagonal(L, i);\n gsl_vector_set_zero(&w.vector);\n }\n\n return GSL_SUCCESS;\n }\n}\n\nint\ngsl_linalg_ldlt_band_rcond (const gsl_matrix * LDLT, double * rcond, gsl_vector * work)\n{\n const size_t N = LDLT->size1;\n\n if (work->size != 3 * N)\n {\n GSL_ERROR (\"work vector must have length 3*N\", GSL_EBADLEN);\n }\n else\n {\n int status;\n const size_t ndiag = LDLT->size2;\n double Anorm; /* ||A||_1 */\n double Ainvnorm; /* ||A^{-1}||_1 */\n\n if (ndiag == 1)\n {\n /* diagonal matrix, compute 1-norm since it has not been stored */\n Anorm = symband_norm1(LDLT);\n }\n else\n {\n /* 1-norm is stored in A(N, ndiag) by gsl_linalg_ldlt_band_decomp() */\n Anorm = gsl_matrix_get(LDLT, N - 1, ndiag - 1);\n }\n\n *rcond = 0.0;\n\n /* return if matrix is singular */\n if (Anorm == 0.0)\n return GSL_SUCCESS;\n\n status = gsl_linalg_invnorm1(N, ldlt_band_Ainv, (void *) LDLT, &Ainvnorm, work);\n if (status)\n return status;\n\n if (Ainvnorm != 0.0)\n *rcond = (1.0 / Anorm) / Ainvnorm;\n\n return GSL_SUCCESS;\n }\n}\n\n/* compute 1-norm of symmetric banded matrix */\nstatic double\nsymband_norm1(const gsl_matrix * A)\n{\n const size_t N = A->size1;\n const size_t ndiag = A->size2; /* number of diagonals in band, including main diagonal */\n double value;\n\n if (ndiag == 1)\n {\n /* diagonal matrix */\n gsl_vector_const_view v = gsl_matrix_const_column(A, 0);\n CBLAS_INDEX_t idx = gsl_blas_idamax(&v.vector);\n value = gsl_vector_get(&v.vector, idx);\n }\n else\n {\n size_t j;\n\n value = 0.0;\n for (j = 0; j < N; ++j)\n {\n size_t ncol = GSL_MIN(ndiag, N - j); /* number of elements in column j below and including main diagonal */\n gsl_vector_const_view v = gsl_matrix_const_subrow(A, j, 0, ncol);\n double sum = gsl_blas_dasum(&v.vector);\n size_t k, l;\n\n /* sum now contains the absolute sum of elements below and including main diagonal for column j; we\n * have to add the symmetric elements above the diagonal */\n k = j;\n l = 1;\n while (k > 0 && l < ndiag)\n {\n double Akl = gsl_matrix_get(A, --k, l++);\n sum += fabs(Akl);\n }\n\n value = GSL_MAX(value, sum);\n }\n }\n\n return value;\n}\n\n/* x := A^{-1} x = A^{-t} x, A = L D L^T */\nstatic int\nldlt_band_Ainv(CBLAS_TRANSPOSE_t TransA, gsl_vector * x, void * params)\n{\n gsl_matrix * LDLT = (gsl_matrix * ) params;\n gsl_vector_const_view diag = gsl_matrix_const_column(LDLT, 0);\n\n (void) TransA; /* unused parameter warning */\n\n /* compute x := L^{-1} x */\n cblas_dtbsv(CblasColMajor, CblasLower, CblasNoTrans, CblasUnit,\n (int) LDLT->size1, (int) (LDLT->size2 - 1), LDLT->data, LDLT->tda,\n x->data, x->stride);\n\n /* compute x := D^{-1} x */\n gsl_vector_div(x, &diag.vector);\n\n /* compute x := L^{-T} x */\n cblas_dtbsv(CblasColMajor, CblasLower, CblasTrans, CblasUnit,\n (int) LDLT->size1, (int) (LDLT->size2 - 1), LDLT->data, LDLT->tda,\n x->data, x->stride);\n\n return GSL_SUCCESS;\n}\n", "meta": {"hexsha": "9c78e26eeaf542c592352808668755c0d849b006", "size": 9920, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.6/linalg/ldlt_band.c", "max_stars_repo_name": "ielomariala/Hex-Game", "max_stars_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-06-14T11:51:37.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-14T11:51:37.000Z", "max_issues_repo_path": "gsl-2.6/linalg/ldlt_band.c", "max_issues_repo_name": "ielomariala/Hex-Game", "max_issues_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-12-16T17:41:24.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-22T00:00:16.000Z", "max_forks_repo_path": "test/lib/gsl-2.6/linalg/ldlt_band.c", "max_forks_repo_name": "karanbirsandhu/nu-sense", "max_forks_repo_head_hexsha": "83fd1fc4cbd053a4f9b673d5cd5841823ddd4d8b", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-01-20T16:22:57.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-14T12:31:02.000Z", "avg_line_length": 28.2621082621, "max_line_length": 117, "alphanum_fraction": 0.5939516129, "num_tokens": 2939, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7401743735019595, "lm_q2_score": 0.6825737214979745, "lm_q1q2_score": 0.5052235766786642}} {"text": "/* ode-initval2/msbdf.c\n * \n * Copyright (C) 2009, 2010 Tuomo Keskitalo\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n/* A variable-coefficient linear multistep backward differentiation\n formula (BDF) method in Nordsieck form. This stepper uses the\n explicit BDF formula as predictor and implicit BDF formula as\n corrector. A modified Newton iteration method is used to\n solve the system of non-linear equations. Method order varies\n dynamically between 1 and 5.\n\n References:\n\n Byrne, G. D., and Hindmarsh, A. C., A Polyalgorithm for the\n Numerical Solution of Ordinary Differential Equations,\n ACM Trans. Math. Software, 1 (1975), pp. 71-96.\n\n Brown, P. N., Byrne, G. D., and Hindmarsh, A. C., VODE: A\n Variable-coefficient ODE Solver, SIAM J. Sci. Stat. Comput. 10,\n (1989), pp. 1038-1051.\n\n Hindmarsh, A. C., Brown, P. N., Grant, K. E., Lee, S. L., Serban,\n R., Shumaker, D. E., and Woodward, C. S., SUNDIALS: Suite of\n Nonlinear and Differential/Algebraic Equation Solvers, ACM\n Trans. Math. Software 31 (2005), pp. 363-396.\n\n Note: The algorithms have been adapted for GSL ode-initval2\n framework.\n*/\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"odeiv_util.h\"\n\n/* Maximum order of BDF methods */\n#define MSBDF_MAX_ORD 5\n\n/* Steps until Jacobian evaluation is forced */\n#define MSBDF_JAC_WAIT 50\n\n/* Steps until iteration matrix M evaluation is forced */\n#define MSBDF_M_WAIT 20\n\ntypedef struct\n{\n /* Nordsieck history matrix. Includes concatenated\n Nordsieck vectors [y_n, h*y_n', (h^2/2!)*y_n'', ...,\n (h^ord/ord!)*d^(ord)(y_n)]. Nordsieck vector number i is located\n at z[i*dim] (i=0..ord).\n */\n double *z;\n\n double *zbackup; /* backup of Nordsieck matrix */\n double *ytmp; /* work area */\n double *ytmp2; /* work area */\n double *l; /* polynomial coefficients */\n double *hprev; /* previous step sizes */\n double *hprevbackup; /* backup of hprev */\n size_t *ordprev; /* orders of previous calls */\n size_t *ordprevbackup; /* backup of ordprev */\n double *errlev; /* desired error level of y */\n gsl_vector *abscor; /* absolute y values for correction */\n gsl_vector *relcor; /* relative y values for correction */\n gsl_vector *svec; /* saved abscor & work area */\n gsl_vector *tempvec; /* work area */\n const gsl_odeiv2_driver *driver; /* pointer to gsl_odeiv2_driver object */\n gsl_matrix *dfdy; /* Jacobian */\n double *dfdt; /* storage for time derivative of f */\n gsl_matrix *M; /* Newton iteration matrix */\n gsl_permutation *p; /* permutation for LU decomposition of M */\n gsl_vector *rhs; /* right hand side equations (-G) */\n\n long int ni; /* stepper call counter */\n size_t ord; /* current order of method */\n double tprev; /* t point of previous call */\n size_t ordwait; /* counter for order change */\n size_t ordwaitbackup; /* backup of ordwait */\n size_t failord; /* order of convergence failure */\n double failt; /* t point of convergence failure */\n double ordp1coeffprev; /* saved order coefficient */\n size_t nJ; /* step counter for Jacobian evaluation */\n size_t nM; /* step counter for update of M */\n double gammaprev; /* gamma of previous call */\n double gammaprevbackup; /* backup of gammaprev */\n size_t failcount; /* counter for rejected steps */\n}\nmsbdf_state_t;\n\n/* Introduce msbdf_reset for use in msbdf_alloc and _apply */\n\nstatic int msbdf_reset (void *, size_t);\n\nstatic void *\nmsbdf_alloc (size_t dim)\n{\n msbdf_state_t *state = (msbdf_state_t *) malloc (sizeof (msbdf_state_t));\n\n if (state == 0)\n {\n GSL_ERROR_NULL (\"failed to allocate space for msbdf_state\", GSL_ENOMEM);\n }\n\n state->z = (double *) malloc ((MSBDF_MAX_ORD + 1) * dim * sizeof (double));\n\n if (state->z == 0)\n {\n free (state);\n GSL_ERROR_NULL (\"failed to allocate space for z\", GSL_ENOMEM);\n }\n\n state->zbackup =\n (double *) malloc ((MSBDF_MAX_ORD + 1) * dim * sizeof (double));\n\n if (state->zbackup == 0)\n {\n free (state->z);\n free (state);\n GSL_ERROR_NULL (\"failed to allocate space for zbackup\", GSL_ENOMEM);\n }\n\n state->ytmp = (double *) malloc (dim * sizeof (double));\n\n if (state->ytmp == 0)\n {\n free (state->zbackup);\n free (state->z);\n free (state);\n GSL_ERROR_NULL (\"failed to allocate space for ytmp\", GSL_ENOMEM);\n }\n\n state->ytmp2 = (double *) malloc (dim * sizeof (double));\n\n if (state->ytmp2 == 0)\n {\n free (state->ytmp);\n free (state->zbackup);\n free (state->z);\n free (state);\n GSL_ERROR_NULL (\"failed to allocate space for ytmp2\", GSL_ENOMEM);\n }\n\n state->l = (double *) malloc ((MSBDF_MAX_ORD + 1) * sizeof (double));\n\n if (state->l == 0)\n {\n free (state->ytmp);\n free (state->zbackup);\n free (state->z);\n free (state);\n GSL_ERROR_NULL (\"failed to allocate space for l\", GSL_ENOMEM);\n }\n\n state->hprev = (double *) malloc (MSBDF_MAX_ORD * sizeof (double));\n\n if (state->hprev == 0)\n {\n free (state->l);\n free (state->ytmp2);\n free (state->ytmp);\n free (state->zbackup);\n free (state->z);\n free (state);\n GSL_ERROR_NULL (\"failed to allocate space for hprev\", GSL_ENOMEM);\n }\n\n state->hprevbackup = (double *) malloc (MSBDF_MAX_ORD * sizeof (double));\n\n if (state->hprevbackup == 0)\n {\n free (state->hprev);\n free (state->l);\n free (state->ytmp2);\n free (state->ytmp);\n free (state->zbackup);\n free (state->z);\n free (state);\n GSL_ERROR_NULL (\"failed to allocate space for hprevbackup\", GSL_ENOMEM);\n }\n\n state->ordprev = (size_t *) malloc (MSBDF_MAX_ORD * sizeof (size_t));\n\n if (state->ordprev == 0)\n {\n free (state->hprevbackup);\n free (state->hprev);\n free (state->l);\n free (state->ytmp2);\n free (state->ytmp);\n free (state->zbackup);\n free (state->z);\n free (state);\n GSL_ERROR_NULL (\"failed to allocate space for ordprev\", GSL_ENOMEM);\n }\n\n state->ordprevbackup = (size_t *) malloc (MSBDF_MAX_ORD * sizeof (size_t));\n\n if (state->ordprevbackup == 0)\n {\n free (state->ordprev);\n free (state->hprevbackup);\n free (state->hprev);\n free (state->l);\n free (state->ytmp2);\n free (state->ytmp);\n free (state->zbackup);\n free (state->z);\n free (state);\n GSL_ERROR_NULL (\"failed to allocate space for ordprevbackup\",\n GSL_ENOMEM);\n }\n\n state->errlev = (double *) malloc (dim * sizeof (double));\n\n if (state->errlev == 0)\n {\n free (state->ordprevbackup);\n free (state->ordprev);\n free (state->hprevbackup);\n free (state->hprev);\n free (state->l);\n free (state->ytmp2);\n free (state->ytmp);\n free (state->zbackup);\n free (state->z);\n free (state);\n GSL_ERROR_NULL (\"failed to allocate space for errlev\", GSL_ENOMEM);\n }\n\n state->abscor = gsl_vector_alloc (dim);\n\n if (state->abscor == 0)\n {\n free (state->errlev);\n free (state->ordprevbackup);\n free (state->ordprev);\n free (state->hprevbackup);\n free (state->hprev);\n free (state->l);\n free (state->ytmp2);\n free (state->ytmp);\n free (state->zbackup);\n free (state->z);\n free (state);\n GSL_ERROR_NULL (\"failed to allocate space for abscor\", GSL_ENOMEM);\n }\n\n state->relcor = gsl_vector_alloc (dim);\n\n if (state->relcor == 0)\n {\n gsl_vector_free (state->abscor);\n free (state->errlev);\n free (state->ordprevbackup);\n free (state->ordprev);\n free (state->hprevbackup);\n free (state->hprev);\n free (state->l);\n free (state->ytmp2);\n free (state->ytmp);\n free (state->zbackup);\n free (state->z);\n free (state);\n GSL_ERROR_NULL (\"failed to allocate space for relcor\", GSL_ENOMEM);\n }\n\n state->svec = gsl_vector_alloc (dim);\n\n if (state->svec == 0)\n {\n gsl_vector_free (state->relcor);\n gsl_vector_free (state->abscor);\n free (state->errlev);\n free (state->ordprevbackup);\n free (state->ordprev);\n free (state->hprevbackup);\n free (state->hprev);\n free (state->l);\n free (state->ytmp2);\n free (state->ytmp);\n free (state->zbackup);\n free (state->z);\n free (state);\n GSL_ERROR_NULL (\"failed to allocate space for svec\", GSL_ENOMEM);\n }\n\n state->tempvec = gsl_vector_alloc (dim);\n\n if (state->tempvec == 0)\n {\n gsl_vector_free (state->svec);\n gsl_vector_free (state->relcor);\n gsl_vector_free (state->abscor);\n free (state->errlev);\n free (state->ordprevbackup);\n free (state->ordprev);\n free (state->hprevbackup);\n free (state->hprev);\n free (state->l);\n free (state->ytmp2);\n free (state->ytmp);\n free (state->zbackup);\n free (state->z);\n free (state);\n GSL_ERROR_NULL (\"failed to allocate space for tempvec\", GSL_ENOMEM);\n }\n\n state->dfdy = gsl_matrix_alloc (dim, dim);\n\n if (state->dfdy == 0)\n {\n gsl_vector_free (state->tempvec);\n gsl_vector_free (state->svec);\n gsl_vector_free (state->relcor);\n gsl_vector_free (state->abscor);\n free (state->errlev);\n free (state->ordprevbackup);\n free (state->ordprev);\n free (state->hprevbackup);\n free (state->hprev);\n free (state->l);\n free (state->ytmp2);\n free (state->ytmp);\n free (state->zbackup);\n free (state->z);\n free (state);\n GSL_ERROR_NULL (\"failed to allocate space for dfdy\", GSL_ENOMEM);\n }\n\n state->dfdt = (double *) malloc (dim * sizeof (double));\n\n if (state->dfdt == 0)\n {\n gsl_matrix_free (state->dfdy);\n gsl_vector_free (state->tempvec);\n gsl_vector_free (state->svec);\n gsl_vector_free (state->relcor);\n gsl_vector_free (state->abscor);\n free (state->errlev);\n free (state->ordprevbackup);\n free (state->ordprev);\n free (state->hprevbackup);\n free (state->hprev);\n free (state->l);\n free (state->ytmp2);\n free (state->ytmp);\n free (state->zbackup);\n free (state->z);\n free (state);\n GSL_ERROR_NULL (\"failed to allocate space for dfdt\", GSL_ENOMEM);\n }\n\n state->M = gsl_matrix_alloc (dim, dim);\n\n if (state->M == 0)\n {\n free (state->dfdt);\n gsl_matrix_free (state->dfdy);\n gsl_vector_free (state->tempvec);\n gsl_vector_free (state->svec);\n gsl_vector_free (state->relcor);\n gsl_vector_free (state->abscor);\n free (state->errlev);\n free (state->ordprevbackup);\n free (state->ordprev);\n free (state->hprevbackup);\n free (state->hprev);\n free (state->l);\n free (state->ytmp2);\n free (state->ytmp);\n free (state->zbackup);\n free (state->z);\n free (state);\n GSL_ERROR_NULL (\"failed to allocate space for M\", GSL_ENOMEM);\n }\n\n state->p = gsl_permutation_alloc (dim);\n\n if (state->p == 0)\n {\n gsl_matrix_free (state->M);\n free (state->dfdt);\n gsl_matrix_free (state->dfdy);\n gsl_vector_free (state->tempvec);\n gsl_vector_free (state->svec);\n gsl_vector_free (state->relcor);\n gsl_vector_free (state->abscor);\n free (state->errlev);\n free (state->ordprevbackup);\n free (state->ordprev);\n free (state->hprevbackup);\n free (state->hprev);\n free (state->l);\n free (state->ytmp2);\n free (state->ytmp);\n free (state->zbackup);\n free (state->z);\n free (state);\n GSL_ERROR_NULL (\"failed to allocate space for p\", GSL_ENOMEM);\n }\n\n state->rhs = gsl_vector_alloc (dim);\n\n if (state->rhs == 0)\n {\n gsl_permutation_free (state->p);\n gsl_matrix_free (state->M);\n free (state->dfdt);\n gsl_matrix_free (state->dfdy);\n gsl_vector_free (state->tempvec);\n gsl_vector_free (state->svec);\n gsl_vector_free (state->relcor);\n gsl_vector_free (state->abscor);\n free (state->errlev);\n free (state->ordprevbackup);\n free (state->ordprev);\n free (state->hprevbackup);\n free (state->hprev);\n free (state->l);\n free (state->ytmp2);\n free (state->ytmp);\n free (state->zbackup);\n free (state->z);\n free (state);\n GSL_ERROR_NULL (\"failed to allocate space for rhs\", GSL_ENOMEM);\n }\n\n msbdf_reset ((void *) state, dim);\n\n state->driver = NULL;\n\n return state;\n}\n\nstatic int\nmsbdf_failurehandler (void *vstate, const size_t dim, const double t)\n{\n /* Internal failure handler routine for msbdf. Adjusted strategy\n for GSL: Decrease order if this is the second time a failure\n has occurred at this order and point.\n */\n\n msbdf_state_t *state = (msbdf_state_t *) vstate;\n\n const size_t ord = state->ord;\n\n if (ord > 1 && (ord - state->ordprev[0] == 0) &&\n ord == state->failord && t == state->failt)\n {\n state->ord--;\n }\n\n /* Save information about failure */\n\n state->failord = ord;\n state->failt = t;\n state->ni++;\n\n /* Force reinitialization if failure took place at lowest\n order \n */\n\n if (ord == 1)\n {\n msbdf_reset (vstate, dim);\n }\n\n return GSL_SUCCESS;\n}\n\nstatic int\nmsbdf_calccoeffs (const size_t ord, const size_t ordwait,\n const double h, const double hprev[],\n double l[],\n double *errcoeff, double *ordm1coeff,\n double *ordp1coeff, double *ordp2coeff, double *gamma)\n{\n /* Calculates coefficients (l) of polynomial Lambda, error and\n auxiliary order change evaluation coefficients.\n */\n\n if (ord == 1)\n {\n l[0] = 1.0;\n l[1] = 1.0;\n *errcoeff = 0.5;\n *ordp1coeff = 2.0;\n\n {\n const double hsum = h + hprev[0];\n \n const double a5 = -1.5;\n const double a6 = -1.0 - h / hsum;\n const double c2 = 2.0 / (1.0 - a6 + a5);\n \n *ordp2coeff = fabs (c2 * (h / hsum) * 3.0 * a5);\n }\n }\n else\n {\n size_t i, j;\n double hsum = h;\n double coeff1 = -1.0;\n double x;\n\n /* Calculate the actual polynomial coefficients (l) */\n\n DBL_ZERO_MEMSET (l, MSBDF_MAX_ORD + 1);\n\n l[0] = 1.0;\n l[1] = 1.0;\n\n for (i = 2; i < ord; i++)\n {\n hsum += hprev[i - 2];\n coeff1 += -1.0 / i;\n\n for (j = i; j > 0; j--)\n {\n l[j] += h / hsum * l[j - 1];\n }\n }\n\n coeff1 += -1.0 / ord;\n\n x = -l[1] - coeff1;\n\n for (i = ord; i > 0; i--)\n {\n l[i] += l[i - 1] * x;\n }\n \n#ifdef DEBUG\n {\n size_t di;\n \n printf (\"-- calccoeffs l: \");\n for (di = 0; di < ord + 1; di++)\n {\n printf (\"%.5e \", l[di]);\n }\n printf (\"\\n\");\n }\n#endif\n\n hsum += hprev[ord - 2];\n\n {\n const double coeff2 = -l[1] - h / hsum;\n const double a1 = 1.0 - coeff2 + coeff1;\n const double a2 = 1.0 + ord * a1;\n\n /* Calculate error coefficient */\n\n *errcoeff = fabs (a1 / (coeff1 * a2));\n\n /* Calculate auxiliary coefficients used in evaluation of change\n of order\n */\n\n if (ordwait < 2)\n {\n const double a3 = coeff1 + 1.0 / ord;\n const double a4 = coeff2 + h / hsum;\n const double c1 = a3 / (1.0 - a4 + a3);\n\n *ordm1coeff = fabs (c1 / (x / l[ord]));\n\n *ordp1coeff = fabs (a2 / (l[ord] * (h / hsum) / x));\n\n hsum += hprev[ord - 1];\n\n {\n const double a5 = coeff1 - 1.0 / (ord + 1.0);\n const double a6 = coeff2 - h / hsum;\n const double c2 = a2 / (1.0 - a6 + a5);\n\n *ordp2coeff = fabs (c2 * (h / hsum) * (ord + 2) * a5);\n }\n }\n }\n }\n\n *gamma = h / l[1];\n\n#ifdef DEBUG\n printf (\"-- calccoeffs ordm1coeff=%.5e \", *ordm1coeff);\n printf (\"ordp1coeff=%.5e \", *ordp1coeff);\n printf (\"ordp2coeff=%.5e \", *ordp2coeff);\n printf (\"errcoeff=%.5e\\n\", *errcoeff);\n#endif\n\n return GSL_SUCCESS;\n}\n\nstatic int\nmsbdf_update (void *vstate, const size_t dim, gsl_matrix * dfdy, double *dfdt,\n const double t, const double *y, const gsl_odeiv2_system * sys,\n gsl_matrix * M, gsl_permutation * p,\n const size_t iter, size_t * nJ, size_t * nM,\n const double tprev, const double failt,\n const double gamma, const double gammaprev, const double hratio)\n{\n /* Evaluates Jacobian dfdy and updates iteration matrix M\n if criteria for update is met.\n */\n\n /* Jacobian is evaluated\n - at first step\n - if MSBDF_JAC_WAIT steps have been made without re-evaluation\n - in case of a convergence failure if\n --- change in gamma is small, or \n --- convergence failure resulted in step size decrease\n */\n\n const double c = 0.2;\n const double gammarel = fabs (gamma / gammaprev - 1.0);\n\n if (*nJ == 0 || *nJ > MSBDF_JAC_WAIT ||\n (t == failt && (gammarel < c || hratio < 1.0)))\n {\n#ifdef DEBUG\n printf (\"-- evaluate jacobian\\n\");\n#endif\n int s = GSL_ODEIV_JA_EVAL (sys, t, y, dfdy->data, dfdt);\n\n if (s == GSL_EBADFUNC)\n {\n return s;\n }\n\n if (s != GSL_SUCCESS)\n {\n msbdf_failurehandler (vstate, dim, t);\n#ifdef DEBUG\n printf (\"-- FAIL at jacobian function evaluation\\n\");\n#endif\n return s;\n }\n\n /* Reset counter */\n\n *nJ = 0;\n }\n\n /* Iteration matrix M (and it's LU decomposition) is generated\n - at first step\n - if MSBDF_M_WAIT steps have been made without an update\n - if change in gamma is significant (e.g. change in step size)\n - if previous step was rejected\n */\n\n if (*nM == 0 || *nM > MSBDF_M_WAIT || gammarel >= c ||\n t == tprev || t == failt)\n {\n#ifdef DEBUG\n printf (\"-- update M, gamma=%.5e\\n\", gamma);\n#endif\n size_t i;\n gsl_matrix_memcpy (M, dfdy);\n gsl_matrix_scale (M, -gamma);\n\n for (i = 0; i < dim; i++)\n {\n gsl_matrix_set (M, i, i, gsl_matrix_get (M, i, i) + 1.0);\n }\n\n {\n int signum;\n int s = gsl_linalg_LU_decomp (M, p, &signum);\n \n if (s != GSL_SUCCESS)\n {\n return GSL_FAILURE;\n }\n }\n\n /* Reset counter */\n\n *nM = 0;\n }\n\n return GSL_SUCCESS;\n}\n\nstatic int\nmsbdf_corrector (void *vstate, const gsl_odeiv2_system * sys,\n const double t, const double h, const size_t dim,\n const double z[], const double errlev[],\n const double l[], const double errcoeff,\n gsl_vector * abscor, gsl_vector * relcor,\n double ytmp[], double ytmp2[],\n gsl_matrix * dfdy, double dfdt[], gsl_matrix * M,\n gsl_permutation * p, gsl_vector * rhs,\n size_t * nJ, size_t * nM,\n const double tprev, const double failt,\n const double gamma, const double gammaprev,\n const double hprev0)\n{\n /* Calculates the correction step (abscor). Equation\n system M = I - gamma * dfdy = -G is solved by Newton iteration.\n */\n\n size_t mi, i;\n const size_t max_iter = 3; /* Maximum number of iterations */\n double convrate = 1.0; /* convergence rate */\n double stepnorm = 0.0; /* norm of correction step */\n double stepnormprev = 0.0; /* previous norm value */\n\n /* Evaluate at predicted values */\n\n {\n int s = GSL_ODEIV_FN_EVAL (sys, t + h, z, ytmp);\n\n if (s == GSL_EBADFUNC)\n {\n return s;\n }\n\n if (s != GSL_SUCCESS)\n {\n msbdf_failurehandler (vstate, dim, t);\n\n#ifdef DEBUG\n printf (\"-- FAIL at user function evaluation\\n\");\n#endif\n return s;\n }\n }\n\n /* Calculate correction step (abscor) */\n\n gsl_vector_set_zero (abscor);\n\n for (mi = 0; mi < max_iter; mi++)\n {\n const double safety = 0.3;\n const double safety2 = 0.1;\n\n /* Generate or update Jacobian and/or iteration matrix M if needed */\n\n if (mi == 0)\n {\n int s = msbdf_update (vstate, dim, dfdy, dfdt, t + h, z,\n sys, M, p, mi,\n nJ, nM, tprev, failt,\n gamma, gammaprev,\n h / hprev0);\n\n if (s != GSL_SUCCESS)\n {\n return s;\n }\n }\n\n /* Evaluate the right hand side (-G) */\n\n for (i = 0; i < dim; i++)\n {\n const double r = -1.0 * gsl_vector_get (abscor, i) -\n z[1 * dim + i] / l[1] + gamma * ytmp[i];\n\n gsl_vector_set (rhs, i, r);\n }\n\n /* Solve system of equations */\n\n {\n int s = gsl_linalg_LU_solve (M, p, rhs, relcor);\n \n if (s != GSL_SUCCESS)\n {\n msbdf_failurehandler (vstate, dim, t);\n \n#ifdef DEBUG\n printf (\"-- FAIL at LU_solve\\n\");\n#endif\n return GSL_FAILURE;\n }\n }\n\n#ifdef DEBUG\n {\n size_t di;\n printf (\"-- dstep: \");\n for (di = 0; di < dim; di++)\n {\n printf (\"%.5e \", gsl_vector_get (relcor, di));\n }\n printf (\"\\n\");\n }\n#endif\n\n /* Add iteration results */\n\n for (i = 0; i < dim; i++)\n {\n const double r =\n gsl_vector_get (abscor, i) + gsl_vector_get (relcor, i);\n\n gsl_vector_set (abscor, i, r);\n\n ytmp2[i] = z[i] + r;\n\n gsl_vector_set (relcor, i, gsl_vector_get (relcor, i) / errlev[i]);\n }\n\n#ifdef DEBUG\n {\n size_t di;\n printf (\"-- abscor: \");\n for (di = 0; di < dim; di++)\n {\n printf (\"%.5e \", gsl_vector_get (abscor, di));\n }\n printf (\"\\n\");\n }\n#endif\n\n /* Convergence test. Norms used are root-mean-square norms. */\n\n stepnorm = gsl_blas_dnrm2 (relcor) / sqrt (dim);\n\n if (mi > 0)\n {\n convrate = GSL_MAX_DBL (safety * convrate, stepnorm / stepnormprev);\n }\n else\n {\n convrate = 1.0;\n }\n\n {\n const double convtest =\n GSL_MIN_DBL (convrate, 1.0) * stepnorm * errcoeff / safety2;\n\n#ifdef DEBUG\n printf\n (\"-- newt iter loop %d, errcoeff=%.5e, stepnorm =%.5e, convrate = %.5e, convtest = %.5e\\n\",\n (int) mi, errcoeff, stepnorm, convrate, convtest);\n#endif\n if (convtest <= 1.0)\n {\n break;\n }\n }\n\n /* Check for divergence during iteration */\n\n {\n const double div_const = 2.0;\n\n if (mi > 1 && stepnorm > div_const * stepnormprev)\n {\n msbdf_failurehandler (vstate, dim, t);\n\n#ifdef DEBUG\n printf (\"-- FAIL, diverging Newton iteration\\n\");\n#endif\n return GSL_FAILURE;\n }\n }\n\n /* Evaluate at new y */\n\n {\n int s = GSL_ODEIV_FN_EVAL (sys, t + h, ytmp2, ytmp);\n\n if (s == GSL_EBADFUNC)\n {\n return s;\n }\n\n if (s != GSL_SUCCESS)\n {\n msbdf_failurehandler (vstate, dim, t);\n\n#ifdef DEBUG\n printf (\"-- FAIL at user function evaluation\\n\");\n#endif\n return s;\n }\n }\n\n stepnormprev = stepnorm;\n }\n\n#ifdef DEBUG\n printf (\"-- Newton iteration exit at mi=%d\\n\", (int) mi);\n#endif\n\n /* Handle convergence failure */\n\n if (mi == max_iter)\n {\n msbdf_failurehandler (vstate, dim, t);\n\n#ifdef DEBUG\n printf (\"-- FAIL, max_iter reached\\n\");\n#endif\n return GSL_FAILURE;\n }\n\n return GSL_SUCCESS;\n}\n\nstatic int\nmsbdf_eval_order (gsl_vector * abscor, gsl_vector * tempvec,\n gsl_vector * svec, const double errcoeff,\n const size_t dim, const double errlev[],\n const double ordm1coeff, const double ordp1coeff,\n const double ordp1coeffprev, const double ordp2coeff,\n const double hprev[],\n const double h, const double z[],\n size_t * ord, size_t * ordwait)\n{\n /* Evaluates and executes change in method order (current, current-1\n or current+1). Order which maximizes the step length is selected.\n */\n\n size_t i;\n\n /* step size estimates at current order, order-1 and order+1 */\n double ordest = 0.0;\n double ordm1est = 0.0;\n double ordp1est = 0.0;\n\n const double safety = 1e-6;\n const double bias = 6.0;\n const double bias2 = 10.0;\n const double min_incr = 1.5;\n\n /* Relative step length estimate for current order */\n\n ordest = 1.0 / (pow (bias * gsl_blas_dnrm2 (abscor) / sqrt (dim)\n * errcoeff, 1.0 / (*ord + 1)) + safety);\n\n /* Relative step length estimate for order ord - 1 */\n\n if (*ord > 1)\n {\n for (i = 0; i < dim; i++)\n {\n gsl_vector_set (tempvec, i, z[*ord * dim + i] / errlev[i]);\n }\n\n ordm1est = 1.0 / (pow (bias * gsl_blas_dnrm2 (tempvec) / sqrt (dim)\n / ordm1coeff, 1.0 / (*ord)) + safety);\n }\n else\n {\n ordm1est = 0.0;\n }\n\n /* Relative step length estimate for order ord + 1 */\n\n if (*ord < MSBDF_MAX_ORD)\n {\n const double c = -ordp1coeff / ordp1coeffprev *\n pow (h / hprev[1], *ord + 1);\n\n for (i = 0; i < dim; i++)\n {\n gsl_vector_set (svec, i, gsl_vector_get (svec, i) * c +\n gsl_vector_get (abscor, i));\n }\n\n ordp1est = 1.0 / (pow (bias2 * gsl_blas_dnrm2 (svec) / sqrt (dim)\n / ordp2coeff, 1.0 / (*ord + 2)) + safety);\n }\n else\n {\n ordp1est = 0.0;\n }\n\n#ifdef DEBUG\n printf\n (\"-- eval_order ord=%d, ordest=%.5e, ordm1est=%.5e, ordp1est=%.5e\\n\",\n (int) *ord, ordest, ordm1est, ordp1est);\n#endif\n\n /* Choose order that maximises step size and increases step\n size markedly compared to current step \n */\n\n if (ordm1est > ordest && ordm1est > ordp1est && ordm1est > min_incr)\n {\n *ord -= 1;\n#ifdef DEBUG\n printf (\"-- eval_order order DECREASED to %d\\n\", (int) *ord);\n#endif\n }\n\n else if (ordp1est > ordest && ordp1est > ordm1est && ordp1est > min_incr)\n {\n *ord += 1;\n#ifdef DEBUG\n printf (\"-- eval_order order INCREASED to %d\\n\", (int) *ord);\n#endif\n }\n\n *ordwait = *ord + 2;\n\n return GSL_SUCCESS;\n}\n\nstatic int\nmsbdf_check_no_order_decrease (size_t const ordprev[])\n{\n /* Checks if order has not been decreased according to order history\n array. Used in stability enhancement.\n */\n\n size_t i;\n\n for (i = 0; i < MSBDF_MAX_ORD - 1; i++)\n {\n if (ordprev[i + 1] > ordprev[i])\n {\n return 0;\n }\n }\n\n return 1;\n}\n\nstatic int\nmsbdf_check_step_size_decrease (double const hprev[])\n{\n /* Checks if step size has decreased markedly according to\n step size history array. Used in stability enhancement.\n */\n\n size_t i;\n double max = fabs (hprev[0]);\n const double min = fabs (hprev[0]);\n const double decrease_limit = 0.5;\n\n for (i = 1; i < MSBDF_MAX_ORD; i++)\n {\n const double h = fabs (hprev[i]);\n\n if (h > min && h > max)\n {\n max = h;\n }\n }\n\n if (min / max < decrease_limit)\n {\n return 1;\n }\n\n return 0;\n}\n\nstatic int\nmsbdf_apply (void *vstate, size_t dim, double t, double h,\n double y[], double yerr[],\n const double dydt_in[], double dydt_out[],\n const gsl_odeiv2_system * sys)\n{\n /* Carries out a step by BDF linear multistep methods. */\n\n msbdf_state_t *state = (msbdf_state_t *) vstate;\n\n double *const z = state->z;\n double *const zbackup = state->zbackup;\n double *const ytmp = state->ytmp;\n double *const ytmp2 = state->ytmp2;\n double *const l = state->l;\n double *const hprev = state->hprev;\n double *const hprevbackup = state->hprevbackup;\n size_t *const ordprev = state->ordprev;\n size_t *const ordprevbackup = state->ordprevbackup;\n double *const errlev = state->errlev;\n gsl_vector *const abscor = state->abscor;\n gsl_vector *const relcor = state->relcor;\n gsl_vector *const svec = state->svec;\n gsl_vector *const tempvec = state->tempvec;\n\n size_t ord = state->ord; /* order for this step */\n double ordm1coeff = 0.0;\n double ordp1coeff = 0.0;\n double ordp2coeff = 0.0;\n double errcoeff = 0.0; /* error coefficient */\n double gamma = 0.0; /* gamma coefficient */\n\n const size_t max_failcount = 3;\n size_t i;\n\n#ifdef DEBUG\n {\n size_t di;\n\n printf (\"msbdf_apply: t=%.5e, ord=%d, h=%.5e, y:\", t, (int) ord, h);\n\n for (di = 0; di < dim; di++)\n {\n printf (\"%.5e \", y[di]);\n }\n printf (\"\\n\");\n }\n#endif\n\n /* Check if t is the same as on previous stepper call (or last\n failed call). This means that calculation of previous step failed\n or the step was rejected, and therefore previous state will be\n restored or the method will be reset.\n */\n\n if (state->ni > 0 && (t == state->tprev || t == state->failt))\n {\n if (state->ni == 1)\n {\n /* No step has been accepted yet, reset method */\n\n msbdf_reset (vstate, dim);\n#ifdef DEBUG\n printf (\"-- first step was REJECTED, msbdf_reset called\\n\");\n#endif\n }\n else\n {\n /* A succesful step has been saved, restore previous state. */\n\n /* If previous step suggests order increase, but the step was\n rejected, then do not increase order.\n */\n\n if (ord > ordprev[0])\n {\n state->ord = ordprev[0];\n ord = state->ord;\n }\n\n /* Restore previous state */\n\n DBL_MEMCPY (z, zbackup, (MSBDF_MAX_ORD + 1) * dim);\n DBL_MEMCPY (hprev, hprevbackup, MSBDF_MAX_ORD);\n\n for (i = 0; i < MSBDF_MAX_ORD; i++)\n {\n ordprev[i] = ordprevbackup[i];\n }\n\n state->ordwait = state->ordwaitbackup;\n state->gammaprev = state->gammaprevbackup;\n\n#ifdef DEBUG\n printf (\"-- previous step was REJECTED, state restored\\n\");\n#endif\n }\n\n /* If step is repeatedly rejected, then reset method */\n\n state->failcount++;\n\n if (state->failcount > max_failcount && state->ni > 1)\n {\n msbdf_reset (vstate, dim);\n ord = state->ord;\n\n#ifdef DEBUG\n printf (\"-- max_failcount reached, msbdf_reset called\\n\");\n#endif\n }\n }\n else\n {\n /* The previous step was accepted. Backup current state. */\n\n DBL_MEMCPY (zbackup, z, (MSBDF_MAX_ORD + 1) * dim);\n DBL_MEMCPY (hprevbackup, hprev, MSBDF_MAX_ORD);\n\n for (i = 0; i < MSBDF_MAX_ORD; i++)\n {\n ordprevbackup[i] = ordprev[i];\n }\n\n state->ordwaitbackup = state->ordwait;\n state->gammaprevbackup = state->gammaprev;\n\n state->failcount = 0;\n\n#ifdef DEBUG\n if (state->ni > 0)\n {\n printf (\"-- previous step was ACCEPTED, state saved\\n\");\n }\n#endif\n }\n\n#ifdef DEBUG\n printf (\"-- ord=%d, ni=%ld, ordwait=%d\\n\", (int) ord, state->ni,\n (int) state->ordwait);\n\n size_t di;\n printf (\"-- ordprev: \");\n\n for (di = 0; di < MSBDF_MAX_ORD; di++)\n {\n printf (\"%d \", (int) ordprev[di]);\n }\n\n printf (\"\\n\");\n#endif\n\n /* Get desired error levels via gsl_odeiv2_control object through driver\n object, which is a requirement for this stepper.\n */\n\n if (state->driver == NULL)\n {\n return GSL_EFAULT;\n }\n else\n {\n size_t i;\n\n for (i = 0; i < dim; i++)\n {\n if (dydt_in != NULL)\n {\n gsl_odeiv2_control_errlevel (state->driver->c, y[i],\n dydt_in[i], h, i, &errlev[i]);\n }\n else\n {\n gsl_odeiv2_control_errlevel (state->driver->c, y[i],\n 0.0, h, i, &errlev[i]);\n }\n }\n }\n\n#ifdef DEBUG\n {\n size_t di;\n printf (\"-- errlev: \");\n for (di = 0; di < dim; di++)\n {\n printf (\"%.5e \", errlev[di]);\n }\n printf (\"\\n\");\n }\n#endif\n\n /* On first call initialize Nordsieck matrix */\n\n if (state->ni == 0)\n {\n size_t i;\n\n DBL_ZERO_MEMSET (z, (MSBDF_MAX_ORD + 1) * dim);\n\n if (dydt_in != NULL)\n {\n DBL_MEMCPY (ytmp, dydt_in, dim);\n }\n else\n {\n int s = GSL_ODEIV_FN_EVAL (sys, t, y, ytmp);\n\n if (s != GSL_SUCCESS)\n {\n return s;\n }\n }\n\n DBL_MEMCPY (&z[0 * dim], y, dim);\n DBL_MEMCPY (&z[1 * dim], ytmp, dim);\n\n for (i = 0; i < dim; i++)\n {\n z[1 * dim + i] *= h;\n }\n }\n\n /* Stability enhancement heuristic for msbdf: If order > 1 and order\n has not been changed, check for decrease in step size, that is\n not accompanied by a decrease in method order. This condition may\n be indication of BDF method stability problems, a change in ODE\n system, or convergence problems in Newton iteration. In all\n cases, the strategy is to decrease method order.\n */\n\n#ifdef DEBUG\n printf (\"-- check_no_order_decrease %d, check_step_size_decrease %d\\n\",\n msbdf_check_no_order_decrease (ordprev),\n msbdf_check_step_size_decrease (hprev));\n#endif\n\n if (ord > 1 &&\n ord - ordprev[0] == 0 &&\n msbdf_check_no_order_decrease (ordprev) &&\n msbdf_check_step_size_decrease (hprev))\n {\n state->ord--;\n state->ordwait = ord + 2;\n ord = state->ord;\n\n#ifdef DEBUG\n printf (\"-- stability enhancement decreased order to %d\\n\", (int) ord);\n#endif\n }\n\n /* Sanity check */\n\n { \n const int deltaord = ord - ordprev[0];\n\n if (deltaord > 1 || deltaord < -1)\n {\n printf (\"-- order change %d\\n\", deltaord);\n GSL_ERROR_NULL (\"msbdf_apply too large order change\", GSL_ESANITY);\n }\n\n /* Modify Nordsieck matrix if order or step length has been changed */\n\n /* If order increased by 1, adjust Nordsieck matrix */\n\n if (deltaord == 1)\n {\n if (ord > 2)\n {\n size_t i, j;\n double hsum = h;\n double coeff1 = -1.0;\n double coeff2 = 1.0;\n double hrelprev = 1.0;\n double hrelprod = 1.0;\n double hrel = 0.0;\n\n /* Calculate coefficients used in adjustment to l */\n\n DBL_ZERO_MEMSET (l, MSBDF_MAX_ORD + 1);\n\n l[2] = 1.0;\n\n for (i = 1; i < ord - 1; i++)\n {\n hsum += hprev[i];\n hrel = hsum / h;\n hrelprod *= hrel;\n coeff1 -= 1.0 / (i + 1);\n coeff2 += 1.0 / hrel;\n\n for (j = i + 2; j > 1; j--)\n {\n l[j] *= hrelprev;\n l[j] += l[j - 1];\n }\n\n hrelprev = hrel;\n }\n\n /* Scale Nordsieck matrix */\n\n {\n const double c = (-coeff1 - coeff2) / hrelprod;\n\n for (i = 0; i < dim; i++)\n {\n z[ord * dim + i] = c * gsl_vector_get (abscor, i);\n }\n }\n for (i = 2; i < ord; i++)\n for (j = 0; j < dim; j++)\n {\n z[i * dim + j] += l[i] * z[ord * dim + j];\n }\n }\n else\n {\n /* zero new vector for order incease from 1 to 2 */\n\n DBL_ZERO_MEMSET (&z[ord * dim], dim);\n }\n\n#ifdef DEBUG\n printf (\"-- order increase detected, Nordsieck modified\\n\");\n#endif\n }\n\n /* If order decreased by 1, adjust Nordsieck matrix */\n\n if (deltaord == -1)\n {\n size_t i, j;\n double hsum = 0.0;\n\n /* Calculate coefficients used in adjustment to l */\n\n DBL_ZERO_MEMSET (l, MSBDF_MAX_ORD + 1);\n\n l[2] = 1.0;\n\n for (i = 1; i < ord; i++)\n {\n hsum += hprev[i - 1];\n\n for (j = i + 2; j > 1; j--)\n {\n l[j] *= hsum / h;\n l[j] += l[j - 1];\n }\n }\n\n /* Scale Nordsieck matrix */\n\n for (i = 2; i < ord + 1; i++)\n for (j = 0; j < dim; j++)\n {\n z[i * dim + j] += -l[i] * z[(ord + 1) * dim + j];\n }\n\n#ifdef DEBUG\n printf (\"-- order decrease detected, Nordsieck modified\\n\");\n#endif\n }\n\n /* Scale Nordsieck vectors if step size has been changed */\n\n if (state->ni > 0 && h != hprev[0])\n {\n size_t i, j;\n const double hrel = h / hprev[0];\n double coeff = hrel;\n\n for (i = 1; i < ord + 1; i++)\n {\n for (j = 0; j < dim; j++)\n {\n z[i * dim + j] *= coeff;\n }\n\n coeff *= hrel;\n }\n\n#ifdef DEBUG\n printf (\"-- h != hprev, Nordsieck modified\\n\");\n#endif\n }\n\n /* Calculate polynomial coefficients (l), error coefficient and\n auxiliary coefficients\n */\n\n msbdf_calccoeffs (ord, state->ordwait, h, hprev, l, &errcoeff,\n º1coeff, &ordp1coeff, &ordp2coeff, &gamma);\n\n /* Carry out the prediction step */\n\n {\n size_t i, j, k;\n\n for (i = 1; i < ord + 1; i++)\n for (j = ord; j > i - 1; j--)\n for (k = 0; k < dim; k++)\n {\n z[(j - 1) * dim + k] += z[j * dim + k];\n }\n\n#ifdef DEBUG\n {\n size_t di;\n printf (\"-- predicted y: \");\n for (di = 0; di < dim; di++)\n {\n printf (\"%.5e \", z[di]);\n }\n printf (\"\\n\");\n }\n#endif\n }\n\n /* Calculate correction step to abscor */\n {\n int s;\n s = msbdf_corrector (vstate, sys, t, h, dim, z, errlev, l, errcoeff,\n abscor, relcor, ytmp, ytmp2,\n state->dfdy, state->dfdt, state->M,\n state->p, state->rhs,\n &(state->nJ), &(state->nM),\n state->tprev, state->failt, gamma,\n state->gammaprev, hprev[0]);\n\n if (s != GSL_SUCCESS)\n {\n return s;\n }\n }\n\n {\n /* Add accepted final correction step to Nordsieck matrix */\n\n size_t i, j;\n\n for (i = 0; i < ord + 1; i++)\n for (j = 0; j < dim; j++)\n {\n z[i * dim + j] += l[i] * gsl_vector_get (abscor, j);\n }\n\n#ifdef DEBUG\n {\n size_t di;\n printf (\"---- l: \");\n for (di = 0; di < ord + 1; di++)\n {\n printf (\"%.5e \", l[di]);\n }\n printf (\"\\n\");\n\n printf (\"-- corrected y: \");\n for (di = 0; di < dim; di++)\n {\n printf (\"%.5e \", z[di]);\n }\n printf (\"\\n\");\n }\n#endif\n\n /* Derivatives at output */\n\n if (dydt_out != NULL)\n {\n int s = GSL_ODEIV_FN_EVAL (sys, t + h, z, dydt_out);\n\n if (s == GSL_EBADFUNC)\n {\n return s;\n }\n\n if (s != GSL_SUCCESS)\n {\n msbdf_failurehandler (vstate, dim, t);\n\n#ifdef DEBUG\n printf (\"-- FAIL at user function evaluation\\n\");\n#endif\n return s;\n }\n }\n\n /* Calculate error estimate */\n\n for (i = 0; i < dim; i++)\n {\n yerr[i] = fabs (gsl_vector_get (abscor, i)) * errcoeff;\n }\n\n#ifdef DEBUG\n {\n size_t di;\n printf (\"-- yerr: \");\n for (di = 0; di < dim; di++)\n {\n printf (\"%.5e \", yerr[di]);\n }\n printf (\"\\n\");\n }\n#endif\n\n /* Save y values */\n\n for (i = 0; i < dim; i++)\n {\n y[i] = z[0 * dim + i];\n }\n }\n\n /* Scale abscor with errlev for later use in norm calculations */\n {\n size_t i;\n\n for (i = 0; i < dim; i++)\n {\n gsl_vector_set (abscor, i, gsl_vector_get (abscor, i) / errlev[i]);\n }\n }\n\n /* Save items needed for evaluation of order increase on next\n call, if needed\n */\n\n if (state->ordwait == 1 && ord < MSBDF_MAX_ORD)\n {\n size_t i;\n\n state->ordp1coeffprev = ordp1coeff;\n\n for (i = 0; i < dim; i++)\n {\n gsl_vector_set (svec, i, gsl_vector_get (abscor, i));\n }\n }\n\n /* Consider and execute order change for next step */\n\n if (state->ordwait == 0)\n {\n msbdf_eval_order (abscor, tempvec, svec, errcoeff, dim, errlev,\n ordm1coeff, ordp1coeff,\n state->ordp1coeffprev, ordp2coeff,\n hprev, h, z, &(state->ord), &(state->ordwait));\n }\n\n /* Undo scaling of abscor for possible order increase on next step */\n {\n size_t i;\n \n for (i = 0; i < dim; i++)\n {\n gsl_vector_set (abscor, i, gsl_vector_get (abscor, i) * errlev[i]);\n }\n }\n \n /* Save information about current step in state and update counters */\n {\n size_t i;\n \n for (i = MSBDF_MAX_ORD - 1; i > 0; i--)\n {\n hprev[i] = hprev[i - 1];\n ordprev[i] = ordprev[i - 1];\n }\n }\n \n hprev[0] = h;\n ordprev[0] = ord;\n \n#ifdef DEBUG\n {\n size_t di;\n printf (\"-- hprev: \");\n for (di = 0; di < MSBDF_MAX_ORD; di++)\n {\n printf (\"%.5e \", hprev[di]);\n }\n printf (\"\\n\");\n }\n#endif\n \n state->tprev = t;\n state->ordwait--;\n state->ni++;\n state->gammaprev = gamma;\n \n state->nJ++;\n state->nM++;\n \n#ifdef DEBUG\n printf (\"-- nJ=%d, nM=%d\\n\", (int) state->nJ, (int) state->nM);\n#endif\n }\n\n return GSL_SUCCESS;\n}\n\nstatic int\nmsbdf_set_driver (void *vstate, const gsl_odeiv2_driver * d)\n{\n msbdf_state_t *state = (msbdf_state_t *) vstate;\n\n state->driver = d;\n\n return GSL_SUCCESS;\n}\n\nstatic int\nmsbdf_reset (void *vstate, size_t dim)\n{\n msbdf_state_t *state = (msbdf_state_t *) vstate;\n size_t i;\n\n state->ni = 0;\n state->ord = 1;\n state->ordwait = 2;\n state->ordwaitbackup = 2;\n state->failord = 0;\n state->failt = GSL_NAN;\n state->gammaprev = 1.0;\n state->nJ = 0;\n state->nM = 0;\n state->failcount = 0;\n\n DBL_ZERO_MEMSET (state->hprev, MSBDF_MAX_ORD);\n DBL_ZERO_MEMSET (state->hprevbackup, MSBDF_MAX_ORD);\n DBL_ZERO_MEMSET (state->z, (MSBDF_MAX_ORD + 1) * dim);\n DBL_ZERO_MEMSET (state->zbackup, (MSBDF_MAX_ORD + 1) * dim);\n\n for (i = 0; i < MSBDF_MAX_ORD; i++)\n {\n state->ordprev[i] = 1;\n state->ordprevbackup[i] = 1;\n }\n\n#ifdef DEBUG\n printf (\"-- msbdf_reset called\\n\");\n#endif\n\n return GSL_SUCCESS;\n}\n\nstatic unsigned int\nmsbdf_order (void *vstate)\n{\n msbdf_state_t *state = (msbdf_state_t *) vstate;\n\n return state->ord;\n}\n\nstatic void\nmsbdf_free (void *vstate)\n{\n msbdf_state_t *state = (msbdf_state_t *) vstate;\n\n gsl_vector_free (state->rhs);\n gsl_permutation_free (state->p);\n gsl_matrix_free (state->M);\n free (state->dfdt);\n gsl_matrix_free (state->dfdy);\n gsl_vector_free (state->tempvec);\n gsl_vector_free (state->svec);\n gsl_vector_free (state->relcor);\n gsl_vector_free (state->abscor);\n free (state->errlev);\n free (state->ordprevbackup);\n free (state->ordprev);\n free (state->hprevbackup);\n free (state->hprev);\n free (state->l);\n free (state->ytmp2);\n free (state->ytmp);\n free (state->zbackup);\n free (state->z);\n free (state);\n}\n\nstatic const gsl_odeiv2_step_type msbdf_type = {\n \"msbdf\", /* name */\n 1, /* can use dydt_in? */\n 1, /* gives exact dydt_out? */\n &msbdf_alloc,\n &msbdf_apply,\n &msbdf_set_driver,\n &msbdf_reset,\n &msbdf_order,\n &msbdf_free\n};\n\nconst gsl_odeiv2_step_type *gsl_odeiv2_step_msbdf = &msbdf_type;\n", "meta": {"hexsha": "d6f28737d5425cb725d95ccd8112884aabd33f57", "size": 44463, "ext": "c", "lang": "C", "max_stars_repo_path": "Integration/gsl-1.15/ode-initval2/msbdf.c", "max_stars_repo_name": "WikiGaze/Wikipedia-readers-gaze", "max_stars_repo_head_hexsha": "b723fcad149662a9af981c4e507678d9c7f106d2", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Integration/gsl-1.15/ode-initval2/msbdf.c", "max_issues_repo_name": "WikiGaze/Wikipedia-readers-gaze", "max_issues_repo_head_hexsha": "b723fcad149662a9af981c4e507678d9c7f106d2", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Integration/gsl-1.15/ode-initval2/msbdf.c", "max_forks_repo_name": "WikiGaze/Wikipedia-readers-gaze", "max_forks_repo_head_hexsha": "b723fcad149662a9af981c4e507678d9c7f106d2", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 25.0495774648, "max_line_length": 101, "alphanum_fraction": 0.5369183366, "num_tokens": 12851, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8688267660487573, "lm_q2_score": 0.5813030906443133, "lm_q1q2_score": 0.5050516843386463}} {"text": "/*\n** Copyright (C) 2004 Jonathan G. Underwood \n** \n** This program is free software; you can redistribute it and/or modify\n** it under the terms of the GNU General Public License as published by\n** the Free Software Foundation; either version 3 of the License, or\n** (at your option) any later version.\n** \n** This program is distributed in the hope that it will be useful,\n** but WITHOUT ANY WARRANTY; without even the implied warranty of\n** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n** GNU General Public License for more details.\n** \n** You should have received a copy of the GNU General Public License\n** along with this program; if not, write to the Free Software \n** Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n*/\n\n#ifndef __GSL_SF_WIGNER_H__\n#define __GSL_SF_WIGNER_H__ 1\n#include \n\n#undef __BEGIN_DECLS\n#undef __END_DECLS\n#ifdef __cplusplus\n# define __BEGIN_DECLS extern \"C\" {\n# define __END_DECLS }\n#else\n# define __BEGIN_DECLS /* empty */\n# define __END_DECLS /* empty */\n#endif\n\n__BEGIN_DECLS\n double gsl_sf_wigner_3j (const int two_j1, const int two_j2,\n const int two_j3, const int two_m1,\n const int two_m2, const int two_m3);\nint gsl_sf_wigner_3j_e (const int two_j1, const int two_j2, const int two_j3,\n const int two_m1, const int two_m2, const int two_m3,\n gsl_sf_result * result);\n\ndouble gsl_sf_wigner_6j (const int two_j1, const int two_j2, const int two_j3,\n const int two_j4, const int two_j5,\n const int two_j6);\nint gsl_sf_wigner_6j_e (const int two_j1, const int two_j2, const int two_j3,\n const int two_j4, const int two_j5, const int two_j6,\n gsl_sf_result * result);\n\ndouble gsl_sf_wigner_9j (const int two_j1, const int two_j2, const int two_j3,\n const int two_j4, const int two_j5, const int two_j6,\n const int two_j7, const int two_j8,\n const int two_j9);\nint gsl_sf_wigner_9j_e (const int two_j1, const int two_j2, const int two_j3,\n const int two_j4, const int two_j5, const int two_j6,\n const int two_j7, const int two_j8, const int two_j9,\n gsl_sf_result * result);\n\ndouble gsl_sf_wigner_drot (const int two_j, const int two_m1,\n const int two_m2, const double theta);\nint gsl_sf_wigner_drot_e (const int two_j, const int two_m1, const int two_m2,\n const double theta, gsl_sf_result * result);\n\n__END_DECLS\n#endif /* __GSL_SF_WIGNER_H__ */\n", "meta": {"hexsha": "4585bcfc883683af48333761179546ef7f6c61e3", "size": 2784, "ext": "h", "lang": "C", "max_stars_repo_path": "include/gsl/wigner.h", "max_stars_repo_name": "vinej/sml", "max_stars_repo_head_hexsha": "115c007926ca80d51a37cdf887b5252338d8bc8d", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-06-14T11:51:37.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-14T11:51:37.000Z", "max_issues_repo_path": "include/gsl/wigner.h", "max_issues_repo_name": "vinej/sml", "max_issues_repo_head_hexsha": "115c007926ca80d51a37cdf887b5252338d8bc8d", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "include/gsl/wigner.h", "max_forks_repo_name": "vinej/sml", "max_forks_repo_head_hexsha": "115c007926ca80d51a37cdf887b5252338d8bc8d", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-01-20T16:22:57.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-14T12:31:02.000Z", "avg_line_length": 43.5, "max_line_length": 81, "alphanum_fraction": 0.6530172414, "num_tokens": 705, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7090191337850933, "lm_q2_score": 0.7122321720225278, "lm_q1q2_score": 0.5049862376612881}} {"text": "#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \"kjg_gsl.h\"\n\nvoid\nkjg_gsl_matrix_fprintf (FILE * stream, gsl_matrix * m, const char *template)\n{\n size_t i, j;\n for (i = 0; i < m->size1; i++)\n {\n fprintf (stream, template, gsl_matrix_get (m, i, 0));\n for (j = 1; j < m->size2; j++)\n\t{\n\t fprintf (stream, \"\\t\");\n\t fprintf (stream, template, gsl_matrix_get (m, i, j));\n\t}\n fprintf (stream, \"\\n\");\n }\n}\n\nvoid\nkjg_gsl_matrix_fscanf (FILE * stream, gsl_matrix * m)\n{\n size_t i, j;\n double x;\n for (i = 0; i < m->size1; i++)\n {\n for (j = 0; j < m->size2; j++)\n\t{\n\t fscanf (stream, \"%lg\", &x);\n\t gsl_matrix_set (m, i, j, x);\n\t}\n }\n}\n\nvoid\nkjg_gsl_evec_fprintf (FILE * stream,\n\t\t gsl_vector * eval,\n\t\t gsl_matrix * evec, const char *template)\n{\n size_t i, j;\n fprintf (stream, \"#\");\n fprintf (stream, template, gsl_vector_get (eval, 0));\n for (i = 1; i < eval->size; i++)\n {\n fprintf (stream, \"\\t\");\n fprintf (stream, template, gsl_vector_get (eval, i));\n }\n fprintf (stream, \"\\n\");\n kjg_gsl_matrix_fprintf (stream, evec, template);\n}\n\nint\nkjg_gsl_evec_fscanf (FILE * stream, gsl_vector * eval, gsl_matrix * evec)\n{\n size_t i, j;\n int r;\n double x;\n\n r = fscanf (stream, \"#%lg\", &x);\n if (r != 1)\n return (r);\n gsl_vector_set (eval, 0, x);\n\n for (i = 1; i < eval->size; i++)\n {\n r = fscanf (stream, \"%lg\", &x);\n if (r != 1)\n\treturn (r);\n gsl_vector_set (eval, i, x);\n }\n\n for (i = 0; i < evec->size1; i++)\n {\n for (j = 0; j < evec->size2; j++)\n\t{\n\t r = fscanf (stream, \"%lg\", &x);\n\t if (r != 1)\n\t return (r);\n\t gsl_matrix_set (evec, i, j, x);\n\t}\n }\n\n return (0);\n}\n\ngsl_rng *\nkjg_gsl_rng_init ()\n{\n const gsl_rng_type *T;\n gsl_rng *r;\n extern long seed;\n\n gsl_rng_env_setup ();\n\n gsl_rng_default_seed = seed;\n\n T = gsl_rng_default;\n r = gsl_rng_alloc (T);\n\n// fprintf (stderr, \"generator type: %s\\n\", gsl_rng_name (r));\n// fprintf (stderr, \"seed = %lu\\n\", gsl_rng_default_seed);\n\n return (r);\n}\n\nint\nkjg_gsl_matrix_frobenius_normalize (gsl_matrix * m)\n{\n double s = kjg_gsl_dlange ('F', m);\n double d = m->size1 * m->size2;\n return (gsl_matrix_scale (m, d / s));\n}\n\ndouble\nkjg_gsl_dlange (const char norm, const gsl_matrix * m)\n{\n return (LAPACKE_dlange (LAPACK_ROW_MAJOR, norm, m->size1, m->size2, m->data,\n\t\t\t m->tda));\n}\n\nint\nkjg_gsl_dgeqrf (gsl_matrix * m, gsl_vector * tau)\n{\n return (LAPACKE_dgeqrf (LAPACK_ROW_MAJOR, m->size1, m->size2, m->data,\n\t\t\t m->tda, tau->data));\n}\n\nint\nkjg_gsl_dorgqr (gsl_matrix * m, gsl_vector * tau)\n{\n return (LAPACKE_dorgqr (LAPACK_ROW_MAJOR, m->size2, m->size2, m->size2,\n\t\t\t m->data, m->tda, tau->data));\n}\n\nvoid\nkjg_gsl_ran_ugaussian_pair (const gsl_rng * r, double x[2])\n{\n double r2;\n\n do\n {\n /* choose x,y in uniform square (-1,-1) to (+1,+1) */\n x[0] = -1 + 2 * gsl_rng_uniform_pos (r);\n x[1] = -1 + 2 * gsl_rng_uniform_pos (r);\n\n /* see if it is in the unit circle */\n r2 = x[0] * x[0] + x[1] * x[1];\n }\n while (r2 > 1.0 || r2 == 0);\n\n r2 = sqrt (-2.0 * log (r2) / r2);\n\n x[0] *= r2;\n x[1] *= r2;\n}\n\nvoid\nkjg_gsl_ran_ugaussian_matrix (const gsl_rng * r, gsl_matrix * m)\n{\n size_t i, j;\n double *data;\n double x, y, r2;\n\n for (i = 0; i < m->size1; i++)\n {\n data = gsl_matrix_ptr (m, i, 0);\n\n for (j = 0; j < m->size2 - 1; j += 2)\n\t{\n\t kjg_gsl_ran_ugaussian_pair (r, data);\n\t data += 2;\n\t}\n\n if (m->size2 % 2)\n\t*data = gsl_rng_uniform_pos (r);\n }\n}\n\nvoid\nkjg_gsl_matrix_QR (gsl_matrix * m)\n{\n gsl_vector *tau = gsl_vector_alloc (m->size2);\n kjg_gsl_dgeqrf (m, tau);\n kjg_gsl_dorgqr (m, tau);\n gsl_vector_free (tau);\n}\n\nint\nkjg_gsl_SVD (gsl_matrix * M, gsl_matrix * V, gsl_vector * S)\n{\n size_t big_enough = M->size1 + V->size2;\n double *superb = malloc (big_enough * sizeof (double));\n double *U;\n int info = LAPACKE_dgesvd (LAPACK_ROW_MAJOR,\t// row major\n\t\t\t 'O', 'S', M->size1, M->size2, M->data, M->tda,\n\t\t\t S->data, U,\n\t\t\t big_enough, V->data, V->tda, superb);\n free (superb);\n return (info);\n}\n", "meta": {"hexsha": "980815b03bf0aa5ce0ea6127bd05d4c19e3c0057", "size": 4218, "ext": "c", "lang": "C", "max_stars_repo_path": "src/ksrc/kjg_gsl.c", "max_stars_repo_name": "nevrome/EIG", "max_stars_repo_head_hexsha": "f7b857d4d347d44c57f70194bb4588fad5b1ffed", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 142.0, "max_stars_repo_stars_event_min_datetime": "2015-03-12T07:58:32.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-29T14:29:55.000Z", "max_issues_repo_path": "src/ksrc/kjg_gsl.c", "max_issues_repo_name": "nevrome/EIG", "max_issues_repo_head_hexsha": "f7b857d4d347d44c57f70194bb4588fad5b1ffed", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": 73.0, "max_issues_repo_issues_event_min_datetime": "2016-03-27T14:57:04.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-30T11:30:51.000Z", "max_forks_repo_path": "src/ksrc/kjg_gsl.c", "max_forks_repo_name": "nevrome/EIG", "max_forks_repo_head_hexsha": "f7b857d4d347d44c57f70194bb4588fad5b1ffed", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 63.0, "max_forks_repo_forks_event_min_datetime": "2015-04-20T08:57:41.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-31T18:57:58.000Z", "avg_line_length": 20.0857142857, "max_line_length": 78, "alphanum_fraction": 0.5810810811, "num_tokens": 1569, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.743167997235783, "lm_q2_score": 0.679178692681616, "lm_q1q2_score": 0.5047438688054139}} {"text": "/* specfunc/gsl_sf_mathieu.h\n * \n * Copyright (C) 2002 Lowell Johnson\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.\n */\n\n/* Author: L. Johnson */\n\n#ifndef __GSL_SF_MATHIEU_H__\n#define __GSL_SF_MATHIEU_H__\n\n#if !defined( GSL_FUN )\n# if !defined( GSL_DLL )\n# define GSL_FUN extern\n# elif defined( BUILD_GSL_DLL )\n# define GSL_FUN extern __declspec(dllexport)\n# else\n# define GSL_FUN extern __declspec(dllimport)\n# endif\n#endif\n\n#include \n#include \n\n#undef __BEGIN_DECLS\n#undef __END_DECLS\n#ifdef __cplusplus\n# define __BEGIN_DECLS extern \"C\" {\n# define __END_DECLS }\n#else\n# define __BEGIN_DECLS /* empty */\n# define __END_DECLS /* empty */\n#endif\n\n__BEGIN_DECLS\n\n#define GSL_SF_MATHIEU_COEFF 100\n\ntypedef struct \n{\n size_t size;\n size_t even_order;\n size_t odd_order;\n int extra_values;\n double qa; /* allow for caching of results: not implemented yet */\n double qb; /* allow for caching of results: not implemented yet */\n double *aa;\n double *bb;\n double *dd;\n double *ee;\n double *tt;\n double *e2;\n double *zz;\n gsl_vector *eval;\n gsl_matrix *evec;\n gsl_eigen_symmv_workspace *wmat;\n} gsl_sf_mathieu_workspace;\n\n\n/* Compute an array of characteristic (eigen) values from the recurrence\n matrices for the Mathieu equations. */\nGSL_FUN int gsl_sf_mathieu_a_array(int order_min, int order_max, double qq, gsl_sf_mathieu_workspace *work, double result_array[]);\nGSL_FUN int gsl_sf_mathieu_b_array(int order_min, int order_max, double qq, gsl_sf_mathieu_workspace *work, double result_array[]);\n\n/* Compute the characteristic value for a Mathieu function of order n and\n type ntype. */\nGSL_FUN int gsl_sf_mathieu_a_e(int order, double qq, gsl_sf_result *result);\nGSL_FUN double gsl_sf_mathieu_a(int order, double qq);\nGSL_FUN int gsl_sf_mathieu_b_e(int order, double qq, gsl_sf_result *result);\nGSL_FUN double gsl_sf_mathieu_b(int order, double qq);\n\n/* Compute the Fourier coefficients for a Mathieu function. */\nGSL_FUN int gsl_sf_mathieu_a_coeff(int order, double qq, double aa, double coeff[]);\nGSL_FUN int gsl_sf_mathieu_b_coeff(int order, double qq, double aa, double coeff[]);\n\n/* Allocate computational storage space for eigenvalue solution. */\nGSL_FUN gsl_sf_mathieu_workspace *gsl_sf_mathieu_alloc(const size_t nn,\n const double qq);\nGSL_FUN void gsl_sf_mathieu_free(gsl_sf_mathieu_workspace *workspace);\n\n/* Compute an angular Mathieu function. */\nGSL_FUN int gsl_sf_mathieu_ce_e(int order, double qq, double zz, gsl_sf_result *result);\nGSL_FUN double gsl_sf_mathieu_ce(int order, double qq, double zz);\nGSL_FUN int gsl_sf_mathieu_se_e(int order, double qq, double zz, gsl_sf_result *result);\nGSL_FUN double gsl_sf_mathieu_se(int order, double qq, double zz);\nGSL_FUN int gsl_sf_mathieu_ce_array(int nmin, int nmax, double qq, double zz,\n gsl_sf_mathieu_workspace *work,\n double result_array[]);\nGSL_FUN int gsl_sf_mathieu_se_array(int nmin, int nmax, double qq, double zz,\n gsl_sf_mathieu_workspace *work,\n double result_array[]);\n\n/* Compute a radial Mathieu function. */\nGSL_FUN int gsl_sf_mathieu_Mc_e(int kind, int order, double qq, double zz,\n gsl_sf_result *result);\nGSL_FUN double gsl_sf_mathieu_Mc(int kind, int order, double qq, double zz);\nGSL_FUN int gsl_sf_mathieu_Ms_e(int kind, int order, double qq, double zz,\n gsl_sf_result *result);\nGSL_FUN double gsl_sf_mathieu_Ms(int kind, int order, double qq, double zz);\nGSL_FUN int gsl_sf_mathieu_Mc_array(int kind, int nmin, int nmax, double qq,\n double zz, gsl_sf_mathieu_workspace *work,\n double result_array[]);\nGSL_FUN int gsl_sf_mathieu_Ms_array(int kind, int nmin, int nmax, double qq,\n double zz, gsl_sf_mathieu_workspace *work,\n double result_array[]);\n\n\n__END_DECLS\n\n#endif /* !__GSL_SF_MATHIEU_H__ */\n", "meta": {"hexsha": "10b8d3ff51600766cd3e9d0fffd4688a55dfafed", "size": 4716, "ext": "h", "lang": "C", "max_stars_repo_path": "Chimera/3rd_Party/GSL_MSVC/gsl/gsl_sf_mathieu.h", "max_stars_repo_name": "zzpwahaha/Chimera-Control-Trim", "max_stars_repo_head_hexsha": "df1bbf6bea0b87b8c7c9a99dce213fdc249118f2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2020-09-28T08:20:20.000Z", "max_stars_repo_stars_event_max_datetime": "2020-09-28T08:20:20.000Z", "max_issues_repo_path": "Chimera/3rd_Party/GSL_MSVC/gsl/gsl_sf_mathieu.h", "max_issues_repo_name": "zzpwahaha/Chimera-Control-Trim", "max_issues_repo_head_hexsha": "df1bbf6bea0b87b8c7c9a99dce213fdc249118f2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Chimera/3rd_Party/GSL_MSVC/gsl/gsl_sf_mathieu.h", "max_forks_repo_name": "zzpwahaha/Chimera-Control-Trim", "max_forks_repo_head_hexsha": "df1bbf6bea0b87b8c7c9a99dce213fdc249118f2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2020-10-14T12:45:35.000Z", "max_forks_repo_forks_event_max_datetime": "2020-10-14T12:45:35.000Z", "avg_line_length": 38.0322580645, "max_line_length": 132, "alphanum_fraction": 0.7190415606, "num_tokens": 1172, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.815232489352, "lm_q2_score": 0.6187804337438501, "lm_q1q2_score": 0.5044499133633091}} {"text": "/* specfunc/gsl_sf_airy.h\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 2 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.\n */\n\n/* Author: G. Jungman */\n\n#ifndef __GSL_SF_AIRY_H__\n#define __GSL_SF_AIRY_H__\n\n#include \n#include \n\n#undef __BEGIN_DECLS\n#undef __END_DECLS\n#ifdef __cplusplus\n# define __BEGIN_DECLS extern \"C\" {\n# define __END_DECLS }\n#else\n# define __BEGIN_DECLS /* empty */\n# define __END_DECLS /* empty */\n#endif\n\n__BEGIN_DECLS\n\n\n/* Airy function Ai(x)\n *\n * exceptions: GSL_EUNDRFLW\n */\nint gsl_sf_airy_Ai_e(const double x, const gsl_mode_t mode, gsl_sf_result * result);\ndouble gsl_sf_airy_Ai(const double x, gsl_mode_t mode);\n\n\n/* Airy function Bi(x)\n *\n * exceptions: GSL_EOVRFLW\n */\nint gsl_sf_airy_Bi_e(const double x, gsl_mode_t mode, gsl_sf_result * result);\ndouble gsl_sf_airy_Bi(const double x, gsl_mode_t mode);\n\n\n/* scaled Ai(x):\n * Ai(x) x < 0\n * exp(+2/3 x^{3/2}) Ai(x) x > 0\n *\n * exceptions: none\n */\nint gsl_sf_airy_Ai_scaled_e(const double x, gsl_mode_t mode, gsl_sf_result * result);\ndouble gsl_sf_airy_Ai_scaled(const double x, gsl_mode_t mode);\n\n\n/* scaled Bi(x):\n * Bi(x) x < 0\n * exp(-2/3 x^{3/2}) Bi(x) x > 0\n *\n * exceptions: none\n */\nint gsl_sf_airy_Bi_scaled_e(const double x, gsl_mode_t mode, gsl_sf_result * result);\ndouble gsl_sf_airy_Bi_scaled(const double x, gsl_mode_t mode);\n\n\n/* derivative Ai'(x)\n *\n * exceptions: GSL_EUNDRFLW\n */\nint gsl_sf_airy_Ai_deriv_e(const double x, gsl_mode_t mode, gsl_sf_result * result);\ndouble gsl_sf_airy_Ai_deriv(const double x, gsl_mode_t mode);\n\n\n/* derivative Bi'(x)\n *\n * exceptions: GSL_EOVRFLW\n */\nint gsl_sf_airy_Bi_deriv_e(const double x, gsl_mode_t mode, gsl_sf_result * result);\ndouble gsl_sf_airy_Bi_deriv(const double x, gsl_mode_t mode);\n\n\n/* scaled derivative Ai'(x):\n * Ai'(x) x < 0\n * exp(+2/3 x^{3/2}) Ai'(x) x > 0\n *\n * exceptions: none\n */\nint gsl_sf_airy_Ai_deriv_scaled_e(const double x, gsl_mode_t mode, gsl_sf_result * result);\ndouble gsl_sf_airy_Ai_deriv_scaled(const double x, gsl_mode_t mode);\n\n\n/* scaled derivative:\n * Bi'(x) x < 0\n * exp(-2/3 x^{3/2}) Bi'(x) x > 0\n *\n * exceptions: none\n */\nint gsl_sf_airy_Bi_deriv_scaled_e(const double x, gsl_mode_t mode, gsl_sf_result * result);\ndouble gsl_sf_airy_Bi_deriv_scaled(const double x, gsl_mode_t mode);\n\n\n/* Zeros of Ai(x)\n */\nint gsl_sf_airy_zero_Ai_e(unsigned int s, gsl_sf_result * result);\ndouble gsl_sf_airy_zero_Ai(unsigned int s);\n\n\n/* Zeros of Bi(x)\n */\nint gsl_sf_airy_zero_Bi_e(unsigned int s, gsl_sf_result * result);\ndouble gsl_sf_airy_zero_Bi(unsigned int s);\n\n\n/* Zeros of Ai'(x)\n */\nint gsl_sf_airy_zero_Ai_deriv_e(unsigned int s, gsl_sf_result * result);\ndouble gsl_sf_airy_zero_Ai_deriv(unsigned int s);\n\n\n/* Zeros of Bi'(x)\n */\nint gsl_sf_airy_zero_Bi_deriv_e(unsigned int s, gsl_sf_result * result);\ndouble gsl_sf_airy_zero_Bi_deriv(unsigned int s);\n\n\n__END_DECLS\n\n#endif /* __GSL_SF_AIRY_H__ */\n", "meta": {"hexsha": "f4be70d31b19dd7259763ad4c659baa9fdc34f7c", "size": 3688, "ext": "h", "lang": "C", "max_stars_repo_path": "code/em/treba/gsl-1.0/specfunc/gsl_sf_airy.h", "max_stars_repo_name": "ICML14MoMCompare/spectral-learn", "max_stars_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-12-18T18:09:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-10T11:31:28.000Z", "max_issues_repo_path": "code/em/treba/gsl-1.0/specfunc/gsl_sf_airy.h", "max_issues_repo_name": "ICML14MoMCompare/spectral-learn", "max_issues_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "code/em/treba/gsl-1.0/specfunc/gsl_sf_airy.h", "max_forks_repo_name": "ICML14MoMCompare/spectral-learn", "max_forks_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2015-10-02T01:32:59.000Z", "max_forks_repo_forks_event_max_datetime": "2015-10-02T01:32:59.000Z", "avg_line_length": 26.3428571429, "max_line_length": 91, "alphanum_fraction": 0.7131236443, "num_tokens": 1069, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7461389817407017, "lm_q2_score": 0.6757646075489392, "lm_q1q2_score": 0.5042143161729704}} {"text": "#include \n#include \n#include \n#include \n\n#define P_inv_gamma gsl_cdf_gamma_Pinv // invverse cumulative gamma dist\n#define P_inc_gamma gsl_sf_gamma_inc_P // regularised incomplete Gamma function\n#define lngamma gsl_sf_lngamma // ln Gamma function\n\n#define V0 9\n#define NUMBER_SHEEP 30\n#define NUM_DONORS 10\n#define SHEEP_FIRST_TEST_WEEK 1\n\n// month defined as 365/12 days \n// week defined as 7 days\n# define WEEKS_PER_MONTH ((365/12)/7) \n\n#include \"Texel_clean_data.h\"\n\ntypedef struct {\n double a, b;\n double *lambda;\n double *Lambda;\n double **W4;\n double *W2;\n} parameters_t;\n\ndouble u(int, double*);\ndouble lngexpan(double, double, int*);\ndouble ln_inc_gamma_star(double, double);\ndouble w(int, int, int, parameters_t*);\ndouble Prob_seroconvert(int, parameters_t*);\nextern double R0(double, double, double, int, double*);\n\nvoid Variables(struct variables *V) \n{\n Var(V, 0, \"week\");\n Var(V, 1, \"field infected\");\n Var(V, 2, \"new positives\");\n Var(V, 3, \"cumulative new positives\");\n Var(V, 4, \"seroconversion rate\");\n Var(V, 5, \"number infectious\");\n Var(V, 6, \"number infectious\");\n Var(V, 6, \"housed infected\");\n Var(V, 7, \"infected\");\n Var(V, 8, \"infected\");\n Var(V, V0, \"log_p_pos\"); \n}\n\nvoid Parameters(int trt, int ind, double *p, struct parameterset *Q) \n{\n Par(Q, 0, Real, \"beta_{field}\", Exponential, 0.0008);\n Par(Q, 1, Real, \"beta_{housed}\", Gamma, 2.0, 0.1);\n Par(Q, 2, Real, \"a\", Exponential, 3.2);\n Par(Q, 3, Real, \"k1\", Gamma, 2.0, 4.0);\n // Par(Q, 0, Real, \"beta_{field}\", Exponential, 0.0082/WEEKS_PER_MONTH);\n // Par(Q, 1, Real, \"beta_{housed}\", Gamma, 2.0, 0.01);\n // Par(Q, 2, Real, \"mu\", Gamma, 2.0, 1.5);\n // Par(Q, 3, Real, \"sigma\", Gamma, 2.0, 1.5);\n\n // Par(Q, 8, Real, \"a\", Der);\n // Par(Q, 9, Real, \"b\", Der);\n // Par(Q, 10, Real, \"beta_{housed}/beta_{field}\", Der);\n // Par(Q, 12, Real, \"E[inf_{field}]\", Der);\n // Par(Q, 13, Real, \"E[inf_{housed}]\", Der);\n // Par(Q, 14, Real, \"E[inf]\", Der);\n // Par(Q, 15, Real, \"s_{low}\", Der);\n // Par(Q, 16, Real, \"s_{high}\", Der);\n}\n\nint Model(const uint trt, const uint ind, const uint nweeks, double *p, double **V, TimePoints *Data)\n{\n int i, j, m, *num_infected;\n double **p_seropos = V, *Einf_field, *Einf_housed;\n parameters_t pars;\n\n double beta_field = p[0]/WEEKS_PER_MONTH;\n double beta_housed = p[1]/WEEKS_PER_MONTH;\n double S_a = p[2];\n double S_b = S_a/p[3]/WEEKS_PER_MONTH;\n int seroconversion = lrint(p[3]);\n \n for (m = 0; m < nweeks; m++)\n V[m][0] = m;\n\n int *num_infectious = integervector(nweeks);\n pars.Lambda = doublevector(nweeks);\n pars.lambda = doublevector(nweeks);\n pars.W4 = doublematrix(nweeks, nweeks);\n pars.W2 = doublevector(nweeks);\n pars.a = S_a;\n pars.b = S_b;\n\n // ewe to ewe transmission\n // the 10 donor sheep are infectious at start of experiment\n for (j = 0; j < NUM_DONORS; j++)\n for (m = 0; m <= sheep_last_week[j]; m++)\n num_infectious[m]++;\n\n for (m = 0; m < nweeks; m++)\n if (m == 20 || m == 21)\n pars.lambda[m] = num_infectious[m]*beta_housed;\n else\n pars.lambda[m] = num_infectious[m]*beta_field;\n\n // cumulative sum of lambda\n pars.Lambda[0] = 0;\n for (m = 1; m < nweeks; m++)\n pars.Lambda[m] = pars.Lambda[m-1]+pars.lambda[m-1];\n\n for (m = 0; m < nweeks; m++) {\n for (i = 0; i < m; i++)\n pars.W4[i][m] = w(i, i+1, m+1, &pars) \n - w(i, i+1, m, &pars) \n - w(i, i, m+1, &pars) \n + w(i, i, m, &pars);\n pars.W2[m] = w(m, m, m+1, &pars);\n }\n \n // for each testing date calculate the probability that a sheep tests positive since the last test\n for (m = 0; m < nweeks; m++)\n p_seropos[m][V0] = Prob_seroconvert(m, &pars);\n\n\n\n /******************** OUTPUT ***********************/\n if (Data->mode == OUTPUT) {\n for (m = 0; m < nweeks; m++)\n V[m][0] = m;\n\n // expected number of new positives on each test date\n for (j = NUM_DONORS; j < NUMBER_SHEEP; j++)\n for (i = 0; i < sheep_last_test_week[j]-1; i++)\n V[i+1][2] += p_seropos[i][V0];\n\n // cumulative expected number of new positives\n V[0][3] = V[0][2];\n for (i = 0; i < nweeks-1; i++)\n V[i+1][3] = V[i][3]+V[i+1][2];\n\n // seroconversion rate (new positives per week)\n // V[0][4] = 0;\n // for (i = 1; i < Data->n; i++)\n // V[i][4] = V[i][2]/(test_weeks[i]-test_weeks[i-1]);\n\n // // number of infectious animals\n // for (i = 0; i < Data->n; i++)\n // V[i][5] = num_infectious[test_weeks[i]];\n\n // Einf_field = doublevector(nweeks);\n // Einf_housed = doublevector(nweeks);\n // for (j = NUM_DONORS; j < NUMBER_SHEEP; j++)\n // for (m = 0; m <= SHEEP_LAST_WEEK; m++)\n // if (test_weeks[m] == 19 || test_weeks[m] == 20)\n // Einf_housed[m] += (1.-exp(-pars.lambda[m]))*u(m, pars.Lambda);\n // else\n // Einf_field[m] += (1.-exp(-pars.lambda[m]))*u(m, pars.Lambda);\n\n // for (m = 1; m < nweeks; m++) {\n // Einf_field[m] += Einf_field[m-1];\n // Einf_housed[m] += Einf_housed[m-1];\n // }\n // for (i = 0; i < Data->n; i++) {\n // V[i][1] = Einf_field[test_weeks[i]];\n // V[i][6] = Einf_housed[test_weeks[i]];\n // V[i][7] = V[i][1]+V[i][6];\n // }\n // free(Einf_field);\n // free(Einf_housed);\n\n // number infected\n // num_infected = integervector(nweeks);\n // for (j = 0; j < NUMBER_SHEEP; j++)\n // if (sheep_pos_week[j] != -1)\n // for (m = max(0, sheep_pos_week[j]-seroconversion); m <= SHEEP_LAST_WEEK; m++)\n // num_infected[m]++;\n\n // for (i = 0; i < Data->n; i++)\n // V[i][8] = num_infected[test_weeks[i]];\n // free(num_infected);\n }\n\n free(num_infectious);\n free(pars.lambda);\n free(pars.Lambda);\n free(pars.W4[0]); free(pars.W4);\n free(pars.W2);\n return SUCCESS;\n}\n\ndouble P_pos(int s1, int s2, double **V)\n{\n int m;\n double sum = 0;\n for (m = s1; m < s2; m++)\n sum += V[m][V0];\n return sum;\n}\n\ndouble logLikelihood(const uint trt, const uint ind, const double *p, double **V, const TimePoints *Data)\n{\n int j, pos_idx;\n double lnL = 0;\n\n for (j = NUM_DONORS; j < NUMBER_SHEEP; j++)\n if (sheep_pos_index[j] != 0) {\n pos_idx = sheep_pos_index[j];\n if (pos_idx > 0) {\n do {\n pos_idx--; \n } while (Data->t[pos_idx][j] == 0);\n // ewe is first seropositive at start of month m, therefore it seroconverted\n // sometime in the months from the last test to the month prior to seroconverting\n lnL += log(P_pos(lrint(Data->t[pos_idx][0]), sheep_pos_week[j], V));\n }\n else\n // ewe never seroconverted\n lnL += log(1. - P_pos(SHEEP_FIRST_TEST_WEEK, sheep_last_test_week[j], V));\n }\n return lnL;\n}\n\nvoid OutputModel(int trt, int ind, double *Output, double *V)\n{\n int i;\n for (i = 1; i < V0; i++)\n Output[i] = V[i];\n}\n\nvoid OutputData(int trt, int ind, double *Output, double *Var, double *Data, uint *value, int index)\n{\n Output[2] = Data[31];\n Output[3] = Data[32];\n Output[4] = Data[33];\n Output[5] = Data[34];\n}\n\nint f0(int trt, int ind, double *x, double *y, double *p, TimePoints *TP)\n{\n // R0 2 month housed\n int i, n = 2;\n if (x == NULL) return n;\n for (i = 0; i < n; i++) {\n x[i] = 100*i+1;\n y[i] = R0(x[i], 2., 0.1, 5, p);\n }\n return n;\n}\n\nint f1(int trt, int ind, double *x, double *y, double *p, TimePoints *TP)\n{\n // R0 0 months housed\n int i, n = 2;\n if (x == NULL) return n;\n for (i = 0; i < n; i++) {\n x[i] = 100*i+1;\n y[i] = R0(x[i], 0., 0.1, 5, p);\n }\n return n;\n}\n\nint f2(int trt, int ind, double *x, double *y, double *p, TimePoints *TP)\n{\n // R0 for 25 sheep housed for different durations\n int i, n = 14;\n if (x == NULL) return n;\n for (i = 0; i < n; i++) {\n x[i] = i;\n y[i] = R0(25., x[i]*12./365., 0.1, 5, p);\n }\n return n;\n}\n\nint f3(int trt, int ind, double *x, double *y, double *p, TimePoints *TP) \n{\n // CDF of normal seroconversion period\n int i, n = 1000;\n if (x == NULL) return n;\n double S_a = p[2];\n double S_k1 = p[3];\n\n for (i = 0; i < n; i++) {\n x[i] = (double)i/20.;\n // y[i] = gsl_ran_gamma_pdf(x[i], a, 1./b);\n y[i] = gsl_cdf_gamma_P(x[i], S_a, S_k1);\n }\n return n;\n}\n\nvoid function_list(functions_t *F)\n{\n F->n_func = 0;\n // F->function_list = (function_ptr*) malloc(F->n_func*sizeof(function_ptr));\n // F->function_list[0] = f0;\n // F->function_list[1] = f1;\n // F->function_list[2] = f2;\n // F->function_list[3] = f3;\n}\n\ndouble u(int m, double *Lambda)\n{\n // The probability a sheep is uninfected at the start of week m\n return exp(-Lambda[m]);\n}\n\ndouble lngseries(double a, double x, int *ierr)\n{\n double giant = HUGE_VAL/1000., eps = 1e-15;\n double t = 1./a, v = t;\n double p, q, lnigam;\n int k = 0;\n *ierr = 0;\n\n while ((fabs(t/v) > eps) && *ierr == 0) {\n p = (a+k)/(a+k+1);\n q = k+1;\n t *= -x*p/q;\n v += t;\n k += 1;\n if (t > giant)\n *ierr = 1;\n }\n if (*ierr == 0)\n if (lngamma(a) < log(giant))\n lnigam = log(v)-lngamma(a);\n else {\n lnigam = 0;\n *ierr = 1;\n }\n else {\n lnigam = 0;\n *ierr = 1;\n }\n return lnigam;\n}\n\ndouble lngexpan(double a, double x, int *ierr)\n{\n double giant = HUGE_VAL/1000., eps = 1e-15;\n double t = 1, v = t;\n double p, lnigam;\n int k = 0;\n *ierr = 0;\n\n if (x > log(giant)) {\n *ierr = 1;\n return 0;\n }\n while ((fabs(t/v) > eps) && *ierr == 0) {\n p = 1-a+k;\n t *= p/x;\n v += t;\n k += 1;\n if (t > giant)\n *ierr = 1;\n }\n if (*ierr == 0)\n if (lngamma(a) < log(giant))\n lnigam = log(v)+x-log(x)-lngamma(a);\n else {\n lnigam = 0;\n *ierr = 1;\n }\n else {\n lnigam = 0;\n *ierr = 1;\n }\n return lnigam;\n}\n\ndouble ln_inc_gamma_star(double a, double z)\n{\n int ierr;\n double lnigam;\n\n if (z < -50) {\n lnigam = lngexpan(a, -z, &ierr);\n if (ierr != 0)\n printf(\"error1\\n\");\n } \n else {\n lnigam = lngseries(a, z, &ierr);\n if (ierr != 0)\n printf(\"error2\\n\");\n }\n return lnigam;\n}\n\ndouble w(int n, int t, int s, parameters_t *p)\n{\n double a = p->a;\n double l = p->lambda[n];\n double b = p->b;\n double r = (b-l)/b;\n double Z, z, v;\n\n Z = b*(s-t);\n if (Z == 0)\n return 0;\n\n z = r*Z;\n if (z <= 0)\n v = exp(a*log(Z) - l*Z/b + ln_inc_gamma_star(a, z));\n else\n v = exp(-a*log(r) - l*Z/b + log(P_inc_gamma(a, z)));\n\n return exp(-l*(t-n))*(v - P_inc_gamma(a, Z));\n}\n\ndouble Prob_seroconvert(int m, parameters_t *p)\n{\n int n;\n double P_m = 0;\n\n for (n = 0; n < m; n++)\n P_m += u(n, p->Lambda)*p->W4[n][m];\n P_m -= u(m, p->Lambda)*p->W2[m];\n\n return min(max(0, P_m), 1);\n}\n\nvoid DerivedParameters(int trt, int ind, int nmonths, double *p, double **V, TimePoints *Data) \n{\n // int i, j, m;\n // double a, b;\n // double beta_field = p[0];\n // double beta_housed = p[1];\n // double mu = p[2];\n // double sd = p[3];\n // int seroconversion = lrint(mu);\n // int latency = lrint(p[4]);\n // int nweeks = lrint(Data->t[Data->n-1][0])+1;\n // int *test_weeks = integervector(Data->n);\n // int *num_infectious = integervector(nweeks);\n // double *Lambda = doublevector(nweeks);\n // double *lambda = doublevector(nweeks);\n\n // p[8] = a = pow(mu/sd, 2.);\n // p[9] = b = a/mu;\n // p[10] = beta_housed/beta_field;\n // p[15] = P_inv_gamma(0.025, a, 1./b);\n // p[16] = P_inv_gamma(0.975, a, 1./b);\n\n // for (i = 0; i < Data->n; i++)\n // test_weeks[i] = lrint(Data->t[i][0]);\n\n // for (j = 0; j < NUM_DONORS; j++)\n // for (m = 0; m <= SHEEP_LAST_WEEK; m++)\n // num_infectious[m]++;\n\n // for (j = NUM_DONORS; j < NUMBER_SHEEP; j++)\n // if (sheep_pos_week[j] > 0)\n // for (m = max(0, sheep_pos_week[j]-seroconversion+latency); m <= SHEEP_LAST_WEEK; m++)\n // num_infectious[m]++;\n\n // for (m = 0; m < nweeks; m++)\n // if (test_weeks[m] == 19 || test_weeks[m] == 20)\n // lambda[m] = num_infectious[m]*beta_housed;\n // else\n // lambda[m] = num_infectious[m]*beta_field;\n\n // Lambda[0] = 0;\n // for (m = 1; m < nweeks; m++)\n // Lambda[m] = Lambda[m-1]+lambda[m-1];\n\n // p[12] = 0;\n // p[13] = 0;\n // for (j = NUM_DONORS; j < NUMBER_SHEEP; j++)\n // for (m = 0; m <= SHEEP_LAST_WEEK; m++)\n // if (test_weeks[m] == 19 || test_weeks[m] == 20)\n // p[13] += (1.-exp(-lambda[m]))*u(m, Lambda);\n // else\n // p[12] += (1.-exp(-lambda[m]))*u(m, Lambda);\n // p[14] = p[12]+p[13];\n \n // free(lambda);\n // free(Lambda);\n // free(num_infectious);\n // free(test_weeks);\n}\n\nvoid WAIC(int trt, int ind, double **lnL, double **V, double *p, const TimePoints *Data) {}\nvoid PredictData(int trt, int ind, double *Output, double *V, double *p, gsl_rng *stream) {}\nvoid SimulateData(int trt, int ind, double *Output, double *V, double *p, double *Data, uint *value, gsl_rng *stream) {}\ndouble timestep(void) {return 1;}\nvoid GlobalParameters() {}\ndouble UserPDF(double x) {return 0;}\nvoid HyperParameters(Treatments T, Hyperparameters *H) {}\nvoid SaturatedModel(int trt, int ind, double **V, double *p, const TimePoints *Data) {}\nvoid Residual(int trt, int ind, double *R, double *V, double *p, double *Data, uint *value) {}\n", "meta": {"hexsha": "f6dbeccf839d7d117b6c9af925de00be74b86f53", "size": 13169, "ext": "c", "lang": "C", "max_stars_repo_path": "Peterson/model60A.c", "max_stars_repo_name": "nicksavill/maedi-visna-epidemiology", "max_stars_repo_head_hexsha": "00771289509727b5b25e3776a0964555f227442d", "max_stars_repo_licenses": ["CC-BY-4.0"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "Peterson/model60A.c", "max_issues_repo_name": "nicksavill/maedi-visna-epidemiology", "max_issues_repo_head_hexsha": "00771289509727b5b25e3776a0964555f227442d", "max_issues_repo_licenses": ["CC-BY-4.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Peterson/model60A.c", "max_forks_repo_name": "nicksavill/maedi-visna-epidemiology", "max_forks_repo_head_hexsha": "00771289509727b5b25e3776a0964555f227442d", "max_forks_repo_licenses": ["CC-BY-4.0"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 26.7662601626, "max_line_length": 120, "alphanum_fraction": 0.554863695, "num_tokens": 4869, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8244619177503205, "lm_q2_score": 0.6113819732941511, "lm_q1q2_score": 0.504061154180071}} {"text": "/* specfunc/legendre_Qn.c\n * \n * Copyright (C) 1996, 1997, 1998, 1999, 2000 Gerard Jungman\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 2 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.\n */\n\n/* Author: G. Jungman */\n\n#include \n#include \n#include \n#include \"gsl_sf_bessel.h\"\n#include \"gsl_sf_elementary.h\"\n#include \"gsl_sf_exp.h\"\n#include \"gsl_sf_pow_int.h\"\n#include \"gsl_sf_legendre.h\"\n\n#include \"error.h\"\n\n/* Evaluate f_{ell+1}/f_ell\n * f_ell := Q^{b}_{a+ell}(x)\n * x > 1\n */\nstatic\nint\nlegendreQ_CF1_xgt1(int ell, double a, double b, double x, double * result)\n{\n const double RECUR_BIG = GSL_SQRT_DBL_MAX;\n const int maxiter = 5000;\n int n = 1;\n double Anm2 = 1.0;\n double Bnm2 = 0.0;\n double Anm1 = 0.0;\n double Bnm1 = 1.0;\n double a1 = ell + 1.0 + a + b;\n double b1 = (2.0*(ell+1.0+a) + 1.0) * x;\n double An = b1*Anm1 + a1*Anm2;\n double Bn = b1*Bnm1 + a1*Bnm2;\n double an, bn;\n double fn = An/Bn;\n\n while(n < maxiter) {\n double old_fn;\n double del;\n double lna;\n n++;\n Anm2 = Anm1;\n Bnm2 = Bnm1;\n Anm1 = An;\n Bnm1 = Bn;\n lna = ell + n + a;\n an = b*b - lna*lna;\n bn = (2.0*lna + 1.0) * x;\n An = bn*Anm1 + an*Anm2;\n Bn = bn*Bnm1 + an*Bnm2;\n\n if(fabs(An) > RECUR_BIG || fabs(Bn) > RECUR_BIG) {\n An /= RECUR_BIG;\n Bn /= RECUR_BIG;\n Anm1 /= RECUR_BIG;\n Bnm1 /= RECUR_BIG;\n Anm2 /= RECUR_BIG;\n Bnm2 /= RECUR_BIG;\n }\n\n old_fn = fn;\n fn = An/Bn;\n del = old_fn/fn;\n\n if(fabs(del - 1.0) < 4.0*GSL_DBL_EPSILON) break;\n }\n\n *result = fn;\n\n if(n == maxiter)\n GSL_ERROR (\"error\", GSL_EMAXITER);\n else\n return GSL_SUCCESS; \n}\n\n\n/* Uniform asymptotic for Q_l(x).\n * Assumes x > -1.0 and x != 1.0.\n * Discards second order and higher terms.\n */\nstatic\nint\nlegendre_Ql_asymp_unif(const double ell, const double x, gsl_sf_result * result)\n{\n if(x < 1.0) {\n double u = ell + 0.5;\n double th = acos(x);\n gsl_sf_result Y0, Y1;\n int stat_Y0, stat_Y1;\n int stat_m;\n double pre;\n double B00;\n double sum;\n\n /* B00 = 1/8 (1 - th cot(th) / th^2\n * pre = sqrt(th/sin(th))\n */\n if(th < GSL_ROOT4_DBL_EPSILON) {\n B00 = (1.0 + th*th/15.0)/24.0;\n pre = 1.0 + th*th/12.0;\n }\n else {\n double sin_th = sqrt(1.0 - x*x);\n double cot_th = x / sin_th;\n B00 = 1.0/8.0 * (1.0 - th * cot_th) / (th*th);\n pre = sqrt(th/sin_th);\n }\n\n stat_Y0 = gsl_sf_bessel_Y0_e(u*th, &Y0);\n stat_Y1 = gsl_sf_bessel_Y1_e(u*th, &Y1);\n\n sum = -0.5*M_PI * (Y0.val + th/u * Y1.val * B00);\n\n stat_m = gsl_sf_multiply_e(pre, sum, result);\n result->err += 0.5*M_PI * fabs(pre) * (Y0.err + fabs(th/u*B00)*Y1.err);\n result->err += GSL_DBL_EPSILON * fabs(result->val);\n\n return GSL_ERROR_SELECT_3(stat_m, stat_Y0, stat_Y1);\n }\n else {\n double u = ell + 0.5;\n double xi = acosh(x);\n gsl_sf_result K0_scaled, K1_scaled;\n int stat_K0, stat_K1;\n int stat_e;\n double pre;\n double B00;\n double sum;\n\n /* B00 = -1/8 (1 - xi coth(xi) / xi^2\n * pre = sqrt(xi/sinh(xi))\n */\n if(xi < GSL_ROOT4_DBL_EPSILON) {\n B00 = (1.0-xi*xi/15.0)/24.0;\n pre = 1.0 - xi*xi/12.0;\n }\n else {\n double sinh_xi = sqrt(x*x - 1.0);\n double coth_xi = x / sinh_xi;\n B00 = -1.0/8.0 * (1.0 - xi * coth_xi) / (xi*xi);\n pre = sqrt(xi/sinh_xi);\n }\n\n stat_K0 = gsl_sf_bessel_K0_scaled_e(u*xi, &K0_scaled);\n stat_K1 = gsl_sf_bessel_K1_scaled_e(u*xi, &K1_scaled);\n\n sum = K0_scaled.val - xi/u * K1_scaled.val * B00;\n\n stat_e = gsl_sf_exp_mult_e(-u*xi, pre * sum, result);\n result->err = GSL_DBL_EPSILON * fabs(result->val) * fabs(u*xi);\n result->err += 2.0 * GSL_DBL_EPSILON * fabs(result->val);\n\n return GSL_ERROR_SELECT_3(stat_e, stat_K0, stat_K1);\n }\n}\n\n\n\n/*-*-*-*-*-*-*-*-*-*-*-* Functions with Error Codes *-*-*-*-*-*-*-*-*-*-*-*/\n\nint\ngsl_sf_legendre_Q0_e(const double x, gsl_sf_result * result)\n{\n /* CHECK_POINTER(result) */\n\n if(x <= -1.0 || x == 1.0) {\n DOMAIN_ERROR(result);\n }\n else if(x*x < GSL_ROOT6_DBL_EPSILON) { /* |x| <~ 0.05 */\n const double c3 = 1.0/3.0;\n const double c5 = 1.0/5.0;\n const double c7 = 1.0/7.0;\n const double c9 = 1.0/9.0;\n const double c11 = 1.0/11.0;\n const double y = x * x;\n const double series = 1.0 + y*(c3 + y*(c5 + y*(c7 + y*(c9 + y*c11))));\n result->val = x * series;\n result->err = 2.0 * GSL_DBL_EPSILON * fabs(x);\n return GSL_SUCCESS;\n }\n else if(x < 1.0) {\n result->val = 0.5 * log((1.0+x)/(1.0-x));\n result->err = 2.0 * GSL_DBL_EPSILON * fabs(result->val);\n return GSL_SUCCESS;\n }\n else if(x < 10.0) {\n result->val = 0.5 * log((x+1.0)/(x-1.0));\n result->err = 2.0 * GSL_DBL_EPSILON * fabs(result->val);\n return GSL_SUCCESS;\n }\n else if(x*GSL_DBL_MIN < 2.0) {\n const double y = 1.0/(x*x);\n const double c1 = 1.0/3.0;\n const double c2 = 1.0/5.0;\n const double c3 = 1.0/7.0;\n const double c4 = 1.0/9.0;\n const double c5 = 1.0/11.0;\n const double c6 = 1.0/13.0;\n const double c7 = 1.0/15.0;\n result->val = (1.0/x) * (1.0 + y*(c1 + y*(c2 + y*(c3 + y*(c4 + y*(c5 + y*(c6 + y*c7)))))));\n result->err = 2.0 * GSL_DBL_EPSILON * fabs(result->val);\n return GSL_SUCCESS;\n }\n else {\n UNDERFLOW_ERROR(result);\n }\n}\n\n\nint\ngsl_sf_legendre_Q1_e(const double x, gsl_sf_result * result)\n{\n /* CHECK_POINTER(result) */\n\n if(x <= -1.0 || x == 1.0) {\n DOMAIN_ERROR(result);\n }\n else if(x*x < GSL_ROOT6_DBL_EPSILON) { /* |x| <~ 0.05 */\n const double c3 = 1.0/3.0;\n const double c5 = 1.0/5.0;\n const double c7 = 1.0/7.0;\n const double c9 = 1.0/9.0;\n const double c11 = 1.0/11.0;\n const double y = x * x;\n const double series = 1.0 + y*(c3 + y*(c5 + y*(c7 + y*(c9 + y*c11))));\n result->val = x * x * series - 1.0;\n result->err = 2.0 * GSL_DBL_EPSILON * fabs(result->val);\n return GSL_SUCCESS;\n }\n else if(x < 1.0){\n result->val = 0.5 * x * (log((1.0+x)/(1.0-x))) - 1.0;\n result->err = 2.0 * GSL_DBL_EPSILON * fabs(result->val);\n return GSL_SUCCESS;\n }\n else if(x < 6.0) {\n result->val = 0.5 * x * log((x+1.0)/(x-1.0)) - 1.0;\n result->err = 2.0 * GSL_DBL_EPSILON * fabs(result->val);\n return GSL_SUCCESS;\n }\n else if(x*GSL_SQRT_DBL_MIN < 0.99/M_SQRT3) {\n const double y = 1/(x*x);\n const double c1 = 3.0/5.0;\n const double c2 = 3.0/7.0;\n const double c3 = 3.0/9.0;\n const double c4 = 3.0/11.0;\n const double c5 = 3.0/13.0;\n const double c6 = 3.0/15.0;\n const double c7 = 3.0/17.0;\n const double c8 = 3.0/19.0;\n const double sum = 1.0 + y*(c1 + y*(c2 + y*(c3 + y*(c4 + y*(c5 + y*(c6 + y*(c7 + y*c8)))))));\n result->val = sum / (3.0*x*x);\n result->err = 2.0 * GSL_DBL_EPSILON * fabs(result->val);\n return GSL_SUCCESS;\n }\n else {\n UNDERFLOW_ERROR(result);\n }\n}\n\n\nint\ngsl_sf_legendre_Ql_e(const int l, const double x, gsl_sf_result * result)\n{\n /* CHECK_POINTER(result) */\n\n if(x <= -1.0 || x == 1.0 || l < 0) {\n DOMAIN_ERROR(result);\n }\n else if(l == 0) {\n return gsl_sf_legendre_Q0_e(x, result);\n }\n else if(l == 1) {\n return gsl_sf_legendre_Q1_e(x, result);\n }\n else if(l > 100000) {\n return legendre_Ql_asymp_unif(l, x, result);\n }\n else if(x < 1.0){\n /* Forward recurrence.\n */\n gsl_sf_result Q0, Q1;\n int stat_Q0 = gsl_sf_legendre_Q0_e(x, &Q0);\n int stat_Q1 = gsl_sf_legendre_Q1_e(x, &Q1);\n double Qellm1 = Q0.val;\n double Qell = Q1.val;\n double Qellp1;\n int ell;\n for(ell=1; ellval = Qell;\n result->err = GSL_DBL_EPSILON * l * fabs(result->val);\n return GSL_ERROR_SELECT_2(stat_Q0, stat_Q1);\n }\n else {\n /* x > 1.0 */\n\n double rat;\n int stat_CF1 = legendreQ_CF1_xgt1(l, 0.0, 0.0, x, &rat);\n int stat_Q;\n double Qellp1 = rat * GSL_SQRT_DBL_MIN;\n double Qell = GSL_SQRT_DBL_MIN;\n double Qellm1;\n int ell;\n for(ell=l; ell>0; ell--) {\n Qellm1 = (x * (2.0*ell + 1.0) * Qell - (ell+1.0) * Qellp1) / ell;\n Qellp1 = Qell;\n Qell = Qellm1;\n }\n\n if(fabs(Qell) > fabs(Qellp1)) {\n gsl_sf_result Q0;\n stat_Q = gsl_sf_legendre_Q0_e(x, &Q0);\n result->val = GSL_SQRT_DBL_MIN * Q0.val / Qell;\n result->err = l * GSL_DBL_EPSILON * fabs(result->val);\n }\n else {\n gsl_sf_result Q1;\n stat_Q = gsl_sf_legendre_Q1_e(x, &Q1);\n result->val = GSL_SQRT_DBL_MIN * Q1.val / Qellp1;\n result->err = l * GSL_DBL_EPSILON * fabs(result->val);\n }\n\n return GSL_ERROR_SELECT_2(stat_Q, stat_CF1);\n }\n}\n\n\n/*-*-*-*-*-*-*-*-*-* Functions w/ Natural Prototypes *-*-*-*-*-*-*-*-*-*-*/\n\n#include \"eval.h\"\n\ndouble gsl_sf_legendre_Q0(const double x)\n{\n EVAL_RESULT(gsl_sf_legendre_Q0_e(x, &result));\n}\n\ndouble gsl_sf_legendre_Q1(const double x)\n{\n EVAL_RESULT(gsl_sf_legendre_Q1_e(x, &result));\n}\n\ndouble gsl_sf_legendre_Ql(const int l, const double x)\n{\n EVAL_RESULT(gsl_sf_legendre_Ql_e(l, x, &result));\n}\n", "meta": {"hexsha": "5b12356bd5d98fe4bb46180f7847621b0f1db45a", "size": 9676, "ext": "c", "lang": "C", "max_stars_repo_path": "code/em/treba/gsl-1.0/specfunc/legendre_Qn.c", "max_stars_repo_name": "ICML14MoMCompare/spectral-learn", "max_stars_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-12-18T18:09:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-10T11:31:28.000Z", "max_issues_repo_path": "code/em/treba/gsl-1.0/specfunc/legendre_Qn.c", "max_issues_repo_name": "ICML14MoMCompare/spectral-learn", "max_issues_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "code/em/treba/gsl-1.0/specfunc/legendre_Qn.c", "max_forks_repo_name": "ICML14MoMCompare/spectral-learn", "max_forks_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2015-10-02T01:32:59.000Z", "max_forks_repo_forks_event_max_datetime": "2015-10-02T01:32:59.000Z", "avg_line_length": 26.3651226158, "max_line_length": 97, "alphanum_fraction": 0.5819553535, "num_tokens": 3660, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7956581000631541, "lm_q2_score": 0.6334102775181399, "lm_q1q2_score": 0.5039780179705584}} {"text": "//Gets line spectral frequencies (LSFs).\n//from the linear prediction (LP) polynomial coefficients along cols or rows of X.\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \"cmp_ascend.c\"\n\n#ifdef __cplusplus\nnamespace ov {\nextern \"C\" {\n#endif\n\nint poly2lsf_s (float *Y, const float *X, const int iscolmajor, const int R, const int C, const int dim);\nint poly2lsf_d (double *Y, const double *X, const int iscolmajor, const int R, const int C, const int dim);\nint poly2lsf_c (float *Y, const float *X, const int iscolmajor, const int R, const int C, const int dim);\nint poly2lsf_z (double *Y, const double *X, const int iscolmajor, const int R, const int C, const int dim);\n\n\nint poly2lsf_s (float *Y, const float *X, const int iscolmajor, const int R, const int C, const int dim)\n{\n const float z = 0.0f, o = 1.0f;\n const int P = (dim==0) ? R-1 : C-1;\n const int job = 'E', compz = 'N'; //eigenvalues only\n const lapack_int ldh = P+1, n = P+1, ldz = 1;\n const lapack_int ilo = 1, ihi = n; //avoids balancing\n lapack_int info;\n float *poly, *prev, *omegas, *compan, *wr, *wi, zz[1];\n int r, c;\n\n //Checks\n if (R<1) { fprintf(stderr,\"error in poly2lsf_s: nrows X must be positive\\n\"); return 1; }\n if (C<1) { fprintf(stderr,\"error in poly2lsf_s: ncols X must be positive\\n\"); return 1; }\n if (P<1) { fprintf(stderr,\"error in poly2lsf_s: P (length of polynomial coeffs including a0=1) must be positive\\n\"); return 1; }\n\n //Allocate\n if (!(poly=(float *)malloc((size_t)(n+1)*sizeof(float)))) { fprintf(stderr,\"error in poly2lsf_s: problem with malloc. \"); perror(\"malloc\"); return 1; }\n if (!(prev=(float *)malloc((size_t)(n+1)*sizeof(float)))) { fprintf(stderr,\"error in poly2lsf_s: problem with malloc. \"); perror(\"malloc\"); return 1; }\n if (!(omegas=(float *)malloc((size_t)(2*n)*sizeof(float)))) { fprintf(stderr,\"error in poly2lsf_s: problem with malloc. \"); perror(\"malloc\"); return 1; }\n if (!(wr=(float *)malloc((size_t)(n)*sizeof(float)))) { fprintf(stderr,\"error in poly2lsf_s: problem with malloc. \"); perror(\"malloc\"); return 1; }\n if (!(wi=(float *)malloc((size_t)(n)*sizeof(float)))) { fprintf(stderr,\"error in poly2lsf_s: problem with malloc. \"); perror(\"malloc\"); return 1; }\n if (!(compan=(float *)malloc((size_t)(n*n)*sizeof(float)))) { fprintf(stderr,\"error in poly2lsf_s: problem with malloc. \"); perror(\"malloc\"); return 1; }\n\n if (dim==0)\n {\n for (c=0; c10.0f*FLT_EPSILON) ? atan2f(wi[r],wr[r]) : 0.0f; }\n for (r=1; r<=n; r++) { poly[r] += prev[r] + prev[r]; }\n cblas_scopy(n*n,&z,0,compan,1); cblas_scopy(n-1,&o,0,&compan[1],n+1); cblas_scopy(n,&poly[1],1,compan,n);\n //fprintf(stderr,\"compan = \\n\"); for (r=0; r10.0f*FLT_EPSILON) ? atan2f(wi[r],wr[r]) : 0.0f; }\n qsort(omegas,(size_t)(2*n),sizeof(float),cmp_ascend_s);\n if (iscolmajor) { cblas_scopy(n-1,&omegas[n+1],1,&Y[c*(n-1)],1); } //cblas_scopy(2*n,omegas,1,&Y[2*c*n],1);\n else { cblas_scopy(n-1,&omegas[n+1],1,&Y[c],C); } //cblas_scopy(2*n,omegas,1,&Y[c],C);\n }\n }\n else if (dim==1)\n {\n for (r=0; r10.0f*FLT_EPSILON) ? atan2f(wi[c],wr[c]) : 0.0f; }\n for (c=1; c<=n; c++) { poly[c] += prev[c] + prev[c]; }\n cblas_scopy(n*n,&z,0,compan,1); cblas_scopy(n-1,&o,0,&compan[1],n+1); cblas_scopy(n,&poly[1],1,compan,n);\n info = LAPACKE_shseqr(LAPACK_COL_MAJOR,job,compz,n,ilo,ihi,compan,ldh,wr,wi,zz,ldz); //eig\n if (info) { fprintf(stderr,\"error in poly2lsf_s: lapacke decomposition failed\\n\"); return 1; }\n for (c=0; c10.0f*FLT_EPSILON) ? atan2f(wi[c],wr[c]) : 0.0f; }\n qsort(omegas,(size_t)(2*n),sizeof(float),cmp_ascend_s);\n if (iscolmajor) { cblas_scopy(n-1,&omegas[n+1],1,&Y[r],R); } //cblas_scopy(2*n,omegas,1,&Y[r],R);\n else { cblas_scopy(n-1,&omegas[n+1],1,&Y[r*(n-1)],1); } //cblas_scopy(2*n,omegas,1,&Y[2*r*n],1);\n }\n }\n else\n {\n fprintf(stderr,\"error in poly2lsf_s: dim must be 0 or 1.\\n\"); return 1;\n }\n\n //Exit\n free(compan); free(wr); free(wi); free(poly); free(prev); free(omegas);\n return 0;\n}\n\n\nint poly2lsf_d (double *Y, const double *X, const int iscolmajor, const int R, const int C, const int dim)\n{\n const double z = 0.0, o = 1.0;\n const int P = (dim==0) ? R-1 : C-1;\n const int job = 'E', compz = 'N'; //eigenvalues only\n const lapack_int ldh = P+1, n = P+1, ldz = 1;\n const lapack_int ilo = 1, ihi = n; //avoids balancing\n lapack_int info;\n double *poly, *prev, *omegas, *compan, *wr, *wi, zz[1];\n int r, c;\n\n //Checks\n if (R<1) { fprintf(stderr,\"error in poly2lsf_d: nrows X must be positive\\n\"); return 1; }\n if (C<1) { fprintf(stderr,\"error in poly2lsf_d: ncols X must be positive\\n\"); return 1; }\n if (P<1) { fprintf(stderr,\"error in poly2lsf_d: P (length of polynomial coeffs including a0=1) must be positive\\n\"); return 1; }\n\n //Allocate\n if (!(poly=(double *)malloc((size_t)(n+1)*sizeof(double)))) { fprintf(stderr,\"error in poly2lsf_d: problem with malloc. \"); perror(\"malloc\"); return 1; }\n if (!(prev=(double *)malloc((size_t)(n+1)*sizeof(double)))) { fprintf(stderr,\"error in poly2lsf_d: problem with malloc. \"); perror(\"malloc\"); return 1; }\n if (!(omegas=(double *)malloc((size_t)(2*n)*sizeof(double)))) { fprintf(stderr,\"error in poly2lsf_d: problem with malloc. \"); perror(\"malloc\"); return 1; }\n if (!(wr=(double *)malloc((size_t)(n)*sizeof(double)))) { fprintf(stderr,\"error in poly2lsf_d: problem with malloc. \"); perror(\"malloc\"); return 1; }\n if (!(wi=(double *)malloc((size_t)(n)*sizeof(double)))) { fprintf(stderr,\"error in poly2lsf_d: problem with malloc. \"); perror(\"malloc\"); return 1; }\n if (!(compan=(double *)malloc((size_t)(n*n)*sizeof(double)))) { fprintf(stderr,\"error in poly2lsf_d: problem with malloc. \"); perror(\"malloc\"); return 1; }\n\n if (dim==0)\n {\n for (c=0; c10.0*DBL_EPSILON) ? atan2(wi[r],wr[r]) : 0.0; }\n for (r=1; r<=n; r++) { poly[r] += prev[r] + prev[r]; }\n cblas_dcopy(n*n,&z,0,compan,1); cblas_dcopy(n-1,&o,0,&compan[1],n+1); cblas_dcopy(n,&poly[1],1,compan,n);\n info = LAPACKE_dhseqr(LAPACK_COL_MAJOR,job,compz,n,ilo,ihi,compan,ldh,wr,wi,zz,ldz); //eig\n if (info) { fprintf(stderr,\"error in poly2lsf_d: lapacke decomposition failed\\n\"); return 1; }\n for (r=0; r10.0*DBL_EPSILON) ? atan2(wi[r],wr[r]) : 0.0; }\n qsort(omegas,(size_t)(2*n),sizeof(double),cmp_ascend_d);\n if (iscolmajor) { cblas_dcopy(n-1,&omegas[n+1],1,&Y[c*(n-1)],1); } //cblas_dcopy(2*n,omegas,1,&Y[2*c*n],1);\n else { cblas_dcopy(n-1,&omegas[n+1],1,&Y[c],C); } //cblas_dcopy(2*n,omegas,1,&Y[c],C);\n }\n }\n else if (dim==1)\n {\n for (r=0; r10.0*DBL_EPSILON) ? atan2(wi[c],wr[c]) : 0.0; }\n for (c=1; c<=n; c++) { poly[c] += prev[c] + prev[c]; }\n cblas_dcopy(n*n,&z,0,compan,1); cblas_dcopy(n-1,&o,0,&compan[1],n+1); cblas_dcopy(n,&poly[1],1,compan,n);\n info = LAPACKE_dhseqr(LAPACK_COL_MAJOR,job,compz,n,ilo,ihi,compan,ldh,wr,wi,zz,ldz); //eig\n if (info) { fprintf(stderr,\"error in poly2lsf_d: lapacke decomposition failed\\n\"); return 1; }\n for (c=0; c10.0*DBL_EPSILON) ? atan2(wi[c],wr[c]) : 0.0; }\n qsort(omegas,(size_t)(2*n),sizeof(double),cmp_ascend_d);\n if (iscolmajor) { cblas_dcopy(n-1,&omegas[n+1],1,&Y[r],R); } //cblas_dcopy(2*n,omegas,1,&Y[r],R);\n else { cblas_dcopy(n-1,&omegas[n+1],1,&Y[r*(n-1)],1); }\n }\n }\n else\n {\n fprintf(stderr,\"error in poly2lsf_d: dim must be 0 or 1.\\n\"); return 1;\n }\n\n //Exit\n free(compan); free(wr); free(wi); free(poly); free(prev); free(omegas);\n return 0;\n}\n\n\nint poly2lsf_c (float *Y, const float *X, const int iscolmajor, const int R, const int C, const int dim)\n{\n const float z[2] = {0.0f,0.0f}, o[2] = {1.0f,0.0f};\n const int P = (dim==0) ? R-1 : C-1;\n const int job = 'E', compz = 'N'; //eigenvalues only\n const lapack_int ldh = P+1, n = P+1, ldz = 1;\n const lapack_int ilo = 1, ihi = n; //avoids balancing\n lapack_int info;\n float *poly, *prev, *omegas, *compan, *wc, zz[2], sc[2];\n int r, c;\n\n //Checks\n if (R<1) { fprintf(stderr,\"error in poly2lsf_c: nrows X must be positive\\n\"); return 1; }\n if (C<1) { fprintf(stderr,\"error in poly2lsf_c: ncols X must be positive\\n\"); return 1; }\n if (P<1) { fprintf(stderr,\"error in poly2lsf_c: P (length of polynomial coeffs including a0=1) must be positive\\n\"); return 1; }\n\n //Allocate\n if (!(poly=(float *)malloc((size_t)(2*n+2)*sizeof(float)))) { fprintf(stderr,\"error in poly2lsf_c: problem with malloc. \"); perror(\"malloc\"); return 1; }\n if (!(prev=(float *)malloc((size_t)(2*n+2)*sizeof(float)))) { fprintf(stderr,\"error in poly2lsf_c: problem with malloc. \"); perror(\"malloc\"); return 1; }\n if (!(wc=(float *)malloc((size_t)(2*n)*sizeof(float)))) { fprintf(stderr,\"error in poly2lsf_c: problem with malloc. \"); perror(\"malloc\"); return 1; }\n if (!(omegas=(float *)malloc((size_t)(2*n)*sizeof(float)))) { fprintf(stderr,\"error in poly2lsf_c: problem with malloc. \"); perror(\"malloc\"); return 1; }\n if (!(compan=(float *)malloc((size_t)(4*n*n)*sizeof(float)))) { fprintf(stderr,\"error in poly2lsf_c: problem with malloc. \"); perror(\"malloc\"); return 1; }\n\n if (dim==0)\n {\n for (c=0; c10.0f*FLT_EPSILON) ? atan2f(wc[2*r+1],wc[2*r]) : 0.0f; }\n for (r=1; r<=n; r++) { poly[2*r] += prev[2*r] + prev[2*r]; poly[2*r+1] += prev[2*r+1] + prev[2*r+1]; }\n cblas_ccopy(n*n,z,0,compan,1); cblas_ccopy(n-1,o,0,&compan[2],n+1); cblas_ccopy(n,&poly[2],1,compan,n);\n info = LAPACKE_chseqr(LAPACK_COL_MAJOR,job,compz,n,ilo,ihi,(lapack_complex_float *)compan,ldh,(lapack_complex_float *)wc,(lapack_complex_float *)zz,ldz);\n if (info) { fprintf(stderr,\"error in poly2lsf_c: lapacke decomposition failed\\n\"); return 1; }\n for (r=0; r10.0f*FLT_EPSILON) ? atan2f(wc[2*r+1],wc[2*r]) : 0.0f; }\n qsort(omegas,(size_t)(2*n),sizeof(float),cmp_ascend_s);\n if (iscolmajor) { cblas_scopy(2*n,omegas,1,&Y[2*c*n],1); }\n else { cblas_scopy(2*n,omegas,1,&Y[c],C); }\n }\n }\n else if (dim==1)\n {\n for (r=0; r10.0f*FLT_EPSILON) ? atan2f(wc[2*r+1],wc[2*r]) : 0.0f; }\n for (c=1; c<=n; c++) { poly[2*c] += prev[2*c] + prev[2*c]; poly[2*c+1] += prev[2*c+1] + prev[2*c+1]; }\n cblas_ccopy(n*n,z,0,compan,1); cblas_ccopy(n-1,o,0,&compan[2],n+1); cblas_ccopy(n,&poly[2],1,compan,n);\n info = LAPACKE_chseqr(LAPACK_COL_MAJOR,job,compz,n,ilo,ihi,(lapack_complex_float *)compan,ldh,(lapack_complex_float *)wc,(lapack_complex_float *)zz,ldz);\n if (info) { fprintf(stderr,\"error in poly2lsf_c: lapacke decomposition failed\\n\"); return 1; }\n for (c=0; c10.0f*FLT_EPSILON) ? atan2f(wc[2*r+1],wc[2*r]) : 0.0f; }\n qsort(omegas,(size_t)(2*n),sizeof(float),cmp_ascend_s);\n if (iscolmajor) { cblas_scopy(2*n,omegas,1,&Y[r],R); }\n else { cblas_scopy(2*n,omegas,1,&Y[2*r*n],1); }\n }\n }\n else\n {\n fprintf(stderr,\"error in poly2lsf_c: dim must be 0 or 1.\\n\"); return 1;\n }\n\n //Exit\n free(compan); free(wc); free(poly); free(prev); free(omegas);\n return 0;\n}\n\n\nint poly2lsf_z (double *Y, const double *X, const int iscolmajor, const int R, const int C, const int dim)\n{\n const double z[2] = {0.0,0.0}, o[2] = {1.0,0.0};\n const int P = (dim==0) ? R-1 : C-1;\n const int job = 'E', compz = 'N'; //eigenvalues only\n const lapack_int ldh = P+1, n = P+1, ldz = 1;\n const lapack_int ilo = 1, ihi = n; //avoids balancing\n lapack_int info;\n double *poly, *prev, *omegas, *compan, *wc, zz[2], sc[2];\n int r, c;\n\n //Checks\n if (R<1) { fprintf(stderr,\"error in poly2lsf_z: nrows X must be positive\\n\"); return 1; }\n if (C<1) { fprintf(stderr,\"error in poly2lsf_z: ncols X must be positive\\n\"); return 1; }\n if (P<1) { fprintf(stderr,\"error in poly2lsf_z: P (length of polynomial coeffs including a0=1) must be positive\\n\"); return 1; }\n\n //Allocate\n if (!(poly=(double *)malloc((size_t)(2*n+2)*sizeof(double)))) { fprintf(stderr,\"error in poly2lsf_z: problem with malloc. \"); perror(\"malloc\"); return 1; }\n if (!(prev=(double *)malloc((size_t)(2*n+2)*sizeof(double)))) { fprintf(stderr,\"error in poly2lsf_z: problem with malloc. \"); perror(\"malloc\"); return 1; }\n if (!(wc=(double *)malloc((size_t)(2*n)*sizeof(double)))) { fprintf(stderr,\"error in poly2lsf_z: problem with malloc. \"); perror(\"malloc\"); return 1; }\n if (!(omegas=(double *)malloc((size_t)(2*n)*sizeof(double)))) { fprintf(stderr,\"error in poly2lsf_z: problem with malloc. \"); perror(\"malloc\"); return 1; }\n if (!(compan=(double *)malloc((size_t)(4*n*n)*sizeof(double)))) { fprintf(stderr,\"error in poly2lsf_z: problem with malloc. \"); perror(\"malloc\"); return 1; }\n\n if (dim==0)\n {\n for (c=0; c10.0*DBL_EPSILON) ? atan2(wc[2*r+1],wc[2*r]) : 0.0; }\n for (r=1; r<=n; r++) { poly[2*r] += prev[2*r] + prev[2*r]; poly[2*r+1] += prev[2*r+1] + prev[2*r+1]; }\n cblas_zcopy(n*n,z,0,compan,1); cblas_zcopy(n-1,o,0,&compan[2],n+1); cblas_zcopy(n,&poly[2],1,compan,n);\n info = LAPACKE_zhseqr(LAPACK_COL_MAJOR,job,compz,n,ilo,ihi,(lapack_complex_double *)compan,ldh,(lapack_complex_double *)wc,(lapack_complex_double *)zz,ldz);\n if (info) { fprintf(stderr,\"error in poly2lsf_z: lapacke decomposition failed\\n\"); return 1; }\n for (r=0; r10.0*DBL_EPSILON) ? atan2(wc[2*r+1],wc[2*r]) : 0.0; }\n for (c=1; c<=n; c++) { poly[2*c] += prev[2*c] + prev[2*c]; poly[2*c+1] += prev[2*c+1] + prev[2*c+1]; }\n cblas_zcopy(n*n,z,0,compan,1); cblas_zcopy(n-1,o,0,&compan[2],n+1); cblas_zcopy(n,&poly[2],1,compan,n);\n info = LAPACKE_zhseqr(LAPACK_COL_MAJOR,job,compz,n,ilo,ihi,(lapack_complex_double *)compan,ldh,(lapack_complex_double *)wc,(lapack_complex_double *)zz,ldz);\n if (info) { fprintf(stderr,\"error in poly2lsf_z: lapacke decomposition failed\\n\"); return 1; }\n for (c=0; c10.0*DBL_EPSILON) ? atan2(wc[2*r+1],wc[2*r]) : 0.0; }\n qsort(omegas,(size_t)(2*n),sizeof(double),cmp_ascend_d);\n if (iscolmajor) { cblas_dcopy(2*n,omegas,1,&Y[r],R); }\n else { cblas_dcopy(2*n,omegas,1,&Y[2*r*n],1); }\n }\n }\n else\n {\n fprintf(stderr,\"error in poly2lsf_z: dim must be 0 or 1.\\n\"); return 1;\n }\n\n //Exit\n free(compan); free(wc); free(poly); free(prev); free(omegas);\n return 0;\n}\n\n\n#ifdef __cplusplus\n}\n}\n#endif\n\n", "meta": {"hexsha": "9c08ef09227ffb83f01d9d67c40c2f28b9ffca89", "size": 22929, "ext": "c", "lang": "C", "max_stars_repo_path": "c/poly2lsf.c", "max_stars_repo_name": "erikedwards4/aud", "max_stars_repo_head_hexsha": "ee7adeb3b65d4ec45ad026cc915196b92c4b1c2b", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "c/poly2lsf.c", "max_issues_repo_name": "erikedwards4/aud", "max_issues_repo_head_hexsha": "ee7adeb3b65d4ec45ad026cc915196b92c4b1c2b", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "c/poly2lsf.c", "max_forks_repo_name": "erikedwards4/aud", "max_forks_repo_head_hexsha": "ee7adeb3b65d4ec45ad026cc915196b92c4b1c2b", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 63.1652892562, "max_line_length": 168, "alphanum_fraction": 0.5672728859, "num_tokens": 8536, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8438950947024555, "lm_q2_score": 0.5964331462646254, "lm_q1q2_score": 0.5033270064506695}} {"text": "#include \n#include \n#include \n#include \n#include \n\n#ifndef GSL_MAJOR_VERSION\n#define GSL_MAJOR_VERSION 1\n#endif\n#ifndef M_PI\n#define M_PI 3.14159265358979323846\n#endif\n//SCF Disk potential\n//4 arguments: amp, Acos, Asin, a\n\nconst int FORCE =1;\nconst int DERIV =2;\n\n//Useful Functions\n\n//Converts from cylindrical coordinates to spherical\nstatic inline void cyl_to_spher(double R, double Z,double *r, double *theta)\n{\n *r = sqrt(R*R + Z*Z);\n *theta = atan2(R, Z);\n}\n\n//Integer power\ndouble power(double x, int i)\n{\n if (i==0)\n return 1;\n return x*power(x,i - 1);\n}\n\n//Calculates xi\nstatic inline void calculateXi(double r, double a, double *xi)\n{\n *xi = (r - a)/(r + a);\n}\n\n\n//Potentials, forces, and derivative functions\n//LCOV_EXCL_START\ndouble computePhi(double Acos_val, double Asin_val, double mCos, double mSin, double P, double phiTilde, int m)\n{\n return (Acos_val*mCos + Asin_val*mSin)*P*phiTilde;\n}\n//LCOV_EXCL_STOP\ndouble computeAxiPhi(double Acos_val, double P, double phiTilde)\n{\n return Acos_val*P*phiTilde;\n}\n\ndouble computeF_r(double Acos_val, double Asin_val, double mCos, double mSin, double P, double dphiTilde, int m)\n{\n return -(Acos_val*mCos + Asin_val*mSin)*P*dphiTilde;\n}\ndouble computeAxiF_r(double Acos_val, double P, double dphiTilde)\n{\n return -Acos_val*P*dphiTilde;\n}\n\ndouble computeF_theta(double Acos_val, double Asin_val, double mCos, double mSin, double dP, double phiTilde, int m)\n{\n return -(Acos_val*mCos + Asin_val*mSin)*dP*phiTilde;\n}\ndouble computeAxiF_theta(double Acos_val, double dP, double phiTilde)\n{\n return -Acos_val*dP*phiTilde;\n}\n\ndouble computeF_phi(double Acos_val, double Asin_val, double mCos, double mSin, double P, double phiTilde, int m)\n{\n return m*(Acos_val*mSin - Asin_val*mCos)*P*phiTilde;\n}\ndouble computeAxiF_phi(double Acos_val, double P, double phiTilde)\n{\n return 0.;\n}\n\ndouble computeF_rr(double Acos_val, double Asin_val, double mCos, double mSin, double P, double d2phiTilde, int m)\n{\n return -(Acos_val*mCos + Asin_val*mSin)*P*d2phiTilde;\n}\ndouble computeAxiF_rr(double Acos_val, double P, double d2phiTilde)\n{\n return -Acos_val*P*d2phiTilde;\n}\n\ndouble computeF_rphi(double Acos_val, double Asin_val, double mCos, double mSin, double P, double dphiTilde, int m)\n{\n return m*(Acos_val*mSin - Asin_val*mCos)*P*dphiTilde;\n}\ndouble computeAxiF_rphi(double Acos_val, double P, double d2phiTilde)\n{\n return 0.;\n}\n\ndouble computeF_phiphi(double Acos_val, double Asin_val, double mCos, double mSin, double P, double phiTilde, int m)\n{\n return m*m*(Acos_val*mCos + Asin_val*mSin)*P*phiTilde;\n}\ndouble computeAxiF_phiphi(double Acos_val, double P, double d2phiTilde)\n{\n return 0.;\n}\n\n//Calculates the Gegenbauer polynomials\nvoid compute_C(double xi, int N, int L, double * C_array)\n{\n int l;\n for (l = 0; l < L; l++)\n {\n gsl_sf_gegenpoly_array(N - 1, 3./2 + 2*l, xi, C_array + l*N);\n }\n}\n\n//Calculates the derivative of the Gegenbauer polynomials\nvoid compute_dC(double xi, int N, int L, double * dC_array)\n{\n int n,l;\n for (l = 0; l < L; l++)\n {\n *(dC_array +l*N) = 0;\n if (N != 1)\n gsl_sf_gegenpoly_array(N - 2, 5./2 + 2*l, xi, dC_array + l*N + 1);\n for (n = 0; n1)\n *(d2C_array +l*N + 1) = 0;\n if (N > 2)\n gsl_sf_gegenpoly_array(N - 3, 7./2 + 2*l, xi, d2C_array + l*N + 2);\n for (n = 0; nargs;\n //Get args\n double a = *args++;\n int isNonAxi = (int)*args++;\n int N = (int)*args++;\n int L = (int)*args++;\n int M = (int)*args++;\n\n double* Acos = args;\n\n double* caching_i = (args + (isNonAxi + 1)*N*L*M);\n double *Asin;\n if (isNonAxi == 1)\n {\n Asin = args + N*L*M;\n }\n double *cached_type = caching_i;\n double * cached_coords = (caching_i+ 1);\n double * cached_values = (caching_i + 4);\n if ((int)*cached_type==FORCE)\n {\n if (*cached_coords == R && *(cached_coords + 1) == Z && *(cached_coords + 2) == phi)\n {\n *F = *cached_values;\n *(F + 1) = *(cached_values + 1);\n *(F + 2) = *(cached_values + 2);\n return;\n }\n }\n double r;\n double theta;\n cyl_to_spher(R, Z, &r, &theta);\n\n double xi;\n calculateXi(r, a, &xi);\n\n//Compute the gegenbauer polynomials and its derivative.\n double *C= (double *) malloc ( N*L * sizeof(double) );\n double *dC= (double *) malloc ( N*L * sizeof(double) );\n double *phiTilde= (double *) malloc ( N*L * sizeof(double) );\n double *dphiTilde= (double *) malloc ( N*L * sizeof(double) );\n\n compute_C(xi, N, L, C);\n compute_dC(xi, N, L, dC);\n\n//Compute phiTilde and its derivative\n compute_phiTilde(r, a, N, L, C, phiTilde);\n\n compute_dphiTilde(r, a, N, L, C, dC, dphiTilde);\n\n//Compute Associated Legendre Polynomials\n int M_eff = M;\n int size = 0;\n \n if (isNonAxi==0)\n {\n M_eff = 1;\n size = L; \n } else{\n size = L*L - L*(L-1)/2;\n }\n \n double *P= (double *) malloc ( size * sizeof(double) );\n double *dP= (double *) malloc ( size * sizeof(double) );\n compute_P_dP(cos(theta), L, M_eff, P, dP);\n\n double (*PhiTilde_Pointer[3]) = {dphiTilde,phiTilde,phiTilde};\n double (*P_Pointer[3]) = {P, dP, P};\n\n double Constant[3] = {1., -sin(theta), 1.};\n\n if (isNonAxi == 1)\n {\n double (*Eq[3])(double, double, double, double, double, double, int) = {&computeF_r, &computeF_theta, &computeF_phi};\n equations e = {Eq,&PhiTilde_Pointer[0], &P_Pointer[0], &Constant[0]};\n computeNonAxi(a, N, L, M,r, theta, phi, Acos, Asin, 3, e, F);\n }\n else\n {\n double (*Eq[3])(double, double, double) = {&computeAxiF_r, &computeAxiF_theta, &computeAxiF_phi};\n axi_equations e = {Eq,&PhiTilde_Pointer[0], &P_Pointer[0], &Constant[0]};\n compute(a, N, L, M,r, theta, phi, Acos, 3, e, F);\n }\n\n\n\n //Caching\n\n *cached_type = (double)FORCE;\n\n * cached_coords = R;\n * (cached_coords + 1) = Z;\n * (cached_coords + 2) = phi;\n * (cached_values) = *F;\n * (cached_values + 1) = *(F + 1);\n * (cached_values + 2) = *(F + 2);\n\n // Free memory\n free(C);\n free(dC);\n free(phiTilde);\n free(dphiTilde);\n free(P);\n free(dP);\n\n}\n\n//Compute the Derivatives\nvoid computeDeriv(double R,double Z, double phi,\n\t\t double t,\n\t\t struct potentialArg * potentialArgs, double * F)\n{\n double * args= potentialArgs->args;\n //Get args\n double a = *args++;\n int isNonAxi = (int)*args++;\n int N = (int) *args++;\n int L = (int) *args++;\n int M = (int) *args++;\n double* Acos = args;\n\n double * caching_i = (args + (isNonAxi + 1)*N*L*M);\n double *Asin;\n if (isNonAxi == 1)\n {\n Asin = args + N*L*M;\n }\n\n double *cached_type = caching_i;\n double * cached_coords = (caching_i+ 1);\n double * cached_values = (caching_i + 4);\n if ((int)*cached_type==DERIV)\n {\n if (*cached_coords == R && *(cached_coords + 1) == Z && *(cached_coords + 2) == phi)\n {\n *F = *cached_values;\n *(F + 1) = *(cached_values + 1);\n *(F + 2) = *(cached_values + 2);\n return;\n }\n }\n\n double r;\n double theta;\n cyl_to_spher(R, Z, &r, &theta);\n\n double xi;\n calculateXi(r, a, &xi);\n\n//Compute the gegenbauer polynomials and its derivative.\n double *C= (double *) malloc ( N*L * sizeof(double) );\n double *dC= (double *) malloc ( N*L * sizeof(double) );\n double *d2C= (double *) malloc ( N*L * sizeof(double) );\n double *phiTilde= (double *) malloc ( N*L * sizeof(double) );\n double *dphiTilde= (double *) malloc ( N*L * sizeof(double) );\n double *d2phiTilde= (double *) malloc ( N*L * sizeof(double) );\n\n compute_C(xi, N, L, C);\n compute_dC(xi, N, L, dC);\n compute_d2C(xi, N, L, d2C);\n\n//Compute phiTilde and its derivative\n compute_phiTilde(r, a, N, L, C, phiTilde);\n compute_dphiTilde(r, a, N, L, C, dC, dphiTilde);\n compute_d2phiTilde(r, a, N, L, C, dC, d2C, d2phiTilde);\n\n\n//Compute Associated Legendre Polynomials\n int M_eff = M;\n int size = 0;\n \n if (isNonAxi==0)\n {\n M_eff = 1;\n size = L; \n } else{\n size = L*L - L*(L-1)/2;\n }\n double *P= (double *) malloc ( size * sizeof(double) );\n\n compute_P(cos(theta), L,M_eff, P);\n\n double (*PhiTilde_Pointer[3])= {d2phiTilde,phiTilde,dphiTilde};\n double (*P_Pointer[3]) = {P, P, P};\n\n double Constant[3] = {1., 1., 1.};\n\n if (isNonAxi==1)\n {\n double (*Eq[3])(double, double, double, double, double, double, int) = {&computeF_rr, &computeF_phiphi, &computeF_rphi};\n equations e = {Eq,&PhiTilde_Pointer[0],&P_Pointer[0],&Constant[0]};\n computeNonAxi(a, N, L, M,r, theta, phi, Acos, Asin, 3, e, F);\n }\n else\n {\n double (*Eq[3])(double, double, double) = {&computeAxiF_rr, &computeAxiF_phiphi, &computeAxiF_rphi};\n axi_equations e = {Eq,&PhiTilde_Pointer[0],&P_Pointer[0],&Constant[0]};\n compute(a, N, L, M,r, theta, phi, Acos, 3, e, F);\n }\n\n\n //Caching\n\n *cached_type = (double)DERIV;\n\n * cached_coords = R;\n * (cached_coords + 1) = Z;\n * (cached_coords + 2) = phi;\n * (cached_values) = *F;\n * (cached_values + 1) = *(F + 1);\n * (cached_values + 2) = *(F + 2);\n\n //Free memory\n free(C);\n free(dC);\n free(d2C);\n free(phiTilde);\n free(dphiTilde);\n free(d2phiTilde);\n free(P);\n}\n\n//Compute the Potential\ndouble SCFPotentialEval(double R,double Z, double phi,\n double t,\n struct potentialArg * potentialArgs)\n{\n double * args= potentialArgs->args;\n //Get args\n double a = *args++;\n int isNonAxi = (int)*args++;\n int N = (int) *args++;\n int L = (int) *args++;\n int M = (int) *args++;\n double* Acos = args;\n double* Asin;\n if (isNonAxi==1) //LCOV_EXCL_START\n {\n Asin = args + N*L*M;\n } //LCOV_EXCL_STOP\n //convert R,Z to r, theta\n double r;\n double theta;\n cyl_to_spher(R, Z,&r, &theta);\n double xi;\n calculateXi(r, a, &xi);\n\n //Compute the gegenbauer polynomials and its derivative.\n double *C= (double *) malloc ( N*L * sizeof(double) );\n double *phiTilde= (double *) malloc ( N*L * sizeof(double) );\n\n compute_C(xi, N, L, C);\n\n //Compute phiTilde and its derivative\n compute_phiTilde(r, a, N, L, C, phiTilde);\n //Compute Associated Legendre Polynomials\n\n int M_eff = M;\n int size = 0;\n \n if (isNonAxi==0)\n {\n M_eff = 1;\n size = L; \n } else{ //LCOV_EXCL_START\n size = L*L - L*(L-1)/2;\n } //LCOV_EXCL_STOP\n \n double *P= (double *) malloc ( size * sizeof(double) );\n\n compute_P(cos(theta), L,M_eff, P);\n\n double potential;\n\n double (*PhiTilde_Pointer[1]) = {phiTilde};\n double (*P_Pointer[1]) = {P};\n\n double Constant[1] = {1.};\n\n if (isNonAxi==1) //LCOV_EXCL_START\n {\n double (*Eq[1])(double, double, double, double, double, double, int) = {&computePhi};\n equations e = {Eq,&PhiTilde_Pointer[0],&P_Pointer[0],&Constant[0]};\n computeNonAxi(a, N, L, M,r, theta, phi, Acos, Asin, 1, e, &potential);\n } //LCOV_EXCL_STOP\n else\n {\n double (*Eq[1])(double, double, double) = {&computeAxiPhi};\n axi_equations e = {Eq,&PhiTilde_Pointer[0],&P_Pointer[0],&Constant[0]};\n compute(a, N, L, M,r, theta, phi, Acos, 1, e, &potential);\n }\n\n //Free memory\n free(C);\n free(phiTilde);\n free(P);\n\n return potential;\n\n}\n\n//Compute the force in the R direction\ndouble SCFPotentialRforce(double R,double Z, double phi,\n double t,\n struct potentialArg * potentialArgs)\n{\n double r;\n double theta;\n cyl_to_spher(R, Z, &r, &theta);\n // The derivatives\n double dr_dR = R/r;\n double dtheta_dR = Z/(r*r);\n double dphi_dR = 0;\n\n\n double F[3];\n computeForce(R, Z, phi, t,potentialArgs, &F[0]) ;\n\n return *(F + 0)*dr_dR + *(F + 1)*dtheta_dR + *(F + 2)*dphi_dR;\n\n\n}\n\n//Compute the force in the z direction\ndouble SCFPotentialzforce(double R,double Z, double phi,\n double t,\n struct potentialArg * potentialArgs)\n{\n double r;\n double theta;\n cyl_to_spher(R, Z,&r, &theta);\n\n double dr_dz = Z/r;\n double dtheta_dz = -R/(r*r);\n double dphi_dz = 0;\n\n double F[3];\n computeForce(R, Z, phi, t,potentialArgs, &F[0]) ;\n return *(F + 0)*dr_dz + *(F + 1)*dtheta_dz + *(F + 2)*dphi_dz;\n}\n\n//Compute the force in the phi direction\ndouble SCFPotentialphiforce(double R,double Z, double phi,\n double t,\n struct potentialArg * potentialArgs)\n{\n\n double r;\n double theta;\n cyl_to_spher(R, Z, &r, &theta);\n\n double dr_dphi = 0;\n double dtheta_dphi = 0;\n double dphi_dphi = 1;\n\n double F[3];\n computeForce(R, Z, phi, t,potentialArgs, &F[0]) ;\n\n return *(F + 0)*dr_dphi + *(F + 1)*dtheta_dphi + *(F + 2)*dphi_dphi;\n}\n\n//Compute the planar force in the R direction\ndouble SCFPotentialPlanarRforce(double R,double phi,\n double t,\n struct potentialArg * potentialArgs)\n{\n return SCFPotentialRforce(R,0., phi,t,potentialArgs);\n\n}\n\n//Compute the planar force in the phi direction\ndouble SCFPotentialPlanarphiforce(double R,double phi,\n double t,\n struct potentialArg * potentialArgs)\n{\n return SCFPotentialphiforce(R,0., phi,t,potentialArgs);\n}\n\n\n//Compute the planar double derivative of the potential with respect to R\ndouble SCFPotentialPlanarR2deriv(double R, double phi,\n double t,\n struct potentialArg * potentialArgs)\n{\n double Farray[3];\n computeDeriv(R, 0, phi, t,potentialArgs, &Farray[0]) ;\n return *Farray;\n}\n\n//Compute the planar double derivative of the potential with respect to phi\ndouble SCFPotentialPlanarphi2deriv(double R, double phi,\n double t,\n struct potentialArg * potentialArgs)\n{\n double Farray[3];\n computeDeriv(R, 0, phi, t,potentialArgs, &Farray[0]) ;\n return *(Farray + 1);\n}\n\n//Compute the planar double derivative of the potential with respect to R, Phi\ndouble SCFPotentialPlanarRphideriv(double R, double phi,\n double t,\n struct potentialArg * potentialArgs)\n{\n double Farray[3];\n computeDeriv(R, 0, phi, t,potentialArgs, &Farray[0]) ;\n return *(Farray + 2);\n}\n", "meta": {"hexsha": "e441c2536a54bbb1178e32d08c61d067350ffd15", "size": 21486, "ext": "c", "lang": "C", "max_stars_repo_path": "galpy/potential/potential_c_ext/SCFPotential.c", "max_stars_repo_name": "turnergarrow/galpy", "max_stars_repo_head_hexsha": "7132eddbf2dab491fe137790e31eacdc604b0534", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2019-02-07T10:58:17.000Z", "max_stars_repo_stars_event_max_datetime": "2019-02-07T10:58:17.000Z", "max_issues_repo_path": "galpy/potential/potential_c_ext/SCFPotential.c", "max_issues_repo_name": "BurcuAkbulut/galpy", "max_issues_repo_head_hexsha": "cabb42bef3b4f88a2f593cdb123452cd41451db3", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "galpy/potential/potential_c_ext/SCFPotential.c", "max_forks_repo_name": "BurcuAkbulut/galpy", "max_forks_repo_head_hexsha": "cabb42bef3b4f88a2f593cdb123452cd41451db3", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2020-07-30T06:14:31.000Z", "max_forks_repo_forks_event_max_datetime": "2020-07-30T06:14:31.000Z", "avg_line_length": 26.3308823529, "max_line_length": 128, "alphanum_fraction": 0.5420273667, "num_tokens": 6784, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8333245953120234, "lm_q2_score": 0.6039318337259584, "lm_q1q2_score": 0.5032712509357324}} {"text": "/*\r\n * mcmc_lotkavolterra.c\r\n *\r\n * Created on: 15/11/2015\r\n * Author: Laura Ferrer\r\n */\r\n\r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#include \r\n#define USAGE \"./mcmc_lotkavolterra.x n_steps n_burn\"\r\n\r\nvoid leer(double *tiempo, double *presa, double *depredador, int n_puntos);\r\ndouble* iniciar(int n_puntos);\r\n\r\nint main (int argc, char **argv)\r\n{\t\r\n\tint i=0;\r\n\tint lineas = 0;\r\n\tint iteraciones = atof(argv[2])+atof(argv[1]);\r\n\tint corte = atof(argv[2]);\r\n\r\n\tdouble a = 1;\r\n\tdouble b = 1;\r\n\tdouble c = 1;\r\n\tdouble d = 1;\r\n\r\n\tdouble a2;\r\n\tdouble b2;\r\n\tdouble c2;\r\n\tdouble d2;\r\n\r\n\tFILE *file;\r\n\tfile = fopen(\"lotka_volterra_obs.dat\", \"r\");\r\n\r\n\twhile(!feof(file)) //Cuenta la cantidad de datos provistos.\r\n\t{\r\n \t\tchar ch = fgetc(file);\r\n \t\tif(ch == '\\n')\r\n \t\t{\r\n \t\t\tlineas++;\r\n \t\t}\r\n\t}\r\n\r\n\tfclose(file);\r\n\r\n\tlineas --;// menos la primera línea\r\n\r\n\tdouble *x = iniciar(lineas);\r\n\tdouble *y= iniciar(lineas);\r\n\tdouble *x_real=\tiniciar(lineas);\r\n\tdouble *y_real = iniciar(lineas);\r\n\tdouble *t = iniciar(lineas);\r\n\tdouble *lay = iniciar(lineas);\r\n\tdouble *lax = iniciar(lineas);\r\n\r\n\tleer(t,x_real,y_real,lineas);\r\n\tlay[0]=y_real[0];\r\n\tlax[0]=x_real[0];\r\n\r\n\tdouble parecido (double modo)\r\n\t{\t\r\n\t\ti = 0;\r\n\t\tdouble suma=0;\r\n\t\tif (modo == 1)\r\n\t\t{\r\n\r\n\t\t\tfor (i = 0; i < lineas; i += 1)\r\n\t\t\t{\r\n\t\t\t\tsuma += pow(x[i]-y_real[i],2.0);\r\n\t\t\t\tsuma += pow(y[i]-x_real[i],2.0);\r\n\t\t\t}\r\n\r\n\t\t}\r\n\r\n\t\tif (modo == 2)\r\n\t\t{\r\n\r\n\t\t\tfor (i = 0; i < lineas; i += 1)\r\n\t\t\t{\r\n\t\t\t\tsuma += pow(lax[i]-y_real[i],2.0);\r\n\t\t\t\tsuma += pow(lay[i]-x_real[i],2.0);\r\n\t\t\t}\r\n\t\t}\r\n\r\n\t\treturn (1.0/2.0)*suma;\r\n\t}\r\n\r\n\tdouble dx (double x, double y, double la, double lb)\r\n\t{\r\n\t\tdouble dx = x*(la-lb*y);\r\n\t\treturn dx;\r\n\t}\r\n\r\n\tdouble dy (double x, double y, double lc, double ld)\r\n\t{\r\n\t\tdouble dy = -y*(lc-ld*x);\r\n\t\treturn dy;\r\n\t}\r\n\r\n\tvoid kutta4 (double la, double lb, double lc, double ld)\r\n\t{\r\n\t\t\r\n\t\tdouble h = t[1]-t[0];\r\n\t\ti = 1;\r\n\r\n\t\tfor (i = 1; i < lineas; i += 1)\r\n\t\t{\r\n\t\t\t//Inicio\r\n\t\t\tdouble kx1 = dx(lax[i-1],lay[i-1],la,lb);\r\n\t\t\tdouble ky1 = dy(lax[i-1],lay[i-1],lc,ld);\r\n\r\n\t\t\t//paso 1\r\n\t\t\tdouble x1 = lax[i-1] + (h/2.0)*kx1;\r\n\t\t\tdouble y1 = lay[i-1] + (h/2.0)*ky1;\r\n\r\n\t\t\tdouble kx2 = dx(x1,y1,la,lb);\r\n\t\t\tdouble ky2 = dy(x1,y1,lc,ld);\r\n\r\n\t\t\t//paso 2\r\n\t\t\tdouble x2 = lax[i-1] + (h/2.0)*kx2;\r\n\t\t\tdouble y2 = lay[i-1] + (h/2.0)*ky2;\r\n\r\n\t\t\tdouble kx3 = dx(x2,y2,la,lb);\r\n\t\t\tdouble ky3 = dy(x2,y2,lc,ld);\r\n\r\n\t\t\t//paso 3\r\n\t\t\tdouble x3 = lax[i-1] + h*kx3;\r\n\t\t\tdouble y3 = lay[i-1] + h*ky3;\r\n\r\n\t\t\tdouble kx4 = dx(x3,y3,la,lb);\r\n\t\t\tdouble ky4 = dy(x3,y3,lc,ld);\r\n\r\n\t\t\t//paso 4\r\n\r\n\t\t\tdouble mx = (1.0/6.0)*(kx1 + 2.0*kx2+2.0*kx3+kx4);\r\n\t\t\tdouble my = (1.0/6.0)*(ky1 + 2.0*ky2+2.0*ky3+ky4);\r\n\r\n\t\t\tlax[i]= lax[i-1] + h*mx;\r\n\t\t\tlay[i]= lay[i-1] + h*my;\r\n\r\n\t\t}\r\n\t}\r\n\r\n\tvoid mcmc()\r\n\t{\r\n\t\tint k = 1;\r\n\t\tfor (k = 1; k < iteraciones; k++)\r\n\t\t{\t\r\n \t\t\tconst gsl_rng_type * T;\r\n \t\t\tgsl_rng * r;\r\n \t\t\tgsl_rng_env_setup();\r\n \t\t\tT = gsl_rng_default;\r\n \t\t\tr = gsl_rng_alloc (T);\r\n\r\n\t\t\ta2 = a + (2*gsl_ran_gaussian(r,drand48())+1);\r\n\t\t\tsrand((unsigned)time(NULL));\r\n\t\t\tb2 = b + (2*gsl_ran_gaussian(r,drand48())+1);\r\n\t\t\tsrand((unsigned)time(NULL));\r\n\t\t\tc2 = c + (2*gsl_ran_gaussian(r,drand48())+1);\r\n\t\t\tsrand((unsigned)time(NULL));\r\n\t\t\td2 = d + (2*gsl_ran_gaussian(r,drand48())+1);\r\n\t\t\tsrand((unsigned)time(NULL));\r\n\r\n\t\t\tkutta4(a,b,c,d);\r\n\t\t\t\r\n\t\t\tint j =0;\r\n\r\n\t\t\tfor (j = 0; j < lineas; j++) // Copia las listas\r\n\t\t\t{\r\n \t\t\t\tx[j] = lax[j];\r\n\t\t\t\ty[j] = lay[j];\r\n \t\t\t}\r\n\r\n\t\t\tkutta4(a2,b2,c2,d2);\r\n\r\n\t\t\t// Calculo de los errores y similitudes\r\n\t\t\tdouble difvieja = parecido(1);\r\n\t\t\tdouble difnueva = parecido(2);\r\n\r\n\t\t\tif (difnueva < difvieja)\r\n\t\t\t{\r\n\t\t\t\ta=a2;\r\n \t \t\tb=b2;\r\n \t \t\tc=c2;\r\n \t \t\td=d2;\r\n\t\t\t\tif (k>corte) {printf (\"%g,%g,%g,%g\\n\",a,b,c,d);}\r\n\t\t\t}\r\n\t\t\telse\r\n\t\t\t{\t\r\n\r\n\t\t\t\tsrand((unsigned)time(NULL));\r\n\t\t\t\tdouble alfa = difvieja/difnueva;\r\n\t\t\t\tdouble beta = drand48(); \r\n\t\t\t\t\r\n\t\t\t\tif (beta >= alfa)\r\n\t\t\t\t{\r\n\t\t\t\t\ta=a2;\r\n \t \t\t\tb=b2;\r\n \t \t\t\tc=c2;\r\n \t \t\t\td=d2;\r\n\t\t\t\t\tif (k>corte) {printf (\"%g,%g,%g,%g\\n\",a,b,c,d);}\r\n\t\t\t\t}\r\n\t\t\t\telse if (k>corte)\r\n\t\t\t\t{\r\n\t\t\t\t\tprintf (\"%g,%g,%g,%g\\n\",a,b,c,d);\r\n\t\t\t\t}\t\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n\r\n\tmcmc();\r\n\treturn 0;\r\n}\r\n\r\nvoid leer(double *tiempo, double *presa, double *depredador, int n_puntos)\r\n{\t\r\n\tFILE *file;\r\n\tint j;\r\n\tfile = fopen(\"lotka_volterra_obs.dat\", \"r\");\r\n\trewind(file);\r\n\tfscanf(file,\"%*[^\\n]\\n\"); //Lee cualquier cosa en la primera línea\r\n\tfor(j=0;j output.txt`\r\n\r\nTODO: Export all functions which are specific to the beta-binomial model into\r\nsmc.h, and perhaps rename smc.h as beta_binomial.h\r\n\r\nAuthor: Juvid Aryaman\r\n*/\r\n\r\n#include \r\n#include \r\n#include \r\n\r\n#include \r\n#include \r\n#include \r\n#include \r\n\r\n#define N_DATA 50\r\n#define N_TRUTH 10\r\n\r\n#define PRIOR_ALPHA 0.5\r\n#define PRIOR_BETA 0.5\r\n\r\n#define N_PARTICLES 5000\r\n#define N_ROUNDS_SMC 50\r\n#define KERNEL_SD 0.05\r\n#define QUANTILE_ACCEPT_DISTANCE 0.8\r\n\r\n#define RND gsl_rng_uniform(r)\r\n#define SEED 1\r\n#define DISTANCE_THRESHOLD_INIT 10\r\n\r\n#define OUTFILE_NAME \"particles.csv\"\r\n\r\n//#define DEBUG_MODE\r\n\r\n#include \"smc.h\"\r\n\r\nint main(int argc, char *argv[]) {\r\n\r\n/* set up GSL RNG */\r\ngsl_rng *r = gsl_rng_alloc(gsl_rng_mt19937);\r\n/* end of GSL setup */\r\n\r\ngsl_rng_set(r, SEED);\r\n\r\n/////////////////////////\r\n/*Read data*/\r\n/////////////////////////\r\n\r\nFILE *data_pointer;\r\n\r\ndata_pointer = fopen(\"binom_data.csv\", \"r\");\r\n\r\nint data[N_DATA];\r\nint i, j, read_error_status;\r\nfor (i=0; i < N_DATA; i++){\r\n\tread_error_status = fscanf(data_pointer, \"%d\\n\", &data[i]);\r\n}\r\nif (read_error_status != 1){printf(\"Error reading data\\n\"); return 0;}\r\n\r\n\r\n/////////////////////////\r\n/*Initialise variables*/\r\n/////////////////////////\r\n\r\n/*Make a (N_ROUNDS_SMC X N_PARTICLES) array to store all particles at all rounds\r\nof SMC*/\r\ndouble** theta_particle;\r\ntheta_particle = (double**) malloc(N_ROUNDS_SMC * sizeof(double*));\r\nfor (i = 0; i < N_ROUNDS_SMC; i++){\r\n\ttheta_particle[i] = (double*) malloc(N_PARTICLES * sizeof(double));\r\n}\r\n\r\ndouble distance_threshold = DISTANCE_THRESHOLD_INIT;\r\nint *simulated_data = (int*) malloc(N_DATA * sizeof(int));\r\ndouble *distance = malloc(N_PARTICLES * sizeof(double));\r\ndouble *weight = malloc(N_PARTICLES * sizeof(double));\r\ndouble weight_normalizer = 0.0;\r\n\r\nint time_smc=0; // an index of each round of SMC\r\nint param_index_chosen;\r\n\r\n/////////////////////////\r\n/*Perform ABC SMC*/\r\n/////////////////////////\r\n\r\n/*For every round of SMC*/\r\nfor (time_smc = 0; time_smc < N_ROUNDS_SMC; time_smc++) {\r\n\t#ifndef DEBUG_MODE\r\n\t\tprintf(\"Round %d of SMC\\n\", time_smc);\r\n\t#endif\r\n\r\n\t/*Draw or perturb a particle and compute distance*/\r\n\tfor (i = 0; i < N_PARTICLES; i++) {\r\n\t\tdistance[i] = distance_threshold + 1.0; // reset distance of particle i\r\n\t\twhile (distance[i] > distance_threshold) {\r\n\t\t\tif (time_smc == 0) {\r\n\t\t\t\t// Sample from the prior\r\n\t\t\t\ttheta_particle[0][i] = gsl_ran_beta(r, PRIOR_ALPHA, PRIOR_BETA);\r\n\t\t\t}\r\n\t\t\telse{\r\n\t\t\t\t/*Sample from the old weights and perturb*/\r\n\t\t\t\tparam_index_chosen = weighted_choice(r, weight);\r\n\t\t\t\tif ((param_index_chosen < 0)||(param_index_chosen >= N_PARTICLES)) {\r\n\t\t\t\t\tprintf(\"Error in param_index_chosen\\n\"); return -1;\r\n\t\t\t}\r\n\t\t\t\ttheta_particle[time_smc][i] =\r\n\t\t\t\t\ttheta_particle[time_smc-1][param_index_chosen] +\r\n\t\t\t\t\tgsl_ran_gaussian(r, KERNEL_SD);\r\n\r\n\t\t\t\t// check if bounds of prior exceeded\r\n\t\t\t\tif((theta_particle[time_smc][i]<0) || (theta_particle[time_smc][i] > 1)) continue;\r\n\t\t\t}\r\n\r\n\t\t\t// Simulate a candidate dataset\r\n\t\t\tfor (j = 0; j < N_DATA; j++) {\r\n\t\t\t\tsimulated_data[j] = gsl_ran_binomial(r, theta_particle[time_smc][i], N_TRUTH);\r\n\t\t\t}\r\n\r\n\t\t\t// Compute distance between data and simulation\r\n\t\t\tdistance[i] = distance_metric(data, simulated_data);\r\n\r\n\t\t}\r\n\t}\r\n\t#ifndef DEBUG_MODE\r\n\t\tprintf(\"Particles sampled.\\n\");\r\n\t#endif\r\n\r\n\t/*Compute weights*/\r\n\tif (time_smc==0){ for (i = 0; i < N_PARTICLES; i++) weight[i] = 1.0;}\r\n\telse{\r\n\t\tweight_normalizer = 0.0;\r\n\t\tfor (i = 0; i < N_PARTICLES; i++) {\r\n\t\t\tweight_normalizer += weight[i]*kernel_pdf(theta_particle[time_smc-1][i],\r\n\t\t\t\ttheta_particle[time_smc][i]);\r\n\t\t}\r\n\r\n\t\tfor (i = 0; i < N_PARTICLES; i++) {\r\n\t\t\tweight[i] = prior_pdf(theta_particle[time_smc][i])/weight_normalizer;\r\n\t\t}\r\n\r\n\t}\r\n\r\n\t/*Normalise weights*/\r\n\tweight_normalizer = 0.0;\r\n\tfor (i = 0; i < N_PARTICLES; i++)\tweight_normalizer += weight[i];\r\n\tfor (i = 0; i < N_PARTICLES; i++)\tweight[i] = weight[i]/weight_normalizer;\r\n\r\n\r\n\t/* Resample weights*/\r\n\tdistance_threshold = update_distance_threshold(distance);\r\n\r\n}\r\n\r\n#ifndef DEBUG_MODE\r\n\tprintf(\"Writing particles to file\\n\");\r\n#endif\r\n\twrite_particles_to_csv(theta_particle);\r\n#ifndef DEBUG_MODE\r\n\tprintf(\"Done!\\n\");\r\n#endif\r\n\r\nreturn 0; //return from main\r\n} //close main\r\n", "meta": {"hexsha": "94f51bb74201f935f590a796c7ddad5882350d71", "size": 4819, "ext": "c", "lang": "C", "max_stars_repo_path": "Notebooks/ABC_SMC/Beta_binomial_model/smc.c", "max_stars_repo_name": "jaryaman/ML_demos", "max_stars_repo_head_hexsha": "df270b58d35d1248079e4651988ded4074237bfc", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 2.0, "max_stars_repo_stars_event_min_datetime": "2018-07-28T18:14:12.000Z", "max_stars_repo_stars_event_max_datetime": "2018-07-31T16:51:10.000Z", "max_issues_repo_path": "Notebooks/ABC_SMC/Beta_binomial_model/smc.c", "max_issues_repo_name": "jaryaman/ML_demos", "max_issues_repo_head_hexsha": "df270b58d35d1248079e4651988ded4074237bfc", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 3.0, "max_issues_repo_issues_event_min_datetime": "2020-06-21T18:23:19.000Z", "max_issues_repo_issues_event_max_datetime": "2020-09-28T14:21:39.000Z", "max_forks_repo_path": "Notebooks/ABC_SMC/Beta_binomial_model/smc.c", "max_forks_repo_name": "jaryaman/ML_demos", "max_forks_repo_head_hexsha": "df270b58d35d1248079e4651988ded4074237bfc", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2018-07-02T14:25:20.000Z", "max_forks_repo_forks_event_max_datetime": "2018-07-02T14:25:20.000Z", "avg_line_length": 27.2259887006, "max_line_length": 87, "alphanum_fraction": 0.6596804316, "num_tokens": 1328, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7520125626441471, "lm_q2_score": 0.6688802735722128, "lm_q1q2_score": 0.5030063686311579}} {"text": "//This takes univariate X, windows X with W, applies the 1D FFT to each frame,\n//takes power, transforms with T mat to B cfs, and then compresses power.\n//The output Y is power (real-valued), i.e. the FFT squared.\n//The size of Y is BxC if dim==0, and RxB if dim==1.\n\n//This is equivalent to stft -> apply_spectrogram_T_mat -> pow_compress.\n\n#include \n#include \n#include \n#include \n#include \n\n#ifdef __cplusplus\nnamespace codee {\nextern \"C\" {\n#endif\n\nint spectrogram_s (float *Y, const float *X1, const float *X2, const float *X3, const size_t N, const size_t L, const size_t B, const size_t F, const int c0, const float stp, const int mn0, const float p, const float preg);\n\nint spectrogram_s (float *Y, const int iscolmajor, const int R, const int C, const float *X, const int N, const float *W, const int L, const float *H, const int dim, const int c0, const float stp, const int mn0, const int nfft, const float p, const float preg);\nint spectrogram_d (double *Y, const int iscolmajor, const int R, const int C, const double *X, const int N, const double *W, const int L, const double *H, const int dim, const int c0, const double stp, const int mn0, const int nfft, const double p, const double preg);\n\n\nint spectrogram_s (float *Y, const int iscolmajor, const int R, const int C, const float *X, const int N, const float *W, const int L, const float *H, const int dim, const int c0, const float stp, const int mn0, const int nfft, const float p, const float preg)\n{\n const float z = 0.0f, o = 1.0f;\n const int F = nfft/2 + 1; //num non-negative FFT freqs\n const int Lpre = L/2; //nsamps before center samp\n int ss = c0 - Lpre; //start samp of current frame\n int r, c, f, n = 0;\n float *X1, *Y1;\n fftwf_plan plan;\n //struct timespec tic, toc;\n\n //Checks\n if (N<1) { fprintf(stderr,\"error in spectrogram_s: N (length X) must be positive\\n\"); return 1; }\n if (R<1) { fprintf(stderr,\"error in spectrogram_s: R (nrows Y) must be positive\\n\"); return 1; }\n if (C<1) { fprintf(stderr,\"error in spectrogram_s: C (ncols Y) must be positive\\n\"); return 1; }\n if (L<1) { fprintf(stderr,\"error in spectrogram_s: L (winlength) must be positive\\n\"); return 1; }\n if (c0<0) { fprintf(stderr,\"error in spectrogram_s: c0 (center samp of 1st frame) must be nonnegative\\n\"); return 1; }\n if (c0>N-1) { fprintf(stderr,\"error in spectrogram_s: c0 (center samp of 1st frame) must be < N (length X)\\n\"); return 1; }\n if (L>=N) { fprintf(stderr,\"error in spectrogram_s: L (winlength) must be < N (length X)\\n\"); return 1; }\n if (stp<=0.0f) { fprintf(stderr,\"error in spectrogram_s: stp (step size) must be positive\\n\"); return 1; }\n if (nfft= L (winlength)\\n\"); return 1; }\n if (p!=p || p<0.0f || p>1.0f) { fprintf(stderr,\"error in spectrogram_s: p must be in [0.0 1.0]\\n\"); return 1; }\n if (preg!=preg || preg<0.0f) { fprintf(stderr,\"error in spectrogram_s: preg must be nonnegative\\n\"); return 1; }\n\n //Initialize fftwf\n X1 = fftwf_alloc_real((size_t)nfft);\n Y1 = fftwf_alloc_real((size_t)nfft);\n plan = fftwf_plan_r2r_1d(nfft,X1,Y1,FFTW_R2HC,FFTW_ESTIMATE);\n if (!plan) { fprintf(stderr,\"error in spectrogram_s: problem creating fftw plan\\n\"); return 1; }\n cblas_scopy(nfft,&z,0,&X1[0],1); //zero-pad\n\n //clock_gettime(CLOCK_REALTIME,&tic);\n\n //Initialize Y to preg\n cblas_scopy(R*C,&preg,0,&Y[0],1);\n\n if (dim==0)\n {\n if (iscolmajor)\n {\n for (c=0; cFLT_EPSILON)\n {\n if (p>FLT_EPSILON)\n {\n if (fabsf(p-0.5f)<=FLT_EPSILON) { for (n=0; nN-1) { fprintf(stderr,\"error in spectrogram_d: c0 (center samp of 1st frame) must be < N (length X)\\n\"); return 1; }\n if (L>=N) { fprintf(stderr,\"error in spectrogram_d: L (winlength) must be < N (length X)\\n\"); return 1; }\n if (stp<=0.0) { fprintf(stderr,\"error in spectrogram_d: stp (step size) must be positive\\n\"); return 1; }\n if (nfft= L (winlength)\\n\"); return 1; }\n if (p!=p || p<0.0 || p>1.0) { fprintf(stderr,\"error in spectrogram_d: p must be in [0.0 1.0]\\n\"); return 1; }\n if (preg!=preg || preg<0.0) { fprintf(stderr,\"error in spectrogram_d: preg must be nonnegative\\n\"); return 1; }\n\n //Initialize fftw\n X1 = fftw_alloc_real((size_t)nfft);\n Y1 = fftw_alloc_real((size_t)nfft);\n plan = fftw_plan_r2r_1d(nfft,X1,Y1,FFTW_R2HC,FFTW_ESTIMATE);\n if (!plan) { fprintf(stderr,\"error in spectrogram_d: problem creating fftw plan\\n\"); return 1; }\n cblas_dcopy(nfft,&z,0,&X1[0],1); //zero-pad\n\n //Initialize Y to preg\n cblas_dcopy(R*C,&preg,0,&Y[0],1);\n\n if (dim==0)\n {\n if (iscolmajor)\n {\n for (c=0; cDBL_EPSILON)\n {\n if (p>DBL_EPSILON)\n {\n if (fabs(p-0.5)<=DBL_EPSILON) { for (n=0; n\n#include \n#include \n\n/* This is a combined multiple recursive generator. The sequence is,\n\n z_n = (x_n - y_n) mod m1\n\n where the two underlying generators x and y are,\n\n x_n = (a_{1} x_{n-1} + a_{2} x_{n-2} + a_{3} x_{n-3}) mod m1\n y_n = (b_{1} y_{n-1} + b_{2} y_{n-2} + b_{3} y_{n-3}) mod m2\n\n with coefficients a11 ... a23,\n\n a_{1} = 0, a_{2} = 63308, a_{3} = -183326\n b_{1} = 86098, b_{2} = 0, b_{3} = -539608\n\n and moduli m1, m2,\n\n m1 = 2^31 - 1 = 2147483647\n m2 = 2^31 - 2000169 = 2145483479\n\n We initialize the generator with \n\n x_1 = s_1 MOD m1, x_2 = s_2 MOD m1, x_3 = s_3 MOD m1\n y_1 = s_4 MOD m2, y_2 = s_5 MOD m2, y_3 = s_6 MOD m2\n\n where s_n = (69069 * s_{n-1}) mod 2^32 and s_0 = s is the\n user-supplied seed.\n\n NOTE: According to the paper the initial values for x_n must lie in\n the range 0 <= x_n <= (m1 - 1) and the initial values for y_n must\n lie in the range 0 <= y_n <= (m2 - 1), with at least one non-zero\n value -- our seeding procedure satisfies these constraints.\n\n We then use 7 iterations of the generator to \"warm up\" the internal\n state.\n\n The theoretical value of z_{10008} is 719452880. The subscript 10008\n means (1) seed the generator with s=1, (2) do the seven warm-up\n iterations that are part of the seeding process, (3) then do 10000\n actual iterations.\n\n The period of this generator is about 2^205.\n\n From: P. L'Ecuyer, \"Combined Multiple Recursive Random Number\n Generators,\" Operations Research, 44, 5 (1996), 816--822.\n\n This is available on the net from L'Ecuyer's home page,\n\n http://www.iro.umontreal.ca/~lecuyer/myftp/papers/combmrg.ps\n ftp://ftp.iro.umontreal.ca/pub/simulation/lecuyer/papers/combmrg.ps */\n\nstatic inline unsigned long int cmrg_get (void *vstate);\nstatic double cmrg_get_double (void *vstate);\nstatic void cmrg_set (void *state, unsigned long int s);\n\nstatic const long int m1 = 2147483647, m2 = 2145483479;\n\nstatic const long int a2 = 63308, qa2 = 33921, ra2 = 12979;\nstatic const long int a3 = -183326, qa3 = 11714, ra3 = 2883;\nstatic const long int b1 = 86098, qb1 = 24919, rb1 = 7417;\nstatic const long int b3 = -539608, qb3 = 3976, rb3 = 2071;\n\ntypedef struct\n {\n long int x1, x2, x3;\t/* first component */\n long int y1, y2, y3;\t/* second component */\n }\ncmrg_state_t;\n\nstatic inline unsigned long int\ncmrg_get (void *vstate)\n{\n cmrg_state_t *state = (cmrg_state_t *) vstate;\n\n /* Component 1 */\n\n {\n long int h3 = state->x3 / qa3;\n long int p3 = -a3 * (state->x3 - h3 * qa3) - h3 * ra3;\n\n long int h2 = state->x2 / qa2;\n long int p2 = a2 * (state->x2 - h2 * qa2) - h2 * ra2;\n\n if (p3 < 0)\n p3 += m1;\n if (p2 < 0)\n p2 += m1;\n\n state->x3 = state->x2;\n state->x2 = state->x1;\n state->x1 = p2 - p3;\n if (state->x1 < 0)\n state->x1 += m1;\n }\n\n /* Component 2 */\n\n {\n long int h3 = state->y3 / qb3;\n long int p3 = -b3 * (state->y3 - h3 * qb3) - h3 * rb3;\n\n long int h1 = state->y1 / qb1;\n long int p1 = b1 * (state->y1 - h1 * qb1) - h1 * rb1;\n\n if (p3 < 0)\n p3 += m2;\n if (p1 < 0)\n p1 += m2;\n\n state->y3 = state->y2;\n state->y2 = state->y1;\n state->y1 = p1 - p3;\n if (state->y1 < 0)\n state->y1 += m2;\n }\n \n if (state->x1 < state->y1)\n return (state->x1 - state->y1 + m1);\n else\n return (state->x1 - state->y1);\n}\n\nstatic double \ncmrg_get_double (void *vstate)\n{\n return cmrg_get (vstate) / 2147483647.0 ;\n}\n\n\nstatic void\ncmrg_set (void *vstate, unsigned long int s)\n{\n /* An entirely adhoc way of seeding! This does **not** come from\n L'Ecuyer et al */\n\n cmrg_state_t *state = (cmrg_state_t *) vstate;\n\n if (s == 0)\n s = 1;\t/* default seed is 1 */\n\n#define LCG(n) ((69069 * n) & 0xffffffffUL)\n s = LCG (s);\n state->x1 = s % m1;\n s = LCG (s);\n state->x2 = s % m1;\n s = LCG (s);\n state->x3 = s % m1;\n\n s = LCG (s);\n state->y1 = s % m2;\n s = LCG (s);\n state->y2 = s % m2;\n s = LCG (s);\n state->y3 = s % m2;\n\n /* \"warm it up\" */\n cmrg_get (state);\n cmrg_get (state);\n cmrg_get (state);\n cmrg_get (state);\n cmrg_get (state);\n cmrg_get (state);\n cmrg_get (state);\n}\n\nstatic const gsl_rng_type cmrg_type =\n{\"cmrg\",\t\t\t/* name */\n 2147483646,\t\t\t/* RAND_MAX */\n 0,\t\t\t /* RAND_MIN */\n sizeof (cmrg_state_t),\n &cmrg_set,\n &cmrg_get,\n &cmrg_get_double};\n\nconst gsl_rng_type *gsl_rng_cmrg = &cmrg_type;\n", "meta": {"hexsha": "49e8544345ea6db63d97bec1497fe9f2c0055aa2", "size": 5218, "ext": "c", "lang": "C", "max_stars_repo_path": "code/em/treba/gsl-1.0/rng/cmrg.c", "max_stars_repo_name": "ICML14MoMCompare/spectral-learn", "max_stars_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_stars_repo_licenses": ["Apache-2.0"], "max_stars_count": 14.0, "max_stars_repo_stars_event_min_datetime": "2015-12-18T18:09:25.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-10T11:31:28.000Z", "max_issues_repo_path": "code/em/treba/gsl-1.0/rng/cmrg.c", "max_issues_repo_name": "ICML14MoMCompare/spectral-learn", "max_issues_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "code/em/treba/gsl-1.0/rng/cmrg.c", "max_forks_repo_name": "ICML14MoMCompare/spectral-learn", "max_forks_repo_head_hexsha": "91e70bc88726ee680ec6e8cbc609977db3fdcff9", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2015-10-02T01:32:59.000Z", "max_forks_repo_forks_event_max_datetime": "2015-10-02T01:32:59.000Z", "avg_line_length": 26.3535353535, "max_line_length": 73, "alphanum_fraction": 0.6226523572, "num_tokens": 1881, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8031737963569014, "lm_q2_score": 0.6261241632752915, "lm_q1q2_score": 0.5028865212086043}} {"text": "/*\n** random swap functions\n**\n** M. Kuhlmann, MPI-KYB, Sept 2015\n**/\n\n#include \n#include \n#include \n#include \n#include \n\n#include \n#include \n#include \n#include \n#include \n#include \n\n/* binomial coefficient, n choose k */\ndouble binom (int n,int k)\n{\n double prod,ix,nx,kx;\n int i;\n nx = (double)n;\n kx = (double)k;\n\n prod = ix = 1;\n for (i=1; i<=k; i++) {\n prod *= (nx-kx+ix)/ix;\n ix++;\n }\n return prod;\n}\n\ndouble factorial(int n) {\n int i;\n double ix = 1;\n double prod = 1;\n for (i=1; i<=n; i++) {\n prod *= ix;\n ix++;\n }\n return prod;\n}\n\nchar **enumerate_swaps(int n)\n{\n size_t i,j,num,b;\n\n long maxiter = (size_t) gsl_pow_int(2.0,(int)n);\n \n char **swaps = (char **)VCalloc(maxiter,sizeof(char *));\n for(i = 0; i < maxiter; i++)\n swaps[i] = (char *)VCalloc(n,sizeof(char));\n\n /* generate swap table */\n for (i=0; i 0)\n {\n b=num%2;\n swaps[i][j] = b;\n num=num/2;\n j++;\n }\n }\n \n return swaps;\n}\n\nchar **randomSwaps(long maxiter,int n,unsigned long int seed)\n{\n size_t i,j;\n \n char **swaps = (char **)VCalloc(maxiter,sizeof(char *));\n for(i = 0; i < maxiter; i++)\n swaps[i] = (char *)VCalloc(n,sizeof(char));\n \n gsl_rng_env_setup();\n const gsl_rng_type *T = gsl_rng_default;\n gsl_rng *rx = gsl_rng_alloc(T);\n gsl_rng_set(rx,(unsigned long int)seed);\n \n for(i = 0; i < maxiter; i++)\n for(j = 0; j < n; j++)\n swaps[i][j] = gsl_ran_bernoulli(rx, 0.5);\n \n return swaps;\n}\n\nchar **randomSwaps_noduplicates(long maxiter,int n,unsigned long int seed)\n{\n size_t iter,i,j;\n \n /* if number of maxiter exceeds number of all possible combinations */\n if(maxiter > (size_t) gsl_pow_int(2.0,(int)n))\n VError(\"Error: Number of iterations larger than possible permutations!\");\n \n gsl_rng_env_setup();\n const gsl_rng_type *T = gsl_rng_default;\n gsl_rng *rx = gsl_rng_alloc(T);\n gsl_rng_set(rx,(unsigned long int)seed);\n \n char **swaps = (char **)VCalloc(maxiter,sizeof(char *));\n for(i = 0; i < maxiter; i++)\n swaps[i] = (char *)VCalloc(n,sizeof(char));\n \n /* generate swap table */\n iter = 0;\n while (iter < maxiter) {\n for (j=0; j\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#define SDL_MAIN_HANDLED\n#include \n\n#include \"libvecdisp.h\"\n\nint main(int argc, char * argv[]) {\n\tVECDISP_T ret;\n\n\t// Init\n\tret = vecdisp_init();\n\tassert(ret == VECDISP_SUCCESS);\n\tret = vecdisp_out_init();\n\tassert(ret == VECDISP_SUCCESS);\n\n\tSDL_GameController * controller_p0 = NULL, * controller_p1 = NULL;\n\tint controller_cnt = 0;\n\n\tSDL_Init( SDL_INIT_GAMECONTROLLER );\n\tSDL_GameControllerEventState(SDL_ENABLE);\n\n\tvecdisp_shape_t * shape_cube3d = vecdisp_shape_create(VECDISP_SHAPE_LINES, NULL, 0 );\n\t\n\t// format: {x, y, z}, x = horizontal, y = vertical, z = depth\n\tdouble cube3d[][3] = { \n\t\t{ -1, -1, -1 },\n\t\t{ 1, -1, -1 },\n\t\t{ 1, -1, -1 },\n\t\t{ 1, 1, -1 },\n\t\t{ 1, 1, -1 },\n\t\t{ -1, 1, -1 },\n\t\t{ -1, 1, -1 },\n\t\t{ -1, -1, -1 },\n\t\t{ -1, -1, -1 },\n\t\t{ -1, -1, 1 },\n\t\t{ -1, 1, -1 },\n\t\t{ -1, 1, 1 },\n\t\t{ 1, 1, -1 },\n\t\t{ 1, 1, 1 },\n\t\t{ 1, -1, -1 },\n\t\t{ 1, -1, 1 },\n\t\t{ -1, -1, 1 },\n\t\t{ 1, -1, 1 },\n\t\t{ 1, -1, 1 },\n\t\t{ 1, 1, 1 },\n\t\t{ 1, 1, 1 },\n\t\t{ -1, 1, 1 },\n\t\t{ -1, 1, 1 },\n\t\t{ -1, -1, 1 },\n\t };\n\tfor(int i = 0; i < 24; i++) {\n\t\tuint16_t data[2] = {0,0};\n\t\tvecdisp_shape_data_add(shape_cube3d, &data, 1 );\n\t\t\n\t}\n\tprintf(\"%i\\n\", shape_cube3d->data_len);\n\t\n\tdouble rotx = 0, roty = 0, rotz = 0;\n\tdouble sqrt_3 = sqrt(3);\n\tdouble sqrt_6 = sqrt(6);\n\t\n\t// main loop\n\tSDL_Event event;\n\tbool quit = false;\n\twhile( quit == false ) {\n\t\twhile( SDL_PollEvent(&event) != 0 ) {\n\t\t\tswitch (event.type) {\n\t\t\tcase SDL_QUIT:\n\t\t\t\tquit = true;\n\t\t\t\tbreak;\n\t\t\tcase SDL_CONTROLLERDEVICEADDED:\n\t\t\t\tif(controller_p0 == NULL) {\n\t\t\t\t\tcontroller_p0 = SDL_GameControllerOpen(event.cdevice.which);\n\t\t\t\t\tprintf(\"adding Controller p0\\n\");\n\t\t\t\t\tcontroller_cnt++;\n\t\t\t\t}\n\t\t\t\telse if(controller_p1 == NULL) {\n\t\t\t\t\tcontroller_p1 = SDL_GameControllerOpen(event.cdevice.which);\n\t\t\t\t\tprintf(\"adding Controller p1\\n\");\n\t\t\t\t\tcontroller_cnt++;\n\t\t\t\t}\n\t\t\t\telse {\n\t\t\t\t\tprintf(\"Only two controllers allowed.\\n\");\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tcase SDL_CONTROLLERDEVICEREMOVED:\n\t\t\t\tif (event.cdevice.which == SDL_JoystickInstanceID(SDL_GameControllerGetJoystick(controller_p0) ) ) {\n\t\t\t\t\tSDL_GameControllerClose(controller_p0);\n\t\t\t\t\tprintf(\"freeing controller_p0\\n\");\n\t\t\t\t\tcontroller_p0 = NULL;\n\t\t\t\t\tcontroller_cnt--;\n\t\t\t\t}\n\t\t\t\telse if (event.cdevice.which == SDL_JoystickInstanceID(SDL_GameControllerGetJoystick(controller_p1) ) ) {\n\t\t\t\t\tSDL_GameControllerClose(controller_p1);\n\t\t\t\t\tprintf(\"freeing controller_p1\\n\");\n\t\t\t\t\tcontroller_p1 = NULL;\n\t\t\t\t\tcontroller_cnt--;\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tcase SDL_CONTROLLERBUTTONDOWN:\n\t\t\t\tswitch (event.cbutton.button) {\n\t\t\t\tcase SDL_CONTROLLER_BUTTON_BACK:\n\t\t\t\t\tif(event.cbutton.state == 1) {\n\t\t\t\t\t\tSDL_Event user_quit_event;\n\t\t\t\t\t\tuser_quit_event.type = SDL_QUIT;\n\t\t\t\t\t\tSDL_PushEvent( &user_quit_event );\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tcase SDL_KEYDOWN:\n\t\t\t\tswitch (event.key.keysym.sym) {\n\t\t\t\tcase SDLK_q: {\n\t\t\t\t\tSDL_Event user_quit_event;\n\t\t\t\t\tuser_quit_event.type = SDL_QUIT;\n\t\t\t\t\tSDL_PushEvent( &user_quit_event );\n\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\n\t\t\n\t\trotx += 0.00004;\n\t\troty += 0.00002;\n\t\trotz += 0.00001;\n\t\tif( rotx >= M_PI ) rotx -= M_PI;\n\t\tif( roty >= M_PI ) roty -= M_PI;\n\t\tif( rotz >= M_PI ) rotz -= M_PI;\n\n\t\t\n\t\tfor(int i = 0; i < 24; i++) {\n\t\t\tdouble c[3];\n\t\t\tcube3d[i][0] = cos(rotx) * cube3d[i][0] - sin(rotx) * cube3d[i][1]; // Rotation around X Axis\n\t\t\tcube3d[i][1] = sin(rotx) * cube3d[i][0] + cos(rotx) * cube3d[i][1];\n\t\t\tcube3d[i][2] = 1 * cube3d[i][2];\n\n\t\t\tcube3d[i][0] = cos(roty) * cube3d[i][0] - sin(roty) * cube3d[i][2]; // Rotation around Y Axis\n\t\t\tcube3d[i][1] = 1 * cube3d[i][1];\n\t\t\tcube3d[i][2] = cos(roty) * cube3d[i][2] + sin(roty) * cube3d[i][0];\n\n\t\t\tcube3d[i][0] = 1 * cube3d[i][0]; // Rotation around Z Axis\n\t\t\tcube3d[i][1] = cos(rotz) * cube3d[i][1] - sin(rotz) * cube3d[i][2]; // Rotation around Z Axis\n\t\t\tcube3d[i][2] = cos(rotz) * cube3d[i][2] + sin(rotz) * cube3d[i][1];\n\n\t\t\tc[0] = ( sqrt(3) * cube3d[i][0] + (-1) * sqrt_3 * cube3d[i][2] ) / sqrt_6;\n\t\t\tc[1] = ( 1 * cube3d[i][0] + 2 * cube3d[i][1] + 1 * cube3d[i][2] ) / sqrt_6;\n\t\t\t\n\t\t\tshape_cube3d->data[i][0] = lround((DRAW_RES / 4) * c[0] + (DRAW_RES / 2));\n\t\t\tshape_cube3d->data[i][1] = lround((DRAW_RES / 4) * c[1] + (DRAW_RES / 2));\n\t\t}\n\t\t\n\t\tvecdisp_draw_shape( shape_cube3d, 0, 0, DRAW_RES - 1, DRAW_RES - 1, DRAW_BRTNS_BRIGHT);\n\t\tvecdisp_dbg_showfps();\n\t\tvecdisp_draw_update();\n\t}\n\n\t// cleaning up\n\tvecdisp_shape_destroy(shape_cube3d);\n\tSDL_QuitSubSystem( SDL_INIT_EVERYTHING );\n\tvecdisp_out_end();\n\tvecdisp_end();\n\treturn 0;\n}\n", "meta": {"hexsha": "90d1e16049361b3dad6454e9cd25da8ac82a5cb8", "size": 4634, "ext": "c", "lang": "C", "max_stars_repo_path": "src/demo3d.c", "max_stars_repo_name": "felixzwettler/vecdisp", "max_stars_repo_head_hexsha": "91a8d9968b78b9e6513052490800b40681e8b7db", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 3.0, "max_stars_repo_stars_event_min_datetime": "2022-01-15T12:44:05.000Z", "max_stars_repo_stars_event_max_datetime": "2022-01-24T02:44:30.000Z", "max_issues_repo_path": "src/demo3d.c", "max_issues_repo_name": "fpunktz/vecdisp", "max_issues_repo_head_hexsha": "a3fdd15b228231c69d608af1eb2ea020529c4f5e", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/demo3d.c", "max_forks_repo_name": "fpunktz/vecdisp", "max_forks_repo_head_hexsha": "a3fdd15b228231c69d608af1eb2ea020529c4f5e", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 1.0, "max_forks_repo_forks_event_min_datetime": "2022-01-24T02:44:40.000Z", "max_forks_repo_forks_event_max_datetime": "2022-01-24T02:44:40.000Z", "avg_line_length": 26.1807909605, "max_line_length": 110, "alphanum_fraction": 0.5938713854, "num_tokens": 1707, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8376199714402812, "lm_q2_score": 0.600188359260205, "lm_q1q2_score": 0.5027297563423221}} {"text": "/*************************************************************************************************************\nCalculate shear Gaussian + non-Gaussian covariance using CosmoLike.\nGaussian, super-sample and connected non-Gaussian contributions can each be switched on and off independently.\nThis loops over all combinations of z bins, saving each to disk separately.\n\nProvide two command line arguments:\n 1. Path to ini file with all the configuration (see the example_input/example.ini).\n 2. Index of the first power spectrum, spec1_idx. This will then iterate over all spec2_idx <= spec1_idx.\n**************************************************************************************************************/\n\n#include \n\n#include \n#include \n#include \n\n// CosmoLike includes (std & GSL includes must be above here)\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n\n// Cl covariance params\ntypedef struct {\n int lmin;\n int lmax;\n char ell_str[200];\n char output_dir[200];\n int do_g;\n int do_ss;\n int do_cng;\n} clcov_par;\nclcov_par clcov_params = {.lmin = 2, .lmax = -1, .ell_str = \"NULL\", .do_g = 0, .do_ss = 0, .do_cng = 0};\n\n\n// Set Cl covariance params from ini file\nvoid set_clcov_parameters(char *paramfile, int output)\n{\n char line[256];\n int iline=0;\n\n FILE* input = fopen(paramfile, \"r\");\n while(fgets(line, 256, input) != NULL) {\n char name[128], val[128];\n iline++;\n if(line[0] == '#') continue;\n sscanf(line, \"%128s : %128s\", name, val);\n\n if(strcmp(name, \"lmin\") == 0) {\n sscanf(val, \"%d\", &clcov_params.lmin);\n if(output == 1) printf(\"lmin %d \\n\", clcov_params.lmin);\n } else if(strcmp(name, \"lmax\") == 0) {\n sscanf(val, \"%d\", &clcov_params.lmax);\n if(output == 1) printf(\"lmax %d \\n\", clcov_params.lmax);\n } else if(strcmp(name, \"output_dir\") == 0) {\n sprintf(clcov_params.output_dir, \"%s\", val);\n if(output == 1) printf(\"output_dir %s \\n\", clcov_params.output_dir);\n } else if(strcmp(name, \"c_footprint_file\") == 0) {\n sprintf(covparams.C_FOOTPRINT_FILE, \"%s\", val);\n if(output == 1) printf(\"c_footprint_file %s \\n\", covparams.C_FOOTPRINT_FILE);\n } else if(strcmp(name, \"ell\") == 0) {\n sprintf(clcov_params.ell_str, \"%s\", val);\n if(output == 1) printf(\"ell_str %s \\n\", clcov_params.ell_str);\n } else if(strcmp(name, \"do_g\") == 0) {\n sscanf(val, \"%d\", &clcov_params.do_g);\n if(output == 1) printf(\"do_g %d \\n\", clcov_params.do_g);\n } else if(strcmp(name, \"do_ss\") == 0) {\n sscanf(val, \"%d\", &clcov_params.do_ss);\n if(output == 1) printf(\"do_ss %d \\n\", clcov_params.do_ss);\n } else if(strcmp(name, \"do_cng\") == 0) {\n sscanf(val, \"%d\", &clcov_params.do_cng);\n if(output == 1) printf(\"do_cng %d \\n\", clcov_params.do_cng);\n }\n }\n}\n\n\n// 2D version of numpy savetxt. Use header = \"0\" for no header\nint savetxt_2d(char *path, double **array, int n_row, int n_col, char *header) {\n\n FILE *file = fopen(path, \"w\");\n\n if (strncmp(header, \"0\", 2) != 0) fprintf(file, \"# %s\\n\", header);\n\n for (int i = 0; i < n_row; i++) {\n printf(\"Saving %d / %d ... \\r\", i + 1, n_row);\n for (int j = 0; j < n_col; j++) {\n fprintf(file, \"%.10e\", array[i][j]);\n if (j < n_col - 1) {\n fprintf(file, \" \");\n }\n }\n fprintf(file, \"\\n\");\n }\n\n fclose(file);\n return 0;\n}\n\n\nint main(int argc, char** argv)\n{\n\n if (argc != 3){\n fprintf(stderr, \"Syntax: %s config_file spec1_idx\\n\", argv[0]);\n exit(1);\n }\n\n setbuf(stdout, NULL);\n\n // Set this to 1 to output details about inputs for diagnostics\n int output = 1;\n\n // Set cosmo, survey and Cl covariance params from ini file\n char *inifile = argv[1];\n set_cosmological_parameters(inifile, output);\n set_survey_parameters(inifile, output);\n covparams.full_tomo = 1;\n set_clcov_parameters(inifile, output);\n init_source_sample(redshift.shear_REDSHIFT_FILE, tomo.shear_Nbin);\n init_lens_sample(redshift.clustering_REDSHIFT_FILE, tomo.clustering_Nbin);\n\n // Determine which contributions to include\n char cov_str[9] = \"\";\n printf(\"Including Gaussian contribution: \");\n if (clcov_params.do_g) {\n printf(\"yes \\n\");\n sprintf(cov_str, \"%sg_\", cov_str);\n } else printf(\"no \\n\");\n printf(\"Including super-sample contribution: \");\n if (clcov_params.do_ss) {\n printf(\"yes \\n\");\n sprintf(cov_str, \"%sss_\", cov_str);\n } else printf(\"no \\n\");\n printf(\"Including connected non-Gaussian contribution: \");\n if (clcov_params.do_cng) {\n printf(\"yes \\n\");\n sprintf(cov_str, \"%scng_\", cov_str);\n } else printf(\"no \\n\");\n covparams.ssc = clcov_params.do_ss;\n covparams.cng = clcov_params.do_cng;\n\n // Obtain the number of z bins from config\n int n_zbin;\n if (tomo.shear_Nbin != tomo.clustering_Nbin) error(\"tomo.shear_Nbin != tomo.clustering_Nbin\");\n else n_zbin = tomo.shear_Nbin;\n\n // Determine ells, either from the list provided in the config or the provided lmin and lmax\n // Do this in 2 steps: first determine the number of ells, then the ells themselves\n int n_ell;\n if (strcmp(clcov_params.ell_str, \"NULL\") == 0) {\n if (clcov_params.lmax < clcov_params.lmin) error(\"lmax < lmin, make sure lmax is provided\");\n n_ell = clcov_params.lmax - clcov_params.lmin + 1;\n }\n else { // Count the number of commas + 1\n n_ell = 1;\n const char *remaining_str = clcov_params.ell_str;\n while ((remaining_str = strstr(remaining_str, \",\")))\n {\n n_ell++;\n remaining_str++;\n }\n }\n int ell[n_ell];\n if (strcmp(clcov_params.ell_str, \"NULL\") == 0) {\n for (int l = clcov_params.lmin; l <= clcov_params.lmax; l++) {\n ell[l - clcov_params.lmin] = l;\n }\n }\n else {\n char* rem_str = calloc(strlen(clcov_params.ell_str) + 1, sizeof(char));\n strcpy(rem_str, clcov_params.ell_str);\n int l_idx = 0;\n char *token = strtok(rem_str, \",\");\n while (token != NULL) {\n ell[l_idx] = strtol(token, NULL, 10);\n token = strtok(NULL, \",\");\n l_idx++;\n }\n }\n\n // Prepare a string about the ells to go in the header of the output text files\n char ell_header_str[200];\n if (strcmp(clcov_params.ell_str, \"NULL\") == 0) {\n sprintf(ell_header_str, \"lmin %d, lmax %d\", clcov_params.lmin, clcov_params.lmax);\n } else {\n sprintf(ell_header_str, \"ell: %s\", clcov_params.ell_str);\n }\n printf(\"%s \\n\", ell_header_str);\n\n // Generate list of power spectra within the shear data vector\n // Rows are the different spectra, cols are: z1, z2\n int n_spectra_sametype = n_zbin * (n_zbin + 1) / 2;\n int spectra_sametype[n_spectra_sametype][2];\n int spec_idx = 0;\n for (int diag = 0; diag < n_zbin; diag++) {\n for (int row = 0; row < n_zbin - diag; row++) {\n spectra_sametype[spec_idx][0] = row;\n spectra_sametype[spec_idx][1] = row + diag;\n spec_idx++;\n }\n }\n\n // Read in the provided spec1_idx and check it is allowed\n int spec1_idx = atoi(argv[2]);\n if (spec1_idx < 0 || spec1_idx >= n_spectra_sametype) {\n error(\"spec1_idx provided is not valid\");\n } else {\n printf(\"Requested spec1_idx is %d \\n\", spec1_idx);\n }\n\n // Common variables for the covariance blocks\n int z1, z2, z3, z4, l1, l2;\n double cov;\n char save_path[250];\n char header[250];\n\n // Shear-shear covariance (symmetric so only do spec2_idx <= spec1_idx)\n for (int spec2_idx = 0; spec2_idx <= spec1_idx; spec2_idx++) {\n\n // Allocate memory for the block and fill with nans\n double** cov_shear_shear = (double**) malloc(n_ell * sizeof(double*));\n for (int i = 0; i < n_ell; i++) cov_shear_shear[i] = (double*) malloc(n_ell * sizeof(double));\n for (int l1_idx = 0; l1_idx < n_ell; l1_idx++) {\n for (int l2_idx = 0; l2_idx < n_ell; l2_idx++) {\n cov_shear_shear[l1_idx][l2_idx] = NAN;\n }\n }\n\n // Loop over all combinations of (l1, l2), unless the two spectra are the same in which case only need l2 <= l1\n for (int l1_idx = 0; l1_idx < n_ell; l1_idx++) {\n printf(\"spec2_idx %d / %d, l1_idx %d / %d \\n\", spec2_idx, spec1_idx, l1_idx, n_ell);\n int l2_idx_max;\n if (spec2_idx == spec1_idx) {\n l2_idx_max = l1_idx;\n } else {\n l2_idx_max = n_ell - 1;\n }\n for (int l2_idx = 0; l2_idx <= l2_idx_max; l2_idx++) {\n l1 = ell[l1_idx];\n l2 = ell[l2_idx];\n z1 = spectra_sametype[spec1_idx][0];\n z2 = spectra_sametype[spec1_idx][1];\n z3 = spectra_sametype[spec2_idx][0];\n z4 = spectra_sametype[spec2_idx][1];\n cov = 0.0;\n if (clcov_params.do_g) cov += cov_G_shear_shear_tomo(l1, l2, z1, z2, z3, z4);\n if (clcov_params.do_ss || clcov_params.do_cng) cov += cov_NG_shear_shear_tomo(l1, l2, z1, z2, z3, z4);\n cov_shear_shear[l1_idx][l2_idx] = cov;\n if (spec2_idx == spec1_idx) {\n cov_shear_shear[l2_idx][l1_idx] = cov;\n }\n }\n }\n\n // Save block to disk and free memory\n sprintf(save_path, \"%s/cov_%sspec1_%d_spec2_%d.txt\", clcov_params.output_dir, cov_str, spec1_idx, spec2_idx);\n sprintf(header, \"cov_shear_shear for spec_idx %d and %d with do_g=%d, do_ss=%d, do_cng=%d, %s\",\n spec1_idx, spec2_idx, clcov_params.do_g, clcov_params.do_ss, clcov_params.do_cng, ell_header_str);\n if (savetxt_2d(save_path, cov_shear_shear, n_ell, n_ell, header) == 0) printf(\"\\nSaved %s\\n\", save_path);\n for (int i = 0; i < n_ell; i++) free(cov_shear_shear[i]);\n free(cov_shear_shear);\n\n } // next spec2_idx for this fixed spec1_idx\n\n printf(\"Done \\n\");\n return 0;\n}\n", "meta": {"hexsha": "0a4b361726669c5c70f7a17f93bcd91c16876777", "size": 9921, "ext": "c", "lang": "C", "max_stars_repo_path": "get_shear_clcov.c", "max_stars_repo_name": "robinupham/CosmoCov_ClCov", "max_stars_repo_head_hexsha": "afa02abe76ad1e7b0fc17f43d7f271cb466948c1", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "get_shear_clcov.c", "max_issues_repo_name": "robinupham/CosmoCov_ClCov", "max_issues_repo_head_hexsha": "afa02abe76ad1e7b0fc17f43d7f271cb466948c1", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "get_shear_clcov.c", "max_forks_repo_name": "robinupham/CosmoCov_ClCov", "max_forks_repo_head_hexsha": "afa02abe76ad1e7b0fc17f43d7f271cb466948c1", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.9456521739, "max_line_length": 115, "alphanum_fraction": 0.6285656688, "num_tokens": 3097, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8267117940706735, "lm_q2_score": 0.6076631698328916, "lm_q1q2_score": 0.5023623093232222}} {"text": "#include \n#include \n#include \n#include \n#include \n\n#if __INTEL_COMPILER\n#include \"mkl.h\"\n#else\n#include \n#endif\n\n#include \"defs.h\"\n#include \"utils.h\"\n#include \"progressbar.h\"\n\nlong naive(const double * restrict x1, const double * restrict y1, const int N, double * restrict d)\n{\n\tlong numcomputed=0;\n\n\tfor(int i=0;i block_size ? block_size:(N-i);\n\t\tfor(int j=0;j block_size ? block_size:(N-j);\n\t\t\tfor(int ii=0;ii 1e-8) {\n\t\t\t\tif(numbadprinted < 20) {\n\t\t\t\t\tfprintf(stderr,\"i = %d j = %d d = %0.8lf this_dist = %0.8lf \\n\",i,j,d,this_dist);\n\t\t\t\t\tnumbadprinted++;\n\t\t\t\t}\n\t\t\t\tbad++;\n\t\t\t}\n\t\t}\n\t}\n\t\n\treturn bad;\n}\n\n\nint main(int argc, char **argv)\n{\n\tint numpart = 0;\n\tif(argc > 1 ) {\n\t\tnumpart = atoi(argv[1]);\n\t} else {\n\t\tnumpart = NELEMENTS;\n\t}\n\n\tconst size_t numbytes = NDIM*numpart;\n\tdouble *x = calloc(sizeof(*x), numbytes);\n\tdouble *y = calloc(sizeof(*y), numbytes);\n\tconst long totnpairs = (long) numpart * (long) numpart;\n\tdouble *dist = calloc(sizeof(*dist), totnpairs);\n\tassert(x != NULL && y != NULL && dist != NULL && \"memory allocation failed\");\n const char allfunction_names[][MAXLEN] = {\"naive\",\"chunked\",\"compiler_vectorized_chunked\",\"blas_computed\"};\n\tconst int ntests = sizeof(allfunction_names)/(sizeof(char)*MAXLEN);\n\tlong (*allfunctions[]) (const double * restrict, const double * restrict, const int, double * restrict) = {naive, chunked,compiler_vectorized_chunked,blas_computed};\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\n\tsrand(seed);\n\n\tdouble function_best_mean_time[ntests],function_sigma_time[ntests],function_best_time_in_ms[ntests],function_best_mcycles[ntests];\n\tint function_niterations[ntests];\n\tfor(int i=0;i= 300 && iter >= 5) {\n\t\t\t\t\tnumdone = numdone_before_iter_loop + max_niterations;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}//i loop over ntests\n\t}//irep loop over nrepeats\n finish_myprogressbar(&interrupted);\n\t\n\t\n\tprintf(\"#######################################################\\n\");\n\tprintf(\"## Function Time (ms) \\n\");\n\tprintf(\"#######################################################\\n\");\n\tfor(int i=0;i\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\ntypedef struct\n{\n size_t p; /* number of columns of LS matrix */\n int nblocks; /* number of blocks processed */\n double rnorm; /* || b - A x || residual norm */\n int svd; /* SVD of R factor has been computed */\n\n gsl_matrix *T; /* block reflector matrix, p-by-p */\n gsl_matrix *R; /* R factor, p-by-p */\n gsl_vector *QTb; /* [ Q^T b ; b_i ], size p-by-1 */\n gsl_vector *work; /* workspace, size p */\n gsl_vector *work3; /* workspace, size 3*p */\n\n gsl_multifit_linear_workspace * multifit_workspace_p;\n} tsqr_state_t;\n\nstatic void *tsqr_alloc(const size_t p);\nstatic void tsqr_free(void *vstate);\nstatic int tsqr_reset(void *vstate);\nstatic int tsqr_accumulate(gsl_matrix * A, gsl_vector * b,\n void * vstate);\nstatic int tsqr_solve(const double lambda, gsl_vector * x,\n double * rnorm, double * snorm,\n void * vstate);\nstatic int tsqr_rcond(double * rcond, void * vstate);\nstatic int tsqr_lcurve(gsl_vector * reg_param, gsl_vector * rho,\n gsl_vector * eta, void * vstate);\nstatic const gsl_matrix * tsqr_R(const void * vstate);\nstatic const gsl_vector * tsqr_QTb(const void * vstate);\nstatic int tsqr_svd(tsqr_state_t * state);\n\n/*\ntsqr_alloc()\n Allocate workspace for solving large linear least squares\nproblems using the TSQR approach\n\nInputs: p - number of columns of LS matrix\n\nReturn: pointer to workspace\n*/\n\nstatic void *\ntsqr_alloc(const size_t p)\n{\n tsqr_state_t *state;\n\n if (p == 0)\n {\n GSL_ERROR_NULL(\"p must be a positive integer\",\n GSL_EINVAL);\n }\n\n state = calloc(1, sizeof(tsqr_state_t));\n if (!state)\n {\n GSL_ERROR_NULL(\"failed to allocate tsqr state\", GSL_ENOMEM);\n }\n\n state->p = p;\n state->nblocks = 0;\n state->rnorm = 0.0;\n\n state->R = gsl_matrix_alloc(p, p);\n if (state->R == NULL)\n {\n tsqr_free(state);\n GSL_ERROR_NULL(\"failed to allocate R matrix\", GSL_ENOMEM);\n }\n\n state->QTb = gsl_vector_alloc(p);\n if (state->QTb == NULL)\n {\n tsqr_free(state);\n GSL_ERROR_NULL(\"failed to allocate QTb vector\", GSL_ENOMEM);\n }\n\n state->T = gsl_matrix_alloc(p, p);\n if (state->T == NULL)\n {\n tsqr_free(state);\n GSL_ERROR_NULL(\"failed to allocate T matrix\", GSL_ENOMEM);\n }\n\n state->work = gsl_vector_alloc(p);\n if (state->work == NULL)\n {\n tsqr_free(state);\n GSL_ERROR_NULL(\"failed to allocate workspace vector\", GSL_ENOMEM);\n }\n\n state->work3 = gsl_vector_alloc(3 * p);\n if (state->work3 == NULL)\n {\n tsqr_free(state);\n GSL_ERROR_NULL(\"failed to allocate work3 vector\", GSL_ENOMEM);\n }\n\n state->multifit_workspace_p = gsl_multifit_linear_alloc(p, p);\n if (state->multifit_workspace_p == NULL)\n {\n tsqr_free(state);\n GSL_ERROR_NULL(\"failed to allocate multifit workspace\", GSL_ENOMEM);\n }\n\n return state;\n}\n\nstatic void\ntsqr_free(void *vstate)\n{\n tsqr_state_t *state = (tsqr_state_t *) vstate;\n\n if (state->R)\n gsl_matrix_free(state->R);\n\n if (state->QTb)\n gsl_vector_free(state->QTb);\n\n if (state->T)\n gsl_matrix_free(state->T);\n\n if (state->work)\n gsl_vector_free(state->work);\n\n if (state->work3)\n gsl_vector_free(state->work3);\n\n if (state->multifit_workspace_p)\n gsl_multifit_linear_free(state->multifit_workspace_p);\n\n free(state);\n}\n\nstatic int\ntsqr_reset(void *vstate)\n{\n tsqr_state_t *state = (tsqr_state_t *) vstate;\n\n gsl_matrix_set_zero(state->R);\n gsl_vector_set_zero(state->QTb);\n state->nblocks = 0;\n state->rnorm = 0.0;\n state->svd = 0;\n\n return GSL_SUCCESS;\n}\n\n/*\ntsqr_accumulate()\n Add a new block of rows to the QR system\n\nInputs: A - new block of rows, n-by-p\n b - new rhs vector n-by-1\n vstate - workspace\n\nReturn: success/error\n\nNotes:\n1) On output, the upper triangular portion of state->R(1:p,1:p)\ncontains current R matrix\n\n2) state->QTb(1:p) contains current Q^T b vector\n\n3) A and b are destroyed\n*/\n\nstatic int\ntsqr_accumulate(gsl_matrix * A, gsl_vector * b, void * vstate)\n{\n tsqr_state_t *state = (tsqr_state_t *) vstate;\n const size_t n = A->size1;\n const size_t p = A->size2;\n\n if (p != state->p)\n {\n GSL_ERROR(\"columns of A do not match workspace\", GSL_EBADLEN);\n }\n else if (n != b->size)\n {\n GSL_ERROR(\"A and b have different numbers of rows\", GSL_EBADLEN);\n }\n else if (state->nblocks == 0 && n < p)\n {\n GSL_ERROR (\"n must be >= p\", GSL_EBADLEN);\n }\n else if (state->nblocks == 0)\n {\n int status;\n gsl_matrix_view R = gsl_matrix_submatrix(A, 0, 0, p, p);\n gsl_vector_view QTb = gsl_vector_subvector(state->QTb, 0, p);\n gsl_vector_view b1 = gsl_vector_subvector(b, 0, p);\n\n /* this is the first matrix block A_1, compute its (dense) QR decomposition */\n\n /* compute QR decomposition of A */\n status = gsl_linalg_QR_decomp_r(A, state->T);\n if (status)\n return status;\n\n /* store upper triangular R factor in state->R */\n gsl_matrix_tricpy(CblasUpper, CblasNonUnit, state->R, &R.matrix);\n\n /* compute Q^T b and keep the first p elements */\n gsl_linalg_QR_QTvec_r(A, state->T, b, state->work);\n gsl_vector_memcpy(&QTb.vector, &b1.vector);\n\n if (n > p)\n {\n gsl_vector_view b2 = gsl_vector_subvector(b, p, n - p);\n state->rnorm = gsl_blas_dnrm2(&b2.vector);\n }\n else\n state->rnorm = 0.0;\n\n state->nblocks = 1;\n\n return GSL_SUCCESS;\n }\n else\n {\n int status;\n\n /* compute QR decomposition of [ R_{i-1} ; A_i ], accounting for\n * sparse structure */\n status = gsl_linalg_QR_UR_decomp(state->R, A, state->T);\n if (status)\n return status;\n\n /*\n * Compute:\n *\n * Q^T [ QTb_{i-1} ] = [ QTb_{i-1} - w ]\n * [ b_i ] [ b_i - V~ w ]\n *\n * where:\n * \n * w = T^T (QTb_{i-1} + V~^T b_i)\n *\n * p\n * V = [ I ] p\n * [ V~ ] n\n */\n gsl_vector_memcpy(state->work, state->QTb);\n gsl_blas_dgemv(CblasTrans, 1.0, A, b, 1.0, state->work); /* w := w + V~^T b */\n gsl_blas_dtrmv(CblasUpper, CblasTrans, CblasNonUnit, state->T, state->work); /* w := T^T w */\n gsl_vector_sub(state->QTb, state->work); /* QTb := QTb - w */\n\n /* update residual norm */\n gsl_blas_dgemv(CblasNoTrans, -1.0, A, state->work, 1.0, b); /* b := b - V~ w */\n state->rnorm = gsl_hypot(state->rnorm, gsl_blas_dnrm2(b));\n\n return GSL_SUCCESS;\n }\n}\n\n/*\ntsqr_solve()\n Solve the least squares system:\n\nchi^2 = || QTb - R x ||^2 + lambda^2 || x ||^2\n\nusing the SVD of R\n\nInputs: lambda - regularization parameter\n x - (output) solution vector p-by-1\n rnorm - (output) residual norm ||b - A x||\n snorm - (output) solution norm ||x||\n vstate - workspace\n\nReturn: success/error\n*/\n\nstatic int\ntsqr_solve(const double lambda, gsl_vector * x,\n double * rnorm, double * snorm,\n void * vstate)\n{\n tsqr_state_t *state = (tsqr_state_t *) vstate;\n\n if (x->size != state->p)\n {\n GSL_ERROR (\"solution vector does not match workspace\", GSL_EBADLEN);\n }\n else if (lambda < 0.0)\n {\n GSL_ERROR (\"regularization parameter should be non-negative\", GSL_EINVAL);\n }\n else\n {\n if (lambda == 0.0)\n {\n /* solve: R x = Q^T b */\n gsl_vector_memcpy(x, state->QTb);\n gsl_blas_dtrsv(CblasUpper, CblasNoTrans, CblasNonUnit, state->R, x);\n *rnorm = state->rnorm;\n *snorm = gsl_blas_dnrm2(x);\n }\n else\n {\n int status;\n\n /* compute SVD of R if not already computed */\n if (state->svd == 0)\n {\n status = tsqr_svd(state);\n if (status)\n return status;\n }\n\n status = gsl_multifit_linear_solve(lambda, state->R, state->QTb, x, rnorm, snorm,\n state->multifit_workspace_p);\n if (status)\n return status;\n\n *rnorm = gsl_hypot(*rnorm, state->rnorm);\n }\n\n return GSL_SUCCESS;\n }\n}\n\n/*\ntsqr_lcurve()\n Compute L-curve of least squares system\n\nInputs: reg_param - (output) vector of regularization parameters\n rho - (output) vector of residual norms\n eta - (output) vector of solution norms\n vstate - workspace\n\nReturn: success/error\n*/\n\nstatic int\ntsqr_lcurve(gsl_vector * reg_param, gsl_vector * rho,\n gsl_vector * eta, void * vstate)\n{\n tsqr_state_t *state = (tsqr_state_t *) vstate;\n int status;\n size_t i;\n\n /* compute SVD of R if not already computed */\n if (state->svd == 0)\n {\n status = tsqr_svd(state);\n if (status)\n return status;\n }\n\n status = gsl_multifit_linear_lcurve(state->QTb, reg_param, rho, eta,\n state->multifit_workspace_p);\n\n /* now add contribution to rnorm from Q2 factor */\n for (i = 0; i < rho->size; ++i)\n {\n double *rhoi = gsl_vector_ptr(rho, i);\n *rhoi = gsl_hypot(*rhoi, state->rnorm);\n }\n\n return status;\n}\n\nstatic const gsl_matrix *\ntsqr_R(const void * vstate)\n{\n const tsqr_state_t *state = (const tsqr_state_t *) vstate;\n return state->R;\n}\n\nstatic const gsl_vector *\ntsqr_QTb(const void * vstate)\n{\n const tsqr_state_t *state = (const tsqr_state_t *) vstate;\n return state->QTb;\n}\n\nstatic int\ntsqr_rcond(double * rcond, void * vstate)\n{\n tsqr_state_t *state = (tsqr_state_t *) vstate;\n return gsl_linalg_tri_rcond(CblasUpper, state->R, rcond, state->work3);\n}\n\n/*\ntsqr_svd()\n Compute the SVD of the upper triangular\nR factor. This allows us to compute the upper/lower\nbounds on the regularization parameter and compute\nthe matrix reciprocal condition number.\n\nInputs: state - workspace\n\nReturn: success/error\n*/\n\nstatic int\ntsqr_svd(tsqr_state_t * state)\n{\n int status;\n\n status = gsl_multifit_linear_svd(state->R, state->multifit_workspace_p);\n if (status)\n {\n GSL_ERROR(\"error computing SVD of R\", status);\n }\n\n state->svd = 1;\n\n return GSL_SUCCESS;\n}\n\nstatic const gsl_multilarge_linear_type tsqr_type =\n{\n \"tsqr\",\n tsqr_alloc,\n tsqr_reset,\n tsqr_accumulate,\n tsqr_solve,\n tsqr_rcond,\n tsqr_lcurve,\n tsqr_R,\n tsqr_QTb,\n tsqr_free\n};\n\nconst gsl_multilarge_linear_type * gsl_multilarge_linear_tsqr = &tsqr_type;\n", "meta": {"hexsha": "a2b197351309ea043e1e9effb0b83623f71869f1", "size": 12323, "ext": "c", "lang": "C", "max_stars_repo_path": "Chimera/3rd_Party/GSL_MSVC/multilarge/tsqr.c", "max_stars_repo_name": "zzpwahaha/Chimera-Control-Trim", "max_stars_repo_head_hexsha": "df1bbf6bea0b87b8c7c9a99dce213fdc249118f2", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-06-14T11:51:37.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-14T11:51:37.000Z", "max_issues_repo_path": "Chimera/3rd_Party/GSL_MSVC/multilarge/tsqr.c", "max_issues_repo_name": "zzpwahaha/Chimera-Control-Trim", "max_issues_repo_head_hexsha": "df1bbf6bea0b87b8c7c9a99dce213fdc249118f2", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "Chimera/3rd_Party/GSL_MSVC/multilarge/tsqr.c", "max_forks_repo_name": "zzpwahaha/Chimera-Control-Trim", "max_forks_repo_head_hexsha": "df1bbf6bea0b87b8c7c9a99dce213fdc249118f2", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-01-20T16:22:57.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-14T12:31:02.000Z", "avg_line_length": 25.3039014374, "max_line_length": 104, "alphanum_fraction": 0.6097541183, "num_tokens": 3585, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7662936430859597, "lm_q2_score": 0.6548947425132314, "lm_q1q2_score": 0.5018416780783056}} {"text": "// Copyright (c) 2017, Lawrence Livermore National Security, LLC. Produced at\n// the Lawrence Livermore National Laboratory. LLNL-CODE-734707. All Rights\n// reserved. See files LICENSE and NOTICE for details.\n//\n// This file is part of CEED, a collection of benchmarks, miniapps, software\n// libraries and APIs for efficient high-order finite element and spectral\n// element discretizations for exascale applications. For more information and\n// source code availability see http://github.com/ceed.\n//\n// The CEED research is supported by the Exascale Computing Project 17-SC-20-SC,\n// a collaborative effort of two U.S. Department of Energy organizations (Office\n// of Science and the National Nuclear Security Administration) responsible for\n// the planning and preparation of a capable exascale ecosystem, including\n// software, applications, hardware, advanced system engineering and early\n// testbed platforms, in support of the nation's exascale computing imperative.\n\n// libCEED + PETSc Example: CEED BPs 3-6 with Multigrid\n//\n// This example demonstrates a simple usage of libCEED with PETSc to solve the\n// CEED BP benchmark problems, see http://ceed.exascaleproject.org/bps.\n//\n// The code uses higher level communication protocols in DMPlex.\n//\n// Build with:\n//\n// make multigrid [PETSC_DIR=] [CEED_DIR=]\n//\n// Sample runs:\n//\n// multigrid -problem bp3\n// multigrid -problem bp4\n// multigrid -problem bp5 -ceed /cpu/self\n// multigrid -problem bp6 -ceed /gpu/cuda\n//\n//TESTARGS -ceed {ceed_resource} -test -problem bp3 -degree 3\n\n/// @file\n/// CEED BPs 1-6 multigrid example using PETSc\nconst char help[] = \"Solve CEED BPs using p-multigrid with PETSc and DMPlex\\n\";\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"bps.h\"\n#include \"include/bpsproblemdata.h\"\n#include \"include/petscmacros.h\"\n#include \"include/petscutils.h\"\n#include \"include/matops.h\"\n#include \"include/structs.h\"\n#include \"include/libceedsetup.h\"\n\n#if PETSC_VERSION_LT(3,12,0)\n#ifdef PETSC_HAVE_CUDA\n#include \n// Note: With PETSc prior to version 3.12.0, providing the source path to\n// include 'cublas_v2.h' will be needed to use 'petsccuda.h'.\n#endif\n#endif\n\nint main(int argc, char **argv) {\n PetscInt ierr;\n MPI_Comm comm;\n char filename[PETSC_MAX_PATH_LEN],\n ceed_resource[PETSC_MAX_PATH_LEN] = \"/cpu/self\";\n double my_rt_start, my_rt, rt_min, rt_max;\n PetscInt degree = 3, q_extra, *l_size, *xl_size, *g_size, dim = 3, fine_level,\n mesh_elem[3] = {3, 3, 3}, num_comp_u = 1, num_levels = degree, *level_degrees;\n PetscScalar *r;\n PetscScalar eps = 1.0;\n PetscBool test_mode, benchmark_mode, read_mesh, write_solution;\n PetscLogStage solve_stage;\n DM *dm, dm_orig;\n SNES snes_dummy;\n KSP ksp;\n PC pc;\n Mat *mat_O, *mat_pr, mat_coarse;\n Vec *X, *X_loc, *mult, rhs, rhs_loc;\n PetscMemType mem_type;\n UserO *user_O;\n UserProlongRestr *user_pr;\n Ceed ceed;\n CeedData *ceed_data;\n CeedVector rhs_ceed, target;\n CeedQFunction qf_error, qf_restrict, qf_prolong;\n CeedOperator op_error;\n BPType bp_choice;\n CoarsenType coarsen;\n\n ierr = PetscInitialize(&argc, &argv, NULL, help);\n if (ierr) return ierr;\n comm = PETSC_COMM_WORLD;\n\n // Parse command line options\n ierr = PetscOptionsBegin(comm, NULL, \"CEED BPs in PETSc\", NULL); CHKERRQ(ierr);\n bp_choice = CEED_BP3;\n ierr = PetscOptionsEnum(\"-problem\",\n \"CEED benchmark problem to solve\", NULL,\n bp_types, (PetscEnum)bp_choice, (PetscEnum *)&bp_choice,\n NULL); CHKERRQ(ierr);\n num_comp_u = bp_options[bp_choice].num_comp_u;\n test_mode = PETSC_FALSE;\n ierr = PetscOptionsBool(\"-test\",\n \"Testing mode (do not print unless error is large)\",\n NULL, test_mode, &test_mode, NULL); CHKERRQ(ierr);\n benchmark_mode = PETSC_FALSE;\n ierr = PetscOptionsBool(\"-benchmark\",\n \"Benchmarking mode (prints benchmark statistics)\",\n NULL, benchmark_mode, &benchmark_mode, NULL);\n CHKERRQ(ierr);\n write_solution = PETSC_FALSE;\n ierr = PetscOptionsBool(\"-write_solution\",\n \"Write solution for visualization\",\n NULL, write_solution, &write_solution, NULL);\n CHKERRQ(ierr);\n ierr = PetscOptionsScalar(\"-eps\",\n \"Epsilon parameter for Kershaw mesh transformation\",\n NULL, eps, &eps, NULL);\n if (eps > 1 || eps <= 0) SETERRQ1(PETSC_COMM_WORLD, PETSC_ERR_ARG_OUTOFRANGE,\n \"-eps %D must be (0,1]\", eps);\n degree = test_mode ? 3 : 2;\n ierr = PetscOptionsInt(\"-degree\", \"Polynomial degree of tensor product basis\",\n NULL, degree, °ree, NULL); CHKERRQ(ierr);\n if (degree < 1) SETERRQ1(PETSC_COMM_WORLD, PETSC_ERR_ARG_OUTOFRANGE,\n \"-degree %D must be at least 1\", degree);\n q_extra = bp_options[bp_choice].q_extra;\n ierr = PetscOptionsInt(\"-q_extra\", \"Number of extra quadrature points\",\n NULL, q_extra, &q_extra, NULL); CHKERRQ(ierr);\n ierr = PetscOptionsString(\"-ceed\", \"CEED resource specifier\",\n NULL, ceed_resource, ceed_resource,\n sizeof(ceed_resource), NULL); CHKERRQ(ierr);\n coarsen = COARSEN_UNIFORM;\n ierr = PetscOptionsEnum(\"-coarsen\",\n \"Coarsening strategy to use\", NULL,\n coarsen_types, (PetscEnum)coarsen,\n (PetscEnum *)&coarsen, NULL); CHKERRQ(ierr);\n read_mesh = PETSC_FALSE;\n ierr = PetscOptionsString(\"-mesh\", \"Read mesh from file\", NULL,\n filename, filename, sizeof(filename), &read_mesh);\n CHKERRQ(ierr);\n if (!read_mesh) {\n PetscInt tmp = dim;\n ierr = PetscOptionsIntArray(\"-cells\",\"Number of cells per dimension\", NULL,\n mesh_elem, &tmp, NULL); CHKERRQ(ierr);\n }\n ierr = PetscOptionsEnd(); CHKERRQ(ierr);\n\n // Set up libCEED\n CeedInit(ceed_resource, &ceed);\n CeedMemType mem_type_backend;\n CeedGetPreferredMemType(ceed, &mem_type_backend);\n\n // Setup DM\n if (read_mesh) {\n ierr = DMPlexCreateFromFile(PETSC_COMM_WORLD, filename, PETSC_TRUE, &dm_orig);\n CHKERRQ(ierr);\n } else {\n ierr = DMPlexCreateBoxMesh(PETSC_COMM_WORLD, dim, PETSC_FALSE, mesh_elem, NULL,\n NULL, NULL, PETSC_TRUE, &dm_orig); CHKERRQ(ierr);\n }\n\n {\n DM dm_dist = NULL;\n PetscPartitioner part;\n\n ierr = DMPlexGetPartitioner(dm_orig, &part); CHKERRQ(ierr);\n ierr = PetscPartitionerSetFromOptions(part); CHKERRQ(ierr);\n ierr = DMPlexDistribute(dm_orig, 0, NULL, &dm_dist); CHKERRQ(ierr);\n if (dm_dist) {\n ierr = DMDestroy(&dm_orig); CHKERRQ(ierr);\n dm_orig = dm_dist;\n }\n }\n\n // Apply Kershaw mesh transformation\n ierr = Kershaw(dm_orig, eps); CHKERRQ(ierr);\n\n VecType vec_type;\n switch (mem_type_backend) {\n case CEED_MEM_HOST: vec_type = VECSTANDARD; break;\n case CEED_MEM_DEVICE: {\n const char *resolved;\n CeedGetResource(ceed, &resolved);\n if (strstr(resolved, \"/gpu/cuda\")) vec_type = VECCUDA;\n else if (strstr(resolved, \"/gpu/hip/occa\"))\n vec_type = VECSTANDARD; // https://github.com/CEED/libCEED/issues/678\n else if (strstr(resolved, \"/gpu/hip\")) vec_type = VECHIP;\n else vec_type = VECSTANDARD;\n }\n }\n ierr = DMSetVecType(dm_orig, vec_type); CHKERRQ(ierr);\n ierr = DMSetFromOptions(dm_orig); CHKERRQ(ierr);\n\n // Allocate arrays for PETSc objects for each level\n switch (coarsen) {\n case COARSEN_UNIFORM:\n num_levels = degree;\n break;\n case COARSEN_LOGARITHMIC:\n num_levels = ceil(log(degree)/log(2)) + 1;\n break;\n }\n ierr = PetscMalloc1(num_levels, &level_degrees); CHKERRQ(ierr);\n fine_level = num_levels - 1;\n\n switch (coarsen) {\n case COARSEN_UNIFORM:\n for (int i=0; i 0) {\n // Interp\n ierr = PetscMalloc1(1, &user_pr[i]); CHKERRQ(ierr);\n ierr = MatCreateShell(comm, l_size[i], l_size[i-1], g_size[i], g_size[i-1],\n user_pr[i], &mat_pr[i]); CHKERRQ(ierr);\n ierr = MatShellSetOperation(mat_pr[i], MATOP_MULT,\n (void(*)(void))MatMult_Prolong);\n CHKERRQ(ierr);\n ierr = MatShellSetOperation(mat_pr[i], MATOP_MULT_TRANSPOSE,\n (void(*)(void))MatMult_Restrict);\n CHKERRQ(ierr);\n ierr = MatShellSetVecType(mat_pr[i], vec_type); CHKERRQ(ierr);\n }\n }\n ierr = VecDuplicate(X[fine_level], &rhs); CHKERRQ(ierr);\n\n // Print global grid information\n if (!test_mode) {\n PetscInt P = degree + 1, Q = P + q_extra;\n\n const char *used_resource;\n CeedGetResource(ceed, &used_resource);\n\n ierr = VecGetType(X[0], &vec_type); CHKERRQ(ierr);\n\n ierr = PetscPrintf(comm,\n \"\\n-- CEED Benchmark Problem %d -- libCEED + PETSc + PCMG --\\n\"\n \" PETSc:\\n\"\n \" PETSc Vec Type : %s\\n\"\n \" libCEED:\\n\"\n \" libCEED Backend : %s\\n\"\n \" libCEED Backend MemType : %s\\n\"\n \" Mesh:\\n\"\n \" Number of 1D Basis Nodes (p) : %d\\n\"\n \" Number of 1D Quadrature Points (q) : %d\\n\"\n \" Global Nodes : %D\\n\"\n \" Owned Nodes : %D\\n\"\n \" DoF per node : %D\\n\"\n \" Multigrid:\\n\"\n \" Number of Levels : %d\\n\",\n bp_choice+1, vec_type, used_resource,\n CeedMemTypes[mem_type_backend],\n P, Q, g_size[fine_level]/num_comp_u, l_size[fine_level]/num_comp_u,\n num_comp_u, num_levels); CHKERRQ(ierr);\n }\n\n // Create RHS vector\n ierr = VecDuplicate(X_loc[fine_level], &rhs_loc); CHKERRQ(ierr);\n ierr = VecZeroEntries(rhs_loc); CHKERRQ(ierr);\n ierr = VecGetArrayAndMemType(rhs_loc, &r, &mem_type); CHKERRQ(ierr);\n CeedVectorCreate(ceed, xl_size[fine_level], &rhs_ceed);\n CeedVectorSetArray(rhs_ceed, MemTypeP2C(mem_type), CEED_USE_POINTER, r);\n\n // Set up libCEED operators on each level\n ierr = PetscMalloc1(num_levels, &ceed_data); CHKERRQ(ierr);\n for (int i=0; ielem_restr_u,\n ceed_data[fine_level]->basis_u, CEED_VECTOR_ACTIVE);\n CeedOperatorSetField(op_error, \"true_soln\",\n ceed_data[fine_level]->elem_restr_u_i,\n CEED_BASIS_COLLOCATED, target);\n CeedOperatorSetField(op_error, \"error\", ceed_data[fine_level]->elem_restr_u_i,\n CEED_BASIS_COLLOCATED, CEED_VECTOR_ACTIVE);\n\n // Calculate multiplicity\n for (int i=0; ix_ceed, CEED_MEM_HOST, CEED_USE_POINTER, x);\n\n // Multiplicity\n CeedElemRestrictionGetMultiplicity(ceed_data[i]->elem_restr_u,\n ceed_data[i]->x_ceed);\n CeedVectorSyncArray(ceed_data[i]->x_ceed, CEED_MEM_HOST);\n\n // Restore vector\n ierr = VecRestoreArray(X_loc[i], &x); CHKERRQ(ierr);\n\n // Creat mult vector\n ierr = VecDuplicate(X_loc[i], &mult[i]); CHKERRQ(ierr);\n\n // Local-to-global\n ierr = VecZeroEntries(X[i]); CHKERRQ(ierr);\n ierr = DMLocalToGlobal(dm[i], X_loc[i], ADD_VALUES, X[i]);\n CHKERRQ(ierr);\n ierr = VecZeroEntries(X_loc[i]); CHKERRQ(ierr);\n\n // Global-to-local\n ierr = DMGlobalToLocal(dm[i], X[i], INSERT_VALUES, mult[i]);\n CHKERRQ(ierr);\n ierr = VecZeroEntries(X[i]); CHKERRQ(ierr);\n\n // Multiplicity scaling\n ierr = VecReciprocal(mult[i]);\n }\n\n // Set up Mat\n for (int i=0; icomm = comm;\n user_O[i]->dm = dm[i];\n user_O[i]->X_loc = X_loc[i];\n ierr = VecDuplicate(X_loc[i], &user_O[i]->Y_loc); CHKERRQ(ierr);\n user_O[i]->x_ceed = ceed_data[i]->x_ceed;\n user_O[i]->y_ceed = ceed_data[i]->y_ceed;\n user_O[i]->op = ceed_data[i]->op_apply;\n user_O[i]->ceed = ceed;\n\n if (i > 0) {\n // Prolongation/Restriction Operator\n user_pr[i]->comm = comm;\n user_pr[i]->dmf = dm[i];\n user_pr[i]->dmc = dm[i-1];\n user_pr[i]->loc_vec_c = X_loc[i-1];\n user_pr[i]->loc_vec_f = user_O[i]->Y_loc;\n user_pr[i]->mult_vec = mult[i];\n user_pr[i]->ceed_vec_c = user_O[i-1]->x_ceed;\n user_pr[i]->ceed_vec_f = user_O[i]->y_ceed;\n user_pr[i]->op_prolong = ceed_data[i]->op_prolong;\n user_pr[i]->op_restrict = ceed_data[i]->op_restrict;\n user_pr[i]->ceed = ceed;\n }\n }\n\n // Setup dummy SNES for AMG coarse solve\n ierr = SNESCreate(comm, &snes_dummy); CHKERRQ(ierr);\n ierr = SNESSetDM(snes_dummy, dm[0]); CHKERRQ(ierr);\n ierr = SNESSetSolution(snes_dummy, X[0]); CHKERRQ(ierr);\n\n // -- Jacobian matrix\n ierr = DMSetMatType(dm[0], MATAIJ); CHKERRQ(ierr);\n ierr = DMCreateMatrix(dm[0], &mat_coarse); CHKERRQ(ierr);\n ierr = SNESSetJacobian(snes_dummy, mat_coarse, mat_coarse, NULL,\n NULL); CHKERRQ(ierr);\n\n // -- Residual evaluation function\n ierr = SNESSetFunction(snes_dummy, X[0], FormResidual_Ceed,\n user_O[0]); CHKERRQ(ierr);\n\n // -- Form Jacobian\n ierr = SNESComputeJacobianDefaultColor(snes_dummy, X[0], mat_O[0],\n mat_coarse, NULL); CHKERRQ(ierr);\n\n // Set up KSP\n ierr = KSPCreate(comm, &ksp); CHKERRQ(ierr);\n {\n ierr = KSPSetType(ksp, KSPCG); CHKERRQ(ierr);\n ierr = KSPSetNormType(ksp, KSP_NORM_NATURAL); CHKERRQ(ierr);\n ierr = KSPSetTolerances(ksp, 1e-10, PETSC_DEFAULT, PETSC_DEFAULT,\n PETSC_DEFAULT); CHKERRQ(ierr);\n }\n ierr = KSPSetFromOptions(ksp); CHKERRQ(ierr);\n ierr = KSPSetOperators(ksp, mat_O[fine_level], mat_O[fine_level]);\n CHKERRQ(ierr);\n\n // Set up PCMG\n ierr = KSPGetPC(ksp, &pc); CHKERRQ(ierr);\n PCMGCycleType pcmg_cycle_type = PC_MG_CYCLE_V;\n {\n ierr = PCSetType(pc, PCMG); CHKERRQ(ierr);\n\n // PCMG levels\n ierr = PCMGSetLevels(pc, num_levels, NULL); CHKERRQ(ierr);\n for (int i=0; i 0) {\n // Interpolation\n ierr = PCMGSetInterpolation(pc, i, mat_pr[i]); CHKERRQ(ierr);\n }\n\n // Coarse solve\n KSP coarse;\n PC coarse_pc;\n ierr = PCMGGetCoarseSolve(pc, &coarse); CHKERRQ(ierr);\n ierr = KSPSetType(coarse, KSPPREONLY); CHKERRQ(ierr);\n ierr = KSPSetOperators(coarse, mat_coarse, mat_coarse); CHKERRQ(ierr);\n\n ierr = KSPGetPC(coarse, &coarse_pc); CHKERRQ(ierr);\n ierr = PCSetType(coarse_pc, PCGAMG); CHKERRQ(ierr);\n\n ierr = KSPSetOptionsPrefix(coarse, \"coarse_\"); CHKERRQ(ierr);\n ierr = PCSetOptionsPrefix(coarse_pc, \"coarse_\"); CHKERRQ(ierr);\n ierr = KSPSetFromOptions(coarse); CHKERRQ(ierr);\n ierr = PCSetFromOptions(coarse_pc); CHKERRQ(ierr);\n }\n\n // PCMG options\n ierr = PCMGSetType(pc, PC_MG_MULTIPLICATIVE); CHKERRQ(ierr);\n ierr = PCMGSetNumberSmooth(pc, 3); CHKERRQ(ierr);\n ierr = PCMGSetCycleType(pc, pcmg_cycle_type); CHKERRQ(ierr);\n }\n\n // First run, if benchmarking\n if (benchmark_mode) {\n ierr = KSPSetTolerances(ksp, 1e-10, PETSC_DEFAULT, PETSC_DEFAULT, 1);\n CHKERRQ(ierr);\n ierr = VecZeroEntries(X[fine_level]); CHKERRQ(ierr);\n my_rt_start = MPI_Wtime();\n ierr = KSPSolve(ksp, rhs, X[fine_level]); CHKERRQ(ierr);\n my_rt = MPI_Wtime() - my_rt_start;\n ierr = MPI_Allreduce(MPI_IN_PLACE, &my_rt, 1, MPI_DOUBLE, MPI_MIN, comm);\n CHKERRQ(ierr);\n // Set maxits based on first iteration timing\n if (my_rt > 0.02) {\n ierr = KSPSetTolerances(ksp, 1e-10, PETSC_DEFAULT, PETSC_DEFAULT, 5);\n CHKERRQ(ierr);\n } else {\n ierr = KSPSetTolerances(ksp, 1e-10, PETSC_DEFAULT, PETSC_DEFAULT, 20);\n CHKERRQ(ierr);\n }\n }\n\n // Timed solve\n ierr = VecZeroEntries(X[fine_level]); CHKERRQ(ierr);\n ierr = PetscBarrier((PetscObject)ksp); CHKERRQ(ierr);\n\n // -- Performance logging\n ierr = PetscLogStageRegister(\"Solve Stage\", &solve_stage); CHKERRQ(ierr);\n ierr = PetscLogStagePush(solve_stage); CHKERRQ(ierr);\n\n // -- Solve\n my_rt_start = MPI_Wtime();\n ierr = KSPSolve(ksp, rhs, X[fine_level]); CHKERRQ(ierr);\n my_rt = MPI_Wtime() - my_rt_start;\n\n\n // -- Performance logging\n ierr = PetscLogStagePop();\n\n // Output results\n {\n KSPType ksp_type;\n PCMGType pcmg_type;\n KSPConvergedReason reason;\n PetscReal rnorm;\n PetscInt its;\n ierr = KSPGetType(ksp, &ksp_type); CHKERRQ(ierr);\n ierr = KSPGetConvergedReason(ksp, &reason); CHKERRQ(ierr);\n ierr = KSPGetIterationNumber(ksp, &its); CHKERRQ(ierr);\n ierr = KSPGetResidualNorm(ksp, &rnorm); CHKERRQ(ierr);\n ierr = PCMGGetType(pc, &pcmg_type); CHKERRQ(ierr);\n if (!test_mode || reason < 0 || rnorm > 1e-8) {\n ierr = PetscPrintf(comm,\n \" KSP:\\n\"\n \" KSP Type : %s\\n\"\n \" KSP Convergence : %s\\n\"\n \" Total KSP Iterations : %D\\n\"\n \" Final rnorm : %e\\n\",\n ksp_type, KSPConvergedReasons[reason], its,\n (double)rnorm); CHKERRQ(ierr);\n ierr = PetscPrintf(comm,\n \" PCMG:\\n\"\n \" PCMG Type : %s\\n\"\n \" PCMG Cycle Type : %s\\n\",\n PCMGTypes[pcmg_type],\n PCMGCycleTypes[pcmg_cycle_type]); CHKERRQ(ierr);\n }\n if (!test_mode) {\n ierr = PetscPrintf(comm,\" Performance:\\n\"); CHKERRQ(ierr);\n }\n {\n PetscReal max_error;\n ierr = ComputeErrorMax(user_O[fine_level], op_error, X[fine_level], target,\n &max_error); CHKERRQ(ierr);\n PetscReal tol = 5e-2;\n if (!test_mode || max_error > tol) {\n ierr = MPI_Allreduce(&my_rt, &rt_min, 1, MPI_DOUBLE, MPI_MIN, comm);\n CHKERRQ(ierr);\n ierr = MPI_Allreduce(&my_rt, &rt_max, 1, MPI_DOUBLE, MPI_MAX, comm);\n CHKERRQ(ierr);\n ierr = PetscPrintf(comm,\n \" Pointwise Error (max) : %e\\n\"\n \" CG Solve Time : %g (%g) sec\\n\",\n (double)max_error, rt_max, rt_min); CHKERRQ(ierr);\n }\n }\n if (benchmark_mode && (!test_mode)) {\n ierr = PetscPrintf(comm,\n \" DoFs/Sec in CG : %g (%g) million\\n\",\n 1e-6*g_size[fine_level]*its/rt_max,\n 1e-6*g_size[fine_level]*its/rt_min);\n CHKERRQ(ierr);\n }\n }\n\n if (write_solution) {\n PetscViewer vtk_viewer_soln;\n\n ierr = PetscViewerCreate(comm, &vtk_viewer_soln); CHKERRQ(ierr);\n ierr = PetscViewerSetType(vtk_viewer_soln, PETSCVIEWERVTK); CHKERRQ(ierr);\n ierr = PetscViewerFileSetName(vtk_viewer_soln, \"solution.vtu\"); CHKERRQ(ierr);\n ierr = VecView(X[fine_level], vtk_viewer_soln); CHKERRQ(ierr);\n ierr = PetscViewerDestroy(&vtk_viewer_soln); CHKERRQ(ierr);\n }\n\n // Cleanup\n for (int i=0; iY_loc); CHKERRQ(ierr);\n ierr = MatDestroy(&mat_O[i]); CHKERRQ(ierr);\n ierr = PetscFree(user_O[i]); CHKERRQ(ierr);\n if (i > 0) {\n ierr = MatDestroy(&mat_pr[i]); CHKERRQ(ierr);\n ierr = PetscFree(user_pr[i]); CHKERRQ(ierr);\n }\n ierr = CeedDataDestroy(i, ceed_data[i]); CHKERRQ(ierr);\n ierr = DMDestroy(&dm[i]); CHKERRQ(ierr);\n }\n ierr = PetscFree(level_degrees); CHKERRQ(ierr);\n ierr = PetscFree(dm); CHKERRQ(ierr);\n ierr = PetscFree(X); CHKERRQ(ierr);\n ierr = PetscFree(X_loc); CHKERRQ(ierr);\n ierr = PetscFree(mult); CHKERRQ(ierr);\n ierr = PetscFree(mat_O); CHKERRQ(ierr);\n ierr = PetscFree(mat_pr); CHKERRQ(ierr);\n ierr = PetscFree(ceed_data); CHKERRQ(ierr);\n ierr = PetscFree(user_O); CHKERRQ(ierr);\n ierr = PetscFree(user_pr); CHKERRQ(ierr);\n ierr = PetscFree(l_size); CHKERRQ(ierr);\n ierr = PetscFree(xl_size); CHKERRQ(ierr);\n ierr = PetscFree(g_size); CHKERRQ(ierr);\n ierr = VecDestroy(&rhs); CHKERRQ(ierr);\n ierr = VecDestroy(&rhs_loc); CHKERRQ(ierr);\n ierr = MatDestroy(&mat_coarse); CHKERRQ(ierr);\n ierr = KSPDestroy(&ksp); CHKERRQ(ierr);\n ierr = SNESDestroy(&snes_dummy); CHKERRQ(ierr);\n ierr = DMDestroy(&dm_orig); CHKERRQ(ierr);\n CeedVectorDestroy(&target);\n CeedQFunctionDestroy(&qf_error);\n CeedQFunctionDestroy(&qf_restrict);\n CeedQFunctionDestroy(&qf_prolong);\n CeedOperatorDestroy(&op_error);\n CeedDestroy(&ceed);\n return PetscFinalize();\n}\n", "meta": {"hexsha": "5c1ddb07bd5cbec42d95d4bc1ba0e34ad117bb3b", "size": 26640, "ext": "c", "lang": "C", "max_stars_repo_path": "examples/petsc/multigrid.c", "max_stars_repo_name": "AdelekeBankole/libCEED", "max_stars_repo_head_hexsha": "aae8ce39fa1e28b745979a9cbffc67a790eb3f5e", "max_stars_repo_licenses": ["BSD-2-Clause"], "max_stars_count": 123.0, "max_stars_repo_stars_event_min_datetime": "2018-01-29T02:04:05.000Z", "max_stars_repo_stars_event_max_datetime": "2022-03-21T18:13:48.000Z", "max_issues_repo_path": "examples/petsc/multigrid.c", "max_issues_repo_name": "AdelekeBankole/libCEED", "max_issues_repo_head_hexsha": "aae8ce39fa1e28b745979a9cbffc67a790eb3f5e", "max_issues_repo_licenses": ["BSD-2-Clause"], "max_issues_count": 781.0, "max_issues_repo_issues_event_min_datetime": "2017-12-22T17:20:35.000Z", "max_issues_repo_issues_event_max_datetime": "2022-03-29T21:34:34.000Z", "max_forks_repo_path": "examples/petsc/multigrid.c", "max_forks_repo_name": "AdelekeBankole/libCEED", "max_forks_repo_head_hexsha": "aae8ce39fa1e28b745979a9cbffc67a790eb3f5e", "max_forks_repo_licenses": ["BSD-2-Clause"], "max_forks_count": 41.0, "max_forks_repo_forks_event_min_datetime": "2017-12-27T22:35:13.000Z", "max_forks_repo_forks_event_max_datetime": "2022-03-01T13:02:07.000Z", "avg_line_length": 40.2416918429, "max_line_length": 94, "alphanum_fraction": 0.614527027, "num_tokens": 7363, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7461390043208002, "lm_q2_score": 0.6723317057447908, "lm_q1q2_score": 0.5016529094977235}} {"text": "#ifndef __FFT_DECON_OPERATOR_H__\n#define __FFT_DECON_OPERATOR_H__\n#include \n#include \n#include \n#include \"mspass/seismic/TimeWindow.h\"\n#include \"mspass/utility/Metadata.h\"\n#include \"mspass/seismic/CoreTimeSeries.h\"\n#include \"mspass/algorithms/deconvolution/ComplexArray.h\"\nnamespace mspass::algorithms::deconvolution{\n/*! \\brief Object to hold components needed in all fft based decon algorithms.\n\nThe fft based algorithms implemented here us the GNU Scientific Library\nprime factorization fft algorithm. Those methods require initialization\ngiven length of the fft to load and store the factorization data. This\nobject holds these for all such methods and recomputes them only when\nneeded for efficiency. */\nclass FFTDeconOperator\n{\npublic:\n FFTDeconOperator();\n FFTDeconOperator(const mspass::utility::Metadata& md);\n FFTDeconOperator(const FFTDeconOperator& parent);\n ~FFTDeconOperator();\n FFTDeconOperator& operator=(const FFTDeconOperator& parent);\n void changeparameter(const mspass::utility::Metadata& md);\n void change_size(const int nfft_new);\n void change_shift(const int shift) {\n sample_shift=shift;\n };\n int get_size(){return nfft;};\n int get_shift(){return sample_shift;};\n int operator_size() {\n return static_cast(nfft);\n };\n int operator_shift() {\n return sample_shift;\n };\n double df(const double dt){\n double period;\n period=static_cast(nfft)*dt;\n return 1.0/period;\n };\n /*! \\brief Return inverse wavelet for Fourier methods.\n\n This is a helper to be used by the inverse_wavelet method for all\n Fourier based deconvolution methods. It avoids repetitious code that\n would be required otherwise. inverse_wavelet methods are only\n wrappers for this generic method. See documentation for inverse_wavelet\n for description of tshift and t0parent. */\n mspass::seismic::CoreTimeSeries FourierInverse(const ComplexArray& winv, const ComplexArray& sw,\n \tconst double dt, const double t0parent);\n\nprotected:\n int nfft;\n int sample_shift;\n gsl_fft_complex_wavetable *wavetable;\n gsl_fft_complex_workspace *workspace;\n ComplexArray winv;\n};\n\n/* This helper is best referenced here */\n\n/*! \\brief Circular buffer procedure.\n\n In the Fourier world circular vectors are an important thing\n to deal with because the fft is intimately connected with circlular\n things. This routine can be used, for example, to time shift the\n time domain version of a signal after it was processed with an fft.\n\n \\param d - is the input vector to be shifted\n \\param i0 - is the wrap point. On exit sample i0 of d will be sample 0.\n (Warning - this is C convention sample number)\n*/\n\nstd::vector circular_shift(const std::vector& d,const int i0);\n/*! Derive fft length from a time window.\n\nAll deconvlution methods using an fft need to define nfft based on the\nlength of the working time series. This procedure returns the size from\nan input window and sample interval. */\nint ComputeFFTLength(const mspass::seismic::TimeWindow w, const double dt);\n/*! Derive fft length using parameters in a metadata object.\n\nThis procedure is basically a higher level version of the function of\nthe same name with a time window and sample interval argument.\nThis procedure extracts these using three parameter keys to extract\nthe real numbers form md: deconvolution_data_window_start,\ndecon_window_end, and target dt. */\nint ComputeFFTLength(const mspass::utility::Metadata& md);\n/*! Returns next power of 2 larger than n.\n *\n * Some FFT implementations require the size of the input data vector be a power\n * of 2. This routine can be used to define a buffer size satisfying that constraint.*/\nextern \"C\" {\n unsigned int nextPowerOf2(unsigned int n);\n}\n}\n#endif\n", "meta": {"hexsha": "63fca050efe49bae7365bc547eff8a10060a308e", "size": 3864, "ext": "h", "lang": "C", "max_stars_repo_path": "cxx/include/mspass/algorithms/deconvolution/FFTDeconOperator.h", "max_stars_repo_name": "seisman/mspass", "max_stars_repo_head_hexsha": "11bd292a778a2a0d8470734239a7347fe4a1c0a7", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-10-18T10:02:13.000Z", "max_stars_repo_stars_event_max_datetime": "2021-10-18T10:02:13.000Z", "max_issues_repo_path": "cxx/include/mspass/algorithms/deconvolution/FFTDeconOperator.h", "max_issues_repo_name": "seisman/mspass", "max_issues_repo_head_hexsha": "11bd292a778a2a0d8470734239a7347fe4a1c0a7", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "cxx/include/mspass/algorithms/deconvolution/FFTDeconOperator.h", "max_forks_repo_name": "seisman/mspass", "max_forks_repo_head_hexsha": "11bd292a778a2a0d8470734239a7347fe4a1c0a7", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 38.64, "max_line_length": 100, "alphanum_fraction": 0.7523291925, "num_tokens": 894, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7956581000631542, "lm_q2_score": 0.6297746213017459, "lm_q1q2_score": 0.5010852786529396}} {"text": "/* randist/mvgauss.c\n * \n * Copyright (C) 2016 Timothée Flutre, Patrick Alken\n * \n * This program is free software; you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation; either version 3 of the License, or (at\n * your option) any later version.\n * \n * This program is distributed in the hope that it will be useful, but\n * WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n * General Public License for more details.\n * \n * You should have received a copy of the GNU General Public License\n * along with this program; if not, write to the Free Software\n * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\n */\n\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nstatic int multivar_vcov (const double data[], size_t d, size_t tda, size_t n,\n double vcov[], size_t tda2);\n\n/* Generate a random vector from a multivariate Gaussian distribution using\n * the Cholesky decomposition of the variance-covariance matrix, following\n * \"Computational Statistics\" from Gentle (2009), section 7.4.\n *\n * mu mean vector (dimension d)\n * L matrix resulting from the Cholesky decomposition of\n * variance-covariance matrix Sigma = L L^T (dimension d x d)\n * result output vector (dimension d)\n */\nint\ngsl_ran_multivariate_gaussian (const gsl_rng * r,\n const gsl_vector * mu,\n const gsl_matrix * L,\n gsl_vector * result)\n{\n const size_t M = L->size1;\n const size_t N = L->size2;\n\n if (M != N)\n {\n GSL_ERROR(\"requires square matrix\", GSL_ENOTSQR);\n }\n else if (mu->size != M)\n {\n GSL_ERROR(\"incompatible dimension of mean vector with variance-covariance matrix\", GSL_EBADLEN);\n }\n else if (result->size != M)\n {\n GSL_ERROR(\"incompatible dimension of result vector\", GSL_EBADLEN);\n }\n else\n {\n size_t i;\n\n for (i = 0; i < M; ++i)\n gsl_vector_set(result, i, gsl_ran_ugaussian(r));\n\n gsl_blas_dtrmv(CblasLower, CblasNoTrans, CblasNonUnit, L, result);\n gsl_vector_add(result, mu);\n\n return GSL_SUCCESS;\n }\n}\n\n/* Compute the log of the probability density function at a given quantile\n * vector for a multivariate Gaussian distribution using the Cholesky\n * decomposition of the variance-covariance matrix.\n *\n * x vector of quantiles (dimension d)\n * mu mean vector (dimension d)\n * L matrix resulting from the Cholesky decomposition of\n * variance-covariance matrix Sigma = L L^T (dimension d x d)\n * result output of the density (dimension 1)\n * work vector used for intermediate computations (dimension d)\n */\nint\ngsl_ran_multivariate_gaussian_log_pdf (const gsl_vector * x,\n const gsl_vector * mu,\n const gsl_matrix * L,\n double * result,\n gsl_vector * work)\n{\n const size_t M = L->size1;\n const size_t N = L->size2;\n\n if (M != N)\n {\n GSL_ERROR(\"requires square matrix\", GSL_ENOTSQR);\n }\n else if (mu->size != M)\n {\n GSL_ERROR(\"incompatible dimension of mean vector with variance-covariance matrix\", GSL_EBADLEN);\n }\n else if (x->size != M)\n {\n GSL_ERROR(\"incompatible dimension of quantile vector\", GSL_EBADLEN);\n }\n else if (work->size != M)\n {\n GSL_ERROR(\"incompatible dimension of work vector\", GSL_EBADLEN);\n }\n else\n {\n size_t i;\n double quadForm; /* (x - mu)' Sigma^{-1} (x - mu) */\n double logSqrtDetSigma; /* log [ sqrt(|Sigma|) ] */\n\n /* compute: work = x - mu */\n for (i = 0; i < M; ++i)\n {\n double xi = gsl_vector_get(x, i);\n double mui = gsl_vector_get(mu, i);\n gsl_vector_set(work, i, xi - mui);\n }\n\n /* compute: work = L^{-1} * (x - mu) */\n gsl_blas_dtrsv(CblasLower, CblasNoTrans, CblasNonUnit, L, work);\n\n /* compute: quadForm = (x - mu)' Sigma^{-1} (x - mu) */\n gsl_blas_ddot(work, work, &quadForm);\n\n /* compute: log [ sqrt(|Sigma|) ] = sum_i log L_{ii} */\n logSqrtDetSigma = 0.0;\n for (i = 0; i < M; ++i)\n {\n double Lii = gsl_matrix_get(L, i, i);\n logSqrtDetSigma += log(Lii);\n }\n\n *result = -0.5*quadForm - logSqrtDetSigma - 0.5*M*log(2.0*M_PI);\n\n return GSL_SUCCESS;\n }\n}\n\nint\ngsl_ran_multivariate_gaussian_pdf (const gsl_vector * x,\n const gsl_vector * mu,\n const gsl_matrix * L,\n double * result,\n gsl_vector * work)\n{\n double logpdf;\n int status = gsl_ran_multivariate_gaussian_log_pdf(x, mu, L, &logpdf, work);\n\n if (status == GSL_SUCCESS)\n *result = exp(logpdf);\n\n return status;\n}\n\n/* Compute the maximum-likelihood estimate of the mean vector of samples\n * from a multivariate Gaussian distribution.\n *\n * Example from R (GPL): http://www.r-project.org/\n * (samples <- matrix(c(4.348817, 2.995049, -3.793431, 4.711934, 1.190864, -1.357363), nrow=3, ncol=2))\n * colMeans(samples) # 1.183478 1.515145\n */\nint\ngsl_ran_multivariate_gaussian_mean (const gsl_matrix * X, gsl_vector * mu_hat)\n{\n const size_t M = X->size1;\n const size_t N = X->size2;\n\n if (N != mu_hat->size)\n {\n GSL_ERROR(\"mu_hat vector has wrong size\", GSL_EBADLEN);\n }\n else\n {\n size_t j;\n\n for (j = 0; j < N; ++j)\n {\n gsl_vector_const_view c = gsl_matrix_const_column(X, j);\n double mean = gsl_stats_mean(c.vector.data, c.vector.stride, M);\n gsl_vector_set(mu_hat, j, mean);\n }\n\n return GSL_SUCCESS;\n }\n}\n\n/* Compute the maximum-likelihood estimate of the variance-covariance matrix\n * of samples from a multivariate Gaussian distribution.\n */\nint\ngsl_ran_multivariate_gaussian_vcov (const gsl_matrix * X, gsl_matrix * sigma_hat)\n{\n const size_t M = X->size1;\n const size_t N = X->size2;\n\n if (sigma_hat->size1 != sigma_hat->size2)\n {\n GSL_ERROR(\"sigma_hat must be a square matrix\", GSL_ENOTSQR);\n }\n else if (N != sigma_hat->size1)\n {\n GSL_ERROR(\"sigma_hat does not match X matrix dimensions\", GSL_EBADLEN);\n }\n else\n {\n return multivar_vcov (X->data, N, X->tda, M, sigma_hat->data, sigma_hat->tda);\n }\n}\n\n/* Example from R (GPL): http://www.r-project.org/\n * (samples <- matrix(c(4.348817, 2.995049, -3.793431, 4.711934, 1.190864, -1.357363), nrow=3, ncol=2))\n * cov(samples) # 19.03539 11.91384 \\n 11.91384 9.28796\n */\nstatic int\nmultivar_vcov (const double data[], size_t d, size_t tda, size_t n,\n double vcov[], size_t tda2)\n{\n size_t j1 = 0, j2 = 0;\n\n for (j1 = 0; j1 < d; ++j1)\n {\n vcov[j1 * tda2 + j1] = gsl_stats_variance(&(data[j1]), tda, n);\n for (j2 = j1 + 1; j2 < d; ++j2)\n {\n vcov[j1 * tda2 + j2] = gsl_stats_covariance(&(data[j1]), tda,\n &(data[j2]), tda, n);\n vcov[j2 * tda2 + j1] = vcov[j1 * tda2 + j2];\n }\n }\n \n return GSL_SUCCESS;\n}\n", "meta": {"hexsha": "917429f463b516f26326de53061a454d05d466ea", "size": 7514, "ext": "c", "lang": "C", "max_stars_repo_path": "gsl-2.6/randist/mvgauss.c", "max_stars_repo_name": "ielomariala/Hex-Game", "max_stars_repo_head_hexsha": "2c2e7c85f8414cb0e654cb82e9686cce5e75c63a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2021-06-14T11:51:37.000Z", "max_stars_repo_stars_event_max_datetime": "2021-06-14T11:51:37.000Z", "max_issues_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/randist/mvgauss.c", "max_issues_repo_name": "Brian-ning/HMNE", "max_issues_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_issues_repo_licenses": ["Apache-2.0"], "max_issues_count": 6.0, "max_issues_repo_issues_event_min_datetime": "2019-12-16T17:41:24.000Z", "max_issues_repo_issues_event_max_datetime": "2019-12-22T00:00:16.000Z", "max_forks_repo_path": "Source/BaselineMethods/MNE/C++/gsl-2.4/randist/mvgauss.c", "max_forks_repo_name": "Brian-ning/HMNE", "max_forks_repo_head_hexsha": "1b4ee4c146f526ea6e2f4f8607df7e9687204a9e", "max_forks_repo_licenses": ["Apache-2.0"], "max_forks_count": 2.0, "max_forks_repo_forks_event_min_datetime": "2021-01-20T16:22:57.000Z", "max_forks_repo_forks_event_max_datetime": "2021-02-14T12:31:02.000Z", "avg_line_length": 30.9218106996, "max_line_length": 103, "alphanum_fraction": 0.6027415491, "num_tokens": 2096, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7690802370707283, "lm_q2_score": 0.6513548511303336, "lm_q1q2_score": 0.5009441433244859}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\nvoid read_matrix(int** index, int** matrix, double scaling, int N_kw, char* input_fileName)\n{\n FILE *fp = fopen(input_fileName, \"r\");\n fscanf(fp, \"%*[^\\n]\\n\");\n\n for (int ii = 0; ii < N_kw; ii++)\n fscanf(fp, \"%d,\", &((*index)[ii]));\n fscanf(fp, \"%*[^\\n]\\n\");\n\n int tmp;\n for (int ii = 0; ii < N_kw; ii++)\n {\n for (int jj = 0; jj < N_kw; jj++)\n {\n fscanf(fp, \"%d,\", &tmp);\n (*matrix)[ii*N_kw + jj] = (int) (scaling * tmp);\n }\n fscanf(fp, \"%*[^\\n]\\n\");\n }\n fclose(fp);\n}\n\n\nvoid pad_matrix(int** matrix_padded, int** matrix, int N_kw, int N_doc, int freq_max)\n{\n // Initialising RNG\n const gsl_rng_type * T;\n gsl_rng * r;\n gsl_rng_env_setup();\n T = gsl_rng_default;\n r = gsl_rng_alloc(T);\n\n // perform padding on the keywords\n int ii, jj;\n #pragma omp parallel for private(ii)\n for (int ii = 0; ii < N_kw; ii++)\n (*matrix_padded)[ii*N_kw + ii] = 2*freq_max;\n\n // perform padding\n #pragma omp parallel for private(ii, jj)\n for (ii = 0; ii < N_kw; ii++)\n {\n for (jj = 0; jj < N_kw; jj++)\n {\n if (ii > jj)\n {\n int n1 = 2*freq_max - (*matrix)[ii*N_kw + ii];\n int n2 = 2*freq_max - (*matrix)[jj*N_kw + jj];\n int x1 = gsl_ran_hypergeometric(r, n1, 2*N_doc-n1, (*matrix_padded)[jj*N_kw + jj]);\n int x2 = gsl_ran_hypergeometric(r, n2, 2*N_doc-n2, (*matrix_padded)[ii*N_kw + ii]);\n\n (*matrix_padded)[ii*N_kw + jj] = (*matrix)[ii*N_kw + jj] + x1 + x2;\n (*matrix_padded)[jj*N_kw + ii] = (*matrix_padded)[ii*N_kw + jj];\n }\n }\n }\n gsl_rng_free(r);\n}\n \n\n\nvoid observe_matrix(gsl_matrix* matrix_obs, int** matrix_padded, int N_kw)\n{\n // perform observed count generation\n for (int ii = 0; ii < N_kw; ii++)\n for (int jj = 0; jj < N_kw; jj++)\n gsl_matrix_set(matrix_obs, ii, jj, (double) ((*matrix_padded)[ii*N_kw + jj]));\n}\n\n\n\nvoid permutation_generation(int* idx1, int* idx2, int** permutation_tmp, int** permutation, int** permutation_inv, int N_kw, int N_obs)\n{\n *idx1 = rand() % N_obs;\n *idx2 = -1;\n int idx_old = (*permutation)[*idx1];\n int idx_new = rand() % N_kw;\n\n (*permutation_tmp)[*idx1] = idx_new;\n\n if ((*permutation_inv)[idx_new] >= 0)\n {\n *idx2 = (*permutation_inv)[idx_new];\n (*permutation_tmp)[*idx2] = idx_old;\n }\n}", "meta": {"hexsha": "5612e876afeed0a5ffdee6a30e68b23e9144e9bb", "size": 2670, "ext": "c", "lang": "C", "max_stars_repo_path": "FP-EMM/util.c", "max_stars_repo_name": "RethinkingSSE/Attacks-on-SSE", "max_stars_repo_head_hexsha": "39602b0912b21afc45e73008e598f4377ba237eb", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "FP-EMM/util.c", "max_issues_repo_name": "RethinkingSSE/Attacks-on-SSE", "max_issues_repo_head_hexsha": "39602b0912b21afc45e73008e598f4377ba237eb", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "FP-EMM/util.c", "max_forks_repo_name": "RethinkingSSE/Attacks-on-SSE", "max_forks_repo_head_hexsha": "39602b0912b21afc45e73008e598f4377ba237eb", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 27.8125, "max_line_length": 135, "alphanum_fraction": 0.5445692884, "num_tokens": 826, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8397339756938819, "lm_q2_score": 0.5964331462646255, "lm_q1q2_score": 0.5008451771484045}} {"text": "#pragma once\r\n#include \r\n#include \r\n#include \"IsingLattice2D.h\"\r\n#include \"class_mc_io.h\"\r\n#include \"Matrix.h\"\r\n#include \"MemTimeTester.h\"\r\nextern \"C\" {\r\n#include \"random.h\"\r\n}\r\n#include \r\n#include \r\n#include \"obs_calc_fast.cuh\"\r\n\r\ndouble real_trigamma_cmplxarg(double x, double y, int m, int l);\r\n\r\nclass GeneralLRW{\r\n\t//This is a more lightweight version of the long range wolff class, designed to be\r\n\t//more general - hopefully to admit the use of user-defined \"test_spins\" functions\r\n\t//so that it can be used for many different MC simulations. It does not hold the\r\n\t//lattice in order to keep the lattice easily available for GPU computations\r\n\tstd::vector> interactions;//interaction matrix\r\n\tstd::vector> interaction_sum;//values from interaction sum integral\r\n\tstd::vector site_sums;//absolute sum of interactions at each site\r\n\tdouble mag;//current magnetization\r\n\tdouble h; //applied field\r\n\tstd::vector buffer;//holds the indices of spins to check\r\n\tstd::vector> cluster;//0 at indices that are not in cluster, 1 at indices that are\r\n\tint cluster_size;//size of the cluster during a given MC step\r\n\tint cluster_mag;//total magnetization of the cluster\r\n\tvoid set_spin_boson_model_wc_exp(class_mc_params);//version for finite cutoff frequency with exponential tail\r\n\tvoid set_spin_boson_model_wc_hard(class_mc_params);//version for finite cutoff frequency with sharp cutoff\r\n\tvoid set_spin_boson_model(class_mc_params);//create interaction matrix for the spin boson model with infinite cutoff frequency\r\n\tvoid set_interaction_sum();\r\n\tvoid set_site_sums();\r\n\tMemTimeTester timer;\r\n\r\n\tinline double kernel_integrand(double alpha, int Nt, double rbv, double taub, double u){\r\n\t\t//evaluate the integrand of the kernel of the spin-boson effective interactions\r\n\t\treturn 2.0 * alpha / Nt / Nt * u * cos(rbv*u)*(exp(u*(-taub)) + exp(u*(taub - 1.0)))/(1 - exp(-u));\r\n\t}\r\n\r\n\tdouble simpson_3_8(double alpha, int Nt, double bomc, double rbv, double taub, int N_points){\r\n\t\t//perform an integration of the spin-boson kernel with a hard, finite cutoff bomc. Evaluated at \r\n\t\t//site distance rbv = r/(beta*v), taub = tau/beta, with number of time slices Nt and number of \r\n\t\t//integration slices N_points (this method will multiply N_points by 3 and use simpson's 3/8 rule)\r\n\t\tdouble du = (bomc)/(3.0*N_points);\r\n\t\tdouble result = 3.0*du*(4.0*alpha / Nt / Nt + kernel_integrand(alpha, Nt, rbv, taub, bomc))/8.0;\r\n\t\tfor (int i = 1; i < 3*N_points; ++i){\r\n\t\t\tif(3*(i/3) == i){\r\n\t\t\t\tresult += 0.75*du*kernel_integrand(alpha, Nt, rbv, taub, i*du);\r\n\t\t\t}\r\n\t\t\telse{\r\n\t\t\t\tresult += 9.0*du*kernel_integrand(alpha, Nt, rbv, taub, i*du)/8.0;\t\t\t\t\r\n\t\t\t}\r\n\t\t}\r\n\t\treturn result;\r\n\t}\r\n\r\npublic:\r\n\tGeneralLRW(class_mc_params);\r\n\r\n\tvoid print_timers(){ timer.print_timers(); }\r\n\r\n\tvoid step(IsingLattice2D& lat);\r\n\r\n bool step_one_site(IsingLattice2D& lat, double *prev_action, thrust::host_vector& corr_ref);\r\n\r\n\tbool step_one_site_prealloc(IsingLattice2D& lat, double *prev_action, thrust::host_vector& corr_ref, \r\n\t\t\tcufftHandle *full_forward_plan, cufftHandle *full_backward_plan, cufftHandle *onesite_forward_plan, cufftHandle *onesite_backward_plan,\r\n\t\t\tcudaError cuda_status, cufftDoubleReal *full_state_rs, cufftDoubleComplex *full_state_ft, cufftDoubleReal *onesite_state_rs, cufftDoubleComplex *onesite_state_ft);\r\n\r\n\tbool step_one_site_prealloc_lowmem(IsingLattice2D& lat, double *prev_action, thrust::host_vector& corr_ref, \r\n\t\t\tthrust::host_vector& ,thrust::host_vector& ,thrust::host_vector& ,thrust::host_vector& ,\r\n\t\t\tthrust::host_vector& ,thrust::host_vector& ,\r\n\t\t\tcufftHandle *full_forward_plan, cufftHandle *full_backward_plan, cufftHandle *onesite_forward_plan, cufftHandle *onesite_backward_plan,\r\n\t\t\tcudaError cuda_status, cufftDoubleReal *full_state_rs, cufftDoubleComplex *full_state_ft, cufftDoubleReal *onesite_state_rs, cufftDoubleComplex *onesite_state_ft);\r\n\r\n\tbool metropolis_step(IsingLattice2D& lat, double *action);\r\n\r\n\tbool fast_metropolis_step(IsingLattice2D& lat, double *action);\r\n\r\n\tvoid test_spins(spin, IsingLattice2D& lat);\r\n\r\n void test_spins_one_site(spin, IsingLattice2D& lat);\r\n\r\n\tvoid set_mag(IsingLattice2D& lat){\r\n\t\tmag = 0;\r\n\t\tfor (int i = 0; i < lat.get_Lx(); ++i){\r\n\t\t\tfor (int j = 0; j < lat.get_Ly(); ++j){\r\n\t\t\t\tmag += lat.get_spin(i, j);\r\n\t\t\t}\r\n\t\t}\r\n\t\tmag = ((double) mag) / lat.get_N();\r\n\t}\r\n\r\n\tdouble get_mag(){\r\n\t\treturn mag;\r\n\t}\r\n\r\n\tdouble get_cluster_size() { return (double)cluster_size; }\r\n\r\n void get_thrust_interactions(thrust::host_vector& result){\r\n\t\tif(result.size() != interactions.size()*interactions[0].size()){\r\n\t\t\tresult.resize(interactions.size()*interactions[0].size());\r\n\t\t}\r\n\t\tfor (int i = 0; i < interactions.size(); ++i){\r\n\t\t\tfor (int j = 0; j < interactions[i].size(); ++j){\r\n\t\t\t\tresult[i*interactions[i].size() + j] = interactions[i][j];\r\n\t\t\t}\r\n\t\t}\r\n }\r\n\r\n\tstd::vector get_interaction_vector(){\r\n\t\tstd::vector result(interactions.size()*interactions[0].size());\r\n\t\tint Ly = interactions[0].size();\r\n\t\tfor (int x = 0; x < interactions.size(); ++x){\r\n\t\t\tfor (int y = 0; y < Ly; ++y){\r\n\t\t\t\tresult[x*Ly + y] = interactions[x][y];\r\n\t\t\t}\r\n\t\t}\r\n\t\treturn result;\r\n\t}\r\n\r\n\tstd::vector> get_interactions(){\r\n\t\treturn interactions;\r\n\t}\r\n\r\n double calc_mqt0_abs(IsingLattice2D&, double);\r\n\r\n double calc_mqt0_2_abs(IsingLattice2D&, double);\r\n\r\n double calc_mqt0_4_abs(IsingLattice2D&, double);\r\n\r\n double calc_mqt0_gpu(thrust::host_vector&, double, int);\r\n\r\n double calc_locw1(IsingLattice2D&, double);\r\n \r\n\tdouble calc_sx(IsingLattice2D&);\r\n\r\n\tdouble calc_space_kinks(IsingLattice2D& lat);\r\n\r\n\tdouble calc_sz_stagger(IsingLattice2D&);\r\n\r\n\tdouble calc_xmag(IsingLattice2D&);\r\n\r\n\tdouble calc_xmag2(IsingLattice2D&);\r\n\r\n\tdouble calc_xmag4(IsingLattice2D&);\r\n\r\n double calc_mag(IsingLattice2D&);\r\n\r\n\tdouble calc_loc(IsingLattice2D&);\r\n\r\n\tdouble calc_loc2(IsingLattice2D&);\r\n\r\n\tdouble calc_loc4(IsingLattice2D&);\r\n\r\n\tdouble calc_s1s2(IsingLattice2D&);\r\n\r\n\tdouble calc_action_slow(IsingLattice2D&);\r\n\r\n\tdouble calc_point_action_slow(IsingLattice2D&,int, int);\r\n\r\n\tdouble calc_point_action_fast(IsingLattice2D&, int, int);\r\n\r\n\tvoid print_site_sums(){\r\n\t\tstd::cout << \"Site sums:\\n\" << vec2str(site_sums) << \"\\n\";\r\n\t}\r\n\r\n\tvoid print_interactions() {\r\n\t\tstd::stringstream outstring;\r\n\t\toutstring << \"Interactions:\\n\";\r\n\t\tfor (int i = 0; i < interactions.size(); ++i){\r\n\t\t\toutstring << vec2str(interactions[i]) << \"\\n\";\r\n\t\t}\r\n\t\tstd::cout << outstring.str() << \"\\n\";\r\n\t}\r\n\r\n\r\n\tvoid print_interaction_sum() {\r\n\t\tstd::stringstream outstring;\r\n\t\toutstring << \"Interaction sum:\\n\";\r\n\t\tfor (int i = 0; i < interaction_sum.size(); ++i){\r\n\t\t\toutstring << vec2str(interaction_sum[i]) << \"\\n\";\r\n\t\t}\r\n\t\tstd::cout << outstring.str() << \"\\n\";\r\n\t}\r\n\r\n\tstd::string get_int_string() {\r\n\t\tstd::stringstream ss;\r\n\t\tss << \"Interactions:\\n\" ;\r\n\t\tfor (int i = 0; i < interactions.size(); ++i){\r\n\t\t\tss << vec2str(interactions[i]) << \"\\n\";\r\n\t\t}\r\n\t\treturn ss.str();\r\n\t}\r\n\r\n};\r\n", "meta": {"hexsha": "9011c2f7eacd1e14ff8af3e05b129e1c84478f9a", "size": 7181, "ext": "h", "lang": "C", "max_stars_repo_path": "lib/LongRangeWolff2D.h", "max_stars_repo_name": "butchertx/spin_boson_mc", "max_stars_repo_head_hexsha": "0d47b188b4953734725efe98ea57d4da3d2ffc76", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "lib/LongRangeWolff2D.h", "max_issues_repo_name": "butchertx/spin_boson_mc", "max_issues_repo_head_hexsha": "0d47b188b4953734725efe98ea57d4da3d2ffc76", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "lib/LongRangeWolff2D.h", "max_forks_repo_name": "butchertx/spin_boson_mc", "max_forks_repo_head_hexsha": "0d47b188b4953734725efe98ea57d4da3d2ffc76", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.905, "max_line_length": 167, "alphanum_fraction": 0.6990669823, "num_tokens": 2031, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8615382200964035, "lm_q2_score": 0.5813030906443133, "lm_q1q2_score": 0.50081483005024}} {"text": "#include \r\n#include \r\n#include \r\n#include \r\n\r\n#include \r\n#include \r\n#include \r\n\r\n#define L 1 //1 2 3 4\r\n#define LL 2 //2^(1 2 3 4)\r\n#define LLL 4 //2^(2 3 4 5)\r\n\r\n#define N 8\r\n\r\n#define M 1 //# of trials\r\n#define R 1 //the number of different initial conditions\r\n#define S 100 //the number of different rules\r\n#define T1 100 //transient\r\n#define T2 1000 //time window used\r\nint **mat;\r\nint component[N],cnum;\r\n\r\nvoid findcomponent(int node)\r\n{\r\n\tint i;\r\n\t\r\n\tfor (i=0;i=L-1){\r\n\t\t\t\t\t\t\tfor (i=0;i0.0)edge[nb[i][j]][i]+=p4[i][nb[i][j]][num2][num3]*(log(p4[i][nb[i][j]][num2][num3])/log(2.0) + log(p1[i][num2%LL])/log(2.0) - log(p2[i][num2])/log(2.0) - log(p3[i][nb[i][j]][num2%LL][num3])/log(2.0));\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t}//end of s-loop\r\n\t\t\t\r\n\t\t\tfor (i=0;i0.0)cratio=cl2/el2;\r\n\t\t\telse cratio=0.0;\r\n\t\t\t\r\n\t\t\tel2_av+=el2/(double)M;\r\n\t\t\tgl2_av+=gl2/(double)M;\r\n\t\t\tcl2_av+=cl2/(double)M;\r\n\t\t\tcratio_av+=cratio/(double)M;\r\n\t\t\t\r\n\t\t\t//decomposing circular flow into harmonic and curl flows\r\n\t\t\ttrinum=0;\r\n\t\t\tfor (i=0;i0){\r\n\t\t\t\tcurl=malloc(sizeof(double)*trinum);\r\n\t\t\t\ttri=malloc(sizeof(int*)*trinum);\r\n\t\t\t\tfor (i=0;i1e-8)diag2[i]=1.0/dtmp;\r\n\t\t\t\t\telse {\r\n\t\t\t\t\t\tdiag2[i]=0.0;\r\n\t\t\t\t\t\ttmp++;\r\n\t\t\t\t\t}\r\n\t\t\t\t}\r\n\t\t\t\t\r\n\t\t\t\tct=(double)(trinum-tmp);\r\n\t\t\t\tht=et-gt-ct;\r\n\t\t\t\t\r\n\t\t\t\tfor (i=0;i0.0)gcratio=hl2/el2;\r\n\t\t\telse gcratio=0.0;\r\n\t\t\t\r\n\t\t\thl2_av+=hl2/(double)M;\r\n\t\t\tlcl2_av+=lcl2/(double)M;\r\n\t\t\tgcratio_av+=gcratio/(double)M;\r\n\t\t\t\r\n\t\t\tlcratio=cratio-gcratio;\r\n\t\t\tlcratio_av+=lcratio/(double)M;\r\n\t\t\t\r\n\t\t\tet_av+=et/(double)M;\r\n\t\t\tgt_av+=gt/(double)M;\r\n\t\t\tht_av+=ht/(double)M;\r\n\t\t\tct_av+=ct/(double)M;\r\n\t\t\t\r\n\t\t\tif (m%1==0)printf(\"%lf %d %d %lf %lf %lf %lf %lf %lf\\n\",q,m,cnum,el2,gl2,hl2,lcl2,gcratio,lcratio);\r\n\t\t\tfprintf(fq,\"%lf %d %d %.15lf %.15lf %.15lf %.15lf %.15lf %.15lf %.15lf %.15lf %.15lf %.15lf\\n\",q,m,cnum,el2,gl2,hl2,lcl2,gcratio,lcratio,et,gt,ht,ct);\r\n\t\t\t\r\n\t\t\tif (nb){\r\n\t\t\t\tfor (i=0;i\n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\ntypedef struct init_gbpCosmo2gbpCosmo_integrand_params_struct init_gbpCosmo2gbpCosmo_integrand_params;\nstruct init_gbpCosmo2gbpCosmo_integrand_params_struct {\n double inv_s;\n double z_source;\n double z_target;\n double R_1;\n double R_2;\n cosmo_info ** cosmo_source;\n cosmo_info ** cosmo_target;\n int n_int;\n gsl_integration_workspace *wspace;\n};\n\ndouble init_gbpCosmo2gbpCosmo_integrand(double R, void *params_in) {\n init_gbpCosmo2gbpCosmo_integrand_params *params = (init_gbpCosmo2gbpCosmo_integrand_params *)params_in;\n double inv_s = params->inv_s;\n double z_source = params->z_source;\n double z_target = params->z_target;\n cosmo_info ** cosmo_source = params->cosmo_source;\n cosmo_info ** cosmo_target = params->cosmo_target;\n return (pow(1. - (sigma_R(cosmo_source, inv_s * R, z_source, PSPEC_LINEAR_TF, PSPEC_ALL_MATTER)) /\n (sigma_R(cosmo_target, R, z_target, PSPEC_LINEAR_TF, PSPEC_ALL_MATTER)),\n 2.) /\n R);\n}\n\ndouble init_gbpCosmo2gbpCosmo_minimize_function(const gsl_vector *v_i, void *params_in) {\n // Set variable integrand parameters\n init_gbpCosmo2gbpCosmo_integrand_params *params = (init_gbpCosmo2gbpCosmo_integrand_params *)params_in;\n params->inv_s = gsl_vector_get(v_i, 0);\n params->z_target = gsl_vector_get(v_i, 1);\n\n // Perform integral to minimize\n gsl_function integrand;\n double delta_i;\n double abs_error;\n integrand.function = init_gbpCosmo2gbpCosmo_integrand;\n integrand.params = params_in;\n gsl_integration_qag(&integrand, params->R_1, params->R_2, 0, 1e-3, params->n_int, GSL_INTEG_GAUSS61, params->wspace, &delta_i, &abs_error);\n return (delta_i / take_ln(params->R_2 / params->R_1));\n}\n\nvoid init_gbpCosmo2gbpCosmo(cosmo_info ** cosmo_source,\n cosmo_info ** cosmo_target,\n double z_min,\n double M_min,\n double M_max,\n gbpCosmo2gbpCosmo_info *gbpCosmo2gbpCosmo) {\n SID_log(\"Initializing cosmology scaling...\", SID_LOG_OPEN | SID_LOG_TIMER);\n SID_set_verbosity(SID_SET_VERBOSITY_RELATIVE, -1);\n\n // Store some infor in the gbpCosmo2gbpCosmo_info structure\n gbpCosmo2gbpCosmo->M_min = M_min;\n gbpCosmo2gbpCosmo->M_max = M_max;\n gbpCosmo2gbpCosmo->z_min = z_min;\n gbpCosmo2gbpCosmo->cosmo_source = (*cosmo_source);\n gbpCosmo2gbpCosmo->cosmo_target = (*cosmo_target);\n\n // Perform minimization\n // const gsl_multimin_fminimizer_type *T=gsl_multimin_fminimizer_nmsimplex2;\n const gsl_multimin_fminimizer_type *T = gsl_multimin_fminimizer_nmsimplex;\n gsl_multimin_fminimizer * s = NULL;\n gsl_vector * ss, *x;\n gsl_multimin_function minex_func;\n\n // Starting point\n x = gsl_vector_alloc(2);\n gsl_vector_set(x, 0, 1.); // inv_s\n gsl_vector_set(x, 1, z_min); // z_scaled\n\n // Set initial step sizes to 1\n ss = gsl_vector_alloc(2);\n gsl_vector_set_all(ss, 1.0);\n\n // Set parameters\n init_gbpCosmo2gbpCosmo_integrand_params params;\n params.cosmo_source = cosmo_source;\n params.cosmo_target = cosmo_target;\n params.z_source = z_min;\n params.R_1 = R_of_M(M_min, *cosmo_source);\n params.R_2 = R_of_M(M_max, *cosmo_source);\n params.inv_s = gsl_vector_get(x, 0);\n params.z_target = gsl_vector_get(x, 1);\n params.n_int = 100;\n params.wspace = gsl_integration_workspace_alloc(params.n_int);\n\n // Initialize method\n minex_func.n = 2;\n minex_func.f = init_gbpCosmo2gbpCosmo_minimize_function;\n minex_func.params = (void *)(¶ms);\n s = gsl_multimin_fminimizer_alloc(T, 2);\n gsl_multimin_fminimizer_set(s, &minex_func, x, ss);\n\n // Perform minimization\n double size;\n int status;\n size_t iter = 0;\n size_t iter_max = 200;\n do {\n iter++;\n status = gsl_multimin_fminimizer_iterate(s);\n if(status)\n SID_exit_error(\"Error encountered during minimisation in init_gbpCosmo2gbpCosmo() (status=%d).\",\n SID_ERROR_LOGIC, status);\n size = gsl_multimin_fminimizer_size(s);\n status = gsl_multimin_test_size(size, 1e-2);\n } while(status == GSL_CONTINUE && iter <= iter_max);\n if(status != GSL_SUCCESS)\n SID_exit_error(\"Failed to converge during minimisation in init_gbpCosmo2gbpCosmo() (status=%d,iter=%d).\",\n SID_ERROR_LOGIC, status, iter);\n\n // Finalize results\n double Omega_M_source = ((double *)ADaPS_fetch(*cosmo_source, \"Omega_M\"))[0];\n double H_Hubble_source = 1e2 * ((double *)ADaPS_fetch(*cosmo_source, \"h_Hubble\"))[0];\n double Omega_M_target = ((double *)ADaPS_fetch(*cosmo_target, \"Omega_M\"))[0];\n double H_Hubble_target = 1e2 * ((double *)ADaPS_fetch(*cosmo_target, \"h_Hubble\"))[0];\n gbpCosmo2gbpCosmo->s_L = 1. / gsl_vector_get(s->x, 0);\n gbpCosmo2gbpCosmo->s_M = (Omega_M_target * H_Hubble_target) / (Omega_M_source * H_Hubble_source) * pow((gbpCosmo2gbpCosmo->s_L), 3.);\n gbpCosmo2gbpCosmo->z_min_scaled = gsl_vector_get(s->x, 1);\n ;\n\n // Calculate growth factors needed for\n // determining redshift mappings\n gbpCosmo2gbpCosmo->D_prime_z_min = linear_growth_factor(z_min, cosmo_target);\n gbpCosmo2gbpCosmo->D_z_scaled = linear_growth_factor(gbpCosmo2gbpCosmo->z_min_scaled, cosmo_source);\n gbpCosmo2gbpCosmo->D_ratio = gbpCosmo2gbpCosmo->D_prime_z_min / gbpCosmo2gbpCosmo->D_z_scaled;\n\n // Clean-up\n gsl_vector_free(x);\n gsl_vector_free(ss);\n gsl_multimin_fminimizer_free(s);\n gsl_integration_workspace_free(params.wspace);\n SID_set_verbosity(SID_SET_VERBOSITY_DEFAULT);\n SID_log(\"Done.\", SID_LOG_CLOSE);\n}\n", "meta": {"hexsha": "a9895a0b7bd4cd30a76d2f7e470af99c69242f7e", "size": 6573, "ext": "c", "lang": "C", "max_stars_repo_path": "src/gbpAstro/gbpCosmo/linear_theory/init_gbpCosmo2gbpCosmo.c", "max_stars_repo_name": "gbpoole/gbpCode", "max_stars_repo_head_hexsha": "5157d2e377edbd4806258d1c16b329373186d43a", "max_stars_repo_licenses": ["MIT"], "max_stars_count": 1.0, "max_stars_repo_stars_event_min_datetime": "2015-10-20T11:39:53.000Z", "max_stars_repo_stars_event_max_datetime": "2015-10-20T11:39:53.000Z", "max_issues_repo_path": "src/gbpAstro/gbpCosmo/linear_theory/init_gbpCosmo2gbpCosmo.c", "max_issues_repo_name": "gbpoole/gbpCode", "max_issues_repo_head_hexsha": "5157d2e377edbd4806258d1c16b329373186d43a", "max_issues_repo_licenses": ["MIT"], "max_issues_count": 2.0, "max_issues_repo_issues_event_min_datetime": "2017-07-30T11:10:49.000Z", "max_issues_repo_issues_event_max_datetime": "2019-06-18T00:40:46.000Z", "max_forks_repo_path": "src/gbpAstro/gbpCosmo/linear_theory/init_gbpCosmo2gbpCosmo.c", "max_forks_repo_name": "gbpoole/gbpCode", "max_forks_repo_head_hexsha": "5157d2e377edbd4806258d1c16b329373186d43a", "max_forks_repo_licenses": ["MIT"], "max_forks_count": 4.0, "max_forks_repo_forks_event_min_datetime": "2015-01-23T00:50:40.000Z", "max_forks_repo_forks_event_max_datetime": "2016-08-01T08:14:24.000Z", "avg_line_length": 45.3310344828, "max_line_length": 146, "alphanum_fraction": 0.625893808, "num_tokens": 1816, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8962513842182775, "lm_q2_score": 0.5583269943353745, "lm_q1q2_score": 0.5004013415195098}} {"text": "#ifndef DIFFEQ_SIM_H\n#define DIFFEQ_SIM_H\n\n#include \n#include \n#include \n#include \n\nusing namespace std;\n\n\nclass DiffEq_Sim {\n private:\n double t; //initial time \n double h; //time step\n double tmax; //max time\n double hmin;\n\n public:\n DiffEq_Sim() {\n t = 0.0; //initial time \n h = 0.1; //time step\n tmax = 2000;\n hmin = 0.2;\n };\n\n ~DiffEq_Sim() {};\n\n int nbins;\n double* y;\n\n void printY() { for(int i=0; i < nbins; i++) { cout << y[i] << \" \";} cout << endl; }\n \n vector get_state() {\n vector C;\n C.assign(y, y + nbins);\n return C;\n }\n\n double get_time() { return t; }\n\n\n virtual void initialize() {}\n virtual void derivative(const double y[], double dydt[]){}\n\n static int function(double t, double const y[], double dydt[], void *params) {\n DiffEq_Sim* model = static_cast (params);\n model->derivative(y, dydt);\n return GSL_SUCCESS;\n }\n\n\n int run_simulation() {\n gsl_odeiv_evolve* e = gsl_odeiv_evolve_alloc(nbins);\n gsl_odeiv_control* c = gsl_odeiv_control_y_new(1e-20, 0);\n gsl_odeiv_step* s = gsl_odeiv_step_alloc(gsl_odeiv_step_rkf45, nbins);\n gsl_odeiv_system sys = {function, NULL, nbins, this };\n while (t < tmax) { //convergence check here\n int status = gsl_odeiv_evolve_apply(e, c, s, &sys, &t, tmax, &h, y);\n if (status != GSL_SUCCESS) { return status; }\n }\n return 0;\n }\n\n int step_simulation( double stepsize ) {\n gsl_odeiv_evolve* e = gsl_odeiv_evolve_alloc(nbins);\n gsl_odeiv_control* c = gsl_odeiv_control_y_new(1e-5, 0);\n gsl_odeiv_step* s = gsl_odeiv_step_alloc(gsl_odeiv_step_rkf45, nbins);\n gsl_odeiv_system sys = {function, NULL, nbins, this };\n\n double tstop = t+stepsize;\n while (t < tstop) {\n int status = gsl_odeiv_evolve_apply(e, c, s, &sys, &t, tstop, &h, y);\n if (status != GSL_SUCCESS) { return status; }\n }\n return 0;\n }\n\n /*\n double* advance_simulation(double I_lim) {\n while (t < 2000) { //convergence check here\n int status = gsl_odeiv_evolve_apply(e, c, s, &sys, &t, t1, &h, y);\n if (y[1] < I_lim) { return y; }\n }\n printY();\n return y;\n }\n*/\n};\n\n#endif\n", "meta": {"hexsha": "ae05ed224d585a69a64058c856e748c3f8518236", "size": 2698, "ext": "h", "lang": "C", "max_stars_repo_path": "src/DiffEq_Sim.h", "max_stars_repo_name": "pvnuffel/test_repos", "max_stars_repo_head_hexsha": "c0d957265608b15f216ece67363c827d01122102", "max_stars_repo_licenses": ["BSD-3-Clause"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "src/DiffEq_Sim.h", "max_issues_repo_name": "pvnuffel/test_repos", "max_issues_repo_head_hexsha": "c0d957265608b15f216ece67363c827d01122102", "max_issues_repo_licenses": ["BSD-3-Clause"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "src/DiffEq_Sim.h", "max_forks_repo_name": "pvnuffel/test_repos", "max_forks_repo_head_hexsha": "c0d957265608b15f216ece67363c827d01122102", "max_forks_repo_licenses": ["BSD-3-Clause"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 29.3260869565, "max_line_length": 92, "alphanum_fraction": 0.5159377317, "num_tokens": 747, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7154240079185319, "lm_q2_score": 0.6992544273261175, "lm_q1q2_score": 0.5002634049524288}} {"text": "#include \n#include \n#include \n#include \n#include \n#include \n#include \n#include \n\n#include \"cosmocalc.h\"\n\nstatic double deltaTm[9] = {200.0, 300.0, 400.0, 600.0, 800.0, 1200.0, 1600.0, 2400.0, 3200.0};\nstatic double ATm[9] = {0.186, 0.2, 0.212, 0.218, 0.248, 0.255, 0.260, 0.260, 0.260};\nstatic double aTm[9] = {1.47, 1.52, 1.56, 1.61, 1.87, 2.13, 2.30, 2.53, 2.66};\nstatic double bTm[9] = {2.57, 2.25, 2.05, 1.87, 1.59, 1.51, 1.46, 1.44, 1.41};\nstatic double cTm[9] = {1.19, 1.27, 1.34, 1.45, 1.58, 1.80, 1.97, 2.24, 2.44};\n\ndouble mass_function(double m, double a)\n{\n return tinker2008_mass_function(m,a,cosmoData.delta);\n}\n\ndouble tinker2008_mass_function(double m, double a, double delta)\n{\n double A,am,b,c,alpha;\n \n static int init = 1;\n static gsl_spline *ATm_spline,*aTm_spline,*bTm_spline,*cTm_spline;\n static gsl_interp_accel *ATm_acc,*aTm_acc,*bTm_acc,*cTm_acc;\n \n if(init)\n {\n#define TINKERCODEPARMS\n#ifdef TINKERCODEPARMS\n //first parameter\n ATm[0] = 1.858659e-01 ;\n ATm[1] = 1.995973e-01 ;\n ATm[2] = 2.115659e-01 ;\n ATm[3] = 2.184113e-01 ;\n ATm[4] = 2.480968e-01 ;\n ATm[5] = 2.546053e-01 ;\n ATm[6] = 2.600000e-01 ;\n ATm[7] = 2.600000e-01 ;\n ATm[8] = 2.600000e-01 ;\n \n //second parameter\n aTm[0] = 1.466904e+00 ;\n aTm[1] = 1.521782e+00 ;\n aTm[2] = 1.559186e+00 ;\n aTm[3] = 1.614585e+00 ;\n aTm[4] = 1.869936e+00 ;\n aTm[5] = 2.128056e+00 ;\n aTm[6] = 2.301275e+00 ;\n aTm[7] = 2.529241e+00 ;\n aTm[8] = 2.661983e+00 ;\n \n //third parameter\n bTm[0] = 2.571104e+00 ;\n bTm[1] = 2.254217e+00 ;\n bTm[2] = 2.048674e+00 ;\n bTm[3] = 1.869559e+00 ;\n bTm[4] = 1.588649e+00 ;\n bTm[5] = 1.507134e+00 ;\n bTm[6] = 1.464374e+00 ;\n bTm[7] = 1.436827e+00 ;\n bTm[8] = 1.405210e+00 ;\n\n //fourth parameter\n cTm[0] = 1.193958e+00;\n cTm[1] = 1.270316e+00;\n cTm[2] = 1.335191e+00;\n cTm[3] = 1.446266e+00;\n cTm[4] = 1.581345e+00;\n cTm[5] = 1.795050e+00;\n cTm[6] = 1.965613e+00;\n cTm[7] = 2.237466e+00;\n cTm[8] = 2.439729e+00;\n#endif\n \n ATm_spline = gsl_spline_alloc(gsl_interp_cspline,9);\n aTm_spline = gsl_spline_alloc(gsl_interp_cspline,9);\n bTm_spline = gsl_spline_alloc(gsl_interp_cspline,9);\n cTm_spline = gsl_spline_alloc(gsl_interp_cspline,9);\n \n gsl_spline_init(ATm_spline,deltaTm,ATm,9);\n gsl_spline_init(aTm_spline,deltaTm,aTm,9);\n gsl_spline_init(bTm_spline,deltaTm,bTm,9);\n gsl_spline_init(cTm_spline,deltaTm,cTm,9);\n \n ATm_acc = gsl_interp_accel_alloc();\n aTm_acc = gsl_interp_accel_alloc();\n bTm_acc = gsl_interp_accel_alloc();\n cTm_acc = gsl_interp_accel_alloc();\n \n init = 0;\n }\n \n A = gsl_spline_eval(ATm_spline,delta,ATm_acc);\n#ifdef TINKERCODEPARMS\n if(delta > 1600.0)\n A = 0.26;\n#endif\n am = gsl_spline_eval(aTm_spline,delta,aTm_acc);\n b = gsl_spline_eval(bTm_spline,delta,bTm_acc);\n c = gsl_spline_eval(cTm_spline,delta,cTm_acc);\n \n double onepz = 1.0/a;\n#ifdef TINKERCODEPARMS\n if(onepz > 4.0)\n onepz = 4.0;\n#endif\n \n A *= pow(onepz,-0.14);\n am *= pow(onepz,-0.06);\n alpha = pow(10.0,-1.0*pow(0.75/log10(delta/75.0),1.2));\n b *= pow(onepz,-1.0*alpha);\n \n //fprintf(stderr,\"A = %f, a = %f, b = %f, c = %f\\n\",A,am,b,c);\n \n double sigma = sigmaMtophat(m,a);\n double fsigma = A*(pow(sigma/b,-1.0*am) + 1.0)*exp(-1.0*c/sigma/sigma);\n double dm = 1e-6*m;\n double dlnsiginvdm = log(sigmaMtophat(m-dm/2.0,a)/sigmaMtophat(m+dm/2.0,a))/dm;\n \n return fsigma*RHO_CRIT*cosmoData.OmegaM/m*dlnsiginvdm;\n}\n\nstatic double alphaTm[9] = {0.368, 0.363, 0.385, 0.389, 0.393, 0.365, 0.379, 0.355, 0.327};\nstatic double betaTm[9] = {0.589, 0.585, 0.544, 0.543, 0.564, 0.623, 0.637, 0.673, 0.702};\nstatic double gammaTm[9] = {0.864, 0.922, 0.987, 1.09, 1.20, 1.34, 1.50, 1.68, 1.81};\nstatic double phiTm[9] = {-0.729, -0.789, -0.910, -1.05, -1.20, -1.26, -1.45, -1.50, -1.49};\nstatic double etaTm[9] = {-0.243, -0.261, -0.261, -0.273, -0.278, -0.301, -0.301, -0.319, -0.336};\n\nstatic double tinker2010_mf_norm_integ(double lnnu, void *p)\n{\n double *params = (double*) p;\n double nu = exp(lnnu);\n double fnu,bnu;\n \n double y = log10(params[4]);\n double A = 1.0 + 0.24*y*exp(-1.0*pow(4.0/y,4.0));\n double _a = 0.44*y - 0.88;\n double B = 0.183;\n double b = 1.5;\n double C = 0.019 + 0.107*y + 0.19*exp(-1.0*pow(4.0/y,4.0));\n double c = 2.4;\n \n if(nu == 0.0)\n return 0.0;\n else\n {\n fnu = (1.0 + pow(params[0]*nu,-2.0*params[1]))*pow(nu,2.0*params[2])*exp(-1.0*params[3]*nu*nu/2.0);\n bnu = 1.0 - A*pow(nu,_a)/(pow(nu,_a) + pow(1.686,_a)) + B*pow(nu,b) + C*pow(nu,c);\n \n return bnu*fnu*nu;\n }\n}\n \ndouble tinker2010_mass_function(double m, double a, double delta)\n{\n double z,gsigma,nu,dlnsiginvdm;\n double dm = 1e-6*m;\n double alpha,beta,gamma,phi,eta;\n \n static int init = 1;\n static gsl_spline *alphaTm_spline,*betaTm_spline,*gammaTm_spline,*phiTm_spline,*etaTm_spline;\n static gsl_interp_accel *alphaTm_acc,*betaTm_acc,*gammaTm_acc,*phiTm_acc,*etaTm_acc;\n //static gsl_integration_glfixed_table *gltab;\n static gsl_integration_workspace *w;\n static double aprev = -1.0;\n static double alphaprev = -1.0;\n \n gsl_function f;\n size_t limit = 1000;\n double epsabs,epsrel;\n double abserr;\n double numin,numax;\n //int i,Nnu,dnu;\n double params[5];\n \n if(init)\n {\n alphaTm_spline = gsl_spline_alloc(gsl_interp_cspline,9);\n betaTm_spline = gsl_spline_alloc(gsl_interp_cspline,9);\n gammaTm_spline = gsl_spline_alloc(gsl_interp_cspline,9);\n phiTm_spline = gsl_spline_alloc(gsl_interp_cspline,9);\n etaTm_spline = gsl_spline_alloc(gsl_interp_cspline,9);\n \n gsl_spline_init(alphaTm_spline,deltaTm,alphaTm,9);\n gsl_spline_init(betaTm_spline,deltaTm,betaTm,9);\n gsl_spline_init(gammaTm_spline,deltaTm,gammaTm,9);\n gsl_spline_init(phiTm_spline,deltaTm,phiTm,9);\n gsl_spline_init(etaTm_spline,deltaTm,etaTm,9);\n \n alphaTm_acc = gsl_interp_accel_alloc();\n betaTm_acc = gsl_interp_accel_alloc();\n gammaTm_acc = gsl_interp_accel_alloc();\n phiTm_acc = gsl_interp_accel_alloc();\n etaTm_acc = gsl_interp_accel_alloc();\n \n //gltab = gsl_integration_glfixed_table_alloc((size_t) 500);\n w = gsl_integration_workspace_alloc(limit);\n \n init = 0;\n }\n \n alpha = gsl_spline_eval(alphaTm_spline,delta,alphaTm_acc);\n beta = gsl_spline_eval(betaTm_spline,delta,betaTm_acc);\n gamma = gsl_spline_eval(gammaTm_spline,delta,gammaTm_acc);\n phi = gsl_spline_eval(phiTm_spline,delta,phiTm_acc);\n eta = gsl_spline_eval(etaTm_spline,delta,etaTm_acc);\n \n nu = 1.686/sigmaMtophat(m,a);\n z = 1.0/a - 1.0;\n if(z > 3.0)\n z = 3.0;\n \n beta = beta*pow(1.0+z,0.20);\n phi = phi*pow(1.0+z,-0.08);\n eta = eta*pow(1.0+z,0.27);\n gamma = gamma*pow(1.0+z,-0.01);\n \n //determine alpha by normalization condition\n if(a != aprev)\n {\n aprev = a;\n \n params[0] = beta;\n params[1] = phi;\n params[2] = eta;\n params[3] = gamma;\n params[4] = delta;\n f.function = &tinker2010_mf_norm_integ;\n f.params = params;\n numin = 1e-10;\n numax = 1e10;\n epsabs = 1e-6;\n epsrel = 1e-6;\n \n gsl_integration_qag(&f,log(numin),log(numax),epsabs,epsrel,limit,GSL_INTEG_GAUSS61,w,&alphaprev,&abserr);\n //alphaprev = gsl_integration_glfixed(&f,log(numin),log(numax),gltab);\n \n /*\n alphaprev = 0.0;\n Nnu = 100;\n \n dnu = log(numax/numin)/Nnu;\n for(i=0;i\n#include \n\n#include \n\n#include \"defines.h\"\n#include \"matrix_vector_ops.h\"\n#include \"genann.h\"\n\n#define NUM_STATES 12\n#define NUM_INPUTS 4\n\n// Dynamics model from G. Gremillion, S. Humbert paper \"System Identification of\n// a Quadrotor Micro Air Vehicle\" (equation 3 in paper)\n// Augmented to include position dynamics in hover\n// Dynamics and controls matrix:\n// cos(ps)*u -sin(ps)*v 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n// sin(ps)*u cos(ps)*v 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n// 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0\n// 0 0 0 X_u*u 0 0 0 0 0 0 X_th*th 0 0 0 0 0\n// 0 0 0 0 Y_v*v 0 0 0 0 Y_ph*ph 0 0 0 0 0 0\n// 0 0 0 0 0 Z_w*w 0 0 0 0 0 0 0 0 0 Z_thr*d_thr\n// 0 0 0 0 0 0 L_p*p 0 0 L_ph*ph 0 0 L_la*d_la 0 0 0\n// 0 0 0 0 0 0 0 M_q*q 0 0 M_th*th 0 0 M_lo*d_lo 0 0\n// 0 0 0 0 0 0 0 0 N_r*r 0 0 0 0 0 N_ya*d_ya 0\n// 0 0 0 0 0 0 ph_p*p 0 0 0 0 0 ph_la*d_la 0 0 0\n// 0 0 0 0 0 0 0 th_q*q 0 0 0 0 0 th_lo*d_lo 0 0\n// 0 0 0 0 0 0 0 0 ps_r*r 0 0 0 0 0 ps_ya*d_ya 0\n//\n// Parameters:\n// X_u = -0.27996\n// Y_v = -0.22566\n// Z_w = -1.2991\n// L_p = -2.5110\n// M_q = -2.4467\n// N_r = -0.4948\n// X_th = -10.067\n// Y_ph = 9.8648\n// L_ph = -21.358\n// M_th = -18.664\n// ph_p = 0.9655\n// th_q = 0.9634\n// ps_r = 0.6748\n// Z_thr = -39.282\n// L_la = 11.468\n// M_lo = 9.5711\n// N_ya = 3.5647\n// ph_la = 0.0744\n// th_lo = 0.0594\n// ps_ya = 0.0397\n// \n// State vector:\n// x y z u v w p q r phi theta psi\n//\n// Control vector:\n// del_lat del_lon del_yaw del_thrust\nint dynamics(gsl_vector *dy, double t, const gsl_vector *y, const gsl_vector *u);\nint setupDynamics();\nint teardownDynamics();\n\ngsl_vector *feedback(gsl_vector *yd, gsl_vector *y);\nint setupFeedback();\nint teardownFeedback();\n\ngsl_vector *nnFeedback(gsl_vector *yd, gsl_vector *y);\nint setupNnFeedback(int dataShape[2]);\nint setupNnFeedback(FILE *in);\nint teardownNnFeedback();\ngenann *getFeedbackNn();\n", "meta": {"hexsha": "a1335b98eaa3606832c78856715d6defdf1119ae", "size": 2590, "ext": "h", "lang": "C", "max_stars_repo_path": "dynamics.h", "max_stars_repo_name": "umd-agrc/SimpleControlSim", "max_stars_repo_head_hexsha": "d04a8fa496ec414e2cffdc70ee0beda85e0d7cb4", "max_stars_repo_licenses": ["MIT"], "max_stars_count": null, "max_stars_repo_stars_event_min_datetime": null, "max_stars_repo_stars_event_max_datetime": null, "max_issues_repo_path": "dynamics.h", "max_issues_repo_name": "umd-agrc/SimpleControlSim", "max_issues_repo_head_hexsha": "d04a8fa496ec414e2cffdc70ee0beda85e0d7cb4", "max_issues_repo_licenses": ["MIT"], "max_issues_count": null, "max_issues_repo_issues_event_min_datetime": null, "max_issues_repo_issues_event_max_datetime": null, "max_forks_repo_path": "dynamics.h", "max_forks_repo_name": "umd-agrc/SimpleControlSim", "max_forks_repo_head_hexsha": "d04a8fa496ec414e2cffdc70ee0beda85e0d7cb4", "max_forks_repo_licenses": ["MIT"], "max_forks_count": null, "max_forks_repo_forks_event_min_datetime": null, "max_forks_repo_forks_event_max_datetime": null, "avg_line_length": 35.9722222222, "max_line_length": 107, "alphanum_fraction": 0.4737451737, "num_tokens": 1147, "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8333245828938678, "lm_q2_score": 0.600188359260205, "lm_q1q2_score": 0.5001517141382652}}