Index: trunk/psLib/src/math/psPolynomial.c
===================================================================
--- trunk/psLib/src/math/psPolynomial.c	(revision 1719)
+++ trunk/psLib/src/math/psPolynomial.c	(revision 1723)
@@ -7,6 +7,6 @@
  *  polynomials.  It also contains a Gaussian functions.
  *
- *  @version $Revision: 1.25 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2004-09-08 06:01:21 $
+ *  @version $Revision: 1.26 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2004-09-08 06:23:16 $
  *
  *  Copyright 2004 Maui High Performance Computing Center, University of Hawaii
@@ -36,5 +36,11 @@
 /* DEFINE STATEMENTS                                                         */
 /*****************************************************************************/
-
+/*
+ * The following macros take the vector IN as input.  If IN is not of
+ * the correct type, then a new vector OUT is created of the correct
+ * type, and the elements of IN and converted to OUT.
+ *
+ * If vector IN is the correct type, then OUT is simply set to IN.
+ */
 #define PS_CONVERT_VECTOR_F32(IN, OUT) \
 if (IN->type.type != PS_TYPE_F32) { \
@@ -76,5 +82,4 @@
 
 
-
 /*****************************************************************************/
 /* TYPE DEFINITIONS                                                          */
@@ -141,5 +146,5 @@
  Gaussian distribution as well.
  
- NOTE: There is no way to seed the random generator.
+ NOTE: XXX: There is no way to seed the random generator.
  *****************************************************************************/
 psVector* psGaussianDev(float mean, float sigma, int Npts)
@@ -394,5 +399,5 @@
     Polynomial coefficients will be accessed in [w][x][y][z] fashion.
  
-    XXX: Determine, from IfA, whether ot not the "mask[]" terms should be used
+    XXX: Determine, from IfA, whether or not the "mask[]" terms should be used
     in polynomial evaluation.  If so, then all of the following polynomial
     evaluation functions must be modified to do so.
@@ -400,5 +405,5 @@
     XXX: Should the "coeffErr[]" should be used as well?
  *****************************************************************************/
-float p_psOrgPolynomial1DEval(float x, const psPolynomial1D* myPoly)
+float p_psOrdPolynomial1DEval(float x, const psPolynomial1D* myPoly)
 {
     int loop_x = 0;
@@ -456,5 +461,5 @@
 {
     if (myPoly->type == PS_POLYNOMIAL_ORD) {
-        return(p_psOrgPolynomial1DEval(x, myPoly));
+        return(p_psOrdPolynomial1DEval(x, myPoly));
     } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
         return(p_psChebPolynomial1DEval(x, myPoly));
@@ -486,5 +491,5 @@
 
 
-float p_psOrgPolynomial2DEval(float x, float y, const psPolynomial2D* myPoly)
+float p_psOrdPolynomial2DEval(float x, float y, const psPolynomial2D* myPoly)
 {
     int loop_x = 0;
@@ -508,4 +513,6 @@
 float p_psChebPolynomial2DEval(float x, float y, const psPolynomial2D* myPoly)
 {
+    // XXX: Waiting for Crenshaw extension to multi-dimensional Chebyshevs.
+    psLogMsg(__func__, PS_LOG_WARN, "This function has not been coded.");
     return(0.0);
 }
@@ -514,5 +521,5 @@
 {
     if (myPoly->type == PS_POLYNOMIAL_ORD) {
-        return(p_psOrgPolynomial2DEval(x, y, myPoly));
+        return(p_psOrdPolynomial2DEval(x, y, myPoly));
     } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
         return(p_psChebPolynomial2DEval(x, y, myPoly));
@@ -559,5 +566,5 @@
 
 
-float p_psOrgPolynomial3DEval(float x, float y, float z, const psPolynomial3D* myPoly)
+float p_psOrdPolynomial3DEval(float x, float y, float z, const psPolynomial3D* myPoly)
 {
     int loop_x = 0;
@@ -587,4 +594,6 @@
 float p_psChebPolynomial3DEval(float x, float y, float z, const psPolynomial3D* myPoly)
 {
+    // XXX: Waiting for Crenshaw extension to multi-dimensional Chebyshevs.
+    psLogMsg(__func__, PS_LOG_WARN, "This function has not been coded.");
     return(0.0);
 }
@@ -593,5 +602,5 @@
 {
     if (myPoly->type == PS_POLYNOMIAL_ORD) {
-        return(p_psOrgPolynomial3DEval(x, y, z, myPoly));
+        return(p_psOrdPolynomial3DEval(x, y, z, myPoly));
     } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
         return(p_psChebPolynomial3DEval(x, y, z, myPoly));
@@ -650,5 +659,5 @@
 
 
-float p_psOrgPolynomial4DEval(float w, float x, float y, float z, const psPolynomial4D* myPoly)
+float p_psOrdPolynomial4DEval(float w, float x, float y, float z, const psPolynomial4D* myPoly)
 {
     int loop_w = 0;
@@ -684,4 +693,6 @@
 float p_psChebPolynomial4DEval(float w, float x, float y, float z, const psPolynomial4D* myPoly)
 {
+    // XXX: Waiting for Crenshaw extension to multi-dimensional Chebyshevs.
+    psLogMsg(__func__, PS_LOG_WARN, "This function has not been coded.");
     return(0.0);
 }
@@ -690,5 +701,5 @@
 {
     if (myPoly->type == PS_POLYNOMIAL_ORD) {
-        return(p_psOrgPolynomial4DEval(w,x,y,z, myPoly));
+        return(p_psOrdPolynomial4DEval(w,x,y,z, myPoly));
     } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
         return(p_psChebPolynomial4DEval(w,x,y,z, myPoly));
@@ -977,5 +988,5 @@
     Polynomial coefficients will be accessed in [w][x][y][z] fashion.
  *****************************************************************************/
-double p_psDOrgPolynomial1DEval(double x, const psDPolynomial1D* myPoly)
+double p_psDOrdPolynomial1DEval(double x, const psDPolynomial1D* myPoly)
 {
     int loop_x = 0;
@@ -996,7 +1007,28 @@
 }
 
+// XXX: You can do this without having to psAlloc() vector d.
 double p_psDChebPolynomial1DEval(double x, const psDPolynomial1D* myPoly)
 {
-    return(0.0);
+    psVector *d;
+    int n;
+    int 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);
 }
 
@@ -1004,5 +1036,5 @@
 {
     if (myPoly->type == PS_POLYNOMIAL_ORD) {
-        return(p_psDOrgPolynomial1DEval(x, myPoly));
+        return(p_psDOrdPolynomial1DEval(x, myPoly));
     } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
         return(p_psDChebPolynomial1DEval(x, myPoly));
@@ -1035,5 +1067,5 @@
 
 
-double p_psDOrgPolynomial2DEval(double x, double y, const psDPolynomial2D* myPoly)
+double p_psDOrdPolynomial2DEval(double x, double y, const psDPolynomial2D* myPoly)
 {
     int loop_x = 0;
@@ -1057,4 +1089,6 @@
 double p_psDChebPolynomial2DEval(double x, double y, const psDPolynomial2D* myPoly)
 {
+    // XXX: Waiting for Crenshaw extension to multi-dimensional Chebyshevs.
+    psLogMsg(__func__, PS_LOG_WARN, "This function has not been coded.");
     return(0.0);
 }
@@ -1063,5 +1097,5 @@
 {
     if (myPoly->type == PS_POLYNOMIAL_ORD) {
-        return(p_psDOrgPolynomial2DEval(x, y, myPoly));
+        return(p_psDOrdPolynomial2DEval(x, y, myPoly));
     } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
         return(p_psDChebPolynomial2DEval(x, y, myPoly));
@@ -1107,5 +1141,5 @@
 
 
-double p_psDOrgPolynomial3DEval(double x, double y, double z, const psDPolynomial3D* myPoly)
+double p_psDOrdPolynomial3DEval(double x, double y, double z, const psDPolynomial3D* myPoly)
 {
     int loop_x = 0;
@@ -1135,4 +1169,6 @@
 double p_psDChebPolynomial3DEval(double x, double y, double z, const psDPolynomial3D* myPoly)
 {
+    // XXX: Waiting for Crenshaw extension to multi-dimensional Chebyshevs.
+    psLogMsg(__func__, PS_LOG_WARN, "This function has not been coded.");
     return(0.0);
 }
@@ -1141,5 +1177,5 @@
 {
     if (myPoly->type == PS_POLYNOMIAL_ORD) {
-        return(p_psDOrgPolynomial3DEval(x, y, z, myPoly));
+        return(p_psDOrdPolynomial3DEval(x, y, z, myPoly));
     } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
         return(p_psDChebPolynomial3DEval(x, y, z, myPoly));
@@ -1200,5 +1236,5 @@
 
 
-double p_psDOrgPolynomial4DEval(double w, double x, double y, double z, const psDPolynomial4D* myPoly)
+double p_psDOrdPolynomial4DEval(double w, double x, double y, double z, const psDPolynomial4D* myPoly)
 {
     int loop_w = 0;
@@ -1234,4 +1270,6 @@
 double p_psDChebPolynomial4DEval(double w, double x, double y, double z, const psDPolynomial4D* myPoly)
 {
+    // XXX: Waiting for Crenshaw extension to multi-dimensional Chebyshevs.
+    psLogMsg(__func__, PS_LOG_WARN, "This function has not been coded.");
     return(0.0);
 }
@@ -1240,5 +1278,5 @@
 {
     if (myPoly->type == PS_POLYNOMIAL_ORD) {
-        return(p_psDOrgPolynomial4DEval(w,x,y,z, myPoly));
+        return(p_psDOrdPolynomial4DEval(w,x,y,z, myPoly));
     } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
         return(p_psDChebPolynomial4DEval(w,x,y,z, myPoly));