IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

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

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

File:
1 edited

Legend:

Unmodified
Added
Removed

  • 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 ***));
Note: See TracChangeset for help on using the changeset viewer.