IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 4447


Ignore:
Timestamp:
Jul 1, 2005, 12:01:17 PM (21 years ago)
Author:
drobbin
Message:

revised psPoly struct/fxns, psMemProblem, according to psLib SDRS rev. 15

Location:
trunk/psLib
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/dataManip/psFunctions.c

    r4426 r4447  
    77 *  polynomials.  It also contains a Gaussian functions.
    88 *
    9  *  @version $Revision: 1.114 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2005-06-29 03:23:19 $
     9 *  @version $Revision: 1.115 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2005-07-01 22:01:17 $
    1111 *
    1212 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    10841084    newPoly->coeff = (psF32 *)psAlloc(n * sizeof(psF32));
    10851085    newPoly->coeffErr = (psF32 *)psAlloc(n * sizeof(psF32));
    1086     newPoly->mask = (psU8 *)psAlloc(n * sizeof(psU8));
     1086    newPoly->mask = (char *)psAlloc(n * sizeof(char));
    10871087    for (i = 0; i < n; i++) {
    10881088        newPoly->coeff[i] = 0.0;
    … …  
    11131113    newPoly->coeff = (psF32 **)psAlloc(nX * sizeof(psF32 *));
    11141114    newPoly->coeffErr = (psF32 **)psAlloc(nX * sizeof(psF32 *));
    1115     newPoly->mask = (psU8 **)psAlloc(nX * sizeof(psU8 *));
     1115    newPoly->mask = (char **)psAlloc(nX * sizeof(char *));
    11161116    for (x = 0; x < nX; x++) {
    11171117        newPoly->coeff[x] = (psF32 *)psAlloc(nY * sizeof(psF32));
    11181118        newPoly->coeffErr[x] = (psF32 *)psAlloc(nY * sizeof(psF32));
    1119         newPoly->mask[x] = (psU8 *)psAlloc(nY * sizeof(psU8));
     1119        newPoly->mask[x] = (char *)psAlloc(nY * sizeof(char));
    11201120    }
    11211121    for (x = 0; x < nX; x++) {
    … …  
    11521152    newPoly->coeff = (psF32 ***)psAlloc(nX * sizeof(psF32 **));
    11531153    newPoly->coeffErr = (psF32 ***)psAlloc(nX * sizeof(psF32 **));
    1154     newPoly->mask = (psU8 ***)psAlloc(nX * sizeof(psU8 **));
     1154    newPoly->mask = (char ***)psAlloc(nX * sizeof(char **));
    11551155    for (x = 0; x < nX; x++) {
    11561156        newPoly->coeff[x] = (psF32 **)psAlloc(nY * sizeof(psF32 *));
    11571157        newPoly->coeffErr[x] = (psF32 **)psAlloc(nY * sizeof(psF32 *));
    1158         newPoly->mask[x] = (psU8 **)psAlloc(nY * sizeof(psU8 *));
     1158        newPoly->mask[x] = (char **)psAlloc(nY * sizeof(char *));
    11591159        for (y = 0; y < nY; y++) {
    11601160            newPoly->coeff[x][y] = (psF32 *)psAlloc(nZ * sizeof(psF32));
    11611161            newPoly->coeffErr[x][y] = (psF32 *)psAlloc(nZ * sizeof(psF32));
    1162             newPoly->mask[x][y] = (psU8 *)psAlloc(nZ * sizeof(psU8));
     1162            newPoly->mask[x][y] = (char *)psAlloc(nZ * sizeof(char));
    11631163        }
    11641164    }
    … …  
    12011201    newPoly->coeff = (psF32 ****)psAlloc(nX * sizeof(psF32 ***));
    12021202    newPoly->coeffErr = (psF32 ****)psAlloc(nX * sizeof(psF32 ***));
    1203     newPoly->mask = (psU8 ****)psAlloc(nX * sizeof(psU8 ***));
     1203    newPoly->mask = (char ****)psAlloc(nX * sizeof(char ***));
    12041204    for (x = 0; x < nX; x++) {
    12051205        newPoly->coeff[x] = (psF32 ***)psAlloc(nY * sizeof(psF32 **));
    12061206        newPoly->coeffErr[x] = (psF32 ***)psAlloc(nY * sizeof(psF32 **));
    1207         newPoly->mask[x] = (psU8 ***)psAlloc(nY * sizeof(psU8 **));
     1207        newPoly->mask[x] = (char ***)psAlloc(nY * sizeof(char **));
    12081208        for (y = 0; y < nY; y++) {
    12091209            newPoly->coeff[x][y] = (psF32 **)psAlloc(nZ * sizeof(psF32 *));
    12101210            newPoly->coeffErr[x][y] = (psF32 **)psAlloc(nZ * sizeof(psF32 *));
    1211             newPoly->mask[x][y] = (psU8 **)psAlloc(nZ * sizeof(psU8 *));
     1211            newPoly->mask[x][y] = (char **)psAlloc(nZ * sizeof(char *));
    12121212            for (z = 0; z < nZ; z++) {
    12131213                newPoly->coeff[x][y][z] = (psF32 *)psAlloc(nT * sizeof(psF32));
    12141214                newPoly->coeffErr[x][y][z] = (psF32 *)psAlloc(nT * sizeof(psF32));
    1215                 newPoly->mask[x][y][z] = (psU8 *)psAlloc(nT * sizeof(psU8));
     1215                newPoly->mask[x][y][z] = (char *)psAlloc(nT * sizeof(char));
    12161216            }
    12171217        }
    … …  
    14461446    newPoly->coeff = (psF64 *)psAlloc(n * sizeof(psF64));
    14471447    newPoly->coeffErr = (psF64 *)psAlloc(n * sizeof(psF64));
    1448     newPoly->mask = (psU8 *)psAlloc(n * sizeof(psU8));
     1448    newPoly->mask = (char *)psAlloc(n * sizeof(char));
    14491449    for (i = 0; i < n; i++) {
    14501450        newPoly->coeff[i] = 0.0;
    … …  
    14751475    newPoly->coeff = (psF64 **)psAlloc(nX * sizeof(psF64 *));
    14761476    newPoly->coeffErr = (psF64 **)psAlloc(nX * sizeof(psF64 *));
    1477     newPoly->mask = (psU8 **)psAlloc(nX * sizeof(psU8 *));
     1477    newPoly->mask = (char **)psAlloc(nX * sizeof(char *));
    14781478    for (x = 0; x < nX; x++) {
    14791479        newPoly->coeff[x] = (psF64 *)psAlloc(nY * sizeof(psF64));
    14801480        newPoly->coeffErr[x] = (psF64 *)psAlloc(nY * sizeof(psF64));
    1481         newPoly->mask[x] = (psU8 *)psAlloc(nY * sizeof(psU8));
     1481        newPoly->mask[x] = (char *)psAlloc(nY * sizeof(char));
    14821482    }
    14831483    for (x = 0; x < nX; x++) {
    … …  
    15141514    newPoly->coeff = (psF64 ***)psAlloc(nX * sizeof(psF64 **));
    15151515    newPoly->coeffErr = (psF64 ***)psAlloc(nX * sizeof(psF64 **));
    1516     newPoly->mask = (psU8 ***)psAlloc(nX * sizeof(psU8 **));
     1516    newPoly->mask = (char ***)psAlloc(nX * sizeof(char **));
    15171517    for (x = 0; x < nX; x++) {
    15181518        newPoly->coeff[x] = (psF64 **)psAlloc(nY * sizeof(psF64 *));
    15191519        newPoly->coeffErr[x] = (psF64 **)psAlloc(nY * sizeof(psF64 *));
    1520         newPoly->mask[x] = (psU8 **)psAlloc(nY * sizeof(psU8 *));
     1520        newPoly->mask[x] = (char **)psAlloc(nY * sizeof(char *));
    15211521        for (y = 0; y < nY; y++) {
    15221522            newPoly->coeff[x][y] = (psF64 *)psAlloc(nZ * sizeof(psF64));
    15231523            newPoly->coeffErr[x][y] = (psF64 *)psAlloc(nZ * sizeof(psF64));
    1524             newPoly->mask[x][y] = (psU8 *)psAlloc(nZ * sizeof(psU8));
     1524            newPoly->mask[x][y] = (char *)psAlloc(nZ * sizeof(char));
    15251525        }
    15261526    }
    … …  
    15631563    newPoly->coeff = (psF64 ****)psAlloc(nX * sizeof(psF64 ***));
    15641564    newPoly->coeffErr = (psF64 ****)psAlloc(nX * sizeof(psF64 ***));
    1565     newPoly->mask = (psU8 ****)psAlloc(nX * sizeof(psU8 ***));
     1565    newPoly->mask = (char ****)psAlloc(nX * sizeof(char ***));
    15661566    for (x = 0; x < nX; x++) {
    15671567        newPoly->coeff[x] = (psF64 ***)psAlloc(nY * sizeof(psF64 **));
    15681568        newPoly->coeffErr[x] = (psF64 ***)psAlloc(nY * sizeof(psF64 **));
    1569         newPoly->mask[x] = (psU8 ***)psAlloc(nY * sizeof(psU8 **));
     1569        newPoly->mask[x] = (char ***)psAlloc(nY * sizeof(char **));
    15701570        for (y = 0; y < nY; y++) {
    15711571            newPoly->coeff[x][y] = (psF64 **)psAlloc(nZ * sizeof(psF64 *));
    15721572            newPoly->coeffErr[x][y] = (psF64 **)psAlloc(nZ * sizeof(psF64 *));
    1573             newPoly->mask[x][y] = (psU8 **)psAlloc(nZ * sizeof(psU8 *));
     1573            newPoly->mask[x][y] = (char **)psAlloc(nZ * sizeof(char *));
    15741574            for (z = 0; z < nZ; z++) {
    15751575                newPoly->coeff[x][y][z] = (psF64 *)psAlloc(nT * sizeof(psF64));
    15761576                newPoly->coeffErr[x][y][z] = (psF64 *)psAlloc(nT * sizeof(psF64));
    1577                 newPoly->mask[x][y][z] = (psU8 *)psAlloc(nT * sizeof(psU8));
     1577                newPoly->mask[x][y][z] = (char *)psAlloc(nT * sizeof(char));
    15781578            }
    15791579        }
    … …  
    18221822XXX: What should be the defualty type for knots be?  psF32 is assumed.
    18231823 *****************************************************************************/
    1824 psSpline1D *psSpline1DAlloc(int numSplines,
    1825                             int order,
     1824psSpline1D *psSpline1DAlloc(unsigned int numSplines,
     1825                            unsigned int order,
    18261826                            float min,
    18271827                            float max)
    … …  
    18671867 *****************************************************************************/
    18681868psSpline1D *psSpline1DAllocGeneric(const psVector *bounds,
    1869                                    int order)
     1869                                   unsigned int order)
    18701870{
    18711871    PS_ASSERT_VECTOR_NON_NULL(bounds, NULL);
    … …  
    18741874
    18751875    psSpline1D *tmp = NULL;
    1876     psS32 i;
    1877     psS32 numSplines;
     1876    unsigned int i;
     1877    unsigned int numSplines;
    18781878
    18791879    tmp = (psSpline1D *) psAlloc(sizeof(psSpline1D));
    … …  
    20452045psScalar *p_psVectorInterpolate(psVector *domain,
    20462046                                psVector *range,
    2047                                 psS32 order,
     2047                                unsigned int order,
    20482048                                psScalar *x)
    20492049{
    … …  
    21342134    PS_ASSERT_VECTOR_TYPE(spline->knots, PS_TYPE_F32, NAN);
    21352135
    2136     psS32 binNum;
    2137     psS32 n;
     2136    unsigned int binNum;
     2137    unsigned int n;
    21382138
    21392139    n = spline->n;
    … …  
    21712171    PS_ASSERT_VECTOR_TYPE(spline->knots, PS_TYPE_F32, NULL);
    21722172
    2173     psS32 i;
     2173    unsigned int i;
    21742174    psVector *tmpVector;
    21752175

  • trunk/psLib/src/dataManip/psFunctions.h

    r4426 r4447  
    1212 *  @author GLG, MHPCC
    1313 *
    14  *  @version $Revision: 1.51 $ $Name: not supported by cvs2svn $
    15  *  @date $Date: 2005-06-29 03:23:19 $
     14 *  @version $Revision: 1.52 $ $Name: not supported by cvs2svn $
     15 *  @date $Date: 2005-07-01 22:01:17 $
    1616 *
    1717 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    7474{
    7575    psPolynomialType type;             ///< Polynomial type
    76     unsigned int n;                   ///< Number of terms
     76    psElemType ctype;                  ///< Polynomial precision
     77    unsigned int n;                    ///< Number of terms
    7778    psF32 *coeff;                      ///< Coefficients
    7879    psF32 *coeffErr;                   ///< Error in coefficients
    79     psU8 *mask;                        ///< Coefficient mask
     80    char *mask;                        ///< Coefficient mask
    8081}
    8182psPolynomial1D;
    … …  
    8586{
    8687    psPolynomialType type;             ///< Polynomial type
     88    psElemType ctype;                  ///< Polynomial precision
    8789    unsigned int nX;                   ///< Number of terms in x
    8890    unsigned int nY;                   ///< Number of terms in y
    8991    psF32 **coeff;                     ///< Coefficients
    9092    psF32 **coeffErr;                  ///< Error in coefficients
    91     psU8 **mask;                       ///< Coefficients mask
     93    char **mask;                       ///< Coefficients mask
    9294}
    9395psPolynomial2D;
    … …  
    9799{
    98100    psPolynomialType type;             ///< Polynomial type
     101    psElemType ctype;                  ///< Polynomial precision
    99102    unsigned int nX;                   ///< Number of terms in x
    100103    unsigned int nY;                   ///< Number of terms in y
    … …  
    102105    psF32 ***coeff;                    ///< Coefficients
    103106    psF32 ***coeffErr;                 ///< Error in coefficients
    104     psU8 ***mask;                      ///< Coefficients mask
     107    char ***mask;                      ///< Coefficients mask
    105108}
    106109psPolynomial3D;
    … …  
    110113{
    111114    psPolynomialType type;             ///< Polynomial type
     115    psElemType ctype;                  ///< Polynomial precision
    112116    unsigned int nX;                   ///< Number of terms in x
    113117    unsigned int nY;                   ///< Number of terms in y
    … …  
    116120    psF32 ****coeff;                   ///< Coefficients
    117121    psF32 ****coeffErr;                ///< Error in coefficients
    118     psU8 ****mask;                     ///< Coefficients mask
     122    char ****mask;                     ///< Coefficients mask
    119123}
    120124psPolynomial4D;
    … …  
    206210
    207211/** Evaluates a 1-D polynomial at specific sets of coordinates
    208  * 
     212 *
    209213 *  @return psVector*    results of polynomials at given locations
    210214 */
    … …  
    215219
    216220/** Evaluates a 2-D polynomial at specific sets of coordinates
    217  * 
     221 *
    218222 *  @return psVector*    results of polynomial at given locations
    219223 */
    … …  
    225229
    226230/** Evaluates a 3-D polynomial at specific sets of coordinates
    227  * 
     231 *
    228232 *  @return psVector*    results of polynomial at given locations
    229233 */
    … …  
    236240
    237241/** Evaluates a 4-D polynomial at specific sets of coordinates
    238  * 
     242 *
    239243 *  @return psVector*    results of polynomial at given locations
    240244 */
    … …  
    258262    psF64 *coeff;                      ///< Coefficients
    259263    psF64 *coeffErr;                   ///< Error in coefficients
    260     psU8 *mask;                        ///< Coefficient mask
     264    char *mask;                        ///< Coefficient mask
    261265}
    262266psDPolynomial1D;
    … …  
    270274    psF64 **coeff;                     ///< Coefficients
    271275    psF64 **coeffErr;                  ///< Error in coefficients
    272     psU8 **mask;                       ///< Coefficients mask
     276    char **mask;                       ///< Coefficients mask
    273277}
    274278psDPolynomial2D;
    … …  
    283287    psF64 ***coeff;                    ///< Coefficients
    284288    psF64 ***coeffErr;                 ///< Error in coefficients
    285     psU8 ***mask;                      ///< Coefficient mask
     289    char ***mask;                      ///< Coefficient mask
    286290}
    287291psDPolynomial3D;
    … …  
    297301    psF64 ****coeff;                   ///< Coefficients
    298302    psF64 ****coeffErr;                ///< Error in coefficients
    299     psU8 ****mask;                     ///< Coefficients mask
     303    char ****mask;                     ///< Coefficients mask
    300304}
    301305psDPolynomial4D;
    … …  
    386390
    387391/** Evaluates a double-precision 1-D polynomial at specific sets of coordinates.
    388  * 
     392 *
    389393 *  @return psVector*    results of polynomial at given locations
    390394 */
    … …  
    395399
    396400/** Evaluates a double-precision 2-D polynomial at specific sets of coordinates.
    397  * 
     401 *
    398402 *  @return psVector*    results of polynomial at given locations
    399403 */
    … …  
    405409
    406410/** Evaluates a double-precision 3-D polynomial at specific sets of coordinates.
    407  * 
     411 *
    408412 *  @return psVector*    results of polynomial at given locations
    409413 */
    … …  
    416420
    417421/** Evaluates a double-precision 4-D polynomial at specific sets of coordinates.
    418  * 
     422 *
    419423 *  @return psVector*    results of polynomial at given locations
    420424 */
    … …  
    430434typedef struct
    431435{
    432     psS32 n;                           ///< The number of spline polynomials
     436    unsigned int n;                    ///< The number of spline polynomials
    433437    psPolynomial1D **spline;           ///< An array of n pointers to the spline polynomials
    434438    psF32 *p_psDeriv2;                 ///< For cubic splines, the second derivative at each domain point.  Size is n+1.
    … …  
    439443
    440444/** Allocates a psSpline1D structure
    441  * 
     445 *
    442446 *  Allocator for psSpline1D where the bounds are implicitly specified through specifying
    443447 *  min and max values along with the number of splines.
    … …  
    446450 */
    447451psSpline1D *psSpline1DAlloc(
    448     int n,                             ///< Number of spline polynomials
    449     int order,                         ///< Order of spline polynomials
     452    unsigned int n,                    ///< Number of spline polynomials
     453    unsigned int order,                ///< Order of spline polynomials
    450454    float min,                         ///< Lower boundary value of spline polynomials
    451455    float max                          ///< Upper boundary value of spline polynomials
    … …  
    453457
    454458/** Allocates a psSpline1D structure
    455  * 
    456  *  Allocator for psSpline1D where the bounds are explicitly specified. 
     459 *
     460 *  Allocator for psSpline1D where the bounds are explicitly specified.
    457461 *
    458462 *  @return psSpline1D*    new 1-D spline struct
    … …  
    460464psSpline1D *psSpline1DAllocGeneric(
    461465    const psVector *bounds,            ///< Bounds for spline polynomials
    462     int order                          ///< Order of spline polynomials
     466    unsigned int order                 ///< Order of spline polynomials
    463467);
    464468
    465469/** Evaluates 1-D spline polynomials at a specific coordinate.
    466  * 
     470 *
    467471 *  @return float    result of spline polynomials evaluated at given location
    468472 */
    … …  
    473477
    474478/** Evaluates 1-D spline polynomials at a set of specific coordinates.
    475  * 
     479 *
    476480 *  @return psVector*    results of spline polynomials evaluated at given locations
    477481 */
    … …  
    483487/** Performs a binary disection on a given vector.
    484488 *  Searches through an array of data for a specified value.
    485  * 
     489 *
    486490 *  @return psS32    corresponding index number of specified value
    487491 */
    … …  
    499503    psVector *domain,                  ///< Domain (x coords) for interpolation
    500504    psVector *range,                   ///< Range (y coords) for interpolation
    501     psS32 order,                       ///< Order of interpolation function
     505    unsigned int order,                ///< Order of interpolation function
    502506    psScalar *x                        ///< Location at which to evaluate
    503507);

  • trunk/psLib/src/sysUtils/psMemory.c

    r4444 r4447  
    88*  @author Robert Lupton, Princeton University
    99*
    10 *  @version $Revision: 1.58 $ $Name: not supported by cvs2svn $
    11 *  @date $Date: 2005-07-01 03:57:39 $
     10*  @version $Revision: 1.59 $ $Name: not supported by cvs2svn $
     11*  @date $Date: 2005-07-01 22:01:17 $
    1212*
    1313*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii

  • trunk/psLib/src/sysUtils/psMemory.h

    r4444 r4447  
    1212 *  @ingroup MemoryManagement
    1313 *
    14  *  @version $Revision: 1.45 $ $Name: not supported by cvs2svn $
    15  *  @date $Date: 2005-07-01 03:57:39 $
     14 *  @version $Revision: 1.46 $ $Name: not supported by cvs2svn $
     15 *  @date $Date: 2005-07-01 22:01:17 $
    1616 *
    1717 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii

  • trunk/psLib/test/dataManip/tst_psFunc02.c

    r3682 r4447  
    360360    /****************************************************************************/
    361361    /****************************************************************************/
    362     testStatus = true;
    363     printPositiveTestHeader(stdout,
    364                             "psFunction functions",
    365                             "psSpline1DAllocGeneric(): negative order");
    366 
    367     bounds = psVectorAlloc(5,PS_TYPE_F32);
    368     bounds->n = bounds->nalloc;
    369     for(psU32 n = 0; n < 5; n++ ) {
    370         bounds->data.F32[n] = (n+1) * 2;
    371     }
    372     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message.");
    373     tmpSpline = psSpline1DAllocGeneric(bounds, -1);
    374     if (tmpSpline != NULL) {
    375         psError(PS_ERR_UNKNOWN,true,"Did not return null for negative order");
    376         return 10;
    377     }
     362    ///XXX: REMOVED FOLLOWING TEST AFTER CHANGING TO UNSIGNED INT///
     363    /*    testStatus = true;
     364        printPositiveTestHeader(stdout,
     365                                "psFunction functions",
     366                                "psSpline1DAllocGeneric(): negative order");
     367     
     368        bounds = psVectorAlloc(5,PS_TYPE_F32);
     369        bounds->n = bounds->nalloc;
     370        for(psU32 n = 0; n < 5; n++ ) {
     371            bounds->data.F32[n] = (n+1) * 2;
     372        }
     373        psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message.");
     374        tmpSpline = psSpline1DAllocGeneric(bounds, -1);
     375        if (tmpSpline != NULL) {
     376            psError(PS_ERR_UNKNOWN,true,"Did not return null for negative order");
     377            return 10;
     378        }
     379        psFree(bounds);
     380        psMemCheckCorruption(1);
     381        memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
     382        if (0 != memLeaks) {
     383            psError(PS_ERR_UNKNOWN,true,"Memory Leaks! (%d leaks)", memLeaks);
     384            testStatus = false;
     385        }
     386        printFooter(stdout,
     387                    "psFunctions functions",
     388                    "psSpline1DAllocGeneric(): negative order",
     389                    testStatus);
     390    */
    378391    psFree(bounds);
    379     psMemCheckCorruption(1);
    380     memLeaks = psMemCheckLeaks(currentId,NULL,stderr,false);
    381     if (0 != memLeaks) {
    382         psError(PS_ERR_UNKNOWN,true,"Memory Leaks! (%d leaks)", memLeaks);
    383         testStatus = false;
    384     }
    385     printFooter(stdout,
    386                 "psFunctions functions",
    387                 "psSpline1DAllocGeneric(): negative order",
    388                 testStatus);
    389392
    390393    /****************************************************************************/

  • trunk/psLib/test/dataManip/verified/tst_psFunc02.stderr

    r3127 r4447  
    1010    Following should generate an error message.
    1111<DATE><TIME>|<HOST>|E|psSpline1DAllocGeneric (FILE:LINENO)
    12     Error: order is less than 0.
    13 <DATE><TIME>|<HOST>|I|main
    14     Following should generate an error message.
    15 <DATE><TIME>|<HOST>|E|psSpline1DAllocGeneric (FILE:LINENO)
    1612    Unallowable operation: psVector bounds or its data is NULL.
    1713<DATE><TIME>|<HOST>|I|main

  • trunk/psLib/test/dataManip/verified/tst_psFunc02.stdout

    r3115 r4447  
    8989/***************************** TESTPOINT ******************************************\
    9090*             TestFile: tst_psFunc02.c                                             *
    91 *            TestPoint: psFunction functions{psSpline1DAllocGeneric(): negative order} *
    92 *             TestType: Positive                                                   *
    93 \**********************************************************************************/
    94 
    95 
    96 ---> TESTPOINT PASSED (psFunctions functions{psSpline1DAllocGeneric(): negative order} | tst_psFunc02.c)
    97 
    98 /***************************** TESTPOINT ******************************************\
    99 *             TestFile: tst_psFunc02.c                                             *
    10091*            TestPoint: psFunction functions{psSpline1DAllocGeneric(): bound equal to NULL} *
    10192*             TestType: Positive                                                   *
Note: See TracChangeset for help on using the changeset viewer.