#include "nf_Legendre.h"

Include dependency graph for nf_Legendre.cc:

Classes
struct	nf_Legendre_from_ptwXY_callback_s

Functions
static nfu_status	nf_Legendre_to_ptwXY2 (double mu, double P, void argList)

static nfu_status	nf_Legendre_from_ptwXY_callback (double mu, double f, void argList)

nf_Legendre *	nf_Legendre_new (int initialSize, int maxOrder, double Cls, nfu_status status)

nfu_status	nf_Legendre_setup (nf_Legendre *Legendre, int initialSize, int maxOrder)

nfu_status	nf_Legendre_release (nf_Legendre *Legendre)

nf_Legendre *	nf_Legendre_free (nf_Legendre *Legendre)

nf_Legendre *	nf_Legendre_clone (nf_Legendre nfL, nfu_status status)

nfu_status	nf_Legendre_reallocateCls (nf_Legendre *Legendre, int size, int forceSmallerResize)

int	nf_Legendre_maxOrder (nf_Legendre *Legendre)

int	nf_Legendre_allocated (nf_Legendre *Legendre)

double	nf_Legendre_getCl (nf_Legendre Legendre, int l, nfu_status status)

nfu_status	nf_Legendre_setCl (nf_Legendre *Legendre, int l, double Cl)

nfu_status	nf_Legendre_normalize (nf_Legendre *Legendre)

double	nf_Legendre_evauluateAtMu (nf_Legendre Legendre, double mu, nfu_status status)

double	nf_Legendre_PofL_atMu (int l, double mu)

ptwXYPoints *	nf_Legendre_to_ptwXY (nf_Legendre Legendre, double accuracy, int biSectionMax, int checkForRoots, nfu_status status)

nf_Legendre *	nf_Legendre_from_ptwXY (ptwXYPoints ptwXY, int maxOrder, nfu_status status)

Function Documentation

int nf_Legendre_allocated ( nf_Legendre * Legendre )

Definition at line 112 of file nf_Legendre.cc.

                                                    {
 
     return( Legendre->allocated );
 }

nf_Legendre* nf_Legendre_clone	(	nf_Legendre *	nfL,
		nfu_status *	status
	)

Definition at line 70 of file nf_Legendre.cc.

                                                                        {
 
     return( nf_Legendre_new( 0, nfL->maxOrder, nfL->Cls, status ) );
 }

Here is the call graph for this function:

double nf_Legendre_evauluateAtMu	(	nf_Legendre *	Legendre,
		double	mu,
		nfu_status *	status
	)

Definition at line 160 of file nf_Legendre.cc.

                                                                                          {
 
     int l;
     double P = 0.;
 
     *status = nfu_XOutsideDomain;
     if( ( mu >= -1. ) && ( mu <= 1. ) ) {
         *status = nfu_Okay;
         for( l = 0; l <= Legendre->maxOrder; l++ ) P += ( l + 0.5 ) * Legendre->Cls[l] * nf_Legendre_PofL_atMu( l, mu );
     }
     return( P );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

nf_Legendre* nf_Legendre_free ( nf_Legendre * Legendre )

Definition at line 61 of file nf_Legendre.cc.

                                                        {
 
     nf_Legendre_release( Legendre );
     nfu_free( Legendre );
     return( NULL );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

nf_Legendre* nf_Legendre_from_ptwXY	(	ptwXYPoints *	ptwXY,
		int	maxOrder,
		nfu_status *	status
	)

Definition at line 250 of file nf_Legendre.cc.

                                                                                             {
 
     int l, i, n = (int) ptwXY_length( ptwXY );
     nf_Legendre *Legendre;
     double mu1, mu2, f1, f2, Cl, Cls[1] = { 0 }, integral;
     struct nf_Legendre_from_ptwXY_callback_s argList;
 
     if( ( *status = ptwXY_getStatus( ptwXY ) ) != nfu_Okay ) return( NULL );
 
     ptwXY_getXYPairAtIndex( ptwXY, 0, &mu1, &f1 );
     if( mu1 < -1 ) {
         *status = nfu_XOutsideDomain;
         return( NULL );
     }
 
     ptwXY_getXYPairAtIndex( ptwXY, 0, &mu2, &f2 );
     if( mu2 > 1 ) {
         *status = nfu_XOutsideDomain;
         return( NULL );
     }
 
     if( ( Legendre = nf_Legendre_new( maxOrder + 1, -1, Cls, status ) ) == NULL ) return( NULL );
 
     if( maxOrder > nf_Legendre_maxMaxOrder ) maxOrder = nf_Legendre_maxMaxOrder;
     for( l = 0; l <= maxOrder; l++ ) {
         ptwXY_getXYPairAtIndex( ptwXY, 0, &mu1, &f1 );
         argList.l = l;
         for( i = 1, Cl = 0; i < n; i++ ) {
             ptwXY_getXYPairAtIndex( ptwXY, i, &mu2, &f2 );
             argList.mu1 = mu1;
             argList.f1 = f1;
             argList.mu2 = mu2;
             argList.f2 = f2;
             if( ( *status = nf_Legendre_GaussianQuadrature( l + 1, mu1, mu2, nf_Legendre_from_ptwXY_callback, (void *) &argList, &integral ) ) != nfu_Okay )
                 goto err;
             Cl += integral;
             mu1 = mu2;
             f1 = f2;
         }
         if( ( *status = nf_Legendre_setCl( Legendre, l, Cl ) ) != nfu_Okay ) goto err;
     }
     return( Legendre );
 
 err:
     nf_Legendre_free( Legendre );
     return( NULL );    
 }

Here is the call graph for this function:

static nfu_status nf_Legendre_from_ptwXY_callback	(	double	mu,
		double *	f,
		void *	argList
	)

static

Definition at line 300 of file nf_Legendre.cc.

                                                                                          {
 
     struct nf_Legendre_from_ptwXY_callback_s *args = (struct nf_Legendre_from_ptwXY_callback_s *) argList;
 
     *f = ( args->f1 * ( args->mu2 - mu ) + args->f2 * ( mu - args->mu1 ) ) / ( args->mu2 - args->mu1 );
     *f *= nf_Legendre_PofL_atMu( args->l, mu );
     return( nfu_Okay );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

double nf_Legendre_getCl	(	nf_Legendre *	Legendre,
		int	l,
		nfu_status *	status
	)

Definition at line 119 of file nf_Legendre.cc.

                                                                              {
 
     *status = nfu_Okay;
     if( ( l < 0 ) || ( l > Legendre->maxOrder ) ) {
         *status = nfu_badIndex;
         return( 0. );
     }
     return( Legendre->Cls[l] );
 }

int nf_Legendre_maxOrder ( nf_Legendre * Legendre )

Definition at line 105 of file nf_Legendre.cc.

                                                   {
 
     return( Legendre->maxOrder );
 }

nf_Legendre* nf_Legendre_new	(	int	initialSize,
		int	maxOrder,
		double *	Cls,
		nfu_status *	status
	)

Definition at line 23 of file nf_Legendre.cc.

                                                                                                {
 
     int l;
     nf_Legendre *Legendre = (nf_Legendre *) nfu_malloc( sizeof( nf_Legendre ) );
 
     *status = nfu_mallocError;
     if( Legendre == NULL ) return( NULL );
     if( ( *status = nf_Legendre_setup( Legendre, initialSize, maxOrder ) ) != nfu_Okay ) {
         nfu_free( Legendre );
         return( NULL );
     }
     for( l = 0; l <= Legendre->maxOrder; l++ ) Legendre->Cls[l] = Cls[l];
     return( Legendre );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

nfu_status nf_Legendre_normalize ( nf_Legendre * Legendre )

Definition at line 146 of file nf_Legendre.cc.

                                                           {
 
     int l;
     double norm;
 
     if( Legendre->maxOrder >= 0 ) {
         if( ( norm = Legendre->Cls[0] ) == 0 ) return( nfu_divByZero );
         for( l = 0; l <= Legendre->maxOrder; l++ ) Legendre->Cls[l] /= norm;
     }
     return( nfu_Okay );
 }

double nf_Legendre_PofL_atMu	(	int	l,
		double	mu
	)

Definition at line 175 of file nf_Legendre.cc.

                                                  {
 
     int l_, twoL_plus1;
     double Pl_minus1, Pl, Pl_plus1;
 
     if( l == 0 ) {
         return( 1. ); }
     else if( l == 1 ) {
         return( mu ); }
 /*
     else if( l <= 9 ) {
         double mu2 = mu * mu;
         if ( l == 2 ) {
             return(                1.5 * mu2 - 0.5 ); }
         else if( l == 3 ) {
             return(                2.5 * mu2 -          1.5 ) * mu; }
         else if( l == 4 ) {
             return(              4.375 * mu2 -         3.75 ) * mu2 +       0.375; }
         else if( l == 5 ) {
             return( (            7.875 * mu2 -         8.75 ) * mu2 +       1.875 ) * mu; }
         else if( l == 6 ) {
             return( (          14.4375 * mu2 -      19.6875 ) * mu2 +      6.5625 ) * mu2 -      0.3125; }
         else if( l == 7 ) {
             return( ( (        26.8125 * mu2 -      43.3125 ) * mu2 +     19.6875 ) * mu2 -      2.1875 ) * mu; }
         else if( l == 8 ) {
             return( ( (     50.2734375 * mu2 -     93.84375 ) * mu2 +   54.140625 ) * mu2 -     9.84375 ) * mu2 + 0.2734375; }
         else {
             return( ( ( (   94.9609375 * mu2 -    201.09375 ) * mu2 +  140.765625 ) * mu2 -    36.09375 ) * mu2 + 2.4609375 ) * mu;
         }
     }
 */
 
     Pl = 0.;
     Pl_plus1 = 1.;
     for( l_ = 0, twoL_plus1 = 1; l_ < l; l_++, twoL_plus1 += 2 ) {
         Pl_minus1 = Pl;
         Pl = Pl_plus1;
         Pl_plus1 = ( twoL_plus1 * mu * Pl - l_ * Pl_minus1 ) / ( l_ + 1 );
     }
     return( Pl_plus1 );
 }

Here is the caller graph for this function:

nfu_status nf_Legendre_reallocateCls	(	nf_Legendre *	Legendre,
		int	size,
		int	forceSmallerResize
	)

Definition at line 77 of file nf_Legendre.cc.

                                                                                                 {
 
     nfu_status status = nfu_Okay;
 
     if( size < nf_Legendre_minMaxOrder ) size = nf_Legendre_minMaxOrder;
     if( size > ( nf_Legendre_maxMaxOrder + 1 ) ) size = nf_Legendre_maxMaxOrder + 1;
     if( size != Legendre->allocated ) {
         if( size > Legendre->allocated ) {
             Legendre->Cls = (double *) nfu_realloc( size * sizeof( double ), Legendre->Cls ); }
         else {
             if( size < ( Legendre->maxOrder + 1 ) ) size = Legendre->maxOrder + 1;
             if( ( Legendre->allocated > 2 * size ) || forceSmallerResize ) {
                     Legendre->Cls = (double *) nfu_realloc( size * sizeof( double ), Legendre->Cls ); } 
             else {
                 size = Legendre->allocated;
             }
         }
         if( Legendre->Cls == NULL ) {
             size = 0;
             status = nfu_mallocError;
         }
         Legendre->allocated = size;
     }
     return( status );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

nfu_status nf_Legendre_release ( nf_Legendre * Legendre )

Definition at line 52 of file nf_Legendre.cc.

                                                         {
 
     if( Legendre->allocated > 0 ) nfu_free( Legendre->Cls );
     memset( Legendre, 0, sizeof( nf_Legendre ) );
     return( nfu_Okay );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

nfu_status nf_Legendre_setCl	(	nf_Legendre *	Legendre,
		int	l,
		double	Cl
	)

Definition at line 131 of file nf_Legendre.cc.

                                                                         {
 
     nfu_status status;
 
     if( ( l < 0 ) || ( l > ( Legendre->maxOrder + 1 ) ) ) return( nfu_badIndex );
     if( Legendre->allocated <= l ) {
         if( ( status = nf_Legendre_reallocateCls( Legendre, l + nf_Legendre_sizeIncrement, 0 ) ) != nfu_Okay ) return( status );
     }
     if( l > Legendre->maxOrder ) Legendre->maxOrder = l;
     Legendre->Cls[l] = Cl;
     return( nfu_Okay );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

nfu_status nf_Legendre_setup	(	nf_Legendre *	Legendre,
		int	initialSize,
		int	maxOrder
	)

Definition at line 40 of file nf_Legendre.cc.

                                                                                      {
 
     memset( Legendre, 0, sizeof( nf_Legendre ) );
     if( maxOrder < 0 ) maxOrder = -1;
     if( maxOrder > nf_Legendre_maxMaxOrder ) maxOrder = nf_Legendre_maxMaxOrder;
     Legendre->maxOrder = maxOrder;
     if( initialSize < ( maxOrder + 1 ) ) initialSize = maxOrder + 1;
     return( nf_Legendre_reallocateCls( Legendre, initialSize, 0 ) );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

ptwXYPoints* nf_Legendre_to_ptwXY	(	nf_Legendre *	Legendre,
		double	accuracy,
		int	biSectionMax,
		int	checkForRoots,
		nfu_status *	status
	)

Definition at line 219 of file nf_Legendre.cc.

                                                                                                                                      {
 
     int i, n = 1;
     double dx, xs[1000];
     void *argList = (void *) Legendre;
 
     *status = nfu_Okay;
     xs[0] = -1;
     if( Legendre->maxOrder > 1 ) {
         n = Legendre->maxOrder - 1;
         if( n > 249 ) n = 249;
         n = 4 * n + 1;
         dx = 2. / n;
         for( i = 1; i < n; i++ ) xs[i] = xs[i-1] + dx;
     }
     xs[n] = 1.;
     return( ptwXY_createFromFunction( n + 1, xs, nf_Legendre_to_ptwXY2, (void *) argList, accuracy, checkForRoots, biSectionMax, status ) );
 }

Here is the call graph for this function:

static nfu_status nf_Legendre_to_ptwXY2	(	double	mu,
		double *	P,
		void *	argList
	)

static

Definition at line 240 of file nf_Legendre.cc.

                                                                                {
 
     nfu_status status;      /* Set by nf_Legendre_evauluateAtMu. */
 
     *P = nf_Legendre_evauluateAtMu( (nf_Legendre *) argList, mu, &status );
     return( status );
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Classes

Functions

Function Documentation