コード例 #1
0
    virtual int exec(double* integral,double* error){
        assert(ncomp==1); // gsl mc integration does only single component yo!
        gsl_monte_integrand_wrapper iw;
        iw.ncomp     = ncomp;
        iw.params    = params;
        iw.integrand = integrand;

        gsl_monte_function G;
        G.f      = gsl_monte_integrand_wrapper::f;
        G.dim    = ndim;
        G.params = (void*) &iw;
        
        double xl[ndim];
        double xu[ndim];
        std::fill(xl,xl+ndim,0.); // unit cube!
        std::fill(xu,xu+ndim,1.); // unit cube!
        
        const gsl_rng_type* T;
        gsl_rng* r;

        gsl_rng_env_setup();
        
        T = gsl_rng_default;
        r = gsl_rng_alloc(T);
        
        gsl_monte_miser_state* s = gsl_monte_miser_alloc(ndim);
        gsl_monte_miser_integrate(&G,xl,xu,ndim,calls,r,s,integral,error);
        
        gsl_monte_miser_free(s);
        gsl_rng_free(r);
        return 0; // succes!
        }
コード例 #2
0
ファイル: mlgsl_monte.c プロジェクト: oandrieu/ocamlgsl
CAMLprim value ml_gsl_monte_miser_alloc(value d)
{
    gsl_monte_miser_state *s;
    struct callback_params *params;
    int dim=Int_val(d);

    s=gsl_monte_miser_alloc(dim);
    params=stat_alloc(sizeof(*params));

    {
        CAMLparam0();
        CAMLlocal1(res);
        res=alloc_small(2, Abstract_tag);
        Field(res, 0) = (value)s;
        Field(res, 1) = (value)params;
        params->gslfun.mf.f = &gsl_monte_callback;
        params->gslfun.mf.dim = dim;
        params->gslfun.mf.params = params;
        params->closure = Val_unit;
        params->dbl = alloc(dim * Double_wosize, Double_array_tag);

        register_global_root(&(params->closure));
        register_global_root(&(params->dbl));
        CAMLreturn(res);
    }
}
void monte_carlo_integration()
{
	double res, err;
	double xl[3] = { 0, 0, 0 };
	double xu[3] = { M_PI, M_PI, M_PI };

	gsl_monte_function G = { &local::g, 3, NULL };
	const std::size_t calls = 500000;

	gsl_rng_env_setup();
	const gsl_rng_type *T = gsl_rng_default;
	gsl_rng *r = gsl_rng_alloc(T);

	//
	{
		gsl_monte_plain_state *s = gsl_monte_plain_alloc(3);
		gsl_monte_plain_integrate(&G, xl, xu, 3, calls, r, s, &res, &err);
		gsl_monte_plain_free(s);
		local::display_results("plain", res, err);
	}

	//
	{
		gsl_monte_miser_state *s = gsl_monte_miser_alloc(3);
		gsl_monte_miser_integrate(&G, xl, xu, 3, calls, r, s, &res, &err);
		gsl_monte_miser_free(s);
		local::display_results("miser", res, err);
	}

	//
	{
		gsl_monte_vegas_state *s = gsl_monte_vegas_alloc(3);
		gsl_monte_vegas_integrate(&G, xl, xu, 3, 10000, r, s, &res, &err);
		local::display_results("vegas warm-up", res, err);

		std::cout << "converging..." << std::endl;
		do
		{
			gsl_monte_vegas_integrate(&G, xl, xu, 3, calls/5, r, s, &res, &err);
			std::cout << "result = " << res << " sigma = " << err << " chisq/dof = " << s->chisq << std::endl;
		} while (std::fabs(s->chisq - 1.0) > 0.5);

		local::display_results("vegas final", res, err);
		gsl_monte_vegas_free(s);
	}
}
コード例 #4
0
ファイル: monte.c プロジェクト: juhnowski/FishingRod
/* make the init look similar to the one */
static void *
PyGSL_gsl_monte_alloc(void * type, int n)
{
     enum PyGSL_gsl_monte_type flag = (enum PyGSL_gsl_monte_type) type;
     void * result = NULL;

     FUNC_MESS_BEGIN();
     switch(flag){
     case PyGSL_MONTE_plain:
	  result = gsl_monte_plain_alloc(n);
	  break;
     case PyGSL_MONTE_miser:
	  result = gsl_monte_miser_alloc(n);
	  break;
     case PyGSL_MONTE_vegas:
	  result = gsl_monte_vegas_alloc(n);
	  break;
     default:
	  DEBUG_MESS(2, "Monte type %d unknown",flag);
	  PyGSL_ERROR_NULL("Unknown monte type!", GSL_ESANITY);
     }
     FUNC_MESS_END();
     return result;
}
コード例 #5
0
ファイル: random_walk.c プロジェクト: saintfrank/inte
 int
 main (void)
 {
   double res, err;
 
   double xl[3] = { 0, 0, 0 };
   double xu[3] = { M_PI, M_PI, M_PI };
 
   const gsl_rng_type *T;
   gsl_rng *r;
 
   gsl_monte_function G = { &g, 3, 0 };
 
   size_t calls = 500000;
 
   gsl_rng_env_setup ();
 
   T = gsl_rng_default;
   r = gsl_rng_alloc (T);
 
   {
     gsl_monte_plain_state *s = gsl_monte_plain_alloc (3);
     gsl_monte_plain_integrate (&G, xl, xu, 3, calls, r, s, 
                                &res, &err);
     gsl_monte_plain_free (s);
 
     display_results ("plain", res, err);
   }
 
   {
     gsl_monte_miser_state *s = gsl_monte_miser_alloc (3);
     gsl_monte_miser_integrate (&G, xl, xu, 3, calls, r, s,
                                &res, &err);
     gsl_monte_miser_free (s);
 
     display_results ("miser", res, err);
   }
 
   {
     gsl_monte_vegas_state *s = gsl_monte_vegas_alloc (3);
 
     gsl_monte_vegas_integrate (&G, xl, xu, 3, 10000, r, s,
                                &res, &err);
     display_results ("vegas warm-up", res, err);
 
     printf ("converging...\n");
 
     do
       {
         gsl_monte_vegas_integrate (&G, xl, xu, 3, calls/5, r, s,
                                    &res, &err);
         printf ("result = % .6f sigma = % .6f "
                 "chisq/dof = %.1f\n", res, err, gsl_monte_vegas_chisq (s));
       }
     while (fabs (gsl_monte_vegas_chisq (s) - 1.0) > 0.5);
 
     display_results ("vegas final", res, err);
 
     gsl_monte_vegas_free (s);
   }
 
   gsl_rng_free (r);
 
   return 0;
 }