ptwXY_core.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include "ptwXY.h"

Go to the source code of this file.

Functions
ptwXYPoints *	ptwXY_new (statusMessageReporting *smr, ptwXY_interpolation interpolation, char const *interpolationString, double biSectionMax, double accuracy, int64_t primarySize, int64_t secondarySize, int userFlag)
ptwXYPoints *	ptwXY_new2 (statusMessageReporting *smr, ptwXY_interpolation interpolation, int64_t primarySize, int64_t secondarySize)
nfu_status	ptwXY_initialize (statusMessageReporting *smr, ptwXYPoints *ptwXY, ptwXY_interpolation interpolation, char const *interpolationString, double biSectionMax, double accuracy, int64_t primarySize, int64_t secondarySize, int userFlag)
ptwXYPoints *	ptwXY_create (statusMessageReporting *smr, ptwXY_interpolation interpolation, char const *interpolationString, double biSectionMax, double accuracy, int64_t primarySize, int64_t secondarySize, int64_t length, double const *xy, int userFlag)
ptwXYPoints *	ptwXY_create2 (statusMessageReporting *smr, ptwXY_interpolation interpolation, int64_t primarySize, int64_t secondarySize, int64_t length, double const *xy, int userFlag)
ptwXYPoints *	ptwXY_createFrom_Xs_Ys (statusMessageReporting *smr, ptwXY_interpolation interpolation, char const *interpolationString, double biSectionMax, double accuracy, int64_t primarySize, int64_t secondarySize, int64_t length, double const *Xs, double const *Ys, int userFlag)
ptwXYPoints *	ptwXY_createFrom_Xs_Ys2 (statusMessageReporting *smr, ptwXY_interpolation interpolation, int64_t primarySize, int64_t secondarySize, int64_t length, double const *Xs, double const *Ys, int userFlag)
nfu_status	ptwXY_copy (statusMessageReporting *smr, ptwXYPoints *dest, ptwXYPoints *src)
nfu_status	ptwXY_copyPointsOnly (statusMessageReporting *smr, ptwXYPoints *dest, ptwXYPoints *src)
ptwXYPoints *	ptwXY_clone (statusMessageReporting *smr, ptwXYPoints *ptwXY)
ptwXYPoints *	ptwXY_clone2 (statusMessageReporting *smr, ptwXYPoints const *ptwXY)
ptwXYPoints *	ptwXY_cloneToInterpolation (statusMessageReporting *smr, ptwXYPoints *ptwXY, ptwXY_interpolation interpolationTo)
ptwXYPoints *	ptwXY_slice (statusMessageReporting *smr, ptwXYPoints *ptwXY, int64_t index1, int64_t index2, int64_t secondarySize)
ptwXYPoints *	ptwXY_domainSlice (statusMessageReporting *smr, ptwXYPoints *ptwXY, double domainMin, double domainMax, int64_t secondarySize, int fill)
ptwXYPoints *	ptwXY_domainMinSlice (statusMessageReporting *smr, ptwXYPoints *ptwXY, double domainMin, int64_t secondarySize, int fill)
ptwXYPoints *	ptwXY_domainMaxSlice (statusMessageReporting *smr, ptwXYPoints *ptwXY, double domainMax, int64_t secondarySize, int fill)
ptwXY_interpolation	ptwXY_getInterpolation (ptwXYPoints *ptwXY)
char const *	ptwXY_getInterpolationString (ptwXYPoints *ptwXY)
nfu_status	ptwXY_setInterpolationString (ptwXYPoints *ptwXY, char const *interpolationString)
nfu_status	ptwXY_getStatus (ptwXYPoints *ptwXY)
int	ptwXY_getUserFlag (ptwXYPoints *ptwXY)
void	ptwXY_setUserFlag (ptwXYPoints *ptwXY, int userFlag)
double	ptwXY_getAccuracy (ptwXYPoints *ptwXY)
double	ptwXY_setAccuracy (ptwXYPoints *ptwXY, double accuracy)
double	ptwXY_getBiSectionMax (ptwXYPoints *ptwXY)
double	ptwXY_setBiSectionMax (ptwXYPoints *ptwXY, double biSectionMax)
nfu_status	ptwXY_reallocatePoints (statusMessageReporting *smr, ptwXYPoints *ptwXY, int64_t size, int forceSmallerResize)
nfu_status	ptwXY_reallocateOverflowPoints (statusMessageReporting *smr, ptwXYPoints *ptwXY, int64_t size)
nfu_status	ptwXY_coalescePoints (statusMessageReporting *smr, ptwXYPoints *ptwXY, int64_t size, ptwXYPoint *newPoint, int forceSmallerResize)
nfu_status	ptwXY_simpleCoalescePoints (statusMessageReporting *smr, ptwXYPoints *ptwXY)
nfu_status	ptwXY_clear (statusMessageReporting *smr, ptwXYPoints *ptwXY)
nfu_status	ptwXY_release (statusMessageReporting *smr, ptwXYPoints *ptwXY)
ptwXYPoints *	ptwXY_free (ptwXYPoints *ptwXY)
int64_t	ptwXY_length (statusMessageReporting *smr, ptwXYPoints *ptwXY)
int64_t	ptwXY_getNonOverflowLength (statusMessageReporting *smr, ptwXYPoints const *ptwXY)
nfu_status	ptwXY_startIndex (statusMessageReporting *a_smr, ptwXYPoints *a_ptwXY, double a_x, int64_t *a_startIndex, int64_t *a_length)
nfu_status	ptwXY_setXYData (statusMessageReporting *smr, ptwXYPoints *ptwXY, int64_t length, double const *xy)
nfu_status	ptwXY_setXYDataFromXsAndYs (statusMessageReporting *smr, ptwXYPoints *ptwXY, int64_t length, double const *x, double const *y)
nfu_status	ptwXY_deletePoints (statusMessageReporting *smr, ptwXYPoints *ptwXY, int64_t i1, int64_t i2)
nfu_status	ptwXY_getLowerIndexBoundingX (statusMessageReporting *smr, ptwXYPoints *ptwXY, double x, int64_t *index)
ptwXYPoint *	ptwXY_getPointAtIndex (statusMessageReporting *smr, ptwXYPoints *ptwXY, int64_t index)
ptwXYPoint *	ptwXY_getPointAtIndex_Unsafely (ptwXYPoints const *ptwXY, int64_t index)
nfu_status	ptwXY_getXYPairAtIndex (statusMessageReporting *smr, ptwXYPoints *ptwXY, int64_t index, double *x, double *y)
ptwXY_lessEqualGreaterX	ptwXY_getPointsAroundX (statusMessageReporting *smr, ptwXYPoints *ptwXY, double x, ptwXYOverflowPoint *lessThanEqualXPoint, ptwXYOverflowPoint *greaterThanXPoint)
ptwXY_lessEqualGreaterX	ptwXY_getPointsAroundX_closeIsEqual (statusMessageReporting *smr, ptwXYPoints *ptwXY, double x, ptwXYOverflowPoint *lessThanEqualXPoint, ptwXYOverflowPoint *greaterThanXPoint, double eps, int *closeIsEqual, ptwXYPoint **closePoint)
nfu_status	ptwXY_getValueAtX (statusMessageReporting *smr, ptwXYPoints *ptwXY, double x, double *y)
nfu_status	ptwXY_setValueAtX (statusMessageReporting *smr, ptwXYPoints *ptwXY, double x, double y)
nfu_status	ptwXY_setValueAtX_overrideIfClose (statusMessageReporting *smr, ptwXYPoints *ptwXY, double x, double y, double eps, int override)
nfu_status	ptwXY_mergeFromXsAndYs (statusMessageReporting *smr, ptwXYPoints *ptwXY, int length, double *xs, double *ys)
nfu_status	ptwXY_mergeFromXYs (statusMessageReporting *smr, ptwXYPoints *ptwXY, int length, double *xys)
nfu_status	ptwXY_appendXY (statusMessageReporting *smr, ptwXYPoints *ptwXY, double x, double y)
nfu_status	ptwXY_setXYPairAtIndex (statusMessageReporting *smr, ptwXYPoints *ptwXY, int64_t index, double x, double y)
nfu_status	ptwXY_getSlopeAtX (statusMessageReporting *smr, ptwXYPoints *ptwXY, double x, const char side, double *slope)
nfu_status	ptwXY_domainMinAndFrom (statusMessageReporting *smr, ptwXYPoints *ptwXY, ptwXY_dataFrom *dataFrom, double *domainMin)
nfu_status	ptwXY_domainMin (statusMessageReporting *smr, ptwXYPoints *ptwXY, double *domainMin)
nfu_status	ptwXY_domainMaxAndFrom (statusMessageReporting *smr, ptwXYPoints *ptwXY, ptwXY_dataFrom *dataFrom, double *domainMax)
nfu_status	ptwXY_domainMax (statusMessageReporting *smr, ptwXYPoints *ptwXY, double *domainMax)
nfu_status	ptwXY_range (statusMessageReporting *smr, ptwXYPoints *ptwXY, double *rangeMin, double *rangeMax)
nfu_status	ptwXY_rangeMin (statusMessageReporting *smr, ptwXYPoints *ptwXY, double *rangeMin)
nfu_status	ptwXY_rangeMax (statusMessageReporting *smr, ptwXYPoints *ptwXY, double *rangeMax)
char const *	ptwXY_interpolationToString (ptwXY_interpolation interpolation)
ptwXY_interpolation	ptwXY_stringToInterpolation (char const *interpolationString)

Function Documentation

ptwXY_appendXY()

nfu_status ptwXY_appendXY	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		double	x,
		double	y )

Definition at line 1432 of file ptwXY_core.c.

                                                                                                 {
 
    int64_t nonOverflowLength = ptwXY_getNonOverflowLength( smr, ptwXY );
    ptwXY_dataFrom dataFrom;
 
    if( nonOverflowLength < 0 ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( nfu_Error );
    }
 
    if( ptwXY->length != 0 ) {
        double domainMax;
        nfu_status status;
 
        if( ( status = ptwXY_domainMaxAndFrom( smr, ptwXY, &dataFrom, &domainMax ) ) != nfu_Okay ) {
            smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
            return( status );
        }
        if( domainMax >= x ) {
            smr_setReportError2( smr, nfu_SMR_libraryID, nfu_XNotAscending, "domainMax = %17.e >= x = %.17e", domainMax, x );
            return( ptwXY->status = nfu_XNotAscending );
        }
    }
 
    if( nonOverflowLength < ptwXY->allocatedSize ) {      /* Room at end of points. Also handles the case when length = 0. */
        ptwXY->points[nonOverflowLength].x = x;
        ptwXY->points[nonOverflowLength].y = y; }
    else {
        if( ptwXY->overflowLength == ptwXY->overflowAllocatedSize ) {
            ptwXYPoint newPoint = { x, y };
            if( ptwXY_coalescePoints( smr, ptwXY, ptwXY->length + ptwXY->overflowAllocatedSize, &newPoint, 0 ) != nfu_Okay ) {
                smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
                return( ptwXY->status ); } }
        else {                                              /* Add to end of overflow. */
            ptwXYOverflowPoint *overflowPoint = &(ptwXY->overflowPoints[ptwXY->overflowLength]);
 
            overflowPoint->prior = ptwXY->overflowHeader.prior;
            overflowPoint->next = overflowPoint->prior->next;
            overflowPoint->index = ptwXY->length;
            overflowPoint->prior->next = overflowPoint;
            overflowPoint->next->prior = overflowPoint;
            overflowPoint->point.x = x;
            overflowPoint->point.y = y;
            ptwXY->overflowLength++;
        }
    }
    ptwXY->length++;
    return( nfu_Okay );
}

ptwXY_clear()

nfu_status ptwXY_clear	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY )

Definition at line 743 of file ptwXY_core.c.

                                                                          {
 
    if( ptwXY->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Invalid source." );
        return( ptwXY->status );
    }
 
    ptwXY->length = 0;
    ptwXY->overflowLength = 0;
    ptwXY->overflowHeader.prior = &(ptwXY->overflowHeader);
    ptwXY->overflowHeader.next = &(ptwXY->overflowHeader);
    return( nfu_Okay );
}

Referenced by ptwXY_clip(), ptwXY_copy(), ptwXY_copyPointsOnly(), and ptwXY_setXYDataFromXsAndYs().

ptwXY_clone()

ptwXYPoints * ptwXY_clone	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY )

Definition at line 302 of file ptwXY_core.c.

                                                                            {
 
    ptwXYPoints *ptwXY2 = ptwXY_slice( smr, ptwXY, 0, ptwXY->length, ptwXY->overflowAllocatedSize );
 
    if( ptwXY2 == NULL ) smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
    return( ptwXY2 );
}

Referenced by ptwXY_add_ptwXY(), ptwXY_cloneToInterpolation(), ptwXY_domainSlice(), ptwXY_fromUnitbase(), ptwXY_intersectionWith_ptwX(), ptwXY_mul_ptwXY(), ptwXY_sub_ptwXY(), ptwXY_thin(), ptwXY_thinDomain(), ptwXY_toOtherInterpolation(), ptwXY_toUnitbase(), and ptwXY_unitbaseInterpolate().

ptwXY_clone2()

ptwXYPoints * ptwXY_clone2	(	statusMessageReporting *	smr,
		ptwXYPoints const *	ptwXY )

Definition at line 312 of file ptwXY_core.c.

                                                                                   {
 
    int64_t length = ptwXY->length;
    ptwXYPoints *ptwXY2 = NULL;
    ptwXYPoint *pointsFrom, *pointsTo;
    ptwXYOverflowPoint *last = ptwXY->overflowHeader.prior;
 
    if( ptwXY->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Invalid source." );
        return( NULL );
    }
 
    ptwXY2 = ptwXY_new( smr, ptwXY->interpolation, ptwXY->interpolationString,
            ptwXY->biSectionMax, ptwXY->accuracy, length, ptwXY->overflowAllocatedSize, ptwXY->userFlag );
    if( ptwXY2 == NULL ) smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
 
    pointsFrom = &(ptwXY->points[ptwXY_getNonOverflowLength( smr, ptwXY ) - 1]);
    pointsTo = &(ptwXY2->points[length - 1]);
    while( last != &(ptwXY->overflowHeader) ) {
        if( ( pointsFrom >= ptwXY->points ) && ( pointsFrom->x > last->point.x ) ) {
            *pointsTo = *pointsFrom;
            --pointsFrom; }
        else {
            *pointsTo = last->point;
            last = last->prior;
        }
        --pointsTo;
    }
 
    for( ; pointsFrom >= ptwXY->points; --pointsFrom, --pointsTo ) *pointsTo = *pointsFrom;
    ptwXY2->length = length;
 
    return( ptwXY2 );
}

Referenced by GIDI::Functions::XYs1d::domainSlice(), GIDI::Functions::XYs1d::domainSliceMax(), GIDI::multiGroupTwoXYs1ds(), GIDI::multiGroupXYs1d(), GIDI::Functions::XYs1d::operator=(), and GIDI::Functions::XYs1d::XYs1d().

ptwXY_cloneToInterpolation()

ptwXYPoints * ptwXY_cloneToInterpolation	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		ptwXY_interpolation	interpolationTo )

Definition at line 349 of file ptwXY_core.c.

                                                                                                                                {
 
    ptwXYPoints *n1;
 
    if( ptwXY->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Invalid source." );
        return( NULL );
    }
 
/* Other interpolation should probably be allowed. */
    if( interpolationTo == ptwXY_interpolationOther ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_otherInterpolation, "Other interpolation not allowed." );
        return( NULL );
    }
    if( ( n1 = ptwXY_clone( smr, ptwXY ) ) == NULL ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." ); }
    else {
        if( n1->interpolation == ptwXY_interpolationOther ) smr_freeMemory2( n1->interpolationString );
        n1->interpolation = interpolationTo;
        switch( interpolationTo ) {
            case ptwXY_interpolationLinLin :
                n1->interpolationString = linLinInterpolationString; break;
            case ptwXY_interpolationLogLin :
                n1->interpolationString = logLinInterpolationString; break;
            case ptwXY_interpolationLinLog :
                n1->interpolationString = linLogInterpolationString; break;
            case ptwXY_interpolationLogLog :
                n1->interpolationString = logLogInterpolationString; break;
            case ptwXY_interpolationFlat :
                n1->interpolationString = flatInterpolationString; break;
            case ptwXY_interpolationOther :     /* Does not happen, but needed to stop compilers from complaining. */
                break;
        }
    }
    return( n1 );
}

Referenced by ptwXY_toOtherInterpolation().

ptwXY_coalescePoints()

nfu_status ptwXY_coalescePoints	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		int64_t	size,
		ptwXYPoint *	newPoint,
		int	forceSmallerResize )

Definition at line 667 of file ptwXY_core.c.

                                                       {
 
    int addNewPoint;
    int64_t length = ptwXY->length + ( ( newPoint != NULL ) ? 1 : 0 );
    ptwXYOverflowPoint *last = ptwXY->overflowHeader.prior;
    ptwXYPoint *pointsFrom, *pointsTo;
 
    if( ptwXY->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Invalid source." );
        return( ptwXY->status );
    }
    if( ptwXY->overflowLength == 0 ) return( nfu_Okay );
 
    if( size < length ) size = length;
    if( size > ptwXY->allocatedSize ) {
        if( ptwXY_reallocatePoints( smr, ptwXY, size, forceSmallerResize ) != nfu_Okay ) {
            smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
            return( ptwXY->status );
        }
    }
    pointsFrom = &(ptwXY->points[ptwXY_getNonOverflowLength( smr, ptwXY ) - 1]);
    pointsTo = &(ptwXY->points[length - 1]);
    while( last != &(ptwXY->overflowHeader) ) {
        addNewPoint = 0;
        if( newPoint != NULL ) {
            if( ( pointsFrom >= ptwXY->points ) && ( pointsFrom->x > last->point.x ) ) {
                if( newPoint->x > pointsFrom->x ) addNewPoint = 1; }
            else {
                if( newPoint->x > last->point.x ) addNewPoint = 1;
            }
            if( addNewPoint == 1 ) {
                *pointsTo = *newPoint;
                newPoint = NULL;
            }
        }
        if( addNewPoint == 0 ) {
            if( ( pointsFrom >= ptwXY->points ) && ( pointsFrom->x > last->point.x ) ) {
                *pointsTo = *pointsFrom;
                pointsFrom--; }
            else {
                *pointsTo = last->point;
                last = last->prior;
            }
        }
        pointsTo--;
    }
    while( ( newPoint != NULL ) && ( pointsFrom >= ptwXY->points ) ) {
        if( newPoint->x > pointsFrom->x ) {
            *pointsTo = *newPoint;
             newPoint = NULL; }
         else {
            *pointsTo = *pointsFrom;
            pointsFrom--;
         }
         pointsTo--;
    }
    if( newPoint != NULL ) *pointsTo = *newPoint;
    ptwXY->overflowHeader.prior = &(ptwXY->overflowHeader);
    ptwXY->overflowHeader.next = &(ptwXY->overflowHeader);
    ptwXY->length = length;
    ptwXY->overflowLength = 0;
    return( nfu_Okay );
}

Referenced by ptwXY_appendXY(), ptwXY_createGaussianCenteredSigma1(), ptwXY_domainSlice(), ptwXY_reallocateOverflowPoints(), ptwXY_setValueAtX_overrideIfClose(), and ptwXY_simpleCoalescePoints().

ptwXY_copy()

nfu_status ptwXY_copy	(	statusMessageReporting *	smr,
		ptwXYPoints *	dest,
		ptwXYPoints *	src )

Definition at line 171 of file ptwXY_core.c.

                                                                                          {
 
    int64_t i, nonOverflowLength;
    ptwXYPoint *pointFrom, *pointTo;
    ptwXYOverflowPoint *o, *overflowHeader = &(src->overflowHeader);
 
    if( dest->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Invalid destination." );
        return( dest->status );
    }
    if( src->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Invalid source." );
        return( src->status );
    }
 
    nonOverflowLength = ptwXY_getNonOverflowLength( smr, src );     /* No need to check return value. */
 
    if( ptwXY_clear( smr, dest ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( dest->status );
    }
    if( dest->interpolation == ptwXY_interpolationOther ) {
        if( dest->interpolationString != NULL ) {
            dest->interpolationString = (char const *) smr_freeMemory2( dest->interpolationString );
        }
    }
    dest->interpolation = ptwXY_interpolationLinLin; /* This and prior lines are in case interpolation is 'other' and ptwXY_reallocatePoints fails. */
    if( dest->allocatedSize < src->length ) {
        if( ptwXY_reallocatePoints( smr, dest, src->length, 0 ) != nfu_Okay ) {
            smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
            return( dest->status );
        }
    }
    if( dest->status != nfu_Okay ) return( dest->status );
    dest->interpolation = src->interpolation;
    if( dest->interpolation == ptwXY_interpolationOther ) {
        if( src->interpolationString != NULL ) {
            if( ( dest->interpolationString = smr_allocateCopyString2( smr, src->interpolationString, "interpolationString" ) ) == NULL ) {
                smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
                return( dest->status = nfu_Error );
            }
        } }
    else {
        dest->interpolationString = src->interpolationString;
    }
    dest->userFlag = src->userFlag;
    dest->biSectionMax = src->biSectionMax;
    dest->accuracy = src->accuracy;
    dest->minFractional_dx = src->minFractional_dx;
    pointFrom = src->points;
    o = src->overflowHeader.next;
    pointTo = dest->points;
    i = 0;
    while( o != overflowHeader ) {
        if( i < nonOverflowLength ) {
            if( pointFrom->x < o->point.x ) {
                *pointTo = *pointFrom;
                i++;
                pointFrom++; }
            else {
                *pointTo = o->point;
                o = o->next;
            } }
        else {
            *pointTo = o->point;
            o = o->next;
        }
        pointTo++;
    }
    for( ; i < nonOverflowLength; i++, pointFrom++, pointTo++ ) *pointTo = *pointFrom;
    dest->length = src->length;
    return( dest->status );
}

Referenced by ptwXY_scaleAndOffsetDomainWith_ptwXYs().

ptwXY_copyPointsOnly()

nfu_status ptwXY_copyPointsOnly	(	statusMessageReporting *	smr,
		ptwXYPoints *	dest,
		ptwXYPoints *	src )

Definition at line 247 of file ptwXY_core.c.

                                                                                                    {
 
    int64_t i, nonOverflowLength;
    ptwXYPoint *pointFrom, *pointTo;
    ptwXYOverflowPoint *o, *overflowHeader = &(src->overflowHeader);
 
    if( dest->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Invalid destination." );
        return( dest->status );
    }
    if( src->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Invalid source." );
        return( src->status );
    }
 
    nonOverflowLength = ptwXY_getNonOverflowLength( smr, src );     /* No need to check return value. */
 
    if( ptwXY_clear( smr, dest ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( dest->status );
    }
 
    if( dest->allocatedSize < src->length ) {
        if( ptwXY_reallocatePoints( smr, dest, src->length, 0 ) != nfu_Okay ) {
            smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
            return( dest->status );
        }
    }
    pointFrom = src->points;
    o = src->overflowHeader.next;
    pointTo = dest->points;
    i = 0;
    while( o != overflowHeader ) {
        if( i < nonOverflowLength ) {
            if( pointFrom->x < o->point.x ) {
                *pointTo = *pointFrom;
                i++;
                pointFrom++; }
            else {
                *pointTo = o->point;
                o = o->next;
            } }
        else {
            *pointTo = o->point;
            o = o->next;
        }
        pointTo++;
    }
    for( ; i < nonOverflowLength; i++, pointFrom++, pointTo++ ) *pointTo = *pointFrom;
    dest->length = src->length;
    return( dest->status );
}

ptwXY_create()

ptwXYPoints * ptwXY_create	(	statusMessageReporting *	smr,
		ptwXY_interpolation	interpolation,
		char const *	interpolationString,
		double	biSectionMax,
		double	accuracy,
		int64_t	primarySize,
		int64_t	secondarySize,
		int64_t	length,
		double const *	xy,
		int	userFlag )

Definition at line 110 of file ptwXY_core.c.

                   {
 
    ptwXYPoints *ptwXY;
 
    if( primarySize < length ) primarySize = length;
    if( ( ptwXY = ptwXY_new( smr, interpolation, interpolationString, biSectionMax, accuracy, primarySize, 
            secondarySize, userFlag ) ) != NULL ) {
        if( ptwXY_setXYData( smr, ptwXY, length, xy ) != nfu_Okay ) ptwXY = ptwXY_free( ptwXY );
    }
 
    if( ptwXY == NULL ) smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
    return( ptwXY );
}

Referenced by ptwXY_create2(), ptwXY_fromString(), and GIDI::Functions::XYs1d::XYs1d().

ptwXY_create2()

ptwXYPoints * ptwXY_create2	(	statusMessageReporting *	smr,
		ptwXY_interpolation	interpolation,
		int64_t	primarySize,
		int64_t	secondarySize,
		int64_t	length,
		double const *	xy,
		int	userFlag )

Definition at line 128 of file ptwXY_core.c.

                                                                                                     {
 
    char const *interpolationString = ptwXY_interpolationToString( interpolation );
 
    return( ptwXY_create( smr, interpolation, interpolationString, 12, 1e-3, primarySize, secondarySize, length, xy, userFlag ) );
}

Referenced by GIDI::Functions::XYs1d::XYs1d(), GIDI::Functions::XYs1d::XYs1d(), and GIDI::Functions::XYs1d::XYs1d().

ptwXY_createFrom_Xs_Ys()

ptwXYPoints * ptwXY_createFrom_Xs_Ys	(	statusMessageReporting *	smr,
		ptwXY_interpolation	interpolation,
		char const *	interpolationString,
		double	biSectionMax,
		double	accuracy,
		int64_t	primarySize,
		int64_t	secondarySize,
		int64_t	length,
		double const *	Xs,
		double const *	Ys,
		int	userFlag )

Definition at line 138 of file ptwXY_core.c.

                                     {
 
    int i;
    ptwXYPoints *ptwXY;
 
    if( primarySize < length ) primarySize = length;
    if( ( ptwXY = ptwXY_new( smr, interpolation, interpolationString, biSectionMax, accuracy, primarySize, 
            secondarySize, userFlag ) ) != NULL ) {
        for( i = 0; i < length; i++ ) {
            ptwXY->points[i].x = Xs[i];
            ptwXY->points[i].y = Ys[i];
        }
        ptwXY->length = length;
    }
 
    if( ptwXY == NULL ) smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
    return( ptwXY );
}

Referenced by GIDI::multiGroupXYs1d(), GIDI::Transporting::Flux::process(), and ptwXY_createFrom_Xs_Ys2().

ptwXY_createFrom_Xs_Ys2()

ptwXYPoints * ptwXY_createFrom_Xs_Ys2	(	statusMessageReporting *	smr,
		ptwXY_interpolation	interpolation,
		int64_t	primarySize,
		int64_t	secondarySize,
		int64_t	length,
		double const *	Xs,
		double const *	Ys,
		int	userFlag )

Definition at line 161 of file ptwXY_core.c.

                                                                                              {
 
    char const *interpolationString = ptwXY_interpolationToString( interpolation );
 
    return( ptwXY_createFrom_Xs_Ys( smr, interpolation, interpolationString, 12, 1e-3, primarySize, secondarySize, length, Xs, Ys, userFlag ) );
}

Referenced by GIDI::Functions::XYs1d::XYs1d().

ptwXY_deletePoints()

nfu_status ptwXY_deletePoints	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		int64_t	i1,
		int64_t	i2 )

Definition at line 943 of file ptwXY_core.c.

                                                                                                         {
 
    int64_t n = ptwXY->length - ( i2 - i1 );
 
    if( ptwXY_simpleCoalescePoints( smr, ptwXY ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( ptwXY->status );
    }
 
    if( ( i1 < 0 ) || ( i2 < i1 ) || ( i2 > ptwXY->length ) ) {
        smr_setReportError2( smr, nfu_SMR_libraryID, nfu_badIndex, "Indices = %d, %d out of bounds: length = %d",
                (int) i1, (int) i2, (int) ptwXY->length );
        return( ptwXY->status = nfu_badIndex );
    }
 
    if( i1 != i2 ) {
        for( ; i2 < ptwXY->length; i1++, i2++ ) ptwXY->points[i1] = ptwXY->points[i2];
        ptwXY->length = n;
    }
    return( ptwXY->status );
}

ptwXY_domainMax()

nfu_status ptwXY_domainMax	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		double *	domainMax )

Definition at line 1668 of file ptwXY_core.c.

                                                                                                 {
 
    ptwXY_dataFrom dataFrom;
    nfu_status status;
 
    if( ( status = ptwXY_domainMaxAndFrom( smr, ptwXY, &dataFrom, domainMax ) ) != nfu_Okay ) {
        if( status == nfu_empty ) return( status );
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( nfu_Error );
    }
    return( nfu_Okay );
}

Referenced by GIDI::multiGroupTwoXYs1ds(), ptwXY_binary_ptwXY(), ptwXY_div_ptwXY(), ptwXY_domainMinSlice(), ptwXY_domainSlice(), ptwXY_integrateDomain(), ptwXY_integrateDomainWithWeight_sqrt_x(), ptwXY_integrateDomainWithWeight_x(), and ptwXY_scaleAndOffsetDomainWith_ptwXYs().

ptwXY_domainMaxAndFrom()

nfu_status ptwXY_domainMaxAndFrom	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		ptwXY_dataFrom *	dataFrom,
		double *	domainMax )

Definition at line 1636 of file ptwXY_core.c.

                                                                                                                                  {
 
    int64_t nonOverflowLength = ptwXY_getNonOverflowLength( smr, ptwXY );
 
    *domainMax  = 0;
    *dataFrom = ptwXY_dataFrom_Unknown;
 
    if( nonOverflowLength < 0 ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( nfu_Error );
    }
 
    if( ptwXY->overflowLength > 0 ) {
        *dataFrom = ptwXY_dataFrom_Overflow;
        *domainMax = ptwXY->overflowHeader.prior->point.x;
        if( ( nonOverflowLength > 0 ) ) {
            if( *domainMax < ptwXY->points[nonOverflowLength-1].x ) {
                *dataFrom = ptwXY_dataFrom_Points;
                *domainMax = ptwXY->points[nonOverflowLength-1].x;
            }
        } }
    else if( ptwXY->length > 0 ) {
        *dataFrom = ptwXY_dataFrom_Points;
        *domainMax = ptwXY->points[nonOverflowLength-1].x; }
    else {
        return( nfu_empty );
    }
    return( nfu_Okay );
}

Referenced by ptwXY_appendXY(), ptwXY_domainMax(), and ptwXY_getPointsAroundX_closeIsEqual().

ptwXY_domainMaxSlice()

ptwXYPoints * ptwXY_domainMaxSlice	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		double	domainMax,
		int64_t	secondarySize,
		int	fill )

Definition at line 499 of file ptwXY_core.c.

                                                                                                                                        {
 
    double domainMin = 0.9 * domainMax - 1;
    ptwXYPoints *ptwXY2;
 
    if( domainMax < 0 ) domainMin = 1.1 * domainMax - 1;
    if( ptwXY->length > 0 ) {
        if( ptwXY_domainMin( smr, ptwXY, &domainMin ) != nfu_Okay ) {
            smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
            return( NULL );
        }
    }
    if( ( ptwXY2 = ptwXY_domainSlice( smr, ptwXY, domainMin, domainMax, secondarySize, fill ) ) == NULL )
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
    return( ptwXY2 );
}

Referenced by GIDI::Functions::XYs1d::domainSliceMax(), and GIDI::ProtareTNSL::TNSL_crossSectionSumCorrection().

ptwXY_domainMin()

nfu_status ptwXY_domainMin	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		double *	domainMin )

Definition at line 1620 of file ptwXY_core.c.

                                                                                                 {
 
    ptwXY_dataFrom dataFrom;
    nfu_status status;
    
    if( ( status = ptwXY_domainMinAndFrom( smr, ptwXY, &dataFrom, domainMin ) ) != nfu_Okay ) {
        if( status == nfu_empty ) return( status );
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( nfu_Error );
    }
 
    return( nfu_Okay );
}

Referenced by GIDI::multiGroupTwoXYs1ds(), ptwXY_binary_ptwXY(), ptwXY_div_ptwXY(), ptwXY_domainMaxSlice(), ptwXY_domainSlice(), ptwXY_integrateDomain(), ptwXY_integrateDomainWithWeight_sqrt_x(), ptwXY_integrateDomainWithWeight_x(), and ptwXY_scaleAndOffsetDomainWith_ptwXYs().

ptwXY_domainMinAndFrom()

nfu_status ptwXY_domainMinAndFrom	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		ptwXY_dataFrom *	dataFrom,
		double *	domainMin )

Definition at line 1588 of file ptwXY_core.c.

                                                                                                                                  {
 
    int64_t nonOverflowLength = ptwXY_getNonOverflowLength( smr, ptwXY );
 
    *domainMin  = 0;
    *dataFrom = ptwXY_dataFrom_Unknown;
 
    if( nonOverflowLength < 0 ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( nfu_Error );
    }
 
    if( ptwXY->overflowLength > 0 ) {
        *dataFrom = ptwXY_dataFrom_Overflow;
        *domainMin = ptwXY->overflowHeader.next->point.x;
        if( nonOverflowLength >= 0 ) {
            if( *domainMin > ptwXY->points[0].x ) {
                *dataFrom = ptwXY_dataFrom_Points;
                *domainMin = ptwXY->points[0].x;
            }
        } }
    else if( nonOverflowLength > 0 ) {
        *dataFrom = ptwXY_dataFrom_Points;
        *domainMin = ptwXY->points[0].x; }
    else {
        return( nfu_empty );
    }
    return( nfu_Okay );
}

Referenced by ptwXY_domainMin(), and ptwXY_getPointsAroundX_closeIsEqual().

ptwXY_domainMinSlice()

ptwXYPoints * ptwXY_domainMinSlice	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		double	domainMin,
		int64_t	secondarySize,
		int	fill )

Definition at line 482 of file ptwXY_core.c.

                                                                                                                                        {
 
    double domainMax = 1.1 * domainMin + 1;
    ptwXYPoints *ptwXY2;
 
    if( domainMin < 0 ) domainMax = 0.9 * domainMin + 1;
    if( ptwXY->length > 0 ) {
        if( ptwXY_domainMax( smr, ptwXY, &domainMax ) != nfu_Okay )
            smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
    }
    if( ( ptwXY2 = ptwXY_domainSlice( smr, ptwXY, domainMin, domainMax, secondarySize, fill ) ) == NULL )
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
    return( ptwXY2 );
}

ptwXY_domainSlice()

ptwXYPoints * ptwXY_domainSlice	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		double	domainMin,
		double	domainMax,
		int64_t	secondarySize,
		int	fill )

Definition at line 422 of file ptwXY_core.c.

                                          {
 
    int64_t i, i1, i2;
    double y, _domainMin, _domainMax;
    ptwXYPoints *n = NULL;
 
    if( ptwXY->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Invalid source." );
        return( NULL );
    }
 
    if( ptwXY_domainMin( smr, ptwXY, &_domainMin ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( NULL );
    }
    if( ptwXY_domainMax( smr, ptwXY, &_domainMax ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( NULL );
    }
 
    if( ( ptwXY->length == 0 ) || ( _domainMin >= domainMax ) || ( _domainMax <= domainMin ) ) {
        if( ( n = ptwXY_new( smr, ptwXY->interpolation, ptwXY->interpolationString, ptwXY->biSectionMax, 
                ptwXY->accuracy, 0, secondarySize, ptwXY->userFlag ) ) == NULL ) {
            smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        } }
    else {
        if( ( n = ptwXY_clone( smr, ptwXY ) ) == NULL ) {
            smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
            return( NULL );
        }
        if( ( n->points[0].x < domainMin ) || ( n->points[n->length - 1].x > domainMax ) ) {
            if( fill && ( n->points[n->length - 1].x > domainMax ) ) {
                if( ptwXY_getValueAtX( smr, n, domainMax, &y ) != nfu_Okay ) goto Err;
                if( ptwXY_setValueAtX( smr, n, domainMax,  y ) != nfu_Okay ) goto Err;
            }
            if( fill && ( n->points[0].x < domainMin ) ) {
                if( ptwXY_getValueAtX( smr, n, domainMin, &y ) != nfu_Okay ) goto Err;
                if( ptwXY_setValueAtX( smr, n, domainMin,  y ) != nfu_Okay ) goto Err;
            }
            if( ptwXY_coalescePoints( smr, n, n->length + n->overflowAllocatedSize, NULL, 0 ) != nfu_Okay ) goto Err;
            for( i1 = 0; i1 < n->length; i1++ ) if( n->points[i1].x >= domainMin ) break;
            for( i2 = n->length - 1; i2 > 0; i2-- ) if( n->points[i2].x <= domainMax ) break;
            i2++;
            if( i1 > 0 ) {
                for( i = i1; i < i2; i++ ) n->points[i- i1] = n->points[i];
            }
            n->length = i2 - i1;
        }
    }
    return( n );
 
Err:
    smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
    if( n != NULL ) ptwXY_free( n );
    return( NULL );
}

Referenced by GIDI::Functions::XYs1d::domainSlice(), GIDI::multiGroupTwoXYs1ds(), ptwXY_createGaussian(), ptwXY_domainMaxSlice(), ptwXY_domainMinSlice(), and ptwXY_scaleAndOffsetDomainWith_ptwXYs().

ptwXY_free()

ptwXYPoints * ptwXY_free

(

ptwXYPoints *

ptwXY

)

Definition at line 782 of file ptwXY_core.c.

                                              {
 
    if( ptwXY != NULL ) {
        ptwXY_release( NULL, ptwXY );
        smr_freeMemory2( ptwXY );
    }
    return( (ptwXYPoints *) NULL );
}

Referenced by GIDI::Functions::XYs1d::domainSlice(), GIDI::Functions::XYs1d::domainSliceMax(), GIDI::multiGroupTwoXYs1ds(), GIDI::multiGroupXYs1d(), MCGIDI::Probabilities::NBodyPhaseSpace2d::NBodyPhaseSpace2d(), GIDI::Functions::XYs1d::operator*=(), GIDI::Functions::XYs1d::operator+=(), GIDI::Functions::XYs1d::operator-=(), GIDI::Transporting::Flux::process(), ptwXY_binary_ptwXY(), ptwXY_clip(), ptwXY_convolution(), ptwXY_create(), ptwXY_createFromFunction(), ptwXY_createGaussian(), ptwXY_createGaussianCenteredSigma1(), ptwXY_div_ptwXY(), ptwXY_domainSlice(), ptwXY_flatInterpolationToLinear(), ptwXY_groupOneFunction(), ptwXY_groupThreeFunctions(), ptwXY_groupTwoFunctions(), ptwXY_intersectionWith_ptwX(), ptwXY_inverse(), ptwXY_mul2_ptwXY(), ptwXY_scaleAndOffsetDomainWith_ptwXYs(), ptwXY_sub_ptwXY(), ptwXY_thin(), ptwXY_thinDomain(), ptwXY_toOtherInterpolation(), ptwXY_union(), ptwXY_unitbaseInterpolate(), ptwXY_valueTo_ptwXY(), GIDI::MultiGroupCalulationInformation::~MultiGroupCalulationInformation(), and GIDI::Functions::XYs1d::~XYs1d().

ptwXY_getAccuracy()

double ptwXY_getAccuracy

(

ptwXYPoints *

ptwXY

)

Definition at line 566 of file ptwXY_core.c.

                                               {
 
    return( ptwXY->accuracy );
}

Referenced by ptwXY_inverse().

ptwXY_getBiSectionMax()

double ptwXY_getBiSectionMax

(

ptwXYPoints *

ptwXY

)

Definition at line 582 of file ptwXY_core.c.

                                                   {
 
    return( ptwXY->biSectionMax );
}

Referenced by ptwXY_inverse().

ptwXY_getInterpolation()

ptwXY_interpolation ptwXY_getInterpolation

(

ptwXYPoints *

ptwXY

)

Definition at line 518 of file ptwXY_core.c.

                                                                 {
 
    return( ptwXY->interpolation );
}

Referenced by GIDI::Functions::Regions1d::asXYs1d(), ptwXY_mapToXsAndAdd(), ptwXY_ysMappedToXs(), and GIDI::Functions::XYs1d::XYs1d().

ptwXY_getInterpolationString()

char const * ptwXY_getInterpolationString

(

ptwXYPoints *

ptwXY

)

Definition at line 525 of file ptwXY_core.c.

                                                               {
 
    return( ptwXY->interpolationString );
}

ptwXY_getLowerIndexBoundingX()

nfu_status ptwXY_getLowerIndexBoundingX	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		double	x,
		int64_t *	index )

Definition at line 967 of file ptwXY_core.c.

                                                                                                                     {
 
    int64_t i1, length = ptwXY->length;
 
    *index = -1;
 
    if( ptwXY->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Invalid source." );
        return( ptwXY->status );
    }
 
    if( ptwXY_simpleCoalescePoints( smr, ptwXY ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( ptwXY->status );
    }
 
    if( x < ptwXY->points[0].x ) return( nfu_Okay );
    if( x > ptwXY->points[length-1].x ) return( nfu_Okay );
    for( i1 = 1; i1 < length; ++i1 ) {
        if( x < ptwXY->points[i1].x ) break;
    }
    *index = i1 - 1;
    return( ptwXY->status );
}

ptwXY_getNonOverflowLength()

int64_t ptwXY_getNonOverflowLength	(	statusMessageReporting *	smr,
		ptwXYPoints const *	ptwXY )

Definition at line 805 of file ptwXY_core.c.

                                                                                            {
 
    if( ptwXY->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Invalid source." );
        return( -ptwXY->status );
    }
 
    return( ptwXY->length - ptwXY->overflowLength );
}

Referenced by ptwXY_abs(), ptwXY_appendXY(), ptwXY_clone2(), ptwXY_coalescePoints(), ptwXY_copy(), ptwXY_copyPointsOnly(), ptwXY_div_fromDouble(), ptwXY_domainMaxAndFrom(), ptwXY_domainMinAndFrom(), ptwXY_getPointsAroundX_closeIsEqual(), ptwXY_mod(), ptwXY_neg(), ptwXY_range(), ptwXY_rangeMax(), ptwXY_rangeMin(), ptwXY_setValueAtX_overrideIfClose(), ptwXY_showInteralStructure(), and ptwXY_slopeOffset().

ptwXY_getPointAtIndex()

ptwXYPoint * ptwXY_getPointAtIndex	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		int64_t	index )

Definition at line 994 of file ptwXY_core.c.

                                                                                                    {
 
    if( ptwXY->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Invalid source." );
        return( NULL );
    }
 
    if( ( index < 0 ) || ( index >= ptwXY->length ) ) return( NULL );
    return( ptwXY_getPointAtIndex_Unsafely( ptwXY, index ) );
}

Referenced by ptwXY_getXYPairAtIndex().

ptwXY_getPointAtIndex_Unsafely()

ptwXYPoint * ptwXY_getPointAtIndex_Unsafely	(	ptwXYPoints const *	ptwXY,
		int64_t	index )

Definition at line 1007 of file ptwXY_core.c.

                                                                                      {
 
    int64_t i;
    ptwXYOverflowPoint *overflowPoint;
 
    for( overflowPoint = ptwXY->overflowHeader.next, i = 0; overflowPoint != &(ptwXY->overflowHeader); overflowPoint = overflowPoint->next, i++ ) {
        if( overflowPoint->index == index ) return( &(overflowPoint->point) );
        if( overflowPoint->index > index ) break;
    }
    return( &(ptwXY->points[index - i]) );
}

Referenced by GIDI::Functions::XYs1d::evaluate(), GIDI::Functions::XYs1d::operator[](), ptwXY_areDomainsMutual(), ptwXY_clip(), ptwXY_dullEdges(), ptwXY_getPointAtIndex(), ptwXY_getSlopeAtX(), ptwXY_mutualifyDomains(), ptwXY_showInteralStructure(), ptwXY_simpleWrite(), ptwXY_tweakDomainsToMutualify(), GIDI::Functions::XYs1d::xs(), GIDI::Functions::XYs1d::ys(), and GIDI::Functions::XYs1d::ysMappedToXs().

ptwXY_getPointsAroundX()

ptwXY_lessEqualGreaterX ptwXY_getPointsAroundX	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		double	x,
		ptwXYOverflowPoint *	lessThanEqualXPoint,
		ptwXYOverflowPoint *	greaterThanXPoint )

Definition at line 1036 of file ptwXY_core.c.

                                                                                         {
 
    int closeIsEqual;
    ptwXYPoint *closePoint;
    ptwXY_lessEqualGreaterX lessEqualGreaterX;
 
    if( ptwXY->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Invalid source." );
        return( ptwXY_lessEqualGreaterX_Error );
    }
 
    lessEqualGreaterX = ptwXY_getPointsAroundX_closeIsEqual( smr, ptwXY, x, lessThanEqualXPoint, greaterThanXPoint, 
            0, &closeIsEqual, &closePoint );
    if( lessEqualGreaterX == ptwXY_lessEqualGreaterX_Error ) smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
    return( lessEqualGreaterX );
}

Referenced by ptwXY_getSlopeAtX(), and ptwXY_getValueAtX().

ptwXY_getPointsAroundX_closeIsEqual()

ptwXY_lessEqualGreaterX ptwXY_getPointsAroundX_closeIsEqual	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		double	x,
		ptwXYOverflowPoint *	lessThanEqualXPoint,
		ptwXYOverflowPoint *	greaterThanXPoint,
		double	eps,
		int *	closeIsEqual,
		ptwXYPoint **	closePoint )

Definition at line 1056 of file ptwXY_core.c.

                                  {
 
    int64_t overflowIndex, nonOverflowLength = ptwXY_getNonOverflowLength( smr, ptwXY );
    int64_t indexMin, indexMid, indexMax;
    ptwXY_dataFrom domainMinFrom, domainMaxFrom;
    double domainMin, domainMax;
    ptwXYOverflowPoint *overflowPoint, *overflowHeader = &(ptwXY->overflowHeader);
    ptwXY_lessEqualGreaterX status = ptwXY_lessEqualGreaterX_empty;
    ptwXYPoint *lowerPoint = NULL, *upperPoint = NULL;
 
    if( nonOverflowLength < 0 ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( ptwXY_lessEqualGreaterX_Error );
    }
 
    *closeIsEqual = 0;
    if( ptwXY->length == 0 ) return( status );
 
    if( ptwXY_domainMinAndFrom( smr, ptwXY, &domainMinFrom, &domainMin ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( ptwXY_lessEqualGreaterX_Error );
    }
        
    if( ptwXY_domainMaxAndFrom( smr, ptwXY, &domainMaxFrom, &domainMax ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( ptwXY_lessEqualGreaterX_Error );
    }
 
    ptwXY_initialOverflowPoint( lessThanEqualXPoint, overflowHeader, NULL );
    ptwXY_initialOverflowPoint( greaterThanXPoint, overflowHeader, NULL );
    if( x < domainMin ) {
        status = ptwXY_lessEqualGreaterX_lessThan;
        if( domainMinFrom == ptwXY_dataFrom_Points ) {
            greaterThanXPoint->prior = overflowHeader;
            greaterThanXPoint->index = 0;
            greaterThanXPoint->point = ptwXY->points[0];
            *closePoint = &(ptwXY->points[0]); }
        else {
            *greaterThanXPoint = *(overflowHeader->next);
            *closePoint = &(overflowHeader->next->point);
        } }
    else if( x > domainMax ) {
        status = ptwXY_lessEqualGreaterX_greater;
        if( domainMaxFrom == ptwXY_dataFrom_Points ) {
            lessThanEqualXPoint->prior = overflowHeader->prior;
            lessThanEqualXPoint->index = nonOverflowLength - 1;
            lessThanEqualXPoint->point = ptwXY->points[lessThanEqualXPoint->index];
            *closePoint = &(ptwXY->points[lessThanEqualXPoint->index]); }
        else {
            *lessThanEqualXPoint = *(overflowHeader->prior);
            *closePoint = &(overflowHeader->prior->point);
        } }
    else {                                                  /* domainMin <= x <= domainMax */
        status = ptwXY_lessEqualGreaterX_between;           /* Default for this condition, can only be between or equal. */
        for( overflowPoint = overflowHeader->next, overflowIndex = 0; overflowPoint != overflowHeader; 
            overflowPoint = overflowPoint->next, overflowIndex++ ) if( overflowPoint->point.x > x ) break;
        overflowPoint = overflowPoint->prior;
        if( ( overflowPoint != overflowHeader ) && ( overflowPoint->point.x == x ) ) {
            status = ptwXY_lessEqualGreaterX_equal;
            *lessThanEqualXPoint = *overflowPoint; }
        else if( ptwXY->length == 1 ) {                    /* If here and length = 1, then ptwXY->points[0].x == x. */
            status = ptwXY_lessEqualGreaterX_equal;
            lessThanEqualXPoint->index = 0;
            lessThanEqualXPoint->point = ptwXY->points[0]; }
        else {                                              /* ptwXY->length > 1 */
            indexMin = 0;
            indexMax = nonOverflowLength - 1;
            indexMid = ( indexMin + indexMax ) >> 1;
            while( ( indexMin != indexMid ) && ( indexMid != indexMax ) ) {
                if( ptwXY->points[indexMid].x > x ) {
                    indexMax = indexMid; }
                else {
                    indexMin = indexMid;
                }
                indexMid = ( indexMin + indexMax ) >> 1;
            }
            if( ptwXY->points[indexMin].x == x ) {
                status = ptwXY_lessEqualGreaterX_equal;
                lessThanEqualXPoint->index = indexMin;
                lessThanEqualXPoint->point = ptwXY->points[indexMin]; }
            else if( ptwXY->points[indexMax].x == x ) {
                status = ptwXY_lessEqualGreaterX_equal;
                lessThanEqualXPoint->index = indexMax;
                lessThanEqualXPoint->point = ptwXY->points[indexMax]; }
            else {
                if( ptwXY->points[indexMin].x > x ) indexMax = 0;
                if( ptwXY->points[indexMax].x < x ) indexMin = indexMax;
                if( ( overflowPoint == overflowHeader ) ||     /* x < domainMin of overflow points. */
                        ( ( ptwXY->points[indexMin].x > overflowPoint->point.x ) && ( ptwXY->points[indexMin].x < x ) ) ) {
                    if( overflowPoint != overflowHeader ) lessThanEqualXPoint->prior = overflowPoint;
                    lowerPoint = &(ptwXY->points[indexMin]);
                    lessThanEqualXPoint->index = indexMin;
                    lessThanEqualXPoint->point = ptwXY->points[indexMin]; }
                else {
                    lowerPoint = &(overflowPoint->point);
                    *lessThanEqualXPoint = *overflowPoint;
                }
                if( ( overflowPoint->next == overflowHeader ) ||     /* x > domainMax of overflow points. */
                        ( ( ptwXY->points[indexMax].x < overflowPoint->next->point.x ) && ( ptwXY->points[indexMax].x > x ) ) ) {
                    upperPoint = &(ptwXY->points[indexMax]);
                    greaterThanXPoint->index = indexMax;
                    greaterThanXPoint->point = ptwXY->points[indexMax]; }
                else {
                    upperPoint = &(overflowPoint->next->point);
                    *greaterThanXPoint = *(overflowPoint->next);
                }
            }
        }
    }
 
    if( eps > 0 ) {
        double absX = fabs( x );
 
        if( status == ptwXY_lessEqualGreaterX_lessThan ) {
            if( absX < fabs( greaterThanXPoint->point.x ) ) absX = fabs( greaterThanXPoint->point.x );
            if( ( greaterThanXPoint->point.x - x ) < eps * absX ) *closeIsEqual = 1; }
        else if( status == ptwXY_lessEqualGreaterX_greater ) {
            if( absX < fabs( lessThanEqualXPoint->point.x ) ) absX = fabs( lessThanEqualXPoint->point.x );
            if( ( x - lessThanEqualXPoint->point.x ) < eps * absX ) *closeIsEqual = -1; }
        else if( status == ptwXY_lessEqualGreaterX_between ) {
            if( ( x - lessThanEqualXPoint->point.x ) < ( greaterThanXPoint->point.x - x ) ) {   /* x is closer to lower point. */
                *closePoint = lowerPoint;
                if( absX < fabs( lessThanEqualXPoint->point.x ) ) absX = fabs( lessThanEqualXPoint->point.x );
                if( ( x - lessThanEqualXPoint->point.x ) < eps * absX ) *closeIsEqual = -1; }
            else {                                                                              /* x is closer to upper point. */
                *closePoint = upperPoint;
                if( absX < fabs( greaterThanXPoint->point.x ) ) absX = fabs( greaterThanXPoint->point.x );
                if( ( greaterThanXPoint->point.x - x ) < eps * absX ) *closeIsEqual = 1;
            } }
        else if( status == ptwXY_lessEqualGreaterX_equal ) {
            *closeIsEqual = 1;
        }
    }
    return( status );
}

Referenced by ptwXY_getPointsAroundX(), and ptwXY_setValueAtX_overrideIfClose().

ptwXY_getSlopeAtX()

nfu_status ptwXY_getSlopeAtX	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		double	x,
		const char	side,
		double *	slope )

Definition at line 1533 of file ptwXY_core.c.

                                                                                                                          {
 
    nfu_status status  = nfu_Okay;
    ptwXYOverflowPoint lessThanEqualXPoint = { NULL, NULL, 0, {0.0, 0.0}}, greaterThanXPoint;
    ptwXY_lessEqualGreaterX legx = ptwXY_getPointsAroundX( smr, ptwXY, x, &lessThanEqualXPoint, &greaterThanXPoint );
    ptwXYPoint *point;
    greaterThanXPoint = lessThanEqualXPoint;        /* Done to stop a compiler from complaining. */
 
    *slope = 0.;
 
    if( ptwXY->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Invalid source." );
        return( ptwXY->status );
    }
    if( ( side != '-' ) && ( side != '+' ) ) {
        smr_setReportError2( smr, nfu_SMR_libraryID, nfu_badSelf, "Invalid side = '%c'.", side );
        return( nfu_badInput );
    }
 
    switch( legx ) {
    case ptwXY_lessEqualGreaterX_Error :
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( nfu_Error );
    case ptwXY_lessEqualGreaterX_empty :
    case ptwXY_lessEqualGreaterX_lessThan :
    case ptwXY_lessEqualGreaterX_greater :
        status = nfu_XOutsideDomain;
        break;
    case ptwXY_lessEqualGreaterX_between :
        *slope = ( greaterThanXPoint.point.y - lessThanEqualXPoint.point.y ) / 
            ( greaterThanXPoint.point.x - lessThanEqualXPoint.point.x );
        break;
    case ptwXY_lessEqualGreaterX_equal :
        if( side == '-' ) {
            if( lessThanEqualXPoint.index == 0 ) {
                status = nfu_XOutsideDomain; }
            else {
                point = ptwXY_getPointAtIndex_Unsafely( ptwXY, lessThanEqualXPoint.index - 1 );
                *slope = ( lessThanEqualXPoint.point.y - point->y ) / ( lessThanEqualXPoint.point.x - point->x );
            } }
        else {
            if( lessThanEqualXPoint.index == ( ptwXY->length - 1 ) ) {
                status = nfu_XOutsideDomain; }
            else {
                point = ptwXY_getPointAtIndex_Unsafely( ptwXY, lessThanEqualXPoint.index + 1 );
                *slope = ( point->y - lessThanEqualXPoint.point.y ) / ( point->x - lessThanEqualXPoint.point.x );
            }
        }
    }
 
    return( status );
}

Referenced by ptwXY_div_ptwXY().

ptwXY_getStatus()

nfu_status ptwXY_getStatus

(

ptwXYPoints *

ptwXY

)

Definition at line 545 of file ptwXY_core.c.

                                                 {
 
    return( ptwXY->status );
}

ptwXY_getUserFlag()

int ptwXY_getUserFlag

(

ptwXYPoints *

ptwXY

)

Definition at line 552 of file ptwXY_core.c.

                                            {
 
    return( ptwXY->userFlag );
}

ptwXY_getValueAtX()

nfu_status ptwXY_getValueAtX	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		double	x,
		double *	y )

Definition at line 1196 of file ptwXY_core.c.

                                                                                                     {
 
    nfu_status status = nfu_XOutsideDomain;
    ptwXYOverflowPoint lessThanEqualXPoint, greaterThanXPoint;
    ptwXY_lessEqualGreaterX legx = ptwXY_getPointsAroundX( smr, ptwXY, x, &lessThanEqualXPoint, &greaterThanXPoint );
 
    *y = 0.;
    switch( legx ) {
    case ptwXY_lessEqualGreaterX_Error :
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( ptwXY->status );
    case ptwXY_lessEqualGreaterX_empty :
    case ptwXY_lessEqualGreaterX_lessThan :
    case ptwXY_lessEqualGreaterX_greater :
        break;
    case ptwXY_lessEqualGreaterX_equal :
        status = nfu_Okay;
        *y = lessThanEqualXPoint.point.y;
        break;
    case ptwXY_lessEqualGreaterX_between :
        status = ptwXY_interpolatePoint( smr, ptwXY->interpolation, x, y, lessThanEqualXPoint.point.x, lessThanEqualXPoint.point.y, 
                greaterThanXPoint.point.x, greaterThanXPoint.point.y );
        break;
    }
    return( status );
}

Referenced by GIDI::Functions::XYs1d::evaluate(), ptwXY_domainSlice(), ptwXY_dullEdges(), ptwXY_intersectionWith_ptwX(), and ptwXY_thinDomain().

ptwXY_getXYPairAtIndex()

nfu_status ptwXY_getXYPairAtIndex	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		int64_t	index,
		double *	x,
		double *	y )

Definition at line 1021 of file ptwXY_core.c.

                                                                                                                          {
 
    ptwXYPoint *p = ptwXY_getPointAtIndex( smr, ptwXY, index );
 
    if( p == NULL ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( ptwXY->status );
    }
    *x = p->x;
    *y = p->y;
    return( nfu_Okay );
}

Referenced by nf_Legendre_from_ptwXY().

ptwXY_initialize()

nfu_status ptwXY_initialize	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		ptwXY_interpolation	interpolation,
		char const *	interpolationString,
		double	biSectionMax,
		double	accuracy,
		int64_t	primarySize,
		int64_t	secondarySize,
		int	userFlag )

Definition at line 53 of file ptwXY_core.c.

                       {
 
    ptwXY->status = nfu_Okay;
    ptwXY->interpolation = interpolation;
    ptwXY->interpolationString = NULL;
    switch( interpolation ) {
    case ptwXY_interpolationLinLin :
        ptwXY->interpolationString = linLinInterpolationString; break;
    case ptwXY_interpolationLogLin :
        ptwXY->interpolationString = logLinInterpolationString; break;
    case ptwXY_interpolationLinLog :
        ptwXY->interpolationString = linLogInterpolationString; break;
    case ptwXY_interpolationLogLog :
        ptwXY->interpolationString = logLogInterpolationString; break;
    case ptwXY_interpolationFlat :
        ptwXY->interpolationString = flatInterpolationString; break;
    case ptwXY_interpolationOther :         /* For ptwXY_interpolationOther, interpolationString must be defined. */
        if( interpolationString == NULL ) {
            smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_otherInterpolation,
                    "Invalid other interplation. interpolationString is NULL, it must be a defined string" );
            ptwXY->status = nfu_Error; }
        else {
            if( ( ptwXY->interpolationString = smr_allocateCopyString2( smr, interpolationString, "interpolationString" ) ) == NULL ) 
                    ptwXY->status = nfu_Error;
        }
    }
    ptwXY->userFlag = 0;
    ptwXY_setUserFlag( ptwXY, userFlag );
    ptwXY->biSectionMax = ptwXY_maxBiSectionMax;
    ptwXY_setBiSectionMax( ptwXY, biSectionMax );
    ptwXY->accuracy = ptwXY_minAccuracy;
    ptwXY_setAccuracy( ptwXY, accuracy );
 
    ptwXY->length = 0;
    ptwXY->allocatedSize = 0;
    ptwXY->overflowLength = 0;
    ptwXY->overflowAllocatedSize = 0;
    ptwXY->mallocFailedSize = 0;
 
    ptwXY_initialOverflowPoint( &(ptwXY->overflowHeader), &(ptwXY->overflowHeader), &(ptwXY->overflowHeader) );
 
    ptwXY->points = NULL;
    ptwXY->overflowPoints = NULL;
 
    if( ptwXY_reallocatePoints( smr, ptwXY, primarySize, 0 ) == nfu_Okay )
        ptwXY_reallocateOverflowPoints( smr, ptwXY, secondarySize );
    if( ptwXY->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        ptwXY_release( smr, ptwXY );
    }
    return( ptwXY->status );
}

Referenced by ptwXY_new().

ptwXY_interpolationToString()

char const * ptwXY_interpolationToString

(

ptwXY_interpolation

interpolation

)

Definition at line 1780 of file ptwXY_core.c.

                                                                             {
 
    switch( interpolation ) {
    case ptwXY_interpolationLinLin : return( linLinInterpolationString );
    case ptwXY_interpolationLogLin : return( logLinInterpolationString );
    case ptwXY_interpolationLinLog : return( linLogInterpolationString );
    case ptwXY_interpolationLogLog : return( logLogInterpolationString );
    case ptwXY_interpolationFlat :   return( flatInterpolationString );
    default :
        break;
    }
    return( NULL );
}

Referenced by GIDI::Functions::FunctionForm::FunctionForm(), GIDI::Functions::FunctionForm::FunctionForm(), GIDI::multiGroupXYs1d(), GIDI::Transporting::Flux::process(), ptwXY_binary_ptwXY(), ptwXY_create2(), ptwXY_createFrom_Xs_Ys2(), ptwXY_new2(), ptwXY_setInterpolationString(), and GIDI::Functions::FunctionForm::setInterpolation().

ptwXY_length()

int64_t ptwXY_length	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY )

Definition at line 793 of file ptwXY_core.c.

                                                                        {
 
    if( ptwXY->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Invalid source." );
        return( -ptwXY->status );
    }
 
    return( ptwXY->length );
}

Referenced by GIDI::Functions::XYs1d::evaluate(), GIDI::Reaction::modifyCrossSection(), nf_Legendre_from_ptwXY(), GIDI::Functions::XYs1d::operator[](), ptwXY_inverse(), ptwXY_startIndex(), ptwXY_valuesToC_XsAndYs(), ptwXY_ysMappedToXs(), GIDI::Functions::XYs1d::size(), and GIDI::ProtareTNSL::TNSL_crossSectionSumCorrection().

ptwXY_mergeFromXsAndYs()

nfu_status ptwXY_mergeFromXsAndYs	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		int	length,
		double *	xs,
		double *	ys )

Definition at line 1325 of file ptwXY_core.c.

                                                                                                                         {
 
    if( ptwXY_mergeFrom( smr, ptwXY, 1, length, xs, ys ) != nfu_Okay )
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
    return( ptwXY->status );
}

ptwXY_mergeFromXYs()

nfu_status ptwXY_mergeFromXYs	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		int	length,
		double *	xys )

Definition at line 1334 of file ptwXY_core.c.

                                                                                                          {
 
    int i;
    double *xs, *p1, *p2;
 
    if( length == 0 ) return( nfu_Okay );
    if( length < 0 ) {
        smr_setReportError2( smr, nfu_SMR_libraryID, nfu_badInput, "Negative length = %d.", length );
        return( nfu_badInput );
    }
 
    if( ( xs = (double *) smr_malloc2( smr, length * sizeof( double ), 0, "xs" ) ) == NULL ) return( nfu_mallocError );
    for( i = 0, p1 = xs, p2 = xys; i < length; i++, p1++, p2 += 2 ) *p1 = *p2;
    if( ptwXY_mergeFrom( smr, ptwXY, 2, length, xs, xys ) != nfu_Okay )
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
    smr_freeMemory2( xs );
 
    return( ptwXY->status );
}

ptwXY_new()

ptwXYPoints * ptwXY_new	(	statusMessageReporting *	smr,
		ptwXY_interpolation	interpolation,
		char const *	interpolationString,
		double	biSectionMax,
		double	accuracy,
		int64_t	primarySize,
		int64_t	secondarySize,
		int	userFlag )

Definition at line 28 of file ptwXY_core.c.

                                                                                                         {
 
    ptwXYPoints *ptwXY = (ptwXYPoints *) smr_malloc2( smr, sizeof( ptwXYPoints ), 1, "ptwXY" );
 
    if( ptwXY == NULL ) return( NULL );
    if( ptwXY_initialize( smr, ptwXY, interpolation, interpolationString, biSectionMax, accuracy, primarySize, secondarySize, userFlag ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        smr_freeMemory2( ptwXY );
    }
    return( ptwXY );
}

Referenced by ptwXY_clip(), ptwXY_clone2(), ptwXY_convolution(), ptwXY_create(), ptwXY_createFrom_Xs_Ys(), ptwXY_createFromFunction(), ptwXY_createGaussianCenteredSigma1(), ptwXY_domainSlice(), ptwXY_flatInterpolationToLinear(), ptwXY_inverse(), ptwXY_new2(), ptwXY_slice(), ptwXY_thin(), ptwXY_thinDomain(), ptwXY_union(), and ptwXY_valueTo_ptwXY().

ptwXY_new2()

ptwXYPoints * ptwXY_new2	(	statusMessageReporting *	smr,
		ptwXY_interpolation	interpolation,
		int64_t	primarySize,
		int64_t	secondarySize )

Definition at line 44 of file ptwXY_core.c.

                                                                                                                                      {
 
    char const *interpolationString = ptwXY_interpolationToString( interpolation );
 
    return( ptwXY_new( smr, interpolation, interpolationString, 12, 1e-3, primarySize, secondarySize, 0 ) );
}

ptwXY_range()

nfu_status ptwXY_range	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		double *	rangeMin,
		double *	rangeMax )

Definition at line 1683 of file ptwXY_core.c.

                                                                                                              {
 
    int64_t i, nonOverflowLength = ptwXY_getNonOverflowLength( smr, ptwXY  );
    ptwXYPoint *p = ptwXY->points;
    ptwXYOverflowPoint *overflowPoint = ptwXY->overflowHeader.next;
 
    *rangeMin = *rangeMax = 0.;
 
    if( nonOverflowLength < 0 ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( nfu_Error );
    }
 
    if( ptwXY->length == 0 ) return( nfu_empty );
    if( nonOverflowLength > 0 ) {
        *rangeMin = *rangeMax = p->y;
        for( i = 1, p++; i < nonOverflowLength; i++, p++ ) {
            *rangeMin = ( ( *rangeMin < p->y ) ? *rangeMin : p->y );
            *rangeMax = ( ( *rangeMax > p->y ) ? *rangeMax : p->y );
        } }
    else {
        *rangeMin = *rangeMax = overflowPoint->point.y;
    }
    for( ; overflowPoint != &(ptwXY->overflowHeader); overflowPoint = overflowPoint->next ) {
        *rangeMin = ( ( *rangeMin < overflowPoint->point.y ) ? *rangeMin : overflowPoint->point.y );
        *rangeMax = ( ( *rangeMax < overflowPoint->point.y ) ? *rangeMax : overflowPoint->point.y );
    }
    return( nfu_Okay );
}

Referenced by ptwXY_clip().

ptwXY_rangeMax()

nfu_status ptwXY_rangeMax	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		double *	rangeMax )

Definition at line 1742 of file ptwXY_core.c.

                                                                                               {
 
    int64_t i, nonOverflowLength = ptwXY_getNonOverflowLength( smr, ptwXY  );
    ptwXYPoint *p = ptwXY->points;
    ptwXYOverflowPoint *overflowPoint = ptwXY->overflowHeader.next;
 
    *rangeMax = 0.;
 
    if( nonOverflowLength < 0 ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( nfu_Error );
    }
 
    if( ptwXY->length == 0 ) return( nfu_empty );
    if( nonOverflowLength > 0 ) {
        *rangeMax = p->y;
        for( i = 1, p++; i < nonOverflowLength; i++, p++ ) *rangeMax = ( ( *rangeMax > p->y ) ? *rangeMax : p->y ); }
    else {
        *rangeMax = overflowPoint->point.y;
    }
    for( ; overflowPoint != &(ptwXY->overflowHeader); overflowPoint = overflowPoint->next )
        *rangeMax = ( ( *rangeMax > overflowPoint->point.y ) ? *rangeMax : overflowPoint->point.y );
    return( nfu_Okay );
}

ptwXY_rangeMin()

nfu_status ptwXY_rangeMin	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		double *	rangeMin )

Definition at line 1715 of file ptwXY_core.c.

                                                                                               {
 
    int64_t i, nonOverflowLength = ptwXY_getNonOverflowLength( smr, ptwXY  );
    ptwXYPoint *p = ptwXY->points;
    ptwXYOverflowPoint *overflowPoint = ptwXY->overflowHeader.next;
 
    *rangeMin = 0.;
 
    if( nonOverflowLength < 0 ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( nfu_Error );
    }
 
    if( ptwXY->length == 0 ) return( nfu_empty );
    if( nonOverflowLength > 0 ) {
        *rangeMin = p->y;
        for( i = 1, p++; i < nonOverflowLength; i++, p++ ) *rangeMin = ( ( *rangeMin < p->y ) ? *rangeMin : p->y ); }
    else {
        *rangeMin = overflowPoint->point.y;
    }
    for( ; overflowPoint != &(ptwXY->overflowHeader); overflowPoint = overflowPoint->next ) 
        *rangeMin = ( ( *rangeMin < overflowPoint->point.y ) ? *rangeMin : overflowPoint->point.y );
    return( nfu_Okay );
}

ptwXY_reallocateOverflowPoints()

nfu_status ptwXY_reallocateOverflowPoints	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		int64_t	size )

Definition at line 634 of file ptwXY_core.c.

                                                                                                           {
/*
*   This is for allocating/reallocating the secondary data memory.
*/
    if( ptwXY->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Invalid source." );
        return( ptwXY->status );
    }
 
    if( size < ptwXY_minimumOverflowSize ) size = ptwXY_minimumOverflowSize;      /* ptwXY_minimumOverflowSize must be > 0. */
    if( size < ptwXY->overflowLength ) {
        if( ptwXY_coalescePoints( smr, ptwXY, ptwXY->length + ptwXY->overflowAllocatedSize, NULL, 0 ) != nfu_Okay ) {
            smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
            return( ptwXY->status );
        }
    }
    if( size != ptwXY->overflowAllocatedSize ) {
        ptwXY->overflowPoints = (ptwXYOverflowPoint *) smr_realloc2( smr, ptwXY->overflowPoints, 
                (size_t) size * sizeof( ptwXYOverflowPoint ), "ptwXY->overflowPoints" );
        if( ptwXY->overflowPoints == NULL ) {
            ptwXY->length = 0;
            ptwXY->overflowLength = 0;
            ptwXY->mallocFailedSize = size;
            size = 0;
            ptwXY->status = nfu_mallocError;
        }
    }
    ptwXY->overflowAllocatedSize = size;
    return( ptwXY->status );
}

Referenced by ptwXY_initialize().

ptwXY_reallocatePoints()

nfu_status ptwXY_reallocatePoints	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		int64_t	size,
		int	forceSmallerResize )

Definition at line 602 of file ptwXY_core.c.

                                                                                                                           {
/*
*   This is for allocating/reallocating the primary data memory.
*/
    if( ptwXY->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Invalid source." );
        return( ptwXY->status );
    }
 
    if( size < ptwXY_minimumSize ) size = ptwXY_minimumSize;                      /* ptwXY_minimumSize must be > 0. */
    if( size < ptwXY->length ) size = ptwXY->length;
    if( size != ptwXY->allocatedSize ) {
        if( size > ptwXY->allocatedSize ) {                                        /* Increase size of allocated points. */
            ptwXY->points = (ptwXYPoint *) smr_realloc2( smr, ptwXY->points, (size_t) size * sizeof( ptwXYPoint ), "ptwXY->points" ); }
        else if( ( ptwXY->allocatedSize > 2 * size ) || forceSmallerResize ) {     /* Decrease size, if at least 1/2 size reduction or if forced to. */
            ptwXY->points = (ptwXYPoint *) smr_realloc2( smr, ptwXY->points, (size_t) size * sizeof( ptwXYPoint ), "ptwXY->points" ); }
        else {
            size = ptwXY->allocatedSize;                                           /* Size is < ptwXY->allocatedSize, but realloc not called. */
        }
        if( ptwXY->points == NULL ) {
            ptwXY->length = 0;
            ptwXY->mallocFailedSize = size;
            size = 0;
            ptwXY->status = nfu_mallocError;
        }
        ptwXY->allocatedSize = size;
    }
    return( ptwXY->status );
}

Referenced by ptwXY_coalescePoints(), ptwXY_copy(), ptwXY_copyPointsOnly(), ptwXY_initialize(), ptwXY_setXYData(), and ptwXY_setXYDataFromXsAndYs().

ptwXY_release()

nfu_status ptwXY_release	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY )

Definition at line 759 of file ptwXY_core.c.

                                                                            {
/*
*   Note, this routine does not free ptwXY (i.e., it does not undo all of ptwXY_new).
*/
 
    if( ptwXY->interpolation == ptwXY_interpolationOther ) {
        if( ptwXY->interpolationString != NULL ) 
            ptwXY->interpolationString = (char const *) smr_freeMemory2( ptwXY->interpolationString );
    }
    ptwXY->interpolation = ptwXY_interpolationLinLin;
    ptwXY->length = 0;
    ptwXY->allocatedSize = 0;
    ptwXY->points = (ptwXYPoint *) smr_freeMemory2( ptwXY->points );
 
    ptwXY->overflowLength = 0;
    ptwXY->overflowAllocatedSize = 0;
    ptwXY->overflowPoints = (ptwXYOverflowPoint *) smr_freeMemory2( ptwXY->overflowPoints );
 
    return( nfu_Okay );
}

Referenced by ptwXY_free(), and ptwXY_initialize().

ptwXY_setAccuracy()

double ptwXY_setAccuracy	(	ptwXYPoints *	ptwXY,
		double	accuracy )

Definition at line 573 of file ptwXY_core.c.

                                                                {
 
    accuracy = ptwXY_limitAccuracy( accuracy );
    ptwXY->accuracy = accuracy;
    return( ptwXY->accuracy );
}

Referenced by ptwXY_initialize().

ptwXY_setBiSectionMax()

double ptwXY_setBiSectionMax	(	ptwXYPoints *	ptwXY,
		double	biSectionMax )

Definition at line 589 of file ptwXY_core.c.

                                                                        {
 
    if( biSectionMax < 0 ) {
        biSectionMax = 0; }
    else if( biSectionMax > ptwXY_maxBiSectionMax ) {
        biSectionMax = ptwXY_maxBiSectionMax;
    }
    ptwXY->biSectionMax = biSectionMax;
    return( ptwXY->biSectionMax );
}

Referenced by ptwXY_initialize().

ptwXY_setInterpolationString()

nfu_status ptwXY_setInterpolationString	(	ptwXYPoints *	ptwXY,
		char const *	interpolationString )

Definition at line 532 of file ptwXY_core.c.

                                                                                               {
 
    ptwXY_interpolation interpolation = ptwXY_stringToInterpolation( interpolationString );
 
    if( interpolation == ptwXY_interpolationOther ) return( nfu_invalidInterpolation );
 
    ptwXY->interpolation = interpolation;
    ptwXY->interpolationString = ptwXY_interpolationToString( interpolation );
    return( nfu_Okay );
}

ptwXY_setUserFlag()

void ptwXY_setUserFlag	(	ptwXYPoints *	ptwXY,
		int	userFlag )

Definition at line 559 of file ptwXY_core.c.

                                                           {
 
    ptwXY->userFlag = userFlag;
}

Referenced by ptwXY_initialize().

ptwXY_setValueAtX()

nfu_status ptwXY_setValueAtX	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		double	x,
		double	y )

Definition at line 1225 of file ptwXY_core.c.

                                                                                                    {
 
    if( ptwXY_setValueAtX_overrideIfClose( smr, ptwXY, x, y, 0., 0 ) != nfu_Okay )
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
    return( ptwXY->status );
}

Referenced by ptwXY_clip(), ptwXY_convolution(), ptwXY_createGaussianCenteredSigma1(), ptwXY_div_ptwXY(), ptwXY_domainSlice(), ptwXY_dullEdges(), ptwXY_flatInterpolationToLinear(), ptwXY_intersectionWith_ptwX(), ptwXY_mul2_ptwXY(), ptwXY_scaleAndOffsetDomainWith_ptwXYs(), ptwXY_thicken(), and ptwXY_valueTo_ptwXY().

ptwXY_setValueAtX_overrideIfClose()

nfu_status ptwXY_setValueAtX_overrideIfClose	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		double	x,
		double	y,
		double	eps,
		int	override )

Definition at line 1234 of file ptwXY_core.c.

                                   {
 
    int closeIsEqual;
    int64_t nonOverflowLength = ptwXY_getNonOverflowLength( smr, ptwXY ), i;
    ptwXY_lessEqualGreaterX legx;
    ptwXYPoint *point = NULL, newPoint = { x, y };
    ptwXYOverflowPoint *overflowPoint, *p, *overflowHeader = &(ptwXY->overflowHeader);
    ptwXYOverflowPoint lessThanEqualXPoint, greaterThanXPoint;
    ptwXYPoint *closePoint;
 
    if( nonOverflowLength < 0 ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( nfu_Error );
    }
 
    legx = ptwXY_getPointsAroundX_closeIsEqual( smr, ptwXY, x, &lessThanEqualXPoint, &greaterThanXPoint, eps, &closeIsEqual, &closePoint );
    switch( legx ) {
    case ptwXY_lessEqualGreaterX_Error :
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( nfu_Error );
    case ptwXY_lessEqualGreaterX_lessThan :
    case ptwXY_lessEqualGreaterX_greater :
    case ptwXY_lessEqualGreaterX_between :
        if( closeIsEqual ) {
            if( !override ) return( nfu_Okay );
            point = closePoint;
            legx = ptwXY_lessEqualGreaterX_equal;
            x = point->x; }
        else {
            if( ( legx == ptwXY_lessEqualGreaterX_greater ) && ( nonOverflowLength < ptwXY->allocatedSize ) ) {
                point = &(ptwXY->points[nonOverflowLength]); }
            else {
                if( ptwXY->overflowLength == ptwXY->overflowAllocatedSize ) {
                    if( ptwXY_coalescePoints( smr, ptwXY, ptwXY->length + ptwXY->overflowAllocatedSize, &newPoint, 0 ) != nfu_Okay )
                        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
                    return( ptwXY->status );
                }
                overflowPoint = &(ptwXY->overflowPoints[ptwXY->overflowLength]);
                if( legx == ptwXY_lessEqualGreaterX_lessThan ) {
                    overflowPoint->prior = greaterThanXPoint.prior;
                    overflowPoint->index = 0; }
                else {                                      /* Between or greater and must go in overflow area. */
                    if( legx == ptwXY_lessEqualGreaterX_greater ) {
                        overflowPoint->prior = overflowHeader->prior;
                        overflowPoint->index = ptwXY->length; }
                    else {
                        overflowPoint->prior = lessThanEqualXPoint.prior;
                        if( lessThanEqualXPoint.next != NULL ) {
                            if( lessThanEqualXPoint.point.x < x ) 
                                overflowPoint->prior = lessThanEqualXPoint.prior->next;
                            i = 1; }
                        else {
                            for( p = overflowHeader->next, i = 1; p != overflowHeader; p = p->next, i++ ) 
                                if( p->point.x > x ) break;
                        }
                        overflowPoint->index = lessThanEqualXPoint.index + i;
                    }
                }
                overflowPoint->next = overflowPoint->prior->next;
                overflowPoint->prior->next = overflowPoint;
                overflowPoint->next->prior = overflowPoint;
                point = &(overflowPoint->point);
                for( overflowPoint = overflowPoint->next; overflowPoint != overflowHeader; overflowPoint = overflowPoint->next ) {
                    overflowPoint->index++;
                }
                ptwXY->overflowLength++;
            }
        }
        break;
    case ptwXY_lessEqualGreaterX_empty :
        point = ptwXY->points;                 /* ptwXY_minimumSize must be > 0 so there is always space here. */
        break;
    case ptwXY_lessEqualGreaterX_equal :
        if( closeIsEqual && !override ) return( nfu_Okay );
        if( lessThanEqualXPoint.next == NULL ) {
            point = &(ptwXY->points[lessThanEqualXPoint.index]); }
        else {
            point = &(lessThanEqualXPoint.prior->next->point);
        }
        break;
    }
 
    point->x = x;
    point->y = y;
    if( legx != ptwXY_lessEqualGreaterX_equal ) ptwXY->length++;
    return( nfu_Okay );
}

Referenced by ptwXY_createFromFunction(), and ptwXY_setValueAtX().

ptwXY_setXYData()

nfu_status ptwXY_setXYData	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		int64_t	length,
		double const *	xy )

Definition at line 866 of file ptwXY_core.c.

                                                                                                                {
 
    int64_t index;
    ptwXYPoint *p;
    double const *d = xy;
    double priorX = 0.;
 
    if( ptwXY->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Invalid source." );
        return( ptwXY->status );
    }
 
    if( length > ptwXY->allocatedSize ) {
        if( ptwXY_reallocatePoints( smr, ptwXY, length, 0 ) != nfu_Okay ) {
            smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
            return( ptwXY->status );
        }
    }
    for( index = 0, p = ptwXY->points; index < length; index++, p++ ) {
        if( index != 0 ) {
            if( *d <= priorX ) {
                smr_setReportError2( smr, nfu_SMR_libraryID, nfu_XNotAscending, 
                        "X value at index = %d of %.17e is <= prior value of %.17e", (int) index, *d, priorX );
                ptwXY->status = nfu_XNotAscending;
                length = 0;
                break;
            }
        }
        priorX = *d;
        p->x = *(d++);
        p->y = *(d++);
    }
    ptwXY->overflowHeader.next = &(ptwXY->overflowHeader);
    ptwXY->overflowHeader.prior = &(ptwXY->overflowHeader);
    ptwXY->overflowLength = 0;
    ptwXY->length = length;
    return( ptwXY->status );
}

Referenced by ptwXY_create().

ptwXY_setXYDataFromXsAndYs()

nfu_status ptwXY_setXYDataFromXsAndYs	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		int64_t	length,
		double const *	x,
		double const *	y )

Definition at line 907 of file ptwXY_core.c.

                                           {
 
    int64_t i;
    ptwXYPoint *p;
    double xOld = 0.;
 
    if( ptwXY_clear( smr, ptwXY ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( ptwXY->status );
    }
 
    if( length > ptwXY->allocatedSize ) {
        if( ptwXY_reallocatePoints( smr, ptwXY, length, 0 ) != nfu_Okay ) {
            smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
            return( ptwXY->status );
        }
    }
    for( i = 0, p = ptwXY->points; i < length; i++, p++, x++, y++ ) {
        if( i != 0 ) {
            if( *x <= xOld ) {
                ptwXY->status = nfu_XNotAscending;
                length = 0;
                break;
            }
        }
        xOld = *x;
        p->x = *x;
        p->y = *y;
    }
    ptwXY->length = length;
    return( ptwXY->status );
}

ptwXY_setXYPairAtIndex()

nfu_status ptwXY_setXYPairAtIndex	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		int64_t	index,
		double	x,
		double	y )

Definition at line 1484 of file ptwXY_core.c.

                                                                                                                        {
 
    int64_t i, ip1;
    ptwXYOverflowPoint *overflowPoint, *pm1, *pp1;
 
    if( ptwXY->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Invalid source." );
        return( ptwXY->status );
    }
 
    if( ( index < 0 ) || ( index >= ptwXY->length ) ) {
        smr_setReportError2( smr, nfu_SMR_libraryID, nfu_badIndex, "Index = %d, out of bounds: length = %d",
                (int) index, (int) ptwXY->length );
        return( ptwXY->status = nfu_badIndex );
    }
 
    for( overflowPoint = ptwXY->overflowHeader.next, i = 0; overflowPoint != &(ptwXY->overflowHeader); overflowPoint = overflowPoint->next, i++ ) {
        if( overflowPoint->index >= index ) break;
    }
    ip1 = i;
    pm1 = pp1 = overflowPoint;
    if( overflowPoint->index == index ) {                                           /* Note, if overflowPoint is header, then its index = -1. */
        pp1 = overflowPoint->next;
        ip1++;
    }
    if( ( pp1 != &(ptwXY->overflowHeader) ) && ( pp1->index == ( index + 1 ) ) ) {     /* This if and else check that x < element[index+1]'s x values. */
        if( pp1->point.x <= x ) return( nfu_badIndexForX ); }
    else {
        if( ( ( index + 1 ) < ptwXY->length ) && ( ptwXY->points[index + 1 - ip1].x <= x ) ) return( nfu_badIndexForX );
    }
    if( overflowPoint != &(ptwXY->overflowHeader) ) pm1 = overflowPoint->prior;
    if( ( pm1 != &(ptwXY->overflowHeader) ) && ( pm1->index == ( index - 1 ) ) ) {     /* This if and else check that x > element[index-1]'s x values. */
        if( pm1->point.x >= x ) return( nfu_badIndexForX ); }
    else {
        if( ( ( index - 1 ) >= 0 ) && ( ptwXY->points[index - 1 - i].x >= x ) ) return( nfu_badIndexForX );
    }
    if( ( overflowPoint != &(ptwXY->overflowHeader) ) && ( overflowPoint->index == index ) ) {
        overflowPoint->point.x = x;
        overflowPoint->point.y = y; }
    else {
        index -= i;
        ptwXY->points[index].x = x;
        ptwXY->points[index].y = y;
    }
    return( nfu_Okay );
}

ptwXY_simpleCoalescePoints()

nfu_status ptwXY_simpleCoalescePoints	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY )

Definition at line 734 of file ptwXY_core.c.

                                                                                         {
 
    if( ptwXY_coalescePoints( smr, ptwXY, ptwXY->length, NULL, 0 ) != nfu_Okay )
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
    return( ptwXY->status );
}

Referenced by ptwXY_applyFunction(), ptwXY_clip(), ptwXY_convolution(), ptwXY_copyToC_XY(), ptwXY_createFromFunction(), ptwXY_deletePoints(), ptwXY_div_ptwXY(), ptwXY_exp(), ptwXY_flatInterpolationToLinear(), ptwXY_getLowerIndexBoundingX(), ptwXY_getXArray(), ptwXY_groupOneFunction(), ptwXY_groupThreeFunctions(), ptwXY_groupTwoFunctions(), ptwXY_integrate(), ptwXY_integrateWithFunction(), ptwXY_integrateWithWeight_sqrt_x(), ptwXY_integrateWithWeight_x(), ptwXY_intersectionWith_ptwX(), ptwXY_inverse(), ptwXY_mergeClosePoints(), ptwXY_mul2_ptwXY(), ptwXY_runningIntegral(), ptwXY_scaleAndOffsetDomainWith_ptwXYs(), ptwXY_scaleOffsetXAndY(), ptwXY_slice(), ptwXY_startIndex(), ptwXY_thicken(), ptwXY_thin(), ptwXY_thinDomain(), ptwXY_toOtherInterpolation(), ptwXY_trim(), ptwXY_union(), ptwXY_valuesToC_XsAndYs(), and ptwXY_ysMappedToXs().

ptwXY_slice()

ptwXYPoints * ptwXY_slice	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		int64_t	index1,
		int64_t	index2,
		int64_t	secondarySize )

Definition at line 388 of file ptwXY_core.c.

                                                                                                                                   {
 
    int64_t i, length;
    ptwXYPoints *n;
 
    if( ptwXY->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Invalid source." );
        return( NULL );
    }
 
    if( ( index1 < 0 ) || ( index2 < index1 ) || ( index2 > ptwXY->length ) ) {
        smr_setReportError2( smr, nfu_SMR_libraryID, nfu_badIndex, "Indices = %d, %d out of bounds: length = %d",
                (int) index1, (int) index2, (int) ptwXY->length );
        return( NULL );
    }
 
    length = index2 - index1;
    if( ptwXY_simpleCoalescePoints( smr, ptwXY ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( NULL );
    }
    if( ( n = ptwXY_new( smr, ptwXY->interpolation, ptwXY->interpolationString, ptwXY->biSectionMax, 
            ptwXY->accuracy, length, secondarySize, ptwXY->userFlag ) ) == NULL ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( NULL );
    }
 
    for( i = index1; i < index2; i++ ) n->points[i - index1] = ptwXY->points[i];
    n->length = length;
    return( n );
}

Referenced by ptwXY_clone().

ptwXY_startIndex()

nfu_status ptwXY_startIndex	(	statusMessageReporting *	a_smr,
		ptwXYPoints *	a_ptwXY,
		double	a_x,
		int64_t *	a_startIndex,
		int64_t *	a_length )

Definition at line 818 of file ptwXY_core.c.

                                                                                                                                         {
/*
    Sets *a_startIndex to -2 if a_x < domainMin, -1 if a_x > domainMax, otherwise to the lowest index in a_ptwXY->points 
where a_x >= a_ptwXY->points[*a_startIndex]. The logic below guarantees that *a_startIndex < (*a_length - 1 ). For example, if
a_x == domainMax, then *a_startIndex = *a_length - 2, or the next to the last point.
*/
 
    int64_t lower = 0, mid, upper;
    ptwXYPoint *point;
    *a_length = ptwXY_length( NULL, a_ptwXY );
 
    if( ptwXY_simpleCoalescePoints( a_smr, a_ptwXY ) != nfu_Okay ) { 
        smr_setReportError2p( a_smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( a_ptwXY->status );
    }
 
    if( *a_length < 2 ) {
        smr_setReportError2( a_smr, nfu_SMR_libraryID, nfu_tooFewPoints, "number of points = %lld < 2", *a_length );
        return( nfu_tooFewPoints );
    }
 
    *a_startIndex = -2;
    point = &a_ptwXY->points[lower];
    if( a_x < point->x ) return( nfu_Okay );
 
    upper = *a_length - 1;
    *a_startIndex = -1;
    point = &a_ptwXY->points[upper];
    if( a_x > point->x ) return( nfu_Okay );
 
    while( 1 ) {
        mid = ( lower + upper ) >> 1;
        if( mid == lower ) break;
        point = &a_ptwXY->points[mid];
        if( a_x < point->x ) {
            upper = mid; }
        else {
            lower = mid;
        }
    }
 
    *a_startIndex = mid;
    return( nfu_Okay );
}

Referenced by ptwXY_mapToXsAndAdd().

ptwXY_stringToInterpolation()

ptwXY_interpolation ptwXY_stringToInterpolation

(

char const *

interpolationString

)

Definition at line 1796 of file ptwXY_core.c.

                                                                                   {
 
    if( strcmp( interpolationString, "" ) == 0 ) return( ptwXY_interpolationLinLin );
    if( strcmp( interpolationString, linLinInterpolationString ) == 0 ) return( ptwXY_interpolationLinLin );
    if( strcmp( interpolationString, logLinInterpolationString ) == 0 ) return( ptwXY_interpolationLogLin );
    if( strcmp( interpolationString, linLogInterpolationString ) == 0 ) return( ptwXY_interpolationLinLog );
    if( strcmp( interpolationString, logLogInterpolationString ) == 0 ) return( ptwXY_interpolationLogLog );
    if( strcmp( interpolationString, flatInterpolationString ) == 0 ) return( ptwXY_interpolationFlat );
    return( ptwXY_interpolationOther );
}

Referenced by MCGIDI::Distributions::CoherentElasticTNSL::CoherentElasticTNSL(), and ptwXY_setInterpolationString().