Index: trunk/psLib/src/math/psSpline.c
===================================================================
--- trunk/psLib/src/math/psSpline.c	(revision 4392)
+++ trunk/psLib/src/math/psSpline.c	(revision 4405)
@@ -7,6 +7,6 @@
  *  polynomials.  It also contains a Gaussian functions.
  *
- *  @version $Revision: 1.111 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2005-06-25 02:02:05 $
+ *  @version $Revision: 1.112 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2005-06-28 00:53:53 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -1232,24 +1232,24 @@
 }
 
-psF32 psPolynomial1DEval(const psPolynomial1D* myPoly, psF32 x)
-{
-    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
-
-    if (myPoly->type == PS_POLYNOMIAL_ORD) {
-        return(ordPolynomial1DEval(x, myPoly));
-    } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
-        return(chebPolynomial1DEval(x, myPoly));
+psF64 psPolynomial1DEval(const psPolynomial1D* poly, psF64 x)
+{
+    PS_ASSERT_POLY_NON_NULL(poly, NAN);
+
+    if (poly->type == PS_POLYNOMIAL_ORD) {
+        return(ordPolynomial1DEval(x, poly));
+    } else if (poly->type == PS_POLYNOMIAL_CHEB) {
+        return(chebPolynomial1DEval(x, poly));
     } else {
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
                 PS_ERRORTEXT_psFunctions_INVALID_POLYNOMIAL_TYPE,
-                myPoly->type);
+                poly->type);
     }
     return(NAN);
 }
 
-psVector *psPolynomial1DEvalVector(const psPolynomial1D *myPoly,
+psVector *psPolynomial1DEvalVector(const psPolynomial1D *poly,
                                    const psVector *x)
 {
-    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
+    PS_ASSERT_POLY_NON_NULL(poly, NULL);
     PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
@@ -1259,5 +1259,5 @@
     tmp = psVectorAlloc(x->n, PS_TYPE_F32);
     for (psS32 i=0;i<x->n;i++) {
-        tmp->data.F32[i] = psPolynomial1DEval(myPoly, x->data.F32[i]);
+        tmp->data.F32[i] = psPolynomial1DEval(poly, x->data.F32[i]);
     }
 
@@ -1265,26 +1265,26 @@
 }
 
-psF32 psPolynomial2DEval(const psPolynomial2D* myPoly, psF32 x, psF32 y)
-{
-    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
-
-    if (myPoly->type == PS_POLYNOMIAL_ORD) {
-        return(ordPolynomial2DEval(x, y, myPoly));
-    } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
-        return(chebPolynomial2DEval(x, y, myPoly));
+psF64 psPolynomial2DEval(const psPolynomial2D* poly, psF64 x, psF64 y)
+{
+    PS_ASSERT_POLY_NON_NULL(poly, NAN);
+
+    if (poly->type == PS_POLYNOMIAL_ORD) {
+        return(ordPolynomial2DEval(x, y, poly));
+    } else if (poly->type == PS_POLYNOMIAL_CHEB) {
+        return(chebPolynomial2DEval(x, y, poly));
     } else {
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
                 PS_ERRORTEXT_psFunctions_INVALID_POLYNOMIAL_TYPE,
-                myPoly->type);
+                poly->type);
     }
     return(NAN);
 }
 
-psVector *psPolynomial2DEvalVector(const psPolynomial2D *myPoly,
+psVector *psPolynomial2DEvalVector(const psPolynomial2D *poly,
                                    const psVector *x,
                                    const psVector *y)
 
 {
-    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
+    PS_ASSERT_POLY_NON_NULL(poly, NULL);
     PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
@@ -1305,5 +1305,5 @@
     // Evaluate the polynomial at the specified points
     for (psS32 i=0; i<vecLen; i++) {
-        tmp->data.F32[i] = psPolynomial2DEval(myPoly,x->data.F32[i],y->data.F32[i]);
+        tmp->data.F32[i] = psPolynomial2DEval(poly,x->data.F32[i],y->data.F32[i]);
     }
 
@@ -1312,21 +1312,21 @@
 }
 
-psF32 psPolynomial3DEval(const psPolynomial3D* myPoly, psF32 x, psF32 y, psF32 z)
-{
-    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
-
-    if (myPoly->type == PS_POLYNOMIAL_ORD) {
-        return(ordPolynomial3DEval(x, y, z, myPoly));
-    } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
-        return(chebPolynomial3DEval(x, y, z, myPoly));
+psF64 psPolynomial3DEval(const psPolynomial3D* poly, psF64 x, psF64 y, psF64 z)
+{
+    PS_ASSERT_POLY_NON_NULL(poly, NAN);
+
+    if (poly->type == PS_POLYNOMIAL_ORD) {
+        return(ordPolynomial3DEval(x, y, z, poly));
+    } else if (poly->type == PS_POLYNOMIAL_CHEB) {
+        return(chebPolynomial3DEval(x, y, z, poly));
     } else {
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
                 PS_ERRORTEXT_psFunctions_INVALID_POLYNOMIAL_TYPE,
-                myPoly->type);
+                poly->type);
     }
     return(NAN);
 }
 
-psVector *psPolynomial3DEvalVector(const psPolynomial3D *myPoly,
+psVector *psPolynomial3DEvalVector(const psPolynomial3D *poly,
                                    const psVector *x,
                                    const psVector *y,
@@ -1334,5 +1334,5 @@
 
 {
-    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
+    PS_ASSERT_POLY_NON_NULL(poly, NULL);
     PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
@@ -1358,5 +1358,5 @@
     // Evaluate polynomial
     for (psS32 i = 0; i < vecLen; i++) {
-        tmp->data.F32[i] = psPolynomial3DEval(myPoly,
+        tmp->data.F32[i] = psPolynomial3DEval(poly,
                                               x->data.F32[i],
                                               y->data.F32[i],
@@ -1368,29 +1368,27 @@
 }
 
-psF32 psPolynomial4DEval(const psPolynomial4D* myPoly, psF32 w, psF32 x, psF32 y, psF32 z)
-{
-    PS_ASSERT_POLY_NON_NULL(myPoly, NAN);
-
-    if (myPoly->type == PS_POLYNOMIAL_ORD) {
-        return(ordPolynomial4DEval(w,x,y,z, myPoly));
-    } else if (myPoly->type == PS_POLYNOMIAL_CHEB) {
-        return(chebPolynomial4DEval(w,x,y,z, myPoly));
+psF64 psPolynomial4DEval(const psPolynomial4D* poly, psF64 x, psF64 y, psF64 z, psF64 t)
+{
+    PS_ASSERT_POLY_NON_NULL(poly, NAN);
+
+    if (poly->type == PS_POLYNOMIAL_ORD) {
+        return(ordPolynomial4DEval(x,y,z,t, poly));
+    } else if (poly->type == PS_POLYNOMIAL_CHEB) {
+        return(chebPolynomial4DEval(x,y,z,t, poly));
     } else {
         psError(PS_ERR_BAD_PARAMETER_TYPE, true,
                 PS_ERRORTEXT_psFunctions_INVALID_POLYNOMIAL_TYPE,
-                myPoly->type);
+                poly->type);
     }
     return(NAN);
 }
 
-psVector *psPolynomial4DEvalVector(const psPolynomial4D *myPoly,
-                                   const psVector *w,
+psVector *psPolynomial4DEvalVector(const psPolynomial4D *poly,
                                    const psVector *x,
                                    const psVector *y,
-                                   const psVector *z)
-{
-    PS_ASSERT_POLY_NON_NULL(myPoly, NULL);
-    PS_ASSERT_VECTOR_NON_NULL(w, NULL);
-    PS_ASSERT_VECTOR_TYPE(w, PS_TYPE_F32, NULL);
+                                   const psVector *z,
+                                   const psVector *t)
+{
+    PS_ASSERT_POLY_NON_NULL(poly, NULL);
     PS_ASSERT_VECTOR_NON_NULL(x, NULL);
     PS_ASSERT_VECTOR_TYPE(x, PS_TYPE_F32, NULL);
@@ -1399,17 +1397,19 @@
     PS_ASSERT_VECTOR_NON_NULL(z, NULL);
     PS_ASSERT_VECTOR_TYPE(z, PS_TYPE_F32, NULL);
+    PS_ASSERT_VECTOR_NON_NULL(t, NULL);
+    PS_ASSERT_VECTOR_TYPE(t, PS_TYPE_F32, NULL);
 
     psVector *tmp;
-    psS32 vecLen=w->n;
+    psS32 vecLen=x->n;
 
     // Determine output vector size from min of input vectors
+    if (z->n < vecLen) {
+        vecLen = z->n;
+    }
     if (y->n < vecLen) {
         vecLen = y->n;
     }
-    if (x->n < vecLen) {
-        vecLen = x->n;
-    }
-    if (z->n < vecLen) {
-        vecLen = z->n;
+    if (t->n < vecLen) {
+        vecLen = t->n;
     }
 
@@ -1419,9 +1419,9 @@
     // Evaluate polynomial
     for (psS32 i = 0; i < vecLen; i++) {
-        tmp->data.F32[i] = psPolynomial4DEval(myPoly,
-                                              w->data.F32[i],
+        tmp->data.F32[i] = psPolynomial4DEval(poly,
                                               x->data.F32[i],
                                               y->data.F32[i],
-                                              z->data.F32[i]);
+                                              z->data.F32[i],
+                                              t->data.F32[i]);
     }