IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Dec 21, 2004, 7:09:32 PM (22 years ago)
Author:
gusciora
Message:

Changed types to PS types.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r2778 r2788  
    77 *  polynomials.  It also contains a Gaussian functions.
    88 *
    9  *  @version $Revision: 1.74 $ $Name: not supported by cvs2svn $
    10  *  @date $Date: 2004-12-21 20:42:07 $
     9 *  @version $Revision: 1.75 $ $Name: not supported by cvs2svn $
     10 *  @date $Date: 2004-12-22 05:09:32 $
    1111 *
    1212 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
    … …  
    5555static void dPolynomial4DFree(psDPolynomial4D* myPoly);
    5656static void spline1DFree(psSpline1D *tmpSpline);
    57 static psS32 vectorBinDisectF32(float *bins,psS32 numBins,float x);
     57static psS32 vectorBinDisectF32(psF32 *bins,psS32 numBins,psF32 x);
    5858static psS32 vectorBinDisectS32(psS32 *bins,psS32 numBins,psS32 x);
    5959
    … …  
    277277 
    278278 *****************************************************************************/
    279 static float ordPolynomial1DEval(float x, const psPolynomial1D* myPoly)
     279static psF32 ordPolynomial1DEval(psF32 x, const psPolynomial1D* myPoly)
    280280{
    281281    psS32 loop_x = 0;
    282     float polySum = 0.0;
    283     float xSum = 1.0;
     282    psF32 polySum = 0.0;
     283    psF32 xSum = 1.0;
    284284
    285285    psTrace(".psLib.dataManip.psFunctions.ordPolynomial1DEval", 4,
    … …  
    307307// XXX: How does the mask vector effect Crenshaw's formula?
    308308// XXX: We assume that x is scaled between -1.0 and 1.0;
    309 static float chebPolynomial1DEval(float x, const psPolynomial1D* myPoly)
     309static psF32 chebPolynomial1DEval(psF32 x, const psPolynomial1D* myPoly)
    310310{
    311311    //    PS_FLOAT_CHECK_RANGE(x, -1.0, 1.0, 0.0);
    … …  
    314314    psS32 n;
    315315    psS32 i;
    316     float tmp;
     316    psF32 tmp;
    317317
    318318    n = myPoly->n;
    … …  
    337337    psS32 n;
    338338    psS32 i;
    339     float tmp;
     339    psF32 tmp;
    340340    psPolynomial1D **chebPolys = NULL;
    341341
    … …  
    355355}
    356356
    357 static float ordPolynomial2DEval(float x, float y, const psPolynomial2D* myPoly)
     357static psF32 ordPolynomial2DEval(psF32 x, psF32 y, const psPolynomial2D* myPoly)
    358358{
    359359    PS_POLY_CHECK_NULL(myPoly, NAN);
    … …  
    361361    psS32 loop_x = 0;
    362362    psS32 loop_y = 0;
    363     float polySum = 0.0;
    364     float xSum = 1.0;
    365     float ySum = 1.0;
     363    psF32 polySum = 0.0;
     364    psF32 xSum = 1.0;
     365    psF32 ySum = 1.0;
    366366
    367367    for (loop_x = 0; loop_x < myPoly->nX; loop_x++) {
    … …  
    379379}
    380380
    381 static float chebPolynomial2DEval(float x, float y, const psPolynomial2D* myPoly)
     381static psF32 chebPolynomial2DEval(psF32 x, psF32 y, const psPolynomial2D* myPoly)
    382382{
    383383    PS_POLY_CHECK_NULL(myPoly, NAN);
    … …  
    386386    psS32 loop_y = 0;
    387387    psS32 i = 0;
    388     float polySum = 0.0;
     388    psF32 polySum = 0.0;
    389389    psPolynomial1D* *chebPolys = NULL;
    390390    psS32 maxChebyPoly = 0;
    … …  
    414414}
    415415
    416 static float ordPolynomial3DEval(float x, float y, float z, const psPolynomial3D* myPoly)
     416static psF32 ordPolynomial3DEval(psF32 x, psF32 y, psF32 z, const psPolynomial3D* myPoly)
    417417{
    418418    psS32 loop_x = 0;
    419419    psS32 loop_y = 0;
    420420    psS32 loop_z = 0;
    421     float polySum = 0.0;
    422     float xSum = 1.0;
    423     float ySum = 1.0;
    424     float zSum = 1.0;
     421    psF32 polySum = 0.0;
     422    psF32 xSum = 1.0;
     423    psF32 ySum = 1.0;
     424    psF32 zSum = 1.0;
    425425
    426426    for (loop_x = 0; loop_x < myPoly->nX; loop_x++) {
    … …  
    442442}
    443443
    444 static float chebPolynomial3DEval(float x, float y, float z, const psPolynomial3D* myPoly)
     444static psF32 chebPolynomial3DEval(psF32 x, psF32 y, psF32 z, const psPolynomial3D* myPoly)
    445445{
    446446    psS32 loop_x = 0;
    … …  
    448448    psS32 loop_z = 0;
    449449    psS32 i = 0;
    450     float polySum = 0.0;
     450    psF32 polySum = 0.0;
    451451    psPolynomial1D* *chebPolys = NULL;
    452452    psS32 maxChebyPoly = 0;
    … …  
    483483}
    484484
    485 static float ordPolynomial4DEval(float w, float x, float y, float z, const psPolynomial4D* myPoly)
     485static psF32 ordPolynomial4DEval(psF32 w, psF32 x, psF32 y, psF32 z, const psPolynomial4D* myPoly)
    486486{
    487487    psS32 loop_w = 0;
    … …  
    489489    psS32 loop_y = 0;
    490490    psS32 loop_z = 0;
    491     float polySum = 0.0;
    492     float wSum = 1.0;
    493     float xSum = 1.0;
    494     float ySum = 1.0;
    495     float zSum = 1.0;
     491    psF32 polySum = 0.0;
     492    psF32 wSum = 1.0;
     493    psF32 xSum = 1.0;
     494    psF32 ySum = 1.0;
     495    psF32 zSum = 1.0;
    496496
    497497    for (loop_w = 0; loop_w < myPoly->nW; loop_w++) {
    … …  
    517517}
    518518
    519 static float chebPolynomial4DEval(float w, float x, float y, float z, const psPolynomial4D* myPoly)
     519static psF32 chebPolynomial4DEval(psF32 w, psF32 x, psF32 y, psF32 z, const psPolynomial4D* myPoly)
    520520{
    521521    psS32 loop_w = 0;
    … …  
    524524    psS32 loop_z = 0;
    525525    psS32 i = 0;
    526     float polySum = 0.0;
     526    psF32 polySum = 0.0;
    527527    psPolynomial1D* *chebPolys = NULL;
    528528    psS32 maxChebyPoly = 0;
    … …  
    568568    Polynomial coefficients will be accessed in [w][x][y][z] fashion.
    569569 *****************************************************************************/
    570 static double dOrdPolynomial1DEval(double x, const psDPolynomial1D* myPoly)
     570static psF64 dOrdPolynomial1DEval(psF64 x, const psDPolynomial1D* myPoly)
    571571{
    572572    psS32 loop_x = 0;
    573     double polySum = 0.0;
    574     double xSum = 1.0;
     573    psF64 polySum = 0.0;
     574    psF64 xSum = 1.0;
    575575
    576576    for (loop_x = 0; loop_x < myPoly->n; loop_x++) {
    … …  
    586586// XXX: You can do this without having to psAlloc() vector d.
    587587// XXX: How does the mask vector effect Crenshaw's formula?
    588 static double dChebPolynomial1DEval(double x, const psDPolynomial1D* myPoly)
     588static psF64 dChebPolynomial1DEval(psF64 x, const psDPolynomial1D* myPoly)
    589589{
    590590    psVector *d;
    591591    psS32 n;
    592592    psS32 i;
    593     double tmp;
     593    psF64 tmp;
    594594
    595595    n = myPoly->n;
    … …  
    611611}
    612612
    613 static double dOrdPolynomial2DEval(double x, double y, const psDPolynomial2D* myPoly)
     613static psF64 dOrdPolynomial2DEval(psF64 x, psF64 y, const psDPolynomial2D* myPoly)
    614614{
    615615    psS32 loop_x = 0;
    616616    psS32 loop_y = 0;
    617     double polySum = 0.0;
    618     double xSum = 1.0;
    619     double ySum = 1.0;
     617    psF64 polySum = 0.0;
     618    psF64 xSum = 1.0;
     619    psF64 ySum = 1.0;
    620620
    621621    for (loop_x = 0; loop_x < myPoly->nX; loop_x++) {
    … …  
    633633}
    634634
    635 static double dChebPolynomial2DEval(double x, double y, const psDPolynomial2D* myPoly)
     635static psF64 dChebPolynomial2DEval(psF64 x, psF64 y, const psDPolynomial2D* myPoly)
    636636{
    637637    psS32 loop_x = 0;
    638638    psS32 loop_y = 0;
    639639    psS32 i = 0;
    640     double polySum = 0.0;
     640    psF64 polySum = 0.0;
    641641    psPolynomial1D* *chebPolys = NULL;
    642642    psS32 maxChebyPoly = 0;
    … …  
    667667}
    668668
    669 static double dOrdPolynomial3DEval(double x, double y, double z, const psDPolynomial3D* myPoly)
     669static psF64 dOrdPolynomial3DEval(psF64 x, psF64 y, psF64 z, const psDPolynomial3D* myPoly)
    670670{
    671671    psS32 loop_x = 0;
    672672    psS32 loop_y = 0;
    673673    psS32 loop_z = 0;
    674     double polySum = 0.0;
    675     double xSum = 1.0;
    676     double ySum = 1.0;
    677     double zSum = 1.0;
     674    psF64 polySum = 0.0;
     675    psF64 xSum = 1.0;
     676    psF64 ySum = 1.0;
     677    psF64 zSum = 1.0;
    678678
    679679    for (loop_x = 0; loop_x < myPoly->nX; loop_x++) {
    … …  
    695695}
    696696
    697 static double dChebPolynomial3DEval(double x, double y, double z, const psDPolynomial3D* myPoly)
     697static psF64 dChebPolynomial3DEval(psF64 x, psF64 y, psF64 z, const psDPolynomial3D* myPoly)
    698698{
    699699    psS32 loop_x = 0;
    … …  
    701701    psS32 loop_z = 0;
    702702    psS32 i = 0;
    703     double polySum = 0.0;
     703    psF64 polySum = 0.0;
    704704    psPolynomial1D* *chebPolys = NULL;
    705705    psS32 maxChebyPoly = 0;
    … …  
    736736}
    737737
    738 static double dOrdPolynomial4DEval(double w, double x, double y, double z, const psDPolynomial4D* myPoly)
     738static psF64 dOrdPolynomial4DEval(psF64 w, psF64 x, psF64 y, psF64 z, const psDPolynomial4D* myPoly)
    739739{
    740740    psS32 loop_w = 0;
    … …  
    742742    psS32 loop_y = 0;
    743743    psS32 loop_z = 0;
    744     double polySum = 0.0;
    745     double wSum = 1.0;
    746     double xSum = 1.0;
    747     double ySum = 1.0;
    748     double zSum = 1.0;
     744    psF64 polySum = 0.0;
     745    psF64 wSum = 1.0;
     746    psF64 xSum = 1.0;
     747    psF64 ySum = 1.0;
     748    psF64 zSum = 1.0;
    749749
    750750    for (loop_w = 0; loop_w < myPoly->nW; loop_w++) {
    … …  
    770770}
    771771
    772 static double dChebPolynomial4DEval(double w, double x, double y, double z, const psDPolynomial4D* myPoly)
     772static psF64 dChebPolynomial4DEval(psF64 w, psF64 x, psF64 y, psF64 z, const psDPolynomial4D* myPoly)
    773773{
    774774    psS32 loop_w = 0;
    … …  
    777777    psS32 loop_z = 0;
    778778    psS32 i = 0;
    779     double polySum = 0.0;
     779    psF64 polySum = 0.0;
    780780    psPolynomial1D* *chebPolys = NULL;
    781781    psS32 maxChebyPoly = 0;
    … …  
    828828 *****************************************************************************/
    829829#define FUNC_MACRO_FULL_INTERPOLATE_1D(TYPE) \
    830 static float fullInterpolate1D##TYPE(ps##TYPE *domain, \
     830static psF32 fullInterpolate1D##TYPE(ps##TYPE *domain, \
    831831                                     ps##TYPE *range, \
    832832                                     psS32 n, \
    … …  
    896896LaGrange interpolation.
    897897 *****************************************************************************/
    898 static float interpolate1DF32(float *domain,
    899                               float *range,
     898static psF32 interpolate1DF32(psF32 *domain,
     899                              psF32 *range,
    900900                              psS32 n,
    901901                              psS32 order,
    902                               float x)
     902                              psF32 x)
    903903{
    904904    psS32 binNum;
    … …  
    941941    evaluated Gaussian is: \f[ exp(-\frac{(x-mean)^2}{2\sigma^2}) \f]
    942942 *****************************************************************************/
    943 float psGaussian(float x, float mean, float sigma, psBool normal)
    944 {
    945     float tmp = 1.0;
     943psF32 psGaussian(psF32 x, psF32 mean, psF32 sigma, psBool normal)
     944{
     945    psF32 tmp = 1.0;
    946946
    947947    psTrace(".psLib.dataManip.psFunctions.psGaussian", 4,
    … …  
    967967XXX: There is no way to seed the random generator.
    968968 *****************************************************************************/
    969 psVector* p_psGaussianDev(float mean, float sigma, psS32 Npts)
     969psVector* p_psGaussianDev(psF32 mean, psF32 sigma, psS32 Npts)
    970970{
    971971    PS_INT_CHECK_NON_NEGATIVE(Npts, NULL);
    … …  
    10071007    newPoly->type = type;
    10081008    newPoly->n = n;
    1009     newPoly->coeff = (float *)psAlloc(n * sizeof(float));
    1010     newPoly->coeffErr = (float *)psAlloc(n * sizeof(float));
    1011     newPoly->mask = (char *)psAlloc(n * sizeof(char));
     1009    newPoly->coeff = (psF32 *)psAlloc(n * sizeof(psF32));
     1010    newPoly->coeffErr = (psF32 *)psAlloc(n * sizeof(psF32));
     1011    newPoly->mask = (psU8 *)psAlloc(n * sizeof(psU8));
    10121012    for (i = 0; i < n; i++) {
    10131013        newPoly->coeff[i] = 0.0;
    … …  
    10361036    newPoly->nY = nY;
    10371037
    1038     newPoly->coeff = (float **)psAlloc(nX * sizeof(float *));
    1039     newPoly->coeffErr = (float **)psAlloc(nX * sizeof(float *));
    1040     newPoly->mask = (char **)psAlloc(nX * sizeof(char *));
     1038    newPoly->coeff = (psF32 **)psAlloc(nX * sizeof(psF32 *));
     1039    newPoly->coeffErr = (psF32 **)psAlloc(nX * sizeof(psF32 *));
     1040    newPoly->mask = (psU8 **)psAlloc(nX * sizeof(psU8 *));
    10411041    for (x = 0; x < nX; x++) {
    1042         newPoly->coeff[x] = (float *)psAlloc(nY * sizeof(float));
    1043         newPoly->coeffErr[x] = (float *)psAlloc(nY * sizeof(float));
    1044         newPoly->mask[x] = (char *)psAlloc(nY * sizeof(char));
     1042        newPoly->coeff[x] = (psF32 *)psAlloc(nY * sizeof(psF32));
     1043        newPoly->coeffErr[x] = (psF32 *)psAlloc(nY * sizeof(psF32));
     1044        newPoly->mask[x] = (psU8 *)psAlloc(nY * sizeof(psU8));
    10451045    }
    10461046    for (x = 0; x < nX; x++) {
    … …  
    10751075    newPoly->nZ = nZ;
    10761076
    1077     newPoly->coeff = (float ***)psAlloc(nX * sizeof(float **));
    1078     newPoly->coeffErr = (float ***)psAlloc(nX * sizeof(float **));
    1079     newPoly->mask = (char ***)psAlloc(nX * sizeof(char **));
     1077    newPoly->coeff = (psF32 ***)psAlloc(nX * sizeof(psF32 **));
     1078    newPoly->coeffErr = (psF32 ***)psAlloc(nX * sizeof(psF32 **));
     1079    newPoly->mask = (psU8 ***)psAlloc(nX * sizeof(psU8 **));
    10801080    for (x = 0; x < nX; x++) {
    1081         newPoly->coeff[x] = (float **)psAlloc(nY * sizeof(float *));
    1082         newPoly->coeffErr[x] = (float **)psAlloc(nY * sizeof(float *));
    1083         newPoly->mask[x] = (char **)psAlloc(nY * sizeof(char *));
     1081        newPoly->coeff[x] = (psF32 **)psAlloc(nY * sizeof(psF32 *));
     1082        newPoly->coeffErr[x] = (psF32 **)psAlloc(nY * sizeof(psF32 *));
     1083        newPoly->mask[x] = (psU8 **)psAlloc(nY * sizeof(psU8 *));
    10841084        for (y = 0; y < nY; y++) {
    1085             newPoly->coeff[x][y] = (float *)psAlloc(nZ * sizeof(float));
    1086             newPoly->coeffErr[x][y] = (float *)psAlloc(nZ * sizeof(float));
    1087             newPoly->mask[x][y] = (char *)psAlloc(nZ * sizeof(char));
     1085            newPoly->coeff[x][y] = (psF32 *)psAlloc(nZ * sizeof(psF32));
     1086            newPoly->coeffErr[x][y] = (psF32 *)psAlloc(nZ * sizeof(psF32));
     1087            newPoly->mask[x][y] = (psU8 *)psAlloc(nZ * sizeof(psU8));
    10881088        }
    10891089    }
    … …  
    11241124    newPoly->nZ = nZ;
    11251125
    1126     newPoly->coeff = (float ****)psAlloc(nW * sizeof(float ***));
    1127     newPoly->coeffErr = (float ****)psAlloc(nW * sizeof(float ***));
    1128     newPoly->mask = (char ****)psAlloc(nW * sizeof(char ***));
     1126    newPoly->coeff = (psF32 ****)psAlloc(nW * sizeof(psF32 ***));
     1127    newPoly->coeffErr = (psF32 ****)psAlloc(nW * sizeof(psF32 ***));
     1128    newPoly->mask = (psU8 ****)psAlloc(nW * sizeof(psU8 ***));
    11291129    for (w = 0; w < nW; w++) {
    1130         newPoly->coeff[w] = (float ***)psAlloc(nX * sizeof(float **));
    1131         newPoly->coeffErr[w] = (float ***)psAlloc(nX * sizeof(float **));
    1132         newPoly->mask[w] = (char ***)psAlloc(nX * sizeof(char **));
     1130        newPoly->coeff[w] = (psF32 ***)psAlloc(nX * sizeof(psF32 **));
     1131        newPoly->coeffErr[w] = (psF32 ***)psAlloc(nX * sizeof(psF32 **));
     1132        newPoly->mask[w] = (psU8 ***)psAlloc(nX * sizeof(psU8 **));
    11331133        for (x = 0; x < nX; x++) {
    1134             newPoly->coeff[w][x] = (float **)psAlloc(nY * sizeof(float *));
    1135             newPoly->coeffErr[w][x] = (float **)psAlloc(nY * sizeof(float *));
    1136             newPoly->mask[w][x] = (char **)psAlloc(nY * sizeof(char *));
     1134            newPoly->coeff[w][x] = (psF32 **)psAlloc(nY * sizeof(psF32 *));
     1135            newPoly->coeffErr[w][x] = (psF32 **)psAlloc(nY * sizeof(psF32 *));
     1136            newPoly->mask[w][x] = (psU8 **)psAlloc(nY * sizeof(psU8 *));
    11371137            for (y = 0; y < nY; y++) {
    1138                 newPoly->coeff[w][x][y] = (float *)psAlloc(nZ * sizeof(float));
    1139                 newPoly->coeffErr[w][x][y] = (float *)psAlloc(nZ * sizeof(float));
    1140                 newPoly->mask[w][x][y] = (char *)psAlloc(nZ * sizeof(char));
     1138                newPoly->coeff[w][x][y] = (psF32 *)psAlloc(nZ * sizeof(psF32));
     1139                newPoly->coeffErr[w][x][y] = (psF32 *)psAlloc(nZ * sizeof(psF32));
     1140                newPoly->mask[w][x][y] = (psU8 *)psAlloc(nZ * sizeof(psU8));
    11411141            }
    11421142        }
    … …  
    11571157}
    11581158
    1159 float psPolynomial1DEval(const psPolynomial1D* myPoly, float x)
     1159psF32 psPolynomial1DEval(const psPolynomial1D* myPoly, psF32 x)
    11601160{
    11611161    PS_POLY_CHECK_NULL(myPoly, NAN);
    … …  
    11951195}
    11961196
    1197 float psPolynomial2DEval(const psPolynomial2D* myPoly, float x, float y)
     1197psF32 psPolynomial2DEval(const psPolynomial2D* myPoly, psF32 x, psF32 y)
    11981198{
    11991199    PS_POLY_CHECK_NULL(myPoly, NAN);
    … …  
    12501250}
    12511251
    1252 float psPolynomial3DEval(const psPolynomial3D* myPoly, float x, float y, float z)
     1252psF32 psPolynomial3DEval(const psPolynomial3D* myPoly, psF32 x, psF32 y, psF32 z)
    12531253{
    12541254    PS_POLY_CHECK_NULL(myPoly, NAN);
    … …  
    13161316}
    13171317
    1318 float psPolynomial4DEval(const psPolynomial4D* myPoly, float w, float x, float y, float z)
     1318psF32 psPolynomial4DEval(const psPolynomial4D* myPoly, psF32 w, psF32 x, psF32 y, psF32 z)
    13191319{
    13201320    PS_POLY_CHECK_NULL(myPoly, NAN);
    … …  
    14061406    newPoly->type = type;
    14071407    newPoly->n = n;
    1408     newPoly->coeff = (double *)psAlloc(n * sizeof(double));
    1409     newPoly->coeffErr = (double *)psAlloc(n * sizeof(double));
    1410     newPoly->mask = (char *)psAlloc(n * sizeof(char));
     1408    newPoly->coeff = (psF64 *)psAlloc(n * sizeof(psF64));
     1409    newPoly->coeffErr = (psF64 *)psAlloc(n * sizeof(psF64));
     1410    newPoly->mask = (psU8 *)psAlloc(n * sizeof(psU8));
    14111411    for (i = 0; i < n; i++) {
    14121412        newPoly->coeff[i] = 0.0;
    … …  
    14351435    newPoly->nY = nY;
    14361436
    1437     newPoly->coeff = (double **)psAlloc(nX * sizeof(double *));
    1438     newPoly->coeffErr = (double **)psAlloc(nX * sizeof(double *));
    1439     newPoly->mask = (char **)psAlloc(nX * sizeof(char *));
     1437    newPoly->coeff = (psF64 **)psAlloc(nX * sizeof(psF64 *));
     1438    newPoly->coeffErr = (psF64 **)psAlloc(nX * sizeof(psF64 *));
     1439    newPoly->mask = (psU8 **)psAlloc(nX * sizeof(psU8 *));
    14401440    for (x = 0; x < nX; x++) {
    1441         newPoly->coeff[x] = (double *)psAlloc(nY * sizeof(double));
    1442         newPoly->coeffErr[x] = (double *)psAlloc(nY * sizeof(double));
    1443         newPoly->mask[x] = (char *)psAlloc(nY * sizeof(char));
     1441        newPoly->coeff[x] = (psF64 *)psAlloc(nY * sizeof(psF64));
     1442        newPoly->coeffErr[x] = (psF64 *)psAlloc(nY * sizeof(psF64));
     1443        newPoly->mask[x] = (psU8 *)psAlloc(nY * sizeof(psU8));
    14441444    }
    14451445    for (x = 0; x < nX; x++) {
    … …  
    14741474    newPoly->nZ = nZ;
    14751475
    1476     newPoly->coeff = (double ***)psAlloc(nX * sizeof(double **));
    1477     newPoly->coeffErr = (double ***)psAlloc(nX * sizeof(double **));
    1478     newPoly->mask = (char ***)psAlloc(nX * sizeof(char **));
     1476    newPoly->coeff = (psF64 ***)psAlloc(nX * sizeof(psF64 **));
     1477    newPoly->coeffErr = (psF64 ***)psAlloc(nX * sizeof(psF64 **));
     1478    newPoly->mask = (psU8 ***)psAlloc(nX * sizeof(psU8 **));
    14791479    for (x = 0; x < nX; x++) {
    1480         newPoly->coeff[x] = (double **)psAlloc(nY * sizeof(double *));
    1481         newPoly->coeffErr[x] = (double **)psAlloc(nY * sizeof(double *));
    1482         newPoly->mask[x] = (char **)psAlloc(nY * sizeof(char *));
     1480        newPoly->coeff[x] = (psF64 **)psAlloc(nY * sizeof(psF64 *));
     1481        newPoly->coeffErr[x] = (psF64 **)psAlloc(nY * sizeof(psF64 *));
     1482        newPoly->mask[x] = (psU8 **)psAlloc(nY * sizeof(psU8 *));
    14831483        for (y = 0; y < nY; y++) {
    1484             newPoly->coeff[x][y] = (double *)psAlloc(nZ * sizeof(double));
    1485             newPoly->coeffErr[x][y] = (double *)psAlloc(nZ * sizeof(double));
    1486             newPoly->mask[x][y] = (char *)psAlloc(nZ * sizeof(char));
     1484            newPoly->coeff[x][y] = (psF64 *)psAlloc(nZ * sizeof(psF64));
     1485            newPoly->coeffErr[x][y] = (psF64 *)psAlloc(nZ * sizeof(psF64));
     1486            newPoly->mask[x][y] = (psU8 *)psAlloc(nZ * sizeof(psU8));
    14871487        }
    14881488    }
    … …  
    15231523    newPoly->nZ = nZ;
    15241524
    1525     newPoly->coeff = (double ****)psAlloc(nW * sizeof(double ***));
    1526     newPoly->coeffErr = (double ****)psAlloc(nW * sizeof(double ***));
    1527     newPoly->mask = (char ****)psAlloc(nW * sizeof(char ***));
     1525    newPoly->coeff = (psF64 ****)psAlloc(nW * sizeof(psF64 ***));
     1526    newPoly->coeffErr = (psF64 ****)psAlloc(nW * sizeof(psF64 ***));
     1527    newPoly->mask = (psU8 ****)psAlloc(nW * sizeof(psU8 ***));
    15281528    for (w = 0; w < nW; w++) {
    1529         newPoly->coeff[w] = (double ***)psAlloc(nX * sizeof(double **));
    1530         newPoly->coeffErr[w] = (double ***)psAlloc(nX * sizeof(double **));
    1531         newPoly->mask[w] = (char ***)psAlloc(nX * sizeof(char **));
     1529        newPoly->coeff[w] = (psF64 ***)psAlloc(nX * sizeof(psF64 **));
     1530        newPoly->coeffErr[w] = (psF64 ***)psAlloc(nX * sizeof(psF64 **));
     1531        newPoly->mask[w] = (psU8 ***)psAlloc(nX * sizeof(psU8 **));
    15321532        for (x = 0; x < nX; x++) {
    1533             newPoly->coeff[w][x] = (double **)psAlloc(nY * sizeof(double *));
    1534             newPoly->coeffErr[w][x] = (double **)psAlloc(nY * sizeof(double *));
    1535             newPoly->mask[w][x] = (char **)psAlloc(nY * sizeof(char *));
     1533            newPoly->coeff[w][x] = (psF64 **)psAlloc(nY * sizeof(psF64 *));
     1534            newPoly->coeffErr[w][x] = (psF64 **)psAlloc(nY * sizeof(psF64 *));
     1535            newPoly->mask[w][x] = (psU8 **)psAlloc(nY * sizeof(psU8 *));
    15361536            for (y = 0; y < nY; y++) {
    1537                 newPoly->coeff[w][x][y] = (double *)psAlloc(nZ * sizeof(double));
    1538                 newPoly->coeffErr[w][x][y] = (double *)psAlloc(nZ * sizeof(double));
    1539                 newPoly->mask[w][x][y] = (char *)psAlloc(nZ * sizeof(char));
     1537                newPoly->coeff[w][x][y] = (psF64 *)psAlloc(nZ * sizeof(psF64));
     1538                newPoly->coeffErr[w][x][y] = (psF64 *)psAlloc(nZ * sizeof(psF64));
     1539                newPoly->mask[w][x][y] = (psU8 *)psAlloc(nZ * sizeof(psU8));
    15401540            }
    15411541        }
    … …  
    15571557
    15581558
    1559 double psDPolynomial1DEval(const psDPolynomial1D* myPoly, double x)
     1559psF64 psDPolynomial1DEval(const psDPolynomial1D* myPoly, psF64 x)
    15601560{
    15611561    PS_POLY_CHECK_NULL(myPoly, NAN);
    … …  
    15981598
    15991599
    1600 double psDPolynomial2DEval(const psDPolynomial2D* myPoly,
    1601                            double x,
    1602                            double y)
     1600psF64 psDPolynomial2DEval(const psDPolynomial2D* myPoly,
     1601                          psF64 x,
     1602                          psF64 y)
    16031603{
    16041604    PS_POLY_CHECK_NULL(myPoly, NAN);
    … …  
    16551655
    16561656
    1657 double psDPolynomial3DEval(const psDPolynomial3D* myPoly,
    1658                            double x,
    1659                            double y,
    1660                            double z)
     1657psF64 psDPolynomial3DEval(const psDPolynomial3D* myPoly,
     1658                          psF64 x,
     1659                          psF64 y,
     1660                          psF64 z)
    16611661{
    16621662    PS_POLY_CHECK_NULL(myPoly, NAN);
    … …  
    17241724}
    17251725
    1726 double psDPolynomial4DEval(const psDPolynomial4D* myPoly,
    1727                            double w,
    1728                            double x,
    1729                            double y,
    1730                            double z)
     1726psF64 psDPolynomial4DEval(const psDPolynomial4D* myPoly,
     1727                          psF64 w,
     1728                          psF64 x,
     1729                          psF64 y,
     1730                          psF64 z)
    17311731{
    17321732    PS_POLY_CHECK_NULL(myPoly, NAN);
    … …  
    18101810//    psS32 n;
    18111811//    psPolynomial1D **spline;
    1812 //    float *p_psDeriv2;
    1813 //    float *domains;
     1812//    psF32 *p_psDeriv2;
     1813//    psF32 *domains;
    18141814//} psSpline1D;
    18151815
    … …  
    18221822psSpline1D *psSpline1DAlloc(psS32 numSplines,
    18231823                            psS32 order,
    1824                             float min,
    1825                             float max)
     1824                            psF32 min,
     1825                            psF32 max)
    18261826{
    18271827    PS_INT_CHECK_NON_NEGATIVE(numSplines, NULL);
    … …  
    18311831    psSpline1D *tmp = NULL;
    18321832    psS32 i;
    1833     float tmpDomain;
    1834     float width;
     1833    psF32 tmpDomain;
     1834    psF32 width;
    18351835
    18361836    tmp = (psSpline1D *) psAlloc(sizeof(psSpline1D));
    … …  
    18451845    tmp->p_psDeriv2 = NULL;
    18461846
    1847     tmp->domains = (float *) psAlloc((numSplines+1) * sizeof(float));
    1848     width = (max - min) / ((float) numSplines);
     1847    tmp->domains = (psF32 *) psAlloc((numSplines+1) * sizeof(psF32));
     1848    width = (max - min) / ((psF32) numSplines);
    18491849
    18501850    (tmp->domains)[0] = min;
    … …  
    18841884    }
    18851885
    1886     tmp->domains = (float *) psAlloc((bounds->n) * sizeof(float));
     1886    tmp->domains = (psF32 *) psAlloc((bounds->n) * sizeof(psF32));
    18871887
    18881888    for (i=0;i<bounds->n;i++) {
    … …  
    19771977{
    19781978    PS_PTR_CHECK_TYPE_EQUAL(x, bins, -3);
    1979     char* strType;
     1979    psS8* strType;
    19801980
    19811981    switch (x->type.type) {
    … …  
    20742074        domain32 = psVectorCopy(domain32, domain, PS_TYPE_F32);
    20752075
    2076         psScalar *tmpScalar = psScalarAlloc((double)
     2076        psScalar *tmpScalar = psScalarAlloc((psF64)
    20772077                                            interpolate1DF32(domain32->data.F32,
    20782078                                                             range32->data.F32,
    20792079                                                             domain32->n,
    20802080                                                             order,
    2081                                                              (float) x->data.F64), PS_TYPE_F64);
     2081                                                             (psF32) x->data.F64), PS_TYPE_F64);
    20822082        psFree(range32);
    20832083        psFree(domain32);
    … …  
    20892089
    20902090    } else {
    2091         char* strType;
     2091        psS8* strType;
    20922092        PS_TYPE_NAME(strType,x->type.type);
    20932093        psError(PS_ERR_BAD_PARAMETER_TYPE,
    … …  
    21152115     the spline fit functions require F32 and F64.
    21162116 *****************************************************************************/
    2117 float psSpline1DEval(
    2118     float x,
     2117psF32 psSpline1DEval(
     2118    psF32 x,
    21192119    const psSpline1D *spline
    21202120)
    … …  
    21722172        for (i=0;i<x->n;i++) {
    21732173            tmpVector->data.F32[i] = psSpline1DEval(
    2174                                          (float) x->data.F64[i],
     2174                                         (psF32) x->data.F64[i],
    21752175                                         spline
    21762176                                     );
    21772177        }
    21782178    } else {
    2179         char* strType;
     2179        psS8* strType;
    21802180        PS_TYPE_NAME(strType,x->type.type);
    21812181        psError(PS_ERR_BAD_PARAMETER_TYPE,
Note: See TracChangeset for help on using the changeset viewer.