ptwXY_misc.cc File Reference

#include <stdio.h>
#include <stdlib.h>
#include <cmath>
#include <float.h>
#include "ptwXY.h"

Go to the source code of this file.

Functions
void	ptwXY_update_biSectionMax (ptwXYPoints *ptwXY1, double oldLength)
ptwXYPoints *	ptwXY_createFromFunction (int n, double *xs, ptwXY_createFromFunction_callback func, void *argList, double accuracy, int checkForRoots, int biSectionMax, nfu_status *status)
ptwXYPoints *	ptwXY_createFromFunction2 (ptwXPoints *xs, ptwXY_createFromFunction_callback func, void *argList, double accuracy, int checkForRoots, int biSectionMax, nfu_status *status)
nfu_status	ptwXY_applyFunction (ptwXYPoints *ptwXY1, ptwXY_applyFunction_callback func, void *argList, int checkForRoots)
ptwXYPoints *	ptwXY_fromString (char const *str, ptwXY_interpolation interpolation, ptwXY_interpolationOtherInfo const *interpolationOtherInfo, double biSectionMax, double accuracy, char **endCharacter, nfu_status *status)
void	ptwXY_showInteralStructure (ptwXYPoints *ptwXY, FILE *f, int printPointersAsNull)
void	ptwXY_simpleWrite (ptwXYPoints *ptwXY, FILE *f, char *format)
void	ptwXY_simplePrint (ptwXYPoints *ptwXY, char *format)

Function Documentation

ptwXY_applyFunction()

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

Definition at line 146 of file ptwXY_misc.cc.

                                                                                                                           {
 
    int64_t i, originalLength = ptwXY1->length, notFirstPass = 0;
    double y1, y2 = 0;
    nfu_status status;
    ptwXYPoint p1, p2;
 
    checkForRoots = checkForRoots && ptwXY1->biSectionMax;
    if( ptwXY1->status != nfu_Okay ) return( ptwXY1->status );
    if( ptwXY1->interpolation == ptwXY_interpolationOther ) return( nfu_otherInterpolation );
    if( ptwXY1->interpolation == ptwXY_interpolationFlat ) return( nfu_invalidInterpolation );
    if( ( status = ptwXY_simpleCoalescePoints( ptwXY1 ) ) != nfu_Okay ) return( status );
    for( i = originalLength - 1; i >= 0; i-- ) {
        y1 = ptwXY1->points[i].y;
        if( ( status = func( &(ptwXY1->points[i]), argList ) ) != nfu_Okay ) return( status );
        p1 = ptwXY1->points[i];
        if( notFirstPass ) {
            if( ( status = ptwXY_applyFunction2( ptwXY1, y1, y2, &p1, &p2, func, argList, 0, checkForRoots ) ) != nfu_Okay ) return( status );
        }
        notFirstPass = 1;
        p2 = p1;
        y2 = y1;
    }
    ptwXY_update_biSectionMax( ptwXY1, (double) originalLength );
    return( status );
}

Referenced by ptwXY_pow().

ptwXY_createFromFunction()

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

Definition at line 40 of file ptwXY_misc.cc.

                                           {
 
    int64_t i;
    double x1, y1, x2, y2, eps = ClosestAllowXFactor * DBL_EPSILON;
    ptwXYPoints *ptwXY;
    ptwXYPoint *p1, *p2;
 
    *status = nfu_Okay;
    if( n < 2 ) { *status = nfu_tooFewPoints; return( NULL ); }
    for( i = 1; i < n; i++ ) {
        if( xs[i-1] >= xs[i] ) *status = nfu_XNotAscending;
    }
    if( *status == nfu_XNotAscending ) return( NULL );
 
    x1 = xs[0];
    if( ( *status = func( x1, &y1, argList ) ) != nfu_Okay ) return( NULL );
    if( ( ptwXY = ptwXY_new( ptwXY_interpolationLinLin, NULL, biSectionMax, accuracy, 500, 50, status, 0 ) ) == NULL ) return( NULL );
    for( i = 1; i < n; i++ ) {
        if( ( *status = ptwXY_setValueAtX_overrideIfClose( ptwXY, x1, y1, eps, 0 ) ) != nfu_Okay ) goto err;
        x2 = xs[i];
        if( ( *status = func( x2, &y2, argList ) ) != nfu_Okay ) goto err;
        if( ( *status = ptwXY_createFromFunctionBisect( ptwXY, x1, y1, x2, y2, func, argList, 0, checkForRoots, eps ) ) != nfu_Okay ) goto err;
        x1 = x2;
        y1 = y2;
    }
    if( ( *status = ptwXY_setValueAtX_overrideIfClose( ptwXY, x2, y2, eps, 1 ) ) != nfu_Okay ) goto err;
 
    if( checkForRoots ) {
        if( ( *status = ptwXY_simpleCoalescePoints( 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( ( *status = ptwXY_createFromFunctionZeroCrossing( ptwXY, p1->x, p1->y, p2->x, p2->y, func, argList, eps ) ) != nfu_Okay ) goto err;
                }
            }
        }
    }
 
    return( ptwXY );
 
err:
    ptwXY_free( ptwXY );
    return( NULL );
}

Referenced by nf_Legendre_to_ptwXY(), and ptwXY_createFromFunction2().

ptwXY_createFromFunction2()

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

Definition at line 89 of file ptwXY_misc.cc.

                                           {
 
    return( ptwXY_createFromFunction( (int) xs->length, xs->points, func, argList, accuracy, checkForRoots, biSectionMax, status ) );
}

ptwXY_fromString()

ptwXYPoints * ptwXY_fromString	(	char const *	str,
		ptwXY_interpolation	interpolation,
		ptwXY_interpolationOtherInfo const *	interpolationOtherInfo,
		double	biSectionMax,
		double	accuracy,
		char **	endCharacter,
		nfu_status *	status
	)

Definition at line 236 of file ptwXY_misc.cc.

                                                                                    {
 
    int64_t numberConverted;
    double  *doublePtr;
    ptwXYPoints *ptwXY = NULL;
 
    if( ( *status = nfu_stringToListOfDoubles( str, &numberConverted, &doublePtr, endCharacter ) ) != nfu_Okay ) return( NULL );
    *status = nfu_oddNumberOfValues;
    if( ( numberConverted % 2 ) == 0 )
        ptwXY = ptwXY_create( interpolation, interpolationOtherInfo, biSectionMax, accuracy, numberConverted, 10, numberConverted / 2, doublePtr, status, 0 );
    nfu_free( doublePtr );
    return( ptwXY );
}

ptwXY_showInteralStructure()

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

Definition at line 253 of file ptwXY_misc.cc.

                                                                                        {
 
    int64_t i, n = ptwXY_getNonOverflowLength( ptwXY );
    ptwXYPoint *point = ptwXY->points;
    ptwXYOverflowPoint *overflowPoint;
 
    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->interpolationOtherInfo.interpolationString );
    fprintf( f, "getValueFunc is NULL = %d. argList is NULL = %d.\n", 
        ptwXY->interpolationOtherInfo.getValueFunc == NULL, ptwXY->interpolationOtherInfo.argList == NULL );
    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 : (void*)ptwXY->points ) );
    for( i = 0; i < n; i++,  point++ ) fprintf( f, "    %14.7e %14.7e\n", point->x, point->y );
    fprintf( f, "  Overflow points data; %20p\n", ( printPointersAsNull ? NULL : (void*)&(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, 
    (void*) ( printPointersAsNull ? NULL : overflowPoint ), (void*) ( printPointersAsNull ? NULL : overflowPoint->prior ), 
    (void*) ( printPointersAsNull ? NULL : overflowPoint->next ) );
    }
    fprintf( f, "  Points in order\n" );
    for( i = 0; i < ptwXY->length; i++ ) {
        point = ptwXY_getPointAtIndex( ptwXY, i );
        fprintf( f, "    %14.7e %14.7e\n", point->x, point->y );
    }
}

ptwXY_simplePrint()

void ptwXY_simplePrint	(	ptwXYPoints *	ptwXY,
		char *	format
	)

Definition at line 298 of file ptwXY_misc.cc.

                                                           {
 
    ptwXY_simpleWrite( ptwXY, stdout, format );
}

ptwXY_simpleWrite()

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

Definition at line 285 of file ptwXY_misc.cc.

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

Referenced by ptwXY_simplePrint().

ptwXY_update_biSectionMax()

void ptwXY_update_biSectionMax	(	ptwXYPoints *	ptwXY1,
		double	oldLength
	)

Definition at line 31 of file ptwXY_misc.cc.

                                                                        {
 
    ptwXY1->biSectionMax = ptwXY1->biSectionMax - 1.442695 * G4Log( ptwXY1->length / oldLength ); /* 1.442695 = 1 / std::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().