IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 5294 for trunk/psLib/src/math


Ignore:
Timestamp:
Oct 12, 2005, 11:02:20 AM (21 years ago)
Author:
gusciora
Message:

Polynomial members are now nX, nY, nZ, nT.

Location:
trunk/psLib/src/math
Files:
4 edited

Legend:

Unmodified
Added
Removed

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

    r5155 r5294  
    66 *  @author GLG, MHPCC
    77 *
    8  *  @version $Revision: 1.77 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2005-09-27 23:16:59 $
     8 *  @version $Revision: 1.78 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2005-10-12 21:02:20 $
    1010 *
    1111 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    579579
    580580#define PS_POLY_PRINT_1D(NAME) \
    581 for (psS32 i = 0 ; i < NAME->COOL_1D_n ; i++) {\
     581for (psS32 i = 0 ; i < NAME->nX ; i++) {\
    582582    printf("%s->coeff[%d] is %f\n", #NAME, i, NAME->coeff[i]); \
    583583}\

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

    r5175 r5294  
    1010 *  @author EAM, IfA
    1111 *
    12  *  @version $Revision: 1.141 $ $Name: not supported by cvs2svn $
    13  *  @date $Date: 2005-09-29 02:13:54 $
     12 *  @version $Revision: 1.142 $ $Name: not supported by cvs2svn $
     13 *  @date $Date: 2005-10-12 21:02:20 $
    1414 *
    1515 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    15071507    // XXX: these ASSERTS are redundant.
    15081508    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
    1509     PS_ASSERT_INT_NONNEGATIVE(myPoly->COOL_1D_n, NULL);
     1509    PS_ASSERT_INT_NONNEGATIVE(myPoly->nX, NULL);
    15101510    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
    15111511    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F64, NULL);
    … …  
    15711571    fac = 2.0/((psF32) n);
    15721572    // XXX: is this loop bound correct?
    1573     for (j=0;j<myPoly->COOL_1D_n+1;j++) {
     1573    for (j=0;j<myPoly->nX+1;j++) {
    15741574        sum = 0.0;
    15751575        for (k=0;k<n;k++) {
    … …  
    16001600    // XXX: these ASSERTS are redundant.
    16011601    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
    1602     PS_ASSERT_INT_NONNEGATIVE(myPoly->COOL_1D_n, NULL);
     1602    PS_ASSERT_INT_NONNEGATIVE(myPoly->nX, NULL);
    16031603    PS_ASSERT_VECTOR_NON_NULL(f, NULL);
    16041604    PS_ASSERT_VECTOR_TYPE(f, PS_TYPE_F64, NULL);
    … …  
    16431643    }
    16441644
    1645     nTerm = 1 + myPoly->COOL_1D_n;
     1645    nTerm = 1 + myPoly->nX;
    16461646    nOrder = nTerm - 1;
    16471647
    … …  
    17431743
    17441744    PS_ASSERT_POLY_NON_NULL(poly, NULL);
    1745     PS_ASSERT_INT_NONNEGATIVE(poly->COOL_1D_n, NULL);
     1745    PS_ASSERT_INT_NONNEGATIVE(poly->nX, NULL);
    17461746    PS_ASSERT_VECTOR_NON_NULL(f, NULL);
    17471747    PS_ASSERT_VECTOR_NON_EMPTY(f, NULL);
    … …  
    18831883    // These ASSERTS are redundant.
    18841884    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
    1885     PS_ASSERT_INT_NONNEGATIVE(myPoly->COOL_2D_nX, NULL);
    1886     PS_ASSERT_INT_NONNEGATIVE(myPoly->COOL_2D_nY, NULL);
     1885    PS_ASSERT_INT_NONNEGATIVE(myPoly->nX, NULL);
     1886    PS_ASSERT_INT_NONNEGATIVE(myPoly->nY, NULL);
    18871887
    18881888    PS_ASSERT_VECTOR_NON_NULL(f, NULL);
    … …  
    19111911
    19121912    // XXX:Watch for changes to the psPolys: nTerm != nOrder.
    1913     psS32 nXterm = 1 + myPoly->COOL_2D_nX;
    1914     psS32 nYterm = 1 + myPoly->COOL_2D_nY;
     1913    psS32 nXterm = 1 + myPoly->nX;
     1914    psS32 nYterm = 1 + myPoly->nY;
    19151915    nTerm = nXterm * nYterm;
    19161916
    … …  
    23102310    // These ASSERTS are redundant.
    23112311    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
    2312     PS_ASSERT_INT_NONNEGATIVE(myPoly->COOL_3D_nX, NULL);
    2313     PS_ASSERT_INT_NONNEGATIVE(myPoly->COOL_3D_nY, NULL);
    2314     PS_ASSERT_INT_NONNEGATIVE(myPoly->COOL_3D_nZ, NULL);
     2312    PS_ASSERT_INT_NONNEGATIVE(myPoly->nX, NULL);
     2313    PS_ASSERT_INT_NONNEGATIVE(myPoly->nY, NULL);
     2314    PS_ASSERT_INT_NONNEGATIVE(myPoly->nZ, NULL);
    23152315
    23162316    PS_ASSERT_VECTOR_NON_NULL(f, NULL);
    … …  
    25732573    // These ASSERTS are redundant.
    25742574    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
    2575     PS_ASSERT_INT_NONNEGATIVE(myPoly->COOL_4D_nX, NULL);
    2576     PS_ASSERT_INT_NONNEGATIVE(myPoly->COOL_4D_nY, NULL);
    2577     PS_ASSERT_INT_NONNEGATIVE(myPoly->COOL_4D_nZ, NULL);
    2578     PS_ASSERT_INT_NONNEGATIVE(myPoly->COOL_4D_nT, NULL);
     2575    PS_ASSERT_INT_NONNEGATIVE(myPoly->nX, NULL);
     2576    PS_ASSERT_INT_NONNEGATIVE(myPoly->nY, NULL);
     2577    PS_ASSERT_INT_NONNEGATIVE(myPoly->nZ, NULL);
     2578    PS_ASSERT_INT_NONNEGATIVE(myPoly->nT, NULL);
    25792579    PS_ASSERT_VECTOR_NON_NULL(f, NULL);
    25802580    PS_ASSERT_VECTOR_TYPE(f, PS_TYPE_F64, NULL);

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

    r5180 r5294  
    77*  polynomials.  It also contains a Gaussian functions.
    88*
    9 *  @version $Revision: 1.129 $ $Name: not supported by cvs2svn $
    10 *  @date $Date: 2005-09-29 20:06:58 $
     9*  @version $Revision: 1.130 $ $Name: not supported by cvs2svn $
     10*  @date $Date: 2005-10-12 21:02:20 $
    1111*
    1212*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    9595    unsigned int x = 0;
    9696
    97     for (x = 0; x < (1 + poly->COOL_2D_nX); x++) {
     97    for (x = 0; x < (1 + poly->nX); x++) {
    9898        psFree(poly->coeff[x]);
    9999        psFree(poly->coeffErr[x]);
    … …  
    110110    unsigned int y = 0;
    111111
    112     for (x = 0; x < (1 + poly->COOL_3D_nX); x++) {
    113         for (y = 0; y < (1 + poly->COOL_3D_nY); y++) {
     112    for (x = 0; x < (1 + poly->nX); x++) {
     113        for (y = 0; y < (1 + poly->nY); y++) {
    114114            psFree(poly->coeff[x][y]);
    115115            psFree(poly->coeffErr[x][y]);
    … …  
    132132    unsigned int z = 0;
    133133
    134     for (x = 0; x < (1 + poly->COOL_4D_nX); x++) {
    135         for (y = 0; y < (1 + poly->COOL_4D_nY); y++) {
    136             for (z = 0; z < (1 + poly->COOL_4D_nZ); z++) {
     134    for (x = 0; x < (1 + poly->nX); x++) {
     135        for (y = 0; y < (1 + poly->nY); y++) {
     136            for (z = 0; z < (1 + poly->nZ); z++) {
    137137                psFree(poly->coeff[x][y][z]);
    138138                psFree(poly->coeffErr[x][y][z]);
    … …  
    185185
    186186        for (psS32 i = 2; i < maxChebyPoly; i++) {
    187             for (psS32 j = 0; j < chebPolys[i - 1]->COOL_1D_n; j++) {
     187            for (psS32 j = 0; j < chebPolys[i - 1]->nX; j++) {
    188188                chebPolys[i]->coeff[j + 1] = 2 * chebPolys[i - 1]->coeff[j];
    189189            }
    190             for (psS32 j = 0; j < chebPolys[i - 2]->COOL_1D_n; j++) {
     190            for (psS32 j = 0; j < chebPolys[i - 2]->nX; j++) {
    191191                chebPolys[i]->coeff[j] -= chebPolys[i - 2]->coeff[j];
    192192            }
    … …  
    213213            "---- Calling ordPolynomial1DEval(%lf)\n", x);
    214214    psTrace(".psLib.dataManip.psPolynomial.ordPolynomial1DEval", 4,
    215             "Polynomial order is %u\n", poly->COOL_1D_n);
    216     for (loop_x = 0; loop_x < poly->COOL_1D_n+1; loop_x++) {
     215            "Polynomial order is %u\n", poly->nX);
     216    for (loop_x = 0; loop_x < poly->nX+1; loop_x++) {
    217217        psTrace(".psLib.dataManip.psPolynomial.ordPolynomial1DEval", 4,
    218218                "Polynomial coeff[%u] is %lf\n", loop_x, poly->coeff[loop_x]);
    219219    }
    220220
    221     for (loop_x = 0; loop_x < poly->COOL_1D_n+1; loop_x++) {
     221    for (loop_x = 0; loop_x < poly->nX+1; loop_x++) {
    222222        if (poly->mask[loop_x] == 0) {
    223223            // XXX: If you set the tracelevel to 10 here, and later set the tracelevel to
    … …  
    241241    PS_ASSERT_DOUBLE_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
    242242    // XXX: Create a macro for this in psConstants.h
    243     if (poly->COOL_1D_n < 1) {
    244         psError(PS_ERR_BAD_PARAMETER_VALUE, true, "Error: Chebyshev polynomial is order %u.", poly->COOL_1D_n);
     243    if (poly->nX < 1) {
     244        psError(PS_ERR_BAD_PARAMETER_VALUE, true, "Error: Chebyshev polynomial is order %u.", poly->nX);
    245245        return(NAN);
    246246    }
    247247    psVector *d;
    248248    // XXX: n should be nTerms here (for clarity).  Or get rid of the variable.
    249     unsigned int n = 1 + poly->COOL_1D_n;
     249    unsigned int n = 1 + poly->nX;
    250250    unsigned int i;
    251251    psF64 tmp = 0.0;
    … …  
    305305    psPolynomial1D **chebPolys = NULL;
    306306
    307     chebPolys = createChebyshevPolys(1 + poly->COOL_1D_n);
     307    chebPolys = createChebyshevPolys(1 + poly->nX);
    308308
    309309    tmp = 0.0;
    310     for (i=0;i<(1 + poly->COOL_1D_n);i++) {
     310    for (i=0;i<(1 + poly->nX);i++) {
    311311        tmp+= (poly->coeff[i] * psPolynomial1DEval(x, chebPolys[i]));
    312312    }
    … …  
    330330    psF64 ySum = 1.0;
    331331
    332     for (loop_x = 0; loop_x < (1 + poly->COOL_2D_nX); loop_x++) {
     332    for (loop_x = 0; loop_x < (1 + poly->nX); loop_x++) {
    333333        ySum = xSum;
    334         for (loop_y = 0; loop_y < (1 + poly->COOL_2D_nY); loop_y++) {
     334        for (loop_y = 0; loop_y < (1 + poly->nY); loop_y++) {
    335335            if (poly->mask[loop_x][loop_y] == 0) {
    336336                polySum += ySum * poly->coeff[loop_x][loop_y];
    … …  
    361361    // Determine how many Chebyshev polynomials
    362362    // are needed, then create them.
    363     maxChebyPoly = poly->COOL_2D_nX;
    364     if (poly->COOL_2D_nY > maxChebyPoly) {
    365         maxChebyPoly = poly->COOL_2D_nY;
     363    maxChebyPoly = poly->nX;
     364    if (poly->nY > maxChebyPoly) {
     365        maxChebyPoly = poly->nY;
    366366    }
    367367    chebPolys = createChebyshevPolys(maxChebyPoly + 1);
    368368
    369     for (loop_x = 0; loop_x < (1 + poly->COOL_2D_nX); loop_x++) {
    370         for (loop_y = 0; loop_y < (1 + poly->COOL_2D_nY); loop_y++) {
     369    for (loop_x = 0; loop_x < (1 + poly->nX); loop_x++) {
     370        for (loop_y = 0; loop_y < (1 + poly->nY); loop_y++) {
    371371            if (poly->mask[loop_x][loop_y] == 0) {
    372372                polySum += poly->coeff[loop_x][loop_y] *
    … …  
    396396    psF64 zSum = 1.0;
    397397
    398     for (loop_x = 0; loop_x < (1 + poly->COOL_3D_nX); loop_x++) {
     398    for (loop_x = 0; loop_x < (1 + poly->nX); loop_x++) {
    399399        ySum = xSum;
    400         for (loop_y = 0; loop_y < (1 + poly->COOL_3D_nY); loop_y++) {
     400        for (loop_y = 0; loop_y < (1 + poly->nY); loop_y++) {
    401401            zSum = ySum;
    402             for (loop_z = 0; loop_z < (1 + poly->COOL_3D_nZ); loop_z++) {
     402            for (loop_z = 0; loop_z < (1 + poly->nZ); loop_z++) {
    403403                if (poly->mask[loop_x][loop_y][loop_z] == 0) {
    404404                    polySum += zSum * poly->coeff[loop_x][loop_y][loop_z];
    … …  
    432432    // Determine how many Chebyshev polynomials
    433433    // are needed, then create them.
    434     maxChebyPoly = poly->COOL_3D_nX;
    435     if (poly->COOL_3D_nY > maxChebyPoly) {
    436         maxChebyPoly = poly->COOL_3D_nY;
    437     }
    438     if (poly->COOL_3D_nZ > maxChebyPoly) {
    439         maxChebyPoly = poly->COOL_3D_nZ;
     434    maxChebyPoly = poly->nX;
     435    if (poly->nY > maxChebyPoly) {
     436        maxChebyPoly = poly->nY;
     437    }
     438    if (poly->nZ > maxChebyPoly) {
     439        maxChebyPoly = poly->nZ;
    440440    }
    441441    chebPolys = createChebyshevPolys(maxChebyPoly + 1);
    442442
    443     for (loop_x = 0; loop_x < (1 + poly->COOL_3D_nX); loop_x++) {
    444         for (loop_y = 0; loop_y < (1 + poly->COOL_3D_nY); loop_y++) {
    445             for (loop_z = 0; loop_z < (1 + poly->COOL_3D_nZ); loop_z++) {
     443    for (loop_x = 0; loop_x < (1 + poly->nX); loop_x++) {
     444        for (loop_y = 0; loop_y < (1 + poly->nY); loop_y++) {
     445            for (loop_z = 0; loop_z < (1 + poly->nZ); loop_z++) {
    446446                if (poly->mask[loop_x][loop_y][loop_z] == 0) {
    447447                    polySum += poly->coeff[loop_x][loop_y][loop_z] *
    … …  
    477477    psF64 tSum = 1.0;
    478478
    479     for (loop_x = 0; loop_x < (1 + poly->COOL_4D_nX); loop_x++) {
     479    for (loop_x = 0; loop_x < (1 + poly->nX); loop_x++) {
    480480        ySum = xSum;
    481         for (loop_y = 0; loop_y < (1 + poly->COOL_4D_nY); loop_y++) {
     481        for (loop_y = 0; loop_y < (1 + poly->nY); loop_y++) {
    482482            zSum = ySum;
    483             for (loop_z = 0; loop_z < (1 + poly->COOL_4D_nZ); loop_z++) {
     483            for (loop_z = 0; loop_z < (1 + poly->nZ); loop_z++) {
    484484                tSum = zSum;
    485                 for (loop_t = 0; loop_t < (1 + poly->COOL_4D_nT); loop_t++) {
     485                for (loop_t = 0; loop_t < (1 + poly->nT); loop_t++) {
    486486                    if (poly->mask[loop_x][loop_y][loop_z][loop_t] == 0) {
    487487                        polySum += tSum * poly->coeff[loop_x][loop_y][loop_z][loop_t];
    … …  
    520520    // Determine how many Chebyshev polynomials
    521521    // are needed, then create them.
    522     maxChebyPoly = poly->COOL_4D_nX;
    523     if (poly->COOL_4D_nY > maxChebyPoly) {
    524         maxChebyPoly = poly->COOL_4D_nY;
    525     }
    526     if (poly->COOL_4D_nZ > maxChebyPoly) {
    527         maxChebyPoly = poly->COOL_4D_nZ;
    528     }
    529     if (poly->COOL_4D_nT > maxChebyPoly) {
    530         maxChebyPoly = poly->COOL_4D_nT;
     522    maxChebyPoly = poly->nX;
     523    if (poly->nY > maxChebyPoly) {
     524        maxChebyPoly = poly->nY;
     525    }
     526    if (poly->nZ > maxChebyPoly) {
     527        maxChebyPoly = poly->nZ;
     528    }
     529    if (poly->nT > maxChebyPoly) {
     530        maxChebyPoly = poly->nT;
    531531    }
    532532    // XXX: Add 1 since createChebyshevPolys() takes nTerms, not nOrder.
    533533    chebPolys = createChebyshevPolys(maxChebyPoly + 1);
    534534
    535     for (loop_x = 0; loop_x < (1 + poly->COOL_4D_nX); loop_x++) {
    536         for (loop_y = 0; loop_y < (1 + poly->COOL_4D_nY); loop_y++) {
    537             for (loop_z = 0; loop_z < (1 + poly->COOL_4D_nZ); loop_z++) {
    538                 for (loop_t = 0; loop_t < (1 + poly->COOL_4D_nT); loop_t++) {
     535    for (loop_x = 0; loop_x < (1 + poly->nX); loop_x++) {
     536        for (loop_y = 0; loop_y < (1 + poly->nY); loop_y++) {
     537            for (loop_z = 0; loop_z < (1 + poly->nZ); loop_z++) {
     538                for (loop_t = 0; loop_t < (1 + poly->nT); loop_t++) {
    539539                    if (poly->mask[loop_x][loop_y][loop_z][loop_t] == 0) {
    540540                        polySum += poly->coeff[loop_x][loop_y][loop_z][loop_t] *
    … …  
    627627
    628628    newPoly->type = type;
    629     newPoly->COOL_1D_n = n;
     629    newPoly->nX = n;
    630630    newPoly->coeff = psAlloc((n + 1) * sizeof(psF64));
    631631    newPoly->coeffErr = psAlloc((n + 1) * sizeof(psF64));
    … …  
    655655
    656656    newPoly->type = type;
    657     newPoly->COOL_2D_nX = nX;
    658     newPoly->COOL_2D_nY = nY;
     657    newPoly->nX = nX;
     658    newPoly->nY = nY;
    659659
    660660    newPoly->coeff = psAlloc((1 + nX) * sizeof(psF64 *));
    … …  
    695695
    696696    newPoly->type = type;
    697     newPoly->COOL_3D_nX = nX;
    698     newPoly->COOL_3D_nY = nY;
    699     newPoly->COOL_3D_nZ = nZ;
     697    newPoly->nX = nX;
     698    newPoly->nY = nY;
     699    newPoly->nZ = nZ;
    700700
    701701    newPoly->coeff = psAlloc((nX + 1) * sizeof(psF64 **));
    … …  
    746746
    747747    newPoly->type = type;
    748     newPoly->COOL_4D_nX = nX;
    749     newPoly->COOL_4D_nY = nY;
    750     newPoly->COOL_4D_nZ = nZ;
    751     newPoly->COOL_4D_nT = nT;
     748    newPoly->nX = nX;
     749    newPoly->nY = nY;
     750    newPoly->nZ = nZ;
     751    newPoly->nT = nT;
    752752
    753753    newPoly->coeff = psAlloc((nX + 1) * sizeof(psF64 ***));

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

    r5090 r5294  
    1111 *  @author GLG, MHPCC
    1212 *
    13  *  @version $Revision: 1.57 $ $Name: not supported by cvs2svn $
    14  *  @date $Date: 2005-09-22 02:47:16 $
     13 *  @version $Revision: 1.58 $ $Name: not supported by cvs2svn $
     14 *  @date $Date: 2005-10-12 21:02:20 $
    1515 *
    1616 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    7676{
    7777    psPolynomialType type;              ///< Polynomial type
    78     unsigned int COOL_1D_n;             ///< Polynomial order
     78    unsigned int nX;             ///< Polynomial order
    7979    psF64 *coeff;                       ///< Coefficients
    8080    psF64 *coeffErr;                    ///< Error in coefficients
    … …  
    9090{
    9191    psPolynomialType type;              ///< Polynomial type
    92     unsigned int COOL_2D_nX;            ///< Polynomial order in x
    93     unsigned int COOL_2D_nY;            ///< Polynomial order in y
     92    unsigned int nX;            ///< Polynomial order in x
     93    unsigned int nY;            ///< Polynomial order in y
    9494    psF64 **coeff;                      ///< Coefficients
    9595    psF64 **coeffErr;                   ///< Error in coefficients
    … …  
    105105{
    106106    psPolynomialType type;              ///< Polynomial type
    107     unsigned int COOL_3D_nX;            ///< Polynomial order in x
    108     unsigned int COOL_3D_nY;            ///< Polynomial order in y
    109     unsigned int COOL_3D_nZ;            ///< Polynomial order in z
     107    unsigned int nX;            ///< Polynomial order in x
     108    unsigned int nY;            ///< Polynomial order in y
     109    unsigned int nZ;            ///< Polynomial order in z
    110110    psF64 ***coeff;                     ///< Coefficients
    111111    psF64 ***coeffErr;                  ///< Error in coefficients
    … …  
    121121{
    122122    psPolynomialType type;              ///< Polynomial type
    123     unsigned int COOL_4D_nX;            ///< Polynomial order in x
    124     unsigned int COOL_4D_nY;            ///< Polynomial order in y
    125     unsigned int COOL_4D_nZ;            ///< Polynomial order in z
    126     unsigned int COOL_4D_nT;            ///< Polynomial order in t
     123    unsigned int nX;            ///< Polynomial order in x
     124    unsigned int nY;            ///< Polynomial order in y
     125    unsigned int nZ;            ///< Polynomial order in z
     126    unsigned int nT;            ///< Polynomial order in t
    127127    psF64 ****coeff;                    ///< Coefficients
    128128    psF64 ****coeffErr;                 ///< Error in coefficients
Note: See TracChangeset for help on using the changeset viewer.