Changeset 2273 for trunk/psLib/src/dataManip

Timestamp:

Nov 3, 2004, 3:05:00 PM (22 years ago)

Author:

desonia

Message:

changed the psError signature to match SDRS. Also made misc. cleanups as
I was combing the files.

Location:

trunk/psLib/src/dataManip

Files:

• psConstants.h (modified) (14 diffs)
• psDataManipErrors.dat (modified) (2 diffs)
• psDataManipErrors.h (modified) (3 diffs)
• psFunctions.c (modified) (40 diffs)
• psFunctions.h (modified) (2 diffs)
• psMatrix.c (modified) (17 diffs)
• psMatrixVectorArithmetic.c (modified) (34 diffs)
• psMinimize.c (modified) (8 diffs)
• psStats.c (modified) (10 diffs)
• psVectorFFT.c (modified) (9 diffs)

trunk/psLib/src/dataManip/psConstants.h

@@ -6 +6 @@
  *  @author GLG, MHPCC
  *
- *  @version $Revision: 1.33 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-11-03 22:58:53 $
+ *  @version $Revision: 1.34 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-11-04 01:04:57 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -32 +32 @@
 #define PS_INT_CHECK_NON_NEGATIVE(NAME, RVAL) \
 if (NAME < 0) { \
-    psError(__func__,"Error: %s is less than 0.", #NAME); \
+    psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
+            "Error: %s is less than 0.", #NAME); \
     return(RVAL); \
 }
@@ -38 +39 @@
 #define PS_INT_CHECK_POSITIVE(NAME, RVAL) \
 if (NAME < 1) { \
-    psError(__func__,"Error: %s is 0 or less.", #NAME); \
-    return(RVAL); \
-}
-
-// Produce an error if ((NAME1 > NAME2)
+    psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
+            "Error: %s is 0 or less.", #NAME); \
+    return(RVAL); \
+}
+
+#define PS_INT_CHECK_RANGE(NAME, LOWER, UPPER, RVAL) \
+if ((int)NAME < LOWER || (int)NAME > UPPER) { \
+    psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
+            "Error: %s, %d, is out of range.  Must be between %d and %d.", \
+            #NAME,(int)NAME,LOWER,UPPER); \
+    return RVAL; \
+}
+
+// Produce an error if (NAME1 > NAME2)
 #define PS_INT_COMPARE(NAME1, NAME2, RVAL) \
 if (NAME1 > NAME2) { \
-    psError(__func__,"Error: (%s > %s) (%d %d).", #NAME1, #NAME2, NAME1, NAME2); \
+    psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
+            "Error: (%s > %s) (%d %d).", \
+            #NAME1, #NAME2, NAME1, NAME2); \
     return(RVAL); \
 }
@@ -53 +65 @@
 #define PS_FLOAT_COMPARE(NAME1, NAME2, RVAL) \
 if (NAME1 > NAME2) { \
-    psError(__func__,"Error: (%s > %s) (%f %f)", #NAME1, #NAME2, NAME1, NAME2); \
+    psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
+            "Error: (%s > %s) (%f %f)", \
+            #NAME1, #NAME2, NAME1, NAME2); \
     return(RVAL); \
 }
@@ -59 +73 @@
 #define PS_FLOAT_CHECK_NON_EQUAL(NAME1, NAME2, RVAL) \
 if (fabs(NAME2 - NAME1) < FLT_EPSILON) { \
-    psError(__func__,"Error: %s and %s are equal.", #NAME1, #NAME2); \
+    psError(PS_ERR_BAD_PARAMETER_VALUE, true, \
+            "Error: %s and %s are equal.", \
+            #NAME1, #NAME2); \
     return(RVAL); \
 }
@@ -67 +83 @@
 the wrong type.
 *****************************************************************************/
-#define PS_PTR_CHECK_NULL(NAME, RVAL) \
+#define PS_PTR_CHECK_NULL(NAME, RVAL) PS_PTR_CHECK_NULL_GENERAL(NAME, return RVAL)
+#define PS_PTR_CHECK_NULL_GENERAL(NAME, CLEANUP) \
 if (NAME == NULL) { \
-    psError(__func__,"Unallowable operation: %s is NULL.", #NAME); \
-    return(RVAL); \
+    psError(PS_ERR_BAD_PARAMETER_NULL, true, \
+            "Unallowable operation: %s is NULL.", \
+            #NAME); \
+    CLEANUP; \
 }
 
 #define PS_PTR_CHECK_TYPE(NAME, TYPE, RVAL) \
 if (NAME->type.type != TYPE) { \
-    psError(__func__,"Unallowable operation: %s has incorrect type.", #NAME); \
-    return(RVAL); \
-}
+    psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
+            "Unallowable operation: %s has incorrect type.", \
+            #NAME); \
+    return(RVAL); \
+}
+
+#define PS_PTR_CHECK_DIMEN(NAME, DIMEN, RVAL) PS_PTR_CHECK_DIMEN_GENERAL(NAME, DIMEN, return RVAL)
+#define PS_PTR_CHECK_DIMEN_GENERAL(NAME, DIMEN, CLEANUP) \
+if (NAME->type.dimen != DIMEN) { \
+    psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
+            "Unallowable operation: %s has incorrect dimensionality.", \
+            #NAME); \
+    CLEANUP; \
+}
+
 
 #define PS_PTR_CHECK_SIZE_EQUAL(PTR1, PTR2, RVAL) \
 if (PTR1->n != PTR2->n) { \
-    psError(__func__,"ptr %s has size %d, ptr %s has size %d.", #PTR1, PTR1->n, #PTR2, PTR2->n); \
-    return(RVAL); \
-}
-
-#define PS_PTR_CHECK_TYPE_EQUAL(PTR1, PTR2, RVAL) \
+    psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
+            "ptr %s has size %d, ptr %s has size %d.", \
+            #PTR1, PTR1->n, #PTR2, PTR2->n); \
+    return(RVAL); \
+}
+
+#define PS_PTR_CHECK_TYPE_EQUAL(PTR1, PTR2, RVAL) PS_PTR_CHECK_TYPE_EQUAL_GENERAL(PTR1, PTR2, return RVAL)
+
+#define PS_PTR_CHECK_TYPE_EQUAL_GENERAL(PTR1, PTR2, CLEANUP) \
 if (PTR1->type.type != PTR2->type.type) { \
-    psError(__func__,"ptr %s has type %d, ptr %s has type %d.", #PTR1, PTR1->type.type, #PTR2, PTR2->type.type); \
-    return(RVAL); \
+    psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
+            "ptr %s has type %d, ptr %s has type %d.", \
+            #PTR1, PTR1->type.type, #PTR2, PTR2->type.type); \
+    CLEANUP; \
 }
 
@@ -95 +132 @@
     PS_VECTOR macros:
  *****************************************************************************/
-#define PS_VECTOR_CHECK_NULL(NAME, RVAL) \
+#define PS_VECTOR_CHECK_NULL(NAME, RVAL) PS_VECTOR_CHECK_NULL_GENERAL(NAME, return RVAL)
+#define PS_VECTOR_CHECK_NULL_GENERAL(NAME, CLEANUP) \
 if (NAME == NULL || NAME->data.V == NULL) { \
-    psError(__func__,"Unallowable operation: psVector %s or its data is NULL.", #NAME); \
-    return(RVAL); \
+    psError(PS_ERR_BAD_PARAMETER_NULL, true, \
+            "Unallowable operation: psVector %s or its data is NULL.", \
+            #NAME); \
+    CLEANUP; \
 } \
 
 #define PS_VECTOR_CHECK_EMPTY(NAME, RVAL) \
 if (NAME->n < 1) { \
-    psError(__func__,"Unallowable operation: psVector %s has no elements.", #NAME); \
+    psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
+            "Unallowable operation: psVector %s has no elements.", \
+            #NAME); \
     return(RVAL); \
 } \
@@ -109 +151 @@
 #define PS_VECTOR_CHECK_TYPE_F32_OR_F64(NAME, RVAL) \
 if ((NAME->type.type != PS_TYPE_F32) && (NAME->type.type != PS_TYPE_F64)) { \
-    psError(__func__, "psVector %s: bad type(%d)", #NAME, NAME->type.type); \
+    psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
+            "psVector %s: bad type(%d)", \
+            #NAME, NAME->type.type); \
     return(RVAL); \
 } \
@@ -115 +159 @@
 #define PS_VECTOR_CHECK_TYPE(NAME, TYPE, RVAL) \
 if (NAME->type.type != TYPE) { \
-    psError(__func__,"Unallowable operation: psVector %s has incorrect type.", #NAME); \
+    psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
+            "Unallowable operation: psVector %s has incorrect type.", \
+            #NAME); \
     return(RVAL); \
 }
@@ -121 +167 @@
 #define PS_VECTOR_CHECK_SIZE_EQUAL(VEC1, VEC2, RVAL) \
 if (VEC1->n != VEC2->n) { \
-    psError(__func__,"psVector %s has size %d, psVector %s has size %d.", #VEC1, VEC1->n, #VEC2, VEC2->n); \
+    psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
+            "psVector %s has size %d, psVector %s has size %d.", \
+            #VEC1, VEC1->n, #VEC2, VEC2->n); \
     return(RVAL); \
 }
@@ -221 +269 @@
 #define PS_POLY_CHECK_NULL(NAME, RVAL) \
 if (NAME == NULL || NAME->coeff == NULL) { \
-    psError(__func__,"Unallowable operation: polynomial %s or its coeffs is NULL.", #NAME); \
+    psError(PS_ERR_BAD_PARAMETER_NULL, true, \
+            "Unallowable operation: polynomial %s or its coeffs is NULL.", \
+            #NAME); \
     return(RVAL); \
 } \
@@ -227 +277 @@
 #define PS_POLY_CHECK_TYPE(NAME, TYPE, RVAL) \
 if (NAME->type != TYPE) { \
-    psError(__func__,"Unallowable operation: polynomial %s has wrong type.", #NAME); \
+    psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
+            "Unallowable operation: polynomial %s has wrong type.", #NAME); \
     return(RVAL); \
 } \
@@ -234 +285 @@
     PS_IMAGE macros:
 *****************************************************************************/
-#define PS_IMAGE_CHECK_NULL(NAME, RVAL) \
+#define PS_IMAGE_CHECK_NULL(NAME, RVAL) PS_IMAGE_CHECK_NULL_GENERAL(NAME, return RVAL)
+#define PS_IMAGE_CHECK_NULL_GENERAL(NAME, CLEANUP) \
 if (NAME == NULL || NAME->data.V == NULL) { \
-    psError(__func__,"Unallowable operation: psImage %s or its data is NULL.", #NAME); \
-    return(RVAL); \
-}
-
-#define PS_IMAGE_CHECK_EMPTY(NAME, RVAL) \
+    psError(PS_ERR_BAD_PARAMETER_NULL, true, \
+            "Unallowable operation: psImage %s or its data is NULL.", \
+            #NAME); \
+    CLEANUP; \
+}
+
+#define PS_IMAGE_CHECK_EMPTY(NAME, RVAL) PS_IMAGE_CHECK_EMPTY_GENERAL(NAME, return RVAL)
+#define PS_IMAGE_CHECK_EMPTY_GENERAL(NAME, CLEANUP) \
 if (NAME->numCols < 1 || NAME->numRows < 1) { \
-    psError(__func__,"Unallowable operation: psImage %s has zero rows or columns (%dx%d).", #NAME, \
-            NAME->numCols, NAME->numRows); \
-    return(RVAL); \
+    psError(PS_ERR_BAD_PARAMETER_SIZE, true, \
+            "Unallowable operation: psImage %s has zero rows or columns (%dx%d).", \
+            #NAME, NAME->numCols, NAME->numRows); \
+    CLEANUP; \
 }
 
 #define PS_IMAGE_CHECK_TYPE(NAME, TYPE, RVAL) \
 if (NAME->type.type != TYPE) { \
-    psError(__func__,"Unallowable operation: psImage %s has incorrect type.", #NAME); \
+    psError(PS_ERR_BAD_PARAMETER_TYPE, true, \
+            "Unallowable operation: psImage %s has incorrect type.", \
+            #NAME); \
     return(RVAL); \
 }
@@ -260 +318 @@
 #define PS_READOUT_CHECK_NULL(NAME, RVAL) \
 if (NAME == NULL || NAME->image == NULL) { \
-    psError(__func__,"Unallowable operation: psReadout %s or its data is NULL.", #NAME); \
+    psError(PS_ERR_BAD_PARAMETER_NULL, true, \
+            "Unallowable operation: psReadout %s or its data is NULL.", \
+            #NAME); \
     return(RVAL); \
 }

trunk/psLib/src/dataManip/psDataManipErrors.dat

@@ -8 +8 @@
 ####################################################################
 #
-psVectorFFT_IMAGE_TYPE_UNSUPPORTED     Input psVector type, %s, is not supported. Valid data types are psF32 and psC32.
+psVectorFFT_TYPE_NOT_F32_C32           Input psVector type, %s, is not supported. Valid data types are psF32 and psC32.
 psVectorFFT_REVERSE_NOT_COMPLEX        Input psVector (%s) is not complex.  Reverse FFT operation requires a complex input.
 psVectorFFT_FORWARD_NOT_REAL           Input psVector (%s) is not real.  Forward FFT operation requires a real input.
@@ -18 +18 @@
 psVectorFFT_NONCOMPLEX_NOTSUPPORTED    Input psVector type, %s, is required to be either psC32 or psC64.
 psVectorFFT_DIRECTION_NOTSET           Must specify the direction as either PS_FFT_FORWARD or PS_FFT_REVERSE.
+#
+psStats_NOT_F32_F64                    Invalid data type, %s.  Only psF32 and psF64 data types are supported.
+psStats_VECTOR_TYPE_UNSUPPORTED        Input psVector type, %s, is not supported.
+psStats_YVAL_OUT_OF_RANGE              Specified yVal, %g, is not within y-range, %g to %g.
+psStats_ROBUST_QUARTILE_BINS_FAILED    Could not determine the robust lower/upper quartile bin numbers.
+psStats_STATS_FAILED                   Failed to calculate the specified statistic.
+#
+psFunctions_INVALID_POLYNOMIAL_TYPE    Unknown polynomial type 0x%x found.  Evaluation failed.
+psFunctions_TYPE_NOT_SUPPORTED         Input psVector type, %s, is not supported.
+psFunctions_NOT_ENOUGH_DATAPOINTS      Given vector does not have enough data points for %d-order interpolation.
+#
+psMatrix_COUNT_DIFFERS                 Number of elements inconsistent, %d vs %d.  Number of elements must match.
+psMatrix_IMAGE_SIZE_DIFFERS            Specified psImage dimensions differed, %dx%d vs %dx%d.
+psMatrix_TYPE_MISMATCH                 Specified data type, %s, is not supported.
+psMatrix_MIN_COMPLEX_SUPPORT           The minimum operation is not supported with complex data.
+psMatrix_MAX_COMPLEX_SUPPORT           The maximum operation is not supported with complex data.
+psMatrix_OPERATION_UNSUPPORTED         Specified operation, %s, is not supported.
+psMatrix_DIMEN_OTHER_FOUND             %s's dimensionality is PS_DIMEN_OTHER, which is  not allowed.
+psMatrix_OUTPUT_VECTOR_NOT_CREATED     Couldn't create a proper output psVector.
+psMatrix_OUTPUT_IMAGE_NOT_CREATED      Couldn't create a proper output psImage.
+psMatrix_DIMEN_INVALID                 Specified parameter, %s, has invalid dimensionality, %d.
+psMatrix_VECTOR_EMPTY                  Input psVector contains no elements.  No data to perform operation with.
+psMatrix_IMAGE_EMPTY                   Input psImage contains no pixels.  No data to perform operation with.

trunk/psLib/src/dataManip/psDataManipErrors.h

@@ -7 +7 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.3 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-10-13 20:46:57 $
+ *  @version $Revision: 1.4 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-11-04 01:04:59 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -30 +30 @@
 
 //~Start #define PS_ERRORTEXT_$1 "$2"
-#define PS_ERRORTEXT_psVectorFFT_IMAGE_TYPE_UNSUPPORTED "Input psVector type, %s, is not supported. Valid data types are psF32 and psC32."
+#define PS_ERRORTEXT_psVectorFFT_TYPE_NOT_F32_C32 "Input psVector type, %s, is not supported. Valid data types are psF32 and psC32."
 #define PS_ERRORTEXT_psVectorFFT_REVERSE_NOT_COMPLEX "Input psVector (%s) is not complex.  Reverse FFT operation requires a complex input."
 #define PS_ERRORTEXT_psVectorFFT_FORWARD_NOT_REAL "Input psVector (%s) is not real.  Forward FFT operation requires a real input."
@@ -40 +40 @@
 #define PS_ERRORTEXT_psVectorFFT_NONCOMPLEX_NOTSUPPORTED "Input psVector type, %s, is required to be either psC32 or psC64."
 #define PS_ERRORTEXT_psVectorFFT_DIRECTION_NOTSET "Must specify the direction as either PS_FFT_FORWARD or PS_FFT_REVERSE."
+#define PS_ERRORTEXT_psStats_NOT_F32_F64 "Invalid data type, %s.  Only psF32 and psF64 data types are supported."
+#define PS_ERRORTEXT_psStats_VECTOR_TYPE_UNSUPPORTED "Input psVector type, %s, is not supported."
+#define PS_ERRORTEXT_psStats_YVAL_OUT_OF_RANGE "Specified yVal, %g, is not within y-range, %g to %g."
+#define PS_ERRORTEXT_psStats_ROBUST_QUARTILE_BINS_FAILED "Could not determine the robust lower/upper quartile bin numbers."
+#define PS_ERRORTEXT_psStats_STATS_FAILED "Failed to calculate the specified statistic."
+#define PS_ERRORTEXT_psFunctions_INVALID_POLYNOMIAL_TYPE "Unknown polynomial type 0x%x found.  Evaluation failed."
+#define PS_ERRORTEXT_psFunctions_TYPE_NOT_SUPPORTED "Input psVector type, %s, is not supported."
+#define PS_ERRORTEXT_psFunctions_NOT_ENOUGH_DATAPOINTS "Given vector does not have enough data points for %d-order interpolation."
+#define PS_ERRORTEXT_psMatrix_COUNT_DIFFERS "Number of elements inconsistent, %d vs %d.  Number of elements must match."
+#define PS_ERRORTEXT_psMatrix_IMAGE_SIZE_DIFFERS "Specified psImage dimensions differed, %dx%d vs %dx%d."
+#define PS_ERRORTEXT_psMatrix_TYPE_MISMATCH "Specified data type, %s, is not supported."
+#define PS_ERRORTEXT_psMatrix_MIN_COMPLEX_SUPPORT "The minimum operation is not supported with complex data."
+#define PS_ERRORTEXT_psMatrix_MAX_COMPLEX_SUPPORT "The maximum operation is not supported with complex data."
+#define PS_ERRORTEXT_psMatrix_OPERATION_UNSUPPORTED "Specified operation, %s, is not supported."
+#define PS_ERRORTEXT_psMatrix_DIMEN_OTHER_FOUND "%s's dimensionality is PS_DIMEN_OTHER, which is  not allowed."
+#define PS_ERRORTEXT_psMatrix_OUTPUT_VECTOR_NOT_CREATED "Couldn't create a proper output psVector."
+#define PS_ERRORTEXT_psMatrix_OUTPUT_IMAGE_NOT_CREATED "Couldn't create a proper output psImage."
+#define PS_ERRORTEXT_psMatrix_DIMEN_INVALID "Specified parameter, %s, has invalid dimensionality, %d."
+#define PS_ERRORTEXT_psMatrix_VECTOR_EMPTY "Input psVector contains no elements.  No data to perform operation with."
+#define PS_ERRORTEXT_psMatrix_IMAGE_EMPTY "Input psImage contains no pixels.  No data to perform operation with."
 //~End
 

trunk/psLib/src/dataManip/psFunctions.c

@@ -7 +7 @@
  *  polynomials.  It also contains a Gaussian functions.
  *
- *  @version $Revision: 1.58 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-10-28 00:22:53 $
+ *  @version $Revision: 1.59 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-11-04 01:04:59 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -35 +35 @@
 #include "psFunctions.h"
 #include "psConstants.h"
+
+#include "psDataManipErrors.h"
+
 /*****************************************************************************/
 /* DEFINE STATEMENTS                                                         */
@@ -50 +53 @@
 static void dPolynomial3DFree(psDPolynomial3D* myPoly);
 static void dPolynomial4DFree(psDPolynomial4D* myPoly);
+static void spline1DFree(psSpline1D *tmpSpline);
+static psS32 vectorBinDisectF32(float *bins,psS32 numBins,float x);
+static psS32 vectorBinDisectS32(psS32 *bins,psS32 numBins,psS32 x);
 
 /*****************************************************************************/
@@ -67 +73 @@
 /*****************************************************************************/
 
+static void spline1DFree(psSpline1D *tmpSpline)
+{
+    psS32 i;
+
+    if (tmpSpline == NULL) {
+        return;
+    }
+
+    if (tmpSpline->spline != NULL) {
+        for (i=0;i<tmpSpline->n;i++) {
+            psFree((tmpSpline->spline)[i]);
+        }
+        psFree(tmpSpline->spline);
+    }
+
+    if (tmpSpline->p_psDeriv2 != NULL) {
+        psFree(tmpSpline->p_psDeriv2);
+    }
+    psFree(tmpSpline->domains);
+
+    return;
+}
+
+static void polynomial1DFree(psPolynomial1D* myPoly)
+{
+    psFree(myPoly->coeff);
+    psFree(myPoly->coeffErr);
+    psFree(myPoly->mask);
+}
+
+static void polynomial2DFree(psPolynomial2D* myPoly)
+{
+    psS32 x = 0;
+
+    for (x = 0; x < myPoly->nX; x++) {
+        psFree(myPoly->coeff[x]);
+        psFree(myPoly->coeffErr[x]);
+        psFree(myPoly->mask[x]);
+    }
+    psFree(myPoly->coeff);
+    psFree(myPoly->coeffErr);
+    psFree(myPoly->mask);
+}
+
+static void polynomial3DFree(psPolynomial3D* myPoly)
+{
+    psS32 x = 0;
+    psS32 y = 0;
+
+    for (x = 0; x < myPoly->nX; x++) {
+        for (y = 0; y < myPoly->nY; y++) {
+            psFree(myPoly->coeff[x][y]);
+            psFree(myPoly->coeffErr[x][y]);
+            psFree(myPoly->mask[x][y]);
+        }
+        psFree(myPoly->coeff[x]);
+        psFree(myPoly->coeffErr[x]);
+        psFree(myPoly->mask[x]);
+    }
+
+    psFree(myPoly->coeff);
+    psFree(myPoly->coeffErr);
+    psFree(myPoly->mask);
+}
+
+static void polynomial4DFree(psPolynomial4D* myPoly)
+{
+    psS32 w = 0;
+    psS32 x = 0;
+    psS32 y = 0;
+
+    for (w = 0; w < myPoly->nW; w++) {
+        for (x = 0; x < myPoly->nX; x++) {
+            for (y = 0; y < myPoly->nY; y++) {
+                psFree(myPoly->coeff[w][x][y]);
+                psFree(myPoly->coeffErr[w][x][y]);
+                psFree(myPoly->mask[w][x][y]);
+            }
+            psFree(myPoly->coeff[w][x]);
+            psFree(myPoly->coeffErr[w][x]);
+            psFree(myPoly->mask[w][x]);
+        }
+        psFree(myPoly->coeff[w]);
+        psFree(myPoly->coeffErr[w]);
+        psFree(myPoly->mask[w]);
+    }
+
+    psFree(myPoly->coeff);
+    psFree(myPoly->coeffErr);
+    psFree(myPoly->mask);
+}
+
+static void dPolynomial1DFree(psDPolynomial1D* myPoly)
+{
+    psFree(myPoly->coeff);
+    psFree(myPoly->coeffErr);
+    psFree(myPoly->mask);
+}
+
+static void dPolynomial2DFree(psDPolynomial2D* myPoly)
+{
+    psS32 x = 0;
+
+    for (x = 0; x < myPoly->nX; x++) {
+        psFree(myPoly->coeff[x]);
+        psFree(myPoly->coeffErr[x]);
+        psFree(myPoly->mask[x]);
+    }
+    psFree(myPoly->coeff);
+    psFree(myPoly->coeffErr);
+    psFree(myPoly->mask);
+}
+
+static void dPolynomial3DFree(psDPolynomial3D* myPoly)
+{
+    psS32 x = 0;
+    psS32 y = 0;
+
+    for (x = 0; x < myPoly->nX; x++) {
+        for (y = 0; y < myPoly->nY; y++) {
+            psFree(myPoly->coeff[x][y]);
+            psFree(myPoly->coeffErr[x][y]);
+            psFree(myPoly->mask[x][y]);
+        }
+        psFree(myPoly->coeff[x]);
+        psFree(myPoly->coeffErr[x]);
+        psFree(myPoly->mask[x]);
+    }
+
+    psFree(myPoly->coeff);
+    psFree(myPoly->coeffErr);
+    psFree(myPoly->mask);
+}
+
+static void dPolynomial4DFree(psDPolynomial4D* myPoly)
+{
+    psS32 w = 0;
+    psS32 x = 0;
+    psS32 y = 0;
+
+    for (w = 0; w < myPoly->nW; w++) {
+        for (x = 0; x < myPoly->nX; x++) {
+            for (y = 0; y < myPoly->nY; y++) {
+                psFree(myPoly->coeff[w][x][y]);
+                psFree(myPoly->coeffErr[w][x][y]);
+                psFree(myPoly->mask[w][x][y]);
+            }
+            psFree(myPoly->coeff[w][x]);
+            psFree(myPoly->coeffErr[w][x]);
+            psFree(myPoly->mask[w][x]);
+        }
+        psFree(myPoly->coeff[w]);
+        psFree(myPoly->coeffErr[w]);
+        psFree(myPoly->mask[w]);
+    }
+
+    psFree(myPoly->coeff);
+    psFree(myPoly->coeffErr);
+    psFree(myPoly->mask);
+}
+
 /*****************************************************************************
-CreateChebyshevPolys(n): this routine takes as input the required order n,
+createChebyshevPolys(n): this routine takes as input the required order n,
 and returns as output as a pointer to an array of n psPolynomial1D
 structures, corresponding to the first n Chebyshev polynomials.
@@ -76 +243 @@
 outer coefficients of the Chebyshev polynomials.
  *****************************************************************************/
-static psPolynomial1D **CreateChebyshevPolys(psS32 maxChebyPoly)
+static psPolynomial1D **createChebyshevPolys(psS32 maxChebyPoly)
 {
     PS_INT_CHECK_NON_NEGATIVE(maxChebyPoly, NULL);
@@ -103 +270 @@
 
     return (chebPolys);
+}
+
+/*****************************************************************************
+    Polynomial coefficients will be accessed in [w][x][y][z] fashion.
+ 
+    XXX: Should the "coeffErr[]" should be used as well?
+ *****************************************************************************/
+static float ordPolynomial1DEval(float x, const psPolynomial1D* myPoly)
+{
+    psS32 loop_x = 0;
+    float polySum = 0.0;
+    float xSum = 1.0;
+
+    psTrace(".psLib.dataManip.psFunctions.ordPolynomial1DEval", 4,
+            "---- Calling ordPolynomial1DEval(%f)\n", x);
+    psTrace(".psLib.dataManip.psFunctions.ordPolynomial1DEval", 4,
+            "Polynomial order is %d\n", myPoly->n);
+    for (loop_x = 0; loop_x < myPoly->n; loop_x++) {
+        psTrace(".psLib.dataManip.psFunctions.ordPolynomial1DEval", 4,
+                "Polynomial coeff[%d] is %f\n", loop_x, myPoly->coeff[loop_x]);
+    }
+
+    for (loop_x = 0; loop_x < myPoly->n; loop_x++) {
+        if (myPoly->mask[loop_x] == 0) {
+            psTrace(".psLib.dataManip.psFunctions.ordPolynomial1DEval", 10,
+                    "polysum+= sum*coeff [%f+= (%f * %f)\n", polySum, xSum, myPoly->coeff[loop_x]);
+            polySum += xSum * myPoly->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 float chebPolynomial1DEval(float x, const psPolynomial1D* myPoly)
+{
+    psVector *d;
+    psS32 n;
+    psS32 i;
+    float tmp;
+
+    n = myPoly->n;
+    d = psVectorAlloc(n, PS_TYPE_F32);
+    d->data.F32[n-1] = myPoly->coeff[n-1];
+    d->data.F32[n-2] = (2.0 * x * d->data.F32[n-1]) + myPoly->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]) +
+                         (myPoly->coeff[i]);
+    }
+
+    tmp = (x * d->data.F32[1]) -
+          (d->data.F32[2]) +
+          (0.5 * myPoly->coeff[0]);
+
+    psFree(d);
+    return(tmp);
+    /*
+
+    psS32 n;
+    psS32 i;
+    float tmp;
+    psPolynomial1D **chebPolys = NULL;
+
+    n = myPoly->n;
+    chebPolys = createChebyshevPolys(n);
+
+    tmp = 0.0;
+    for (i=0;i<myPoly->n;i++) {
+        tmp+= (myPoly->coeff[i] * psPolynomial1DEval(x, chebPolys[i]));
+        //            printf("HMMM: psPolynomial1DEval(%f, chebPolys[%d]) is %f\n", x, i, psPolynomial1DEval(x, chebPolys[i]));
+    }
+    tmp-= (myPoly->coeff[0]/2.0);
+
+
+    return(tmp);
+    */
+}
+
+static float ordPolynomial2DEval(float x, float y, const psPolynomial2D* myPoly)
+{
+    PS_POLY_CHECK_NULL(myPoly, NAN);
+
+    psS32 loop_x = 0;
+    psS32 loop_y = 0;
+    float polySum = 0.0;
+    float xSum = 1.0;
+    float ySum = 1.0;
+
+    for (loop_x = 0; loop_x < myPoly->nX; loop_x++) {
+        ySum = xSum;
+        for (loop_y = 0; loop_y < myPoly->nY; loop_y++) {
+            if (myPoly->mask[loop_x][loop_y] == 0) {
+                polySum += ySum * myPoly->coeff[loop_x][loop_y];
+                ySum *= y;
+            }
+        }
+        xSum *= x;
+    }
+
+    return(polySum);
+}
+
+static float chebPolynomial2DEval(float x, float y, const psPolynomial2D* myPoly)
+{
+    PS_POLY_CHECK_NULL(myPoly, NAN);
+
+    psS32 loop_x = 0;
+    psS32 loop_y = 0;
+    psS32 i = 0;
+    float polySum = 0.0;
+    psPolynomial1D* *chebPolys = NULL;
+    psS32 maxChebyPoly = 0;
+
+    // Determine how many Chebyshev polynomials
+    // are needed, then create them.
+    maxChebyPoly = myPoly->nX;
+    if (myPoly->nY > maxChebyPoly) {
+        maxChebyPoly = myPoly->nY;
+    }
+    chebPolys = createChebyshevPolys(maxChebyPoly);
+
+    for (loop_x = 0; loop_x < myPoly->nX; loop_x++) {
+        for (loop_y = 0; loop_y < myPoly->nY; loop_y++) {
+            if (myPoly->mask[loop_x][loop_y] == 0) {
+                polySum += myPoly->coeff[loop_x][loop_y] *
+                           psPolynomial1DEval(x, chebPolys[loop_x]) *
+                           psPolynomial1DEval(y, chebPolys[loop_y]);
+            }
+        }
+    }
+    for (i=0;i<maxChebyPoly;i++) {
+        psFree(chebPolys[i]);
+    }
+    psFree(chebPolys);
+    return(polySum);
+}
+
+static float ordPolynomial3DEval(float x, float y, float z, const psPolynomial3D* myPoly)
+{
+    psS32 loop_x = 0;
+    psS32 loop_y = 0;
+    psS32 loop_z = 0;
+    float polySum = 0.0;
+    float xSum = 1.0;
+    float ySum = 1.0;
+    float zSum = 1.0;
+
+    for (loop_x = 0; loop_x < myPoly->nX; loop_x++) {
+        ySum = xSum;
+        for (loop_y = 0; loop_y < myPoly->nY; loop_y++) {
+            zSum = ySum;
+            for (loop_z = 0; loop_z < myPoly->nZ; loop_z++) {
+                if (myPoly->mask[loop_x][loop_y][loop_z] == 0) {
+                    polySum += zSum * myPoly->coeff[loop_x][loop_y][loop_z];
+                    zSum *= z;
+                }
+            }
+            ySum *= y;
+        }
+        xSum *= x;
+    }
+
+    return(polySum);
+}
+
+static float chebPolynomial3DEval(float x, float y, float z, const psPolynomial3D* myPoly)
+{
+    psS32 loop_x = 0;
+    psS32 loop_y = 0;
+    psS32 loop_z = 0;
+    psS32 i = 0;
+    float polySum = 0.0;
+    psPolynomial1D* *chebPolys = NULL;
+    psS32 maxChebyPoly = 0;
+
+    // Determine how many Chebyshev polynomials
+    // are needed, then create them.
+    maxChebyPoly = myPoly->nX;
+    if (myPoly->nY > maxChebyPoly) {
+        maxChebyPoly = myPoly->nY;
+    }
+    if (myPoly->nZ > maxChebyPoly) {
+        maxChebyPoly = myPoly->nZ;
+    }
+    chebPolys = createChebyshevPolys(maxChebyPoly);
+
+    for (loop_x = 0; loop_x < myPoly->nX; loop_x++) {
+        for (loop_y = 0; loop_y < myPoly->nY; loop_y++) {
+            for (loop_z = 0; loop_z < myPoly->nZ; loop_z++) {
+                if (myPoly->mask[loop_x][loop_y][loop_z] == 0) {
+                    polySum += myPoly->coeff[loop_x][loop_y][loop_z] *
+                               psPolynomial1DEval(x, chebPolys[loop_x]) *
+                               psPolynomial1DEval(y, chebPolys[loop_y]) *
+                               psPolynomial1DEval(z, chebPolys[loop_z]);
+                }
+            }
+        }
+    }
+
+    for (i=0;i<maxChebyPoly;i++) {
+        psFree(chebPolys[i]);
+    }
+    psFree(chebPolys);
+    return(polySum);
+}
+
+static float ordPolynomial4DEval(float w, float x, float y, float z, const psPolynomial4D* myPoly)
+{
+    psS32 loop_w = 0;
+    psS32 loop_x = 0;
+    psS32 loop_y = 0;
+    psS32 loop_z = 0;
+    float polySum = 0.0;
+    float wSum = 1.0;
+    float xSum = 1.0;
+    float ySum = 1.0;
+    float zSum = 1.0;
+
+    for (loop_w = 0; loop_w < myPoly->nW; loop_w++) {
+        xSum = wSum;
+        for (loop_x = 0; loop_x < myPoly->nX; loop_x++) {
+            ySum = xSum;
+            for (loop_y = 0; loop_y < myPoly->nY; loop_y++) {
+                zSum = ySum;
+                for (loop_z = 0; loop_z < myPoly->nZ; loop_z++) {
+                    if (myPoly->mask[loop_w][loop_x][loop_y][loop_z] == 0) {
+                        polySum += zSum * myPoly->coeff[loop_w][loop_x][loop_y][loop_z];
+                        zSum *= z;
+                    }
+                }
+                ySum *= y;
+            }
+            xSum *= x;
+        }
+        wSum *= w;
+    }
+
+    return(polySum);
+}
+
+static float chebPolynomial4DEval(float w, float x, float y, float z, const psPolynomial4D* myPoly)
+{
+    psS32 loop_w = 0;
+    psS32 loop_x = 0;
+    psS32 loop_y = 0;
+    psS32 loop_z = 0;
+    psS32 i = 0;
+    float polySum = 0.0;
+    psPolynomial1D* *chebPolys = NULL;
+    psS32 maxChebyPoly = 0;
+
+    // Determine how many Chebyshev polynomials
+    // are needed, then create them.
+    maxChebyPoly = myPoly->nW;
+    if (myPoly->nX > maxChebyPoly) {
+        maxChebyPoly = myPoly->nX;
+    }
+    if (myPoly->nY > maxChebyPoly) {
+        maxChebyPoly = myPoly->nY;
+    }
+    if (myPoly->nZ > maxChebyPoly) {
+        maxChebyPoly = myPoly->nZ;
+    }
+    chebPolys = createChebyshevPolys(maxChebyPoly);
+
+    for (loop_w = 0; loop_w < myPoly->nW; loop_w++) {
+        for (loop_x = 0; loop_x < myPoly->nX; loop_x++) {
+            for (loop_y = 0; loop_y < myPoly->nY; loop_y++) {
+                for (loop_z = 0; loop_z < myPoly->nZ; loop_z++) {
+                    if (myPoly->mask[loop_w][loop_x][loop_y][loop_z] == 0) {
+                        polySum += myPoly->coeff[loop_w][loop_x][loop_y][loop_z] *
+                                   psPolynomial1DEval(w, chebPolys[loop_w]) *
+                                   psPolynomial1DEval(x, chebPolys[loop_x]) *
+                                   psPolynomial1DEval(y, chebPolys[loop_y]) *
+                                   psPolynomial1DEval(z, chebPolys[loop_z]);
+                    }
+                }
+            }
+        }
+    }
+
+    for (i=0;i<maxChebyPoly;i++) {
+        psFree(chebPolys[i]);
+    }
+    psFree(chebPolys);
+    return(polySum);
+}
+
+/*****************************************************************************
+    Polynomial coefficients will be accessed in [w][x][y][z] fashion.
+ *****************************************************************************/
+static double dOrdPolynomial1DEval(double x, const psDPolynomial1D* myPoly)
+{
+    psS32 loop_x = 0;
+    double polySum = 0.0;
+    double xSum = 1.0;
+
+    for (loop_x = 0; loop_x < myPoly->n; loop_x++) {
+        if (myPoly->mask[loop_x] == 0) {
+            polySum += xSum * myPoly->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 double dChebPolynomial1DEval(double x, const psDPolynomial1D* myPoly)
+{
+    psVector *d;
+    psS32 n;
+    psS32 i;
+    double tmp;
+
+    n = myPoly->n;
+    d = psVectorAlloc(n, PS_TYPE_F64);
+    d->data.F64[n-1] = myPoly->coeff[n-1];
+    d->data.F64[n-2] = (2.0 * x * d->data.F64[n-1]) + myPoly->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]) +
+                         (myPoly->coeff[i]);
+    }
+
+    tmp = (x * d->data.F64[1]) -
+          (d->data.F64[2]) +
+          (0.5 * myPoly->coeff[0]);
+
+    psFree(d);
+    return(tmp);
+}
+
+static double dOrdPolynomial2DEval(double x, double y, const psDPolynomial2D* myPoly)
+{
+    psS32 loop_x = 0;
+    psS32 loop_y = 0;
+    double polySum = 0.0;
+    double xSum = 1.0;
+    double ySum = 1.0;
+
+    for (loop_x = 0; loop_x < myPoly->nX; loop_x++) {
+        ySum = xSum;
+        for (loop_y = 0; loop_y < myPoly->nY; loop_y++) {
+            if (myPoly->mask[loop_x][loop_y] == 0) {
+                polySum += ySum * myPoly->coeff[loop_x][loop_y];
+                ySum *= y;
+            }
+        }
+        xSum *= x;
+    }
+
+    return(polySum);
+}
+
+static double dChebPolynomial2DEval(double x, double y, const psDPolynomial2D* myPoly)
+{
+    psS32 loop_x = 0;
+    psS32 loop_y = 0;
+    psS32 i = 0;
+    double polySum = 0.0;
+    psPolynomial1D* *chebPolys = NULL;
+    psS32 maxChebyPoly = 0;
+
+    // Determine how many Chebyshev polynomials
+    // are needed, then create them.
+    maxChebyPoly = myPoly->nX;
+    if (myPoly->nY > maxChebyPoly) {
+        maxChebyPoly = myPoly->nY;
+    }
+    chebPolys = createChebyshevPolys(maxChebyPoly);
+
+    for (loop_x = 0; loop_x < myPoly->nX; loop_x++) {
+        for (loop_y = 0; loop_y < myPoly->nY; loop_y++) {
+            if (myPoly->mask[loop_x][loop_y] == 0) {
+                polySum += myPoly->coeff[loop_x][loop_y] *
+                           psPolynomial1DEval(x, chebPolys[loop_x]) *
+                           psPolynomial1DEval(y, chebPolys[loop_y]);
+            }
+        }
+    }
+
+    for (i=0;i<maxChebyPoly;i++) {
+        psFree(chebPolys[i]);
+    }
+    psFree(chebPolys);
+    return(polySum);
+}
+
+static double dOrdPolynomial3DEval(double x, double y, double z, const psDPolynomial3D* myPoly)
+{
+    psS32 loop_x = 0;
+    psS32 loop_y = 0;
+    psS32 loop_z = 0;
+    double polySum = 0.0;
+    double xSum = 1.0;
+    double ySum = 1.0;
+    double zSum = 1.0;
+
+    for (loop_x = 0; loop_x < myPoly->nX; loop_x++) {
+        ySum = xSum;
+        for (loop_y = 0; loop_y < myPoly->nY; loop_y++) {
+            zSum = ySum;
+            for (loop_z = 0; loop_z < myPoly->nZ; loop_z++) {
+                if (myPoly->mask[loop_x][loop_y][loop_z] == 0) {
+                    polySum += zSum * myPoly->coeff[loop_x][loop_y][loop_z];
+                    zSum *= z;
+                }
+            }
+            ySum *= y;
+        }
+        xSum *= x;
+    }
+
+    return(polySum);
+}
+
+static double dChebPolynomial3DEval(double x, double y, double z, const psDPolynomial3D* myPoly)
+{
+    psS32 loop_x = 0;
+    psS32 loop_y = 0;
+    psS32 loop_z = 0;
+    psS32 i = 0;
+    double polySum = 0.0;
+    psPolynomial1D* *chebPolys = NULL;
+    psS32 maxChebyPoly = 0;
+
+    // Determine how many Chebyshev polynomials
+    // are needed, then create them.
+    maxChebyPoly = myPoly->nX;
+    if (myPoly->nY > maxChebyPoly) {
+        maxChebyPoly = myPoly->nY;
+    }
+    if (myPoly->nZ > maxChebyPoly) {
+        maxChebyPoly = myPoly->nZ;
+    }
+    chebPolys = createChebyshevPolys(maxChebyPoly);
+
+    for (loop_x = 0; loop_x < myPoly->nX; loop_x++) {
+        for (loop_y = 0; loop_y < myPoly->nY; loop_y++) {
+            for (loop_z = 0; loop_z < myPoly->nZ; loop_z++) {
+                if (myPoly->mask[loop_x][loop_y][loop_z] == 0) {
+                    polySum += myPoly->coeff[loop_x][loop_y][loop_z] *
+                               psPolynomial1DEval(x, chebPolys[loop_x]) *
+                               psPolynomial1DEval(y, chebPolys[loop_y]) *
+                               psPolynomial1DEval(z, chebPolys[loop_z]);
+                }
+            }
+        }
+    }
+
+    for (i=0;i<maxChebyPoly;i++) {
+        psFree(chebPolys[i]);
+    }
+    psFree(chebPolys);
+    return(polySum);
+}
+
+static double dOrdPolynomial4DEval(double w, double x, double y, double z, const psDPolynomial4D* myPoly)
+{
+    psS32 loop_w = 0;
+    psS32 loop_x = 0;
+    psS32 loop_y = 0;
+    psS32 loop_z = 0;
+    double polySum = 0.0;
+    double wSum = 1.0;
+    double xSum = 1.0;
+    double ySum = 1.0;
+    double zSum = 1.0;
+
+    for (loop_w = 0; loop_w < myPoly->nW; loop_w++) {
+        xSum = wSum;
+        for (loop_x = 0; loop_x < myPoly->nX; loop_x++) {
+            ySum = xSum;
+            for (loop_y = 0; loop_y < myPoly->nY; loop_y++) {
+                zSum = ySum;
+                for (loop_z = 0; loop_z < myPoly->nZ; loop_z++) {
+                    if (myPoly->mask[loop_w][loop_x][loop_y][loop_z] == 0) {
+                        polySum += zSum * myPoly->coeff[loop_w][loop_x][loop_y][loop_z];
+                        zSum *= z;
+                    }
+                }
+                ySum *= y;
+            }
+            xSum *= x;
+        }
+        wSum *= w;
+    }
+
+    return(polySum);
+}
+
+static double dChebPolynomial4DEval(double w, double x, double y, double z, const psDPolynomial4D* myPoly)
+{
+    psS32 loop_w = 0;
+    psS32 loop_x = 0;
+    psS32 loop_y = 0;
+    psS32 loop_z = 0;
+    psS32 i = 0;
+    double polySum = 0.0;
+    psPolynomial1D* *chebPolys = NULL;
+    psS32 maxChebyPoly = 0;
+
+    // Determine how many Chebyshev polynomials
+    // are needed, then create them.
+    maxChebyPoly = myPoly->nW;
+    if (myPoly->nX > maxChebyPoly) {
+        maxChebyPoly = myPoly->nX;
+    }
+    if (myPoly->nY > maxChebyPoly) {
+        maxChebyPoly = myPoly->nY;
+    }
+    if (myPoly->nZ > maxChebyPoly) {
+        maxChebyPoly = myPoly->nZ;
+    }
+    chebPolys = createChebyshevPolys(maxChebyPoly);
+
+    for (loop_w = 0; loop_w < myPoly->nW; loop_w++) {
+        for (loop_x = 0; loop_x < myPoly->nX; loop_x++) {
+            for (loop_y = 0; loop_y < myPoly->nY; loop_y++) {
+                for (loop_z = 0; loop_z < myPoly->nZ; loop_z++) {
+                    if (myPoly->mask[loop_w][loop_x][loop_y][loop_z] == 0) {
+                        polySum += myPoly->coeff[loop_w][loop_x][loop_y][loop_z] *
+                                   psPolynomial1DEval(w, chebPolys[loop_w]) *
+                                   psPolynomial1DEval(x, chebPolys[loop_x]) *
+                                   psPolynomial1DEval(y, chebPolys[loop_y]) *
+                                   psPolynomial1DEval(z, chebPolys[loop_z]);
+                    }
+                }
+            }
+        }
+    }
+
+    for (i=0;i<maxChebyPoly;i++) {
+        psFree(chebPolys[i]);
+    }
+    psFree(chebPolys);
+    return(polySum);
+}
+
+
+/*****************************************************************************
+p_psInterpolate1D(): This routine will take as input n-element floating
+point arrays domain and range, and the x value, assumed to lie with the
+domain vector.  It produces as output the (n-1)-order LaGrange interpolated
+value of x.
+ 
+XXX: do we error check for non-distinct domain values?
+ *****************************************************************************/
+static float fullInterpolate1DF32(float *domain,
+                                  float *range,
+                                  psS32 n,
+                                  float x)
+{
+    PS_INT_CHECK_NON_NEGATIVE(n, NAN);
+    PS_PTR_CHECK_NULL(domain, NAN);
+    PS_PTR_CHECK_NULL(range, NAN);
+
+    psS32 i;
+    psS32 m;
+    static psVector *p = NULL;
+    p = psVectorRecycle(p, n, PS_TYPE_F32);
+    p_psMemSetPersistent(p, true);
+    p_psMemSetPersistent(p->data.F32, true);
+    /*
+        psVector *p = psVectorAlloc(n, PS_TYPE_F32);
+        float tmp;
+    */
+
+    psTrace(".psLib.dataManip.psFunctions.fullInterpolate1DF32", 4,
+            "---- fullInterpolate1DF32() begin (%d-order at x=%f) (%d data points)----\n", n-1, x, n);
+
+    for (i=0;i<n;i++) {
+        psTrace(".psLib.dataManip.psFunctions.fullInterpolate1DF32", 6,
+                "domain/range is (%f %f)\n", domain[i], range[i]);
+    }
+
+    for (i=0;i<n;i++) {
+        p->data.F32[i] = range[i];
+        psTrace(".psLib.dataManip.psFunctions.fullInterpolate1DF32", 6,
+                "p->data.F32[%d] is %f\n", i, p->data.F32[i]);
+
+    }
+
+    // From NR, during each iteration of the m loop, we are computing the
+    // p_{i ... i+m} terms.
+    for (m=1;m<n;m++) {
+        for (i=0;i<n-m;i++) {
+            // From NR: we are computing P_{i ... i+m}
+            p->data.F32[i] = (((x-domain[i+m]) * p->data.F32[i]) +
+                              ((domain[i]-x) * p->data.F32[i+1])) /
+                             (domain[i] - domain[i+m]);
+            //printf("((%f-%f * %f) + (%f-%f * %f)) / (%f - %f)\n", x, domain[i+m], p->data.F32[i], domain[i], x, p->data.F32[i+1], domain[i], domain[i+m]);
+            psTrace(".psLib.dataManip.psFunctions.fullInterpolate1DF32", 6,
+                    "p->data.F32[%d] is %f\n", i, p->data.F32[i]);
+        }
+    }
+    psTrace(".psLib.dataManip.psFunctions.fullInterpolate1DF32", 4,
+            "---- fullInterpolate1DF32() end ----\n");
+
+    /*
+        tmp = p->data.F32[0];
+        psFree(p);
+        return(tmp);
+    */
+    return(p->data.F32[0]);
+}
+
+
+/*****************************************************************************
+interpolate1DF32(): this is the base 1-D flat memory routine to perform
+LaGrange interpolation.
+ *****************************************************************************/
+static float interpolate1DF32(float *domain,
+                              float *range,
+                              psS32 n,
+                              psS32 order,
+                              float x)
+{
+    psS32 binNum;
+    psS32 numIntPoints = order+1;
+    psS32 origin;
+
+    psTrace(".psLib.dataManip.psFunctions.interpolate1DF32", 4,
+            "---- interpolate1DF32() begin ----\n");
+
+    binNum = vectorBinDisectF32(domain, n, x);
+
+    if (0 == numIntPoints%2) {
+        origin = binNum - ((numIntPoints/2) - 1);
+    } else {
+        origin = binNum - (numIntPoints/2);
+        if ((x-domain[binNum]) > (domain[binNum+1]-x)) {
+            // x is closer to binNum+1.
+            origin = 1 + (binNum - (numIntPoints/2));
+        }
+    }
+    if (origin < 0) {
+        origin = 0;
+    }
+    if ((origin + numIntPoints) > n) {
+        origin = n - numIntPoints;
+    }
+
+    psTrace(".psLib.dataManip.psFunctions.interpolate1DF32", 4,
+            "---- interpolate1DF32() end ----\n");
+    return(fullInterpolate1DF32(&domain[origin], &range[origin], order+1, x));
 }
 
@@ -336 +1154 @@
 }
 
-static void polynomial1DFree(psPolynomial1D* myPoly)
-{
-    psFree(myPoly->coeff);
-    psFree(myPoly->coeffErr);
-    psFree(myPoly->mask);
-}
-
-static void polynomial2DFree(psPolynomial2D* myPoly)
-{
-    psS32 x = 0;
-
-    for (x = 0; x < myPoly->nX; x++) {
-        psFree(myPoly->coeff[x]);
-        psFree(myPoly->coeffErr[x]);
-        psFree(myPoly->mask[x]);
-    }
-    psFree(myPoly->coeff);
-    psFree(myPoly->coeffErr);
-    psFree(myPoly->mask);
-}
-
-static void polynomial3DFree(psPolynomial3D* myPoly)
-{
-    psS32 x = 0;
-    psS32 y = 0;
-
-    for (x = 0; x < myPoly->nX; x++) {
-        for (y = 0; y < myPoly->nY; y++) {
-            psFree(myPoly->coeff[x][y]);
-            psFree(myPoly->coeffErr[x][y]);
-            psFree(myPoly->mask[x][y]);
-        }
-        psFree(myPoly->coeff[x]);
-        psFree(myPoly->coeffErr[x]);
-        psFree(myPoly->mask[x]);
-    }
-
-    psFree(myPoly->coeff);
-    psFree(myPoly->coeffErr);
-    psFree(myPoly->mask);
-}
-
-static void polynomial4DFree(psPolynomial4D* myPoly)
-{
-    psS32 w = 0;
-    psS32 x = 0;
-    psS32 y = 0;
-
-    for (w = 0; w < myPoly->nW; w++) {
-        for (x = 0; x < myPoly->nX; x++) {
-            for (y = 0; y < myPoly->nY; y++) {
-                psFree(myPoly->coeff[w][x][y]);
-                psFree(myPoly->coeffErr[w][x][y]);
-                psFree(myPoly->mask[w][x][y]);
-            }
-            psFree(myPoly->coeff[w][x]);
-            psFree(myPoly->coeffErr[w][x]);
-            psFree(myPoly->mask[w][x]);
-        }
-        psFree(myPoly->coeff[w]);
-        psFree(myPoly->coeffErr[w]);
-        psFree(myPoly->mask[w]);
-    }
-
-    psFree(myPoly->coeff);
-    psFree(myPoly->coeffErr);
-    psFree(myPoly->mask);
-}
-
-/*****************************************************************************
-    Polynomial coefficients will be accessed in [w][x][y][z] fashion.
- 
-    XXX: Should the "coeffErr[]" should be used as well?
- *****************************************************************************/
-float p_psOrdPolynomial1DEval(float x, const psPolynomial1D* myPoly)
-{
-    psS32 loop_x = 0;
-    float polySum = 0.0;
-    float xSum = 1.0;
-
-    psTrace(".psLib.dataManip.psFunctions.p_psOrdPolynomial1DEval", 4,
-            "---- Calling p_psOrdPolynomial1DEval(%f)\n", x);
-    psTrace(".psLib.dataManip.psFunctions.p_psOrdPolynomial1DEval", 4,
-            "Polynomial order is %d\n", myPoly->n);
-    for (loop_x = 0; loop_x < myPoly->n; loop_x++) {
-        psTrace(".psLib.dataManip.psFunctions.p_psOrdPolynomial1DEval", 4,
-                "Polynomial coeff[%d] is %f\n", loop_x, myPoly->coeff[loop_x]);
-    }
-
-    for (loop_x = 0; loop_x < myPoly->n; loop_x++) {
-        if (myPoly->mask[loop_x] == 0) {
-            psTrace(".psLib.dataManip.psFunctions.p_psOrdPolynomial1DEval", 10,
-                    "polysum+= sum*coeff [%f+= (%f * %f)\n", polySum, xSum, myPoly->coeff[loop_x]);
-            polySum += xSum * myPoly->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?
-float p_psChebPolynomial1DEval(float x, const psPolynomial1D* myPoly)
-{
-    psVector *d;
-    psS32 n;
-    psS32 i;
-    float tmp;
-
-    n = myPoly->n;
-    d = psVectorAlloc(n, PS_TYPE_F32);
-    d->data.F32[n-1] = myPoly->coeff[n-1];
-    d->data.F32[n-2] = (2.0 * x * d->data.F32[n-1]) + myPoly->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]) +
-                         (myPoly->coeff[i]);
-    }
-
-    tmp = (x * d->data.F32[1]) -
-          (d->data.F32[2]) +
-          (0.5 * myPoly->coeff[0]);
-
-    psFree(d);
-    return(tmp);
-    /*
-
-    psS32 n;
-    psS32 i;
-    float tmp;
-    psPolynomial1D **chebPolys = NULL;
-
-    n = myPoly->n;
-    chebPolys = CreateChebyshevPolys(n);
-
-    tmp = 0.0;
-    for (i=0;i<myPoly->n;i++) {
-        tmp+= (myPoly->coeff[i] * psPolynomial1DEval(x, chebPolys[i]));
-        //            printf("HMMM: psPolynomial1DEval(%f, chebPolys[%d]) is %f\n", x, i, psPolynomial1DEval(x, chebPolys[i]));
-    }
-    tmp-= (myPoly->coeff[0]/2.0);
-
-
-    return(tmp);
-    */
-}
-
 float psPolynomial1DEval(float x, const psPolynomial1D* myPoly)
 {
@@ -489 +1159 @@
 
     if (myPoly->type == PS_POLYNOMIAL_ORD) {
-        return(p_psOrdPolynomial1DEval(x, myPoly));
+        return(ordPolynomial1DEval(x, myPoly));
     } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
-        return(p_psChebPolynomial1DEval(x, myPoly));
+        return(chebPolynomial1DEval(x, myPoly));
     } else {
-        psError(__func__, "Unknown polynomial type 0x%x\n", myPoly->type);
+        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
+                PS_ERRORTEXT_psFunctions_INVALID_POLYNOMIAL_TYPE,
+                myPoly->type);
     }
     return(0.0);
@@ -520 +1192 @@
 }
 
-
-float p_psOrdPolynomial2DEval(float x, float y, const psPolynomial2D* myPoly)
+float psPolynomial2DEval(float x, float y, const psPolynomial2D* myPoly)
 {
     PS_POLY_CHECK_NULL(myPoly, NAN);
 
-    psS32 loop_x = 0;
-    psS32 loop_y = 0;
-    float polySum = 0.0;
-    float xSum = 1.0;
-    float ySum = 1.0;
-
-    for (loop_x = 0; loop_x < myPoly->nX; loop_x++) {
-        ySum = xSum;
-        for (loop_y = 0; loop_y < myPoly->nY; loop_y++) {
-            if (myPoly->mask[loop_x][loop_y] == 0) {
-                polySum += ySum * myPoly->coeff[loop_x][loop_y];
-                ySum *= y;
-            }
-        }
-        xSum *= x;
-    }
-
-    return(polySum);
-}
-
-float p_psChebPolynomial2DEval(float x, float y, const psPolynomial2D* myPoly)
-{
-    PS_POLY_CHECK_NULL(myPoly, NAN);
-
-    psS32 loop_x = 0;
-    psS32 loop_y = 0;
-    psS32 i = 0;
-    float polySum = 0.0;
-    psPolynomial1D* *chebPolys = NULL;
-    psS32 maxChebyPoly = 0;
-
-    // Determine how many Chebyshev polynomials
-    // are needed, then create them.
-    maxChebyPoly = myPoly->nX;
-    if (myPoly->nY > maxChebyPoly) {
-        maxChebyPoly = myPoly->nY;
-    }
-    chebPolys = CreateChebyshevPolys(maxChebyPoly);
-
-    for (loop_x = 0; loop_x < myPoly->nX; loop_x++) {
-        for (loop_y = 0; loop_y < myPoly->nY; loop_y++) {
-            if (myPoly->mask[loop_x][loop_y] == 0) {
-                polySum += myPoly->coeff[loop_x][loop_y] *
-                           psPolynomial1DEval(x, chebPolys[loop_x]) *
-                           psPolynomial1DEval(y, chebPolys[loop_y]);
-            }
-        }
-    }
-    for (i=0;i<maxChebyPoly;i++) {
-        psFree(chebPolys[i]);
-    }
-    psFree(chebPolys);
-    return(polySum);
-}
-
-float psPolynomial2DEval(float x, float y, const psPolynomial2D* myPoly)
-{
-    PS_POLY_CHECK_NULL(myPoly, NAN);
-
     if (myPoly->type == PS_POLYNOMIAL_ORD) {
-        return(p_psOrdPolynomial2DEval(x, y, myPoly));
+        return(ordPolynomial2DEval(x, y, myPoly));
     } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
-        return(p_psChebPolynomial2DEval(x, y, myPoly));
+        return(chebPolynomial2DEval(x, y, myPoly));
     } else {
-        psError(__func__, "Unknown polynomial type 0x%x\n", myPoly->type);
+        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
+                PS_ERRORTEXT_psFunctions_INVALID_POLYNOMIAL_TYPE,
+                myPoly->type);
     }
     return(0.0);
 }
-
 
 psVector *psPolynomial2DEvalVector(const psVector *x,
@@ -632 +1245 @@
 }
 
-
-
-float p_psOrdPolynomial3DEval(float x, float y, float z, const psPolynomial3D* myPoly)
-{
-    psS32 loop_x = 0;
-    psS32 loop_y = 0;
-    psS32 loop_z = 0;
-    float polySum = 0.0;
-    float xSum = 1.0;
-    float ySum = 1.0;
-    float zSum = 1.0;
-
-    for (loop_x = 0; loop_x < myPoly->nX; loop_x++) {
-        ySum = xSum;
-        for (loop_y = 0; loop_y < myPoly->nY; loop_y++) {
-            zSum = ySum;
-            for (loop_z = 0; loop_z < myPoly->nZ; loop_z++) {
-                if (myPoly->mask[loop_x][loop_y][loop_z] == 0) {
-                    polySum += zSum * myPoly->coeff[loop_x][loop_y][loop_z];
-                    zSum *= z;
-                }
-            }
-            ySum *= y;
-        }
-        xSum *= x;
-    }
-
-    return(polySum);
-}
-
-float p_psChebPolynomial3DEval(float x, float y, float z, const psPolynomial3D* myPoly)
-{
-    psS32 loop_x = 0;
-    psS32 loop_y = 0;
-    psS32 loop_z = 0;
-    psS32 i = 0;
-    float polySum = 0.0;
-    psPolynomial1D* *chebPolys = NULL;
-    psS32 maxChebyPoly = 0;
-
-    // Determine how many Chebyshev polynomials
-    // are needed, then create them.
-    maxChebyPoly = myPoly->nX;
-    if (myPoly->nY > maxChebyPoly) {
-        maxChebyPoly = myPoly->nY;
-    }
-    if (myPoly->nZ > maxChebyPoly) {
-        maxChebyPoly = myPoly->nZ;
-    }
-    chebPolys = CreateChebyshevPolys(maxChebyPoly);
-
-    for (loop_x = 0; loop_x < myPoly->nX; loop_x++) {
-        for (loop_y = 0; loop_y < myPoly->nY; loop_y++) {
-            for (loop_z = 0; loop_z < myPoly->nZ; loop_z++) {
-                if (myPoly->mask[loop_x][loop_y][loop_z] == 0) {
-                    polySum += myPoly->coeff[loop_x][loop_y][loop_z] *
-                               psPolynomial1DEval(x, chebPolys[loop_x]) *
-                               psPolynomial1DEval(y, chebPolys[loop_y]) *
-                               psPolynomial1DEval(z, chebPolys[loop_z]);
-                }
-            }
-        }
-    }
-
-    for (i=0;i<maxChebyPoly;i++) {
-        psFree(chebPolys[i]);
-    }
-    psFree(chebPolys);
-    return(polySum);
-}
-
 float psPolynomial3DEval(float x, float y, float z, const psPolynomial3D* myPoly)
 {
@@ -708 +1250 @@
 
     if (myPoly->type == PS_POLYNOMIAL_ORD) {
-        return(p_psOrdPolynomial3DEval(x, y, z, myPoly));
+        return(ordPolynomial3DEval(x, y, z, myPoly));
     } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
-        return(p_psChebPolynomial3DEval(x, y, z, myPoly));
+        return(chebPolynomial3DEval(x, y, z, myPoly));
     } else {
-        psError(__func__, "Unknown polynomial type 0x%x\n", myPoly->type);
+        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
+                PS_ERRORTEXT_psFunctions_INVALID_POLYNOMIAL_TYPE,
+                myPoly->type);
     }
     return(0.0);
@@ -765 +1309 @@
 }
 
-
-
-
-
-
-float p_psOrdPolynomial4DEval(float w, float x, float y, float z, const psPolynomial4D* myPoly)
-{
-    psS32 loop_w = 0;
-    psS32 loop_x = 0;
-    psS32 loop_y = 0;
-    psS32 loop_z = 0;
-    float polySum = 0.0;
-    float wSum = 1.0;
-    float xSum = 1.0;
-    float ySum = 1.0;
-    float zSum = 1.0;
-
-    for (loop_w = 0; loop_w < myPoly->nW; loop_w++) {
-        xSum = wSum;
-        for (loop_x = 0; loop_x < myPoly->nX; loop_x++) {
-            ySum = xSum;
-            for (loop_y = 0; loop_y < myPoly->nY; loop_y++) {
-                zSum = ySum;
-                for (loop_z = 0; loop_z < myPoly->nZ; loop_z++) {
-                    if (myPoly->mask[loop_w][loop_x][loop_y][loop_z] == 0) {
-                        polySum += zSum * myPoly->coeff[loop_w][loop_x][loop_y][loop_z];
-                        zSum *= z;
-                    }
-                }
-                ySum *= y;
-            }
-            xSum *= x;
-        }
-        wSum *= w;
-    }
-
-    return(polySum);
-}
-
-float p_psChebPolynomial4DEval(float w, float x, float y, float z, const psPolynomial4D* myPoly)
-{
-    psS32 loop_w = 0;
-    psS32 loop_x = 0;
-    psS32 loop_y = 0;
-    psS32 loop_z = 0;
-    psS32 i = 0;
-    float polySum = 0.0;
-    psPolynomial1D* *chebPolys = NULL;
-    psS32 maxChebyPoly = 0;
-
-    // Determine how many Chebyshev polynomials
-    // are needed, then create them.
-    maxChebyPoly = myPoly->nW;
-    if (myPoly->nX > maxChebyPoly) {
-        maxChebyPoly = myPoly->nX;
-    }
-    if (myPoly->nY > maxChebyPoly) {
-        maxChebyPoly = myPoly->nY;
-    }
-    if (myPoly->nZ > maxChebyPoly) {
-        maxChebyPoly = myPoly->nZ;
-    }
-    chebPolys = CreateChebyshevPolys(maxChebyPoly);
-
-    for (loop_w = 0; loop_w < myPoly->nW; loop_w++) {
-        for (loop_x = 0; loop_x < myPoly->nX; loop_x++) {
-            for (loop_y = 0; loop_y < myPoly->nY; loop_y++) {
-                for (loop_z = 0; loop_z < myPoly->nZ; loop_z++) {
-                    if (myPoly->mask[loop_w][loop_x][loop_y][loop_z] == 0) {
-                        polySum += myPoly->coeff[loop_w][loop_x][loop_y][loop_z] *
-                                   psPolynomial1DEval(w, chebPolys[loop_w]) *
-                                   psPolynomial1DEval(x, chebPolys[loop_x]) *
-                                   psPolynomial1DEval(y, chebPolys[loop_y]) *
-                                   psPolynomial1DEval(z, chebPolys[loop_z]);
-                    }
-                }
-            }
-        }
-    }
-
-    for (i=0;i<maxChebyPoly;i++) {
-        psFree(chebPolys[i]);
-    }
-    psFree(chebPolys);
-    return(polySum);
-}
-
 float psPolynomial4DEval(float w, float x, float y, float z, const psPolynomial4D* myPoly)
 {
@@ -857 +1314 @@
 
     if (myPoly->type == PS_POLYNOMIAL_ORD) {
-        return(p_psOrdPolynomial4DEval(w,x,y,z, myPoly));
+        return(ordPolynomial4DEval(w,x,y,z, myPoly));
     } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
-        return(p_psChebPolynomial4DEval(w,x,y,z, myPoly));
+        return(chebPolynomial4DEval(w,x,y,z, myPoly));
     } else {
-        psError(__func__, "Unknown polynomial type 0x%x\n", myPoly->type);
+        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
+                PS_ERRORTEXT_psFunctions_INVALID_POLYNOMIAL_TYPE,
+                myPoly->type);
     }
     return(0.0);
@@ -924 +1383 @@
     return(tmp);
 }
-
-
-
 
 
@@ -1092 +1548 @@
 }
 
-static void dPolynomial1DFree(psDPolynomial1D* myPoly)
-{
-    psFree(myPoly->coeff);
-    psFree(myPoly->coeffErr);
-    psFree(myPoly->mask);
-}
-
-static void dPolynomial2DFree(psDPolynomial2D* myPoly)
-{
-    psS32 x = 0;
-
-    for (x = 0; x < myPoly->nX; x++) {
-        psFree(myPoly->coeff[x]);
-        psFree(myPoly->coeffErr[x]);
-        psFree(myPoly->mask[x]);
-    }
-    psFree(myPoly->coeff);
-    psFree(myPoly->coeffErr);
-    psFree(myPoly->mask);
-}
-
-static void dPolynomial3DFree(psDPolynomial3D* myPoly)
-{
-    psS32 x = 0;
-    psS32 y = 0;
-
-    for (x = 0; x < myPoly->nX; x++) {
-        for (y = 0; y < myPoly->nY; y++) {
-            psFree(myPoly->coeff[x][y]);
-            psFree(myPoly->coeffErr[x][y]);
-            psFree(myPoly->mask[x][y]);
-        }
-        psFree(myPoly->coeff[x]);
-        psFree(myPoly->coeffErr[x]);
-        psFree(myPoly->mask[x]);
-    }
-
-    psFree(myPoly->coeff);
-    psFree(myPoly->coeffErr);
-    psFree(myPoly->mask);
-}
-
-static void dPolynomial4DFree(psDPolynomial4D* myPoly)
-{
-    psS32 w = 0;
-    psS32 x = 0;
-    psS32 y = 0;
-
-    for (w = 0; w < myPoly->nW; w++) {
-        for (x = 0; x < myPoly->nX; x++) {
-            for (y = 0; y < myPoly->nY; y++) {
-                psFree(myPoly->coeff[w][x][y]);
-                psFree(myPoly->coeffErr[w][x][y]);
-                psFree(myPoly->mask[w][x][y]);
-            }
-            psFree(myPoly->coeff[w][x]);
-            psFree(myPoly->coeffErr[w][x]);
-            psFree(myPoly->mask[w][x]);
-        }
-        psFree(myPoly->coeff[w]);
-        psFree(myPoly->coeffErr[w]);
-        psFree(myPoly->mask[w]);
-    }
-
-    psFree(myPoly->coeff);
-    psFree(myPoly->coeffErr);
-    psFree(myPoly->mask);
-}
-
-/*****************************************************************************
-    Polynomial coefficients will be accessed in [w][x][y][z] fashion.
- *****************************************************************************/
-double p_psDOrdPolynomial1DEval(double x, const psDPolynomial1D* myPoly)
-{
-    psS32 loop_x = 0;
-    double polySum = 0.0;
-    double xSum = 1.0;
-
-    for (loop_x = 0; loop_x < myPoly->n; loop_x++) {
-        if (myPoly->mask[loop_x] == 0) {
-            polySum += xSum * myPoly->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?
-double p_psDChebPolynomial1DEval(double x, const psDPolynomial1D* myPoly)
-{
-    psVector *d;
-    psS32 n;
-    psS32 i;
-    double tmp;
-
-    n = myPoly->n;
-    d = psVectorAlloc(n, PS_TYPE_F64);
-    d->data.F64[n-1] = myPoly->coeff[n-1];
-    d->data.F64[n-2] = (2.0 * x * d->data.F64[n-1]) + myPoly->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]) +
-                         (myPoly->coeff[i]);
-    }
-
-    tmp = (x * d->data.F64[1]) -
-          (d->data.F64[2]) +
-          (0.5 * myPoly->coeff[0]);
-
-    psFree(d);
-    return(tmp);
-}
 
 double psDPolynomial1DEval(double x, const psDPolynomial1D* myPoly)
@@ -1212 +1554 @@
 
     if (myPoly->type == PS_POLYNOMIAL_ORD) {
-        return(p_psDOrdPolynomial1DEval(x, myPoly));
+        return(dOrdPolynomial1DEval(x, myPoly));
     } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
-        return(p_psDChebPolynomial1DEval(x, myPoly));
+        return(dChebPolynomial1DEval(x, myPoly));
     } else {
-        psError(__func__, "Unknown polynomial type 0x%x\n", myPoly->type);
+        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
+                PS_ERRORTEXT_psFunctions_INVALID_POLYNOMIAL_TYPE,
+                myPoly->type);
     }
     return(0.0);
@@ -1244 +1588 @@
 
 
-
-double p_psDOrdPolynomial2DEval(double x, double y, const psDPolynomial2D* myPoly)
-{
-    psS32 loop_x = 0;
-    psS32 loop_y = 0;
-    double polySum = 0.0;
-    double xSum = 1.0;
-    double ySum = 1.0;
-
-    for (loop_x = 0; loop_x < myPoly->nX; loop_x++) {
-        ySum = xSum;
-        for (loop_y = 0; loop_y < myPoly->nY; loop_y++) {
-            if (myPoly->mask[loop_x][loop_y] == 0) {
-                polySum += ySum * myPoly->coeff[loop_x][loop_y];
-                ySum *= y;
-            }
-        }
-        xSum *= x;
-    }
-
-    return(polySum);
-}
-
-double p_psDChebPolynomial2DEval(double x, double y, const psDPolynomial2D* myPoly)
-{
-    psS32 loop_x = 0;
-    psS32 loop_y = 0;
-    psS32 i = 0;
-    double polySum = 0.0;
-    psPolynomial1D* *chebPolys = NULL;
-    psS32 maxChebyPoly = 0;
-
-    // Determine how many Chebyshev polynomials
-    // are needed, then create them.
-    maxChebyPoly = myPoly->nX;
-    if (myPoly->nY > maxChebyPoly) {
-        maxChebyPoly = myPoly->nY;
-    }
-    chebPolys = CreateChebyshevPolys(maxChebyPoly);
-
-    for (loop_x = 0; loop_x < myPoly->nX; loop_x++) {
-        for (loop_y = 0; loop_y < myPoly->nY; loop_y++) {
-            if (myPoly->mask[loop_x][loop_y] == 0) {
-                polySum += myPoly->coeff[loop_x][loop_y] *
-                           psPolynomial1DEval(x, chebPolys[loop_x]) *
-                           psPolynomial1DEval(y, chebPolys[loop_y]);
-            }
-        }
-    }
-
-    for (i=0;i<maxChebyPoly;i++) {
-        psFree(chebPolys[i]);
-    }
-    psFree(chebPolys);
-    return(polySum);
-}
-
 double psDPolynomial2DEval(double x, double y, const psDPolynomial2D* myPoly)
 {
@@ -1306 +1593 @@
 
     if (myPoly->type == PS_POLYNOMIAL_ORD) {
-        return(p_psDOrdPolynomial2DEval(x, y, myPoly));
+        return(dOrdPolynomial2DEval(x, y, myPoly));
     } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
-        return(p_psDChebPolynomial2DEval(x, y, myPoly));
+        return(dChebPolynomial2DEval(x, y, myPoly));
     } else {
-        psError(__func__, "Unknown polynomial type 0x%x\n", myPoly->type);
+        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
+                PS_ERRORTEXT_psFunctions_INVALID_POLYNOMIAL_TYPE,
+                myPoly->type);
     }
     return(0.0);
@@ -1353 +1642 @@
 
 
-
-double p_psDOrdPolynomial3DEval(double x, double y, double z, const psDPolynomial3D* myPoly)
-{
-    psS32 loop_x = 0;
-    psS32 loop_y = 0;
-    psS32 loop_z = 0;
-    double polySum = 0.0;
-    double xSum = 1.0;
-    double ySum = 1.0;
-    double zSum = 1.0;
-
-    for (loop_x = 0; loop_x < myPoly->nX; loop_x++) {
-        ySum = xSum;
-        for (loop_y = 0; loop_y < myPoly->nY; loop_y++) {
-            zSum = ySum;
-            for (loop_z = 0; loop_z < myPoly->nZ; loop_z++) {
-                if (myPoly->mask[loop_x][loop_y][loop_z] == 0) {
-                    polySum += zSum * myPoly->coeff[loop_x][loop_y][loop_z];
-                    zSum *= z;
-                }
-            }
-            ySum *= y;
-        }
-        xSum *= x;
-    }
-
-    return(polySum);
-}
-
-double p_psDChebPolynomial3DEval(double x, double y, double z, const psDPolynomial3D* myPoly)
-{
-    psS32 loop_x = 0;
-    psS32 loop_y = 0;
-    psS32 loop_z = 0;
-    psS32 i = 0;
-    double polySum = 0.0;
-    psPolynomial1D* *chebPolys = NULL;
-    psS32 maxChebyPoly = 0;
-
-    // Determine how many Chebyshev polynomials
-    // are needed, then create them.
-    maxChebyPoly = myPoly->nX;
-    if (myPoly->nY > maxChebyPoly) {
-        maxChebyPoly = myPoly->nY;
-    }
-    if (myPoly->nZ > maxChebyPoly) {
-        maxChebyPoly = myPoly->nZ;
-    }
-    chebPolys = CreateChebyshevPolys(maxChebyPoly);
-
-    for (loop_x = 0; loop_x < myPoly->nX; loop_x++) {
-        for (loop_y = 0; loop_y < myPoly->nY; loop_y++) {
-            for (loop_z = 0; loop_z < myPoly->nZ; loop_z++) {
-                if (myPoly->mask[loop_x][loop_y][loop_z] == 0) {
-                    polySum += myPoly->coeff[loop_x][loop_y][loop_z] *
-                               psPolynomial1DEval(x, chebPolys[loop_x]) *
-                               psPolynomial1DEval(y, chebPolys[loop_y]) *
-                               psPolynomial1DEval(z, chebPolys[loop_z]);
-                }
-            }
-        }
-    }
-
-    for (i=0;i<maxChebyPoly;i++) {
-        psFree(chebPolys[i]);
-    }
-    psFree(chebPolys);
-    return(polySum);
-}
-
 double psDPolynomial3DEval(double x, double y, double z, const psDPolynomial3D* myPoly)
 {
@@ -1428 +1647 @@
 
     if (myPoly->type == PS_POLYNOMIAL_ORD) {
-        return(p_psDOrdPolynomial3DEval(x, y, z, myPoly));
+        return(dOrdPolynomial3DEval(x, y, z, myPoly));
     } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
-        return(p_psDChebPolynomial3DEval(x, y, z, myPoly));
+        return(dChebPolynomial3DEval(x, y, z, myPoly));
     } else {
-        psError(__func__, "Unknown polynomial type 0x%x\n", myPoly->type);
+        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
+                PS_ERRORTEXT_psFunctions_INVALID_POLYNOMIAL_TYPE,
+                myPoly->type);
     }
     return(0.0);
@@ -1485 +1706 @@
 }
 
-
-
-
-
-
-
-
-double p_psDOrdPolynomial4DEval(double w, double x, double y, double z, const psDPolynomial4D* myPoly)
-{
-    psS32 loop_w = 0;
-    psS32 loop_x = 0;
-    psS32 loop_y = 0;
-    psS32 loop_z = 0;
-    double polySum = 0.0;
-    double wSum = 1.0;
-    double xSum = 1.0;
-    double ySum = 1.0;
-    double zSum = 1.0;
-
-    for (loop_w = 0; loop_w < myPoly->nW; loop_w++) {
-        xSum = wSum;
-        for (loop_x = 0; loop_x < myPoly->nX; loop_x++) {
-            ySum = xSum;
-            for (loop_y = 0; loop_y < myPoly->nY; loop_y++) {
-                zSum = ySum;
-                for (loop_z = 0; loop_z < myPoly->nZ; loop_z++) {
-                    if (myPoly->mask[loop_w][loop_x][loop_y][loop_z] == 0) {
-                        polySum += zSum * myPoly->coeff[loop_w][loop_x][loop_y][loop_z];
-                        zSum *= z;
-                    }
-                }
-                ySum *= y;
-            }
-            xSum *= x;
-        }
-        wSum *= w;
-    }
-
-    return(polySum);
-}
-
-double p_psDChebPolynomial4DEval(double w, double x, double y, double z, const psDPolynomial4D* myPoly)
-{
-    psS32 loop_w = 0;
-    psS32 loop_x = 0;
-    psS32 loop_y = 0;
-    psS32 loop_z = 0;
-    psS32 i = 0;
-    double polySum = 0.0;
-    psPolynomial1D* *chebPolys = NULL;
-    psS32 maxChebyPoly = 0;
-
-    // Determine how many Chebyshev polynomials
-    // are needed, then create them.
-    maxChebyPoly = myPoly->nW;
-    if (myPoly->nX > maxChebyPoly) {
-        maxChebyPoly = myPoly->nX;
-    }
-    if (myPoly->nY > maxChebyPoly) {
-        maxChebyPoly = myPoly->nY;
-    }
-    if (myPoly->nZ > maxChebyPoly) {
-        maxChebyPoly = myPoly->nZ;
-    }
-    chebPolys = CreateChebyshevPolys(maxChebyPoly);
-
-    for (loop_w = 0; loop_w < myPoly->nW; loop_w++) {
-        for (loop_x = 0; loop_x < myPoly->nX; loop_x++) {
-            for (loop_y = 0; loop_y < myPoly->nY; loop_y++) {
-                for (loop_z = 0; loop_z < myPoly->nZ; loop_z++) {
-                    if (myPoly->mask[loop_w][loop_x][loop_y][loop_z] == 0) {
-                        polySum += myPoly->coeff[loop_w][loop_x][loop_y][loop_z] *
-                                   psPolynomial1DEval(w, chebPolys[loop_w]) *
-                                   psPolynomial1DEval(x, chebPolys[loop_x]) *
-                                   psPolynomial1DEval(y, chebPolys[loop_y]) *
-                                   psPolynomial1DEval(z, chebPolys[loop_z]);
-                    }
-                }
-            }
-        }
-    }
-
-    for (i=0;i<maxChebyPoly;i++) {
-        psFree(chebPolys[i]);
-    }
-    psFree(chebPolys);
-    return(polySum);
-}
-
 double psDPolynomial4DEval(double w, double x, double y, double z, const psDPolynomial4D* myPoly)
 {
@@ -1579 +1711 @@
 
     if (myPoly->type == PS_POLYNOMIAL_ORD) {
-        return(p_psDOrdPolynomial4DEval(w,x,y,z, myPoly));
+        return(dOrdPolynomial4DEval(w,x,y,z, myPoly));
     } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
-        return(p_psDChebPolynomial4DEval(w,x,y,z, myPoly));
+        return(dChebPolynomial4DEval(w,x,y,z, myPoly));
     } else {
-        psError(__func__, "Unknown polynomial type 0x%x\n", myPoly->type);
+        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
+                PS_ERRORTEXT_psFunctions_INVALID_POLYNOMIAL_TYPE,
+                myPoly->type);
     }
     return(0.0);
@@ -1699 +1833 @@
     (tmp->domains)[numSplines] = max;
 
+    p_psMemSetDeallocator(tmp,(psFreeFcn)spline1DFree);
     return(tmp);
 }
 
-// XXX: Have Robert put the dealocator in the memory file.
-psS32 p_psSpline1DFree(psSpline1D *tmpSpline)
-{
-    psS32 i;
-
-    if (tmpSpline == NULL) {
-        return(0);
-    }
-
-    if (tmpSpline->spline != NULL) {
-        for (i=0;i<tmpSpline->n;i++) {
-            psFree((tmpSpline->spline)[i]);
-        }
-        psFree(tmpSpline->spline);
-    }
-
-    if (tmpSpline->p_psDeriv2 != NULL) {
-        psFree(tmpSpline->p_psDeriv2);
-    }
-    psFree(tmpSpline->domains);
-    psFree(tmpSpline);
-
-    return(0);
-}
 
 /*****************************************************************************
@@ -1765 +1876 @@
 
 /*****************************************************************************
-p_psVectorBinDisectF32(): This is a private function which takes as input a
+vectorBinDisectF32(): This is a private function which takes as input a
 vector of floating point data as well as a single floating point values.
 The input vector values are assumed to be non-decreasing (v[i-1] <= v[j] for
@@ -1776 +1887 @@
 XXX: name since we don't take psVectors as input.
  *****************************************************************************/
-psS32 p_psVectorBinDisectF32(float *bins,
-                             psS32 numBins,
-                             float x)
+static psS32 vectorBinDisectF32(float *bins,
+                                psS32 numBins,
+                                float x)
 {
     psS32 min;
@@ -1784 +1895 @@
     psS32 mid;
 
-    psTrace(".psLib.dataManip.psFunctions.p_psVectorBinDisectF32", 4,
-            "---- Calling p_psVectorBinDisectF32(%f)\n", x);
+    psTrace(".psLib.dataManip.psFunctions.vectorBinDisectF32", 4,
+            "---- Calling vectorBinDisectF32(%f)\n", x);
 
     if (x < bins[0]) {
         psLogMsg(__func__, PS_LOG_WARN,
-                 "p_psVectorBinDisectF32(): ordinate %f is outside vector range (%f - %f).",
+                 "vectorBinDisectF32(): ordinate %f is outside vector range (%f - %f).",
                  x, bins[0], bins[numBins-1]);
         return(-2);
@@ -1796 +1907 @@
     if (x > bins[numBins-1]) {
         psLogMsg(__func__, PS_LOG_WARN,
-                 "p_psVectorBinDisectF32(): ordinate %f is outside vector range (%f - %f).",
+                 "vectorBinDisectF32(): ordinate %f is outside vector range (%f - %f).",
                  x, bins[0], bins[numBins-1]);
         return(-1);
@@ -1806 +1917 @@
 
     while (min != max) {
-        psTrace(".psLib.dataManip.psFunctions.p_psVectorBinDisectF32", 4,
+        psTrace(".psLib.dataManip.psFunctions.vectorBinDisectF32", 4,
                 "(min, mid, max) is (%d, %d, %d): (x, bins) is (%f, %f)\n",
                 min, mid, max, x, bins[mid]);
 
         if (x == bins[mid]) {
-            psTrace(".psLib.dataManip.psFunctions.p_psVectorBinDisectF32", 4,
-                    "---- Exiting p_psVectorBinDisectF32(): bin %d\n", mid);
+            psTrace(".psLib.dataManip.psFunctions.vectorBinDisectF32", 4,
+                    "---- Exiting vectorBinDisectF32(): bin %d\n", mid);
             return(mid);
         } else if (x < bins[mid]) {
@@ -1822 +1933 @@
     }
 
-    psTrace(".psLib.dataManip.psFunctions.p_psVectorBinDisectF32", 4,
-            "---- Exiting p_psVectorBinDisectF32(): bin %d\n", min);
+    psTrace(".psLib.dataManip.psFunctions.vectorBinDisectF32", 4,
+            "---- Exiting vectorBinDisectF32(): bin %d\n", min);
     return(min);
 }
 
 /*****************************************************************************
-p_psVectorBinDisectS32(): integer version of above.
+vectorBinDisectS32(): integer version of above.
  *****************************************************************************/
-psS32 p_psVectorBinDisectS32(psS32 *bins,
-                             psS32 numBins,
-                             psS32 x)
+static psS32 vectorBinDisectS32(psS32 *bins,
+                                psS32 numBins,
+                                psS32 x)
 {
     psS32 min;
@@ -1838 +1949 @@
     psS32 mid;
 
-    psTrace(".psLib.dataManip.psFunctions.p_psVectorBinDisectS32", 4,
-            "---- Calling p_psVectorBinDisectS32(%f)\n", x);
+    psTrace(".psLib.dataManip.psFunctions.vectorBinDisectS32", 4,
+            "---- Calling vectorBinDisectS32(%f)\n", x);
 
     if ((x < bins[0]) ||
             (x > bins[numBins-1])) {
         psLogMsg(__func__, PS_LOG_WARN,
-                 "p_psVectorBinDisectS32(): ordinate %f is outside vector range (%f - %f).",
+                 "vectorBinDisectS32(): ordinate %f is outside vector range (%f - %f).",
                  x, bins[0], bins[numBins-1]);
         return(-1);
@@ -1854 +1965 @@
 
     while (min != max) {
-        psTrace(".psLib.dataManip.psFunctions.p_psVectorBinDisectS32", 4,
+        psTrace(".psLib.dataManip.psFunctions.vectorBinDisectS32", 4,
                 "(min, mid, max) is (%d, %d, %d): (x, bins) is (%f, %f)\n",
                 min, mid, max, x, bins[mid]);
 
         if (x == bins[mid]) {
-            psTrace(".psLib.dataManip.psFunctions.p_psVectorBinDisectS32", 4,
-                    "---- Exiting p_psVectorBinDisectS32(): bin %d\n", min);
+            psTrace(".psLib.dataManip.psFunctions.vectorBinDisectS32", 4,
+                    "---- Exiting vectorBinDisectS32(): bin %d\n", min);
             return(min);
         } else if (x < bins[mid]) {
@@ -1870 +1981 @@
     }
 
-    psTrace(".psLib.dataManip.psFunctions.p_psVectorBinDisectS32", 4,
-            "---- Exiting p_psVectorBinDisectS32(): bin %d\n", min);
+    psTrace(".psLib.dataManip.psFunctions.vectorBinDisectS32", 4,
+            "---- Exiting vectorBinDisectS32(): bin %d\n", min);
     return(min);
 }
@@ -1884 +1995 @@
 
     if (x->type.type == PS_TYPE_S32) {
-        return(p_psVectorBinDisectS32(bins->data.S32, bins->n, x->data.S32));
+        return(vectorBinDisectS32(bins->data.S32, bins->n, x->data.S32));
     } else if (x->type.type == PS_TYPE_F32) {
-        return(p_psVectorBinDisectF32(bins->data.F32, bins->n, x->data.F32));
+        return(vectorBinDisectF32(bins->data.F32, bins->n, x->data.F32));
     } else {
-        psError(__func__, "Unallowable data type.");
+        char* strType;
+        PS_TYPE_NAME(strType,x->type.type);
+        psError(PS_ERR_BAD_PARAMETER_TYPE,
+                PS_ERRORTEXT_psFunctions_TYPE_NOT_SUPPORTED,
+                strType);
         return(-2);
     }
     return(-1);
-}
-
-/*****************************************************************************
-p_psInterpolate1D(): This routine will take as input n-element floating
-point arrays domain and range, and the x value, assumed to lie with the
-domain vector.  It produces as output the (n-1)-order LaGrange interpolated
-value of x.
- 
-XXX: do we error check for non-distinct domain values?
- *****************************************************************************/
-float p_ps1DFullInterpolateF32(float *domain,
-                               float *range,
-                               psS32 n,
-                               float x)
-{
-    PS_INT_CHECK_NON_NEGATIVE(n, NAN);
-    PS_PTR_CHECK_NULL(domain, NAN);
-    PS_PTR_CHECK_NULL(range, NAN);
-
-    psS32 i;
-    psS32 m;
-    static psVector *p = NULL;
-    p = psVectorRecycle(p, n, PS_TYPE_F32);
-    p_psMemSetPersistent(p, true);
-    p_psMemSetPersistent(p->data.F32, true);
-    /*
-        psVector *p = psVectorAlloc(n, PS_TYPE_F32);
-        float tmp;
-    */
-
-    psTrace(".psLib.dataManip.psFunctions.p_ps1DFullInterpolateF32", 4,
-            "---- p_ps1DFullInterpolateF32() begin (%d-order at x=%f) (%d data points)----\n", n-1, x, n);
-
-    for (i=0;i<n;i++) {
-        psTrace(".psLib.dataManip.psFunctions.p_ps1DFullInterpolateF32", 6,
-                "domain/range is (%f %f)\n", domain[i], range[i]);
-    }
-
-    for (i=0;i<n;i++) {
-        p->data.F32[i] = range[i];
-        psTrace(".psLib.dataManip.psFunctions.p_ps1DFullInterpolateF32", 6,
-                "p->data.F32[%d] is %f\n", i, p->data.F32[i]);
-
-    }
-
-    // From NR, during each iteration of the m loop, we are computing the
-    // p_{i ... i+m} terms.
-    for (m=1;m<n;m++) {
-        for (i=0;i<n-m;i++) {
-            // From NR: we are computing P_{i ... i+m}
-            p->data.F32[i] = (((x-domain[i+m]) * p->data.F32[i]) +
-                              ((domain[i]-x) * p->data.F32[i+1])) /
-                             (domain[i] - domain[i+m]);
-            //printf("((%f-%f * %f) + (%f-%f * %f)) / (%f - %f)\n", x, domain[i+m], p->data.F32[i], domain[i], x, p->data.F32[i+1], domain[i], domain[i+m]);
-            psTrace(".psLib.dataManip.psFunctions.p_ps1DFullInterpolateF32", 6,
-                    "p->data.F32[%d] is %f\n", i, p->data.F32[i]);
-        }
-    }
-    psTrace(".psLib.dataManip.psFunctions.p_ps1DFullInterpolateF32", 4,
-            "---- p_ps1DFullInterpolateF32() end ----\n");
-
-    /*
-        tmp = p->data.F32[0];
-        psFree(p);
-        return(tmp);
-    */
-    return(p->data.F32[0]);
-}
-
-
-/*****************************************************************************
-p_ps1DInterpolateF32(): this is the base 1-D flat memory routine to perform
-LaGrange interpolation.
- *****************************************************************************/
-float p_ps1DInterpolateF32(float *domain,
-                           float *range,
-                           psS32 n,
-                           psS32 order,
-                           float x)
-{
-    psS32 binNum;
-    psS32 numIntPoints = order+1;
-    psS32 origin;
-
-    psTrace(".psLib.dataManip.psFunctions.p_ps1DInterpolateF32", 4,
-            "---- p_ps1DInterpolateF32() begin ----\n");
-
-    binNum = p_psVectorBinDisectF32(domain, n, x);
-
-    if (0 == numIntPoints%2) {
-        origin = binNum - ((numIntPoints/2) - 1);
-    } else {
-        origin = binNum - (numIntPoints/2);
-        if ((x-domain[binNum]) > (domain[binNum+1]-x)) {
-            // x is closer to binNum+1.
-            origin = 1 + (binNum - (numIntPoints/2));
-        }
-    }
-    if (origin < 0) {
-        origin = 0;
-    }
-    if ((origin + numIntPoints) > n) {
-        origin = n - numIntPoints;
-    }
-
-    psTrace(".psLib.dataManip.psFunctions.p_ps1DInterpolateF32", 4,
-            "---- p_ps1DInterpolateF32() end ----\n");
-    return(p_ps1DFullInterpolateF32(&domain[origin], &range[origin], order+1, x));
 }
 
@@ -2035 +2042 @@
 
     if (order > (domain->n - 1)) {
-        psError(__func__, "not enough data points for %d-order interpolation.\n", order);
+        psError(PS_ERR_BAD_PARAMETER_SIZE, true,
+                PS_ERRORTEXT_psFunctions_NOT_ENOUGH_DATAPOINTS,
+                order);
         return(NULL);
     }
@@ -2042 +2051 @@
         psTrace(".psLib.dataManip.psFunctions.p_psVectorInterpolate", 4,
                 "---- p_psVectorInterpolate() end ----\n");
-        return(psScalarAlloc(p_ps1DInterpolateF32(domain->data.F32,
-                             range->data.F32,
-                             domain->n,
-                             order,
-                             x->data.F32), PS_TYPE_F32));
+        return(psScalarAlloc(interpolate1DF32(domain->data.F32,
+                                              range->data.F32,
+                                              domain->n,
+                                              order,
+                                              x->data.F32), PS_TYPE_F32));
     } else if (x->type.type == PS_TYPE_F64) {
         // XXX: use recycled vectors here.
@@ -2053 +2062 @@
 
         psScalar *tmpScalar = psScalarAlloc((double)
-                                            p_ps1DInterpolateF32(domain32->data.F32,
-                                                                 range32->data.F32,
-                                                                 domain32->n,
-                                                                 order,
-                                                                 (float) x->data.F64), PS_TYPE_F64);
+                                            interpolate1DF32(domain32->data.F32,
+                                                             range32->data.F32,
+                                                             domain32->n,
+                                                             order,
+                                                             (float) x->data.F64), PS_TYPE_F64);
         psFree(range32);
         psFree(domain32);
@@ -2067 +2076 @@
 
     } else {
-        // XXX psError: type not supported
-        psError(__func__, "type %d not supported\n", x->type.type);
+        char* strType;
+        PS_TYPE_NAME(strType,x->type.type);
+        psError(PS_ERR_BAD_PARAMETER_TYPE,
+                PS_ERRORTEXT_psFunctions_TYPE_NOT_SUPPORTED,
+                strType);
     }
 
@@ -2084 +2096 @@
 and an independent x value.  Each determines which spline that x corresponds
 to by doing a bracket disection on the domains of the spline data structure
-(p_psVectorBinDisectF32()).  Then it evaluates the spline at that x location
+(vectorBinDisectF32()).  Then it evaluates the spline at that x location
 by a call to the 1D polynomial functions.
  
@@ -2100 +2112 @@
 
     n = spline->n;
-    binNum = p_psVectorBinDisectF32(spline->domains, (spline->n)+1, x);
+    binNum = vectorBinDisectF32(spline->domains, (spline->n)+1, x);
     if (binNum < 0) {
         psLogMsg(__func__, PS_LOG_WARN,
@@ -2139 +2151 @@
         }
     } else {
-        psError(__func__, "Unknown data type.\n");
+        char* strType;
+        PS_TYPE_NAME(strType,x->type.type);
+        psError(PS_ERR_BAD_PARAMETER_TYPE,
+                PS_ERRORTEXT_psFunctions_TYPE_NOT_SUPPORTED,
+                strType);
         return(NULL);
     }

trunk/psLib/src/dataManip/psFunctions.h

@@ -12 +12 @@
 *  @author George Gusciora, MHPCC
 *
-*  @version $Revision: 1.32 $ $Name: not supported by cvs2svn $
-*  @date $Date: 2004-11-03 03:30:30 $
+*  @version $Revision: 1.33 $ $Name: not supported by cvs2svn $
+*  @date $Date: 2004-11-04 01:04:59 $
 *
 *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -398 +398 @@
                             float max);
 
-psS32 p_psSpline1DFree(psSpline1D *tmpSpline);
-
 psSpline1D *psSpline1DAllocGeneric(const psVector *bounds,
                                    psS32 order);

trunk/psLib/src/dataManip/psMatrix.c

@@ -20 +20 @@
  *  @author Ross Harman, MHPCC
  *   
- *  @version $Revision: 1.18 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-10-27 20:20:11 $
+ *  @version $Revision: 1.19 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-11-04 01:04:59 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -40 +40 @@
 #include "psVector.h"
 #include "psMatrix.h"
-
-/** Preprocessor macro to generate error a NULL image */
-#define PS_VECTOR_CHECK_NULL(NAME, RETURN)                                                          \
-if (NAME == NULL || NAME->data.V == NULL) {                                                         \
-    psError(__func__,"Invalid operation: %s or its data is NULL.", #NAME);                          \
-    return RETURN;                                                                                  \
-}
-
-/** Preprocessor macro to create vector based on another */
-#define PS_CHECK_ALLOC_VECTOR(NAME, SIZE, PS_TYPE)                                                  \
-if(NAME == NULL) {                                                                                  \
-    NAME = psVectorAlloc(SIZE, PS_TYPE);                                                            \
-}
-
-/** Preprocessor macro to generate error for zero length vector */
-#define PS_CHECK_SIZE_VECTOR(NAME, RETURN)                                                          \
-if (NAME->n < 1) {                                                                                  \
-    psError(__func__,"Invalid operation: %s has zero n value.", #NAME);                             \
-    return RETURN;                                                                                  \
-}
-
-/** Preprocessor macro to generate error a NULL image */
-#define PS_IMAGE_CHECK_NULL(NAME, RETURN)                                                           \
-if (NAME == NULL || NAME->data.V == NULL) {                                                         \
-    psError(__func__,"Invalid operation: %s or its data is NULL.", #NAME);                          \
-    return RETURN;                                                                                  \
-}
-
-/** Preprocessor macro to create image based on another */
-#define PS_CHECK_ALLOC_IMAGE(NAME, NCOLS, NROWS, PS_TYPE)                                           \
-if(NAME == NULL) {                                                                                  \
-    NAME = psImageAlloc(NCOLS, NROWS, PS_TYPE);                                                     \
-}
-
-/** Preprocessor macro to generate error for zero length rows or columns */
-#define PS_CHECK_SIZE_IMAGE(NAME, RETURN)                                                           \
-if (NAME->numCols < 1 || NAME->numRows < 1) {                                                       \
-    psError(__func__,"Invalid operation: %s has zero rows or columns (%dx%d).", #NAME,              \
-            NAME->numCols, NAME->numRows);                                                          \
-    return RETURN;                                                                                  \
-}
+#include "psConstants.h"
+
+
 
 /** Preprocessor macro to generate error for image dimensionality not set to PS_DIMEN_IMAGE */
 #define PS_CHECK_DIMEN_AND_TYPE(NAME, PS_DIMEN, RETURN)                                             \
 if (NAME->type.dimen != PS_DIMEN) {                                                                 \
-    psError(__func__,"Invalid operation: %s incorrect dimensionality %d.", #NAME, PS_DIMEN);        \
+    psError(PS_ERR_BAD_PARAMETER_TYPE, true,                                                        \
+            "Invalid operation. %s has incorrect dimensionality %d.", #NAME, PS_DIMEN);             \
     return RETURN;                                                                                  \
 } else if(NAME->type.type != PS_TYPE_F64) {                                                         \
-    psError(__func__, "Invalid operation: %s not PS_TYPE_F64.", #NAME);                             \
+    psError(PS_ERR_BAD_PARAMETER_TYPE, true,                                                        \
+            "Invalid operation. %s not PS_TYPE_F64.", #NAME);                                       \
     return RETURN;                                                                                  \
 }
@@ -95 +59 @@
 #define PS_CHECK_POINTERS(NAME1, NAME2, RETURN)                                                     \
 if (NAME1 == NAME2) {                                                                               \
-    psError(__func__,"Invalid operation: Pointer to %s is same as %s.", #NAME1, #NAME2);            \
+    psError(PS_ERR_BAD_PARAMETER_VALUE, true,                                                       \
+            "Invalid operation: Pointer to %s is same as %s.", #NAME1, #NAME2);                     \
     return RETURN;                                                                                  \
 }
@@ -102 +67 @@
 #define PS_CHECK_SQUARE(NAME, RETURN)                                                               \
 if (NAME->numCols != NAME->numRows) {                                                               \
-    psError(__func__,"Invalid operation: %s not square array.", #NAME);                             \
+    psError(PS_ERR_BAD_PARAMETER_SIZE, true,                                                       \
+            "Invalid operation: %s not square array.", #NAME);                             \
     return RETURN;                                                                                  \
 }
@@ -126 +92 @@
     gsl_permutation perm;
 
+    #define psMatrixLUD_EXIT { \
+                               psFree(outImage); \
+                               return NULL; \
+                             }
+
     // Error checks
     PS_CHECK_POINTERS(inImage, outImage, outImage);
-    PS_IMAGE_CHECK_NULL(inImage, outImage);
     PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, outImage);
-    PS_CHECK_SIZE_IMAGE(inImage, outImage);
-    PS_CHECK_ALLOC_IMAGE(outImage, inImage->numCols, inImage->numRows, inImage->type.type);
-    PS_CHECK_DIMEN_AND_TYPE(outImage, PS_DIMEN_IMAGE, outImage);
-    PS_CHECK_SIZE_IMAGE(outImage, outImage);
-    PS_CHECK_ALLOC_VECTOR(outPerm, inImage->numRows, inImage->type.type);
-    PS_VECTOR_CHECK_NULL(outPerm, outImage);
+
+    PS_IMAGE_CHECK_NULL_GENERAL(inImage, psMatrixLUD_EXIT);
+    PS_VECTOR_CHECK_NULL_GENERAL(outPerm, psMatrixLUD_EXIT);
+
     PS_CHECK_DIMEN_AND_TYPE(outPerm, PS_DIMEN_VECTOR, outImage);
+
+    psImageRecycle(outImage, inImage->numCols, inImage->numRows, inImage->type.type);
+    psVectorRecycle(outPerm, inImage->numRows, inImage->type.type);
 
     // Initialize data
@@ -179 +150 @@
     PS_IMAGE_CHECK_NULL(inImage, outVector);
     PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, outVector);
-    PS_CHECK_SIZE_IMAGE(inImage, outVector);
-    PS_CHECK_ALLOC_VECTOR(outVector, inImage->numRows, inImage->type.type);
+    PS_IMAGE_CHECK_EMPTY(inImage, outVector);
     PS_VECTOR_CHECK_NULL(outVector, outVector);
     PS_CHECK_DIMEN_AND_TYPE(outVector, PS_DIMEN_VECTOR, outVector);
@@ -188 +158 @@
     PS_CHECK_DIMEN_AND_TYPE(inPerm, PS_DIMEN_VECTOR, outVector);
 
+    psVectorRecycle(outVector, inImage->numRows, inImage->type.type);
+
+
     // Initialize data
     numRows = inImage->numRows;
@@ -226 +199 @@
 
     // Error checks
-    if (det == NULL) {
-        psError(__func__, "Invalid operation: determinant argument is NULL.");
-        return outImage;
-    }
+    PS_PTR_CHECK_NULL(det, outImage);
     PS_CHECK_POINTERS(inImage, outImage, outImage);
     PS_IMAGE_CHECK_NULL(inImage, outImage);
     PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, outImage);
-    PS_CHECK_SIZE_IMAGE(inImage, outImage);
-    PS_CHECK_ALLOC_IMAGE(outImage, inImage->numCols, inImage->numRows, inImage->type.type);
-    PS_CHECK_DIMEN_AND_TYPE(outImage, PS_DIMEN_IMAGE, outImage);
-    PS_CHECK_SIZE_IMAGE(outImage, outImage);
+    PS_IMAGE_CHECK_EMPTY(inImage, outImage);
+
+    psImageRecycle(outImage, inImage->numCols, inImage->numRows, inImage->type.type);
 
     // Initialize data
@@ -282 +251 @@
     PS_IMAGE_CHECK_NULL(inImage, NULL);
     PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, NULL);
-    PS_CHECK_SIZE_IMAGE(inImage, NULL);
+    PS_IMAGE_CHECK_EMPTY(inImage, NULL);
 
     // Initialize data
@@ -325 +294 @@
     PS_IMAGE_CHECK_NULL(inImage1, outImage);
     PS_CHECK_DIMEN_AND_TYPE(inImage1, PS_DIMEN_IMAGE, outImage);
-    PS_CHECK_SIZE_IMAGE(inImage1, outImage);
+    PS_IMAGE_CHECK_EMPTY(inImage1, outImage);
     PS_IMAGE_CHECK_NULL(inImage2, outImage);
     PS_CHECK_DIMEN_AND_TYPE(inImage2, PS_DIMEN_IMAGE, outImage);
-    PS_CHECK_SIZE_IMAGE(inImage2, outImage);
-    PS_CHECK_ALLOC_IMAGE(outImage, inImage2->numCols, inImage2->numRows, inImage2->type.type);
+    PS_IMAGE_CHECK_EMPTY(inImage2, outImage);
     PS_CHECK_DIMEN_AND_TYPE(inImage1, PS_DIMEN_IMAGE, outImage);
-    PS_CHECK_SIZE_IMAGE(outImage, outImage);
+
+    psImageRecycle(outImage, inImage2->numCols, inImage2->numRows, inImage2->type.type);
 
     // Initialize data
@@ -364 +333 @@
     PS_IMAGE_CHECK_NULL(inImage, outImage);
     PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, outImage);
-    PS_CHECK_SIZE_IMAGE(inImage, outImage);
-    PS_CHECK_ALLOC_IMAGE(outImage, inImage->numCols, inImage->numRows, inImage->type.type);
-    PS_CHECK_DIMEN_AND_TYPE(outImage, PS_DIMEN_IMAGE, outImage);
-    PS_CHECK_SIZE_IMAGE(outImage, outImage);
+    PS_IMAGE_CHECK_EMPTY(inImage, outImage);
+
+    psImageRecycle(outImage, inImage->numCols, inImage->numRows, inImage->type.type);
 
     // Initialize data
@@ -403 +371 @@
     PS_IMAGE_CHECK_NULL(inImage, outImage);
     PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, outImage);
-    PS_CHECK_SIZE_IMAGE(inImage, outImage);
-    PS_CHECK_ALLOC_IMAGE(outImage, inImage->numCols, inImage->numRows, inImage->type.type);
-    PS_CHECK_DIMEN_AND_TYPE(outImage, PS_DIMEN_IMAGE, outImage);
-    PS_CHECK_SIZE_IMAGE(outImage, outImage);
+    PS_IMAGE_CHECK_EMPTY(inImage, outImage);
+
+    psImageRecycle(outImage, inImage->numCols, inImage->numRows, inImage->type.type);
 
     // Initialize data
@@ -438 +405 @@
     psS32 size = 0;
 
-    // Error checks
-    PS_IMAGE_CHECK_NULL(inImage, outVector);
+    #define psMatrixToVector_EXIT { \
+                                    psFree(outVector); \
+                                    return NULL; \
+                                  }
+
+    // Error checks
+    PS_IMAGE_CHECK_NULL_GENERAL(inImage, psMatrixToVector_EXIT);
     PS_CHECK_DIMEN_AND_TYPE(inImage, PS_DIMEN_IMAGE, outVector);
-    PS_CHECK_SIZE_IMAGE(inImage, outVector);
+    PS_IMAGE_CHECK_EMPTY_GENERAL(inImage, psMatrixToVector_EXIT);
 
     if (inImage->numRows == 1) {
         // Create transposed row vector
-        PS_CHECK_ALLOC_VECTOR(outVector, inImage->numCols, inImage->type.type);
+        psVectorRecycle(outVector, inImage->numCols, inImage->type.type);
         outVector->type.dimen = PS_DIMEN_TRANSV;
     } else if (inImage->numCols == 1) {
         // Create non-transposed column vector
-        PS_CHECK_ALLOC_VECTOR(outVector, inImage->numRows, inImage->type.type);
+        psVectorRecycle(outVector, inImage->numRows, inImage->type.type);
     } else {
-        psError(__func__, "Image does not have dim with 1 col or 1 row: (%d x %d).", inImage->numRows,
-                inImage->numCols);
+        psError(PS_ERR_BAD_PARAMETER_SIZE, true,
+                "Image does not have dim with 1 col or 1 row: (%d x %d).",
+                inImage->numRows, inImage->numCols);
         return outVector;
     }
@@ -467 +440 @@
 
         if (outVector->n != inImage->numRows) {
-            psError(__func__, "Image and vector sizes differ: (%d vs %d).", inImage->numRows, outVector->n);
+            psError(PS_ERR_BAD_PARAMETER_SIZE, true,
+                    "Image and vector sizes differ: (%d vs %d).",
+                    inImage->numRows, outVector->n);
             return outVector;
         }
@@ -481 +456 @@
 
         if (outVector->n != inImage->numCols) {
-            psError(__func__, "Image and vector sizes differ: (%d vs %d).", inImage->numCols, outVector->n);
+            psError(PS_ERR_BAD_PARAMETER_SIZE, true,
+                    "Image and vector sizes differ: (%d vs %d).",
+                    inImage->numCols, outVector->n);
             return outVector;
         }
@@ -502 +479 @@
     if (inVector->type.dimen == PS_DIMEN_VECTOR) {
         PS_CHECK_DIMEN_AND_TYPE(inVector, PS_DIMEN_VECTOR, outImage);
-        PS_CHECK_SIZE_VECTOR(inVector, outImage);
-        PS_CHECK_ALLOC_IMAGE(outImage, 1, inVector->n, PS_TYPE_F64)
+        PS_VECTOR_CHECK_EMPTY(inVector, outImage);
+        psImageRecycle(outImage, 1, inVector->n, PS_TYPE_F64);
         // More checks for PS_DIMEN_VECTOR
         if (outImage->numCols > 1) {
-            psError(__func__, "Image has more than 1 column: numCols = %d.", outImage->numCols);
+            psError(PS_ERR_BAD_PARAMETER_SIZE, true,
+                    "Image has more than 1 column: numCols = %d.",
+                    outImage->numCols);
             return outImage;
         } else if (outImage->numRows != inVector->n) {
-            psError(__func__, "Image and vector sizes differ: (%d vs %d).", outImage->numRows, inVector->n);
+            psError(PS_ERR_BAD_PARAMETER_SIZE, true,
+                    "Image and vector sizes differ: (%d vs %d).",
+                    outImage->numRows, inVector->n);
             return outImage;
         }
@@ -517 +498 @@
     } else if (inVector->type.dimen == PS_DIMEN_TRANSV) {
         PS_CHECK_DIMEN_AND_TYPE(inVector, PS_DIMEN_TRANSV, outImage);
-        PS_CHECK_SIZE_VECTOR(inVector, outImage);
-        PS_CHECK_ALLOC_IMAGE(outImage, inVector->n, 1, PS_TYPE_F64)
+        PS_VECTOR_CHECK_EMPTY(inVector, outImage);
+        psImageRecycle(outImage, inVector->n, 1, PS_TYPE_F64);
         // More checks for PS_DIMEN_TRANSV
         if (outImage->numRows > 1) {
-            psError(__func__, "Image has more than 1 row: numRows = %d.", outImage->numRows);
+            psError(PS_ERR_BAD_PARAMETER_SIZE, true,
+                    "Image has more than 1 row: numRows = %d.",
+                    outImage->numRows);
             return outImage;
         } else if (outImage->numCols != inVector->n) {
-            psError(__func__, "Image and vector sizes differ: (%d vs %d).", outImage->numCols, inVector->n);
+            psError(PS_ERR_BAD_PARAMETER_SIZE, true,
+                    "Image and vector sizes differ: (%d vs %d).",
+                    outImage->numCols, inVector->n);
             return outImage;
         }

trunk/psLib/src/dataManip/psMatrixVectorArithmetic.c

@@ -29 +29 @@
  *  @author Ross Harman, MHPCC
  *
- *  @version $Revision: 1.29 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-10-27 00:57:31 $
+ *  @version $Revision: 1.30 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-11-04 01:04:59 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -48 +48 @@
 #include "psScalar.h"
 #include "psLogMsg.h"
+#include "psConstants.h"
+#include "psDataManipErrors.h"
 
 /*****************************************************************************
@@ -58 +60 @@
 // Conversion for radians to degrees
 #define R2D 57.29577950924861   /* 180.0/PI */
-
-/* IEEE Standards on floating-point makes this function pointless, really.
-// Division with NAN checking
-static complex double psNanDiv(complex double a, complex double b)
-{
-    complex double out = 0 + 0i;
- 
-    out = a / b;
-    if (isnan(creal(out)) || isnan(cimag(out))) {
-        psError(__func__, ": Divide by zero");
-    }
- 
-    return out;
-}
-*/
 
 // Binary SCALAR_XXXX operations
@@ -142 +129 @@
 #define VECTOR_VECTOR(OUT,IN1,OP,IN2,TYPE)                                                                   \
 {                                                                                                            \
-    psS32 i = 0;                                                                                               \
-    psS32 n1 = 0;                                                                                              \
-    psS32 n2 = 0;                                                                                              \
+    psS32 i = 0;                                                                                             \
+    psS32 n1 = 0;                                                                                            \
+    psS32 n2 = 0;                                                                                            \
     ps##TYPE *o = NULL;                                                                                      \
     ps##TYPE *i1 = NULL;                                                                                     \
@@ -151 +138 @@
     n2  = ((psVector* )IN2)->n;                                                                              \
     if(n1 != n2) {                                                                                           \
-        psError(__func__, ": Inconsistent element count: %d vs %d", n1, n2);                                 \
+        psError(PS_ERR_BAD_PARAMETER_SIZE, true,                                                             \
+                PS_ERRORTEXT_psMatrix_COUNT_DIFFERS,                                                         \
+                n1, n2);                                                                                     \
         if (OUT != IN1 && OUT != IN2) {                                                                      \
             psFree(OUT);                                                                                     \
@@ -167 +156 @@
 #define VECTOR_IMAGE(OUT,IN1,OP,IN2,TYPE)                                                                    \
 {                                                                                                            \
-    psS32 i = 0;                                                                                               \
-    psS32 j = 0;                                                                                               \
-    psS32 n1 = 0;                                                                                              \
-    psS32 numRows2 = 0;                                                                                        \
-    psS32 numCols2 = 0;                                                                                        \
+    psS32 i = 0;                                                                                             \
+    psS32 j = 0;                                                                                             \
+    psS32 n1 = 0;                                                                                            \
+    psS32 numRows2 = 0;                                                                                      \
+    psS32 numCols2 = 0;                                                                                      \
     psDimen dim1 = 0;                                                                                        \
     ps##TYPE *o = NULL;                                                                                      \
@@ -181 +170 @@
     numCols2 = ((psImage* )IN2)->numCols;                                                                    \
     \
-    if(dim1 == PS_DIMEN_VECTOR) { /* Regular vectors */                                                      \
+    if(dim1 == PS_DIMEN_VECTOR) { /* Regular vectors */                                             \
         if(n1!=numRows2) {                                                                                   \
-            psError(__func__, ": Inconsistent element count: %d vs %d", n1, numRows2);                       \
+            psError(PS_ERR_BAD_PARAMETER_SIZE, true,                                                         \
+                    PS_ERRORTEXT_psMatrix_COUNT_DIFFERS,                                                           \
+                    n1, numRows2);                                                                           \
             if (OUT != IN1 && OUT != IN2) {                                                                  \
                 psFree(OUT);                                                                                 \
@@ -200 +191 @@
     } else {  /* Transposed vectors */                                                                       \
         if(n1!=numCols2) {                                                                                   \
-            psError(__func__, ": Inconsistent element count: %d vs %d", n1, numCols2);                       \
+            psError(PS_ERR_BAD_PARAMETER_SIZE, true,                                                 \
+                    PS_ERRORTEXT_psMatrix_COUNT_DIFFERS,                                                     \
+                    n1, numCols2);                       \
             if (OUT != IN1 && OUT != IN2) {                                                                  \
                 psFree(OUT);                                                                                 \
@@ -256 +249 @@
     numCols1 = ((psImage* )IN1)->numCols;                                                                    \
     \
-    if(dim2 == PS_DIMEN_VECTOR) { /* Regular vectors */                                                      \
+    if(dim2 == PS_DIMEN_VECTOR) { /* Regular vectors */                                             \
         if(n2!=numRows1) {                                                                                   \
-            psError(__func__, ": Inconsistent element count: %d vs %d", n2, numRows1);                       \
+            psError(PS_ERR_BAD_PARAMETER_SIZE, true,                                                         \
+                    PS_ERRORTEXT_psMatrix_COUNT_DIFFERS,                                                     \
+                    n2, numRows1);                                                                           \
             if (OUT != IN1 && OUT != IN2) {                                                                  \
                 psFree(OUT);                                                                                 \
@@ -275 +270 @@
     } else {  /* Transposed vectors */                                                                       \
         if(n2!=numCols1) {                                                                                   \
-            psError(__func__, ": Inconsistent element count: %d vs %d", n2, numCols1);                       \
+            psError(PS_ERR_BAD_PARAMETER_SIZE, true,                                                         \
+                    PS_ERRORTEXT_psMatrix_COUNT_DIFFERS,                                                     \
+                    n2, numCols1);                                                                           \
             if (OUT != IN1) {                                                                                \
                 psFree(OUT);                                                                                 \
@@ -309 +306 @@
     numCols2 = ((psImage* )IN2)->numCols;                                                                    \
     if(numRows1!=numRows2 || numCols1!=numCols2) {                                                           \
-        psError(__func__, ": Inconsistent element count: numRows: %d vs %d numCols: %d vs %d", numRows1,     \
-                numRows2, numCols1, numCols2);                                                               \
+        psError(PS_ERR_BAD_PARAMETER_SIZE, true,                                                             \
+                PS_ERRORTEXT_psMatrix_IMAGE_SIZE_DIFFERS,                                                     \
+                numCols1, numRows1, numCols2, numRows2);                                                     \
         if (OUT != IN1 && OUT != IN2) {                                                                      \
             psFree(OUT);                                                                                     \
@@ -366 +364 @@
     break;                                                                                                   \
 default:                                                                                                     \
-    psError(__func__, ": Invalid PS_TYPE: %d", IN1->type);                                                   \
+    /* char* strType; \
+    PS_TYPE_NAME(strType,IN1->type);                                                                         \
+    psError(PS_ERR_BAD_PARAMETER_TYPE, true,                                                                 \
+            PS_ERRORTEXT_psMatrix_TYPE_MISMATCH,                                                             \
+            strType);  */                                                                                      \
     if (OUT != IN1 && OUT != IN2) {                                                                          \
         psFree(OUT);                                                                                         \
@@ -391 +393 @@
 } else if(!strncmp(OP, "min", 3)) {                                                                          \
     if(PS_IS_PSELEMTYPE_COMPLEX(IN1->type)) {                                                                \
-        psError(__func__, ": Minimum operation not supported for complex numbers");                          \
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true,                                                            \
+                PS_ERRORTEXT_psMatrix_MIN_COMPLEX_SUPPORT);                                                  \
         if (OUT != IN1 && OUT != IN2) {                                                                      \
             psFree(OUT);                                                                                     \
@@ -401 +404 @@
 } else if(!strncmp(OP, "max", 3)) {                                                                          \
     if(PS_IS_PSELEMTYPE_COMPLEX(IN1->type)) {                                                                \
-        psError(__func__, ": Maximum operation not supported for complex numbers");                          \
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true,                                                            \
+                PS_ERRORTEXT_psMatrix_MAX_COMPLEX_SUPPORT);                                                  \
         if (OUT != IN1 && OUT != IN2) {                                                                      \
             psFree(OUT);                                                                                     \
@@ -410 +414 @@
     }                                                                                                        \
 } else {                                                                                                     \
-    psError(__func__, ": Invalid operation: %s", OP);                                                        \
+    psError(PS_ERR_BAD_PARAMETER_VALUE, true,                                                                \
+            PS_ERRORTEXT_psMatrix_OPERATION_UNSUPPORTED,                                                     \
+            OP);                                                                                             \
     if (OUT != IN1 && OUT != IN2) {                                                                          \
         psFree(OUT);                                                                                         \
@@ -419 +425 @@
 psPtr psBinaryOp(psPtr out, psPtr in1, char *op, psPtr in2)
 {
-    psDimen dim1 = 0;
-    psDimen dim2 = 0;
-    psElemType elType1 = 0;
-    psElemType elType2 = 0;
-    psType* psType1 = NULL;
-    psType* psType2 = NULL;
-
-    psType1 = (psType* ) in1;
-    if (psType1 == NULL) {
-        psError(__func__, ": Line %d - Null in1 argument", __LINE__);
-        if (out != in1 && out != in2) {
-            psFree(out);
-        }
-        return NULL;
-    }
-
-    psType2 = (psType* ) in2;
-    if (psType2 == NULL) {
-        psError(__func__, ": Line %d - Null in2 argument", __LINE__);
-        if (out != in1 && out != in2) {
-            psFree(out);
-        }
-        return NULL;
-    }
-
-    if (op == NULL) {
-        psError(__func__, ": Line %d - Null op argument", __LINE__);
-        if (out != in1 && out != in2) {
-            psFree(out);
-        }
-        return NULL;
-    }
-
-    dim1 = psType1->dimen;
-    dim2 = psType2->dimen;
-    elType1 = psType1->type;
-    elType2 = psType2->type;
-
-    if (elType1 != elType2) {
-        psError(__func__, ": Line %d - Element types for arguments inconsistent: (%d, %d)", __LINE__,
-                elType1, elType2);
-        if (out != in1 && out != in2) {
-            psFree(out);
-        }
-        return NULL;
-    }
-
-    if (dim1 == PS_DIMEN_OTHER || dim2 == PS_DIMEN_OTHER) {
-        psError(__func__, ": Line %d - PS_DIMEN_OTHER not allowed for arguments: (%d, %d)", __LINE__,
-                dim1, dim2);
-        if (out != in1 && out != in2) {
-            psFree(out);
-        }
-        return NULL;
-    }
+
+    psVector* input1 = (psVector* ) in1;
+    psVector* input2 = (psVector* ) in2;
+
+    #define psBinaryOp_EXIT { \
+                              if (out != in1 && out != in2) { \
+                              psFree(out); \
+                              } \
+                              return NULL; \
+                            }
+
+    PS_PTR_CHECK_NULL_GENERAL(input1, psBinaryOp_EXIT);
+    PS_PTR_CHECK_NULL_GENERAL(input2, psBinaryOp_EXIT);
+    PS_PTR_CHECK_NULL_GENERAL(op, psBinaryOp_EXIT);
+
+    PS_PTR_CHECK_TYPE_EQUAL_GENERAL(input1,input2, psBinaryOp_EXIT);
+
+    PS_PTR_CHECK_DIMEN_GENERAL(input1, PS_DIMEN_OTHER, psBinaryOp_EXIT);
+    PS_PTR_CHECK_DIMEN_GENERAL(input2, PS_DIMEN_OTHER, psBinaryOp_EXIT);
+
+    psType* psType1 = (psType*)in1;
+    psType* psType2 = (psType*)in2;
+    psDimen dim1 = psType1->dimen;
+    psDimen dim2 = psType2->dimen;
+    psElemType elType1 = psType1->type;
+    psElemType elType2 = psType2->type;
 
     if (dim1 == PS_DIMEN_VECTOR || dim1 == PS_DIMEN_TRANSV) {
         if (((psVector* ) in1)->n == 0) {
-            psLogMsg(__func__, PS_LOG_WARN, ": Line %d - Vector contains zero elements");
+            psLogMsg(__func__, PS_LOG_WARN, "Vector contains zero elements");
         }
     } else if (dim1 == PS_DIMEN_IMAGE) {
         if (((psImage* ) in1)->numCols == 0 || ((psImage* ) in1)->numRows == 0) {
-            psLogMsg(__func__, PS_LOG_WARN, ": Line %d - Image contains zero length row or cols");
+            psLogMsg(__func__, PS_LOG_WARN, "Image contains zero length row or cols");
         }
     }
@@ -487 +464 @@
     if (dim2 == PS_DIMEN_VECTOR || dim2 == PS_DIMEN_TRANSV) {
         if (((psVector* ) in2)->n == 0) {
-            psLogMsg(__func__, PS_LOG_WARN, ": Line %d - Vector contains zero elements");
+            psLogMsg(__func__, PS_LOG_WARN, "Vector contains zero elements");
         }
     } else if (dim2 == PS_DIMEN_IMAGE) {
         if (((psImage* ) in2)->numCols == 0 || ((psImage* ) in2)->numRows == 0) {
-            psLogMsg(__func__, PS_LOG_WARN, ": Line %d - Image contains zero length row or cols");
+            psLogMsg(__func__, PS_LOG_WARN, "Image contains zero length row or cols");
         }
     }
@@ -513 +490 @@
             out = psVectorRecycle(out,((psVector*)in2)->n,elType1);
             if (out == NULL) {
-                psError(__func__, "Couldn't create a proper output psVector.");
+                psError(PS_ERR_UNKNOWN, false,
+                        PS_ERRORTEXT_psMatrix_OUTPUT_VECTOR_NOT_CREATED);
                 return NULL;
             }
@@ -520 +498 @@
             out = psImageRecycle(out, ((psImage* ) in2)->numCols, ((psImage* ) in2)->numRows,elType1);
             if (out == NULL) {
-                psError(__func__, "Couldn't create a proper output psImage.");
+                psError(PS_ERR_UNKNOWN, false,
+                        PS_ERRORTEXT_psMatrix_OUTPUT_IMAGE_NOT_CREATED);
                 return NULL;
             }
             BINARY_OP(SCALAR, IMAGE, out, psType1, op, psType2);        // scalar op image
         } else {
-            psError(__func__, ": Line %d - Invalid dimensionality for in2 arg: %d", __LINE__, dim2);
+            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
+                    PS_ERRORTEXT_psMatrix_DIMEN_INVALID,
+                    "in2",dim2);
+            psBinaryOp_EXIT;
         }
     } else if (dim1 == PS_DIMEN_VECTOR || dim1 == PS_DIMEN_TRANSV) {
@@ -531 +513 @@
             out = psVectorRecycle(out,((psVector*)in1)->n,elType1);
             if (out == NULL) {
-                psError(__func__, "Couldn't create a proper output psVector.");
+                psError(PS_ERR_UNKNOWN, false,
+                        PS_ERRORTEXT_psMatrix_OUTPUT_VECTOR_NOT_CREATED);
                 return NULL;
             }
@@ -538 +521 @@
             out = psVectorRecycle(out,((psVector*)in2)->n,elType2);
             if (out == NULL) {
-                psError(__func__, "Couldn't create a proper output psVector.");
+                psError(PS_ERR_UNKNOWN, false,
+                        PS_ERRORTEXT_psMatrix_OUTPUT_VECTOR_NOT_CREATED);
                 return NULL;
             }
@@ -545 +529 @@
             out = psImageRecycle(out, ((psImage* ) in2)->numCols, ((psImage* ) in2)->numRows, elType2);
             if (out == NULL) {
-                psError(__func__, "Couldn't create a proper output psImage.");
+                psError(PS_ERR_UNKNOWN, false,
+                        PS_ERRORTEXT_psMatrix_OUTPUT_IMAGE_NOT_CREATED);
                 return NULL;
             }
             BINARY_OP(VECTOR, IMAGE, out, psType1, op, psType2);        // vector op image
         } else {
-            psError(__func__, ": Line %d - Invalid dimensionality for in2 arg: %d", __LINE__, dim2);
+            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
+                    PS_ERRORTEXT_psMatrix_DIMEN_INVALID,
+                    "in2",dim2);
+            psBinaryOp_EXIT;
         }
     } else if (dim1 == PS_DIMEN_IMAGE) {
         out = psImageRecycle(out, ((psImage*)in1)->numCols, ((psImage*)in1)->numRows, elType1);
         if (out == NULL) {
-            psError(__func__, "Couldn't create a proper output psImage.");
+            psError(PS_ERR_UNKNOWN, false,
+                    PS_ERRORTEXT_psMatrix_OUTPUT_IMAGE_NOT_CREATED);
             return NULL;
         }
@@ -565 +554 @@
             BINARY_OP(IMAGE, IMAGE, out, psType1, op, psType2); // image op image
         } else {
-            if (out != in1 && out != in2) {
-                psFree(out);
-            }
-            psError(__func__, ": Line %d - Invalid dimensionality for in2 arg: %d", __LINE__, dim2);
-            return NULL;
+            psError(PS_ERR_BAD_PARAMETER_TYPE, true,
+                    PS_ERRORTEXT_psMatrix_DIMEN_INVALID,
+                    "in2",dim2);
+            psBinaryOp_EXIT;
         }
     } else {
-        if (out != in1 && out != in2) {
-            psFree(out);
-        }
-        psError(__func__, ": Line %d - Invalid dimensionality for in1 arg: %d", __LINE__, dim1);
-        return NULL;
+        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
+                PS_ERRORTEXT_psMatrix_DIMEN_INVALID,
+                "in1",dim1);
+        psBinaryOp_EXIT;
     }
 
@@ -605 +592 @@
 #define VECTOR(OUT,IN,OP,TYPE)                                                                               \
 {                                                                                                            \
-    psS32 i = 0;                                                                                               \
-    psS32 nIn = 0;                                                                                             \
-    psS32 nOut = 0;                                                                                            \
+    psS32 i = 0;                                                                                             \
+    psS32 nIn = 0;                                                                                           \
+    psS32 nOut = 0;                                                                                          \
     ps##TYPE *o = NULL;                                                                                      \
     ps##TYPE *i1 = NULL;                                                                                     \
@@ -613 +600 @@
     nOut = ((psVector* )OUT)->n;                                                                             \
     if(nIn != nOut) {                                                                                        \
-        psError(__func__, ": Inconsistent element count: %d vs %d", nIn, nOut);                              \
+        psError(PS_ERR_BAD_PARAMETER_SIZE, true,                                                             \
+                PS_ERRORTEXT_psMatrix_COUNT_DIFFERS,                                                         \
+                nIn, nOut);                                                                                  \
         if (OUT != IN) {                                                                                     \
             psFree(OUT);                                                                                     \
@@ -629 +618 @@
 #define IMAGE(OUT,IN,OP,TYPE)                                                                                \
 {                                                                                                            \
-    psS32 i = 0;                                                                                               \
-    psS32 j = 0;                                                                                               \
-    psS32 numRowsIn = 0;                                                                                       \
-    psS32 numColsIn = 0;                                                                                       \
-    psS32 numRowsOut = 0;                                                                                      \
-    psS32 numColsOut = 0;                                                                                      \
+    psS32 i = 0;                                                                                             \
+    psS32 j = 0;                                                                                             \
+    psS32 numRowsIn = 0;                                                                                     \
+    psS32 numColsIn = 0;                                                                                     \
+    psS32 numRowsOut = 0;                                                                                    \
+    psS32 numColsOut = 0;                                                                                    \
     ps##TYPE *o = NULL;                                                                                      \
     ps##TYPE *i1 = NULL;                                                                                     \
@@ -642 +631 @@
     numColsOut = ((psImage* )OUT)->numCols;                                                                  \
     if(numRowsIn!=numRowsOut || numColsIn!=numColsOut) {                                                     \
-        psError(__func__, ": Inconsistent element count: numRows: %d vs %d numCols: %d vs %d", numRowsIn,    \
-                numRowsOut, numColsIn, numColsOut);                                                          \
+        psError(PS_ERR_BAD_PARAMETER_SIZE, true,                                                             \
+                PS_ERRORTEXT_psMatrix_IMAGE_SIZE_DIFFERS,                                                    \
+                numColsIn, numRowsIn, numColsOut, numRowsOut);                                               \
         if (OUT != IN) {                                                                                     \
             psFree(OUT);                                                                                     \
@@ -697 +687 @@
     DIM(OUT,IN,OP,C32);                                                                                      \
     break;                                                                                                   \
-default:                                                                                                     \
-    psError(__func__, ": Invalid PS_TYPE: %d", IN->type);                                                    \
-    if (OUT != IN) {                                                                                         \
-        psFree(OUT);                                                                                         \
-    }                                                                                                        \
-    return NULL;                                                                                             \
+default: {                                                                                                     \
+        char* strType;                                                                                           \
+        PS_TYPE_NAME(strType, IN->type);                                                                         \
+        psError(PS_ERR_BAD_PARAMETER_TYPE, true,                                                                 \
+                PS_ERRORTEXT_psMatrix_TYPE_MISMATCH,                                                             \
+                strType);                                                                                        \
+        if (OUT != IN) {                                                                                         \
+            psFree(OUT);                                                                                         \
+        }                                                                                                        \
+        return NULL;                                                                                             \
+    } \
 }
 
@@ -815 +810 @@
     }                                                                                                        \
 } else {                                                                                                     \
-    psError(__func__, ": Invalid operation: %s", OP);                                                        \
+    psError(PS_ERR_BAD_PARAMETER_VALUE, true,                                                                \
+            PS_ERRORTEXT_psMatrix_OPERATION_UNSUPPORTED,                                                     \
+            OP);                                                                                             \
 }
 
 psPtr psUnaryOp(psPtr out, psPtr in, char *op)
 {
-    psDimen dimIn = 0;
-    psElemType elTypeIn = 0;
-    psType* psTypeIn = NULL;
-
-    psTypeIn = (psType* ) in;
-    if (psTypeIn == NULL) {
-        psError(__func__, ": Line %d - Null in argument", __LINE__);
-        if (out != in) {
-            psFree(out);
-        }
-        return NULL;
-    }
-
-    if (op == NULL) {
-        psError(__func__, ": Line %d - Null op argument", __LINE__);
-        if (out != in) {
-            psFree(out);
-        }
-        return NULL;
-    }
-
-    dimIn = psTypeIn->dimen;
-    elTypeIn = psTypeIn->type;
+    #define psUnaryOp_EXIT { \
+                             if (out != in) { \
+                             psFree(out); \
+                             } \
+                             if(psTypeIn->dimen==PS_DIMEN_SCALAR && in!=out) { \
+                             psFree(in); \
+                             } \
+                             return NULL; \
+                           }
+
+    psType* psTypeIn = (psType* ) in;
+
+    PS_PTR_CHECK_NULL_GENERAL(in, psUnaryOp_EXIT);
+    PS_PTR_CHECK_NULL_GENERAL(op, psUnaryOp_EXIT);
+
+    psDimen dimIn = psTypeIn->dimen;
+    psElemType elTypeIn = psTypeIn->type;
 
     switch (dimIn) {
@@ -857 +848 @@
     case PS_DIMEN_TRANSV:
         if (((psVector*)in)->n == 0) {
-            if (out != in) {
-                psFree(out);
-            }
-            psError(__func__, ": Line %d - Vector contains zero elements");
-            return NULL;
+            psError(PS_ERR_BAD_PARAMETER_SIZE, true,
+                    PS_ERRORTEXT_psMatrix_VECTOR_EMPTY);
+            psUnaryOp_EXIT;
         }
 
@@ -868 +857 @@
                               elTypeIn);
         if (out == NULL) {
-            psError(__func__, "Couldn't create a proper output psVector.");
-            return NULL;
+            psError(PS_ERR_UNKNOWN, false,
+                    PS_ERRORTEXT_psMatrix_OUTPUT_VECTOR_NOT_CREATED);
+            psUnaryOp_EXIT;
         }
 
@@ -876 +866 @@
     case PS_DIMEN_IMAGE:
         if (((psImage* ) in)->numCols == 0 || ((psImage* ) in)->numRows == 0) {
-            if (out != in) {
-                psFree(out);
-            }
-            psError(__func__, ": Line %d - Image contains zero length row or cols");
-            return NULL;
+            psError(PS_ERR_BAD_PARAMETER_SIZE, true,
+                    PS_ERRORTEXT_psMatrix_IMAGE_EMPTY);
+            psUnaryOp_EXIT;
         }
 
@@ -888 +876 @@
                              elTypeIn);
         if (out == NULL) {
-            psError(__func__, "Couldn't create a proper output psImage.");
-            return NULL;
+            psError(PS_ERR_UNKNOWN, false,
+                    PS_ERRORTEXT_psMatrix_OUTPUT_IMAGE_NOT_CREATED);
+            psUnaryOp_EXIT;
         }
 
@@ -898 +887 @@
             psFree(out);
         }
-        psError(__func__, ": Line %d - Invalid dimensionality for in arg: %d", __LINE__, dimIn);
-        return NULL;
+        psError(PS_ERR_BAD_PARAMETER_SIZE, true,
+                PS_ERRORTEXT_psMatrix_DIMEN_INVALID,
+                "in", dimIn);
+        psUnaryOp_EXIT;
     }
 

trunk/psLib/src/dataManip/psMinimize.c

@@ -9 +9 @@
  *  @author GLG, MHPCC
  *
- *  @version $Revision: 1.84 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-11-03 03:30:30 $
+ *  @version $Revision: 1.85 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-11-04 01:04:59 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -291 +291 @@
 
     if (y32->n != (1 + mySpline->n)) {
-        psError(__func__, "data size / spline size mismatch (%d %d)\n",
+        psError(PS_ERR_BAD_PARAMETER_SIZE, true,
+                "data size / spline size mismatch (%d %d)\n",
                 y32->n, mySpline->n);
         return(NULL);
@@ -318 +319 @@
     // Check if these are cubic splines (n==4).  If not, psError.
     if (4 != (mySpline->spline[0])->n) {
-        psError(__func__, "Don't know how to generate %d-order splines.",
+        psError(PS_ERR_BAD_PARAMETER_SIZE, true,
+                "Don't know how to generate %d-order splines.",
                 (mySpline->spline[0])->n-1);
         return(NULL);
@@ -952 +954 @@
         PS_VECTOR_GEN_X_INDEX_STATIC_F64(x64Static, y->n);
         if (myPoly->type == PS_POLYNOMIAL_CHEB) {
-            p_psNormalizeVectorRange(x64Static, -1.0, 1.0);
+            psNormalizeVectorRange(x64Static, -1.0, 1.0);
         }
         x64 = x64Static;
@@ -968 +970 @@
         tmpPoly = VectorFitPolynomial1DOrd(myPoly, x64, y64, yErr64);
     } else {
-        psError(__func__, "unknown polynomial type.\n");
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
+                "unknown polynomial type.\n");
         return(NULL);
     }
@@ -1365 +1368 @@
     bracket = p_psDetermineBracket2(params, line, paramMask, coords, func);
     if (bracket == NULL) {
-        psError(__func__, "(1) Could not bracket minimum.");
+        psError(PS_ERR_UNKNOWN, false,
+                "Could not bracket minimum.");
         return(NAN);
     }
@@ -1552 +1556 @@
                                   func);
                 if (isnan(mul)) {
-                    psError(__func__, "Could not perform line minimization (1).\n");
+                    psError(PS_ERR_UNKNOWN, false,
+                            "Could not perform line minimization");
                     psFree(v);
                     return(false);
@@ -1592 +1597 @@
         mul = p_psLineMin(&dummyMin, params, u, myParamMask, coords, func);
         if (isnan(mul)) {
-            psError(__func__, "Could not perform line minimization. (2)\n");
+            psError(PS_ERR_UNKNOWN, false,
+                    "Could not perform line minimization.");
             psFree(v);
             return(false);

trunk/psLib/src/dataManip/psStats.c

@@ -9 +9 @@
  *  @author GLG, MHPCC
  *
- *  @version $Revision: 1.84 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-11-03 03:30:30 $
+ *  @version $Revision: 1.85 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-11-04 01:04:59 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -34 +34 @@
 #include "psFunctions.h"
 #include "psConstants.h"
+
+#include "psDataManipErrors.h"
 
 /*****************************************************************************/
@@ -735 +737 @@
 
     // Ensure that stats->clipIter is within the proper range.
-    if (!((PS_CLIPPED_NUM_ITER_LB <= stats->clipIter) && (stats->clipIter <= PS_CLIPPED_NUM_ITER_UB))) {
-        psError(__func__, "Unallowed value for clipIter (%d).\n", stats->clipIter);
-        return(-1);
-    }
+    PS_INT_CHECK_RANGE(stats->clipIter,PS_CLIPPED_NUM_ITER_LB,PS_CLIPPED_NUM_ITER_UB,-1);
+
     // Ensure that stats->clipSigma is within the proper range.
-    if (!((PS_CLIPPED_SIGMA_LB <= stats->clipSigma) && (stats->clipSigma <= PS_CLIPPED_SIGMA_UB))) {
-        psError(__func__, "Unallowed value for clipSigma (%f).\n", stats->clipSigma);
-        return(-1);
-    }
+    PS_INT_CHECK_RANGE(stats->clipSigma,PS_CLIPPED_SIGMA_LB,PS_CLIPPED_SIGMA_UB,-1);
+
     // We allocate a temporary mask vector since during the iterative
     // steps that follow, we will be masking off additional data points.
@@ -869 +867 @@
         p_psNormalizeVectorRangeF64(myData, low, high);
     } else {
-        psError(__func__, "Unalowable data type.\n");
+        char* strType;
+        PS_TYPE_NAME(strType,myData->type.type);
+        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
+                PS_ERRORTEXT_psStats_NOT_F32_F64,
+                strType);
     }
 }
@@ -954 +956 @@
         // Ensure that yVal is within the range of the bins we are using.
         if (!((y->data.F64[0] <= yVal) && (yVal <= y->data.F64[2]))) {
-            printf("((%f), %f, %f)\n", yVal, y->data.F64[0], y->data.F64[2]);
-            psError(__func__, "yVal not within y-range\n");
+            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
+                    PS_ERRORTEXT_psStats_YVAL_OUT_OF_RANGE,
+                    (double)yVal,y->data.F64[2],y->data.F64[0]);
         }
         yErr->data.F64[0] = 1.0;
@@ -1113 +1116 @@
 
     if ((LQBinNum < 0) || (UQBinNum < 0)) {
-        psError(__func__, "Could not determine the robust lower/upper quartile bin numbers.");
+        psError(PS_ERR_UNKNOWN, true,
+                PS_ERRORTEXT_psStats_ROBUST_QUARTILE_BINS_FAILED);
         return(1);
     }
     if (medianBinNum < 0) {
-        psError(__func__, "Could not determine the robust lower/upper quartile bin numbers.");
+        psError(PS_ERR_UNKNOWN, true,
+                PS_ERRORTEXT_psStats_ROBUST_QUARTILE_BINS_FAILED);
         return(1);
     }
@@ -1174 +1179 @@
     psVector *y = psVectorAlloc(robustHistogramVector->n, PS_TYPE_F32);
 
-    p_psNormalizeVectorRange(robustHistogramVector, 0.0, 1.0);
+    psNormalizeVectorRange(robustHistogramVector, 0.0, 1.0);
     for (i=0;i<robustHistogramVector->n;i++) {
         myCoords->data[i] = (psPtr *) psVectorAlloc(2, PS_TYPE_F32);
@@ -1536 +1541 @@
         // do nothing
     } else {
-        psError(__func__, "unsupported vector type 0x%x\n", in->type.type);
+        char* strType;
+        PS_TYPE_NAME(strType,in->type.type);
+        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
+                PS_ERRORTEXT_psStats_VECTOR_TYPE_UNSUPPORTED,
+                strType);
     }
     return (tmp);
@@ -1603 +1612 @@
             (stats->options & PS_STAT_ROBUST_STDEV) || (stats->options & PS_STAT_ROBUST_QUARTILE)) {
         if (0 != p_psVectorRobustStats(inF32, mask, maskVal, stats)) {
-            psError(__func__, "p_psVectorRobustStats() failed.\n");
+            psError(PS_ERR_UNKNOWN, false,
+                    PS_ERRORTEXT_psStats_STATS_FAILED);
         }
     }
@@ -1609 +1619 @@
     if ((stats->options & PS_STAT_CLIPPED_MEAN) || (stats->options & PS_STAT_CLIPPED_STDEV)) {
         if (0 != p_psVectorClippedStats(inF32, mask, maskVal, stats)) {
-            psError(__func__, "p_psVectorClippedStats() failed.\n");
+            psError(PS_ERR_UNKNOWN, false,
+                    "Failed to calculate statistics for input psVector.");
         }
     }

trunk/psLib/src/dataManip/psVectorFFT.c

@@ -5 +5 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.27 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-10-27 00:57:31 $
+ *  @version $Revision: 1.28 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-11-04 01:04:59 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -63 +63 @@
                                  (fftwf_complex *) out->data.C32, FFTW_BACKWARD, P_FFTW_PLAN_RIGOR);
     } else {
-        psErrorMsg(PS_ERRORNAME_DOMAIN "psVectorFFT",
-                   PS_ERR_BAD_PARAMETER_VALUE, true,
-                   PS_ERRORTEXT_psVectorFFT_DIRECTION_NOTSET);
+        psError(PS_ERR_BAD_PARAMETER_VALUE, true,
+                PS_ERRORTEXT_psVectorFFT_DIRECTION_NOTSET);
         psFree(out);
         return NULL;
@@ -72 +71 @@
     /* check if a plan exists now */
     if (plan == NULL) {
-        psErrorMsg(PS_ERRORNAME_DOMAIN "psVectorFFT",
-                   PS_ERR_BAD_PARAMETER_TYPE, true,
-                   PS_ERRORTEXT_psVectorFFT_FFTW_PLAN_NULL);
+        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
+                PS_ERRORTEXT_psVectorFFT_FFTW_PLAN_NULL);
         psFree(out);
         return NULL;
@@ -144 +142 @@
         char* typeStr;
         PS_TYPE_NAME(typeStr,type);
-        psErrorMsg(PS_ERRORNAME_DOMAIN "psVectorReal",
-                   PS_ERR_BAD_PARAMETER_TYPE, true,
-                   PS_ERRORTEXT_psVectorFFT_TYPE_UNSUPPORTED,
-                   typeStr);
+        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
+                PS_ERRORTEXT_psVectorFFT_TYPE_UNSUPPORTED,
+                typeStr);
         psFree(out);
         return NULL;
@@ -204 +201 @@
         char* typeStr;
         PS_TYPE_NAME(typeStr,type);
-        psErrorMsg(PS_ERRORNAME_DOMAIN "psVectorImaginary",
-                   PS_ERR_BAD_PARAMETER_TYPE, true,
-                   PS_ERRORTEXT_psVectorFFT_TYPE_UNSUPPORTED,
-                   typeStr);
+        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
+                PS_ERRORTEXT_psVectorFFT_TYPE_UNSUPPORTED,
+                typeStr);
         psFree(out);
         return NULL;
@@ -237 +233 @@
         PS_TYPE_NAME(typeStrReal,type);
         PS_TYPE_NAME(typeStrImag,imag->type.type);
-        psErrorMsg(PS_ERRORNAME_DOMAIN "psVectorComplex",
-                   PS_ERR_BAD_PARAMETER_TYPE, true,
-                   PS_ERRORTEXT_psVectorFFT_REAL_IMAG_TYPE_MISMATCH,
-                   typeStrReal,typeStrImag);
+        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
+                PS_ERRORTEXT_psVectorFFT_REAL_IMAG_TYPE_MISMATCH,
+                typeStrReal,typeStrImag);
         psFree(out);
         return NULL;
@@ -272 +267 @@
         char* typeStr;
         PS_TYPE_NAME(typeStr,type);
-        psErrorMsg(PS_ERRORNAME_DOMAIN "psVectorComplex",
-                   PS_ERR_BAD_PARAMETER_TYPE, true,
-                   PS_ERRORTEXT_psVectorFFT_NONREAL_NOTSUPPORTED,
-                   typeStr);
+        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
+                PS_ERRORTEXT_psVectorFFT_NONREAL_NOTSUPPORTED,
+                typeStr);
         psFree(out);
         return NULL;
@@ -333 +327 @@
         char* typeStr;
         PS_TYPE_NAME(typeStr,type);
-        psErrorMsg(PS_ERRORNAME_DOMAIN "psVectorConjugate",
-                   PS_ERR_BAD_PARAMETER_TYPE, true,
-                   PS_ERRORTEXT_psVectorFFT_NONCOMPLEX_NOTSUPPORTED,
-                   typeStr);
+        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
+                PS_ERRORTEXT_psVectorFFT_NONCOMPLEX_NOTSUPPORTED,
+                typeStr);
         psFree(out);
         return NULL;
@@ -414 +407 @@
         char* typeStr;
         PS_TYPE_NAME(typeStr,type);
-        psErrorMsg(PS_ERRORNAME_DOMAIN "psVectorPowerSpectrum",
-                   PS_ERR_BAD_PARAMETER_TYPE, true,
-                   PS_ERRORTEXT_psVectorFFT_NONCOMPLEX_NOTSUPPORTED,
-                   typeStr);
-        psFree(out);
-        return NULL;
-    }
-
-    return out;
-
-}
+        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
+                PS_ERRORTEXT_psVectorFFT_NONCOMPLEX_NOTSUPPORTED,
+                typeStr);
+        psFree(out);
+        return NULL;
+    }
+
+    return out;
+
+}