nf_Legendre.h File Reference

#include <nf_utilities.h>
#include <ptwXY.h>

Go to the source code of this file.

Classes
struct	nf_Legendre_s

Macros
#define	nf_Legendre_minMaxOrder   4
#define	nf_Legendre_maxMaxOrder   64
#define	nf_Legendre_sizeIncrement   8

Typedefs
typedef struct nf_Legendre_s	nf_Legendre
typedef nfu_status(*	nf_Legendre_GaussianQuadrature_callback) (double x, double *y, void *argList)

Functions
nf_Legendre *	nf_Legendre_new (int initialSize, int maxOrder, double *Cls, nfu_status *status)
nfu_status	nf_Legendre_setup (nf_Legendre *nfL, int initialSize, int maxOrder)
nfu_status	nf_Legendre_release (nf_Legendre *nfL)
nf_Legendre *	nf_Legendre_free (nf_Legendre *nfL)
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 *nfL, double mu, nfu_status *status)
double	nf_Legendre_PofL_atMu (int l, double mu)
ptwXYPoints *	nf_Legendre_to_ptwXY (nf_Legendre *nfL, double accuracy, int biSectionMax, int checkForRoots, nfu_status *status)
nf_Legendre *	nf_Legendre_from_ptwXY (ptwXYPoints *ptwXY, int maxOrder, nfu_status *status)
nfu_status	nf_Legendre_GaussianQuadrature (int degree, double x1, double x2, nf_Legendre_GaussianQuadrature_callback func, void *argList, double *integral)

Macro Definition Documentation

nf_Legendre_maxMaxOrder

#define nf_Legendre_maxMaxOrder   64

Definition at line 18 of file nf_Legendre.h.

Referenced by nf_Legendre_from_ptwXY(), nf_Legendre_reallocateCls(), and nf_Legendre_setup().

nf_Legendre_minMaxOrder

#define nf_Legendre_minMaxOrder   4

Definition at line 17 of file nf_Legendre.h.

Referenced by nf_Legendre_reallocateCls().

nf_Legendre_sizeIncrement

#define nf_Legendre_sizeIncrement   8

Definition at line 19 of file nf_Legendre.h.

Referenced by nf_Legendre_setCl().

Typedef Documentation

nf_Legendre

typedef struct nf_Legendre_s nf_Legendre

Definition at line 21 of file nf_Legendre.h.

nf_Legendre_GaussianQuadrature_callback

typedef nfu_status(* nf_Legendre_GaussianQuadrature_callback) (double x, double *y, void *argList)

Definition at line 29 of file nf_Legendre.h.

Function Documentation

nf_Legendre_allocated()

int nf_Legendre_allocated

(

nf_Legendre *

Legendre

)

Definition at line 112 of file nf_Legendre.cc.

                                                   {
 
    return( Legendre->allocated );
}

nf_Legendre_clone()

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 ) );
}

nf_Legendre_evauluateAtMu()

double nf_Legendre_evauluateAtMu	(	nf_Legendre *	nfL,
		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 );
}

nf_Legendre_free()

nf_Legendre * nf_Legendre_free

(

nf_Legendre *

nfL

)

Definition at line 61 of file nf_Legendre.cc.

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

Referenced by nf_Legendre_from_ptwXY().

nf_Legendre_from_ptwXY()

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 );    
}

nf_Legendre_GaussianQuadrature()

nfu_status nf_Legendre_GaussianQuadrature	(	int	degree,
		double	x1,
		double	x2,
		nf_Legendre_GaussianQuadrature_callback	func,
		void *	argList,
		double *	integral )

Definition at line 63 of file nf_Legendre_GaussianQuadrature.cc.

                                                                                                                                                             {
 
    int i, n;
    double x, mu, sum, *weights, *xis;
    nfu_status status = nfu_Okay;
 
    *integral = 0;
    if( degree < 2 ) {
        status = func( 0.5 * ( x1 + x2 ), integral, argList );
        *integral *= 2.; }
    else if( degree < 4 ) {
        x = 0.5 * ( -sqrt_inv3 * ( x2 - x1 ) + x1 + x2 );
        if( ( status = func( x, integral, argList ) ) == nfu_Okay ) {
            x = 0.5 * (  sqrt_inv3 * ( x2 - x1 ) + x1 + x2 );
            status = func( x, &sum, argList );
            *integral += sum;
        } }
    else {
        for( i = 0; i < nSets - 1; i++ ) {
            if( GaussianQuadrature_degrees[i].n > ( degree + 1 ) / 2 ) break;
        }
        n = ( GaussianQuadrature_degrees[i].n + 1 ) / 2;
        weights = GaussianQuadrature_degrees[i].weights;
        xis = GaussianQuadrature_degrees[i].xis;
        for( i = 0; i < n; i++ ) {
            mu = xis[i];
            x = 0.5 * ( x1 * ( 1 - mu ) + x2 * ( mu + 1 ) );
            if( ( status = func( x, &sum, argList ) ) != nfu_Okay ) break;
            *integral += sum * weights[i];
            if( mu == 0 ) continue;
            x = x1 + x2 - x;
            if( ( status = func( x, &sum, argList ) ) != nfu_Okay ) break;
            *integral += sum * weights[i];
        }
    }
    *integral *= 0.5 * ( x2 - x1 );
    return( status );
}

Referenced by nf_Legendre_from_ptwXY().

nf_Legendre_getCl()

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] );
}

nf_Legendre_maxOrder()

int nf_Legendre_maxOrder

(

nf_Legendre *

Legendre

)

Definition at line 105 of file nf_Legendre.cc.

                                                  {
 
    return( Legendre->maxOrder );
}

nf_Legendre_new()

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 );
}

Referenced by nf_Legendre_clone(), and nf_Legendre_from_ptwXY().

nf_Legendre_normalize()

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 );
}

nf_Legendre_PofL_atMu()

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 );
}

Referenced by nf_Legendre_evauluateAtMu().

nf_Legendre_reallocateCls()

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 );
}

Referenced by nf_Legendre_setCl(), and nf_Legendre_setup().

nf_Legendre_release()

nfu_status nf_Legendre_release

(

nf_Legendre *

nfL

)

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 );
}

Referenced by nf_Legendre_free().

nf_Legendre_setCl()

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 );
}

Referenced by nf_Legendre_from_ptwXY().

nf_Legendre_setup()

nfu_status nf_Legendre_setup	(	nf_Legendre *	nfL,
		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 ) );
}

Referenced by nf_Legendre_new().

nf_Legendre_to_ptwXY()

ptwXYPoints * nf_Legendre_to_ptwXY	(	nf_Legendre *	nfL,
		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 ) );
}