ptwXY.h File Reference

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

Go to the source code of this file.

Classes
struct	ptwXYPoint_s
struct	ptwXYOverflowPoint_s
struct	ptwXYPoints_s

Macros
#define	ptwXY_minimumSize   10 /* This must be > 0 otherwise some logic will fail. */
#define	ptwXY_minimumOverflowSize   4 /* This must be > 0 otherwise some logic will fail. */
#define	ptwXY_maxBiSectionMax   20
#define	ptwXY_minAccuracy   1e-14
#define	ptwXY_sectionSubdivideMax   1 << 16
#define	ClosestAllowXFactor   10
#define	ptwXY_union_fill   1 /* If filling, union is filled with y value of first ptw. */
#define	ptwXY_union_trim   2 /* If trimming, union in only over common domain of ptw1 and ptw2. */
#define	ptwXY_union_mergeClosePoints   4 /* If true, union calls ptwXY_mergeClosePoints with eps = 4 * DBL_EPSILON. */

Typedefs
typedef enum ptwXY_dataFrom_e	ptwXY_dataFrom
typedef enum ptwXY_group_normType_e	ptwXY_group_normType
typedef enum ptwXY_interpolation_e	ptwXY_interpolation
typedef enum ptwXY_lessEqualGreaterX_e	ptwXY_lessEqualGreaterX
typedef struct ptwXYPoint_s	ptwXYPoint
typedef nfu_status(*	ptwXY_createFromFunction_callback) (statusMessageReporting *smr, double x, double *y, void *argList)
typedef nfu_status(*	ptwXY_applyFunction_callback) (statusMessageReporting *smr, ptwXYPoint *point, void *argList)
typedef struct ptwXYOverflowPoint_s	ptwXYOverflowPoint
typedef struct ptwXYPoints_s	ptwXYPoints

Enumerations
enum	ptwXY_dataFrom_e { ptwXY_dataFrom_Unknown , ptwXY_dataFrom_Points , ptwXY_dataFrom_Overflow }
enum	ptwXY_group_normType_e { ptwXY_group_normType_none , ptwXY_group_normType_dx , ptwXY_group_normType_norm }
enum	ptwXY_interpolation_e {   ptwXY_interpolationLinLin , ptwXY_interpolationLogLin , ptwXY_interpolationLinLog , ptwXY_interpolationLogLog ,   ptwXY_interpolationFlat , ptwXY_interpolationOther }
enum	ptwXY_lessEqualGreaterX_e {   ptwXY_lessEqualGreaterX_empty , ptwXY_lessEqualGreaterX_lessThan , ptwXY_lessEqualGreaterX_equal , ptwXY_lessEqualGreaterX_between ,   ptwXY_lessEqualGreaterX_greater , ptwXY_lessEqualGreaterX_Error }

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, char side, double *slope)
nfu_status	ptwXY_domainMinAndFrom (statusMessageReporting *smr, ptwXYPoints *ptwXY, ptwXY_dataFrom *dataFrom, double *value)
nfu_status	ptwXY_domainMin (statusMessageReporting *smr, ptwXYPoints *ptwXY, double *value)
nfu_status	ptwXY_domainMaxAndFrom (statusMessageReporting *smr, ptwXYPoints *ptwXY, ptwXY_dataFrom *dataFrom, double *value)
nfu_status	ptwXY_domainMax (statusMessageReporting *smr, ptwXYPoints *ptwXY, double *value)
nfu_status	ptwXY_range (statusMessageReporting *smr, ptwXYPoints *ptwXY, double *rangeMin, double *rangeMax)
nfu_status	ptwXY_rangeMin (statusMessageReporting *smr, ptwXYPoints *ptwXY, double *value)
nfu_status	ptwXY_rangeMax (statusMessageReporting *smr, ptwXYPoints *ptwXY, double *value)
char const *	ptwXY_interpolationToString (ptwXY_interpolation interpolation)
ptwXY_interpolation	ptwXY_stringToInterpolation (char const *interpolationString)
nfu_status	ptwXY_clip (statusMessageReporting *smr, ptwXYPoints *ptwXY1, double rangeMin, double rangeMax)
nfu_status	ptwXY_thicken (statusMessageReporting *smr, ptwXYPoints *ptwXY1, int sectionSubdivideMax, double dDomainMax, double fDomainMax)
ptwXYPoints *	ptwXY_thin (statusMessageReporting *smr, ptwXYPoints *ptwXY1, double accuracy)
ptwXYPoints *	ptwXY_thinDomain (statusMessageReporting *smr, ptwXYPoints *ptwXY1, double epsilon)
nfu_status	ptwXY_trim (statusMessageReporting *smr, ptwXYPoints *ptwXY)
ptwXYPoints *	ptwXY_union (statusMessageReporting *smr, ptwXYPoints *ptwXY1, ptwXYPoints *ptwXY2, int unionOptions)
nfu_status	ptwXY_scaleOffsetXAndY (statusMessageReporting *smr, ptwXYPoints *ptwXY, double xScale, double xOffset, double yScale, double yOffset)
nfu_status	ptwXY_scaleAndOffsetDomainWith_ptwXYs (statusMessageReporting *smr, ptwXYPoints *ptwXY, ptwXYPoints *offset, ptwXYPoints *slope, int skipLastPoint)
nfu_status	ptwXY_abs (statusMessageReporting *smr, ptwXYPoints *ptwXY)
nfu_status	ptwXY_neg (statusMessageReporting *smr, ptwXYPoints *ptwXY)
nfu_status	ptwXY_slopeOffset (statusMessageReporting *smr, ptwXYPoints *ptwXY, double slope, double offset)
nfu_status	ptwXY_add_double (statusMessageReporting *smr, ptwXYPoints *ptwXY, double value)
nfu_status	ptwXY_sub_doubleFrom (statusMessageReporting *smr, ptwXYPoints *ptwXY, double value)
nfu_status	ptwXY_sub_fromDouble (statusMessageReporting *smr, ptwXYPoints *ptwXY, double value)
nfu_status	ptwXY_mul_double (statusMessageReporting *smr, ptwXYPoints *ptwXY, double value)
nfu_status	ptwXY_div_doubleFrom (statusMessageReporting *smr, ptwXYPoints *ptwXY, double value)
nfu_status	ptwXY_div_fromDouble (statusMessageReporting *smr, ptwXYPoints *ptwXY, double value)
nfu_status	ptwXY_mod (statusMessageReporting *smr, ptwXYPoints *ptwXY, double m, int pythonMod)
ptwXYPoints *	ptwXY_binary_ptwXY (statusMessageReporting *smr, ptwXYPoints *ptwXY1, ptwXYPoints *ptwXY2, double v1, double v2, double v1v2)
ptwXYPoints *	ptwXY_add_ptwXY (statusMessageReporting *smr, ptwXYPoints *ptwXY1, ptwXYPoints *ptwXY2)
ptwXYPoints *	ptwXY_sub_ptwXY (statusMessageReporting *smr, ptwXYPoints *ptwXY1, ptwXYPoints *ptwXY2)
ptwXYPoints *	ptwXY_mul_ptwXY (statusMessageReporting *smr, ptwXYPoints *ptwXY1, ptwXYPoints *ptwXY2)
ptwXYPoints *	ptwXY_mul2_ptwXY (statusMessageReporting *smr, ptwXYPoints *ptwXY1, ptwXYPoints *ptwXY2)
ptwXYPoints *	ptwXY_div_ptwXY (statusMessageReporting *smr, ptwXYPoints *ptwXY1, ptwXYPoints *ptwXY2, int safeDivide)
nfu_status	ptwXY_pow (statusMessageReporting *smr, ptwXYPoints *ptwXY, double p)
nfu_status	ptwXY_exp (statusMessageReporting *smr, ptwXYPoints *ptwXY, double a)
ptwXYPoints *	ptwXY_convolution (statusMessageReporting *smr, ptwXYPoints *ptwXY1, ptwXYPoints *ptwXY2, int mode)
ptwXYPoints *	ptwXY_inverse (statusMessageReporting *smr, ptwXYPoints *ptwXY)
nfu_status	ptwXY_interpolatePoint (statusMessageReporting *smr, ptwXY_interpolation interpolation, double x, double *y, double x1, double y1, double x2, double y2)
ptwXYPoints *	ptwXY_flatInterpolationToLinear (statusMessageReporting *smr, ptwXYPoints *ptwXY, double lowerEps, double upperEps)
ptwXYPoints *	ptwXY_toOtherInterpolation (statusMessageReporting *smr, ptwXYPoints *ptwXY, ptwXY_interpolation interpolation, double accuracy)
ptwXYPoints *	ptwXY_unitbaseInterpolate (statusMessageReporting *smr, double w, double w1, ptwXYPoints *ptwXY1, double w2, ptwXYPoints *ptwXY2, int scaleRange)
ptwXYPoints *	ptwXY_toUnitbase (statusMessageReporting *smr, ptwXYPoints *ptwXY, int scaleRange)
ptwXYPoints *	ptwXY_fromUnitbase (statusMessageReporting *smr, ptwXYPoints *ptwXY, double domainMin, double domainMax, int scaleRange)
ptwXPoints *	ptwXY_getXArray (statusMessageReporting *smr, ptwXYPoints *ptwXY)
ptwXPoints *	ptwXY_ysMappedToXs (statusMessageReporting *smr, ptwXYPoints *ptwXY, ptwXPoints *Xs, int64_t *offset)
nfu_status	ptwXY_mapToXsAndAdd (statusMessageReporting *a_smr, ptwXYPoints *a_ptwXY, int64_t a_offset, int64_t a_length, double const *a_Xs, double *a_results, double a_scaleFractor)
nfu_status	ptwXY_dullEdges (statusMessageReporting *smr, ptwXYPoints *ptwXY, double lowerEps, double upperEps, int positiveXOnly)
nfu_status	ptwXY_mergeClosePoints (statusMessageReporting *smr, ptwXYPoints *ptwXY, double epsilon)
ptwXYPoints *	ptwXY_intersectionWith_ptwX (statusMessageReporting *smr, ptwXYPoints *ptwXY, ptwXPoints *ptwX)
nfu_status	ptwXY_areDomainsMutual (statusMessageReporting *smr, ptwXYPoints *ptwXY1, ptwXYPoints *ptwXY2)
nfu_status	ptwXY_tweakDomainsToMutualify (statusMessageReporting *smr, ptwXYPoints *ptwXY1, ptwXYPoints *ptwXY2, int epsilonFactor, double epsilon)
nfu_status	ptwXY_mutualifyDomains (statusMessageReporting *smr, ptwXYPoints *ptwXY1, double lowerEps1, double upperEps1, int positiveXOnly1, ptwXYPoints *ptwXY2, double lowerEps2, double upperEps2, int positiveXOnly2)
nfu_status	ptwXY_copyToC_XY (statusMessageReporting *smr, ptwXYPoints *ptwXY, int64_t index1, int64_t index2, int64_t allocatedSize, int64_t *numberOfPoints, double *xy)
nfu_status	ptwXY_valuesToC_XsAndYs (statusMessageReporting *smr, ptwXYPoints *ptwXY, double **xs, double **ys)
ptwXYPoints *	ptwXY_valueTo_ptwXY (statusMessageReporting *smr, double x1, double x2, double y)
ptwXYPoints *	ptwXY_createGaussianCenteredSigma1 (statusMessageReporting *smr, double accuracy)
ptwXYPoints *	ptwXY_createGaussian (statusMessageReporting *smr, double accuracy, double xCenter, double sigma, double amplitude, double domainMin, double domainMax, double dullEps)
double	ptwXY_limitAccuracy (double accuracy)
void	ptwXY_update_biSectionMax (ptwXYPoints *ptwXY1, double oldLength)
ptwXYPoints *	ptwXY_createFromFunction (statusMessageReporting *smr, int n, double *xs, ptwXY_createFromFunction_callback func, void *argList, double accuracy, int checkForRoots, int biSectionMax)
ptwXYPoints *	ptwXY_createFromFunction2 (statusMessageReporting *smr, ptwXPoints *xs, ptwXY_createFromFunction_callback func, void *argList, double accuracy, int checkForRoots, int biSectionMax)
nfu_status	ptwXY_applyFunction (statusMessageReporting *smr, ptwXYPoints *ptwXY1, ptwXY_applyFunction_callback func, void *argList, int checkForRoots)
ptwXYPoints *	ptwXY_fromString (statusMessageReporting *smr, char const *str, char sep, ptwXY_interpolation interpolation, char const *interpolationString, double biSectionMax, double accuracy, char **endCharacter, int useSystem_strtod)
void	ptwXY_showInteralStructure (ptwXYPoints *ptwXY, FILE *f, int printPointersAsNull)
void	ptwXY_simpleWrite (ptwXYPoints *ptwXY, FILE *f, char const *format)
void	ptwXY_simplePrint (ptwXYPoints *ptwXY, char const *format)
nfu_status	ptwXY_f_integrate (statusMessageReporting *smr, ptwXY_interpolation interpolation, double x1, double y1, double x2, double y2, double *value)
nfu_status	ptwXY_integrate (statusMessageReporting *smr, ptwXYPoints *ptwXY, double domainMin, double domainMax, double *value)
nfu_status	ptwXY_integrateDomain (statusMessageReporting *smr, ptwXYPoints *ptwXY, double *value)
nfu_status	ptwXY_normalize (statusMessageReporting *smr, ptwXYPoints *ptwXY1)
nfu_status	ptwXY_integrateDomainWithWeight_x (statusMessageReporting *smr, ptwXYPoints *ptwXY, double *value)
nfu_status	ptwXY_integrateWithWeight_x (statusMessageReporting *smr, ptwXYPoints *ptwXY, double domainMin, double domainMax, double *value)
nfu_status	ptwXY_integrateDomainWithWeight_sqrt_x (statusMessageReporting *smr, ptwXYPoints *ptwXY, double *value)
nfu_status	ptwXY_integrateWithWeight_sqrt_x (statusMessageReporting *smr, ptwXYPoints *ptwXY, double domainMin, double domainMax, double *value)
ptwXPoints *	ptwXY_groupOneFunction (statusMessageReporting *smr, ptwXYPoints *ptwXY, ptwXPoints *groupBoundaries, ptwXY_group_normType normType, ptwXPoints *ptwX_norm)
ptwXPoints *	ptwXY_groupTwoFunctions (statusMessageReporting *smr, ptwXYPoints *ptwXY1, ptwXYPoints *ptwXY2, ptwXPoints *groupBoundaries, ptwXY_group_normType normType, ptwXPoints *ptwX_norm)
ptwXPoints *	ptwXY_groupThreeFunctions (statusMessageReporting *smr, ptwXYPoints *ptwXY1, ptwXYPoints *ptwXY2, ptwXYPoints *ptwXY3, ptwXPoints *groupBoundaries, ptwXY_group_normType normType, ptwXPoints *ptwX_norm)
ptwXPoints *	ptwXY_runningIntegral (statusMessageReporting *smr, ptwXYPoints *ptwXY)
nfu_status	ptwXY_integrateWithFunction (statusMessageReporting *smr, ptwXYPoints *ptwXY, ptwXY_createFromFunction_callback func, void *argList, double domainMin, double domainMax, int degree, int recursionLimit, double tolerance, double *value)
ptwXPoints *	ptwXY_equalProbableBins (statusMessageReporting *smr, ptwXYPoints *ptwXY, int numberOfBins)

Macro Definition Documentation

ClosestAllowXFactor

#define ClosestAllowXFactor   10

Definition at line 28 of file ptwXY.h.

Referenced by ptwXY_createFromFunction().

ptwXY_maxBiSectionMax

#define ptwXY_maxBiSectionMax   20

Definition at line 25 of file ptwXY.h.

Referenced by ptwXY_initialize(), ptwXY_setBiSectionMax(), ptwXY_update_biSectionMax(), and ptwXY_valueTo_ptwXY().

ptwXY_minAccuracy

#define ptwXY_minAccuracy   1e-14

Definition at line 26 of file ptwXY.h.

Referenced by ptwXY_initialize(), ptwXY_limitAccuracy(), and ptwXY_valueTo_ptwXY().

ptwXY_minimumOverflowSize

#define ptwXY_minimumOverflowSize   4 /* This must be > 0 otherwise some logic will fail. */

Definition at line 24 of file ptwXY.h.

Referenced by ptwXY_reallocateOverflowPoints().

ptwXY_minimumSize

#define ptwXY_minimumSize   10 /* This must be > 0 otherwise some logic will fail. */

Definition at line 23 of file ptwXY.h.

Referenced by ptwXY_reallocatePoints(), and ptwXY_union().

ptwXY_sectionSubdivideMax

#define ptwXY_sectionSubdivideMax   1 << 16

Definition at line 27 of file ptwXY.h.

Referenced by ptwXY_thicken().

ptwXY_union_fill

#define ptwXY_union_fill   1 /* If filling, union is filled with y value of first ptw. */

Definition at line 34 of file ptwXY.h.

Referenced by ptwXY_binary_ptwXY(), ptwXY_div_ptwXY(), ptwXY_groupThreeFunctions(), ptwXY_groupTwoFunctions(), and ptwXY_union().

ptwXY_union_mergeClosePoints

#define ptwXY_union_mergeClosePoints   4 /* If true, union calls ptwXY_mergeClosePoints with eps = 4 * DBL_EPSILON. */

Definition at line 36 of file ptwXY.h.

Referenced by ptwXY_binary_ptwXY(), ptwXY_div_ptwXY(), and ptwXY_union().

ptwXY_union_trim

#define ptwXY_union_trim   2 /* If trimming, union in only over common domain of ptw1 and ptw2. */

Definition at line 35 of file ptwXY.h.

Referenced by ptwXY_union().

Typedef Documentation

ptwXY_applyFunction_callback

typedef nfu_status(* ptwXY_applyFunction_callback) (statusMessageReporting *smr, ptwXYPoint *point, void *argList)

Definition at line 68 of file ptwXY.h.

ptwXY_createFromFunction_callback

typedef nfu_status(* ptwXY_createFromFunction_callback) (statusMessageReporting *smr, double x, double *y, void *argList)

Definition at line 67 of file ptwXY.h.

ptwXY_dataFrom

typedef enum ptwXY_dataFrom_e ptwXY_dataFrom

ptwXY_group_normType

typedef enum ptwXY_group_normType_e ptwXY_group_normType

ptwXY_interpolation

typedef enum ptwXY_interpolation_e ptwXY_interpolation

ptwXY_lessEqualGreaterX

typedef enum ptwXY_lessEqualGreaterX_e ptwXY_lessEqualGreaterX

ptwXYOverflowPoint

typedef struct ptwXYOverflowPoint_s ptwXYOverflowPoint

ptwXYPoint

typedef struct ptwXYPoint_s ptwXYPoint

ptwXYPoints

typedef struct ptwXYPoints_s ptwXYPoints

Enumeration Type Documentation

ptwXY_dataFrom_e

enum ptwXY_dataFrom_e

Enumerator
ptwXY_dataFrom_Unknown
ptwXY_dataFrom_Points
ptwXY_dataFrom_Overflow

Definition at line 30 of file ptwXY.h.

{ ptwXY_dataFrom_Unknown, ptwXY_dataFrom_Points, ptwXY_dataFrom_Overflow } ptwXY_dataFrom;

ptwXY_group_normType_e

enum ptwXY_group_normType_e

Enumerator
ptwXY_group_normType_none
ptwXY_group_normType_dx
ptwXY_group_normType_norm

Definition at line 31 of file ptwXY.h.

{ ptwXY_group_normType_none, ptwXY_group_normType_dx, ptwXY_group_normType_norm } ptwXY_group_normType;

ptwXY_interpolation_e

enum ptwXY_interpolation_e

Enumerator
ptwXY_interpolationLinLin
ptwXY_interpolationLogLin
ptwXY_interpolationLinLog
ptwXY_interpolationLogLog
ptwXY_interpolationFlat
ptwXY_interpolationOther

Definition at line 37 of file ptwXY.h.

                                   { ptwXY_interpolationLinLin, ptwXY_interpolationLogLin, ptwXY_interpolationLinLog, 
    ptwXY_interpolationLogLog, ptwXY_interpolationFlat, ptwXY_interpolationOther } ptwXY_interpolation;

ptwXY_lessEqualGreaterX_e

enum ptwXY_lessEqualGreaterX_e

Enumerator
ptwXY_lessEqualGreaterX_empty
ptwXY_lessEqualGreaterX_lessThan
ptwXY_lessEqualGreaterX_equal
ptwXY_lessEqualGreaterX_between
ptwXY_lessEqualGreaterX_greater
ptwXY_lessEqualGreaterX_Error

Definition at line 59 of file ptwXY.h.

                                       { ptwXY_lessEqualGreaterX_empty, ptwXY_lessEqualGreaterX_lessThan, ptwXY_lessEqualGreaterX_equal,
    ptwXY_lessEqualGreaterX_between, ptwXY_lessEqualGreaterX_greater, ptwXY_lessEqualGreaterX_Error } ptwXY_lessEqualGreaterX;

Function Documentation

ptwXY_abs()

nfu_status ptwXY_abs	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY )

Definition at line 18 of file ptwXY_unitaryOperators.c.

                                                                        {
 
    int64_t i, nonOverflowLength;
    ptwXYPoint *p;
    ptwXYOverflowPoint *o, *overflowHeader = &(ptwXY->overflowHeader);
 
    if( ( nonOverflowLength = ptwXY_getNonOverflowLength( smr, ptwXY ) ) < 0 ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( ptwXY->status );
    }
 
    for( i = 0, p = ptwXY->points; i < nonOverflowLength; i++, p++ ) p->y = fabs( p->y );
    for( o = overflowHeader->next; o != overflowHeader; o = o->next ) o->point.y = fabs( o->point.y );
    return( ptwXY->status );
}

ptwXY_add_double()

nfu_status ptwXY_add_double	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		double	value )

Definition at line 45 of file ptwXY_binaryOperators.c.

                                                                                             {
    
    if( ptwXY_slopeOffset( smr, ptwXY, 1., value ) != nfu_Okay )
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
    return( ptwXY->status );
}

ptwXY_add_ptwXY()

ptwXYPoints * ptwXY_add_ptwXY	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY1,
		ptwXYPoints *	ptwXY2 )

Definition at line 228 of file ptwXY_binaryOperators.c.

                                                                                                      {
 
    ptwXYPoints *sum;
 
    if( ptwXY1->length == 0 ) {
        sum = ptwXY_clone( smr, ptwXY2 ); }
    else if( ptwXY2->length == 0 ) {
        sum = ptwXY_clone( smr, ptwXY1 ); }
    else {
        sum = ptwXY_binary_ptwXY( smr, ptwXY1, ptwXY2, 1., 1., 0. );
    }
    if( sum == NULL ) smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
    return( sum );
}

Referenced by GIDI::Functions::XYs1d::operator+=(), and ptwXY_unitbaseInterpolate().

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_applyFunction()

nfu_status ptwXY_applyFunction	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY1,
		ptwXY_applyFunction_callback	func,
		void *	argList,
		int	checkForRoots )

Definition at line 165 of file ptwXY_misc.c.

                                           {
 
    int64_t i, originalLength = ptwXY1->length, notFirstPass = 0;
    double y1, y2 = 0;
    nfu_status status;
    ptwXYPoint p1, p2;
 
    checkForRoots = checkForRoots && ptwXY1->biSectionMax;
 
    if( ptwXY1->interpolation == ptwXY_interpolationOther ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_otherInterpolation, "Other interpolation not allowed." );
        return( ptwXY1->status = nfu_otherInterpolation );
    }
    if( ptwXY1->interpolation == ptwXY_interpolationFlat ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_flatInterpolation, "Flat interpolation not allowed." );
        return( ptwXY1->status = nfu_flatInterpolation );
    }
 
    if( ptwXY_simpleCoalescePoints( smr, ptwXY1 ) != nfu_Okay ) goto Err;
    for( i = originalLength - 1; i >= 0; i-- ) {
        y1 = ptwXY1->points[i].y;
        if( ( status = func( smr, &(ptwXY1->points[i]), argList ) ) != nfu_Okay ) {
            if( ptwXY1->status == nfu_Okay ) ptwXY1->status = status;
            return( status );
        }
        p1 = ptwXY1->points[i];
        if( notFirstPass ) {
            if( ptwXY_applyFunction2( smr, ptwXY1, y1, y2, &p1, &p2, func, argList, 0, checkForRoots ) != nfu_Okay ) goto Err;
        }
        notFirstPass = 1;
        p2 = p1;
        y2 = y1;
    }
    ptwXY_update_biSectionMax( ptwXY1, (double) originalLength );
    return( status );
 
Err:
    smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
    if( ptwXY1->status == nfu_Okay ) ptwXY1->status = nfu_Error;
    return( nfu_Error );
}

Referenced by ptwXY_pow().

ptwXY_areDomainsMutual()

nfu_status ptwXY_areDomainsMutual	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY1,
		ptwXYPoints *	ptwXY2 )

Definition at line 431 of file ptwXY_convenient.c.

                                                                                                           {
 
    nfu_status status = nfu_Okay;
    int64_t n1 = ptwXY1->length, n2 = ptwXY2->length;
    ptwXYPoint *xy1, *xy2;
 
    if( ptwXY1->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Invalid source1." );
        return( ptwXY1->status );
    }
 
    if( ptwXY2->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Invalid source2." );
        return( ptwXY2->status );
    }
 
    if( n1 == 0 ) return( nfu_empty );
    if( n2 == 0 ) return( nfu_empty );
    if( n1 < 2 ) { 
        status = nfu_tooFewPoints; }
    else if( n2 < 2 ) { 
        status = nfu_tooFewPoints; }
    else {
        xy1 = ptwXY_getPointAtIndex_Unsafely( ptwXY1, 0 );
        xy2 = ptwXY_getPointAtIndex_Unsafely( ptwXY2, 0 );
        if( xy1->x < xy2->x ) {
            if( xy2->y != 0. ) status = nfu_domainsNotMutual; }
        else if( xy1->x > xy2->x ) {
            if( xy1->y != 0. ) status = nfu_domainsNotMutual;
        }
 
        if( status == nfu_Okay ) {
            xy1 = ptwXY_getPointAtIndex_Unsafely( ptwXY1, n1 - 1 );
            xy2 = ptwXY_getPointAtIndex_Unsafely( ptwXY2, n2 - 1 );
            if( xy1->x < xy2->x ) {
                if( xy1->y != 0. ) status = nfu_domainsNotMutual; }
            else if( xy1->x > xy2->x ) {
                if( xy2->y != 0. ) status = nfu_domainsNotMutual;
            }
        }
    }
    return( status );
}

Referenced by ptwXY_binary_ptwXY(), ptwXY_div_ptwXY(), and ptwXY_mutualifyDomains().

ptwXY_binary_ptwXY()

ptwXYPoints * ptwXY_binary_ptwXY	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY1,
		ptwXYPoints *	ptwXY2,
		double	v1,
		double	v2,
		double	v1v2 )

Definition at line 165 of file ptwXY_binaryOperators.c.

                                            {
 
    int64_t i;
    int unionOptions = ptwXY_union_fill | ptwXY_union_mergeClosePoints;
    double y;
    ptwXYPoints *ptwXYNew;
    ptwXYPoint *p;
 
    if( ptwXY1->interpolation == ptwXY_interpolationOther ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_otherInterpolation, "Source1: Other interpolation not allowed." );
        return( NULL );
    }
    if( ptwXY2->interpolation == ptwXY_interpolationOther ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_otherInterpolation, "Source2: Other interpolation not allowed." );
        return( NULL );
    }
 
    if( ptwXY1->interpolation != ptwXY2->interpolation ) {
        smr_setReportError2( smr, nfu_SMR_libraryID, nfu_invalidInterpolation, 
                "Source1 interpolation '%s' not same as Source2 interpolation '%s'.",
                    ptwXY1->interpolationString, ptwXY2->interpolationString );
        return( NULL );
    }
 
    if( ( ptwXY1->interpolation != ptwXY_interpolationLinLin ) && ( ptwXY1->interpolation != ptwXY_interpolationLinLog ) &&
            ( ptwXY1->interpolation != ptwXY_interpolationFlat ) ) {
        smr_setReportError2( smr, nfu_SMR_libraryID, nfu_invalidInterpolation,
                "Only '%s' and '%s' interpolation supported, not '%s' interpolation.", ptwXY_interpolationToString( ptwXY_interpolationLinLin ),
                ptwXY_interpolationToString( ptwXY_interpolationFlat ), ptwXY1->interpolationString );
        return( NULL );
    }
 
    if( ptwXY_areDomainsMutual( smr, ptwXY1, ptwXY2 ) != nfu_Okay ) {
        double domainMin1, domainMax1, domainMin2, domainMax2;
 
        ptwXY_domainMin( NULL, ptwXY1, &domainMin1 );
        ptwXY_domainMax( NULL, ptwXY1, &domainMax1 );
        ptwXY_domainMin( NULL, ptwXY2, &domainMin2 );
        ptwXY_domainMax( NULL, ptwXY2, &domainMax2 );
 
        smr_setReportError2( smr, nfu_SMR_libraryID, nfu_domainsNotMutual, "Domains not mutual (%.17e, %.17e) vs (%.17e, %.17e).",
                domainMin1, domainMax1, domainMin2, domainMax2 );
        return( NULL );
    }
 
    if( ( ptwXYNew = ptwXY_union( smr, ptwXY1, ptwXY2, unionOptions ) ) == NULL ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." ); }
    else {
        for( i = 0, p = ptwXYNew->points; i < ptwXYNew->length; i++, p++ ) {
            if( ptwXY_getValueAtX_ignore_XOutsideDomainError( smr, ptwXY2, p->x, &y ) != nfu_Okay ) goto Err;
            p->y = v1 * p->y + v2 * y + v1v2 * y * p->y;
        }
    }
    return( ptwXYNew );
Err:
    smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
    if( ptwXYNew ) ptwXY_free( ptwXYNew );
    return( NULL );
}

Referenced by ptwXY_add_ptwXY(), ptwXY_mul_ptwXY(), and ptwXY_sub_ptwXY().

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_clip()

nfu_status ptwXY_clip	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY1,
		double	rangeMin,
		double	rangeMax )

Definition at line 21 of file ptwXY_methods.c.

                                                                                                            {
/*
    This function acts oddly for xy = [ [ 1, 0 ], [ 3, -2 ], [ 4, 1 ] ] and rangeMin = 0.2, why???????
    This function probably only works for linear, linear interpolation (mainly because of ptwXY_clip2).
*/
    int64_t i, j, n;
    double x2, y2, _rangeMin, _rangeMax;
    ptwXYPoints *clipped;
    ptwXYPoint *points;
 
    if( ptwXY_simpleCoalescePoints( smr, ptwXY1 ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( ptwXY1->status );
    }
 
    if( ptwXY1->interpolation == ptwXY_interpolationOther ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_otherInterpolation, "Other interpolation not allowed." );
        return( nfu_otherInterpolation );
    }
    n = ptwXY1->length;
    if( n > 0 ) {
        i = 0;
        if( ptwXY_range( smr, ptwXY1, &_rangeMin, &_rangeMax ) != nfu_Okay ) {
            smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
            return( nfu_Error );
        }
        if( _rangeMax < rangeMin ) i = 1;
        if( _rangeMin > rangeMax ) i = 1;
        if( i == 1 ) {
            if( ptwXY_clear( smr, ptwXY1 ) != nfu_Okay ) smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
            return( ptwXY1->status );
        }
    }
    if( n == 1 ) {
        y2 = ptwXY1->points[0].y;
        if( y2 < rangeMin ) {
            ptwXY1->points[0].y = rangeMin; }
        else if( y2 > rangeMax ) {
            ptwXY1->points[0].y = rangeMax;
        } }
    else if( n > 1 ) {
        if( ( clipped = ptwXY_new( smr, ptwXY1->interpolation, ptwXY1->interpolationString, 
                ptwXY1->biSectionMax, ptwXY1->accuracy, n, 10, ptwXY1->userFlag ) ) == NULL ) {
            smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
            return( ptwXY1->status );
        }
        for( i = 0; i < n; i++ ) {
            x2 = ptwXY1->points[i].x;
            y2 = ptwXY1->points[i].y;
            if( y2 < rangeMin ) {
                if( i > 0 ) {
                    points = ptwXY_getPointAtIndex_Unsafely( clipped, clipped->length - 1 );
                    if( points->y > rangeMin ) {
                        if( ptwXY_clip2( smr, clipped, rangeMin, points->x, points->y, x2, y2 ) != nfu_Okay ) goto Err;
                    }
                }
                if( ptwXY_setValueAtX( smr, clipped, x2, rangeMin ) != nfu_Okay ) goto Err;
                j = i;
                for( i++; i < n; i++ ) if( !( ptwXY1->points[i].y < rangeMin ) ) break;
                if( i < n ) {
                    x2 = ptwXY1->points[i].x;
                    y2 = ptwXY1->points[i].y;
                    if( ptwXY_clip2( smr, clipped, rangeMin, ptwXY1->points[i-1].x, ptwXY1->points[i-1].y, x2, y2 ) != nfu_Okay ) goto Err;
                    if( y2 > rangeMax ) {
                        if( ptwXY_clip2( smr, clipped, rangeMax, ptwXY1->points[i-1].x, ptwXY1->points[i-1].y, x2, y2 ) != nfu_Okay ) goto Err;
                    } }
                else if( j != n - 1 ) {
                    if( ptwXY_setValueAtX( smr, clipped, ptwXY1->points[n - 1].x, rangeMin ) != nfu_Okay ) goto Err;
                }
                i--; }
            else if( y2 > rangeMax ) {
                if( i > 0 ) {
                    points = ptwXY_getPointAtIndex_Unsafely( clipped, clipped->length - 1 );
                    if( points->y < rangeMax ) {
                        if( ptwXY_clip2( smr, clipped, rangeMax, points->x, points->y, x2, y2 ) != nfu_Okay ) goto Err;
                    }
                }
                if( ptwXY_setValueAtX( smr, clipped, x2, rangeMax ) != nfu_Okay ) goto Err;
                j = i;
                for( i++; i < n; i++ ) if( !( ptwXY1->points[i].y > rangeMax ) ) break;
                if( i < n ) {
                    x2 = ptwXY1->points[i].x;
                    y2 = ptwXY1->points[i].y;
                    if( ptwXY_clip2( smr, clipped, rangeMax, ptwXY1->points[i-1].x, ptwXY1->points[i-1].y, x2, y2 ) != nfu_Okay ) goto Err;
                    if( y2 < rangeMin ) {
                        if( ptwXY_clip2( smr, clipped, rangeMin, ptwXY1->points[i-1].x, ptwXY1->points[i-1].y, x2, y2 ) != nfu_Okay ) goto Err;
                    } }
                else if( j != n - 1 ) {
                    if( ptwXY_setValueAtX( smr, clipped, ptwXY1->points[n - 1].x, rangeMax ) != nfu_Okay ) goto Err;
                }
                i--; }
            else {
                if( ptwXY_setValueAtX( smr, clipped, x2, y2 ) != nfu_Okay ) goto Err;
            }
        }
        if( ptwXY_simpleCoalescePoints( smr, clipped ) != nfu_Okay ) goto Err;
        ptwXY1->length = clipped->length;   /* The squeamish may want to skip the next few lines. */
        clipped->length = n;
        n = ptwXY1->allocatedSize;
        ptwXY1->allocatedSize = clipped->allocatedSize;
        clipped->allocatedSize = n;
        points = clipped->points;
        clipped->points = ptwXY1->points;
        ptwXY1->points = points;
        ptwXY_free( clipped );
    }
 
    return( ptwXY1->status );
 
Err:
    smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
    ptwXY_free( clipped );
    return( ptwXY1->status );
}

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_convolution()

ptwXYPoints * ptwXY_convolution	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY1,
		ptwXYPoints *	ptwXY2,
		int	mode )

Definition at line 111 of file ptwXY_functions.c.

                                                                                                                  {
/*
*   Currently, only supports linear-linear interpolation.
*
*   This function calculates        c(y) = integral dx f1(x) * f2(y-x)
*
*/
    int64_t i1, i2, n1, n2, n;
    ptwXYPoints *f1 = ptwXY1, *f2 = ptwXY2, *convolute;
    double accuracy = ptwXY1->accuracy, rangeMin, rangeMax, c, y, dy;
 
    if( ptwXY_simpleCoalescePoints( smr, ptwXY1 ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via (source1)." );
        return( NULL );
    }
    if( ptwXY_simpleCoalescePoints( smr, ptwXY2 ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via (source2)." );
        return( NULL );
    }
 
    if( ptwXY1->interpolation != ptwXY_interpolationLinLin ) {
        smr_setReportError2( smr, nfu_SMR_libraryID, nfu_unsupportedInterpolation, 
            "Source1: unsupported interpolation = '%s'", ptwXY1->interpolationString );
        return( NULL );
    }
    if( ptwXY2->interpolation != ptwXY_interpolationLinLin ) {
        smr_setReportError2( smr, nfu_SMR_libraryID, nfu_unsupportedInterpolation, 
            "Source2: unsupported interpolation = '%s'", ptwXY2->interpolationString );
        return( NULL );
    }
 
    n1 = f1->length;
    n2 = f2->length;
 
    if( ( n1 == 0 ) || ( n2 == 0 ) ) {
        convolute = ptwXY_new( smr, ptwXY_interpolationLinLin, NULL, 1., accuracy, 0, 0, 0 );
        if( convolute == NULL ) smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( convolute );
    }
 
    if( ( n1 == 1 ) || ( n2 == 1 ) ) {
        smr_setReportError2( smr, nfu_SMR_libraryID, nfu_tooFewPoints,
                "Too few points: len( source1 ) = %d, len( source1 ) = %d.", (int) n1, (int) n2 );
        return( NULL );
    }
 
    if( accuracy < ptwXY2->accuracy ) accuracy = ptwXY2->accuracy;
    n = n1 * n2;
    if( mode == 0 ) {
        mode = 1;
        if( n > 10000 ) mode = -1;
    }
    if( n > 100000 ) mode = -1;
    if( ( convolute = ptwXY_new( smr, ptwXY_interpolationLinLin, NULL, 1., accuracy, 400, 40, 0 ) ) == NULL ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( NULL );
    }
 
    rangeMin = f1->points[0].x + f2->points[0].x;
    rangeMax = f1->points[n1 - 1].x + f2->points[n2 - 1].x;
 
    if( ptwXY_setValueAtX( smr, convolute, rangeMin, 0. ) != nfu_Okay ) goto Err;
 
    if( mode < 0 ) {
        dy = ( rangeMax - rangeMin ) / 2000;
        for( y = rangeMin + dy; y < rangeMax; y += dy ) {
            if( ptwXY_convolution2( smr, f1, f2, y, rangeMin, &c ) != nfu_Okay ) goto Err;
            if( ptwXY_setValueAtX( smr, convolute, y, c ) != nfu_Okay ) goto Err;
        } }
    else {
        for( i1 = 0; i1 < n1; i1++ ) {
            for( i2 = 0; i2 < n2; i2++ ) {
                y = rangeMin + ( f1->points[i1].x - f1->points[0].x ) + ( f2->points[i2].x - f2->points[0].x );
                if( y <= rangeMin ) continue;
                if( y >= rangeMax ) continue;
                if( ptwXY_convolution2( smr, f1, f2, y, rangeMin, &c ) != nfu_Okay ) goto Err;
                if( ptwXY_setValueAtX( smr, convolute, y, c ) != nfu_Okay ) goto Err;
            }
        }
    }
    if( ptwXY_setValueAtX( smr, convolute, rangeMax, 0. ) != nfu_Okay ) goto Err;
    if( ptwXY_simpleCoalescePoints( smr, convolute ) != nfu_Okay ) goto Err;
    for( i1 = convolute->length - 1; i1 > 0; i1-- ) {
        if( ptwXY_convolution3( smr, convolute, f1, f2, convolute->points[i1 - 1].x, convolute->points[i1 - 1].y, 
            convolute->points[i1].x, convolute->points[i1].y, rangeMin ) != nfu_Okay ) goto Err;
    }
 
    return( convolute );
 
Err:
    ptwXY_free( convolute );
    smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
    return( NULL );
}

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_copyToC_XY()

nfu_status ptwXY_copyToC_XY	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		int64_t	index1,
		int64_t	index2,
		int64_t	allocatedSize,
		int64_t *	numberOfPoints,
		double *	xy )

Definition at line 699 of file ptwXY_convenient.c.

                                                                      {
 
    int64_t i;
    double *d = xys;
    ptwXYPoint *pointFrom;
 
    if( ptwXY_simpleCoalescePoints( smr, ptwXY ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Invalid source." );
        return( ptwXY->status );
    }
 
    if( index1 < 0 ) index1 = 0;
    if( index2 > ptwXY->length ) index2 = ptwXY->length;
    if( index2 < index1 ) index2 = index1;
    *numberOfPoints = index2 - index1;
    if( allocatedSize < ( index2 - index1 ) ) return( nfu_insufficientMemory );
 
    for( i = index1, pointFrom = ptwXY->points; i < index2; i++, pointFrom++ ) {
        *(d++) = pointFrom->x;
        *(d++) = pointFrom->y;
    }
 
    return( nfu_Okay );
}

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_createFromFunction()

ptwXYPoints * ptwXY_createFromFunction	(	statusMessageReporting *	smr,
		int	n,
		double *	xs,
		ptwXY_createFromFunction_callback	func,
		void *	argList,
		double	accuracy,
		int	checkForRoots,
		int	biSectionMax )

Definition at line 46 of file ptwXY_misc.c.

                                                                              {
 
    int64_t i;
    double x1, y1, x2, y2, eps = ClosestAllowXFactor * DBL_EPSILON;
    ptwXYPoints *ptwXY;
    ptwXYPoint *p1, *p2;
 
    if( n < 2 ) {
        smr_setReportError2( smr, nfu_SMR_libraryID, nfu_tooFewPoints, "Too few point = %d.", (int) n );
        return( NULL );
    }
    for( i = 1; i < n; i++ ) {
        if( xs[i-1] >= xs[i] ) {
            smr_setReportError2( smr, nfu_SMR_libraryID, nfu_XNotAscending, 
                    "Non-ascending domain values: xs[%d] = %.17e >= xs[%d] = %.17e.", 
                    (int) (i-1), xs[i-1], (int) i, xs[i] );
            return( NULL );
        }
    }
 
    x1 = xs[0];
    if( func( smr, x1, &y1, argList ) != nfu_Okay ) {
        return( NULL );
    }
    if( ( ptwXY = ptwXY_new( smr, ptwXY_interpolationLinLin, NULL, biSectionMax, accuracy, 500, 50, 0 ) ) == NULL ) goto Err;
    for( i = 1; i < n; i++ ) {
        if( ptwXY_setValueAtX_overrideIfClose( smr, ptwXY, x1, y1, eps, 0 ) != nfu_Okay ) goto Err;
        x2 = xs[i];
        if( func( smr, x2, &y2, argList ) != nfu_Okay ) goto Err;
        if( ptwXY_createFromFunctionBisect( smr, ptwXY, x1, y1, x2, y2, func, argList, 0, checkForRoots, eps ) != nfu_Okay ) goto Err;
        x1 = x2;
        y1 = y2;
    }
    if( ptwXY_setValueAtX_overrideIfClose( smr, ptwXY, x2, y2, eps, 1 ) != nfu_Okay ) goto Err;
 
    if( checkForRoots ) {
        if( ptwXY_simpleCoalescePoints( NULL, ptwXY ) != nfu_Okay ) goto Err;
        for( i = ptwXY->length - 1, p2 = NULL; i >= 0; i--, p2 = p1 ) { /* Work backward so lower points are still valid if a new point is added. */
            p1 = &(ptwXY->points[i]);
            if( p2 != NULL ) {
                if( ( p1->y * p2->y ) < 0. ) {
                    if( ptwXY_createFromFunctionZeroCrossing( smr, ptwXY, p1->x, p1->y, p2->x, p2->y, func, argList, eps ) != nfu_Okay ) goto Err;
                }
            }
        }
    }
 
    return( ptwXY );
 
Err:
    smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
    if( ptwXY != NULL ) ptwXY_free( ptwXY );
    return( NULL );
}

Referenced by GIDI::Functions::Polynomial1d::asXYs1d(), MCGIDI::Probabilities::NBodyPhaseSpace2d::NBodyPhaseSpace2d(), nf_Legendre_to_ptwXY(), and ptwXY_createFromFunction2().

ptwXY_createFromFunction2()

ptwXYPoints * ptwXY_createFromFunction2	(	statusMessageReporting *	smr,
		ptwXPoints *	xs,
		ptwXY_createFromFunction_callback	func,
		void *	argList,
		double	accuracy,
		int	checkForRoots,
		int	biSectionMax )

Definition at line 104 of file ptwXY_misc.c.

                                                                              {
 
    ptwXYPoints *ptwXY = ptwXY_createFromFunction( smr, (int) xs->length, xs->points, func, argList, accuracy, 
            checkForRoots, biSectionMax );
 
    if( ptwXY == NULL ) smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
    return( ptwXY );
}

ptwXY_createGaussian()

ptwXYPoints * ptwXY_createGaussian	(	statusMessageReporting *	smr,
		double	accuracy,
		double	xCenter,
		double	sigma,
		double	amplitude,
		double	domainMin,
		double	domainMax,
		double	dullEps )

Definition at line 864 of file ptwXY_convenient.c.

                                                                               {
 
    int64_t i;
    ptwXYPoints *gaussian, *sliced;
    ptwXYPoint *point;
 
    if( ( gaussian = ptwXY_createGaussianCenteredSigma1( smr, accuracy ) ) == NULL ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( NULL );
    }
 
    for( i = 0, point = gaussian->points; i < gaussian->length; i++, point++ ) {
        point->x = point->x * sigma + xCenter;
        point->y *= amplitude;
    }
    if( ( gaussian->points[0].x < domainMin ) || ( gaussian->points[gaussian->length - 1].x > domainMax ) ) {
        if( ( sliced = ptwXY_domainSlice( smr, gaussian, domainMin, domainMax, 10, 1 ) ) == NULL ) goto Err;
        ptwXY_free( gaussian );
        gaussian = sliced;
    }
 
    return( gaussian );
 
Err:
    smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
    ptwXY_free( gaussian );
    return( NULL );
}

ptwXY_createGaussianCenteredSigma1()

ptwXYPoints * ptwXY_createGaussianCenteredSigma1	(	statusMessageReporting *	smr,
		double	accuracy )

Definition at line 784 of file ptwXY_convenient.c.

                                                                                                {
 
    int64_t i, n;
    ptwXYPoint *pm, *pp;
    double x1, y1, x2, y2, accuracy2, rangeMin = 1e-10;
    ptwXYPoints *gaussian;
 
    if( accuracy < 1e-5 ) accuracy = 1e-5;
    if( accuracy > 1e-1 ) accuracy = 1e-1;
    if( ( gaussian = ptwXY_new( smr, ptwXY_interpolationLinLin, NULL, 1., accuracy, 200, 100, 0 ) ) == NULL ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( NULL );
    }
 
    accuracy2 = accuracy = gaussian->accuracy;
    if( accuracy2 > 5e-3 ) accuracy2 = 5e-3;
 
    x1 = -sqrt( -2. * log( rangeMin ) );
    y1 = rangeMin;
    x2 = -5.2;
    y2 = exp( -0.5 * x2 * x2 );
    if( ptwXY_setValueAtX( smr, gaussian, x1, y1 ) != nfu_Okay ) goto Err;
    gaussian->accuracy = 20 * accuracy2;
    if( ptwXY_createGaussianCenteredSigma1_2( smr, gaussian, x1, y1, x2, y2, 1 ) != nfu_Okay ) goto Err;
    x1 = x2;
    y1 = y2;
    x2 = -4.;
    y2 = exp( -0.5 * x2 * x2 );
    gaussian->accuracy = 5 * accuracy2;
    if( ptwXY_createGaussianCenteredSigma1_2( smr, gaussian, x1, y1, x2, y2, 1 ) != nfu_Okay ) goto Err;
    x1 = x2;
    y1 = y2;
    x2 = -1;
    y2 = exp( -0.5 * x2 * x2 );
    gaussian->accuracy = accuracy;
    if( ptwXY_createGaussianCenteredSigma1_2( smr, gaussian, x1, y1, x2, y2, 1 ) != nfu_Okay ) goto Err;
    x1 = x2;
    y1 = y2;
    x2 =  0;
    y2 = exp( -0.5 * x2 * x2 );
    if( ptwXY_createGaussianCenteredSigma1_2( smr, gaussian, x1, y1, x2, y2, 1 ) != nfu_Okay ) goto Err;
 
    n = gaussian->length;
    if( ptwXY_coalescePoints( smr, gaussian, 2 * n + 1, NULL, 0 ) != nfu_Okay ) goto Err;
    if( ptwXY_setValueAtX( smr, gaussian, 0., 1. ) != nfu_Okay ) goto Err;
    pp = &(gaussian->points[gaussian->length]);
    for( i = 0, pm = pp - 2; i < n; i++, pp++, pm-- ) {
        *pp = *pm;
        pp->x *= -1;
    }
    gaussian->length = 2 * n + 1;
 
    return( gaussian );
 
Err:
    ptwXY_free( gaussian );
    smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
    return( NULL );
}

Referenced by ptwXY_createGaussian().

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_div_doubleFrom()

nfu_status ptwXY_div_doubleFrom	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		double	value )

Definition at line 81 of file ptwXY_binaryOperators.c.

                                                                                                 { 
 
    if( value == 0. ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_divByZero, "Divide by 0." );
        ptwXY->status = nfu_divByZero; }
    else {
        if( ptwXY_slopeOffset( smr, ptwXY, 1. / value, 0. ) != nfu_Okay )
            smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
    }
    return( ptwXY->status );
}

ptwXY_div_fromDouble()

nfu_status ptwXY_div_fromDouble	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		double	value )

Definition at line 95 of file ptwXY_binaryOperators.c.

                                                                                                 {
/*
*   This does not do any infilling and it should?????????
*/
 
    int64_t i, nonOverflowLength;
    ptwXYPoint *p;
    ptwXYOverflowPoint *o, *overflowHeader = &(ptwXY->overflowHeader);
 
    if( ( nonOverflowLength = ptwXY_getNonOverflowLength( smr, ptwXY ) ) < 0 ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( ptwXY->status );
    }
    if( ptwXY->interpolation == ptwXY_interpolationOther ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_otherInterpolation, "Other interpolation not allowed." );
        return( nfu_otherInterpolation );
    }
 
    for( i = 0, p = ptwXY->points; i < nonOverflowLength; i++, p++ ) if( p->y == 0. ) ptwXY->status = nfu_divByZero;
    for( o = overflowHeader->next; o != overflowHeader; o = o->next ) if( o->point.y == 0. ) ptwXY->status = nfu_divByZero;
    if( ptwXY->status == nfu_divByZero ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_divByZero, "Divide by 0." ); }
    else {
        for( i = 0, p = ptwXY->points; i < nonOverflowLength; i++, p++ ) p->y = value / p->y;
        for( o = overflowHeader->next; o != overflowHeader; o = o->next ) o->point.y = value / o->point.y; 
    }
    return( ptwXY->status );
}

ptwXY_div_ptwXY()

ptwXYPoints * ptwXY_div_ptwXY	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY1,
		ptwXYPoints *	ptwXY2,
		int	safeDivide )

Definition at line 387 of file ptwXY_binaryOperators.c.

                                                                                                                      {
 
    int isNAN1, isNAN2;
    int64_t i, j, k, zeros = 0, length, iYs;
    double x1, x2, y1, y2, u1, u2, v1, v2, y, xz, nan = nfu_getNAN( ), s1, s2;
    ptwXYPoints *div = NULL;
    ptwXYPoint *p;
    nfu_status status = ptwXY_simpleCoalescePoints( smr, ptwXY1 );
 
    if( status != nfu_Okay ) goto Err;
    if( ptwXY_simpleCoalescePoints( smr, ptwXY2 ) != nfu_Okay ) goto Err;
 
    if( ptwXY1->interpolation == ptwXY_interpolationOther ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_otherInterpolation, "Source1: Other interpolation not allowed." );
        return( NULL );
    }
    if( ptwXY2->interpolation == ptwXY_interpolationOther ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_otherInterpolation, "Source2: Other interpolation not allowed." );
        return( NULL );
    }
 
    if( ( ptwXY1->interpolation == ptwXY_interpolationFlat ) || ( ptwXY1->interpolation == ptwXY_interpolationFlat ) ) {
        div = ptwXY_div_ptwXY_forFlats( smr, ptwXY1, ptwXY2, safeDivide );
        if( div == NULL ) smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( div );
    }
 
    if( ptwXY_areDomainsMutual( smr, ptwXY1, ptwXY2 ) != nfu_Okay ) {
        double domainMin1, domainMax1, domainMin2, domainMax2;
 
        ptwXY_domainMin( NULL, ptwXY1, &domainMin1 );
        ptwXY_domainMax( NULL, ptwXY1, &domainMax1 );
        ptwXY_domainMin( NULL, ptwXY2, &domainMin2 );
        ptwXY_domainMax( NULL, ptwXY2, &domainMax2 );
 
        smr_setReportError2( smr, nfu_SMR_libraryID, nfu_domainsNotMutual, "Domains not mutual (%.17e, %.17e) vs (%.17e, %.17e).",
                domainMin1, domainMax1, domainMin2, domainMax2 );
        return( NULL );
    }
 
    if( ( div = ptwXY_union( smr, ptwXY1, ptwXY2, ptwXY_union_fill | ptwXY_union_mergeClosePoints ) ) == NULL ) goto Err;
    for( i = 0, p = div->points; i < div->length; i++, p++ ) {
        if( ptwXY_getValueAtX_ignore_XOutsideDomainError( smr, ptwXY2, p->x, &y ) != nfu_Okay ) goto Err;
        if( y == 0. ) {
            if( p->y == 0. ) {
                iYs = 0;
                y1 = 0.;
                y2 = 0.;
                if( i > 0 ) {
                    if( ( status = ptwXY_getSlopeAtX( smr, ptwXY1, p->x, '-', &s1 ) ) != nfu_Okay ) {
                        if( status != nfu_XOutsideDomain ) goto Err;
                        s1 = 0.;
                    }
                    if( ( status = ptwXY_getSlopeAtX( smr, ptwXY2, p->x, '-', &s2 ) ) != nfu_Okay ) goto Err;
                    if( s2 == 0. ) {
                        y1 = nan; }
                    else {
                        y1 = s1 / s2;
                    } 
                    iYs++;
                }
                if( i < ( div->length - 1 ) ) {
                    if( ( status = ptwXY_getSlopeAtX( smr, ptwXY1, p->x, '+', &s1 ) ) != nfu_Okay ) {
                        if( status != nfu_XOutsideDomain ) goto Err;
                        s1 = 0.;
                    }
                    if( ( status = ptwXY_getSlopeAtX( smr, ptwXY2, p->x, '+', &s2 ) ) != nfu_Okay ) goto Err;
                    if( s2 == 0. ) {
                        y2 = nan; }
                    else {
                        y2 = s1 / s2;
                    }
                    iYs++;
                }
                p->y = ( y1 + y2 ) / iYs; 
                if( nfu_isNAN( p->y ) ) zeros++; }
            else {
                if( !safeDivide ) {
                    smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_divByZero, "Divide by 0." );
                    goto Err2;
                }
                zeros++;
                p->y = nan;
            } }
        else {
            p->y /= y;
        }
    }
    length = div->length - 1;
    if( length > 0 ) {
        x2 = div->points[length].x;
        for( i = length - 1; i >= 0; i-- ) {             /* Find and add y zeros and NAN not currently in div's. */
            x1 = div->points[i].x;
            if( ptwXY_getValueAtX_ignore_XOutsideDomainError( smr, ptwXY1, x1, &u1 ) != nfu_Okay ) goto Err;
            if( ptwXY_getValueAtX_ignore_XOutsideDomainError( smr, ptwXY1, x2, &u2 ) != nfu_Okay ) goto Err;
            if( ptwXY_getValueAtX_signal_XOutsideDomainError( smr, __LINE__, __func__, ptwXY2, x1, &v1 ) != nfu_Okay ) goto Err;
            if( ptwXY_getValueAtX_signal_XOutsideDomainError( smr, __LINE__, __func__, ptwXY2, x2, &v2 ) != nfu_Okay ) goto Err;
            if( u1 * u2 < 0 ) {
                xz = ( u1 * x2 - u2 * x1 ) / ( u1 - u2 );
                if( ptwXY_setValueAtX( smr, div, xz, 0. ) != nfu_Okay ) goto Err;
            }
            if( v1 * v2 < 0 ) {
                if( !safeDivide ) {
                    smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_divByZero, "Divide by 0." );
                    goto Err2;
                }
                zeros++;
                xz = ( v1 * x2 - v2 * x1 ) / ( v1 - v2 );
                if( ptwXY_setValueAtX( smr, div, xz, nan ) != nfu_Okay ) goto Err;
            }
            x2 = x1;
        }
        if( ptwXY_simpleCoalescePoints( smr, div ) != nfu_Okay ) goto Err;
        length = div->length;
        x2 = div->points[div->length-1].x;
        y2 = div->points[div->length-1].y;
        isNAN2 = nfu_isNAN( y2 );
        for( i = div->length - 2; i >= 0; i-- ) {             /* Make interpolation fit accuracy. Work backwards so new points will not mess up loop. */
            x1 = div->points[i].x;
            y1 = div->points[i].y;
            isNAN1 = nfu_isNAN( y1 );
            if( !isNAN1 || !isNAN2 ) {
                if( ptwXY_div_s_ptwXY( smr, div, ptwXY1, ptwXY2, x1, y1, x2, y2, 0, isNAN1, isNAN2 ) != nfu_Okay ) goto Err;
            }
            x2 = x1;
            y2 = y1;
            isNAN2 = isNAN1;
        }
        ptwXY_update_biSectionMax( div, (double) length );
        if( zeros ) {
            if( ptwXY_simpleCoalescePoints( smr, div ) != nfu_Okay ) goto Err;
            for( i = 0; i < div->length; i++ ) if( !nfu_isNAN( div->points[i].y ) ) break;
            if( nfu_isNAN( div->points[0].y ) ) {                     /* Special case for first point. */
                if( i == div->length ) {                              /* They are all nan's, what now? */
                    zeros = 0;
                    for( i = 0; i < div->length; i++ ) div->points[i].y = 0.; }
                else {
                     div->points[0].y = 2. * div->points[i].y;
                    zeros--;
                }
            }
            for( i = div->length - 1; i > 0; i-- ) if( !nfu_isNAN( div->points[i].y ) ) break;
            if( nfu_isNAN( div->points[div->length - 1].y ) ) {         /* Special case for last point. */
                div->points[div->length - 1].y = 2. * div->points[i].y;
                zeros--;
            }
            if( zeros ) {
                for( i = 0; i < div->length; i++ ) if( nfu_isNAN( div->points[i].y ) ) break;
                for( k = i + 1, j = i; k < div->length; k++ ) {
                if( nfu_isNAN( div->points[k].y ) ) continue;
                    div->points[j] = div->points[k];
                    j++;
                }
                div->length = j;
            }
        }
    }
    return( div );
 
Err:
    if( status == nfu_XOutsideDomain ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_XOutsideDomain, "x-value outside domain." ); }
    else {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
    }
Err2:
    if( div ) ptwXY_free( div );
    return( NULL );
}

ptwXY_domainMax()

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

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 *	value )

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 *	value )

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 *	value )

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_dullEdges()

nfu_status ptwXY_dullEdges	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		double	lowerEps,
		double	upperEps,
		int	positiveXOnly )

Definition at line 185 of file ptwXY_convenient.c.

                                                                                                                                   {
 
#define minEps 5e-16
 
    nfu_status status;
    double xm, xp, dx, y, x1, y1, x2, y2, sign;
    ptwXYPoint *p;
 
/* This routine can only be used for linear interpolation for the y-axes since for log interpolation, y cannot be 0. 
This needs to be fixed and documented. */
    if( ptwXY->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Invalid source." );
        return( ptwXY->status );
    }
 
    if( ptwXY->interpolation == ptwXY_interpolationOther ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_otherInterpolation, "Other interpolation not allowed." );
        return( nfu_otherInterpolation );
    }
 
    if( ptwXY->interpolation == ptwXY_interpolationFlat ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_invalidInterpolation, "Flat interpolation not allowed." );
        return( nfu_invalidInterpolation );
    }
 
    if( ptwXY->length < 2 ) return( nfu_Okay );
 
    if( lowerEps != 0. ) {
        if( fabs( lowerEps ) < minEps ) {
            sign = 1;
            if( lowerEps < 0. ) sign = -1;
            lowerEps = sign * minEps;
        }
 
        p = ptwXY_getPointAtIndex_Unsafely( ptwXY, 0 );
        x1 = p->x;
        y1 = p->y;
        p = ptwXY_getPointAtIndex_Unsafely( ptwXY, 1 );
        x2 = p->x;
        y2 = p->y;
 
        if( y1 != 0. ) {
            dx = fabs( x1 * lowerEps );
            if( x1 == 0 ) dx = fabs( lowerEps );
            xm = x1 - dx;
            xp = x1 + dx;
            if( ( xp + dx ) < x2 ) {
                if( ( status = ptwXY_getValueAtX( smr, ptwXY, xp, &y ) ) != nfu_Okay ) return( ptwXY->status = status );
                if( ( status = ptwXY_setValueAtX( smr, ptwXY, xp,  y ) ) != nfu_Okay ) return( ptwXY->status = status ); }
            else {
                xp = x2;
                y = y2;
            }
            if( lowerEps > 0 ) {
                if( ( status = ptwXY_setValueAtX( smr, ptwXY, x1, 0. ) ) != nfu_Okay ) return( ptwXY->status = status ); }
            else {
                if( ( xm < 0. ) && ( x1 >= 0. ) && positiveXOnly ) {
                    if( ( status = ptwXY_setValueAtX( smr, ptwXY, x1, 0. ) ) != nfu_Okay ) return( ptwXY->status = status ); }
                else {
                    if( ( status = ptwXY_setValueAtX( smr, ptwXY, xm, 0. ) ) != nfu_Okay ) return( ptwXY->status = status );
                    if( ( status = ptwXY_interpolatePoint( smr, ptwXY->interpolation, x1, &y, xm, 0., xp, y )  ) != nfu_Okay )
                        return( ptwXY->status = status );
                    if( ( status = ptwXY_setValueAtX( smr, ptwXY, x1, y ) ) != nfu_Okay ) return( ptwXY->status = status );
                }
            }
        }
    }
 
    if( upperEps != 0. ) {
        if( fabs( upperEps ) < minEps ) {
            sign = 1;
            if( upperEps < 0. ) sign = -1;
            upperEps = sign * minEps;
        }
 
        p = ptwXY_getPointAtIndex_Unsafely( ptwXY, ptwXY->length - 2 );
        x1 = p->x;
        y1 = p->y;
        p = ptwXY_getPointAtIndex_Unsafely( ptwXY, ptwXY->length - 1 );
        x2 = p->x;
        y2 = p->y;
 
        if( y2 != 0. ) {
            dx = fabs( x2 * upperEps );
            if( x2 == 0 ) dx = fabs( upperEps );
            xm = x2 - dx;
            xp = x2 + dx;
            if( ( xm - dx ) > x1 ) {
                if( ( status = ptwXY_getValueAtX( smr, ptwXY, xm, &y ) ) != nfu_Okay ) return( ptwXY->status = status );
                if( ( status = ptwXY_setValueAtX( smr, ptwXY, xm,  y ) ) != nfu_Okay ) return( ptwXY->status = status ); }
            else {
                xm = x1;
                y = y1;
            }
            if( upperEps < 0 ) {
                if( ( status = ptwXY_setValueAtX( smr, ptwXY, x2, 0. ) ) != nfu_Okay ) return( ptwXY->status = status ); }
            else {
                if( ( status = ptwXY_setValueAtX( smr, ptwXY, xp, 0. ) ) != nfu_Okay ) return( ptwXY->status = status );
                if( ( status = ptwXY_interpolatePoint( smr, ptwXY->interpolation, x2, &y, xm, y, xp, 0. )  ) != nfu_Okay )
                    return( ptwXY->status = status );
                if( ( status = ptwXY_setValueAtX( smr, ptwXY, x2, y ) ) != nfu_Okay ) return( ptwXY->status = status );
            }
        }
    }
 
    return( ptwXY->status );
 
#undef minEps
}

Referenced by ptwXY_mutualifyDomains().

ptwXY_equalProbableBins()

ptwXPoints * ptwXY_equalProbableBins	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		int	numberOfBins )

Definition at line 1036 of file ptwXY_integration.c.

                                                                                                         {
 
    int index = 1;
    int64_t i1, length = ptwXY->length;
    double x1, y1, x2, y2, integral, runningIntegral1 = 0., runningIntegral2, nextCDF, dIntegral;
    double dx, temp, norm;
    ptwXYPoint *point;
    ptwXPoints *equalProbableBins = NULL;
 
    if( ptwXY->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Bad self." );
        goto Err;
    }
 
    switch( ptwXY->interpolation ) {
        case ptwXY_interpolationLinLin :
        case ptwXY_interpolationFlat :
            break;
        default :
            smr_setReportError2( smr, nfu_SMR_libraryID, nfu_unsupportedInterpolation,
                    "interpolation = %d not supported", ptwXY->interpolation );
            goto Err;
    }
 
    if( length < 2 ) {
        smr_setReportError2( smr, nfu_SMR_libraryID, nfu_tooFewPoints, "number of points = %lld < 2", length );
        goto Err;
    }
 
    if( numberOfBins < 1 ) {
        smr_setReportError2( smr, nfu_SMR_libraryID, nfu_badInput, "numberOfBins = %d < 1", numberOfBins );
        goto Err;
    }
    if( ( equalProbableBins = ptwX_new( smr, numberOfBins ) ) == NULL ) goto Err;
 
    if( ptwXY_integrateDomain( smr, ptwXY, &norm ) != nfu_Okay ) goto Err;
    if( norm <= 0 ) {
        smr_setReportError2( smr, nfu_SMR_libraryID, nfu_badNorm, "norm = %e <= 0", norm );
        goto Err;
    }
 
    point = ptwXY->points;
    x1 = point->x;
    y1 = point->y;
    ++point;
    if( ptwX_setPointAtIndex( smr, equalProbableBins, 0, x1 ) != nfu_Okay ) goto Err;
    for( i1 = 1; i1 < length; ++i1, ++point ) {
        x2 = point->x;
        y2 = point->y;
        if( ptwXY_f_integrate( smr, ptwXY->interpolation, x1, y1, x2, y2, &integral ) != nfu_Okay ) goto Err;
        runningIntegral2 = runningIntegral1 + integral;
        while( index < numberOfBins ) {
            nextCDF = norm * index / (double) numberOfBins;
            if( runningIntegral2 < nextCDF ) break;
            dIntegral = nextCDF - runningIntegral1;
 
            if( ptwXY->interpolation == ptwXY_interpolationLinLin ) {
                temp = ( y2 - y1 ) / ( x2 - x1 );                       /* slope. */
                dx = 2. * dIntegral / ( y1 + sqrt( y1 * y1 + 2. * temp * dIntegral ) ); }
            else {
                dx = dIntegral / y1;
            }
 
            if( ptwX_setPointAtIndex( smr, equalProbableBins, index, dx + x1 ) != nfu_Okay ) goto Err;
            ++index;
        }
        runningIntegral1 = runningIntegral2;
 
        x1 = x2;
        y1 = y2;
    }
    if( ptwX_setPointAtIndex( smr, equalProbableBins, index, x2 ) != nfu_Okay ) goto Err;
 
    return( equalProbableBins );
 
Err:
    if( equalProbableBins != NULL ) ptwX_free( equalProbableBins );
    return( NULL );
}

ptwXY_exp()

nfu_status ptwXY_exp	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		double	a )

Definition at line 46 of file ptwXY_functions.c.

                                                                                  { 
 
    int64_t i, length;
    nfu_status status;
    double x1, y1, z1, x2, y2, z2;
 
    length = ptwXY->length;
    if( length < 1 ) return( ptwXY->status );
 
    if( ptwXY->interpolation == ptwXY_interpolationOther ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_otherInterpolation, "Other interpolation not allowed." );
        return( ptwXY->status = nfu_otherInterpolation );
    }
    if( ptwXY->interpolation == ptwXY_interpolationFlat ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_flatInterpolation, "Flat interpolation not allowed." );
        return( ptwXY->status = nfu_flatInterpolation );
    }
 
    if( ( status = ptwXY_simpleCoalescePoints( smr, ptwXY ) ) != nfu_Okay ) goto Err;
    x2 = ptwXY->points[length-1].x;
    y2 = a * ptwXY->points[length-1].y;
    z2 = ptwXY->points[length-1].y = exp( y2 );
    for( i = length - 2; i >= 0; i-- ) {
        x1 = ptwXY->points[i].x;
        y1 = a * ptwXY->points[i].y;
        z1 = ptwXY->points[i].y = exp( y1 );
        if( ( status = ptwXY_exp_s( smr, ptwXY, x1, y1, z1, x2, y2, z2, 0 ) ) != nfu_Okay ) goto Err;
        x2 = x1;
        y2 = y1;
    }
    return( status );
 
Err:
    if( status != nfu_Okay ) smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
    if( ptwXY->status != nfu_Okay ) ptwXY->status = status;
    return( status );
}

ptwXY_f_integrate()

nfu_status ptwXY_f_integrate	(	statusMessageReporting *	smr,
		ptwXY_interpolation	interpolation,
		double	x1,
		double	y1,
		double	x2,
		double	y2,
		double *	value )

Definition at line 31 of file ptwXY_integration.c.

                                              {
 
    nfu_status status = nfu_Okay;
    double r, _sign = 1.0;
    double ratioX, logX, ratioY, logY, numerator;
 
    if( x2 < x1 ) {
        double x = x1;
        x1 = x2;
        x2 = x;
        _sign = -1.;
    }
 
    *value = 0.;
    switch( interpolation ) {
    case ptwXY_interpolationLinLin :                            /* x linear, y linear */
        *value = 0.5 * ( y1 + y2 ) * ( x2 - x1 );
        break;
    case ptwXY_interpolationLogLin :                            /* x linear, y log */
        if( ( y1 <= 0. ) || ( y2 <= 0. ) ) {
            smr_setReportError2( smr, nfu_SMR_libraryID, nfu_badIntegrationInput, 
                    "0 or negative values for log-y integration: y1 = %.17e, y2 = %.17e", y1, y2 );
            status = nfu_badIntegrationInput; }
        else {
            r = y2 / y1;
            if( fabs( r - 1. ) < 1e-4 ) {
                r = r - 1.;
                *value = y1 * ( x2 - x1 ) / ( 1. + r * ( -0.5 + r * ( 1. / 3. + r * ( -0.25 + .2 * r ) ) ) ); }
            else {
                *value = ( y2 - y1 ) * ( x2 - x1 ) / log( r );
            }
        }
        break;
    case ptwXY_interpolationLinLog :                            /* x log, y linear */
        if( ( x1 <= 0. ) || ( x2 <= 0. ) ) {
            smr_setReportError2( smr, nfu_SMR_libraryID, nfu_badIntegrationInput, 
                    "0 or negative values for log-x integration: x1 = %.17e, x2 = %.17e", x1, x2 );
            status = nfu_badIntegrationInput; }
        else {
            r = x2 / x1;
            if( fabs( r - 1. ) < 1e-4 ) {
                r = r - 1.;
                r = r * ( -0.5 + r * ( 1. / 3. + r * ( -0.25 + .2 * r ) ) );
                *value = x1 * ( y2 - y1 ) * r / ( 1. + r ) + y2 * ( x2 - x1 ); }
            else {
                *value = ( y1 - y2 ) * ( x2 - x1 ) / log( r ) + x2 * y2 - x1 * y1;
            }
        }
        break;
    case ptwXY_interpolationLogLog :                            /* x log, y log */
        ratioX = x2 / x1;
        if( fabs( ratioX - 1. ) < 1e-4 ) {
            ratioX -= 1.0;
            logX = ratioX * ( 1. + ratioX * ( -0.5 + ratioX * ( 1. / 3. - 0.25 * ratioX ) ) );
            ratioX = x2 / x1; }
        else {
            logX = log( ratioX );
        }
 
        ratioY = y2 / y1;
        if( fabs( ratioY - 1. ) < 1e-4 ) {
            ratioY -= 1.0;
            logY = ratioY * ( 1. + ratioY * ( -0.5 + ratioY * ( 1. / 3. - 0.25 * ratioY ) ) );
            ratioY = y2 / y1; }
        else {
            logY = log( ratioY );
        }
 
        numerator = ratioX * ratioY - 1.0;
        if( numerator < 1e-4 ) {
            *value = y1 * x1 * logX * ( 1.0 + 0.5 * numerator * ( 1.0 + numerator * ( 1 + 0.5 * numerator * ( 1 + 19.0 * numerator / 30.0 ) ) / 6.0 ) ); }
        else {
            *value = y1 * x1 * numerator / ( logY / logX + 1.0 );
        }
        break;
    case ptwXY_interpolationFlat :                            /* x ?, y flat */
        *value = y1 * ( x2 - x1 );
        break;
    case ptwXY_interpolationOther :
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_otherInterpolation, "Other interpolation not supported for integration." );
        status = nfu_otherInterpolation;
    }
 
    *value *= _sign;
 
    return( status );
}

Referenced by ptwXY_equalProbableBins(), ptwXY_integrate(), and ptwXY_runningIntegral().

ptwXY_flatInterpolationToLinear()

ptwXYPoints * ptwXY_flatInterpolationToLinear	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		double	lowerEps,
		double	upperEps )

Definition at line 100 of file ptwXY_interpolation.c.

                                                                                                                                  {
 
    int64_t i, length;
    double x;
    ptwXYPoints *n;
    ptwXYPoint *p1 = NULL, *p2 = NULL, *p3;
 
#define minEps 5e-16
 
    if( ptwXY_simpleCoalescePoints( smr, ptwXY ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( NULL );
    }
        
    if( ptwXY->interpolation != ptwXY_interpolationFlat ) {
        smr_setReportError2( smr, nfu_SMR_libraryID, nfu_invalidInterpolation, "Source interpolation not 'flat' but '%s'.",
                ptwXY->interpolationString );
        return( NULL );
    }
 
    if( ( lowerEps < 0 ) || ( upperEps < 0 ) || ( ( lowerEps == 0 ) && ( upperEps == 0 ) ) ) {
        smr_setReportError2( smr, nfu_SMR_libraryID, nfu_badInput, "Bad epsilons: lowerEps = %.17e and upperEps = %.17e.",
                lowerEps, upperEps );
        return( NULL );
    }
    if( ( lowerEps != 0 ) && ( lowerEps < minEps ) ) lowerEps = minEps;
    if( ( upperEps != 0 ) && ( upperEps < minEps ) ) upperEps = minEps;
 
    length = ptwXY->length * ( 1 + ( lowerEps == 0 ? 0 : 1 ) + ( lowerEps == 0 ? 0 : 1 ) );
    if( ( n = ptwXY_new( smr, ptwXY_interpolationLinLin, NULL, ptwXY->biSectionMax, ptwXY->accuracy, length, 
            ptwXY->overflowLength, ptwXY->userFlag ) ) == NULL ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( NULL );
    }
 
    p3 = ptwXY->points;
    if( ptwXY->length > 0 ) {
        if( ptwXY_setValueAtX( smr, n, p3->x, p3->y ) != nfu_Okay ) goto Err;
    }
    for( i = 0; i < ptwXY->length; i++, p3++ ) {
        if( i > 1 ) {
            if( lowerEps > 0 ) {
                x = ptwXY_flatInterpolationToLinear_eps( p2->x, -lowerEps );
                if( x > p1->x ) {
                    if( ptwXY_setValueAtX( smr, n, x, p1->y ) != nfu_Okay ) goto Err;
                }
            }
            if( lowerEps == 0 ) if( ptwXY_setValueAtX( smr, n, p2->x, p1->y ) != nfu_Okay ) goto Err;
            if( upperEps == 0 ) if( ptwXY_setValueAtX( smr, n, p2->x, p2->y ) != nfu_Okay ) goto Err;
            if( upperEps > 0 ) {
                x = ptwXY_flatInterpolationToLinear_eps( p2->x, upperEps );
                if( x < p3->x ) {
                    if( ptwXY_setValueAtX( smr, n, x, p2->y ) != nfu_Okay ) goto Err;
                }
            }
        }
        p1 = p2;
        p2 = p3;
    }
    if( ptwXY->length > 1 ) {
        if( ( lowerEps != 0 ) && ( p1->y != p2->y ) ) {
            x = ptwXY_flatInterpolationToLinear_eps( p2->x, -lowerEps );
            if( x > p1->x ) {
                if( ptwXY_setValueAtX( smr, n, x, p1->y ) != nfu_Okay ) goto Err;
            }
        }
        if( ptwXY_setValueAtX( smr, n, p2->x, p2->y ) != nfu_Okay ) goto Err;
    }
 
    return( n );
 
Err:
    smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
    ptwXY_free( n );
    return( NULL );
 
#undef minEps
}

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

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_fromString()

ptwXYPoints * ptwXY_fromString	(	statusMessageReporting *	smr,
		char const *	str,
		char	sep,
		ptwXY_interpolation	interpolation,
		char const *	interpolationString,
		double	biSectionMax,
		double	accuracy,
		char **	endCharacter,
		int	useSystem_strtod )

Definition at line 275 of file ptwXY_misc.c.

                                                                                                                           {
 
    int64_t numberConverted;
    double  *doublePtr;
    ptwXYPoints *ptwXY = NULL;
 
    if( ( doublePtr = nfu_stringToListOfDoubles( smr, str, sep, &numberConverted, endCharacter, useSystem_strtod ) ) == NULL ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( NULL );
    }
    if( ( numberConverted % 2 ) == 0 ) {
        ptwXY = ptwXY_create( smr, interpolation, interpolationString, biSectionMax, accuracy, numberConverted / 2, 10, numberConverted / 2, doublePtr, 0 ); }
    else {
        smr_setReportError2( smr, nfu_SMR_libraryID, nfu_oddNumberOfValues, "Odd number = %d of float for ptwXY.", (int) numberConverted );
    }
    smr_freeMemory2( doublePtr );
    return( ptwXY );
}

ptwXY_fromUnitbase()

ptwXYPoints * ptwXY_fromUnitbase	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		double	domainMin,
		double	domainMax,
		int	scaleRange )

Definition at line 403 of file ptwXY_interpolation.c.

                         {
 
    int64_t i, length;
    ptwXYPoints *n;
    ptwXYPoint *p, *p2;
    double dx, inverseDx, xLast = 0.;
 
    if( ptwXY->length < 2 ) {
        smr_setReportError2( smr, nfu_SMR_libraryID, nfu_tooFewPoints, "Too few points %d", (int) ptwXY->length );
        return( NULL );
    }
    if( ( n = ptwXY_clone( smr, ptwXY ) ) == NULL ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( NULL );
    }
 
    dx = domainMax - domainMin;
    inverseDx = 1. / dx;
    length = n->length;
    for( i = 0, p2 = p = n->points; i < length; ++i, ++p ) {
        p2->x = p->x * dx + domainMin;
        if( i > 0 ) {
            if( fabs( p2->x - xLast ) <= 10. * DBL_EPSILON * ( fabs( p2->x ) + fabs( xLast ) ) ) {
                --(n->length);
                continue;
            }
        }
        if( scaleRange ) p2->y = p->y * inverseDx;
        xLast = p2->x;
        ++p2;
    }
    n->points[n->length-1].x = domainMax;                          /* Make sure last point is realy domainMax. */
    return( n );
}

Referenced by ptwXY_unitbaseInterpolate().

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,
		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_getXArray()

ptwXPoints * ptwXY_getXArray	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY )

Definition at line 21 of file ptwXY_convenient.c.

                                                                               {
 
    int64_t i, n;
    ptwXPoints *xArray;
 
    if( ptwXY_simpleCoalescePoints( smr, ptwXY ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( NULL );
    }
    n = ptwXY->length;
 
    if( ( xArray = ptwX_new( smr, n ) ) == NULL ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( NULL );
    }
    for( i = 0; i < n; i++ ) xArray->points[i] = ptwXY->points[i].x;
    xArray->length = n;
 
    return( xArray );
}

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_groupOneFunction()

ptwXPoints * ptwXY_groupOneFunction	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		ptwXPoints *	groupBoundaries,
		ptwXY_group_normType	normType,
		ptwXPoints *	ptwX_norm )

Definition at line 552 of file ptwXY_integration.c.

                                                               {
 
    int64_t i, igs, ngs;
    double x1, y1, x2, y2, y2p, xg1, xg2, sum;
    ptwXYPoints *f;
    ptwXPoints *groupedData = NULL;
 
    if( ptwXY_simpleCoalescePoints( smr, ptwXY ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( NULL );
    }
    if( groupBoundaries->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Via: groupBoundaries." );
        return( NULL );
    }
    if( ptwXY->interpolation == ptwXY_interpolationOther ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_otherInterpolation, "Other interpolation not supported for integration." );
        return( NULL );
    }
 
    ngs = ptwX_length( smr, groupBoundaries ) - 1;
    if( normType == ptwXY_group_normType_norm ) {
        if( ptwX_norm == NULL ) {
            smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badNorm, "Norm function required but is NULL." );
            return( NULL );
        }
        if( ptwX_norm->status != nfu_Okay ) {
            smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Via: norm." );
            return( NULL );
        }
        if( ptwX_length( smr, ptwX_norm ) != ngs ) {
            smr_setReportError2( smr, nfu_SMR_libraryID, nfu_badNorm, "Norm length = %d but there are %d groups.",
                    (int) ptwX_length( NULL, ptwX_norm ), (int) ngs );
            return( NULL );
        }
    }
 
    if( ( f = ptwXY_intersectionWith_ptwX( smr, ptwXY, groupBoundaries ) ) == NULL ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( NULL );
    }
    if( f->length == 0 ) {
        groupedData = ptwX_createLine( smr, ngs, ngs, 0, 0 );
        if( groupedData == NULL ) smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( groupedData );
    }
 
    if( ( groupedData = ptwX_new( smr, ngs ) ) == NULL ) goto Err;
    xg1 = groupBoundaries->points[0];
    x1 = f->points[0].x;
    y1 = f->points[0].y;
    for( igs = 0, i = 1; igs < ngs; igs++ ) {
        xg2 = groupBoundaries->points[igs+1];
        sum = 0;
        if( xg2 > x1 ) {
            for( ; i < f->length; i++, x1 = x2, y1 = y2 ) {
                x2 = f->points[i].x;
                if( x2 > xg2 ) break;
                y2p = y2 = f->points[i].y;
                if( f->interpolation == ptwXY_interpolationFlat ) y2p = y1;
                sum += ( y1 + y2p ) * ( x2 - x1 );
            }
        }
        if( sum != 0. ) {
            if( normType == ptwXY_group_normType_dx ) {
                sum /= ( xg2 - xg1 ); }
            else if( normType == ptwXY_group_normType_norm ) {
                if( ptwX_norm->points[igs] == 0. ) {
                    smr_setReportError2( smr, nfu_SMR_libraryID, nfu_divByZero, "Divide by 0. Norm at index %d is 0.", (int) igs );
                    goto Err;
                }
                sum /= ptwX_norm->points[igs];
            }
        }
        groupedData->points[igs] = 0.5 * sum;
        groupedData->length++;
        xg1 = xg2;
    }
 
    ptwXY_free( f );
    return( groupedData );
 
Err:
    smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
    ptwXY_free( f );
    if( groupedData != NULL ) ptwX_free( groupedData );
    return( NULL );
}

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

ptwXY_groupThreeFunctions()

ptwXPoints * ptwXY_groupThreeFunctions	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY1,
		ptwXYPoints *	ptwXY2,
		ptwXYPoints *	ptwXY3,
		ptwXPoints *	groupBoundaries,
		ptwXY_group_normType	normType,
		ptwXPoints *	ptwX_norm )

Definition at line 764 of file ptwXY_integration.c.

                                                                                                                 {
 
    int64_t i, igs, ngs;
    nfu_status status = nfu_Okay;
    double x1, fy1, gy1, hy1, x2, fy2, gy2, hy2, fy2p, gy2p, hy2p, xg1, xg2, sum;
    ptwXYPoints *f = NULL, *ff, *fff = NULL, *g = NULL, *gg = NULL, *h = NULL, *hh = NULL;
    ptwXPoints *groupedData = NULL;
 
    if( ptwXY_simpleCoalescePoints( smr, ptwXY1 ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via: source1." );
        return( NULL );
    }
    if( ptwXY_simpleCoalescePoints( smr, ptwXY2 ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via: source2." );
        return( NULL );
    }
    if( ptwXY_simpleCoalescePoints( smr, ptwXY3 ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via: source3." );
        return( NULL );
    }
    if( groupBoundaries->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Via: groupBoundaries." );
        return( NULL );
    }
 
    if( ptwXY1->interpolation == ptwXY_interpolationOther ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_otherInterpolation, "Other interpolation not supported for integration: source1." );
        return( NULL );
    }
    if( ptwXY2->interpolation == ptwXY_interpolationOther ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_otherInterpolation, "Other interpolation not supported for integration: source2." );
        return( NULL );
    }
    if( ptwXY3->interpolation == ptwXY_interpolationOther ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_otherInterpolation, "Other interpolation not supported for integration: source3." );
        return( NULL );
    }
 
    ngs = ptwX_length( smr, groupBoundaries ) - 1;
    if( normType == ptwXY_group_normType_norm ) {
        if( ptwX_norm == NULL ) {
            smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badNorm, "Norm function required but is NULL." );
            return( NULL );
        }
        if( ptwX_norm->status != nfu_Okay ) {
            smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Via: norm." );
            return( NULL );
        }
        if( ptwX_length( smr, ptwX_norm ) != ngs ) {
            smr_setReportError2( smr, nfu_SMR_libraryID, nfu_badNorm, "Norm length = %d but there are %d groups.",
                    (int) ptwX_length( NULL, ptwX_norm ), (int) ngs );
            return( NULL );
        }
    }
 
    if( ( ff = ptwXY_intersectionWith_ptwX( smr, ptwXY1, groupBoundaries ) ) == NULL ) goto Err;
    if( ( gg = ptwXY_intersectionWith_ptwX( smr, ptwXY2, groupBoundaries ) ) == NULL ) goto Err;
    if( ( hh = ptwXY_intersectionWith_ptwX( smr, ptwXY3, groupBoundaries ) ) == NULL ) goto Err;
    if( ( ff->length == 0 ) || ( gg->length == 0 ) || ( hh->length == 0 ) ) {
        ptwXY_free( ff );
        ptwXY_free( gg );
        ptwXY_free( hh );
        groupedData = ptwX_createLine( smr, ngs, ngs, 0, 0 );
        if( groupedData == NULL ) smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( groupedData );
    }
 
    if( ( status = ptwXY_tweakDomainsToMutualify( smr, ff, gg, 4, 0 ) ) != nfu_Okay ) goto Err2;
    if( ( status = ptwXY_tweakDomainsToMutualify( smr, ff, hh, 4, 0 ) ) != nfu_Okay ) goto Err2;
    if( ( status = ptwXY_tweakDomainsToMutualify( smr, gg, hh, 4, 0 ) ) != nfu_Okay ) goto Err2;
    if( ( fff = ptwXY_union( smr,  ff,  gg, ptwXY_union_fill ) ) == NULL ) goto Err;
    if( (   h = ptwXY_union( smr,  hh, fff, ptwXY_union_fill ) ) == NULL ) goto Err;
    if( (   f = ptwXY_union( smr, fff,   h, ptwXY_union_fill ) ) == NULL ) goto Err;
    if( (   g = ptwXY_union( smr,  gg,   h, ptwXY_union_fill ) ) == NULL ) goto Err;
 
    if( ( groupedData = ptwX_new( smr, ngs ) ) == NULL ) goto Err;
    xg1 = groupBoundaries->points[0];
    x1 = f->points[0].x;
    fy1 = f->points[0].y;
    gy1 = g->points[0].y;
    hy1 = h->points[0].y;
    for( igs = 0, i = 1; igs < ngs; igs++ ) {
        xg2 = groupBoundaries->points[igs+1];
        sum = 0;
        if( xg2 > x1 ) {
            for( ; i < f->length; i++, x1 = x2, fy1 = fy2, gy1 = gy2, hy1 = hy2 ) {
                x2 = f->points[i].x;
                if( x2 > xg2 ) break;
                fy2p = fy2 = f->points[i].y;
                if( f->interpolation == ptwXY_interpolationFlat ) fy2p = fy1;
                gy2p = gy2 = g->points[i].y;
                if( g->interpolation == ptwXY_interpolationFlat ) gy2p = gy1;
                hy2p = hy2 = h->points[i].y;
                if( h->interpolation == ptwXY_interpolationFlat ) hy2p = hy1;
                sum += ( ( fy1 + fy2p ) * ( gy1 + gy2p ) * ( hy1 + hy2p ) + 2 * fy1 * gy1 * hy1 + 2 * fy2p * gy2p * hy2p ) * ( x2 - x1 );
            }
        }
        if( sum != 0. ) {
            if( normType == ptwXY_group_normType_dx ) {
                sum /= ( xg2 - xg1 ); }
            else if( normType == ptwXY_group_normType_norm ) {
                if( ptwX_norm->points[igs] == 0. ) {
                    smr_setReportError2( smr, nfu_SMR_libraryID, nfu_divByZero, "Divide by 0. Norm at index %d is 0.", (int) igs );
                    goto Err;
                }
                sum /= ptwX_norm->points[igs];
            }
        }
        groupedData->points[igs] = sum / 12.;
        groupedData->length++;
        xg1 = xg2;
    }
 
    ptwXY_free( f );
    ptwXY_free( g );
    ptwXY_free( h );
    ptwXY_free( ff );
    ptwXY_free( gg );
    ptwXY_free( hh );
    ptwXY_free( fff );
    return( groupedData );
 
Err:
    smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
    if( fff != NULL ) ptwXY_free( fff );
    if( ff != NULL ) ptwXY_free( ff );
    if( gg != NULL ) ptwXY_free( gg );
    if( hh != NULL ) ptwXY_free( hh );
    if( f != NULL ) ptwXY_free( f );
    if( g != NULL ) ptwXY_free( g );
    if( h != NULL ) ptwXY_free( h );
    if( groupedData != NULL ) ptwX_free( groupedData );
    return( NULL );
 
Err2:
    smr_setReportError2p( smr, nfu_SMR_libraryID, status, "ptwXY_tweakDomainsToMutualify failed: most likely functions cannot be mutualified by tweaking." );
    goto Err;
}

Referenced by GIDI::multiGroupTwoXYs1ds().

ptwXY_groupTwoFunctions()

ptwXPoints * ptwXY_groupTwoFunctions	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY1,
		ptwXYPoints *	ptwXY2,
		ptwXPoints *	groupBoundaries,
		ptwXY_group_normType	normType,
		ptwXPoints *	ptwX_norm )

Definition at line 644 of file ptwXY_integration.c.

                                                                                            {
 
    int64_t i, igs, ngs;
    nfu_status status = nfu_Okay;
    double x1, fy1, gy1, x2, fy2, gy2, fy2p, gy2p, xg1, xg2, sum;
    ptwXYPoints *f = NULL, *ff, *g = NULL, *gg = NULL;
    ptwXPoints *groupedData = NULL;
 
    if( ptwXY_simpleCoalescePoints( smr, ptwXY1 ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via: source1." );
        return( NULL );
    }
    if( ptwXY_simpleCoalescePoints( smr, ptwXY2 ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via: source2." );
        return( NULL );
    }
    if( groupBoundaries->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Via: groupBoundaries." );
        return( NULL );
    }
 
    if( ptwXY1->interpolation == ptwXY_interpolationOther ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_otherInterpolation, 
                "Other interpolation not supported for integration: source1." );
        return( NULL );
    }
    if( ptwXY2->interpolation == ptwXY_interpolationOther ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_otherInterpolation, 
                "Other interpolation not supported for integration: source2." );
        return( NULL );
    }
 
    ngs = ptwX_length( smr, groupBoundaries ) - 1;
    if( normType == ptwXY_group_normType_norm ) {
        if( ptwX_norm == NULL ) {
            smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badNorm, "Norm function required but is NULL." );
            return( NULL );
        }
        if( ptwX_norm->status != nfu_Okay ) {
            smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Via: norm." );
            return( NULL );
        }
        if( ptwX_length( smr, ptwX_norm ) != ngs ) {
            smr_setReportError2( smr, nfu_SMR_libraryID, nfu_badNorm, "Norm length = %d but there are %d groups.",
                    (int) ptwX_length( NULL, ptwX_norm ), (int) ngs );
            return( NULL );
        }
    }
 
    if( ( ff = ptwXY_intersectionWith_ptwX( smr, ptwXY1, groupBoundaries ) ) == NULL ) goto Err;
    if( ( gg = ptwXY_intersectionWith_ptwX( smr, ptwXY2, groupBoundaries ) ) == NULL ) goto Err;
    if( ( ff->length == 0 ) || ( gg->length == 0 ) ) {
        ptwXY_free( ff );
        ptwXY_free( gg );
        groupedData = ptwX_createLine( smr, ngs, ngs, 0, 0 );
        if( groupedData == NULL ) smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( groupedData );
    }
 
    if( ( status = ptwXY_tweakDomainsToMutualify( smr, ff, gg, 4, 0 ) ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, status, "ptwXY_tweakDomainsToMutualify failed: most likely functions cannot be mutualified by tweaking." );
        goto Err;
    }
    if( ( f = ptwXY_union( smr, ff, gg, ptwXY_union_fill ) ) == NULL ) goto Err;
    if( ( g = ptwXY_union( smr, gg, f,  ptwXY_union_fill ) ) == NULL ) goto Err;
 
    if( ( groupedData = ptwX_new( smr, ngs ) ) == NULL ) goto Err;
    xg1 = groupBoundaries->points[0];
    x1 = f->points[0].x;
    fy1 = f->points[0].y;
    gy1 = g->points[0].y;
    for( igs = 0, i = 1; igs < ngs; igs++ ) {
        xg2 = groupBoundaries->points[igs+1];
        sum = 0;
        if( xg2 > x1 ) {
            for( ; i < f->length; i++, x1 = x2, fy1 = fy2, gy1 = gy2 ) {
                x2 = f->points[i].x;
                if( x2 > xg2 ) break;
                fy2p = fy2 = f->points[i].y;
                if( f->interpolation == ptwXY_interpolationFlat ) fy2p = fy1;
                gy2p = gy2 = g->points[i].y;
                if( g->interpolation == ptwXY_interpolationFlat ) gy2p = gy1;
                sum += ( ( fy1 + fy2p ) * ( gy1 + gy2p ) + fy1 * gy1 + fy2p * gy2p ) * ( x2 - x1 );
            }
        }
        if( sum != 0. ) {
            if( normType == ptwXY_group_normType_dx ) {
                sum /= ( xg2 - xg1 ); }
            else if( normType == ptwXY_group_normType_norm ) {
                if( ptwX_norm->points[igs] == 0. ) {
                    smr_setReportError2( smr, nfu_SMR_libraryID, nfu_divByZero, "Divide by 0. Norm at index %d is 0.", (int) igs );
                    goto Err;
                }
                sum /= ptwX_norm->points[igs];
            }
        }
        groupedData->points[igs] = sum / 6.;
        groupedData->length++;
        xg1 = xg2;
    }
 
    ptwXY_free( f );
    ptwXY_free( g );
    ptwXY_free( ff );
    ptwXY_free( gg );
    return( groupedData );
 
Err:
    smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
    if( ff != NULL ) ptwXY_free( ff );
    if( gg != NULL ) ptwXY_free( gg );
    if( f != NULL ) ptwXY_free( f );
    if( g != NULL ) ptwXY_free( g );
    if( groupedData != NULL ) ptwX_free( groupedData );
    return( NULL );
}

Referenced by GIDI::multiGroupXYs1d().

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_integrate()

nfu_status ptwXY_integrate	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		double	domainMin,
		double	domainMax,
		double *	value )

Definition at line 122 of file ptwXY_integration.c.

                                                                                                                                 {
 
    int64_t i, n = ptwXY->length;
    double dSum, x, y, x1, x2, y1, y2, _sign = 1.;
    ptwXYPoint *point;
    nfu_status status;
 
    *value = 0.;
 
    if( ptwXY->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Via." );
        return( nfu_badSelf );
    }
    if( ptwXY->interpolation == ptwXY_interpolationOther ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_otherInterpolation, "Other interpolation not supported for integration." );
        return( nfu_otherInterpolation );
    }
 
    if( n < 2 ) return( nfu_Okay );
 
    if( domainMax < domainMin ) {
        x = domainMin;
        domainMin = domainMax;
        domainMax = x;
        _sign = -1.;
    }
 
    if( ( status = ptwXY_simpleCoalescePoints( smr, ptwXY ) ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Via." );
        return( status );
    }
 
    for( i = 0, point = ptwXY->points; i < n; i++, point++ ) {
        if( point->x >= domainMin ) break;
    }
    if( i == n ) return( nfu_Okay );
 
    x2 = point->x;
    y2 = point->y;
    if( i > 0 ) {
        if( x2 > domainMin ) {
            x1 = point[-1].x;
            y1 = point[-1].y;
            if( ( status = ptwXY_interpolatePoint( smr, ptwXY->interpolation, domainMin, &y, x1, y1, x2, y2 ) ) != nfu_Okay ) {
                smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Via." );
                return( status );
            }
            if( x2 > domainMax ) {
                double rangeMax;
 
                if( ( status = ptwXY_interpolatePoint( smr, ptwXY->interpolation, domainMax, &rangeMax, x1, y1, x2, y2 ) ) == nfu_Okay ) {
                    status = ptwXY_f_integrate( smr, ptwXY->interpolation, domainMin, y, domainMax, rangeMax, value );
                }
                if( status != nfu_Okay ) smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Via." );
                return( status ); }
            else {
                if( ( status = ptwXY_f_integrate( smr, ptwXY->interpolation, domainMin, y, x2, y2, value ) ) != nfu_Okay ) {
                    smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Via." );
                    return( status );
                }
            }
        }
    }
    i++;
    point++;
    for( ; i < n; i++, point++ ) {
        x1 = x2;
        y1 = y2;
        x2 = point->x;
        y2 = point->y;
        if( x2 > domainMax ) {
            if( ( status = ptwXY_interpolatePoint( smr, ptwXY->interpolation, domainMax, &y, x1, y1, x2, y2 ) ) != nfu_Okay ) {
                smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
                return( status );
            }
            if( ( status = ptwXY_f_integrate( smr, ptwXY->interpolation, x1, y1, domainMax, y, &dSum ) ) != nfu_Okay ) {
                smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
                return( status );
            }
            *value += dSum;
            break;
        }
        if( ( status = ptwXY_f_integrate( smr, ptwXY->interpolation, x1, y1, x2, y2, &dSum ) ) != nfu_Okay ) {
            smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
            return( status );
        }
        *value += dSum;
    }
 
    *value *= _sign;
 
    return( nfu_Okay );
}

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

ptwXY_integrateDomain()

nfu_status ptwXY_integrateDomain	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		double *	value )

Definition at line 218 of file ptwXY_integration.c.

                                                                                                   {
 
    nfu_status status = nfu_Okay;
 
    *value = 0;
 
    if( ptwXY->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Via." );
        return( nfu_badSelf );
    }
 
    if( ptwXY->length > 0 ) {
        double domainMin, domainMax;
 
        if( ptwXY_domainMin( smr, ptwXY, &domainMin ) != nfu_Okay ) smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Via." );
        if( ptwXY_domainMax( smr, ptwXY, &domainMax ) != nfu_Okay ) smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Via." );
        if( ( status = ptwXY_integrate( smr, ptwXY, domainMin, domainMax, value ) ) != nfu_Okay )
            smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Via." );
    }
    return( status );
}

Referenced by GIDI::Functions::XYs1d::normalize(), ptwXY_equalProbableBins(), and ptwXY_normalize().

ptwXY_integrateDomainWithWeight_sqrt_x()

nfu_status ptwXY_integrateDomainWithWeight_sqrt_x	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		double *	value )

Definition at line 436 of file ptwXY_integration.c.

                                                                                                                    {
 
    nfu_status status;
    double domainMin, domainMax;
 
    *value = 0.;
 
    if( ptwXY->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Via." );
        return( nfu_badSelf );
    }
 
    if( ptwXY->length < 2 ) return( nfu_Okay );
 
    if( ptwXY_domainMin( smr, ptwXY, &domainMin ) != nfu_Okay ) smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Via." );
    if( ptwXY_domainMax( smr, ptwXY, &domainMax ) != nfu_Okay ) smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Via." );
    if( ( status = ptwXY_integrateWithWeight_sqrt_x( smr, ptwXY, domainMin, domainMax, value ) ) != nfu_Okay )
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Via." );
    return( status );
}

ptwXY_integrateDomainWithWeight_x()

nfu_status ptwXY_integrateDomainWithWeight_x	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		double *	value )

Definition at line 271 of file ptwXY_integration.c.

                                                                                                               {
 
    nfu_status status = nfu_Okay;
    double domainMin, domainMax;
 
    *value = 0.;
 
    if( ptwXY->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Via." );
        return( nfu_badSelf );
    }
 
    if( ptwXY->length < 2 ) return( nfu_Okay );
 
    if( ptwXY_domainMin( smr, ptwXY, &domainMin ) != nfu_Okay ) smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Via." );
    if( ptwXY_domainMax( smr, ptwXY, &domainMax ) != nfu_Okay ) smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Via." );
    if( ( status = ptwXY_integrateWithWeight_x( smr, ptwXY, domainMin, domainMax, value ) ) != nfu_Okay )
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Via." );
    return( status );
}

ptwXY_integrateWithFunction()

nfu_status ptwXY_integrateWithFunction	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		ptwXY_createFromFunction_callback	func,
		void *	argList,
		double	domainMin,
		double	domainMax,
		int	degree,
		int	recursionLimit,
		double	tolerance,
		double *	value )

Definition at line 938 of file ptwXY_integration.c.

                                                                                                                             {
 
    int64_t i1, i2, n1 = ptwXY->length;
    long evaluations;
    double integral = 0., integral_, sign = -1., xa, xb;
    ptwXY_integrateWithFunctionInfo integrateWithFunctionInfo;
    ptwXYPoint *point;
    nfu_status status;
 
    *value = 0;
 
    if( ptwXY_simpleCoalescePoints( smr, ptwXY ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( nfu_Error );
    }
 
    if( domainMin == domainMax ) return( nfu_Okay );
    if( n1 < 2 ) return( nfu_Okay );
 
    if( domainMin > domainMax ) {
        sign = domainMin;
        domainMin = domainMax;
        domainMax = sign;
        sign = -1.;
    }
    if( domainMin >= ptwXY->points[n1-1].x ) return( nfu_Okay );
    if( domainMax <= ptwXY->points[0].x ) return( nfu_Okay );
 
    for( i1 = 0; i1 < ( n1 - 1 ); i1++ ) {
        if( ptwXY->points[i1+1].x > domainMin ) break;
    }
    for( i2 = n1 - 1; i2 > i1; i2-- ) {
        if( ptwXY->points[i2-1].x < domainMax ) break;
    }
    point = &(ptwXY->points[i1]);
 
    integrateWithFunctionInfo.degree = degree;
    integrateWithFunctionInfo.func = func;
    integrateWithFunctionInfo.argList = argList;
    integrateWithFunctionInfo.interpolation = ptwXY->interpolation;
    integrateWithFunctionInfo.x2 = point->x;
    integrateWithFunctionInfo.y2 = point->y;
 
    xa = domainMin;
    for( ; i1 < i2; i1++ ) {
        integrateWithFunctionInfo.x1 = integrateWithFunctionInfo.x2;
        integrateWithFunctionInfo.y1 = integrateWithFunctionInfo.y2;
        ++point;
        integrateWithFunctionInfo.x2 = point->x;
        integrateWithFunctionInfo.y2 = point->y;
        xb = point->x;
        if( xb > domainMax ) xb = domainMax;
        status = nf_GnG_adaptiveQuadrature( ptwXY_integrateWithFunction2, ptwXY_integrateWithFunction3, &integrateWithFunctionInfo,
            xa, xb, recursionLimit, tolerance, &integral_, &evaluations );
        if( status != nfu_Okay ) {
            smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via. Error from nf_GnG_adaptiveQuadrature." );
            return( status );
        }
        integral += integral_;
        xa = xb;
    }
    *value = sign * integral;
 
    return( nfu_Okay );
}

ptwXY_integrateWithWeight_sqrt_x()

nfu_status ptwXY_integrateWithWeight_sqrt_x	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		double	domainMin,
		double	domainMax,
		double *	value )

Definition at line 459 of file ptwXY_integration.c.

                        {
 
    int64_t i, n = ptwXY->length;
    double sum = 0., x, y, x1, x2, y1, y2, _sign = 1., sqrt_x1, sqrt_x2, inv_apb, c;
    ptwXYPoint *point;
    nfu_status status;
 
    *value = 0.;
 
    if( ptwXY->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Via." );
        return( nfu_badSelf );
    }
 
    if(     ( ptwXY->interpolation != ptwXY_interpolationLinLin ) &&
            ( ptwXY->interpolation != ptwXY_interpolationFlat ) ) {
        smr_setReportError2( smr, nfu_SMR_libraryID, nfu_unsupportedInterpolation,
            "Unsupported interpolation = '%s'", ptwXY->interpolationString );
        return( nfu_unsupportedInterpolation );
    }
 
    if( n < 2 ) return( nfu_Okay );
    if( domainMax < domainMin ) {
        x = domainMin;
        domainMin = domainMax;
        domainMax = x;
        _sign = -1.;
    }
 
    if( ptwXY_simpleCoalescePoints( smr, ptwXY ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( nfu_Error );
    }
 
    for( i = 0, point = ptwXY->points; i < n; ++i, ++point ) {
        if( point->x >= domainMin ) break;
    }
    if( i == n ) return( nfu_Okay );
    x2 = point->x;
    y2 = point->y;
    if( i > 0 ) {
        if( x2 > domainMin ) {
            if( ( status = ptwXY_interpolatePoint( smr, ptwXY->interpolation, domainMin, &y, point[-1].x, point[-1].y, x2, y2 ) ) != nfu_Okay ) {
                smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
                return( status );
            }
            x2 = domainMin;
            y2 = y;
            --i;
            --point;
        }
    }
    ++i;
    ++point;
    sqrt_x2 = sqrt( x2 );
    for( ; i < n; ++i, ++point ) {
        x1 = x2;
        y1 = y2;
        sqrt_x1 = sqrt_x2;
        x2 = point->x;
        y2 = point->y;
        if( x2 > domainMax ) {
            if( ( status = ptwXY_interpolatePoint( smr, ptwXY->interpolation, domainMax, &y, x1, y1, x2, y2 ) ) != nfu_Okay ) {
                smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
                return( status );
            }
            x2 = domainMax;
            y2 = y;
        }
        sqrt_x2 = sqrt( x2 );
        inv_apb = sqrt_x1 + sqrt_x2;
        c = 2. * ( sqrt_x1 * sqrt_x2 + x1 + x2 );
        switch( ptwXY->interpolation ) {
        case ptwXY_interpolationFlat :
            sum += ( sqrt_x2 - sqrt_x1 ) * y1 * 2.5 * c;
            break;
        case ptwXY_interpolationLinLin :
            sum += ( sqrt_x2 - sqrt_x1 ) * ( y1 * ( c + x1 * ( 1. + sqrt_x2 / inv_apb ) ) + y2 * ( c + x2 * ( 1. + sqrt_x1 / inv_apb ) ) );
            break;
        default :       /* Only to stop compilers from complaining. */
            break;
        }
        if( x2 == domainMax ) break;
    }
 
    *value = 2. / 15. * _sign * sum;
 
    return( nfu_Okay );
}

Referenced by ptwXY_integrateDomainWithWeight_sqrt_x().

ptwXY_integrateWithWeight_x()

nfu_status ptwXY_integrateWithWeight_x	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		double	domainMin,
		double	domainMax,
		double *	value )

Definition at line 294 of file ptwXY_integration.c.

                        {
 
    int64_t i, n = ptwXY->length;
    double sum = 0., x, y, x1, x2, y1, y2, _sign = 1., invLog, dx, dy, ratioX, logX, ratioY, logY, numerator;
    ptwXYPoint *point;
    nfu_status status;
 
    *value = 0.;
 
    if( ptwXY->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Via." );
        return( nfu_badSelf );
    }
 
    if( ptwXY->interpolation == ptwXY_interpolationOther ) {
        smr_setReportError2( smr, nfu_SMR_libraryID, nfu_unsupportedInterpolation, "Unsupported interpolation = '%s'", ptwXY->interpolationString );
        return( nfu_unsupportedInterpolation );
    }
 
    if( n < 2 ) return( nfu_Okay );
 
    if( domainMax < domainMin ) {
        x = domainMin;
        domainMin = domainMax;
        domainMax = x;
        _sign = -1.;
    }
 
    if( ptwXY_simpleCoalescePoints( smr, ptwXY ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( nfu_Error );
    }
 
    for( i = 0, point = ptwXY->points; i < n; ++i, ++point ) {
        if( point->x >= domainMin ) break;
    }
    if( i == n ) return( nfu_Okay );
 
    x2 = point->x;
    y2 = point->y;
    if( i > 0 ) {
        if( x2 > domainMin ) {
            if( ( status = ptwXY_interpolatePoint( smr, ptwXY->interpolation, domainMin, &y, point[-1].x, point[-1].y, x2, y2 ) ) != nfu_Okay ) {
                smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
                return( status );
            }
            x2 = domainMin;
            y2 = y;
            --i;
            --point;
        }
    }
    ++i;
    ++point;
    for( ; i < n; ++i, ++point ) {
        x1 = x2;
        y1 = y2;
        x2 = point->x;
        y2 = point->y;
        if( x2 > domainMax ) {
            if( ( status = ptwXY_interpolatePoint( smr, ptwXY->interpolation, domainMax, &y, x1, y1, x2, y2 ) ) != nfu_Okay ) {
                smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
                return( status );
            }
            x2 = domainMax;
            y2 = y;
        }
        switch( ptwXY->interpolation ) {
        case ptwXY_interpolationFlat :
            sum += 0.5 * ( x2 - x1 ) * y1 * ( x1 + x2 );
            break;
        case ptwXY_interpolationLinLin :
            sum += ( x2 - x1 ) * ( y1 * ( 2 * x1 + x2 ) + y2 * ( x1 + 2 * x2 ) ) / 6.;
            break;
        case ptwXY_interpolationLogLin :
            ratioY = y2 / y1;
            dx = x2 - x1;
            dy = y2 - y1;
            if( fabs( ratioY - 1 ) < 1e-3 ) {
                double sum2 = 0.0;
 
                ratioY -= 1.0;
                sum2 = x1 * ( 1.0 + 0.5 * ratioY * ( 1.0 + ratioY * ( -1.0 + 0.5 * ratioY * ( 1.0 - 19 * ratioY / 30 ) ) / 6.0 ) );
                sum2 += 0.5 * ( x2 - x1 ) * ( 1.0 + ratioY * ( 2.0 + 0.25 * ratioY * ( -1.0 + ratioY * ( 7 - 4.25 * ratioY ) / 15.0 ) ) / 3.0 );
                sum += y1 * ( x2 - x1 ) * sum2;
                }
            else {
                invLog = 1.0 / log( ratioY );
                sum += dx * invLog * ( dx * ( y2 - dy * invLog ) + x1 * dy );
            }
            break;
        case ptwXY_interpolationLinLog :
            sum += 0.5 * ( x2 - x1 ) * y1 * ( x1 + x2 );
            ratioX = x2 / x1;
            if( fabs( ratioX - 1 ) < 1e-3 ) {
                ratioX -= 1.0;
                sum += 0.5 * ( y2 - y1 ) * x1 * ( x2 - x1 ) * ( 1.0 + ratioX * ( 5.0 + ratioX * ratioX * ( 1.0 + ratioX ) / 30.0 ) / 6.0 ); }
            else {
                logX = log( ratioX );
                sum += 0.25 * ( y2 - y1 ) * x1 * x1 * ( 1.0 + ratioX * ratioX * ( 2.0 * logX - 1.0 ) ) / logX;
            }
            break;
        case ptwXY_interpolationLogLog :
            ratioX = x2 / x1;
            if( fabs( ratioX - 1. ) < 1e-4 ) {
                ratioX -= 1.0;
                logX = ratioX * ( 1. + ratioX * ( -0.5 + ratioX * ( 1. / 3. - 0.25 * ratioX ) ) );
                ratioX = x2 / x1; }
            else {
                logX = log( ratioX );
            }
 
            ratioY = y2 / y1;
            if( fabs( ratioY - 1. ) < 1e-4 ) {
                ratioY -= 1.0;
                logY = ratioY * ( 1. + ratioY * ( -0.5 + ratioY * ( 1. / 3. - 0.25 * ratioY ) ) );
                ratioY = y2 / y1; }
            else {
                logY = log( ratioY );
            }
 
            numerator = ratioX * ratioX * ratioY - 1.0;
            if( numerator < 1e-4 ) {
                sum += y1 * x1 * x1 * logX * ( 1.0 + 0.5 * numerator * ( 1.0 + numerator * ( 1 + 0.5 * numerator * ( 1 + 19.0 * numerator / 30.0 ) ) / 6.0 ) ); }
            else {
                sum += y1 * x1 * x1 * numerator / ( logY / logX + 2.0 );
            }
            break;
        default :       /* Only to stop compilers from complaining. */
            break;
        }
        if( x2 == domainMax ) break;
    }
 
    *value = _sign * sum;
 
    return( nfu_Okay );
}

Referenced by ptwXY_integrateDomainWithWeight_x().

ptwXY_interpolatePoint()

nfu_status ptwXY_interpolatePoint	(	statusMessageReporting *	smr,
		ptwXY_interpolation	interpolation,
		double	x,
		double *	y,
		double	x1,
		double	y1,
		double	x2,
		double	y2 )

Definition at line 30 of file ptwXY_interpolation.c.

                                                     {
 
    nfu_status status = nfu_Okay;
 
    if( interpolation == ptwXY_interpolationOther ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_otherInterpolation, "Other interpolation not allow." );
        return( nfu_otherInterpolation );
    }
    if( ( x1 > x2 ) || ( x < x1 ) || ( x > x2 ) ) {
        smr_setReportError2( smr, nfu_SMR_libraryID, nfu_invalidInterpolation, 
                "Interpolation point.x = %.17e not between function points x1 = %.17e and x2 = %.17e.", x, x1, x2 );
        return( nfu_invalidInterpolation );
    }
    if( y1 == y2 ) {
        *y = y1; }
    else if( x1 == x2 ) {
        *y = 0.5 * ( y1  + y2 ); }
    else if( x == x1 ) {
        *y = y1; }
    else if( x == x2 ) {
        *y = y2; }
    else {
        switch( interpolation ) {
        case ptwXY_interpolationLinLin :
            *y = ( y1 * ( x2 - x ) + y2 * ( x - x1 ) ) / ( x2 - x1 );
            break;
        case ptwXY_interpolationLinLog :
            if( ( x <= 0. ) || ( x1 <= 0. ) || ( x2 <= 0. ) ) {
                smr_setReportError2( smr, nfu_SMR_libraryID, nfu_invalidInterpolation, 
                        "For log(x), some x-values  less than equal to 0, x1 = %.17e, x = %.17e, x2 = %.17e.", x1, x, x2 );
                return( nfu_invalidInterpolation );
            }
            *y = ( y1 * log( x2 / x ) + y2 * log( x / x1 ) ) / log( x2 / x1 );
            break;
        case ptwXY_interpolationLogLin :
            if( ( y1 <= 0. ) || ( y2 <= 0. ) ) {
                smr_setReportError2( smr, nfu_SMR_libraryID, nfu_invalidInterpolation, 
                        "For log(y), some y-values less than equal to 0, y1 = %.17e, y2 = %.17e.", y1, y2 );
                return( nfu_invalidInterpolation );
            }
            *y = exp( ( log( y1 ) * ( x2 - x ) + log( y2 ) * ( x - x1 ) ) / ( x2 - x1 ) );
            break;
        case ptwXY_interpolationLogLog :
            if( ( x <= 0. ) || ( x1 <= 0. ) || ( x2 <= 0. ) ) {
                smr_setReportError2( smr, nfu_SMR_libraryID, nfu_invalidInterpolation, 
                        "For log(x), some x-values  less than equal to 0, x1 = %.17e, x = %.17e, x2 = %.17e.", x1, x, x2 );
                return( nfu_invalidInterpolation );
            }
            if( ( y1 <= 0. ) || ( y2 <= 0. ) ) {
                smr_setReportError2( smr, nfu_SMR_libraryID, nfu_invalidInterpolation, 
                        "For log(y), some y-values less than equal to 0, y1 = %.17e, y2 = %.17e.", y1, y2 );
                return( nfu_invalidInterpolation );
            }
            *y = exp( ( log( y1 ) * log( x2 / x ) + log( y2 ) * log( x / x1 ) ) / log( x2 / x1 ) );
            break;
        case ptwXY_interpolationFlat :
            *y = y1;
            break;
        default :
            smr_setReportError2( smr, nfu_SMR_libraryID, nfu_invalidInterpolation,
                    "Invalid interpolation token = %d.", interpolation );
            status = nfu_invalidInterpolation;
        }
    }
    return( status );
}

Referenced by ptwXY_dullEdges(), ptwXY_getValueAtX(), ptwXY_integrate(), ptwXY_integrateWithWeight_sqrt_x(), ptwXY_integrateWithWeight_x(), ptwXY_mapToXsAndAdd(), ptwXY_thicken(), ptwXY_union(), ptwXY_ysMappedToXs(), and GIDI::Functions::XYs1d::ysMappedToXs().

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_intersectionWith_ptwX()

ptwXYPoints * ptwXY_intersectionWith_ptwX	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		ptwXPoints *	ptwX )

Definition at line 353 of file ptwXY_convenient.c.

                                                                                                              {
 
    int64_t i, i1, i2, lengthX = ptwX_length( smr, ptwX );
    double x, y, domainMin, domainMax;
    ptwXYPoints *n = NULL;
 
    if( ptwX->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Invalid ptwXPoints." );
        return( NULL );
    }
 
    if( ptwXY_simpleCoalescePoints( smr, ptwXY ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( NULL );
    }
 
    if( ptwXY->interpolation == ptwXY_interpolationOther ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_otherInterpolation, "Other interpolation not allowed." );
        return( NULL );
    }
 
    if( ( n = ptwXY_clone( smr, ptwXY ) ) == NULL ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( NULL );
    }
 
    if( ptwXY->length == 0 ) return( n );
    domainMin = ptwXY->points[0].x;
    domainMax = ptwXY->points[ptwXY->length - 1].x;
 
    if( ( domainMin >= ptwX->points[lengthX-1] ) || ( domainMax <= ptwX->points[0] ) ) {  /* No overlap. */
        n->length = 0;
        return( n );
    }
 
    for( i = 0; i < lengthX; i++ ) {        /* Fill in ptwXY at x-points in ptwX. */
        x = ptwX->points[i];
        if( x <= domainMin ) continue;
        if( x >= domainMax ) break;
        if( ptwXY_getValueAtX( smr, ptwXY, x, &y ) != nfu_Okay ) goto Err;
        if( ptwXY_setValueAtX( smr, n, x, y ) != nfu_Okay ) goto Err;
    }
    if( ptwXY_simpleCoalescePoints( smr, n ) != nfu_Okay ) goto Err;
 
    i1 = 0;
    i2 = n->length - 1;
    if( lengthX > 0 ) {
        x = ptwX->points[0];
        if( x > n->points[i1].x ) {
            for( ; i1 < n->length; i1++ ) {
                if( n->points[i1].x == x ) break;
            }
        }
 
        x = ptwX->points[lengthX - 1];
        if( x < n->points[i2].x ) {
            for( ; i2 > i1; i2-- ) {
                if( n->points[i2].x == x ) 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." );
     ptwXY_free( n );
     return( NULL );
}

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

ptwXY_inverse()

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

Definition at line 356 of file ptwXY_functions.c.

                                                                              {
 
    int64_t length;
    ptwXY_interpolation interpolation;
    ptwXYPoints *ptwXYInverse;
 
    length = ptwXY_length( NULL, ptwXY );
 
    if( ptwXY->interpolation == ptwXY_interpolationFlat ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_flatInterpolation, "flat interpolation not allowed." );
        return( NULL );
    }
 
    if( ptwXY->interpolation == ptwXY_interpolationOther ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_otherInterpolation, "Other interpolation not allowed." );
        return( NULL );
    }
 
    if( ptwXY_simpleCoalescePoints( smr, ptwXY ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( NULL );
    }
 
    switch( ptwXY->interpolation ) {
    case ptwXY_interpolationLogLin :
        interpolation = ptwXY_interpolationLinLog;
        break;
    case ptwXY_interpolationLinLog :
        interpolation = ptwXY_interpolationLogLin;
        break;
    default :
        interpolation = ptwXY->interpolation;
        break;
    }
 
    if( ( ptwXYInverse = ptwXY_new( smr, interpolation, NULL, ptwXY_getBiSectionMax( ptwXY ), ptwXY_getAccuracy( ptwXY ), 
            length, 10, 0 ) ) == NULL ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( NULL );
    }
 
    if( length == 1 ) {
        ptwXYInverse->points[0].x = ptwXY->points[0].y;
        ptwXYInverse->points[0].y = ptwXY->points[0].x; }
    else if( length > 1 ) {
        int64_t i1, start = 0, order = 1;
 
        if( ptwXY->points[0].y > ptwXY->points[1].y ) {
            start = length - 1;
            order = -1;
        }
        ptwXYInverse->points[0].x = ptwXY->points[start].y;
        ptwXYInverse->points[0].y = ptwXY->points[start].x;
        for( i1 = 1, start += order; i1 < length; ++i1, start += order ) {
            ptwXYInverse->points[i1].x = ptwXY->points[start].y;
            ptwXYInverse->points[i1].y = ptwXY->points[start].x;
            if( ptwXYInverse->points[i1-1].x >= ptwXYInverse->points[i1].x ) {
                smr_setReportError2( smr, nfu_SMR_libraryID, nfu_XNotAscending,
                        "Non-ascending domain values: x[%d] = %.17e >= x[%d] = %.17e.",
                        (int) (i1-1), ptwXYInverse->points[i1-1].x, (int) i1, ptwXYInverse->points[i1].x );
                ptwXY_free( ptwXYInverse );
                return( NULL );
            }
        }
    }
    ptwXYInverse->length = length;
    return( ptwXYInverse );
}

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_limitAccuracy()

double ptwXY_limitAccuracy

(

double

accuracy

)

Definition at line 28 of file ptwXY_misc.c.

                                              {
 
    if( accuracy < ptwXY_minAccuracy ) accuracy = ptwXY_minAccuracy;
    if( accuracy > 1 ) accuracy = 1.;
    return( accuracy );
}

Referenced by ptwXY_setAccuracy(), ptwXY_thin(), and ptwXY_toOtherInterpolation().

ptwXY_mapToXsAndAdd()

nfu_status ptwXY_mapToXsAndAdd	(	statusMessageReporting *	a_smr,
		ptwXYPoints *	a_ptwXY,
		int64_t	a_offset,
		int64_t	a_length,
		double const *	a_Xs,
		double *	a_results,
		double	a_scaleFractor )

Definition at line 131 of file ptwXY_convenient.c.

                                                   {
 
    int64_t offset, startIndex, length, length_m1;
    double x1, x2, y1, y2;
    ptwXYPoint *point;
    ptwXY_interpolation interpolation = ptwXY_getInterpolation( a_ptwXY );
    double xValue, yValue;
 
    if( a_offset < 0 ) a_offset = 0;                                    /* This and next line also ensure that a_length > 0. */
    if( a_offset >= a_length ) return( nfu_Okay );
 
    offset = a_offset;
    nfu_status status = ptwXY_startIndex( a_smr, a_ptwXY, a_Xs[a_offset], &startIndex, &length );
    if( status != nfu_Okay ) return( status );
    if( startIndex < 0 ) {
        if( startIndex == -2 ) {
            if( a_Xs[a_length-1] >= a_ptwXY->points[0].x ) startIndex = 0;      /* Case A. */
        }
        if( startIndex < 0 ) return( nfu_Okay );
    }
 
    length_m1 = length - 1;
    point = &a_ptwXY->points[startIndex];
    x1 = point->x;
    y1 = point->y;
    while( startIndex < length_m1 ) {
        ++startIndex;
        point = &a_ptwXY->points[startIndex];
        x2 = point->x;
        y2 = point->y;
 
        for( ; offset < a_length; ++offset ) {
            xValue = a_Xs[offset];
 
            if( xValue < x1 ) continue;                     /* Can happend per case A above. */
            if( xValue > x2 ) break;
 
            if( ( status = ptwXY_interpolatePoint( a_smr, interpolation, xValue, &yValue, x1, y1, x2, y2 ) ) != nfu_Okay ) {
                smr_setReportError2p( a_smr, nfu_SMR_libraryID, nfu_Error, "Via." );
                return( status );
            }
            a_results[offset] += a_scaleFractor * yValue;
        }
        x1 = x2;
        y1 = y2;
    }
 
    return( nfu_Okay );
}

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

ptwXY_mergeClosePoints()

nfu_status ptwXY_mergeClosePoints	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		double	epsilon )

Definition at line 297 of file ptwXY_convenient.c.

                                                                                                     {
 
    int64_t i, i1, j, k, n = ptwXY->length;
    double x, y;
    ptwXYPoint *p1, *p2;
 
    if( n < 2 ) return( ptwXY->status );
    if( epsilon < 4 * DBL_EPSILON ) epsilon = 4 * DBL_EPSILON;
    if( ptwXY_simpleCoalescePoints( smr, ptwXY ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( ptwXY->status );
    }
 
    p2 = ptwXY->points;
    x = p2->x;
    for( i1 = 1, p2++; i1 < ( n - 1 ); i1++, p2++ ) {                 /* The first point shall remain the first point and all points close to it are deleted. */
        if( ( p2->x - x ) > 0.5 * epsilon * ( fabs( x ) + fabs( p2->x ) ) ) break;
    }
    if( i1 != 1 ) {
        for( i = i1, p1 = &(ptwXY->points[1]); i < n; i++, p1++, p2++ ) *p1 = *p2;
        n = ptwXY->length = ptwXY->length - i1 + 1;
    }
 
    p1 = &(ptwXY->points[n-1]);
    x = p1->x;
    for( i1 = n - 2, p1--; i1 > 0; i1--, p1-- ) {            /* The last point shall remain the last point and all points close to it are deleted. */
        if( x - p1->x > 0.5 * epsilon * ( fabs( x ) + fabs( p1->x ) ) ) break;
    }
    if( i1 != ( n - 2 ) ) {
        ptwXY->points[i1 + 1] = ptwXY->points[n - 1];
        n = ptwXY->length = i1 + 2;
    }
 
    for( i = 1; i < n - 1; i++ ) {
        p1 = &(ptwXY->points[i]);
        x = p1->x;
        y = p1->y;
        for( j = i + 1, p2 = &(ptwXY->points[i+1]); j < n - 1; j++, p2++ ) {
            if( ( p2->x - p1->x ) > 0.5 * epsilon * ( fabs( p2->x ) + fabs( p1->x ) ) ) break;
            x += p2->x;
            y += p2->y;
        }
        if( ( k = ( j - i ) ) > 1 ) {
            p1->x = x / k;
            p1->y = y / k;
            for( p1 = &(ptwXY->points[i+1]); j < n; j++, p1++, p2++ ) *p1 = *p2;
            n -= ( k - 1 );
        }
    }
    ptwXY->length = n;
 
    return( ptwXY->status );
}

Referenced by ptwXY_union().

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_mod()

nfu_status ptwXY_mod	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		double	m,
		int	pythonMod )

Definition at line 126 of file ptwXY_binaryOperators.c.

                                                                                                 { 
 
    int64_t i, nonOverflowLength;
    ptwXYPoint *p;
    ptwXYOverflowPoint *o, *overflowHeader = &(ptwXY->overflowHeader);
 
    if( ( nonOverflowLength = ptwXY_getNonOverflowLength( smr, ptwXY ) ) < 0 ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( ptwXY->status );
    }
 
    if( m == 0 ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_divByZero, "Divide by 0." );
        ptwXY->status = nfu_divByZero;
    }
 
    for( i = 0, p = ptwXY->points; i < nonOverflowLength; i++, p++ ) p->y = ptwXY_mod2( p->y, m, pythonMod );
    for( o = overflowHeader->next; o != overflowHeader; o = o->next ) o->point.y = ptwXY_mod2( o->point.y, m, pythonMod );
    return( ptwXY->status );
}

ptwXY_mul2_ptwXY()

ptwXYPoints * ptwXY_mul2_ptwXY	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY1,
		ptwXYPoints *	ptwXY2 )

Definition at line 282 of file ptwXY_binaryOperators.c.

                                                                                                       {
 
    int64_t i, length;
    ptwXYPoints *mul = NULL;
    int found;
    double x1, y1, x2, y2, u1, u2, v1, v2, xz1 = 0, xz2 = 0, x;
 
    if( ( mul = ptwXY_mul_ptwXY( smr, ptwXY1, ptwXY2 ) ) == NULL ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( NULL );
    }
    if( mul->length == 0 ) return( mul );
    if( ptwXY1->interpolation == ptwXY_interpolationFlat ) return( mul );
    if( ptwXY2->interpolation == ptwXY_interpolationFlat ) return( mul );
 
    length = mul->length - 1;
    if( length > 0 ) {
        x2 = mul->points[length].x;
        for( i = length - 1; i >= 0; i-- ) {             /* Find and add y zeros not currently in mul's. */
            x1 = mul->points[i].x;
            if( ptwXY_getValueAtX_ignore_XOutsideDomainError( smr, ptwXY1, x1, &u1 ) != nfu_Okay ) goto Err;
            if( ptwXY_getValueAtX_ignore_XOutsideDomainError( smr, ptwXY1, x2, &u2 ) != nfu_Okay ) goto Err;
            if( ptwXY_getValueAtX_ignore_XOutsideDomainError( smr, ptwXY2, x1, &v1 ) != nfu_Okay ) goto Err;
            if( ptwXY_getValueAtX_ignore_XOutsideDomainError( smr, ptwXY2, x2, &v2 ) != nfu_Okay ) goto Err;
            found = 0;
            if( u1 * u2 < 0 ) {
                xz1 = ( u1 * x2 - u2 * x1 ) / ( u1 - u2 );
                if( ptwXY_setValueAtX( smr, mul, xz1, 0. ) != nfu_Okay ) goto Err;
                found = 1;
            }
            if( v1 * v2 < 0 ) {
                xz2 = ( v1 * x2 - v2 * x1 ) / ( v1 - v2 );
                if( ptwXY_setValueAtX( smr, mul, xz2, 0. ) != nfu_Okay ) goto Err;
                found += 1;
            }
            if( found > 1 ) {
                x = 0.5 * ( xz1 + xz2 );
                if( ptwXY_getValueAtX_ignore_XOutsideDomainError( smr, ptwXY1, x, &u1 ) != nfu_Okay ) goto Err;
                if( ptwXY_getValueAtX_ignore_XOutsideDomainError( smr, ptwXY2, x, &v1 ) != nfu_Okay ) goto Err;
                if( ptwXY_setValueAtX( smr, mul, x, u1 * v1 ) != nfu_Okay ) goto Err;
            }
            x2 = x1;
        }
 
        if( ptwXY_simpleCoalescePoints( smr, mul ) != nfu_Okay ) goto Err;
        length = mul->length;
        x2 = mul->points[mul->length-1].x;
        y2 = mul->points[mul->length-1].y;
        for( i = mul->length - 2; i >= 0; i-- ) {           /* Make interpolation fit accuracy. Work backwards so new */
            x1 = mul->points[i].x;                          /* points will not mess up loop. */
            y1 = mul->points[i].y;
            if( ptwXY_mul2_s_ptwXY( smr, mul, ptwXY1, ptwXY2, x1, y1, x2, y2, 0 ) != nfu_Okay ) goto Err;
            x2 = x1;
            y2 = y1;
        }
        ptwXY_update_biSectionMax( mul, (double) length );
    }
    return( mul );
 
Err:
    smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
    if( mul ) ptwXY_free( mul );
    return( NULL );
}

Referenced by GIDI::Functions::XYs1d::operator*=(), and ptwXY_scaleAndOffsetDomainWith_ptwXYs().

ptwXY_mul_double()

nfu_status ptwXY_mul_double	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		double	value )

Definition at line 72 of file ptwXY_binaryOperators.c.

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

Referenced by GIDI::Functions::XYs1d::operator*=().

ptwXY_mul_ptwXY()

ptwXYPoints * ptwXY_mul_ptwXY	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY1,
		ptwXYPoints *	ptwXY2 )

Definition at line 265 of file ptwXY_binaryOperators.c.

                                                                                                      {
 
    ptwXYPoints *mul;
 
    if( ptwXY1->length == 0 ) {
        mul = ptwXY_clone( smr, ptwXY1 ); }
    else if( ptwXY2->length == 0 ) {
        mul = ptwXY_clone( smr, ptwXY2 ); }
    else {
        mul = ptwXY_binary_ptwXY( smr, ptwXY1, ptwXY2, 0., 0., 1. );
    }
    if( mul == NULL ) smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
    return( mul );
}

Referenced by ptwXY_mul2_ptwXY().

ptwXY_mutualifyDomains()

nfu_status ptwXY_mutualifyDomains	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY1,
		double	lowerEps1,
		double	upperEps1,
		int	positiveXOnly1,
		ptwXYPoints *	ptwXY2,
		double	lowerEps2,
		double	upperEps2,
		int	positiveXOnly2 )

Definition at line 558 of file ptwXY_convenient.c.

                                                                                                          {
 
    nfu_status status;
    int64_t n1 = ptwXY1->length, n2 = ptwXY2->length;
    int code1, code2;
    ptwXYPoint *xy1, *xy2;
 
    switch( status = ptwXY_areDomainsMutual( smr, ptwXY1, ptwXY2 ) ) {
    case nfu_Okay :
    case nfu_empty :
        return( nfu_Okay );
    case nfu_domainsNotMutual :
        break;
    default :
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( status );
    }
 
    if( ptwXY1->interpolation == ptwXY_interpolationOther ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_otherInterpolation, "Other interpolation not allowed for source1." );
        return( nfu_otherInterpolation );
    }
    if( ptwXY2->interpolation == ptwXY_interpolationOther ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_otherInterpolation, "Other interpolation not allowed for source2." );
        return( nfu_otherInterpolation );
    }
 
    if( ptwXY1->interpolation == ptwXY_interpolationFlat ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_invalidInterpolation, "Flat interpolation not allowed for source1." );
        return( nfu_invalidInterpolation );
    }
    if( ptwXY2->interpolation == ptwXY_interpolationFlat ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_invalidInterpolation, "Flat interpolation not allowed for source2." );
        return( nfu_invalidInterpolation );
    }
 
    xy1 = ptwXY_getPointAtIndex_Unsafely( ptwXY1, 0 );
    xy2 = ptwXY_getPointAtIndex_Unsafely( ptwXY2, 0 );
    code1 = 0;
    if( xy1->x < xy2->x ) {
        lowerEps1 = 0.;
        if( xy2->y == 0. ) {
            lowerEps2 = 0.; }
        else {
            if( lowerEps2 == 0 ) {
                code1 = -1; }
            else {
                if( ( xy2->x - xy1->x ) < lowerEps2 * ( fabs( xy1->x ) + fabs( xy2->x ) ) ) {
                    lowerEps2 = 0;
                    xy1->x = xy2->x;
                    status = ptwXY_areDomainsMutual( smr, ptwXY1, ptwXY2 );
                }
            }
        } }
    else if( xy1->x > xy2->x ) {
        lowerEps2 = 0.;
        if( xy1->y == 0. ) {
            lowerEps1 = 0.; }
        else {
            if( lowerEps1 == 0 ) {
                code1 = 1; }
            else {
                if( ( xy1->x - xy2->x ) < lowerEps1 * ( fabs( xy1->x ) + fabs( xy2->x ) ) ) {
                    lowerEps1 = 0;
                    xy2->x = xy1->x;
                    status = ptwXY_areDomainsMutual( smr, ptwXY1, ptwXY2 );
                }
            }
        } }
    else {
        lowerEps1 = lowerEps2 = 0.;
    }
 
    xy1 = ptwXY_getPointAtIndex_Unsafely( ptwXY1, n1 - 1 );
    xy2 = ptwXY_getPointAtIndex_Unsafely( ptwXY2, n2 - 1 );
    code2 = 0;
    if( xy1->x < xy2->x ) {
        upperEps2 = 0.;
        if( xy1->y == 0. ) {
            upperEps1 = 0.; }
        else {
            if( upperEps1 == 0 ) {
                code2 = -1; }
            else {
                if( ( xy2->x - xy1->x ) < upperEps1 * ( fabs( xy1->x ) + fabs( xy2->x ) ) ) {
                    upperEps1 = 0;
                    xy2->x = xy1->x;
                    status = ptwXY_areDomainsMutual( smr, ptwXY1, ptwXY2 );
                }
            }
        } }
    else if( xy1->x > xy2->x ) {
        upperEps1 = 0.;
        if( xy2->y == 0. ) {
            upperEps2 = 0.; }
        else {
            if( upperEps2 == 0 ) {
                code2 = 1; }
            else {
                if( ( xy1->x - xy2->x ) < upperEps2 * ( fabs( xy1->x ) + fabs( xy2->x ) ) ) {
                    upperEps2 = 0;
                    xy1->x = xy2->x;
                    status = ptwXY_areDomainsMutual( smr, ptwXY1, ptwXY2 );
                }
            }
        } }
    else {
        upperEps1 = upperEps2 = 0.;
    }
 
    if( ( lowerEps1 != 0. ) || ( upperEps1 != 0. ) ) {
        if( ( status = ptwXY_dullEdges( smr, ptwXY1, lowerEps1, upperEps1, positiveXOnly1 ) ) != nfu_Okay ) {
            smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
            return( status );
        }
    }
    if( ( lowerEps2 != 0. ) || ( upperEps2 != 0. ) ) {
        if( ( status = ptwXY_dullEdges( smr, ptwXY2, lowerEps2, upperEps2, positiveXOnly2 ) ) != nfu_Okay ) {
            smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
            return( status );
        }
    }
 
    if( status == nfu_domainsNotMutual ) {
        char str[256] = "";
 
        if( code1 ==  1 ) strcat( str, " lowerEps1" );
        if( code1 == -1 ) strcat( str, " lowerEps2" );
        if( code2 ==  1 ) strcat( str, " upperEps2" );
        if( code2 == -1 ) strcat( str, " upperEps1" );
        smr_setReportError2( smr, nfu_SMR_libraryID, nfu_badInput, 
                "The following inputs are 0 and must be a non 0 value: %s.", str );
        status = nfu_badInput;
    }
 
    return( status );
}

Referenced by GIDI::multiGroupTwoXYs1ds(), and GIDI::multiGroupXYs1d().

ptwXY_neg()

nfu_status ptwXY_neg	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY )

Definition at line 36 of file ptwXY_unitaryOperators.c.

                                                                        {
 
    int64_t i, nonOverflowLength;
    ptwXYPoint *p;
    ptwXYOverflowPoint *o, *overflowHeader = &(ptwXY->overflowHeader);
 
    if( ( nonOverflowLength = ptwXY_getNonOverflowLength( smr, ptwXY ) ) < 0 ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( ptwXY->status );
    }
 
    if( ( ptwXY->interpolation != ptwXY_interpolationLinLin ) && ( ptwXY->interpolation != ptwXY_interpolationLinLog ) &&
            ( ptwXY_interpolationLinLog != ptwXY_interpolationFlat ) ) {
        smr_setReportError2( smr, nfu_SMR_libraryID, nfu_unsupportedInterpolation, 
                "Negation of non-linear y-interpolation not allowed: interpolation = '%s'.",
                ptwXY->interpolationString ); 
        return( nfu_unsupportedInterpolation );
    }
 
    for( i = 0, p = ptwXY->points; i < nonOverflowLength; i++, p++ ) p->y = -p->y;
    for( o = overflowHeader->next; o != overflowHeader; o = o->next ) o->point.y = -o->point.y;
    return( ptwXY->status );
}

Referenced by ptwXY_sub_ptwXY().

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_normalize()

nfu_status ptwXY_normalize	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY1 )

Definition at line 242 of file ptwXY_integration.c.

                                                                              {
/*
*   This function assumes ptwXY_integrateDomain coalesces the points.
*/
    int64_t i1;
    nfu_status status = nfu_Okay;
    double sum;
 
    if( status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Via." );
        return( nfu_badSelf );
    }
 
    if( ( status = ptwXY_integrateDomain( smr, ptwXY, &sum ) ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Via." );
        return( status );
    }
 
    if( sum == 0. ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badNorm, "Cannot normalize curve with 0 norm." );
        status = nfu_badNorm; }
    else {
        for( i1 = 0; i1 < ptwXY->length; i1++ ) ptwXY->points[i1].y /= sum;
    }
    return( status );
}

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

ptwXY_pow()

nfu_status ptwXY_pow	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		double	p )

Definition at line 24 of file ptwXY_functions.c.

                                                                                  { 
 
    nfu_status status = ptwXY_applyFunction( smr, ptwXY, ptwXY_pow_callback, (void *) &v, 0 );
 
    if( status != nfu_Okay ) smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
    return( status );
}

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 *	value )

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 *	value )

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_runningIntegral()

ptwXPoints * ptwXY_runningIntegral	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY )

Definition at line 906 of file ptwXY_integration.c.

                                                                                     {
 
    int i;
    ptwXPoints *runningIntegral = NULL;
    double integral = 0., sum;
 
    if( ptwXY_simpleCoalescePoints( smr, ptwXY ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( NULL );
    }
 
    if( ( runningIntegral = ptwX_new( smr, ptwXY->length ) ) == NULL ) goto Err;
 
    if( ptwXY->length == 0 ) return( runningIntegral );
 
    if( ptwX_setPointAtIndex( smr, runningIntegral, 0, 0. ) != nfu_Okay ) goto Err;
    for( i = 1; i < ptwXY->length; i++ ) {
        if( ptwXY_f_integrate( smr, ptwXY->interpolation, ptwXY->points[i-1].x, ptwXY->points[i-1].y, 
            ptwXY->points[i].x, ptwXY->points[i].y, &sum ) != nfu_Okay ) goto Err;
        integral += sum;
        if( ptwX_setPointAtIndex( smr, runningIntegral, i, integral ) != nfu_Okay ) goto Err;
    }
    return( runningIntegral );
 
Err:
    smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
    if( runningIntegral != NULL ) ptwX_free( runningIntegral );
    return( NULL );
}

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

ptwXY_scaleAndOffsetDomainWith_ptwXYs()

nfu_status ptwXY_scaleAndOffsetDomainWith_ptwXYs	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		ptwXYPoints *	offset,
		ptwXYPoints *	slope,
		int	skipLastPoint )

Definition at line 709 of file ptwXY_methods.c.

                                    {
/*
    This function only modifies ptwXY over the domain defined by offsetXY via the equation ptwXY = offsetXY + slopeXY * ptwXY. 
    slopeXY must have the same domain as offsetXY.  If skipLastPoint is non-zero, the last point modified is reverted by to its 
    origial value.  This allows one to call this function multiple times with abutting domains for the offset and slope without 
    getting weird jumps at the boundaries. For example, suppose ptwXY is initially defined to be 1 in the domain [0,10]. Let,
    ptwXY have the points [ [ 0, 1 ], [ 5, 1 ], [ 10, 1 ] ]. Calling this function with an offset and slope with the points
    [ [ 0, 0 ], [ 5, 0 ] ] and [ 0, 2 ], [ 5, 2 ], respectively would return ptwXY as [ [ 0, 2 ], [ 5, 2 ], [ 10, 1 ] ]
    if skipLastPoint is 0 and [ [ 0, 2 ], [ 5, 1 ], [ 10, 1 ] ] otherwise. Now calling the returned ptwXYPoints instances with an 
    offset and slope with the points [ [ 5, 0 ], [ 10, 0 ] ] and [ 5, 2 ], [ 10, 2 ], respectively would return ptwXY as 
    [ [ 0, 2 ], [ 5, 4 ], [ 10, 2 ] ] and [ [ 0, 2 ], [ 5, 2 ], [ 10, 2 ] ], respectively.
*/
 
    int64_t i1;
    ptwXYPoint *p1;
    nfu_status status1, status2;
    double offsetXYMin, offsetXYMax, slopeXYMin, slopeXYMax, domainMin, domainMax, domainMinXY, domainMaxXY;
    ptwXYPoints *ptwXY2 = NULL, *offsetXY2 = NULL, *slopeXY2 = NULL;
    ptwXYPoints *mulXY = NULL, *addXY = NULL;
 
    if( ptwXY_simpleCoalescePoints( smr, ptwXY ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( ptwXY->status );
    }
 
    status1 = ptwXY_domainMin( smr, offsetXY, &offsetXYMin );       /* Also verifies that offsetXY has no issues. */
    if( ( status1 != nfu_Okay ) && ( status1 != nfu_empty ) ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( status1 );
    }
    ptwXY_domainMax( smr, offsetXY, &offsetXYMax );                 /* If ptwXY_domainMin succeeded, this will succeed. */
 
    status2 = ptwXY_domainMin( smr, slopeXY, &slopeXYMin );
    if( ( status2 != nfu_Okay ) && ( status2 != nfu_empty ) ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( status2 );
    }
    ptwXY_domainMax( smr, slopeXY, &slopeXYMax );
 
    if( ( status1 == nfu_empty ) && ( status2 == nfu_empty ) ) return( nfu_Okay );
 
    if( ( offsetXYMin != slopeXYMin ) || ( offsetXYMax != slopeXYMax ) ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_domainsNotMutual, "Offset and slope do not have the same domain." );
        return( ptwXY->status = nfu_domainsNotMutual );
    }
 
    if( ptwXY->length == 0 ) return( nfu_Okay );
 
    ptwXY_domainMin( smr, ptwXY, &domainMinXY );
    ptwXY_domainMax( smr, ptwXY, &domainMaxXY );
 
    if( ( domainMinXY >= offsetXYMax ) || ( domainMaxXY <= offsetXYMin ) ) return( nfu_Okay );
 
    domainMin = ( domainMinXY > offsetXYMin ? domainMinXY : offsetXYMin );
    domainMax = ( domainMaxXY < offsetXYMax ? domainMaxXY : offsetXYMax );
 
    if( ( domainMinXY == offsetXYMin ) && ( domainMaxXY == offsetXYMax ) ) {
        ptwXY2 = ptwXY;
        offsetXY2 = offsetXY;
        slopeXY2 = slopeXY; }
    else {
        if( ( ptwXY2 = ptwXY_domainSlice( smr, ptwXY, domainMin, domainMax, 0, 1 ) ) == NULL ) {
            smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
            goto Err;
        }
 
        if( ( offsetXY2 = ptwXY_domainSlice( smr, offsetXY, domainMin, domainMax, 0, 1 ) ) == NULL ) {
            smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
            goto Err;
        }
 
        if( ( slopeXY2 = ptwXY_domainSlice( smr, slopeXY, domainMin, domainMax, 0, 1 ) ) == NULL ) {
            smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
            goto Err;
        }
    }
 
    if( ( mulXY = ptwXY_mul2_ptwXY( smr, ptwXY2, slopeXY2 ) ) == NULL ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        goto Err;
    }
    if( ( addXY = ptwXY_mul2_ptwXY( smr, mulXY, offsetXY2 ) ) == NULL ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        goto Err;
    }
    if( skipLastPoint != 0 ) addXY->points[addXY->length-1].y = ptwXY2->points[ptwXY2->length-1].y;
 
    if( domainMin > domainMinXY ) {
        for( i1 = 0, p1 = ptwXY2->points; i1 < ptwXY2->length; i1++, p1++ ) {
            if( p1->x >= domainMin ) break;
            if( ptwXY_setValueAtX( smr, addXY, p1->x, p1->y ) != nfu_Okay ) goto Err;
        }
    }
 
    if( domainMax < domainMaxXY ) {
        for( i1 = 0, p1 = ptwXY2->points; i1 < ptwXY2->length; i1++, p1++ ) if( p1->x > domainMax ) break;
        for( ; i1 < ptwXY2->length; i1++, p1++ ) {
            if( ptwXY_setValueAtX( smr, addXY, p1->x, p1->y ) != nfu_Okay ) goto Err;
        }
    }
 
    ptwXY_copy( smr, ptwXY, addXY );
 
TheEnd:
    if( offsetXY2 != offsetXY ) ptwXY_free( offsetXY2 );
    if( slopeXY2 != slopeXY ) ptwXY_free( slopeXY2 );
    if( ptwXY2 != ptwXY ) ptwXY_free( ptwXY2 );
    ptwXY_free( mulXY );
    ptwXY_free( addXY );
 
    return( ptwXY->status );
 
Err:
    ptwXY->status = nfu_Error;
    goto TheEnd;
}

ptwXY_scaleOffsetXAndY()

nfu_status ptwXY_scaleOffsetXAndY	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		double	xScale,
		double	xOffset,
		double	yScale,
		double	yOffset )

Definition at line 666 of file ptwXY_methods.c.

                                        {
 
    int64_t i1, length = ptwXY->length;
    ptwXYPoint *p1;
    nfu_status status;
 
    if( ptwXY->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Invalid destination." );
        return( ptwXY->status );
    }
 
    if( xScale == 0 ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_XNotAscending, "xScale is 0 that will cause a non-ascending domain." );
        return( ptwXY->status = nfu_XNotAscending );
    }
 
    if( ( status = ptwXY_simpleCoalescePoints( smr, ptwXY ) ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( status );
    }
 
    for( i1 = 0, p1 = ptwXY->points; i1 < length; i1++, p1++ ) {
        p1->x = xScale * p1->x + xOffset;
        p1->y = yScale * p1->y + yOffset;
    }
 
    if( xScale < 0 ) {
        int64_t length_2 = length / 2;
        ptwXYPoint tmp, *p2;
 
        for( i1 = 0, p1 = ptwXY->points, p2 = &(ptwXY->points[length-1]); i1 < length_2; i1++ ) {
            tmp = *p1;
            *p1 = *p2;
            *p2 = tmp;
        }
    }
 
    return( ptwXY->status );
}

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_showInteralStructure()

void ptwXY_showInteralStructure	(	ptwXYPoints *	ptwXY,
		FILE *	f,
		int	printPointersAsNull )

Definition at line 297 of file ptwXY_misc.c.

                                                                                        {
 
    int64_t i, n1;
    ptwXYPoint *point = ptwXY->points;
    ptwXYOverflowPoint *overflowPoint;
 
    n1 = ptwXY_getNonOverflowLength( NULL, ptwXY );
 
    fprintf( f, "status = %d  interpolation = %d  length = %d  allocatedSize = %d\n", 
        (int) ptwXY->status, (int) ptwXY->interpolation, (int) ptwXY->length, (int) ptwXY->allocatedSize );
    fprintf( f, "userFlag = %d  biSectionMax = %.8e  accuracy = %.2e  minFractional_dx = %.6e\n", 
        ptwXY->userFlag, ptwXY->biSectionMax, ptwXY->accuracy, ptwXY->minFractional_dx );
    fprintf( f, "interpolationString = %s\n", ptwXY->interpolationString );
    fprintf( f, "  overflowLength = %d  overflowAllocatedSize = %d  mallocFailedSize = %d\n", 
        (int) ptwXY->overflowLength, (int) ptwXY->overflowAllocatedSize, (int) ptwXY->mallocFailedSize );
    fprintf( f, "  Points data, points = %20p\n", ( printPointersAsNull ? NULL : ptwXY->points ) );
    for( i = 0; i < n1; i++,  point++ ) fprintf( f, "    %14.7e %14.7e\n", point->x, point->y );
    fprintf( f, "  Overflow points data; %20p\n", ( printPointersAsNull ? NULL : &(ptwXY->overflowHeader) ) );
    for( overflowPoint = ptwXY->overflowHeader.next; overflowPoint != &(ptwXY->overflowHeader); overflowPoint = overflowPoint->next ) {
        fprintf( f, "    %14.7e %14.7e %8d %20p %20p %20p\n", overflowPoint->point.x, overflowPoint->point.y, (int) overflowPoint->index, 
            ( printPointersAsNull ? NULL : overflowPoint ), ( printPointersAsNull ? NULL : overflowPoint->prior ), 
            ( printPointersAsNull ? NULL : overflowPoint->next ) );
    }
    fprintf( f, "  Points in order\n" );
    for( i = 0; i < ptwXY->length; i++ ) {
        point = ptwXY_getPointAtIndex_Unsafely( ptwXY, i );
        fprintf( f, "    %14.7e %14.7e\n", point->x, point->y );
    }
}

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_simplePrint()

void ptwXY_simplePrint	(	ptwXYPoints *	ptwXY,
		char const *	format )

Definition at line 342 of file ptwXY_misc.c.

                                                                 {
 
    ptwXY_simpleWrite( ptwXY, stdout, format );
}

ptwXY_simpleWrite()

void ptwXY_simpleWrite	(	ptwXYPoints *	ptwXY,
		FILE *	f,
		char const *	format )

Definition at line 329 of file ptwXY_misc.c.

                                                                          {
 
    int64_t i;
    ptwXYPoint *point;
 
    for( i = 0; i < ptwXY->length; i++ ) {
        point = ptwXY_getPointAtIndex_Unsafely( ptwXY, i );
        fprintf( f, format, point->x, point->y );
    }
}

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

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_slopeOffset()

nfu_status ptwXY_slopeOffset	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		double	slope,
		double	offset )

Definition at line 27 of file ptwXY_binaryOperators.c.

                                                                                                             { 
 
    int64_t i, nonOverflowLength;
    ptwXYPoint *p;
    ptwXYOverflowPoint *o, *overflowHeader = &(ptwXY->overflowHeader);
 
    if( ( nonOverflowLength = ptwXY_getNonOverflowLength( smr, ptwXY ) ) < 0 ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( ptwXY->status );
    }
 
    for( i = 0, p = ptwXY->points; i < nonOverflowLength; i++, p++ ) p->y = slope * p->y + offset;
    for( o = overflowHeader->next; o != overflowHeader; o = o->next ) o->point.y = slope * o->point.y + offset; 
    return( ptwXY->status );
}   

Referenced by ptwXY_add_double(), ptwXY_div_doubleFrom(), ptwXY_mul_double(), ptwXY_sub_doubleFrom(), and ptwXY_sub_fromDouble().

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().

ptwXY_sub_doubleFrom()

nfu_status ptwXY_sub_doubleFrom	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		double	value )

Definition at line 54 of file ptwXY_binaryOperators.c.

                                                                                                 {
 
    if( ptwXY_slopeOffset( smr, ptwXY,  1., -value ) != nfu_Okay )
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
    return( ptwXY->status );
}

ptwXY_sub_fromDouble()

nfu_status ptwXY_sub_fromDouble	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		double	value )

Definition at line 63 of file ptwXY_binaryOperators.c.

                                                                                                 {
 
    if( ptwXY_slopeOffset( smr, ptwXY, -1.,  value ) != nfu_Okay )
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
    return( ptwXY->status );
}

ptwXY_sub_ptwXY()

ptwXYPoints * ptwXY_sub_ptwXY	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY1,
		ptwXYPoints *	ptwXY2 )

Definition at line 245 of file ptwXY_binaryOperators.c.

                                                                                                      {
 
    ptwXYPoints *diff = NULL;
 
    if( ptwXY1->length == 0 ) {
        diff = ptwXY_clone( smr, ptwXY2 );
        if( diff != NULL ) {
            if( ptwXY_neg( smr, diff ) != nfu_Okay ) diff = ptwXY_free( diff );
        } }
    else if( ptwXY2->length == 0 ) {
        diff = ptwXY_clone( smr, ptwXY1 ); }
    else {
        diff = ptwXY_binary_ptwXY( smr, ptwXY1, ptwXY2, 1., -1., 0. );
    }
    if( diff == NULL ) smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
    return( diff );
}

Referenced by GIDI::Functions::XYs1d::operator-=().

ptwXY_thicken()

nfu_status ptwXY_thicken	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY1,
		int	sectionSubdivideMax,
		double	dDomainMax,
		double	fDomainMax )

Definition at line 155 of file ptwXY_methods.c.

                                               {
 
    double x1, x2 = 0., y1, y2 = 0., fx = 1.1, x, dx, dxp, lfx, y;    /* fx initialized so compilers want complain. */
    int64_t i, notFirstPass = 0;
    int nfx, nDone, doLinear;
 
    if( ptwXY1->interpolation == ptwXY_interpolationOther ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_otherInterpolation, "Other interpolation not allowed." );
        return( nfu_otherInterpolation );
    }
    if( ( sectionSubdivideMax < 1 ) || ( dDomainMax < 0. ) || ( fDomainMax < 1. ) ) {
        smr_setReportError2( smr, nfu_SMR_libraryID, nfu_Error, 
                "ptwXY_thicken: One or more of the following not satisfied: sectionSubdivideMax = %d > 0, dDomainMax = %e >= 0.0, fDomainMax = %e >= 1.0",
                sectionSubdivideMax, dDomainMax, fDomainMax );
        return( nfu_badInput );
    }
    if( sectionSubdivideMax > ptwXY_sectionSubdivideMax ) sectionSubdivideMax = ptwXY_sectionSubdivideMax;
    if( ptwXY_simpleCoalescePoints( smr, ptwXY1 ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( ptwXY1->status );
    }
    for( i = ptwXY1->length - 1; i >= 0; i-- ) {
        x1 = ptwXY1->points[i].x;
        y1 = ptwXY1->points[i].y;
        if( notFirstPass ) {
            dx = ptwXY_thicken_linear_dx( sectionSubdivideMax, dDomainMax, x1, x2 );
 
            if( x1 == 0. ) {
                doLinear = 1; }
            else {
                fx = x2 / x1;
                if( fx > 0. ) {
                    lfx = log( fx );
                    if( fDomainMax == 1. ) {
                        nfx = sectionSubdivideMax; }
                    else {
                        nfx = ( (int) ( lfx / log( fDomainMax ) ) ) + 1;
                        if( nfx > sectionSubdivideMax ) nfx = sectionSubdivideMax;
                    }
                    if( nfx > 0 ) fx = exp( lfx / nfx );
                    doLinear = 0;
                    if( dx < ( fx - 1 ) * x1 ) doLinear = 1; }
                else {
                    doLinear = 1;
                }
            }
            x = x1;
            dxp = dx;
            nDone = 0;
            while( 1 ) {
                if( doLinear ) {
                    x += dx; }
                else {
                    dx = ptwXY_thicken_linear_dx( sectionSubdivideMax - nDone, dDomainMax, x, x2 );
                    if( dx <= ( fx - 1 ) * x ) {
                        dxp = dx;
                        doLinear = 1;
                        continue;
                    }
                    dxp = ( fx - 1. ) * x;
                    x *= fx;
                }
                if( ( x2 - x ) < 0.05 * fabs( dxp ) ) break;
                if( ( ptwXY1->status = ptwXY_interpolatePoint( smr, ptwXY1->interpolation, x, &y, x1, y1, x2, y2 ) ) != nfu_Okay ) {
                    smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
                    return( ptwXY1->status );
                }
                if( ( ptwXY1->status = ptwXY_setValueAtX( smr, ptwXY1, x, y ) ) != nfu_Okay ) {
                    smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
                    return( ptwXY1->status );
                }
                nDone++;
            }
        }
        notFirstPass = 1;
        x2 = x1;
        y2 = y1;
    }
    return( ptwXY1->status );
}

ptwXY_thin()

ptwXYPoints * ptwXY_thin	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY1,
		double	accuracy )

Definition at line 259 of file ptwXY_methods.c.

                                                                                             {
 
    int64_t i, j, length = ptwXY1->length;
    ptwXYPoints *thinned = NULL;
    double y1, y2, y3, accuracyNew;
    char *thin = NULL;
 
    if( length < 3 ) {                          /* Logic below requires at least 2 points. */
        if( ( thinned = ptwXY_clone( smr, ptwXY1 ) ) == NULL )
            smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( thinned );
    }
 
    if( ptwXY_simpleCoalescePoints( smr, ptwXY1 ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( NULL );
    }
 
    if( ptwXY1->interpolation == ptwXY_interpolationOther ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_otherInterpolation, "Other interpolation not allowed." );
        return( NULL );
    }
 
    accuracy = ptwXY_limitAccuracy( accuracy );
    accuracyNew = accuracy;
    if( accuracyNew < ptwXY1->accuracy ) accuracyNew = ptwXY1->accuracy;
    if( ( thinned = ptwXY_new( smr, ptwXY1->interpolation, ptwXY1->interpolationString, 
            ptwXY1->biSectionMax, accuracyNew, length, ptwXY1->overflowLength, ptwXY1->userFlag ) ) == NULL ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( NULL );
    }
 
    thinned->points[0] = ptwXY1->points[0];                     /* This sections removes middle point if surrounding points have the same y-value. */
    y1 = ptwXY1->points[0].y;
    y2 = ptwXY1->points[1].y;
    for( i = 2, j = 1; i < length; i++ ) {
        y3 = ptwXY1->points[i].y;
        if( ( y1 != y2 ) || ( y2 != y3 ) ) {
            thinned->points[j++] = ptwXY1->points[i - 1];
            y1 = y2;
            y2 = y3;
        }
    }
    thinned->points[j++] = ptwXY1->points[length - 1];
 
    if( ptwXY1->interpolation != ptwXY_interpolationFlat ) {    /* Now call ptwXY_thin2 for more thinning. */
        length = thinned->length = j;
        if( ( thin = (char *) smr_malloc2( smr, (size_t) length, 1, "thin" ) ) == NULL ) goto Err2;
        if( ptwXY_thin2( smr, thinned, thin, accuracy, 0, length - 1 ) != nfu_Okay ) goto Err1;
        for( j = 1; j < length; j++ ) if( thin[j] != 0 ) break;
        for( i = j + 1; i < length; i++ ) {
            if( thin[i] == 0 ) {
                thinned->points[j] = thinned->points[i];
                j++;
            }
        }
        smr_freeMemory2( thin );
    }
    thinned->length = j;
 
    return( thinned );
 
Err1:
    smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
Err2:
    ptwXY_free( thinned );
    if( thin != NULL ) smr_freeMemory2( thin );
    return( NULL );
}

ptwXY_thinDomain()

ptwXYPoints * ptwXY_thinDomain	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY1,
		double	epsilon )

Definition at line 365 of file ptwXY_methods.c.

                                                                                                  {
/*
*   Thins domain points that are closer the '0.5 * (x[i+1] + x[i]) * epsilon'.
*/
    int64_t i1, i2, length = ptwXY1->length, lengthm1 = length - 1, thinnedLength = 0;
    ptwXYPoint *points;
    ptwXYPoints *thinned = NULL;
    double x1, x2, x3, dx, y2, half_epsilon = 0.5 * epsilon;
 
    if( ptwXY1->interpolation == ptwXY_interpolationFlat ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_invalidInterpolation, "Flat interpolation not allowed." );
        return( NULL );
    }
 
    if( ptwXY1->interpolation == ptwXY_interpolationOther ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_otherInterpolation, "Other interpolation not allowed." );
        return( NULL );
    }
 
    if( ptwXY_simpleCoalescePoints( smr, ptwXY1 ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( NULL );
    }
 
    if( length > 1 ) {
        if( ( ptwXY1->points[length-1].x - ptwXY1->points[0].x ) < half_epsilon * ( fabs( ptwXY1->points[0].x ) + fabs( ptwXY1->points[0].x ) ) ) {
            smr_setReportError2( smr, nfu_SMR_libraryID, nfu_Error, "Domain (%.17e, %.17e) is less than epsilon = %.17e.", 
                    ptwXY1->points[0].x, ptwXY1->points[length-1].x, epsilon );
            return( NULL );
        }
    }
 
    if( ( length <= 2 ) || ( epsilon < 2 * DBL_EPSILON ) ) {
        if( ( thinned = ptwXY_clone( smr, ptwXY1 ) ) == NULL ) smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( thinned );
    }
 
    if( ( thinned = ptwXY_new( smr, ptwXY1->interpolation, ptwXY1->interpolationString, ptwXY1->biSectionMax, ptwXY1->accuracy, 
            length, ptwXY1->overflowAllocatedSize, ptwXY1->userFlag ) ) == NULL ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( NULL );
    }
 
    points = thinned->points;
    *points = ptwXY1->points[0];
    ++points;
    ++thinnedLength;
    x1 = ptwXY1->points[0].x;
    x2 = x3 = x1;                                                       /* To stop some compilers from printing a warning. */
    for( i1 = 1; i1 < lengthm1; i1 = i2 ) {
        for( i2 = i1; i2 < length; ++i2 ) {                             /* Find next x3 that is  epsilon * ( x1 + x2 ) / 2 above x1. */
            x3 = ptwXY1->points[i2].x;
            if( ( x3 - x1 ) >= half_epsilon * ( fabs( x1 ) + fabs( x3 ) ) ) break;
            x2 = x3;
        }
        if( i1 == i2 ) {
            y2 = ptwXY1->points[i2].y;
            x2 = x3; }
        else {
            if( ( x3 - x1 ) > ( epsilon * ( fabs( x1 ) + fabs( x3 ) ) ) ) {
                dx = fabs( x2 * epsilon );
                x2 = x1 + dx;
                if( ptwXY_getValueAtX( smr, ptwXY1, x2, &y2 ) != nfu_Okay ) {
                    smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
                    ptwXY_free( thinned );
                    return( NULL );
                }
                --i2; }
            else {
                if( i2 == length ) break;
                x2 = x3;
                y2 = ptwXY1->points[i2].y;
            }
        }
        points->x = x2;
        points->y = y2;
        ++points;
        ++thinnedLength;
        x1 = x2;
        ++i2;
    }
 
    x3 = ptwXY1->points[lengthm1].x;
    x2 = thinned->points[thinnedLength-1].x;
    if( ( x3 - x2 ) < ( half_epsilon * ( fabs( x2 ) + fabs( x3 ) ) ) ) {
        --points;
        --thinnedLength;
        x1 = thinned->points[thinnedLength-1].x;
        if( ( x3 - x1 ) > ( epsilon * ( fabs( x1 ) + fabs( x2 ) ) ) ) {
            dx = fabs( x3 * epsilon );
            x2 = x3 - dx;
            if( ptwXY_getValueAtX( smr, ptwXY1, x2, &y2 ) != nfu_Okay ) {
                smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
                ptwXY_free( thinned );
                return( NULL );
            }
            points->x = x2;
            points->y = y2;
            ++points;
            ++thinnedLength;
        }
    }
    points->x = x3;
    points->y = ptwXY1->points[lengthm1].y;
    ++thinnedLength;
    thinned->length = thinnedLength;
 
    return( thinned );
}

ptwXY_toOtherInterpolation()

ptwXYPoints * ptwXY_toOtherInterpolation	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		ptwXY_interpolation	interpolation,
		double	accuracy )

Definition at line 197 of file ptwXY_interpolation.c.

                                                               {
/*
*   This function only works when 'ptwXY->interpolation == interpolationTo' or when interpolationTo is ptwXY_interpolationLinLin.
*/
    int i1, logX = 0, logY = 0;
    ptwXYPoints *n1;
    interpolation_func func = NULL;
 
    if( ptwXY->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Invalid source." );
        return( NULL );
    }
 
    if( ptwXY->interpolation == interpolationTo ) {
        if( ( n1 = ptwXY_clone( smr, ptwXY ) ) == NULL ) smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( n1 ); }
    else {
        if( interpolationTo == ptwXY_interpolationLinLin ) {
            switch( ptwXY->interpolation ) {
            case ptwXY_interpolationLogLog :
                logX = logY = 1;
                func = ptwXY_LogLogToLinLin; break;
            case ptwXY_interpolationLogLin :
                logY = 1;
                func = ptwXY_LogLinToLinLin; break;
            case ptwXY_interpolationLinLog :
                logX = 1;
                func = ptwXY_LinLogToLinLin; break;
            case ptwXY_interpolationLinLin :        /* Stops compilers from complaining. */
            case ptwXY_interpolationFlat :
            case ptwXY_interpolationOther :
                break;
            }
        }
    }
    if( func == NULL ) {
        smr_setReportError2( smr, nfu_SMR_libraryID, nfu_unsupportedInterpolationConversion,
                "Interpolation conversion from '%s' to %d not supported.", ptwXY->interpolationString, interpolationTo );
        return( NULL );
    }
 
    if( ( logX != 0 ) || ( logY != 0 ) ) {
        ptwXYPoint *point;
 
        if( ptwXY_simpleCoalescePoints( smr, ptwXY ) != nfu_Okay ) {
            smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
            return( NULL );
        }
 
        for( i1 = 0, point = ptwXY->points; i1 < ptwXY->length; ++i1, ++point ) {
            if( ( logX != 0 ) && ( point->x <= 0 ) ) {
                smr_setReportError2( smr, nfu_SMR_libraryID, nfu_badLogValue, "At index %d x-value %.16e for log <= 0.", 
                        (int) i1, point->x );
                return( NULL );
            }
            if( ( logY != 0 ) && ( point->y <= 0 ) ) {
                smr_setReportError2( smr, nfu_SMR_libraryID, nfu_badLogValue, "At index %d y-value %.16e for log <= 0.", 
                        (int) i1, point->y );
                return( NULL );
            }
        }
    }
 
    if( ( n1 = ptwXY_cloneToInterpolation( smr, ptwXY, interpolationTo ) ) == NULL ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( NULL );
    }
    n1->accuracy = ptwXY_limitAccuracy( accuracy );
 
    if( ptwXY_toOtherInterpolation2( smr, n1, ptwXY, func ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        n1 = ptwXY_free( n1 ); }
    else {
        if( n1->accuracy < ptwXY->accuracy ) n1->accuracy = ptwXY->accuracy;
    }
    return( n1 );
}

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

ptwXY_toUnitbase()

ptwXYPoints * ptwXY_toUnitbase	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		int	scaleRange )

Definition at line 373 of file ptwXY_interpolation.c.

                                                                                                 {
 
    int64_t i;
    ptwXYPoints *n;
    ptwXYPoint *p;
    double domainMin, domainMax, dx, inverseDx;
 
    if( ptwXY->length < 2 ) {
        smr_setReportError2( smr, nfu_SMR_libraryID, nfu_tooFewPoints, "Too few points %d", (int) ptwXY->length );
        return( NULL );
    }
    if( ( n = ptwXY_clone( smr, ptwXY ) ) == NULL ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( NULL );
    }
 
    domainMin = n->points[0].x;
    domainMax = n->points[n->length-1].x;
    dx = domainMax - domainMin;
    inverseDx = 1. / dx;
    for( i = 0, p = n->points; i < n->length; i++, p++ ) {
        p->x = ( p->x - domainMin ) * inverseDx;
        if( scaleRange ) p->y = p->y * dx;
    }
    n->points[n->length-1].x = 1.;                          /* Make sure last point is realy 1. */
    return( n );
}

Referenced by ptwXY_unitbaseInterpolate().

ptwXY_trim()

nfu_status ptwXY_trim	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY )

Definition at line 477 of file ptwXY_methods.c.

                                                                         {
/*
c   Remove extra zeros at beginning and end.
*/
    int64_t i, i1, i2;
 
    if( ptwXY->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Invalid destination." );
        return( ptwXY->status );
    }
 
    if( ptwXY_simpleCoalescePoints( smr, ptwXY ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( ptwXY->status );
    }
 
    for( i1 = 0; i1 < ptwXY->length; i1++ ) {
        if( ptwXY->points[i1].y != 0 ) break;
    }
    if( i1 > 0 ) i1--;
    for( i2 = ptwXY->length - 1; i2 >= 0; i2-- ) {
        if( ptwXY->points[i2].y != 0 ) break;
    }
    i2++;
    if( i2 < ptwXY->length ) i2++;
    if( i2 > i1 ) {
        if( i1 > 0 ) {
            for( i = i1; i < i2; i++ ) ptwXY->points[i - i1] = ptwXY->points[i];
        }
        ptwXY->length = i2 - i1; }
    else if( i2 < i1 ) {                /* Remove all zeros between endpoints. */
        ptwXY->points[1] = ptwXY->points[ptwXY->length - 1];
        ptwXY->length = 2;
    }
 
    return( nfu_Okay );
}

ptwXY_tweakDomainsToMutualify()

nfu_status ptwXY_tweakDomainsToMutualify	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY1,
		ptwXYPoints *	ptwXY2,
		int	epsilonFactor,
		double	epsilon )

Definition at line 477 of file ptwXY_convenient.c.

                                            {
 
    nfu_status status = nfu_Okay;
    int64_t n1 = ptwXY1->length, n2 = ptwXY2->length;
    double sum, diff;
    ptwXYPoint *xy1, *xy2;
 
    epsilon = fabs( epsilon ) + fabs( epsilonFactor * DBL_EPSILON );
 
    if( ptwXY1->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Invalid source1." );
        return( ptwXY1->status );
    }
    if( ptwXY2->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Invalid source2." );
        return( ptwXY2->status );
    }
 
    if( n1 == 0 ) return( nfu_empty );
    if( n2 == 0 ) return( nfu_empty );
    if( n1 < 2 ) { 
        status = nfu_tooFewPoints; }
    else if( n2 < 2 ) { 
        status = nfu_tooFewPoints; }
    else {
        xy1 = ptwXY_getPointAtIndex_Unsafely( ptwXY1, 0 );
        xy2 = ptwXY_getPointAtIndex_Unsafely( ptwXY2, 0 );
        if( xy1->x < xy2->x ) {
            if( xy2->y != 0. ) {
                sum = fabs( xy1->x ) + fabs( xy2->x );
                diff = fabs( xy2->x - xy1->x );
                if( diff > epsilon * sum ) {
                    status = nfu_domainsNotMutual; }
                else {
                    xy1->x = xy2->x;
                }
            } }
        else if( xy1->x > xy2->x ) {
            if( xy1->y != 0. ) {
                sum = fabs( xy1->x ) + fabs( xy2->x );
                diff = fabs( xy2->x - xy1->x );
                if( diff > epsilon * sum ) {
                    status = nfu_domainsNotMutual; }
                else {
                    xy2->x = xy1->x;
                }
            }
        }
 
        if( status == nfu_Okay ) {
            xy1 = ptwXY_getPointAtIndex_Unsafely( ptwXY1, n1 - 1 );
            xy2 = ptwXY_getPointAtIndex_Unsafely( ptwXY2, n2 - 1 );
            if( xy1->x < xy2->x ) {
                if( xy1->y != 0. ) {
                    sum = fabs( xy1->x ) + fabs( xy2->x );
                    diff = fabs( xy2->x - xy1->x );
                    if( diff > epsilon * sum ) {
                        status = nfu_domainsNotMutual; }
                    else {
                        xy2->x = xy1->x;
                    }
                } }
            else if( xy1->x > xy2->x ) {
                if( xy2->y != 0. ) {
                    sum = fabs( xy1->x ) + fabs( xy2->x );
                    diff = fabs( xy2->x - xy1->x );
                    if( diff > epsilon * sum ) {
                        status = nfu_domainsNotMutual; }
                    else {
                        xy1->x = xy2->x;
                    }
                }
            }
        }
    }
    return( status );
}

Referenced by ptwXY_groupThreeFunctions(), and ptwXY_groupTwoFunctions().

ptwXY_union()

ptwXYPoints * ptwXY_union	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY1,
		ptwXYPoints *	ptwXY2,
		int	unionOptions )

Definition at line 517 of file ptwXY_methods.c.

                                                                                                                    {
 
    int64_t overflowSize, i, i1 = 0, i2 = 0, n1 = ptwXY1->length, n2 = ptwXY2->length, length;
    int fillWithFirst = unionOptions & ptwXY_union_fill, trim = unionOptions & ptwXY_union_trim;
    ptwXYPoints *n;
    double x1 = 0., x2 = 0., y1 = 0., y2 = 0., y, biSectionMax, accuracy;
/*
*   Many other routines use the fact that ptwXY_union calls ptwXY_coalescePoints for ptwXY1 and ptwXY2 so do not change it.
*/
    if( ptwXY_simpleCoalescePoints( smr, ptwXY1 ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( NULL );
    }
    if( ptwXY_simpleCoalescePoints( smr, ptwXY2 ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( NULL );
    }
 
    if( ptwXY1->interpolation == ptwXY_interpolationOther ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_otherInterpolation, "Other interpolation not allowed for source1." );
        return( NULL );
    }
    if( ptwXY2->interpolation == ptwXY_interpolationOther ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_otherInterpolation, "Other interpolation not allowed for source2." );
        return( NULL );
    }
 
    if( ( n1 == 1 ) || ( n2 == 1 ) ) {
        smr_setReportError2( smr, nfu_SMR_libraryID, nfu_tooFewPoints, 
                "Too few point in one of the sources: len( source1 ) = %d, len( source2 ) = %d", (int) n1, (int) n2 );
        return( NULL );
    }
    if( trim ) {
        if( n1 > 0 ) {
            if( n2 > 0 ) {
                if( ptwXY1->points[0].x < ptwXY2->points[0].x ) {
                    while( i1 < n1 ) {
                        if( ptwXY1->points[i1].x >= ptwXY2->points[0].x ) break;
                        if( fillWithFirst ) {
                            if( i1 < ( ptwXY1->length - 1 ) ) {
                                x1 = ptwXY1->points[i1].x;
                                y1 = ptwXY1->points[i1].y;
                                x2 = ptwXY1->points[i1+1].x;
                                y2 = ptwXY1->points[i1+1].y; 
                            }
                        }
                        i1++;
                    } }
                else {
                    while( i2 < n2 ) {
                        if( ptwXY2->points[i2].x >= ptwXY1->points[0].x ) break;
                        i2++;
                    }
                }
                if( ptwXY1->points[n1-1].x > ptwXY2->points[n2-1].x ) {
                    while( i1 < n1 ) {
                        if( ptwXY1->points[n1-1].x <= ptwXY2->points[n2-1].x ) break;
                        n1--;
                    } }
                else {
                    while( i2 < n2 ) {
                        if( ptwXY2->points[n2-1].x <= ptwXY1->points[n1-1].x ) break;
                        n2--;
                    }
                } }
            else {
                n1 = 0;
            } }
        else {
            n2 = 0;
        }
    }
    overflowSize = ptwXY1->overflowAllocatedSize;
    if( overflowSize < ptwXY2->overflowAllocatedSize ) overflowSize = ptwXY2->overflowAllocatedSize;
    length = ( n1 - i1 ) + ( n2 - i2 );
    if( length == 0 ) length = ptwXY_minimumSize;
    biSectionMax = ptwXY1->biSectionMax;
    if( biSectionMax < ptwXY2->biSectionMax ) biSectionMax = ptwXY2->biSectionMax;
    accuracy = ptwXY1->accuracy;
    if( accuracy < ptwXY2->accuracy ) accuracy = ptwXY2->accuracy;
    n = ptwXY_new( smr, ptwXY1->interpolation, NULL, biSectionMax, accuracy, length, overflowSize, ptwXY1->userFlag );
    if( n == NULL ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( NULL );
    }
 
    for( i = 0; ( i1 < n1 ) && ( i2 < n2 ); i++ ) {
        y = 0.;
        if( ptwXY1->points[i1].x <= ptwXY2->points[i2].x ) {
            n->points[i].x = ptwXY1->points[i1].x;
            if( fillWithFirst ) {
                y = ptwXY1->points[i1].y;
                if( i1 < ( ptwXY1->length - 1 ) ) {
                    x1 = ptwXY1->points[i1].x;
                    y1 = ptwXY1->points[i1].y;
                    x2 = ptwXY1->points[i1+1].x;
                    y2 = ptwXY1->points[i1+1].y; }
                else {
                    y1 = 0.;
                    y2 = 0.;
                }
            }
            if( ptwXY1->points[i1].x == ptwXY2->points[i2].x ) i2++;
            i1++; }
        else {
            n->points[i].x = ptwXY2->points[i2].x;
            if( fillWithFirst && ( ( y1 != 0. ) || ( y2 != 0. ) ) ) {
                if( ptwXY_interpolatePoint( smr, ptwXY1->interpolation, ptwXY2->points[i2].x, &y, x1, y1, x2, y2 ) != nfu_Okay ) {
                    smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
                    ptwXY_free( n );
                    return( NULL );
                }
            }
            i2++;
        }
        n->points[i].y = y;
    }
 
    y = 0.;
    for( ; i1 < n1; i1++, i++ ) {
        n->points[i].x = ptwXY1->points[i1].x;
        if( fillWithFirst ) y = ptwXY1->points[i1].y;
        n->points[i].y = y;
    }
    for( ; i2 < n2; i2++, i++ ) {
        n->points[i].x = ptwXY2->points[i2].x;
        if( fillWithFirst && trim && ( n->points[i].x <= x2 ) ) {
            if( ptwXY_interpolatePoint( smr, ptwXY1->interpolation, n->points[i].x, &y, x1, y1, x2, y2 ) != nfu_Okay ) {
                smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
                ptwXY_free( n );
                return( NULL );
            }
        }
        n->points[i].y = y;
    }
    n->length = i;
 
    if( unionOptions & ptwXY_union_mergeClosePoints ) {
        if( ptwXY_mergeClosePoints( smr, n, 4 * DBL_EPSILON ) != nfu_Okay ) {
            smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
            ptwXY_free( n );
            return( NULL );
        }
    }
    return( n );
}

Referenced by ptwXY_binary_ptwXY(), ptwXY_div_ptwXY(), ptwXY_groupThreeFunctions(), and ptwXY_groupTwoFunctions().

ptwXY_unitbaseInterpolate()

ptwXYPoints * ptwXY_unitbaseInterpolate	(	statusMessageReporting *	smr,
		double	w,
		double	w1,
		ptwXYPoints *	ptwXY1,
		double	w2,
		ptwXYPoints *	ptwXY2,
		int	scaleRange )

Definition at line 441 of file ptwXY_interpolation.c.

                                                         {
/* 
*   Should we not be checking the interpolation members???????
*/
    int64_t i;
    ptwXYPoints *n1 = NULL, *n2 = NULL, *a = NULL, *r = NULL;
    ptwXYPoint *p;
    double f, g, domainMin, domainMax;
 
    if( ( w < w1 ) || ( w > w2 ) ) {
        smr_setReportError2( smr, nfu_SMR_libraryID, nfu_XOutsideDomain, "W value outside w-domain: (%.15e, %.15e)",
                w1, w2 );
        return( NULL );
    }
    if( w == w1 ) {
        if( ( n1 = ptwXY_clone( smr, ptwXY1 ) ) == NULL ) smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via (source1)." );
        return( n1 );
    }
    if( w == w2 ) {
        if( ( n1 = ptwXY_clone( smr, ptwXY2 ) ) == NULL ) smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via (source2)." );
        return( n1 );
    }
    if( ( n1 = ptwXY_toUnitbase( smr, ptwXY1, scaleRange ) ) == NULL ) goto Err;
    if( ( n2 = ptwXY_toUnitbase( smr, ptwXY2, scaleRange ) ) == NULL ) goto Err;
    f = ( w - w1 ) / ( w2 - w1 );
    g = 1. - f;
    for( i = 0, p = n1->points; i < n1->length; i++, p++ ) p->y *= g;
    for( i = 0, p = n2->points; i < n2->length; i++, p++ ) p->y *= f;
    if( ( a = ptwXY_add_ptwXY( smr, n1, n2 ) ) == NULL ) goto Err;
 
    domainMin = g * ptwXY1->points[0].x + f * ptwXY2->points[0].x;
    domainMax = g * ptwXY1->points[ptwXY1->length-1].x + f * ptwXY2->points[ptwXY2->length-1].x;
    if( ( r = ptwXY_fromUnitbase( smr, a, domainMin, domainMax, scaleRange ) ) == NULL ) goto Err;
    ptwXY_free( n1 );
    ptwXY_free( n2 );
    ptwXY_free( a );
    return( r );
 
Err:
    smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
    if( n1 != NULL ) ptwXY_free( n1 );
    if( n2 != NULL ) ptwXY_free( n2 );
    if( a  != NULL ) ptwXY_free( a );
    return( NULL );
}

ptwXY_update_biSectionMax()

void ptwXY_update_biSectionMax	(	ptwXYPoints *	ptwXY1,
		double	oldLength )

Definition at line 37 of file ptwXY_misc.c.

                                                                        {
 
    ptwXY1->biSectionMax = ptwXY1->biSectionMax - 1.442695 * log( ptwXY1->length / oldLength ); /* 1.442695 = 1 / log( 2. ) */
    if( ptwXY1->biSectionMax < 0 ) ptwXY1->biSectionMax = 0;
    if( ptwXY1->biSectionMax > ptwXY_maxBiSectionMax ) ptwXY1->biSectionMax = ptwXY_maxBiSectionMax;
}

Referenced by ptwXY_applyFunction(), ptwXY_div_ptwXY(), and ptwXY_mul2_ptwXY().

ptwXY_valuesToC_XsAndYs()

nfu_status ptwXY_valuesToC_XsAndYs	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		double **	xs,
		double **	ys )

Definition at line 727 of file ptwXY_convenient.c.

                                                                                                                {
 
    int64_t i1, length;
    double *xps, *yps;
    ptwXYPoint *pointFrom;
 
    if( ptwXY_simpleCoalescePoints( smr, ptwXY ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Invalid source." );
        return( ptwXY->status );
    }
    length = ptwXY_length( NULL, ptwXY );
 
    if( ( *xs = (double *) smr_malloc2( smr, (size_t) length * sizeof( double ), 0, "xs" ) ) == NULL ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( nfu_mallocError );
    }
    if( ( *ys = (double *) smr_malloc2( smr, (size_t) length * sizeof( double ), 0, "ys" ) ) == NULL ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        smr_freeMemory2( *xs );
        return( nfu_mallocError );
    }
 
    for( i1 = 0, pointFrom = ptwXY->points, xps = *xs, yps = *ys; i1 < length; ++i1, ++pointFrom, ++xps, ++yps ) {
        *xps = pointFrom->x;
        *yps = pointFrom->y;
    }
 
    return( nfu_Okay );
}

ptwXY_valueTo_ptwXY()

ptwXYPoints * ptwXY_valueTo_ptwXY	(	statusMessageReporting *	smr,
		double	x1,
		double	x2,
		double	y )

Definition at line 759 of file ptwXY_convenient.c.

                                                                                                {
 
    ptwXYPoints *n1;
 
    if( x1 >= x2 ) {
        smr_setReportError2( smr, nfu_SMR_libraryID, nfu_XNotAscending,
                "X-values not ascend: x1 = %.17e, x2 = %.17e", x1, x2 );
        return( NULL );
    }
    if( ( n1 = ptwXY_new( smr, ptwXY_interpolationLinLin, NULL, ptwXY_maxBiSectionMax, ptwXY_minAccuracy, 2, 0, 0 ) ) == NULL ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( NULL );
    }
    if( ptwXY_setValueAtX( smr, n1, x1, y ) != nfu_Okay ) goto Err;
    if( ptwXY_setValueAtX( smr, n1, x2, y ) != nfu_Okay ) goto Err;
    return( n1 );
 
Err:
    smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
    ptwXY_free( n1 );
    return( NULL );
}

ptwXY_ysMappedToXs()

ptwXPoints * ptwXY_ysMappedToXs	(	statusMessageReporting *	smr,
		ptwXYPoints *	ptwXY,
		ptwXPoints *	Xs,
		int64_t *	offset )

Definition at line 44 of file ptwXY_convenient.c.

                                                                                                                   {
 
    int64_t iXY, iX, nXY = ptwXY_length( NULL, ptwXY ), nX = ptwX_length( NULL, Xs );
    ptwXYPoint *point1, *point2;
    ptwXY_interpolation interpolation = ptwXY_getInterpolation( ptwXY );
    ptwXPoints *Ys = NULL;
 
    *offset = 0;
 
    if( ptwXY_simpleCoalescePoints( smr, ptwXY ) != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( NULL );
    }
 
    if( Xs->status != nfu_Okay ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_badSelf, "Invalid destination." );
        return( NULL );
    }
 
    if( ( nXY == 1 ) || ( nX == 1 ) ) {
        smr_setReportError2( smr, nfu_SMR_libraryID, nfu_tooFewPoints, "number of points less than 2: %lld  %lld", nXY, nX );
        return( NULL );
    }
 
    if( ( nXY == 0 ) || ( nX == 0 ) ) {
        if( ( Ys = ptwX_new( smr, 0 ) ) == NULL ) {
            smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
            return( NULL );
        }
        return( Ys );
    }
 
    point1 = &ptwXY->points[0];
    point2 = &ptwXY->points[nXY-1];
 
    for( iX = 0; iX < nX; ++iX ) {
        if( Xs->points[iX] >= point1->x ) break;
    }
    *offset = iX;
 
    for( iX = 0; iX < nX; ++iX ) {
        if( Xs->points[iX] > point2->x ) break;
    }
    nX = iX;
    iX = *offset;
 
    if( ( Ys = ptwX_new( smr, nX - iX ) ) == NULL ) {
        smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
        return( NULL );
    }
    if( nX - iX < 2 ) return( Ys );
 
    for( iXY = 1; iXY < nXY; ++iXY ) {
        point2 = &ptwXY->points[iXY];
        if( point2->x >= Xs->points[iX] ) break;
        point1 = point2;
    }
 
    for( ; iXY < nXY; ++iXY ) {
        point2 = &ptwXY->points[iXY];
 
        while( iX < nX ) {
            double xValue = Xs->points[iX], yValue;
 
            if( xValue > point2->x ) break;
 
            if( ptwXY_interpolatePoint( smr, interpolation, xValue, &yValue, point1->x, point1->y, point2->x, point2->y ) != nfu_Okay ) {
                smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
                ptwX_free( Ys );
                return( NULL );
            }
            if( ptwX_setPointAtIndex( smr, Ys, ptwX_length( NULL, Ys ), yValue ) != nfu_Okay ) {
                smr_setReportError2p( smr, nfu_SMR_libraryID, nfu_Error, "Via." );
                ptwX_free( Ys );
                return( NULL );
            }
            ++iX;
        }
        point1 = point2;
    }
 
    return( Ys );
}