IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 6204


Ignore:
Timestamp:
Jan 26, 2006, 11:10:22 AM (20 years ago)
Author:
gusciora
Message:

Implemented the polynomial alloc argument changes.

Location:
trunk/psLib
Files:
25 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/astro/psCoord.c

    r6186 r6204  
    1010*  @author GLG, MHPCC
    1111*
    12 *  @version $Revision: 1.100 $ $Name: not supported by cvs2svn $
    13 *  @date $Date: 2006-01-23 22:25:31 $
     12*  @version $Revision: 1.101 $ $Name: not supported by cvs2svn $
     13*  @date $Date: 2006-01-26 21:10:22 $
    1414*
    1515*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    212212
    213213    psPlaneTransform *pt = psAlloc(sizeof(psPlaneTransform));
    214     pt->x = psPolynomial2DAlloc(order1, order2, PS_POLYNOMIAL_ORD);
    215     pt->y = psPolynomial2DAlloc(order1, order2, PS_POLYNOMIAL_ORD);
     214    pt->x = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, order1, order2);
     215    pt->y = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, order1, order2);
    216216
    217217    psMemSetDeallocator(pt, (psFreeFunc) planeTransformFree);
    … …  
    275275
    276276    psPlaneDistort *pt = psAlloc(sizeof(psPlaneDistort));
    277     pt->x = psPolynomial4DAlloc(order1, order2, order3, order4, PS_POLYNOMIAL_ORD);
    278     pt->y = psPolynomial4DAlloc(order1, order2, order3, order4, PS_POLYNOMIAL_ORD);
     277    pt->x = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, order1, order2, order3, order4);
     278    pt->y = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, order1, order2, order3, order4);
    279279
    280280    psMemSetDeallocator(pt, (psFreeFunc) planeDistortFree);
    … …  
    573573    psTrace(__func__, 5, "out poly (nX, nY) is (%d, %d)\n", orderX, orderY);
    574574
    575     psPolynomial2D *out = psPolynomial2DAlloc(orderX, orderY, PS_POLYNOMIAL_ORD);
     575    psPolynomial2D *out = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, orderX, orderY);
    576576    psTrace(__func__, 5, "Creating poly (%d, %d)\n", orderX, orderY);
    577577
    … …  
    689689                psTrace(__func__, 6, "In this iteration, we raise trans1->x to the %d power and trans1->y to the %d-power.\n", t2x, t2y);
    690690                // Create the constant "f(x, y) = 1" polynomial.
    691                 psPolynomial2D *currPoly = psPolynomial2DAlloc(0, 0, PS_POLYNOMIAL_ORD);
     691                psPolynomial2D *currPoly = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, 0, 0);
    692692                currPoly->coeff[0][0] = 1.0;
    693693
    … …  
    738738                psTrace(__func__, 5, "In this iteration, we raise trans1->x to the %d power and trans1->y to the %d-power.\n", t2x, t2y);
    739739                // Create the constant "f(x, y) = 1" polynomial.
    740                 psPolynomial2D *currPoly = psPolynomial2DAlloc(0, 0, PS_POLYNOMIAL_ORD);
     740                psPolynomial2D *currPoly = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, 0, 0);
    741741                currPoly->coeff[0][0] = 1.0;
    742742
    … …  
    809809    //
    810810    // XXX: Verify this (poly order/nterm change)
    811     psPolynomial2D *fakePoly = psPolynomial2DAlloc(order-1, order-1, PS_POLYNOMIAL_ORD);
     811    psPolynomial2D *fakePoly = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, order-1, order-1);
    812812    for (int i = 0; i < order; i++) {
    813813        for (int j = 0; j < order; j++) {

  • trunk/psLib/src/astro/psEarthOrientation.c

    r6184 r6204  
    88 *  @author Robert Daniel DeSonia, MHPCC
    99 *
    10  *  @version $Revision: 1.30 $ $Name: not supported by cvs2svn $
    11  *  @date $Date: 2006-01-23 20:04:31 $
     10 *  @version $Revision: 1.31 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2006-01-26 21:10:22 $
    1212 *
    1313 *  Copyright 2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    228228        return false;
    229229    }
    230     xPoly = psPolynomial1DAlloc(xCoeff->n, PS_POLYNOMIAL_ORD);
     230    xPoly = psPolynomial1DAlloc(PS_POLYNOMIAL_ORD, xCoeff->n);
    231231    memcpy(xPoly->coeff, xCoeff->data.F64,PSELEMTYPE_SIZEOF(PS_TYPE_F64)*xCoeff->n);
    232     yPoly = psPolynomial1DAlloc(yCoeff->n, PS_POLYNOMIAL_ORD);
     232    yPoly = psPolynomial1DAlloc(PS_POLYNOMIAL_ORD, yCoeff->n);
    233233    memcpy(yPoly->coeff, yCoeff->data.F64,PSELEMTYPE_SIZEOF(PS_TYPE_F64)*yCoeff->n);
    234     sPoly = psPolynomial1DAlloc(sCoeff->n, PS_POLYNOMIAL_ORD);
     234    sPoly = psPolynomial1DAlloc(PS_POLYNOMIAL_ORD, sCoeff->n);
    235235    memcpy(sPoly->coeff, sCoeff->data.F64,PSELEMTYPE_SIZEOF(PS_TYPE_F64)*sCoeff->n);
    236236

  • trunk/psLib/src/astro/psTime.c

    r6184 r6204  
    1010 *  @author Ross Harman, MHPCC
    1111 *
    12  *  @version $Revision: 1.78 $ $Name: not supported by cvs2svn $
    13  *  @date $Date: 2006-01-23 20:04:31 $
     12 *  @version $Revision: 1.79 $ $Name: not supported by cvs2svn $
     13 *  @date $Date: 2006-01-26 21:10:22 $
    1414 *
    1515 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    11701170
    11711171    // Interpolation of look up table
    1172     results = psLookupTableInterpolateAll(table, jd);
     1172    results = psLookupTableInterpolateAll(table, jd, NULL);
    11731173
    11741174    // Check for successful interpolation

  • trunk/psLib/src/math/psConstants.h

    r6193 r6204  
    66 *  @author GLG, MHPCC
    77 *
    8  *  @version $Revision: 1.83 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2006-01-26 00:31:19 $
     8 *  @version $Revision: 1.84 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2006-01-26 21:10:22 $
    1010 *
    1111 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    512512static psPolynomial1D *(NAME) = NULL; \
    513513if ((NAME) == NULL) { \
    514     (NAME) = psPolynomial1DAlloc(ORDER, TYPE); \
     514    (NAME) = psPolynomial1DAlloc(TYPE, ORDER); \
    515515    p_psMemSetPersistent((NAME), true); \
    516516    p_psMemSetPersistent((NAME)->coeff, true); \
    … …  
    519519} \
    520520
    521 #define PS_POLY_2D_DECLARE_ALLOC_STATIC(NAME, ORDER, TYPE) \
    522 static psPolynomial2D *(NAME) = NULL; \
    523 if ((NAME) == NULL) { \
    524     (NAME) = psPolynomial2DAlloc(ORDER, TYPE); \
    525     p_psMemSetPersistent((NAME), true); \
    526 } \
    527 
    528 #define PS_POLY_3D_DECLARE_ALLOC_STATIC(NAME, ORDER, TYPE) \
    529 static psPolynomial3D *(NAME) = NULL; \
    530 if ((NAME) == NULL) { \
    531     (NAME) = psPolynomial3DAlloc(ORDER, TYPE); \
    532     p_psMemSetPersistent((NAME), true); \
    533 } \
    534 
    535 #define PS_POLY_4D_DECLARE_ALLOC_STATIC(NAME, ORDER, TYPE) \
    536 static psPolynomial4D *(NAME) = NULL; \
    537 if ((NAME) == NULL) { \
    538     (NAME) = psPolynomial4DAlloc(ORDER, TYPE); \
    539     p_psMemSetPersistent((NAME), true); \
    540 } \
     521/* XXX: This is not correct
     522    #define PS_POLY_2D_DECLARE_ALLOC_STATIC(NAME, ORDER, TYPE) \
     523    static psPolynomial2D *(NAME) = NULL; \
     524    if ((NAME) == NULL) { \
     525        (NAME) = psPolynomial2DAlloc(ORDER, TYPE); \
     526        p_psMemSetPersistent((NAME), true); \
     527    } \
     528 
     529    #define PS_POLY_3D_DECLARE_ALLOC_STATIC(NAME, ORDER, TYPE) \
     530    static psPolynomial3D *(NAME) = NULL; \
     531    if ((NAME) == NULL) { \
     532        (NAME) = psPolynomial3DAlloc(ORDER, TYPE); \
     533        p_psMemSetPersistent((NAME), true); \
     534    } \
     535 
     536    #define PS_POLY_4D_DECLARE_ALLOC_STATIC(NAME, ORDER, TYPE) \
     537    static psPolynomial4D *(NAME) = NULL; \
     538    if ((NAME) == NULL) { \
     539        (NAME) = psPolynomial4DAlloc(ORDER, TYPE); \
     540        p_psMemSetPersistent((NAME), true); \
     541    } \
     542*/
    541543
    542544#define PS_POLY_1D_D_DECLARE_ALLOC_STATIC(NAME, ORDER, TYPE) \
    543545static psPolynomial1D *(NAME) = NULL; \
    544546if ((NAME) == NULL) { \
    545     (NAME) = psPolynomial1DAlloc(ORDER, TYPE); \
     547    (NAME) = psPolynomial1DAlloc(TYPE, ORDER); \
    546548    p_psMemSetPersistent((NAME), true); \
    547549} \
    548550
    549 #define PS_POLY_2D_D_DECLARE_ALLOC_STATIC(NAME, ORDER, TYPE) \
    550 static psPolynomial2D *(NAME) = NULL; \
    551 if ((NAME) == NULL) { \
    552     (NAME) = psPolynomial2DAlloc(ORDER, TYPE); \
    553     p_psMemSetPersistent((NAME), true); \
    554 } \
    555 
    556 #define PS_POLY_3D_D_DECLARE_ALLOC_STATIC(NAME, ORDER, TYPE) \
    557 static psPolynomial3D *(NAME) = NULL; \
    558 if ((NAME) == NULL) { \
    559     (NAME) = psPolynomial3DAlloc(ORDER, TYPE); \
    560     p_psMemSetPersistent((NAME), true); \
    561 } \
    562 
    563 #define PS_POLY_4D_D_DECLARE_ALLOC_STATIC(NAME, ORDER, TYPE) \
    564 static psPolynomial4D *(NAME) = NULL; \
    565 if ((NAME) == NULL) { \
    566     (NAME) = psPolynomial4DAlloc(ORDER, TYPE); \
    567     p_psMemSetPersistent((NAME), true); \
    568 } \
     551/* XXX: This is not correct
     552    #define PS_POLY_2D_D_DECLARE_ALLOC_STATIC(NAME, ORDER, TYPE) \
     553    static psPolynomial2D *(NAME) = NULL; \
     554    if ((NAME) == NULL) { \
     555        (NAME) = psPolynomial2DAlloc(ORDER, TYPE); \
     556        p_psMemSetPersistent((NAME), true); \
     557    } \
     558 
     559    #define PS_POLY_3D_D_DECLARE_ALLOC_STATIC(NAME, ORDER, TYPE) \
     560    static psPolynomial3D *(NAME) = NULL; \
     561    if ((NAME) == NULL) { \
     562        (NAME) = psPolynomial3DAlloc(ORDER, TYPE); \
     563        p_psMemSetPersistent((NAME), true); \
     564    } \
     565 
     566    #define PS_POLY_4D_D_DECLARE_ALLOC_STATIC(NAME, ORDER, TYPE) \
     567    static psPolynomial4D *(NAME) = NULL; \
     568    if ((NAME) == NULL) { \
     569        (NAME) = psPolynomial4DAlloc(ORDER, TYPE); \
     570        p_psMemSetPersistent((NAME), true); \
     571    } \
     572*/
    569573
    570574#define PS_POLY_PRINT_1D(NAME) \

  • trunk/psLib/src/math/psMinimizeLMM.c

    r6101 r6204  
    1010 *  @author EAM, IfA
    1111 *
    12  *  @version $Revision: 1.1 $ $Name: not supported by cvs2svn $
    13  *  @date $Date: 2006-01-21 02:43:31 $
     12 *  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
     13 *  @date $Date: 2006-01-26 21:10:22 $
    1414 *
    1515 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    204204    psMinimizeLMChi2Func func)
    205205{
     206    // XXX: Check vector sizes.
    206207    PS_ASSERT_IMAGE_NON_NULL(alpha, NAN);
    207208    PS_ASSERT_VECTOR_NON_NULL(beta, NAN);
    … …  
    218219
    219220    // zero alpha and beta for summing below
    220     for (int j = 0; j < params->n; j++) {
    221         for (int k = 0; k < params->n; k++) {
     221    for (psS32 j = 0; j < params->n; j++) {
     222        for (psS32 k = 0; k < params->n; k++) {
    222223            alpha->data.F64[j][k] = 0;
    223224        }
    … …  
    227228
    228229    // calculate chisq, alpha, beta
    229     for (int i = 0; i < y->n; i++) {
     230    for (psS32 i = 0; i < y->n; i++) {
    230231        ymodel = func(deriv, params, (psVector *) x->data[i]);
    231232
    … …  
    233234        chisq += PS_SQR(delta) * dy->data.F32[i];
    234235
    235         for (int j = 0; j < params->n; j++) {
     236        for (psS32 j = 0; j < params->n; j++) {
    236237            if ((paramMask != NULL) && (paramMask->data.U8[j]))
    237238                continue;
    238239            weight = deriv->data.F32[j] * dy->data.F32[i];
    239             for (int k = 0; k <= j; k++) {
     240            for (psS32 k = 0; k <= j; k++) {
    240241                if ((paramMask != NULL) && (paramMask->data.U8[k]))
    241242                    continue;
    … …  
    247248
    248249    // calculate lower-left half of alpha
    249     for (int j = 1; j < params->n; j++) {
    250         for (int k = 0; k < j; k++) {
     250    for (psS32 j = 1; j < params->n; j++) {
     251        for (psS32 k = 0; k < j; k++) {
    251252            alpha->data.F64[k][j] = alpha->data.F64[j][k];
    252253        }
    … …  
    255256    // fill in pivots if we apply a mask
    256257    if (paramMask != NULL) {
    257         for (int j = 0; j < params->n; j++) {
     258        for (psS32 j = 0; j < params->n; j++) {
    258259            if (paramMask->data.U8[j]) {
    259260                alpha->data.F64[j][j] = 1;

  • trunk/psLib/src/math/psMinimizePolyFit.c

    r6193 r6204  
    1010 *  @author EAM, IfA
    1111 *
    12  *  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
    13  *  @date $Date: 2006-01-26 00:31:19 $
     12 *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
     13 *  @date $Date: 2006-01-26 21:10:22 $
    1414 *
    1515 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    350350    // We first fit an ordinary polynomial to the data.
    351351    //
    352     psPolynomial1D *ordPoly = psPolynomial1DAlloc(polyOrder, PS_POLYNOMIAL_ORD);
     352    psPolynomial1D *ordPoly = psPolynomial1DAlloc(PS_POLYNOMIAL_ORD, polyOrder);
    353353    psPolynomial1D *rc = VectorFitPolynomial1DOrd(ordPoly, mask, maskValue, y, yErr, x);
    354354    if (rc == NULL) {
    … …  
    965965        }
    966966    } else {
    967         psError(PS_ERR_UNKNOWN, true, "Incorrect polynomial type.  Returning NULL.\n");
     967        psError(PS_ERR_UNKNOWN, true, "Incorrect polynomial type (%d).  Returning NULL.\n", poly->type);
    968968        poly = NULL;
    969969    }

  • trunk/psLib/src/math/psPolynomial.c

    r6199 r6204  
    77*  polynomials.  It also contains a Gaussian functions.
    88*
    9 *  @version $Revision: 1.139 $ $Name: not supported by cvs2svn $
    10 *  @date $Date: 2006-01-26 02:44:56 $
     9*  @version $Revision: 1.140 $ $Name: not supported by cvs2svn $
     10*  @date $Date: 2006-01-26 21:10:22 $
    1111*
    1212*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    168168        psPolynomial1D **chebPolys = (psPolynomial1D **) psAlloc(numPolys * sizeof(psPolynomial1D *));
    169169        for (psS32 i = 0; i < numPolys; i++) {
    170             chebPolys[i] = psPolynomial1DAlloc(i, PS_POLYNOMIAL_ORD);
     170            chebPolys[i] = psPolynomial1DAlloc(PS_POLYNOMIAL_ORD, i);
    171171            chebPolys[i]->coeff[i] = 1;
    172172        }
    … …  
    175175        psPolynomial1D **chebPolys = (psPolynomial1D **) psAlloc(numPolys * sizeof(psPolynomial1D *));
    176176        for (psS32 i = 0; i < numPolys; i++) {
    177             chebPolys[i] = psPolynomial1DAlloc(i, PS_POLYNOMIAL_ORD);
     177            chebPolys[i] = psPolynomial1DAlloc(PS_POLYNOMIAL_ORD, i);
    178178        }
    179179
    … …  
    615615 *****************************************************************************/
    616616psPolynomial1D* psPolynomial1DAlloc(
    617     unsigned int n,
    618     psPolynomialType type)
     617    psPolynomialType type,
     618    unsigned int nX)
    619619{
    620620    //PS_ASSERT_INT_NONNEGATIVE(n, NULL);
    621     psU32 nOrder = n;
     621    psU32 nOrder = nX;
    622622    psPolynomial1D *newPoly = (psPolynomial1D* ) psAlloc(sizeof(psPolynomial1D));
    623623    psMemSetDeallocator(newPoly, (psFreeFunc) polynomial1DFree);
    … …  
    639639}
    640640
    641 psPolynomial2D* psPolynomial2DAlloc( unsigned int nX,
    642                                      unsigned int nY,
    643                                      psPolynomialType type)
     641psPolynomial2D* psPolynomial2DAlloc(
     642    psPolynomialType type,
     643    unsigned int nX,
     644    unsigned int nY)
    644645{
    645646    //PS_ASSERT_INT_NONNEGATIVE(nX, NULL);
    … …  
    676677}
    677678
    678 psPolynomial3D* psPolynomial3DAlloc( unsigned int nX,
    679                                      unsigned int nY,
    680                                      unsigned int nZ,
    681                                      psPolynomialType type)
     679psPolynomial3D* psPolynomial3DAlloc(
     680    psPolynomialType type,
     681    unsigned int nX,
     682    unsigned int nY,
     683    unsigned int nZ)
    682684{
    683685    //PS_ASSERT_INT_NONNEGATIVE(nX, NULL);
    … …  
    724726}
    725727
    726 psPolynomial4D* psPolynomial4DAlloc( unsigned int nX,
    727                                      unsigned int nY,
    728                                      unsigned int nZ,
    729                                      unsigned int nT,
    730                                      psPolynomialType type)
     728psPolynomial4D* psPolynomial4DAlloc(
     729    psPolynomialType type,
     730    unsigned int nX,
     731    unsigned int nY,
     732    unsigned int nZ,
     733    unsigned int nT)
    731734{
    732735    //PS_ASSERT_INT_NONNEGATIVE(nX, NULL);

  • trunk/psLib/src/math/psPolynomial.h

    r6186 r6204  
    1111 *  @author GLG, MHPCC
    1212 *
    13  *  @version $Revision: 1.60 $ $Name: not supported by cvs2svn $
    14  *  @date $Date: 2006-01-23 22:25:31 $
     13 *  @version $Revision: 1.61 $ $Name: not supported by cvs2svn $
     14 *  @date $Date: 2006-01-26 21:10:22 $
    1515 *
    1616 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    127127 */
    128128psPolynomial1D* psPolynomial1DAlloc(
    129     unsigned int n,                    ///< Number of terms
    130     psPolynomialType type              ///< Polynomial Type
     129    psPolynomialType type,             ///< Polynomial Type
     130    unsigned int nX                    ///< Number of terms
    131131);
    132132
    … …  
    136136 */
    137137psPolynomial2D* psPolynomial2DAlloc(
     138    psPolynomialType type,             ///< Polynomial Type
     139    unsigned int nX,                   ///< Number of terms in x
     140    unsigned int nY                    ///< Number of terms in y
     141);
     142
     143/** Allocates a 3-D polynomial structure
     144 *
     145 *  @return  psPolynomial3D*    new 3-D polynomial struct
     146 */
     147psPolynomial3D* psPolynomial3DAlloc(
     148    psPolynomialType type,             ///< Polynomial Type
    138149    unsigned int nX,                   ///< Number of terms in x
    139150    unsigned int nY,                   ///< Number of terms in y
    140     psPolynomialType type              ///< Polynomial Type
    141 );
    142 
    143 /** Allocates a 3-D polynomial structure
    144  *
    145  *  @return  psPolynomial3D*    new 3-D polynomial struct
    146  */
    147 psPolynomial3D* psPolynomial3DAlloc(
     151    unsigned int nZ                    ///< Number of terms in z
     152);
     153
     154/** Allocates a 4-D polynomial structure
     155 *
     156 *  @return  psPolynomial4D*    new 4-D polynomial struct
     157 */
     158psPolynomial4D* psPolynomial4DAlloc(
     159    psPolynomialType type,             ///< Polynomial Type
    148160    unsigned int nX,                   ///< Number of terms in x
    149161    unsigned int nY,                   ///< Number of terms in y
    150162    unsigned int nZ,                   ///< Number of terms in z
    151     psPolynomialType type              ///< Polynomial Type
    152 );
    153 
    154 /** Allocates a 4-D polynomial structure
    155  *
    156  *  @return  psPolynomial4D*    new 4-D polynomial struct
    157  */
    158 psPolynomial4D* psPolynomial4DAlloc(
    159     unsigned int nX,                   ///< Number of terms in x
    160     unsigned int nY,                   ///< Number of terms in y
    161     unsigned int nZ,                   ///< Number of terms in z
    162     unsigned int nT,                   ///< Number of terms in t
    163     psPolynomialType type              ///< Polynomial Type
     163    unsigned int nT                    ///< Number of terms in t
    164164);
    165165

  • trunk/psLib/src/math/psSpline.c

    r6186 r6204  
    77*  splines.
    88*
    9 *  @version $Revision: 1.133 $ $Name: not supported by cvs2svn $
    10 *  @date $Date: 2006-01-23 22:25:31 $
     9*  @version $Revision: 1.134 $ $Name: not supported by cvs2svn $
     10*  @date $Date: 2006-01-26 21:10:22 $
    1111*
    1212*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    507507    spline->spline = (psPolynomial1D **) psAlloc(numSplines * sizeof(psPolynomial1D *));
    508508    for (psS32 i=0;i<numSplines;i++) {
    509         spline->spline[i] = psPolynomial1DAlloc(3, PS_POLYNOMIAL_ORD);
     509        spline->spline[i] = psPolynomial1DAlloc(PS_POLYNOMIAL_ORD, 3);
    510510    }
    511511

  • trunk/psLib/src/math/psStats.c

    r6193 r6204  
    1414 *      stats->binsize
    1515 *
    16  *  @version $Revision: 1.161 $ $Name: not supported by cvs2svn $
    17  *  @date $Date: 2006-01-26 00:31:19 $
     16 *  @version $Revision: 1.162 $ $Name: not supported by cvs2svn $
     17 *  @date $Date: 2006-01-26 21:10:22 $
    1818 *
    1919 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    14571457    psVector *y = psVectorAlloc(3, PS_TYPE_F64);
    14581458    psVector *yErr = psVectorAlloc(3, PS_TYPE_F64);
    1459     psPolynomial1D *myPoly = psPolynomial1DAlloc(2, PS_POLYNOMIAL_ORD);
     1459    psPolynomial1D *myPoly = psPolynomial1DAlloc(PS_POLYNOMIAL_ORD, 2);
    14601460
    14611461    psF32 tmpFloat = 0.0f;

  • trunk/psLib/src/types/psLookupTable.c

    r5522 r6204  
    77*  @author Ross Harman, MHPCC
    88*
    9 *  @version $Revision: 1.27 $ $Name: not supported by cvs2svn $
    10 *  @date $Date: 2005-11-16 02:40:13 $
     9*  @version $Revision: 1.28 $ $Name: not supported by cvs2svn $
     10*  @date $Date: 2006-01-26 21:10:22 $
    1111*
    1212*  Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
    … …  
    841841}
    842842
    843 psVector* psLookupTableInterpolateAll(const psLookupTable *table,
    844                                       double index)
     843psVector* psLookupTableInterpolateAll(
     844    const psLookupTable *table,
     845    double index,
     846    psVector *stats)
    845847{
    846848    long numCols = 0;
    … …  
    851853    numCols = table->values->n;
    852854    PS_ASSERT_INT_UNEQUAL(numCols, 0,NULL);
     855    if (stats != NULL) {
     856        // XXX: Determine what the stats vector is for.  Not documented in SDRS.
     857        psLogMsg(__func__, PS_LOG_WARN, "WARNING: the psVector stats is currently ignored by this function.\n");
     858    }
    853859
    854860    // Create output vector

  • trunk/psLib/src/types/psLookupTable.h

    r4898 r6204  
    77*  @author Ross Harman, MHPCC
    88*
    9 *  @version $Revision: 1.12 $ $Name: not supported by cvs2svn $
    10 *  @date $Date: 2005-08-30 01:14:13 $
     9*  @version $Revision: 1.13 $ $Name: not supported by cvs2svn $
     10*  @date $Date: 2006-01-26 21:10:22 $
    1111*
    1212*  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    1919#include "psVector.h"
    2020#include "psArray.h"
     21#include "psLogMsg.h"
    2122
    2223
    … …  
    138139 */
    139140psVector* psLookupTableInterpolateAll(
    140     const psLookupTable *table,        ///< Table with data
    141     double index                       ///< Value to be interpolated
     141    const psLookupTable *table,         ///< Table with data
     142    double index,                       ///< Value to be interpolated
     143    psVector *stats                     ///< Unknown
    142144);
    143145

  • trunk/psLib/test/astronomy/tst_psAstrometry01.c

    r4581 r6204  
    55*  @author GLG, MHPCC
    66*
    7 *  @version $Revision: 1.33 $ $Name: not supported by cvs2svn $
    8 *  @date $Date: 2005-07-20 01:21:13 $
     7*  @version $Revision: 1.34 $ $Name: not supported by cvs2svn $
     8*  @date $Date: 2006-01-26 21:10:22 $
    99*
    1010* XXX: Must test
    … …  
    113113    NAME = (psPlaneTransform *) psAlloc(sizeof(psPlaneTransform)); \
    114114    psMemSetDeallocator(NAME, (psFreeFunc) psPlaneTransformFree); \
    115     NAME->x = psPolynomial2DAlloc(2, 2, PS_POLYNOMIAL_ORD); \
    116     NAME->y = psPolynomial2DAlloc(2, 2, PS_POLYNOMIAL_ORD); \
     115    NAME->x = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, 2, 2); \
     116    NAME->y = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, 2, 2); \
    117117    NAME->x->coeff[1][0] = 1.0; \
    118118    NAME->y->coeff[0][1] = 1.0; \
    … …  
    123123    NAME = (psPlaneDistort *) psAlloc(sizeof(psPlaneDistort)); \
    124124    psMemSetDeallocator(NAME, (psFreeFunc) psPlaneDistortFree); \
    125     NAME->x = psPolynomial4DAlloc(2, 2, 2, 2, PS_POLYNOMIAL_ORD); \
    126     NAME->y = psPolynomial4DAlloc(2, 2, 2, 2, PS_POLYNOMIAL_ORD); \
     125    NAME->x = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, 2, 2, 2, 2); \
     126    NAME->y = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, 2, 2, 2, 2); \
    127127    NAME->x->coeff[1][0][0][0] = 1.0; \
    128128    NAME->y->coeff[0][1][0][0] = 1.0; \

  • trunk/psLib/test/imageops/tst_psImageStats.c

    r5839 r6204  
    410410        }
    411411    }
    412     my2DPoly = psPolynomial2DAlloc( CHEBY_X_DIM-1, CHEBY_Y_DIM-1, PS_POLYNOMIAL_CHEB );
     412    my2DPoly = psPolynomial2DAlloc(PS_POLYNOMIAL_CHEB, CHEBY_X_DIM-1, CHEBY_Y_DIM-1);
    413413    /*************************************************************************/
    414414    /*  Calculate Chebyshev Polynomials, no mask                     */
    … …  
    571571    }
    572572
    573     psPolynomial2D *chebys = psPolynomial2DAlloc(5, 5, PS_POLYNOMIAL_CHEB);
     573    psPolynomial2D *chebys = psPolynomial2DAlloc(PS_POLYNOMIAL_CHEB, 5, 5);
    574574
    575575    chebys = psImageFitPolynomial(chebys, tmpImage);
    … …  
    634634    }
    635635
    636     psPolynomial2D *chebys = psPolynomial2DAlloc(5, 5, PS_POLYNOMIAL_CHEB);
     636    psPolynomial2D *chebys = psPolynomial2DAlloc(PS_POLYNOMIAL_CHEB, 5, 5);
    637637
    638638    chebys = psImageFitPolynomial(chebys, tmpImage);
    … …  
    765765        return 100;
    766766    }
     767
    767768    //Test for invalid region (0 pixels, lower = upper)
    768769    reg.x0 = 1;

  • trunk/psLib/test/math/tst_psFunc08.c

    r5092 r6204  
    44*  ORD and CHEB type polynomials.
    55*
    6 *  @version  $Revision: 1.5 $  $Name: not supported by cvs2svn $
    7 *  @date  $Date: 2005-09-22 20:45:43 $
     6*  @version  $Revision: 1.6 $  $Name: not supported by cvs2svn $
     7*  @date  $Date: 2006-01-26 21:10:22 $
    88*
    99*  XXX: Probably should test single- and multi-dimensional polynomials in
    … …  
    6262
    6363    // Allocate polynomial structure
    64     psPolynomial1D*  polyOrd = psPolynomial1DAlloc(TERMS-1, PS_POLYNOMIAL_ORD);
    65     psPolynomial1D*  polyCheb = psPolynomial1DAlloc(TERMS-1, PS_POLYNOMIAL_CHEB);
     64    psPolynomial1D*  polyOrd = psPolynomial1DAlloc(PS_POLYNOMIAL_ORD, TERMS-1);
     65    psPolynomial1D*  polyCheb = psPolynomial1DAlloc(PS_POLYNOMIAL_CHEB, TERMS-1);
    6666    // Set polynomial members
    6767    for(psS32 i = 0; i < TERMS; i++) {
    … …  
    9090
    9191    // Allocate polynomial with invalid type
    92     polyOrd = psPolynomial1DAlloc(TERMS-1, 99);
     92    polyOrd = psPolynomial1DAlloc(99, TERMS-1);
    9393    // Attempt to evaluation invalid polynomial type
    9494    psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type");
    … …  
    107107{
    108108    // Allocate polynomial
    109     psPolynomial1D* polyOrd = psPolynomial1DAlloc(TERMS-1,PS_POLYNOMIAL_ORD);
    110     psPolynomial1D* polyCheb = psPolynomial1DAlloc(TERMS-1,PS_POLYNOMIAL_CHEB);
     109    psPolynomial1D* polyOrd = psPolynomial1DAlloc(PS_POLYNOMIAL_ORD, TERMS-1);
     110    psPolynomial1D* polyCheb = psPolynomial1DAlloc(PS_POLYNOMIAL_CHEB, TERMS-1);
    111111
    112112    // Set polynomial members

  • trunk/psLib/test/math/tst_psFunc09.c

    r5092 r6204  
    44*  ORD and CHEB type polynomials.
    55*
    6 *  @version  $Revision: 1.5 $  $Name: not supported by cvs2svn $
    7 *  @date  $Date: 2005-09-22 20:45:43 $
     6*  @version  $Revision: 1.6 $  $Name: not supported by cvs2svn $
     7*  @date  $Date: 2006-01-26 21:10:22 $
    88*
    99* Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
    … …  
    8989
    9090    // Allocate polynomial structure
    91     psPolynomial2D*  polyOrd = psPolynomial2DAlloc(TERMS-1, TERMS-1, PS_POLYNOMIAL_ORD);
    92     psPolynomial2D*  polyCheb = psPolynomial2DAlloc(TERMS-1, TERMS-1, PS_POLYNOMIAL_CHEB);
     91    psPolynomial2D*  polyOrd = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, TERMS-1, TERMS-1);
     92    psPolynomial2D*  polyCheb = psPolynomial2DAlloc(PS_POLYNOMIAL_CHEB, TERMS-1, TERMS-1);
    9393    // Set polynomial members
    9494    for(psS32 i = 0; i < TERMS; i++) {
    … …  
    117117
    118118    // Allocate polynomial with invalid type
    119     polyOrd = psPolynomial2DAlloc(TERMS-1, TERMS-1, 99);
     119    polyOrd = psPolynomial2DAlloc(99, TERMS-1, TERMS-1);
    120120    // Attempt to evaluation invalid polynomial type
    121121    psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type");
    … …  
    134134    psBool testStatus = true;
    135135    // Allocate polynomial
    136     psPolynomial2D* polyOrd = psPolynomial2DAlloc(TERMS-1,TERMS-1,PS_POLYNOMIAL_ORD);
    137     psPolynomial2D* polyCheb = psPolynomial2DAlloc(TERMS-1,TERMS-1,PS_POLYNOMIAL_CHEB);
     136    psPolynomial2D* polyOrd = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, TERMS-1, TERMS-1);
     137    psPolynomial2D* polyCheb = psPolynomial2DAlloc(PS_POLYNOMIAL_CHEB, TERMS-1, TERMS-1);
    138138
    139139    // Set polynomial members

  • trunk/psLib/test/math/tst_psFunc10.c

    r5094 r6204  
    44*  ORD and CHEB type polynomials.
    55*
    6 *  @version  $Revision: 1.6 $  $Name: not supported by cvs2svn $
    7 *  @date  $Date: 2005-09-22 22:22:15 $
     6*  @version  $Revision: 1.7 $  $Name: not supported by cvs2svn $
     7*  @date  $Date: 2006-01-26 21:10:22 $
    88*
    99* Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
    … …  
    140140
    141141    // Allocate polynomial structure
    142     psPolynomial3D*  polyOrd = psPolynomial3DAlloc(TERMS-1, TERMS-1, TERMS-1,PS_POLYNOMIAL_ORD);
    143     psPolynomial3D*  polyCheb = psPolynomial3DAlloc(TERMS-1, TERMS-1, TERMS-1,PS_POLYNOMIAL_CHEB);
     142    psPolynomial3D*  polyOrd = psPolynomial3DAlloc(PS_POLYNOMIAL_ORD, TERMS-1, TERMS-1, TERMS-1);
     143    psPolynomial3D*  polyCheb = psPolynomial3DAlloc(PS_POLYNOMIAL_CHEB, TERMS-1, TERMS-1, TERMS-1);
    144144    // Set polynomial members
    145145    for(psS32 i = 0; i < TERMS; i++) {
    … …  
    174174
    175175    // Allocate polynomial with invalid type
    176     polyOrd = psPolynomial3DAlloc(TERMS-1, TERMS-1, TERMS-1, 99);
     176    polyOrd = psPolynomial3DAlloc(99, TERMS-1, TERMS-1, TERMS-1);
    177177    // Attempt to evaluation invalid polynomial type
    178178    psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type");
    … …  
    191191    psBool testStatus = true;
    192192    // Allocate polynomial
    193     psPolynomial3D* polyOrd = psPolynomial3DAlloc(TERMS-1, TERMS-1, TERMS-1,PS_POLYNOMIAL_ORD);
    194     psPolynomial3D* polyCheb = psPolynomial3DAlloc(TERMS-1, TERMS-1, TERMS-1,PS_POLYNOMIAL_CHEB);
     193    psPolynomial3D* polyOrd = psPolynomial3DAlloc(PS_POLYNOMIAL_ORD, TERMS-1, TERMS-1, TERMS-1);
     194    psPolynomial3D* polyCheb = psPolynomial3DAlloc(PS_POLYNOMIAL_CHEB, TERMS-1, TERMS-1, TERMS-1);
    195195
    196196    // Set polynomial members

  • trunk/psLib/test/math/tst_psFunc11.c

    r6197 r6204  
    44*  ORD and CHEB type polynomials.
    55*
    6 *  @version  $Revision: 1.7 $  $Name: not supported by cvs2svn $
    7 *  @date  $Date: 2006-01-26 02:11:01 $
     6*  @version  $Revision: 1.8 $  $Name: not supported by cvs2svn $
     7*  @date  $Date: 2006-01-26 21:10:22 $
    88*
    99* Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
    … …  
    379379    psBool testStatus = true;
    380380    // Allocate polynomial structure
    381     psPolynomial4D*  polyOrd = psPolynomial4DAlloc(TERMS-1, TERMS-1, TERMS-1, TERMS-1, PS_POLYNOMIAL_ORD);
    382     psPolynomial4D*  polyCheb = psPolynomial4DAlloc(TERMS-1, TERMS-1, TERMS-1, TERMS-1, PS_POLYNOMIAL_CHEB);
     381    psPolynomial4D*  polyOrd = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, TERMS-1, TERMS-1, TERMS-1, TERMS-1);
     382    psPolynomial4D*  polyCheb = psPolynomial4DAlloc(PS_POLYNOMIAL_CHEB, TERMS-1, TERMS-1, TERMS-1, TERMS-1);
    383383    // Set polynomial members
    384384    for(psS32 i = 0; i < TERMS; i++) {
    … …  
    418418
    419419    // Allocate polynomial with invalid type
    420     polyOrd = psPolynomial4DAlloc(TERMS-1, TERMS-1, TERMS-1, TERMS-1, 99);
     420    polyOrd = psPolynomial4DAlloc(99, TERMS-1, TERMS-1, TERMS-1, TERMS-1);
    421421    // Attempt to evaluation invalid polynomial type
    422422    psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type");
    … …  
    435435    psBool testStatus = true;
    436436    // Allocate polynomial
    437     psPolynomial4D* polyOrd = psPolynomial4DAlloc(TERMS-1, TERMS-1, TERMS-1, TERMS-1, PS_POLYNOMIAL_ORD);
    438     psPolynomial4D* polyCheb = psPolynomial4DAlloc(TERMS-1, TERMS-1, TERMS-1, TERMS-1, PS_POLYNOMIAL_CHEB);
     437    psPolynomial4D* polyOrd = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, TERMS-1, TERMS-1, TERMS-1, TERMS-1);
     438    psPolynomial4D* polyCheb = psPolynomial4DAlloc(PS_POLYNOMIAL_CHEB, TERMS-1, TERMS-1, TERMS-1, TERMS-1);
    439439
    440440    // Set polynomial members

  • trunk/psLib/test/math/tst_psPolyFit1D.c

    r6194 r6204  
    8484    if (flags & TS00_POLY_ORD) {
    8585        printf(" using ordinary polynomials\n");
    86         myPoly = psPolynomial1DAlloc(polyOrder, PS_POLYNOMIAL_ORD);
     86        myPoly = psPolynomial1DAlloc(PS_POLYNOMIAL_ORD, polyOrder);
    8787    }
    8888
    8989    if (flags & TS00_POLY_CHEB) {
    9090        printf(" using chebyshev polynomials\n");
    91         myPoly = psPolynomial1DAlloc(polyOrder, PS_POLYNOMIAL_CHEB);
     91        myPoly = psPolynomial1DAlloc(PS_POLYNOMIAL_CHEB, polyOrder);
    9292    }
    9393

  • trunk/psLib/test/math/tst_psPolyFit2D.c

    r6193 r6204  
    9090    if (flags & TS00_POLY_ORD) {
    9191        printf(" using ordinary polynomials\n");
    92         myPoly = psPolynomial2DAlloc(polyOrderX, polyOrderY, PS_POLYNOMIAL_ORD);
     92        myPoly = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, polyOrderX, polyOrderY);
    9393    }
    9494

  • trunk/psLib/test/math/tst_psPolyFit3D.c

    r6193 r6204  
    107107    if (flags & TS00_POLY_ORD) {
    108108        printf(" using ordinary polynomials\n");
    109         myPoly = psPolynomial3DAlloc(polyOrderX, polyOrderY, polyOrderZ, PS_POLYNOMIAL_ORD);
     109        myPoly = psPolynomial3DAlloc(PS_POLYNOMIAL_ORD, polyOrderX, polyOrderY, polyOrderZ);
    110110    }
    111111

  • trunk/psLib/test/math/tst_psPolyFit4D.c

    r6193 r6204  
    120120    if (flags & TS00_POLY_ORD) {
    121121        printf(" using ordinary polynomials\n");
    122         myPoly = psPolynomial4DAlloc(polyOrderX, polyOrderY, polyOrderZ, polyOrderT, PS_POLYNOMIAL_ORD);
     122        myPoly = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, polyOrderX, polyOrderY, polyOrderZ, polyOrderT);
    123123    }
    124124

  • trunk/psLib/test/math/tst_psSpline1D.c

    r5647 r6204  
    1313*  @author GLG, MHPCC
    1414*
    15 *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
    16 *  @date $Date: 2005-12-01 01:20:38 $
     15*  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
     16*  @date $Date: 2006-01-26 21:10:22 $
    1717*
    1818*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    120120        tmpSline->spline = (psPolynomial1D **) psAlloc(numSplines * sizeof(psPolynomial1D *));
    121121        for (psS32 i=0;i<numSplines;i++) {
    122             spline->spline[i] = psPolynomial1DAlloc(3, PS_POLYNOMIAL_ORD);
     122            spline->spline[i] = psPolynomial1DAlloc(PS_POLYNOMIAL_ORD, 3);
    123123        }
    124124    */

  • trunk/psLib/test/sys/tst_psMemory.c

    r5512 r6204  
    66*  @author Robert DeSonia, MHPCC
    77*
    8 *  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
    9 *  @date $Date: 2005-11-14 22:18:48 $
     8*  @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
     9*  @date $Date: 2006-01-26 21:10:22 $
    1010*
    1111*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    712712
    713713    psPolynomial1D *poly1;
    714     poly1 = psPolynomial1DAlloc(2, PS_POLYNOMIAL_ORD);
     714    poly1 = psPolynomial1DAlloc(PS_POLYNOMIAL_ORD, 2);
    715715    if ( !psMemCheckType(PS_DATA_POLYNOMIAL1D, poly1) ) {
    716716        psError(PS_ERR_BAD_PARAMETER_VALUE, true, "psMemCheckPolynomial1D failed in memCheckType. \n");
    … …  
    721721
    722722    psPolynomial2D *poly2;
    723     poly2 = psPolynomial2DAlloc(2, 1, PS_POLYNOMIAL_ORD);
     723    poly2 = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, 2, 1);
    724724    if ( !psMemCheckType(PS_DATA_POLYNOMIAL2D, poly2) ) {
    725725        psError(PS_ERR_BAD_PARAMETER_VALUE, true, "psMemCheckPolynomial2D failed in memCheckType. \n");
    … …  
    730730
    731731    psPolynomial3D *poly3;
    732     poly3 = psPolynomial3DAlloc(2, 1, 2, PS_POLYNOMIAL_ORD);
     732    poly3 = psPolynomial3DAlloc(PS_POLYNOMIAL_ORD, 2, 1, 1);
    733733    if ( !psMemCheckType(PS_DATA_POLYNOMIAL3D, poly3) ) {
    734734        psError(PS_ERR_BAD_PARAMETER_VALUE, true, "psMemCheckPolynomial3D failed in memCheckType. \n");
    … …  
    739739
    740740    psPolynomial4D *poly4;
    741     poly4 = psPolynomial4DAlloc(2, 1, 2, 1, PS_POLYNOMIAL_ORD);
     741    poly4 = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, 2, 1, 2, 1);
    742742    if ( !psMemCheckType(PS_DATA_POLYNOMIAL4D, poly4) ) {
    743743        psError(PS_ERR_BAD_PARAMETER_VALUE, true, "psMemCheckPolynomial4D failed in memCheckType. \n");

  • trunk/psLib/test/types/tst_psLookupTable_01.c

    r5303 r6204  
    1212*  @author  Ross Harman, MHPCC
    1313*
    14 *  @version $Revision: 1.2 $  $Name: not supported by cvs2svn $
    15 *  @date  $Date: 2005-10-13 00:38:56 $
     14*  @version $Revision: 1.3 $  $Name: not supported by cvs2svn $
     15*  @date  $Date: 2006-01-26 21:10:22 $
    1616*
    1717*  Copyright 2004-5 Maui High Performance Computing Center, University of Hawaii
    … …  
    816816    // Interpolate values with NULL table
    817817    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL table");
    818     interpValues = psLookupTableInterpolateAll(table1,5);
     818    interpValues = psLookupTableInterpolateAll(table1,5, NULL);
    819819    if(interpValues != NULL ) {
    820820        psError(PS_ERR_UNKNOWN,true,"Did not return NULL for NULL table");
    … …  
    829829        return 6;
    830830    }
    831     interpValues = psLookupTableInterpolateAll(table1,5.25);
     831    interpValues = psLookupTableInterpolateAll(table1,5.25, NULL);
    832832    if(interpValues == NULL) {
    833833        psError(PS_ERR_UNKNOWN,true,"Returned vector is NULL.");
    … …  
    844844
    845845    // Interpolate values with index outside table
    846     interpValues = psLookupTableInterpolateAll(table1,0);
     846    interpValues = psLookupTableInterpolateAll(table1,0, NULL);
    847847    if(interpValues != NULL) {
    848848        psError(PS_ERR_UNKNOWN,true,"Did return NULL");
Note: See TracChangeset for help on using the changeset viewer.