IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 5090


Ignore:
Timestamp:
Sep 21, 2005, 4:47:16 PM (21 years ago)
Author:
gusciora
Message:

The nX terms for the polynomials now refer to the order, not the number
of terms.

Location:
trunk/psLib
Files:
19 edited

Legend:

Unmodified
Added
Removed

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

    r4991 r5090  
    1010*  @author GLG, MHPCC
    1111*
    12 *  @version $Revision: 1.86 $ $Name: not supported by cvs2svn $
    13 *  @date $Date: 2005-09-11 22:18:40 $
     12*  @version $Revision: 1.87 $ $Name: not supported by cvs2svn $
     13*  @date $Date: 2005-09-22 02:47:16 $
    1414*
    1515*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    9090
    9191    A = transform->x->coeff[0][0];
    92     if (transform->x->nX >= 2) {
     92    if (transform->x->COOL_2D_nX >= 1) {
    9393        B = transform->x->coeff[1][0];
    9494    }
    95     if (transform->x->nY >= 2) {
     95    if (transform->x->COOL_2D_nY >= 1) {
    9696        C = transform->x->coeff[0][1];
    9797    }
    9898    D = transform->y->coeff[0][0];
    99     if (transform->y->nX >= 2) {
     99    if (transform->y->COOL_2D_nX >= 1) {
    100100        E = transform->y->coeff[1][0];
    101101    }
    102     if (transform->y->nY >= 2) {
     102    if (transform->y->COOL_2D_nY >= 1) {
    103103        F = transform->y->coeff[0][1];
    104104    }
    … …  
    154154    PS_ASSERT_PTR_NON_NULL(transform->y, 0);
    155155
    156     for (psS32 i=0;i<(transform->x->nX);i++) {
    157         for (psS32 j=0;j<(transform->x->nY);j++) {
     156    for (psS32 i=0;i<(1 + transform->x->COOL_2D_nX);i++) {
     157        for (psS32 j=0;j<(1 + transform->x->COOL_2D_nY);j++) {
    158158            if (transform->x->coeff[i][j] != 0.0) {
    159159                if (!(((i == 0) && (j == 0)) ||
    … …  
    166166    }
    167167
    168     for (psS32 i=0;i<(transform->y->nX);i++) {
    169         for (psS32 j=0;j<(transform->y->nY);j++) {
     168    for (psS32 i=0;i<(1 + transform->y->COOL_2D_nX);i++) {
     169        for (psS32 j=0;j<(1 + transform->y->COOL_2D_nY);j++) {
    170170            if (transform->y->coeff[i][j] != 0.0) {
    171171                if (!(((i == 0) && (j == 0)) ||
    … …  
    208208}
    209209
     210// XXX: Verify the order/nterms poly changes
    210211psPlaneTransform* psPlaneTransformAlloc(int n1, int n2)
    211212{
    … …  
    214215
    215216    psPlaneTransform *pt = psAlloc(sizeof(psPlaneTransform));
    216     pt->x = psPolynomial2DAlloc(n1, n2, PS_POLYNOMIAL_ORD);
    217     pt->y = psPolynomial2DAlloc(n1, n2, PS_POLYNOMIAL_ORD);
     217    pt->x = psPolynomial2DAlloc(n1-1, n2-1, PS_POLYNOMIAL_ORD);
     218    pt->y = psPolynomial2DAlloc(n1-1, n2-1, PS_POLYNOMIAL_ORD);
    218219
    219220    psMemSetDeallocator(pt, (psFreeFunc) planeTransformFree);
    … …  
    276277}
    277278
     279// XXX: Verify the order/nterms poly changes
    278280psPlaneDistort* psPlaneDistortAlloc(int n1, int n2, int n3, int n4)
    279281{
    … …  
    284286
    285287    psPlaneDistort *pt = psAlloc(sizeof(psPlaneDistort));
    286     pt->x = psPolynomial4DAlloc(n1, n2, n3, n4, PS_POLYNOMIAL_ORD);
    287     pt->y = psPolynomial4DAlloc(n1, n2, n3, n4, PS_POLYNOMIAL_ORD);
     288    pt->x = psPolynomial4DAlloc(n1-1, n2-1, n3-1, n4-1, PS_POLYNOMIAL_ORD);
     289    pt->y = psPolynomial4DAlloc(n1-1, n2-1, n3-1, n4-1, PS_POLYNOMIAL_ORD);
    288290
    289291    psMemSetDeallocator(pt, (psFreeFunc) planeDistortFree);
    … …  
    499501                                       psPolynomial2D *trans2)
    500502{
    501     //TRACE: printf("multiplyDPoly2D(%d %d: %d %d)\n", trans1->nX, trans1->nY, trans2->nX, trans2->nY);
    502     psS32 orderX = (trans1->nX + trans2->nX) - 1;
    503     psS32 orderY = (trans1->nY + trans2->nY) - 1;
    504 
    505     psPolynomial2D *out = psPolynomial2DAlloc(orderX, orderY, PS_POLYNOMIAL_ORD);
     503    //TRACE: printf("multiplyDPoly2D(%d %d: %d %d)\n", trans1->COOL_2D_nX, trans1->COOL_2D_nY, trans2->COOL_2D_nX, trans2->COOL_2D_nY);
     504    // XXX: OLD:  psS32 orderX = (trans1->nX + trans2->nX) - 1;
     505    // XXX: Verify this (the poly order change)
     506    psS32 orderX = trans1->COOL_2D_nX + trans2->COOL_2D_nX + 1;
     507    psS32 orderY = trans1->COOL_2D_nY + trans2->COOL_2D_nY + 1;
     508
     509    // XXX: Verify this (the poly order change)
     510    psPolynomial2D *out = psPolynomial2DAlloc(orderX-1, orderY-1, PS_POLYNOMIAL_ORD);
    506511    //TRACE: printf("Creating poly (%d, %d)\n", orderX, orderY);
    507     for (psS32 i = 0 ; i < out->nX; i++) {
    508         for (psS32 j = 0 ; j < out->nY; j++) {
     512    for (psS32 i = 0 ; i < (1 + out->COOL_2D_nX); i++) {
     513        for (psS32 j = 0 ; j < (1 + out->COOL_2D_nY); j++) {
    509514            out->coeff[i][j] = 0.0;
    510515            out->mask[i][j] = 0;
    … …  
    512517    }
    513518
    514     for (psS32 t1x = 0 ; t1x < trans1->nX ; t1x++) {
    515         for (psS32 t1y = 0 ; t1y < trans1->nY ; t1y++) {
     519    for (psS32 t1x = 0 ; t1x < (1 + trans1->COOL_2D_nX) ; t1x++) {
     520        for (psS32 t1y = 0 ; t1y < (1 + trans1->COOL_2D_nY) ; t1y++) {
    516521            if (0.0 != trans1->coeff[t1x][t1y]) {
    517                 for (psS32 t2x = 0 ; t2x < trans2->nX ; t2x++) {
    518                     for (psS32 t2y = 0 ; t2y < trans2->nY ; t2y++) {
     522                for (psS32 t2x = 0 ; t2x < (1 + trans2->COOL_2D_nX) ; t2x++) {
     523                    for (psS32 t2y = 0 ; t2y < (1 + trans2->COOL_2D_nY) ; t2y++) {
    519524                        /* Possible debug-only macro which checks these coords?
    520525                        if ((t1x+t2x) >= orderX)
    … …  
    547552    PS_ASSERT_PTR_NON_NULL(trans1, NULL);
    548553    PS_ASSERT_PTR_NON_NULL(trans2, NULL);
    549     //TRACE: printf("psPlaneTransformCombine(%d, %d, %d, %d: %d, %d, %d, %d)\n", trans1->x->nX, trans1->x->nY, trans1->y->nX, trans1->y->nY, trans2->x->nX, trans2->x->nY, trans2->y->nX, trans2->y->nY);
     554    //TRACE: printf("psPlaneTransformCombine(%d, %d, %d, %d: %d, %d, %d, %d)\n", trans1->x->COOL_2D_nX, trans1->x->COOL_2D_nY, trans1->y->COOL_2D_nX, trans1->y->COOL_2D_nY, trans2->x->COOL_2D_nX, trans2->x->COOL_2D_nY, trans2->y->COOL_2D_nX, trans2->y->COOL_2D_nY);
    550555    //
    551556    // Determine the size of the new psPlaneTransform.
    … …  
    553558    // PS_MAX(  Number of x terms in T2->x * number of x terms in T1->x,
    554559    //          Number of y terms in T2->x * number of x terms in T1->y,
    555     psS32 orderXnX = PS_MAX((trans2->x->nX * trans1->x->nX),
    556                             (trans2->x->nY * trans1->y->nX));
    557     psS32 orderXnY = PS_MAX((trans2->x->nX * trans1->x->nY),
    558                             (trans2->x->nY * trans1->y->nY));
    559 
    560     psS32 orderYnX = PS_MAX((trans2->y->nX * trans1->x->nX),
    561                             (trans2->y->nY * trans1->y->nX));
    562     psS32 orderYnY = PS_MAX((trans2->y->nX * trans1->x->nY),
    563                             (trans2->y->nY * trans1->y->nY));
     560    psS32 orderXnX = PS_MAX(((1 + trans2->x->COOL_2D_nX) * (1 + trans1->x->COOL_2D_nX)),
     561                            ((1 + trans2->x->COOL_2D_nY) * (1 + trans1->y->COOL_2D_nX)));
     562    psS32 orderXnY = PS_MAX(((1 + trans2->x->COOL_2D_nX) * (1 + trans1->x->COOL_2D_nY)),
     563                            ((1 + trans2->x->COOL_2D_nY) * (1 + trans1->y->COOL_2D_nY)));
     564
     565    psS32 orderYnX = PS_MAX(((1 + trans2->y->COOL_2D_nX) * (1 + trans1->x->COOL_2D_nX)),
     566                            ((1 + trans2->y->COOL_2D_nY) * (1 + trans1->y->COOL_2D_nX)));
     567    psS32 orderYnY = PS_MAX(((1 + trans2->y->COOL_2D_nX) * (1 + trans1->x->COOL_2D_nY)),
     568                            ((1 + trans2->y->COOL_2D_nY) * (1 + trans1->y->COOL_2D_nY)));
    564569    psS32 orderX = PS_MAX(orderXnX, orderYnX);
    565570    psS32 orderY = PS_MAX(orderXnY, orderYnY);
    … …  
    568573    // Allocate the new psPlaneTransform, if necessary.
    569574    //
     575    // XXX: rename, or verify, or recode, after the poly norder/nterm change.
    570576    psPlaneTransform *myPT = NULL;
    571577    if (out == NULL) {
    572578        myPT = psPlaneTransformAlloc(orderX, orderY);
    573579    } else {
    574         if ((out->x->nX == orderX) && (out->x->nY == orderY) &&
    575                 (out->y->nX == orderX) && (out->y->nY == orderY)) {
     580        if (((1 + out->x->COOL_2D_nX) == orderX) && ((1 + out->x->COOL_2D_nY) == orderY) &&
     581                ((1 + out->y->COOL_2D_nX) == orderX) && ((1 + out->y->COOL_2D_nY) == orderY)) {
    576582            myPT = out;
    577583        } else {
    … …  
    603609    //
    604610
    605     for (psS32 t2x = 0 ; t2x < trans2->x->nX ; t2x++) {
    606         for (psS32 t2y = 0 ; t2y < trans2->x->nY ; t2y++) {
    607             psPolynomial2D *currPoly = psPolynomial2DAlloc(1, 1, PS_POLYNOMIAL_ORD);
     611    for (psS32 t2x = 0 ; t2x < (1 + trans2->x->COOL_2D_nX) ; t2x++) {
     612        for (psS32 t2y = 0 ; t2y < (1 + trans2->x->COOL_2D_nX) ; t2y++) {
     613            // XXX: Verify this (poly order/nterm change)
     614            psPolynomial2D *currPoly = psPolynomial2DAlloc(1-1, 1-1, PS_POLYNOMIAL_ORD);
    608615
    609616            currPoly->coeff[0][0] = 1.0;
    … …  
    627634
    628635                // Set the appropriate coeffs in myPT->x
    629                 for (psS32 i = 0 ; i < currPoly->nX ; i++) {
    630                     for (psS32 j = 0 ; j < currPoly->nY ; j++) {
     636                for (psS32 i = 0 ; i < (1 + currPoly->COOL_2D_nX) ; i++) {
     637                    for (psS32 j = 0 ; j < (1 + currPoly->COOL_2D_nY) ; j++) {
    631638                        myPT->x->coeff[i][j]+= currPoly->coeff[i][j] * trans2->x->coeff[t2x][t2y];
    632639                    }
    … …  
    638645
    639646
    640     for (psS32 t2x = 0 ; t2x < trans2->y->nX ; t2x++) {
    641         for (psS32 t2y = 0 ; t2y < trans2->y->nY ; t2y++) {
    642             psPolynomial2D *currPoly = psPolynomial2DAlloc(1, 1, PS_POLYNOMIAL_ORD);
     647    for (psS32 t2x = 0 ; t2x < (1 + trans2->y->COOL_2D_nX) ; t2x++) {
     648        for (psS32 t2y = 0 ; t2y < (1 + trans2->y->COOL_2D_nY) ; t2y++) {
     649            // XXX: Verify this (poly order/nterm change)
     650            psPolynomial2D *currPoly = psPolynomial2DAlloc(1-1, 1-1, PS_POLYNOMIAL_ORD);
    643651            currPoly->coeff[0][0] = 1.0;
    644652            currPoly->mask[0][0] = 0;
    … …  
    662670
    663671                // Set the appropriate coeffs in myPT->x
    664                 for (psS32 i = 0 ; i < currPoly->nX ; i++) {
    665                     for (psS32 j = 0 ; j < currPoly->nY ; j++) {
     672                for (psS32 i = 0 ; i < (1 + currPoly->COOL_2D_nX) ; i++) {
     673                    for (psS32 j = 0 ; j < (1 + currPoly->COOL_2D_nY) ; j++) {
    666674                        myPT->y->coeff[i][j]+= currPoly->coeff[i][j] * trans2->y->coeff[t2x][t2y];
    667675                    }
    … …  
    694702
    695703    psS32 numCoords = PS_MIN(source->n, dest->n);
    696     psS32 order = PS_MAX(trans->x->nX, trans->x->nY);
    697     order = PS_MAX(order, trans->y->nX);
    698     order = PS_MAX(order, trans->y->nY);
     704    psS32 order = PS_MAX(trans->x->COOL_2D_nX, trans->x->COOL_2D_nY);
     705    order = PS_MAX(order, trans->y->COOL_2D_nX);
     706    order = PS_MAX(order, trans->y->COOL_2D_nY);
     707    // XXX: Verify, or recode, after the poly norder/nterm change.
     708    order++;
    699709
    700710    //
    701711    // Create fake polynomial to use in evaluation
    702712    //
    703     psPolynomial2D *fakePoly = psPolynomial2DAlloc(order, order, PS_POLYNOMIAL_ORD);
     713    // XXX: Verify this (poly order/nterm change)
     714    psPolynomial2D *fakePoly = psPolynomial2DAlloc(order-1, order-1, PS_POLYNOMIAL_ORD);
    704715    for (int i = 0; i < order; i++) {
    705716        for (int j = 0; j < order; j++) {
    … …  
    811822
    812823    // Ensure that the input transformation is symmetrical.
    813     if ((in->x->nX != in->x->nY) ||
    814             (in->y->nX != in->y->nY) ||
    815             (in->x->nX != in->y->nX)) {
     824    if ((in->x->COOL_2D_nX != in->x->COOL_2D_nY) ||
     825            (in->y->COOL_2D_nX != in->y->COOL_2D_nY) ||
     826            (in->x->COOL_2D_nX != in->y->COOL_2D_nX)) {
    816827        psError(PS_ERR_BAD_PARAMETER_TYPE, true, "Input transformation must have same nX==nY.");
    817828    }
    818     psS32 order = in->x->nX;
     829    // XXX: recode or verify after poly changes
     830    psS32 order = 1 + in->x->COOL_2D_nX;
    819831
    820832    psPlaneTransform *myPT = NULL;
    … …  
    826838    //
    827839    if (out == NULL) {
     840        // XXX: Verify this (poly order/nterm change)
    828841        myPT = psPlaneTransformAlloc(order, order);
    829842    } else {
    830         if ((out->x->nX == order) && (out->x->nY == order) &&
    831                 (out->y->nX == order) && (out->y->nY == order)) {
     843        // XXX: recode or verify after poly changes
     844        if (((1 + out->x->COOL_2D_nX) == order) && ((1 + out->x->COOL_2D_nY) == order) &&
     845                ((1 + out->y->COOL_2D_nX) == order) && ((1 + out->y->COOL_2D_nX) == order)) {
    832846            myPT = out;
    833847        } else {
    … …  
    840854    // Copy the input transform to myPT.
    841855    //
    842     for (psS32 i = 0 ; i < in->x->nX ; i++) {
    843         for (psS32 j = 0 ; j < in->x->nY ; j++) {
     856    for (psS32 i = 0 ; i < (1 + in->x->COOL_2D_nX) ; i++) {
     857        for (psS32 j = 0 ; j < (1 + in->x->COOL_2D_nY) ; j++) {
    844858            myPT->x->coeff[i][j] = in->x->coeff[i][j];
    845859        }
    846860    }
    847     for (psS32 i = 0 ; i < in->y->nX ; i++) {
    848         for (psS32 j = 0 ; j < in->y->nY ; j++) {
     861    for (psS32 i = 0 ; i < (1 + in->y->COOL_2D_nX) ; i++) {
     862        for (psS32 j = 0 ; j < (1 + in->y->COOL_2D_nY) ; j++) {
    849863            myPT->y->coeff[i][j] = in->y->coeff[i][j];
    850864        }
    … …  
    926940
    927941    // This loop starts at loop_x=1 since the derivative of the loop_x=0 terms are all 0.0
    928     for (psS32 loop_x = 1; loop_x < xPoly->nX; loop_x++) {
     942    for (psS32 loop_x = 1; loop_x < (1 + xPoly->COOL_2D_nX); loop_x++) {
    929943        ySum = 1.0;
    930         for (psS32 loop_y = 0; loop_y < xPoly->nY; loop_y++) {
     944        for (psS32 loop_y = 0; loop_y < (1 + xPoly->COOL_2D_nY); loop_y++) {
    931945            //
    932946            // For each iteration of the loop, we multiple the (x, y) coefficient
    … …  
    946960
    947961    // This loop starts at loop_y=1 since the derivative of the loop_y=0 terms are all 0.0
    948     for (psS32 loop_x = 0; loop_x < yPoly->nX; loop_x++) {
     962    for (psS32 loop_x = 0; loop_x < (1 + yPoly->COOL_2D_nX); loop_x++) {
    949963        ySum = 1.0;
    950         for (psS32 loop_y = 1; loop_y < yPoly->nY; loop_y++) {
     964        for (psS32 loop_y = 1; loop_y < (1 + yPoly->COOL_2D_nY); loop_y++) {
    951965            //
    952966            // For each iteration of the loop, we multiple the (x, y) coefficient

  • trunk/psLib/src/imageops/psImageStats.c

    r5089 r5090  
    99 *  @author GLG, MHPCC
    1010 *
    11  *  @version $Revision: 1.78 $ $Name: not supported by cvs2svn $
    12  *  @date $Date: 2005-09-22 02:32:00 $
     11 *  @version $Revision: 1.79 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2005-09-22 02:47:16 $
    1313 *
    1414 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    224224    chebPolys = (psPolynomial1D **) psAlloc(maxChebyPoly * sizeof(psPolynomial1D *));
    225225    for (i = 0; i < maxChebyPoly; i++) {
    226         chebPolys[i] = psPolynomial1DAlloc(i + 1, PS_POLYNOMIAL_ORD);
     226        // XXX: verify this, poly nOrder/nTerms change.
     227        chebPolys[i] = psPolynomial1DAlloc(i, PS_POLYNOMIAL_ORD);
    227228    }
    228229
    … …  
    232233    chebPolys[1]->coeff[1] = 1;
    233234    for (i = 2; i < maxChebyPoly; i++) {
    234         for (j = 0; j < chebPolys[i - 1]->n; j++) {
     235        for (j = 0; j < (1 + chebPolys[i - 1]->COOL_1D_n); j++) {
    235236            chebPolys[i]->coeff[j + 1] = 2 * chebPolys[i - 1]->coeff[j];
    236237        }
    237         for (j = 0; j < chebPolys[i - 2]->n; j++) {
     238        for (j = 0; j < (1 + chebPolys[i - 2]->COOL_1D_n); j++) {
    238239            chebPolys[i]->coeff[j] -= chebPolys[i - 2]->coeff[j];
    239240        }
    … …  
    290291    // 29 in the ADD: sums[k][l] = SUM {
    291292    // image(x,y) * Tk(x) * Tl(y) }
    292     sums = (double **)psAlloc(coeffs->nX * sizeof(double *));
    293     for (i = 0; i < coeffs->nX; i++) {
    294         sums[i] = (double *)psAlloc(coeffs->nY * sizeof(double));
     293    sums = (double **)psAlloc((1 + coeffs->COOL_2D_nX) * sizeof(double *));
     294    for (i = 0; i < (1 + coeffs->COOL_2D_nX); i++) {
     295        sums[i] = (double *)psAlloc((1 + coeffs->COOL_2D_nY) * sizeof(double));
    295296    }
    296297    // We scale the pixel positions to values
    … …  
    301302    // Determine how many Chebyshev polynomials
    302303    // are needed, then create them.
    303     maxChebyPoly = coeffs->nX;
    304     if (coeffs->nY > coeffs->nX) {
    305         maxChebyPoly = coeffs->nY;
    306     }
    307     chebPolys = p_psCreateChebyshevPolys(maxChebyPoly);
     304    // XXX: recorde or verify the poly order/nterm change
     305    maxChebyPoly = coeffs->COOL_2D_nX;
     306    if (coeffs->COOL_2D_nY > coeffs->COOL_2D_nX) {
     307        maxChebyPoly = coeffs->COOL_2D_nY;
     308    }
     309    chebPolys = p_psCreateChebyshevPolys(maxChebyPoly + 1);
    308310
    309311    // Compute the sums[][] data structure.
    310     for (i = 0; i < coeffs->nX; i++) {
    311         for (j = 0; j < coeffs->nY; j++) {
     312    for (i = 0; i < (1 + coeffs->COOL_2D_nX); i++) {
     313        for (j = 0; j < (1 + coeffs->COOL_2D_nY); j++) {
    312314            sums[i][j] = 0.0;
    313315            for (x = 0; x < input->numRows; x++) {
    … …  
    330332    }
    331333
    332     for (i = 0; i < coeffs->nX; i++) {
    333         for (j = 0; j < coeffs->nY; j++) {
     334    for (i = 0; i < (1 + coeffs->COOL_2D_nX); i++) {
     335        for (j = 0; j < (1 + coeffs->COOL_2D_nY); j++) {
    334336            coeffs->coeff[i][j] = sums[i][j];
    335337            coeffs->coeff[i][j] /= (double)(input->numRows * input->numCols);
    … …  
    353355
    354356    // Free some data
    355     for (i = 0; i < coeffs->nX; i++) {
     357    for (i = 0; i < (1 + coeffs->COOL_2D_nX); i++) {
    356358        psFree(sums[i]);
    357359    }
    … …  
    436438    // 29 in the ADD: sums[k][l] = SUM {
    437439    // image(x,y) * Tk(x) * Tl(y) }
    438     sums = (double **)psAlloc(coeffs->nX * sizeof(double *));
    439     for (i = 0; i < coeffs->nX; i++) {
    440         sums[i] = (double *)psAlloc(coeffs->nY * sizeof(double));
     440    sums = (double **)psAlloc((1 + coeffs->COOL_2D_nX) * sizeof(double *));
     441    for (i = 0; i < (1 + coeffs->COOL_2D_nX); i++) {
     442        sums[i] = (double *)psAlloc((1 + coeffs->COOL_2D_nY) * sizeof(double));
    441443    }
    442444    // We scale the pixel positions to values
    … …  
    447449    // Determine how many Chebyshev polynomials
    448450    // are needed, then create them.
    449     maxChebyPoly = coeffs->nX;
    450     if (coeffs->nY > coeffs->nX) {
    451         maxChebyPoly = coeffs->nY;
    452     }
    453     chebPolys = p_psCreateChebyshevPolys(maxChebyPoly);
     451    maxChebyPoly = coeffs->COOL_2D_nX;
     452    if (coeffs->COOL_2D_nY > coeffs->COOL_2D_nX) {
     453        maxChebyPoly = coeffs->COOL_2D_nY;
     454    }
     455    chebPolys = 1 + p_psCreateChebyshevPolys(maxChebyPoly);
    454456
    455457    // Compute the sums[][] data structure.
    456     for (i = 0; i < coeffs->nX; i++) {
    457         for (j = 0; j < coeffs->nY; j++) {
     458    for (i = 0; i < (1 + coeffs->COOL_2D_nX); i++) {
     459        for (j = 0; j < (1 + coeffs->COOL_2D_nY); j++) {
    458460            sums[i][j] = 0.0;
    459461            for (x = 0; x < input->numRows; x++) {
    … …  
    479481    }
    480482
    481     for (i = 0; i < coeffs->nX; i++) {
    482         for (j = 0; j < coeffs->nY; j++) {
     483    for (i = 0; i < (1 + coeffs->COOL_2D_nX); i++) {
     484        for (j = 0; j < (1 + coeffs->COOL_2D_nY); j++) {
    483485            coeffs->coeff[i][j] = sums[i][j];
    484486            coeffs->coeff[i][j] /= (double)(input->numRows * input->numCols);
    … …  
    502504
    503505    // Free some data
    504     for (i = 0; i < coeffs->nX; i++) {
     506    for (i = 0; i < (1 + coeffs->COOL_2D_nX); i++) {
    505507        psFree(sums[i]);
    506508    }
    … …  
    538540    // Determine how many Chebyshev polynomials
    539541    // are needed, then create them.
    540     maxChebyPoly = coeffs->nX;
    541     if (coeffs->nY > coeffs->nX) {
    542         maxChebyPoly = coeffs->nY;
    543     }
    544 
    545     chebPolys = p_psCreateChebyshevPolys(maxChebyPoly);
     542    maxChebyPoly = coeffs->COOL_2D_nX;
     543    if (coeffs->COOL_2D_nY > coeffs->COOL_2D_nX) {
     544        maxChebyPoly = coeffs->COOL_2D_nY;
     545    }
     546
     547    chebPolys = 1 + p_psCreateChebyshevPolys(maxChebyPoly);
    546548
    547549    for (x = 0; x < input->numRows; x++) {
    548550        for (y = 0; y < input->numCols; y++) {
    549551            polySum = 0.0;
    550             for (i = 0; i < coeffs->nX; i++) {
    551                 for (j = 0; j < coeffs->nY; j++) {
     552            for (i = 0; i < (1 + coeffs->COOL_2D_nX); i++) {
     553                for (j = 0; j < (1 + coeffs->COOL_2D_nY); j++) {
    552554                    polySum +=
    553555                        psPolynomial1DEval(chebPolys[i], rScalingFactors[x]) *

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

    r5041 r5090  
    1010 *  @author EAM, IfA
    1111 *
    12  *  @version $Revision: 1.138 $ $Name: not supported by cvs2svn $
    13  *  @date $Date: 2005-09-13 21:43:47 $
     12 *  @version $Revision: 1.139 $ $Name: not supported by cvs2svn $
     13 *  @date $Date: 2005-09-22 02:47:16 $
    1414 *
    1515 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    14591459    // XXX: these ASSERTS are redundant.
    14601460    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
    1461     PS_ASSERT_INT_NONNEGATIVE(myPoly->n, NULL);
     1461    PS_ASSERT_INT_NONNEGATIVE(myPoly->COOL_1D_n, NULL);
    14621462    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
    14631463    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F64, NULL);
    … …  
    15231523    fac = 2.0/((psF32) n);
    15241524    // XXX: is this loop bound correct?
    1525     for (j=0;j<myPoly->n;j++) {
     1525    for (j=0;j<myPoly->COOL_1D_n+1;j++) {
    15261526        sum = 0.0;
    15271527        for (k=0;k<n;k++) {
    … …  
    15521552    // XXX: these ASSERTS are redundant.
    15531553    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
    1554     PS_ASSERT_INT_NONNEGATIVE(myPoly->n, NULL);
     1554    PS_ASSERT_INT_NONNEGATIVE(myPoly->COOL_1D_n, NULL);
    15551555    PS_ASSERT_VECTOR_NON_NULL(f, NULL);
    15561556    PS_ASSERT_VECTOR_TYPE(f, PS_TYPE_F64, NULL);
    … …  
    15971597    }
    15981598
    1599     nTerm = myPoly->n;
     1599    nTerm = 1 + myPoly->COOL_1D_n;
    16001600    nOrder = nTerm - 1;
    16011601
    … …  
    16971697
    16981698    PS_ASSERT_POLY_NON_NULL(poly, NULL);
    1699     PS_ASSERT_INT_NONNEGATIVE(poly->n, NULL);
     1699    PS_ASSERT_INT_NONNEGATIVE(poly->COOL_1D_n, NULL);
    17001700    PS_ASSERT_VECTOR_NON_NULL(f, NULL);
    17011701    PS_ASSERT_VECTOR_NON_EMPTY(f, NULL);
    … …  
    18371837    // These ASSERTS are redundant.
    18381838    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
    1839     PS_ASSERT_INT_NONNEGATIVE(myPoly->nX, NULL);
    1840     PS_ASSERT_INT_NONNEGATIVE(myPoly->nY, NULL);
     1839    PS_ASSERT_INT_NONNEGATIVE(myPoly->COOL_2D_nX, NULL);
     1840    PS_ASSERT_INT_NONNEGATIVE(myPoly->COOL_2D_nY, NULL);
    18411841
    18421842    PS_ASSERT_VECTOR_NON_NULL(f, NULL);
    … …  
    18651865
    18661866    // XXX:Watch for changes to the psPolys: nTerm != nOrder.
    1867     psS32 nXterm = myPoly->nX;
    1868     psS32 nYterm = myPoly->nY;
     1867    psS32 nXterm = 1 + myPoly->COOL_2D_nX;
     1868    psS32 nYterm = 1 + myPoly->COOL_2D_nY;
    18691869    nTerm = nXterm * nYterm;
    18701870
    … …  
    22642264    // These ASSERTS are redundant.
    22652265    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
    2266     PS_ASSERT_INT_NONNEGATIVE(myPoly->nX, NULL);
    2267     PS_ASSERT_INT_NONNEGATIVE(myPoly->nY, NULL);
    2268     PS_ASSERT_INT_NONNEGATIVE(myPoly->nZ, NULL);
     2266    PS_ASSERT_INT_NONNEGATIVE(myPoly->COOL_3D_nX, NULL);
     2267    PS_ASSERT_INT_NONNEGATIVE(myPoly->COOL_3D_nY, NULL);
     2268    PS_ASSERT_INT_NONNEGATIVE(myPoly->COOL_3D_nZ, NULL);
    22692269
    22702270    PS_ASSERT_VECTOR_NON_NULL(f, NULL);
    … …  
    25272527    // These ASSERTS are redundant.
    25282528    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
    2529     PS_ASSERT_INT_NONNEGATIVE(myPoly->nX, NULL);
    2530     PS_ASSERT_INT_NONNEGATIVE(myPoly->nY, NULL);
    2531     PS_ASSERT_INT_NONNEGATIVE(myPoly->nZ, NULL);
    2532     PS_ASSERT_INT_NONNEGATIVE(myPoly->nT, NULL);
     2529    PS_ASSERT_INT_NONNEGATIVE(myPoly->COOL_4D_nX, NULL);
     2530    PS_ASSERT_INT_NONNEGATIVE(myPoly->COOL_4D_nY, NULL);
     2531    PS_ASSERT_INT_NONNEGATIVE(myPoly->COOL_4D_nZ, NULL);
     2532    PS_ASSERT_INT_NONNEGATIVE(myPoly->COOL_4D_nT, NULL);
    25332533    PS_ASSERT_VECTOR_NON_NULL(f, NULL);
    25342534    PS_ASSERT_VECTOR_TYPE(f, PS_TYPE_F64, NULL);

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

    r5074 r5090  
    77*  polynomials.  It also contains a Gaussian functions.
    88*
    9 *  @version $Revision: 1.122 $ $Name: not supported by cvs2svn $
    10 *  @date $Date: 2005-09-20 20:48:35 $
     9*  @version $Revision: 1.123 $ $Name: not supported by cvs2svn $
     10*  @date $Date: 2005-09-22 02:47:16 $
    1111*
    1212*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    9595    unsigned int x = 0;
    9696
    97     for (x = 0; x < poly->nX; x++) {
     97    for (x = 0; x < poly->COOL_2D_nX; x++) {
    9898        psFree(poly->coeff[x]);
    9999        psFree(poly->coeffErr[x]);
    … …  
    110110    unsigned int y = 0;
    111111
    112     for (x = 0; x < poly->nX; x++) {
    113         for (y = 0; y < poly->nY; y++) {
     112    for (x = 0; x < poly->COOL_3D_nX; x++) {
     113        for (y = 0; y < poly->COOL_3D_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 < poly->nX; x++) {
    135         for (y = 0; y < poly->nY; y++) {
    136             for (z = 0; z < poly->nZ; z++) {
     134    for (x = 0; x < poly->COOL_4D_nX; x++) {
     135        for (y = 0; y < poly->COOL_4D_nY; y++) {
     136            for (z = 0; z < poly->COOL_4D_nZ; z++) {
    137137                psFree(poly->coeff[x][y][z]);
    138138                psFree(poly->coeffErr[x][y][z]);
    … …  
    170170    chebPolys = (psPolynomial1D **) psAlloc(maxChebyPoly * sizeof(psPolynomial1D *));
    171171    for (unsigned int i = 0; i < maxChebyPoly; i++) {
    172         chebPolys[i] = psPolynomial1DAlloc(i + 1, PS_POLYNOMIAL_ORD);
     172        chebPolys[i] = psPolynomial1DAlloc(i, PS_POLYNOMIAL_ORD);
    173173    }
    174174
    … …  
    182182
    183183        for (psS32 i = 2; i < maxChebyPoly; i++) {
    184             for (psS32 j = 0; j < chebPolys[i - 1]->n; j++) {
     184            for (psS32 j = 0; j < chebPolys[i - 1]->COOL_1D_n; j++) {
    185185                chebPolys[i]->coeff[j + 1] = 2 * chebPolys[i - 1]->coeff[j];
    186186            }
    187             for (psS32 j = 0; j < chebPolys[i - 2]->n; j++) {
     187            for (psS32 j = 0; j < chebPolys[i - 2]->COOL_1D_n; j++) {
    188188                chebPolys[i]->coeff[j] -= chebPolys[i - 2]->coeff[j];
    189189            }
    … …  
    210210            "---- Calling ordPolynomial1DEval(%lf)\n", x);
    211211    psTrace(".psLib.dataManip.psPolynomial.ordPolynomial1DEval", 4,
    212             "Polynomial order is %u\n", poly->n);
    213     for (loop_x = 0; loop_x < poly->n; loop_x++) {
     212            "Polynomial order is %u\n", poly->COOL_1D_n);
     213    for (loop_x = 0; loop_x < poly->COOL_1D_n+1; loop_x++) {
    214214        psTrace(".psLib.dataManip.psPolynomial.ordPolynomial1DEval", 4,
    215215                "Polynomial coeff[%u] is %lf\n", loop_x, poly->coeff[loop_x]);
    216216    }
    217217
    218     for (loop_x = 0; loop_x < poly->n; loop_x++) {
     218    for (loop_x = 0; loop_x < poly->COOL_1D_n+1; loop_x++) {
    219219        if (poly->mask[loop_x] == 0) {
    220220            // XXX: If you set the tracelevel to 10 here, and later set the tracelevel to
    … …  
    238238    PS_ASSERT_DOUBLE_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
    239239    // XXX: Create a macro for this in psConstants.h
    240     if (poly->n < 1) {
    241         psError(PS_ERR_BAD_PARAMETER_VALUE, true, "Error: Chebyshev polynomial as order %u.", poly->n);
     240    if (poly->COOL_1D_n < 1) {
     241        psError(PS_ERR_BAD_PARAMETER_VALUE, true, "Error: Chebyshev polynomial is order %u.", poly->COOL_1D_n);
    242242        return(NAN);
    243243    }
    244244    psVector *d;
    245     unsigned int n = poly->n;
     245    // XXX: n should be nTerms here (for clarity).  Or get rid of the variable.
     246    unsigned int n = 1 + poly->COOL_1D_n;
    246247    unsigned int i;
    247248    psF64 tmp = 0.0;
    … …  
    302303    psPolynomial1D **chebPolys = NULL;
    303304
    304     n = poly->n;
     305    n = 1 + poly->COOL_1D_n;
    305306    chebPolys = createChebyshevPolys(n);
    306307
    307308    tmp = 0.0;
    308     for (i=0;i<poly->n;i++) {
     309    for (i=0;i<(1 + poly->COOL_1D_n);i++) {
    309310        tmp+= (poly->coeff[i] * psPolynomial1DEval(x, chebPolys[i]));
    310311    }
    … …  
    328329    psF64 ySum = 1.0;
    329330
    330     for (loop_x = 0; loop_x < poly->nX; loop_x++) {
     331    for (loop_x = 0; loop_x < (1 + poly->COOL_2D_nX); loop_x++) {
    331332        ySum = xSum;
    332         for (loop_y = 0; loop_y < poly->nY; loop_y++) {
     333        for (loop_y = 0; loop_y < (1 + poly->COOL_2D_nY); loop_y++) {
    333334            if (poly->mask[loop_x][loop_y] == 0) {
    334335                polySum += ySum * poly->coeff[loop_x][loop_y];
    … …  
    359360    // Determine how many Chebyshev polynomials
    360361    // are needed, then create them.
    361     maxChebyPoly = poly->nX;
    362     if (poly->nY > maxChebyPoly) {
    363         maxChebyPoly = poly->nY;
     362    maxChebyPoly = 1 + poly->COOL_2D_nX;
     363    if ((1 + poly->COOL_2D_nY) > maxChebyPoly) {
     364        maxChebyPoly = (1 + poly->COOL_2D_nY);
    364365    }
    365366    chebPolys = createChebyshevPolys(maxChebyPoly);
    366367
    367     for (loop_x = 0; loop_x < poly->nX; loop_x++) {
    368         for (loop_y = 0; loop_y < poly->nY; loop_y++) {
     368    for (loop_x = 0; loop_x < (1 + poly->COOL_2D_nX); loop_x++) {
     369        for (loop_y = 0; loop_y < (1 + poly->COOL_2D_nY); loop_y++) {
    369370            if (poly->mask[loop_x][loop_y] == 0) {
    370371                polySum += poly->coeff[loop_x][loop_y] *
    … …  
    394395    psF64 zSum = 1.0;
    395396
    396     for (loop_x = 0; loop_x < poly->nX; loop_x++) {
     397    for (loop_x = 0; loop_x < (1 + poly->COOL_3D_nX); loop_x++) {
    397398        ySum = xSum;
    398         for (loop_y = 0; loop_y < poly->nY; loop_y++) {
     399        for (loop_y = 0; loop_y < (1 + poly->COOL_3D_nY); loop_y++) {
    399400            zSum = ySum;
    400             for (loop_z = 0; loop_z < poly->nZ; loop_z++) {
     401            for (loop_z = 0; loop_z < (1 + poly->COOL_3D_nZ); loop_z++) {
    401402                if (poly->mask[loop_x][loop_y][loop_z] == 0) {
    402403                    polySum += zSum * poly->coeff[loop_x][loop_y][loop_z];
    … …  
    430431    // Determine how many Chebyshev polynomials
    431432    // are needed, then create them.
    432     maxChebyPoly = poly->nX;
    433     if (poly->nY > maxChebyPoly) {
    434         maxChebyPoly = poly->nY;
    435     }
    436     if (poly->nZ > maxChebyPoly) {
    437         maxChebyPoly = poly->nZ;
    438     }
    439     chebPolys = createChebyshevPolys(maxChebyPoly);
    440 
    441     for (loop_x = 0; loop_x < poly->nX; loop_x++) {
    442         for (loop_y = 0; loop_y < poly->nY; loop_y++) {
    443             for (loop_z = 0; loop_z < poly->nZ; loop_z++) {
     433    maxChebyPoly = poly->COOL_3D_nX;
     434    if (poly->COOL_3D_nY > maxChebyPoly) {
     435        maxChebyPoly = poly->COOL_3D_nY;
     436    }
     437    if (poly->COOL_3D_nZ > maxChebyPoly) {
     438        maxChebyPoly = poly->COOL_3D_nZ;
     439    }
     440    chebPolys = createChebyshevPolys(maxChebyPoly + 1);
     441
     442    for (loop_x = 0; loop_x < (1 + poly->COOL_3D_nX); loop_x++) {
     443        for (loop_y = 0; loop_y < (1 + poly->COOL_3D_nY); loop_y++) {
     444            for (loop_z = 0; loop_z < (1 + poly->COOL_3D_nZ); loop_z++) {
    444445                if (poly->mask[loop_x][loop_y][loop_z] == 0) {
    445446                    polySum += poly->coeff[loop_x][loop_y][loop_z] *
    … …  
    475476    psF64 tSum = 1.0;
    476477
    477     for (loop_x = 0; loop_x < poly->nX; loop_x++) {
     478    for (loop_x = 0; loop_x < (1 + poly->COOL_4D_nX); loop_x++) {
    478479        ySum = xSum;
    479         for (loop_y = 0; loop_y < poly->nY; loop_y++) {
     480        for (loop_y = 0; loop_y < (1 + poly->COOL_4D_nY); loop_y++) {
    480481            zSum = ySum;
    481             for (loop_z = 0; loop_z < poly->nZ; loop_z++) {
     482            for (loop_z = 0; loop_z < (1 + poly->COOL_4D_nZ); loop_z++) {
    482483                tSum = zSum;
    483                 for (loop_t = 0; loop_t < poly->nT; loop_t++) {
     484                for (loop_t = 0; loop_t < (1 + poly->COOL_4D_nT); loop_t++) {
    484485                    if (poly->mask[loop_x][loop_y][loop_z][loop_t] == 0) {
    485486                        polySum += tSum * poly->coeff[loop_x][loop_y][loop_z][loop_t];
    … …  
    518519    // Determine how many Chebyshev polynomials
    519520    // are needed, then create them.
    520     maxChebyPoly = poly->nX;
    521     if (poly->nY > maxChebyPoly) {
    522         maxChebyPoly = poly->nY;
    523     }
    524     if (poly->nZ > maxChebyPoly) {
    525         maxChebyPoly = poly->nZ;
    526     }
    527     if (poly->nT > maxChebyPoly) {
    528         maxChebyPoly = poly->nT;
     521    maxChebyPoly = poly->COOL_4D_nX;
     522    if (poly->COOL_4D_nY > maxChebyPoly) {
     523        maxChebyPoly = poly->COOL_4D_nY;
     524    }
     525    if (poly->COOL_4D_nZ > maxChebyPoly) {
     526        maxChebyPoly = poly->COOL_4D_nZ;
     527    }
     528    if (poly->COOL_4D_nT > maxChebyPoly) {
     529        maxChebyPoly = poly->COOL_4D_nT;
    529530    }
    530531    chebPolys = createChebyshevPolys(maxChebyPoly);
    531532
    532     for (loop_x = 0; loop_x < poly->nX; loop_x++) {
    533         for (loop_y = 0; loop_y < poly->nY; loop_y++) {
    534             for (loop_z = 0; loop_z < poly->nZ; loop_z++) {
    535                 for (loop_t = 0; loop_t < poly->nT; loop_t++) {
     533    for (loop_x = 0; loop_x < (1 + poly->COOL_4D_nX); loop_x++) {
     534        for (loop_y = 0; loop_y < (1 + poly->COOL_4D_nY); loop_y++) {
     535            for (loop_z = 0; loop_z < (1 + poly->COOL_4D_nZ); loop_z++) {
     536                for (loop_t = 0; loop_t < (1 + poly->COOL_4D_nZ); loop_t++) {
    536537                    if (poly->mask[loop_x][loop_y][loop_z][loop_t] == 0) {
    537538                        polySum += poly->coeff[loop_x][loop_y][loop_z][loop_t] *
    … …  
    610611/*****************************************************************************
    611612    This routine must allocate memory for the polynomial structures.
     613    XXX: replaces nterms variables with nOrder.  Lots of potential for bugs
     614         here.  Probably should create separately named private variables
     615         in these functions.
    612616 *****************************************************************************/
    613617psPolynomial1D* psPolynomial1DAlloc(unsigned int n,
    … …  
    623627
    624628    newPoly->type = type;
    625     newPoly->n = n;
     629    newPoly->COOL_1D_n = n;
    626630    newPoly->coeff = psAlloc(n * sizeof(psF64));
    627631    newPoly->coeffErr = psAlloc(n * sizeof(psF64));
    628     newPoly->mask = (psMaskType *)psAlloc(n * sizeof(psMaskType));
    629     for (i = 0; i < n; i++) {
     632    newPoly->mask = (psMaskType *)psAlloc((n + 1) * sizeof(psMaskType));
     633    for (i = 0; i < (n + 1); i++) {
    630634        newPoly->coeff[i] = 0.0;
    631635        newPoly->coeffErr[i] = 0.0;
    … …  
    651655
    652656    newPoly->type = type;
    653     newPoly->nX = nX;
    654     newPoly->nY = nY;
    655 
    656     newPoly->coeff = psAlloc(nX * sizeof(psF64 *));
    657     newPoly->coeffErr = psAlloc(nX * sizeof(psF64 *));
    658     newPoly->mask = (psMaskType **)psAlloc(nX * sizeof(psMaskType *));
    659     for (x = 0; x < nX; x++) {
    660         newPoly->coeff[x] = psAlloc(nY * sizeof(psF64));
    661         newPoly->coeffErr[x] = psAlloc(nY * sizeof(psF64));
    662         newPoly->mask[x] = (psMaskType *)psAlloc(nY * sizeof(psMaskType));
    663     }
    664     for (x = 0; x < nX; x++) {
    665         for (y = 0; y < nY; y++) {
     657    newPoly->COOL_2D_nX = nX;
     658    newPoly->COOL_2D_nY = nY;
     659
     660    newPoly->coeff = psAlloc((1 + nX) * sizeof(psF64 *));
     661    newPoly->coeffErr = psAlloc((1 + nX) * sizeof(psF64 *));
     662    newPoly->mask = (psMaskType **)psAlloc((1 + nX) * sizeof(psMaskType *));
     663    for (x = 0; x < (1 + nX); x++) {
     664        newPoly->coeff[x] = psAlloc((1 + nY) * sizeof(psF64));
     665        newPoly->coeffErr[x] = psAlloc((1 + nY) * sizeof(psF64));
     666        newPoly->mask[x] = (psMaskType *)psAlloc((1 + nY) * sizeof(psMaskType));
     667    }
     668    for (x = 0; x < (1 + nX); x++) {
     669        for (y = 0; y < (1 + nY); y++) {
    666670            newPoly->coeff[x][y] = 0.0;
    667671            newPoly->coeffErr[x][y] = 0.0;
    … …  
    691695
    692696    newPoly->type = type;
    693     newPoly->nX = nX;
    694     newPoly->nY = nY;
    695     newPoly->nZ = nZ;
    696 
    697     newPoly->coeff = psAlloc(nX * sizeof(psF64 **));
    698     newPoly->coeffErr = psAlloc(nX * sizeof(psF64 **));
    699     newPoly->mask = (psMaskType ***)psAlloc(nX * sizeof(psMaskType **));
    700     for (x = 0; x < nX; x++) {
    701         newPoly->coeff[x] = psAlloc(nY * sizeof(psF64 *));
    702         newPoly->coeffErr[x] = psAlloc(nY * sizeof(psF64 *));
    703         newPoly->mask[x] = (psMaskType **)psAlloc(nY * sizeof(psMaskType *));
    704         for (y = 0; y < nY; y++) {
    705             newPoly->coeff[x][y] = psAlloc(nZ * sizeof(psF64));
    706             newPoly->coeffErr[x][y] = psAlloc(nZ * sizeof(psF64));
    707             newPoly->mask[x][y] = (psMaskType *)psAlloc(nZ * sizeof(psMaskType));
    708         }
    709     }
    710     for (x = 0; x < nX; x++) {
    711         for (y = 0; y < nY; y++) {
    712             for (z = 0; z < nZ; z++) {
     697    newPoly->COOL_3D_nX = nX;
     698    newPoly->COOL_3D_nY = nY;
     699    newPoly->COOL_3D_nZ = nZ;
     700
     701    newPoly->coeff = psAlloc((nX + 1) * sizeof(psF64 **));
     702    newPoly->coeffErr = psAlloc((nX + 1) * sizeof(psF64 **));
     703    newPoly->mask = (psMaskType ***)psAlloc((nX + 1) * sizeof(psMaskType **));
     704    for (x = 0; x < (1 + nX); x++) {
     705        newPoly->coeff[x] = psAlloc((nY + 1) * sizeof(psF64 *));
     706        newPoly->coeffErr[x] = psAlloc((nY + 1) * sizeof(psF64 *));
     707        newPoly->mask[x] = (psMaskType **)psAlloc((nY + 1) * sizeof(psMaskType *));
     708        for (y = 0; y < (nY + 1); y++) {
     709            newPoly->coeff[x][y] = psAlloc((nZ + 1) * sizeof(psF64));
     710            newPoly->coeffErr[x][y] = psAlloc((nZ + 1) * sizeof(psF64));
     711            newPoly->mask[x][y] = (psMaskType *)psAlloc((nZ + 1) * sizeof(psMaskType));
     712        }
     713    }
     714    for (x = 0; x < (nX + 1); x++) {
     715        for (y = 0; y < (nY + 1); y++) {
     716            for (z = 0; z < (nZ + 1); z++) {
    713717                newPoly->coeff[x][y][z] = 0.0;
    714718                newPoly->coeffErr[x][y][z] = 0.0;
    … …  
    742746
    743747    newPoly->type = type;
    744     newPoly->nX = nX;
    745     newPoly->nY = nY;
    746     newPoly->nZ = nZ;
    747     newPoly->nT = nT;
    748 
    749     newPoly->coeff = psAlloc(nX * sizeof(psF64 ***));
    750     newPoly->coeffErr = psAlloc(nX * sizeof(psF64 ***));
    751     newPoly->mask = (psMaskType ****)psAlloc(nX * sizeof(psMaskType ***));
    752     for (x = 0; x < nX; x++) {
    753         newPoly->coeff[x] = psAlloc(nY * sizeof(psF64 **));
    754         newPoly->coeffErr[x] = psAlloc(nY * sizeof(psF64 **));
    755         newPoly->mask[x] = (psMaskType ***)psAlloc(nY * sizeof(psMaskType **));
    756         for (y = 0; y < nY; y++) {
    757             newPoly->coeff[x][y] = psAlloc(nZ * sizeof(psF64 *));
    758             newPoly->coeffErr[x][y] = psAlloc(nZ * sizeof(psF64 *));
    759             newPoly->mask[x][y] = (psMaskType **)psAlloc(nZ * sizeof(psMaskType *));
    760             for (z = 0; z < nZ; z++) {
    761                 newPoly->coeff[x][y][z] = psAlloc(nT * sizeof(psF64));
    762                 newPoly->coeffErr[x][y][z] = psAlloc(nT * sizeof(psF64));
    763                 newPoly->mask[x][y][z] = (psMaskType *)psAlloc(nT * sizeof(psMaskType));
    764             }
    765         }
    766     }
    767     for (x = 0; x < nX; x++) {
    768         for (y = 0; y < nY; y++) {
    769             for (z = 0; z < nZ; z++) {
    770                 for (t = 0; t < nT; t++) {
     748    newPoly->COOL_4D_nX = nX;
     749    newPoly->COOL_4D_nY = nY;
     750    newPoly->COOL_4D_nZ = nZ;
     751    newPoly->COOL_4D_nT = nT;
     752
     753    newPoly->coeff = psAlloc((nX + 1) * sizeof(psF64 ***));
     754    newPoly->coeffErr = psAlloc((nX + 1) * sizeof(psF64 ***));
     755    newPoly->mask = (psMaskType ****)psAlloc((nX + 1) * sizeof(psMaskType ***));
     756    for (x = 0; x < (nX + 1); x++) {
     757        newPoly->coeff[x] = psAlloc((nY + 1) * sizeof(psF64 **));
     758        newPoly->coeffErr[x] = psAlloc((nY + 1) * sizeof(psF64 **));
     759        newPoly->mask[x] = (psMaskType ***)psAlloc((nY + 1) * sizeof(psMaskType **));
     760        for (y = 0; y < (nY + 1); y++) {
     761            newPoly->coeff[x][y] = psAlloc((nZ + 1) * sizeof(psF64 *));
     762            newPoly->coeffErr[x][y] = psAlloc((nZ + 1) * sizeof(psF64 *));
     763            newPoly->mask[x][y] = (psMaskType **)psAlloc((nZ + 1) * sizeof(psMaskType *));
     764            for (z = 0; z < (nZ + 1); z++) {
     765                newPoly->coeff[x][y][z] = psAlloc((nT + 1) * sizeof(psF64));
     766                newPoly->coeffErr[x][y][z] = psAlloc((nT + 1) * sizeof(psF64));
     767                newPoly->mask[x][y][z] = (psMaskType *)psAlloc((nT + 1) * sizeof(psMaskType));
     768            }
     769        }
     770    }
     771    for (x = 0; x < (nX + 1); x++) {
     772        for (y = 0; y < (nY + 1); y++) {
     773            for (z = 0; z < (nZ + 1); z++) {
     774                for (t = 0; t < (nT + 1); t++) {
    771775                    newPoly->coeff[x][y][z][t] = 0.0;
    772776                    newPoly->coeffErr[x][y][z][t] = 0.0;
    … …  
    972976    }
    973977
    974     // Allocate output vector
     978    // Allocoutput vector
    975979    tmp = psVectorAlloc(vecLen, PS_TYPE_F64);
    976980

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

    r5066 r5090  
    1111 *  @author GLG, MHPCC
    1212 *
    13  *  @version $Revision: 1.56 $ $Name: not supported by cvs2svn $
    14  *  @date $Date: 2005-09-19 19:53:13 $
     13 *  @version $Revision: 1.57 $ $Name: not supported by cvs2svn $
     14 *  @date $Date: 2005-09-22 02:47:16 $
    1515 *
    1616 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    6464 */
    6565typedef enum {
    66     PS_POLYNOMIAL_ORD,                 ///< Ordinary Polynomial
    67     PS_POLYNOMIAL_CHEB                 ///< Chebyshev Polynomial
     66    PS_POLYNOMIAL_ORD,                  ///< Ordinary Polynomial
     67    PS_POLYNOMIAL_CHEB                  ///< Chebyshev Polynomial
    6868}
    6969psPolynomialType;
    7070
     71// XXX: These are incorrect names for the order of the polynomial.  We
     72// keep them here temporarily so we can later sed replace them with the
     73// correct names.
    7174/** One-dimensional polynomial */
    7275typedef struct
    7376{
    74     psPolynomialType type;             ///< Polynomial type
    75     unsigned int n;                    ///< Number of terms
    76     psF64 *coeff;                      ///< Coefficients
    77     psF64 *coeffErr;                   ///< Error in coefficients
    78     psMaskType *mask;                  ///< Coefficient mask
     77    psPolynomialType type;              ///< Polynomial type
     78    unsigned int COOL_1D_n;             ///< Polynomial order
     79    psF64 *coeff;                       ///< Coefficients
     80    psF64 *coeffErr;                    ///< Error in coefficients
     81    psMaskType *mask;                   ///< Coefficient mask
    7982}
    8083psPolynomial1D;
    8184
     85// XXX: These are incorrect names for the order of the polynomial.  We
     86// keep them here temporarily so we can later sed replace them with the
     87// correct names.
    8288/** Two-dimensional polynomial */
    8389typedef struct
    8490{
    85     psPolynomialType type;             ///< Polynomial type
    86     unsigned int nX;                   ///< Number of terms in x
    87     unsigned int nY;                   ///< Number of terms in y
    88     psF64 **coeff;                     ///< Coefficients
    89     psF64 **coeffErr;                  ///< Error in coefficients
    90     psMaskType **mask;                 ///< Coefficients mask
     91    psPolynomialType type;              ///< Polynomial type
     92    unsigned int COOL_2D_nX;            ///< Polynomial order in x
     93    unsigned int COOL_2D_nY;            ///< Polynomial order in y
     94    psF64 **coeff;                      ///< Coefficients
     95    psF64 **coeffErr;                   ///< Error in coefficients
     96    psMaskType **mask;                  ///< Coefficients mask
    9197}
    9298psPolynomial2D;
    9399
     100// XXX: These are incorrect names for the order of the polynomial.  We
     101// keep them here temporarily so we can later sed replace them with the
     102// correct names.
    94103/** Three-dimensional polynomial */
    95104typedef struct
    96105{
    97     psPolynomialType type;             ///< Polynomial type
    98     unsigned int nX;                   ///< Number of terms in x
    99     unsigned int nY;                   ///< Number of terms in y
    100     unsigned int nZ;                   ///< Number of terms in z
    101     psF64 ***coeff;                    ///< Coefficients
    102     psF64 ***coeffErr;                 ///< Error in coefficients
    103     psMaskType ***mask;                ///< Coefficients mask
     106    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
     110    psF64 ***coeff;                     ///< Coefficients
     111    psF64 ***coeffErr;                  ///< Error in coefficients
     112    psMaskType ***mask;                 ///< Coefficients mask
    104113}
    105114psPolynomial3D;
    106115
     116// XXX: These are incorrect names for the order of the polynomial.  We
     117// keep them here temporarily so we can later sed replace them with the
     118// correct names.
    107119/** Four-dimensional polynomial */
    108120typedef struct
    109121{
    110     psPolynomialType type;             ///< Polynomial type
    111     unsigned int nX;                   ///< Number of terms in x
    112     unsigned int nY;                   ///< Number of terms in y
    113     unsigned int nZ;                   ///< Number of terms in z
    114     unsigned int nT;                   ///< Number of terms in t
    115     psF64 ****coeff;                   ///< Coefficients
    116     psF64 ****coeffErr;                ///< Error in coefficients
    117     psMaskType ****mask;               ///< Coefficients mask
     122    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
     127    psF64 ****coeff;                    ///< Coefficients
     128    psF64 ****coeffErr;                 ///< Error in coefficients
     129    psMaskType ****mask;                ///< Coefficients mask
    118130}
    119131psPolynomial4D;

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

    r5072 r5090  
    77*  splines.
    88*
    9 *  @version $Revision: 1.126 $ $Name: not supported by cvs2svn $
    10 *  @date $Date: 2005-09-20 02:43:53 $
     9*  @version $Revision: 1.127 $ $Name: not supported by cvs2svn $
     10*  @date $Date: 2005-09-22 02:47:16 $
    1111*
    1212*
    … …  
    383383    // If these are linear splines, which means their polynomials will have
    384384    // two coefficients, then we do the simple calculation.
    385     if (2 == (spline->spline[0])->n) {
     385    if (1 == (spline->spline[0])->COOL_1D_n) {
    386386        for (i=0;i<spline->n;i++) {
    387387            slope = (y32->data.F32[i+1] - y32->data.F32[i]) /
    … …  
    402402
    403403    // Check if these are cubic splines (n==4).  If not, psError.
    404     if (4 != (spline->spline[0])->n) {
     404    if (3 != (spline->spline[0])->COOL_1D_n) {
    405405        psError(PS_ERR_BAD_PARAMETER_SIZE, true,
    406406                "Don't know how to generate %u-order splines.",
    407                 (spline->spline[0])->n-1);
     407                (spline->spline[0])->COOL_1D_n);
    408408        return(NULL);
    409409    }
    … …  
    745745    tmpSpline->spline = (psPolynomial1D **) psAlloc(numSplines * sizeof(psPolynomial1D *));
    746746    for (unsigned int i=0;i<numSplines;i++) {
    747         (tmpSpline->spline)[i] = psPolynomial1DAlloc(order+1, PS_POLYNOMIAL_ORD);
     747        (tmpSpline->spline)[i] = psPolynomial1DAlloc(order, PS_POLYNOMIAL_ORD);
    748748    }
    749749
    … …  
    809809    tmpSpline->spline = (psPolynomial1D **) psAlloc(numSplines * sizeof(psPolynomial1D *));
    810810    for (unsigned int i=0;i<numSplines;i++) {
    811         (tmpSpline->spline)[i] = psPolynomial1DAlloc(order+1, PS_POLYNOMIAL_ORD);
     811        (tmpSpline->spline)[i] = psPolynomial1DAlloc(order, PS_POLYNOMIAL_ORD);
    812812    }
    813813

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

    r4991 r5090  
    1717 *
    1818 *
    19  *  @version $Revision: 1.145 $ $Name: not supported by cvs2svn $
    20  *  @date $Date: 2005-09-11 22:18:40 $
     19 *  @version $Revision: 1.146 $ $Name: not supported by cvs2svn $
     20 *  @date $Date: 2005-09-22 02:47:16 $
    2121 *
    2222 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    15021502    psVector *y = psVectorAlloc(3, PS_TYPE_F64);
    15031503    psVector *yErr = psVectorAlloc(3, PS_TYPE_F64);
     1504    // XXX: Why was this 2 when the alloc function specified number of terms?  Note: it's correct now.
    15041505    psPolynomial1D *myPoly = psPolynomial1DAlloc(2, PS_POLYNOMIAL_ORD);
    15051506
    … …  
    15521553
    15531554        // Determine the coefficients of the polynomial.
    1554         //        myPoly = psVectorFitPolynomial1D(myPoly, x, y, yErr);
    15551555        myPoly = psVectorFitPolynomial1D(myPoly, NULL, 0, y, yErr, x);
    15561556        if (myPoly == NULL) {
    … …  
    18271827        }
    18281828
    1829         psPolynomial1D *tmpPoly = psPolynomial1DAlloc(3, PS_POLYNOMIAL_ORD);
     1829        psPolynomial1D *tmpPoly = psPolynomial1DAlloc(2, PS_POLYNOMIAL_ORD);
    18301830        // XXX: What about the NULL x argument?
    18311831        tmpPoly = psVectorFitPolynomial1D(tmpPoly, NULL, 0, y, NULL, NULL);

  • trunk/psLib/test/astro/tst_psCoord.c

    r4601 r5090  
    66*  @author GLG, MHPCC
    77*
    8 *  @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
    9 *  @date $Date: 2005-07-23 02:44:09 $
     8*  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
     9*  @date $Date: 2005-09-22 02:47:16 $
    1010*
    1111*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    5151
    5252    // Verify returned transform has members set properly
    53     if (myPT->x->nX != NX_TERMS) {
    54         psError(PS_ERR_UNKNOWN,true,"myPT->x->nX is %d, should be %d",
    55                 myPT->x->nX, NX_TERMS);
     53    if ((1 + myPT->x->COOL_2D_nX) != NX_TERMS) {
     54        psError(PS_ERR_UNKNOWN,true,"myPT->x->COOL_2D_nX is %d, should be %d",
     55                myPT->x->COOL_2D_nX, NX_TERMS-1);
    5656        return 2;
    5757    }
    58     if (myPT->y->nX != NX_TERMS) {
    59         psError(PS_ERR_UNKNOWN,true,"myPT->y->nX is %d, should be %d",
    60                 myPT->y->nX, NX_TERMS);
     58    if ((1 + myPT->y->COOL_2D_nX) != NX_TERMS) {
     59        psError(PS_ERR_UNKNOWN,true,"myPT->y->COOL_2D_nX is %d, should be %d",
     60                myPT->y->COOL_2D_nX, NX_TERMS-1);
    6161        return 3;
    6262    }
    63     if (myPT->x->nY != NY_TERMS) {
    64         psError(PS_ERR_UNKNOWN,true,"myPT->x->nY is %d, should be %d",
    65                 myPT->x->nY, NY_TERMS);
     63    if ((1 + myPT->x->COOL_2D_nY) != NY_TERMS) {
     64        psError(PS_ERR_UNKNOWN,true,"myPT->x->COOL_2D_nY is %d, should be %d",
     65                myPT->x->COOL_2D_nY, NY_TERMS-1);
    6666        return 4;
    6767    }
    68     if (myPT->y->nY != NY_TERMS) {
    69         psError(PS_ERR_UNKNOWN,true,"myPT->y->nY is %d, should be %d",
    70                 myPT->y->nY, NY_TERMS);
     68    if ((1 + myPT->y->COOL_2D_nY) != NY_TERMS) {
     69        psError(PS_ERR_UNKNOWN,true,"myPT->y->COOL_2D_nY is %d, should be %d",
     70                myPT->y->COOL_2D_nY, NY_TERMS-1);
    7171        return 5;
    7272    }
    … …  
    108108    }
    109109    // Verify the terms are properly set after allocation
    110     if (myPD->x->nX != NX_TERMS) {
    111         psError(PS_ERR_UNKNOWN,true,"myPD->x->nX is %d, should be %d",
    112                 myPD->x->nX, NX_TERMS);
     110    if ((1 + myPD->x->COOL_4D_nX) != NX_TERMS) {
     111        psError(PS_ERR_UNKNOWN,true,"myPD->x->COOL_4D_nX is %d, should be %d",
     112                myPD->x->COOL_4D_nX, NX_TERMS-1);
    113113        return 2;
    114114    }
    115     if (myPD->y->nX != NX_TERMS) {
    116         psError(PS_ERR_UNKNOWN,true,"myPD->y->nX is %d, should be %d",
    117                 myPD->y->nX, NX_TERMS);
     115    if ((1 + myPD->y->COOL_4D_nX) != NX_TERMS) {
     116        psError(PS_ERR_UNKNOWN,true,"myPD->y->COOL_4D_nX is %d, should be %d",
     117                myPD->y->COOL_4D_nX, NX_TERMS-1);
    118118        return 3;
    119119    }
    120     if (myPD->x->nY != NY_TERMS) {
    121         psError(PS_ERR_UNKNOWN,true,"myPD->x->nY is %d, should be %d",
    122                 myPD->x->nY, NY_TERMS);
     120    if ((1 + myPD->x->COOL_4D_nY) != NY_TERMS) {
     121        psError(PS_ERR_UNKNOWN,true,"myPD->x->COOL_4D_nY is %d, should be %d",
     122                myPD->x->COOL_4D_nY, NY_TERMS-1);
    123123        return 4;
    124124    }
    125     if (myPD->y->nY != NY_TERMS) {
    126         psError(PS_ERR_UNKNOWN,true,"myPD->y->nY is %d, should be %d",
    127                 myPD->y->nY, NY_TERMS);
     125    if ((1 + myPD->y->COOL_4D_nY) != NY_TERMS) {
     126        psError(PS_ERR_UNKNOWN,true,"myPD->y->COOL_4D_nY is %d, should be %d",
     127                myPD->y->COOL_4D_nY, NY_TERMS-1);
    128128        return 5;
    129129    }
    130     if (myPD->x->nZ != NZ_TERMS) {
    131         psError(PS_ERR_UNKNOWN,true,"myPD->x->nZ is %d, should be %d",
    132                 myPD->x->nZ, NZ_TERMS);
     130    if ((1 + myPD->x->COOL_4D_nZ) != NZ_TERMS) {
     131        psError(PS_ERR_UNKNOWN,true,"myPD->x->COOL_4D_nZ is %d, should be %d",
     132                myPD->x->COOL_4D_nX, NZ_TERMS-1);
    133133        return 6;
    134134    }
    135     if (myPD->y->nZ != NZ_TERMS) {
    136         psError(PS_ERR_UNKNOWN,true,"myPD->y->nZ is %d, should be %d",
    137                 myPD->y->nZ, NZ_TERMS);
     135    if ((1 + myPD->y->COOL_4D_nZ) != NZ_TERMS) {
     136        psError(PS_ERR_UNKNOWN,true,"myPD->y->COOL_4D_nZ is %d, should be %d",
     137                myPD->y->COOL_4D_nZ, NZ_TERMS-1);
    138138        return 7;
    139139    }
    140     if (myPD->x->nT != NT_TERMS) {
    141         psError(PS_ERR_UNKNOWN,true,"myPD->x->nT is %d, should be %d",
    142                 myPD->x->nT, NT_TERMS);
     140    if ((1 + myPD->x->COOL_4D_nT) != NT_TERMS) {
     141        psError(PS_ERR_UNKNOWN,true,"myPD->x->COOL_4D_nT is %d, should be %d",
     142                myPD->x->COOL_4D_nT, NT_TERMS-1);
    143143        return 8;
    144144    }
    145     if (myPD->y->nT != NT_TERMS) {
    146         psError(PS_ERR_UNKNOWN,true,"myPD->y->nT is %d, should be %d",
    147                 myPD->y->nT, NT_TERMS);
     145    if ((1 + myPD->y->COOL_4D_nT) != NT_TERMS) {
     146        psError(PS_ERR_UNKNOWN,true,"myPD->y->COOL_4D_nT is %d, should be %d",
     147                myPD->y->COOL_4D_nT, NT_TERMS-1);
    148148        return 9;
    149149    }

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

    r4731 r5090  
    1414*    orders are created.
    1515*
    16 *    @version $Revision: 1.3 $  $Name: not supported by cvs2svn $
    17 *    @date $Date: 2005-08-08 21:44:09 $
     16*    @version $Revision: 1.4 $  $Name: not supported by cvs2svn $
     17*    @date $Date: 2005-09-22 02:47:16 $
    1818*
    1919*  Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
    … …  
    6363    }
    6464    // Verify polynomial structure members set properly
    65     if(my1DPoly->n != ORDER) {
    66         psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
    67                 my1DPoly->n, ORDER);
     65    if(my1DPoly->COOL_1D_n != ORDER) {
     66        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
     67                my1DPoly->COOL_1D_n, ORDER);
    6868        return 2;
    6969    }
    … …  
    7373        return 3;
    7474    }
    75     for(psS32 i = 0; i < ORDER; i++) {
     75    for(psS32 i = 0; i < ORDER+1; i++) {
    7676        if(my1DPoly->coeff[i] != 0.0) {
    7777            psError(PS_ERR_UNKNOWN,true,"Coeff[%d] %lg not as expected %lg",
    … …  
    115115    }
    116116    // Verify polynomial structure members set properly
    117     if(my2DPoly->nX != ORDER) {
    118         psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
    119                 my2DPoly->nX, ORDER);
     117    if(my2DPoly->COOL_2D_nX != ORDER) {
     118        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
     119                my2DPoly->COOL_2D_nX, ORDER);
    120120        return 2;
    121121    }
    122122    // Verify polynomial structure members set properly
    123     if(my2DPoly->nY != ORDER+1) {
    124         psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
    125                 my2DPoly->nY, ORDER+1);
     123    if(my2DPoly->COOL_2D_nY != ORDER+1) {
     124        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
     125                my2DPoly->COOL_2D_nY, ORDER+1);
    126126        return 3;
    127127    }
    … …  
    131131        return 4;
    132132    }
    133     for(psS32 i = 0; i < ORDER; i++) {
    134         for(psS32 j = 0; j < ORDER+1; j++) {
     133    for(psS32 i = 0; i < ORDER+1; i++) {
     134        for(psS32 j = 0; j < ORDER+2; j++) {
    135135            if(my2DPoly->coeff[i][j] != 0.0) {
    136136                psError(PS_ERR_UNKNOWN,true,"Coeff[%d][%d] %lg not as expected %lg",
    … …  
    181181    }
    182182    // Verify polynomial structure members set properly
    183     if(my3DPoly->nX != ORDER) {
    184         psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
    185                 my3DPoly->nX, ORDER);
     183    if(my3DPoly->COOL_3D_nX != ORDER) {
     184        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
     185                my3DPoly->COOL_3D_nX, ORDER);
    186186        return 2;
    187187    }
    188188    // Verify polynomial structure members set properly
    189     if(my3DPoly->nY != ORDER+1) {
    190         psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
    191                 my3DPoly->nY, ORDER+1);
     189    if(my3DPoly->COOL_3D_nY != ORDER+1) {
     190        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
     191                my3DPoly->COOL_3D_nY, ORDER+1);
    192192        return 3;
    193193    }
    194194    // Verify polynomial structure members set properly
    195     if(my3DPoly->nZ != ORDER+2) {
    196         psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
    197                 my3DPoly->nZ, ORDER+2);
     195    if(my3DPoly->COOL_3D_nZ != ORDER+2) {
     196        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
     197                my3DPoly->COOL_3D_nZ, ORDER+2);
    198198        return 4;
    199199    }
    … …  
    203203        return 5;
    204204    }
    205     for(psS32 i = 0; i < ORDER; i++) {
    206         for(psS32 j = 0; j < ORDER+1; j++) {
    207             for(psS32 k = 0; k < ORDER+2; k++) {
     205    for(psS32 i = 0; i < ORDER+1; i++) {
     206        for(psS32 j = 0; j < ORDER+2; j++) {
     207            for(psS32 k = 0; k < ORDER+3; k++) {
    208208                if(my3DPoly->coeff[i][j][k] != 0.0) {
    209209                    psError(PS_ERR_UNKNOWN,true,"Coeff[%d][%d][%d] %lg not as expected %lg",
    … …  
    254254
    255255    // Allocate polynomial
    256     my4DPoly = psPolynomial4DAlloc(ORDER+3,ORDER,ORDER+1,ORDER+2,PS_POLYNOMIAL_ORD);
     256    my4DPoly = psPolynomial4DAlloc(ORDER,ORDER+1,ORDER+2,ORDER+3,PS_POLYNOMIAL_ORD);
    257257    // Verify structure allocated
    258258    if(my4DPoly == NULL) {
    … …  
    261261    }
    262262    // Verify polynomial structure members set properly
    263     if(my4DPoly->nY != ORDER) {
    264         psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
    265                 my4DPoly->nY, ORDER);
     263    if(my4DPoly->COOL_4D_nX != ORDER) {
     264        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
     265                my4DPoly->COOL_4D_nX, ORDER);
    266266        return 2;
    267267    }
    268268    // Verify polynomial structure members set properly
    269     if(my4DPoly->nZ != ORDER+1) {
    270         psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
    271                 my4DPoly->nZ, ORDER+1);
     269    if(my4DPoly->COOL_4D_nY != ORDER+1) {
     270        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
     271                my4DPoly->COOL_4D_nX, ORDER+1);
    272272        return 3;
    273273    }
    274274    // Verify polynomial structure members set properly
    275     if(my4DPoly->nT != ORDER+2) {
    276         psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
    277                 my4DPoly->nT, ORDER+2);
     275    if(my4DPoly->COOL_4D_nZ != ORDER+2) {
     276        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
     277                my4DPoly->COOL_4D_nZ, ORDER+2);
    278278        return 4;
    279279    }
    280280    // Verify polynomial structure members set properly
    281     if(my4DPoly->nX != ORDER+3) {
    282         psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
    283                 my4DPoly->nX, ORDER+3);
     281    if(my4DPoly->COOL_4D_nT != ORDER+3) {
     282        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
     283                my4DPoly->COOL_4D_nT, ORDER+3);
    284284        return 5;
    285285    }
    … …  
    289289        return 6;
    290290    }
    291     for(psS32 i = 0; i < ORDER+3; i++) {
    292         for(psS32 j = 0; j < ORDER; j++) {
    293             for(psS32 k = 0; k < ORDER+1; k++) {
    294                 for(psS32 l = 0; l < ORDER+2; l++) {
     291    for(psS32 i = 0; i < ORDER+1; i++) {
     292        for(psS32 j = 0; j < ORDER+2; j++) {
     293            for(psS32 k = 0; k < ORDER+3; k++) {
     294                for(psS32 l = 0; l < ORDER+4; l++) {
    295295                    if(my4DPoly->coeff[i][j][k][l] != 0.0) {
    296296                        psError(PS_ERR_UNKNOWN,true,"Coeff[%d][%d][%d][%d] %lg not as expected %lg",

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

    r4731 r5090  
    44*  ORD and CHEB type polynomials.
    55*
    6 *  @version  $Revision: 1.3 $  $Name: not supported by cvs2svn $
    7 *  @date  $Date: 2005-08-08 21:44:09 $
     6*  @version  $Revision: 1.4 $  $Name: not supported by cvs2svn $
     7*  @date  $Date: 2005-09-22 02:47:16 $
    88*
    99*  XXX: Probably should test single- and multi-dimensional polynomials in
    … …  
    5959
    6060    // Allocate polynomial structure
    61     psPolynomial1D*  polyOrd = psPolynomial1DAlloc(TERMS, PS_POLYNOMIAL_ORD);
    62     psPolynomial1D*  polyCheb = psPolynomial1DAlloc(TERMS, PS_POLYNOMIAL_CHEB);
     61    psPolynomial1D*  polyOrd = psPolynomial1DAlloc(TERMS-1, PS_POLYNOMIAL_ORD);
     62    psPolynomial1D*  polyCheb = psPolynomial1DAlloc(TERMS-1, PS_POLYNOMIAL_CHEB);
    6363    // Set polynomial members
    6464    for(psS32 i = 0; i < TERMS; i++) {
    … …  
    8787
    8888    // Allocate polynomial with invalid type
    89     polyOrd = psPolynomial1DAlloc(TERMS, 99);
     89    polyOrd = psPolynomial1DAlloc(TERMS-1, 99);
    9090    // Attempt to evaluation invalid polynomial type
    9191    psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type");
    … …  
    104104{
    105105    // Allocate polynomial
    106     psPolynomial1D* polyOrd = psPolynomial1DAlloc(TERMS,PS_POLYNOMIAL_ORD);
    107     psPolynomial1D* polyCheb = psPolynomial1DAlloc(TERMS,PS_POLYNOMIAL_CHEB);
     106    psPolynomial1D* polyOrd = psPolynomial1DAlloc(TERMS-1,PS_POLYNOMIAL_ORD);
     107    psPolynomial1D* polyCheb = psPolynomial1DAlloc(TERMS-1,PS_POLYNOMIAL_CHEB);
    108108
    109109    // Set polynomial members

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

    r4731 r5090  
    44*  ORD and CHEB type polynomials.
    55*
    6 *  @version  $Revision: 1.3 $  $Name: not supported by cvs2svn $
    7 *  @date  $Date: 2005-08-08 21:44:09 $
     6*  @version  $Revision: 1.4 $  $Name: not supported by cvs2svn $
     7*  @date  $Date: 2005-09-22 02:47:16 $
    88*
    99* Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
    … …  
    8888 
    8989    // Allocate polynomial structure
    90     psPolynomial2D*  polyOrd = psPolynomial2DAlloc(TERMS, TERMS, PS_POLYNOMIAL_ORD);
    91     psPolynomial2D*  polyCheb = psPolynomial2DAlloc(TERMS, TERMS, PS_POLYNOMIAL_CHEB);
     90    psPolynomial2D*  polyOrd = psPolynomial2DAlloc(TERMS-1, TERMS-1, PS_POLYNOMIAL_ORD);
     91    psPolynomial2D*  polyCheb = psPolynomial2DAlloc(TERMS-1, TERMS-1, PS_POLYNOMIAL_CHEB);
    9292    // Set polynomial members
    9393    for(psS32 i = 0; i < TERMS; i++) {
    … …  
    118118 
    119119    // Allocate polynomial with invalid type
    120     polyOrd = psPolynomial2DAlloc(TERMS, TERMS, 99);
     120    polyOrd = psPolynomial2DAlloc(TERMS-1, TERMS-1, 99);
    121121    // Attempt to evaluation invalid polynomial type
    122122    psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type");
    … …  
    138138
    139139    // Allocate polynomial structure
    140     psPolynomial2D*  polyOrd = psPolynomial2DAlloc(TERMS, TERMS, PS_POLYNOMIAL_ORD);
    141     psPolynomial2D*  polyCheb = psPolynomial2DAlloc(TERMS, TERMS, PS_POLYNOMIAL_CHEB);
     140    psPolynomial2D*  polyOrd = psPolynomial2DAlloc(TERMS-1, TERMS-1, PS_POLYNOMIAL_ORD);
     141    psPolynomial2D*  polyCheb = psPolynomial2DAlloc(TERMS-1, TERMS-1, PS_POLYNOMIAL_CHEB);
    142142    // Set polynomial members
    143143    for(psS32 i = 0; i < TERMS; i++) {
    … …  
    168168
    169169    // Allocate polynomial with invalid type
    170     polyOrd = psPolynomial2DAlloc(TERMS, TERMS, 99);
     170    polyOrd = psPolynomial2DAlloc(TERMS-1, TERMS-1, 99);
    171171    // Attempt to evaluation invalid polynomial type
    172172    psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type");
    … …  
    184184{
    185185    // Allocate polynomial
    186     psPolynomial2D* polyOrd = psPolynomial2DAlloc(TERMS,TERMS,PS_POLYNOMIAL_ORD);
    187     psPolynomial2D* polyCheb = psPolynomial2DAlloc(TERMS,TERMS,PS_POLYNOMIAL_CHEB);
     186    psPolynomial2D* polyOrd = psPolynomial2DAlloc(TERMS-1,TERMS-1,PS_POLYNOMIAL_ORD);
     187    psPolynomial2D* polyCheb = psPolynomial2DAlloc(TERMS-1,TERMS-1,PS_POLYNOMIAL_CHEB);
    188188 
    189189    // Set polynomial members
    … …  
    297297{
    298298    // Allocate polynomial
    299     psPolynomial2D* polyOrd = psPolynomial2DAlloc(TERMS,TERMS,PS_POLYNOMIAL_ORD);
    300     psPolynomial2D* polyCheb = psPolynomial2DAlloc(TERMS,TERMS,PS_POLYNOMIAL_CHEB);
     299    psPolynomial2D* polyOrd = psPolynomial2DAlloc(TERMS-1,TERMS-1,PS_POLYNOMIAL_ORD);
     300    psPolynomial2D* polyCheb = psPolynomial2DAlloc(TERMS-1,TERMS-1,PS_POLYNOMIAL_CHEB);
    301301
    302302    // Set polynomial members

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

    r4731 r5090  
    44*  ORD and CHEB type polynomials.
    55*
    6 *  @version  $Revision: 1.3 $  $Name: not supported by cvs2svn $
    7 *  @date  $Date: 2005-08-08 21:44:09 $
     6*  @version  $Revision: 1.4 $  $Name: not supported by cvs2svn $
     7*  @date  $Date: 2005-09-22 02:47:16 $
    88*
    99* Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
    … …  
    139139 
    140140    // Allocate polynomial structure
    141     psPolynomial3D*  polyOrd = psPolynomial3DAlloc(TERMS, TERMS, TERMS, PS_POLYNOMIAL_ORD);
    142     psPolynomial3D*  polyCheb = psPolynomial3DAlloc(TERMS, TERMS, TERMS, PS_POLYNOMIAL_CHEB);
     141    psPolynomial3D*  polyOrd = psPolynomial3DAlloc(TERMS-1, TERMS-1, TERMS-1, PS_POLYNOMIAL_ORD);
     142    psPolynomial3D*  polyCheb = psPolynomial3DAlloc(TERMS-1, TERMS-1, TERMS-1, PS_POLYNOMIAL_CHEB);
    143143    // Set polynomial members
    144144    for(psS32 i = 0; i < TERMS; i++) {
    … …  
    173173 
    174174    // Allocate polynomial with invalid type
    175     polyOrd = psPolynomial3DAlloc(TERMS, TERMS, TERMS, 99);
     175    polyOrd = psPolynomial3DAlloc(TERMS-1, TERMS-1, TERMS-1, 99);
    176176    // Attempt to evaluation invalid polynomial type
    177177    psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type");
    … …  
    193193
    194194    // Allocate polynomial structure
    195     psPolynomial3D*  polyOrd = psPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
    196     psPolynomial3D*  polyCheb = psPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
     195    psPolynomial3D*  polyOrd = psPolynomial3DAlloc(TERMS-1, TERMS-1, TERMS-1,PS_POLYNOMIAL_ORD);
     196    psPolynomial3D*  polyCheb = psPolynomial3DAlloc(TERMS-1, TERMS-1, TERMS-1,PS_POLYNOMIAL_CHEB);
    197197    // Set polynomial members
    198198    for(psS32 i = 0; i < TERMS; i++) {
    … …  
    227227
    228228    // Allocate polynomial with invalid type
    229     polyOrd = psPolynomial3DAlloc(TERMS, TERMS, TERMS, 99);
     229    polyOrd = psPolynomial3DAlloc(TERMS-1, TERMS-1, TERMS-1, 99);
    230230    // Attempt to evaluation invalid polynomial type
    231231    psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type");
    … …  
    243243{
    244244    // Allocate polynomial
    245     psPolynomial3D* polyOrd  = psPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
    246     psPolynomial3D* polyCheb = psPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
     245    psPolynomial3D* polyOrd  = psPolynomial3DAlloc(TERMS-1, TERMS-1, TERMS-1,PS_POLYNOMIAL_ORD);
     246    psPolynomial3D* polyCheb = psPolynomial3DAlloc(TERMS-1, TERMS-1, TERMS-1,PS_POLYNOMIAL_CHEB);
    247247 
    248248    // Set polynomial members
    … …  
    378378{
    379379    // Allocate polynomial
    380     psPolynomial3D* polyOrd = psPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
    381     psPolynomial3D* polyCheb = psPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
     380    psPolynomial3D* polyOrd = psPolynomial3DAlloc(TERMS-1, TERMS-1, TERMS-1,PS_POLYNOMIAL_ORD);
     381    psPolynomial3D* polyCheb = psPolynomial3DAlloc(TERMS-1, TERMS-1, TERMS-1,PS_POLYNOMIAL_CHEB);
    382382
    383383    // Set polynomial members

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

    r4731 r5090  
    44*  ORD and CHEB type polynomials.
    55*
    6 *  @version  $Revision: 1.3 $  $Name: not supported by cvs2svn $
    7 *  @date  $Date: 2005-08-08 21:44:09 $
     6*  @version  $Revision: 1.4 $  $Name: not supported by cvs2svn $
     7*  @date  $Date: 2005-09-22 02:47:16 $
    88*
    99* Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
    … …  
    381381 
    382382    // Allocate polynomial structure
    383     psPolynomial4D*  polyOrd  = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
    384     psPolynomial4D*  polyCheb = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
     383    psPolynomial4D*  polyOrd  = psPolynomial4DAlloc(TERMS-1, TERMS-1, TERMS-1, TERMS-1, PS_POLYNOMIAL_ORD);
     384    psPolynomial4D*  polyCheb = psPolynomial4DAlloc(TERMS-1, TERMS-1, TERMS-1, TERMS-1, PS_POLYNOMIAL_CHEB);
    385385    // Set polynomial members
    386386    for(psS32 i = 0; i < TERMS; i++) {
    … …  
    417417 
    418418    // Allocate polynomial with invalid type
    419     polyOrd = psPolynomial4DAlloc(TERMS, TERMS, TERMS, TERMS, 99);
     419    polyOrd = psPolynomial4DAlloc(TERMS-1, TERMS-1, TERMS-1, TERMS-1, 99);
    420420    // Attempt to evaluation invalid polynomial type
    421421    psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type");
    … …  
    437437
    438438    // Allocate polynomial structure
    439     psPolynomial4D*  polyOrd = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
    440     psPolynomial4D*  polyCheb = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
     439    psPolynomial4D*  polyOrd = psPolynomial4DAlloc(TERMS-1, TERMS-1, TERMS-1, TERMS-1, PS_POLYNOMIAL_ORD);
     440    psPolynomial4D*  polyCheb = psPolynomial4DAlloc(TERMS-1, TERMS-1, TERMS-1, TERMS-1, PS_POLYNOMIAL_CHEB);
    441441    // Set polynomial members
    442442    for(psS32 i = 0; i < TERMS; i++) {
    … …  
    473473
    474474    // Allocate polynomial with invalid type
    475     polyOrd = psPolynomial4DAlloc(TERMS, TERMS, TERMS, TERMS, 99);
     475    polyOrd = psPolynomial4DAlloc(TERMS-1, TERMS-1, TERMS-1, TERMS-1, 99);
    476476    // Attempt to evaluation invalid polynomial type
    477477    psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type");
    … …  
    489489{
    490490    // Allocate polynomial
    491     psPolynomial4D* polyOrd  = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
    492     psPolynomial4D* polyCheb = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
     491    psPolynomial4D* polyOrd  = psPolynomial4DAlloc(TERMS-1, TERMS-1, TERMS-1, TERMS-1, PS_POLYNOMIAL_ORD);
     492    psPolynomial4D* polyCheb = psPolynomial4DAlloc(TERMS-1, TERMS-1, TERMS-1, TERMS-1, PS_POLYNOMIAL_CHEB);
    493493 
    494494    // Set polynomial members
    … …  
    646646{
    647647    // Allocate polynomial
    648     psPolynomial4D* polyOrd = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
    649     psPolynomial4D* polyCheb = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
     648    psPolynomial4D* polyOrd = psPolynomial4DAlloc(TERMS-1, TERMS-1, TERMS-1, TERMS-1, PS_POLYNOMIAL_ORD);
     649    psPolynomial4D* polyCheb = psPolynomial4DAlloc(TERMS-1, TERMS-1, TERMS-1, TERMS-1, PS_POLYNOMIAL_CHEB);
    650650
    651651    // Set polynomial members

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

    r4995 r5090  
    4545    double actualData;
    4646
    47     psPolynomial2D *myPoly = psPolynomial2DAlloc(POLY_ORDER+1, POLY_ORDER+1, PS_POLYNOMIAL_ORD);
     47    psPolynomial2D *myPoly = psPolynomial2DAlloc(POLY_ORDER, POLY_ORDER, PS_POLYNOMIAL_ORD);
    4848    psVector *x = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
    4949    psVector *y = psVectorAlloc(NUM_DATA, PS_TYPE_F32);

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

    r4995 r5090  
    4545    float actualData;
    4646
    47     myPoly = psPolynomial1DAlloc(POLY_ORDER+1, PS_POLYNOMIAL_ORD);
     47    myPoly = psPolynomial1DAlloc(POLY_ORDER, PS_POLYNOMIAL_ORD);
    4848    x = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
    4949    y = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
    … …  
    114114    float actualData;
    115115
    116     myPoly = psPolynomial1DAlloc(POLY_ORDER+1, PS_POLYNOMIAL_ORD);
     116    myPoly = psPolynomial1DAlloc(POLY_ORDER, PS_POLYNOMIAL_ORD);
    117117    x = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
    118118    y = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
    … …  
    179179    float actualData;
    180180
    181     myPoly = psPolynomial1DAlloc(POLY_ORDER+1, PS_POLYNOMIAL_ORD);
     181    myPoly = psPolynomial1DAlloc(POLY_ORDER, PS_POLYNOMIAL_ORD);
    182182    y = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
    183183

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

    r4995 r5090  
    3838    psS32 memLeaks = 0;
    3939
    40     myPoly = psPolynomial1DAlloc(POLY_ORDER+1, PS_POLYNOMIAL_CHEB);
     40    myPoly = psPolynomial1DAlloc(POLY_ORDER, PS_POLYNOMIAL_CHEB);
    4141    x = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
    4242    y = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
    … …  
    109109    psS32 memLeaks = 0;
    110110
    111     myPoly = psPolynomial1DAlloc(POLY_ORDER+1, PS_POLYNOMIAL_CHEB);
     111    myPoly = psPolynomial1DAlloc(POLY_ORDER, PS_POLYNOMIAL_CHEB);
    112112    x = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
    113113    y = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
    … …  
    172172    psS32 memLeaks = 0;
    173173
    174     myPoly = psPolynomial1DAlloc(POLY_ORDER+1, PS_POLYNOMIAL_CHEB);
     174    myPoly = psPolynomial1DAlloc(POLY_ORDER, PS_POLYNOMIAL_CHEB);
    175175    x = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
    176176    y = psVectorAlloc(NUM_DATA, PS_TYPE_F64);

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

    r4995 r5090  
    3838    psS32 memLeaks = 0;
    3939
    40     myPoly = psPolynomial1DAlloc(POLY_ORDER+1, PS_POLYNOMIAL_CHEB);
     40    myPoly = psPolynomial1DAlloc(POLY_ORDER, PS_POLYNOMIAL_CHEB);
    4141    x = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
    4242    y = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
    … …  
    109109    psS32 memLeaks = 0;
    110110
    111     myPoly = psPolynomial1DAlloc(POLY_ORDER+1, PS_POLYNOMIAL_CHEB);
     111    myPoly = psPolynomial1DAlloc(POLY_ORDER, PS_POLYNOMIAL_CHEB);
    112112    x = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
    113113    y = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
    … …  
    172172    psS32 memLeaks = 0;
    173173
    174     myPoly = psPolynomial1DAlloc(POLY_ORDER+1, PS_POLYNOMIAL_CHEB);
     174    myPoly = psPolynomial1DAlloc(POLY_ORDER, PS_POLYNOMIAL_CHEB);
    175175    x = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
    176176    y = psVectorAlloc(NUM_DATA, PS_TYPE_F32);

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

    r4995 r5090  
    4545    double actualData;
    4646
    47     psPolynomial2D *myPoly = psPolynomial2DAlloc(POLY_ORDER+1, POLY_ORDER+1, PS_POLYNOMIAL_ORD);
     47    psPolynomial2D *myPoly = psPolynomial2DAlloc(POLY_ORDER, POLY_ORDER, PS_POLYNOMIAL_ORD);
    4848    psVector *x = psVectorAlloc(NUM_DATA, PS_TYPE_F64);
    4949    psVector *y = psVectorAlloc(NUM_DATA, PS_TYPE_F64);

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

    r4995 r5090  
    4545    double actualData;
    4646
    47     psPolynomial2D *myPoly = psPolynomial2DAlloc(POLY_ORDER+1, POLY_ORDER+1, PS_POLYNOMIAL_ORD);
     47    psPolynomial2D *myPoly = psPolynomial2DAlloc(POLY_ORDER, POLY_ORDER, PS_POLYNOMIAL_ORD);
    4848    psVector *x = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
    4949    psVector *y = psVectorAlloc(NUM_DATA, PS_TYPE_F32);
Note: See TracChangeset for help on using the changeset viewer.