IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Aug 6, 2004, 2:06:06 PM (22 years ago)
Author:
desonia
Message:

another attempt to get astyle to get it right.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r1406 r1407  
     1
    12/** @file  psFunctions.c
    23 *
    … …  
    78 *  polynomials.  It also contains a Gaussian functions.
    89 *
    9  *  @version $Revision: 1.20 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2004-08-06 22:34:05 $
     10 *  @version $Revision: 1.21 $ $Name: not supported by cvs2svn $
     11 *  @date $Date: 2004-08-07 00:06:06 $
    1112 *
    1213 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    1314 */
    14 /*****************************************************************************/
     15
     16/*****************************************************************************/
     17
    1518/*  INCLUDE FILES                                                            */
     19
    1620/*****************************************************************************/
    1721#include <stdlib.h>
    … …  
    3135#include <gsl/gsl_rng.h>
    3236#include <gsl/gsl_randist.h>
    33 /*****************************************************************************/
     37
     38/*****************************************************************************/
     39
    3440/* DEFINE STATEMENTS                                                         */
     41
    3542/*****************************************************************************/
    3643
    … …  
    3845
    3946/*****************************************************************************/
     47
    4048/* TYPE DEFINITIONS                                                          */
    41 /*****************************************************************************/
    42 static void polynomial1DFree(psPolynomial1D *myPoly);
    43 static void polynomial2DFree(psPolynomial2D *myPoly);
    44 static void polynomial3DFree(psPolynomial3D *myPoly);
    45 static void polynomial4DFree(psPolynomial4D *myPoly);
    46 static void dPolynomial1DFree(psDPolynomial1D *myPoly);
    47 static void dPolynomial2DFree(psDPolynomial2D *myPoly);
    48 static void dPolynomial3DFree(psDPolynomial3D *myPoly);
    49 static void dPolynomial4DFree(psDPolynomial4D *myPoly);
    50 
    51 /*****************************************************************************/
     49
     50/*****************************************************************************/
     51static void polynomial1DFree(psPolynomial1D * myPoly);
     52static void polynomial2DFree(psPolynomial2D * myPoly);
     53static void polynomial3DFree(psPolynomial3D * myPoly);
     54static void polynomial4DFree(psPolynomial4D * myPoly);
     55static void dPolynomial1DFree(psDPolynomial1D * myPoly);
     56static void dPolynomial2DFree(psDPolynomial2D * myPoly);
     57static void dPolynomial3DFree(psDPolynomial3D * myPoly);
     58static void dPolynomial4DFree(psDPolynomial4D * myPoly);
     59
     60/*****************************************************************************/
     61
    5262/* GLOBAL VARIABLES                                                          */
     63
    5364/*****************************************************************************/
    5465
    … …  
    5667
    5768/*****************************************************************************/
     69
    5870/* FILE STATIC VARIABLES                                                     */
     71
    5972/*****************************************************************************/
    6073
    … …  
    6275
    6376/*****************************************************************************/
     77
    6478/* FUNCTION IMPLEMENTATION - LOCAL                                           */
     79
    6580/*****************************************************************************/
    6681
    … …  
    6883
    6984/*****************************************************************************/
     85
    7086/*  FUNCTION IMPLEMENTATION - PUBLIC                                         */
     87
    7188/*****************************************************************************/
    7289
    … …  
    7693    evaluated Gaussian is: \f[ exp(-\frac{(x-mean)^2}{2\sigma^2}) \f]
    7794 *****************************************************************************/
    78 float
    79 psGaussian(float x,
    80            float mean,
    81            float sigma,
    82            bool  normal)
     95float psGaussian(float x, float mean, float sigma, bool normal)
    8396{
    8497    float tmp = 1.0;
    … …  
    94107    }
    95108
    96     return(tmp * exp(-((x-mean) * (x-mean)) / (2.0 * sigma * sigma)));
     109    return (tmp * exp(-((x - mean) * (x - mean)) / (2.0 * sigma * sigma)));
    97110}
    98111
    … …  
    107120 NOTE: There is no way to seed the random generator.
    108121 *****************************************************************************/
    109 psVector *psGaussianDev(float mean,
    110                         float sigma,
    111                         int Npts)
     122psVector *psGaussianDev(float mean, float sigma, int Npts)
    112123{
    113124    psVector *gauss = NULL;
    … …  
    127138
    128139    // NOTE: Should I free r as well?
    129     return(gauss);
    130 }
    131 
     140    return (gauss);
     141}
    132142
    133143/*****************************************************************************
    … …  
    140150
    141151    newPoly = (psPolynomial1D *) psAlloc(sizeof(psPolynomial1D));
    142     p_psMemSetDeallocator(newPoly,(psFreeFcn)polynomial1DFree);
     152    p_psMemSetDeallocator(newPoly, (psFreeFcn) polynomial1DFree);
    143153    newPoly->n = n;
    144     newPoly->coeff    = (float *) psAlloc(n * sizeof(float));
    145     newPoly->coeffErr = (float *) psAlloc(n * sizeof(float));
    146     newPoly->mask     = (char *)  psAlloc(n * sizeof(char));
    147     for (i=0;i<n;i++) {
     154    newPoly->coeff = (float *)psAlloc(n * sizeof(float));
     155    newPoly->coeffErr = (float *)psAlloc(n * sizeof(float));
     156    newPoly->mask = (char *)psAlloc(n * sizeof(char));
     157    for (i = 0; i < n; i++) {
    148158        newPoly->coeff[i] = 0.0;
    149159        newPoly->coeffErr[i] = 0.0;
    … …  
    151161    }
    152162
    153     return(newPoly);
     163    return (newPoly);
    154164}
    155165
    … …  
    161171
    162172    newPoly = (psPolynomial2D *) psAlloc(sizeof(psPolynomial2D));
    163     p_psMemSetDeallocator(newPoly,(psFreeFcn)polynomial2DFree);
     173    p_psMemSetDeallocator(newPoly, (psFreeFcn) polynomial2DFree);
    164174    newPoly->nX = nX;
    165175    newPoly->nY = nY;
    166176
    167     newPoly->coeff    = (float **) psAlloc(nX * sizeof(float *));
    168     newPoly->coeffErr = (float **) psAlloc(nX * sizeof(float *));
    169     newPoly->mask     = (char **)  psAlloc(nX * sizeof(char *));
    170     for (x=0;x<nX;x++) {
    171         newPoly->coeff[x]    = (float *) psAlloc(nY * sizeof(float));
    172         newPoly->coeffErr[x] = (float *) psAlloc(nY * sizeof(float));
    173         newPoly->mask[x]     = (char *)  psAlloc(nY * sizeof(char));
    174     }
    175     for (x=0;x<nX;x++) {
    176         for (y=0;y<nY;y++) {
     177    newPoly->coeff = (float **)psAlloc(nX * sizeof(float *));
     178    newPoly->coeffErr = (float **)psAlloc(nX * sizeof(float *));
     179    newPoly->mask = (char **)psAlloc(nX * sizeof(char *));
     180    for (x = 0; x < nX; x++) {
     181        newPoly->coeff[x] = (float *)psAlloc(nY * sizeof(float));
     182        newPoly->coeffErr[x] = (float *)psAlloc(nY * sizeof(float));
     183        newPoly->mask[x] = (char *)psAlloc(nY * sizeof(char));
     184    }
     185    for (x = 0; x < nX; x++) {
     186        for (y = 0; y < nY; y++) {
    177187            newPoly->coeff[x][y] = 0.0;
    178188            newPoly->coeffErr[x][y] = 0.0;
    … …  
    181191    }
    182192
    183     return(newPoly);
     193    return (newPoly);
    184194}
    185195
    … …  
    192202
    193203    newPoly = (psPolynomial3D *) psAlloc(sizeof(psPolynomial3D));
    194     p_psMemSetDeallocator(newPoly,(psFreeFcn)polynomial3DFree);
     204    p_psMemSetDeallocator(newPoly, (psFreeFcn) polynomial3DFree);
    195205    newPoly->nX = nX;
    196206    newPoly->nY = nY;
    197207    newPoly->nZ = nZ;
    198208
    199     newPoly->coeff    = (float ***) psAlloc(nX * sizeof(float **));
    200     newPoly->coeffErr = (float ***) psAlloc(nX * sizeof(float **));
    201     newPoly->mask     = (char ***)  psAlloc(nX * sizeof(char **));
    202     for (x=0;x<nX;x++) {
    203         newPoly->coeff[x]    = (float **) psAlloc(nY * sizeof(float *));
    204         newPoly->coeffErr[x] = (float **) psAlloc(nY * sizeof(float *));
    205         newPoly->mask[x]     = (char **)  psAlloc(nY * sizeof(char *));
    206         for (y=0;y<nY;y++) {
    207             newPoly->coeff[x][y]    = (float *) psAlloc(nZ * sizeof(float));
    208             newPoly->coeffErr[x][y] = (float *) psAlloc(nZ * sizeof(float));
    209             newPoly->mask[x][y]     = (char *)  psAlloc(nZ * sizeof(char));
    210         }
    211     }
    212     for (x=0;x<nX;x++) {
    213         for (y=0;y<nY;y++) {
    214             for (z=0;z<nZ;z++) {
     209    newPoly->coeff = (float ***)psAlloc(nX * sizeof(float **));
     210    newPoly->coeffErr = (float ***)psAlloc(nX * sizeof(float **));
     211    newPoly->mask = (char ***)psAlloc(nX * sizeof(char **));
     212    for (x = 0; x < nX; x++) {
     213        newPoly->coeff[x] = (float **)psAlloc(nY * sizeof(float *));
     214        newPoly->coeffErr[x] = (float **)psAlloc(nY * sizeof(float *));
     215        newPoly->mask[x] = (char **)psAlloc(nY * sizeof(char *));
     216        for (y = 0; y < nY; y++) {
     217            newPoly->coeff[x][y] = (float *)psAlloc(nZ * sizeof(float));
     218            newPoly->coeffErr[x][y] = (float *)psAlloc(nZ * sizeof(float));
     219            newPoly->mask[x][y] = (char *)psAlloc(nZ * sizeof(char));
     220        }
     221    }
     222    for (x = 0; x < nX; x++) {
     223        for (y = 0; y < nY; y++) {
     224            for (z = 0; z < nZ; z++) {
    215225                newPoly->coeff[x][y][z] = 0.0;
    216226                newPoly->coeffErr[x][y][z] = 0.0;
    … …  
    220230    }
    221231
    222     return(newPoly);
     232    return (newPoly);
    223233}
    224234
    … …  
    232242
    233243    newPoly = (psPolynomial4D *) psAlloc(sizeof(psPolynomial4D));
    234     p_psMemSetDeallocator(newPoly,(psFreeFcn)polynomial4DFree);
     244    p_psMemSetDeallocator(newPoly, (psFreeFcn) polynomial4DFree);
    235245    newPoly->nW = nW;
    236246    newPoly->nX = nX;
    … …  
    238248    newPoly->nZ = nZ;
    239249
    240     newPoly->coeff    = (float ****) psAlloc(nW * sizeof(float ***));
    241     newPoly->coeffErr = (float ****) psAlloc(nW * sizeof(float ***));
    242     newPoly->mask     = (char ****)  psAlloc(nW * sizeof(char ***));
    243     for (w=0;w<nW;w++) {
    244         newPoly->coeff[w]    = (float ***) psAlloc(nX * sizeof(float **));
    245         newPoly->coeffErr[w] = (float ***) psAlloc(nX * sizeof(float **));
    246         newPoly->mask[w]     = (char ***)  psAlloc(nX * sizeof(char **));
    247         for (x=0;x<nX;x++) {
    248             newPoly->coeff[w][x]    = (float **) psAlloc(nY * sizeof(float *));
    249             newPoly->coeffErr[w][x] = (float **) psAlloc(nY * sizeof(float *));
    250             newPoly->mask[w][x]     = (char **) psAlloc(nY * sizeof(char *));
    251             for (y=0;y<nY;y++) {
    252                 newPoly->coeff[w][x][y]    = (float *) psAlloc(nZ * sizeof(float));
    253                 newPoly->coeffErr[w][x][y] = (float *) psAlloc(nZ * sizeof(float));
    254                 newPoly->mask[w][x][y]     = (char *) psAlloc(nZ * sizeof(char));
    255             }
    256         }
    257     }
    258     for (w=0;w<nW;w++) {
    259         for (x=0;x<nX;x++) {
    260             for (y=0;y<nY;y++) {
    261                 for (z=0;z<nZ;z++) {
     250    newPoly->coeff = (float ****)psAlloc(nW * sizeof(float ***));
     251    newPoly->coeffErr = (float ****)psAlloc(nW * sizeof(float ***));
     252    newPoly->mask = (char ****)psAlloc(nW * sizeof(char ***));
     253    for (w = 0; w < nW; w++) {
     254        newPoly->coeff[w] = (float ***)psAlloc(nX * sizeof(float **));
     255        newPoly->coeffErr[w] = (float ***)psAlloc(nX * sizeof(float **));
     256        newPoly->mask[w] = (char ***)psAlloc(nX * sizeof(char **));
     257        for (x = 0; x < nX; x++) {
     258            newPoly->coeff[w][x] = (float **)psAlloc(nY * sizeof(float *));
     259            newPoly->coeffErr[w][x] = (float **)psAlloc(nY * sizeof(float *));
     260            newPoly->mask[w][x] = (char **)psAlloc(nY * sizeof(char *));
     261            for (y = 0; y < nY; y++) {
     262                newPoly->coeff[w][x][y] = (float *)psAlloc(nZ * sizeof(float));
     263                newPoly->coeffErr[w][x][y] = (float *)psAlloc(nZ * sizeof(float));
     264                newPoly->mask[w][x][y] = (char *)psAlloc(nZ * sizeof(char));
     265            }
     266        }
     267    }
     268    for (w = 0; w < nW; w++) {
     269        for (x = 0; x < nX; x++) {
     270            for (y = 0; y < nY; y++) {
     271                for (z = 0; z < nZ; z++) {
    262272                    newPoly->coeff[w][x][y][z] = 0.0;
    263273                    newPoly->coeffErr[w][x][y][z] = 0.0;
    … …  
    268278    }
    269279
    270     return(newPoly);
    271 }
    272 
    273 static void polynomial1DFree(psPolynomial1D *myPoly)
     280    return (newPoly);
     281}
     282
     283static void polynomial1DFree(psPolynomial1D * myPoly)
    274284{
    275285    psFree(myPoly->coeff);
    … …  
    278288}
    279289
    280 static void polynomial2DFree(psPolynomial2D *myPoly)
    281 {
    282     int x = 0;
    283 
    284     for (x=0;x<myPoly->nX;x++) {
     290static void polynomial2DFree(psPolynomial2D * myPoly)
     291{
     292    int x = 0;
     293
     294    for (x = 0; x < myPoly->nX; x++) {
    285295        psFree(myPoly->coeff[x]);
    286296        psFree(myPoly->coeffErr[x]);
    … …  
    292302}
    293303
    294 static void polynomial3DFree(psPolynomial3D *myPoly)
    295 {
    296     int x = 0;
    297     int y = 0;
    298 
    299     for (x=0;x<myPoly->nX;x++) {
    300         for (y=0;y<myPoly->nY;y++) {
     304static void polynomial3DFree(psPolynomial3D * myPoly)
     305{
     306    int x = 0;
     307    int y = 0;
     308
     309    for (x = 0; x < myPoly->nX; x++) {
     310        for (y = 0; y < myPoly->nY; y++) {
    301311            psFree(myPoly->coeff[x][y]);
    302312            psFree(myPoly->coeffErr[x][y]);
    … …  
    313323}
    314324
    315 static void polynomial4DFree(psPolynomial4D *myPoly)
     325static void polynomial4DFree(psPolynomial4D * myPoly)
    316326{
    317327    int w = 0;
    … …  
    319329    int y = 0;
    320330
    321     for (w=0;w<myPoly->nW;w++) {
    322         for (x=0;x<myPoly->nX;x++) {
    323             for (y=0;y<myPoly->nY;y++) {
     331    for (w = 0; w < myPoly->nW; w++) {
     332        for (x = 0; x < myPoly->nX; x++) {
     333            for (y = 0; y < myPoly->nY; y++) {
    324334                psFree(myPoly->coeff[w][x][y]);
    325335                psFree(myPoly->coeffErr[w][x][y]);
    … …  
    343353    Polynomial coefficients will be accessed in [w][x][y][z] fashion.
    344354 *****************************************************************************/
    345 float
    346 psPolynomial1DEval(float x,
    347                    const psPolynomial1D *myPoly)
     355float psPolynomial1DEval(float x, const psPolynomial1D * myPoly)
    348356{
    349357    int loop_x = 0;
    … …  
    355363    }
    356364
    357 
    358365    // NOTE: Do we want to flag this case?
    359366    if (myPoly->n == 0) {
    360         return(1.0);
     367        return (1.0);
    361368    }
    362369
    … …  
    365372    }
    366373
    367     for (loop_x=0;loop_x<myPoly->n;loop_x++) {
    368         polySum+= xSum * myPoly->coeff[loop_x];
    369         xSum*=x;
    370     }
    371 
    372     return(polySum);
    373 }
    374 
    375 
    376 float
    377 psPolynomial2DEval(float x,
    378                    float y,
    379                    const psPolynomial2D *myPoly)
     374    for (loop_x = 0; loop_x < myPoly->n; loop_x++) {
     375        polySum += xSum * myPoly->coeff[loop_x];
     376        xSum *= x;
     377    }
     378
     379    return (polySum);
     380}
     381
     382float psPolynomial2DEval(float x, float y, const psPolynomial2D * myPoly)
    380383{
    381384    int loop_x = 0;
    … …  
    385388    float ySum = 1.0;
    386389
    387     for (loop_x=0;loop_x<myPoly->nX;loop_x++) {
     390    for (loop_x = 0; loop_x < myPoly->nX; loop_x++) {
    388391        ySum = xSum;
    389         for (loop_y=0;loop_y<myPoly->nY;loop_y++) {
    390             polySum+= ySum * myPoly->coeff[loop_x][loop_y];
    391             ySum*=y;
    392         }
    393         xSum*=x;
    394     }
    395 
    396     return(polySum);
    397 }
    398 
    399 float
    400 psPolynomial3DEval(float x,
    401                    float y,
    402                    float z,
    403                    const psPolynomial3D *myPoly)
     392        for (loop_y = 0; loop_y < myPoly->nY; loop_y++) {
     393            polySum += ySum * myPoly->coeff[loop_x][loop_y];
     394            ySum *= y;
     395        }
     396        xSum *= x;
     397    }
     398
     399    return (polySum);
     400}
     401
     402float psPolynomial3DEval(float x, float y, float z, const psPolynomial3D * myPoly)
    404403{
    405404    int loop_x = 0;
    … …  
    411410    float zSum = 1.0;
    412411
    413     for (loop_x=0;loop_x<myPoly->nX;loop_x++) {
     412    for (loop_x = 0; loop_x < myPoly->nX; loop_x++) {
    414413        ySum = xSum;
    415         for (loop_y=0;loop_y<myPoly->nY;loop_y++) {
     414        for (loop_y = 0; loop_y < myPoly->nY; loop_y++) {
    416415            zSum = ySum;
    417             for (loop_z=0;loop_z<myPoly->nZ;loop_z++) {
    418                 polySum+= zSum * myPoly->coeff[loop_x][loop_y][loop_z];
    419                 zSum*=z;
    420             }
    421             ySum*=y;
    422         }
    423         xSum*=x;
    424     }
    425 
    426     return(polySum);
    427 }
    428 
    429 float
    430 psPolynomial4DEval(float w,
    431                    float x,
    432                    float y,
    433                    float z,
    434                    const psPolynomial4D *myPoly)
     416            for (loop_z = 0; loop_z < myPoly->nZ; loop_z++) {
     417                polySum += zSum * myPoly->coeff[loop_x][loop_y][loop_z];
     418                zSum *= z;
     419            }
     420            ySum *= y;
     421        }
     422        xSum *= x;
     423    }
     424
     425    return (polySum);
     426}
     427
     428float psPolynomial4DEval(float w, float x, float y, float z, const psPolynomial4D * myPoly)
    435429{
    436430    int loop_w = 0;
    … …  
    444438    float zSum = 1.0;
    445439
    446     for (loop_w=0;loop_w<myPoly->nW;loop_w++) {
     440    for (loop_w = 0; loop_w < myPoly->nW; loop_w++) {
    447441        xSum = wSum;
    448         for (loop_x=0;loop_x<myPoly->nX;loop_x++) {
     442        for (loop_x = 0; loop_x < myPoly->nX; loop_x++) {
    449443            ySum = xSum;
    450             for (loop_y=0;loop_y<myPoly->nY;loop_y++) {
     444            for (loop_y = 0; loop_y < myPoly->nY; loop_y++) {
    451445                zSum = ySum;
    452                 for (loop_z=0;loop_z<myPoly->nZ;loop_z++) {
    453                     polySum+= zSum *
    454                               myPoly->coeff[loop_w][loop_x][loop_y][loop_z];
    455                     zSum*=z;
     446                for (loop_z = 0; loop_z < myPoly->nZ; loop_z++) {
     447                    polySum += zSum * myPoly->coeff[loop_w][loop_x][loop_y][loop_z];
     448                    zSum *= z;
    456449                }
    457                 ySum*=y;
    458             }
    459             xSum*=x;
    460         }
    461         wSum*=w;
    462     }
    463 
    464     return(polySum);
    465 }
    466 
    467 
    468 
     450                ySum *= y;
     451            }
     452            xSum *= x;
     453        }
     454        wSum *= w;
     455    }
     456
     457    return (polySum);
     458}
    469459
    470460psDPolynomial1D *psDPolynomial1DAlloc(int n)
    … …  
    474464
    475465    newPoly = (psDPolynomial1D *) psAlloc(sizeof(psDPolynomial1D));
    476     p_psMemSetDeallocator(newPoly,(psFreeFcn)dPolynomial1DFree);
     466    p_psMemSetDeallocator(newPoly, (psFreeFcn) dPolynomial1DFree);
    477467    newPoly->n = n;
    478     newPoly->coeff    = (double *) psAlloc(n * sizeof(double));
    479     newPoly->coeffErr = (double *) psAlloc(n * sizeof(double));
    480     newPoly->mask     = (char *)  psAlloc(n * sizeof(char));
    481     for (i=0;i<n;i++) {
     468    newPoly->coeff = (double *)psAlloc(n * sizeof(double));
     469    newPoly->coeffErr = (double *)psAlloc(n * sizeof(double));
     470    newPoly->mask = (char *)psAlloc(n * sizeof(char));
     471    for (i = 0; i < n; i++) {
    482472        newPoly->coeff[i] = 0.0;
    483473        newPoly->coeffErr[i] = 0.0;
    … …  
    485475    }
    486476
    487     return(newPoly);
     477    return (newPoly);
    488478}
    489479
    … …  
    495485
    496486    newPoly = (psDPolynomial2D *) psAlloc(sizeof(psDPolynomial2D));
    497     p_psMemSetDeallocator(newPoly,(psFreeFcn)dPolynomial2DFree);
     487    p_psMemSetDeallocator(newPoly, (psFreeFcn) dPolynomial2DFree);
    498488    newPoly->nX = nX;
    499489    newPoly->nY = nY;
    500490
    501     newPoly->coeff    = (double **) psAlloc(nX * sizeof(double *));
    502     newPoly->coeffErr = (double **) psAlloc(nX * sizeof(double *));
    503     newPoly->mask     = (char **)  psAlloc(nX * sizeof(char *));
    504     for (x=0;x<nX;x++) {
    505         newPoly->coeff[x]    = (double *) psAlloc(nY * sizeof(double));
    506         newPoly->coeffErr[x] = (double *) psAlloc(nY * sizeof(double));
    507         newPoly->mask[x]     = (char *)  psAlloc(nY * sizeof(char));
    508     }
    509     for (x=0;x<nX;x++) {
    510         for (y=0;y<nY;y++) {
     491    newPoly->coeff = (double **)psAlloc(nX * sizeof(double *));
     492    newPoly->coeffErr = (double **)psAlloc(nX * sizeof(double *));
     493    newPoly->mask = (char **)psAlloc(nX * sizeof(char *));
     494    for (x = 0; x < nX; x++) {
     495        newPoly->coeff[x] = (double *)psAlloc(nY * sizeof(double));
     496        newPoly->coeffErr[x] = (double *)psAlloc(nY * sizeof(double));
     497        newPoly->mask[x] = (char *)psAlloc(nY * sizeof(char));
     498    }
     499    for (x = 0; x < nX; x++) {
     500        for (y = 0; y < nY; y++) {
    511501            newPoly->coeff[x][y] = 0.0;
    512502            newPoly->coeffErr[x][y] = 0.0;
    … …  
    515505    }
    516506
    517     return(newPoly);
     507    return (newPoly);
    518508}
    519509
    … …  
    526516
    527517    newPoly = (psDPolynomial3D *) psAlloc(sizeof(psDPolynomial3D));
    528     p_psMemSetDeallocator(newPoly,(psFreeFcn)dPolynomial3DFree);
     518    p_psMemSetDeallocator(newPoly, (psFreeFcn) dPolynomial3DFree);
    529519    newPoly->nX = nX;
    530520    newPoly->nY = nY;
    531521    newPoly->nZ = nZ;
    532522
    533     newPoly->coeff    = (double ***) psAlloc(nX * sizeof(double **));
    534     newPoly->coeffErr = (double ***) psAlloc(nX * sizeof(double **));
    535     newPoly->mask     = (char ***)  psAlloc(nX * sizeof(char **));
    536     for (x=0;x<nX;x++) {
    537         newPoly->coeff[x]    = (double **) psAlloc(nY * sizeof(double *));
    538         newPoly->coeffErr[x] = (double **) psAlloc(nY * sizeof(double *));
    539         newPoly->mask[x]     = (char **)  psAlloc(nY * sizeof(char *));
    540         for (y=0;y<nY;y++) {
    541             newPoly->coeff[x][y]    = (double *) psAlloc(nZ * sizeof(double));
    542             newPoly->coeffErr[x][y] = (double *) psAlloc(nZ * sizeof(double));
    543             newPoly->mask[x][y]     = (char *)  psAlloc(nZ * sizeof(char));
    544         }
    545     }
    546     for (x=0;x<nX;x++) {
    547         for (y=0;y<nY;y++) {
    548             for (z=0;z<nZ;z++) {
     523    newPoly->coeff = (double ***)psAlloc(nX * sizeof(double **));
     524    newPoly->coeffErr = (double ***)psAlloc(nX * sizeof(double **));
     525    newPoly->mask = (char ***)psAlloc(nX * sizeof(char **));
     526    for (x = 0; x < nX; x++) {
     527        newPoly->coeff[x] = (double **)psAlloc(nY * sizeof(double *));
     528        newPoly->coeffErr[x] = (double **)psAlloc(nY * sizeof(double *));
     529        newPoly->mask[x] = (char **)psAlloc(nY * sizeof(char *));
     530        for (y = 0; y < nY; y++) {
     531            newPoly->coeff[x][y] = (double *)psAlloc(nZ * sizeof(double));
     532            newPoly->coeffErr[x][y] = (double *)psAlloc(nZ * sizeof(double));
     533            newPoly->mask[x][y] = (char *)psAlloc(nZ * sizeof(char));
     534        }
     535    }
     536    for (x = 0; x < nX; x++) {
     537        for (y = 0; y < nY; y++) {
     538            for (z = 0; z < nZ; z++) {
    549539                newPoly->coeff[x][y][z] = 0.0;
    550540                newPoly->coeffErr[x][y][z] = 0.0;
    … …  
    554544    }
    555545
    556     return(newPoly);
     546    return (newPoly);
    557547}
    558548
    … …  
    566556
    567557    newPoly = (psDPolynomial4D *) psAlloc(sizeof(psDPolynomial4D));
    568     p_psMemSetDeallocator(newPoly,(psFreeFcn)dPolynomial4DFree);
     558    p_psMemSetDeallocator(newPoly, (psFreeFcn) dPolynomial4DFree);
    569559    newPoly->nW = nW;
    570560    newPoly->nX = nX;
    … …  
    572562    newPoly->nZ = nZ;
    573563
    574     newPoly->coeff    = (double ****) psAlloc(nW * sizeof(double ***));
    575     newPoly->coeffErr = (double ****) psAlloc(nW * sizeof(double ***));
    576     newPoly->mask     = (char ****)  psAlloc(nW * sizeof(char ***));
    577     for (w=0;w<nW;w++) {
    578         newPoly->coeff[w]    = (double ***) psAlloc(nX * sizeof(double **));
    579         newPoly->coeffErr[w] = (double ***) psAlloc(nX * sizeof(double **));
    580         newPoly->mask[w]     = (char ***)  psAlloc(nX * sizeof(char **));
    581         for (x=0;x<nX;x++) {
    582             newPoly->coeff[w][x]    = (double **) psAlloc(nY * sizeof(double *));
    583             newPoly->coeffErr[w][x] = (double **) psAlloc(nY * sizeof(double *));
    584             newPoly->mask[w][x]     = (char **) psAlloc(nY * sizeof(char *));
    585             for (y=0;y<nY;y++) {
    586                 newPoly->coeff[w][x][y]    = (double *) psAlloc(nZ * sizeof(double));
    587                 newPoly->coeffErr[w][x][y] = (double *) psAlloc(nZ * sizeof(double));
    588                 newPoly->mask[w][x][y]     = (char *) psAlloc(nZ * sizeof(char));
    589             }
    590         }
    591     }
    592     for (w=0;w<nW;w++) {
    593         for (x=0;x<nX;x++) {
    594             for (y=0;y<nY;y++) {
    595                 for (z=0;z<nZ;z++) {
     564    newPoly->coeff = (double ****)psAlloc(nW * sizeof(double ***));
     565    newPoly->coeffErr = (double ****)psAlloc(nW * sizeof(double ***));
     566    newPoly->mask = (char ****)psAlloc(nW * sizeof(char ***));
     567    for (w = 0; w < nW; w++) {
     568        newPoly->coeff[w] = (double ***)psAlloc(nX * sizeof(double **));
     569        newPoly->coeffErr[w] = (double ***)psAlloc(nX * sizeof(double **));
     570        newPoly->mask[w] = (char ***)psAlloc(nX * sizeof(char **));
     571        for (x = 0; x < nX; x++) {
     572            newPoly->coeff[w][x] = (double **)psAlloc(nY * sizeof(double *));
     573            newPoly->coeffErr[w][x] = (double **)psAlloc(nY * sizeof(double *));
     574            newPoly->mask[w][x] = (char **)psAlloc(nY * sizeof(char *));
     575            for (y = 0; y < nY; y++) {
     576                newPoly->coeff[w][x][y] = (double *)psAlloc(nZ * sizeof(double));
     577                newPoly->coeffErr[w][x][y] = (double *)psAlloc(nZ * sizeof(double));
     578                newPoly->mask[w][x][y] = (char *)psAlloc(nZ * sizeof(char));
     579            }
     580        }
     581    }
     582    for (w = 0; w < nW; w++) {
     583        for (x = 0; x < nX; x++) {
     584            for (y = 0; y < nY; y++) {
     585                for (z = 0; z < nZ; z++) {
    596586                    newPoly->coeff[w][x][y][z] = 0.0;
    597587                    newPoly->coeffErr[w][x][y][z] = 0.0;
    … …  
    602592    }
    603593
    604     return(newPoly);
    605 }
    606 
    607 static void dPolynomial1DFree(psDPolynomial1D *myPoly)
     594    return (newPoly);
     595}
     596
     597static void dPolynomial1DFree(psDPolynomial1D * myPoly)
    608598{
    609599    psFree(myPoly->coeff);
    … …  
    612602}
    613603
    614 static void dPolynomial2DFree(psDPolynomial2D *myPoly)
    615 {
    616     int x = 0;
    617 
    618     for (x=0;x<myPoly->nX;x++) {
     604static void dPolynomial2DFree(psDPolynomial2D * myPoly)
     605{
     606    int x = 0;
     607
     608    for (x = 0; x < myPoly->nX; x++) {
    619609        psFree(myPoly->coeff[x]);
    620610        psFree(myPoly->coeffErr[x]);
    … …  
    626616}
    627617
    628 static void dPolynomial3DFree(psDPolynomial3D *myPoly)
    629 {
    630     int x = 0;
    631     int y = 0;
    632 
    633     for (x=0;x<myPoly->nX;x++) {
    634         for (y=0;y<myPoly->nY;y++) {
     618static void dPolynomial3DFree(psDPolynomial3D * myPoly)
     619{
     620    int x = 0;
     621    int y = 0;
     622
     623    for (x = 0; x < myPoly->nX; x++) {
     624        for (y = 0; y < myPoly->nY; y++) {
    635625            psFree(myPoly->coeff[x][y]);
    636626            psFree(myPoly->coeffErr[x][y]);
    … …  
    647637}
    648638
    649 static void dPolynomial4DFree(psDPolynomial4D *myPoly)
     639static void dPolynomial4DFree(psDPolynomial4D * myPoly)
    650640{
    651641    int w = 0;
    … …  
    653643    int y = 0;
    654644
    655     for (w=0;w<myPoly->nW;w++) {
    656         for (x=0;x<myPoly->nX;x++) {
    657             for (y=0;y<myPoly->nY;y++) {
     645    for (w = 0; w < myPoly->nW; w++) {
     646        for (x = 0; x < myPoly->nX; x++) {
     647            for (y = 0; y < myPoly->nY; y++) {
    658648                psFree(myPoly->coeff[w][x][y]);
    659649                psFree(myPoly->coeffErr[w][x][y]);
    … …  
    677667    Polynomial coefficients will be accessed in [w][x][y][z] fashion.
    678668 *****************************************************************************/
    679 double
    680 psDPolynomial1DEval(double x,
    681                     const psDPolynomial1D *myPoly)
     669double psDPolynomial1DEval(double x, const psDPolynomial1D * myPoly)
    682670{
    683671    int loop_x = 0;
    … …  
    687675    // NOTE: Do we want to flag this case?
    688676    if (myPoly->n == 0) {
    689         return(1.0);
    690     }
    691 
    692     for (loop_x=0;loop_x<myPoly->n;loop_x++) {
    693         polySum+= xSum * myPoly->coeff[loop_x];
    694         xSum*=x;
    695     }
    696 
    697     return(polySum);
    698 }
    699 
    700 
    701 double
    702 psDPolynomial2DEval(double x,
    703                     double y,
    704                     const psDPolynomial2D *myPoly)
     677        return (1.0);
     678    }
     679
     680    for (loop_x = 0; loop_x < myPoly->n; loop_x++) {
     681        polySum += xSum * myPoly->coeff[loop_x];
     682        xSum *= x;
     683    }
     684
     685    return (polySum);
     686}
     687
     688double psDPolynomial2DEval(double x, double y, const psDPolynomial2D * myPoly)
    705689{
    706690    int loop_x = 0;
    … …  
    710694    double ySum = 1.0;
    711695
    712     for (loop_x=0;loop_x<myPoly->nX;loop_x++) {
     696    for (loop_x = 0; loop_x < myPoly->nX; loop_x++) {
    713697        ySum = xSum;
    714         for (loop_y=0;loop_y<myPoly->nY;loop_y++) {
    715             polySum+= ySum * myPoly->coeff[loop_x][loop_y];
    716             ySum*=y;
    717         }
    718         xSum*=x;
    719     }
    720 
    721     return(polySum);
    722 }
    723 
    724 double
    725 psDPolynomial3DEval(double x,
    726                     double y,
    727                     double z,
    728                     const psDPolynomial3D *myPoly)
     698        for (loop_y = 0; loop_y < myPoly->nY; loop_y++) {
     699            polySum += ySum * myPoly->coeff[loop_x][loop_y];
     700            ySum *= y;
     701        }
     702        xSum *= x;
     703    }
     704
     705    return (polySum);
     706}
     707
     708double psDPolynomial3DEval(double x, double y, double z, const psDPolynomial3D * myPoly)
    729709{
    730710    int loop_x = 0;
    … …  
    736716    double zSum = 1.0;
    737717
    738     for (loop_x=0;loop_x<myPoly->nX;loop_x++) {
     718    for (loop_x = 0; loop_x < myPoly->nX; loop_x++) {
    739719        ySum = xSum;
    740         for (loop_y=0;loop_y<myPoly->nY;loop_y++) {
     720        for (loop_y = 0; loop_y < myPoly->nY; loop_y++) {
    741721            zSum = ySum;
    742             for (loop_z=0;loop_z<myPoly->nZ;loop_z++) {
    743                 polySum+= zSum * myPoly->coeff[loop_x][loop_y][loop_z];
    744                 zSum*=z;
    745             }
    746             ySum*=y;
    747         }
    748         xSum*=x;
    749     }
    750 
    751     return(polySum);
    752 }
    753 
    754 double
    755 psDPolynomial4DEval(double w,
    756                     double x,
    757                     double y,
    758                     double z,
    759                     const psDPolynomial4D *myPoly)
     722            for (loop_z = 0; loop_z < myPoly->nZ; loop_z++) {
     723                polySum += zSum * myPoly->coeff[loop_x][loop_y][loop_z];
     724                zSum *= z;
     725            }
     726            ySum *= y;
     727        }
     728        xSum *= x;
     729    }
     730
     731    return (polySum);
     732}
     733
     734double psDPolynomial4DEval(double w, double x, double y, double z, const psDPolynomial4D * myPoly)
    760735{
    761736    int loop_w = 0;
    … …  
    769744    double zSum = 1.0;
    770745
    771     for (loop_w=0;loop_w<myPoly->nW;loop_w++) {
     746    for (loop_w = 0; loop_w < myPoly->nW; loop_w++) {
    772747        xSum = wSum;
    773         for (loop_x=0;loop_x<myPoly->nX;loop_x++) {
     748        for (loop_x = 0; loop_x < myPoly->nX; loop_x++) {
    774749            ySum = xSum;
    775             for (loop_y=0;loop_y<myPoly->nY;loop_y++) {
     750            for (loop_y = 0; loop_y < myPoly->nY; loop_y++) {
    776751                zSum = ySum;
    777                 for (loop_z=0;loop_z<myPoly->nZ;loop_z++) {
    778                     polySum+= zSum *
    779                               myPoly->coeff[loop_w][loop_x][loop_y][loop_z];
    780                     zSum*=z;
     752                for (loop_z = 0; loop_z < myPoly->nZ; loop_z++) {
     753                    polySum += zSum * myPoly->coeff[loop_w][loop_x][loop_y][loop_z];
     754                    zSum *= z;
    781755                }
    782                 ySum*=y;
    783             }
    784             xSum*=x;
    785         }
    786         wSum*=w;
    787     }
    788 
    789     return(polySum);
    790 }
     756                ySum *= y;
     757            }
     758            xSum *= x;
     759        }
     760        wSum *= w;
     761    }
     762
     763    return (polySum);
     764}
Note: See TracChangeset for help on using the changeset viewer.