示例#1
0
static gsl_poly_int* mygsl_poly_laguerre(int n)
{
  size_t m, k;
  int val;
  gsl_vector_int *p0;
  if (n < 0) rb_raise(rb_eArgError, "order must be >= 0");
  p0 = gsl_vector_int_calloc(n + 1);
  switch (n) {
  case 0:
    gsl_vector_int_set(p0, 0, 1);
    break;
  case 1:
    gsl_vector_int_set(p0, 0, 1);
    gsl_vector_int_set(p0, 1, -1);
    break;
  default:
    k = gsl_sf_fact(n);
    for (m = 0; m <= n; m++) {
      val = k*k/gsl_sf_fact(n-m)/gsl_pow_2(gsl_sf_fact(m));
      if (m%2 == 1) val *= -1;
      gsl_vector_int_set(p0, m, val);
    }
    break;
  }
  return p0;
}
示例#2
0
static gsl_poly_int* mygsl_poly_bessel(int n)
{
  size_t k;
  gsl_vector_int *p0;
  if (n < 0) rb_raise(rb_eArgError, "order must be >= 0");
  p0 = gsl_vector_int_calloc(n + 1);
  for (k = 0; k <= n; k++) {
    gsl_vector_int_set(p0, k, gsl_sf_fact(n+k)/gsl_sf_fact(n-k)/gsl_sf_fact(k)/((int) pow(2, k)));
  }
  return p0;
}
示例#3
0
void ambisonicWeight::computeInPhaseOptim()
{
	m_optimMode = "inPhase"; 
	for (int i = 0; i < m_number_of_harmonics; i++) 
	{
		if (i == 0) 
			m_optimVector[i] = 1.;
		else 
			m_optimVector[i] = pow(gsl_sf_fact(m_order), 2) / ( gsl_sf_fact(m_order+abs(m_index_of_harmonics[i])) * gsl_sf_fact(m_order-abs(m_index_of_harmonics[i])));
	}
}
示例#4
0
double Anl_tilde(int n ,int l){
    double K_nl, factor, A_nl;
    double gamma_factor;

    K_nl = 0.5*n*(n+4.*l+3.) + (l+1.)*(2.*l+1.);
    factor = pow(2,8.*l+6.) / (4.*M_PI*K_nl);
    gamma_factor = pow(gsl_sf_gamma(2.0*l+1.5),2)/gsl_sf_gamma(n+4.*l+3.);
    A_nl =-factor* gsl_sf_fact(n)*(n+2.*l+1.5)*gamma_factor;
    return A_nl;
}
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray
                 *prhs[])
{


  int i, j;
  int N, Nperm;
  int *d;
  
  int subs[2];
  double *ptr;
  gsl_permutation *c;
  

 if(nrhs != 1)
    mexErrMsgTxt("1 input required");

  if(nlhs != 1)
    mexErrMsgTxt("Requires one output.");
  
  if(mxGetM(prhs[0]) * mxGetN(prhs[0]) != 1)
    mexErrMsgTxt("N must be scalar");
  
  N = mxGetScalar(prhs[0]);

  Nperm = (int) (gsl_sf_fact(N));
  
  c = gsl_permutation_calloc (N);
  gsl_permutation_init(c);



  plhs[0] = mxCreateDoubleMatrix(Nperm, N, mxREAL);
  ptr = mxGetPr(plhs[0]);

  for(i = 0; i < Nperm; i++)
    {
      d = gsl_permutation_data(c);
      for(j = 0; j < N; j++)
	{

	  subs[0] = i;
	  subs[1] = j;
	  ptr[mxCalcSingleSubscript(plhs[0], 2, subs)] = 
	    (double)d[j] + 1.;
	}
      
      gsl_permutation_next(c);
    }
  


  gsl_permutation_free(c);
  
}
示例#6
0
void AmbisonicEase::computeVectors()
{
	m_index_of_harmonics	= new long[m_number_of_harmonics ];
    m_ambiCoeffs            = new double[m_number_of_harmonics];
    m_optimVector           = new double[m_number_of_harmonics];
    m_minus_vector          = new double[m_number_of_harmonics];
	m_dot_vector            = new double[m_number_of_harmonics];
    m_widen_vector          = new double[m_number_of_harmonics];
    
	m_index_of_harmonics[0] = 0;
    m_order_weight = log((double)(m_order + 1));
	for(int i = 1; i < m_number_of_harmonics; i++)
	{
		m_index_of_harmonics[i] = (i - 1) / 2 + 1;
		if (i % 2 == 1)
			m_index_of_harmonics[i] = - m_index_of_harmonics[i];
	}
    for(int i = 1; i < m_number_of_harmonics; i++)
	{
        m_minus_vector[i] = Tools::clip_min(log((double)abs(m_index_of_harmonics[i])), 0.);
		m_dot_vector[i]	= Tools::clip_min(log((double)abs(m_index_of_harmonics[i]) + 1.), 0.);
		m_dot_vector[i] -= m_minus_vector[i];
		m_dot_vector[i] = 1. / m_dot_vector[i];
    }
    for (int i = 0; i < NUMBEROFCIRCLEPOINTS; i++)
	{
		m_cosLookUp[i] = cos((double)i * CICM_2PI / (double)NUMBEROFCIRCLEPOINTS);
		m_sinLookUp[i] = sin((double)i * CICM_2PI / (double)NUMBEROFCIRCLEPOINTS);
	}
    for (int i = 0; i < m_number_of_harmonics; i++)
	{
		if (i == 0)
			m_optimVector[i] = 1.;
		else
			m_optimVector[i] = pow(gsl_sf_fact(m_order), 2) / ( gsl_sf_fact(m_order+abs(m_index_of_harmonics[i])) * gsl_sf_fact(m_order-abs(m_index_of_harmonics[i])));
	}
}
//------------------------------------------------------------------------------
/// \f$ n! \f$
inline double factorial(const unsigned int n)
{
   return gsl_sf_fact(n);
}
/**
 * Function to calculate associated Legendre function used by the spherical harmonics function
 */
static REAL8
XLALAssociatedLegendreXIsZero( const int l,
                               const int m )
{

  REAL8 legendre;

  if ( l < 0 )
  {
    XLALPrintError( "l cannot be < 0\n" );
    XLAL_ERROR_REAL8( XLAL_EINVAL );
  }
  
  if ( m < 0 || m > l )
  {
    XLALPrintError( "Invalid value of m!\n" );
    XLAL_ERROR_REAL8( XLAL_EINVAL );
  }

  /* we will switch on the values of m and n */
  switch ( l )
  {
    case 1:
      switch ( m )
      {
        case 1:
          legendre = - 1.;
          break;
        default:
          XLAL_ERROR_REAL8( XLAL_EINVAL );
      }
      break;
    case 2:
      switch ( m )
      {
        case 2:
          legendre = 3.;
          break;
        case 1:
          legendre = 0.;
          break;
        default:
          XLAL_ERROR_REAL8( XLAL_EINVAL );
      }
      break;
    case 3:
      switch ( m )
      {
        case 3:
          legendre = -15.;
          break;
        case 2:
          legendre = 0.;
          break;
        case 1:
          legendre = 1.5;
          break;
        default:
          XLAL_ERROR_REAL8( XLAL_EINVAL );
      }
      break;
    case 4:
      switch ( m )
      {
        case 4:
          legendre = 105.;
          break;
        case 3:
          legendre = 0.;
          break;
        case 2:
          legendre = - 7.5;
          break;
        case 1:
          legendre = 0;
          break;
        default:
          XLAL_ERROR_REAL8( XLAL_EINVAL );
      }
      break;
    case 5:
      switch ( m )
      {
        case 5:
          legendre = - 945.;
          break;
        case 4:
          legendre = 0.;
          break;
        case 3:
          legendre = 52.5;
          break;
        case 2:
          legendre = 0;
          break;
        case 1:
          legendre = - 1.875;
          break;
        default:
          XLAL_ERROR_REAL8( XLAL_EINVAL );
      }
      break;
    case 6:
      switch ( m )
      {
        case 6:
          legendre = 10395.;
          break;
        case 5:
          legendre = 0.;
          break;
        case 4:
          legendre = - 472.5;
          break;
        case 3:
          legendre = 0;
          break;
        case 2:
          legendre = 13.125;
          break;
        case 1:
          legendre = 0;
          break;
        default:
          XLAL_ERROR_REAL8( XLAL_EINVAL );
      }
      break;
    case 7:
      switch ( m )
      {
        case 7:
          legendre = - 135135.;
          break;
        case 6:
          legendre = 0.;
          break;
        case 5:
          legendre = 5197.5;
          break;
        case 4:
          legendre = 0.;
          break;
        case 3:
          legendre = - 118.125;
          break;
        case 2:
          legendre = 0.;
          break;
        case 1:
          legendre = 2.1875;
          break;
        default:
          XLAL_ERROR_REAL8( XLAL_EINVAL );
      }
      break;
    case 8:
      switch ( m )
      {
        case 8:
          legendre = 2027025.;
          break;
        case 7:
          legendre = 0.;
          break;
        case 6:
          legendre = - 67567.5;
          break;
        case 5:
          legendre = 0.;
          break;
        case 4:
          legendre = 1299.375;
          break;
        case 3:
          legendre = 0.;
          break;
        case 2:
          legendre = - 19.6875;
          break;
        case 1:
          legendre = 0.;
          break;
        default:
          XLAL_ERROR_REAL8( XLAL_EINVAL );
      }
      break;
    default:
      XLALPrintError( "Unsupported (l, m): %d, %d\n", l, m );
      XLAL_ERROR_REAL8( XLAL_EINVAL );
  }

  legendre *= sqrt( (REAL8)(2*l+1)*gsl_sf_fact( l-m ) / (4.*LAL_PI*gsl_sf_fact(l+m)));

  return legendre;
}
示例#9
0
double ho_A (int n, int l, double b)
{   return sqrt (2. * gsl_sf_fact ((unsigned) (n - 1)) / (b * gsl_sf_gamma ((double)n + (double)l + 1. / 2.))); }
scalar sasfit_peak_QENS_ConfinementWithGaussianPotential(scalar energy, sasfit_param * param)
{
	scalar gamma,v,q,sigma,hbar,de,q2,a0,an, sqe;
	int i;
	sasfit_param subParam;

	SASFIT_ASSERT_PTR( param );

	sigma = SIGMA0+Q*SIGMA1+Q*Q*SIGMA2;

	SASFIT_CHECK_COND1((sigma < 0), param, "sigma(%lg) < 0",sigma);
	SASFIT_CHECK_COND1((U2 < 0),    param, "<u^2>(%lg) < 0",U2);

	q = Q/1.e-10; // convertion from Angstrom in meter 
	q2 = q*q;
	a0 = exp(-q2*U2);
	de = energy-E0;

	if (sigma == 0.0) {
		if (de == 0.0) {
			sqe = a0;
		} else {
			sqe = 0.0;
		}
	} else {
		if (de ==0.0) {
			sqe = a0/(sqrt(2.0*M_PI)*sigma);
		} else {
			sqe = a0/(sqrt(2.0*M_PI)*sigma)*exp(-de*de/(2.0*sigma*sigma));
		}
	}

	sqe = AMPL*sqe;

//  hbar in meV
	hbar = GSL_CONST_MKSA_PLANCKS_CONSTANT_HBAR / GSL_CONST_MKSA_ELECTRON_VOLT * 1e3;

	sasfit_init_param( &subParam );

	for (i=1; i<=N; i++) {
		if (U2 == 0.0) break;
		gamma = i*hbar*DIFF/U2;
		if (q2*U2 == 0.0) {
			an=0.0;
		} else {
//			an = a0* exp(i*log(q2*u2)-gsl_sf_lngamma(i+1));
			an = a0 *pow(q2*U2,i)/gsl_sf_fact(i);
		}
		
		if (sigma == 0.0) {
			if ((gamma == 0.0) && (de == 0.0)) {
				v = 1/M_PI;
			} else {
				v = gamma/(gamma*gamma+de*de)/M_PI;
			}
		} else {
			subParam.p[0] = 1.0;
			subParam.p[1] = 0.0;
			subParam.p[2] = sigma;
			subParam.p[3] = gamma;
			subParam.p[4] = 0.0;
			v = sasfit_peak_VoigtPeakArea(de,&subParam);
			if (subParam.errStatus) {
				param->errStatus = subParam.errStatus;
				strcpy(param->errStr,subParam.errStr);
				return sqe;
			}
			if (v<=0) {
				fprintf(stderr,"energy=%lg v=%lg\ngamma=%lg sigma=%lg energy=%lg\n", energy, v, gamma, sigma, E0);
			}
		}
		sqe = sqe+AMPL*an*v;
	}
	return sqe+BACKGR;
}
示例#11
0
    SET_METHOD( Polymorph, SSystemMatrix )
    {
        SSystemMatrix = value;
        PolymorphVector aValueVector( value.as<PolymorphVector>() );
        theSystemSize = aValueVector.size();

        // init Substance Vector
        theY.resize( boost::extents[ theSystemSize + 1 ][ Order + 1 ] );

        // init S-System Vector & Matrix
        theAlpha.resize( boost::extents[ theSystemSize + 1 ] );
        theBeta.resize( boost::extents[ theSystemSize + 1] );
        theG.resize( boost::extents[ theSystemSize + 1 ][ theSystemSize + 1 ] );
        theH.resize( boost::extents[ theSystemSize + 1 ][ theSystemSize + 1 ] );

        // init S-System tmp Vector & Matrix
        theAlphaBuffer.resize( boost::extents[ theSystemSize + 1 ][ Order + 1 ] );
        theBetaBuffer.resize( boost::extents[ theSystemSize + 1 ][ Order + 1 ] );
        theGBuffer.resize( boost::extents[ theSystemSize + 1 ][ Order + 1 ] );
        theHBuffer.resize( boost::extents[ theSystemSize + 1 ][ Order + 1 ] );

        theFBuffer.resize( boost::extents[ Order + 1 ][ Order + 1 ] );

        // init Factorial matrix
        for(int m( 2 ) ; m < Order+1 ; m++)
        {
            for(int q( 1 ); q < m ; q++)
            {
                const Real aFact( 1 / gsl_sf_fact(q-1) * gsl_sf_fact(m-q-1) * m * (m-1) );
                (theFBuffer[m])[q] = aFact;
            }
        }

        // set Alpha, Beta, G, H
        for( int i( 0 ); i < theSystemSize; ++i )
        {

            theAlpha[i+1] = (aValueVector[i].as<PolymorphVector>())[0].as<Real>() ;
            for( int j( 0 ); j < theSystemSize; ++j )
            {
                if( i == j )
                {

                    (theG[i+1])[j+1] = (aValueVector[i].as<PolymorphVector>())[j+1].as<Real>() - 1 ;
                }
                else
                {
                    (theG[i+1])[j+1] = (aValueVector[i].as<PolymorphVector>())[j+1].as<Real>() ;
                }
            }
            theBeta[i+1] = (aValueVector[i].as<PolymorphVector>())[1+theSystemSize].as<Real>() ;
            for( int j( 0 ); j < theSystemSize; ++j )
            {
                if( i == j )
                {
                    (theH[i+1])[j+1] = (aValueVector[i].as<PolymorphVector>())[2+j+theSystemSize].as<Real>() -1 ;
                }
                else
                {
                    (theH[i+1])[j+1] = (aValueVector[i].as<PolymorphVector>())[2+j+theSystemSize].as<Real>() ;
                }
            }
        }
    }
示例#12
0
int rgb_permutations(Test **test,int irun)
{

 uint i,j,k,permindex=0,t;
 Vtest vtest;
 double *testv;
 size_t ps[4096];
 gsl_permutation** lookup;


 MYDEBUG(D_RGB_PERMUTATIONS){
   printf("#==================================================================\n");
   printf("# rgb_permutations: Debug with %u\n",D_RGB_PERMUTATIONS);
 }

 /*
  * Number of permutations.  Note that the minimum ntuple value for a
  * valid test is 2.  If ntuple is less than 2, we choose the default
  * test size as 5 (like operm5).
  */
 if(ntuple<2){
   test[0]->ntuple = 5;
 } else {
   test[0]->ntuple = ntuple;
 }
 k = test[0]->ntuple;
 nperms = gsl_sf_fact(k);

 /*
  * A vector to accumulate rands in some sort order
  */
 testv = (double *)malloc(k*sizeof(double));

 MYDEBUG(D_RGB_PERMUTATIONS){
   printf("# rgb_permutations: There are %u permutations of length k = %u\n",nperms,k);
 }

 /*
  * Create a test, initialize it.
  */
 Vtest_create(&vtest,nperms);
 vtest.cutoff = 5.0;
 for(i=0;i<nperms;i++){
   vtest.x[i] = 0.0;
   vtest.y[i] = (double) test[0]->tsamples/nperms;
 }

 MYDEBUG(D_RGB_PERMUTATIONS){
   printf("# rgb_permutations: Allocating permutation lookup table.\n");
 }
 lookup = (gsl_permutation**) malloc(nperms*sizeof(gsl_permutation*));
 for(i=0;i<nperms;i++){
   lookup[i] = gsl_permutation_alloc(k);
 }
 for(i=0;i<nperms;i++){
   if(i == 0){
     gsl_permutation_init(lookup[i]);
   } else {
     gsl_permutation_memcpy(lookup[i],lookup[i-1]);
     gsl_permutation_next(lookup[i]);
   }
 }

 MYDEBUG(D_RGB_PERMUTATIONS){
   for(i=0;i<nperms;i++){
     printf("# rgb_permutations: %u => ",i);
     gsl_permutation_fprintf(stdout,lookup[i]," %u");
     printf("\n");
   }
 }

 /*
  * We count the order permutations in a long string of samples of
  * rgb_permutation_k non-overlapping rands.  This is done by:
  *   a) Filling testv[] with rgb_permutation_k rands.
  *   b) Using gsl_sort_index to generate the permutation index.
  *   c) Incrementing a counter for that index (a-c done tsamples times)
  *   d) Doing a straight chisq on the counter vector with nperms-1 DOF
  *
  * This test should be done with tsamples > 30*nperms, easily met for
  * reasonable rgb_permutation_k
  */
 for(t=0;t<test[0]->tsamples;t++){
   /*
    * To sort into a perm, test vector needs to be double.
    */
   for(i=0;i<k;i++) {
     testv[i] = (double) gsl_rng_get(rng);
     MYDEBUG(D_RGB_PERMUTATIONS){
       printf("# rgb_permutations: testv[%u] = %u\n",i,(uint) testv[i]);
     }
   }

   gsl_sort_index(ps,testv,1,k);

   MYDEBUG(D_RGB_PERMUTATIONS){
     for(i=0;i<k;i++) {
       printf("# rgb_permutations: ps[%u] = %lu\n",i,ps[i]);
     }
   }

   for(i=0;i<nperms;i++){
     if(memcmp(ps,lookup[i]->data,k*sizeof(size_t))==0){
       permindex = i;
       MYDEBUG(D_RGB_PERMUTATIONS){
         printf("# Found permutation: ");
         gsl_permutation_fprintf(stdout,lookup[i]," %u");
         printf(" = %u\n",i);
       }
       break;
     }
   }

   vtest.x[permindex]++;
   MYDEBUG(D_RGB_PERMUTATIONS){
     printf("# rgb_permutations: Augmenting vtest.x[%u] = %f\n",permindex,vtest.x[permindex]);
   }

 }