ptwX.h File Reference

#include <stdio.h>
#include <stdint.h>
#include <nf_utilities.h>

Go to the source code of this file.

Data Structures
struct	ptwXPoints_s

Macros
#define	ptwX_minimumSize   10

Typedefs
typedef struct ptwXPoints_s	ptwXPoints

Enumerations
enum	ptwX_sort_order { ptwX_sort_order_descending , ptwX_sort_order_ascending }

Functions
nfu_status	ptwX_abs (ptwXPoints *ptwX)
nfu_status	ptwX_add_double (ptwXPoints *ptwX, double value)
nfu_status	ptwX_add_ptwX (ptwXPoints *ptwX1, ptwXPoints *ptwX2)
int	ptwX_ascendingOrder (ptwXPoints *ptwX)
nfu_status	ptwX_clear (ptwXPoints *ptwX)
ptwXPoints *	ptwX_clone (ptwXPoints *ptwX, nfu_status *status)
int	ptwX_close (ptwXPoints *ptwX1, ptwXPoints *ptwX2, int epsilonFactor, double epsilon, nfu_status *status)
nfu_status	ptwX_closesDifference (ptwXPoints *ptwX, double value, int64_t *index, double *difference)
nfu_status	ptwX_closesDifferenceInRange (ptwXPoints *ptwX, int64_t i1, int64_t i2, double value, int64_t *index, double *difference)
nfu_status	ptwX_compare (ptwXPoints *ptwX1, ptwXPoints *ptwX2, int *comparison)
nfu_status	ptwX_copy (ptwXPoints *dest, ptwXPoints *src)
nfu_status	ptwX_countOccurrences (ptwXPoints *ptwX, double value, int *count)
ptwXPoints *	ptwX_create (int64_t size, int64_t length, double const *xs, nfu_status *status)
ptwXPoints *	ptwX_createLine (int64_t size, int64_t length, double slope, double offset, nfu_status *status)
nfu_status	ptwX_deletePoints (ptwXPoints *ptwX, int64_t i1, int64_t i2)
ptwXPoints *	ptwX_free (ptwXPoints *ptwX)
ptwXPoints *	ptwX_fromString (char const *str, char **endCharacter, nfu_status *status)
double *	ptwX_getPointAtIndex (ptwXPoints *ptwX, int64_t index)
double	ptwX_getPointAtIndex_Unsafely (ptwXPoints *ptwX, int64_t index)
nfu_status	ptwX_insertPointsAtIndex (ptwXPoints *ptwX, int64_t index, int64_t n1, double const *xs)
int64_t	ptwX_length (ptwXPoints *ptwX)
nfu_status	ptwX_mul_double (ptwXPoints *ptwX, double value)
nfu_status	ptwX_neg (ptwXPoints *ptwX)
ptwXPoints *	ptwX_new (int64_t size, nfu_status *status)
nfu_status	ptwX_reallocatePoints (ptwXPoints *ptwX, int64_t size, int forceSmallerResize)
nfu_status	ptwX_release (ptwXPoints *ptwX)
nfu_status	ptwX_reverse (ptwXPoints *ptwX)
nfu_status	ptwX_setData (ptwXPoints *ptwX, int64_t length, double const *xs)
nfu_status	ptwX_setPointAtIndex (ptwXPoints *ptwX, int64_t index, double x)
nfu_status	ptwX_setup (ptwXPoints *ptwX, int64_t size)
void	ptwX_simplePrint (ptwXPoints const *ptwX, char const *format)
void	ptwX_simpleWrite (ptwXPoints const *ptwX, FILE *f, char const *format)
ptwXPoints *	ptwX_slice (ptwXPoints *ptwX, int64_t index1, int64_t index2, nfu_status *status)
nfu_status	ptwX_slopeOffset (ptwXPoints *ptwX, double slope, double offset)
nfu_status	ptwX_sort (ptwXPoints *ptwX, enum ptwX_sort_order order)
nfu_status	ptwX_sub_ptwX (ptwXPoints *ptwX1, ptwXPoints *ptwX2)
ptwXPoints *	ptwX_unique (ptwXPoints *ptwX, int order, nfu_status *status)
nfu_status	ptwX_xMinMax (ptwXPoints *ptwX, double *xMin, double *xMax)

Macro Definition Documentation

ptwX_minimumSize

#define ptwX_minimumSize   10

Definition at line 19 of file ptwX.h.

Typedef Documentation

ptwXPoints

typedef struct ptwXPoints_s ptwXPoints

Enumeration Type Documentation

ptwX_sort_order

enum ptwX_sort_order

Enumerator
ptwX_sort_order_descending
ptwX_sort_order_ascending

Definition at line 21 of file ptwX.h.

{ ptwX_sort_order_descending, ptwX_sort_order_ascending };

Function Documentation

ptwX_abs()

nfu_status ptwX_abs

(

ptwXPoints *

ptwX

)

Definition at line 434 of file ptwX_core.cc.

                                        {
 
    int64_t i1;
    double *p1;
 
    if( ptwX->status != nfu_Okay ) return( ptwX->status );
    for( i1 = 0, p1 = ptwX->points; i1 < ptwX->length; i1++, p1++ ) *p1 = std::fabs( *p1 );
    return( nfu_Okay );
}

References nfu_Okay, ptwXPoints_s::points, and ptwXPoints_s::status.

ptwX_add_double()

nfu_status ptwX_add_double	(	ptwXPoints *	ptwX,
		double	value
	)

Definition at line 453 of file ptwX_core.cc.

                                                             {
 
    return( ptwX_slopeOffset( ptwX, 1, value ) );
}

References ptwX_slopeOffset().

ptwX_add_ptwX()

nfu_status ptwX_add_ptwX	(	ptwXPoints *	ptwX1,
		ptwXPoints *	ptwX2
	)

Definition at line 479 of file ptwX_core.cc.

                                                                 {
 
    int64_t i1;
    double *p1 = ptwX1->points, *p2 = ptwX2->points;
 
    if( ptwX1->status != nfu_Okay ) return( ptwX1->status );
    if( ptwX2->status != nfu_Okay ) return( ptwX2->status );
    if( ptwX1->length != ptwX2->length ) return( nfu_domainsNotMutual );
 
    for( i1 = 0; i1 < ptwX1->length; i1++, p1++, p2++ ) *p1 += *p2;
    return( nfu_Okay );
}

References ptwXPoints_s::length, nfu_domainsNotMutual, nfu_Okay, ptwXPoints_s::points, and ptwXPoints_s::status.

Referenced by MCGIDI_reaction_recast().

ptwX_ascendingOrder()

int ptwX_ascendingOrder

(

ptwXPoints *

ptwX

)

Definition at line 257 of file ptwX_core.cc.

                                            {
/*
*    Returns -1 list is descending, 1 if ascending and 0 otherwise (i.e., mixed).
*/
    int order = 1;
    int64_t i;
    double x1, x2;
 
    if( ptwX->length < 2 ) return( 0 );
 
    if( ( x1 = ptwX->points[0] ) < ( x2 = ptwX->points[1] ) ) {     /* Check for ascending order. */
        for( i = 2; i < ptwX->length; i++ ) {
            x1 = x2;
            x2 = ptwX->points[i];
            if( x2 <= x1 ) return( 0 );
        } }
    else {
        if( x1 == x2 ) return( 0 );
        order = -1;                                                 /* Check for descending order. */
        for( i = 2; i < ptwX->length; i++ ) {
            x1 = x2;
            x2 = ptwX->points[i];
            if( x1 <= x2 ) return( 0 );
        }
    }
    return( order );
}

References ptwXPoints_s::length, and ptwXPoints_s::points.

ptwX_clear()

nfu_status ptwX_clear

(

ptwXPoints *

ptwX

)

Definition at line 139 of file ptwX_core.cc.

                                          {
 
    ptwX->length = 0;
    return( ptwX->status );
}

References ptwXPoints_s::length, and ptwXPoints_s::status.

Referenced by ptwX_copy().

ptwX_clone()

ptwXPoints * ptwX_clone	(	ptwXPoints *	ptwX,
		nfu_status *	status
	)

Definition at line 88 of file ptwX_core.cc.

                                                               {
 
    return( ptwX_slice( ptwX, 0, ptwX->length, status ) );
}

References ptwXPoints_s::length, and ptwX_slice().

Referenced by GIDI_settings_processedFlux::GIDI_settings_processedFlux(), MCGIDI_target_heated_recast(), GIDI_settings_processedFlux::operator=(), and ptwX_unique().

ptwX_close()

int ptwX_close	(	ptwXPoints *	ptwX1,
		ptwXPoints *	ptwX2,
		int	epsilonFactor,
		double	epsilon,
		nfu_status *	status
	)

Definition at line 553 of file ptwX_core.cc.

                                                                                                              {
 
    int64_t i1, n1 = ptwX1->length;
    double larger;
    double *p1 = ptwX1->points, *p2 = ptwX2->points;
 
    epsilon = std::fabs( epsilon ) + std::abs( epsilonFactor ) * DBL_EPSILON;
 
    *status = ptwX1->status;
    if( ptwX1->status != nfu_Okay ) return( -1 );
    *status = ptwX2->status;
    if( ptwX2->status != nfu_Okay ) return( -1 );
    *status = nfu_domainsNotMutual;
    if( n1 != ptwX2->length ) return( -1 );
 
    *status = nfu_Okay;
    for( i1 = 0; i1 < n1; i1++, p1++, p2++ ) {
        larger = std::fabs( *p1 );
        if( std::fabs( *p2 ) > larger ) larger = std::fabs( *p2 );
        if( std::fabs( *p2 - *p1 ) > epsilon * larger ) return( (int) ( i1 + 1 ) );
    }
    return( 0 );
}

References DBL_EPSILON, epsilon(), ptwXPoints_s::length, nfu_domainsNotMutual, nfu_Okay, ptwXPoints_s::points, and ptwXPoints_s::status.

ptwX_closesDifference()

nfu_status ptwX_closesDifference	(	ptwXPoints *	ptwX,
		double	value,
		int64_t *	index,
		double *	difference
	)

Definition at line 352 of file ptwX_core.cc.

                                                                                                       {
 
    return( ptwX_closesDifferenceInRange( ptwX, 0, ptwX->length, value, index, difference ) );
}

References ptwXPoints_s::length, and ptwX_closesDifferenceInRange().

ptwX_closesDifferenceInRange()

nfu_status ptwX_closesDifferenceInRange	(	ptwXPoints *	ptwX,
		int64_t	i1,
		int64_t	i2,
		double	value,
		int64_t *	index,
		double *	difference
	)

Definition at line 359 of file ptwX_core.cc.

                                                                                                                                      {
/*
*   Finds the closes datum to value. If *difference is zero, datum is same as value.
*/
    double d1;
 
    *index = -1;
    *difference = -1;
    if( ptwX->status != nfu_Okay ) return( ptwX->status );
    if( i1 < 0 ) i1 = 0;
    if( i2 > ptwX->length ) i2 = ptwX->length;
    if( i1 >= i2 ) return( nfu_Okay );
    *index = i1;
    *difference = value - ptwX->points[i1];
    for( i1++; i1 < i2; i1++ ) {
        d1 = value - ptwX->points[i1];
        if( std::fabs( *difference ) > std::fabs( d1 ) ) {
            *index = i1;
            *difference = d1;
        }
    }
    return( nfu_Okay );
}

References d1, ptwXPoints_s::length, nfu_Okay, ptwXPoints_s::points, and ptwXPoints_s::status.

Referenced by ptwX_closesDifference().

ptwX_compare()

nfu_status ptwX_compare	(	ptwXPoints *	ptwX1,
		ptwXPoints *	ptwX2,
		int *	comparison
	)

Definition at line 528 of file ptwX_core.cc.

                                                                                 {
 
    int64_t i1, n1 = ptwX1->length, n2 = ptwX2->length, nn = n1;
    double *p1 = ptwX1->points, *p2 = ptwX2->points;
 
    *comparison = 0;
    if( ptwX1->status != nfu_Okay ) return( ptwX1->status );
    if( ptwX2->status != nfu_Okay ) return( ptwX2->status );
    if( nn > n2 ) nn = n2;
    for( i1 = 0; i1 < nn; i1++, p1++, p2++ ) {
        if( *p1 == *p2 ) continue;
        *comparison = 1;
        if( *p1 < *p2 ) *comparison = -1;
        return( nfu_Okay );
    }
    if( n1 < n2 ) {
        *comparison = -1; }
    else if( n1 > n2 ) {
        *comparison = 1;
    }
    return( nfu_Okay );
}

References ptwXPoints_s::length, nfu_Okay, G4InuclParticleNames::nn, ptwXPoints_s::points, and ptwXPoints_s::status.

ptwX_copy()

nfu_status ptwX_copy	(	ptwXPoints *	dest,
		ptwXPoints *	src
	)

Definition at line 78 of file ptwX_core.cc.

                                                          {
 
    if( dest->status == nfu_Okay ) return( dest->status );
    if( src->status == nfu_Okay ) return( src->status );
    ptwX_clear( dest );
    return( ptwX_setData( dest, src->length, src->points ) );
}

References ptwXPoints_s::length, nfu_Okay, ptwXPoints_s::points, ptwX_clear(), ptwX_setData(), and ptwXPoints_s::status.

ptwX_countOccurrences()

nfu_status ptwX_countOccurrences	(	ptwXPoints *	ptwX,
		double	value,
		int *	count
	)

Definition at line 301 of file ptwX_core.cc.

                                                                               {
 
    int64_t i1;
 
    *count = 0;
    for( i1 = 0; i1 < ptwX->length; i1++ ) {
        if( ptwX->points[i1] == value ) (*count)++;
    }
    return( nfu_Okay );
}

References ptwXPoints_s::length, nfu_Okay, and ptwXPoints_s::points.

ptwX_create()

ptwXPoints * ptwX_create	(	int64_t	size,
		int64_t	length,
		double const *	xs,
		nfu_status *	status
	)

Definition at line 50 of file ptwX_core.cc.

                                                                                              {
 
    ptwXPoints *ptwX = ptwX_new( size, status );
 
    if( ptwX != NULL ) {
        if( ( *status = ptwX_setData( ptwX, length, xs ) ) != nfu_Okay ) ptwX = ptwX_free( ptwX );
    }
    return( ptwX );
}

References nfu_Okay, ptwX_free(), ptwX_new(), and ptwX_setData().

Referenced by ptwX_fromString(), and GIDI_settings_particle::setGroup().

ptwX_createLine()

ptwXPoints * ptwX_createLine	(	int64_t	size,
		int64_t	length,
		double	slope,
		double	offset,
		nfu_status *	status
	)

Definition at line 62 of file ptwX_core.cc.

                                                                                                             {
 
    int64_t i1;
    double *p1;
    ptwXPoints *ptwX;
 
    if( size < length ) size = length;
    if( ( ptwX = ptwX_new( size, status ) ) != NULL ) {
        for( i1 = 0, p1 = ptwX->points; i1 < length; i1++, p1++ ) *p1 = slope * i1 + offset;
        ptwX->length = length;
    }
    return( ptwX );
}

References ptwXPoints_s::length, ptwXPoints_s::points, and ptwX_new().

Referenced by MCGIDI_target_heated_recast(), ptwXY_groupOneFunction(), ptwXY_groupThreeFunctions(), and ptwXY_groupTwoFunctions().

ptwX_deletePoints()

nfu_status ptwX_deletePoints	(	ptwXPoints *	ptwX,
		int64_t	i1,
		int64_t	i2
	)

Definition at line 191 of file ptwX_core.cc.

                                                                         {
 
    int64_t n = ptwX->length - ( i2 - i1 );
 
    if( ptwX->status != nfu_Okay ) return( ptwX->status );
    if( ( i1 < 0 ) || ( i1 > i2 ) || ( i2 > ptwX->length ) ) return( nfu_badIndex );
    if( i1 != i2 ) {
        for( ; i2 < ptwX->length; i1++, i2++ ) ptwX->points[i1] = ptwX->points[i2];
        ptwX->length = n;
    }
    return( ptwX->status );
}

References ptwXPoints_s::length, CLHEP::detail::n, nfu_badIndex, nfu_Okay, ptwXPoints_s::points, and ptwXPoints_s::status.

ptwX_free()

ptwXPoints * ptwX_free

(

ptwXPoints *

ptwX

)

Definition at line 158 of file ptwX_core.cc.

                                          {
 
    if( ptwX != NULL ) ptwX_release( ptwX );
    return( (ptwXPoints *) nfu_free( ptwX ) );
}

References nfu_free(), and ptwX_release().

Referenced by GIDI_settings_processedFlux::GIDI_settings_processedFlux(), MCGIDI_angular_parseFromTOM(), MCGIDI_energy_parseMadlandNixFromTOM(), MCGIDI_fromTOM_pdfOfX(), MCGIDI_KalbachMann_parseFromTOM2(), MCGIDI_reaction_recast(), MCGIDI_reaction_release(), MCGIDI_target_heated_recast(), MCGIDI_target_heated_release(), GIDI_settings_processedFlux::operator=(), ptwX_create(), ptwX_unique(), ptwXY_groupOneFunction(), ptwXY_groupThreeFunctions(), ptwXY_groupTwoFunctions(), ptwXY_runningIntegral(), GIDI_settings_particle::setGroup(), GIDI_settings_particle::~GIDI_settings_particle(), and GIDI_settings_processedFlux::~GIDI_settings_processedFlux().

ptwX_fromString()

ptwXPoints * ptwX_fromString	(	char const *	str,
		char **	endCharacter,
		nfu_status *	status
	)

Definition at line 287 of file ptwX_core.cc.

                                                                                        {
 
    int64_t numberConverted;
    double  *doublePtr;
    ptwXPoints *ptwX = NULL;
 
    if( ( *status = nfu_stringToListOfDoubles( str, &numberConverted, &doublePtr, endCharacter ) ) != nfu_Okay ) return( NULL );
    ptwX = ptwX_create( numberConverted, numberConverted, doublePtr, status );
    nfu_free( doublePtr );
    return( ptwX );
}

References nfu_free(), nfu_Okay, nfu_stringToListOfDoubles(), and ptwX_create().

ptwX_getPointAtIndex()

double * ptwX_getPointAtIndex	(	ptwXPoints *	ptwX,
		int64_t	index
	)

Definition at line 206 of file ptwX_core.cc.

                                                                {
 
    if( ptwX->status != nfu_Okay ) return( NULL );
    if( ( index < 0 ) || ( index >= ptwX->length ) ) return( NULL );
    return( &(ptwX->points[index]) );
}

References ptwXPoints_s::length, nfu_Okay, ptwXPoints_s::points, and ptwXPoints_s::status.

Referenced by MCGIDI_reaction_getCrossSectionAtE(), MCGIDI_reaction_recast(), and MCGIDI_target_heated_getTotalCrossSectionAtE().

ptwX_getPointAtIndex_Unsafely()

double ptwX_getPointAtIndex_Unsafely	(	ptwXPoints *	ptwX,
		int64_t	index
	)

Definition at line 215 of file ptwX_core.cc.

                                                                        {
 
    return( ptwX->points[index] );
}

References ptwXPoints_s::points.

Referenced by MCGIDI_angular_parseFromTOM(), MCGIDI_energy_parseMadlandNixFromTOM(), MCGIDI_fromTOM_pdfOfX(), MCGIDI_KalbachMann_parseFromTOM2(), and MCGIDI_target_heated_recast().

ptwX_insertPointsAtIndex()

nfu_status ptwX_insertPointsAtIndex	(	ptwXPoints *	ptwX,
		int64_t	index,
		int64_t	n1,
		double const *	xs
	)

Definition at line 238 of file ptwX_core.cc.

                                                                                                     {
 
    nfu_status status;
    int64_t i1, i2, n1p, size = n1 + ptwX->length;
 
    if( ptwX->status != nfu_Okay ) return( ptwX->status );
    if( n1 < 1 ) return( nfu_Okay );
    if( ( index < 0 ) || ( index > ptwX->length ) ) return( nfu_badIndex );
    if( size > ptwX->allocatedSize ) {
        if( ( status = ptwX_reallocatePoints( ptwX, size, 0 ) ) != nfu_Okay ) return( status );
    }
    for( i1 = ptwX->length - 1, i2 = size - 1, n1p = ptwX->length - index + 1; n1p > 0; i1--, i2--, n1p-- ) ptwX->points[i2] = ptwX->points[i1];
    for( i1 = 0, i2 = index; i1 < n1; i1++, i2++ ) ptwX->points[i2] = xs[i1];
    ptwX->length += n1;
    return( nfu_Okay );
}

References ptwXPoints_s::allocatedSize, ptwXPoints_s::length, nfu_badIndex, nfu_Okay, ptwXPoints_s::points, ptwX_reallocatePoints(), and ptwXPoints_s::status.

ptwX_length()

int64_t ptwX_length

(

ptwXPoints *

ptwX

)

Definition at line 166 of file ptwX_core.cc.

                                        {
 
    return( ptwX->length );
}

References ptwXPoints_s::length.

Referenced by MCGIDI_target_heated_getTotalCrossSectionAtE(), ptwXY_groupOneFunction(), ptwXY_groupThreeFunctions(), ptwXY_groupTwoFunctions(), and ptwXY_intersectionWith_ptwX().

ptwX_mul_double()

nfu_status ptwX_mul_double	(	ptwXPoints *	ptwX,
		double	value
	)

Definition at line 460 of file ptwX_core.cc.

                                                             {
 
    return( ptwX_slopeOffset( ptwX, value, 0 ) );
}

References ptwX_slopeOffset().

ptwX_neg()

nfu_status ptwX_neg

(

ptwXPoints *

ptwX

)

Definition at line 446 of file ptwX_core.cc.

                                        {
 
    return( ptwX_slopeOffset( ptwX, -1, 0 ) );
}

References ptwX_slopeOffset().

ptwX_new()

ptwXPoints * ptwX_new	(	int64_t	size,
		nfu_status *	status
	)

Definition at line 24 of file ptwX_core.cc.

                                                         {
 
    ptwXPoints *ptwX = (ptwXPoints *) nfu_calloc( sizeof( ptwXPoints ), 1 );
 
    *status = nfu_mallocError;
    if( ptwX == NULL ) return( NULL );
    ptwX_setup( ptwX, size );
    if( ( *status = ptwX->status ) != nfu_Okay ) ptwX = (ptwXPoints *) nfu_free( ptwX );
    return( ptwX );
}

References nfu_calloc(), nfu_free(), nfu_mallocError, nfu_Okay, ptwX_setup(), and ptwXPoints_s::status.

Referenced by ptwX_create(), ptwX_createLine(), ptwX_slice(), ptwX_unique(), ptwXY_getXArray(), ptwXY_groupOneFunction(), ptwXY_groupThreeFunctions(), ptwXY_groupTwoFunctions(), and ptwXY_runningIntegral().

ptwX_reallocatePoints()

nfu_status ptwX_reallocatePoints	(	ptwXPoints *	ptwX,
		int64_t	size,
		int	forceSmallerResize
	)

Definition at line 116 of file ptwX_core.cc.

                                                                                           {
 
    if( size < ptwX_minimumSize ) size = ptwX_minimumSize;                        /* ptwX_minimumSize must be > 0 for other routines to work properly. */
    if( size < ptwX->length ) size = ptwX->length;
    if( size != ptwX->allocatedSize ) {
        if( size > ptwX->allocatedSize ) {                                         /* Increase size of allocated points. */
             ptwX->points = (double *) nfu_realloc( (size_t) size * sizeof( double ), ptwX->points ); }
        else if( ( ptwX->allocatedSize > 2 * size ) || forceSmallerResize ) {      /* Decrease size, if at least 1/2 size reduction or if forced to. */
            ptwX->points = (double *) nfu_realloc( (size_t) size * sizeof( double ), ptwX->points );
        }
        if( ptwX->points == NULL ) {
            ptwX->mallocFailedSize = size;
            size = 0;
            ptwX->status = nfu_mallocError;
        }
        ptwX->allocatedSize = size;
    }
 
    return( ptwX->status );
}

References ptwXPoints_s::allocatedSize, ptwXPoints_s::length, ptwXPoints_s::mallocFailedSize, nfu_mallocError, nfu_realloc(), ptwXPoints_s::points, ptwX_minimumSize, and ptwXPoints_s::status.

Referenced by ptwX_insertPointsAtIndex(), ptwX_setData(), ptwX_setPointAtIndex(), and ptwX_setup().

ptwX_release()

nfu_status ptwX_release

(

ptwXPoints *

ptwX

)

Definition at line 147 of file ptwX_core.cc.

                                            {
 
    ptwX->length = 0;
    ptwX->allocatedSize = 0;
    ptwX->points = (double *) nfu_free( ptwX->points );
 
    return( nfu_Okay );
}

References ptwXPoints_s::allocatedSize, ptwXPoints_s::length, nfu_free(), nfu_Okay, and ptwXPoints_s::points.

Referenced by ptwX_free().

ptwX_reverse()

nfu_status ptwX_reverse

(

ptwXPoints *

ptwX

)

Definition at line 314 of file ptwX_core.cc.

                                            {
 
    int64_t i1, i2 = ptwX->length - 1, n1 = ptwX->length / 2;
    double tmp;
 
    for( i1 = 0; i1 < n1; i1++, i2-- ) {
        tmp = ptwX->points[i1];
        ptwX->points[i1] = ptwX->points[i2];
        ptwX->points[i2] = tmp;
    }
    return( nfu_Okay );
}

References ptwXPoints_s::length, nfu_Okay, and ptwXPoints_s::points.

ptwX_setData()

nfu_status ptwX_setData	(	ptwXPoints *	ptwX,
		int64_t	length,
		double const *	xs
	)

Definition at line 173 of file ptwX_core.cc.

                                                                              {
 
    int64_t  i;
 
    if( ptwX->status != nfu_Okay ) return( ptwX->status );
 
    if( length > ptwX->allocatedSize ) {
        ptwX_reallocatePoints( ptwX, length, 0 );
        if( ptwX->status != nfu_Okay ) return( ptwX->status );
    }
    for( i = 0; i < length; i++ ) ptwX->points[i] = xs[i];
    ptwX->length = length;
 
    return( ptwX->status );
}

References ptwXPoints_s::allocatedSize, ptwXPoints_s::length, nfu_Okay, ptwXPoints_s::points, ptwX_reallocatePoints(), and ptwXPoints_s::status.

Referenced by ptwX_copy(), and ptwX_create().

ptwX_setPointAtIndex()

nfu_status ptwX_setPointAtIndex	(	ptwXPoints *	ptwX,
		int64_t	index,
		double	x
	)

Definition at line 222 of file ptwX_core.cc.

                                                                             {
 
    nfu_status status;
 
    if( ptwX->status != nfu_Okay ) return( ptwX->status );
    if( ( index < 0 ) || ( index > ptwX->length ) ) return( nfu_badIndex );
    if( index == ptwX->allocatedSize ) {
        if( ( status = ptwX_reallocatePoints( ptwX, ptwX->allocatedSize + 10, 0 ) ) != nfu_Okay ) return( status );
    }
    ptwX->points[index] = x;
    if( index == ptwX->length ) ptwX->length++;
    return( nfu_Okay );
}

References ptwXPoints_s::allocatedSize, ptwXPoints_s::length, nfu_badIndex, nfu_Okay, ptwXPoints_s::points, ptwX_reallocatePoints(), and ptwXPoints_s::status.

Referenced by MCGIDI_target_heated_recast(), and ptwXY_runningIntegral().

ptwX_setup()

nfu_status ptwX_setup	(	ptwXPoints *	ptwX,
		int64_t	size
	)

Definition at line 37 of file ptwX_core.cc.

                                                        {
 
    ptwX->status = nfu_Okay;
    ptwX->length = 0;
    ptwX->allocatedSize = 0;
    ptwX->mallocFailedSize = 0;
    ptwX->points = NULL;
    ptwX_reallocatePoints( ptwX, size, 0 );
    return( ptwX->status );
}

References ptwXPoints_s::allocatedSize, ptwXPoints_s::length, ptwXPoints_s::mallocFailedSize, nfu_Okay, ptwXPoints_s::points, ptwX_reallocatePoints(), and ptwXPoints_s::status.

Referenced by ptwX_new().

ptwX_simplePrint()

void ptwX_simplePrint	(	ptwXPoints const *	ptwX,
		char const *	format
	)

Definition at line 29 of file ptwX_misc.cc.

                                                                    {
 
    ptwX_simpleWrite( ptwX, stdout, format );
}

References ptwX_simpleWrite().

ptwX_simpleWrite()

void ptwX_simpleWrite	(	ptwXPoints const *	ptwX,
		FILE *	f,
		char const *	format
	)

Definition at line 19 of file ptwX_misc.cc.

                                                                             {
 
    int64_t i1;
    double *p1 = ptwX->points;
 
    for( i1 = 0; i1 < ptwX->length; ++i1, ++p1 ) fprintf( f, format, *p1 );
}

References ptwXPoints_s::length, and ptwXPoints_s::points.

Referenced by ptwX_simplePrint().

ptwX_slice()

ptwXPoints * ptwX_slice	(	ptwXPoints *	ptwX,
		int64_t	index1,
		int64_t	index2,
		nfu_status *	status
	)

Definition at line 95 of file ptwX_core.cc.

                                                                                               {
 
    int64_t i, j, length;
    ptwXPoints *n;
 
    *status = nfu_badSelf;
    if( ptwX->status != nfu_Okay ) return( NULL );
    *status = nfu_badIndex;
    if( index1 < 0 ) return( NULL );
    if( index2 < index1 ) return( NULL );
    if( index2 > ptwX->length ) return( NULL );
    length = ( index2 - index1 );
    if( ( n = ptwX_new( length, status ) ) == NULL ) return( n );
    *status = n->status;
    for( j = 0, i = index1; i < index2; i++, j++ ) n->points[j] = ptwX->points[i];
    n->length = length;
    return( n );
}

References ptwXPoints_s::length, CLHEP::detail::n, nfu_badIndex, nfu_badSelf, nfu_Okay, ptwXPoints_s::points, ptwX_new(), and ptwXPoints_s::status.

Referenced by ptwX_clone().

ptwX_slopeOffset()

nfu_status ptwX_slopeOffset	(	ptwXPoints *	ptwX,
		double	slope,
		double	offset
	)

Definition at line 467 of file ptwX_core.cc.

                                                                             {
 
    int64_t i1;
    double *p1;
 
    if( ptwX->status != nfu_Okay ) return( ptwX->status );
    for( i1 = 0, p1 = ptwX->points; i1 < ptwX->length; i1++, p1++ ) *p1 = slope * *p1 + offset;
    return( nfu_Okay );
}

References nfu_Okay, ptwXPoints_s::points, and ptwXPoints_s::status.

Referenced by ptwX_add_double(), ptwX_mul_double(), and ptwX_neg().

ptwX_sort()

nfu_status ptwX_sort	(	ptwXPoints *	ptwX,
		enum ptwX_sort_order	order
	)

Definition at line 329 of file ptwX_core.cc.

                                                                     {
 
    int (*cmp)( void const *, void const * ) = ptwX_sort_descending;
 
    if( order == ptwX_sort_order_ascending ) cmp = ptwX_sort_ascending;
    qsort( ptwX->points, (size_t) ptwX->length, sizeof( ptwX->points[0] ), cmp );
    return( nfu_Okay );
}

References ptwXPoints_s::length, nfu_Okay, ptwXPoints_s::points, ptwX_sort_ascending(), ptwX_sort_descending(), and ptwX_sort_order_ascending.

Referenced by ptwX_unique().

ptwX_sub_ptwX()

nfu_status ptwX_sub_ptwX	(	ptwXPoints *	ptwX1,
		ptwXPoints *	ptwX2
	)

Definition at line 494 of file ptwX_core.cc.

                                                                 {
 
    int64_t i1;
    double *p1 = ptwX1->points, *p2 = ptwX2->points;
 
    if( ptwX1->status != nfu_Okay ) return( ptwX1->status );
    if( ptwX2->status != nfu_Okay ) return( ptwX2->status );
    if( ptwX1->length != ptwX2->length ) return( nfu_domainsNotMutual );
 
    for( i1 = 0; i1 < ptwX1->length; i1++, p1++, p2++ ) *p1 -= *p2;
    return( nfu_Okay );
}

References ptwXPoints_s::length, nfu_domainsNotMutual, nfu_Okay, ptwXPoints_s::points, and ptwXPoints_s::status.

ptwX_unique()

ptwXPoints * ptwX_unique	(	ptwXPoints *	ptwX,
		int	order,
		nfu_status *	status
	)

Definition at line 385 of file ptwX_core.cc.

                                                                           {
/*
*   If order < 0 order is descending, if order > 0 order is ascending, otherwise, order is the same as ptwX.
*/
    int64_t i1, i2, n1 = 0;
    double x1, *p2;
    ptwXPoints *ptwX2 = NULL;
 
    if( order == 0 ) {
        if( ( ptwX2 = ptwX_new( ptwX->length, status ) ) == NULL ) return( NULL );
        for( i1 = 0; i1 < ptwX->length; i1++ ) {
            x1 = ptwX->points[i1];
            for( i2 = 0, p2 = ptwX2->points; i2 < ptwX2->length; i2++, p2++ ) {
                if( *p2 == x1 ) break;
            }
            if( i2 == ptwX2->length ) {
                ptwX2->points[ptwX2->length] = x1;
                ptwX2->length++;
            }
        } }
    else {
        if( ( ptwX2 = ptwX_clone( ptwX, status ) ) == NULL ) return( NULL );
        if( ( *status = ptwX_sort( ptwX2, ptwX_sort_order_ascending ) ) != nfu_Okay ) goto err;
 
        if( ptwX2->length > 1 ) {
            x1 = ptwX2->points[n1];
            n1++;
            for( i1 = 1; i1 < ptwX2->length; i1++ ) {
                if( x1 != ptwX2->points[i1] ) {
                    x1 = ptwX2->points[i1];
                    ptwX2->points[n1] = x1;
                    n1++;
                }
            }
            ptwX2->length = n1;
            if( order < 0 ) {
                if( ( *status = ptwX_sort( ptwX2, ptwX_sort_order_descending ) ) != nfu_Okay ) goto err;
            }
        }
    }
    return( ptwX2 );
 
err:
    if( ptwX2 != NULL ) ptwX_free( ptwX2 );
    return( NULL );
}

References ptwXPoints_s::length, nfu_Okay, ptwXPoints_s::points, ptwX_clone(), ptwX_free(), ptwX_new(), ptwX_sort(), ptwX_sort_order_ascending, and ptwX_sort_order_descending.

ptwX_xMinMax()

nfu_status ptwX_xMinMax	(	ptwXPoints *	ptwX,
		double *	xMin,
		double *	xMax
	)

Definition at line 509 of file ptwX_core.cc.

                                                                        {
 
    int64_t i1, n1 = ptwX->length;
    *xMin = *xMax = 0;
    double *p1 = ptwX->points;
 
    if( ptwX->status != nfu_Okay ) return( ptwX->status );
    if( n1 > 0 ) {
        *xMin = *xMax = *(p1++);
        for( i1 = 1; i1 < n1; ++i1, ++p1 ) {
            if( *p1 < *xMin ) *xMin = *p1;
            if( *p1 > *xMax ) *xMax = *p1;
        }
    }
    return( nfu_Okay );
}

References ptwXPoints_s::length, nfu_Okay, ptwXPoints_s::points, and ptwXPoints_s::status.