Changeset 4581

Timestamp:

Jul 19, 2005, 3:21:13 PM (21 years ago)

Author:

drobbin

Message:

changed psPolynomial fxns to use F64 and removed psDPoly fxns

Location:

trunk/psLib

Files:

• src/astro/psCoord.c (modified) (14 diffs)
• src/astro/psCoord.h (modified) (3 diffs)
• src/math/psConstants.h (modified) (2 diffs)
• src/math/psFunctions.c (modified) (30 diffs)
• src/math/psFunctions.h (modified) (6 diffs)
• test/astro/tst_psCoord.c (modified) (3 diffs)
• test/astronomy/tst_psAstrometry01.c (modified) (3 diffs)
• test/db/verified/tst_psDB.stderr (modified) (1 diff)
• test/imageops/verified/tst_psImageStats.stderr (modified) (1 diff)
• test/math/tst_psFunc00.c (modified) (7 diffs)
• test/math/tst_psFunc08.c (modified) (10 diffs)
• test/math/tst_psFunc09.c (modified) (25 diffs)
• test/math/tst_psFunc10.c (modified) (27 diffs)
• test/math/tst_psFunc11.c (modified) (29 diffs)
• test/math/verified/tst_psFunc00.stderr (modified) (1 diff)
• test/math/verified/tst_psFunc08.stderr (modified) (2 diffs)
• test/math/verified/tst_psFunc09.stderr (modified) (2 diffs)
• test/math/verified/tst_psFunc10.stderr (modified) (2 diffs)
• test/math/verified/tst_psFunc11.stderr (modified) (2 diffs)

trunk/psLib/src/astro/psCoord.c

@@ -10 +10 @@
 *  @author GLG, MHPCC
 *
-*  @version $Revision: 1.79 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2005-07-12 19:12:00 $
+*  @version $Revision: 1.80 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2005-07-20 01:21:13 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -226 +226 @@
 
     psPlaneTransform *pt = psAlloc(sizeof(psPlaneTransform));
-    pt->x = psDPolynomial2DAlloc(n1, n2, PS_POLYNOMIAL_ORD);
-    pt->y = psDPolynomial2DAlloc(n1, n2, PS_POLYNOMIAL_ORD);
+    pt->x = psPolynomial2DAlloc(n1, n2, PS_POLYNOMIAL_ORD);
+    pt->y = psPolynomial2DAlloc(n1, n2, PS_POLYNOMIAL_ORD);
 
     psMemSetDeallocator(pt, (psFreeFunc) planeTransformFree);
@@ -246 +246 @@
     }
 
-    out->x = psDPolynomial2DEval(
+    out->x = psPolynomial2DEval(
                  transform->x,
                  coords->x,
@@ -252 +252 @@
              );
 
-    out->y = psDPolynomial2DEval(
+    out->y = psPolynomial2DEval(
                  transform->y,
                  coords->x,
@@ -275 +275 @@
 
     psPlaneDistort *pt = psAlloc(sizeof(psPlaneDistort));
-    pt->x = psDPolynomial4DAlloc(n1, n2, n3, n4, PS_POLYNOMIAL_ORD);
-    pt->y = psDPolynomial4DAlloc(n1, n2, n3, n4, PS_POLYNOMIAL_ORD);
+    pt->x = psPolynomial4DAlloc(n1, n2, n3, n4, PS_POLYNOMIAL_ORD);
+    pt->y = psPolynomial4DAlloc(n1, n2, n3, n4, PS_POLYNOMIAL_ORD);
 
     psMemSetDeallocator(pt, (psFreeFunc) planeDistortFree);
@@ -300 +300 @@
         out = (psPlane* ) psAlloc(sizeof(psPlane));
     }
-    out->x = psDPolynomial4DEval(
+    out->x = psPolynomial4DEval(
                  distort->x,
                  coords->x,
@@ -307 +307 @@
                  color
              );
-    out->y = psDPolynomial4DEval(
+    out->y = psPolynomial4DEval(
                  distort->y,
                  coords->x,
@@ -854 +854 @@
  *****************************************************************************/
 
-static psDPolynomial2D *multiplyDPoly2D(psDPolynomial2D *trans1,
-                                        psDPolynomial2D *trans2)
+static psPolynomial2D *multiplyDPoly2D(psPolynomial2D *trans1,
+                                       psPolynomial2D *trans2)
 {
     //TRACE: printf("multiplyDPoly2D(%d %d: %d %d)\n", trans1->nX, trans1->nY, trans2->nX, trans2->nY);
@@ -861 +861 @@
     psS32 orderY = (trans1->nY + trans2->nY) - 1;
 
-    psDPolynomial2D *out = psDPolynomial2DAlloc(orderX, orderY, PS_POLYNOMIAL_ORD);
+    psPolynomial2D *out = psPolynomial2DAlloc(orderX, orderY, PS_POLYNOMIAL_ORD);
     //TRACE: printf("Creating poly (%d, %d)\n", orderX, orderY);
     for (psS32 i = 0 ; i < out->nX; i++) {
@@ -966 +966 @@
     for (psS32 t2x = 0 ; t2x < trans2->x->nX ; t2x++) {
         for (psS32 t2y = 0 ; t2y < trans2->x->nY ; t2y++) {
-            psDPolynomial2D *currPoly = psDPolynomial2DAlloc(1, 1, PS_POLYNOMIAL_ORD);
+            psPolynomial2D *currPoly = psPolynomial2DAlloc(1, 1, PS_POLYNOMIAL_ORD);
 
             currPoly->coeff[0][0] = 1.0;
             currPoly->mask[0][0] = 0;
-            psDPolynomial2D *newPoly = NULL;
+            psPolynomial2D *newPoly = NULL;
 
             if (trans2->x->mask[t2x][t2y] == 0) {
@@ -1001 +1001 @@
     for (psS32 t2x = 0 ; t2x < trans2->y->nX ; t2x++) {
         for (psS32 t2y = 0 ; t2y < trans2->y->nY ; t2y++) {
-            psDPolynomial2D *currPoly = psDPolynomial2DAlloc(1, 1, PS_POLYNOMIAL_ORD);
+            psPolynomial2D *currPoly = psPolynomial2DAlloc(1, 1, PS_POLYNOMIAL_ORD);
             currPoly->coeff[0][0] = 1.0;
             currPoly->mask[0][0] = 0;
-            psDPolynomial2D *newPoly = NULL;
+            psPolynomial2D *newPoly = NULL;
 
             if (trans2->y->mask[t2x][t2y] == 0) {
@@ -1062 +1062 @@
     // Create fake polynomial to use in evaluation
     //
-    psDPolynomial2D *fakePoly = psDPolynomial2DAlloc(order, order, PS_POLYNOMIAL_ORD);
+    psPolynomial2D *fakePoly = psPolynomial2DAlloc(order, order, PS_POLYNOMIAL_ORD);
     for (int i = 0; i < order; i++) {
         for (int j = 0; j < order; j++) {
@@ -1098 +1098 @@
                 psF64 xOut = ((psPlane *) dest->data[g])->x;
                 psF64 yOut = ((psPlane *) dest->data[g])->y;
-                psF64 ijPoly = psDPolynomial2DEval(fakePoly, xIn, yIn);
+                psF64 ijPoly = psPolynomial2DEval(fakePoly, xIn, yIn);
                 fakePoly->mask[i][j] = 1;
 
@@ -1104 +1104 @@
                     for (psS32 n = 0; n < order - m; n++, mnIndex++) {
                         fakePoly->mask[m][n] = 0;
-                        psF64 mnPoly = psDPolynomial2DEval(fakePoly, xIn, yIn);
+                        psF64 mnPoly = psPolynomial2DEval(fakePoly, xIn, yIn);
                         fakePoly->mask[m][n] = 1;
 

trunk/psLib/src/astro/psCoord.h

@@ -10 +10 @@
 *  @author GLG, MHPCC
 *
-*  @version $Revision: 1.37 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2005-06-27 20:38:11 $
+*  @version $Revision: 1.38 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2005-07-20 01:21:13 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -71 +71 @@
 typedef struct
 {
-    psDPolynomial2D* x;         ///< 2D polynomial transform of X coordinates
-    psDPolynomial2D* y;         ///< 2D polynomial transform of Y coordinates
+    psPolynomial2D* x;         ///< 2D polynomial transform of X coordinates
+    psPolynomial2D* y;         ///< 2D polynomial transform of Y coordinates
 }
 psPlaneTransform;
@@ -90 +90 @@
 typedef struct
 {
-    psDPolynomial4D* x;         ///< 4D polynomial transform of X coordinates
-    psDPolynomial4D* y;         ///< 4D polynomial transform of Y coordinates
+    psPolynomial4D* x;         ///< 4D polynomial transform of X coordinates
+    psPolynomial4D* y;         ///< 4D polynomial transform of Y coordinates
 }
 psPlaneDistort;

trunk/psLib/src/math/psConstants.h

@@ -6 +6 @@
  *  @author GLG, MHPCC
  *
- *  @version $Revision: 1.74 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2005-06-28 23:28:31 $
+ *  @version $Revision: 1.75 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-07-20 01:21:13 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -201 +201 @@
 }
 
+#define PS_ASSERT_DOUBLE_WITHIN_RANGE(NAME, LOWER, UPPER, RVAL) \
+if ((NAME) < (LOWER) || (NAME) > (UPPER)) { \
+    psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
+            "Error: %s, %lf, is out of range.  Must be between %lf and %lf.", \
+            #NAME, NAME, LOWER, UPPER); \
+    return RVAL; \
+}
+
 // Return an error if the arg lies outside the supplied range
 #define PS_ASSERT_LONG_WITHIN_RANGE(NAME, LOWER, UPPER, RVAL) \

trunk/psLib/src/math/psFunctions.c

@@ -7 +7 @@
 *  polynomials.  It also contains a Gaussian functions.
 *
-*  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2005-07-19 02:55:54 $
+*  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2005-07-20 01:21:13 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -50 +50 @@
 static void polynomial3DFree(psPolynomial3D* poly);
 static void polynomial4DFree(psPolynomial4D* poly);
-static void dPolynomial1DFree(psDPolynomial1D* poly);
-static void dPolynomial2DFree(psDPolynomial2D* poly);
-static void dPolynomial3DFree(psDPolynomial3D* poly);
-static void dPolynomial4DFree(psDPolynomial4D* poly);
 static void spline1DFree(psSpline1D *tmpSpline);
 static psS32 vectorBinDisectF32(psF32 *bins,psS32 numBins,psF32 x);
@@ -166 +162 @@
 }
 
-static void dPolynomial1DFree(psDPolynomial1D* poly)
-{
-    psFree(poly->coeff);
-    psFree(poly->coeffErr);
-    psFree(poly->mask);
-}
-
-static void dPolynomial2DFree(psDPolynomial2D* poly)
-{
-    for (unsigned int x = 0; x < poly->nX; x++) {
-        psFree(poly->coeff[x]);
-        psFree(poly->coeffErr[x]);
-        psFree(poly->mask[x]);
-    }
-    psFree(poly->coeff);
-    psFree(poly->coeffErr);
-    psFree(poly->mask);
-}
-
-static void dPolynomial3DFree(psDPolynomial3D* poly)
-{
-    unsigned int x = 0;
-    unsigned int y = 0;
-
-    for (x = 0; x < poly->nX; x++) {
-        for (y = 0; y < poly->nY; y++) {
-            psFree(poly->coeff[x][y]);
-            psFree(poly->coeffErr[x][y]);
-            psFree(poly->mask[x][y]);
-        }
-        psFree(poly->coeff[x]);
-        psFree(poly->coeffErr[x]);
-        psFree(poly->mask[x]);
-    }
-
-    psFree(poly->coeff);
-    psFree(poly->coeffErr);
-    psFree(poly->mask);
-}
-
-static void dPolynomial4DFree(psDPolynomial4D* poly)
-{
-    unsigned int x = 0;
-    unsigned int y = 0;
-    unsigned int z = 0;
-
-    for (x = 0; x < poly->nX; x++) {
-        for (y = 0; y < poly->nY; y++) {
-            for (z = 0; z < poly->nZ; z++) {
-                psFree(poly->coeff[x][y][z]);
-                psFree(poly->coeffErr[x][y][z]);
-                psFree(poly->mask[x][y][z]);
-            }
-            psFree(poly->coeff[x][y]);
-            psFree(poly->coeffErr[x][y]);
-            psFree(poly->mask[x][y]);
-        }
-        psFree(poly->coeff[x]);
-        psFree(poly->coeffErr[x]);
-        psFree(poly->mask[x]);
-    }
-
-    psFree(poly->coeff);
-    psFree(poly->coeffErr);
-    psFree(poly->mask);
-}
-
 /*****************************************************************************
 createChebyshevPolys(n): this routine takes as input the required order n,
@@ -283 +212 @@
 {
     psS32 loop_x = 0;
-    psF32 polySum = 0.0;
-    psF32 xSum = 1.0;
+    psF64 polySum = 0.0;
+    psF64 xSum = 1.0;
 
     psTrace(".psLib.dataManip.psFunctions.ordPolynomial1DEval", 4,
-            "---- Calling ordPolynomial1DEval(%f)\n", x);
+            "---- Calling ordPolynomial1DEval(%lf)\n", x);
     psTrace(".psLib.dataManip.psFunctions.ordPolynomial1DEval", 4,
             "Polynomial order is %d\n", poly->n);
     for (loop_x = 0; loop_x < poly->n; loop_x++) {
         psTrace(".psLib.dataManip.psFunctions.ordPolynomial1DEval", 4,
-                "Polynomial coeff[%d] is %f\n", loop_x, poly->coeff[loop_x]);
+                "Polynomial coeff[%d] is %lf\n", loop_x, poly->coeff[loop_x]);
     }
 
@@ -298 +227 @@
         if (poly->mask[loop_x] == 0) {
             psTrace(".psLib.dataManip.psFunctions.ordPolynomial1DEval", 10,
-                    "polysum+= sum*coeff [%f+= (%f * %f)\n", polySum, xSum, poly->coeff[loop_x]);
+                    "polysum+= sum*coeff [%lf+= (%lf * %lf)\n", polySum, xSum, poly->coeff[loop_x]);
             polySum += xSum * poly->coeff[loop_x];
         }
@@ -312 +241 @@
 static psF64 chebPolynomial1DEval(psF64 x, const psPolynomial1D* poly)
 {
-    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
+    PS_ASSERT_DOUBLE_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
     // XXX: Create a macro for this in psConstants.h
     if (poly->n < 1) {
@@ -321 +250 @@
     psS32 n = poly->n;
     psS32 i;
-    psF32 tmp = 0.0;
+    psF64 tmp = 0.0;
 
     // Special case where the Chebyshev poly is constant.
@@ -343 +272 @@
 
     // General case where the Chebyshev poly has 2 or more terms.
-    d = psVectorAlloc(n, PS_TYPE_F32);
+    d = psVectorAlloc(n, PS_TYPE_F64);
     if(poly->mask[n-1] == 0) {
-        d->data.F32[n-1] = poly->coeff[n-1];
+        d->data.F64[n-1] = poly->coeff[n-1];
     } else {
-        d->data.F32[n-1] = 0.0;
-    }
-
-    d->data.F32[n-2] = (2.0 * x * d->data.F32[n-1]);
+        d->data.F64[n-1] = 0.0;
+    }
+
+    d->data.F64[n-2] = (2.0 * x * d->data.F64[n-1]);
     if(poly->mask[n-2] == 0) {
-        d->data.F32[n-2] += poly->coeff[n-2];
+        d->data.F64[n-2] += poly->coeff[n-2];
     }
 
     for (i=n-3;i>=1;i--) {
-        d->data.F32[i] = (2.0 * x * d->data.F32[i+1]) -
-                         (d->data.F32[i+2]);
+        d->data.F64[i] = (2.0 * x * d->data.F64[i+1]) -
+                         (d->data.F64[i+2]);
         if(poly->mask[i] == 0) {
-            d->data.F32[i] += poly->coeff[i];
-        }
-    }
-
-    tmp = (x * d->data.F32[1]) -
-          (d->data.F32[2]);
+            d->data.F64[i] += poly->coeff[i];
+        }
+    }
+
+    tmp = (x * d->data.F64[1]) -
+          (d->data.F64[2]);
     if(poly->mask[0] == 0) {
         tmp += (0.5 * poly->coeff[0]);
@@ -400 +329 @@
     psS32 loop_x = 0;
     psS32 loop_y = 0;
-    psF32 polySum = 0.0;
-    psF32 xSum = 1.0;
-    psF32 ySum = 1.0;
+    psF64 polySum = 0.0;
+    psF64 xSum = 1.0;
+    psF64 ySum = 1.0;
 
     for (loop_x = 0; loop_x < poly->nX; loop_x++) {
@@ -420 +349 @@
 static psF64 chebPolynomial2DEval(psF64 x, psF64 y, const psPolynomial2D* poly)
 {
-    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
-    PS_ASSERT_FLOAT_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
+    PS_ASSERT_DOUBLE_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
+    PS_ASSERT_DOUBLE_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
     PS_ASSERT_POLY_NON_NULL(poly, NAN);
 
@@ -427 +356 @@
     psS32 loop_y = 0;
     psS32 i = 0;
-    psF32 polySum = 0.0;
+    psF64 polySum = 0.0;
     psPolynomial1D* *chebPolys = NULL;
     psS32 maxChebyPoly = 0;
@@ -460 +389 @@
     psS32 loop_y = 0;
     psS32 loop_z = 0;
-    psF32 polySum = 0.0;
-    psF32 xSum = 1.0;
-    psF32 ySum = 1.0;
-    psF32 zSum = 1.0;
+    psF64 polySum = 0.0;
+    psF64 xSum = 1.0;
+    psF64 ySum = 1.0;
+    psF64 zSum = 1.0;
 
     for (loop_x = 0; loop_x < poly->nX; loop_x++) {
@@ -485 +414 @@
 static psF64 chebPolynomial3DEval(psF64 x, psF64 y, psF64 z, const psPolynomial3D* poly)
 {
-    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
-    PS_ASSERT_FLOAT_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
-    PS_ASSERT_FLOAT_WITHIN_RANGE(z, -1.0, 1.0, 0.0);
+    PS_ASSERT_DOUBLE_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
+    PS_ASSERT_DOUBLE_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
+    PS_ASSERT_DOUBLE_WITHIN_RANGE(z, -1.0, 1.0, 0.0);
     psS32 loop_x = 0;
     psS32 loop_y = 0;
     psS32 loop_z = 0;
     psS32 i = 0;
-    psF32 polySum = 0.0;
+    psF64 polySum = 0.0;
     psPolynomial1D* *chebPolys = NULL;
     psS32 maxChebyPoly = 0;
@@ -533 +462 @@
     psS32 loop_z = 0;
     psS32 loop_t = 0;
-    psF32 polySum = 0.0;
-    psF32 xSum = 1.0;
-    psF32 ySum = 1.0;
-    psF32 zSum = 1.0;
-    psF32 tSum = 1.0;
+    psF64 polySum = 0.0;
+    psF64 xSum = 1.0;
+    psF64 ySum = 1.0;
+    psF64 zSum = 1.0;
+    psF64 tSum = 1.0;
 
     for (loop_x = 0; loop_x < poly->nX; loop_x++) {
@@ -563 +492 @@
 static psF64 chebPolynomial4DEval(psF64 x, psF64 y, psF64 z, psF64 t, const psPolynomial4D* poly)
 {
-    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
-    PS_ASSERT_FLOAT_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
-    PS_ASSERT_FLOAT_WITHIN_RANGE(z, -1.0, 1.0, 0.0);
-    PS_ASSERT_FLOAT_WITHIN_RANGE(t, -1.0, 1.0, 0.0);
+    PS_ASSERT_DOUBLE_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
+    PS_ASSERT_DOUBLE_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
+    PS_ASSERT_DOUBLE_WITHIN_RANGE(z, -1.0, 1.0, 0.0);
+    PS_ASSERT_DOUBLE_WITHIN_RANGE(t, -1.0, 1.0, 0.0);
     psS32 loop_x = 0;
     psS32 loop_y = 0;
@@ -572 +501 @@
     psS32 loop_t = 0;
     psS32 i = 0;
-    psF32 polySum = 0.0;
+    psF64 polySum = 0.0;
     psPolynomial1D* *chebPolys = NULL;
     psS32 maxChebyPoly = 0;
@@ -612 +541 @@
     return(polySum);
 }
-
-/*****************************************************************************
-    Polynomial coefficients will be accessed in [w][x][y][z] fashion.
- *****************************************************************************/
-static psF64 dOrdPolynomial1DEval(psF64 x, const psDPolynomial1D* poly)
-{
-    psS32 loop_x = 0;
-    psF64 polySum = 0.0;
-    psF64 xSum = 1.0;
-
-    for (loop_x = 0; loop_x < poly->n; loop_x++) {
-        if (poly->mask[loop_x] == 0) {
-            polySum += xSum * poly->coeff[loop_x];
-        }
-        xSum *= x;
-    }
-
-    return(polySum);
-}
-
-// XXX: You can do this without having to psAlloc() vector d.
-// XXX: How does the mask vector effect Crenshaw's formula?
-static psF64 dChebPolynomial1DEval(psF64 x, const psDPolynomial1D* poly)
-{
-    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
-    psVector *d;
-    psS32 n;
-    psS32 i;
-    psF64 tmp;
-
-    n = poly->n;
-    d = psVectorAlloc(n, PS_TYPE_F64);
-    if(poly->mask[n-1] == 0) {
-        d->data.F64[n-1] = poly->coeff[n-1];
-    } else {
-        d->data.F64[n-1] = 0.0;
-    }
-    d->data.F64[n-2] = (2.0 * x * d->data.F64[n-1]);
-    if(poly->mask[n-2] == 0) {
-        d->data.F64[n-2] += poly->coeff[n-2];
-    }
-    for (i=n-3;i>=1;i--) {
-        d->data.F64[i] = (2.0 * x * d->data.F64[i+1]) -
-                         (d->data.F64[i+2]);
-        if(poly->mask[i] == 0) {
-            d->data.F64[i] += poly->coeff[i];
-        }
-    }
-
-    tmp = (x * d->data.F64[1]) -
-          (d->data.F64[2]);
-    if(poly->mask[0] == 0) {
-        tmp += (0.5 * poly->coeff[0]);
-    }
-
-    psFree(d);
-    return(tmp);
-}
-
-static psF64 dOrdPolynomial2DEval(psF64 x,
-                                  psF64 y,
-                                  const psDPolynomial2D* poly)
-{
-    psS32 loop_x = 0;
-    psS32 loop_y = 0;
-    psF64 polySum = 0.0;
-    psF64 xSum = 1.0;
-    psF64 ySum = 1.0;
-
-    for (loop_x = 0; loop_x < poly->nX; loop_x++) {
-        ySum = xSum;
-        for (loop_y = 0; loop_y < poly->nY; loop_y++) {
-            if (poly->mask[loop_x][loop_y] == 0) {
-                polySum += ySum * poly->coeff[loop_x][loop_y];
-            }
-            ySum *= y;
-        }
-        xSum *= x;
-    }
-
-    return(polySum);
-}
-
-static psF64 dChebPolynomial2DEval(psF64 x, psF64 y, const psDPolynomial2D* poly)
-{
-    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
-    PS_ASSERT_FLOAT_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
-    psS32 loop_x = 0;
-    psS32 loop_y = 0;
-    psS32 i = 0;
-    psF64 polySum = 0.0;
-    psPolynomial1D* *chebPolys = NULL;
-    psS32 maxChebyPoly = 0;
-
-    // Determine how many Chebyshev polynomials
-    // are needed, then create them.
-    maxChebyPoly = poly->nX;
-    if (poly->nY > maxChebyPoly) {
-        maxChebyPoly = poly->nY;
-    }
-    chebPolys = createChebyshevPolys(maxChebyPoly);
-
-    for (loop_x = 0; loop_x < poly->nX; loop_x++) {
-        for (loop_y = 0; loop_y < poly->nY; loop_y++) {
-            if (poly->mask[loop_x][loop_y] == 0) {
-                polySum += poly->coeff[loop_x][loop_y] *
-                           psPolynomial1DEval(chebPolys[loop_x], x) *
-                           psPolynomial1DEval(chebPolys[loop_y], y);
-            }
-        }
-    }
-
-    for (i=0;i<maxChebyPoly;i++) {
-        psFree(chebPolys[i]);
-    }
-    psFree(chebPolys);
-    return(polySum);
-}
-
-static psF64 dOrdPolynomial3DEval(psF64 x, psF64 y, psF64 z, const psDPolynomial3D* poly)
-{
-    psS32 loop_x = 0;
-    psS32 loop_y = 0;
-    psS32 loop_z = 0;
-    psF64 polySum = 0.0;
-    psF64 xSum = 1.0;
-    psF64 ySum = 1.0;
-    psF64 zSum = 1.0;
-
-    for (loop_x = 0; loop_x < poly->nX; loop_x++) {
-        ySum = xSum;
-        for (loop_y = 0; loop_y < poly->nY; loop_y++) {
-            zSum = ySum;
-            for (loop_z = 0; loop_z < poly->nZ; loop_z++) {
-                if (poly->mask[loop_x][loop_y][loop_z] == 0) {
-                    polySum += zSum * poly->coeff[loop_x][loop_y][loop_z];
-                }
-                zSum *= z;
-            }
-            ySum *= y;
-        }
-        xSum *= x;
-    }
-
-    return(polySum);
-}
-
-static psF64 dChebPolynomial3DEval(psF64 x, psF64 y, psF64 z, const psDPolynomial3D* poly)
-{
-    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
-    PS_ASSERT_FLOAT_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
-    PS_ASSERT_FLOAT_WITHIN_RANGE(z, -1.0, 1.0, 0.0);
-    psS32 loop_x = 0;
-    psS32 loop_y = 0;
-    psS32 loop_z = 0;
-    psS32 i = 0;
-    psF64 polySum = 0.0;
-    psPolynomial1D* *chebPolys = NULL;
-    psS32 maxChebyPoly = 0;
-
-    // Determine how many Chebyshev polynomials
-    // are needed, then create them.
-    maxChebyPoly = poly->nX;
-    if (poly->nY > maxChebyPoly) {
-        maxChebyPoly = poly->nY;
-    }
-    if (poly->nZ > maxChebyPoly) {
-        maxChebyPoly = poly->nZ;
-    }
-    chebPolys = createChebyshevPolys(maxChebyPoly);
-
-    for (loop_x = 0; loop_x < poly->nX; loop_x++) {
-        for (loop_y = 0; loop_y < poly->nY; loop_y++) {
-            for (loop_z = 0; loop_z < poly->nZ; loop_z++) {
-                if (poly->mask[loop_x][loop_y][loop_z] == 0) {
-                    polySum += poly->coeff[loop_x][loop_y][loop_z] *
-                               psPolynomial1DEval(chebPolys[loop_x], x) *
-                               psPolynomial1DEval(chebPolys[loop_y], y) *
-                               psPolynomial1DEval(chebPolys[loop_z], z);
-                }
-            }
-        }
-    }
-
-    for (i=0;i<maxChebyPoly;i++) {
-        psFree(chebPolys[i]);
-    }
-    psFree(chebPolys);
-    return(polySum);
-}
-
-static psF64 dOrdPolynomial4DEval(psF64 x, psF64 y, psF64 z, psF64 t, const psDPolynomial4D* poly)
-{
-    psS32 loop_x = 0;
-    psS32 loop_y = 0;
-    psS32 loop_z = 0;
-    psS32 loop_t = 0;
-    psF64 polySum = 0.0;
-    psF64 xSum = 1.0;
-    psF64 ySum = 1.0;
-    psF64 zSum = 1.0;
-    psF64 tSum = 1.0;
-
-    for (loop_x = 0; loop_x < poly->nX; loop_x++) {
-        ySum = xSum;
-        for (loop_y = 0; loop_y < poly->nY; loop_y++) {
-            zSum = ySum;
-            for (loop_z = 0; loop_z < poly->nZ; loop_z++) {
-                tSum = zSum;
-                for (loop_t = 0; loop_t < poly->nT; loop_t++) {
-                    if (poly->mask[loop_x][loop_y][loop_z][loop_t] == 0) {
-                        polySum += tSum * poly->coeff[loop_x][loop_y][loop_z][loop_t];
-                    }
-                    tSum *= t;
-                }
-                zSum *= z;
-            }
-            ySum *= y;
-        }
-        xSum *= x;
-    }
-
-    return(polySum);
-}
-
-static psF64 dChebPolynomial4DEval(psF64 x, psF64 y, psF64 z, psF64 t, const psDPolynomial4D* poly)
-{
-    PS_ASSERT_FLOAT_WITHIN_RANGE(x, -1.0, 1.0, 0.0);
-    PS_ASSERT_FLOAT_WITHIN_RANGE(y, -1.0, 1.0, 0.0);
-    PS_ASSERT_FLOAT_WITHIN_RANGE(z, -1.0, 1.0, 0.0);
-    PS_ASSERT_FLOAT_WITHIN_RANGE(t, -1.0, 1.0, 0.0);
-    psS32 loop_x = 0;
-    psS32 loop_y = 0;
-    psS32 loop_z = 0;
-    psS32 loop_t = 0;
-    psS32 i = 0;
-    psF64 polySum = 0.0;
-    psPolynomial1D* *chebPolys = NULL;
-    psS32 maxChebyPoly = 0;
-
-    // Determine how many Chebyshev polynomials
-    // are needed, then create them.
-    maxChebyPoly = poly->nX;
-    if (poly->nY > maxChebyPoly) {
-        maxChebyPoly = poly->nY;
-    }
-    if (poly->nZ > maxChebyPoly) {
-        maxChebyPoly = poly->nZ;
-    }
-    if (poly->nT > maxChebyPoly) {
-        maxChebyPoly = poly->nT;
-    }
-    chebPolys = createChebyshevPolys(maxChebyPoly);
-
-    for (loop_x = 0; loop_x < poly->nX; loop_x++) {
-        for (loop_y = 0; loop_y < poly->nY; loop_y++) {
-            for (loop_z = 0; loop_z < poly->nZ; loop_z++) {
-                for (loop_t = 0; loop_t < poly->nT; loop_t++) {
-                    if (poly->mask[loop_x][loop_y][loop_z][loop_t] == 0) {
-                        polySum += poly->coeff[loop_x][loop_y][loop_z][loop_t] *
-                                   psPolynomial1DEval(chebPolys[loop_x], x) *
-                                   psPolynomial1DEval(chebPolys[loop_y], y) *
-                                   psPolynomial1DEval(chebPolys[loop_z], z) *
-                                   psPolynomial1DEval(chebPolys[loop_t], t);
-                    }
-                }
-            }
-        }
-    }
-
-    for (i=0;i<maxChebyPoly;i++) {
-        psFree(chebPolys[i]);
-    }
-    psFree(chebPolys);
-    return(polySum);
-}
-
 
 /*****************************************************************************
@@ -1082 +734 @@
     newPoly->type = type;
     newPoly->n = n;
-    newPoly->coeff = (psF32 *)psAlloc(n * sizeof(psF32));
-    newPoly->coeffErr = (psF32 *)psAlloc(n * sizeof(psF32));
+    newPoly->coeff = psAlloc(n * sizeof(psF64));
+    newPoly->coeffErr = psAlloc(n * sizeof(psF64));
     newPoly->mask = (char *)psAlloc(n * sizeof(char));
     for (i = 0; i < n; i++) {
@@ -1111 +763 @@
     newPoly->nY = nY;
 
-    newPoly->coeff = (psF32 **)psAlloc(nX * sizeof(psF32 *));
-    newPoly->coeffErr = (psF32 **)psAlloc(nX * sizeof(psF32 *));
+    newPoly->coeff = psAlloc(nX * sizeof(psF64 *));
+    newPoly->coeffErr = psAlloc(nX * sizeof(psF64 *));
     newPoly->mask = (char **)psAlloc(nX * sizeof(char *));
     for (x = 0; x < nX; x++) {
-        newPoly->coeff[x] = (psF32 *)psAlloc(nY * sizeof(psF32));
-        newPoly->coeffErr[x] = (psF32 *)psAlloc(nY * sizeof(psF32));
+        newPoly->coeff[x] = psAlloc(nY * sizeof(psF64));
+        newPoly->coeffErr[x] = psAlloc(nY * sizeof(psF64));
         newPoly->mask[x] = (char *)psAlloc(nY * sizeof(char));
     }
@@ -1150 +802 @@
     newPoly->nZ = nZ;
 
-    newPoly->coeff = (psF32 ***)psAlloc(nX * sizeof(psF32 **));
-    newPoly->coeffErr = (psF32 ***)psAlloc(nX * sizeof(psF32 **));
+    newPoly->coeff = psAlloc(nX * sizeof(psF64 **));
+    newPoly->coeffErr = psAlloc(nX * sizeof(psF64 **));
     newPoly->mask = (char ***)psAlloc(nX * sizeof(char **));
     for (x = 0; x < nX; x++) {
-        newPoly->coeff[x] = (psF32 **)psAlloc(nY * sizeof(psF32 *));
-        newPoly->coeffErr[x] = (psF32 **)psAlloc(nY * sizeof(psF32 *));
+        newPoly->coeff[x] = psAlloc(nY * sizeof(psF64 *));
+        newPoly->coeffErr[x] = psAlloc(nY * sizeof(psF64 *));
         newPoly->mask[x] = (char **)psAlloc(nY * sizeof(char *));
         for (y = 0; y < nY; y++) {
-            newPoly->coeff[x][y] = (psF32 *)psAlloc(nZ * sizeof(psF32));
-            newPoly->coeffErr[x][y] = (psF32 *)psAlloc(nZ * sizeof(psF32));
+            newPoly->coeff[x][y] = psAlloc(nZ * sizeof(psF64));
+            newPoly->coeffErr[x][y] = psAlloc(nZ * sizeof(psF64));
             newPoly->mask[x][y] = (char *)psAlloc(nZ * sizeof(char));
         }
@@ -1199 +851 @@
     newPoly->nT = nT;
 
-    newPoly->coeff = (psF32 ****)psAlloc(nX * sizeof(psF32 ***));
-    newPoly->coeffErr = (psF32 ****)psAlloc(nX * sizeof(psF32 ***));
+    newPoly->coeff = psAlloc(nX * sizeof(psF64 ***));
+    newPoly->coeffErr = psAlloc(nX * sizeof(psF64 ***));
     newPoly->mask = (char ****)psAlloc(nX * sizeof(char ***));
     for (x = 0; x < nX; x++) {
-        newPoly->coeff[x] = (psF32 ***)psAlloc(nY * sizeof(psF32 **));
-        newPoly->coeffErr[x] = (psF32 ***)psAlloc(nY * sizeof(psF32 **));
+        newPoly->coeff[x] = psAlloc(nY * sizeof(psF64 **));
+        newPoly->coeffErr[x] = psAlloc(nY * sizeof(psF64 **));
         newPoly->mask[x] = (char ***)psAlloc(nY * sizeof(char **));
         for (y = 0; y < nY; y++) {
-            newPoly->coeff[x][y] = (psF32 **)psAlloc(nZ * sizeof(psF32 *));
-            newPoly->coeffErr[x][y] = (psF32 **)psAlloc(nZ * sizeof(psF32 *));
+            newPoly->coeff[x][y] = psAlloc(nZ * sizeof(psF64 *));
+            newPoly->coeffErr[x][y] = psAlloc(nZ * sizeof(psF64 *));
             newPoly->mask[x][y] = (char **)psAlloc(nZ * sizeof(char *));
             for (z = 0; z < nZ; z++) {
-                newPoly->coeff[x][y][z] = (psF32 *)psAlloc(nT * sizeof(psF32));
-                newPoly->coeffErr[x][y][z] = (psF32 *)psAlloc(nT * sizeof(psF32));
+                newPoly->coeff[x][y][z] = psAlloc(nT * sizeof(psF64));
+                newPoly->coeffErr[x][y][z] = psAlloc(nT * sizeof(psF64));
                 newPoly->mask[x][y][z] = (char *)psAlloc(nT * sizeof(char));
             }
@@ -1253 +905 @@
     PS_ASSERT_POLY_NON_NULL(poly, NULL);
     PS_ASSERT_VECTOR_NON_NULL(x, NULL);
-    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
+    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F64, NULL);
 
     psVector *tmp;
 
-    tmp = psVectorAlloc(x->n, PS_TYPE_F32);
+    tmp = psVectorAlloc(x->n, PS_TYPE_F64);
     for (psS32 i=0;i<x->n;i++) {
-        tmp->data.F32[i] = psPolynomial1DEval(poly, x->data.F32[i]);
+        tmp->data.F64[i] = psPolynomial1DEval(poly, x->data.F64[i]);
     }
 
@@ -1288 +940 @@
     PS_ASSERT_POLY_NON_NULL(poly, NULL);
     PS_ASSERT_VECTOR_NON_NULL(x, NULL);
-    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
+    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F64, NULL);
     PS_ASSERT_VECTOR_NON_NULL(y, NULL);
-    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F32, NULL);
+    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F64, NULL);
 
     psVector *tmp;
@@ -1301 +953 @@
 
     // Create output vector to return
-    tmp = psVectorAlloc(vecLen, PS_TYPE_F32);
+    tmp = psVectorAlloc(vecLen, PS_TYPE_F64);
 
     // Evaluate the polynomial at the specified points
     for (psS32 i=0; i<vecLen; i++) {
-        tmp->data.F32[i] = psPolynomial2DEval(poly,x->data.F32[i],y->data.F32[i]);
+        tmp->data.F64[i] = psPolynomial2DEval(poly,x->data.F64[i],y->data.F64[i]);
     }
 
@@ -1336 +988 @@
     PS_ASSERT_POLY_NON_NULL(poly, NULL);
     PS_ASSERT_VECTOR_NON_NULL(x, NULL);
-    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
+    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F64, NULL);
     PS_ASSERT_VECTOR_NON_NULL(y, NULL);
-    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F32, NULL);
+    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F64, NULL);
     PS_ASSERT_VECTOR_NON_NULL(z, NULL);
-    PS_ASSERT_VECTOR_TYPE(z, PS_TYPE_F32, NULL);
+    PS_ASSERT_VECTOR_TYPE(z, PS_TYPE_F64, NULL);
 
     psVector *tmp;
@@ -1354 +1006 @@
 
     // Allocate output vector
-    tmp = psVectorAlloc(vecLen, PS_TYPE_F32);
+    tmp = psVectorAlloc(vecLen, PS_TYPE_F64);
 
     // Evaluate polynomial
     for (psS32 i = 0; i < vecLen; i++) {
-        tmp->data.F32[i] = psPolynomial3DEval(poly,
-                                              x->data.F32[i],
-                                              y->data.F32[i],
-                                              z->data.F32[i]);
+        tmp->data.F64[i] = psPolynomial3DEval(poly,
+                                              x->data.F64[i],
+                                              y->data.F64[i],
+                                              z->data.F64[i]);
     }
 
@@ -1389 +1041 @@
                                    const psVector *z,
                                    const psVector *t)
-{
-    PS_ASSERT_POLY_NON_NULL(poly, NULL);
-    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
-    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
-    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
-    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F32, NULL);
-    PS_ASSERT_VECTOR_NON_NULL(z, NULL);
-    PS_ASSERT_VECTOR_TYPE(z, PS_TYPE_F32, NULL);
-    PS_ASSERT_VECTOR_NON_NULL(t, NULL);
-    PS_ASSERT_VECTOR_TYPE(t, PS_TYPE_F32, NULL);
-
-    psVector *tmp;
-    psS32 vecLen=x->n;
-
-    // Determine output vector size from min of input vectors
-    if (z->n < vecLen) {
-        vecLen = z->n;
-    }
-    if (y->n < vecLen) {
-        vecLen = y->n;
-    }
-    if (t->n < vecLen) {
-        vecLen = t->n;
-    }
-
-    // Allocate output vector
-    tmp = psVectorAlloc(vecLen, PS_TYPE_F32);
-
-    // Evaluate polynomial
-    for (psS32 i = 0; i < vecLen; i++) {
-        tmp->data.F32[i] = psPolynomial4DEval(poly,
-                                              x->data.F32[i],
-                                              y->data.F32[i],
-                                              z->data.F32[i],
-                                              t->data.F32[i]);
-    }
-
-    // Return output vector
-    return(tmp);
-}
-
-
-psDPolynomial1D* psDPolynomial1DAlloc( int n,
-                                       psPolynomialType type)
-{
-    PS_ASSERT_INT_POSITIVE(n, NULL);
-
-    unsigned int i = 0;
-    psDPolynomial1D* newPoly = NULL;
-
-    newPoly = (psDPolynomial1D* ) psAlloc(sizeof(psDPolynomial1D));
-    psMemSetDeallocator(newPoly, (psFreeFunc) dPolynomial1DFree);
-
-    newPoly->type = type;
-    newPoly->n = n;
-    newPoly->coeff = (psF64 *)psAlloc(n * sizeof(psF64));
-    newPoly->coeffErr = (psF64 *)psAlloc(n * sizeof(psF64));
-    newPoly->mask = (char *)psAlloc(n * sizeof(char));
-    for (i = 0; i < n; i++) {
-        newPoly->coeff[i] = 0.0;
-        newPoly->coeffErr[i] = 0.0;
-        newPoly->mask[i] = 0;
-    }
-
-    return(newPoly);
-}
-
-psDPolynomial2D* psDPolynomial2DAlloc( int nX,  int nY,
-                                       psPolynomialType type)
-{
-    PS_ASSERT_INT_POSITIVE(nX, NULL);
-    PS_ASSERT_INT_POSITIVE(nY, NULL);
-
-    unsigned int x = 0;
-    unsigned int y = 0;
-    psDPolynomial2D* newPoly = NULL;
-
-    newPoly = (psDPolynomial2D* ) psAlloc(sizeof(psDPolynomial2D));
-    psMemSetDeallocator(newPoly, (psFreeFunc) dPolynomial2DFree);
-
-    newPoly->type = type;
-    newPoly->nX = nX;
-    newPoly->nY = nY;
-
-    newPoly->coeff = (psF64 **)psAlloc(nX * sizeof(psF64 *));
-    newPoly->coeffErr = (psF64 **)psAlloc(nX * sizeof(psF64 *));
-    newPoly->mask = (char **)psAlloc(nX * sizeof(char *));
-    for (x = 0; x < nX; x++) {
-        newPoly->coeff[x] = (psF64 *)psAlloc(nY * sizeof(psF64));
-        newPoly->coeffErr[x] = (psF64 *)psAlloc(nY * sizeof(psF64));
-        newPoly->mask[x] = (char *)psAlloc(nY * sizeof(char));
-    }
-    for (x = 0; x < nX; x++) {
-        for (y = 0; y < nY; y++) {
-            newPoly->coeff[x][y] = 0.0;
-            newPoly->coeffErr[x][y] = 0.0;
-            newPoly->mask[x][y] = 0;
-        }
-    }
-
-    return(newPoly);
-}
-
-psDPolynomial3D* psDPolynomial3DAlloc( int nX,  int nY,  int nZ,
-                                       psPolynomialType type)
-{
-    PS_ASSERT_INT_POSITIVE(nX, NULL);
-    PS_ASSERT_INT_POSITIVE(nY, NULL);
-    PS_ASSERT_INT_POSITIVE(nZ, NULL);
-
-    unsigned int x = 0;
-    unsigned int y = 0;
-    unsigned int z = 0;
-    psDPolynomial3D* newPoly = NULL;
-
-    newPoly = (psDPolynomial3D* ) psAlloc(sizeof(psDPolynomial3D));
-    psMemSetDeallocator(newPoly, (psFreeFunc) dPolynomial3DFree);
-
-    newPoly->type = type;
-    newPoly->nX = nX;
-    newPoly->nY = nY;
-    newPoly->nZ = nZ;
-
-    newPoly->coeff = (psF64 ***)psAlloc(nX * sizeof(psF64 **));
-    newPoly->coeffErr = (psF64 ***)psAlloc(nX * sizeof(psF64 **));
-    newPoly->mask = (char ***)psAlloc(nX * sizeof(char **));
-    for (x = 0; x < nX; x++) {
-        newPoly->coeff[x] = (psF64 **)psAlloc(nY * sizeof(psF64 *));
-        newPoly->coeffErr[x] = (psF64 **)psAlloc(nY * sizeof(psF64 *));
-        newPoly->mask[x] = (char **)psAlloc(nY * sizeof(char *));
-        for (y = 0; y < nY; y++) {
-            newPoly->coeff[x][y] = (psF64 *)psAlloc(nZ * sizeof(psF64));
-            newPoly->coeffErr[x][y] = (psF64 *)psAlloc(nZ * sizeof(psF64));
-            newPoly->mask[x][y] = (char *)psAlloc(nZ * sizeof(char));
-        }
-    }
-    for (x = 0; x < nX; x++) {
-        for (y = 0; y < nY; y++) {
-            for (z = 0; z < nZ; z++) {
-                newPoly->coeff[x][y][z] = 0.0;
-                newPoly->coeffErr[x][y][z] = 0.0;
-                newPoly->mask[x][y][z] = 0;
-            }
-        }
-    }
-
-    return(newPoly);
-}
-
-psDPolynomial4D* psDPolynomial4DAlloc( int nX,  int nY,  int nZ,  int nT,
-                                       psPolynomialType type)
-{
-    PS_ASSERT_INT_POSITIVE(nX, NULL);
-    PS_ASSERT_INT_POSITIVE(nY, NULL);
-    PS_ASSERT_INT_POSITIVE(nZ, NULL);
-    PS_ASSERT_INT_POSITIVE(nT, NULL);
-
-    unsigned int x = 0;
-    unsigned int y = 0;
-    unsigned int z = 0;
-    unsigned int t = 0;
-    psDPolynomial4D* newPoly = NULL;
-
-    newPoly = (psDPolynomial4D* ) psAlloc(sizeof(psDPolynomial4D));
-    psMemSetDeallocator(newPoly, (psFreeFunc) dPolynomial4DFree);
-
-    newPoly->type = type;
-    newPoly->nX = nX;
-    newPoly->nY = nY;
-    newPoly->nZ = nZ;
-    newPoly->nT = nT;
-
-    newPoly->coeff = (psF64 ****)psAlloc(nX * sizeof(psF64 ***));
-    newPoly->coeffErr = (psF64 ****)psAlloc(nX * sizeof(psF64 ***));
-    newPoly->mask = (char ****)psAlloc(nX * sizeof(char ***));
-    for (x = 0; x < nX; x++) {
-        newPoly->coeff[x] = (psF64 ***)psAlloc(nY * sizeof(psF64 **));
-        newPoly->coeffErr[x] = (psF64 ***)psAlloc(nY * sizeof(psF64 **));
-        newPoly->mask[x] = (char ***)psAlloc(nY * sizeof(char **));
-        for (y = 0; y < nY; y++) {
-            newPoly->coeff[x][y] = (psF64 **)psAlloc(nZ * sizeof(psF64 *));
-            newPoly->coeffErr[x][y] = (psF64 **)psAlloc(nZ * sizeof(psF64 *));
-            newPoly->mask[x][y] = (char **)psAlloc(nZ * sizeof(char *));
-            for (z = 0; z < nZ; z++) {
-                newPoly->coeff[x][y][z] = (psF64 *)psAlloc(nT * sizeof(psF64));
-                newPoly->coeffErr[x][y][z] = (psF64 *)psAlloc(nT * sizeof(psF64));
-                newPoly->mask[x][y][z] = (char *)psAlloc(nT * sizeof(char));
-            }
-        }
-    }
-    for (x = 0; x < nX; x++) {
-        for (y = 0; y < nY; y++) {
-            for (z = 0; z < nZ; z++) {
-                for (t = 0; t < nT; t++) {
-                    newPoly->coeff[x][y][z][t] = 0.0;
-                    newPoly->coeffErr[x][y][z][t] = 0.0;
-                    newPoly->mask[x][y][z][t] = 0;
-                }
-            }
-        }
-    }
-
-    return(newPoly);
-}
-
-
-psF64 psDPolynomial1DEval(const psDPolynomial1D* poly, psF64 x)
-{
-    PS_ASSERT_POLY_NON_NULL(poly, NAN);
-
-    if (poly->type == PS_POLYNOMIAL_ORD) {
-        return(dOrdPolynomial1DEval(x, poly));
-    } else if (poly->type == PS_POLYNOMIAL_CHEB) {
-        return(dChebPolynomial1DEval(x, poly));
-    } else {
-        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psFunctions_INVALID_POLYNOMIAL_TYPE,
-                poly->type);
-    }
-    return(NAN);
-}
-
-psVector *psDPolynomial1DEvalVector(const psDPolynomial1D *poly,
-                                    const psVector *x)
-
-{
-    PS_ASSERT_POLY_NON_NULL(poly, NULL);
-    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
-    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F64, NULL);
-
-    psVector *tmp;
-
-    tmp = psVectorAlloc(x->n, PS_TYPE_F64);
-    for (psS32 i=0;i<x->n;i++) {
-        tmp->data.F64[i] = psDPolynomial1DEval(poly,
-                                               x->data.F64[i]);
-    }
-
-    return(tmp);
-}
-
-
-psF64 psDPolynomial2DEval(const psDPolynomial2D* poly,
-                          psF64 x,
-                          psF64 y)
-{
-    PS_ASSERT_POLY_NON_NULL(poly, NAN);
-    if (poly->type == PS_POLYNOMIAL_ORD) {
-        return(dOrdPolynomial2DEval(x, y, poly));
-    } else if (poly->type == PS_POLYNOMIAL_CHEB) {
-        return(dChebPolynomial2DEval(x, y, poly));
-    } else {
-        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psFunctions_INVALID_POLYNOMIAL_TYPE,
-                poly->type);
-    }
-    return(NAN);
-}
-
-psVector *psDPolynomial2DEvalVector(const psDPolynomial2D *poly,
-                                    const psVector *x,
-                                    const psVector *y)
-{
-    PS_ASSERT_POLY_NON_NULL(poly, NULL);
-    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
-    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F64, NULL);
-    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
-    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F64, NULL);
-
-    psVector *tmp;
-    psS32 vecLen=x->n;
-
-    // Determine the output vector length from minimum length of input vectors
-    if (y->n < vecLen) {
-        vecLen = y->n;
-    }
-
-    // Allocate output vector
-    tmp = psVectorAlloc(vecLen, PS_TYPE_F64);
-
-    // Evaluate the polynomial
-    for (psS32 i = 0; i < vecLen; i++) {
-        tmp->data.F64[i] = psDPolynomial2DEval(poly,x->data.F64[i],y->data.F64[i]);
-    }
-
-    // Return output vector
-    return(tmp);
-}
-
-
-psF64 psDPolynomial3DEval(const psDPolynomial3D* poly,
-                          psF64 x,
-                          psF64 y,
-                          psF64 z)
-{
-    PS_ASSERT_POLY_NON_NULL(poly, NAN);
-
-    if (poly->type == PS_POLYNOMIAL_ORD) {
-        return(dOrdPolynomial3DEval(x, y, z, poly));
-    } else if (poly->type == PS_POLYNOMIAL_CHEB) {
-        return(dChebPolynomial3DEval(x, y, z, poly));
-    } else {
-        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psFunctions_INVALID_POLYNOMIAL_TYPE,
-                poly->type);
-    }
-    return(NAN);
-}
-
-psVector *psDPolynomial3DEvalVector(const psDPolynomial3D *poly,
-                                    const psVector *x,
-                                    const psVector *y,
-                                    const psVector *z)
-
-{
-    PS_ASSERT_POLY_NON_NULL(poly, NULL);
-    PS_ASSERT_VECTOR_NON_NULL(x, NULL);
-    PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F64, NULL);
-    PS_ASSERT_VECTOR_NON_NULL(y, NULL);
-    PS_ASSERT_VECTOR_TYPE(y, PS_TYPE_F64, NULL);
-    PS_ASSERT_VECTOR_NON_NULL(z, NULL);
-    PS_ASSERT_VECTOR_TYPE(z, PS_TYPE_F64, NULL);
-
-    psVector *tmp;
-    psS32 vecLen=x->n;
-
-    // Determine the size of output vector from min of input vectors
-    if (y->n < vecLen) {
-        vecLen = y->n;
-    }
-    if (z->n < vecLen) {
-        vecLen = z->n;
-    }
-
-    // Allocate output vector
-    tmp = psVectorAlloc(vecLen, PS_TYPE_F64);
-
-    // Evaluate polynomial
-    for (psS32 i = 0; i < vecLen; i++) {
-        tmp->data.F64[i] = psDPolynomial3DEval(poly,
-                                               x->data.F64[i],
-                                               y->data.F64[i],
-                                               z->data.F64[i]);
-    }
-
-    // Return output vector
-    return(tmp);
-}
-
-psF64 psDPolynomial4DEval(const psDPolynomial4D* poly,
-                          psF64 x,
-                          psF64 y,
-                          psF64 z,
-                          psF64 t)
-{
-    PS_ASSERT_POLY_NON_NULL(poly, NAN);
-
-    if (poly->type == PS_POLYNOMIAL_ORD) {
-        return(dOrdPolynomial4DEval(x,y,z,t, poly));
-    } else if (poly->type == PS_POLYNOMIAL_CHEB) {
-        return(dChebPolynomial4DEval(x,y,z,t, poly));
-    } else {
-        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
-                PS_ERRORTEXT_psFunctions_INVALID_POLYNOMIAL_TYPE,
-                poly->type);
-    }
-    return(NAN);
-}
-
-psVector *psDPolynomial4DEvalVector(const psDPolynomial4D *poly,
-                                    const psVector *x,
-                                    const psVector *y,
-                                    const psVector *z,
-                                    const psVector *t)
 {
     PS_ASSERT_POLY_NON_NULL(poly, NULL);
@@ -1777 +1055 @@
     psS32 vecLen=x->n;
 
-    // Determine the output vector size from min of input vectors
+    // Determine output vector size from min of input vectors
     if (z->n < vecLen) {
         vecLen = z->n;
@@ -1791 +1069 @@
     tmp = psVectorAlloc(vecLen, PS_TYPE_F64);
 
-    // Evaluate the polynomial
+    // Evaluate polynomial
     for (psS32 i = 0; i < vecLen; i++) {
-        tmp->data.F64[i] = psDPolynomial4DEval(poly,
-                                               x->data.F64[i],
-                                               y->data.F64[i],
-                                               z->data.F64[i],
-                                               t->data.F64[i]);
+        tmp->data.F64[i] = psPolynomial4DEval(poly,
+                                              x->data.F64[i],
+                                              y->data.F64[i],
+                                              z->data.F64[i],
+                                              t->data.F64[i]);
     }
 
@@ -1803 +1081 @@
     return(tmp);
 }
-
-
-
 
 //typedef struct {

trunk/psLib/src/math/psFunctions.h

@@ -12 +12 @@
  *  @author GLG, MHPCC
  *
- *  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2005-07-16 00:06:32 $
+ *  @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-07-20 01:21:13 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -74 +74 @@
 {
     psPolynomialType type;             ///< Polynomial type
-    psElemType ctype;                  ///< Polynomial precision
     int n;                             ///< Number of terms
-    psF32 *coeff;                      ///< Coefficients
-    psF32 *coeffErr;                   ///< Error in coefficients
+    psF64 *coeff;                      ///< Coefficients
+    psF64 *coeffErr;                   ///< Error in coefficients
     char *mask;                        ///< Coefficient mask
 }
@@ -86 +85 @@
 {
     psPolynomialType type;             ///< Polynomial type
-    psElemType ctype;                  ///< Polynomial precision
     int nX;                            ///< Number of terms in x
     int nY;                            ///< Number of terms in y
-    psF32 **coeff;                     ///< Coefficients
-    psF32 **coeffErr;                  ///< Error in coefficients
+    psF64 **coeff;                     ///< Coefficients
+    psF64 **coeffErr;                  ///< Error in coefficients
     char **mask;                       ///< Coefficients mask
 }
@@ -99 +97 @@
 {
     psPolynomialType type;             ///< Polynomial type
-    psElemType ctype;                  ///< Polynomial precision
     int nX;                           ///< Number of terms in x
     int nY;                            ///< Number of terms in y
     int nZ;                           ///< Number of terms in z
-    psF32 ***coeff;                    ///< Coefficients
-    psF32 ***coeffErr;                 ///< Error in coefficients
+    psF64 ***coeff;                    ///< Coefficients
+    psF64 ***coeffErr;                 ///< Error in coefficients
     char ***mask;                      ///< Coefficients mask
 }
@@ -113 +110 @@
 {
     psPolynomialType type;             ///< Polynomial type
-    psElemType ctype;                  ///< Polynomial precision
     int nX;                            ///< Number of terms in x
     int nY;                            ///< Number of terms in y
     int nZ;                            ///< Number of terms in z
     int nT;                            ///< Number of terms in t
-    psF32 ****coeff;                   ///< Coefficients
-    psF32 ****coeffErr;                ///< Error in coefficients
+    psF64 ****coeff;                   ///< Coefficients
+    psF64 ****coeffErr;                ///< Error in coefficients
     char ****mask;                     ///< Coefficients mask
 }
@@ -251 +247 @@
 );
 
-/*****************************************************************************/
-
-/* Double-precision polynomials, mainly for use in astrometry */
-
-/** Double-precision one-dimensional polynomial */
-typedef struct
-{
-    psPolynomialType type;             ///< Polynomial type
-    int n;                             ///< Number of terms
-    psF64 *coeff;                      ///< Coefficients
-    psF64 *coeffErr;                   ///< Error in coefficients
-    char *mask;                        ///< Coefficient mask
-}
-psDPolynomial1D;
-
-/** Double-precision two-dimensional polynomial */
-typedef struct
-{
-    psPolynomialType type;             ///< Polynomial type
-    int nX;                            ///< Number of terms in x
-    int nY;                            ///< Number of terms in y
-    psF64 **coeff;                     ///< Coefficients
-    psF64 **coeffErr;                  ///< Error in coefficients
-    char **mask;                       ///< Coefficients mask
-}
-psDPolynomial2D;
-
-/** Double-precision three-dimensional polynomial */
-typedef struct
-{
-    psPolynomialType type;             ///< Polynomial type
-    int nX;                            ///< Number of terms in x
-    int nY;                            ///< Number of terms in y
-    int nZ;                            ///< Number of terms in z
-    psF64 ***coeff;                    ///< Coefficients
-    psF64 ***coeffErr;                 ///< Error in coefficients
-    char ***mask;                      ///< Coefficient mask
-}
-psDPolynomial3D;
-
-/** Double-precision four-dimensional polynomial */
-typedef struct
-{
-    psPolynomialType type;             ///< Polynomial type
-    int nX;                            ///< Number of terms in w
-    int nY;                            ///< Number of terms in x
-    int nZ;                            ///< Number of terms in y
-    int nT;                            ///< Number of terms in z
-    psF64 ****coeff;                   ///< Coefficients
-    psF64 ****coeffErr;                ///< Error in coefficients
-    char ****mask;                     ///< Coefficients mask
-}
-psDPolynomial4D;
-
-/** Allocates a double-precision 1-D polynomial structure with n terms
- *
- *  @return  psPolynomial1D*    new double-precision 1-D polynomial struct
- */
-psDPolynomial1D* psDPolynomial1DAlloc(
-    int n,                             ///< Number of terms
-    psPolynomialType type              ///< Polynomial Type
-);
-
-/** Allocates a double-precision 2-D polynomial structure
- *
- *  @return  psPolynomial2D*    new double-precision 2-D polynomial struct
- */
-psDPolynomial2D* psDPolynomial2DAlloc(
-    int nX,                            ///< Number of terms in x
-    int nY,                            ///< Number of terms in y
-    psPolynomialType type              ///< Polynomial Type
-);
-
-/** Allocates a double-precision 3-D polynomial structure
- *
- *  @return  psPolynomial3D*    new double-precision 3-D polynomial struct
- */
-psDPolynomial3D* psDPolynomial3DAlloc(
-    int nX,                            ///< Number of terms in x
-    int nY,                            ///< Number of terms in y
-    int nZ,                            ///< Number of terms in z
-    psPolynomialType type              ///< Polynomial Type
-);
-
-/** Allocates a double-precision 4-D polynomial structure
- *
- *  @return  psPolynomial4D*    new double-precision 4-D polynomial struct
- */
-psDPolynomial4D* psDPolynomial4DAlloc(
-    int nX,                            ///< Number of terms in w
-    int nY,                            ///< Number of terms in x
-    int nZ,                            ///< Number of terms in y
-    int nT,                            ///< Number of terms in z
-    psPolynomialType type              ///< Polynomial Type
-);
-
-/** Evaluates a double-precision 1-D polynomial at specific coordinates.
- *
- *  @return psF32    result of polynomial at given location
- */
-psF64 psDPolynomial1DEval(
-    const psDPolynomial1D* poly,     ///< Coefficients for the polynomial
-    psF64 x                            ///< Value at which to evaluate
-);
-
-/** Evaluates a double-precision 2-D polynomial at specific coordinates.
- *
- *  @return psF32    result of polynomial at given location
- */
-psF64 psDPolynomial2DEval(
-    const psDPolynomial2D* poly,      ///< Coefficients for the polynomial
-    psF64 x,                            ///< Value x at which to evaluate
-    psF64 y                             ///< Value y at which to evaluate
-);
-
-/** Evaluates a double-precision 3-D polynomial at specific coordinates.
- *
- *  @return psF64    result of polynomial at given location
- */
-psF64 psDPolynomial3DEval(
-    const psDPolynomial3D* poly,     ///< Coefficients for the polynomial
-    psF64 x,                           ///< Value x at which to evaluate
-    psF64 y,                           ///< Value y at which to evaluate
-    psF64 z                            ///< Value z at which to evaluate
-);
-
-/** Evaluates a double-precision 4-D polynomial at specific coordinates.
- *
- *  @return psF64    result of polynomial at given location
- */
-psF64 psDPolynomial4DEval(
-    const psDPolynomial4D* poly,     ///< Coefficients for the polynomial
-    psF64 x,                           ///< Value w at which to evaluate
-    psF64 y,                           ///< Value x at which to evaluate
-    psF64 z,                           ///< Value y at which to evaluate
-    psF64 t                            ///< Value z at which to evaluate
-);
-
-/** Evaluates a double-precision 1-D polynomial at specific sets of coordinates.
- *
- *  @return psVector*    results of polynomial at given locations
- */
-psVector *psDPolynomial1DEvalVector(
-    const psDPolynomial1D *poly,     ///< Coefficients for the polynomial
-    const psVector *x                  ///< x locations at which to evaluate
-);
-
-/** Evaluates a double-precision 2-D polynomial at specific sets of coordinates.
- *
- *  @return psVector*    results of polynomial at given locations
- */
-psVector *psDPolynomial2DEvalVector(
-    const psDPolynomial2D *poly,     ///< Coefficients for the polynomial
-    const psVector *x,                 ///< x locations at which to evaluate
-    const psVector *y                  ///< y locations at which to evaluate
-);
-
-/** Evaluates a double-precision 3-D polynomial at specific sets of coordinates.
- *
- *  @return psVector*    results of polynomial at given locations
- */
-psVector *psDPolynomial3DEvalVector(
-    const psDPolynomial3D *poly,     ///< Coefficients for the polynomial
-    const psVector *x,                 ///< x locations at which to evaluate
-    const psVector *y,                 ///< y locations at which to evaluate
-    const psVector *z                  ///< z locations at which to evaluate
-);
-
-/** Evaluates a double-precision 4-D polynomial at specific sets of coordinates.
- *
- *  @return psVector*    results of polynomial at given locations
- */
-psVector *psDPolynomial4DEvalVector(
-    const psDPolynomial4D *poly,     ///< Coefficients for the polynomial
-    const psVector *x,                 ///< w locations at which to evaluate
-    const psVector *y,                 ///< x locations at which to evaluate
-    const psVector *z,                 ///< y locations at which to evaluate
-    const psVector *t                  ///< z locations at which to evaluate
-);
 
 /** One-Dimensional Spline */

trunk/psLib/test/astro/tst_psCoord.c

@@ -6 +6 @@
 *  @author GLG, MHPCC
 *
-*  @version $Revision: 1.1 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2005-07-13 02:46:58 $
+*  @version $Revision: 1.2 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2005-07-20 01:21:13 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -265 +265 @@
 {
     psPlane*          out = NULL;
-    psDPolynomial2D*  tmp2DPoly = NULL;
+    psPolynomial2D*  tmp2DPoly = NULL;
     psPlane*          rc;
 
@@ -359 +359 @@
     psPlane*         out       = NULL;
     psPlane*         rc        = NULL;
-    psDPolynomial4D* tmp4DPoly = NULL;
+    psPolynomial4D* tmp4DPoly = NULL;
 
     // Allocate input coordinate

trunk/psLib/test/astronomy/tst_psAstrometry01.c

@@ -5 +5 @@
 *  @author GLG, MHPCC
 *
-*  @version $Revision: 1.32 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2005-06-25 02:02:05 $
+*  @version $Revision: 1.33 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2005-07-20 01:21:13 $
 *
 * XXX: Must test
@@ -113 +113 @@
     NAME = (psPlaneTransform *) psAlloc(sizeof(psPlaneTransform)); \
     psMemSetDeallocator(NAME, (psFreeFunc) psPlaneTransformFree); \
-    NAME->x = psDPolynomial2DAlloc(2, 2, PS_POLYNOMIAL_ORD); \
-    NAME->y = psDPolynomial2DAlloc(2, 2, PS_POLYNOMIAL_ORD); \
+    NAME->x = psPolynomial2DAlloc(2, 2, PS_POLYNOMIAL_ORD); \
+    NAME->y = psPolynomial2DAlloc(2, 2, PS_POLYNOMIAL_ORD); \
     NAME->x->coeff[1][0] = 1.0; \
     NAME->y->coeff[0][1] = 1.0; \
@@ -123 +123 @@
     NAME = (psPlaneDistort *) psAlloc(sizeof(psPlaneDistort)); \
     psMemSetDeallocator(NAME, (psFreeFunc) psPlaneDistortFree); \
-    NAME->x = psDPolynomial4DAlloc(2, 2, 2, 2, PS_POLYNOMIAL_ORD); \
-    NAME->y = psDPolynomial4DAlloc(2, 2, 2, 2, PS_POLYNOMIAL_ORD); \
+    NAME->x = psPolynomial4DAlloc(2, 2, 2, 2, PS_POLYNOMIAL_ORD); \
+    NAME->y = psPolynomial4DAlloc(2, 2, 2, 2, PS_POLYNOMIAL_ORD); \
     NAME->x->coeff[1][0][0][0] = 1.0; \
     NAME->y->coeff[0][1][0][0] = 1.0; \

trunk/psLib/test/db/verified/tst_psDB.stderr

@@ -168 +168 @@
     Following should generate an error message for invalid table
 <DATE><TIME>|<HOST>|E|p_psDBRunQuery (FILE:LINENO)
-    Failed to execute SQL query.  Error: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'null)' at line 1
+    Failed to execute SQL query.  Error: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'null) WHERE key_s32=1974' at line 1
 <DATE><TIME>|<HOST>|E|psDBSelectRows (FILE:LINENO)
     Query execution failed.

trunk/psLib/test/imageops/verified/tst_psImageStats.stderr

@@ -610 +610 @@
 pixel [0][3] is 320.00 should be 64.00
 pixel [0][4] is 545.00 should be 109.00
-The chi-squared per pixel is 54524.81
+The chi-squared per pixel is 54524.80
 psImageFitPolynomial(), psImageEvalPolynom(): (5 by 5)
 The chi-squared per pixel is 0.00

trunk/psLib/test/math/tst_psFunc00.c

@@ -4 +4 @@
 *    allocated and deallocated by the psPolynomialXXXlloc() procedures.
 *    It also calls the various psPolynomialXXXEval() procedures.
-* 
+*
 *    The F32 and F64 polynomials are tested for all orders (1 - 4) and for
 *    both ordinary and chebyshev polynomials.
-* 
+*
 *    NOTE: This test code requries the stdout file to verify that the results
 *    are good.
-* 
+*
 *    XXX: Modify these tests so that polynomials with a variety of different
 *    orders are created.
-* 
-*    @version $Revision: 1.1 $  $Name: not supported by cvs2svn $
-*    @date $Date: 2005-07-13 02:47:00 $
+*
+*    @version $Revision: 1.2 $  $Name: not supported by cvs2svn $
+*    @date $Date: 2005-07-20 01:21:13 $
 *
 *  Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
-*   
+*
 *****************************************************************************/
 #include <stdio.h>
@@ -31 +31 @@
 static psS32 testPolynomial3DAlloc(void);
 static psS32 testPolynomial4DAlloc(void);
-static psS32 testDPolynomial1DAlloc(void);
-static psS32 testDPolynomial2DAlloc(void);
-static psS32 testDPolynomial3DAlloc(void);
-static psS32 testDPolynomial4DAlloc(void);
 
 testDescription tests[] = {
@@ -41 +37 @@
                               {testPolynomial3DAlloc,578,"psPolynomial3DAlloc",0,false},
                               {testPolynomial4DAlloc,578,"psPolynomial4DAlloc",0,false},
-                              {testDPolynomial1DAlloc,579,"psDPolynomial1DAlloc",0,false},
-                              {testDPolynomial2DAlloc,579,"psDPolynomial2DAlloc",0,false},
-                              {testDPolynomial3DAlloc,579,"psDPolynomial3DAlloc",0,false},
-                              {testDPolynomial4DAlloc,579,"psDPolynomial4DAlloc",0,false},
                               {NULL}
                           };
@@ -109 +101 @@
 }
 
-// This test will allocate a 1D polynomial and verify the structure allocated
-psS32 testDPolynomial1DAlloc(void)
-{
-    psDPolynomial1D*  my1DDPoly  = NULL;
-
-    // Allocate polynomial
-    my1DDPoly = psDPolynomial1DAlloc(ORDER,PS_POLYNOMIAL_CHEB);
-    // Verify structure allocated
-    if(my1DDPoly == NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Returned NULL not expected");
-        return 1;
-    }
-    // Verify polynomial structure members set properly
-    if(my1DDPoly->n != ORDER) {
-        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
-                my1DDPoly->n, ORDER);
-        return 2;
-    }
-    if(my1DDPoly->type != PS_POLYNOMIAL_CHEB) {
-        psError(PS_ERR_UNKNOWN,true,"Type %d not as expected %d",
-                my1DDPoly->type, PS_POLYNOMIAL_CHEB);
-        return 3;
-    }
-    for(psS32 i = 0; i < ORDER; i++) {
-        if(my1DDPoly->coeff[i] != 0.0) {
-            psError(PS_ERR_UNKNOWN,true,"Coeff[%d] %lg not as expected %lg",
-                    i, my1DDPoly->coeff[i], 0.0);
-            return 4;
-        }
-        if(my1DDPoly->coeffErr[i] != 0.0) {
-            psError(PS_ERR_UNKNOWN,true,"CoeffErr[%d] %lg not as expected %lg",
-                    i, my1DDPoly->coeffErr[i], 0.0);
-            return 5;
-        }
-        if(my1DDPoly->mask[i] != 0) {
-            psError(PS_ERR_UNKNOWN,true,"Mask[%d] %d not as expected %d",
-                    i, my1DDPoly->mask[i], 0);
-            return 6;
-        }
-    }
-    psFree(my1DDPoly);
-
-    /*    // Attempt to allocate with negative order
-        psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms");
-        if(psDPolynomial1DAlloc(-1,PS_POLYNOMIAL_ORD) != NULL) {
-            psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL");
-            return 7;
-        }
-    */
-    return 0;
-}
-
 // This test will allocate a 2D polynomial and verify the structure allocated
 psS32 testPolynomial2DAlloc(void)
@@ -220 +160 @@
         psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms");
         if(psPolynomial2DAlloc(1,-1,PS_POLYNOMIAL_ORD) != NULL) {
-            psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL");
-            return 9;
-        }
-    */
-    return 0;
-}
-
-// This test will allocate a 2D polynomial and verify the structure allocated
-psS32 testDPolynomial2DAlloc(void)
-{
-    psDPolynomial2D* my2DDPoly = NULL;
-
-    // Allocate polynomial
-    my2DDPoly = psDPolynomial2DAlloc(ORDER,ORDER+1,PS_POLYNOMIAL_CHEB);
-    // Verify structure allocated
-    if(my2DDPoly == NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Returned NULL not expected");
-        return 1;
-    }
-    // Verify polynomial structure members set properly
-    if(my2DDPoly->nX != ORDER) {
-        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
-                my2DDPoly->nX, ORDER);
-        return 2;
-    }
-    // Verify polynomial structure members set properly
-    if(my2DDPoly->nY != ORDER+1) {
-        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
-                my2DDPoly->nY, ORDER+1);
-        return 3;
-    }
-    if(my2DDPoly->type != PS_POLYNOMIAL_CHEB) {
-        psError(PS_ERR_UNKNOWN,true,"Type %d not as expected %d",
-                my2DDPoly->type, PS_POLYNOMIAL_ORD);
-        return 4;
-    }
-    for(psS32 i = 0; i < ORDER; i++) {
-        for(psS32 j = 0; j < ORDER+1; j++) {
-            if(my2DDPoly->coeff[i][j] != 0.0) {
-                psError(PS_ERR_UNKNOWN,true,"Coeff[%d][%d] %lg not as expected %lg",
-                        i, j, my2DDPoly->coeff[i][j], 0.0);
-                return 5;
-            }
-            if(my2DDPoly->coeffErr[i][j] != 0.0) {
-                psError(PS_ERR_UNKNOWN,true,"CoeffErr[%d][%d] %lg not as expected %lg",
-                        i, j, my2DDPoly->coeffErr[i][j], 0.0);
-                return 6;
-            }
-            if(my2DDPoly->mask[i][j] != 0) {
-                psError(PS_ERR_UNKNOWN,true,"Mask[%d][%d] %d not as expected %d",
-                        i, j, my2DDPoly->mask[i][j], 0);
-                return 7;
-            }
-        }
-    }
-    psFree(my2DDPoly);
-    /*
-        // Attempt to allocate with negative order
-        psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms");
-        if(psDPolynomial2DAlloc(-1,1,PS_POLYNOMIAL_ORD) != NULL) {
-            psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL");
-            return 8;
-        }
-        // Attempt to allocate with negative order
-        psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms");
-        if(psDPolynomial2DAlloc(1,-1,PS_POLYNOMIAL_ORD) != NULL) {
             psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL");
             return 9;
@@ -366 +240 @@
         psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms");
         if(psPolynomial3DAlloc(1,1,-1,PS_POLYNOMIAL_ORD) != NULL) {
-            psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL");
-            return 11;
-        }
-    */
-    return 0;
-}
-
-// This test will allocate a 3D polynomial and verify the structure allocated
-psS32 testDPolynomial3DAlloc(void)
-{
-    psDPolynomial3D* my3DDPoly = NULL;
-
-    // Allocate polynomial
-    my3DDPoly = psDPolynomial3DAlloc(ORDER,ORDER+1,ORDER+2,PS_POLYNOMIAL_CHEB);
-    // Verify structure allocated
-    if(my3DDPoly == NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Returned NULL not expected");
-        return 1;
-    }
-    // Verify polynomial structure members set properly
-    if(my3DDPoly->nX != ORDER) {
-        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
-                my3DDPoly->nX, ORDER);
-        return 2;
-    }
-    // Verify polynomial structure members set properly
-    if(my3DDPoly->nY != ORDER+1) {
-        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
-                my3DDPoly->nY, ORDER+1);
-        return 3;
-    }
-    // Verify polynomial structure members set properly
-    if(my3DDPoly->nZ != ORDER+2) {
-        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
-                my3DDPoly->nZ, ORDER+2);
-        return 4;
-    }
-    if(my3DDPoly->type != PS_POLYNOMIAL_CHEB) {
-        psError(PS_ERR_UNKNOWN,true,"Type %d not as expected %d",
-                my3DDPoly->type, PS_POLYNOMIAL_ORD);
-        return 5;
-    }
-    for(psS32 i = 0; i < ORDER; i++) {
-        for(psS32 j = 0; j < ORDER+1; j++) {
-            for(psS32 k = 0; k < ORDER+2; k++) {
-                if(my3DDPoly->coeff[i][j][k] != 0.0) {
-                    psError(PS_ERR_UNKNOWN,true,"Coeff[%d][%d][%d] %lg not as expected %lg",
-                            i, j, k, my3DDPoly->coeff[i][j][k], 0.0);
-                    return 6;
-                }
-                if(my3DDPoly->coeffErr[i][j][k] != 0.0) {
-                    psError(PS_ERR_UNKNOWN,true,"CoeffErr[%d][%d][%d] %lg not as expected %lg",
-                            i, j, k, my3DDPoly->coeffErr[i][j][k], 0.0);
-                    return 7;
-                }
-                if(my3DDPoly->mask[i][j][k] != 0) {
-                    psError(PS_ERR_UNKNOWN,true,"Mask[%d][%d] %d not as expected %d",
-                            i, j, k, my3DDPoly->mask[i][j][k], 0);
-                    return 8;
-                }
-            }
-        }
-    }
-    psFree(my3DDPoly);
-
-    /*    // Attempt to allocate with negative order
-        psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms");
-        if(psDPolynomial3DAlloc(-1,1,1,PS_POLYNOMIAL_ORD) != NULL) {
-            psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL");
-            return 9;
-        }
-        // Attempt to allocate with negative order
-        psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms");
-        if(psDPolynomial3DAlloc(1,-1,1,PS_POLYNOMIAL_ORD) != NULL) {
-            psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL");
-            return 10;
-        }
-        // Attempt to allocate with negative order
-        psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms");
-        if(psDPolynomial3DAlloc(1,1,-1,PS_POLYNOMIAL_ORD) != NULL) {
             psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL");
             return 11;
@@ -547 +341 @@
 }
 
-// This test will allocate a 4D polynomial and verify the structure allocated
-psS32 testDPolynomial4DAlloc(void)
-{
-    psDPolynomial4D* my4DDPoly = NULL;
-
-    // Allocate polynomial
-    my4DDPoly = psDPolynomial4DAlloc(ORDER+3,ORDER,ORDER+1,ORDER+2,PS_POLYNOMIAL_ORD);
-    // Verify structure allocated
-    if(my4DDPoly == NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Returned NULL not expected");
-        return 1;
-    }
-    // Verify polynomial structure members set properly
-    if(my4DDPoly->nY != ORDER) {
-        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
-                my4DDPoly->nY, ORDER);
-        return 2;
-    }
-    // Verify polynomial structure members set properly
-    if(my4DDPoly->nZ != ORDER+1) {
-        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
-                my4DDPoly->nZ, ORDER+1);
-        return 3;
-    }
-    // Verify polynomial structure members set properly
-    if(my4DDPoly->nT != ORDER+2) {
-        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
-                my4DDPoly->nT, ORDER+2);
-        return 4;
-    }
-    // Verify polynomial structure members set properly
-    if(my4DDPoly->nX != ORDER+3) {
-        psError(PS_ERR_UNKNOWN,true,"Number of terms %d not as expected %d",
-                my4DDPoly->nX, ORDER+3);
-        return 5;
-    }
-    if(my4DDPoly->type != PS_POLYNOMIAL_ORD) {
-        psError(PS_ERR_UNKNOWN,true,"Type %d not as expected %d",
-                my4DDPoly->type, PS_POLYNOMIAL_ORD);
-        return 6;
-    }
-    for(psS32 i = 0; i < ORDER+3; i++) {
-        for(psS32 j = 0; j < ORDER; j++) {
-            for(psS32 k = 0; k < ORDER+1; k++) {
-                for(psS32 l = 0; l < ORDER+2; l++) {
-                    if(my4DDPoly->coeff[i][j][k][l] != 0.0) {
-                        psError(PS_ERR_UNKNOWN,true,"Coeff[%d][%d][%d][%d] %lg not as expected %lg",
-                                i, j, k, l, my4DDPoly->coeff[i][j][k][l], 0.0);
-                        return 7;
-                    }
-                    if(my4DDPoly->coeffErr[i][j][k][l] != 0.0) {
-                        psError(PS_ERR_UNKNOWN,true,"CoeffErr[%d][%d][%d][l] %lg not as expected %lg",
-                                i, j, k, l, my4DDPoly->coeffErr[i][j][k][l], 0.0);
-                        return 8;
-                    }
-                    if(my4DDPoly->mask[i][j][k][l] != 0) {
-                        psError(PS_ERR_UNKNOWN,true,"Mask[%d][%d][%d][%d] %d not as expected %d",
-                                i, j, k, l, my4DDPoly->mask[i][j][k][l], 0);
-                        return 9;
-                    }
-                }
-            }
-        }
-    }
-    psFree(my4DDPoly);
-
-    /*    // Attempt to allocate with negative order
-        psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms");
-        if(psDPolynomial4DAlloc(-1,1,1,1,PS_POLYNOMIAL_ORD) != NULL) {
-            psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL");
-            return 10;
-        }
-        // Attempt to allocate with negative order
-        psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms");
-        if(psDPolynomial4DAlloc(1,-1,1,1,PS_POLYNOMIAL_ORD) != NULL) {
-            psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL");
-            return 11;
-        }
-        // Attempt to allocate with negative order
-        psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms");
-        if(psDPolynomial4DAlloc(1,1,-1,1,PS_POLYNOMIAL_ORD) != NULL) {
-            psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL");
-            return 12;
-        }
-        // Attempt to allocate with negative order
-        psLogMsg(__func__,PS_LOG_INFO,"Following should generate error msg for negative terms");
-        if(psDPolynomial4DAlloc(1,1,1,-1,PS_POLYNOMIAL_ORD) != NULL) {
-            psError(PS_ERR_UNKNOWN,true,"Returned structure but expected NULL");
-            return 13;
-        }
-    */
-    return 0;
-}
-

trunk/psLib/test/math/tst_psFunc08.c

@@ -4 +4 @@
 *  ORD and CHEB type polynomials.
 *
-*  @version  $Revision: 1.1 $  $Name: not supported by cvs2svn $
-*  @date  $Date: 2005-07-13 02:47:00 $
+*  @version  $Revision: 1.2 $  $Name: not supported by cvs2svn $
+*  @date  $Date: 2005-07-20 01:21:13 $
 *
 *  XXX: Probably should test single- and multi-dimensional polynomials in
@@ -22 +22 @@
 
 static psS32 testPoly1DEval(void);
-static psS32 testDPoly1DEval(void);
 static psS32 testPoly1DEvalVector(void);
-static psS32 testDPoly1DEvalVector(void);
 
 testDescription tests[] = {
                               {testPoly1DEval,000,"psPolynomial1DEval",0,false},
-                              {testDPoly1DEval,000,"psDPolynomial1DEval",0,false},
                               {testPoly1DEvalVector,000,"psPolynomial1DEvalVector",0,false},
-                              {testDPoly1DEvalVector,000,"psDPolynomial1DEvalVector",0,false},
                               {NULL}
                           };
@@ -58 +54 @@
 psS32 testPoly1DEval(void)
 {
-    psF32  result;
-    psF32  resultCheb;
+    psF64  result;
+    psF64  resultCheb;
 
     // Allocate polynomial structure
@@ -103 +99 @@
 }
 
-// This test will verify operation of 1D polynomial evaluation
-psS32 testDPoly1DEval(void)
-{
-    psF64  result;
-    psF64  resultCheb;
-
-    // Allocate polynomial structure
-    psDPolynomial1D*  polyOrd = psDPolynomial1DAlloc(TERMS, PS_POLYNOMIAL_ORD);
-    psDPolynomial1D*  polyCheb = psDPolynomial1DAlloc(TERMS, PS_POLYNOMIAL_CHEB);
-    // Set polynomial members
-    for(psS32 i = 0; i < TERMS; i++) {
-        polyOrd->coeff[i] = Dpoly1DCoeff[i];
-        polyOrd->mask[i]  = poly1DMask[i];
-        polyCheb->coeff[i] = 1.0;
-        polyCheb->mask[i]  = poly1DMask[i];
-    }
-    // Evaluate test points and verify results
-    for(psS32 i = 0; i < TESTPOINTS; i++) {
-        result = psDPolynomial1DEval(polyOrd,Dpoly1DXValue[i]);
-        if(fabs(Dpoly1DXResult[i]-result) > ERROR_TOL ) {
-            psError(PS_ERR_UNKNOWN,true,"Evaluated value %lg not as expected %lg",
-                    result, Dpoly1DXResult[i]);
-            return i;
-        }
-        resultCheb = psDPolynomial1DEval(polyCheb,Dpoly1DXChebValue[i]);
-        if(fabs(Dpoly1DXChebResult[i]-resultCheb) > ERROR_TOL ) {
-            psError(PS_ERR_UNKNOWN,true,"Evaluated Chebyshev value %lg not as expected %lg",
-                    resultCheb, Dpoly1DXChebResult[i]);
-            return 5*i;
-        }
-    }
-    psFree(polyOrd);
-    psFree(polyCheb);
-
-    // Allocate polynomial with invalid type
-    polyOrd = psDPolynomial1DAlloc(TERMS, 99);
-    // Attempt to evaluation invalid polynomial type
-    psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type");
-    result = psDPolynomial1DEval(polyOrd,0.0);
-    if ( !isnan(result) ) {
-        psError(PS_ERR_UNKNOWN,true,"Did not return NAN for invalid polynomial type");
-        return 20;
-    }
-    psFree(polyOrd);
-
-    return 0;
-}
 
 psS32 testPoly1DEvalVector(void)
@@ -156 +105 @@
     psPolynomial1D* polyOrd = psPolynomial1DAlloc(TERMS,PS_POLYNOMIAL_ORD);
     psPolynomial1D* polyCheb = psPolynomial1DAlloc(TERMS,PS_POLYNOMIAL_CHEB);
-
-    // Set polynomial members
-    for(psS32 i = 0; i < TERMS; i++) {
-        polyOrd->coeff[i] = poly1DCoeff[i];
-        polyOrd->mask[i]  = poly1DMask[i];
-        polyCheb->coeff[i] = 1.0;
-        polyCheb->mask[i]  = poly1DMask[i];
-    }
-
-    // Create input vectors
-    psVector* inputOrd = psVectorAlloc(TESTPOINTS, PS_TYPE_F32);
-    psVector* inputCheb = psVectorAlloc(TESTPOINTS, PS_TYPE_F32);
-    for(psS32 i = 0; i < TESTPOINTS; i++) {
-        inputOrd->data.F32[i] = poly1DXValue[i];
-        inputCheb->data.F32[i] = poly1DXChebValue[i];
-    }
-
-    // Evaluate the vectors
-    psVector* outputOrd = psPolynomial1DEvalVector(polyOrd, inputOrd);
-    if(outputOrd == NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL.");
-        return 1;
-    }
-    if(outputOrd->type.type != PS_TYPE_F32) {
-        psError(PS_ERR_UNKNOWN,true,"Output vector of type %d expected %d",
-                outputOrd->type.type, PS_TYPE_F32);
-        return 2;
-    }
-    psVector* outputCheb = psPolynomial1DEvalVector(polyCheb, inputCheb);
-    if(outputCheb == NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL.");
-        return 1;
-    }
-    if(outputCheb->type.type != PS_TYPE_F32) {
-        psError(PS_ERR_UNKNOWN,true,"Output vector of type %d expected %d",
-                outputCheb->type.type, PS_TYPE_F32);
-        return 2;
-    }
-
-    // Verify the results
-    for(psS32 i = 0; i < TESTPOINTS; i++) {
-        if(fabs(poly1DXResult[i]-outputOrd->data.F32[i]) > ERROR_TOL) {
-            psError(PS_ERR_UNKNOWN,true,"Result[%d] %g not equal to expected %g",
-                    i, outputOrd->data.F32[i], poly1DXResult[i]);
-            return i*5;
-        }
-        if(fabs(poly1DXChebResult[i]-outputCheb->data.F32[i]) > ERROR_TOL) {
-            psError(PS_ERR_UNKNOWN,true,"ResultCheb[%d] %g not equal to expected %g",
-                    i, outputCheb->data.F32[i], poly1DXChebResult[i]);
-            return i*10;
-        }
-    }
-
-    // Attempt to invoke function with null polynomial
-    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL polynomial");
-    if(psPolynomial1DEvalVector(NULL, inputOrd) != NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL polynomial");
-        return 60;
-    }
-
-    // Attempt to invoke function with null input vector
-    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
-    if(psPolynomial1DEvalVector(polyOrd,NULL) != NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
-        return 61;
-    }
-
-    // Attempt to invoke function with a non F32 type input vector
-    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
-    inputOrd->type.type = PS_TYPE_U8;
-    if(psPolynomial1DEvalVector(polyOrd,inputOrd) != NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F32 input vector");
-        return 62;
-    }
-    inputOrd->type.type = PS_TYPE_F32;
-
-    psFree(inputOrd);
-    psFree(inputCheb);
-    psFree(outputOrd);
-    psFree(outputCheb);
-    psFree(polyOrd);
-    psFree(polyCheb);
-
-    return 0;
-}
-
-psS32 testDPoly1DEvalVector(void)
-{
-    // Allocate polynomial
-    psDPolynomial1D* polyOrd = psDPolynomial1DAlloc(TERMS,PS_POLYNOMIAL_ORD);
-    psDPolynomial1D* polyCheb = psDPolynomial1DAlloc(TERMS,PS_POLYNOMIAL_CHEB);
 
     // Set polynomial members
@@ -265 +123 @@
 
     // Evaluate the vectors
-    psVector* outputOrd = psDPolynomial1DEvalVector(polyOrd, inputOrd);
+    psVector* outputOrd = psPolynomial1DEvalVector(polyOrd, inputOrd);
     if(outputOrd == NULL) {
         psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL.");
@@ -275 +133 @@
         return 2;
     }
-    psVector* outputCheb = psDPolynomial1DEvalVector(polyCheb, inputCheb);
+    psVector* outputCheb = psPolynomial1DEvalVector(polyCheb, inputCheb);
     if(outputCheb == NULL) {
         psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL.");
@@ -302 +160 @@
     // Attempt to invoke function with null polynomial
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL polynomial");
-    if(psDPolynomial1DEvalVector(NULL, inputOrd) != NULL) {
+    if(psPolynomial1DEvalVector(NULL, inputOrd) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL polynomial");
         return 60;
@@ -309 +167 @@
     // Attempt to invoke function with null input vector
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
-    if(psDPolynomial1DEvalVector(polyOrd,NULL) != NULL) {
+    if(psPolynomial1DEvalVector(polyOrd,NULL) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
         return 61;
@@ -317 +175 @@
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
     inputOrd->type.type = PS_TYPE_U8;
-    if(psDPolynomial1DEvalVector(polyOrd,inputOrd) != NULL) {
+    if(psPolynomial1DEvalVector(polyOrd,inputOrd) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector");
         return 62;

trunk/psLib/test/math/tst_psFunc09.c

@@ -4 +4 @@
 *  ORD and CHEB type polynomials.
 *
-*  @version  $Revision: 1.1 $  $Name: not supported by cvs2svn $
-*  @date  $Date: 2005-07-13 02:47:00 $
+*  @version  $Revision: 1.2 $  $Name: not supported by cvs2svn $
+*  @date  $Date: 2005-07-20 01:21:13 $
 *
 * Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
@@ -19 +19 @@
 
 static psS32 testPoly2DEval(void);
-static psS32 testDPoly2DEval(void);
 static psS32 testPoly2DEvalVector(void);
-static psS32 testDPoly2DEvalVector(void);
 
 testDescription tests[] = {
                               {testPoly2DEval,583,"psPolynomial2DEval",0,false},
-                              {testDPoly2DEval,582,"psDPolynomial2DEval",0,false},
                               {testPoly2DEvalVector,000,"psPolynomial2DEvalVector",0,false},
-                              {testDPoly2DEvalVector,000,"psDPolynomial2DEvalVector",0,false},
                               {NULL}
                           };
@@ -85 +81 @@
 
 // This test will verify operation of 1D polynomial evaluation
-psS32 testPoly2DEval(void)
+/*psS32 testPoly2DEval(void)
 {
     psF32  result;
     psF32  resultCheb;
-
+ 
     // Allocate polynomial structure
     psPolynomial2D*  polyOrd = psPolynomial2DAlloc(TERMS, TERMS, PS_POLYNOMIAL_ORD);
@@ -119 +115 @@
     psFree(polyOrd);
     psFree(polyCheb);
-
+ 
     // Allocate polynomial with invalid type
     polyOrd = psPolynomial2DAlloc(TERMS, TERMS, 99);
@@ -130 +126 @@
     }
     psFree(polyOrd);
-
+ 
     return 0;
 }
-
+*/
 // This test will verify operation of 1D polynomial evaluation
-psS32 testDPoly2DEval(void)
+psS32 testPoly2DEval(void)
 {
     psF64  result;
@@ -141 +137 @@
 
     // Allocate polynomial structure
-    psDPolynomial2D*  polyOrd = psDPolynomial2DAlloc(TERMS, TERMS, PS_POLYNOMIAL_ORD);
-    psDPolynomial2D*  polyCheb = psDPolynomial2DAlloc(TERMS, TERMS, PS_POLYNOMIAL_CHEB);
+    psPolynomial2D*  polyOrd = psPolynomial2DAlloc(TERMS, TERMS, PS_POLYNOMIAL_ORD);
+    psPolynomial2D*  polyCheb = psPolynomial2DAlloc(TERMS, TERMS, PS_POLYNOMIAL_CHEB);
     // Set polynomial members
     for(psS32 i = 0; i < TERMS; i++) {
@@ -154 +150 @@
     // Evaluate test points and verify results
     for(psS32 i = 0; i < TESTPOINTS; i++) {
-        result = psDPolynomial2DEval(polyOrd,Dpoly2DXYValue[i][0],Dpoly2DXYValue[i][1]);
+        result = psPolynomial2DEval(polyOrd,Dpoly2DXYValue[i][0],Dpoly2DXYValue[i][1]);
         if(fabs(Dpoly2DResult[i]-result) > ERROR_TOL ) {
             psError(PS_ERR_UNKNOWN,true,"Evaluated value %lg not as expected %lg",
@@ -160 +156 @@
             return i;
         }
-        resultCheb = psDPolynomial2DEval(polyCheb,Dpoly2DXYChebValue[i][0],Dpoly2DXYChebValue[i][1]);
+        resultCheb = psPolynomial2DEval(polyCheb,Dpoly2DXYChebValue[i][0],Dpoly2DXYChebValue[i][1]);
         if(fabs(Dpoly2DChebResult[i]-resultCheb) > ERROR_TOL ) {
             psError(PS_ERR_UNKNOWN,true,"Evaluated Chebyshev value %lg not as expected %lg",
@@ -171 +167 @@
 
     // Allocate polynomial with invalid type
-    polyOrd = psDPolynomial2DAlloc(TERMS, TERMS, 99);
+    polyOrd = psPolynomial2DAlloc(TERMS, TERMS, 99);
     // Attempt to evaluation invalid polynomial type
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type");
-    result = psDPolynomial2DEval(polyOrd,0.0, 0.0);
+    result = psPolynomial2DEval(polyOrd,0.0, 0.0);
     if ( !isnan(result) ) {
         psError(PS_ERR_UNKNOWN,true,"Did not return NAN for invalid polynomial type");
@@ -184 +180 @@
 }
 
-psS32 testPoly2DEvalVector(void)
+/*psS32 testPoly2DEvalVector(void)
 {
     // Allocate polynomial
     psPolynomial2D* polyOrd = psPolynomial2DAlloc(TERMS,TERMS,PS_POLYNOMIAL_ORD);
     psPolynomial2D* polyCheb = psPolynomial2DAlloc(TERMS,TERMS,PS_POLYNOMIAL_CHEB);
-
+ 
     // Set polynomial members
     for(psS32 i = 0; i < TERMS; i++) {
@@ -199 +195 @@
         }
     }
-
+ 
     // Create input vectors
     psVector* inputOrdX  = psVectorAlloc(TESTPOINTS, PS_TYPE_F32);
@@ -211 +207 @@
         inputChebY->data.F32[i] = poly2DXYChebValue[i][1];
     }
-
+ 
     // Evaluate the vectors
     psVector* outputOrd = psPolynomial2DEvalVector(polyOrd, inputOrdX, inputOrdY);
@@ -233 +229 @@
         return 2;
     }
-
+ 
     // Verify the results
     for(psS32 i = 0; i < TESTPOINTS; i++) {
@@ -247 +243 @@
         }
     }
-
+ 
     // Attempt to invoke function with null polynomial
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL polynomial");
@@ -254 +250 @@
         return 60;
     }
-
+ 
     // Attempt to invoke function with null input vector
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
@@ -267 +263 @@
         return 62;
     }
-
+ 
     // Attempt to invoke function with a non F32 type input vector
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
@@ -284 +280 @@
     }
     inputOrdY->type.type = PS_TYPE_F32;
-
+ 
     psFree(inputOrdX);
     psFree(inputOrdY);
@@ -293 +289 @@
     psFree(polyOrd);
     psFree(polyCheb);
-
+ 
     return 0;
 }
-
-psS32 testDPoly2DEvalVector(void)
+*/
+psS32 testPoly2DEvalVector(void)
 {
     // Allocate polynomial
-    psDPolynomial2D* polyOrd = psDPolynomial2DAlloc(TERMS,TERMS,PS_POLYNOMIAL_ORD);
-    psDPolynomial2D* polyCheb = psDPolynomial2DAlloc(TERMS,TERMS,PS_POLYNOMIAL_CHEB);
+    psPolynomial2D* polyOrd = psPolynomial2DAlloc(TERMS,TERMS,PS_POLYNOMIAL_ORD);
+    psPolynomial2D* polyCheb = psPolynomial2DAlloc(TERMS,TERMS,PS_POLYNOMIAL_CHEB);
 
     // Set polynomial members
@@ -326 +322 @@
 
     // Evaluate the vectors
-    psVector* outputOrd = psDPolynomial2DEvalVector(polyOrd, inputOrdX, inputOrdY);
+    psVector* outputOrd = psPolynomial2DEvalVector(polyOrd, inputOrdX, inputOrdY);
     if(outputOrd == NULL) {
         psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL.");
@@ -336 +332 @@
         return 2;
     }
-    psVector* outputCheb = psDPolynomial2DEvalVector(polyCheb, inputChebX, inputChebY);
+    psVector* outputCheb = psPolynomial2DEvalVector(polyCheb, inputChebX, inputChebY);
     if(outputCheb == NULL) {
         psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL.");
@@ -363 +359 @@
     // Attempt to invoke function with null polynomial
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL polynomial");
-    if(psDPolynomial2DEvalVector(NULL, inputOrdX, inputOrdY) != NULL) {
+    if(psPolynomial2DEvalVector(NULL, inputOrdX, inputOrdY) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL polynomial");
         return 60;
@@ -370 +366 @@
     // Attempt to invoke function with null input vector
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
-    if(psDPolynomial2DEvalVector(polyOrd,NULL,inputOrdY) != NULL) {
+    if(psPolynomial2DEvalVector(polyOrd,NULL,inputOrdY) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
         return 61;
@@ -376 +372 @@
     // Attempt to invoke function with null input vector
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
-    if(psDPolynomial2DEvalVector(polyOrd,inputOrdX,NULL) != NULL) {
+    if(psPolynomial2DEvalVector(polyOrd,inputOrdX,NULL) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
         return 62;
@@ -384 +380 @@
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
     inputOrdX->type.type = PS_TYPE_U8;
-    if(psDPolynomial2DEvalVector(polyOrd,inputOrdX, inputOrdY) != NULL) {
+    if(psPolynomial2DEvalVector(polyOrd,inputOrdX, inputOrdY) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector");
         return 63;
@@ -392 +388 @@
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
     inputOrdY->type.type = PS_TYPE_U8;
-    if(psDPolynomial2DEvalVector(polyOrd,inputOrdX, inputOrdY) != NULL) {
+    if(psPolynomial2DEvalVector(polyOrd,inputOrdX, inputOrdY) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector");
         return 64;

trunk/psLib/test/math/tst_psFunc10.c

@@ -4 +4 @@
 *  ORD and CHEB type polynomials.
 *
-*  @version  $Revision: 1.1 $  $Name: not supported by cvs2svn $
-*  @date  $Date: 2005-07-13 02:47:00 $
+*  @version  $Revision: 1.2 $  $Name: not supported by cvs2svn $
+*  @date  $Date: 2005-07-20 01:21:13 $
 *
 * Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
@@ -19 +19 @@
 
 static psS32 testPoly3DEval(void);
-static psS32 testDPoly3DEval(void);
 static psS32 testPoly3DEvalVector(void);
-static psS32 testDPoly3DEvalVector(void);
 
 testDescription tests[] = {
                               {testPoly3DEval,583,"psPolynomial3DEval",0,false},
-                              {testDPoly3DEval,582,"psDPolynomial3DEval",0,false},
                               {testPoly3DEvalVector,000,"psPolynomial3DEvalVector",0,false},
-                              {testDPoly3DEvalVector,000,"psDPolynomial3DEvalVector",0,false},
                               {NULL}
                           };
@@ -136 +132 @@
 
 // This test will verify operation of 1D polynomial evaluation
-psS32 testPoly3DEval(void)
+/*psS32 testPoly3DEval(void)
 {
     psF32  result;
     psF32  resultCheb;
-
+ 
     // Allocate polynomial structure
     psPolynomial3D*  polyOrd = psPolynomial3DAlloc(TERMS, TERMS, TERMS, PS_POLYNOMIAL_ORD);
@@ -174 +170 @@
     psFree(polyOrd);
     psFree(polyCheb);
-
+ 
     // Allocate polynomial with invalid type
     polyOrd = psPolynomial3DAlloc(TERMS, TERMS, TERMS, 99);
@@ -185 +181 @@
     }
     psFree(polyOrd);
-
+ 
     return 0;
 }
-
+*/
 // This test will verify operation of 1D polynomial evaluation
-psS32 testDPoly3DEval(void)
+psS32 testPoly3DEval(void)
 {
     psF64  result;
@@ -196 +192 @@
 
     // Allocate polynomial structure
-    psDPolynomial3D*  polyOrd = psDPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
-    psDPolynomial3D*  polyCheb = psDPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
+    psPolynomial3D*  polyOrd = psPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
+    psPolynomial3D*  polyCheb = psPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
     // Set polynomial members
     for(psS32 i = 0; i < TERMS; i++) {
@@ -211 +207 @@
     // Evaluate test points and verify results
     for(psS32 i = 0; i < TESTPOINTS; i++) {
-        result = psDPolynomial3DEval(polyOrd,Dpoly3DXYZValue[i][0],Dpoly3DXYZValue[i][1],
-                                     Dpoly3DXYZValue[i][2]);
+        result = psPolynomial3DEval(polyOrd,Dpoly3DXYZValue[i][0],Dpoly3DXYZValue[i][1],
+                                    Dpoly3DXYZValue[i][2]);
         if(fabs(Dpoly3DResult[i]-result) > ERROR_TOL ) {
             psError(PS_ERR_UNKNOWN,true,"Evaluated value %lg not as expected %lg",
@@ -218 +214 @@
             return i;
         }
-        resultCheb = psDPolynomial3DEval(polyCheb,Dpoly3DXYZChebValue[i][0],Dpoly3DXYZChebValue[i][1],
-                                         Dpoly3DXYZChebValue[i][2]);
+        resultCheb = psPolynomial3DEval(polyCheb,Dpoly3DXYZChebValue[i][0],Dpoly3DXYZChebValue[i][1],
+                                        Dpoly3DXYZChebValue[i][2]);
         if(fabs(Dpoly3DChebResult[i]-resultCheb) > ERROR_TOL ) {
             psError(PS_ERR_UNKNOWN,true,"Evaluated Chebyshev value %lg not as expected %lg",
@@ -230 +226 @@
 
     // Allocate polynomial with invalid type
-    polyOrd = psDPolynomial3DAlloc(TERMS, TERMS, TERMS, 99);
+    polyOrd = psPolynomial3DAlloc(TERMS, TERMS, TERMS, 99);
     // Attempt to evaluation invalid polynomial type
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type");
-    result = psDPolynomial3DEval(polyOrd,0.0, 0.0, 0.0);
+    result = psPolynomial3DEval(polyOrd,0.0, 0.0, 0.0);
     if ( !isnan(result) ) {
         psError(PS_ERR_UNKNOWN,true,"Did not return NAN for invalid polynomial type");
@@ -243 +239 @@
 }
 
-psS32 testPoly3DEvalVector(void)
+/*psS32 testPoly3DEvalVector(void)
 {
     // Allocate polynomial
     psPolynomial3D* polyOrd  = psPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
     psPolynomial3D* polyCheb = psPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
-
+ 
     // Set polynomial members
     for(psS32 i = 0; i < TERMS; i++) {
@@ -260 +256 @@
         }
     }
-
+ 
     // Create input vectors
     psVector* inputOrdX  = psVectorAlloc(TESTPOINTS, PS_TYPE_F32);
@@ -276 +272 @@
         inputChebZ->data.F32[i] = poly3DXYZChebValue[i][2];
     }
-
+ 
     // Evaluate the vectors
     psVector* outputOrd = psPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ);
@@ -298 +294 @@
         return 2;
     }
-
+ 
     // Verify the results
     for(psS32 i = 0; i < TESTPOINTS; i++) {
@@ -312 +308 @@
         }
     }
-
+ 
     // Attempt to invoke function with null polynomial
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL polynomial");
@@ -319 +315 @@
         return 60;
     }
-
+ 
     // Attempt to invoke function with null input vector
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
@@ -338 +334 @@
         return 63;
     }
-
+ 
     // Attempt to invoke function with a non F32 type input vector
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
@@ -363 +359 @@
     }
     inputOrdZ->type.type = PS_TYPE_F32;
-
+ 
     psFree(inputOrdX);
     psFree(inputOrdY);
@@ -374 +370 @@
     psFree(polyOrd);
     psFree(polyCheb);
-
+ 
     return 0;
 }
-
-psS32 testDPoly3DEvalVector(void)
+*/
+psS32 testPoly3DEvalVector(void)
 {
     // Allocate polynomial
-    psDPolynomial3D* polyOrd = psDPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
-    psDPolynomial3D* polyCheb = psDPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
+    psPolynomial3D* polyOrd = psPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
+    psPolynomial3D* polyCheb = psPolynomial3DAlloc(TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
 
     // Set polynomial members
@@ -413 +409 @@
 
     // Evaluate the vectors
-    psVector* outputOrd = psDPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ);
+    psVector* outputOrd = psPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ);
     if(outputOrd == NULL) {
         psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL.");
@@ -423 +419 @@
         return 2;
     }
-    psVector* outputCheb = psDPolynomial3DEvalVector(polyCheb,inputChebX,inputChebY,inputChebZ);
+    psVector* outputCheb = psPolynomial3DEvalVector(polyCheb,inputChebX,inputChebY,inputChebZ);
     if(outputCheb == NULL) {
         psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL.");
@@ -450 +446 @@
     // Attempt to invoke function with null polynomial
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL polynomial");
-    if(psDPolynomial3DEvalVector(NULL,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
+    if(psPolynomial3DEvalVector(NULL,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL polynomial");
         return 60;
@@ -457 +453 @@
     // Attempt to invoke function with null input vector
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
-    if(psDPolynomial3DEvalVector(polyOrd,NULL,inputOrdY,inputOrdZ) != NULL) {
+    if(psPolynomial3DEvalVector(polyOrd,NULL,inputOrdY,inputOrdZ) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
         return 61;
@@ -463 +459 @@
     // Attempt to invoke function with null input vector
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
-    if(psDPolynomial3DEvalVector(polyOrd,inputOrdX,NULL,inputOrdZ) != NULL) {
+    if(psPolynomial3DEvalVector(polyOrd,inputOrdX,NULL,inputOrdZ) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
         return 62;
@@ -469 +465 @@
     // Attempt to invoke function with null input vector
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
-    if(psDPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,NULL) != NULL) {
+    if(psPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,NULL) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
         return 63;
@@ -477 +473 @@
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
     inputOrdX->type.type = PS_TYPE_U8;
-    if(psDPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
+    if(psPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector");
         return 64;
@@ -485 +481 @@
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
     inputOrdY->type.type = PS_TYPE_U8;
-    if(psDPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
+    if(psPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector");
         return 65;
@@ -493 +489 @@
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
     inputOrdZ->type.type = PS_TYPE_U8;
-    if(psDPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
+    if(psPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector");
         return 66;

trunk/psLib/test/math/tst_psFunc11.c

@@ -4 +4 @@
 *  ORD and CHEB type polynomials.
 *
-*  @version  $Revision: 1.1 $  $Name: not supported by cvs2svn $
-*  @date  $Date: 2005-07-13 02:47:00 $
+*  @version  $Revision: 1.2 $  $Name: not supported by cvs2svn $
+*  @date  $Date: 2005-07-20 01:21:13 $
 *
 * Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
@@ -19 +19 @@
 
 static psS32 testPoly4DEval(void);
-static psS32 testDPoly4DEval(void);
 static psS32 testPoly4DEvalVector(void);
-static psS32 testDPoly4DEvalVector(void);
 
 testDescription tests[] = {
                               {testPoly4DEval,583,"psPolynomial4DEval",0,false},
-                              {testDPoly4DEval,582,"psDPolynomial4DEval",0,false},
                               {testPoly4DEvalVector,000,"psPolynomial4DEvalVector",0,false},
-                              {testDPoly4DEvalVector,000,"psDPolynomial4DEvalVector",0,false},
                               {NULL}
                           };
@@ -378 +374 @@
 
 // This test will verify operation of 1D polynomial evaluation
-psS32 testPoly4DEval(void)
+/*psS32 testPoly4DEval(void)
 {
     psF32  result;
     psF32  resultCheb;
-
+ 
     // Allocate polynomial structure
     psPolynomial4D*  polyOrd  = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
@@ -418 +414 @@
     psFree(polyOrd);
     psFree(polyCheb);
-
+ 
     // Allocate polynomial with invalid type
     polyOrd = psPolynomial4DAlloc(TERMS, TERMS, TERMS, TERMS, 99);
@@ -429 +425 @@
     }
     psFree(polyOrd);
-
+ 
     return 0;
 }
-
+*/
 // This test will verify operation of 1D polynomial evaluation
-psS32 testDPoly4DEval(void)
+psS32 testPoly4DEval(void)
 {
     psF64  result;
@@ -440 +436 @@
 
     // Allocate polynomial structure
-    psDPolynomial4D*  polyOrd = psDPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
-    psDPolynomial4D*  polyCheb = psDPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
+    psPolynomial4D*  polyOrd = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
+    psPolynomial4D*  polyCheb = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
     // Set polynomial members
     for(psS32 i = 0; i < TERMS; i++) {
@@ -457 +453 @@
     // Evaluate test points and verify results
     for(psS32 i = 0; i < TESTPOINTS; i++) {
-        result = psDPolynomial4DEval(polyOrd,Dpoly4DWXYZValue[i][0],Dpoly4DWXYZValue[i][1],
-                                     Dpoly4DWXYZValue[i][2],Dpoly4DWXYZValue[i][3]);
+        result = psPolynomial4DEval(polyOrd,Dpoly4DWXYZValue[i][0],Dpoly4DWXYZValue[i][1],
+                                    Dpoly4DWXYZValue[i][2],Dpoly4DWXYZValue[i][3]);
         if(fabs(Dpoly4DResult[i]-result) > ERROR_TOL ) {
             psError(PS_ERR_UNKNOWN,true,"Evaluated value %lg not as expected %lg",
@@ -464 +460 @@
             return i;
         }
-        resultCheb = psDPolynomial4DEval(polyCheb,Dpoly4DWXYZChebValue[i][0],Dpoly4DWXYZChebValue[i][1],
-                                         Dpoly4DWXYZChebValue[i][2],Dpoly4DWXYZChebValue[i][3]);
+        resultCheb = psPolynomial4DEval(polyCheb,Dpoly4DWXYZChebValue[i][0],Dpoly4DWXYZChebValue[i][1],
+                                        Dpoly4DWXYZChebValue[i][2],Dpoly4DWXYZChebValue[i][3]);
         if(fabs(Dpoly4DChebResult[i]-resultCheb) > ERROR_TOL ) {
             psError(PS_ERR_UNKNOWN,true,"Evaluated Chebyshev value %lg not as expected %lg",
@@ -476 +472 @@
 
     // Allocate polynomial with invalid type
-    polyOrd = psDPolynomial4DAlloc(TERMS, TERMS, TERMS, TERMS, 99);
+    polyOrd = psPolynomial4DAlloc(TERMS, TERMS, TERMS, TERMS, 99);
     // Attempt to evaluation invalid polynomial type
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type");
-    result = psDPolynomial4DEval(polyOrd,0.0, 0.0, 0.0, 0.0);
+    result = psPolynomial4DEval(polyOrd,0.0, 0.0, 0.0, 0.0);
     if ( !isnan(result) ) {
         psError(PS_ERR_UNKNOWN,true,"Did not return NAN for invalid polynomial type");
@@ -489 +485 @@
 }
 
-psS32 testPoly4DEvalVector(void)
+/*psS32 testPoly4DEvalVector(void)
 {
     // Allocate polynomial
     psPolynomial4D* polyOrd  = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
     psPolynomial4D* polyCheb = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
-
+ 
     // Set polynomial members
     for(psS32 i = 0; i < TERMS; i++) {
@@ -508 +504 @@
         }
     }
-
+ 
     // Create input vectors
     psVector* inputOrdW  = psVectorAlloc(TESTPOINTS, PS_TYPE_F32);
@@ -528 +524 @@
         inputChebZ->data.F32[i] = poly4DWXYZChebValue[i][3];
     }
-
+ 
     // Evaluate the vectors
     psVector* outputOrd = psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ);
@@ -550 +546 @@
         return 2;
     }
-
+ 
     // Verify the results
     for(psS32 i = 0; i < TESTPOINTS; i++) {
@@ -564 +560 @@
         }
     }
-
+ 
     // Attempt to invoke function with null polynomial
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL polynomial");
@@ -571 +567 @@
         return 60;
     }
-
+ 
     // Attempt to invoke function with null input vector
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
@@ -596 +592 @@
         return 64;
     }
-
+ 
     // Attempt to invoke function with a non F32 type input vector
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
@@ -629 +625 @@
     }
     inputOrdW->type.type = PS_TYPE_F32;
-
+ 
     psFree(inputOrdW);
     psFree(inputOrdX);
@@ -642 +638 @@
     psFree(polyOrd);
     psFree(polyCheb);
-
+ 
     return 0;
 }
-
-psS32 testDPoly4DEvalVector(void)
+*/
+psS32 testPoly4DEvalVector(void)
 {
     // Allocate polynomial
-    psDPolynomial4D* polyOrd = psDPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
-    psDPolynomial4D* polyCheb = psDPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
+    psPolynomial4D* polyOrd = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_ORD);
+    psPolynomial4D* polyCheb = psPolynomial4DAlloc(TERMS,TERMS,TERMS,TERMS,PS_POLYNOMIAL_CHEB);
 
     // Set polynomial members
@@ -687 +683 @@
 
     // Evaluate the vectors
-    psVector* outputOrd = psDPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ);
+    psVector* outputOrd = psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ);
     if(outputOrd == NULL) {
         psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL.");
@@ -697 +693 @@
         return 2;
     }
-    psVector* outputCheb = psDPolynomial4DEvalVector(polyCheb,inputChebW,inputChebX,inputChebY,inputChebZ);
+    psVector* outputCheb = psPolynomial4DEvalVector(polyCheb,inputChebW,inputChebX,inputChebY,inputChebZ);
     if(outputCheb == NULL) {
         psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL.");
@@ -724 +720 @@
     // Attempt to invoke function with null polynomial
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL polynomial");
-    if(psDPolynomial4DEvalVector(NULL,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
+    if(psPolynomial4DEvalVector(NULL,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL polynomial");
         return 60;
@@ -731 +727 @@
     // Attempt to invoke function with null input vector
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
-    if(psDPolynomial4DEvalVector(polyOrd,NULL,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
+    if(psPolynomial4DEvalVector(polyOrd,NULL,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
         return 61;
@@ -737 +733 @@
     // Attempt to invoke function with null input vector
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
-    if(psDPolynomial4DEvalVector(polyOrd,inputOrdW,NULL,inputOrdY,inputOrdZ) != NULL) {
+    if(psPolynomial4DEvalVector(polyOrd,inputOrdW,NULL,inputOrdY,inputOrdZ) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
         return 62;
@@ -743 +739 @@
     // Attempt to invoke function with null input vector
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
-    if(psDPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,NULL,inputOrdZ) != NULL) {
+    if(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,NULL,inputOrdZ) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
         return 63;
@@ -749 +745 @@
     // Attempt to invoke function with null input vector
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
-    if(psDPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,NULL) != NULL) {
+    if(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,NULL) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
         return 64;
@@ -757 +753 @@
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
     inputOrdX->type.type = PS_TYPE_U8;
-    if(psDPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
+    if(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector");
         return 65;
@@ -765 +761 @@
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
     inputOrdY->type.type = PS_TYPE_U8;
-    if(psDPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
+    if(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector");
         return 66;
@@ -773 +769 @@
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
     inputOrdZ->type.type = PS_TYPE_U8;
-    if(psDPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
+    if(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector");
         return 67;
@@ -781 +777 @@
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
     inputOrdW->type.type = PS_TYPE_U8;
-    if(psDPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
+    if(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
         psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector");
         return 68;

trunk/psLib/test/math/verified/tst_psFunc00.stderr

@@ -35 +35 @@
 ---> TESTPOINT PASSED (psPolynomialXD{psPolynomial4DAlloc} | tst_psFunc00.c)
 
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psFunc00.c                                             *
-*            TestPoint: psPolynomialXD{psDPolynomial1DAlloc}                       *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-
----> TESTPOINT PASSED (psPolynomialXD{psDPolynomial1DAlloc} | tst_psFunc00.c)
-
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psFunc00.c                                             *
-*            TestPoint: psPolynomialXD{psDPolynomial2DAlloc}                       *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-
----> TESTPOINT PASSED (psPolynomialXD{psDPolynomial2DAlloc} | tst_psFunc00.c)
-
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psFunc00.c                                             *
-*            TestPoint: psPolynomialXD{psDPolynomial3DAlloc}                       *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-
----> TESTPOINT PASSED (psPolynomialXD{psDPolynomial3DAlloc} | tst_psFunc00.c)
-
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psFunc00.c                                             *
-*            TestPoint: psPolynomialXD{psDPolynomial4DAlloc}                       *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-
----> TESTPOINT PASSED (psPolynomialXD{psDPolynomial4DAlloc} | tst_psFunc00.c)
-

trunk/psLib/test/math/verified/tst_psFunc08.stderr

@@ -11 +11 @@
 
 ---> TESTPOINT PASSED (psPolynomialXDEval{psPolynomial1DEval} | tst_psFunc08.c)
-
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psFunc08.c                                             *
-*            TestPoint: psPolynomialXDEval{psDPolynomial1DEval}                    *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-<DATE><TIME>|<HOST>|I|testDPoly1DEval
-    Following should generate error message invalid type
-<DATE><TIME>|<HOST>|E|psDPolynomial1DEval (FILE:LINENO)
-    Unknown polynomial type 0x63 found.  Evaluation failed.
-
----> TESTPOINT PASSED (psPolynomialXDEval{psDPolynomial1DEval} | tst_psFunc08.c)
 
 /***************************** TESTPOINT ******************************************\
@@ -46 +33 @@
 ---> TESTPOINT PASSED (psPolynomialXDEval{psPolynomial1DEvalVector} | tst_psFunc08.c)
 
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psFunc08.c                                             *
-*            TestPoint: psPolynomialXDEval{psDPolynomial1DEvalVector}              *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-<DATE><TIME>|<HOST>|I|testDPoly1DEvalVector
-    Following should generate an error message for NULL polynomial
-<DATE><TIME>|<HOST>|E|psDPolynomial1DEvalVector (FILE:LINENO)
-    Unallowable operation: polynomial poly or its coeffs is NULL.
-<DATE><TIME>|<HOST>|I|testDPoly1DEvalVector
-    Following should generate an error message for NULL input vector
-<DATE><TIME>|<HOST>|E|psDPolynomial1DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector x or its data is NULL.
-<DATE><TIME>|<HOST>|I|testDPoly1DEvalVector
-    Following should generate an error message for invalid input type
-<DATE><TIME>|<HOST>|E|psDPolynomial1DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector x has incorrect type.
-
----> TESTPOINT PASSED (psPolynomialXDEval{psDPolynomial1DEvalVector} | tst_psFunc08.c)
-

trunk/psLib/test/math/verified/tst_psFunc09.stderr

@@ -11 +11 @@
 
 ---> TESTPOINT PASSED (psPolynomialXDEval{psPolynomial2DEval} | tst_psFunc09.c)
-
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psFunc09.c                                             *
-*            TestPoint: psPolynomialXDEval{psDPolynomial2DEval}                    *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-<DATE><TIME>|<HOST>|I|testDPoly2DEval
-    Following should generate error message invalid type
-<DATE><TIME>|<HOST>|E|psDPolynomial2DEval (FILE:LINENO)
-    Unknown polynomial type 0x63 found.  Evaluation failed.
-
----> TESTPOINT PASSED (psPolynomialXDEval{psDPolynomial2DEval} | tst_psFunc09.c)
 
 /***************************** TESTPOINT ******************************************\
@@ -54 +41 @@
 ---> TESTPOINT PASSED (psPolynomialXDEval{psPolynomial2DEvalVector} | tst_psFunc09.c)
 
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psFunc09.c                                             *
-*            TestPoint: psPolynomialXDEval{psDPolynomial2DEvalVector}              *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-<DATE><TIME>|<HOST>|I|testDPoly2DEvalVector
-    Following should generate an error message for NULL polynomial
-<DATE><TIME>|<HOST>|E|psDPolynomial2DEvalVector (FILE:LINENO)
-    Unallowable operation: polynomial poly or its coeffs is NULL.
-<DATE><TIME>|<HOST>|I|testDPoly2DEvalVector
-    Following should generate an error message for NULL input vector
-<DATE><TIME>|<HOST>|E|psDPolynomial2DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector x or its data is NULL.
-<DATE><TIME>|<HOST>|I|testDPoly2DEvalVector
-    Following should generate an error message for NULL input vector
-<DATE><TIME>|<HOST>|E|psDPolynomial2DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector y or its data is NULL.
-<DATE><TIME>|<HOST>|I|testDPoly2DEvalVector
-    Following should generate an error message for invalid input type
-<DATE><TIME>|<HOST>|E|psDPolynomial2DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector x has incorrect type.
-<DATE><TIME>|<HOST>|I|testDPoly2DEvalVector
-    Following should generate an error message for invalid input type
-<DATE><TIME>|<HOST>|E|psDPolynomial2DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector y has incorrect type.
-
----> TESTPOINT PASSED (psPolynomialXDEval{psDPolynomial2DEvalVector} | tst_psFunc09.c)
-

trunk/psLib/test/math/verified/tst_psFunc10.stderr

@@ -11 +11 @@
 
 ---> TESTPOINT PASSED (psPolynomialXDEval{psPolynomial3DEval} | tst_psFunc10.c)
-
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psFunc10.c                                             *
-*            TestPoint: psPolynomialXDEval{psDPolynomial3DEval}                    *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-<DATE><TIME>|<HOST>|I|testDPoly3DEval
-    Following should generate error message invalid type
-<DATE><TIME>|<HOST>|E|psDPolynomial3DEval (FILE:LINENO)
-    Unknown polynomial type 0x63 found.  Evaluation failed.
-
----> TESTPOINT PASSED (psPolynomialXDEval{psDPolynomial3DEval} | tst_psFunc10.c)
 
 /***************************** TESTPOINT ******************************************\
@@ -62 +49 @@
 ---> TESTPOINT PASSED (psPolynomialXDEval{psPolynomial3DEvalVector} | tst_psFunc10.c)
 
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psFunc10.c                                             *
-*            TestPoint: psPolynomialXDEval{psDPolynomial3DEvalVector}              *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-<DATE><TIME>|<HOST>|I|testDPoly3DEvalVector
-    Following should generate an error message for NULL polynomial
-<DATE><TIME>|<HOST>|E|psDPolynomial3DEvalVector (FILE:LINENO)
-    Unallowable operation: polynomial poly or its coeffs is NULL.
-<DATE><TIME>|<HOST>|I|testDPoly3DEvalVector
-    Following should generate an error message for NULL input vector
-<DATE><TIME>|<HOST>|E|psDPolynomial3DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector x or its data is NULL.
-<DATE><TIME>|<HOST>|I|testDPoly3DEvalVector
-    Following should generate an error message for NULL input vector
-<DATE><TIME>|<HOST>|E|psDPolynomial3DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector y or its data is NULL.
-<DATE><TIME>|<HOST>|I|testDPoly3DEvalVector
-    Following should generate an error message for NULL input vector
-<DATE><TIME>|<HOST>|E|psDPolynomial3DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector z or its data is NULL.
-<DATE><TIME>|<HOST>|I|testDPoly3DEvalVector
-    Following should generate an error message for invalid input type
-<DATE><TIME>|<HOST>|E|psDPolynomial3DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector x has incorrect type.
-<DATE><TIME>|<HOST>|I|testDPoly3DEvalVector
-    Following should generate an error message for invalid input type
-<DATE><TIME>|<HOST>|E|psDPolynomial3DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector y has incorrect type.
-<DATE><TIME>|<HOST>|I|testDPoly3DEvalVector
-    Following should generate an error message for invalid input type
-<DATE><TIME>|<HOST>|E|psDPolynomial3DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector z has incorrect type.
-
----> TESTPOINT PASSED (psPolynomialXDEval{psDPolynomial3DEvalVector} | tst_psFunc10.c)
-

trunk/psLib/test/math/verified/tst_psFunc11.stderr

@@ -11 +11 @@
 
 ---> TESTPOINT PASSED (psPolynomialXDEval{psPolynomial4DEval} | tst_psFunc11.c)
-
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psFunc11.c                                             *
-*            TestPoint: psPolynomialXDEval{psDPolynomial4DEval}                    *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-<DATE><TIME>|<HOST>|I|testDPoly4DEval
-    Following should generate error message invalid type
-<DATE><TIME>|<HOST>|E|psDPolynomial4DEval (FILE:LINENO)
-    Unknown polynomial type 0x63 found.  Evaluation failed.
-
----> TESTPOINT PASSED (psPolynomialXDEval{psDPolynomial4DEval} | tst_psFunc11.c)
 
 /***************************** TESTPOINT ******************************************\
@@ -70 +57 @@
 ---> TESTPOINT PASSED (psPolynomialXDEval{psPolynomial4DEvalVector} | tst_psFunc11.c)
 
-/***************************** TESTPOINT ******************************************\
-*             TestFile: tst_psFunc11.c                                             *
-*            TestPoint: psPolynomialXDEval{psDPolynomial4DEvalVector}              *
-*             TestType: Positive                                                   *
-\**********************************************************************************/
-
-<DATE><TIME>|<HOST>|I|testDPoly4DEvalVector
-    Following should generate an error message for NULL polynomial
-<DATE><TIME>|<HOST>|E|psDPolynomial4DEvalVector (FILE:LINENO)
-    Unallowable operation: polynomial poly or its coeffs is NULL.
-<DATE><TIME>|<HOST>|I|testDPoly4DEvalVector
-    Following should generate an error message for NULL input vector
-<DATE><TIME>|<HOST>|E|psDPolynomial4DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector x or its data is NULL.
-<DATE><TIME>|<HOST>|I|testDPoly4DEvalVector
-    Following should generate an error message for NULL input vector
-<DATE><TIME>|<HOST>|E|psDPolynomial4DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector y or its data is NULL.
-<DATE><TIME>|<HOST>|I|testDPoly4DEvalVector
-    Following should generate an error message for NULL input vector
-<DATE><TIME>|<HOST>|E|psDPolynomial4DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector z or its data is NULL.
-<DATE><TIME>|<HOST>|I|testDPoly4DEvalVector
-    Following should generate an error message for NULL input vector
-<DATE><TIME>|<HOST>|E|psDPolynomial4DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector t or its data is NULL.
-<DATE><TIME>|<HOST>|I|testDPoly4DEvalVector
-    Following should generate an error message for invalid input type
-<DATE><TIME>|<HOST>|E|psDPolynomial4DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector y has incorrect type.
-<DATE><TIME>|<HOST>|I|testDPoly4DEvalVector
-    Following should generate an error message for invalid input type
-<DATE><TIME>|<HOST>|E|psDPolynomial4DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector z has incorrect type.
-<DATE><TIME>|<HOST>|I|testDPoly4DEvalVector
-    Following should generate an error message for invalid input type
-<DATE><TIME>|<HOST>|E|psDPolynomial4DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector t has incorrect type.
-<DATE><TIME>|<HOST>|I|testDPoly4DEvalVector
-    Following should generate an error message for invalid input type
-<DATE><TIME>|<HOST>|E|psDPolynomial4DEvalVector (FILE:LINENO)
-    Unallowable operation: psVector x has incorrect type.
-
----> TESTPOINT PASSED (psPolynomialXDEval{psDPolynomial4DEvalVector} | tst_psFunc11.c)
-