ptwX_core.cc File Reference

#include <stdio.h>
#include <stdlib.h>
#include <cmath>
#include <cstdlib>
#include <float.h>
#include "ptwX.h"

Include dependency graph for ptwX_core.cc:

Go to the source code of this file.

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

Function Documentation

nfu_status ptwX_abs

(

ptwXPoints *

ptwX

)

Definition at line 434 of file ptwX_core.cc.

                                        {

    int64_t i1;
    double *p1;

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

nfu_status ptwX_add_double	(	ptwXPoints *	ptwX,
		double	value
	)

Definition at line 453 of file ptwX_core.cc.

                                                             {

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

Here is the call graph for this function:

nfu_status ptwX_add_ptwX	(	ptwXPoints *	ptwX1,
		ptwXPoints *	ptwX2
	)

Definition at line 479 of file ptwX_core.cc.

                                                                 {

    int64_t i1;
    double *p1 = ptwX1->points, *p2 = ptwX2->points;

    if( ptwX1->status != nfu_Okay ) return( ptwX1->status );
    if( ptwX2->status != nfu_Okay ) return( ptwX2->status );
    if( ptwX1->length != ptwX2->length ) return( nfu_domainsNotMutual );

    for( i1 = 0; i1 < ptwX1->length; i1++, p1++, p2++ ) *p1 += *p2;
    return( nfu_Okay );
}

Here is the caller graph for this function:

int ptwX_ascendingOrder

(

ptwXPoints *

ptwX

)

Definition at line 257 of file ptwX_core.cc.

                                            {
/*
*    Returns -1 list is descending, 1 if ascending and 0 otherwise (i.e., mixed).
*/
    int order = 1;
    int64_t i;
    double x1, x2;

    if( ptwX->length < 2 ) return( 0 );

    if( ( x1 = ptwX->points[0] ) < ( x2 = ptwX->points[1] ) ) {     /* Check for ascending order. */
        for( i = 2; i < ptwX->length; i++ ) {
            x1 = x2;
            x2 = ptwX->points[i];
            if( x2 <= x1 ) return( 0 );
        } }
    else {
        if( x1 == x2 ) return( 0 );
        order = -1;                                                 /* Check for descending order. */
        for( i = 2; i < ptwX->length; i++ ) {
            x1 = x2;
            x2 = ptwX->points[i];
            if( x1 <= x2 ) return( 0 );
        }
    }
    return( order );
}

nfu_status ptwX_clear

(

ptwXPoints *

ptwX

)

Definition at line 139 of file ptwX_core.cc.

                                          {

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

Here is the caller graph for this function:

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

Definition at line 88 of file ptwX_core.cc.

                                                               {

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 553 of file ptwX_core.cc.

                                                                                                              {

    int64_t i1, n1 = ptwX1->length;
    double larger;
    double *p1 = ptwX1->points, *p2 = ptwX2->points;

    epsilon = std::fabs( epsilon ) + std::abs( epsilonFactor ) * DBL_EPSILON;

    *status = ptwX1->status;
    if( ptwX1->status != nfu_Okay ) return( -1 );
    *status = ptwX2->status;
    if( ptwX2->status != nfu_Okay ) return( -1 );
    *status = nfu_domainsNotMutual;
    if( n1 != ptwX2->length ) return( -1 );

    *status = nfu_Okay;
    for( i1 = 0; i1 < n1; i1++, p1++, p2++ ) {
        larger = std::fabs( *p1 );
        if( std::fabs( *p2 ) > larger ) larger = std::fabs( *p2 );
        if( std::fabs( *p2 - *p1 ) > epsilon * larger ) return( (int) ( i1 + 1 ) );
    }
    return( 0 );
}

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

Definition at line 352 of file ptwX_core.cc.

                                                                                                       {

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

Here is the call graph for this function:

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

Definition at line 359 of file ptwX_core.cc.

                                                                                                                                      {
/*
*   Finds the closes datum to value. If *difference is zero, datum is same as value.
*/
    double d1;

    *index = -1;
    *difference = -1;
    if( ptwX->status != nfu_Okay ) return( ptwX->status );
    if( i1 < 0 ) i1 = 0;
    if( i2 > ptwX->length ) i2 = ptwX->length;
    if( i1 >= i2 ) return( nfu_Okay );
    *index = i1;
    *difference = value - ptwX->points[i1];
    for( i1++; i1 < i2; i1++ ) {
        d1 = value - ptwX->points[i1];
        if( std::fabs( *difference ) > std::fabs( d1 ) ) {
            *index = i1;
            *difference = d1;
        }
    }
    return( nfu_Okay );
}

Here is the caller graph for this function:

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

Definition at line 528 of file ptwX_core.cc.

                                                                                 {

    int64_t i1, n1 = ptwX1->length, n2 = ptwX2->length, nn = n1;
    double *p1 = ptwX1->points, *p2 = ptwX2->points;

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

nfu_status ptwX_copy	(	ptwXPoints *	dest,
		ptwXPoints *	src
	)

Definition at line 78 of file ptwX_core.cc.

                                                          {

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

Here is the call graph for this function:

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

Definition at line 301 of file ptwX_core.cc.

                                                                               {

    int64_t i1;

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

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

Definition at line 50 of file ptwX_core.cc.

                                                                                              {

    ptwXPoints *ptwX = ptwX_new( size, status );

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 62 of file ptwX_core.cc.

                                                                                                             {

    int64_t i1;
    double *p1;
    ptwXPoints *ptwX;

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 191 of file ptwX_core.cc.

                                                                         {

    int64_t n = ptwX->length - ( i2 - i1 );

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

ptwXPoints* ptwX_free

(

ptwXPoints *

ptwX

)

Definition at line 158 of file ptwX_core.cc.

                                          {

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 287 of file ptwX_core.cc.

                                                                                        {

    int64_t numberConverted;
    double  *doublePtr;
    ptwXPoints *ptwX = NULL;

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

Here is the call graph for this function:

double* ptwX_getPointAtIndex	(	ptwXPoints *	ptwX,
		int64_t	index
	)

Definition at line 206 of file ptwX_core.cc.

                                                                {

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

Here is the caller graph for this function:

double ptwX_getPointAtIndex_Unsafely	(	ptwXPoints *	ptwX,
		int64_t	index
	)

Definition at line 215 of file ptwX_core.cc.

                                                                        {

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

Here is the caller graph for this function:

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

Definition at line 238 of file ptwX_core.cc.

                                                                                                     {

    nfu_status status;
    int64_t i1, i2, n1p, size = n1 + ptwX->length;

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

Here is the call graph for this function:

int64_t ptwX_length

(

ptwXPoints *

ptwX

)

Definition at line 166 of file ptwX_core.cc.

                                        {

    return( ptwX->length );
}

Here is the caller graph for this function:

nfu_status ptwX_mul_double	(	ptwXPoints *	ptwX,
		double	value
	)

Definition at line 460 of file ptwX_core.cc.

                                                             {

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

Here is the call graph for this function:

nfu_status ptwX_neg

(

ptwXPoints *

ptwX

)

Definition at line 446 of file ptwX_core.cc.

                                        {

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

Here is the call graph for this function:

ptwXPoints* ptwX_new	(	int64_t	size,
		nfu_status *	status
	)

Definition at line 24 of file ptwX_core.cc.

                                                         {

    ptwXPoints *ptwX = (ptwXPoints *) nfu_calloc( sizeof( ptwXPoints ), 1 );

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 116 of file ptwX_core.cc.

                                                                                           {

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

    return( ptwX->status );
}

Here is the call graph for this function:

Here is the caller graph for this function:

nfu_status ptwX_release

(

ptwXPoints *

ptwX

)

Definition at line 147 of file ptwX_core.cc.

                                            {

    ptwX->length = 0;
    ptwX->allocatedSize = 0;
    ptwX->points = (double *) nfu_free( ptwX->points );

    return( nfu_Okay );
}

Here is the call graph for this function:

Here is the caller graph for this function:

nfu_status ptwX_reverse

(

ptwXPoints *

ptwX

)

Definition at line 314 of file ptwX_core.cc.

                                            {

    int64_t i1, i2 = ptwX->length - 1, n1 = ptwX->length / 2;
    double tmp;

    for( i1 = 0; i1 < n1; i1++, i2-- ) {
        tmp = ptwX->points[i1];
        ptwX->points[i1] = ptwX->points[i2];
        ptwX->points[i2] = tmp;
    }
    return( nfu_Okay );
}

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

Definition at line 173 of file ptwX_core.cc.

                                                                              {

    int64_t  i;

    if( ptwX->status != nfu_Okay ) return( ptwX->status );

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

    return( ptwX->status );
}

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 222 of file ptwX_core.cc.

                                                                             {

    nfu_status status;

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

Here is the call graph for this function:

Here is the caller graph for this function:

nfu_status ptwX_setup	(	ptwXPoints *	ptwX,
		int64_t	size
	)

Definition at line 37 of file ptwX_core.cc.

                                                        {

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 95 of file ptwX_core.cc.

                                                                                               {

    int64_t i, j, length;
    ptwXPoints *n;

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 467 of file ptwX_core.cc.

                                                                             {

    int64_t i1;
    double *p1;

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

Here is the caller graph for this function:

nfu_status ptwX_sort	(	ptwXPoints *	ptwX,
		enum ptwX_sort_order	order
	)

Definition at line 329 of file ptwX_core.cc.

                                                                     {

    int (*cmp)( void const *, void const * ) = ptwX_sort_descending;

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

Here is the call graph for this function:

Here is the caller graph for this function:

static int ptwX_sort_ascending ( void const *  p1, void const *  p2  )

static

Definition at line 341 of file ptwX_core.cc.

                                                                 {

    double *d1 = (double *) p1, *d2 = (double *) p2;

    if( *d1 < *d2 ) return( -1 );
    if( *d1 == *d2 ) return( 0 );
    return( 1 );
}

Here is the caller graph for this function:

static int ptwX_sort_descending ( void const *  p1, void const *  p2  )

static

Definition at line 340 of file ptwX_core.cc.

{ return( -ptwX_sort_ascending( p1, p2 ) ); }

Here is the call graph for this function:

Here is the caller graph for this function:

nfu_status ptwX_sub_ptwX	(	ptwXPoints *	ptwX1,
		ptwXPoints *	ptwX2
	)

Definition at line 494 of file ptwX_core.cc.

                                                                 {

    int64_t i1;
    double *p1 = ptwX1->points, *p2 = ptwX2->points;

    if( ptwX1->status != nfu_Okay ) return( ptwX1->status );
    if( ptwX2->status != nfu_Okay ) return( ptwX2->status );
    if( ptwX1->length != ptwX2->length ) return( nfu_domainsNotMutual );

    for( i1 = 0; i1 < ptwX1->length; i1++, p1++, p2++ ) *p1 -= *p2;
    return( nfu_Okay );
}

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

Definition at line 385 of file ptwX_core.cc.

                                                                           {
/*
*   If order < 0 order is descending, if order > 0 order is ascending, otherwise, order is the same as ptwX.
*/
    int64_t i1, i2, n1 = 0;
    double x1, *p2;
    ptwXPoints *ptwX2 = NULL;

    if( order == 0 ) {
        if( ( ptwX2 = ptwX_new( ptwX->length, status ) ) == NULL ) return( NULL );
        for( i1 = 0; i1 < ptwX->length; i1++ ) {
            x1 = ptwX->points[i1];
            for( i2 = 0, p2 = ptwX2->points; i2 < ptwX2->length; i2++, p2++ ) {
                if( *p2 == x1 ) break;
            }
            if( i2 == ptwX2->length ) {
                ptwX2->points[ptwX2->length] = x1;
                ptwX2->length++;
            }
        } }
    else {
        if( ( ptwX2 = ptwX_clone( ptwX, status ) ) == NULL ) return( NULL );
        if( ( *status = ptwX_sort( ptwX2, ptwX_sort_order_ascending ) ) != nfu_Okay ) goto err;

        if( ptwX2->length > 1 ) {
            x1 = ptwX2->points[n1];
            n1++;
            for( i1 = 1; i1 < ptwX2->length; i1++ ) {
                if( x1 != ptwX2->points[i1] ) {
                    x1 = ptwX2->points[i1];
                    ptwX2->points[n1] = x1;
                    n1++;
                }
            }
            ptwX2->length = n1;
            if( order < 0 ) {
                if( ( *status = ptwX_sort( ptwX2, ptwX_sort_order_descending ) ) != nfu_Okay ) goto err;
            }
        }
    }
    return( ptwX2 );

err:
    if( ptwX2 != NULL ) ptwX_free( ptwX2 );
    return( NULL );
}

Here is the call graph for this function:

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

Definition at line 509 of file ptwX_core.cc.

                                                                        {

    int64_t i1, n1 = ptwX->length;
    *xMin = *xMax = 0;
    double *p1 = ptwX->points;

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